vim

Fork of vim, an acceptable text editor
git clone git://git.laack.co/vim.git
Log | Files | Refs | README | LICENSE

pattern.txt (65635B)


      1 *pattern.txt*	For Vim version 9.2.  Last change: 2026 Aug 25
      2 
      3 
      4 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
      5 
      6 
      7 Patterns and search commands				*pattern-searches*
      8 
      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|.
     11 
     12 1. Search commands		|search-commands|
     13 2. The definition of a pattern	|search-pattern|
     14 3. Magic			|/magic|
     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|
     22 11. Fuzzy matching		|fuzzy-matching|
     23 
     24 ==============================================================================
     25 1. Search commands				*search-commands*
     26 
     27 							*/*
     28 /{pattern}[/]<CR>	Search forward for the [count]'th occurrence of
     29 			{pattern} |exclusive|.
     30 
     31 /{pattern}/{offset}<CR>	Search forward for the [count]'th occurrence of
     32 			{pattern} and go |{offset}| lines up or down.
     33 			|linewise|.
     34 
     35 							*/<CR>*
     36 /<CR>			Search forward for the [count]'th occurrence of the
     37 			latest used pattern |last-pattern| with latest used
     38 			|{offset}|.
     39 
     40 //{offset}<CR>		Search forward for the [count]'th occurrence of the
     41 			latest used pattern |last-pattern| with new
     42 			|{offset}|.  If {offset} is empty no offset is used.
     43 
     44 							*?*
     45 ?{pattern}[?]<CR>	Search backward for the [count]'th previous
     46 			occurrence of {pattern} |exclusive|.
     47 
     48 ?{pattern}?{offset}<CR>	Search backward for the [count]'th previous
     49 			occurrence of {pattern} and go |{offset}| lines up or
     50 			down |linewise|.
     51 
     52 							*?<CR>*
     53 ?<CR>			Search backward for the [count]'th occurrence of the
     54 			latest used pattern |last-pattern| with latest used
     55 			|{offset}|.
     56 
     57 ??{offset}<CR>		Search backward for the [count]'th occurrence of the
     58 			latest used pattern |last-pattern| with new
     59 			|{offset}|.  If {offset} is empty no offset is used.
     60 
     61 							*n*
     62 n			Repeat the latest "/" or "?" [count] times.
     63 			If the cursor doesn't move the search is repeated with
     64 			count + 1.
     65 			|last-pattern|
     66 
     67 							*N*
     68 N			Repeat the latest "/" or "?" [count] times in
     69 			opposite direction. |last-pattern|
     70 
     71 							*star* *E348* *E349*
     72 *			Search forward for the [count]'th occurrence of the
     73 			word nearest to the cursor.  The word used for the
     74 			search is the first of:
     75 				1. the keyword under the cursor 'iskeyword'
     76 				2. the first keyword after the cursor, in the
     77 				   current line
     78 				3. the non-blank word under the cursor
     79 				4. the first non-blank word after the cursor,
     80 				   in the current line
     81 			Only whole keywords are searched for, like with the
     82 			command "/\<keyword\>".  |exclusive|
     83 			'ignorecase' is used, 'smartcase' is not.
     84 
     85 							*#*
     86 #			Same as "*", but search backward.  The pound sign
     87 			(character 163) also works.  If the "#" key works as
     88 			backspace, try using "stty erase <BS>" before starting
     89 			Vim (<BS> is CTRL-H or a real backspace).
     90 
     91 							*gstar*
     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.
     95 
     96 							*g#*
     97 g#			Like "#", but don't put "\<" and "\>" around the word.
     98 			This makes the search also find matches that are not a
     99 			whole word.
    100 
    101 							*gd*
    102 gd			Goto local Declaration.  When the cursor is on a local
    103 			variable, this command will jump to its declaration.
    104 			This was made to work for C code, in other languages
    105 			it may not work well.
    106 			First Vim searches for the start of the current
    107 			function, just like "[[".  If it is not found the
    108 			search stops in line 1.  If it is found, Vim goes back
    109 			until a blank line is found.  From this position Vim
    110 			searches for the keyword under the cursor, like with
    111 			"*", but lines that look like a comment are ignored
    112 			(see 'comments' option).
    113 			Note that this is not guaranteed to work, Vim does not
    114 			really check the syntax, it only searches for a match
    115 			with the keyword.  If included files also need to be
    116 			searched use the commands listed in |include-search|.
    117 			After this command |n| searches forward for the next
    118 			match (not backward).
    119 
    120 							*gD*
    121 gD			Goto global Declaration.  When the cursor is on a
    122 			global variable that is defined in the file, this
    123 			command will jump to its declaration.  This works just
    124 			like "gd", except that the search for the keyword
    125 			always starts in line 1.
    126 
    127 							*1gd*
    128 1gd			Like "gd", but ignore matches inside a {} block that
    129 			ends before the cursor position.
    130 
    131 							*1gD*
    132 1gD			Like "gD", but ignore matches inside a {} block that
    133 			ends before the cursor position.
    134 
    135 							*CTRL-C*
    136 CTRL-C			Interrupt current (search) command.  Use CTRL-Break on
    137 			MS-Windows |dos-CTRL-Break|.
    138 			In Normal mode, any pending command is aborted.
    139 			When Vim was started with output redirected and there
    140 			are no changed buffers CTRL-C exits Vim.  That is to
    141 			help users who use "vim file | grep word" and don't
    142 			know how to get out (blindly typing :qa<CR> would
    143 			work).
    144 			If a popup with a |popup-filter| is open, the popup
    145 			will be closed.
    146 
    147 							*:noh* *:nohlsearch*
    148 :noh[lsearch]		Stop the highlighting for the 'hlsearch' option.  It
    149 			is automatically turned back on when using a search
    150 			command, or setting the 'hlsearch' option.
    151 			This command doesn't work in an autocommand, because
    152 			the highlighting state is saved and restored when
    153 			executing autocommands |autocmd-searchpat|.
    154 			Same thing for when invoking a user function.
    155 
    156 
    157 While typing the search pattern the current match will be shown if the
    158 'incsearch' option is on.  Remember that you still have to finish the search
    159 command with <CR> to actually position the cursor at the displayed match.  Or
    160 use <Esc> to abandon the search.
    161 
    162 							*nohlsearch-auto*
    163 All matches for the last used search pattern will be highlighted if you set
    164 the 'hlsearch' option.  This can be suspended with the |:nohlsearch| command
    165 or auto suspended with nohlsearch plugin.  See |nohlsearch-install|.
    166 
    167 
    168 When 'shortmess' does not include the "S" flag, Vim will automatically show an
    169 index, on which the cursor is.  This can look like this: >
    170 
    171   [1/5]		Cursor is on first of 5 matches.
    172   [1/>99]	Cursor is on first of more than 99 matches.
    173   [>99/>99]	Cursor is after 99 match of more than 99 matches.
    174   [?/??]	Unknown how many matches exists, generating the
    175 		statistics was aborted because of search timeout.
    176 
    177 Note: the count does not take offset into account.
    178 
    179 When no match is found you get the error: *E486* Pattern not found
    180 Note that for the `:global` command, when used in legacy script, you get a
    181 normal message "Pattern not found", for Vi compatibility.
    182 In |Vim9| script you get E486 for "pattern not found" or *E538* when the pattern
    183 matches in every line with `:vglobal`.
    184 For the |:s| command the "e" flag can be used to avoid the error message
    185 |:s_flags|.
    186 
    187 					*search-options*
    188 The following options affect how a search is performed in Vim:
    189     'hlsearch'		highlight matches
    190     'ignorecase'	ignore case when searching
    191     'imsearch'		use |IME| when entering the search pattern
    192     'incsearch'		show matches incrementally as the pattern is typed
    193     'maxsearchcount'	maximum number for the search count |shm-S|
    194     'shortmess'		suppress messages |shm-s|; show search count |shm-S|
    195     'smartcase'		override 'ignorecase' if pattern contains uppercase
    196     'wrapscan'		continue searching from the start of the file
    197 
    198 					*search-offset* *{offset}*
    199 These commands search for the specified pattern.  With "/" and "?" an
    200 additional offset may be given.  There are two types of offsets: line offsets
    201 and character offsets.
    202 
    203 The offset gives the cursor position relative to the found match:
    204     [num]	[num] lines downwards, in column 1
    205     +[num]	[num] lines downwards, in column 1
    206     -[num]	[num] lines upwards, in column 1
    207     e[+num]	[num] characters to the right of the end of the match
    208     e[-num]	[num] characters to the left of the end of the match
    209     s[+num]	[num] characters to the right of the start of the match
    210     s[-num]	[num] characters to the left of the start of the match
    211     b[+num]	[num] identical to s[+num] above (mnemonic: begin)
    212     b[-num]	[num] identical to s[-num] above (mnemonic: begin)
    213     ;{pattern}  perform another search, see |//;|
    214 
    215 If a '-' or '+' is given but [num] is omitted, a count of one will be used.
    216 When including an offset with 'e', the search becomes inclusive (the
    217 character the cursor lands on is included in operations).
    218 
    219 Examples:
    220 
    221 pattern			cursor position	~
    222 /test/+1		one line below "test", in column 1
    223 /test/e			on the last t of "test"
    224 /test/s+2		on the 's' of "test"
    225 /test/b-3		three characters before "test"
    226 
    227 If one of these commands is used after an operator, the characters between
    228 the cursor position before and after the search is affected.  However, if a
    229 line offset is given, the whole lines between the two cursor positions are
    230 affected.
    231 
    232 An example of how to search for matches with a pattern and change the match
    233 with another word: >
    234 	/foo<CR>	find "foo"
    235 	c//e<CR>	change until end of match
    236 	bar<Esc>	type replacement
    237 	//<CR>		go to start of next match
    238 	c//e<CR>	change until end of match
    239 	beep<Esc>	type another replacement
    240 			etc.
    241 <
    242 							*//;* *E386*
    243 A very special offset is ';' followed by another search command.  For example: >
    244 
    245    /test 1/;/test
    246    /test.*/+1;?ing?
    247 
    248 The first one first finds the next occurrence of "test 1", and then the first
    249 occurrence of "test" after that.
    250 
    251 This is like executing two search commands after each other, except that:
    252 - It can be used as a single motion command after an operator.
    253 - The direction for a following "n" or "N" command comes from the first
    254   search command.
    255 - When an error occurs the cursor is not moved at all.
    256 
    257 							*last-pattern*
    258 The last used pattern and offset are remembered.  They can be used to repeat
    259 the search, possibly in another direction or with another count.  Note that
    260 two patterns are remembered: One for "normal" search commands and one for the
    261 substitute command ":s".  Each time an empty pattern is given, the previously
    262 used pattern is used.  However, if there is no previous search command, a
    263 previous substitute pattern is used, if possible.
    264 
    265 The 'magic' option sticks with the last used pattern.  If you change 'magic',
    266 this will not change how the last used pattern will be interpreted.
    267 The 'ignorecase' option does not do this.  When 'ignorecase' is changed, it
    268 will result in the pattern to match other text.
    269 
    270 All matches for the last used search pattern will be highlighted if you set
    271 the 'hlsearch' option.
    272 
    273 To clear the last used search pattern: >
    274 	:let @/ = ""
    275 This will not set the pattern to an empty string, because that would match
    276 everywhere.  The pattern is really cleared, like when starting Vim.
    277 
    278 The search usually skips matches that don't move the cursor.  Whether the next
    279 match is found at the next character or after the skipped match depends on the
    280 'c' flag in 'cpoptions'.  See |cpo-c|.
    281 	   with 'c' flag:   "/..." advances 1 to 3 characters
    282 	without 'c' flag:   "/..." advances 1 character
    283 The unpredictability with the 'c' flag is caused by starting the search in the
    284 first column, skipping matches until one is found past the cursor position.
    285 
    286 When searching backwards, searching starts at the start of the line, using the
    287 'c' flag in 'cpoptions' as described above.  Then the last match before the
    288 cursor position is used.
    289 
    290 In Vi the ":tag" command sets the last search pattern when the tag is searched
    291 for.  In Vim this is not done, the previous search pattern is still
    292 remembered, unless the 't' flag is present in 'cpoptions'.  The search pattern
    293 is always put in the search history.
    294 
    295 If the 'wrapscan' option is on (which is the default), searches wrap around
    296 the end of the buffer.  If 'wrapscan' is not set, the backward search stops
    297 at the beginning and the forward search stops at the end of the buffer.  If
    298 'wrapscan' is set and the pattern was not found the error message "pattern
    299 not found" is given, and the cursor will not be moved.  If 'wrapscan' is not
    300 set the message becomes "search hit BOTTOM without match" when searching
    301 forward, or "search hit TOP without match" when searching backward.  If
    302 wrapscan is set and the search wraps around the end of the file the message
    303 "search hit TOP, continuing at BOTTOM" or "search hit BOTTOM, continuing at
    304 TOP" is given when searching backwards or forwards respectively.  This can be
    305 switched off by setting the 's' flag in the 'shortmess' option.  The highlight
    306 method 'w' is used for this message (default: standout).
    307 
    308 							*search-range*
    309 You can limit the search command "/" to a certain range of lines by including
    310 \%>l items.  For example, to match the word "limit" below line 199 and above
    311 line 300: >
    312 	/\%>199l\%<300llimit
    313 Also see |/\%>l|.
    314 
    315 Another way is to use the ":substitute" command with the 'c' flag.  Example: >
    316    :.,300s/Pattern//gc
    317 This command will search from the cursor position until line 300 for
    318 "Pattern".  At the match, you will be asked to type a character.  Type 'q' to
    319 stop at this match, type 'n' to find the next match.
    320 
    321 The "*", "#", "g*" and "g#" commands look for a word near the cursor in this
    322 order, the first one that is found is used:
    323 - The keyword currently under the cursor.
    324 - The first keyword to the right of the cursor, in the same line.
    325 - The WORD currently under the cursor.
    326 - The first WORD to the right of the cursor, in the same line.
    327 The keyword may only contain letters and characters in 'iskeyword'.
    328 The WORD may contain any non-blanks (<Tab>s and/or <Space>s).
    329 Note that if you type with ten fingers, the characters are easy to remember:
    330 the "#" is under your left hand middle finger (search to the left and up) and
    331 the "*" is under your right hand middle finger (search to the right and down).
    332 (this depends on your keyboard layout though).
    333 
    334 								*E956*
    335 In very rare cases a regular expression is used recursively.  This can happen
    336 when executing a pattern takes a long time and when checking for messages on
    337 channels a callback is invoked that also uses a pattern or an autocommand is
    338 triggered.  In most cases this should be fine, but if a pattern is in use when
    339 it's used again it fails.  Usually this means there is something wrong with
    340 the pattern.
    341 
    342 ==============================================================================
    343 2. The definition of a pattern		*search-pattern* *pattern* *[pattern]*
    344 					*regular-expression* *regexp* *Pattern*
    345 					*E383* *E476*
    346 
    347 For starters, read chapter 27 of the user manual |usr_27.txt|.
    348 
    349 						*/bar* */\bar* */pattern*
    350 1. A pattern is one or more branches, separated by "\|".  It matches anything
    351    that matches one of the branches.  Example: "foo\|beep" matches "foo" and
    352    matches "beep".  If more than one branch matches, the first one is used.
    353 
    354    pattern ::=	    branch
    355 		or  branch \| branch
    356 		or  branch \| branch \| branch
    357 		etc.
    358 
    359 						*/branch* */\&*
    360 2. A branch is one or more concats, separated by "\&".  It matches the last
    361    concat, but only if all the preceding concats also match at the same
    362    position.  Examples:
    363 	"foobeep\&..." matches "foo" in "foobeep".
    364 	".*Peter\&.*Bob" matches in a line containing both "Peter" and "Bob"
    365 
    366    branch ::=	    concat
    367 		or  concat \& concat
    368 		or  concat \& concat \& concat
    369 		etc.
    370 
    371 						*/concat*
    372 3. A concat is one or more pieces, concatenated.  It matches a match for the
    373    first piece, followed by a match for the second piece, etc.  Example:
    374    "f[0-9]b", first matches "f", then a digit and then "b".
    375 
    376    concat  ::=	    piece
    377 		or  piece piece
    378 		or  piece piece piece
    379 		etc.
    380 
    381 						*/piece*
    382 4. A piece is an atom, possibly followed by a multi, an indication of how many
    383    times the atom can be matched.  Example: "a*" matches any sequence of "a"
    384    characters: "", "a", "aa", etc.  See |/multi|.
    385 
    386    piece   ::=	    atom
    387 		or  atom  multi
    388 
    389 						*/atom*
    390 5. An atom can be one of a long list of items.  Many atoms match one character
    391    in the text.  It is often an ordinary character or a character class.
    392    Parentheses can be used to make a pattern into an atom.  The "\z(\)"
    393    construct is only for syntax highlighting.
    394 
    395    atom    ::=	    ordinary-atom		|/ordinary-atom|
    396 		or  \( pattern \)		|/\(|
    397 		or  \%( pattern \)		|/\%(|
    398 		or  \z( pattern \)		|/\z(|
    399 
    400 
    401 				*/\%#=* *two-engines* *NFA*
    402 Vim includes two regexp engines:
    403 1. An old, backtracking engine that supports everything.
    404 2. A new, NFA engine that works much faster on some patterns, possibly slower
    405    on some patterns.
    406 								 *E1281*
    407 Vim will automatically select the right engine for you.  However, if you run
    408 into a problem or want to specifically select one engine or the other, you can
    409 prepend one of the following to the pattern:
    410 
    411 	\%#=0	Force automatic selection.  Only has an effect when
    412 	        'regexpengine' has been set to a non-zero value.
    413 	\%#=1	Force using the old engine.
    414 	\%#=2	Force using the NFA engine.
    415 
    416 You can also use the 'regexpengine' option to change the default.
    417 
    418 			 *E864* *E868* *E874* *E875* *E876* *E877* *E878*
    419 If selecting the NFA engine and it runs into something that is not implemented
    420 the pattern will not match.  This is only useful when debugging Vim.
    421 
    422 ==============================================================================
    423 3. Magic							*/magic*
    424 
    425 Some characters in the pattern, such as letters, are taken literally.  They
    426 match exactly the same character in the text.  When preceded with a backslash
    427 however, these characters may get a special meaning.  For example, "a" matches
    428 the letter "a", while "\a" matches any alphabetic character.
    429 
    430 Other characters have a special meaning without a backslash.  They need to be
    431 preceded with a backslash to match literally.  For example "." matches any
    432 character while "\." matches a dot.
    433 
    434 If a character is taken literally or not depends on the 'magic' option and the
    435 items in the pattern mentioned next.  The 'magic' option should always be set,
    436 but it can be switched off for Vi compatibility.  We mention the effect of
    437 'nomagic' here for completeness, but we recommend against using that.
    438 							*/\m* */\M*
    439 Use of "\m" makes the pattern after it be interpreted as if 'magic' is set,
    440 ignoring the actual value of the 'magic' option.
    441 Use of "\M" makes the pattern after it be interpreted as if 'nomagic' is used.
    442 							*/\v* */\V*
    443 Use of "\v" means that after it, all ASCII characters except '0'-'9', 'a'-'z',
    444 'A'-'Z' and '_' have special meaning: "very magic"
    445 
    446 Use of "\V" means that after it, only a backslash and the terminating
    447 character (usually / or ?) have special meaning: "very nomagic"
    448 
    449 Examples:
    450 after:	  \v	   \m	    \M	     \V		matches ~
    451 		'magic' 'nomagic'
    452 	  a	   a	    a	     a		literal 'a'
    453 	  \a	   \a	    \a	     \a		any alphabetic character
    454 	  .	   .	    \.	     \.		any character
    455 	  \.	   \.	    .	     .		literal dot
    456 	  $	   $	    $	     \$		end-of-line
    457 	  *	   *	    \*	     \*		any number of the previous atom
    458 	  ~	   ~	    \~	     \~		latest substitute string
    459 	  ()	   \(\)     \(\)     \(\)	group as an atom
    460 	  |	   \|	    \|	     \|		nothing: separates alternatives
    461 	  \\	   \\	    \\	     \\		literal backslash
    462 	  \{	   {	    {	     {		literal curly brace
    463 
    464 {only Vim supports \m, \M, \v and \V}
    465 
    466 If you want to you can make a pattern immune to the 'magic' option being set
    467 or not by putting "\m" or "\M" at the start of the pattern.
    468 
    469 ==============================================================================
    470 4. Overview of pattern items				*pattern-overview*
    471 						*E865* *E866* *E867* *E869*
    472 
    473 Overview of multi items.				*/multi* *E61* *E62*
    474 More explanation and examples below, follow the links.		*E64* *E871*
    475 
    476 	  multi ~
    477      'magic' 'nomagic'	matches of the preceding atom ~
    478 |/star|	*	\*	0 or more	as many as possible
    479 |/\+|	\+	\+	1 or more	as many as possible
    480 |/\=|	\=	\=	0 or 1		as many as possible
    481 |/\?|	\?	\?	0 or 1		as many as possible
    482 
    483 |/\{|	\{n,m}	\{n,m}	n to m		as many as possible
    484 	\{n}	\{n}	n		exactly
    485 	\{n,}	\{n,}	at least n	as many as possible
    486 	\{,m}	\{,m}	0 to m		as many as possible
    487 	\{}	\{}	0 or more	as many as possible (same as *)
    488 
    489 |/\{-|	\{-n,m}	\{-n,m}	n to m		as few as possible
    490 	\{-n}	\{-n}	n		exactly
    491 	\{-n,}	\{-n,}	at least n	as few as possible
    492 	\{-,m}	\{-,m}	0 to m		as few as possible
    493 	\{-}	\{-}	0 or more	as few as possible
    494 
    495 							*E59*
    496 |/\@>|	\@>	\@>	1, like matching a whole pattern
    497 |/\@=|	\@=	\@=	nothing, requires a match |/zero-width|
    498 |/\@!|	\@!	\@!	nothing, requires NO match |/zero-width|
    499 |/\@<=|	\@<=	\@<=	nothing, requires a match behind |/zero-width|
    500 |/\@<!|	\@<!	\@<!	nothing, requires NO match behind |/zero-width|
    501 
    502 
    503 Overview of ordinary atoms.				*/ordinary-atom*
    504 More explanation and examples below, follow the links.
    505 
    506       ordinary atom ~
    507       magic   nomagic	matches ~
    508 |/^|	^	^	start-of-line (at start of pattern) |/zero-width|
    509 |/\^|	\^	\^	literal '^'
    510 |/\_^|	\_^	\_^	start-of-line (used anywhere) |/zero-width|
    511 |/$|	$	$	end-of-line (at end of pattern) |/zero-width|
    512 |/\$|	\$	\$	literal '$'
    513 |/\_$|	\_$	\_$	end-of-line (used anywhere) |/zero-width|
    514 |/.|	.	\.	any single character (not an end-of-line)
    515 |/\_.|	\_.	\_.	any single character or end-of-line
    516 |/\<|	\<	\<	beginning of a word |/zero-width|
    517 |/\>|	\>	\>	end of a word |/zero-width|
    518 |/\zs|	\zs	\zs	anything, sets start of match
    519 |/\ze|	\ze	\ze	anything, sets end of match
    520 |/\%^|	\%^	\%^	beginning of file |/zero-width|		*E71*
    521 |/\%$|	\%$	\%$	end of file |/zero-width|
    522 |/\%V|	\%V	\%V	inside Visual area |/zero-width|
    523 |/\%#|	\%#	\%#	cursor position |/zero-width|
    524 |/\%'m|	\%'m	\%'m	mark m position |/zero-width|
    525 |/\%l|	\%23l	\%23l	in line 23 |/zero-width|
    526 |/\%c|	\%23c	\%23c	in column 23 |/zero-width|
    527 |/\%v|	\%23v	\%23v	in virtual column 23 |/zero-width|
    528 
    529 Character classes:					*/character-classes*
    530       magic   nomagic	matches ~
    531 |/\i|	\i	\i	identifier character (see 'isident' option)
    532 |/\I|	\I	\I	like "\i", but excluding digits
    533 |/\k|	\k	\k	keyword character (see 'iskeyword' option)
    534 |/\K|	\K	\K	like "\k", but excluding digits
    535 |/\f|	\f	\f	file name character (see 'isfname' option)
    536 |/\F|	\F	\F	like "\f", but excluding digits
    537 |/\p|	\p	\p	printable character (see 'isprint' option)
    538 |/\P|	\P	\P	like "\p", but excluding digits
    539 |/\s|	\s	\s	whitespace character: <Space> and <Tab>
    540 |/\S|	\S	\S	non-whitespace character; opposite of \s
    541 |/\d|	\d	\d	digit:				[0-9]
    542 |/\D|	\D	\D	non-digit:			[^0-9]
    543 |/\x|	\x	\x	hex digit:			[0-9A-Fa-f]
    544 |/\X|	\X	\X	non-hex digit:			[^0-9A-Fa-f]
    545 |/\o|	\o	\o	octal digit:			[0-7]
    546 |/\O|	\O	\O	non-octal digit:		[^0-7]
    547 |/\w|	\w	\w	word character:			[0-9A-Za-z_]
    548 |/\W|	\W	\W	non-word character:		[^0-9A-Za-z_]
    549 |/\h|	\h	\h	head of word character:		[A-Za-z_]
    550 |/\H|	\H	\H	non-head of word character:	[^A-Za-z_]
    551 |/\a|	\a	\a	alphabetic character:		[A-Za-z]
    552 |/\A|	\A	\A	non-alphabetic character:	[^A-Za-z]
    553 |/\l|	\l	\l	lowercase character:		[a-z]
    554 |/\L|	\L	\L	non-lowercase character:	[^a-z]
    555 |/\u|	\u	\u	uppercase character:		[A-Z]
    556 |/\U|	\U	\U	non-uppercase character		[^A-Z]
    557 |/\_|	\_x	\_x	where x is any of the characters above: character
    558 			class with end-of-line included
    559 (end of character classes)
    560 
    561       magic   nomagic	matches ~
    562 |/\e|	\e	\e	<Esc>
    563 |/\t|	\t	\t	<Tab>
    564 |/\r|	\r	\r	<CR>
    565 |/\b|	\b	\b	<BS>
    566 |/\n|	\n	\n	end-of-line
    567 |/~|	~	\~	last given substitute string
    568 |/\1|	\1	\1	same string as matched by first \(\)
    569 |/\2|	\2	\2	Like "\1", but uses second \(\)
    570 	   ...
    571 |/\9|	\9	\9	Like "\1", but uses ninth \(\)
    572 								*E68*
    573 |/\z1|	\z1	\z1	only for syntax highlighting, see |:syn-ext-match|
    574 	   ...
    575 |/\z1|	\z9	\z9	only for syntax highlighting, see |:syn-ext-match|
    576 
    577 	x	x	a character with no special meaning matches itself
    578 
    579 |/[]|	[]	\[]	any character specified inside the []
    580 |/\%[]|	\%[]	\%[]	a sequence of optionally matched atoms
    581 
    582 |/\c|	\c	\c	ignore case, do not use the 'ignorecase' option
    583 |/\C|	\C	\C	match case, do not use the 'ignorecase' option
    584 |/\Z|	\Z	\Z	ignore differences in Unicode "combining characters".
    585 			Useful when searching voweled Hebrew or Arabic text.
    586 
    587       magic   nomagic	matches ~
    588 |/\m|	\m	\m	'magic' on for the following chars in the pattern
    589 |/\M|	\M	\M	'magic' off for the following chars in the pattern
    590 |/\v|	\v	\v	the following chars in the pattern are "very magic"
    591 |/\V|	\V	\V	the following chars in the pattern are "very nomagic"
    592 |/\%#=|   \%#=1   \%#=1   select regexp engine |/zero-width|
    593 
    594 |/\%d|	\%d	\%d	match specified decimal character (eg \%d123)
    595 |/\%x|	\%x	\%x	match specified hex character (eg \%x2a)
    596 |/\%o|	\%o	\%o	match specified octal character (eg \%o040)
    597 |/\%u|	\%u	\%u	match specified multibyte character (eg \%u20ac)
    598 |/\%U|	\%U	\%U	match specified large multibyte character (eg
    599 			\%U12345678)
    600 |/\%C|	\%C	\%C	match any composing characters
    601 
    602 Example			matches ~
    603 \<\I\i*		or
    604 \<\h\w*
    605 \<[a-zA-Z_][a-zA-Z0-9_]*
    606 			An identifier (e.g., in a C program).
    607 
    608 \(\.$\|\. \)		A period followed by <EOL> or a space.
    609 
    610 [.!?][])"']*\($\|[ ]\)	A search pattern that finds the end of a sentence,
    611 			with almost the same definition as the ")" command.
    612 
    613 cat\Z			Both "cat" and "càt" ("a" followed by 0x0300)
    614 			Does not match "càt" (character 0x00e0), even
    615 			though it may look the same.
    616 
    617 
    618 ==============================================================================
    619 5. Multi items						*pattern-multi-items*
    620 
    621 An atom can be followed by an indication of how many times the atom can be
    622 matched and in what way.  This is called a multi.  See |/multi| for an
    623 overview.
    624 
    625 							*/star* */\star*
    626 *	(use \* when 'magic' is not set)
    627 	Matches 0 or more of the preceding atom, as many as possible.
    628 	Example  'nomagic'	matches ~
    629 	a*	   a\*		"", "a", "aa", "aaa", etc.
    630 	.*	   \.\*		anything, also an empty string, no end-of-line
    631 	\_.*	   \_.\*	everything up to the end of the buffer
    632 	\_.*END	   \_.\*END	everything up to and including the last "END"
    633 				in the buffer
    634 
    635 	Exception: When "*" is used at the start of the pattern or just after
    636 	"^" it matches the star character.
    637 
    638 	Be aware that repeating "\_." can match a lot of text and take a long
    639 	time.  For example, "\_.*END" matches all text from the current
    640 	position to the last occurrence of "END" in the file.  Since the "*"
    641 	will match as many as possible, this first skips over all lines until
    642 	the end of the file and then tries matching "END", backing up one
    643 	character at a time.
    644 
    645 							*/\+*
    646 \+	Matches 1 or more of the preceding atom, as many as possible.
    647 	Example		matches ~
    648 	^.\+$		any non-empty line
    649 	\s\+		white space of at least one character
    650 
    651 							*/\=*
    652 \=	Matches 0 or 1 of the preceding atom, as many as possible.
    653 	Example		matches ~
    654 	foo\=		"fo" and "foo"
    655 
    656 							*/\?*
    657 \?	Just like \=.  Cannot be used when searching backwards with the "?"
    658 	command.
    659 
    660 					*/\{* *E60* *E554* *E870*
    661 \{n,m}	Matches n to m of the preceding atom, as many as possible
    662 \{n}	Matches n of the preceding atom
    663 \{n,}	Matches at least n of the preceding atom, as many as possible
    664 \{,m}	Matches 0 to m of the preceding atom, as many as possible
    665 \{}	Matches 0 or more of the preceding atom, as many as possible (like *)
    666 							*/\{-*
    667 \{-n,m}	matches n to m of the preceding atom, as few as possible
    668 \{-n}	matches n of the preceding atom
    669 \{-n,}	matches at least n of the preceding atom, as few as possible
    670 \{-,m}	matches 0 to m of the preceding atom, as few as possible
    671 \{-}	matches 0 or more of the preceding atom, as few as possible
    672 
    673 	n and m are positive decimal numbers or zero
    674 								*non-greedy*
    675 	If a "-" appears immediately after the "{", then a shortest match
    676 	first algorithm is used (see example below).  In particular, "\{-}" is
    677 	the same as "*" but uses the shortest match first algorithm.  BUT: A
    678 	match that starts earlier is preferred over a shorter match: "a\{-}b"
    679 	matches "aaab" in "xaaab".
    680 
    681 	Example			matches ~
    682 	ab\{2,3}c		"abbc" or "abbbc"
    683 	a\{5}			"aaaaa"
    684 	ab\{2,}c		"abbc", "abbbc", "abbbbc", etc.
    685 	ab\{,3}c		"ac", "abc", "abbc" or "abbbc"
    686 	a[bc]\{3}d		"abbbd", "abbcd", "acbcd", "acccd", etc.
    687 	a\(bc\)\{1,2}d		"abcd" or "abcbcd"
    688 	a[bc]\{-}[cd]		"abc" in "abcd"
    689 	a[bc]*[cd]		"abcd" in "abcd"
    690 
    691 	The } may optionally be preceded with a backslash: \{n,m\}.
    692 
    693 							*/\@=*
    694 \@=	Matches the preceding atom with zero width.
    695 	Like "(?=pattern)" in Perl.
    696 	Example			matches ~
    697 	foo\(bar\)\@=		"foo" in "foobar"
    698 	foo\(bar\)\@=foo	nothing
    699 							*/zero-width*
    700 	When using "\@=" (or "^", "$", "\<", "\>") no characters are included
    701 	in the match.  These items are only used to check if a match can be
    702 	made.  This can be tricky, because a match with following items will
    703 	be done in the same position.  The last example above will not match
    704 	"foobarfoo", because it tries match "foo" in the same position where
    705 	"bar" matched.
    706 
    707 	Note that using "\&" works the same as using "\@=": "foo\&.." is the
    708 	same as "\(foo\)\@=..".  But using "\&" is easier, you don't need the
    709 	parentheses.
    710 
    711 
    712 							*/\@!*
    713 \@!	Matches with zero width if the preceding atom does NOT match at the
    714 	current position. |/zero-width|
    715 	Like "(?!pattern)" in Perl.
    716 	Example			matches ~
    717 	foo\(bar\)\@!		any "foo" not followed by "bar"
    718 	a.\{-}p\@!		"a", "ap", "app", "appp", etc. not immediately
    719 				followed by a "p"
    720 	if \(\(then\)\@!.\)*$	"if " not followed by "then"
    721 
    722 	Using "\@!" is tricky, because there are many places where a pattern
    723 	does not match.  "a.*p\@!" will match from an "a" to the end of the
    724 	line, because ".*" can match all characters in the line and the "p"
    725 	doesn't match at the end of the line.  "a.\{-}p\@!" will match any
    726 	"a", "ap", "app", etc. that isn't followed by a "p", because the "."
    727 	can match a "p" and "p\@!" doesn't match after that.
    728 
    729 	You can't use "\@!" to look for a non-match before the matching
    730 	position: "\(foo\)\@!bar" will match "bar" in "foobar", because at the
    731 	position where "bar" matches, "foo" does not match.  To avoid matching
    732 	"foobar" you could use "\(foo\)\@!...bar", but that doesn't match a
    733 	bar at the start of a line.  Use "\(foo\)\@<!bar".
    734 
    735 	Useful example: to find "foo" in a line that does not contain "bar": >
    736 		/^\%(.*bar\)\@!.*\zsfoo
    737 <	This pattern first checks that there is not a single position in the
    738 	line where "bar" matches.  If ".*bar" matches somewhere the \@! will
    739 	reject the pattern.  When there is no match any "foo" will be found.
    740 	The "\zs" is to have the match start just before "foo".
    741 
    742 							*/\@<=*
    743 \@<=	Matches with zero width if the preceding atom matches just before what
    744 	follows. |/zero-width|
    745 	Like "(?<=pattern)" in Perl, but Vim allows non-fixed-width patterns.
    746 	Example			matches ~
    747 	\(an\_s\+\)\@<=file	"file" after "an" and white space or an
    748 				end-of-line
    749 	For speed it's often much better to avoid this multi.  Try using "\zs"
    750 	instead |/\zs|.  To match the same as the above example:
    751 		an\_s\+\zsfile
    752 	At least set a limit for the look-behind, see below.
    753 
    754 	"\@<=" and "\@<!" check for matches just before what follows.
    755 	Theoretically these matches could start anywhere before this position.
    756 	But to limit the time needed, only the line where what follows matches
    757 	is searched, and one line before that (if there is one).  This should
    758 	be sufficient to match most things and not be too slow.
    759 
    760 	In the old regexp engine the part of the pattern after "\@<=" and
    761 	"\@<!" are checked for a match first, thus things like "\1" don't work
    762 	to reference \(\) inside the preceding atom.  It does work the other
    763 	way around:
    764 	Bad example			matches ~
    765 	\%#=1\1\@<=,\([a-z]\+\)		",abc" in "abc,abc"
    766 
    767 	However, the new regexp engine works differently, it is better to not
    768 	rely on this behavior, do not use \@<= if it can be avoided:
    769 	Example				matches ~
    770 	\([a-z]\+\)\zs,\1		",abc" in "abc,abc"
    771 
    772 \@123<=
    773 	Like "\@<=" but only look back 123 bytes.  This avoids trying lots
    774 	of matches that are known to fail and make executing the pattern very
    775 	slow.  Example, check if there is a "<" just before "span":
    776 		/<\@1<=span
    777 	This will try matching "<" only one byte before "span", which is the
    778 	only place that works anyway.
    779 	After crossing a line boundary, the limit is relative to the end of
    780 	the line.  Thus the characters at the start of the line with the match
    781 	are not counted (this is just to keep it simple).
    782 	The number zero is the same as no limit.
    783 
    784 							*/\@<!*
    785 \@<!	Matches with zero width if the preceding atom does NOT match just
    786 	before what follows.  Thus this matches if there is no position in the
    787 	current or previous line where the atom matches such that it ends just
    788 	before what follows.  |/zero-width|
    789 	Like "(?<!pattern)" in Perl, but Vim allows non-fixed-width patterns.
    790 	The match with the preceding atom is made to end just before the match
    791 	with what follows, thus an atom that ends in ".*" will work.
    792 	Warning: This can be slow (because many positions need to be checked
    793 	for a match).  Use a limit if you can, see below.
    794 	Example			matches ~
    795 	\(foo\)\@<!bar		any "bar" that's not in "foobar"
    796 	\(\/\/.*\)\@<!in	"in" which is not after "//"
    797 
    798 \@123<!
    799 	Like "\@<!" but only look back 123 bytes.  This avoids trying lots of
    800 	matches that are known to fail and make executing the pattern very
    801 	slow.
    802 
    803 							*/\@>*
    804 \@>	Matches the preceding atom like matching a whole pattern.
    805 	Like "(?>pattern)" in Perl.
    806 	Example		matches ~
    807 	\(a*\)\@>a	nothing (the "a*" takes all the "a"'s, there can't be
    808 			another one following)
    809 
    810 	This matches the preceding atom as if it was a pattern by itself.  If
    811 	it doesn't match, there is no retry with shorter sub-matches or
    812 	anything.  Observe this difference: "a*b" and "a*ab" both match
    813 	"aaab", but in the second case the "a*" matches only the first two
    814 	"a"s.  "\(a*\)\@>ab" will not match "aaab", because the "a*" matches
    815 	the "aaa" (as many "a"s as possible), thus the "ab" can't match.
    816 
    817 
    818 ==============================================================================
    819 6.  Ordinary atoms					*pattern-atoms*
    820 
    821 An ordinary atom can be:
    822 
    823 							*/^*
    824 ^	At beginning of pattern or after "\|", "\(", "\%(" or "\n": matches
    825 	start-of-line; at other positions, matches literal '^'. |/zero-width|
    826 	Example		matches ~
    827 	^beep(		the start of the C function "beep" (probably).
    828 
    829 							*/\^*
    830 \^	Matches literal '^'.  Can be used at any position in the pattern, but
    831 	not inside [].
    832 
    833 							*/\_^*
    834 \_^	Matches start-of-line. |/zero-width|  Can be used at any position in
    835 	the pattern, but not inside [].
    836 	Example		matches ~
    837 	\_s*\_^foo	white space and blank lines and then "foo" at
    838 			start-of-line
    839 
    840 							*/$*
    841 $	At end of pattern or in front of "\|", "\)" or "\n" ('magic' on):
    842 	matches end-of-line <EOL>; at other positions, matches literal '$'.
    843 	|/zero-width|
    844 
    845 							*/\$*
    846 \$	Matches literal '$'.  Can be used at any position in the pattern, but
    847 	not inside [].
    848 
    849 							*/\_$*
    850 \_$	Matches end-of-line. |/zero-width|  Can be used at any position in the
    851 	pattern, but not inside [].  Note that "a\_$b" never matches, since
    852 	"b" cannot match an end-of-line.  Use "a\nb" instead |/\n|.
    853 	Example		matches ~
    854 	foo\_$\_s*	"foo" at end-of-line and following white space and
    855 			blank lines
    856 
    857 .	(with 'nomagic': \.)				*/.* */\.*
    858 	Matches any single character, but not an end-of-line.
    859 
    860 							*/\_.*
    861 \_.	Matches any single character or end-of-line.
    862 	Careful: "\_.*" matches all text to the end of the buffer!
    863 
    864 							*/\<*
    865 \<	Matches the beginning of a word: The next char is the first char of a
    866 	word.  The 'iskeyword' option specifies what is a word character.
    867 	|/zero-width|
    868 
    869 							*/\>*
    870 \>	Matches the end of a word: The previous char is the last char of a
    871 	word.  The 'iskeyword' option specifies what is a word character.
    872 	|/zero-width|
    873 
    874 							*/\zs*
    875 \zs	Matches at any position, but not inside [], and sets the start of the
    876 	match there: The next char is the first char of the whole match.
    877 	|/zero-width|
    878 	Example: >
    879 		/^\s*\zsif
    880 <	matches an "if" at the start of a line, ignoring white space.
    881 	Can be used multiple times, the last one encountered in a matching
    882 	branch is used.  Example: >
    883 		/\(.\{-}\zsFab\)\{3}
    884 <	Finds the third occurrence of "Fab".
    885 	This cannot be followed by a multi. *E888*
    886 	{not available when compiled without the |+syntax| feature}
    887 							*/\ze*
    888 \ze	Matches at any position, but not inside [], and sets the end of the
    889 	match there: The previous char is the last char of the whole match.
    890 	|/zero-width|
    891 	Can be used multiple times, the last one encountered in a matching
    892 	branch is used.
    893 	Example: "end\ze\(if\|for\)" matches the "end" in "endif" and
    894 	"endfor".
    895 	This cannot be followed by a multi. |E888|
    896 	{not available when compiled without the |+syntax| feature}
    897 
    898 						*/\%^* *start-of-file*
    899 \%^	Matches start of the file.  When matching with a string, matches the
    900 	start of the string.
    901 	For example, to find the first "VIM" in a file: >
    902 		/\%^\_.\{-}\zsVIM
    903 <
    904 						*/\%$* *end-of-file*
    905 \%$	Matches end of the file.  When matching with a string, matches the
    906 	end of the string.
    907 	Note that this does NOT find the last "VIM" in a file: >
    908 		/VIM\_.\{-}\%$
    909 <	It will find the next VIM, because the part after it will always
    910 	match.  This one will find the last "VIM" in the file: >
    911 		/VIM\ze\(\(VIM\)\@!\_.\)*\%$
    912 <	This uses |/\@!| to ascertain that "VIM" does NOT match in any
    913 	position after the first "VIM".
    914 	Searching from the end of the file backwards is easier!
    915 
    916 						*/\%V*
    917 \%V	Match inside the Visual area.  When Visual mode has already been
    918 	stopped match in the area that |gv| would reselect.
    919 	This is a |/zero-width| match.  To make sure the whole pattern is
    920 	inside the Visual area put it at the start and just before the end of
    921 	the pattern, e.g.: >
    922 		/\%Vfoo.*ba\%Vr
    923 <	This also works if only "foo bar" was Visually selected.  This: >
    924 		/\%Vfoo.*bar\%V
    925 <	would match "foo bar" if the Visual selection continues after the "r".
    926 	Only works for the current buffer.
    927 
    928 						*/\%#* *cursor-position*
    929 \%#	Matches with the cursor position.  Only works when matching in a
    930 	buffer displayed in a window.
    931 	WARNING: When the cursor is moved after the pattern was used, the
    932 	result becomes invalid.  Vim doesn't automatically update the matches.
    933 	This is especially relevant for syntax highlighting and 'hlsearch'.
    934 	In other words: When the cursor moves the display isn't updated for
    935 	this change.  An update is done for lines which are changed (the whole
    936 	line is updated) or when using the |CTRL-L| command (the whole screen
    937 	is updated).  Example, to highlight the word under the cursor: >
    938 		/\k*\%#\k*
    939 <	When 'hlsearch' is set and you move the cursor around and make changes
    940 	this will clearly show when the match is updated or not.
    941 
    942 						*/\%'m* */\%<'m* */\%>'m*
    943 \%'m	Matches with the position of mark m.
    944 \%<'m	Matches before the position of mark m.
    945 \%>'m	Matches after the position of mark m.
    946 	Example, to highlight the text from mark 's to 'e: >
    947 		/.\%>'s.*\%<'e..
    948 <	Note that two dots are required to include mark 'e in the match.  That
    949 	is because "\%<'e" matches at the character before the 'e mark, and
    950 	since it's a |/zero-width| match it doesn't include that character.
    951 	WARNING: When the mark is moved after the pattern was used, the result
    952 	becomes invalid.  Vim doesn't automatically update the matches.
    953 	Similar to moving the cursor for "\%#" |/\%#|.
    954 
    955 				*/\%l* */\%>l* */\%<l* *E951* *E1204* *E1273*
    956 \%23l	Matches in a specific line.
    957 \%<23l	Matches above a specific line (lower line number).
    958 \%>23l	Matches below a specific line (higher line number).
    959 \%.l	Matches at the cursor line.
    960 \%<.l	Matches above the cursor line.
    961 \%>.l	Matches below the cursor line.
    962 	These six can be used to match specific lines in a buffer.  The "23"
    963 	can be any line number.  The first line is 1.
    964 	WARNING: When inserting or deleting lines Vim does not automatically
    965 	update the matches.  This means Syntax highlighting quickly becomes
    966 	wrong.  Also when referring to the cursor position (".") and
    967 	the cursor moves the display isn't updated for this change.  An update
    968 	is done when using the |CTRL-L| command (the whole screen is updated).
    969 	Example, to highlight the line where the cursor currently is: >
    970 		:exe '/\%' .. line(".") .. 'l'
    971 <	Alternatively use: >
    972 		/\%.l
    973 <	When 'hlsearch' is set and you move the cursor around and make changes
    974 	this will clearly show when the match is updated or not.
    975 
    976 						*/\%c* */\%>c* */\%<c*
    977 \%23c	Matches in a specific column.
    978 \%<23c	Matches before a specific column.
    979 \%>23c	Matches after a specific column.
    980 \%.c	Matches at the cursor column.
    981 \%<.c	Matches before the cursor column.
    982 \%>.c	Matches after the cursor column.
    983 	These six can be used to match specific columns in a buffer or string.
    984 	The "23" can be any column number.  The first column is 1.  Actually,
    985 	the column is the byte number (thus it's not exactly right for
    986 	multibyte characters).
    987 	WARNING: When inserting or deleting text Vim does not automatically
    988 	update the matches.  This means Syntax highlighting quickly becomes
    989 	wrong.  Also when referring to the cursor position (".") and
    990 	the cursor moves the display isn't updated for this change.  An update
    991 	is done when using the |CTRL-L| command (the whole screen is updated).
    992 	Example, to highlight the column where the cursor currently is: >
    993 		:exe '/\%' .. col(".") .. 'c'
    994 <	Alternatively use: >
    995 		/\%.c
    996 <	When 'hlsearch' is set and you move the cursor around and make changes
    997 	this will clearly show when the match is updated or not.
    998 	Example for matching a single byte in column 44: >
    999 		/\%>43c.\%<46c
   1000 <	Note that "\%<46c" matches in column 45 when the "." matches a byte in
   1001 	column 44.
   1002 						*/\%v* */\%>v* */\%<v*
   1003 \%23v	Matches in a specific virtual column.
   1004 \%<23v	Matches before a specific virtual column.
   1005 \%>23v	Matches after a specific virtual column.
   1006 \%.v	Matches at the current virtual column.
   1007 \%<.v	Matches before the current virtual column.
   1008 \%>.v	Matches after the current virtual column.
   1009 	These six can be used to match specific virtual columns in a buffer or
   1010 	string.  When not matching with a buffer in a window, the option
   1011 	values of the current window are used (e.g., 'tabstop').
   1012 	The "23" can be any column number.  The first column is 1.
   1013 	Note that some virtual column positions will never match, because they
   1014 	are halfway through a tab or other character that occupies more than
   1015 	one screen character.
   1016 	WARNING: When inserting or deleting text Vim does not automatically
   1017 	update highlighted matches.  This means Syntax highlighting quickly
   1018 	becomes wrong.  Also when referring to the cursor position (".") and
   1019 	the cursor moves the display isn't updated for this change.  An update
   1020 	is done when using the |CTRL-L| command (the whole screen is updated).
   1021 	Example, to highlight all the characters after virtual column 72: >
   1022 		/\%>72v.*
   1023 <	When 'hlsearch' is set and you move the cursor around and make changes
   1024 	this will clearly show when the match is updated or not.
   1025 	To match the text up to column 17: >
   1026 		/^.*\%17v
   1027 <	To match all characters after the current virtual column (where the
   1028 	cursor is): >
   1029 		/\%>.v.*
   1030 <	Column 17 is not included, because this is a |/zero-width| match.  To
   1031 	include the column use: >
   1032 		/^.*\%17v.
   1033 <	This command does the same thing, but also matches when there is no
   1034 	character in column 17: >
   1035 		/^.*\%<18v.
   1036 <	Note that without the "^" to anchor the match in the first column,
   1037 	this will also highlight column 17: >
   1038 		/.*\%17v
   1039 <	Column 17 is highlighted by 'hlsearch' because there is another match
   1040 	where ".*" matches zero characters.
   1041 
   1042 
   1043 Character classes:
   1044 \i	identifier character (see 'isident' option)	*/\i*
   1045 \I	like "\i", but excluding digits			*/\I*
   1046 \k	keyword character (see 'iskeyword' option)	*/\k*
   1047 \K	like "\k", but excluding digits			*/\K*
   1048 \f	file name character (see 'isfname' option)	*/\f*
   1049 \F	like "\f", but excluding digits			*/\F*
   1050 \p	printable character (see 'isprint' option)	*/\p*
   1051 \P	like "\p", but excluding digits			*/\P*
   1052 
   1053 NOTE: the above also work for multibyte characters.  The ones below only
   1054 match ASCII characters, as indicated by the range.
   1055 
   1056 						*whitespace* *white-space*
   1057 \s	whitespace character: <Space> and <Tab>		*/\s*
   1058 \S	non-whitespace character; opposite of \s	*/\S*
   1059 \d	digit:				[0-9]		*/\d*
   1060 \D	non-digit:			[^0-9]		*/\D*
   1061 \x	hex digit:			[0-9A-Fa-f]	*/\x*
   1062 \X	non-hex digit:			[^0-9A-Fa-f]	*/\X*
   1063 \o	octal digit:			[0-7]		*/\o*
   1064 \O	non-octal digit:		[^0-7]		*/\O*
   1065 \w	word character:			[0-9A-Za-z_]	*/\w*
   1066 \W	non-word character:		[^0-9A-Za-z_]	*/\W*
   1067 \h	head of word character:		[A-Za-z_]	*/\h*
   1068 \H	non-head of word character:	[^A-Za-z_]	*/\H*
   1069 \a	alphabetic character:		[A-Za-z]	*/\a*
   1070 \A	non-alphabetic character:	[^A-Za-z]	*/\A*
   1071 \l	lowercase character:		[a-z]		*/\l*
   1072 \L	non-lowercase character:	[^a-z]		*/\L*
   1073 \u	uppercase character:		[A-Z]		*/\u*
   1074 \U	non-uppercase character:	[^A-Z]		*/\U*
   1075 
   1076 	NOTE: Using the atom is faster than the [] form.
   1077 
   1078 	NOTE: 'ignorecase', "\c" and "\C" are not used by character classes.
   1079 
   1080 			*/\_* *E63* */\_i* */\_I* */\_k* */\_K* */\_f* */\_F*
   1081 			*/\_p* */\_P* */\_s* */\_S* */\_d* */\_D* */\_x* */\_X*
   1082 			*/\_o* */\_O* */\_w* */\_W* */\_h* */\_H* */\_a* */\_A*
   1083 			*/\_l* */\_L* */\_u* */\_U*
   1084 \_x	Where "x" is any of the characters above: The character class with
   1085 	end-of-line added
   1086 (end of character classes)
   1087 
   1088 \e	matches <Esc>					*/\e*
   1089 \t	matches <Tab>					*/\t*
   1090 \r	matches <CR>					*/\r*
   1091 \b	matches <BS>					*/\b*
   1092 \n	matches an end-of-line				*/\n*
   1093 	When matching in a string instead of buffer text a literal newline
   1094 	character is matched.
   1095 
   1096 ~	matches the last given substitute string	*/~* */\~*
   1097 
   1098 \(\)	A pattern enclosed by escaped parentheses.	*/\(* */\(\)* */\)*
   1099 	E.g., "\(^a\)" matches 'a' at the start of a line.
   1100 	There can only be nine of these.  You can use "\%(" to add more, but
   1101 	not counting it as a sub-expression.
   1102 	*E51* *E54* *E55* *E872* *E873*
   1103 
   1104 \1      Matches the same string that was matched by	*/\1* *E65*
   1105 	the first sub-expression in \( and \).
   1106 	Example: "\([a-z]\).\1" matches "ata", "ehe", "tot", etc.
   1107 \2      Like "\1", but uses second sub-expression,	*/\2*
   1108    ...							*/\3*
   1109 \9      Like "\1", but uses ninth sub-expression.	*/\9*
   1110 	Note: The numbering of groups is done based on which "\(" comes first
   1111 	in the pattern (going left to right), NOT based on what is matched
   1112 	first.
   1113 
   1114 \%(\)	A pattern enclosed by escaped parentheses.	*/\%(\)* */\%(* *E53*
   1115 	Just like \(\), but without counting it as a sub-expression.  This
   1116 	allows using more groups and it's a little bit faster.
   1117 
   1118 x	A single character, with no special meaning, matches itself
   1119 
   1120 							*/\* */\\*
   1121 \x	A backslash followed by a single character, with no special meaning,
   1122 	is reserved for future expansions
   1123 
   1124 []	(with 'nomagic': \[])		*/[]* */\[]* */\_[]* */collection* *E76*
   1125 \_[]
   1126 	A collection.  This is a sequence of characters enclosed in square
   1127 	brackets.  It matches any single character in the collection.
   1128 	Example		matches ~
   1129 	[xyz]		any 'x', 'y' or 'z'
   1130 	[a-zA-Z]$	any alphabetic character at the end of a line
   1131 	\c[a-z]$	same
   1132 	[А-яЁё]		Russian alphabet (with utf-8 and cp1251)
   1133 
   1134 								*/[\n]*
   1135 	With "\_" prepended the collection also includes the end-of-line.
   1136 	The same can be done by including "\n" in the collection.  The
   1137 	end-of-line is also matched when the collection starts with "^"!  Thus
   1138 	"\_[^ab]" matches the end-of-line and any character but "a" and "b".
   1139 	This makes it Vi compatible: Without the "\_" or "\n" the collection
   1140 	does not match an end-of-line.
   1141 								*E769*
   1142 	When the ']' is not there Vim will not give an error message but
   1143 	assume no collection is used.  Useful to search for '['.  However, you
   1144 	do get E769 for internal searching.  And be aware that in a
   1145 	`:substitute` command the whole command becomes the pattern.  E.g.
   1146 	":s/[/x/" searches for "[/x" and replaces it with nothing.  It does
   1147 	not search for "[" and replaces it with "x"!
   1148 
   1149 								*E944* *E945*
   1150 	If the sequence begins with "^", it matches any single character NOT
   1151 	in the collection: "[^xyz]" matches anything but 'x', 'y' and 'z'.
   1152 	- If two characters in the sequence are separated by '-', this is
   1153 	  shorthand for the full list of ASCII characters between them.  E.g.,
   1154 	  "[0-9]" matches any decimal digit.  If the starting character
   1155 	  exceeds the ending character, e.g. [c-a], E944 occurs.  Non-ASCII
   1156 	  characters can be used, but the character values must not be more
   1157 	  than 256 apart in the old regexp engine.  For example, searching by
   1158 	  [\u3000-\u4000] after setting re=1 emits a E945 error.  Prepending
   1159 	  \%#=2 will fix it.
   1160 	- A character class expression is evaluated to the set of characters
   1161 	  belonging to that character class.  The following character classes
   1162 	  are supported:
   1163 		  Name	      Func	Contents ~
   1164 *[:alnum:]*	  [:alnum:]   isalnum	ASCII letters and digits
   1165 *[:alpha:]*	  [:alpha:]   isalpha	ASCII letters
   1166 *[:blank:]*	  [:blank:]		space and tab
   1167 *[:cntrl:]*	  [:cntrl:]   iscntrl	ASCII control characters
   1168 *[:digit:]*	  [:digit:]		decimal digits '0' to '9'
   1169 *[:graph:]*	  [:graph:]   isgraph	ASCII printable characters excluding
   1170 					space
   1171 *[:lower:]*	  [:lower:]   (1)	lowercase letters (all letters when
   1172 					'ignorecase' is used and the old
   1173 					engine is in use |two-engines|)
   1174 *[:print:]*	  [:print:]   (2)	printable characters including space
   1175 *[:punct:]*	  [:punct:]   ispunct	ASCII punctuation characters
   1176 *[:space:]*	  [:space:]		whitespace characters: space, tab, CR,
   1177 					NL, vertical tab, form feed
   1178 *[:upper:]*	  [:upper:]   (3)	uppercase letters (all letters when
   1179 					'ignorecase' is used and the old
   1180 					engine is in use |two-engines|)
   1181 *[:xdigit:]*	  [:xdigit:]		hexadecimal digits: 0-9, a-f, A-F
   1182 *[:return:]*	  [:return:]		the <CR> character
   1183 *[:tab:]*	  [:tab:]		the <Tab> character
   1184 *[:escape:]*	  [:escape:]		the <Esc> character
   1185 *[:backspace:]*	  [:backspace:]		the <BS> character
   1186 *[:ident:]*	  [:ident:]		identifier character (same as "\i")
   1187 *[:keyword:]*	  [:keyword:]		keyword character (same as "\k")
   1188 *[:fname:]*	  [:fname:]		file name character (same as "\f")
   1189 	  The square brackets in character class expressions are additional to
   1190 	  the square brackets delimiting a collection.  For example, the
   1191 	  following is a plausible pattern for a UNIX filename:
   1192 	  "[-./[:alnum:]_~]\+".  That is, a list of at least one character,
   1193 	  each of which is either '-', '.', '/', alphabetic, numeric, '_' or
   1194 	  '~'.
   1195 	  These items only work for 8-bit characters, except [:lower:] and
   1196 	  [:upper:] also work for multibyte characters when using the new
   1197 	  regexp engine.  See |two-engines|.  In the future these items may
   1198 	  work for multibyte characters.  For now, to get all "alpha"
   1199 	  characters you can use: [[:lower:][:upper:]].
   1200 
   1201 	  The "Func" column shows what library function is used.  The
   1202 	  implementation depends on the system.  Otherwise:
   1203 	  (1) Uses islower() for ASCII and Vim builtin rules for other
   1204 	  characters.
   1205 	  (2) Uses Vim builtin rules
   1206 	  (3) As with (1) but using isupper()
   1207 							*/[[=* *[==]*
   1208 	- An equivalence class.  This means that characters are matched that
   1209 	  have almost the same meaning, e.g., when ignoring accents.  This
   1210 	  only works for Unicode, latin1 and latin9.  The form is:
   1211 		[=a=]
   1212 							*/[[.* *[..]*
   1213 	- A collation element.  This currently simply accepts a single
   1214 	  character in the form:
   1215 		[.a.]
   1216 							  */\]*
   1217 	- To include a literal ']', '^', '-' or '\' in the collection, put a
   1218 	  backslash before it: "[xyz\]]", "[\^xyz]", "[xy\-z]" and "[xyz\\]".
   1219 	  (Note: POSIX does not support the use of a backslash this way).  For
   1220 	  ']' you can also make it the first character (following a possible
   1221 	  "^"):  "[]xyz]" or "[^]xyz]".
   1222 	  For '-' you can also make it the first or last character: "[-xyz]",
   1223 	  "[^-xyz]" or "[xyz-]".  For '\' you can also let it be followed by
   1224 	  any character that's not in "^]-\bdertnoUux".  "[\xyz]" matches '\',
   1225 	  'x', 'y' and 'z'.  It's better to use "\\" though, future expansions
   1226 	  may use other characters after '\'.
   1227 	- Omitting the trailing ] is not considered an error.  "[]" works like
   1228 	  "[]]", it matches the ']' character.
   1229 	- The following translations are accepted when the 'l' flag is not
   1230 	  included in 'cpoptions':
   1231 		\e	<Esc>
   1232 		\t	<Tab>
   1233 		\r	<CR>	(NOT end-of-line!)
   1234 		\b	<BS>
   1235 		\n	line break, see above |/[\n]|
   1236 		\d123	decimal number of character
   1237 		\o40	octal number of character up to 0o377
   1238 		\x20	hexadecimal number of character up to 0xff
   1239 		\u20AC	hex. number of multibyte character up to 0xffff
   1240 		\U1234	hex. number of multibyte character up to 8 characters
   1241 			0xffffffff |E1541|
   1242 	  NOTE: The other backslash codes mentioned above do not work inside
   1243 	  []!
   1244 	- Matching with a collection can be slow, because each character in
   1245 	  the text has to be compared with each character in the collection.
   1246 	  Use one of the other atoms above when possible.  Example: "\d" is
   1247 	  much faster than "[0-9]" and matches the same characters.  However,
   1248 	  the new |NFA| regexp engine deals with this better than the old one.
   1249 
   1250 						*/\%[]* *E69* *E70* *E369*
   1251 \%[]	A sequence of optionally matched atoms.  This always matches.
   1252 	It matches as much of the list of atoms it contains as possible.  Thus
   1253 	it stops at the first atom that doesn't match.  For example: >
   1254 		/r\%[ead]
   1255 <	matches "r", "re", "rea" or "read".  The longest that matches is used.
   1256 	To match the Ex command "function", where "fu" is required and
   1257 	"nction" is optional, this would work: >
   1258 		/\<fu\%[nction]\>
   1259 <	The end-of-word atom "\>" is used to avoid matching "fu" in "full".
   1260 	It gets more complicated when the atoms are not ordinary characters.
   1261 	You don't often have to use it, but it is possible.  Example: >
   1262 		/\<r\%[[eo]ad]\>
   1263 <	Matches the words "r", "re", "ro", "rea", "roa", "read" and "road".
   1264 	There can be no \(\), \%(\) or \z(\) items inside the [] and \%[] does
   1265 	not nest.
   1266 	To include a "[" use "[[]" and for "]" use []]", e.g.,: >
   1267 		/index\%[[[]0[]]]
   1268 <	matches "index" "index[", "index[0" and "index[0]".
   1269 	{not available when compiled without the |+syntax| feature}
   1270 
   1271 				*/\%d* */\%x* */\%o* */\%u* */\%U* *E678*
   1272 
   1273 \%d123	Matches the character specified with a decimal number.  Must be
   1274 	followed by a non-digit.
   1275 \%o40	Matches the character specified with an octal number up to 0o377.
   1276 	Numbers below 0o40 must be followed by a non-octal digit or a
   1277 	non-digit.
   1278 \%x2a	Matches the character specified with up to two hexadecimal characters.
   1279 \%u20AC	Matches the character specified with up to four hexadecimal
   1280 	characters.
   1281 \%U1234abcd	Matches the character specified with up to eight hexadecimal
   1282 	characters, up to 0x7fffffff (the maximum allowed value is INT_MAX
   1283 	|E1541|, but the maximum valid Unicode codepoint is U+10FFFF).
   1284 
   1285 ==============================================================================
   1286 7. Ignoring case in a pattern					*/ignorecase*
   1287 
   1288 If the 'ignorecase' option is on, the case of normal letters is ignored.
   1289 'smartcase' can be set to ignore case when the pattern contains lowercase
   1290 letters only.
   1291 							*/\c* */\C*
   1292 When "\c" appears anywhere in the pattern, the whole pattern is handled like
   1293 'ignorecase' is on.  The actual value of 'ignorecase' and 'smartcase' is
   1294 ignored.  "\C" does the opposite: Force matching case for the whole pattern.
   1295 {only Vim supports \c and \C}
   1296 Note that 'ignorecase', "\c" and "\C" are not used for the character classes.
   1297 
   1298 Examples:
   1299       pattern	'ignorecase'  'smartcase'	matches ~
   1300 	foo	  off		-		foo
   1301 	foo	  on		-		foo Foo FOO
   1302 	Foo	  on		off		foo Foo FOO
   1303 	Foo	  on		on		    Foo
   1304 	\cfoo	  -		-		foo Foo FOO
   1305 	foo\C	  -		-		foo
   1306 
   1307 Technical detail:				*NL-used-for-Nul*
   1308 <Nul> characters in the file are stored as <NL> in memory.  In the display
   1309 they are shown as "^@".  The translation is done when reading and writing
   1310 files.  To match a <Nul> with a search pattern you can just enter CTRL-@ or
   1311 "CTRL-V 000".  This is probably just what you expect.  Internally the
   1312 character is replaced with a <NL> in the search pattern.  What is unusual is
   1313 that typing CTRL-V CTRL-J also inserts a <NL>, thus also searches for a <Nul>
   1314 in the file.
   1315 
   1316 						*CR-used-for-NL*
   1317 When 'fileformat' is "mac", <NL> characters in the file are stored as <CR>
   1318 characters internally.  In the text they are shown as "^J".  Otherwise this
   1319 works similar to the usage of <NL> for a <Nul>.
   1320 
   1321 When working with expression evaluation, a <NL> character in the pattern
   1322 matches a <NL> in the string.  The use of "\n" (backslash n) to match a <NL>
   1323 doesn't work there, it only works to match text in the buffer.
   1324 
   1325 				*pattern-multi-byte* *pattern-multibyte*
   1326 Patterns will also work with multibyte characters, mostly as you would
   1327 expect.  But invalid bytes may cause trouble, a pattern with an invalid byte
   1328 will probably never match.
   1329 
   1330 ==============================================================================
   1331 8. Composing characters					*patterns-composing*
   1332 
   1333 							*/\Z*
   1334 When "\Z" appears anywhere in the pattern, all composing characters are
   1335 ignored.  Thus only the base characters need to match, the composing
   1336 characters may be different and the number of composing characters may differ.
   1337 Only relevant when 'encoding' is "utf-8".
   1338 Exception: If the pattern starts with one or more composing characters, these
   1339 must match.
   1340 							*/\%C*
   1341 Use "\%C" to skip any composing characters.  For example, the pattern "a" does
   1342 not match in "càt" (where the a has the composing character 0x0300), but
   1343 "a\%C" does.  Note that this does not match "cát" (where the á is character
   1344 0xe1, it does not have a compositing character).  It does match "cat" (where
   1345 the a is just an a).
   1346 
   1347 When a composing character appears at the start of the pattern or after an
   1348 item that doesn't include the composing character, a match is found at any
   1349 character that includes this composing character.
   1350 
   1351 When using a dot and a composing character, this works the same as the
   1352 composing character by itself, except that it doesn't matter what comes before
   1353 this.
   1354 
   1355 The order of composing characters does not matter.  Also, the text may have
   1356 more composing characters than the pattern, it still matches.  But all
   1357 composing characters in the pattern must be found in the text.
   1358 
   1359 Suppose B is a base character and x and y are composing characters:
   1360 	pattern		text		match ~
   1361 	Bxy		Bxy		yes (perfect match)
   1362 	Bxy		Byx		yes (order ignored)
   1363 	Bxy		By		no (x missing)
   1364 	Bxy		Bx		no (y missing)
   1365 	Bx		Bx		yes (perfect match)
   1366 	Bx		By		no (x missing)
   1367 	Bx		Bxy		yes (extra y ignored)
   1368 	Bx		Byx		yes (extra y ignored)
   1369 
   1370 ==============================================================================
   1371 9. Compare with Perl patterns				*perl-patterns*
   1372 
   1373 Vim's regexps are most similar to Perl's, in terms of what you can do.  The
   1374 difference between them is mostly just notation;  here's a summary of where
   1375 they differ:
   1376 
   1377 Capability			in Vimspeak	in Perlspeak ~
   1378 ----------------------------------------------------------------
   1379 force case insensitivity	\c		(?i)
   1380 force case sensitivity		\C		(?-i)
   1381 backref-less grouping		\%(atom\)	(?:atom)
   1382 conservative quantifiers	\{-n,m}		*?, +?, ??, {}?
   1383 0-width match			atom\@=		(?=atom)
   1384 0-width non-match		atom\@!		(?!atom)
   1385 0-width preceding match		atom\@<=	(?<=atom)
   1386 0-width preceding non-match	atom\@<!	(?<!atom)
   1387 match without retry		atom\@>		(?>atom)
   1388 
   1389 Vim and Perl handle newline characters inside a string a bit differently:
   1390 
   1391 In Perl, ^ and $ only match at the very beginning and end of the text,
   1392 by default, but you can set the 'm' flag, which lets them match at
   1393 embedded newlines as well.  You can also set the 's' flag, which causes
   1394 a . to match newlines as well.  (Both these flags can be changed inside
   1395 a pattern using the same syntax used for the i flag above, BTW.)
   1396 
   1397 On the other hand, Vim's ^ and $ always match at embedded newlines, and
   1398 you get two separate atoms, \%^ and \%$, which only match at the very
   1399 start and end of the text, respectively.  Vim solves the second problem
   1400 by giving you the \_ "modifier":  put it in front of a . or a character
   1401 class, and they will match newlines as well.
   1402 
   1403 Finally, these constructs are unique to Perl:
   1404 - execution of arbitrary code in the regexp:  (?{perl code})
   1405 - conditional expressions:  (?(condition)true-expr|false-expr)
   1406 
   1407 ...and these are unique to Vim:
   1408 - changing the magic-ness of a pattern:  \v \V \m \M
   1409    (very useful for avoiding backslashitis)
   1410 - sequence of optionally matching atoms:  \%[atoms]
   1411 - \& (which is to \| what "and" is to "or";  it forces several branches
   1412    to match at one spot)
   1413 - matching lines/columns by number:  \%5l \%5c \%5v
   1414 - setting the start and end of the match:  \zs \ze
   1415 
   1416 ==============================================================================
   1417 10. Highlighting matches				*match-highlight*
   1418 
   1419 							*syntax-vs-match*
   1420 		Note that the match highlight mechanism is independent
   1421 		of |syntax-highlighting|, which is (usually) a buffer-local
   1422 		highlighting, while matching is window-local, both methods
   1423 		can be freely mixed.  Match highlighting functions give you
   1424 		a bit more flexibility in when and how to apply, but are
   1425 		typically only used for temporary highlighting, without strict
   1426 		rules.  Both methods can be used to conceal text.
   1427 
   1428 		Thus the matching functions like |matchadd()| won't consider
   1429 		syntax rules and functions like |synconcealed()| and the
   1430 		other way around.
   1431 
   1432 							*:mat* *:match*
   1433 :mat[ch] {group} /{pattern}/
   1434 		Define a pattern to highlight in the current window.  It will
   1435 		be highlighted with {group}.  Example: >
   1436 			:highlight MyGroup ctermbg=green guibg=green
   1437 			:match MyGroup /TODO/
   1438 <		Instead of // any character can be used to mark the start and
   1439 		end of the {pattern}.  Watch out for using special characters,
   1440 		such as '"' and '|'.
   1441 
   1442 		{group} must exist at the moment this command is executed.
   1443 
   1444 		The {group} highlighting still applies when a character is
   1445 		to be highlighted for 'hlsearch', as the highlighting for
   1446 		matches is given higher priority than that of 'hlsearch'.
   1447 		Syntax highlighting (see 'syntax') is also overruled by
   1448 		matches.
   1449 
   1450 		Note that highlighting the last used search pattern with
   1451 		'hlsearch' is used in all windows, while the pattern defined
   1452 		with ":match" only exists in the current window.  It is kept
   1453 		when switching to another buffer.
   1454 
   1455 		'ignorecase' does not apply, use |/\c| in the pattern to
   1456 		ignore case.  Otherwise case is not ignored.
   1457 
   1458 		'redrawtime' defines the maximum time searched for pattern
   1459 		matches.
   1460 
   1461 		When matching end-of-line and Vim redraws only part of the
   1462 		display you may get unexpected results.  That is because Vim
   1463 		looks for a match in the line where redrawing starts.
   1464 
   1465 		Also see |matcharg()| and |getmatches()|.  The former returns
   1466 		the highlight group and pattern of a previous |:match|
   1467 		command.  The latter returns a list with highlight groups and
   1468 		patterns defined by both |matchadd()| and |:match|.
   1469 
   1470 		Highlighting matches using |:match| are limited to three
   1471 		matches (aside from |:match|, |:2match| and |:3match| are
   1472 		available).  |matchadd()| does not have this limitation and in
   1473 		addition makes it possible to prioritize matches.
   1474 
   1475 		Another example, which highlights all characters in virtual
   1476 		column 72 and more: >
   1477 			:highlight rightMargin term=bold ctermfg=blue guifg=blue
   1478 			:match rightMargin /.\%>72v/
   1479 <		To highlight all character that are in virtual column 7: >
   1480 			:highlight col8 ctermbg=grey guibg=grey
   1481 			:match col8 /\%<8v.\%>7v/
   1482 <		Note the use of two items to also match a character that
   1483 		occupies more than one virtual column, such as a TAB.
   1484 
   1485 :mat[ch]
   1486 :mat[ch] none
   1487 		Clear a previously defined match pattern.
   1488 
   1489 
   1490 :2mat[ch] {group} /{pattern}/					*:2match*
   1491 :2mat[ch]
   1492 :2mat[ch] none
   1493 :3mat[ch] {group} /{pattern}/					*:3match*
   1494 :3mat[ch]
   1495 :3mat[ch] none
   1496 		Just like |:match| above, but set a separate match.  Thus
   1497 		there can be three matches active at the same time.  The match
   1498 		with the lowest number has priority if several match at the
   1499 		same position.  It uses the match id 3.
   1500 		The ":3match" command is used by (Vim < 9.0.2054) |matchparen|
   1501 		plugin.  You are suggested to use ":match" for manual matching
   1502 		and ":2match" for another plugin or even better make use of
   1503 		the more flexible |matchadd()| (and similar) functions instead.
   1504 
   1505 ==============================================================================
   1506 11. Fuzzy matching					*fuzzy-matching*
   1507 
   1508 Fuzzy matching scores how well a string matches a pattern when the pattern
   1509 characters appear in order but not necessarily contiguously.
   1510 
   1511 Example: >
   1512     Pattern:	"vim"
   1513     Candidates:	"vim"	     -> perfect
   1514 		"vimeo"	     -> good (v i m)
   1515 		"voice mail" -> weaker (v _ i _ _ _ m)
   1516 		"vintage"    -> no match (no "m")
   1517 <
   1518 If the search string has multiple words, each word is matched separately and
   1519 may appear in any order in the candidate.  For example "get pat" matches
   1520 "GetPattern", "PatternGet", "getPattern", "patGetter", "getSomePattern",
   1521 "MatchpatternGet", etc.
   1522 
   1523 The 'ignorecase' and 'smartcase' options do not apply, case is ignored if the
   1524 pattern is all lower case.
   1525 
   1526 Vim's implementation is based on the algorithm from the fzy project:
   1527 https://github.com/jhawthorn/fzy
   1528 
   1529 It uses dynamic programming to compute an optimal score for a given pattern
   1530 and candidate.
   1531 
   1532 The algorithm works in two stages:
   1533 
   1534 1. Forward pass
   1535    Scan the candidate left to right, tracking the best score for each
   1536    pattern position.  Matches score higher when they occur at the start
   1537    of the candidate, the start of a word (space, underscore, dash,
   1538    camelCase), or directly after the previous match.
   1539 
   1540 2. Backward pass
   1541    Start from the best-scoring end position and step back to find match
   1542    positions, ensuring the alignment is optimal.
   1543 
   1544 Vim extends the original algorithm to support multibyte codepoints, allowing
   1545 correct matching for UTF-8 and other encodings.
   1546 
   1547 Time complexity is O(pattern * candidate).  Memory usage is proportional
   1548 to the same.
   1549 
   1550 The |matchfuzzy()| and |matchfuzzypos()| functions perform fuzzy searching in
   1551 a List of strings.  |matchfuzzy()| returns the matching strings, while
   1552 |matchfuzzypos()| returns the matches along with their positions and scores.
   1553 
   1554 The "f" flag of `:vimgrep` enables fuzzy matching.
   1555 
   1556 To enable fuzzy matching for |ins-completion|, add "fuzzy" to the
   1557 'completeopt' option.  For |cmdline-completion|, add "fuzzy" to the
   1558 'wildoptions' option.
   1559 
   1560  vim:tw=78:ts=8:noet:ft=help:norl: