Searching and Matching
**********************

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.

The skip-chars... functions also perform a kind of searching. See Skipping Characters.  To search for changes in character properties, see Property Search.

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; 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 Text Representations.

 -- Command: search-forward string &optional limit noerror repeat
     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 existing programs may depend on a value of nil.)

     The argument NOERROR only affects valid searches which fail to find a match.  Invalid arguments cause errors regardless of NOERROR.

     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, with results depending on the value of NOERROR, as described above.

 -- Command: search-backward string &optional limit noerror repeat
     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 repeat
     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; it specifies 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 accessible portion 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.

 -- Command: word-search-backward string &optional limit noerror repeat
     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.

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.  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 Intro to Buffer-Local.)  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.

 -- User Option: case-replace
     This variable determines whether the higher level 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.

     This variable is used by passing it as an argument to the function replace-match.  See Replacing Match.

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

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.

For convenient interactive development of regular expressions, you can use the M-x re-builder command.  It provides a convenient interface for creating regular expressions, by giving immediate visual feedback in a separate buffer.  As you edit the regexp, all its matches in the target buffer are highlighted.  Each parenthesized sub-expression of the regexp is shown in a distinct face, which makes it easier to verify even very complex regexps.

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.  The character ] is special if it ends a character alternative (see later). The character - is special inside a character alternative.  A [: and balancing :] enclose a character class inside a character alternative.  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.

Special Characters in Regular Expressions
.........................................

Here is a list of the characters that are special in a regular expression.

. (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 postfix operator that means to match the preceding regular expression repetitively as many times as possible.  Thus, o* matches any number of os (including no os).

     * 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 as; 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 as.  With this choice, the rest of the regexp matches successfully.

     Warning: Nested repetition operators can run for an indefinitely long time, if they lead to ambiguous matching.  For example, trying to match the regular expression \(x+y*\)*a against the string xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxz could take hours before it ultimately fails.  Emacs must try each way of grouping the xs before concluding that none of them can work. Even worse, \(x*\)* can match the null string in infinitely many ways, so it causes an infinite loop.  To avoid these problems, check nested repetitions carefully, to make sure that they do not cause combinatorial explosions in backtracking.

+
     is a postfix operator, similar to * except that it must match the preceding expression at least once.  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 postfix operator, similar to * except that it must match the preceding expression either once or not at all.  For example, ca?r matches car or cr; nothing else.

*?, +?, ??
     These are ``non-greedy'' variants of the operators *, + and ?.  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 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.)

[ ... ]
     is a character alternative, which begins with [ and is terminated by ].  In the simplest case, the characters between the two brackets are what this character alternative can match.

     Thus, [ad] matches either one a or one d, and [ad]* matches any string composed of just as and ds (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 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 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.

     A character alternative can also specify named character classes (see Char 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.

[^ ... ]
     [^ begins a complemented character alternative.  This 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 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 buffer, ^ matches the empty string, but only at the beginning of a line in the text being matched (or the beginning of the accessible portion of the buffer).  Otherwise it fails to match anything.  Thus, ^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.

     For historical compatibility reasons, ^ can be used only at the beginning of the regular expression, or after \(, \(?: or \|.

$
     is similar to ^ but matches only at the end of a line (or the end of the accessible portion of the buffer).  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.

     For historical compatibility reasons, $ can be used only at the end of the regular expression, or before \) or \|.

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

As a \ is not special inside a character alternative, it can never remove the special meaning of - or ].  So you should not quote these characters when they have no special meaning either.  This would not clarify anything, since backslashes can legitimately precede these characters where they have special meaning, as in [^\] ("[^\\]" for Lisp string syntax), which matches any single character except a backslash.

In practice, most ] that occur in regular expressions close a character alternative and hence are special.  However, occasionally a regular expression may try to match a complex pattern of literal [ and ].  In such situations, it sometimes may be necessary to carefully parse the regexp from the start to determine which square brackets enclose a character alternative.  For example, [^][]] consists of the complemented character alternative [^][] (which matches any single character that is not a square bracket), followed by a literal ].

The exact rules are that at the beginning of a regexp, [ is special and ] not.  This lasts until the first unquoted [, after which we are in a character alternative; [ is no longer special (except when it starts a character class) but ] is special, unless it immediately follows the special [ or that [ followed by a ^.  This lasts until the next special ] that does not end a character class.  This ends the character alternative and restores the ordinary syntax of regular expressions; an unquoted [ is special again and a ] not.

Character Classes
.................

Here is a table of the classes you can use in a character alternative, and what they mean:

[:ascii:]
     This matches any ASCII character (codes 0--127).

[:alnum:]
     This matches any letter or digit.  (At present, for multibyte characters, it matches anything that has word syntax.)

[:alpha:]
     This matches any letter.  (At present, for multibyte characters, it matches anything that has word syntax.)

[:blank:]
     This matches space and tab only.

[:cntrl:]
     This matches any ASCII control character.

[:digit:]
     This matches 0 through 9.  Thus, [-+[:digit:]] matches any digit, as well as + and -.

[:graph:]
     This matches graphic characters---everything except ASCII control characters, space, and the delete character.

[:lower:]
     This matches any lower-case letter, as determined by the current case table (see Case Tables).

[:multibyte:]
     This matches any multibyte character (see Text Representations).

[:nonascii:]
     This matches any non-ASCII character.

[:print:]
     This matches printing characters---everything except ASCII control characters and the delete character.

[:punct:]
     This matches any punctuation character.  (At present, for multibyte characters, it matches anything that has non-word syntax.)

[:space:]
     This matches any character that has whitespace syntax (see Syntax Class Table).

[:unibyte:]
     This matches any unibyte character (see Text Representations).

[:upper:]
     This matches any upper-case letter, as determined by the current case table (see Case Tables).

[:word:]
     This matches any character that has word syntax (see Syntax Class Table).

[:xdigit:]
     This matches the hexadecimal digits: 0 through 9, a through f and A through F.

Backslash Constructs in Regular Expressions
...........................................

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.

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

     If you need full backtracking capability to handle multiple uses of \|, use the POSIX regular expression functions (see POSIX Regexps).

\{M\}
     is a postfix operator that repeats the previous pattern exactly M times.  Thus, x\{5\} matches the string xxxxx and nothing else.  c[ad]\{3\}r matches string such as caaar, cdddr, cadar, and so on.

\{M,N\}
     is a more general postfix operator that specifies repetition with a minimum of M repeats and a maximum of N repeats.  If M is omitted, the minimum is 0; if N is omitted, there is no maximum.

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

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

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

      2. To enclose a complicated expression for the postfix operators *, + and ? to operate on.  Thus, ba\(na\)* matches ba, bana, banana, bananana, etc., with any number (zero or more) of na strings.

      3. To record a matched substring for future reference with \DIGIT (see below).

     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 practice, there was usually no conflict between the two meanings.  But occasionally there is a conflict, and that led to the introduction of shy groups.

\(?: ... \)
     is the 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 \DIGIT.

     Shy groups are particularly useful for mechanically-constructed regular expressions because they can be added automatically without altering the numbering of any ordinary, non-shy groups.

\DIGIT
     matches the same text that matched the DIGITth occurrence of a grouping (\( ... \)) construct.

     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 \( ... \) construct matches more than once (which can happen, for instance, if it is followed by *), only the last match is recorded.

     If a particular grouping construct in the regular expression was never matched---for instance, if it appears inside of an alternative that wasn't used, or inside of a repetition that repeated zero times---then the corresponding \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.

\w
     matches any word-constituent character.  The editor syntax table determines which characters these are.  See 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.  To represent whitespace syntax, use either - or a space character.  See Syntax Class Table, for a list of syntax codes and the characters that stand for them.

\SCODE
     matches any character whose syntax is not CODE.

\cC
     matches any character whose category is C.  Here C is a character that represents a category: thus, c for Chinese characters or g for Greek characters in the standard category table.

\CC
     matches any character whose category is not C.

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.  For all, the beginning and end of the accessible portion of the buffer are treated as if they were the actual beginning and end of the buffer.

\`
     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 at the beginning or end of the buffer (or string) regardless of what text appears next to it.

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

\<
     matches the empty string, but only at the beginning of a word. \< matches at the beginning of the buffer (or string) only if a word-constituent character follows.

\>
     matches the empty string, but only at the end of a word.  \> matches at the end of the buffer (or string) only if the contents end with a word-constituent character.

\_<
     matches the empty string, but only at the beginning of a symbol.  A symbol is a sequence of one or more word or symbol constituent characters.  \_< matches at the beginning of the buffer (or string) only if a symbol-constituent character follows.

\_>
     matches the empty string, but only at the end of a symbol.  \_> matches at the end of the buffer (or string) only if the contents end with a symbol-constituent character.

Not every string is a valid regular expression.  For example, a string that ends inside a character alternative without terminating ] is invalid, 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.

Complex Regexp Example
----------------------

Here is a complicated regexp which was formerly used by Emacs to recognize the end of a sentence together with any whitespace that follows.  (Nowadays Emacs uses a similar but more complex default regexp constructed by the function sentence-end. See Standard Regexps.)

First, we show the regexp as a string in Lisp syntax to distinguish spaces from tab characters.  The string constant begins and ends with a 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 this string, you will see the following:

     "[.?!][]\"')}]*\\($\\| $\\|\t\\|  \\)[ \t\n]*"
          => "[.?!][]\"')}]*\\($\\| $\\|  \\|  \\)[
     ]*"

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 alternative that matches any one of three characters: period, question mark, and exclamation mark.  The match must begin with one of these three characters.  (This is one point where the new default regexp used by Emacs differs from the old.  The new value also allows some non-ASCII characters that end a sentence without any following whitespace.)

[]\"')}]*
     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 alternative, 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 (optionally with a space), 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.

Regular Expression Functions
----------------------------

These functions operate on regular expressions.

 -- Function: regexp-quote string
     This function returns a regular expression whose only exact match is STRING.  Using this regular expression in 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-"))

 -- Function: regexp-opt strings &optional paren
     This function returns an efficient regular expression that will match any of the strings in the list 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 PAREN is non-nil, then the returned regular expression is always enclosed by at least one parentheses-grouping construct.  If PAREN is words, then that construct is additionally surrounded by \< and \>.

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

 -- Function: regexp-opt-depth regexp
     This function returns the total number of grouping constructs (parenthesized expressions) in REGEXP.  (This does not include shy groups.)

Regular Expression Searching
============================

In GNU Emacs, you can search for the next match for a regular expression either incrementally or not.  For incremental search commands, see Regular Expression Search (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 Text Representations.

 -- Command: re-search-forward regexp &optional limit noerror repeat
     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.  It specifies the upper bound to the search.  No match extending after that position is accepted.

     If REPEAT is supplied, it must be a positive number; the search is repeated that many times; each repetition starts at the end of the previous match.  If all these successive searches succeed, the search succeeds, moving point and returning its new value.  Otherwise the search fails.  What re-search-forward does when the search fails depends on the value of NOERROR:

     nil
          Signal a search-failed error.

     t
          Do nothing and return nil.

     anything else
          Move point to LIMIT (or the end of the accessible portion of the buffer) and return 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 ----------

 -- Command: re-search-backward regexp &optional limit noerror repeat
     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 (and yet ends before the starting point).  The reason for this is that matching a regular expression at a given spot always works from beginning to end, and starts at a specified beginning position.

     A true mirror-image of 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.

 -- Function: string-match regexp string &optional start
     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.

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

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

          (match-end 0)
               => 32

 -- Function: looking-at regexp
     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 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

 -- Function: looking-back regexp &optional limit
     This function returns t if REGEXP matches text before point, ending at point, and nil otherwise.

     Because regular expression matching works only going forward, this is implemented by searching backwards from point for a match that ends at point.  That can be quite slow if it has to search a long distance. You can bound the time required by specifying LIMIT, which says not to search before LIMIT.  In this case, the match that is found must begin at or after LIMIT.

          ---------- Buffer: foo ----------
          I read "-!-The cat in the hat
          comes back" twice.
          ---------- Buffer: foo ----------

          (looking-back "read \"" 3)
               => t
          (looking-back "read \"" 4)
               => nil

 -- Variable: search-spaces-regexp
     If this variable is non-nil, it should be a regular expression that says how to search for whitespace.  In that case, any group of spaces in a regular expression being searched for stands for use of this regular expression.  However, spaces inside of constructs such as [...] and *, +, ? are not affected by search-spaces-regexp.

     Since this variable affects all regular expression search and match constructs, you should bind it temporarily for as small as possible a part of the code.

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.

The POSIX search and match functions do not properly support the non-greedy repetition operators.  This is because POSIX backtracking conflicts with the semantics of non-greedy repetition.

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

 -- Function: posix-search-backward regexp &optional limit noerror repeat
     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
     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
     This is like string-match except that it performs the full backtracking specified by the POSIX standard for regular expression matching.

The Match Data
==============

Emacs keeps track of the start and end positions of the segments of text found during a search; this is called the match data. Thanks to the match data, you can search for a complex pattern, such as a date in a mail message, and then extract parts of the match under control of the pattern.

Because the match data normally describe the most recent search only, you must be careful not to do another search inadvertently between the 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.

Replacing the Text that Matched
-------------------------------

This function replaces all or part of the text matched by the last search.  It works by means of the match data.

 -- Function: replace-match replacement &optional fixedcase literal string subexp
     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 and make sure that the current buffer when you call replace-match is the one in which you did the searching or matching.  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 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 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 \(...\). If the Nth subexpression never matched, an empty string is substituted.

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

     These substitutions occur after case conversion, if any, so the strings they substitute are never case-converted.

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

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, if it succeeded.

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.

Every successful search sets the match data.  Therefore, you should query the match data immediately after searching, before calling any other function that might perform another search.  Alternatively, you may save and restore the match data (see Saving Match Data) around the call to functions that could perform another search.

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.  So don't try to rely on the value of the match data after a failing search.

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

 -- Function: match-string-no-properties count &optional in-string
     This function is like match-string except that the result has no text properties.

 -- 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 or a repetition that repeated zero times.

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

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 reseat
     This function returns a list of positions (markers or integers) that record all the information on what text the last search matched. Element zero is the position of the beginning of the match for the whole expression; element one is the position of the end of the match for the expression.  The next two elements are the positions of the beginning and end of the match for the first subexpression, and so on. In general, element number 2N corresponds to (match-beginning N); and element number 2N + 1 corresponds to (match-end N).

     Normally all the elements are markers or nil, but if INTEGERS is non-nil, that means to use integers instead of markers.  (In that case, the buffer itself is appended as an additional element at the end of the list, to facilitate complete restoration of the match data.)  If the last match was done on a string with string-match, then integers are always used, since markers can't point into a string.

     If REUSE is non-nil, it should be a list.  In that case, match-data stores the match data in REUSE.  That is, REUSE is destructively modified.  REUSE does not need to have the right length.  If it is not long enough to contain the match data, it is extended.  If it is too long, the length of REUSE stays the same, but the elements that were not used are set to nil.  The purpose of this feature is to reduce the need for garbage collection.

     If RESEAT is non-nil, all markers on the REUSE list are reseated to point to nowhere.

     As always, there must be no possibility of intervening searches between the call to a search function and the call to 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 &optional reseat
     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.  (More precisely, anything that has the same format will work.)

     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.

     If RESEAT is non-nil, all markers on the MATCH-LIST list are reseated to point to nowhere.

     store-match-data is a semi-obsolete alias for set-match-data.

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.  The return value is the value of the last form in BODY.

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 Filter Functions) and process sentinels (see Sentinels).

Search and Replace
==================

If you want to find all matches for a regexp in part of the buffer, and replace them, the best way is to write an explicit loop using re-search-forward and replace-match, like this:

     (while (re-search-forward "foo[ \t]+bar" nil t)
       (replace-match "foobar"))

See Replacing the Text that Matched, for a description of replace-match.

However, replacing matches in a string is more complex, especially if you want to do it efficiently.  So Emacs provides a function to do this.

 -- Function: replace-regexp-in-string regexp rep string &optional fixedcase literal subexp start
     This function copies STRING and searches it for matches for REGEXP, and replaces them with REP.  It returns the modified copy.  If START is non-nil, the search for matches starts at that index in STRING, so matches starting before that index are not changed.

     This function uses replace-match to do the replacement, and it passes the optional arguments FIXEDCASE, LITERAL and SUBEXP along to replace-match.

     Instead of a string, REP can be a function.  In that case, replace-regexp-in-string calls REP for each match, passing the text of the match as its sole argument.  It collects the value REP returns and passes that to replace-match as the replacement string.  The match-data at this point are the result of matching REGEXP against a substring of STRING.

If you want to write a command along the lines of query-replace, you can use perform-replace to do the work.

 -- Function: perform-replace from-string replacements query-flag regexp-flag delimited-flag &optional repeat-count map start end
     This function is the guts of 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 (or omitted), point is used instead, and the end of the buffer's accessible portion 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 cyclically 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, specifies 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 perform-replace and the commands that use it, as well as y-or-n-p and map-y-or-n-p.  This map is unusual in two ways:

       * The ``key bindings'' are not commands, just symbols that are meaningful to the functions that use this map.

       * Prefix keys are not supported; each key binding must be for a single-event key sequence.  This is because the functions don't use 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
     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.

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 regular expression 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 "\f\\|[ \t]*$", which matches a line containing only whitespace or starting with a form feed (after its left margin).

 -- Variable: sentence-end
     If non-nil, the value should be a regular expression describing the end of a sentence, including the whitespace following the sentence.  (All paragraph boundaries also end sentences, regardless.)

     If the value is nil, the default, then the function sentence-end has to construct the regexp.  That is why you should always call the function sentence-end to obtain the regexp to be used to recognize the end of a sentence.

 -- Function: sentence-end
     This function returns the value of the variable sentence-end, if non-nil.  Otherwise it returns a default value based on the values of the variables sentence-end-double-space (see Definition of sentence-end-double-space), sentence-end-without-period and sentence-end-without-space.