Vim documentation: pattern

/\@=* \@= Matches the preceding atom with zero width. a>/a> Like "(?=pattern)" in Perl . Example matches foo\(bar\)\@= "foo" in "foobar" foo\(bar\)\@=foo nothing

/zero-width* When using "\@=" (or "^", "$", "\<", "\>") no characters are included in the match. These items are only used to check if a match can be made. This can be tricky, because a match with following items will be done in the same position. The last example above will not match "foobarfoo", because it tries match "foo" in the same position where "bar" matched.

Note that using "\&" works the same as using "\@=": "foo\&.." is the same as "\(foo\)\@=..". But using "\&" is easier, you don't need the braces.

/\@!* \@! Matches with zero width if the preceding atom does NOT match at the current position. /zero-width a>/a> Like '(?!pattern)" in Perl . Example matches foo\(bar\)\@! any "foo" not followed by "bar" a.\{-}p\@! " a ", "ap", "app", etc. not followed by a "p" if \(\(then\)\@!.\)*$ "if " not followed by "then"

Using "\@!" is tricky, because there are many places where a pattern does not match. "a.*p\@!" will match from an " a " to the end of the line, because ".*" can match all characters in the line and the "p" doesn't match at the end of the line. "a.\{-}p\@!" will match any " a ", "ap", "app", etc. that isn't followed by a "p", because the " . " can match a "p" and "p\@!" doesn't match after that.

You can't use "\@!" to look for a non-match before the matching position: "\(foo\)\@!bar" will match "bar" in "foobar", because at the position where "bar" matches, "foo" does not match. To avoid matching "foobar" you could use "\(foo\)\@!...bar", but that doesn't match a bar at the start of a line. Use "\(foo\)\@<!bar".

/\@<=* \@<= Matches with zero width if the preceding atom matches just before what follows. /zero-width a>/a> Like '(?<=pattern)" in Perl , but Vim allows non-fixed-width patterns. Example matches \(an\_s\+\)\@<=file "file" after "an" and white space or an end-of-line For speed it's often much better to avoid this multi. Try using "\zs" instead /\zs. To match the same as the above example: an\_s\+\zsfile

"\@<=" and "\@<!" check for matches just before what follows. Theoretically these matches could start anywhere before this position. But to limit the time needed, only the line where what follows matches is searched, and one line before that (if there is one). This should be sufficient to match most things and not be too slow. The part of the pattern after "\@<=" and "\@<!" are checked for a match first, thus things like "\1" don't work to reference \(\) inside the preceding atom. It does work the other way around: Example matches \1\@<=,\([a-z]\+\) ",abc" in "abc,abc"

/\@<!* \@<! Matches with zero width if the preceding atom does NOT match just before what follows. Thus this matches if there is no position in the current or previous line where the atom matches such that it ends just before what follows. /zero-width a>/a> Like '(?<!pattern)" in Perl , but Vim allows non-fixed-width patterns. The match with the preceding atom is made to end just before the match with what follows, thus an atom that ends in ".*" will work. Warning: This can be slow (because many positions need to be checked for a match). Example matches \(foo\)\@<!bar any "bar" that's not in "foobar" \(\/\/.*\)\@<!in "in" which is not after " // "

/\@>* \@> Matches the preceding atom like matching a whole pattern. a>/a> Like "(?>pattern)" in Perl . Example matches \(a*\)\@>a nothing (the "a*" takes all the "a"'s, there can't be another one following)

This matches the preceding atom as if it was a pattern by itself. If it doesn't match, there is no retry with shorter sub-matches or anything. Observe this difference: "a*b" and "a*ab" both match "aaab", but in the second case the "a*" matches only the first two "a"s. "\(a*\)\@>ab" will not match "aaab", because the "a*" matches the "aaa" (as many " a "s as possible), thus the "ab" can't match.

==============================================================================

6. Ordinary atoms pattern-atoms*

An ordinary atom can be:

/^* ^ At beginning of pattern or after "\|", "\(", "\%(" or "\n": matches start-of-line; at other positions, matches literal '^'. /zero-width Example matches ^beep( the start of the C function "beep" (probably).

/\^* \^ Matches literal '^'. Can be used at any position in the pattern.

/\_^* \_^ Matches start-of-line. /zero-width Can be used at any position in the pattern. Example matches \_s*\_^foo white space and blank lines and then "foo" at start-of-line

/$* $ At end of pattern or in front of "\|", "\)" or "\n" ('magic' on): matches end-of-line <EOL>; at other positions, matches literal '$'. /zero-width

/\$* \$ Matches literal '$'. Can be used at any position in the pattern.

/\_$* \_$ Matches end-of-line. /zero-width Can be used at any position in the pattern. Note that "a\_$b" never matches, since "b" cannot match an end-of-line. Use "a\nb" instead /\n. Example matches foo\_$\_s* "foo" at end-of-line and following white space and blank lines

. (with 'nomagic': \.) /.* /\.* Matches any single character, but not an end-of-line.

/\_.* \_. Matches any single character or end-of-line. Careful: "\_.*" matches all text to the end of the buffer!

/\<* \< Matches the beginning of a word: The next char is the first char of a word. The 'iskeyword' option specifies what is a word character. /zero-width

/\>* \> Matches the end of a word: The previous char is the last char of a word. The 'iskeyword' option specifies what is a word character. /zero-width

/\zs* \zs Matches at any position, and sets the start of the match there: The next char is the first char of the whole match. /zero-width Example: /^\s*\zsif matches an "if" at the start of a line, ignoring white space. Can be used multiple times, the last one encountered in a matching branch is used. Example: /\(.\{-}\zsFab\)\{3} Finds the third occurrence of "Fab". a>/a> {not available when compiled without the +syntax feature}

/\ze* \ze Matches at any position, and sets the end of the match there: The previous char is the last char of the whole match. /zero-width Can be used multiple times, the last one encountered in a matching branch is used. Example: "end\ze\(if\|for\)" matches the "end" in "endif" and "endfor". a>/a> {not available when compiled without the +syntax feature}

/\%^* start-of-file* \%^ Matches start of the file. When matching with a string, matches the start of the string. a>/a> For example, to find the first "VIM" in a file: /\%^\_.\{-}\zsVIM

/\%$* end-of-file* \%$ Matches end of the file. When matching with a string, matches the end of the string. a>/a> Note that this does NOT find the last "VIM" in a file: /VIM\_.\{-}\%$ It will find the next VIM, because the part after it will always match. This one will find the last "VIM" in the file: /VIM\ze\(\(VIM\)\@!\_.\)*\%$ This uses /\@! to ascertain that "VIM" does NOT match in any position after the first "VIM". Searching from the end of the file backwards is easier!

/\%V* \%V Match inside the Visual area. When Visual mode has already been stopped match in the area that gv would reselect. This is a /zero-width match. To make sure the whole pattern is inside the Visual area put it at the start and end of the pattern, e.g.: /\%Vfoo.*bar\%V Only works for the current buffer.

/\%#* cursor-position* \%# Matches with the cursor position. Only works when matching in a buffer displayed in a window . a>/a> WARNING: When the cursor is moved after the pattern was used, the result becomes invalid. Vim doesn't automatically update the matches. This is especially relevant for syntax highlighting and 'hlsearch'. In other words: When the cursor moves the display isn't updated for this change. An update is done for lines which are changed (the whole line is updated) or when using the CTRL-L command (the whole screen is updated). Example, to highlight the word under the cursor: /\k*\%#\k When 'hlsearch' is set and you move the cursor around and make changes this will clearly show when the match is updated or not.

/\%'m* /\%<'m* /\%>'m* \%'m Matches with the position of mark m. \%<'m Matches before the position of mark m. \%>'m Matches after the position of mark m. Example, to highlight the text from mark 's to 'e: /.\%>'s.*\%<'e.. Note that two dots are required to include mark 'e in the match. That is because "\%<'e" matches at the character before the 'e mark, and since it's a /zero-width match it doesn't include that character. a>/a> WARNING: When the mark is moved after the pattern was used, the result becomes invalid. Vim doesn't automatically update the matches. Similar to moving the cursor for "\%#" /\%#.

/\%l* /\%>l* /\%<l* \%23l Matches in a specific line. \%<23l Matches above a specific line (lower line number). \%>23l Matches below a specific line (higher line number). These three can be used to match specific lines in a buffer. The "23" can be any line number. The first line is 1. a>/a> WARNING: When inserting or deleting lines Vim does not automatically update the matches. This means Syntax highlighting quickly becomes wrong. Example, to highlight the line where the cursor currently is: :exe '/\%' . line(".") . 'l.*' When 'hlsearch' is set and you move the cursor around and make changes this will clearly show when the match is updated or not.

/\%c* /\%>c* /\%<c* \%23c Matches in a specific column. \%<23c Matches before a specific column. \%>23c Matches after a specific column. These three can be used to match specific columns in a buffer or string. The "23" can be any column number. The first column is 1. Actually, the column is the byte number (thus it's not exactly right for multi-byte characters). a>/a> WARNING: When inserting or deleting text Vim does not automatically update the matches. This means Syntax highlighting quickly becomes wrong. Example, to highlight the column where the cursor currently is: :exe '/\%' . col(".") . 'c' When 'hlsearch' is set and you move the cursor around and make changes this will clearly show when the match is updated or not. Example for matching a single byte in column 44: /\%>43c.\%<46c Note that "\%<46c" matches in column 45 when the " . " matches a byte in column 44.

/\%v* /\%>v* /\%<v* \%23v Matches in a specific virtual column. \%<23v Matches before a specific virtual column. \%>23v Matches after a specific virtual column. These three can be used to match specific virtual columns in a buffer or string. When not matching with a buffer in a window , the option values of the current window are used (e.g., 'tabstop'). The "23" can be any column number. The first column is 1. Note that some virtual column positions will never match, because they are halfway through a tab or other character that occupies more than one screen character. a>/a> WARNING: When inserting or deleting text Vim does not automatically update highlighted matches. This means Syntax highlighting quickly becomes wrong. Example, to highlight all the characters after virtual column 72: /\%>72v. When 'hlsearch' is set and you move the cursor around and make changes this will clearly show when the match is updated or not. To match the text up to column 17: /.*\%17v Column 17 is included, because that's where the "\%17v" matches, even though this is a /zero-width match. Adding a dot to match the next character has the same result: /.*\%17v. This command does the same thing, but also matches when there is no character in column 17: /.*\%<18v.

Character classes:

\i identifier character (see 'isident' option) /\i*

\I like "\i", but excluding digits /\I*

\k keyword character (see 'iskeyword' option) /\k*

\K like "\k", but excluding digits /\K*

\f file name character (see 'isfname' option) /\f*

\F like "\f", but excluding digits /\F*

\p printable character (see 'isprint' option) /\p*

\P like "\p", but excluding digits /\P*

the above also work for multi-byte characters. The ones below only match ASCII characters, as indicated by the range.

whitespace* white-space*

\s whitespace character: <Space> and <Tab> /\s*

\S non-whitespace character; opposite of \s /\S*

\d digit: [0-9] /\d*

\D non-digit: [^0-9] /\D*

\x hex digit: [0-9A-Fa-f] /\x*

\X non-hex digit: [^0-9A-Fa-f] /\X*

\o octal digit: [0-7] /\o*

\O non-octal digit: [^0-7] /\O*

\w word character: [0-9A-Za-z_] /\w*

\W non-word character: [^0-9A-Za-z_] /\W*

\h head of word character: [A-Za-z_] /\h*

\H non-head of word character: [^A-Za-z_] /\H*

\a alphabetic character: [A-Za-z] /\a*

\A non-alphabetic character: [^A-Za-z] /\A*

\l lowercase character: [a-z] /\l*

\L non-lowercase character: [^a-z] /\L*

\u uppercase character: [A-Z] /\u*

\U non-uppercase character [^A-Z] /\U*

'ignorecase', "\c" and "\C" are not used by character classes.

/\_* E63* /\_i* /\_I* /\_k* /\_K* /\_f* /\_F*

/\_p* /\_P* /\_s* /\_S* /\_d* /\_D* /\_x* /\_X*

/\_o* /\_O* /\_w* /\_W* /\_h* /\_H* /\_a* /\_A*

/\_l* /\_L* /\_u* /\_U* \_x Where "x" is any of the characters above: The character class with end-of-line added (end of character classes)

\e matches ␛ /\e*

\t matches <Tab> /\t*

\r matches ␍ /\r*

\b matches <BS> /\b*

\n matches an end-of-line /\n* When matching in a string instead of buffer text a literal newline character is matched.

~ matches the last given substitute string /~* /\~*

\(\) A pattern enclosed by escaped parentheses. /\(* /\(\)* /\)*

E.g., "\(^a\)" matches ' a ' at the start of a line. E51* E54* E55*

\1 Matches the same string that was matched by /\1* E65* the first sub-expression in \( and \). a>/a> Example: "\([a-z]\).\1" matches "ata", "ehe", "tot", etc.

\2 Like "\1", but uses second sub-expression, /\2*

... /\3*

\9 Like "\1", but uses ninth sub-expression. /\9* Note: The numbering of groups is done based on which "\(" comes first in the pattern (going left to right), NOT based on what is matched first.

\%(\) A pattern enclosed by escaped parentheses. /\%(\)* /\%(* E53* Just like \(\), but without counting it as a sub-expression. This allows using more groups and it's a little bit faster. a>/a>

x A single character, with no special meaning, matches itself

/\* /\\* \x A backslash followed by a single character, with no special meaning, is reserved for future expansions

[] (with 'nomagic': \[]) /[]* /\[]* /\_[]* /collection* \_[] A collection. This is a sequence of characters enclosed in brackets. It matches any single character in the collection. Example matches [xyz] any 'x', 'y' or ' z ' [a-zA-Z]$ any alphabetic character at the end of a line \c[a-z]$ same

/[\n]* With "\_" prepended the collection also includes the end-of-line. The same can be done by including "\n" in the collection. The end-of-line is also matched when the collection starts with "^"! Thus "\_[^ab]" matches the end-of-line and any character but " a " and "b". This makes it Vi compatible: Without the "\_" or "\n" the collection does not match an end-of-line.

E769* When the ' ] ' is not there Vim will not give an error message but assume no collection is used. Useful to search for ' [ '. However, you do get E769 for internal searching.

If the sequence begins with "^", it matches any single character NOT in the collection: "[^xyz]" matches anything but 'x', 'y' and ' z '. - If two characters in the sequence are separated by '-', this is shorthand for the full list of ASCII characters between them. E.g., "[0-9]" matches any decimal digit.

A character class expression is evaluated to the set of characters belonging to that character class. Name Contents

[:alnum:]* [:alnum:] letters and digits

[:alpha:]* [:alpha:] letters

[:blank:]* [:blank:] space and tab characters

[:cntrl:]* [:cntrl:] control characters

[:digit:]* [:digit:] decimal digits

[:graph:]* [:graph:] printable characters excluding space

[:lower:]* [:lower:] lowercase letters (all letters when 'ignorecase' is used)

[:print:]* [:print:] printable characters including space

[:punct:]* [:punct:] punctuation characters

[:space:]* [:space:] whitespace characters

[:upper:]* [:upper:] uppercase letters (all letters when 'ignorecase' is used)

[:xdigit:]* [:xdigit:] hexadecimal digits

[:return:]* [:return:] the ␍ character

[:tab:]* [:tab:] the <Tab> character

[:escape:]* [:escape:] the ␛ character

[:backspace:]* [:backspace:] the <BS> character The brackets in character class expressions are additional to the brackets delimiting a collection. For example, the following is a plausible pattern for a UNIX filename: "[-./[:alnum:]_~]\+" That is, a list of at least one character, each of which is either '-', ' . ', '#/">/', alphabetic, numeric, '_' or '~'. These items only work for 8-bit characters.

/[[=* [==]* - An equivalence class. This means that characters are matched that have almost the same meaning, e.g., when ignoring accents. The form is: [=a=] Currently this is only implemented for latin1. Also works for the latin1 characters in utf-8 and latin9.

/[[.* [..]* - A collation element. This currently simply accepts a single character in the form: [.a.]

/\]* - To include a literal ' ] ', '^', '-' or '\' in the collection, put a backslash before it: ;[xyz\]], ;[\^xyz], ;[xy\-z] and ;[xyz\\]. (Note: POSIX does not support the use of a backslash this way).
For ] you can also make it the first character (following a possible ;^): ;[]xyz] or ;[^]xyz] a>/a>.
For '-' you can also make it the first or last character: ;[-xyz];, ;[^-xyz] or ;[xyz-].
For \ you can also let it be followed by any character that's not in ;^]-\bertn. ;[\xyz] matches '\', 'x', 'y' and ' z '. It's better to use ;\\ though, future expansions may use other characters after '\'.

- The following translations are accepted when the 'l' flag is not included in cpoptions a>/a>:

\e ␛

\t <Tab>

\r ␍ (NOT end-of-line!)

\b <BS>

\n line break, see above /[\n]

\d123 decimal number of character

\o40 octal number of character up to 0377

\x20 hexadecimal number of character up to 0xff

\u20AC hex. number of multibyte character up to 0xffff

\U1234 hex. number of multibyte character up to 0xffffffff

NOTE: The other backslash codes mentioned above do not work inside []! - Matching with a collection can be slow, because each character in the text has to be compared with each character in the collection. Use one of the other atoms above when possible. Example: "\d" is much faster than "[0-9]" and matches the same characters.

/\%[]* A sequence of optionally matched atoms. This always matches. It matches as much of the list of atoms it contains as possible. Thus it stops at the first atom that doesn't match. For example: /r\%[ead] matches ;r, ;re, ;rea or ;read. The longest that matches is used. To match the Ex command ;function, where ;fu is required and ;nction is optional, this would work: /\<fu\%[nction]\> The end-of-word atom ;\> is used to avoid matching ;fu in ;full. It gets more complicated when the atoms are not ordinary characters. You don't often have to use it, but it is possible. Example: /\<r\%[[eo]ad]\> Matches the words ;r, ;re, ;ro, ;rea, ;roa, ;read and ;road.
There can be no \(\), \%(\) or \z(\) items inside the [] and \%[] does not nest.
To include a ; [ use ;[[] and for ; ] use []];, e.g.,: /index\%[[[]0[]]] matches ;index ;index[, ;index[0 and ;index[0]. {not available when compiled without the +syntax feature} /\%d /\%x /\%o /\%u /\%U E678

\%d123 Matches the character specified with a decimal number. Must be followed by a non-digit.
\%o40 Matches the character specified with an octal number up to 0377.
Numbers below 040 must be followed by a non-octal digit or a non-digit.
\%x2a Matches the character specified with up to two hexadecimal characters.
\%u20AC Matches the character specified with up to four hexadecimal characters.
\%U1234abcd Matches the character specified with up to eight hexadecimal characters.

7. Ignoring case in a pattern /ignorecase*

If the 'ignorecase' option is on, the case of normal letters is ignored. 'smartcase' can be set to ignore case when the pattern contains lowercase letters only.

/\c* /\C* When "\c" appears anywhere in the pattern, the whole pattern is handled like 'ignorecase' is on. The actual value of 'ignorecase' and 'smartcase' is ignored. "\C" does the opposite: Force matching case for the whole pattern. {only Vim supports \c and \C} Note that 'ignorecase', "\c" and "\C" are not used for the character classes.

Examples: pattern 'ignorecase' 'smartcase' matches foo off - foo foo on - foo Foo FOO Foo on off foo Foo FOO Foo on on Foo \cfoo - - foo Foo FOO foo\C - - foo

Technical detail: NL-used-for-Nul* <Nul> characters in the file are stored as <NL> in memory. In the display they are shown as "^@". The translation is done when reading and writing files. To match a <Nul> with a search pattern you can just enter CTRL-@ or " CTRL-V 000". This is probably just what you expect. Internally the character is replaced with a <NL> in the search pattern. What is unusual is that typing CTRL-V CTRL-J also inserts a <NL>, thus also searches for a <Nul> in the file. {Vi cannot handle <Nul> characters in the file at all}

CR-used-for-NL* When 'fileformat' is " mac ", <NL> characters in the file are stored as ␍ characters internally. In the text they are shown as "^J". Otherwise this works similar to the usage of <NL> for a <Nul>.

When working with expression evaluation, a <NL> character in the pattern matches a <NL> in the string. The use of "\n" (backslash n) to match a <NL> doesn't work there, it only works to match text in the buffer.

pattern-multi-byte* Patterns will also work with multi-byte characters, mostly as you would expect. But invalid bytes may cause trouble, a pattern with an invalid byte will probably never match.

==============================================================================

8. Composing characters patterns-composing*

/\Z* When "\Z" appears anywhere in the pattern, composing characters are ignored. Thus only the base characters need to match, the composing characters may be different and the number of composing characters may differ. Only relevant when 'encoding' is " utf-8 ".

When a composing character appears at the start of the pattern of after an item that doesn't include the composing character, a match is found at any character that includes this composing character.

When using a dot and a composing character, this works the same as the composing character by itself, except that it doesn't matter what comes before this.

The order of composing characters matters, even though changing the order doesn't change what a character looks like. This may change in the future.

==============================================================================

9. Compare with Perl patterns perl-patterns*

Vim's regexes are most similar to Perl's, in terms of what you can do . The difference between them is mostly just notation; here's a summary of where they differ:

Capability in Vimspeak in Perlspeak force case insensitivity \c (?i) force case sensitivity \C (?-i) backref-less grouping \%(atom\) (?:atom) conservative quantifiers \{-n,m} *?, +?, ??, {}? 0-width match atom\@= (?=atom) 0-width non-match atom\@! (?!atom) 0-width preceding match atom\@<= (?<=atom) 0-width preceding non-match atom\@<! (?<!atom) match without retry atom\@> (?>atom)

Vim and Perl handle newline characters inside a string a bit differently:

In Perl , ^ and $ only match at the very beginning and end of the text, by default, but you can set the 'm' flag, which lets them match at embedded newlines as well. You can also set the 's' flag, which causes a . to match newlines as well. (Both these flags can be changed inside a pattern using the same syntax used for the i flag above, BTW.)

On the other hand, Vim's ^ and $ always match at embedded newlines, and you get two separate atoms, \%^ and \%$, which only match at the very start and end of the text, respectively. Vim solves the second problem by giving you the \_ "modifier": put it in front of a . or a character class, and they will match newlines as well.

Finally, these constructs are unique to Perl : - execution of arbitrary code in the regex: (?{perl code}) - conditional expressions: (?(condition)true-expr|false-expr)

...and these are unique to Vim: - changing the magic-ness of a pattern: \v \V \m \M (very useful for avoiding backslashitis) - sequence of optionally matching atoms: \%[atoms] - \& (which is to \| what "and" is to "or"; it forces several branches to match at one spot) - matching lines/columns by number: \%5l \%5c \%5v - setting the start and end of the match: \zs \ze

==============================================================================

10. Highlighting matches match-highlight*

:mat* :match* :mat[ch] {group} /{pattern}/ Define a pattern to highlight in the current window . It will be highlighted with {group}. Example: :highlight MyGroup ctermbg=green guibg=green :match MyGroup /TODO/ Instead of // any character can be used to mark the start and end of the {pattern}. Watch out for using special characters, such as '"'' and '|'.

{group} must exist at the moment this command is executed.

The {group} highlighting still applies when a character is to be highlighted for 'hlsearch', as the highlighting for matches is given higher priority than that of 'hlsearch'. Syntax highlighting (see 'syntax') is also overruled by matches.

Note that highlighting the last used search pattern with 'hlsearch' is used in all windows , while the pattern defined with "#:match">:match" only exists in the current window . It is kept when switching to another buffer.

'ignorecase' does not apply, use /\c in the pattern to ignore case. Otherwise case is not ignored.

'redrawtime' defines the maximum time searched for pattern matches.

When matching end-of-line and Vim redraws only part of the display you may get unexpected results. That is because Vim looks for a match in the line where redrawing starts.

Also see matcharg() and getmatches() . The former returns the highlight group and pattern of a previous :match command. The latter returns a list with highlight groups and patterns defined by both matchadd() and :match.

Highlighting matches using :match are limited to three matches (aside from :match, :2match and :3match are available). matchadd() does not have this limitation and in addition makes it possible to prioritize matches.

Another example, which highlights all characters in virtual column 72 and more: :highlight rightMargin term=bold ctermfg=blue guifg=blue :match rightMargin /.\%>72v/
To highlight all character that are in virtual column 7: :highlight col8 ctermbg=grey guibg=grey
:match col8 /\%<8v.\%>7v/
Note the use of two items to also match a character that occupies more than one virtual column, such as a TAB.

:mat[ch] :mat[ch] none Clear a previously defined match pattern.
:2mat[ch] {group} /pattern/ :2mat[ch] :2mat[ch] none
:3mat[ch] {group} /pattern/ :3mat[ch] :3mat[ch] none	like #:match">:match, but set a separate match. Thus there can be three matches active at the same time. The match with the lowest number has priority if several match at the same position. #:3match">:3match is used by the matchparen plugin . Suggest using #:match">:match for manual matching and #:2match">:2match for another plugin .

main help file