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