vim: runtime/doc/motion.txt comparison

comparison runtime/doc/motion.txt @ 16553:0e473e9e70c2 v8.1.1280

patch 8.1.1280: remarks about functionality not in Vi clutters the help commit https://github.com/vim/vim/commit/25c9c680ec4dfbb51f4ef21c3460a48d3c67ffc8 Author: Bram Moolenaar <Bram@vim.org> Date: Sun May 5 18:13:34 2019 +0200 patch 8.1.1280: remarks about functionality not in Vi clutters the help Problem: Remarks about functionality not in Vi clutters the help. Solution: Move all info about what is new in Vim or already existed in Vi to vi_diff.txt. Remove {not in Vi} remarks. (closes #4268) Add "noet" to the help files modeline. Also include many other help file improvements.

author	Bram Moolenaar <Bram@vim.org>
date	Sun, 05 May 2019 18:15:06 +0200
parents	dc766e1b0c95
children	1eaf34420bb3

comparison

equal deleted inserted replaced

-:deb3d4f5be8b
+:0e473e9e70c2
-*motion.txt*    For Vim version 8.1.  Last change: 2019 Mar 02
+*motion.txt*    For Vim version 8.1.  Last change: 2019 May 05
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
 <Home>			To the first character of the line.  |exclusive|
 			motion.  When moving up or down next, stay in same
 			TEXT column (if possible).  Most other commands stay
 			in the same SCREEN column.  <Home> works like "1|",
 			which differs from "0" when the line starts with a
-			<Tab>.  {not in Vi}
+			<Tab>.
 							*^*
 ^			To the first non-blank character of the line.
 			|exclusive| motion.
 			back from past the end of the line to the last
 			character in the line.
 							*g_*
 g_			To the last non-blank character of the line and
-			[count - 1] lines downward |inclusive|. {not in Vi}
+			[count - 1] lines downward |inclusive|.
 							*g0* *g<Home>*
 g0 or g<Home>		When lines wrap ('wrap' on): To the first character of
 			the screen line.  |exclusive| motion.  Differs from
 			"0" when a line is wider than the screen.
 			When lines don't wrap ('wrap' off): To the leftmost
 			character of the current line that is on the screen.
 			Differs from "0" when the first character of the line
-			is not on the screen.  {not in Vi}
+			is not on the screen.
 							*g^*
 g^			When lines wrap ('wrap' on): To the first non-blank
 			character of the screen line.  |exclusive| motion.
 			Differs from "^" when a line is wider than the screen.
 			When lines don't wrap ('wrap' off): To the leftmost
 			non-blank character of the current line that is on the
 			screen.  Differs from "^" when the first non-blank
-			character of the line is not on the screen.  {not in
+			character of the line is not on the screen.
-			Vi}
 							*gm*
 gm			Like "g0", but half a screenwidth to the right (or as
-			much as possible). {not in Vi}
+			much as possible).
 							*g$* *g<End>*
 g$ or g<End>		When lines wrap ('wrap' on): To the last character of
 			the screen line and [count - 1] screen lines downward
 			|inclusive|.  Differs from "$" when a line is wider
 			the line is not on the screen or when a count is used.
 			Additionally, vertical movements keep the column,
 			instead of going to the end of the line.
 			When 'virtualedit' is enabled moves to the end of the
 			screen line.
-			{not in Vi}
 							*bar*
 |			To screen column [count] in the current line.
 			|exclusive| motion.  Ceci n'est pas une pipe.
 CTRL-N			[count] lines downward |linewise|.
 gk		or					*gk* *g<Up>*
 g<Up>			[count] display lines upward.  |exclusive| motion.
 			Differs from 'k' when lines wrap, and when used with
-			an operator, because it's not linewise.  {not in Vi}
+			an operator, because it's not linewise.
 gj		or					*gj* *g<Down>*
 g<Down>			[count] display lines downward.  |exclusive| motion.
 			Differs from 'j' when lines wrap, and when used with
-			an operator, because it's not linewise.  {not in Vi}
+			an operator, because it's not linewise.
 							*-*
 -  <minus>		[count] lines upward, on the first non-blank
 			character |linewise|.
 			set, keep the same column.
 			G is one of the |jump-motions|.
 							*<C-End>*
 <C-End>			Goto line [count], default last line, on the last
-			character |inclusive|. {not in Vi}
+			character |inclusive|.
 <C-Home>	or					*gg* *<C-Home>*
 gg			Goto line [count], default first line, on the first
 			non-blank character |linewise|.  If 'startofline' not
 			set, keep the same column.
 							*N%*
 {count}%		Go to {count} percentage in the file, on the first
 			non-blank in the line |linewise|.  To compute the new
 			line number this formula is used:
 			    ({count} * number-of-lines + 99) / 100
-			See also 'startofline' option.  {not in Vi}
+			See also 'startofline' option.
 :[range]go[to] [count]					*:go* *:goto* *go*
 [count]go		Go to [count] byte in the buffer.  Default [count] is
 			one, start of the file.  When giving [range], the
 			last number in it used as the byte count.  End-of-line
 			characters are counted depending on the current
 			'fileformat' setting.
 			Also see the |line2byte()| function, and the 'o'
 			option in 'statusline'.
-			{not in Vi}
 			{not available when compiled without the
 			|+byte_offset| feature}
 These commands move to the specified line.  They stop when reaching the first
 or the last line.  The first two commands put the cursor in the same column
 after an operator.  The commands that start with "a" select "a"n object
 including white space, the commands starting with "i" select an "inner" object
 without white space, or just the white space.  Thus the "inner" commands
 always select less text than the "a" commands.
-These commands are {not in Vi}.
 These commands are not available when the |+textobjects| feature has been
 disabled at compile time.
 Also see `gn` and `gN`, operating on the last search pattern.
 							*v_aw* *aw*
 						*'* *'a* *`* *`a*
 '{a-z}  `{a-z}		Jump to the mark {a-z} in the current buffer.
 						*'A* *'0* *`A* *`0*
 '{A-Z0-9}  `{A-Z0-9}	To the mark {A-Z0-9} in the file where it was set (not
-			a motion command when in another file).  {not in Vi}
+			a motion command when in another file).
 						*g'* *g'a* *g`* *g`a*
 g'{mark}  g`{mark}
 			Jump to the {mark}, but don't change the jumplist when
 			jumping within the current buffer.  Example: >
 				g`"
 <			jumps to the last known position in a file.  See
 			$VIMRUNTIME/vimrc_example.vim.
 			Also see |:keepjumps|.
-			{not in Vi}
 						*:marks*
 :marks			List all the current marks (not a motion command).
 			The |'(|, |')|, |'{| and |'}| marks are not listed.
 			The first column has number zero.
-			{not in Vi}
 						*E283*
 :marks {arg}		List the marks that are mentioned in {arg} (not a
 			motion command).  For example: >
 				:marks aB
-<			to list marks 'a' and 'B'.  {not in Vi}
+<			to list marks 'a' and 'B'.
 							*:delm* *:delmarks*
 :delm[arks] {marks}	Delete the specified marks.  Marks that can be deleted
 			include A-Z and 0-9.  You cannot delete the ' mark.
 			They can be specified by giving the list of mark
 			   :delmarks a b 1    deletes marks a, b and 1
 			   :delmarks Aa       deletes marks A and a
 			   :delmarks p-z      deletes marks in the range p to z
 			   :delmarks ^.[]     deletes marks ^ . [ ]
 			   :delmarks \"	      deletes mark "
-<			{not in Vi}
 :delm[arks]!		Delete all marks for the current buffer, but not marks
 			A-Z or 0-9.
-			{not in Vi}
 A mark is not visible in any way.  It is just a position in the file that is
 remembered.  Do not confuse marks with named registers, they are totally
 unrelated.
 Numbered mark should be stored.  See |viminfo-file-marks|.
 							*'[* *`[*
 '[  `[			To the first character of the previously changed
-			or yanked text.  {not in Vi}
+			or yanked text.
 							*']* *`]*
 ']  `]			To the last character of the previously changed or
-			yanked text.  {not in Vi}
+			yanked text.
 After executing an operator the Cursor is put at the beginning of the text
 that was operated upon.  After a put command ("p" or "P") the cursor is
 sometimes placed at the first inserted line and sometimes on the last inserted
 character.  The four commands above put the cursor at either end.  Example:
 							*'<* *`<*
 '<  `<			To the first line or character of the last selected
 			Visual area in the current buffer.  For block mode it
 			may also be the last character in the first line (to
-			be able to define the block).  {not in Vi}.
+			be able to define the block).
 							*'>* *`>*
 '>  `>			To the last line or character of the last selected
 			Visual area in the current buffer.  For block mode it
 			may also be the first character of the last line (to
 			be able to define the block).  Note that 'selection'
 			applies, the position may be just after the Visual
-			area.  {not in Vi}.
+			area.
 							*''* *``*
 ''  ``			To the position before the latest jump, or where the
 			last "m'" or "m`" command was given.  Not set when the
 			|:keepjumps| command modifier was used.
 			line.  See |last-position-jump| for how to use this
 			for each opened file.
 			Only one position is remembered per buffer, not one
 			for each window.  As long as the buffer is visible in
 			a window the position won't be changed.
-			{not in Vi}.
 							*'^* *`^*
 '^  `^			To the position where the cursor was the last time
 			when Insert mode was stopped.  This is used by the
 			|gi| command.  Not set when the |:keepjumps| command
-			modifier was used.  {not in Vi}
+			modifier was used.
 							*'.* *`.*
 '.  `.			To the position where the last change was made.  The
 			position is at or near where the change started.
 			Sometimes a command is executed as several changes,
 			then the position can be near the end of what the
 			command changed.  For example when inserting a word,
 			the position will be on the last character.
 			To jump to older changes use |g;|.
-			{not in Vi}
 							*'(* *`(*
 '(  `(			To the start of the current sentence, like the |(|
-			command.  {not in Vi}
+			command.
 							*')* *`)*
 ')  `)			To the end of the current sentence, like the |)|
-			command.  {not in Vi}
+			command.
 							*'{* *`{*
 '{  `{			To the start of the current paragraph, like the |{|
-			command.  {not in Vi}
+			command.
 							*'}* *`}*
 '}  `}			To the end of the current paragraph, like the |}|
-			command.  {not in Vi}
+			command.
 These commands are not marks themselves, but jump to a mark:
 							*]'*
 ]'			[count] times to next line with a lowercase mark below
 			the cursor, on the first non-blank character in the
-			line. {not in Vi}
+			line.
 							*]`*
 ]`			[count] times to lowercase mark after the cursor. {not
 			in Vi}
 							*['*
 ['			[count] times to previous line with a lowercase mark
 			before the cursor, on the first non-blank character in
-			the line. {not in Vi}
+			the line.
 							*[`*
 [`			[count] times to lowercase mark before the cursor.
-			{not in Vi}
 :loc[kmarks] {command}					*:loc* *:lockmarks*
 			Execute {command} without adjusting marks.  This is
 			useful when changing text in a way that the line count
 commands that start editing a new file.
 							*CTRL-O*
 CTRL-O			Go to [count] Older cursor position in jump list
 			(not a motion command).
-			{not in Vi}
 			{not available without the |+jumplist| feature}
 <Tab>		or					*CTRL-I* *<Tab>*
 CTRL-I			Go to [count] newer cursor position in jump list
 			(not a motion command).
-			{not in Vi}
 			{not available without the |+jumplist| feature}
 							*:ju* *:jumps*
 :ju[mps]		Print the jump list (not a motion command).
-			{not in Vi}
 			{not available without the |+jumplist| feature}
 							*:cle* *:clearjumps*
 :cle[arjumps]		Clear the jump list of the current window.
-			{not in Vi}
 			{not available without the |+jumplist| feature}
 							*jumplist*
 Jumps are remembered in a jump list.  With the CTRL-O and CTRL-I command you
 can go to cursor positions before older jumps, and back again.  Thus you can
 g;			Go to [count] older position in change list.
 			If [count] is larger than the number of older change
 			positions go to the oldest change.
 			If there is no older change an error message is given.
 			(not a motion command)
-			{not in Vi}
 			{not available without the |+jumplist| feature}
 							*g,* *E663*
 g,			Go to [count] newer cursor position in change list.
 			Just like |g;| but in the opposite direction.
 			(not a motion command)
-			{not in Vi}
 			{not available without the |+jumplist| feature}
 When using a count you jump as far back or forward as possible.  Thus you can
 use "999g;" to go to the first change for which the position is still
 remembered.  The number of entries in the change list is fixed and is the same
 			percentage down the file |N%|.  Using '%' on
 			#if/#else/#endif makes the movement linewise.
 						*[(*
 [(			go to [count] previous unmatched '('.
-			|exclusive| motion. {not in Vi}
+			|exclusive| motion.
 						*[{*
 [{			go to [count] previous unmatched '{'.
-			|exclusive| motion. {not in Vi}
+			|exclusive| motion.
 						*])*
 ])			go to [count] next unmatched ')'.
-			|exclusive| motion. {not in Vi}
+			|exclusive| motion.
 						*]}*
 ]}			go to [count] next unmatched '}'.
-			|exclusive| motion. {not in Vi}
+			|exclusive| motion.
 The above four commands can be used to go to the start or end of the current
 code block.  It is like doing "%" on the '(', ')', '{' or '}' at the other
 end of the code block, but you can do this from anywhere in the code block.
 Very useful for C programs.  Example: When standing on "case x:", "[{" will
 						*]m*
 ]m			Go to [count] next start of a method (for Java or
 			similar structured language).  When not before the
 			start of a method, jump to the start or end of the
 			class.  When no '{' is found after the cursor, this is
-			an error.  |exclusive| motion. {not in Vi}
+			an error.  |exclusive| motion.
 						*]M*
 ]M			Go to [count] next end of a method (for Java or
 			similar structured language).  When not before the end
 			of a method, jump to the start or end of the class.
 			When no '}' is found after the cursor, this is an
-			error. |exclusive| motion. {not in Vi}
+			error. |exclusive| motion.
 						*[m*
 [m			Go to [count] previous start of a method (for Java or
 			similar structured language).  When not after the
 			start of a method, jump to the start or end of the
 			class.  When no '{' is found before the cursor this is
-			an error. |exclusive| motion. {not in Vi}
+			an error. |exclusive| motion.
 						*[M*
 [M			Go to [count] previous end of a method (for Java or
 			similar structured language).  When not after the
 			end of a method, jump to the start or end of the
 			class.  When no '}' is found before the cursor this is
-			an error. |exclusive| motion. {not in Vi}
+			an error. |exclusive| motion.
 The above two commands assume that the file contains a class with methods.
 The class definition is surrounded in '{' and '}'.  Each method in the class
 is also surrounded with '{' and '}'.  This applies to the Java language.  The
 file looks like this: >
 method is long!).  Using "2[m" will jump to the start of "method_one()".
 Using "3[m" will jump to the start of the class.
 						*[#*
 [#			go to [count] previous unmatched "#if" or "#else".
-			|exclusive| motion. {not in Vi}
+			|exclusive| motion.
 						*]#*
 ]#			go to [count] next unmatched "#else" or "#endif".
-			|exclusive| motion. {not in Vi}
+			|exclusive| motion.
 These two commands work in C programs that contain #if/#else/#endif
 constructs.  It brings you to the start or end of the #if/#else/#endif where
 the current line is included.  You can then use "%" to go to the matching line.
 						*[star* *[/*
 [*  or  [/		go to [count] previous start of a C comment "/*".
-			|exclusive| motion. {not in Vi}
+			|exclusive| motion.
 						*]star* *]/*
 ]*  or  ]/		go to [count] next end of a C comment "*/".
-			|exclusive| motion. {not in Vi}
+			|exclusive| motion.
 						*H*
 H			To line [count] from top (Home) of window (default:
 			first line on the window) on the first non-blank
 			visible line.
 <LeftMouse>		Moves to the position on the screen where the mouse
 			click is |exclusive|.  See also |<LeftMouse>|.  If the
 			position is in a status line, that window is made the
-			active window and the cursor is not moved.  {not in Vi}
+			active window and the cursor is not moved.
 vim:tw=78:ts=8:noet:ft=help:norl:

Mercurial > vim

comparison runtime/doc/motion.txt @ 16553:0e473e9e70c2 v8.1.1280