|
1702
|
1 *motion.txt* For Vim version 7.2. Last change: 2008 Aug 03
|
|
7
|
2
|
|
|
3
|
|
|
4 VIM REFERENCE MANUAL by Bram Moolenaar
|
|
|
5
|
|
|
6
|
|
|
7 Cursor motions *cursor-motions* *navigation*
|
|
|
8
|
|
|
9 These commands move the cursor position. If the new position is off of the
|
|
|
10 screen, the screen is scrolled to show the cursor (see also 'scrolljump' and
|
|
|
11 'scrolloff' options).
|
|
|
12
|
|
|
13 1. Motions and operators |operator|
|
|
|
14 2. Left-right motions |left-right-motions|
|
|
|
15 3. Up-down motions |up-down-motions|
|
|
|
16 4. Word motions |word-motions|
|
|
|
17 5. Text object motions |object-motions|
|
|
|
18 6. Text object selection |object-select|
|
|
|
19 7. Marks |mark-motions|
|
|
|
20 8. Jumps |jump-motions|
|
|
|
21 9. Various motions |various-motions|
|
|
|
22
|
|
|
23 General remarks:
|
|
|
24
|
|
|
25 If you want to know where you are in the file use the "CTRL-G" command
|
|
|
26 |CTRL-G| or the "g CTRL-G" command |g_CTRL-G|. If you set the 'ruler' option,
|
|
|
27 the cursor position is continuously shown in the status line (which slows down
|
|
|
28 Vim a little).
|
|
|
29
|
|
|
30 Experienced users prefer the hjkl keys because they are always right under
|
|
|
31 their fingers. Beginners often prefer the arrow keys, because they do not
|
|
|
32 know what the hjkl keys do. The mnemonic value of hjkl is clear from looking
|
|
|
33 at the keyboard. Think of j as an arrow pointing downwards.
|
|
|
34
|
|
|
35 The 'virtualedit' option can be set to make it possible to move the cursor to
|
|
|
36 positions where there is no character or halfway a character.
|
|
|
37
|
|
|
38 ==============================================================================
|
|
|
39 1. Motions and operators *operator*
|
|
|
40
|
|
|
41 The motion commands can be used after an operator command, to have the command
|
|
|
42 operate on the text that was moved over. That is the text between the cursor
|
|
|
43 position before and after the motion. Operators are generally used to delete
|
|
|
44 or change text. The following operators are available:
|
|
|
45
|
|
|
46 |c| c change
|
|
|
47 |d| d delete
|
|
|
48 |y| y yank into register (does not change the text)
|
|
|
49 |~| ~ swap case (only if 'tildeop' is set)
|
|
|
50 |g~| g~ swap case
|
|
|
51 |gu| gu make lowercase
|
|
|
52 |gU| gU make uppercase
|
|
|
53 |!| ! filter through an external program
|
|
|
54 |=| = filter through 'equalprg' or C-indenting if empty
|
|
|
55 |gq| gq text formatting
|
|
|
56 |g?| g? ROT13 encoding
|
|
|
57 |>| > shift right
|
|
|
58 |<| < shift left
|
|
|
59 |zf| zf define a fold
|
|
593
|
60 |g@| g@ call function set with the 'operatorfunc' option
|
|
7
|
61
|
|
|
62 If the motion includes a count and the operator also had a count before it,
|
|
|
63 the two counts are multiplied. For example: "2d3w" deletes six words.
|
|
|
64
|
|
|
65 After applying the operator the cursor is mostly left at the start of the text
|
|
|
66 that was operated upon. For example, "yfe" doesn't move the cursor, but "yFe"
|
|
|
67 moves the cursor leftwards to the "e" where the yank started.
|
|
|
68
|
|
|
69 *linewise* *characterwise*
|
|
|
70 The operator either affects whole lines, or the characters between the start
|
|
|
71 and end position. Generally, motions that move between lines affect lines
|
|
|
72 (are linewise), and motions that move within a line affect characters (are
|
|
|
73 characterwise). However, there are some exceptions.
|
|
|
74
|
|
|
75 *exclusive* *inclusive*
|
|
456
|
76 A character motion is either inclusive or exclusive. When inclusive, the
|
|
|
77 start and end position of the motion are included in the operation. When
|
|
|
78 exclusive, the last character towards the end of the buffer is not included.
|
|
|
79 Linewise motions always include the start and end position.
|
|
7
|
80
|
|
456
|
81 Which motions are linewise, inclusive or exclusive is mentioned with the
|
|
|
82 command. There are however, two general exceptions:
|
|
7
|
83 1. If the motion is exclusive and the end of the motion is in column 1, the
|
|
|
84 end of the motion is moved to the end of the previous line and the motion
|
|
|
85 becomes inclusive. Example: "}" moves to the first line after a paragraph,
|
|
|
86 but "d}" will not include that line.
|
|
20
|
87 *exclusive-linewise*
|
|
7
|
88 2. If the motion is exclusive, the end of the motion is in column 1 and the
|
|
|
89 start of the motion was at or before the first non-blank in the line, the
|
|
|
90 motion becomes linewise. Example: If a paragraph begins with some blanks
|
|
|
91 and you do "d}" while standing on the first non-blank, all the lines of
|
|
|
92 the paragraph are deleted, including the blanks. If you do a put now, the
|
|
|
93 deleted lines will be inserted below the cursor position.
|
|
|
94
|
|
|
95 Note that when the operator is pending (the operator command is typed, but the
|
|
|
96 motion isn't yet), a special set of mappings can be used. See |:omap|.
|
|
|
97
|
|
|
98 Instead of first giving the operator and then a motion you can use Visual
|
|
|
99 mode: mark the start of the text with "v", move the cursor to the end of the
|
|
|
100 text that is to be affected and then hit the operator. The text between the
|
|
|
101 start and the cursor position is highlighted, so you can see what text will
|
|
|
102 be operated upon. This allows much more freedom, but requires more key
|
|
|
103 strokes and has limited redo functionality. See the chapter on Visual mode
|
|
|
104 |Visual-mode|.
|
|
|
105
|
|
|
106 You can use a ":" command for a motion. For example "d:call FindEnd()".
|
|
|
107 But this can't be redone with "." if the command is more than one line.
|
|
|
108 This can be repeated: >
|
|
|
109 d:call search("f")<CR>
|
|
|
110 This cannot be repeated: >
|
|
|
111 d:if 1<CR>
|
|
|
112 call search("f")<CR>
|
|
|
113 endif<CR>
|
|
|
114
|
|
|
115
|
|
|
116 FORCING A MOTION TO BE LINEWISE, CHARACTERWISE OR BLOCKWISE
|
|
|
117
|
|
|
118 When a motion is not of the type you would like to use, you can force another
|
|
|
119 type by using "v", "V" or CTRL-V just after the operator.
|
|
|
120 Example: >
|
|
|
121 dj
|
|
|
122 deletes two lines >
|
|
|
123 dvj
|
|
|
124 deletes from the cursor position until the character below the cursor >
|
|
|
125 d<C-V>j
|
|
|
126 deletes the character under the cursor and the character below the cursor. >
|
|
|
127
|
|
|
128 Be careful with forcing a linewise movement to be used characterwise or
|
|
|
129 blockwise, the column may not always be defined.
|
|
|
130
|
|
|
131 *o_v*
|
|
|
132 v When used after an operator, before the motion command: Force
|
|
|
133 the operator to work characterwise, also when the motion is
|
|
|
134 linewise. If the motion was linewise, it will become
|
|
|
135 |exclusive|.
|
|
|
136 If the motion already was characterwise, toggle
|
|
|
137 inclusive/exclusive. This can be used to make an exclusive
|
|
|
138 motion inclusive and an inclusive motion exclusive.
|
|
|
139
|
|
|
140 *o_V*
|
|
|
141 V When used after an operator, before the motion command: Force
|
|
|
142 the operator to work linewise, also when the motion is
|
|
|
143 characterwise.
|
|
|
144
|
|
|
145 *o_CTRL-V*
|
|
|
146 CTRL-V When used after an operator, before the motion command: Force
|
|
|
147 the operator to work blockwise. This works like Visual block
|
|
|
148 mode selection, with the corners defined by the cursor
|
|
|
149 position before and after the motion.
|
|
|
150
|
|
|
151 ==============================================================================
|
|
|
152 2. Left-right motions *left-right-motions*
|
|
|
153
|
|
|
154 h or *h*
|
|
|
155 <Left> or *<Left>*
|
|
|
156 CTRL-H or *CTRL-H* *<BS>*
|
|
|
157 <BS> [count] characters to the left. |exclusive| motion.
|
|
|
158 Note: If you prefer <BS> to delete a character, use
|
|
|
159 the mapping:
|
|
|
160 :map CTRL-V<BS> X
|
|
|
161 (to enter "CTRL-V<BS>" type the CTRL-V key, followed
|
|
|
162 by the <BS> key)
|
|
|
163 See |:fixdel| if the <BS> key does not do what you
|
|
|
164 want.
|
|
|
165
|
|
|
166 l or *l*
|
|
|
167 <Right> or *<Right>* *<Space>*
|
|
|
168 <Space> [count] characters to the right. |exclusive| motion.
|
|
|
169
|
|
|
170 *0*
|
|
|
171 0 To the first character of the line. |exclusive|
|
|
1121
|
172 motion.
|
|
7
|
173
|
|
|
174 *<Home>* *<kHome>*
|
|
|
175 <Home> To the first character of the line. |exclusive|
|
|
1121
|
176 motion. When moving up or down next, stay in same
|
|
|
177 TEXT column (if possible). Most other commands stay
|
|
|
178 in the same SCREEN column. <Home> works like "1|",
|
|
|
179 which differs from "0" when the line starts with a
|
|
|
180 <Tab>. {not in Vi}
|
|
7
|
181
|
|
|
182 *^*
|
|
|
183 ^ To the first non-blank character of the line.
|
|
|
184 |exclusive| motion.
|
|
|
185
|
|
|
186 *$* *<End>* *<kEnd>*
|
|
|
187 $ or <End> To the end of the line. When a count is given also go
|
|
|
188 [count - 1] lines downward |inclusive|.
|
|
|
189 In Visual mode the cursor goes to just after the last
|
|
|
190 character in the line.
|
|
|
191 When 'virtualedit' is active, "$" may move the cursor
|
|
|
192 back from past the end of the line to the last
|
|
|
193 character in the line.
|
|
|
194
|
|
|
195 *g_*
|
|
|
196 g_ To the last non-blank character of the line and
|
|
|
197 [count - 1] lines downward |inclusive|. {not in Vi}
|
|
|
198
|
|
|
199 *g0* *g<Home>*
|
|
|
200 g0 or g<Home> When lines wrap ('wrap' on): To the first character of
|
|
|
201 the screen line. |exclusive| motion. Differs from
|
|
|
202 "0" when a line is wider than the screen.
|
|
|
203 When lines don't wrap ('wrap' off): To the leftmost
|
|
|
204 character of the current line that is on the screen.
|
|
|
205 Differs from "0" when the first character of the line
|
|
|
206 is not on the screen. {not in Vi}
|
|
|
207
|
|
|
208 *g^*
|
|
|
209 g^ When lines wrap ('wrap' on): To the first non-blank
|
|
|
210 character of the screen line. |exclusive| motion.
|
|
|
211 Differs from "^" when a line is wider than the screen.
|
|
|
212 When lines don't wrap ('wrap' off): To the leftmost
|
|
|
213 non-blank character of the current line that is on the
|
|
|
214 screen. Differs from "^" when the first non-blank
|
|
|
215 character of the line is not on the screen. {not in
|
|
|
216 Vi}
|
|
|
217
|
|
|
218 *gm*
|
|
|
219 gm Like "g0", but half a screenwidth to the right (or as
|
|
|
220 much as possible). {not in Vi}
|
|
|
221
|
|
|
222 *g$* *g<End>*
|
|
|
223 g$ or g<End> When lines wrap ('wrap' on): To the last character of
|
|
|
224 the screen line and [count - 1] screen lines downward
|
|
|
225 |inclusive|. Differs from "$" when a line is wider
|
|
|
226 than the screen.
|
|
|
227 When lines don't wrap ('wrap' off): To the rightmost
|
|
|
228 character of the current line that is visible on the
|
|
|
229 screen. Differs from "$" when the last character of
|
|
|
230 the line is not on the screen or when a count is used.
|
|
|
231 Additionally, vertical movements keep the column,
|
|
|
232 instead of going to the end of the line.
|
|
|
233 {not in Vi}
|
|
|
234
|
|
|
235 *bar*
|
|
|
236 | To screen column [count] in the current line.
|
|
|
237 |exclusive| motion.
|
|
|
238
|
|
|
239 *f*
|
|
|
240 f{char} To [count]'th occurrence of {char} to the right. The
|
|
|
241 cursor is placed on {char} |inclusive|.
|
|
|
242 {char} can be entered as a digraph |digraph-arg|.
|
|
|
243 When 'encoding' is set to Unicode, composing
|
|
|
244 characters may be used, see |utf-8-char-arg|.
|
|
|
245 |:lmap| mappings apply to {char}. The CTRL-^ command
|
|
|
246 in Insert mode can be used to switch this on/off
|
|
|
247 |i_CTRL-^|.
|
|
|
248
|
|
|
249 *F*
|
|
|
250 F{char} To the [count]'th occurrence of {char} to the left.
|
|
456
|
251 The cursor is placed on {char} |exclusive|.
|
|
7
|
252 {char} can be entered like with the |f| command.
|
|
|
253
|
|
|
254 *t*
|
|
|
255 t{char} Till before [count]'th occurrence of {char} to the
|
|
|
256 right. The cursor is placed on the character left of
|
|
|
257 {char} |inclusive|.
|
|
|
258 {char} can be entered like with the |f| command.
|
|
|
259
|
|
|
260 *T*
|
|
|
261 T{char} Till after [count]'th occurrence of {char} to the
|
|
|
262 left. The cursor is placed on the character right of
|
|
456
|
263 {char} |exclusive|.
|
|
7
|
264 {char} can be entered like with the |f| command.
|
|
|
265
|
|
|
266 *;*
|
|
|
267 ; Repeat latest f, t, F or T [count] times.
|
|
|
268
|
|
|
269 *,*
|
|
|
270 , Repeat latest f, t, F or T in opposite direction
|
|
|
271 [count] times.
|
|
|
272
|
|
|
273 These commands move the cursor to the specified column in the current line.
|
|
|
274 They stop at the first column and at the end of the line, except "$", which
|
|
|
275 may move to one of the next lines. See 'whichwrap' option to make some of the
|
|
|
276 commands move across line boundaries.
|
|
|
277
|
|
|
278 ==============================================================================
|
|
|
279 3. Up-down motions *up-down-motions*
|
|
|
280
|
|
|
281 k or *k*
|
|
|
282 <Up> or *<Up>* *CTRL-P*
|
|
|
283 CTRL-P [count] lines upward |linewise|.
|
|
|
284
|
|
|
285 j or *j*
|
|
|
286 <Down> or *<Down>*
|
|
|
287 CTRL-J or *CTRL-J*
|
|
|
288 <NL> or *<NL>* *CTRL-N*
|
|
|
289 CTRL-N [count] lines downward |linewise|.
|
|
|
290
|
|
|
291 gk or *gk* *g<Up>*
|
|
|
292 g<Up> [count] display lines upward. |exclusive| motion.
|
|
|
293 Differs from 'k' when lines wrap, and when used with
|
|
|
294 an operator, because it's not linewise. {not in Vi}
|
|
|
295
|
|
|
296 gj or *gj* *g<Down>*
|
|
|
297 g<Down> [count] display lines downward. |exclusive| motion.
|
|
|
298 Differs from 'j' when lines wrap, and when used with
|
|
|
299 an operator, because it's not linewise. {not in Vi}
|
|
|
300
|
|
|
301 *-*
|
|
|
302 - <minus> [count] lines upward, on the first non-blank
|
|
|
303 character |linewise|.
|
|
|
304
|
|
|
305 + or *+*
|
|
|
306 CTRL-M or *CTRL-M* *<CR>*
|
|
|
307 <CR> [count] lines downward, on the first non-blank
|
|
|
308 character |linewise|.
|
|
|
309
|
|
|
310 *_*
|
|
|
311 _ <underscore> [count] - 1 lines downward, on the first non-blank
|
|
|
312 character |linewise|.
|
|
|
313
|
|
|
314 *G*
|
|
|
315 G Goto line [count], default last line, on the first
|
|
|
316 non-blank character |linewise|. If 'startofline' not
|
|
|
317 set, keep the same column.
|
|
|
318
|
|
|
319 *<C-End>*
|
|
|
320 <C-End> Goto line [count], default last line, on the last
|
|
|
321 character |inclusive|. {not in Vi}
|
|
|
322
|
|
|
323 <C-Home> or *gg* *<C-Home>*
|
|
|
324 gg Goto line [count], default first line, on the first
|
|
|
325 non-blank character |linewise|. If 'startofline' not
|
|
|
326 set, keep the same column.
|
|
|
327
|
|
|
328 :[range] Set the cursor on the specified line number. If
|
|
|
329 there are several numbers, the last one is used.
|
|
|
330
|
|
|
331 *N%*
|
|
|
332 {count}% Go to {count} percentage in the file, on the first
|
|
|
333 non-blank in the line |linewise|. To compute the new
|
|
|
334 line number this formula is used:
|
|
|
335 ({count} * number-of-lines + 99) / 100
|
|
|
336 See also 'startofline' option. {not in Vi}
|
|
|
337
|
|
|
338 :[range]go[to] [count] *:go* *:goto* *go*
|
|
|
339 [count]go Go to {count} byte in the buffer. Default [count] is
|
|
|
340 one, start of the file. When giving [range], the
|
|
|
341 last number in it used as the byte count. End-of-line
|
|
|
342 characters are counted depending on the current
|
|
|
343 'fileformat' setting.
|
|
|
344 {not in Vi}
|
|
|
345 {not available when compiled without the
|
|
|
346 |+byte_offset| feature}
|
|
|
347
|
|
|
348 These commands move to the specified line. They stop when reaching the first
|
|
|
349 or the last line. The first two commands put the cursor in the same column
|
|
|
350 (if possible) as it was after the last command that changed the column,
|
|
|
351 except after the "$" command, then the cursor will be put on the last
|
|
|
352 character of the line.
|
|
|
353
|
|
161
|
354 If "k", "-" or CTRL-P is used with a [count] and there are less than [count]
|
|
|
355 lines above the cursor and the 'cpo' option includes the "-" flag it is an
|
|
|
356 error. |cpo--|.
|
|
|
357
|
|
7
|
358 ==============================================================================
|
|
|
359 4. Word motions *word-motions*
|
|
|
360
|
|
|
361 <S-Right> or *<S-Right>* *w*
|
|
|
362 w [count] words forward. |exclusive| motion.
|
|
|
363
|
|
|
364 <C-Right> or *<C-Right>* *W*
|
|
|
365 W [count] WORDS forward. |exclusive| motion.
|
|
|
366
|
|
|
367 *e*
|
|
|
368 e Forward to the end of word [count] |inclusive|.
|
|
1621
|
369 Does not stop in an empty line.
|
|
7
|
370
|
|
|
371 *E*
|
|
|
372 E Forward to the end of WORD [count] |inclusive|.
|
|
1621
|
373 Does not stop in an empty line.
|
|
7
|
374
|
|
|
375 <S-Left> or *<S-Left>* *b*
|
|
|
376 b [count] words backward. |exclusive| motion.
|
|
|
377
|
|
|
378 <C-Left> or *<C-Left>* *B*
|
|
|
379 B [count] WORDS backward. |exclusive| motion.
|
|
|
380
|
|
|
381 *ge*
|
|
|
382 ge Backward to the end of word [count] |inclusive|.
|
|
|
383
|
|
|
384 *gE*
|
|
|
385 gE Backward to the end of WORD [count] |inclusive|.
|
|
|
386
|
|
|
387 These commands move over words or WORDS.
|
|
|
388 *word*
|
|
|
389 A word consists of a sequence of letters, digits and underscores, or a
|
|
|
390 sequence of other non-blank characters, separated with white space (spaces,
|
|
625
|
391 tabs, <EOL>). This can be changed with the 'iskeyword' option. An empty line
|
|
|
392 is also considered to be a word.
|
|
7
|
393 *WORD*
|
|
|
394 A WORD consists of a sequence of non-blank characters, separated with white
|
|
625
|
395 space. An empty line is also considered to be a WORD.
|
|
7
|
396
|
|
|
397 A sequence of folded lines is counted for one word of a single character.
|
|
|
398 "w" and "W", "e" and "E" move to the start/end of the first word or WORD after
|
|
|
399 a range of folded lines. "b" and "B" move to the start of the first word or
|
|
|
400 WORD before the fold.
|
|
|
401
|
|
|
402 Special case: "cw" and "cW" are treated like "ce" and "cE" if the cursor is
|
|
|
403 on a non-blank. This is because "cw" is interpreted as change-word, and a
|
|
|
404 word does not include the following white space. {Vi: "cw" when on a blank
|
|
|
405 followed by other blanks changes only the first blank; this is probably a
|
|
|
406 bug, because "dw" deletes all the blanks}
|
|
|
407
|
|
|
408 Another special case: When using the "w" motion in combination with an
|
|
|
409 operator and the last word moved over is at the end of a line, the end of
|
|
|
410 that word becomes the end of the operated text, not the first word in the
|
|
|
411 next line.
|
|
|
412
|
|
|
413 The original Vi implementation of "e" is buggy. For example, the "e" command
|
|
|
414 will stop on the first character of a line if the previous line was empty.
|
|
|
415 But when you use "2e" this does not happen. In Vim "ee" and "2e" are the
|
|
|
416 same, which is more logical. However, this causes a small incompatibility
|
|
|
417 between Vi and Vim.
|
|
|
418
|
|
|
419 ==============================================================================
|
|
|
420 5. Text object motions *object-motions*
|
|
|
421
|
|
|
422 *(*
|
|
|
423 ( [count] sentences backward. |exclusive| motion.
|
|
|
424
|
|
|
425 *)*
|
|
|
426 ) [count] sentences forward. |exclusive| motion.
|
|
|
427
|
|
|
428 *{*
|
|
|
429 { [count] paragraphs backward. |exclusive| motion.
|
|
|
430
|
|
|
431 *}*
|
|
|
432 } [count] paragraphs forward. |exclusive| motion.
|
|
|
433
|
|
|
434 *]]*
|
|
|
435 ]] [count] sections forward or to the next '{' in the
|
|
20
|
436 first column. When used after an operator, then also
|
|
|
437 stops below a '}' in the first column. |exclusive|
|
|
|
438 Note that |exclusive-linewise| often applies.
|
|
7
|
439
|
|
|
440 *][*
|
|
|
441 ][ [count] sections forward or to the next '}' in the
|
|
20
|
442 first column. |exclusive|
|
|
|
443 Note that |exclusive-linewise| often applies.
|
|
7
|
444
|
|
|
445 *[[*
|
|
|
446 [[ [count] sections backward or to the previous '{' in
|
|
20
|
447 the first column. |exclusive|
|
|
|
448 Note that |exclusive-linewise| often applies.
|
|
7
|
449
|
|
|
450 *[]*
|
|
|
451 [] [count] sections backward or to the previous '}' in
|
|
20
|
452 the first column. |exclusive|
|
|
|
453 Note that |exclusive-linewise| often applies.
|
|
7
|
454
|
|
|
455 These commands move over three kinds of text objects.
|
|
|
456
|
|
|
457 *sentence*
|
|
|
458 A sentence is defined as ending at a '.', '!' or '?' followed by either the
|
|
|
459 end of a line, or by a space or tab. Any number of closing ')', ']', '"'
|
|
|
460 and ''' characters may appear after the '.', '!' or '?' before the spaces,
|
|
|
461 tabs or end of line. A paragraph and section boundary is also a sentence
|
|
|
462 boundary.
|
|
|
463 If the 'J' flag is present in 'cpoptions', at least two spaces have to
|
|
|
464 follow the punctuation mark; <Tab>s are not recognized as white space.
|
|
|
465 The definition of a sentence cannot be changed.
|
|
|
466
|
|
|
467 *paragraph*
|
|
|
468 A paragraph begins after each empty line, and also at each of a set of
|
|
|
469 paragraph macros, specified by the pairs of characters in the 'paragraphs'
|
|
1621
|
470 option. The default is "IPLPPPQPP TPHPLIPpLpItpplpipbp", which corresponds to
|
|
|
471 the macros ".IP", ".LP", etc. (These are nroff macros, so the dot must be in
|
|
|
472 the first column). A section boundary is also a paragraph boundary.
|
|
164
|
473 Note that a blank line (only containing white space) is NOT a paragraph
|
|
|
474 boundary.
|
|
|
475 Also note that this does not include a '{' or '}' in the first column. When
|
|
|
476 the '{' flag is in 'cpoptions' then '{' in the first column is used as a
|
|
|
477 paragraph boundary |posix|.
|
|
7
|
478
|
|
|
479 *section*
|
|
|
480 A section begins after a form-feed (<C-L>) in the first column and at each of
|
|
|
481 a set of section macros, specified by the pairs of characters in the
|
|
|
482 'sections' option. The default is "SHNHH HUnhsh", which defines a section to
|
|
|
483 start at the nroff macros ".SH", ".NH", ".H", ".HU", ".nh" and ".sh".
|
|
|
484
|
|
|
485 The "]" and "[" commands stop at the '{' or '}' in the first column. This is
|
|
|
486 useful to find the start or end of a function in a C program. Note that the
|
|
|
487 first character of the command determines the search direction and the
|
|
|
488 second character the type of brace found.
|
|
|
489
|
|
|
490 If your '{' or '}' are not in the first column, and you would like to use "[["
|
|
|
491 and "]]" anyway, try these mappings: >
|
|
|
492 :map [[ ?{<CR>w99[{
|
|
|
493 :map ][ /}<CR>b99]}
|
|
|
494 :map ]] j0[[%/{<CR>
|
|
|
495 :map [] k$][%?}<CR>
|
|
|
496 [type these literally, see |<>|]
|
|
|
497
|
|
|
498 ==============================================================================
|
|
|
499 6. Text object selection *object-select* *text-objects*
|
|
|
500 *v_a* *v_i*
|
|
|
501
|
|
|
502 This is a series of commands that can only be used while in Visual mode or
|
|
|
503 after an operator. The commands that start with "a" select "a"n object
|
|
|
504 including white space, the commands starting with "i" select an "inner" object
|
|
|
505 without white space, or just the white space. Thus the "inner" commands
|
|
|
506 always select less text than the "a" commands.
|
|
|
507
|
|
|
508 These commands are {not in Vi}.
|
|
|
509 These commands are not available when the |+textobjects| feature has been
|
|
|
510 disabled at compile time.
|
|
|
511 *v_aw* *aw*
|
|
|
512 aw "a word", select [count] words (see |word|).
|
|
|
513 Leading or trailing white space is included, but not
|
|
|
514 counted.
|
|
|
515 When used in Visual linewise mode "aw" switches to
|
|
|
516 Visual characterwise mode.
|
|
|
517
|
|
|
518 *v_iw* *iw*
|
|
|
519 iw "inner word", select [count] words (see |word|).
|
|
|
520 White space between words is counted too.
|
|
|
521 When used in Visual linewise mode "iw" switches to
|
|
|
522 Visual characterwise mode.
|
|
|
523
|
|
|
524 *v_aW* *aW*
|
|
|
525 aW "a WORD", select [count] WORDs (see |WORD|).
|
|
|
526 Leading or trailing white space is included, but not
|
|
|
527 counted.
|
|
|
528 When used in Visual linewise mode "aW" switches to
|
|
|
529 Visual characterwise mode.
|
|
|
530
|
|
|
531 *v_iW* *iW*
|
|
|
532 iW "inner WORD", select [count] WORDs (see |WORD|).
|
|
|
533 White space between words is counted too.
|
|
|
534 When used in Visual linewise mode "iW" switches to
|
|
|
535 Visual characterwise mode.
|
|
|
536
|
|
|
537 *v_as* *as*
|
|
|
538 as "a sentence", select [count] sentences (see
|
|
|
539 |sentence|).
|
|
|
540 When used in Visual mode it is made characterwise.
|
|
|
541
|
|
|
542 *v_is* *is*
|
|
|
543 is "inner sentence", select [count] sentences (see
|
|
|
544 |sentence|).
|
|
|
545 When used in Visual mode it is made characterwise.
|
|
|
546
|
|
|
547 *v_ap* *ap*
|
|
|
548 ap "a paragraph", select [count] paragraphs (see
|
|
|
549 |paragraph|).
|
|
|
550 Exception: a blank line (only containing white space)
|
|
|
551 is also a paragraph boundary.
|
|
|
552 When used in Visual mode it is made linewise.
|
|
|
553
|
|
|
554 *v_ip* *ip*
|
|
|
555 ip "inner paragraph", select [count] paragraphs (see
|
|
|
556 |paragraph|).
|
|
|
557 Exception: a blank line (only containing white space)
|
|
|
558 is also a paragraph boundary.
|
|
|
559 When used in Visual mode it is made linewise.
|
|
|
560
|
|
|
561 a] *v_a]* *v_a[* *a]* *a[*
|
|
|
562 a[ "a [] block", select [count] '[' ']' blocks. This
|
|
|
563 goes backwards to the [count] unclosed '[', and finds
|
|
|
564 the matching ']'. The enclosed text is selected,
|
|
|
565 including the '[' and ']'.
|
|
|
566 When used in Visual mode it is made characterwise.
|
|
|
567
|
|
|
568 i] *v_i]* *v_i[* *i]* *i[*
|
|
|
569 i[ "inner [] block", select [count] '[' ']' blocks. This
|
|
|
570 goes backwards to the [count] unclosed '[', and finds
|
|
|
571 the matching ']'. The enclosed text is selected,
|
|
|
572 excluding the '[' and ']'.
|
|
|
573 When used in Visual mode it is made characterwise.
|
|
|
574
|
|
|
575 a) *v_a)* *a)* *a(*
|
|
|
576 a( *v_ab* *v_a(* *ab*
|
|
|
577 ab "a block", select [count] blocks, from "[count] [(" to
|
|
|
578 the matching ')', including the '(' and ')' (see
|
|
|
579 |[(|). Does not include white space outside of the
|
|
|
580 parenthesis.
|
|
|
581 When used in Visual mode it is made characterwise.
|
|
|
582
|
|
|
583 i) *v_i)* *i)* *i(*
|
|
|
584 i( *v_ib* *v_i(* *ib*
|
|
|
585 ib "inner block", select [count] blocks, from "[count] [("
|
|
|
586 to the matching ')', excluding the '(' and ')' (see
|
|
|
587 |[(|).
|
|
|
588 When used in Visual mode it is made characterwise.
|
|
|
589
|
|
|
590 a> *v_a>* *v_a<* *a>* *a<*
|
|
|
591 a< "a <> block", select [count] <> blocks, from the
|
|
|
592 [count]'th unmatched '<' backwards to the matching
|
|
|
593 '>', including the '<' and '>'.
|
|
|
594 When used in Visual mode it is made characterwise.
|
|
|
595
|
|
|
596 i> *v_i>* *v_i<* *i>* *i<*
|
|
|
597 i< "inner <> block", select [count] <> blocks, from
|
|
|
598 the [count]'th unmatched '<' backwards to the matching
|
|
|
599 '>', excluding the '<' and '>'.
|
|
|
600 When used in Visual mode it is made characterwise.
|
|
|
601
|
|
422
|
602 *v_at* *at*
|
|
|
603 at "a tag block", select [count] tag blocks, from the
|
|
|
604 [count]'th unmatched "<aaa>" backwards to the matching
|
|
|
605 "</aaa>", including the "<aaa>" and "</aaa>".
|
|
|
606 See |tag-blocks| about the details.
|
|
|
607 When used in Visual mode it is made characterwise.
|
|
|
608
|
|
|
609 *v_it* *it*
|
|
|
610 it "inner tag block", select [count] tag blocks, from the
|
|
|
611 [count]'th unmatched "<aaa>" backwards to the matching
|
|
|
612 "</aaa>", excluding the "<aaa>" and "</aaa>".
|
|
|
613 See |tag-blocks| about the details.
|
|
|
614 When used in Visual mode it is made characterwise.
|
|
|
615
|
|
7
|
616 a} *v_a}* *a}* *a{*
|
|
|
617 a{ *v_aB* *v_a{* *aB*
|
|
|
618 aB "a Block", select [count] Blocks, from "[count] [{" to
|
|
|
619 the matching '}', including the '{' and '}' (see
|
|
|
620 |[{|).
|
|
|
621 When used in Visual mode it is made characterwise.
|
|
|
622
|
|
|
623 i} *v_i}* *i}* *i{*
|
|
|
624 i{ *v_iB* *v_i{* *iB*
|
|
|
625 iB "inner Block", select [count] Blocks, from "[count] [{"
|
|
|
626 to the matching '}', excluding the '{' and '}' (see
|
|
|
627 |[{|).
|
|
|
628 When used in Visual mode it is made characterwise.
|
|
|
629
|
|
12
|
630 a" *v_aquote* *aquote*
|
|
|
631 a' *v_a'* *a'*
|
|
|
632 a` *v_a`* *a`*
|
|
|
633 "a quoted string". Selects the text from the previous
|
|
849
|
634 quote until the next quote. The 'quoteescape' option
|
|
|
635 is used to skip escaped quotes.
|
|
|
636 Only works within one line.
|
|
12
|
637 When the cursor starts on a quote, Vim will figure out
|
|
|
638 which quote pairs form a string by searching from the
|
|
|
639 start of the line.
|
|
|
640 Any trailing or leading white space is included.
|
|
|
641 When used in Visual mode it is made characterwise.
|
|
|
642 Repeating this object in Visual mode another string is
|
|
|
643 included. A count is currently not used.
|
|
|
644
|
|
|
645 i" *v_iquote* *iquote*
|
|
|
646 i' *v_i'* *i'*
|
|
|
647 i` *v_i`* *i`*
|
|
|
648 Like a", a' and a`, but exclude the quotes and
|
|
|
649 repeating won't extend the Visual selection.
|
|
527
|
650 Special case: With a count of 2 the quotes are
|
|
|
651 included, but no extra white space as with a"/a'/a`.
|
|
12
|
652
|
|
7
|
653 When used after an operator:
|
|
|
654 For non-block objects:
|
|
|
655 For the "a" commands: The operator applies to the object and the white
|
|
|
656 space after the object. If there is no white space after the object
|
|
|
657 or when the cursor was in the white space before the object, the white
|
|
|
658 space before the object is included.
|
|
|
659 For the "inner" commands: If the cursor was on the object, the
|
|
|
660 operator applies to the object. If the cursor was on white space, the
|
|
|
661 operator applies to the white space.
|
|
|
662 For a block object:
|
|
|
663 The operator applies to the block where the cursor is in, or the block
|
|
|
664 on which the cursor is on one of the braces. For the "inner" commands
|
|
|
665 the surrounding braces are excluded. For the "a" commands, the braces
|
|
|
666 are included.
|
|
|
667
|
|
|
668 When used in Visual mode:
|
|
|
669 When start and end of the Visual area are the same (just after typing "v"):
|
|
|
670 One object is selected, the same as for using an operator.
|
|
|
671 When start and end of the Visual area are not the same:
|
|
|
672 For non-block objects the area is extended by one object or the white
|
|
|
673 space up to the next object, or both for the "a" objects. The
|
|
|
674 direction in which this happens depends on which side of the Visual
|
|
|
675 area the cursor is. For the block objects the block is extended one
|
|
|
676 level outwards.
|
|
|
677
|
|
|
678 For illustration, here is a list of delete commands, grouped from small to big
|
|
|
679 objects. Note that for a single character and a whole line the existing vi
|
|
|
680 movement commands are used.
|
|
|
681 "dl" delete character (alias: "x") |dl|
|
|
|
682 "diw" delete inner word *diw*
|
|
|
683 "daw" delete a word *daw*
|
|
|
684 "diW" delete inner WORD (see |WORD|) *diW*
|
|
|
685 "daW" delete a WORD (see |WORD|) *daW*
|
|
|
686 "dd" delete one line |dd|
|
|
|
687 "dis" delete inner sentence *dis*
|
|
|
688 "das" delete a sentence *das*
|
|
|
689 "dib" delete inner '(' ')' block *dib*
|
|
|
690 "dab" delete a '(' ')' block *dab*
|
|
|
691 "dip" delete inner paragraph *dip*
|
|
|
692 "dap" delete a paragraph *dap*
|
|
|
693 "diB" delete inner '{' '}' block *diB*
|
|
|
694 "daB" delete a '{' '}' block *daB*
|
|
|
695
|
|
|
696 Note the difference between using a movement command and an object. The
|
|
|
697 movement command operates from here (cursor position) to where the movement
|
|
|
698 takes us. When using an object the whole object is operated upon, no matter
|
|
|
699 where on the object the cursor is. For example, compare "dw" and "daw": "dw"
|
|
|
700 deletes from the cursor position to the start of the next word, "daw" deletes
|
|
|
701 the word under the cursor and the space after or before it.
|
|
|
702
|
|
422
|
703
|
|
|
704 Tag blocks *tag-blocks*
|
|
|
705
|
|
|
706 For the "it" and "at" text objects an attempt is done to select blocks between
|
|
|
707 matching tags for HTML and XML. But since these are not completely compatible
|
|
|
708 there are a few restrictions.
|
|
|
709
|
|
|
710 The normal method is to select a <tag> until the matching </tag>. For "at"
|
|
|
711 the tags are included, for "it" they are excluded. But when "it" is repeated
|
|
853
|
712 the tags will be included (otherwise nothing would change). Also, "it" used
|
|
|
713 on a tag block with no contents will select the leading tag.
|
|
422
|
714
|
|
|
715 "<aaa/>" items are skipped. Case is ignored, also for XML where case does
|
|
|
716 matter.
|
|
|
717
|
|
|
718 In HTML it is possible to have a tag like <br> or <meta ...> without a
|
|
|
719 matching end tag. These are ignored.
|
|
|
720
|
|
|
721 The text objects are tolerant about mistakes. Stray end tags are ignored.
|
|
|
722
|
|
7
|
723 ==============================================================================
|
|
|
724 7. Marks *mark-motions* *E20* *E78*
|
|
|
725
|
|
|
726 Jumping to a mark can be done in two ways:
|
|
|
727 1. With ` (backtick): The cursor is positioned at the specified location
|
|
|
728 and the motion is |exclusive|.
|
|
|
729 2. With ' (single quote): The cursor is positioned on the first non-blank
|
|
|
730 character in the line of the specified location and
|
|
|
731 the motion is linewise.
|
|
|
732
|
|
|
733 *m* *mark* *Mark*
|
|
|
734 m{a-zA-Z} Set mark {a-zA-Z} at cursor position (does not move
|
|
|
735 the cursor, this is not a motion command).
|
|
|
736
|
|
|
737 *m'* *m`*
|
|
|
738 m' or m` Set the previous context mark. This can be jumped to
|
|
|
739 with the "''" or "``" command (does not move the
|
|
|
740 cursor, this is not a motion command).
|
|
|
741
|
|
|
742 *m[* *m]*
|
|
|
743 m[ or m] Set the |'[| or |']| mark. Useful when an operator is
|
|
|
744 to be simulated by multiple commands. (does not move
|
|
|
745 the cursor, this is not a motion command).
|
|
|
746
|
|
|
747 *:ma* *:mark* *E191*
|
|
9
|
748 :[range]ma[rk] {a-zA-Z'}
|
|
|
749 Set mark {a-zA-Z'} at last line number in [range],
|
|
7
|
750 column 0. Default is cursor line.
|
|
|
751
|
|
|
752 *:k*
|
|
9
|
753 :[range]k{a-zA-Z'} Same as :mark, but the space before the mark name can
|
|
7
|
754 be omitted.
|
|
|
755
|
|
|
756 *'* *'a* *`* *`a*
|
|
1121
|
757 '{a-z} `{a-z} Jump to the mark {a-z} in the current buffer.
|
|
7
|
758
|
|
|
759 *'A* *'0* *`A* *`0*
|
|
1121
|
760 '{A-Z0-9} `{A-Z0-9} To the mark {A-Z0-9} in the file where it was set (not
|
|
|
761 a motion command when in another file). {not in Vi}
|
|
7
|
762
|
|
|
763 *g'* *g'a* *g`* *g`a*
|
|
|
764 g'{mark} g`{mark}
|
|
|
765 Jump to the {mark}, but don't change the jumplist when
|
|
|
766 jumping within the current buffer. Example: >
|
|
|
767 g`"
|
|
|
768 < jumps to the last known position in a file. See
|
|
9
|
769 $VIMRUNTIME/vimrc_example.vim.
|
|
|
770 Also see |:keepjumps|.
|
|
|
771 {not in Vi}
|
|
7
|
772
|
|
|
773 *:marks*
|
|
|
774 :marks List all the current marks (not a motion command).
|
|
|
775 The |'(|, |')|, |'{| and |'}| marks are not listed.
|
|
843
|
776 The first column has number zero.
|
|
7
|
777 {not in Vi}
|
|
|
778 *E283*
|
|
|
779 :marks {arg} List the marks that are mentioned in {arg} (not a
|
|
|
780 motion command). For example: >
|
|
|
781 :marks aB
|
|
|
782 < to list marks 'a' and 'B'. {not in Vi}
|
|
|
783
|
|
24
|
784 *:delm* *:delmarks*
|
|
856
|
785 :delm[arks] {marks} Delete the specified marks. Marks that can be deleted
|
|
24
|
786 include A-Z and 0-9. You cannot delete the ' mark.
|
|
|
787 They can be specified by giving the list of mark
|
|
|
788 names, or with a range, separated with a dash. Spaces
|
|
|
789 are ignored. Examples: >
|
|
|
790 :delmarks a deletes mark a
|
|
|
791 :delmarks a b 1 deletes marks a, b and 1
|
|
|
792 :delmarks Aa deletes marks A and a
|
|
|
793 :delmarks p-z deletes marks in the range p to z
|
|
|
794 :delmarks ^.[] deletes marks ^ . [ ]
|
|
|
795 :delmarks \" deletes mark "
|
|
|
796 < {not in Vi}
|
|
|
797
|
|
|
798 :delm[arks]! Delete all marks for the current buffer, but not marks
|
|
|
799 A-Z or 0-9.
|
|
|
800 {not in Vi}
|
|
|
801
|
|
7
|
802 A mark is not visible in any way. It is just a position in the file that is
|
|
|
803 remembered. Do not confuse marks with named registers, they are totally
|
|
|
804 unrelated.
|
|
|
805
|
|
|
806 'a - 'z lowercase marks, valid within one file
|
|
|
807 'A - 'Z uppercase marks, also called file marks, valid between files
|
|
|
808 '0 - '9 numbered marks, set from .viminfo file
|
|
|
809
|
|
|
810 Lowercase marks 'a to 'z are remembered as long as the file remains in the
|
|
|
811 buffer list. If you remove the file from the buffer list, all its marks are
|
|
|
812 lost. If you delete a line that contains a mark, that mark is erased.
|
|
|
813
|
|
|
814 Lowercase marks can be used in combination with operators. For example: "d't"
|
|
|
815 deletes the lines from the cursor position to mark 't'. Hint: Use mark 't' for
|
|
|
816 Top, 'b' for Bottom, etc.. Lowercase marks are restored when using undo and
|
|
|
817 redo.
|
|
|
818
|
|
|
819 Uppercase marks 'A to 'Z include the file name. {Vi: no uppercase marks} You
|
|
|
820 can use them to jump from file to file. You can only use an uppercase mark
|
|
|
821 with an operator if the mark is in the current file. The line number of the
|
|
|
822 mark remains correct, even if you insert/delete lines or edit another file for
|
|
|
823 a moment. When the 'viminfo' option is not empty, uppercase marks are kept in
|
|
|
824 the .viminfo file. See |viminfo-file-marks|.
|
|
|
825
|
|
|
826 Numbered marks '0 to '9 are quite different. They can not be set directly.
|
|
|
827 They are only present when using a viminfo file |viminfo-file|. Basically '0
|
|
|
828 is the location of the cursor when you last exited Vim, '1 the last but one
|
|
|
829 time, etc. Use the "r" flag in 'viminfo' to specify files for which no
|
|
|
830 Numbered mark should be stored. See |viminfo-file-marks|.
|
|
|
831
|
|
|
832
|
|
|
833 *'[* *`[*
|
|
|
834 '[ `[ To the first character of the previously changed
|
|
|
835 or yanked text. {not in Vi}
|
|
|
836
|
|
|
837 *']* *`]*
|
|
|
838 '] `] To the last character of the previously changed or
|
|
|
839 yanked text. {not in Vi}
|
|
|
840
|
|
|
841 After executing an operator the Cursor is put at the beginning of the text
|
|
|
842 that was operated upon. After a put command ("p" or "P") the cursor is
|
|
|
843 sometimes placed at the first inserted line and sometimes on the last inserted
|
|
|
844 character. The four commands above put the cursor at either end. Example:
|
|
|
845 After yanking 10 lines you want to go to the last one of them: "10Y']". After
|
|
|
846 inserting several lines with the "p" command you want to jump to the lowest
|
|
|
847 inserted line: "p']". This also works for text that has been inserted.
|
|
|
848
|
|
|
849 Note: After deleting text, the start and end positions are the same, except
|
|
|
850 when using blockwise Visual mode. These commands do not work when no change
|
|
|
851 was made yet in the current file.
|
|
|
852
|
|
|
853 *'<* *`<*
|
|
1698
|
854 '< `< To the first line or character of the last selected
|
|
|
855 Visual area in the current buffer. For block mode it
|
|
|
856 may also be the last character in the first line (to
|
|
|
857 be able to define the block). {not in Vi}.
|
|
7
|
858
|
|
|
859 *'>* *`>*
|
|
1698
|
860 '> `> To the last line or character of the last selected
|
|
|
861 Visual area in the current buffer. For block mode it
|
|
|
862 may also be the first character of the last line (to
|
|
|
863 be able to define the block). Note that 'selection'
|
|
856
|
864 applies, the position may be just after the Visual
|
|
|
865 area. {not in Vi}.
|
|
7
|
866
|
|
|
867 *''* *``*
|
|
36
|
868 '' `` To the position before the latest jump, or where the
|
|
|
869 last "m'" or "m`" command was given. Not set when the
|
|
7
|
870 |:keepjumps| command modifier was used.
|
|
|
871 Also see |restore-position|.
|
|
|
872
|
|
|
873 *'quote* *`quote*
|
|
|
874 '" `" To the cursor position when last exiting the current
|
|
|
875 buffer. Defaults to the first character of the first
|
|
|
876 line. See |last-position-jump| for how to use this
|
|
|
877 for each opened file.
|
|
|
878 Only one position is remembered per buffer, not one
|
|
|
879 for each window. As long as the buffer is visible in
|
|
|
880 a window the position won't be changed.
|
|
|
881 {not in Vi}.
|
|
|
882
|
|
|
883 *'^* *`^*
|
|
|
884 '^ `^ To the position where the cursor was the last time
|
|
42
|
885 when Insert mode was stopped. This is used by the
|
|
|
886 |gi| command. Not set when the |:keepjumps| command
|
|
7
|
887 modifier was used. {not in Vi}
|
|
|
888
|
|
|
889 *'.* *`.*
|
|
|
890 '. `. To the position where the last change was made. The
|
|
|
891 position is at or near where the change started.
|
|
|
892 Sometimes a command is executed as several changes,
|
|
|
893 then the position can be near the end of what the
|
|
|
894 command changed. For example when inserting a word,
|
|
|
895 the position will be on the last character.
|
|
|
896 {not in Vi}
|
|
|
897
|
|
|
898 *'(* *`(*
|
|
|
899 '( `( To the start of the current sentence, like the |(|
|
|
|
900 command. {not in Vi}
|
|
|
901
|
|
|
902 *')* *`)*
|
|
|
903 ') `) To the end of the current sentence, like the |)|
|
|
|
904 command. {not in Vi}
|
|
|
905
|
|
|
906 *'{* *`{*
|
|
|
907 '{ `{ To the start of the current paragraph, like the |{|
|
|
|
908 command. {not in Vi}
|
|
|
909
|
|
|
910 *'}* *`}*
|
|
|
911 '} `} To the end of the current paragraph, like the |}|
|
|
|
912 command. {not in Vi}
|
|
|
913
|
|
|
914 These commands are not marks themselves, but jump to a mark:
|
|
|
915
|
|
|
916 *]'*
|
|
|
917 ]' [count] times to next line with a lowercase mark below
|
|
|
918 the cursor, on the first non-blank character in the
|
|
|
919 line. {not in Vi}
|
|
|
920
|
|
|
921 *]`*
|
|
|
922 ]` [count] times to lowercase mark after the cursor. {not
|
|
|
923 in Vi}
|
|
|
924
|
|
|
925 *['*
|
|
|
926 [' [count] times to previous line with a lowercase mark
|
|
|
927 before the cursor, on the first non-blank character in
|
|
|
928 the line. {not in Vi}
|
|
|
929
|
|
|
930 *[`*
|
|
|
931 [` [count] times to lowercase mark before the cursor.
|
|
|
932 {not in Vi}
|
|
|
933
|
|
|
934
|
|
|
935 :loc[kmarks] {command} *:loc* *:lockmarks*
|
|
|
936 Execute {command} without adjusting marks. This is
|
|
|
937 useful when changing text in a way that the line count
|
|
|
938 will be the same when the change has completed.
|
|
|
939 WARNING: When the line count does change, marks below
|
|
|
940 the change will keep their line number, thus move to
|
|
|
941 another text line.
|
|
|
942 These items will not be adjusted for deleted/inserted
|
|
|
943 lines:
|
|
|
944 - lower case letter marks 'a - 'z
|
|
|
945 - upper case letter marks 'A - 'Z
|
|
|
946 - numbered marks '0 - '9
|
|
|
947 - last insert position '^
|
|
|
948 - last change position '.
|
|
|
949 - the Visual area '< and '>
|
|
|
950 - line numbers in placed signs
|
|
|
951 - line numbers in quickfix positions
|
|
|
952 - positions in the |jumplist|
|
|
|
953 - positions in the |tagstack|
|
|
|
954 These items will still be adjusted:
|
|
|
955 - previous context mark ''
|
|
|
956 - the cursor position
|
|
|
957 - the view of a window on a buffer
|
|
|
958 - folds
|
|
|
959 - diffs
|
|
|
960
|
|
|
961 :kee[pmarks] {command} *:kee* *:keepmarks*
|
|
|
962 Currently only has effect for the filter command
|
|
|
963 |:range!|:
|
|
|
964 - When the number of lines after filtering is equal to
|
|
|
965 or larger than before, all marks are kept at the
|
|
|
966 same line number.
|
|
|
967 - When the number of lines decreases, the marks in the
|
|
9
|
968 lines that disappeared are deleted.
|
|
7
|
969 In any case the marks below the filtered text have
|
|
|
970 their line numbers adjusted, thus stick to the text,
|
|
|
971 as usual.
|
|
|
972 When the 'R' flag is missing from 'cpoptions' this has
|
|
|
973 the same effect as using ":keepmarks".
|
|
|
974
|
|
|
975 *:keepj* *:keepjumps*
|
|
|
976 :keepj[umps] {command}
|
|
9
|
977 Moving around in {command} does not change the |''|,
|
|
|
978 |'.| and |'^| marks, the |jumplist| or the
|
|
|
979 |changelist|.
|
|
|
980 Useful when making a change or inserting text
|
|
|
981 automatically and the user doesn't want to go to this
|
|
|
982 position. E.g., when updating a "Last change"
|
|
|
983 timestamp in the first line: >
|
|
|
984
|
|
586
|
985 :let lnum = line(".")
|
|
9
|
986 :keepjumps normal gg
|
|
|
987 :call SetLastChange()
|
|
|
988 :keepjumps exe "normal " . lnum . "G"
|
|
|
989 <
|
|
|
990 Note that ":keepjumps" must be used for every command.
|
|
|
991 When invoking a function the commands in that function
|
|
856
|
992 can still change the jumplist. Also, for
|
|
85
|
993 ":keepjumps exe 'command '" the "command" won't keep
|
|
|
994 jumps. Instead use: ":exe 'keepjumps command'"
|
|
7
|
995
|
|
|
996 ==============================================================================
|
|
|
997 8. Jumps *jump-motions*
|
|
|
998
|
|
|
999 A "jump" is one of the following commands: "'", "`", "G", "/", "?", "n",
|
|
|
1000 "N", "%", "(", ")", "[[", "]]", "{", "}", ":s", ":tag", "L", "M", "H" and
|
|
|
1001 the commands that start editing a new file. If you make the cursor "jump"
|
|
|
1002 with one of these commands, the position of the cursor before the jump is
|
|
|
1003 remembered. You can return to that position with the "''" and "``" command,
|
|
|
1004 unless the line containing that position was changed or deleted.
|
|
|
1005
|
|
|
1006 *CTRL-O*
|
|
|
1007 CTRL-O Go to [count] Older cursor position in jump list
|
|
|
1008 (not a motion command). {not in Vi}
|
|
|
1009 {not available without the +jumplist feature}
|
|
|
1010
|
|
|
1011 <Tab> or *CTRL-I* *<Tab>*
|
|
|
1012 CTRL-I Go to [count] newer cursor position in jump list
|
|
|
1013 (not a motion command).
|
|
|
1014 In a |quickfix-window| it takes you to the position of
|
|
|
1015 the error under the cursor.
|
|
|
1016 {not in Vi}
|
|
|
1017 {not available without the +jumplist feature}
|
|
|
1018
|
|
|
1019 *:ju* *:jumps*
|
|
|
1020 :ju[mps] Print the jump list (not a motion command). {not in
|
|
|
1021 Vi} {not available without the +jumplist feature}
|
|
|
1022
|
|
|
1023 *jumplist*
|
|
|
1024 Jumps are remembered in a jump list. With the CTRL-O and CTRL-I command you
|
|
|
1025 can go to cursor positions before older jumps, and back again. Thus you can
|
|
|
1026 move up and down the list. There is a separate jump list for each window.
|
|
|
1027 The maximum number of entries is fixed at 100.
|
|
|
1028 {not available without the +jumplist feature}
|
|
|
1029
|
|
|
1030 For example, after three jump commands you have this jump list:
|
|
|
1031
|
|
|
1032 jump line col file/line ~
|
|
|
1033 3 1 0 some text ~
|
|
|
1034 2 70 0 another line ~
|
|
|
1035 1 1154 23 end. ~
|
|
|
1036 > ~
|
|
|
1037
|
|
|
1038 The "file/line" column shows the file name, or the text at the jump if it is
|
|
|
1039 in the current file (an indent is removed and a long line is truncated to fit
|
|
|
1040 in the window).
|
|
|
1041
|
|
|
1042 You are currently in line 1167. If you then use the CTRL-O command, the
|
|
|
1043 cursor is put in line 1154. This results in:
|
|
|
1044
|
|
|
1045 jump line col file/line ~
|
|
|
1046 2 1 0 some text ~
|
|
|
1047 1 70 0 another line ~
|
|
|
1048 > 0 1154 23 end. ~
|
|
|
1049 1 1167 0 foo bar ~
|
|
|
1050
|
|
|
1051 The pointer will be set at the last used jump position. The next CTRL-O
|
|
|
1052 command will use the entry above it, the next CTRL-I command will use the
|
|
|
1053 entry below it. If the pointer is below the last entry, this indicates that
|
|
|
1054 you did not use a CTRL-I or CTRL-O before. In this case the CTRL-O command
|
|
|
1055 will cause the cursor position to be added to the jump list, so you can get
|
|
|
1056 back to the position before the CTRL-O. In this case this is line 1167.
|
|
|
1057
|
|
|
1058 With more CTRL-O commands you will go to lines 70 and 1. If you use CTRL-I
|
|
|
1059 you can go back to 1154 and 1167 again. Note that the number in the "jump"
|
|
|
1060 column indicates the count for the CTRL-O or CTRL-I command that takes you to
|
|
|
1061 this position.
|
|
|
1062
|
|
|
1063 If you use a jump command, the current line number is inserted at the end of
|
|
|
1064 the jump list. If the same line was already in the jump list, it is removed.
|
|
|
1065 The result is that when repeating CTRL-O you will get back to old positions
|
|
|
1066 only once.
|
|
|
1067
|
|
|
1068 When the |:keepjumps| command modifier is used, jumps are not stored in the
|
|
836
|
1069 jumplist. Jumps are also not stored in other cases, e.g., in a |:global|
|
|
|
1070 command. You can explicitly add a jump by setting the ' mark.
|
|
7
|
1071
|
|
|
1072 After the CTRL-O command that got you into line 1154 you could give another
|
|
|
1073 jump command (e.g., "G"). The jump list would then become:
|
|
|
1074
|
|
|
1075 jump line col file/line ~
|
|
|
1076 4 1 0 some text ~
|
|
|
1077 3 70 0 another line ~
|
|
|
1078 2 1167 0 foo bar ~
|
|
|
1079 1 1154 23 end. ~
|
|
|
1080 > ~
|
|
|
1081
|
|
|
1082 The line numbers will be adjusted for deleted and inserted lines. This fails
|
|
|
1083 if you stop editing a file without writing, like with ":n!".
|
|
|
1084
|
|
|
1085 When you split a window, the jumplist will be copied to the new window.
|
|
|
1086
|
|
|
1087 If you have included the ' item in the 'viminfo' option the jumplist will be
|
|
|
1088 stored in the viminfo file and restored when starting Vim.
|
|
|
1089
|
|
|
1090
|
|
|
1091 CHANGE LIST JUMPS *changelist* *change-list-jumps* *E664*
|
|
|
1092
|
|
|
1093 When making a change the cursor position is remembered. One position is
|
|
|
1094 remembered for every change that can be undone, unless it is close to a
|
|
|
1095 previous change. Two commands can be used to jump to positions of changes,
|
|
|
1096 also those that have been undone:
|
|
|
1097
|
|
|
1098 *g;* *E662*
|
|
|
1099 g; Go to [count] older position in change list.
|
|
|
1100 If [count] is larger than the number of older change
|
|
|
1101 positions go to the oldest change.
|
|
|
1102 If there is no older change an error message is given.
|
|
|
1103 (not a motion command)
|
|
|
1104 {not in Vi}
|
|
|
1105 {not available without the +jumplist feature}
|
|
|
1106
|
|
|
1107 *g,* *E663*
|
|
|
1108 g, Go to [count] newer cursor position in change list.
|
|
236
|
1109 Just like |g;| but in the opposite direction.
|
|
7
|
1110 (not a motion command)
|
|
|
1111 {not in Vi}
|
|
|
1112 {not available without the +jumplist feature}
|
|
|
1113
|
|
|
1114 When using a count you jump as far back or forward as possible. Thus you can
|
|
|
1115 use "999g;" to go to the first change for which the position is still
|
|
|
1116 remembered. The number of entries in the change list is fixed and is the same
|
|
|
1117 as for the |jumplist|.
|
|
|
1118
|
|
|
1119 When two undo-able changes are in the same line and at a column position less
|
|
|
1120 than 'textwidth' apart only the last one is remembered. This avoids that a
|
|
|
1121 sequence of small changes in a line, for example "xxxxx", adds many positions
|
|
|
1122 to the change list. When 'textwidth' is zero 'wrapmargin' is used. When that
|
|
|
1123 also isn't set a fixed number of 79 is used. Detail: For the computations
|
|
|
1124 bytes are used, not characters, to avoid a speed penalty (this only matters
|
|
|
1125 for multi-byte encodings).
|
|
|
1126
|
|
|
1127 Note that when text has been inserted or deleted the cursor position might be
|
|
|
1128 a bit different from the position of the change. Especially when lines have
|
|
|
1129 been deleted.
|
|
|
1130
|
|
|
1131 When the |:keepjumps| command modifier is used the position of a change is not
|
|
|
1132 remembered.
|
|
|
1133
|
|
|
1134 *:changes*
|
|
|
1135 :changes Print the change list. A ">" character indicates the
|
|
|
1136 current position. Just after a change it is below the
|
|
|
1137 newest entry, indicating that "g;" takes you to the
|
|
|
1138 newest entry position. The first column indicates the
|
|
|
1139 count needed to take you to this position. Example:
|
|
|
1140
|
|
|
1141 change line col text ~
|
|
|
1142 3 9 8 bla bla bla
|
|
|
1143 2 11 57 foo is a bar
|
|
|
1144 1 14 54 the latest changed line
|
|
|
1145 >
|
|
|
1146
|
|
|
1147 The "3g;" command takes you to line 9. Then the
|
|
|
1148 output of ":changes is:
|
|
|
1149
|
|
|
1150 change line col text ~
|
|
|
1151 > 0 9 8 bla bla bla
|
|
|
1152 1 11 57 foo is a bar
|
|
|
1153 2 14 54 the latest changed line
|
|
|
1154
|
|
|
1155 Now you can use "g," to go to line 11 and "2g," to go
|
|
|
1156 to line 14.
|
|
|
1157
|
|
|
1158 ==============================================================================
|
|
|
1159 9. Various motions *various-motions*
|
|
|
1160
|
|
|
1161 *%*
|
|
|
1162 % Find the next item in this line after or under the
|
|
|
1163 cursor and jump to its match. |inclusive| motion.
|
|
|
1164 Items can be:
|
|
|
1165 ([{}]) parenthesis or (curly/square) brackets
|
|
|
1166 (this can be changed with the
|
|
|
1167 'matchpairs' option)
|
|
|
1168 /* */ start or end of C-style comment
|
|
|
1169 #if, #ifdef, #else, #elif, #endif
|
|
|
1170 C preprocessor conditionals (when the
|
|
|
1171 cursor is on the # or no ([{
|
|
|
1172 following)
|
|
|
1173 For other items the matchit plugin can be used, see
|
|
1621
|
1174 |matchit-install|. This plugin also helps to skip
|
|
|
1175 matches in comments.
|
|
7
|
1176
|
|
|
1177 When 'cpoptions' contains "M" |cpo-M| backslashes
|
|
|
1178 before parens and braces are ignored. Without "M" the
|
|
|
1179 number of backslashes matters: an even number doesn't
|
|
|
1180 match with an odd number. Thus in "( \) )" and "\( (
|
|
|
1181 \)" the first and last parenthesis match.
|
|
1621
|
1182
|
|
7
|
1183 When the '%' character is not present in 'cpoptions'
|
|
|
1184 |cpo-%|, parens and braces inside double quotes are
|
|
|
1185 ignored, unless the number of parens/braces in a line
|
|
|
1186 is uneven and this line and the previous one does not
|
|
|
1187 end in a backslash. '(', '{', '[', ']', '}' and ')'
|
|
|
1188 are also ignored (parens and braces inside single
|
|
|
1189 quotes). Note that this works fine for C, but not for
|
|
|
1190 Perl, where single quotes are used for strings.
|
|
1621
|
1191
|
|
|
1192 Nothing special is done for matches in comments. You
|
|
|
1193 can either use the matchit plugin |matchit-install| or
|
|
|
1194 put quotes around matches.
|
|
|
1195
|
|
|
1196 No count is allowed, {count}% jumps to a line {count}
|
|
|
1197 percentage down the file |N%|. Using '%' on
|
|
7
|
1198 #if/#else/#endif makes the movement linewise.
|
|
|
1199
|
|
|
1200 *[(*
|
|
|
1201 [( go to [count] previous unmatched '('.
|
|
|
1202 |exclusive| motion. {not in Vi}
|
|
|
1203
|
|
|
1204 *[{*
|
|
|
1205 [{ go to [count] previous unmatched '{'.
|
|
|
1206 |exclusive| motion. {not in Vi}
|
|
|
1207
|
|
|
1208 *])*
|
|
|
1209 ]) go to [count] next unmatched ')'.
|
|
|
1210 |exclusive| motion. {not in Vi}
|
|
|
1211
|
|
|
1212 *]}*
|
|
|
1213 ]} go to [count] next unmatched '}'.
|
|
|
1214 |exclusive| motion. {not in Vi}
|
|
|
1215
|
|
|
1216 The above four commands can be used to go to the start or end of the current
|
|
|
1217 code block. It is like doing "%" on the '(', ')', '{' or '}' at the other
|
|
|
1218 end of the code block, but you can do this from anywhere in the code block.
|
|
|
1219 Very useful for C programs. Example: When standing on "case x:", "[{" will
|
|
|
1220 bring you back to the switch statement.
|
|
|
1221
|
|
|
1222 *]m*
|
|
|
1223 ]m Go to [count] next start of a method (for Java or
|
|
|
1224 similar structured language). When not before the
|
|
|
1225 start of a method, jump to the start or end of the
|
|
|
1226 class. When no '{' is found after the cursor, this is
|
|
|
1227 an error. |exclusive| motion. {not in Vi}
|
|
|
1228 *]M*
|
|
|
1229 ]M Go to [count] next end of a method (for Java or
|
|
|
1230 similar structured language). When not before the end
|
|
|
1231 of a method, jump to the start or end of the class.
|
|
|
1232 When no '}' is found after the cursor, this is an
|
|
|
1233 error. |exclusive| motion. {not in Vi}
|
|
|
1234 *[m*
|
|
|
1235 [m Go to [count] previous start of a method (for Java or
|
|
|
1236 similar structured language). When not after the
|
|
|
1237 start of a method, jump to the start or end of the
|
|
|
1238 class. When no '{' is found before the cursor this is
|
|
|
1239 an error. |exclusive| motion. {not in Vi}
|
|
|
1240 *[M*
|
|
|
1241 [M Go to [count] previous end of a method (for Java or
|
|
|
1242 similar structured language). When not after the
|
|
|
1243 end of a method, jump to the start or end of the
|
|
|
1244 class. When no '}' is found before the cursor this is
|
|
|
1245 an error. |exclusive| motion. {not in Vi}
|
|
|
1246
|
|
|
1247 The above two commands assume that the file contains a class with methods.
|
|
|
1248 The class definition is surrounded in '{' and '}'. Each method in the class
|
|
|
1249 is also surrounded with '{' and '}'. This applies to the Java language. The
|
|
|
1250 file looks like this: >
|
|
|
1251
|
|
|
1252 // comment
|
|
|
1253 class foo {
|
|
|
1254 int method_one() {
|
|
|
1255 body_one();
|
|
|
1256 }
|
|
|
1257 int method_two() {
|
|
|
1258 body_two();
|
|
|
1259 }
|
|
|
1260 }
|
|
|
1261 Starting with the cursor on "body_two()", using "[m" will jump to the '{' at
|
|
|
1262 the start of "method_two()" (obviously this is much more useful when the
|
|
|
1263 method is long!). Using "2[m" will jump to the start of "method_one()".
|
|
|
1264 Using "3[m" will jump to the start of the class.
|
|
|
1265
|
|
|
1266 *[#*
|
|
|
1267 [# go to [count] previous unmatched "#if" or "#else".
|
|
|
1268 |exclusive| motion. {not in Vi}
|
|
|
1269
|
|
|
1270 *]#*
|
|
|
1271 ]# go to [count] next unmatched "#else" or "#endif".
|
|
|
1272 |exclusive| motion. {not in Vi}
|
|
|
1273
|
|
|
1274 These two commands work in C programs that contain #if/#else/#endif
|
|
|
1275 constructs. It brings you to the start or end of the #if/#else/#endif where
|
|
|
1276 the current line is included. You can then use "%" to go to the matching line.
|
|
|
1277
|
|
|
1278 *[star* *[/*
|
|
|
1279 [* or [/ go to [count] previous start of a C comment "/*".
|
|
|
1280 |exclusive| motion. {not in Vi}
|
|
|
1281
|
|
|
1282 *]star* *]/*
|
|
|
1283 ]* or ]/ go to [count] next end of a C comment "*/".
|
|
|
1284 |exclusive| motion. {not in Vi}
|
|
|
1285
|
|
|
1286
|
|
|
1287 *H*
|
|
|
1288 H To line [count] from top (Home) of window (default:
|
|
|
1289 first line on the window) on the first non-blank
|
|
|
1290 character |linewise|. See also 'startofline' option.
|
|
|
1291 Cursor is adjusted for 'scrolloff' option.
|
|
|
1292
|
|
|
1293 *M*
|
|
|
1294 M To Middle line of window, on the first non-blank
|
|
|
1295 character |linewise|. See also 'startofline' option.
|
|
|
1296
|
|
|
1297 *L*
|
|
|
1298 L To line [count] from bottom of window (default: Last
|
|
|
1299 line on the window) on the first non-blank character
|
|
|
1300 |linewise|. See also 'startofline' option.
|
|
|
1301 Cursor is adjusted for 'scrolloff' option.
|
|
|
1302
|
|
|
1303 <LeftMouse> Moves to the position on the screen where the mouse
|
|
36
|
1304 click is |exclusive|. See also |<LeftMouse>|. If the
|
|
7
|
1305 position is in a status line, that window is made the
|
|
|
1306 active window and the cursor is not moved. {not in Vi}
|
|
|
1307
|
|
|
1308 vim:tw=78:ts=8:ft=help:norl:
|
