1 *pattern.txt* For Vim version 7.2. Last change: 2008 Jul 16
4 VIM REFERENCE MANUAL by Bram Moolenaar
7 Patterns and search commands *pattern-searches*
9 The very basics can be found in section |03.9| of the user manual. A few more
10 explanations are in chapter 27 |usr_27.txt|.
12 1. Search commands |search-commands|
13 2. The definition of a pattern |search-pattern|
15 4. Overview of pattern items |pattern-overview|
16 5. Multi items |pattern-multi-items|
17 6. Ordinary atoms |pattern-atoms|
18 7. Ignoring case in a pattern |/ignorecase|
19 8. Composing characters |patterns-composing|
20 9. Compare with Perl patterns |perl-patterns|
21 10. Highlighting matches |match-highlight|
23 ==============================================================================
24 1. Search commands *search-commands* *E486*
27 /{pattern}[/]<CR> Search forward for the [count]'th occurrence of
28 {pattern} |exclusive|.
30 /{pattern}/{offset}<CR> Search forward for the [count]'th occurrence of
31 {pattern} and go |{offset}| lines up or down.
35 /<CR> Search forward for the [count]'th latest used
36 pattern |last-pattern| with latest used |{offset}|.
38 //{offset}<CR> Search forward for the [count]'th latest used
39 pattern |last-pattern| with new |{offset}|. If
40 {offset} is empty no offset is used.
43 ?{pattern}[?]<CR> Search backward for the [count]'th previous
44 occurrence of {pattern} |exclusive|.
46 ?{pattern}?{offset}<CR> Search backward for the [count]'th previous
47 occurrence of {pattern} and go |{offset}| lines up or
51 ?<CR> Search backward for the [count]'th latest used
52 pattern |last-pattern| with latest used |{offset}|.
54 ??{offset}<CR> Search backward for the [count]'th latest used
55 pattern |last-pattern| with new |{offset}|. If
56 {offset} is empty no offset is used.
59 n Repeat the latest "/" or "?" [count] times.
60 |last-pattern| {Vi: no count}
63 N Repeat the latest "/" or "?" [count] times in
64 opposite direction. |last-pattern| {Vi: no count}
67 * Search forward for the [count]'th occurrence of the
68 word nearest to the cursor. The word used for the
69 search is the first of:
70 1. the keyword under the cursor |'iskeyword'|
71 2. the first keyword after the cursor, in the
73 3. the non-blank word under the cursor
74 4. the first non-blank word after the cursor,
76 Only whole keywords are searched for, like with the
77 command "/\<keyword\>". |exclusive| {not in Vi}
78 'ignorecase' is used, 'smartcase' is not.
81 # Same as "*", but search backward. The pound sign
82 (character 163) also works. If the "#" key works as
83 backspace, try using "stty erase <BS>" before starting
84 Vim (<BS> is CTRL-H or a real backspace). {not in Vi}
87 g* Like "*", but don't put "\<" and "\>" around the word.
88 This makes the search also find matches that are not a
89 whole word. {not in Vi}
92 g# Like "#", but don't put "\<" and "\>" around the word.
93 This makes the search also find matches that are not a
94 whole word. {not in Vi}
97 gd Goto local Declaration. When the cursor is on a local
98 variable, this command will jump to its declaration.
99 First Vim searches for the start of the current
100 function, just like "[[". If it is not found the
101 search stops in line 1. If it is found, Vim goes back
102 until a blank line is found. From this position Vim
103 searches for the keyword under the cursor, like with
104 "*", but lines that look like a comment are ignored
105 (see 'comments' option).
106 Note that this is not guaranteed to work, Vim does not
107 really check the syntax, it only searches for a match
108 with the keyword. If included files also need to be
109 searched use the commands listed in |include-search|.
110 After this command |n| searches forward for the next
111 match (not backward).
115 gD Goto global Declaration. When the cursor is on a
116 global variable that is defined in the file, this
117 command will jump to its declaration. This works just
118 like "gd", except that the search for the keyword
119 always starts in line 1. {not in Vi}
122 1gd Like "gd", but ignore matches inside a {} block that
123 ends before the cursor position. {not in Vi}
126 1gD Like "gD", but ignore matches inside a {} block that
127 ends before the cursor position. {not in Vi}
130 CTRL-C Interrupt current (search) command. Use CTRL-Break on
131 MS-DOS |dos-CTRL-Break|.
132 In Normal mode, any pending command is aborted.
135 :noh[lsearch] Stop the highlighting for the 'hlsearch' option. It
136 is automatically turned back on when using a search
137 command, or setting the 'hlsearch' option.
138 This command doesn't work in an autocommand, because
139 the highlighting state is saved and restored when
140 executing autocommands |autocmd-searchpat|.
141 Same thing for when invoking a user function.
143 While typing the search pattern the current match will be shown if the
144 'incsearch' option is on. Remember that you still have to finish the search
145 command with <CR> to actually position the cursor at the displayed match. Or
146 use <Esc> to abandon the search.
148 All matches for the last used search pattern will be highlighted if you set
149 the 'hlsearch' option. This can be suspended with the |:nohlsearch| command.
151 *search-offset* *{offset}*
152 These commands search for the specified pattern. With "/" and "?" an
153 additional offset may be given. There are two types of offsets: line offsets
154 and character offsets. {the character offsets are not in Vi}
156 The offset gives the cursor position relative to the found match:
157 [num] [num] lines downwards, in column 1
158 +[num] [num] lines downwards, in column 1
159 -[num] [num] lines upwards, in column 1
160 e[+num] [num] characters to the right of the end of the match
161 e[-num] [num] characters to the left of the end of the match
162 s[+num] [num] characters to the right of the start of the match
163 s[-num] [num] characters to the left of the start of the match
164 b[+num] [num] identical to s[+num] above (mnemonic: begin)
165 b[-num] [num] identical to s[-num] above (mnemonic: begin)
166 ;{pattern} perform another search, see |//;|
168 If a '-' or '+' is given but [num] is omitted, a count of one will be used.
169 When including an offset with 'e', the search becomes inclusive (the
170 character the cursor lands on is included in operations).
174 pattern cursor position ~
175 /test/+1 one line below "test", in column 1
176 /test/e on the last t of "test"
177 /test/s+2 on the 's' of "test"
178 /test/b-3 three characters before "test"
180 If one of these commands is used after an operator, the characters between
181 the cursor position before and after the search is affected. However, if a
182 line offset is given, the whole lines between the two cursor positions are
185 An example of how to search for matches with a pattern and change the match
188 c//e change until end of match
189 bar<Esc> type replacement
190 //<CR> go to start of next match
191 c//e change until end of match
192 beep<Esc> type another replacement
196 A very special offset is ';' followed by another search command. For example: >
201 The first one first finds the next occurrence of "test 1", and then the first
202 occurrence of "test" after that.
204 This is like executing two search commands after each other, except that:
205 - It can be used as a single motion command after an operator.
206 - The direction for a following "n" or "N" command comes from the first
208 - When an error occurs the cursor is not moved at all.
211 The last used pattern and offset are remembered. They can be used to repeat
212 the search, possibly in another direction or with another count. Note that
213 two patterns are remembered: One for 'normal' search commands and one for the
214 substitute command ":s". Each time an empty pattern is given, the previously
215 used pattern is used.
217 The 'magic' option sticks with the last used pattern. If you change 'magic',
218 this will not change how the last used pattern will be interpreted.
219 The 'ignorecase' option does not do this. When 'ignorecase' is changed, it
220 will result in the pattern to match other text.
222 All matches for the last used search pattern will be highlighted if you set
223 the 'hlsearch' option.
225 To clear the last used search pattern: >
227 This will not set the pattern to an empty string, because that would match
228 everywhere. The pattern is really cleared, like when starting Vim.
230 The search usually skips matches that don't move the cursor. Whether the next
231 match is found at the next character or after the skipped match depends on the
232 'c' flag in 'cpoptions'. See |cpo-c|.
233 with 'c' flag: "/..." advances 1 to 3 characters
234 without 'c' flag: "/..." advances 1 character
235 The unpredictability with the 'c' flag is caused by starting the search in the
236 first column, skipping matches until one is found past the cursor position.
238 When searching backwards, searching starts at the start of the line, using the
239 'c' flag in 'cpoptions' as described above. Then the last match before the
240 cursor position is used.
242 In Vi the ":tag" command sets the last search pattern when the tag is searched
243 for. In Vim this is not done, the previous search pattern is still remembered,
244 unless the 't' flag is present in 'cpoptions'. The search pattern is always
245 put in the search history.
247 If the 'wrapscan' option is on (which is the default), searches wrap around
248 the end of the buffer. If 'wrapscan' is not set, the backward search stops
249 at the beginning and the forward search stops at the end of the buffer. If
250 'wrapscan' is set and the pattern was not found the error message "pattern
251 not found" is given, and the cursor will not be moved. If 'wrapscan' is not
252 set the message becomes "search hit BOTTOM without match" when searching
253 forward, or "search hit TOP without match" when searching backward. If
254 wrapscan is set and the search wraps around the end of the file the message
255 "search hit TOP, continuing at BOTTOM" or "search hit BOTTOM, continuing at
256 TOP" is given when searching backwards or forwards respectively. This can be
257 switched off by setting the 's' flag in the 'shortmess' option. The highlight
258 method 'w' is used for this message (default: standout).
261 You can limit the search command "/" to a certain range of lines by including
262 \%>l items. For example, to match the word "limit" below line 199 and above
267 Another way is to use the ":substitute" command with the 'c' flag. Example: >
269 This command will search from the cursor position until line 300 for
270 "Pattern". At the match, you will be asked to type a character. Type 'q' to
271 stop at this match, type 'n' to find the next match.
273 The "*", "#", "g*" and "g#" commands look for a word near the cursor in this
274 order, the first one that is found is used:
275 - The keyword currently under the cursor.
276 - The first keyword to the right of the cursor, in the same line.
277 - The WORD currently under the cursor.
278 - The first WORD to the right of the cursor, in the same line.
279 The keyword may only contain letters and characters in 'iskeyword'.
280 The WORD may contain any non-blanks (<Tab>s and/or <Space>s).
281 Note that if you type with ten fingers, the characters are easy to remember:
282 the "#" is under your left hand middle finger (search to the left and up) and
283 the "*" is under your right hand middle finger (search to the right and down).
284 (this depends on your keyboard layout though).
286 ==============================================================================
287 2. The definition of a pattern *search-pattern* *pattern* *[pattern]*
288 *regular-expression* *regexp* *Pattern*
291 For starters, read chapter 27 of the user manual |usr_27.txt|.
293 */bar* */\bar* */pattern*
294 1. A pattern is one or more branches, separated by "\|". It matches anything
295 that matches one of the branches. Example: "foo\|beep" matches "foo" and
296 matches "beep". If more than one branch matches, the first one is used.
300 or branch \| branch \| branch
304 2. A branch is one or more concats, separated by "\&". It matches the last
305 concat, but only if all the preceding concats also match at the same
307 "foobeep\&..." matches "foo" in "foobeep".
308 ".*Peter\&.*Bob" matches in a line containing both "Peter" and "Bob"
312 or concat \& concat \& concat
316 3. A concat is one or more pieces, concatenated. It matches a match for the
317 first piece, followed by a match for the second piece, etc. Example:
318 "f[0-9]b", first matches "f", then a digit and then "b".
326 4. A piece is an atom, possibly followed by a multi, an indication of how many
327 times the atom can be matched. Example: "a*" matches any sequence of "a"
328 characters: "", "a", "aa", etc. See |/multi|.
334 5. An atom can be one of a long list of items. Many atoms match one character
335 in the text. It is often an ordinary character or a character class.
336 Braces can be used to make a pattern into an atom. The "\z(\)" construct
337 is only for syntax highlighting.
339 atom ::= ordinary-atom |/ordinary-atom|
340 or \( pattern \) |/\(|
341 or \%( pattern \) |/\%(|
342 or \z( pattern \) |/\z(|
345 ==============================================================================
348 Some characters in the pattern are taken literally. They match with the same
349 character in the text. When preceded with a backslash however, these
350 characters get a special meaning.
352 Other characters have a special meaning without a backslash. They need to be
353 preceded with a backslash to match literally.
355 If a character is taken literally or not depends on the 'magic' option and the
356 items mentioned next.
358 Use of "\m" makes the pattern after it be interpreted as if 'magic' is set,
359 ignoring the actual value of the 'magic' option.
360 Use of "\M" makes the pattern after it be interpreted as if 'nomagic' is used.
362 Use of "\v" means that in the pattern after it all ASCII characters except
363 '0'-'9', 'a'-'z', 'A'-'Z' and '_' have a special meaning. "very magic"
365 Use of "\V" means that in the pattern after it only the backslash has a
366 special meaning. "very nomagic"
369 after: \v \m \M \V matches ~
371 $ $ $ \$ matches end-of-line
372 . . \. \. matches any character
373 * * \* \* any number of the previous atom
374 () \(\) \(\) \(\) grouping into an atom
375 | \| \| \| separating alternatives
376 \a \a \a \a alphabetic character
377 \\ \\ \\ \\ literal backslash
378 \. \. . . literal dot
382 {only Vim supports \m, \M, \v and \V}
384 It is recommended to always keep the 'magic' option at the default setting,
385 which is 'magic'. This avoids portability problems. To make a pattern immune
386 to the 'magic' option being set or not, put "\m" or "\M" at the start of the
389 ==============================================================================
390 4. Overview of pattern items *pattern-overview*
392 Overview of multi items. */multi* *E61* *E62*
393 More explanation and examples below, follow the links. *E64*
396 'magic' 'nomagic' matches of the preceding atom ~
397 |/star| * \* 0 or more as many as possible
398 |/\+| \+ \+ 1 or more as many as possible (*)
399 |/\=| \= \= 0 or 1 as many as possible (*)
400 |/\?| \? \? 0 or 1 as many as possible (*)
402 |/\{| \{n,m} \{n,m} n to m as many as possible (*)
403 \{n} \{n} n exactly (*)
404 \{n,} \{n,} at least n as many as possible (*)
405 \{,m} \{,m} 0 to m as many as possible (*)
406 \{} \{} 0 or more as many as possible (same as *) (*)
408 |/\{-| \{-n,m} \{-n,m} n to m as few as possible (*)
409 \{-n} \{-n} n exactly (*)
410 \{-n,} \{-n,} at least n as few as possible (*)
411 \{-,m} \{-,m} 0 to m as few as possible (*)
412 \{-} \{-} 0 or more as few as possible (*)
415 |/\@>| \@> \@> 1, like matching a whole pattern (*)
416 |/\@=| \@= \@= nothing, requires a match |/zero-width| (*)
417 |/\@!| \@! \@! nothing, requires NO match |/zero-width| (*)
418 |/\@<=| \@<= \@<= nothing, requires a match behind |/zero-width| (*)
419 |/\@<!| \@<! \@<! nothing, requires NO match behind |/zero-width| (*)
424 Overview of ordinary atoms. */ordinary-atom*
425 More explanation and examples below, follow the links.
428 magic nomagic matches ~
429 |/^| ^ ^ start-of-line (at start of pattern) |/zero-width|
430 |/\^| \^ \^ literal '^'
431 |/\_^| \_^ \_^ start-of-line (used anywhere) |/zero-width|
432 |/$| $ $ end-of-line (at end of pattern) |/zero-width|
433 |/\$| \$ \$ literal '$'
434 |/\_$| \_$ \_$ end-of-line (used anywhere) |/zero-width|
435 |/.| . \. any single character (not an end-of-line)
436 |/\_.| \_. \_. any single character or end-of-line
437 |/\<| \< \< beginning of a word |/zero-width|
438 |/\>| \> \> end of a word |/zero-width|
439 |/\zs| \zs \zs anything, sets start of match
440 |/\ze| \ze \ze anything, sets end of match
441 |/\%^| \%^ \%^ beginning of file |/zero-width| *E71*
442 |/\%$| \%$ \%$ end of file |/zero-width|
443 |/\%V| \%V \%V inside Visual area |/zero-width|
444 |/\%#| \%# \%# cursor position |/zero-width|
445 |/\%'m| \%'m \%'m mark m position |/zero-width|
446 |/\%l| \%23l \%23l in line 23 |/zero-width|
447 |/\%c| \%23c \%23c in column 23 |/zero-width|
448 |/\%v| \%23v \%23v in virtual column 23 |/zero-width|
450 Character classes {not in Vi}: */character-classes*
451 |/\i| \i \i identifier character (see 'isident' option)
452 |/\I| \I \I like "\i", but excluding digits
453 |/\k| \k \k keyword character (see 'iskeyword' option)
454 |/\K| \K \K like "\k", but excluding digits
455 |/\f| \f \f file name character (see 'isfname' option)
456 |/\F| \F \F like "\f", but excluding digits
457 |/\p| \p \p printable character (see 'isprint' option)
458 |/\P| \P \P like "\p", but excluding digits
459 |/\s| \s \s whitespace character: <Space> and <Tab>
460 |/\S| \S \S non-whitespace character; opposite of \s
461 |/\d| \d \d digit: [0-9]
462 |/\D| \D \D non-digit: [^0-9]
463 |/\x| \x \x hex digit: [0-9A-Fa-f]
464 |/\X| \X \X non-hex digit: [^0-9A-Fa-f]
465 |/\o| \o \o octal digit: [0-7]
466 |/\O| \O \O non-octal digit: [^0-7]
467 |/\w| \w \w word character: [0-9A-Za-z_]
468 |/\W| \W \W non-word character: [^0-9A-Za-z_]
469 |/\h| \h \h head of word character: [A-Za-z_]
470 |/\H| \H \H non-head of word character: [^A-Za-z_]
471 |/\a| \a \a alphabetic character: [A-Za-z]
472 |/\A| \A \A non-alphabetic character: [^A-Za-z]
473 |/\l| \l \l lowercase character: [a-z]
474 |/\L| \L \L non-lowercase character: [^a-z]
475 |/\u| \u \u uppercase character: [A-Z]
476 |/\U| \U \U non-uppercase character [^A-Z]
477 |/\_| \_x \_x where x is any of the characters above: character
478 class with end-of-line included
479 (end of character classes)
485 |/\n| \n \n end-of-line
486 |/~| ~ \~ last given substitute string
487 |/\1| \1 \1 same string as matched by first \(\) {not in Vi}
488 |/\2| \2 \2 Like "\1", but uses second \(\)
490 |/\9| \9 \9 Like "\1", but uses ninth \(\)
492 |/\z1| \z1 \z1 only for syntax highlighting, see |:syn-ext-match|
494 |/\z1| \z9 \z9 only for syntax highlighting, see |:syn-ext-match|
496 x x a character with no special meaning matches itself
498 |/[]| [] \[] any character specified inside the []
499 |/\%[]| \%[] \%[] a sequence of optionally matched atoms
501 |/\c| \c \c ignore case, do not use the 'ignorecase' option
502 |/\C| \C \C match case, do not use the 'ignorecase' option
503 |/\m| \m \m 'magic' on for the following chars in the pattern
504 |/\M| \M \M 'magic' off for the following chars in the pattern
505 |/\v| \v \v the following chars in the pattern are "very magic"
506 |/\V| \V \V the following chars in the pattern are "very nomagic"
507 |/\Z| \Z \Z ignore differences in Unicode "combining characters".
508 Useful when searching voweled Hebrew or Arabic text.
510 |/\%d| \%d \%d match specified decimal character (eg \%d123
511 |/\%x| \%x \%x match specified hex character (eg \%x2a)
512 |/\%o| \%o \%o match specified octal character (eg \%o040)
513 |/\%u| \%u \%u match specified multibyte character (eg \%u20ac)
514 |/\%U| \%U \%U match specified large multibyte character (eg
520 \<[a-zA-Z_][a-zA-Z0-9_]*
521 An identifier (e.g., in a C program).
523 \(\.$\|\. \) A period followed by <EOL> or a space.
525 [.!?][])"']*\($\|[ ]\) A search pattern that finds the end of a sentence,
526 with almost the same definition as the ")" command.
528 cat\Z Both "cat" and "càt" ("a" followed by 0x0300)
529 Does not match "cà t" (character 0x00e0), even
530 though it may look the same.
533 ==============================================================================
534 5. Multi items *pattern-multi-items*
536 An atom can be followed by an indication of how many times the atom can be
537 matched and in what way. This is called a multi. See |/multi| for an
540 */star* */\star* *E56*
541 * (use \* when 'magic' is not set)
542 Matches 0 or more of the preceding atom, as many as possible.
543 Example 'nomagic' matches ~
544 a* a\* "", "a", "aa", "aaa", etc.
545 .* \.\* anything, also an empty string, no end-of-line
546 \_.* \_.\* everything up to the end of the buffer
547 \_.*END \_.\*END everything up to and including the last "END"
550 Exception: When "*" is used at the start of the pattern or just after
551 "^" it matches the star character.
553 Be aware that repeating "\_." can match a lot of text and take a long
554 time. For example, "\_.*END" matches all text from the current
555 position to the last occurrence of "END" in the file. Since the "*"
556 will match as many as possible, this first skips over all lines until
557 the end of the file and then tries matching "END", backing up one
561 \+ Matches 1 or more of the preceding atom, as many as possible. {not in
564 ^.\+$ any non-empty line
565 \s\+ white space of at least one character
568 \= Matches 0 or 1 of the preceding atom, as many as possible. {not in Vi}
573 \? Just like \=. Cannot be used when searching backwards with the "?"
576 */\{* *E58* *E60* *E554*
577 \{n,m} Matches n to m of the preceding atom, as many as possible
578 \{n} Matches n of the preceding atom
579 \{n,} Matches at least n of the preceding atom, as many as possible
580 \{,m} Matches 0 to m of the preceding atom, as many as possible
581 \{} Matches 0 or more of the preceding atom, as many as possible (like *)
583 \{-n,m} matches n to m of the preceding atom, as few as possible
584 \{-n} matches n of the preceding atom
585 \{-n,} matches at least n of the preceding atom, as few as possible
586 \{-,m} matches 0 to m of the preceding atom, as few as possible
587 \{-} matches 0 or more of the preceding atom, as few as possible
588 {Vi does not have any of these}
590 n and m are positive decimal numbers or zero
592 If a "-" appears immediately after the "{", then a shortest match
593 first algorithm is used (see example below). In particular, "\{-}" is
594 the same as "*" but uses the shortest match first algorithm. BUT: A
595 match that starts earlier is preferred over a shorter match: "a\{-}b"
596 matches "aaab" in "xaaab".
599 ab\{2,3}c "abbc" or "abbbc"
601 ab\{2,}c "abbc", "abbbc", "abbbbc", etc.
602 ab\{,3}c "ac", "abc", "abbc" or "abbbc"
603 a[bc]\{3}d "abbbd", "abbcd", "acbcd", "acccd", etc.
604 a\(bc\)\{1,2}d "abcd" or "abcbcd"
605 a[bc]\{-}[cd] "abc" in "abcd"
606 a[bc]*[cd] "abcd" in "abcd"
608 The } may optionally be preceded with a backslash: \{n,m\}.
611 \@= Matches the preceding atom with zero width. {not in Vi}
612 Like "(?=pattern)" in Perl.
614 foo\(bar\)\@= "foo" in "foobar"
615 foo\(bar\)\@=foo nothing
617 When using "\@=" (or "^", "$", "\<", "\>") no characters are included
618 in the match. These items are only used to check if a match can be
619 made. This can be tricky, because a match with following items will
620 be done in the same position. The last example above will not match
621 "foobarfoo", because it tries match "foo" in the same position where
624 Note that using "\&" works the same as using "\@=": "foo\&.." is the
625 same as "\(foo\)\@=..". But using "\&" is easier, you don't need the
630 \@! Matches with zero width if the preceding atom does NOT match at the
631 current position. |/zero-width| {not in Vi}
632 Like '(?!pattern)" in Perl.
634 foo\(bar\)\@! any "foo" not followed by "bar"
635 a.\{-}p\@! "a", "ap", "app", etc. not followed by a "p"
636 if \(\(then\)\@!.\)*$ "if " not followed by "then"
638 Using "\@!" is tricky, because there are many places where a pattern
639 does not match. "a.*p\@!" will match from an "a" to the end of the
640 line, because ".*" can match all characters in the line and the "p"
641 doesn't match at the end of the line. "a.\{-}p\@!" will match any
642 "a", "ap", "aap", etc. that isn't followed by a "p", because the "."
643 can match a "p" and "p\@!" doesn't match after that.
645 You can't use "\@!" to look for a non-match before the matching
646 position: "\(foo\)\@!bar" will match "bar" in "foobar", because at the
647 position where "bar" matches, "foo" does not match. To avoid matching
648 "foobar" you could use "\(foo\)\@!...bar", but that doesn't match a
649 bar at the start of a line. Use "\(foo\)\@<!bar".
652 \@<= Matches with zero width if the preceding atom matches just before what
653 follows. |/zero-width| {not in Vi}
654 Like '(?<=pattern)" in Perl, but Vim allows non-fixed-width patterns.
656 \(an\_s\+\)\@<=file "file" after "an" and white space or an
658 For speed it's often much better to avoid this multi. Try using "\zs"
659 instead |/\zs|. To match the same as the above example:
662 "\@<=" and "\@<!" check for matches just before what follows.
663 Theoretically these matches could start anywhere before this position.
664 But to limit the time needed, only the line where what follows matches
665 is searched, and one line before that (if there is one). This should
666 be sufficient to match most things and not be too slow.
667 The part of the pattern after "\@<=" and "\@<!" are checked for a
668 match first, thus things like "\1" don't work to reference \(\) inside
669 the preceding atom. It does work the other way around:
671 \1\@<=,\([a-z]\+\) ",abc" in "abc,abc"
674 \@<! Matches with zero width if the preceding atom does NOT match just
675 before what follows. Thus this matches if there is no position in the
676 current or previous line where the atom matches such that it ends just
677 before what follows. |/zero-width| {not in Vi}
678 Like '(?<!pattern)" in Perl, but Vim allows non-fixed-width patterns.
679 The match with the preceding atom is made to end just before the match
680 with what follows, thus an atom that ends in ".*" will work.
681 Warning: This can be slow (because many positions need to be checked
684 \(foo\)\@<!bar any "bar" that's not in "foobar"
685 \(\/\/.*\)\@<!in "in" which is not after "//"
688 \@> Matches the preceding atom like matching a whole pattern. {not in Vi}
689 Like "(?>pattern)" in Perl.
691 \(a*\)\@>a nothing (the "a*" takes all the "a"'s, there can't be
692 another one following)
694 This matches the preceding atom as if it was a pattern by itself. If
695 it doesn't match, there is no retry with shorter sub-matches or
696 anything. Observe this difference: "a*b" and "a*ab" both match
697 "aaab", but in the second case the "a*" matches only the first two
698 "a"s. "\(a*\)\@>ab" will not match "aaab", because the "a*" matches
699 the "aaa" (as many "a"s as possible), thus the "ab" can't match.
702 ==============================================================================
703 6. Ordinary atoms *pattern-atoms*
705 An ordinary atom can be:
708 ^ At beginning of pattern or after "\|", "\(", "\%(" or "\n": matches
709 start-of-line; at other positions, matches literal '^'. |/zero-width|
711 ^beep( the start of the C function "beep" (probably).
714 \^ Matches literal '^'. Can be used at any position in the pattern.
717 \_^ Matches start-of-line. |/zero-width| Can be used at any position in
720 \_s*\_^foo white space and blank lines and then "foo" at
724 $ At end of pattern or in front of "\|", "\)" or "\n" ('magic' on):
725 matches end-of-line <EOL>; at other positions, matches literal '$'.
729 \$ Matches literal '$'. Can be used at any position in the pattern.
732 \_$ Matches end-of-line. |/zero-width| Can be used at any position in the
733 pattern. Note that "a\_$b" never matches, since "b" cannot match an
734 end-of-line. Use "a\nb" instead |/\n|.
736 foo\_$\_s* "foo" at end-of-line and following white space and
739 . (with 'nomagic': \.) */.* */\.*
740 Matches any single character, but not an end-of-line.
743 \_. Matches any single character or end-of-line.
744 Careful: "\_.*" matches all text to the end of the buffer!
747 \< Matches the beginning of a word: The next char is the first char of a
748 word. The 'iskeyword' option specifies what is a word character.
752 \> Matches the end of a word: The previous char is the last char of a
753 word. The 'iskeyword' option specifies what is a word character.
757 \zs Matches at any position, and sets the start of the match there: The
758 next char is the first char of the whole match. |/zero-width|
761 < matches an "if" at the start of a line, ignoring white space.
762 Can be used multiple times, the last one encountered in a matching
763 branch is used. Example: >
765 < Finds the third occurrence of "Fab".
766 {not in Vi} {not available when compiled without the +syntax feature}
768 \ze Matches at any position, and sets the end of the match there: The
769 previous char is the last char of the whole match. |/zero-width|
770 Can be used multiple times, the last one encountered in a matching
772 Example: "end\ze\(if\|for\)" matches the "end" in "endif" and
774 {not in Vi} {not available when compiled without the +syntax feature}
776 */\%^* *start-of-file*
777 \%^ Matches start of the file. When matching with a string, matches the
778 start of the string. {not in Vi}
779 For example, to find the first "VIM" in a file: >
783 \%$ Matches end of the file. When matching with a string, matches the
784 end of the string. {not in Vi}
785 Note that this does NOT find the last "VIM" in a file: >
787 < It will find the next VIM, because the part after it will always
788 match. This one will find the last "VIM" in the file: >
789 /VIM\ze\(\(VIM\)\@!\_.\)*\%$
790 < This uses |/\@!| to ascertain that "VIM" does NOT match in any
791 position after the first "VIM".
792 Searching from the end of the file backwards is easier!
795 \%V Match inside the Visual area. When Visual mode has already been
796 stopped match in the area that |gv| would reselect.
797 Only works for the current buffer.
799 */\%#* *cursor-position*
800 \%# Matches with the cursor position. Only works when matching in a
801 buffer displayed in a window. {not in Vi}
802 WARNING: When the cursor is moved after the pattern was used, the
803 result becomes invalid. Vim doesn't automatically update the matches.
804 This is especially relevant for syntax highlighting and 'hlsearch'.
805 In other words: When the cursor moves the display isn't updated for
806 this change. An update is done for lines which are changed (the whole
807 line is updated) or when using the |CTRL-L| command (the whole screen
808 is updated). Example, to highlight the word under the cursor: >
810 < When 'hlsearch' is set and you move the cursor around and make changes
811 this will clearly show when the match is updated or not.
813 */\%'m* */\%<'m* */\%>'m*
814 \%'m Matches with the position of mark m.
815 \%<'m Matches before the position of mark m.
816 \%>'m Matches after the position of mark m.
817 Example, to highlight the text from mark 's to 'e: >
819 < Note that two dots are required to include mark 'e in the match. That
820 is because "\%<'e" matches at the character before the 'e mark, and
821 since it's a |/zero-width| match it doesn't include that character.
823 WARNING: When the mark is moved after the pattern was used, the result
824 becomes invalid. Vim doesn't automatically update the matches.
825 Similar to moving the cursor for "\%#" |/\%#|.
827 */\%l* */\%>l* */\%<l*
828 \%23l Matches in a specific line.
829 \%<23l Matches above a specific line (lower line number).
830 \%>23l Matches below a specific line (higher line number).
831 These three can be used to match specific lines in a buffer. The "23"
832 can be any line number. The first line is 1. {not in Vi}
833 WARNING: When inserting or deleting lines Vim does not automatically
834 update the matches. This means Syntax highlighting quickly becomes
836 Example, to highlight the line where the cursor currently is: >
837 :exe '/\%' . line(".") . 'l.*'
838 < When 'hlsearch' is set and you move the cursor around and make changes
839 this will clearly show when the match is updated or not.
841 */\%c* */\%>c* */\%<c*
842 \%23c Matches in a specific column.
843 \%<23c Matches before a specific column.
844 \%>23c Matches after a specific column.
845 These three can be used to match specific columns in a buffer or
846 string. The "23" can be any column number. The first column is 1.
847 Actually, the column is the byte number (thus it's not exactly right
848 for multi-byte characters). {not in Vi}
849 WARNING: When inserting or deleting text Vim does not automatically
850 update the matches. This means Syntax highlighting quickly becomes
852 Example, to highlight the column where the cursor currently is: >
853 :exe '/\%' . col(".") . 'c'
854 < When 'hlsearch' is set and you move the cursor around and make changes
855 this will clearly show when the match is updated or not.
856 Example for matching a single byte in column 44: >
858 < Note that "\%<46c" matches in column 45 when the "." matches a byte in
860 */\%v* */\%>v* */\%<v*
861 \%23v Matches in a specific virtual column.
862 \%<23v Matches before a specific virtual column.
863 \%>23v Matches after a specific virtual column.
864 These three can be used to match specific virtual columns in a buffer
865 or string. When not matching with a buffer in a window, the option
866 values of the current window are used (e.g., 'tabstop').
867 The "23" can be any column number. The first column is 1.
868 Note that some virtual column positions will never match, because they
869 are halfway through a tab or other character that occupies more than
870 one screen character. {not in Vi}
871 WARNING: When inserting or deleting text Vim does not automatically
872 update highlighted matches. This means Syntax highlighting quickly
874 Example, to highlight all the characters after virtual column 72: >
876 < When 'hlsearch' is set and you move the cursor around and make changes
877 this will clearly show when the match is updated or not.
878 To match the text up to column 17: >
880 < Column 17 is not included, because that's where the "\%17v" matches,
881 and since this is a |/zero-width| match, column 17 isn't included in
882 the match. This does the same: >
886 Character classes: {not in Vi}
887 \i identifier character (see 'isident' option) */\i*
888 \I like "\i", but excluding digits */\I*
889 \k keyword character (see 'iskeyword' option) */\k*
890 \K like "\k", but excluding digits */\K*
891 \f file name character (see 'isfname' option) */\f*
892 \F like "\f", but excluding digits */\F*
893 \p printable character (see 'isprint' option) */\p*
894 \P like "\p", but excluding digits */\P*
896 NOTE: the above also work for multi-byte characters. The ones below only
897 match ASCII characters, as indicated by the range.
899 *whitespace* *white-space*
900 \s whitespace character: <Space> and <Tab> */\s*
901 \S non-whitespace character; opposite of \s */\S*
902 \d digit: [0-9] */\d*
903 \D non-digit: [^0-9] */\D*
904 \x hex digit: [0-9A-Fa-f] */\x*
905 \X non-hex digit: [^0-9A-Fa-f] */\X*
906 \o octal digit: [0-7] */\o*
907 \O non-octal digit: [^0-7] */\O*
908 \w word character: [0-9A-Za-z_] */\w*
909 \W non-word character: [^0-9A-Za-z_] */\W*
910 \h head of word character: [A-Za-z_] */\h*
911 \H non-head of word character: [^A-Za-z_] */\H*
912 \a alphabetic character: [A-Za-z] */\a*
913 \A non-alphabetic character: [^A-Za-z] */\A*
914 \l lowercase character: [a-z] */\l*
915 \L non-lowercase character: [^a-z] */\L*
916 \u uppercase character: [A-Z] */\u*
917 \U non-uppercase character [^A-Z] */\U*
919 NOTE: Using the atom is faster than the [] form.
921 NOTE: 'ignorecase', "\c" and "\C" are not used by character classes.
923 */\_* *E63* */\_i* */\_I* */\_k* */\_K* */\_f* */\_F*
924 */\_p* */\_P* */\_s* */\_S* */\_d* */\_D* */\_x* */\_X*
925 */\_o* */\_O* */\_w* */\_W* */\_h* */\_H* */\_a* */\_A*
926 */\_l* */\_L* */\_u* */\_U*
927 \_x Where "x" is any of the characters above: The character class with
929 (end of character classes)
931 \e matches <Esc> */\e*
932 \t matches <Tab> */\t*
933 \r matches <CR> */\r*
934 \b matches <BS> */\b*
935 \n matches an end-of-line */\n*
936 When matching in a string instead of buffer text a literal newline
937 character is matched.
939 ~ matches the last given substitute string */~* */\~*
941 \(\) A pattern enclosed by escaped parentheses. */\(* */\(\)* */\)*
942 E.g., "\(^a\)" matches 'a' at the start of a line. *E51* *E54* *E55*
944 \1 Matches the same string that was matched by */\1* *E65*
945 the first sub-expression in \( and \). {not in Vi}
946 Example: "\([a-z]\).\1" matches "ata", "ehe", "tot", etc.
947 \2 Like "\1", but uses second sub-expression, */\2*
949 \9 Like "\1", but uses ninth sub-expression. */\9*
950 Note: The numbering of groups is done based on which "\(" comes first
951 in the pattern (going left to right), NOT based on what is matched
954 \%(\) A pattern enclosed by escaped parentheses. */\%(\)* */\%(* *E53*
955 Just like \(\), but without counting it as a sub-expression. This
956 allows using more groups and it's a little bit faster.
959 x A single character, with no special meaning, matches itself
962 \x A backslash followed by a single character, with no special meaning,
963 is reserved for future expansions
965 [] (with 'nomagic': \[]) */[]* */\[]* */\_[]* */collection*
967 A collection. This is a sequence of characters enclosed in brackets.
968 It matches any single character in the collection.
970 [xyz] any 'x', 'y' or 'z'
971 [a-zA-Z]$ any alphabetic character at the end of a line
974 With "\_" prepended the collection also includes the end-of-line.
975 The same can be done by including "\n" in the collection. The
976 end-of-line is also matched when the collection starts with "^"! Thus
977 "\_[^ab]" matches the end-of-line and any character but "a" and "b".
978 This makes it Vi compatible: Without the "\_" or "\n" the collection
979 does not match an end-of-line.
981 When the ']' is not there Vim will not give an error message but
982 assume no collection is used. Useful to search for '['. However, you
983 do get E769 for internal searching.
985 If the sequence begins with "^", it matches any single character NOT
986 in the collection: "[^xyz]" matches anything but 'x', 'y' and 'z'.
987 - If two characters in the sequence are separated by '-', this is
988 shorthand for the full list of ASCII characters between them. E.g.,
989 "[0-9]" matches any decimal digit.
990 - A character class expression is evaluated to the set of characters
991 belonging to that character class. The following character classes
994 *[:alnum:]* [:alnum:] letters and digits
995 *[:alpha:]* [:alpha:] letters
996 *[:blank:]* [:blank:] space and tab characters
997 *[:cntrl:]* [:cntrl:] control characters
998 *[:digit:]* [:digit:] decimal digits
999 *[:graph:]* [:graph:] printable characters excluding space
1000 *[:lower:]* [:lower:] lowercase letters (all letters when
1001 'ignorecase' is used)
1002 *[:print:]* [:print:] printable characters including space
1003 *[:punct:]* [:punct:] punctuation characters
1004 *[:space:]* [:space:] whitespace characters
1005 *[:upper:]* [:upper:] uppercase letters (all letters when
1006 'ignorecase' is used)
1007 *[:xdigit:]* [:xdigit:] hexadecimal digits
1008 *[:return:]* [:return:] the <CR> character
1009 *[:tab:]* [:tab:] the <Tab> character
1010 *[:escape:]* [:escape:] the <Esc> character
1011 *[:backspace:]* [:backspace:] the <BS> character
1012 The brackets in character class expressions are additional to the
1013 brackets delimiting a collection. For example, the following is a
1014 plausible pattern for a UNIX filename: "[-./[:alnum:]_~]\+" That is,
1015 a list of at least one character, each of which is either '-', '.',
1016 '/', alphabetic, numeric, '_' or '~'.
1017 These items only work for 8-bit characters.
1019 - An equivalence class. This means that characters are matched that
1020 have almost the same meaning, e.g., when ignoring accents. The form
1023 Currently this is only implemented for latin1. Also works for the
1024 latin1 characters in utf-8 and latin9.
1026 - A collation element. This currently simply accepts a single
1027 character in the form:
1030 - To include a literal ']', '^', '-' or '\' in the collection, put a
1031 backslash before it: "[xyz\]]", "[\^xyz]", "[xy\-z]" and "[xyz\\]".
1032 (Note: POSIX does not support the use of a backslash this way). For
1033 ']' you can also make it the first character (following a possible
1034 "^"): "[]xyz]" or "[^]xyz]" {not in Vi}.
1035 For '-' you can also make it the first or last character: "[-xyz]",
1036 "[^-xyz]" or "[xyz-]". For '\' you can also let it be followed by
1037 any character that's not in "^]-\bertn". "[\xyz]" matches '\', 'x',
1038 'y' and 'z'. It's better to use "\\" though, future expansions may
1039 use other characters after '\'.
1040 - The following translations are accepted when the 'l' flag is not
1041 included in 'cpoptions' {not in Vi}:
1044 \r <CR> (NOT end-of-line!)
1046 \n line break, see above |/[\n]|
1047 \d123 decimal number of character
1048 \o40 octal number of character up to 0377
1049 \x20 hexadecimal number of character up to 0xff
1050 \u20AC hex. number of multibyte character up to 0xffff
1051 \U1234 hex. number of multibyte character up to 0xffffffff
1052 NOTE: The other backslash codes mentioned above do not work inside
1054 - Matching with a collection can be slow, because each character in
1055 the text has to be compared with each character in the collection.
1056 Use one of the other atoms above when possible. Example: "\d" is
1057 much faster than "[0-9]" and matches the same characters.
1059 */\%[]* *E69* *E70* *E369*
1060 \%[] A sequence of optionally matched atoms. This always matches.
1061 It matches as much of the list of atoms it contains as possible. Thus
1062 it stops at the first atom that doesn't match. For example: >
1064 < matches "r", "re", "rea" or "read". The longest that matches is used.
1065 To match the Ex command "function", where "fu" is required and
1066 "nction" is optional, this would work: >
1068 < The end-of-word atom "\>" is used to avoid matching "fu" in "full".
1069 It gets more complicated when the atoms are not ordinary characters.
1070 You don't often have to use it, but it is possible. Example: >
1072 < Matches the words "r", "re", "ro", "rea", "roa", "read" and "road".
1073 There can be no \(\), \%(\) or \z(\) items inside the [] and \%[] does
1075 To include a "[" use "[[]" and for "]" use []]", e.g.,: >
1077 < matches "index" "index[", "index[0" and "index[0]".
1078 {not available when compiled without the +syntax feature}
1080 */\%d* */\%x* */\%o* */\%u* */\%U* *E678*
1082 \%d123 Matches the character specified with a decimal number. Must be
1083 followed by a non-digit.
1084 \%o40 Matches the character specified with an octal number up to 0377.
1085 Numbers below 040 must be followed by a non-octal digit or a non-digit.
1086 \%x2a Matches the character specified with up to two hexadecimal characters.
1087 \%u20AC Matches the character specified with up to four hexadecimal
1089 \%U1234abcd Matches the character specified with up to eight hexadecimal
1092 ==============================================================================
1093 7. Ignoring case in a pattern */ignorecase*
1095 If the 'ignorecase' option is on, the case of normal letters is ignored.
1096 'smartcase' can be set to ignore case when the pattern contains lowercase
1099 When "\c" appears anywhere in the pattern, the whole pattern is handled like
1100 'ignorecase' is on. The actual value of 'ignorecase' and 'smartcase' is
1101 ignored. "\C" does the opposite: Force matching case for the whole pattern.
1102 {only Vim supports \c and \C}
1103 Note that 'ignorecase', "\c" and "\C" are not used for the character classes.
1106 pattern 'ignorecase' 'smartcase' matches ~
1108 foo on - foo Foo FOO
1109 Foo on off foo Foo FOO
1111 \cfoo - - foo Foo FOO
1114 Technical detail: *NL-used-for-Nul*
1115 <Nul> characters in the file are stored as <NL> in memory. In the display
1116 they are shown as "^@". The translation is done when reading and writing
1117 files. To match a <Nul> with a search pattern you can just enter CTRL-@ or
1118 "CTRL-V 000". This is probably just what you expect. Internally the
1119 character is replaced with a <NL> in the search pattern. What is unusual is
1120 that typing CTRL-V CTRL-J also inserts a <NL>, thus also searches for a <Nul>
1121 in the file. {Vi cannot handle <Nul> characters in the file at all}
1124 When 'fileformat' is "mac", <NL> characters in the file are stored as <CR>
1125 characters internally. In the text they are shown as "^J". Otherwise this
1126 works similar to the usage of <NL> for a <Nul>.
1128 When working with expression evaluation, a <NL> character in the pattern
1129 matches a <NL> in the string. The use of "\n" (backslash n) to match a <NL>
1130 doesn't work there, it only works to match text in the buffer.
1132 *pattern-multi-byte*
1133 Patterns will also work with multi-byte characters, mostly as you would
1134 expect. But invalid bytes may cause trouble, a pattern with an invalid byte
1135 will probably never match.
1137 ==============================================================================
1138 8. Composing characters *patterns-composing*
1141 When "\Z" appears anywhere in the pattern, composing characters are ignored.
1142 Thus only the base characters need to match, the composing characters may be
1143 different and the number of composing characters may differ. Only relevant
1144 when 'encoding' is "utf-8".
1146 When a composing character appears at the start of the pattern of after an
1147 item that doesn't include the composing character, a match is found at any
1148 character that includes this composing character.
1150 When using a dot and a composing character, this works the same as the
1151 composing character by itself, except that it doesn't matter what comes before
1154 The order of composing characters matters, even though changing the order
1155 doesn't change what a character looks like. This may change in the future.
1157 ==============================================================================
1158 9. Compare with Perl patterns *perl-patterns*
1160 Vim's regexes are most similar to Perl's, in terms of what you can do. The
1161 difference between them is mostly just notation; here's a summary of where
1164 Capability in Vimspeak in Perlspeak ~
1165 ----------------------------------------------------------------
1166 force case insensitivity \c (?i)
1167 force case sensitivity \C (?-i)
1168 backref-less grouping \%(atom\) (?:atom)
1169 conservative quantifiers \{-n,m} *?, +?, ??, {}?
1170 0-width match atom\@= (?=atom)
1171 0-width non-match atom\@! (?!atom)
1172 0-width preceding match atom\@<= (?<=atom)
1173 0-width preceding non-match atom\@<! (?<!atom)
1174 match without retry atom\@> (?>atom)
1176 Vim and Perl handle newline characters inside a string a bit differently:
1178 In Perl, ^ and $ only match at the very beginning and end of the text,
1179 by default, but you can set the 'm' flag, which lets them match at
1180 embedded newlines as well. You can also set the 's' flag, which causes
1181 a . to match newlines as well. (Both these flags can be changed inside
1182 a pattern using the same syntax used for the i flag above, BTW.)
1184 On the other hand, Vim's ^ and $ always match at embedded newlines, and
1185 you get two separate atoms, \%^ and \%$, which only match at the very
1186 start and end of the text, respectively. Vim solves the second problem
1187 by giving you the \_ "modifier": put it in front of a . or a character
1188 class, and they will match newlines as well.
1190 Finally, these constructs are unique to Perl:
1191 - execution of arbitrary code in the regex: (?{perl code})
1192 - conditional expressions: (?(condition)true-expr|false-expr)
1194 ...and these are unique to Vim:
1195 - changing the magic-ness of a pattern: \v \V \m \M
1196 (very useful for avoiding backslashitis)
1197 - sequence of optionally matching atoms: \%[atoms]
1198 - \& (which is to \| what "and" is to "or"; it forces several branches
1199 to match at one spot)
1200 - matching lines/columns by number: \%5l \%5c \%5v
1201 - setting the start and end of the match: \zs \ze
1203 ==============================================================================
1204 10. Highlighting matches *match-highlight*
1207 :mat[ch] {group} /{pattern}/
1208 Define a pattern to highlight in the current window. It will
1209 be highlighted with {group}. Example: >
1210 :highlight MyGroup ctermbg=green guibg=green
1211 :match MyGroup /TODO/
1212 < Instead of // any character can be used to mark the start and
1213 end of the {pattern}. Watch out for using special characters,
1214 such as '"' and '|'.
1216 {group} must exist at the moment this command is executed.
1218 The {group} highlighting still applies when a character is
1219 to be highlighted for 'hlsearch', as the highlighting for
1220 matches is given higher priority than that of 'hlsearch'.
1221 Syntax highlighting (see 'syntax') is also overruled by
1224 Note that highlighting the last used search pattern with
1225 'hlsearch' is used in all windows, while the pattern defined
1226 with ":match" only exists in the current window. It is kept
1227 when switching to another buffer.
1229 'ignorecase' does not apply, use |/\c| in the pattern to
1230 ignore case. Otherwise case is not ignored.
1232 'redrawtime' defines the maximum time searched for pattern
1235 When matching end-of-line and Vim redraws only part of the
1236 display you may get unexpected results. That is because Vim
1237 looks for a match in the line where redrawing starts.
1239 Also see |matcharg()| and |getmatches()|. The former returns
1240 the highlight group and pattern of a previous |:match|
1241 command. The latter returns a list with highlight groups and
1242 patterns defined by both |matchadd()| and |:match|.
1244 Highlighting matches using |:match| are limited to three
1245 matches (aside from |:match|, |:2match| and |:3match|are
1246 available). |matchadd()| does not have this limitation and in
1247 addition makes it possible to prioritize matches.
1249 Another example, which highlights all characters in virtual
1250 column 72 and more: >
1251 :highlight rightMargin term=bold ctermfg=blue guifg=blue
1252 :match rightMargin /.\%>72v/
1253 < To highlight all character that are in virtual column 7: >
1254 :highlight col8 ctermbg=grey guibg=grey
1255 :match col8 /\%<8v.\%>7v/
1256 < Note the use of two items to also match a character that
1257 occupies more than one virtual column, such as a TAB.
1261 Clear a previously defined match pattern.
1264 :2mat[ch] {group} /{pattern}/ *:2match*
1267 :3mat[ch] {group} /{pattern}/ *:3match*
1270 Just like |:match| above, but set a separate match. Thus
1271 there can be three matches active at the same time. The match
1272 with the lowest number has priority if several match at the
1274 The ":3match" command is used by the |matchparen| plugin. You
1275 are suggested to use ":match" for manual matching and
1276 ":2match" for another plugin.
1279 vim:tw=78:ts=8:ft=help:norl: