1*pattern.txt* For Vim version 7.1a. Last change: 2007 Apr 24 2 3 4 VIM REFERENCE MANUAL by Bram Moolenaar 5 6 7Patterns and search commands *pattern-searches* 8 9The very basics can be found in section |03.9| of the user manual. A few more 10explanations are in chapter 27 |usr_27.txt|. 11 121. Search commands |search-commands| 132. The definition of a pattern |search-pattern| 143. Magic |/magic| 154. Overview of pattern items |pattern-overview| 165. Multi items |pattern-multi-items| 176. Ordinary atoms |pattern-atoms| 187. Ignoring case in a pattern |/ignorecase| 198. Composing characters |patterns-composing| 209. Compare with Perl patterns |perl-patterns| 2110. Highlighting matches |match-highlight| 22 23============================================================================== 241. Search commands *search-commands* *E486* 25 26 */* 27/{pattern}[/]<CR> Search forward for the [count]'th occurrence of 28 {pattern} |exclusive|. 29 30/{pattern}/{offset}<CR> Search forward for the [count]'th occurrence of 31 {pattern} and go |{offset}| lines up or down. 32 |linewise|. 33 34 */<CR>* 35/<CR> Search forward for the [count]'th latest used 36 pattern |last-pattern| with latest used |{offset}|. 37 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. 41 42 *?* 43?{pattern}[?]<CR> Search backward for the [count]'th previous 44 occurrence of {pattern} |exclusive|. 45 46?{pattern}?{offset}<CR> Search backward for the [count]'th previous 47 occurrence of {pattern} and go |{offset}| lines up or 48 down |linewise|. 49 50 *?<CR>* 51?<CR> Search backward for the [count]'th latest used 52 pattern |last-pattern| with latest used |{offset}|. 53 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. 57 58 *n* 59n Repeat the latest "/" or "?" [count] times. 60 |last-pattern| {Vi: no count} 61 62 *N* 63N Repeat the latest "/" or "?" [count] times in 64 opposite direction. |last-pattern| {Vi: no count} 65 66 *star* *E348* *E349* 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 72 current line 73 3. the non-blank word under the cursor 74 4. the first non-blank word after the cursor, 75 in the current line 76 Only whole keywords are searched for, like with the 77 command "/\<keyword\>". |exclusive| {not in Vi} 78 'ignorecase' is used, 'smartcase' is not. 79 80 *#* 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} 85 86 *gstar* 87g* 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} 90 91 *g#* 92g# 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} 95 96 *gd* 97gd 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). 112 {not in Vi} 113 114 *gD* 115gD 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} 120 121 *1gd* 1221gd Like "gd", but ignore matches inside a {} block that 123 ends before the cursor position. {not in Vi} 124 125 *1gD* 1261gD Like "gD", but ignore matches inside a {} block that 127 ends before the cursor position. {not in Vi} 128 129 *CTRL-C* 130CTRL-C Interrupt current (search) command. Use CTRL-Break on 131 MS-DOS |dos-CTRL-Break|. 132 In Normal mode, any pending command is aborted. 133 134 *:noh* *:nohlsearch* 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 142While typing the search pattern the current match will be shown if the 143'incsearch' option is on. Remember that you still have to finish the search 144command with <CR> to actually position the cursor at the displayed match. Or 145use <Esc> to abandon the search. 146 147All matches for the last used search pattern will be highlighted if you set 148the 'hlsearch' option. This can be suspended with the |:nohlsearch| command. 149 150 *search-offset* *{offset}* 151These commands search for the specified pattern. With "/" and "?" an 152additional offset may be given. There are two types of offsets: line offsets 153and character offsets. {the character offsets are not in Vi} 154 155The offset gives the cursor position relative to the found match: 156 [num] [num] lines downwards, in column 1 157 +[num] [num] lines downwards, in column 1 158 -[num] [num] lines upwards, in column 1 159 e[+num] [num] characters to the right of the end of the match 160 e[-num] [num] characters to the left of the end of the match 161 s[+num] [num] characters to the right of the start of the match 162 s[-num] [num] characters to the left of the start of the match 163 b[+num] [num] identical to s[+num] above (mnemonic: begin) 164 b[-num] [num] identical to s[-num] above (mnemonic: begin) 165 ;{pattern} perform another search, see |//;| 166 167If a '-' or '+' is given but [num] is omitted, a count of one will be used. 168When including an offset with 'e', the search becomes inclusive (the 169character the cursor lands on is included in operations). 170 171Examples: 172 173pattern cursor position ~ 174/test/+1 one line below "test", in column 1 175/test/e on the last t of "test" 176/test/s+2 on the 's' of "test" 177/test/b-3 three characters before "test" 178 179If one of these commands is used after an operator, the characters between 180the cursor position before and after the search is affected. However, if a 181line offset is given, the whole lines between the two cursor positions are 182affected. 183 184An example of how to search for matches with a pattern and change the match 185with another word: > 186 /foo<CR> find "foo" 187 c//e change until end of match 188 bar<Esc> type replacement 189 //<CR> go to start of next match 190 c//e change until end of match 191 beep<Esc> type another replacement 192 etc. 193< 194 *//;* *E386* 195A very special offset is ';' followed by another search command. For example: > 196 197 /test 1/;/test 198 /test.*/+1;?ing? 199 200The first one first finds the next occurrence of "test 1", and then the first 201occurrence of "test" after that. 202 203This is like executing two search commands after each other, except that: 204- It can be used as a single motion command after an operator. 205- The direction for a following "n" or "N" command comes from the first 206 search command. 207- When an error occurs the cursor is not moved at all. 208 209 *last-pattern* 210The last used pattern and offset are remembered. They can be used to repeat 211the search, possibly in another direction or with another count. Note that 212two patterns are remembered: One for 'normal' search commands and one for the 213substitute command ":s". Each time an empty pattern is given, the previously 214used pattern is used. 215 216The 'magic' option sticks with the last used pattern. If you change 'magic', 217this will not change how the last used pattern will be interpreted. 218The 'ignorecase' option does not do this. When 'ignorecase' is changed, it 219will result in the pattern to match other text. 220 221All matches for the last used search pattern will be highlighted if you set 222the 'hlsearch' option. 223 224To clear the last used search pattern: > 225 :let @/ = "" 226This will not set the pattern to an empty string, because that would match 227everywhere. The pattern is really cleared, like when starting Vim. 228 229The search usually skips matches that don't move the cursor. Whether the next 230match is found at the next character or after the skipped match depends on the 231'c' flag in 'cpoptions'. See |cpo-c|. 232 with 'c' flag: "/..." advances 1 to 3 characters 233 without 'c' flag: "/..." advances 1 character 234The unpredictability with the 'c' flag is caused by starting the search in the 235first column, skipping matches until one is found past the cursor position. 236 237When searching backwards, searching starts at the start of the line, using the 238'c' flag in 'cpoptions' as described above. Then the last match before the 239cursor position is used. 240 241In Vi the ":tag" command sets the last search pattern when the tag is searched 242for. In Vim this is not done, the previous search pattern is still remembered, 243unless the 't' flag is present in 'cpoptions'. The search pattern is always 244put in the search history. 245 246If the 'wrapscan' option is on (which is the default), searches wrap around 247the end of the buffer. If 'wrapscan' is not set, the backward search stops 248at the beginning and the forward search stops at the end of the buffer. If 249'wrapscan' is set and the pattern was not found the error message "pattern 250not found" is given, and the cursor will not be moved. If 'wrapscan' is not 251set the message becomes "search hit BOTTOM without match" when searching 252forward, or "search hit TOP without match" when searching backward. If 253wrapscan is set and the search wraps around the end of the file the message 254"search hit TOP, continuing at BOTTOM" or "search hit BOTTOM, continuing at 255TOP" is given when searching backwards or forwards respectively. This can be 256switched off by setting the 's' flag in the 'shortmess' option. The highlight 257method 'w' is used for this message (default: standout). 258 259 *search-range* 260You can limit the search command "/" to a certain range of lines by including 261\%>l items. For example, to match the word "limit" below line 199 and above 262line 300: > 263 /\%>199l\%<300llimit 264Also see |/\%>l|. 265 266Another way is to use the ":substitute" command with the 'c' flag. Example: > 267 :.,300s/Pattern//gc 268This command will search from the cursor position until line 300 for 269"Pattern". At the match, you will be asked to type a character. Type 'q' to 270stop at this match, type 'n' to find the next match. 271 272The "*", "#", "g*" and "g#" commands look for a word near the cursor in this 273order, the first one that is found is used: 274- The keyword currently under the cursor. 275- The first keyword to the right of the cursor, in the same line. 276- The WORD currently under the cursor. 277- The first WORD to the right of the cursor, in the same line. 278The keyword may only contain letters and characters in 'iskeyword'. 279The WORD may contain any non-blanks (<Tab>s and/or <Space>s). 280Note that if you type with ten fingers, the characters are easy to remember: 281the "#" is under your left hand middle finger (search to the left and up) and 282the "*" is under your right hand middle finger (search to the right and down). 283(this depends on your keyboard layout though). 284 285============================================================================== 2862. The definition of a pattern *search-pattern* *pattern* *[pattern]* 287 *regular-expression* *regexp* *Pattern* 288 *E76* *E383* *E476* 289 290For starters, read chapter 27 of the user manual |usr_27.txt|. 291 292 */bar* */\bar* */pattern* 2931. A pattern is one or more branches, separated by "\|". It matches anything 294 that matches one of the branches. Example: "foo\|beep" matches "foo" and 295 matches "beep". If more than one branch matches, the first one is used. 296 297 pattern ::= branch 298 or branch \| branch 299 or branch \| branch \| branch 300 etc. 301 302 */branch* */\&* 3032. A branch is one or more concats, separated by "\&". It matches the last 304 concat, but only if all the preceding concats also match at the same 305 position. Examples: 306 "foobeep\&..." matches "foo" in "foobeep". 307 ".*Peter\&.*Bob" matches in a line containing both "Peter" and "Bob" 308 309 branch ::= concat 310 or concat \& concat 311 or concat \& concat \& concat 312 etc. 313 314 */concat* 3153. A concat is one or more pieces, concatenated. It matches a match for the 316 first piece, followed by a match for the second piece, etc. Example: 317 "f[0-9]b", first matches "f", then a digit and then "b". 318 319 concat ::= piece 320 or piece piece 321 or piece piece piece 322 etc. 323 324 */piece* 3254. A piece is an atom, possibly followed by a multi, an indication of how many 326 times the atom can be matched. Example: "a*" matches any sequence of "a" 327 characters: "", "a", "aa", etc. See |/multi|. 328 329 piece ::= atom 330 or atom multi 331 332 */atom* 3335. An atom can be one of a long list of items. Many atoms match one character 334 in the text. It is often an ordinary character or a character class. 335 Braces can be used to make a pattern into an atom. The "\z(\)" construct 336 is only for syntax highlighting. 337 338 atom ::= ordinary-atom |/ordinary-atom| 339 or \( pattern \) |/\(| 340 or \%( pattern \) |/\%(| 341 or \z( pattern \) |/\z(| 342 343 344============================================================================== 3453. Magic */magic* 346 347Some characters in the pattern are taken literally. They match with the same 348character in the text. When preceded with a backslash however, these 349characters get a special meaning. 350 351Other characters have a special meaning without a backslash. They need to be 352preceded with a backslash to match literally. 353 354If a character is taken literally or not depends on the 'magic' option and the 355items mentioned next. 356 */\m* */\M* 357Use of "\m" makes the pattern after it be interpreted as if 'magic' is set, 358ignoring the actual value of the 'magic' option. 359Use of "\M" makes the pattern after it be interpreted as if 'nomagic' is used. 360 */\v* */\V* 361Use of "\v" means that in the pattern after it all ASCII characters except 362'0'-'9', 'a'-'z', 'A'-'Z' and '_' have a special meaning. "very magic" 363 364Use of "\V" means that in the pattern after it only the backslash has a 365special meaning. "very nomagic" 366 367Examples: 368after: \v \m \M \V matches ~ 369 'magic' 'nomagic' 370 $ $ $ \$ matches end-of-line 371 . . \. \. matches any character 372 * * \* \* any number of the previous atom 373 () \(\) \(\) \(\) grouping into an atom 374 | \| \| \| separating alternatives 375 \a \a \a \a alphabetic character 376 \\ \\ \\ \\ literal backslash 377 \. \. . . literal dot 378 \{ { { { literal '{' 379 a a a a literal 'a' 380 381{only Vim supports \m, \M, \v and \V} 382 383It is recommended to always keep the 'magic' option at the default setting, 384which is 'magic'. This avoids portability problems. To make a pattern immune 385to the 'magic' option being set or not, put "\m" or "\M" at the start of the 386pattern. 387 388============================================================================== 3894. Overview of pattern items *pattern-overview* 390 391Overview of multi items. */multi* *E61* *E62* 392More explanation and examples below, follow the links. *E64* 393 394 multi ~ 395 'magic' 'nomagic' matches of the preceding atom ~ 396|/star| * \* 0 or more as many as possible 397|/\+| \+ \+ 1 or more as many as possible (*) 398|/\=| \= \= 0 or 1 as many as possible (*) 399|/\?| \? \? 0 or 1 as many as possible (*) 400 401|/\{| \{n,m} \{n,m} n to m as many as possible (*) 402 \{n} \{n} n exactly (*) 403 \{n,} \{n,} at least n as many as possible (*) 404 \{,m} \{,m} 0 to m as many as possible (*) 405 \{} \{} 0 or more as many as possible (same as *) (*) 406 407|/\{-| \{-n,m} \{-n,m} n to m as few as possible (*) 408 \{-n} \{-n} n exactly (*) 409 \{-n,} \{-n,} at least n as few as possible (*) 410 \{-,m} \{-,m} 0 to m as few as possible (*) 411 \{-} \{-} 0 or more as few as possible (*) 412 413 *E59* 414|/\@>| \@> \@> 1, like matching a whole pattern (*) 415|/\@=| \@= \@= nothing, requires a match |/zero-width| (*) 416|/\@!| \@! \@! nothing, requires NO match |/zero-width| (*) 417|/\@<=| \@<= \@<= nothing, requires a match behind |/zero-width| (*) 418|/\@<!| \@<! \@<! nothing, requires NO match behind |/zero-width| (*) 419 420(*) {not in Vi} 421 422 423Overview of ordinary atoms. */ordinary-atom* 424More explanation and examples below, follow the links. 425 426 ordinary atom ~ 427 magic nomagic matches ~ 428|/^| ^ ^ start-of-line (at start of pattern) |/zero-width| 429|/\^| \^ \^ literal '^' 430|/\_^| \_^ \_^ start-of-line (used anywhere) |/zero-width| 431|/$| $ $ end-of-line (at end of pattern) |/zero-width| 432|/\$| \$ \$ literal '$' 433|/\_$| \_$ \_$ end-of-line (used anywhere) |/zero-width| 434|/.| . \. any single character (not an end-of-line) 435|/\_.| \_. \_. any single character or end-of-line 436|/\<| \< \< beginning of a word |/zero-width| 437|/\>| \> \> end of a word |/zero-width| 438|/\zs| \zs \zs anything, sets start of match 439|/\ze| \ze \ze anything, sets end of match 440|/\%^| \%^ \%^ beginning of file |/zero-width| *E71* 441|/\%$| \%$ \%$ end of file |/zero-width| 442|/\%V| \%V \%V inside Visual area |/zero-width| 443|/\%#| \%# \%# cursor position |/zero-width| 444|/\%'m| \%'m \%'m mark m position |/zero-width| 445|/\%l| \%23l \%23l in line 23 |/zero-width| 446|/\%c| \%23c \%23c in column 23 |/zero-width| 447|/\%v| \%23v \%23v in virtual column 23 |/zero-width| 448 449Character classes {not in Vi}: */character-classes* 450|/\i| \i \i identifier character (see 'isident' option) 451|/\I| \I \I like "\i", but excluding digits 452|/\k| \k \k keyword character (see 'iskeyword' option) 453|/\K| \K \K like "\k", but excluding digits 454|/\f| \f \f file name character (see 'isfname' option) 455|/\F| \F \F like "\f", but excluding digits 456|/\p| \p \p printable character (see 'isprint' option) 457|/\P| \P \P like "\p", but excluding digits 458|/\s| \s \s whitespace character: <Space> and <Tab> 459|/\S| \S \S non-whitespace character; opposite of \s 460|/\d| \d \d digit: [0-9] 461|/\D| \D \D non-digit: [^0-9] 462|/\x| \x \x hex digit: [0-9A-Fa-f] 463|/\X| \X \X non-hex digit: [^0-9A-Fa-f] 464|/\o| \o \o octal digit: [0-7] 465|/\O| \O \O non-octal digit: [^0-7] 466|/\w| \w \w word character: [0-9A-Za-z_] 467|/\W| \W \W non-word character: [^0-9A-Za-z_] 468|/\h| \h \h head of word character: [A-Za-z_] 469|/\H| \H \H non-head of word character: [^A-Za-z_] 470|/\a| \a \a alphabetic character: [A-Za-z] 471|/\A| \A \A non-alphabetic character: [^A-Za-z] 472|/\l| \l \l lowercase character: [a-z] 473|/\L| \L \L non-lowercase character: [^a-z] 474|/\u| \u \u uppercase character: [A-Z] 475|/\U| \U \U non-uppercase character [^A-Z] 476|/\_| \_x \_x where x is any of the characters above: character 477 class with end-of-line included 478(end of character classes) 479 480|/\e| \e \e <Esc> 481|/\t| \t \t <Tab> 482|/\r| \r \r <CR> 483|/\b| \b \b <BS> 484|/\n| \n \n end-of-line 485|/~| ~ \~ last given substitute string 486|/\1| \1 \1 same string as matched by first \(\) {not in Vi} 487|/\2| \2 \2 Like "\1", but uses second \(\) 488 ... 489|/\9| \9 \9 Like "\1", but uses ninth \(\) 490 *E68* 491|/\z1| \z1 \z1 only for syntax highlighting, see |:syn-ext-match| 492 ... 493|/\z1| \z9 \z9 only for syntax highlighting, see |:syn-ext-match| 494 495 x x a character with no special meaning matches itself 496 497|/[]| [] \[] any character specified inside the [] 498|/\%[]| \%[] \%[] a sequence of optionally matched atoms 499 500|/\c| \c \c ignore case 501|/\C| \C \C match case 502|/\m| \m \m 'magic' on for the following chars in the pattern 503|/\M| \M \M 'magic' off for the following chars in the pattern 504|/\v| \v \v the following chars in the pattern are "very magic" 505|/\V| \V \V the following chars in the pattern are "very nomagic" 506|/\Z| \Z \Z ignore differences in Unicode "combining characters". 507 Useful when searching voweled Hebrew or Arabic text. 508 509|/\%d| \%d \%d match specified decimal character (eg \%d123 510|/\%x| \%x \%x match specified hex character (eg \%x2a) 511|/\%o| \%o \%o match specified octal character (eg \%o040) 512|/\%u| \%u \%u match specified multibyte character (eg \%u20ac) 513|/\%U| \%U \%U match specified large multibyte character (eg 514 \%U12345678) 515 516Example matches ~ 517\<\I\i* or 518\<\h\w* 519\<[a-zA-Z_][a-zA-Z0-9_]* 520 An identifier (e.g., in a C program). 521 522\(\.$\|\. \) A period followed by <EOL> or a space. 523 524[.!?][])"']*\($\|[ ]\) A search pattern that finds the end of a sentence, 525 with almost the same definition as the ")" command. 526 527cat\Z Both "cat" and "càt" ("a" followed by 0x0300) 528 Does not match "càt" (character 0x00e0), even 529 though it may look the same. 530 531 532============================================================================== 5335. Multi items *pattern-multi-items* 534 535An atom can be followed by an indication of how many times the atom can be 536matched and in what way. This is called a multi. See |/multi| for an 537overview. 538 539 */star* */\star* *E56* 540* (use \* when 'magic' is not set) 541 Matches 0 or more of the preceding atom, as many as possible. 542 Example 'nomagic' matches ~ 543 a* a\* "", "a", "aa", "aaa", etc. 544 .* \.\* anything, also an empty string, no end-of-line 545 \_.* \_.\* everything up to the end of the buffer 546 \_.*END \_.\*END everything up to and including the last "END" 547 in the buffer 548 549 Exception: When "*" is used at the start of the pattern or just after 550 "^" it matches the star character. 551 552 Be aware that repeating "\_." can match a lot of text and take a long 553 time. For example, "\_.*END" matches all text from the current 554 position to the last occurrence of "END" in the file. Since the "*" 555 will match as many as possible, this first skips over all lines until 556 the end of the file and then tries matching "END", backing up one 557 character at a time. 558 559 */\+* *E57* 560\+ Matches 1 or more of the preceding atom, as many as possible. {not in 561 Vi} 562 Example matches ~ 563 ^.\+$ any non-empty line 564 \s\+ white space of at least one character 565 566 */\=* 567\= Matches 0 or 1 of the preceding atom, as many as possible. {not in Vi} 568 Example matches ~ 569 foo\= "fo" and "foo" 570 571 */\?* 572\? Just like \=. Cannot be used when searching backwards with the "?" 573 command. {not in Vi} 574 575 */\{* *E58* *E60* *E554* 576\{n,m} Matches n to m of the preceding atom, as many as possible 577\{n} Matches n of the preceding atom 578\{n,} Matches at least n of the preceding atom, as many as possible 579\{,m} Matches 0 to m of the preceding atom, as many as possible 580\{} Matches 0 or more of the preceding atom, as many as possible (like *) 581 */\{-* 582\{-n,m} matches n to m of the preceding atom, as few as possible 583\{-n} matches n of the preceding atom 584\{-n,} matches at least n of the preceding atom, as few as possible 585\{-,m} matches 0 to m of the preceding atom, as few as possible 586\{-} matches 0 or more of the preceding atom, as few as possible 587 {Vi does not have any of these} 588 589 n and m are positive decimal numbers or zero 590 *non-greedy* 591 If a "-" appears immediately after the "{", then a shortest match 592 first algorithm is used (see example below). In particular, "\{-}" is 593 the same as "*" but uses the shortest match first algorithm. BUT: A 594 match that starts earlier is preferred over a shorter match: "a\{-}b" 595 matches "aaab" in "xaaab". 596 597 Example matches ~ 598 ab\{2,3}c "abbc" or "abbbc" 599 a\{5} "aaaaa". 600 ab\{2,}c "abbc", "abbbc", "abbbbc", etc 601 ab\{,3}c "ac", "abc", "abbc" or "abbbc". 602 a[bc]\{3}d "abbbd", "abbcd", "acbcd", "acccd", etc. 603 a\(bc\)\{1,2}d "abcd" or "abcbcd" 604 a[bc]\{-}[cd] "abc" in "abcd" 605 a[bc]*[cd] "abcd" in "abcd" 606 607 The } may optionally be preceded with a backslash: \{n,m\}. 608 609 */\@=* 610\@= Matches the preceding atom with zero width. {not in Vi} 611 Like "(?=pattern)" in Perl. 612 Example matches ~ 613 foo\(bar\)\@= "foo" in "foobar" 614 foo\(bar\)\@=foo nothing 615 */zero-width* 616 When using "\@=" (or "^", "$", "\<", "\>") no characters are included 617 in the match. These items are only used to check if a match can be 618 made. This can be tricky, because a match with following items will 619 be done in the same position. The last example above will not match 620 "foobarfoo", because it tries match "foo" in the same position where 621 "bar" matched. 622 623 Note that using "\&" works the same as using "\@=": "foo\&.." is the 624 same as "\(foo\)\@=..". But using "\&" is easier, you don't need the 625 braces. 626 627 628 */\@!* 629\@! Matches with zero width if the preceding atom does NOT match at the 630 current position. |/zero-width| {not in Vi} 631 Like '(?!pattern)" in Perl. 632 Example matches ~ 633 foo\(bar\)\@! any "foo" not followed by "bar" 634 a.\{-}p\@! "a", "ap", "app", etc. not followed by a "p" 635 if \(\(then\)\@!.\)*$ "if " not followed by "then" 636 637 Using "\@!" is tricky, because there are many places where a pattern 638 does not match. "a.*p\@!" will match from an "a" to the end of the 639 line, because ".*" can match all characters in the line and the "p" 640 doesn't match at the end of the line. "a.\{-}p\@!" will match any 641 "a", "ap", "aap", etc. that isn't followed by a "p", because the "." 642 can match a "p" and "p\@!" doesn't match after that. 643 644 You can't use "\@!" to look for a non-match before the matching 645 position: "\(foo\)\@!bar" will match "bar" in "foobar", because at the 646 position where "bar" matches, "foo" does not match. To avoid matching 647 "foobar" you could use "\(foo\)\@!...bar", but that doesn't match a 648 bar at the start of a line. Use "\(foo\)\@<!bar". 649 650 */\@<=* 651\@<= Matches with zero width if the preceding atom matches just before what 652 follows. |/zero-width| {not in Vi} 653 Like '(?<=pattern)" in Perl, but Vim allows non-fixed-width patterns. 654 Example matches ~ 655 \(an\_s\+\)\@<=file "file" after "an" and white space or an 656 end-of-line 657 For speed it's often much better to avoid this multi. Try using "\zs" 658 instead |/\zs|. To match the same as the above example: 659 an\_s\+\zsfile 660 661 "\@<=" and "\@<!" check for matches just before what follows. 662 Theoretically these matches could start anywhere before this position. 663 But to limit the time needed, only the line where what follows matches 664 is searched, and one line before that (if there is one). This should 665 be sufficient to match most things and not be too slow. 666 The part of the pattern after "\@<=" and "\@<!" are checked for a 667 match first, thus things like "\1" don't work to reference \(\) inside 668 the preceding atom. It does work the other way around: 669 Example matches ~ 670 \1\@<=,\([a-z]\+\) ",abc" in "abc,abc" 671 672 */\@<!* 673\@<! Matches with zero width if the preceding atom does NOT match just 674 before what follows. Thus this matches if there is no position in the 675 current or previous line where the atom matches such that it ends just 676 before what follows. |/zero-width| {not in Vi} 677 Like '(?<!pattern)" in Perl, but Vim allows non-fixed-width patterns. 678 The match with the preceding atom is made to end just before the match 679 with what follows, thus an atom that ends in ".*" will work. 680 Warning: This can be slow (because many positions need to be checked 681 for a match). 682 Example matches ~ 683 \(foo\)\@<!bar any "bar" that's not in "foobar" 684 \(\/\/.*\)\@\<!in "in" which is not after "//" 685 686 */\@>* 687\@> Matches the preceding atom like matching a whole pattern. {not in Vi} 688 Like '(?>pattern)" in Perl. 689 Example matches ~ 690 \(a*\)\@>a nothing (the "a*" takes all the "a"'s, there can't be 691 another one following) 692 693 This matches the preceding atom as if it was a pattern by itself. If 694 it doesn't match, there is no retry with shorter sub-matches or 695 anything. Observe this difference: "a*b" and "a*ab" both match 696 "aaab", but in the second case the "a*" matches only the first two 697 "a"s. "\(a*\)\@>ab" will not match "aaab", because the "a*" matches 698 the "aaa" (as many "a"s as possible), thus the "ab" can't match. 699 700 701============================================================================== 7026. Ordinary atoms *pattern-atoms* 703 704An ordinary atom can be: 705 706 */^* 707^ At beginning of pattern or after "\|", "\(", "\%(" or "\n": matches 708 start-of-line; at other positions, matches literal '^'. |/zero-width| 709 Example matches ~ 710 ^beep( the start of the C function "beep" (probably). 711 712 */\^* 713\^ Matches literal '^'. Can be used at any position in the pattern. 714 715 */\_^* 716\_^ Matches start-of-line. |/zero-width| Can be used at any position in 717 the pattern. 718 Example matches ~ 719 \_s*\_^foo white space and blank lines and then "foo" at 720 start-of-line 721 722 */$* 723$ At end of pattern or in front of "\|" or "\)" ("|" or ")" after "\v"): 724 matches end-of-line <EOL>; at other positions, matches literal '$'. 725 |/zero-width| 726 727 */\$* 728\$ Matches literal '$'. Can be used at any position in the pattern. 729 730 */\_$* 731\_$ Matches end-of-line. |/zero-width| Can be used at any position in the 732 pattern. Note that "a\_$b" never matches, since "b" cannot match an 733 end-of-line. Use "a\nb" instead |/\n|. 734 Example matches ~ 735 foo\_$\_s* "foo" at end-of-line and following white space and 736 blank lines 737 738. (with 'nomagic': \.) */.* */\.* 739 Matches any single character, but not an end-of-line. 740 741 */\_.* 742\_. Matches any single character or end-of-line. 743 Careful: "\_.*" matches all text to the end of the buffer! 744 745 */\<* 746\< Matches the beginning of a word: The next char is the first char of a 747 word. The 'iskeyword' option specifies what is a word character. 748 |/zero-width| 749 750 */\>* 751\> Matches the end of a word: The previous char is the last char of a 752 word. The 'iskeyword' option specifies what is a word character. 753 |/zero-width| 754 755 */\zs* 756\zs Matches at any position, and sets the start of the match there: The 757 next char is the first char of the whole match. |/zero-width| 758 Example: > 759 /^\s*\zsif 760< matches an "if" at the start of a line, ignoring white space. 761 Can be used multiple times, the last one encountered in a matching 762 branch is used. Example: > 763 /\(.\{-}\zsFab\)\{3} 764< Finds the third occurrence of "Fab". 765 {not in Vi} {not available when compiled without the +syntax feature} 766 */\ze* 767\ze Matches at any position, and sets the end of the match there: The 768 previous char is the last char of the whole match. |/zero-width| 769 Can be used multiple times, the last one encountered in a matching 770 branch is used. 771 Example: "end\ze\(if\|for\)" matches the "end" in "endif" and 772 "endfor". 773 {not in Vi} {not available when compiled without the +syntax feature} 774 775 */\%^* *start-of-file* 776\%^ Matches start of the file. When matching with a string, matches the 777 start of the string. {not in Vi} 778 For example, to find the first "VIM" in a file: > 779 /\%^\_.\{-}\zsVIM 780< 781 */\%$* *end-of-file* 782\%$ Matches end of the file. When matching with a string, matches the 783 end of the string. {not in Vi} 784 Note that this does NOT find the last "VIM" in a file: > 785 /VIM\_.\{-}\%$ 786< It will find the next VIM, because the part after it will always 787 match. This one will find the last "VIM" in the file: > 788 /VIM\ze\(\(VIM\)\@!\_.\)*\%$ 789< This uses |/\@!| to ascertain that "VIM" does NOT match in any 790 position after the first "VIM". 791 Searching from the end of the file backwards is easier! 792 793 */\%V* 794\%V Match inside the Visual area. When Visual mode has already been 795 stopped match in the area that |gv| would reselect. 796 Only works for the current buffer. 797 798 */\%#* *cursor-position* 799\%# Matches with the cursor position. Only works when matching in a 800 buffer displayed in a window. {not in Vi} 801 WARNING: When the cursor is moved after the pattern was used, the 802 result becomes invalid. Vim doesn't automatically update the matches. 803 This is especially relevant for syntax highlighting and 'hlsearch'. 804 In other words: When the cursor moves the display isn't updated for 805 this change. An update is done for lines which are changed (the whole 806 line is updated) or when using the |CTRL-L| command (the whole screen 807 is updated). Example, to highlight the word under the cursor: > 808 /\k*\%#\k* 809< When 'hlsearch' is set and you move the cursor around and make changes 810 this will clearly show when the match is updated or not. 811 812 */\%'m* */\%<'m* */\%>'m* 813\%'m Matches with the position of mark m. 814\%<'m Matches before the position of mark m. 815\%>'m Matches after the position of mark m. 816 Example, to highlight the text from mark 's to 'e: > 817 /.\%>'s.*\%<'e.. 818< Note that two dots are required to include mark 'e in the match. That 819 is because "\%<'e" matches at the character before the 'e mark, and 820 since it's a |/zero-width| match it doesn't include that character. 821 {not in Vi} 822 WARNING: When the mark is moved after the pattern was used, the result 823 becomes invalid. Vim doesn't automatically update the matches. 824 Similar to moving the cursor for "\%#" |/\%#|. 825 826 */\%l* */\%>l* */\%<l* 827\%23l Matches in a specific line. 828\%<23l Matches above a specific line (lower line number). 829\%>23l Matches below a specific line (higher line number). 830 These three can be used to match specific lines in a buffer. The "23" 831 can be any line number. The first line is 1. {not in Vi} 832 WARNING: When inserting or deleting lines Vim does not automatically 833 update the matches. This means Syntax highlighting quickly becomes 834 wrong. 835 Example, to highlight the line where the cursor currently is: > 836 :exe '/\%' . line(".") . 'l.*' 837< When 'hlsearch' is set and you move the cursor around and make changes 838 this will clearly show when the match is updated or not. 839 840 */\%c* */\%>c* */\%<c* 841\%23c Matches in a specific column. 842\%<23c Matches before a specific column. 843\%>23c Matches after a specific column. 844 These three can be used to match specific columns in a buffer or 845 string. The "23" can be any column number. The first column is 1. 846 Actually, the column is the byte number (thus it's not exactly right 847 for multi-byte characters). {not in Vi} 848 WARNING: When inserting or deleting text Vim does not automatically 849 update the matches. This means Syntax highlighting quickly becomes 850 wrong. 851 Example, to highlight the column where the cursor currently is: > 852 :exe '/\%' . col(".") . 'c' 853< When 'hlsearch' is set and you move the cursor around and make changes 854 this will clearly show when the match is updated or not. 855 Example for matching a single byte in column 44: > 856 /\%>43c.\%<46c 857< Note that "\%<46c" matches in column 45 when the "." matches a byte in 858 column 44. 859 */\%v* */\%>v* */\%<v* 860\%23v Matches in a specific virtual column. 861\%<23v Matches before a specific virtual column. 862\%>23v Matches after a specific virtual column. 863 These three can be used to match specific virtual columns in a buffer 864 or string. When not matching with a buffer in a window, the option 865 values of the current window are used (e.g., 'tabstop'). 866 The "23" can be any column number. The first column is 1. 867 Note that some virtual column positions will never match, because they 868 are halfway a Tab or other character that occupies more than one 869 screen character. {not in Vi} 870 WARNING: When inserting or deleting text Vim does not automatically 871 update highlighted matches. This means Syntax highlighting quickly 872 becomes wrong. 873 Example, to highlight the all characters after virtual column 72: > 874 /\%>72v.* 875< When 'hlsearch' is set and you move the cursor around and make changes 876 this will clearly show when the match is updated or not. 877 To match the text up to column 17: > 878 /.*\%17v 879< Column 17 is not included, because that's where the "\%17v" matches, 880 and since this is a |/zero-width| match, column 17 isn't included in 881 the match. This does the same: > 882 /.*\%<18v 883< 884 885Character classes: {not in Vi} 886\i identifier character (see 'isident' option) */\i* 887\I like "\i", but excluding digits */\I* 888\k keyword character (see 'iskeyword' option) */\k* 889\K like "\k", but excluding digits */\K* 890\f file name character (see 'isfname' option) */\f* 891\F like "\f", but excluding digits */\F* 892\p printable character (see 'isprint' option) */\p* 893\P like "\p", but excluding digits */\P* 894 895NOTE: the above also work for multi-byte characters. The ones below only 896match ASCII characters, as indicated by the range. 897 898 *whitespace* *white-space* 899\s whitespace character: <Space> and <Tab> */\s* 900\S non-whitespace character; opposite of \s */\S* 901\d digit: [0-9] */\d* 902\D non-digit: [^0-9] */\D* 903\x hex digit: [0-9A-Fa-f] */\x* 904\X non-hex digit: [^0-9A-Fa-f] */\X* 905\o octal digit: [0-7] */\o* 906\O non-octal digit: [^0-7] */\O* 907\w word character: [0-9A-Za-z_] */\w* 908\W non-word character: [^0-9A-Za-z_] */\W* 909\h head of word character: [A-Za-z_] */\h* 910\H non-head of word character: [^A-Za-z_] */\H* 911\a alphabetic character: [A-Za-z] */\a* 912\A non-alphabetic character: [^A-Za-z] */\A* 913\l lowercase character: [a-z] */\l* 914\L non-lowercase character: [^a-z] */\L* 915\u uppercase character: [A-Z] */\u* 916\U non-uppercase character [^A-Z] */\U* 917 918 NOTE: Using the atom is faster than the [] form. 919 920 NOTE: 'ignorecase', "\c" and "\C" are not used by character classes. 921 922 */\_* *E63* */\_i* */\_I* */\_k* */\_K* */\_f* */\_F* 923 */\_p* */\_P* */\_s* */\_S* */\_d* */\_D* */\_x* */\_X* 924 */\_o* */\_O* */\_w* */\_W* */\_h* */\_H* */\_a* */\_A* 925 */\_l* */\_L* */\_u* */\_U* 926\_x Where "x" is any of the characters above: The character class with 927 end-of-line added 928(end of character classes) 929 930\e matches <Esc> */\e* 931\t matches <Tab> */\t* 932\r matches <CR> */\r* 933\b matches <BS> */\b* 934\n matches an end-of-line */\n* 935 When matching in a string instead of buffer text a literal newline 936 character is matched. 937 938~ matches the last given substitute string */~* */\~* 939 940\(\) A pattern enclosed by escaped parentheses. */\(* */\(\)* */\)* 941 E.g., "\(^a\)" matches 'a' at the start of a line. *E51* *E54* *E55* 942 943\1 Matches the same string that was matched by */\1* *E65* 944 the first sub-expression in \( and \). {not in Vi} 945 Example: "\([a-z]\).\1" matches "ata", "ehe", "tot", etc. 946\2 Like "\1", but uses second sub-expression, */\2* 947 ... */\3* 948\9 Like "\1", but uses ninth sub-expression. */\9* 949 Note: The numbering of groups is done based on which "\(" comes first 950 in the pattern (going left to right), NOT based on what is matched 951 first. 952 953\%(\) A pattern enclosed by escaped parentheses. */\%(\)* */\%(* *E53* 954 Just like \(\), but without counting it as a sub-expression. This 955 allows using more groups and it's a little bit faster. 956 {not in Vi} 957 958x A single character, with no special meaning, matches itself 959 960 */\* */\\* 961\x A backslash followed by a single character, with no special meaning, 962 is reserved for future expansions 963 964[] (with 'nomagic': \[]) */[]* */\[]* */\_[]* */collection* 965\_[] 966 A collection. This is a sequence of characters enclosed in brackets. 967 It matches any single character in the collection. 968 Example matches ~ 969 [xyz] any 'x', 'y' or 'z' 970 [a-zA-Z]$ any alphabetic character at the end of a line 971 \c[a-z]$ same 972 */[\n]* 973 With "\_" prepended the collection also includes the end-of-line. 974 The same can be done by including "\n" in the collection. The 975 end-of-line is also matched when the collection starts with "^"! Thus 976 "\_[^ab]" matches the end-of-line and any character but "a" and "b". 977 This makes it Vi compatible: Without the "\_" or "\n" the collection 978 does not match an end-of-line. 979 *E769* 980 When the ']' is not there Vim will not give an error message but 981 assume no collection is used. Useful to search for '['. However, you 982 do get E769 for internal searching. 983 984 If the sequence begins with "^", it matches any single character NOT 985 in the collection: "[^xyz]" matches anything but 'x', 'y' and 'z'. 986 - If two characters in the sequence are separated by '-', this is 987 shorthand for the full list of ASCII characters between them. E.g., 988 "[0-9]" matches any decimal digit. 989 - A character class expression is evaluated to the set of characters 990 belonging to that character class. The following character classes 991 are supported: 992 Name Contents ~ 993*[:alnum:]* [:alnum:] letters and digits 994*[:alpha:]* [:alpha:] letters 995*[:blank:]* [:blank:] space and tab characters 996*[:cntrl:]* [:cntrl:] control characters 997*[:digit:]* [:digit:] decimal digits 998*[:graph:]* [:graph:] printable characters excluding space 999*[:lower:]* [:lower:] lowercase letters (all letters when 1000 'ignorecase' is used) 1001*[:print:]* [:print:] printable characters including space 1002*[:punct:]* [:punct:] punctuation characters 1003*[:space:]* [:space:] whitespace characters 1004*[:upper:]* [:upper:] uppercase letters (all letters when 1005 'ignorecase' is used) 1006*[:xdigit:]* [:xdigit:] hexadecimal digits 1007*[:return:]* [:return:] the <CR> character 1008*[:tab:]* [:tab:] the <Tab> character 1009*[:escape:]* [:escape:] the <Esc> character 1010*[:backspace:]* [:backspace:] the <BS> character 1011 The brackets in character class expressions are additional to the 1012 brackets delimiting a collection. For example, the following is a 1013 plausible pattern for a UNIX filename: "[-./[:alnum:]_~]\+" That is, 1014 a list of at least one character, each of which is either '-', '.', 1015 '/', alphabetic, numeric, '_' or '~'. 1016 These items only work for 8-bit characters. 1017 */[[=* *[==]* 1018 - An equivalence class. This means that characters are matched that 1019 have almost the same meaning, e.g., when ignoring accents. The form 1020 is: 1021 [=a=] 1022 Currently this is only implemented for latin1. Also works for the 1023 latin1 characters in utf-8 and latin9. 1024 */[[.* *[..]* 1025 - A collation element. This currently simply accepts a single 1026 character in the form: 1027 [.a.] 1028 */\]* 1029 - To include a literal ']', '^', '-' or '\' in the collection, put a 1030 backslash before it: "[xyz\]]", "[\^xyz]", "[xy\-z]" and "[xyz\\]". 1031 (Note: POSIX does not support the use of a backslash this way). For 1032 ']' you can also make it the first character (following a possible 1033 "^"): "[]xyz]" or "[^]xyz]" {not in Vi}. 1034 For '-' you can also make it the first or last character: "[-xyz]", 1035 "[^-xyz]" or "[xyz-]". For '\' you can also let it be followed by 1036 any character that's not in "^]-\bertn". "[\xyz]" matches '\', 'x', 1037 'y' and 'z'. It's better to use "\\" though, future expansions may 1038 use other characters after '\'. 1039 - The following translations are accepted when the 'l' flag is not 1040 included in 'cpoptions' {not in Vi}: 1041 \e <Esc> 1042 \t <Tab> 1043 \r <CR> (NOT end-of-line!) 1044 \b <BS> 1045 \n line break, see above |/[\n]| 1046 \d123 decimal number of character 1047 \o40 octal number of character up to 0377 1048 \x20 hexadecimal number of character up to 0xff 1049 \u20AC hex. number of multibyte character up to 0xffff 1050 \U1234 hex. number of multibyte character up to 0xffffffff 1051 NOTE: The other backslash codes mentioned above do not work inside 1052 []! 1053 - Matching with a collection can be slow, because each character in 1054 the text has to be compared with each character in the collection. 1055 Use one of the other atoms above when possible. Example: "\d" is 1056 much faster than "[0-9]" and matches the same characters. 1057 1058 */\%[]* *E69* *E70* *E369* 1059\%[] A sequence of optionally matched atoms. This always matches. 1060 It matches as much of the list of atoms it contains as possible. Thus 1061 it stops at the first atom that doesn't match. For example: > 1062 /r\%[ead] 1063< matches "r", "re", "rea" or "read". The longest that matches is used. 1064 To match the Ex command "function", where "fu" is required and 1065 "nction" is optional, this would work: > 1066 /\<fu\%[nction]\> 1067< The end-of-word atom "\>" is used to avoid matching "fu" in "full". 1068 It gets more complicated when the atoms are not ordinary characters. 1069 You don't often have to use it, but it is possible. Example: > 1070 /\<r\%[[eo]ad]\> 1071< Matches the words "r", "re", "ro", "rea", "roa", "read" and "road". 1072 There can be no \(\), \%(\) or \z(\) items inside the [] and \%[] does 1073 not nest. 1074 {not available when compiled without the +syntax feature} 1075 1076 */\%d* */\%x* */\%o* */\%u* */\%U* *E678* 1077 1078\%d123 Matches the character specified with a decimal number. Must be 1079 followed by a non-digit. 1080\%o40 Matches the character specified with an octal number up to 0377. 1081 Numbers below 040 must be followed by a non-octal digit or a non-digit. 1082\%x2a Matches the character specified with up to two hexadecimal characters. 1083\%u20AC Matches the character specified with up to four hexadecimal 1084 characters. 1085\%U1234abcd Matches the character specified with up to eight hexadecimal 1086 characters. 1087 1088============================================================================== 10897. Ignoring case in a pattern */ignorecase* 1090 1091If the 'ignorecase' option is on, the case of normal letters is ignored. 1092'smartcase' can be set to ignore case when the pattern contains lowercase 1093letters only. 1094 */\c* */\C* 1095When "\c" appears anywhere in the pattern, the whole pattern is handled like 1096'ignorecase' is on. The actual value of 'ignorecase' and 'smartcase' is 1097ignored. "\C" does the opposite: Force matching case for the whole pattern. 1098{only Vim supports \c and \C} 1099Note that 'ignorecase', "\c" and "\C" are not used for the character classes. 1100 1101Examples: 1102 pattern 'ignorecase' 'smartcase' matches ~ 1103 foo off - foo 1104 foo on - foo Foo FOO 1105 Foo on off foo Foo FOO 1106 Foo on on Foo 1107 \cfoo - - foo Foo FOO 1108 foo\C - - foo 1109 1110Technical detail: *NL-used-for-Nul* 1111<Nul> characters in the file are stored as <NL> in memory. In the display 1112they are shown as "^@". The translation is done when reading and writing 1113files. To match a <Nul> with a search pattern you can just enter CTRL-@ or 1114"CTRL-V 000". This is probably just what you expect. Internally the 1115character is replaced with a <NL> in the search pattern. What is unusual is 1116that typing CTRL-V CTRL-J also inserts a <NL>, thus also searches for a <Nul> 1117in the file. {Vi cannot handle <Nul> characters in the file at all} 1118 1119 *CR-used-for-NL* 1120When 'fileformat' is "mac", <NL> characters in the file are stored as <CR> 1121characters internally. In the display they are shown as "^M". Otherwise this 1122works similar to the usage of <NL> for a <Nul>. 1123 1124When working with expression evaluation, a <NL> character in the pattern 1125matches a <NL> in the string. The use of "\n" (backslash n) to match a <NL> 1126doesn't work there, it only works to match text in the buffer. 1127 1128 *pattern-multi-byte* 1129Patterns will also work with multi-byte characters, mostly as you would 1130expect. But invalid bytes may cause trouble, a pattern with an invalid byte 1131will probably never match. 1132 1133============================================================================== 11348. Composing characters *patterns-composing* 1135 1136 */\Z* 1137When "\Z" appears anywhere in the pattern, composing characters are ignored. 1138Thus only the base characters need to match, the composing characters may be 1139different and the number of composing characters may differ. Only relevant 1140when 'encoding' is "utf-8". 1141 1142When a composing character appears at the start of the pattern of after an 1143item that doesn't include the composing character, a match is found at any 1144character that includes this composing character. 1145 1146When using a dot and a composing character, this works the same as the 1147composing character by itself, except that it doesn't matter what comes before 1148this. 1149 1150The order of composing characters matters, even though changing the order 1151doesn't change what a character looks like. This may change in the future. 1152 1153============================================================================== 11549. Compare with Perl patterns *perl-patterns* 1155 1156Vim's regexes are most similar to Perl's, in terms of what you can do. The 1157difference between them is mostly just notation; here's a summary of where 1158they differ: 1159 1160Capability in Vimspeak in Perlspeak ~ 1161---------------------------------------------------------------- 1162force case insensitivity \c (?i) 1163force case sensitivity \C (?-i) 1164backref-less grouping \%(atom\) (?:atom) 1165conservative quantifiers \{-n,m} *?, +?, ??, {}? 11660-width match atom\@= (?=atom) 11670-width non-match atom\@! (?!atom) 11680-width preceding match atom\@<= (?<=atom) 11690-width preceding non-match atom\@<! (?<!atom) 1170match without retry atom\@> (?>atom) 1171 1172Vim and Perl handle newline characters inside a string a bit differently: 1173 1174In Perl, ^ and $ only match at the very beginning and end of the text, 1175by default, but you can set the 'm' flag, which lets them match at 1176embedded newlines as well. You can also set the 's' flag, which causes 1177a . to match newlines as well. (Both these flags can be changed inside 1178a pattern using the same syntax used for the i flag above, BTW.) 1179 1180On the other hand, Vim's ^ and $ always match at embedded newlines, and 1181you get two separate atoms, \%^ and \%$, which only match at the very 1182start and end of the text, respectively. Vim solves the second problem 1183by giving you the \_ "modifier": put it in front of a . or a character 1184class, and they will match newlines as well. 1185 1186Finally, these constructs are unique to Perl: 1187- execution of arbitrary code in the regex: (?{perl code}) 1188- conditional expressions: (?(condition)true-expr|false-expr) 1189 1190...and these are unique to Vim: 1191- changing the magic-ness of a pattern: \v \V \m \M 1192 (very useful for avoiding backslashitis) 1193- sequence of optionally matching atoms: \%[atoms] 1194- \& (which is to \| what "and" is to "or"; it forces several branches 1195 to match at one spot) 1196- matching lines/columns by number: \%5l \%5c \%5v 1197- setting the start and end of the match: \zs \ze 1198 1199============================================================================== 120010. Highlighting matches *match-highlight* 1201 1202 *:mat* *:match* 1203:mat[ch] {group} /{pattern}/ 1204 Define a pattern to highlight in the current window. It will 1205 be highlighted with {group}. Example: > 1206 :highlight MyGroup ctermbg=green guibg=green 1207 :match MyGroup /TODO/ 1208< Instead of // any character can be used to mark the start and 1209 end of the {pattern}. Watch out for using special characters, 1210 such as '"' and '|'. 1211 1212 {group} must exist at the moment this command is executed. 1213 1214 The {group} highlighting still applies when a character is 1215 to be highlighted for 'hlsearch'. 1216 1217 Note that highlighting the last used search pattern with 1218 'hlsearch' is used in all windows, while the pattern defined 1219 with ":match" only exists in the current window. It is kept 1220 when switching to another buffer. 1221 1222 'ignorecase' does not apply, use |/\c| in the pattern to 1223 ignore case. Otherwise case is not ignored. 1224 1225 When matching end-of-line and Vim redraws only part of the 1226 display you may get unexpected results. That is because Vim 1227 looks for a match in the line where redrawing starts. 1228 1229 Also see |matcharg()|, it returns the highlight group and 1230 pattern of a previous :match command. 1231 1232 Another example, which highlights all characters in virtual 1233 column 72 and more: > 1234 :highlight rightMargin term=bold ctermfg=blue guifg=blue 1235 :match rightMargin /.\%>72v/ 1236< To highlight all character that are in virtual column 7: > 1237 :highlight col8 ctermbg=grey guibg=grey 1238 :match col8 /\%<8v.\%>7v/ 1239< Note the use of two items to also match a character that 1240 occupies more than one virtual column, such as a TAB. 1241 1242:mat[ch] 1243:mat[ch] none 1244 Clear a previously defined match pattern. 1245 1246 1247:2mat[ch] {group} /{pattern}/ *:2match* 1248:2mat[ch] 1249:2mat[ch] none 1250:3mat[ch] {group} /{pattern}/ *:3match* 1251:3mat[ch] 1252:3mat[ch] none 1253 Just like |:match| above, but set a separate match. Thus 1254 there can be three matches active at the same time. The match 1255 with the lowest number has priority if several match at the 1256 same position. 1257 The ":3match" command is used by the |matchparen| plugin. You 1258 are suggested to use ":match" for manual matching and 1259 ":2match" for another plugin. 1260 1261 1262 vim:tw=78:ts=8:ft=help:norl: 1263