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