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