GNU Emacs
ELisp
Searching and Matching

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. Skipping Characters. To search for changes in character properties, see Property Search.

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. (Intro to Buffer-Local.) Alternatively, you may change the default value. In Lisp code, you will more typically use let to bind case-fold-search to the desired value. Note that the user-level incremental search feature handles case distinctions differently. When the search string contains only lower case letters, the search ignores case, but when the search string contains one or more upper case letters, the search becomes case-sensitive. But this has nothing to do with the searching functions used in Lisp code. Incremental Search.

case-fold-search
This buffer-local variable determines whether searches should ignore case. If the variable is nil they do not ignore case; otherwise (and by default) they do ignore case.
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. Replacing Match.

Regular Expressions

A regular expression, or 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 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. Note that by default Emacs search ignores case (Searching and Case). To enable case-sensitive regexp search and match, bind case-fold-search to nil around the code you want to be case-sensitive.

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 o=s (including no =o=s). =* 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 this will make it possible to match the rest of the pattern. For example, in matching ca*ar against the string caaar, the a* first tries to match all three a=s; but the rest of the pattern is =ar and there is only r left to match, so this try fails. The next alternative is for a* to match only two =a=s. With this choice, the rest of the regexp matches successfully.
+
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.
*?, +?, ??
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 a=s and =d=s (including the empty string). 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. However, the ending character of one range should not be the starting point of another one; for example, [a-m-z] should be avoided. A character alternative can also specify named character classes (Char Classes). This is a POSIX feature. For example, [[:ascii:]] matches any ASCII character. 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. A character class should not appear as the lower or upper bound of a range. The usual regexp special characters are not special inside a character alternative. A completely different set of characters is special: ], - and ^. To include ] in a character alternative, put it at the beginning. To include ^, put it anywhere but at the beginning. To include -, put it at the end. Thus, []^-] matches all three of these special characters. You cannot use \ to escape these three characters, since \ is not special here. The following aspects of ranges are specific to Emacs, in that POSIX allows but does not require this behavior and programs other than Emacs may behave differently:
?
:: If case-fold-search is non-nil, [a-z] also matches upper-case letters.
?
:: A range is not affected by the locale's collation sequence: it always represents the set of characters with codepoints ranging between those of its bounds, so that [a-z] matches only ASCII letters, even outside the C or POSIX locale.
?
:: If the lower bound of a range is greater than its upper bound, the range is empty and represents no characters. Thus, [z-a] always fails to match, and [^z-a] matches any character, including newline. However, a reversed range should always be from the letter z to the letter a to make it clear that it is not a typo; for example, [+-*/] should be avoided, because it matches only / rather than the likely-intended four characters.
?
:: If the end points of a range are raw 8-bit bytes (Text Representations), or if the range start is ASCII and the end is a raw byte (as in [a-\377]), the range will match only ASCII characters and raw 8-bit bytes, but not non-ASCII characters. This feature is intended for searching text in unibyte buffers and strings. Some kinds of character alternatives are not the best style even though they have a well-defined meaning in Emacs. They include:
?
:: Although a range's bound can be almost any character, it is better style to stay within natural sequences of ASCII letters and digits because most people have not memorized character code tables. For example, [.-9] is less clear than [./0-9], and [`-~] is less clear than [`a-z{|}~]. Unicode character escapes can help here; for example, for most programmers [ก-ฺ฿-๛] is less clear than [\u0E01-\u0E3A\u0E3F-\u0E5B].
?
:: Although a character alternative can include duplicates, it is better style to avoid them. For example, [XYa-yYb-zX] is less clear than [XYa-z].
?
:: Although a range can denote just one, two, or three characters, it is simpler to list the characters. For example, [a-a0] is less clear than [a0], [i-j] is less clear than [ij], and [i-k] is less clear than [ijk].
?
:: Although a - can appear at the beginning of a character alternative or as the upper bound of a range, it is better style to put - by itself at the end of a character alternative. For example, although [-a-z] is valid, [a-z-] is better style; and although [*--] is valid, [*+ is clearer.
[^ ... ]
[^ begins a complemented character alternative. This matches any character except the ones specified. Thus, [^a-z0-9A-Z] matches all characters except ASCII 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. You can specify named character classes, just like in character alternatives. For instance, [^[:ascii:]] matches any non-ASCII character. Char Classes.
^
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 (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

Below is a table of the classes you can use in a character alternative, and what they mean. Note that the [ and ] characters that enclose the class name are part of the name, so a regular expression using these classes needs one more pair of brackets. For example, a regular expression matching a sequence of one or more letters and digits would be [[:alnum:]]+, not [:alnum:]+.

[:ascii:]
This matches any ASCII character (codes 0–127).
[:alnum:]
This matches any letter or digit. For multibyte characters, it matches characters whose Unicode general-category property (Character Properties) indicates they are alphabetic or decimal number characters.
[:alpha:]
This matches any letter. For multibyte characters, it matches characters whose Unicode general-category property (Character Properties) indicates they are alphabetic characters.
[:blank:]
This matches horizontal whitespace, as defined by Annex C of the Unicode Technical Standard #18. In particular, it matches spaces, tabs, and other characters whose Unicode general-category property (Character Properties) indicates they are spacing separators.
[:cntrl:]
This matches any character whose code is in the range 0–31.
[:digit:]
This matches 0 through 9. Thus, [-+[:digit:]] matches any digit, as well as + and -.
[:graph:]
This matches graphic characters—everything except whitespace, ASCII and non-ASCII control characters, surrogates, and codepoints unassigned by Unicode, as indicated by the Unicode general-category property (Character Properties).
[:lower:]
This matches any lower-case letter, as determined by the current case table (Case Tables). If case-fold-search is non-nil, this also matches any upper-case letter.
[:multibyte:]
This matches any multibyte character (Text Representations).
[:nonascii:]
This matches any non-ASCII character.
[:print:]
This matches any printing character—either whitespace, or a graphic character matched by [:graph:].
[: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 (Syntax Class Table).
[:unibyte:]
This matches any unibyte character (Text Representations).
[:upper:]
This matches any upper-case letter, as determined by the current case table (Case Tables). If case-fold-search is non-nil, this also matches any lower-case letter.
[:word:]
This matches any character that has word syntax (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 sequences starting with \ that have special meanings. 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 (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 both forms, m and n, if specified, may be no larger than 2**16 − 1 . 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:
?
:: To enclose a set of \| alternatives for other operations. Thus, the regular expression \(foo\|bar\)x matches either foox or barx.
?
:: 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.
?
:: 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 ordinary, non-shy groups. Shy groups are also called non-capturing or unnumbered groups.
\(?NUM: ... \)
is the explicitly numbered group construct. Normal groups get their number implicitly, based on their position, which can be inconvenient. This construct allows you to force a particular group number. There is no particular restriction on the numbering, e.g., you can have several groups with the same number in which case the last one to match (i.e., the rightmost match) will win. Implicitly numbered groups always get the smallest integer larger than the one of any previous group.
\DIGIT
matches the same text that matched the digit/th 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. 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. 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. You can see the list of all the currently defined categories with M-x describe-categories RET. You can also define your own categories in addition to the standard ones using the define-category function (Categories).
\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 a 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. Standard Regexps.) Below, we show first the regexp as a string in Lisp syntax (to distinguish spaces from tab characters), and then the result of evaluating it. 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 the 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.

In the rx notation (Rx Notation), the regexp could be written

(rx (any ".?!")                    ; Punctuation ending sentence.
    (zero-or-more (any "\"')]}"))  ; Closing quotes or brackets.
    (or line-end
        (seq " " line-end)
        "\t"
        "  ")                      ; Two spaces.
    (zero-or-more (any "\t\n ")))  ; Optional extra whitespace.

Since rx regexps are just S-expressions, they can be formatted and commented as such.

The rx Structured Regexp Notation

As an alternative to the string-based syntax, Emacs provides the structured rx notation based on Lisp S-expressions. This notation is usually easier to read, write and maintain than regexp strings, and can be indented and commented freely. It requires a conversion into string form since that is what regexp functions expect, but that conversion typically takes place during byte-compilation rather than when the Lisp code using the regexp is run. Here is an rx regexp(It could be written much simpler with non-greedy operators (how?)) that matches a block comment in the C programming language:

(rx "/*"                          ; Initial /*
    (zero-or-more
     (or (not (any "*"))          ;  Either non-*,
         (seq "*"                 ;  or * followed by
              (not (any "/")))))  ;  non-/
    (one-or-more "*")             ; At least one star,
    "/")                          ; and the final /

or, using shorter synonyms and written more compactly,

(rx "/*"
    (* (| (not "*")
          (: "*" (not "/"))))
    (+ "*") "/")

In conventional string syntax, it would be written

"/\\*\\(?:[^*]\\|\\*[^/]\\)*\\*+/"

The rx notation is mainly useful in Lisp code; it cannot be used in most interactive situations where a regexp is requested, such as when running query-replace-regexp or in variable customization.

Constructs in rx regexps

The various forms in rx regexps are described below. The shorthand rx represents any rx form, and rx… means zero or more rx forms. These are all valid arguments to the rx macro. Where the corresponding string regexp syntax is given, A, B, … are string regexp subexpressions. @subsubheading Literals

"some-string"
Match the string some-string literally. There are no characters with special meaning, unlike in string regexps.
?C
Match the character C literally.

@subsubheading Sequence and alternative

(seq RX...), (sequence RX...), (: RX...), (and RX...)
Match the /rx/s in sequence. Without arguments, the expression matches the empty string. Corresponding string regexp: AB... (subexpressions in sequence).
(or RX...), (| RX...)
Match exactly one of the /rx/s. If all arguments are strings, characters, or or forms so constrained, the longest possible match will always be used. Otherwise, either the longest match or the first (in left-to-right order) will be used. Without arguments, the expression will not match anything at all. Corresponding string regexp: A\|B\|....
unmatchable
Refuse any match. Equivalent to (or). regexp-unmatchable.

@subsubheading Repetition Normally, repetition forms are greedy, in that they attempt to match as many times as possible. Some forms are non-greedy; they try to match as few times as possible (Non-greedy repetition).

(zero-or-more RX...), (0+ RX...)
Match the /rx/s zero or more times. Greedy by default. Corresponding string regexp: A* (greedy), A*? (non-greedy)
(one-or-more RX...), (1+ RX...)
Match the /rx/s one or more times. Greedy by default. Corresponding string regexp: A+ (greedy), A+? (non-greedy)
(zero-or-one RX...), (optional RX...), (opt RX...)
Match the /rx/s once or an empty string. Greedy by default. Corresponding string regexp: A? (greedy), A?? (non-greedy).
(* RX...)
Match the /rx/s zero or more times. Greedy. Corresponding string regexp: A*
(+ RX...)
Match the /rx/s one or more times. Greedy. Corresponding string regexp: A+
(? RX...)
Match the /rx/s once or an empty string. Greedy. Corresponding string regexp: A?
(*? RX...)
Match the /rx/s zero or more times. Non-greedy. Corresponding string regexp: A*?
(+? RX...)
Match the /rx/s one or more times. Non-greedy. Corresponding string regexp: A+?
(?? RX...)
Match the /rx/s or an empty string. Non-greedy. Corresponding string regexp: A??
( N RX…)=, (repeat N RX)
Match the rx/s exactly /n times. Corresponding string regexp: A\{N\}
(> N RX…)=
Match the rx/s /n or more times. Greedy. Corresponding string regexp: A\{N,\}
(** N M RX...), (repeat N M RX...)
Match the rx/s at least /n but no more than m times. Greedy. Corresponding string regexp: A\{N,M\}

The greediness of some repetition forms can be controlled using the following constructs. However, it is usually better to use the explicit non-greedy forms above when such matching is required.

(minimal-match RX)
Match rx, with zero-or-more, 0+, one-or-more, 1+, zero-or-one, opt and optional using non-greedy matching.
(maximal-match RX)
Match rx, with zero-or-more, 0+, one-or-more, 1+, zero-or-one, opt and optional using greedy matching. This is the default.

@subsubheading Matching single characters

(any SET...), (char SET...), (in SET...)
Match a single character from one of the set/s. Each /set is a character, a string representing the set of its characters, a range or a character class (see below). A range is either a hyphen-separated string like "A-Z", or a cons of characters like (?A . ?Z). Note that hyphen (-) is special in strings in this construct, since it acts as a range separator. To include a hyphen, add it as a separate character or single-character string. Corresponding string regexp: [...]
(not CHARSPEC)
Match a character not included in charspec. charspec can be a character, a single-character string, an any, not, or, intersection, syntax or category form, or a character class. If charspec is an or form, its arguments have the same restrictions as those of intersection; see below. Corresponding string regexp: [^...], \SCODE, \CCODE
(intersection CHARSET...)
Match a character included in all of the charset/s. Each /charset can be a character, a single-character string, an any form without character classes, or an intersection, or or not form whose arguments are also /charset/s.
not-newline, nonl
Match any character except a newline. Corresponding string regexp: . (dot)
anychar, anything
Match any character. Corresponding string regexp: .\|\n (for example)
character class
Match a character from a named character class:
alpha, alphabetic, letter
Match alphabetic characters. More precisely, match characters whose Unicode general-category property indicates that they are alphabetic.
alnum, alphanumeric
Match alphabetic characters and digits. More precisely, match characters whose Unicode general-category property indicates that they are alphabetic or decimal digits.
digit, numeric, num
Match the digits 0–9.
xdigit, hex-digit, hex
Match the hexadecimal digits 0–9, A–F and a–f.
cntrl, control
Match any character whose code is in the range 0–31.
blank
Match horizontal whitespace. More precisely, match characters whose Unicode general-category property indicates that they are spacing separators.
space, whitespace, white
Match any character that has whitespace syntax (Syntax Class Table).
lower, lower-case
Match anything lower-case, as determined by the current case table. If case-fold-search is non-nil, this also matches any upper-case letter.
upper, upper-case
Match anything upper-case, as determined by the current case table. If case-fold-search is non-nil, this also matches any lower-case letter.
graph, graphic
Match any character except whitespace, ASCII and non-ASCII control characters, surrogates, and codepoints unassigned by Unicode, as indicated by the Unicode general-category property.
print, printing
Match whitespace or a character matched by graph.
punct, punctuation
Match any punctuation character. (At present, for multibyte characters, anything that has non-word syntax.)
word, wordchar
Match any character that has word syntax (Syntax Class Table).
ascii
Match any ASCII character (codes 0–127).
nonascii
Match any non-ASCII character (but not raw bytes). Corresponding string regexp: [[:CLASS:]]
(syntax SYNTAX)
Match a character with syntax syntax, being one of the following names: @multitable {close-parenthesis} {Syntax character} @headitem Syntax name @tab Syntax character
whitespace @tab -
punctuation @tab .
word @tab w
symbol @tab _
open-parenthesis @tab (
close-parenthesis @tab )
expression-prefix @tab '
string-quote @tab "
paired-delimiter @tab $
escape @tab \
character-quote @tab /
comment-start @tab <
comment-end @tab >
string-delimiter @tab |
comment-delimiter @tab !
@end multitable For details, Syntax Class Table. Please note that (syntax punctuation) is not equivalent to the character class punctuation. Corresponding string regexp: \sCHAR where char is the syntax character.
(category CATEGORY)
Match a character in category category, which is either one of the names below or its category character. @multitable {vowel-modifying-diacritical-mark} {Category character} @headitem Category name @tab Category character
space-for-indent @tab space
base @tab .
consonant @tab 0
base-vowel @tab 1
upper-diacritical-mark @tab 2
lower-diacritical-mark @tab 3
tone-mark @tab 4
symbol @tab 5
digit @tab 6
vowel-modifying-diacritical-mark @tab 7
vowel-sign @tab 8
semivowel-lower @tab 9
not-at-end-of-line @tab <
not-at-beginning-of-line @tab >
alpha-numeric-two-byte @tab A
chinese-two-byte @tab C
greek-two-byte @tab G
japanese-hiragana-two-byte @tab H
indian-two-byte @tab I
japanese-katakana-two-byte @tab K
strong-left-to-right @tab L
korean-hangul-two-byte @tab N
strong-right-to-left @tab R
cyrillic-two-byte @tab Y
combining-diacritic @tab ^
ascii @tab a
arabic @tab b
chinese @tab c
ethiopic @tab e
greek @tab g
korean @tab h
indian @tab i
japanese @tab j
japanese-katakana @tab k
latin @tab l
lao @tab o
tibetan @tab q
japanese-roman @tab r
thai @tab t
vietnamese @tab v
hebrew @tab w
cyrillic @tab y
can-break @tab |
@end multitable For more information about currently defined categories, run the command M-x describe-categories RET. For how to define new categories, Categories. Corresponding string regexp: \cCHAR where char is the category character.

@subsubheading Zero-width assertions These all match the empty string, but only in specific places.

line-start, bol
Match at the beginning of a line. Corresponding string regexp: ^
line-end, eol
Match at the end of a line. Corresponding string regexp: $
string-start, bos, buffer-start, bot
Match at the start of the string or buffer being matched against. Corresponding string regexp: \`
string-end, eos, buffer-end, eot
Match at the end of the string or buffer being matched against. Corresponding string regexp: \'
point
Match at point. Corresponding string regexp: \=
word-start, bow
Match at the beginning of a word. Corresponding string regexp: \<
word-end, eow
Match at the end of a word. Corresponding string regexp: \>
word-boundary
Match at the beginning or end of a word. Corresponding string regexp: \b
not-word-boundary
Match anywhere but at the beginning or end of a word. Corresponding string regexp: \B
symbol-start
Match at the beginning of a symbol. Corresponding string regexp: \_<
symbol-end
Match at the end of a symbol. Corresponding string regexp: \_>

@subsubheading Capture groups

(group RX...), (submatch RX...)
Match the /rx/s, making the matched text and position accessible in the match data. The first group in a regexp is numbered 1; subsequent groups will be numbered one above the previously highest-numbered group in the pattern so far. Corresponding string regexp: \(...\)
(group-n N RX...), (submatch-n N RX...)
Like group, but explicitly assign the group number n. n must be positive. Corresponding string regexp: \(?N:...\)
(backref N)
Match the text previously matched by group number n. n must be in the range 1–9. Corresponding string regexp: \N

@subsubheading Dynamic inclusion

(literal EXPR)
Match the literal string that is the result from evaluating the Lisp expression expr. The evaluation takes place at call time, in the current lexical environment.
(regexp EXPR), (regex EXPR)
Match the string regexp that is the result from evaluating the Lisp expression expr. The evaluation takes place at call time, in the current lexical environment.
(eval EXPR)
Match the rx form that is the result from evaluating the Lisp expression expr. The evaluation takes place at macro-expansion time for rx, at call time for rx-to-string, in the current global environment.
Functions and macros using rx regexps
rx
Translate the /rx-form/s to a string regexp, as if they were the body of a (seq ...) form. The rx macro expands to a string constant, or, if literal or regexp forms are used, a Lisp expression that evaluates to a string. Example:
(rx (+ alpha) "=" (+ digit))
  => "[[:alpha:]]+=[[:digit:]]+"
rx-to-string
Translate rx-expr to a string regexp which is returned. If no-group is absent or nil, bracket the result in a non-capturing group, \(?:...\), if necessary to ensure that a postfix operator appended to it will apply to the whole expression. Example:
(rx-to-string '(seq (+ alpha) "=" (+ digit)) t)
  => "[[:alpha:]]+=[[:digit:]]+"

Arguments to literal and regexp forms in rx-expr must be string literals. The pcase macro can use rx expressions as patterns directly; rx in pcase. For mechanisms to add user-defined extensions to the rx notation, Extending Rx.

Defining new rx forms

The rx notation can be extended by defining new symbols and parameterized forms in terms of other rx expressions. This is handy for sharing parts between several regexps, and for making complex ones easier to build and understand by putting them together from smaller pieces. For example, you could define name to mean (one-or-more letter), and (quoted X) to mean (seq ?' X ?') for any x. These forms could then be used in rx expressions like any other: (rx (quoted name)) would match a nonempty sequence of letters inside single quotes. The Lisp macros below provide different ways of binding names to definitions. Common to all of them are the following rules:

  • Built-in rx forms, like digit and group, cannot be redefined.
  • The definitions live in a name space of their own, separate from that of Lisp variables. There is thus no need to attach a suffix like -regexp to names; they cannot collide with anything else.
  • Definitions cannot refer to themselves recursively, directly or indirectly. If you find yourself needing this, you want a parser, not a regular expression.
  • Definitions are only ever expanded in calls to rx or rx-to-string, not merely by their presence in definition macros. This means that the order of definitions doesn't matter, even when they refer to each other, and that syntax errors only show up when they are used, not when they are defined.
  • User-defined forms are allowed wherever arbitrary rx expressions are expected; for example, in the body of a zero-or-one form, but not inside any or category forms. They are also allowed inside not and intersection forms.
  • rx-define :: Define name globally in all subsequent calls to rx and rx-to-string. If arglist is absent, then name is defined as a plain symbol to be replaced with rx-form. Example:
(rx-define haskell-comment (seq "--" (zero-or-more nonl)))
(rx haskell-comment)
     => "--.*"

If arglist is present, it must be a list of zero or more argument names, and name is then defined as a parameterized form. When used in an rx expression as (NAME ARG...), each arg will replace the corresponding argument name inside rx-form. arglist may end in &rest and one final argument name, denoting a rest parameter. The rest parameter will expand to all extra actual argument values not matched by any other parameter in arglist, spliced into rx-form where it occurs. Example:

(rx-define moan (x y &rest r) (seq x (one-or-more y) r "!"))
(rx (moan "MOO" "A" "MEE" "OW"))
     => "MOOA+MEEOW!"

Since the definition is global, it is recommended to give name a package prefix to avoid name clashes with definitions elsewhere, as is usual when naming non-local variables and functions. Forms defined this way only perform simple template substitution. For arbitrary computations, use them together with the rx forms eval, regexp or literal. Example:

(defun n-tuple-rx (n element)
  `(seq "<"
        (group-n 1 ,element)
        ,@(mapcar (lambda (i) `(seq ?, (group-n ,i ,element)))
                  (number-sequence 2 n))
        ">"))
(rx-define n-tuple (n element) (eval (n-tuple-rx n 'element)))
(rx (n-tuple 3 (+ (in "0-9"))))
  => "<\\(?1:[0-9]+\\),\\(?2:[0-9]+\\),\\(?3:[0-9]+\\)>"
rx-let
Make the rx definitions in bindings available locally for rx macro invocations in body, which is then evaluated. Each element of bindings is on the form (NAME [ARGLIST] RX-FORM), where the parts have the same meaning as in rx-define above. Example:
(rx-let ((comma-separated (item) (seq item (0+ "," item)))
         (number (1+ digit))
         (numbers (comma-separated number)))
  (re-search-forward (rx "(" numbers ")")))

The definitions are only available during the macro-expansion of body, and are thus not present during execution of compiled code. rx-let can be used not only inside a function, but also at top level to include global variable and function definitions that need to share a common set of rx forms. Since the names are local inside body, there is no need for any package prefixes. Example:

(rx-let ((phone-number (seq (opt ?+) (1+ (any digit ?-)))))
  (defun find-next-phone-number ()
    (re-search-forward (rx phone-number)))
  (defun phone-number-p (string)
    (string-match-p (rx bos phone-number eos) string)))

The scope of the rx-let bindings is lexical, which means that they are not visible outside body itself, even in functions called from body.

rx-let-eval
Evaluate bindings to a list of bindings as in rx-let, and evaluate body with those bindings in effect for calls to rx-to-string. This macro is similar to rx-let, except that the bindings argument is evaluated (and thus needs to be quoted if it is a list literal), and the definitions are substituted at run time, which is required for rx-to-string to work. Example:
(rx-let-eval
    '((ponder (x) (seq "Where have all the " x " gone?")))
  (looking-at (rx-to-string
               '(ponder (or "flowers" "young girls"
                            "left socks")))))

Another difference from rx-let is that the bindings are dynamically scoped, and thus also available in functions called from body. However, they are not visible inside functions defined in body.

Regular Expression Functions

These functions operate on regular expressions.

regexp-quote
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. Regexp Search. 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-"))

The returned string may be string itself if it does not contain any special characters.

regexp-opt
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(Note that regexp-opt does not guarantee that its result is absolutely the most efficient form possible. A hand-tuned regular expression can sometimes be slightly more efficient). If strings is the empty list, the return value is a regexp that never matches anything. The optional argument paren can be any of the following:
a string
The resulting regexp is preceded by paren and followed by \), e.g. use "\\(?1:" to produce an explicitly numbered group.
words
The resulting regexp is surrounded by \<\( and \)\>.
symbols
The resulting regexp is surrounded by \_<\( and \)\_> (this is often appropriate when matching programming-language keywords and the like).
non-nil
The resulting regexp is surrounded by \( and \).
nil
The resulting regexp is surrounded by \(?: and \), if it is necessary to ensure that a postfix operator appended to it will apply to the whole expression.

The returned regexp is ordered in such a way that it will always match the longest string possible. Up to reordering, the resulting regexp of regexp-opt is equivalent to but usually more efficient than that of a simplified version:

(defun simplified-regexp-opt (strings &optional paren)
 (let ((parens
        (cond
         ((stringp paren)       (cons paren "\\)"))
         ((eq paren 'words)    '("\\<\\(" . "\\)\\>"))
         ((eq paren 'symbols) '("\\_<\\(" . "\\)\\_>"))
         ((null paren)          '("\\(?:" . "\\)"))
         (t                       '("\\(" . "\\)")))))
   (concat (car parens)
           (mapconcat 'regexp-quote strings "\\|")
           (cdr parens))))
regexp-opt-depth
This function returns the total number of grouping constructs (parenthesized expressions) in regexp. This does not include shy groups (Regexp Backslash).
regexp-opt-charset
This function returns a regular expression matching a character in the list of characters chars.
(regexp-opt-charset '(?a ?b ?c ?d ?e))
     => "[a-e]"
regexp-unmatchable
This variable contains a regexp that is guaranteed not to match any string at all. It is particularly useful as default value for variables that may be set to a pattern that actually matches something.

Problems with Regular Expressions

The Emacs regexp implementation, like many of its kind, is generally robust but occasionally causes trouble in either of two ways: matching may run out of internal stack space and signal an error, and it can take a long time to complete. The advice below will make these symptoms less likely and help alleviate problems that do arise.

  • Anchor regexps at the beginning of a line, string or buffer using zero-width assertions (^ and \`). This takes advantage of fast paths in the implementation and can avoid futile matching attempts. Other zero-width assertions may also bring benefits by causing a match to fail early.
  • Avoid or-patterns in favor of character alternatives: write [ab] instead of a\|b. Recall that \s- and \sw are equivalent to [[:space:]] and [[:word:]], respectively.
  • Since the last branch of an or-pattern does not add a backtrack point on the stack, consider putting the most likely matched pattern last. For example, ^\(?:a\|.b\)*c will run out of stack if trying to match a very long string of a=s, but the equivalent =^\(?:.b\|a\)*c will not. (It is a trade-off: successfully matched or-patterns run faster with the most frequently matched pattern first.)
  • Try to ensure that any part of the text can only match in a single way. For example, a*a* will match the same set of strings as a*, but the former can do so in many ways and will therefore cause slow backtracking if the match fails later on. Make or-pattern branches mutually exclusive if possible, so that matching will not go far into more than one branch before failing. Be especially careful with nested repetitions: they can easily result in very slow matching in the presence of ambiguities. For example, \(?:a*b*\)+c will take a long time attempting to match even a moderately long string of a=s before failing. The equivalent =\(?:a\|b\)*c is much faster, and [ab]*c better still.
  • Don't use capturing groups unless they are really needed; that is, use \(?:...\) instead of \(...\) for bracketing purposes.
  • Consider using rx (Rx Notation); it can optimize some or-patterns automatically and will never introduce capturing groups unless explicitly requested.

If you run into regexp stack overflow despite following the above advice, don't be afraid of performing the matching in multiple function calls, each using a simpler regexp where backtracking can more easily be contained.

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 (non-greedy). This is because POSIX backtracking conflicts with the semantics of non-greedy repetition.

Command posix-search-forward
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
This is like re-search-backward except that it performs the full backtracking specified by the POSIX standard for regular expression matching.
posix-looking-at
This is like looking-at except that it performs the full backtracking specified by the POSIX standard for regular expression matching.
posix-string-match
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. Notice that all functions are allowed to overwrite the match data unless they're explicitly documented not to do so. A consequence is that functions that are run implicitly in the background (Timers, and Idle Timers) should likely save and restore the match data explicitly.

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.

replace-match
This function performs a replacement operation on a buffer or string. If you did the last search in a buffer, you should omit the string argument or specify nil for it, and make sure that the current buffer is the one in which you performed the last search. Then this function edits the buffer, replacing the matched text with replacement. It leaves point at the end of the replacement text. If you performed the last search on a string, pass the same string as string. Then this function returns a new string, in which the matched text is replaced by replacement. 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:
\&
This stands for the entire text being replaced.
\N, where n is a digit
This stands for the text that matched the /n/th subexpression in the original regexp. Subexpressions are those expressions grouped inside \(...\). If the /n/th subexpression never matched, an empty string is substituted.
\\
This stands for a single \ in the replacement text.
\?
This stands for itself (for compatibility with replace-regexp and related commands; Regexp Replace).

Any other character following \ signals an error. The substitutions performed by \& and \N occur after case conversion, if any. Therefore, 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\).

match-substitute-replacement
This function returns the text that would be inserted into the buffer by replace-match, but without modifying the buffer. It is useful if you want to present the user with actual replacement result, with constructs like \N or \& substituted with matched groups. Arguments replacement and optional fixedcase, literal, string and subexp have the same meaning as for replace-match.

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 /count/th 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 (Saving Match Data) around the call to functions that could perform another search. Or use the functions that explicitly do not modify the match data; e.g., string-match-p. A search which fails may or may not alter the match data. In the current implementation, it does not, but we may change it in the future. Don't try to rely on the value of the match data after a failing search.

match-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 count/th 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. Failure to follow this advice will lead to incorrect results. The value is nil if count is out of range, or for a subexpression inside a \| alternative that wasn't used or a repetition that repeated zero times.
match-string-no-properties
This function is like match-string except that the result has no text properties.
match-beginning
If the last regular expression search found a match, this function returns the position of the start of the matching text or of 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.
match-end
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))
    => (17 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.

match-data
This function returns a list of positions (markers or integers) that record all the information on the text that 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 2/n/ corresponds to (match-beginning N); and element number 2/n/ + 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>)
set-match-data
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 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)                   ; foo does more searching.
(match-end 0)
     => 61              ; Unexpected result---not 48!

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

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

Search and Replace

If you want to find all matches for a regexp in part of the buffer and replace them, the most flexible 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"))

Replacing the Text that Matched, for a description of replace-match. It may be more convenient to limit the replacements to a specific region. The function replace-regexp-in-region does that.

replace-regexp-in-region
This function replaces all the occurrences of regexp with replacement in the region of buffer text between start and end; start defaults to position of point, and end defaults to the last accessible position of the buffer. The search for regexp is case-sensitive, and replacement is inserted without changing its letter-case. The replacement string can use the same special elements starting with \ as replace-match does. The function returns the number of replaced occurrences, or nil if regexp is not found. The function preserves the position of point.
(replace-regexp-in-region "foo[ \t]+bar" "foobar")
replace-string-in-region
This function works similarly to replace-regexp-in-region, but searches for, and replaces, literal /string/s instead of regular expressions.

Emacs also has special functions for replacing matches in a string.

replace-regexp-in-string
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, and the returned value does not include the first start characters of string. To get the whole transformed string, concatenate the first start characters of string with the return value. 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.
string-replace
This function replaces all occurrences of from-string with to-string in in-string and returns the result. It may return one of its arguments unchanged, a constant string or a new string. Case is significant, and text properties are ignored.

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

perform-replace
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 the optional argument backward is non-nil, the search starts at end and goes backward.) 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 their case. 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. Non-nil region-noncontiguous-p means that the region between start and end is composed of noncontiguous pieces. The most common example of this is a rectangular region, where the pieces are separated by newline characters. This function uses one of two functions to search for the next occurrence of from-string. These functions are specified by the values of two variables: replace-re-search-function and replace-search-function. The former is called when the argument regexp-flag is non-nil, the latter when it is nil.
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".
exit-prefix
Like exit, but add the key that was pressed to unread-command-events (Event Input Misc).
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.
undo
Undo last replacement and move back to the place where that replacement was performed.
undo-all
Undo all replacements and move back to the place where the first replacement was performed.
edit
Enter a recursive edit to deal with this question—instead of any other action that would normally be taken.
edit-replacement
Edit the replacement for this question in the minibuffer.
delete-and-edit
Delete the text being considered, then enter a recursive edit to replace it.
recenter, scroll-up, scroll-down, scroll-other-window, scroll-other-window-down
Perform the specified window scroll operation, then ask the same question again. Only y-or-n-p and related functions use this answer.
quit
Perform a quit right away. Only y-or-n-p and related functions use this answer.
help
Display some help, then ask again.
multi-query-replace-map
This variable holds a keymap that extends query-replace-map by providing additional keybindings that are useful in multi-buffer replacements. The additional bindings are:
automatic-all
Answer this question and all subsequent questions in the series with "yes", without further user interaction, for all remaining buffers.
exit-current
Answer this question "no", and give up on the entire series of questions for the current buffer. Continue to the next buffer in the sequence.
replace-search-function
This variable specifies a function that perform-replace calls to search for the next string to replace. Its default value is search-forward. Any other value should name a function of 3 arguments: the first 3 arguments of search-forward (String Search).
replace-re-search-function
This variable specifies a function that perform-replace calls to search for the next regexp to replace. Its default value is re-search-forward. Any other value should name a function of 3 arguments: the first 3 arguments of re-search-forward (Regexp Search).

Standard Regular Expressions Used in Editing

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

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.

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).
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).
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, as it is by default, then the function sentence-end constructs 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.
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 (Definition of sentence-end-double-space), sentence-end-without-period, and sentence-end-without-space.
Manual
Emacs Lisp 28.2
Texinfo Node
Searching and Matching
Source Ref
emacs-28.2
Source
View upstream