vim

Fork of vim, an acceptable text editor
git clone git://git.laack.co/vim.git
Log | Files | Refs | README | LICENSE

motion.txt (55309B)


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