Next: Character Classes, Up: Syntax of Regular Expressions   [Contents][Index]

35.3.1.1 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 bracket expression (a.k.a. character alternative), which begins with ‘[’ and is terminated by ‘]’. In the simplest case, the characters between the two brackets are what this bracket expression 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 bracket expression, 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 bracket expression can also specify named character classes (see Character Classes). 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 bracket expression. A completely different set of characters is special: ‘]’, ‘-’ and ‘^’. To include ‘]’ in a bracket expression, 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:

1. If case-fold-search is non-nil, ‘[a-z]’ also matches upper-case letters.
2. 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.
3. 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.
4. If the end points of a range are raw 8-bit bytes (see 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.
5. To search for raw bytes, which are characters belonging to the eight-bit character set (see Character Sets), you can use ‘[\200-\377]’ or ‘[\x3fff80-\x3fffff]’

Some kinds of bracket expressions are not the best style even though they have a well-defined meaning in Emacs. They include:

1. 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]’.
2. Although a bracket expression can include duplicates, it is better style to avoid them. For example, ‘[XYa-yYb-zX]’ is less clear than ‘[XYa-z]’.
3. 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]’.
4. Although a ‘-’ can appear at the beginning of a bracket expression or as the upper bound of a range, it is better style to put ‘-’ by itself at the end of a bracket expression. For example, although ‘[-a-z]’ is valid, ‘[a-z-]’ is better style; and although ‘[*--]’ is valid, ‘[*+,-]’ is clearer.

‘[^ … ]’ ¶

‘[^’ begins a complemented bracket expression, or 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 bracket expression 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 bracket expression 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 bracket expressions. For instance, ‘[^[:ascii:]]’ matches any non-ASCII character. See Character 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, ‘^’ is special only at the beginning of the regular expression, or after ‘\(’, ‘\(?:’ or ‘\|’. Although ‘^’ is an ordinary character in other contexts, it is good practice to use ‘\^’ even then.

‘$’ ¶

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, ‘$’ is special only at the end of the regular expression, or before ‘\)’ or ‘\|’. Although ‘$’ is an ordinary character in other contexts, it is good practice to use ‘\$’ even then.

‘\’ ¶

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

For historical compatibility, a repetition operator is treated as ordinary if it appears at the start of a regular expression or after ‘^’, ‘\`’, ‘\(’, ‘\(?:’ or ‘\|’. For example, ‘*foo’ is treated as ‘\*foo’, and ‘two\|^\{2\}’ is treated as ‘two\|^{2}’. It is poor practice to depend on this behavior; use proper backslash escaping anyway, regardless of where the repetition operator appears.

As a ‘\’ is not special inside a bracket expression, it can never remove the special meaning of ‘-’, ‘^’ or ‘]’. You should not quote these characters when they have no special meaning. 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 bracket expression 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 bracket expression. For example, ‘[^][]]’ consists of the complemented bracket expression ‘[^][]’ (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 bracket expression; ‘[’ 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 bracket expression and restores the ordinary syntax of regular expressions; an unquoted ‘[’ is special again and a ‘]’ not.

---

Next: Backslash Constructs in Regular Expressions, Previous: Special Characters in Regular Expressions, Up: Syntax of Regular Expressions   [Contents][Index]

35.3.1.2 Character Classes ¶

Below is a table of the classes you can use in a bracket expression (see bracket expression), 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 (see 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 (see 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 (see Character Properties) indicates they are spacing separators. (If you only need to look for ASCII whitespace characters, we suggest using an explicit set of character alternatives, such as ‘[ \t]’, instead, as it will be faster than [[:blank:]].)

‘[: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 spaces, ASCII and non-ASCII control characters, surrogates, and codepoints unassigned by Unicode, as indicated by the Unicode ‘general-category’ property (see Character Properties).

‘[:lower:]’

This matches any lower-case letter, as determined by the current case table (see The Case Table). If case-fold-search is non-nil, this also matches any upper-case letter. Note that a buffer can have its own local case table different from the default one.

‘[:multibyte:]’

This matches any multibyte character (see Text Representations).

‘[:nonascii:]’

This matches any non-ASCII character.

‘[:print:]’

This matches any printing character—either spaces or graphic characters matched by ‘[:graph:]’.

‘[:punct:]’

This matches any punctuation character. (At present, for multibyte characters, it matches anything that has non-word syntax, and thus its exact definition can vary from one major mode to another, since the syntax of a character depends on the major mode.)

‘[:space:]’

This matches any character that has whitespace syntax (see Table of Syntax Classes). Note that the syntax of a character, and thus which characters are considered “whitespace”, depends on the major mode.

‘[:unibyte:]’

This matches any unibyte character (see Text Representations).

‘[:upper:]’

This matches any upper-case letter, as determined by the current case table (see The Case Table). If case-fold-search is non-nil, this also matches any lower-case letter. Note that a buffer can have its own local case table different from the default one.

‘[:word:]’

This matches any character that has word syntax (see Table of Syntax Classes). Note that the syntax of a character, and thus which characters are considered “word-constituent”, depends on the major mode.

‘[:xdigit:]’

This matches the hexadecimal digits: ‘0’ through ‘9’, ‘a’ through ‘f’ and ‘A’ through ‘F’.

The classes ‘[:space:]’, ‘[:word:]’ and ‘[:punct:]’ use the syntax-table of the current buffer but not any overriding syntax text properties (see Syntax Properties).

---

Previous: Character Classes, Up: Syntax of Regular Expressions   [Contents][Index]

35.3.1.3 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 (see Emacs versus POSIX Regular Expressions).

‘\{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:

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 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 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 Table of Syntax Classes, for a list of syntax codes and the characters that stand for them.

‘\Scode’ ¶

matches any character whose syntax is not code.

‘\ccode’ ¶

matches any character whose category is code. Here code is a character that represents a category: for example, in the standard category table, ‘c’ stands for Chinese characters and ‘g’ stands for Greek characters. 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 (see Categories).

‘\Ccode’

matches any character whose category is not code.

The following regular expression constructs match the empty string—that is, they don’t consume 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 bracket expression 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.

---

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

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

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

Next: Functions and macros using rx regexps, Up: The rx Structured Regexp Notation   [Contents][Index]

35.3.3.1 Constructs in rx regexps ¶

The various forms in rx regexps are described below. The shorthand rx represents any rx form. rx… means zero or more rx forms and, unless stated otherwise, matches these forms in sequence as if wrapped in a (seq …) subform.

These are all valid arguments to the rx macro. All forms are defined by their described semantics; the corresponding string regexps are provided for ease of understanding only. A, B, … denote (suitably bracketed) string regexp subexpressions therein.

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.

Sequence and alternative ¶

(seq rx…) ¶

(sequence rx…)

(: rx…)

(and rx…)

Match the rxs 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 rxs. 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). See regexp-unmatchable.

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 (see Non-greedy repetition).

(zero-or-more rx…) ¶

(0+ rx…)

Match the rxs zero or more times. Greedy by default.
Corresponding string regexp: ‘A*’ (greedy), ‘A*?’ (non-greedy)

(one-or-more rx…) ¶

(1+ rx…)

Match the rxs 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 rxs once or an empty string. Greedy by default.
Corresponding string regexp: ‘A?’ (greedy), ‘A??’ (non-greedy).

(* rx…) ¶

Match the rxs zero or more times. Greedy.
Corresponding string regexp: ‘A*’

(+ rx…) ¶

Match the rxs one or more times. Greedy.
Corresponding string regexp: ‘A+’

(? rx…) ¶

Match the rxs once or an empty string. Greedy.
Corresponding string regexp: ‘A?’

(*? rx…) ¶

Match the rxs zero or more times. Non-greedy.
Corresponding string regexp: ‘A*?’

(+? rx…) ¶

Match the rxs one or more times. Non-greedy.
Corresponding string regexp: ‘A+?’

(?? rx…) ¶

Match the rxs or an empty string. Non-greedy.
Corresponding string regexp: ‘A??’

(= n rx…)

(repeat n rx)

Match the rxs exactly n times.
Corresponding string regexp: ‘A\{n\}’

(>= n rx…) ¶

Match the rxs n or more times. Greedy.
Corresponding string regexp: ‘A\{n,\}’

(** n m rx…) ¶

(repeat n m rx…)

Match the rxs 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.

Matching single characters ¶

(any set…) ¶

(char set…)

(in set…)

Match a single character from one of the sets. 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 charsets. 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 charsets.

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 (see Table of Syntax Classes).

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 (see Table of Syntax Classes).

ascii

Match any ASCII character (codes 0–127).

nonascii

Match any non-ASCII character (but not raw bytes).

The classes space, word and punct use the syntax-table of the current buffer but not any overriding syntax text properties (see Syntax Properties).
Corresponding string regexp: ‘[[:class:]]’

(syntax syntax) ¶

Match a character with syntax syntax, being one of the following names:

Syntax name	Syntax character
whitespace	-
punctuation	.
word	w
symbol	_
open-parenthesis	(
close-parenthesis	)
expression-prefix	'
string-quote	"
paired-delimiter	$
escape	\
character-quote	/
comment-start	<
comment-end	>
string-delimiter	|
comment-delimiter	!

For details, see Table of Syntax Classes. 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.

Category name	Category character
space-for-indent	space
base	.
consonant	0
base-vowel	1
upper-diacritical-mark	2
lower-diacritical-mark	3
tone-mark	4
symbol	5
digit	6
vowel-modifying-diacritical-mark	7
vowel-sign	8
semivowel-lower	9
not-at-end-of-line	<
not-at-beginning-of-line	>
alpha-numeric-two-byte	A
chinese-two-byte	C
greek-two-byte	G
japanese-hiragana-two-byte	H
indian-two-byte	I
japanese-katakana-two-byte	K
strong-left-to-right	L
korean-hangul-two-byte	N
strong-right-to-left	R
cyrillic-two-byte	Y
combining-diacritic	^
ascii	a
arabic	b
chinese	c
ethiopic	e
greek	g
korean	h
indian	i
japanese	j
japanese-katakana	k
latin	l
lao	o
tibetan	q
japanese-roman	r
thai	t
vietnamese	v
hebrew	w
cyrillic	y
can-break	|

For more information about currently defined categories, run the command M-x describe-categories RET. For how to define new categories, see Categories.
Corresponding string regexp: ‘\cchar’ where char is the category character.

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: ‘\_>’

Capture groups ¶

(group rx…) ¶

(submatch rx…)

Match the rxs, 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’

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.

---

Next: Defining new rx forms, Previous: Constructs in rx regexps, Up: The rx Structured Regexp Notation   [Contents][Index]

35.3.3.2 Functions and macros using rx regexps ¶

Macro: rx rx-form… ¶

Translate the rx-forms 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:]]+"

Function: rx-to-string rx-expr &optional no-group ¶

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; see rx in pcase.

For mechanisms to add user-defined extensions to the rx notation, see Defining new rx forms.

---

Previous: Functions and macros using rx regexps, Up: The rx Structured Regexp Notation   [Contents][Index]

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

Macro: rx-define name [arglist] rx-form ¶

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]+\\)>"

Macro: rx-let (bindings…) body… ¶

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.

Macro: rx-let-eval bindings body… ¶

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.

---