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