vim: runtime/doc/editing.txt comparison

comparison runtime/doc/editing.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	8c3a1bd270bb
children	1eaf34420bb3

comparison

equal deleted inserted replaced

-:deb3d4f5be8b
+:0e473e9e70c2
-*editing.txt*   For Vim version 8.1.  Last change: 2018 Dec 16
+*editing.txt*   For Vim version 8.1.  Last change: 2019 May 05
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
 							*:keepalt* *:keepa*
 :keepalt {cmd}		Execute {cmd} while keeping the current alternate file
 			name.  Note that commands invoked indirectly (e.g.,
 			with a function) may still set the alternate file
-			name.  {not in Vi}
+			name.
 All file names are remembered in the buffer list.  When you enter a file name,
 for editing (e.g., with ":e filename") or writing (e.g., with ":w filename"),
 the file name is added to the list.  You can use the buffer list to remember
 which files you edited and to quickly switch from one file to another (e.g.,
 :f[ile]			Prints the current file name (as typed, unless ":cd"
 			was used), the cursor position (unless the 'ruler'
 			option is set), and the file status (readonly,
 			modified, read errors, new file).  See the 'shortmess'
 			option about how to make this message shorter.
-			{Vi does not include column number}
 :f[ile]!		like |:file|, but don't truncate the name even when
 			'shortmess' indicates this.
 {count}CTRL-G		Like CTRL-G, but prints the current file name with
 			full path.  If the count is higher than 1 the current
-			buffer number is also given.  {not in Vi}
+			buffer number is also given.
 					*g_CTRL-G* *word-count* *byte-count*
 g CTRL-G		Prints the current position of the cursor in five
 			ways: Column, Line, Word, Character and Byte.  If the
 			number of Characters and Bytes is the same then the
 			than one position on the screen (<Tab> or special
 			character), both the "real" column and the screen
 			column are shown, separated with a dash.
 			Also see the 'ruler' option and the |wordcount()|
 			function.
-			{not in Vi}
 							*v_g_CTRL-G*
 {Visual}g CTRL-G	Similar to "g CTRL-G", but Word, Character, Line, and
 			Byte counts for the visually selected region are
 			displayed.
 			In Blockwise mode, Column count is also shown.  (For
 			{Visual} see |Visual-mode|.)
-			{not in VI}
 							*:file_f*
 :f[ile][!] {name}	Sets the current file name to {name}.  The optional !
 			avoids truncating the message, as with |:file|.
 			If the buffer did have a name, that name becomes the
 			|alternate-file| name.  An unlisted buffer is created
 			to hold the old name.
 							*:0file*
 :0f[ile][!]		Remove the name of the current buffer.  The optional !
-			avoids truncating the message, as with |:file|.  {not
+			avoids truncating the message, as with |:file|.
-			in Vi}
 :buffers
 :files
 :ls			List all the currently known file names.  See
-			'windows.txt' |:files| |:buffers| |:ls|.  {not in
+			'windows.txt' |:files| |:buffers| |:ls|.
-			Vi}
 Vim will remember the full path name of a file name that you enter.  In most
 cases when the file name is displayed only the name you typed is shown, but
 the full path name is being used if you used the ":cd" command |:cd|.
 			is set or 'autowriteall' is set and the file can be
 			written.
 			If 'fileformats' is not empty, the first format given
 			will be used for the new buffer.  If 'fileformats' is
 			empty, the 'fileformat' of the current buffer is used.
-			{not in Vi}
 							*:ene!* *:enew!*
 :ene[w]!		Edit a new, unnamed buffer.  Discard any changes to
 			the current buffer.
 			Set 'fileformat' like |:enew|.
-			{not in Vi}
 							*:fin* *:find*
 :fin[d][!] [++opt] [+cmd] {file}
 			Find {file} in 'path' and then |:edit| it.
-			{not in Vi} {not available when the |+file_in_path|
+			{not available when the |+file_in_path| feature was
-			feature was disabled at compile time}
+			disabled at compile time}
 :{count}fin[d][!] [++opt] [+cmd] {file}
 			Just like ":find", but use the {count} match in
 			'path'.  Thus ":2find file" will find the second
 			"file" found in 'path'.  When there are fewer matches
 							*:vie* *:view*
 :vie[w][!] [++opt] [+cmd] file
 			When used in Ex mode: Leave |Ex-mode|, go back to
 			Normal mode.  Otherwise same as |:edit|, but set
-			'readonly' option for this buffer.  {not in Vi}
+			'readonly' option for this buffer.
 							*CTRL-^* *CTRL-6*
 CTRL-^			Edit the alternate file.  Mostly the alternate file is
 			the previously edited file.  This is a quick way to
 			toggle between two files.  It is equivalent to ":e #",
 {count}CTRL-^		Edit [count]th file in the buffer list (equivalent to
 			":e #[count]").  This is a quick way to switch between
 			files.
 			See |CTRL-^| above for further details.
-			{not in Vi}
 [count]]f						*]f* *[f*
 [count][f		Same as "gf".  Deprecated.
 							*gf* *E446* *E447*
 <			If the name is a hypertext link, that looks like
 			"type://machine/path", you need the |netrw| plugin.
 			For Unix the '~' character is expanded, like in
 			"~user/file".  Environment variables are expanded too
 			|expand-env|.
-			{not in Vi}
 			{not available when the |+file_in_path| feature was
 			disabled at compile time}
 							*v_gf*
 {Visual}[count]gf	Same as "gf", but the highlighted text is used as the
 			name of the file to edit.  'isfname' is ignored.
 			Leading blanks are skipped, otherwise all blanks and
 			special characters are included in the file name.
 			(For {Visual} see |Visual-mode|.)
-			{not in VI}
 							*gF*
 [count]gF		Same as "gf", except if a number follows the file
 			name, then the cursor is positioned on that line in
 			the file. The file name and the number must be
 			[count] is used like with |:argadd|.
 			If the current file cannot be |abandon|ed {name}s will
 			still be added to the argument list, but won't be
 			edited. No check for duplicates is done.
 			Also see |++opt| and |+cmd|.
-			{not in Vi}
 :[count]arga[dd] {name} ..			*:arga* *:argadd* *E479*
 :[count]arga[dd]
 			Add the {name}s to the argument list.  When {name} is
 			omitted add the current buffer name to the argument
 			And after the last one:
 				:+2argadd y	a b c x y
 			There is no check for duplicates, it is possible to
 			add a file to the argument list twice.
 			The currently edited file is not changed.
-			{not in Vi}
 			Note: you can also use this method: >
 				:args ## x
 <			This will add the "x" item and sort the new list.
 :argd[elete] {pattern} ..			*:argd* *:argdelete* *E480*
 			current entry.
 			This command keeps the currently edited file, also
 			when it's deleted from the argument list.
 			Example: >
 				:argdel *.obj
-<			{not in Vi}
 :[range]argd[elete]	Delete the {range} files from the argument list.
 			Example: >
 				:10,$argdel
 <			Deletes arguments 10 and further, keeping 1-9. >
 <			Deletes the current argument. >
 				:%argd
 <			Removes all the files from the arglist.
 			When the last number in the range is too high, up to
 			the last argument is deleted.
-			{not in Vi}
 							*:argu* *:argument*
 :[count]argu[ment] [count] [++opt] [+cmd]
 			Edit file [count] in the argument list.  When [count]
 			is omitted the current entry is used.  This fails
 			when changes have been made and Vim does not want to
 			|abandon| the current buffer.
 			Also see |++opt| and |+cmd|.
-			{not in Vi}
 :[count]argu[ment]! [count] [++opt] [+cmd]
 			Edit file [count] in the argument list, discard any
 			changes to the current buffer.  When [count] is
 			omitted the current entry is used.
 			Also see |++opt| and |+cmd|.
-			{not in Vi}
 :[count]n[ext] [++opt] [+cmd]			*:n* *:ne* *:next* *E165* *E163*
 			Edit [count] next file.  This fails when changes have
 			been made and Vim does not want to |abandon| the
 			current buffer.  Also see |++opt| and |+cmd|.  {Vi: no
 :[count]N[ext] [count] [++opt] [+cmd]			*:Next* *:N* *E164*
 			Edit [count] previous file in argument list.  This
 			fails when changes have been made and Vim does not
 			want to |abandon| the current buffer.
-			Also see |++opt| and |+cmd|.  {Vi: no count or ++opt}.
+			Also see |++opt| and |+cmd|.
 :[count]N[ext]! [count] [++opt] [+cmd]
 			Edit [count] previous file in argument list.  Discard
 			any changes to the buffer.  Also see |++opt| and
 			|+cmd|.  {Vi: no count or ++opt}.
 			Also see |++opt| and |+cmd|. {Vi: no ++opt}
 :rew[ind]! [++opt] [+cmd]
 			Start editing the first file in the argument list.
 			Discard any changes to the buffer.  Also see |++opt|
-			and |+cmd|. {Vi: no ++opt}
+			and |+cmd|.
 							*:fir* *:first*
 :fir[st][!] [++opt] [+cmd]
-			Other name for ":rewind". {not in Vi}
+			Other name for ":rewind".
 							*:la* *:last*
 :la[st] [++opt] [+cmd]
 			Start editing the last file in the argument list.
 			This fails when changes have been made and Vim does
 			not want to |abandon| the current buffer.
-			Also see |++opt| and |+cmd|.  {not in Vi}
+			Also see |++opt| and |+cmd|.
 :la[st]! [++opt] [+cmd]
 			Start editing the last file in the argument list.
 			Discard any changes to the buffer.  Also see |++opt|
-			and |+cmd|.  {not in Vi}
+			and |+cmd|.
 							*:wn* *:wnext*
 :[count]wn[ext] [++opt]
 			Write current file and start editing the [count]
-			next file.  Also see |++opt| and |+cmd|.  {not in Vi}
+			next file.  Also see |++opt| and |+cmd|.
 :[count]wn[ext] [++opt] {file}
 			Write current file to {file} and start editing the
 			[count] next file, unless {file} already exists and
 			the 'writeany' option is off.  Also see |++opt| and
-			|+cmd|.  {not in Vi}
+			|+cmd|.
 :[count]wn[ext]! [++opt] {file}
 			Write current file to {file} and start editing the
-			[count] next file.  Also see |++opt| and |+cmd|.  {not
+			[count] next file.  Also see |++opt| and |+cmd|.
-			in Vi}
 :[count]wN[ext][!] [++opt] [file]		*:wN* *:wNext*
 :[count]wp[revious][!] [++opt] [file]		*:wp* *:wprevious*
 			Same as :wnext, but go to previous file instead of
-			next.  {not in Vi}
+			next.
 The [count] in the commands above defaults to one.  For some commands it is
 possible to use two counts.  The last one (rightmost one) is used.
 If no [+cmd] argument is present, the cursor is positioned at the last known
 This means that you are position 4 in the argument list, but not editing the
 fourth file in the argument list.  This happens when you do ":e file".
 LOCAL ARGUMENT LIST
-{not in Vi}
 							*:arglocal*
 :argl[ocal]		Make a local copy of the global argument list.
 			Doesn't start editing another file.
 			{cmd} must not change the argument list.
 			Note: While this command is executing, the Syntax
 			autocommand event is disabled by adding it to
 			'eventignore'.  This considerably speeds up editing
 			each file.
-			{not in Vi}
 			Also see |:windo|, |:tabdo|, |:bufdo|, |:cdo|, |:ldo|,
 			|:cfdo| and |:lfdo|
 Example: >
 	:args *.c
 			previous name is used for the alternate file name.
 			The [!] is needed to overwrite an existing file.
 			When 'filetype' is empty filetype detection is done
 			with the new name, before the file is written.
 			When the write was successful 'readonly' is reset.
-			{not in Vi}
 							*:up* *:update*
 :[range]up[date][!] [++opt] [>>] [file]
 			Like ":write", but only write when the buffer has been
-			modified.  {not in Vi}
+			modified.
 WRITING WITH MULTIPLE BUFFERS				*buffer-write*
 							*:wa* *:wall*
 :wa[ll]			Write all changed buffers.  Buffers without a file
 			name cause an error message.  Buffers which are
-			readonly are not written. {not in Vi}
+			readonly are not written.
 :wa[ll]!		Write all changed buffers, even the ones that are
 			readonly.  Buffers without a file name are not
-			written and cause an error message. {not in Vi}
+			written and cause an error message.
 Vim will warn you if you try to overwrite a file that has been changed
 elsewhere.  See |timestamp|.
 			Triggers the |QuitPre| autocommand event.
 			See |CTRL-W_q| for quitting another window.
 :conf[irm] q[uit]	Quit, but give prompt when changes have been made, or
 			the last file in the argument list has not been
-			edited.  See |:confirm| and 'confirm'.  {not in Vi}
+			edited.  See |:confirm| and 'confirm'.
 :q[uit]!		Quit without writing, also when the current buffer has
 			changes.  The buffer is unloaded, also when it has
 			'hidden' set.
 			If this is the last window and there is a modified
 			buffer.
 			Use ":qall!" to exit always.
 :cq[uit]		Quit always, without writing, and return an error
 			code.  See |:cq|.  Used for Manx's QuickFix mode (see
-			|quickfix|).  {not in Vi}
+			|quickfix|).
 							*:wq*
 :wq [++opt]		Write the current file and quit.  Writing fails when
 			the file is read-only or the buffer does not have a
 			name.  Quitting fails when the last file in the
 			current file, the file is written if it was modified
 			and the window is closed).
 							*ZQ*
 ZQ			Quit without checking for changes (same as ":q!").
-			{not in Vi}
 MULTIPLE WINDOWS AND BUFFERS				*window-exit*
 							*:qa* *:qall*
 :qa[ll]		Exit Vim, unless there are some buffers which have been
 		changed.  (Use ":bmod" to go to the next modified buffer).
 		When 'autowriteall' is set all changed buffers will be
-		written, like |:wqall|. {not in Vi}
+		written, like |:wqall|.
 :conf[irm] qa[ll]
 		Exit Vim.  Bring up a prompt when some buffers have been
-		changed.  See |:confirm|. {not in Vi}
+		changed.  See |:confirm|.
-:qa[ll]!	Exit Vim.  Any changes to buffers are lost. {not in Vi}
+:qa[ll]!	Exit Vim.  Any changes to buffers are lost.
 		Also see |:cquit|, it does the same but exits with a non-zero
 		value.
 							*:quita* *:quitall*
-:quita[ll][!]	Same as ":qall". {not in Vi}
+:quita[ll][!]	Same as ":qall".
 :wqa[ll] [++opt]				*:wqa* *:wqall* *:xa* *:xall*
 :xa[ll]		Write all changed buffers and exit Vim.  If there are buffers
 		without a file name, which are readonly or which cannot be
-		written for another reason, Vim will not quit. {not in Vi}
+		written for another reason, Vim will not quit.
 :conf[irm] wqa[ll] [++opt]
 :conf[irm] xa[ll]
 		Write all changed buffers and exit Vim.  Bring up a prompt
 		when some buffers are readonly or cannot be written for
-		another reason.  See |:confirm|. {not in Vi}
+		another reason.  See |:confirm|.
 :wqa[ll]! [++opt]
 :xa[ll]!	Write all changed buffers, even the ones that are readonly,
 		and exit Vim.  If there are buffers without a file name or
 		which cannot be written for another reason, or there is a
 		terminal with a running job, Vim will not quit.
-		{not in Vi}
 ==============================================================================
 6. Dialogs						*edit-dialogs*
 							*:confirm* *:conf*
 							*:cd* *E747* *E472*
 :cd[!]			On non-Unix systems: Print the current directory
 			name.  On Unix systems: Change the current directory
 			to the home directory.  Use |:pwd| to print the
 			current directory on all systems.
+			On Unix systems: clear any window-local directory.
 :cd[!] {path}		Change the current directory to {path}.
 			If {path} is relative, it is searched for in the
 			directories listed in |'cdpath'|.
+			Clear any window-local directory.
 			Does not change the meaning of an already opened file,
 			because its full path name is remembered.  Files from
 			the |arglist| may change though!
 			On MS-DOS this also changes the active drive.
 			To change to the directory of the current file: >
 				:cd %:h
 <
 							*:cd-* *E186*
 :cd[!] -		Change to the previous current directory (before the
-			previous ":cd {path}" command). {not in Vi}
+			previous ":cd {path}" command).
 							*:chd* *:chdir*
 :chd[ir][!] [path]	Same as |:cd|.
 							*:tcd*
 :tcd[!] {path}		Like |:cd|, but only set the directory for the current
 			tab.  The current window will also use this directory.
 			The current directory is not changed for windows in
 			other tabs and for windows in the current tab that
 			have their own window-local directory.
-			{not in Vi}
 							*:tch* *:tchdir*
-:tch[dir][!]		Same as |:tcd|. {not in Vi}
+:tch[dir][!]		Same as |:tcd|.
 							*:lc* *:lcd*
 :lc[d][!] {path}	Like |:cd|, but only set the current directory when
 			the cursor is in the current window.  The current
 			directory for other windows is not changed, switching
 			to another window will stop using {path}.
-			{not in Vi}
 							*:lch* *:lchdir*
-:lch[dir][!]		Same as |:lcd|. {not in Vi}
+:lch[dir][!]		Same as |:lcd|.
 							*:pw* *:pwd* *E187*
 :pw[d]			Print the current directory name.  {Vi: no pwd}
 			Also see |getcwd()|.
 reading the file.
 - Make sure the 'binary' option is set BEFORE loading the
 file.  Otherwise both <CR> <NL> and <NL> are considered to end a line
 and when the file is written the <NL> will be replaced with <CR> <NL>.
 - <Nul> characters are shown on the screen as ^@.  You can enter them with
-"CTRL-V CTRL-@" or "CTRL-V 000" {Vi cannot handle <Nul> characters in the
+"CTRL-V CTRL-@" or "CTRL-V 000"
-file}
 - To insert a <NL> character in the file split a line.  When writing the
 buffer to a file a <NL> will be written for the <EOL>.
 - Vim normally appends an <EOL> at the end of the file if there is none.
 Setting the 'binary' option prevents this.  If you want to add the final
 <EOL>, set the 'endofline' option.  You can also read the value of this

Mercurial > vim

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