Vi is a screen oriented text editor. Ex is a line-oriented text editor. Ex and vi are different interfaces to the same program, and it is possible to switch back and forth during an edit session. View is the equivalent of using the -R (read-only) option of vi .
This reference manual is the one provided with the nex/nvi versions of the ex/vi text editors. Nex/nvi are intended as bug-for-bug compatible replacements for the original Fourth Berkeley Software Distribution (4BSD) ex/vi programs. This reference manual is accompanied by a traditional-style manual page. That manual page describes the functionality found in ex/vi in far less detail than the description here. In addition, it describes the system interface to ex/vi, e.g. command line options, session recovery, signals, environmental variables, and similar things.
This reference is intended for users already familiar with ex/vi. Anyone else should almost certainly read a good tutorial on the editor first. If you are in an unfamiliar environment, and you absolutely have to get work done immediately, see the section entitled "Fast Startup" in the manual page. It is probably enough to get you started.
There are a few features in nex/nvi that are not found in historic versions of ex/vi. Some of the more interesting of those features are briefly described in the next section, entitled "Additional Features" . For the rest of this document, nex/nvi is used only when it is necessary to distinguish it from the historic implementations of ex/vi.
Future versions of this software will be periodically made available
by anonymous ftp, and can be retrieved from
ftp.cs.berkeley.edu,
in the directory
ucb/4bsd.
There are a few features in nex/nvi that are not found in historic versions of ex/vi. Some of the more interesting of these are as follows:
Nex/nvi will edit any format file. Line lengths are limited by available memory, and file sizes are limited by available disk space. The vi text input mode command <control-X> can insert any possible character value into the text.
The bg command backgrounds the current screen, and the fg command foregrounds backgrounded screens. The display command can be used to list the background screens.
You can enter a normal editing window on the collected commands that
you've entered on the
vi
colon command-line,
and then modify and/or execute the commands.
See the
cedit
edit option for more information.
The display command can be used to display the current buffers, the backgrounded screens, and the tags stack.
The
extended
option causes Regular Expressions to be interpreted as as Extended
Regular Expressions, (i.e. egrep(1) style Regular Expressions).
It is possible to do file name completion and file name displays when
entering commands on the
vi
colon command-line.
See the
filec
option for more information.
Changes made during an edit session may be rolled backward and forward. A . command immediately after a u command continues either forward or backward depending on whether the u command was an undo or a redo.
The leftright option causes nvi to do left-right screen scrolling, instead of the traditional vi line wrapping.
It is possible to display informational and error messages in different
languages by providing a catalog of messages.
See the
msgcat
option and the file
catalog/READMEfor more information.
The # command increments or decrements the number referenced by the cursor.
The previous command edits the previous file from the argument list.
The :pe[rl] cmd, :perld[o] cmd and :tc[l] cmd commands execute Perl and Tcl/Tk commands, respectively, on lines from the edit buffer. See the "Scripting Languages" section and the specific commands for more information.
The Edit , Ex , Next , Previous , Tag and Visual (in vi mode) commands divide the screen into multiple editing regions and then perform their normal function in a new screen area. The <control-W> command rotates between the foreground screens. The resize command can be used to grow or shrink a particular screen.
Tags are now maintained in a stack. The <control-T> command returns to the previous tag location. The tagpop command returns to the most recent tag location by default, or, optionally to a specific tag number in the tag stack, or the most recent tag from a specified file. The display command can be used to list the tags stack. The tagtop command returns to the top of the tag stack.
The exusage and viusage commands provide usage information for all of the ex and vi commands by default, or, optionally, for a specific command or key.
The <control-A> command searches for the word referenced by the cursor.
Ex/vi interprets one of two possible environmental variables and reads up to three of five possible files during startup. The variables and files are expected to contain ex commands, not vi commands. In addition, they are interpreted before the file to be edited is read, and therefore many ex commands may not be used. Generally, any command that requires output to the screen or that needs a file upon which to operate, will cause an error if included in a startup file or environmental variable.
Because the ex command set supported by nex/nvi is a superset of the command set supported by historical implementations of ex , nex/nvi can use the startup files created for the historical implementations, but the converse may not be true.
If the -s (the historic - option) is specified, or if standard input is redirected from a file, all environmental variables and startup files are ignored.
Otherwise, startup files and environmental variables are handled in the following order:
/etc/vi.exrcis read,
as long as it is owned by root or the effective user ID of the user.
NEXINIT(or the variable
EXINIT,
if
NEXINITis not set) is interpreted.
NEXINITor
EXINITwas set, and the
HOMEenvironmental variable is set, the file
$HOME/.nexrc(or the file
$HOME/.exrc,
if
$HOME/.nexrcdoes not exist) is read,
as long as the effective user ID of the user is root or is the same as
the owner of the file.
When the $HOME directory is being used for both
nex/nvi
and an historic implementation of
ex/vi,
a possible solution is to put
nex/nvi
specific commands in the
.nexrcfile, along with a
:source $HOME/.exrc
command to read in the commands common to both implementations.
exrc
option was turned on by one of the previous startup information
sources, the file
.nexrc(or the file
.exrc,
if
.nexrcdoes not exist) is read, as long as the effective user ID of the user
is the same as the owner of the file.
No startup file is read if it is writable by anyone other than its owner.
It is not an error for any of the startup environmental variables or files not to exist.
Once all environmental variables are interpreted, and all startup files are read, the first file to be edited is read in (or a temporary file is created). Then, any commands specified using the -c option are executed, in the context of that file.
There is no recovery program for nex/nvi, nor does nex/nvi run setuid. Recovery files are created readable and writable by the owner only. Users may recover any file which they can read, and the superuser may recover any edit session.
Edit sessions are backed by files in the directory named by the
recdir
option (the directory
/var/tmp/vi.recoverby default), and are named
"vi.XXXXXX",
where
"XXXXXX"
is a number related to the process ID.
When a file is first modified,
a second recovery file containing an email message for the user is created,
and is named
"recover.XXXXXX",
where, again,
"XXXXXX"
is associated with the process ID.
Both files are removed at the end of a normal edit session,
but will remain if the edit session is abnormally terminated
or the user runs the
ex
preserve
command.
The
recdir
option may be set in either the user's or system's startup information,
changing the recovery directory.
(Note, however, that if a memory based file system is used as the backup
directory, each system reboot will delete all of the recovery files!
The same caution applies to directories such as
/tmpwhich are cleared of their contents by a system reboot, or
/usr/tmpwhich is periodically cleared of old files on many systems.)
The recovery directory should be owned by root, or at least by a pseudo-user. In addition, if directory "sticky-bit" semantics are available, the directory should have the sticky-bit set so that files may only be removed by their owners. The recovery directory must be read, write, and executable by any user, i.e. mode 1777.
If the recovery directory does not exist, ex/vi will attempt to create it. This can result in the recovery directory being owned by a normal user, which means that that user will be able to remove other user's recovery and backup files. This is annoying, but is not a security issue as the user cannot otherwise access or modify the files.
The recovery file has all of the necessary information in it to enable the
user to recover the edit session.
In addition, it has all of the necessary email headers for
sendmail(8).
When the system is rebooted, all of the files in
/var/tmp/vi.recovernamed
"recover.XXXXXX"
should be sent to their owners, by email, using the
-t
option of
sendmail
(or a similar mechanism in other mailers).
If
ex/vi
receives a hangup (SIGHUP) signal, or the user executes the
ex
preserve
command,
ex/vi
will automatically email the recovery information to the user.
If your system does not have the
sendmail
utility (or a mailer program which supports its interface)
the source file
nvi/common/recover.cwill have to be modified to use your local mail delivery programs.
Note, if
nex/nvi
is changed to use another mailer,
it is important to remember that the owner of the file given to
the mailer is the
nex/nvi
user, so nothing in the file should be trusted as it may have been
modified in an effort to compromise the system.
Finally, the owner execute bit is set on backup files when they are created, and unset when they are first modified, e.g. backup files that have no associated email recovery file will have this bit set. (There is also a small window where empty files can be created and not yet have this bit set. This is due to the method in which the files are created.) Such files should be deleted when the system reboots.
A simple way to do this cleanup is to run the Bourne shell script
recover ,
from your
/etc/rc.local(or other system startup) file.
The script should work with the historic Bourne shell,
a POSIX 1003.2 shell or the Korn shell.
The
recover
script is installed as part of the
nex/nvi
installation process.
Consult the manual page for details on recovering preserved or aborted editing sessions.
The size of the screen can be set in a number of ways. Ex/vi takes the following steps until values are obtained for both the number of rows and number of columns in the screen.
LINESexists,
it is used to specify the number of rows in the screen.
COLUMNSexists,
it is used to specify the number of columns in the screen.
ioctl(2)
is attempted on the standard error file descriptor.
If a window change size signal (SIGWINCH) is received,
the new window size is retrieved using the TIOCGWINSZ
ioctl(2)
call, and all other information is ignored.
In both
ex
and
vi
printable characters as defined by
isprint(3)
are displayed using the local character set.
Non-printable characters, for which
iscntrl(3)
returns true, and which are less than octal \e040,
are displayed as the string
"^<character>",
where
<character>is the character that is the original character's value offset from the
"@"
character.
For example, the octal character \e001 is displayed as
"^A".
If
iscntrl(3)
returns true for the octal character \e177,
it is displayed as the string
"^?".
All other characters are displayed as either hexadecimal values,
in the form
"0x<high-halfbyte> ... 0x<low-halfbyte>",
or as octal values, in the form
"e<high-one-or-two-bits> ... e<low-three-bits>".
The display of unknown characters is based on the value of the
octal
option.
In vi command mode, the cursor is always positioned on the last column of characters which take up more than one column on the screen. In vi text input mode, the cursor is positioned on the first column of characters which take up more than one column on the screen.
Nvi supports multiple screens by dividing the window into regions. It also supports stacks of screens by permitting the user to change the set of screens that are currently displayed.
The Edit , Ex , Fg , Next , Previous , Tag and Visual (in vi mode) commands divide the current screen into two regions of approximately equal size and then perform their usual action in a new screen area. If the cursor is in the lower half of the screen, the screen will split up, i.e. the new screen will be above the old one. If the cursor is in the upper half of the screen, the new screen will be below the old one.
When more than one screen is editing a file, changes in any screen are reflected in all other screens editing the same file. Exiting a screen without saving any changes (or explicitly discarding them) is permitted until the last screen editing the file is exited, at which time the changes must be saved or discarded.
The resize command permits resizing of individual screens. Screens may be grown, shrunk or set to an absolute number of rows.
The ^W command is used to switch between screens. Each ^W moves to the next lower screen in the window, or to the first screen in the window if there are no lower screens.
The bg command "backgrounds" the current screen. The screen disappears from the window, and the rows it occupied are taken over by a neighboring screen. It is an error to attempt to background the only screen in the window.
The display screens command displays the names of the files associated with the current backgrounded screens in the window.
The fg [file] command moves the specified screen from the list of backgrounded screens to the foreground. If no file argument is specified, the first screen on the list is foregrounded. By default, foregrounding consists of backgrounding the current screen, and replacing its space in the window with the foregrounded screen.
Capitalizing the first letter of the command, i.e. Fg , will foreground the backgrounded screen in a new screen instead of swapping it with the current screen.
If the last foregrounded screen in the window is exited, and there are backgrounded screens, the first screen on the list of backgrounded screens takes over the window.
Nvi
supports the historic
vi
tag command
<control-]> ,
and the historic
ex
tag command
tag .
These commands change the current file context to a new location,
based on information found in the
tagsfiles.
If you are unfamiliar with these commands,
you should review their description in the
ex
and
vi
commands section of this manual.
For additional information on tags files,
see the discussion of the
tags
edit option and the system
ctags(1)
manual page.
In addition, nvi supports the notion of "tags stacks", using the <control-T> command. The <control-T> command returns the user to the previous context, i.e., the last place from which a <control-]> or tag command was entered. These three commands provide the basic functionality which allows you to use vi to review source code in a structured manner.
Nvi also provides two other basic ex commands for tag support: tagpop and tagtop . The tagpop command is identical to the <control-T> command, with the additional functionality that you may specify that modifications to the current file are to be discarded. This cannot be done using the <control-T> command. The tagtop command discards all of the contexts that have been pushed onto the tag stack, returning to the context from which the first <control-]> or tag command was entered.
The historic
ctags(1)
tags file format supports only a single location per tag,
normally the function declaration or structure or string definition.
More sophisticated source code tools often provide multiple locations
per tag, e.g.,
a list of the places from which a function is called or a string
definition is used.
An example of this functionality is the System V source code tool,
cscope .
Cscope
creates a database of information on source code files,
and supports a query language for that information as described in the
cscope(1)
manual page.
Nvi
contains an interface to the
cscope
query language which permits you to query
cscope
and then sequentially step through the locations in the sources files which
cscope
returns.
There are two
nvi
commands which support this ability to step through multiple locations.
They are the
ex
commands
tagnext
and
tagprev .
The
tagnext
command moves to the next location for the current tag.
The
tagprev
command moves to the previous location for the current tag.
(See the
tagnext
and
tagprev
command discussion in the
ex
commands section of this manual for more information.)
At any time during this sequential walk,
you may use the
<control-]> ,
tag
or
cscope
commands to move to a new tag context, and then use the
<control-T>
or
tagpop
commands to return and continue stepping through the locations for this
tag.
This is similar to the previous model of a simple tag stack,
except that each entry in the tag stack may have more than one file context
that is of interest.
Although there is no widely distributed version of
ctags(1)
that creates tags files with multiple locations per tag,
nvi
has been written to understand the obvious extension to the historic
tags file format, i.e., more than a single line in the tags file with
the same initial tag name.
If you wish to extend your
ctags
implementation or other tool with which you build tags files,
this extension should be simple and will require no changes to
nvi .
The nvi and cscope interface is based on the new ex command cscope , which has five subcommands: add , find , help , kill and reset . The subcommand find itself has eight subcommands: c , d , e , f , g , i , s and t .
The add command attaches to the specified cscope database. The file name is expanded using the standard filename expansions. If file is a directory, the file "cscope.out" in that directory is used as the database.
After
nvi
attaches to a new database,
all subsequent
cscope
queries will be asked of that database.
The result of any single query is the collection of response to the query
from all of the attached databases.
If the "CSCOPE_DIRS" environmental variable is set when nvi is run, it is expected to be a <colon> or <blank>-separated list of cscope databases or directories containing cscope databases, to which the user wishes to attach.
The
find
command is the
cscope
query command for
nvi .
For this command,
nvi
queries all attached
cscope
databases for the pattern.
If the pattern is a double-quote character followed by a valid buffer
name (e.g.,
"<character>" ),
then the contents of the named buffer are used as the pattern.
Otherwise, the pattern is a Regular Expression.
The
find
command pushes the current location onto the tags stack,
and switches to the first location resulting from the query,
if the query returned at least one result.
File names returned by the
cscope
query, if not absolute paths, are searched for relative to the directory
where the
cscope
database is located.
In addition, if the file
"cscope.tpath"
appears in the same directory as the
cscope
database,
it is expected to contain a colon-separated list of directory names
where files referenced by its associated
cscope
database may be found.
The find subcommand is one of the following:
List the cscope commands, or optionally list usage help for any single cscope command.
Display the list of cscope databases to which nvi is currently connected.
Disconnect from a specific cscope database. The connection number is the one displayed by the ex display connections command.
Disconnect from all attached cscope databases.
Cscope is not freely redistributable software, but is fairly inexpensive and easily available. To purchase a copy of cscope , see http://www.att.com/ssg/products/toolchest.html.
Regular expressions are used in line addresses, as the first part of the ex substitute , global , and v commands, and in search patterns.
The regular expressions supported by
ex/vi
are, by default, the Basic Regular Expressions (BRE's) described in the
IEEE POSIX Standard 1003.2.
The
extended
option causes all regular expressions to be interpreted as the Extended
Regular Expressions (ERE's) described by the same standard.
(See
re_format(7)
for more information.)
Generally speaking, BRE's are the Regular Expressions found in
ed(1)
and
grep(1),
and ERE's are the Regular Expressions found in
egrep(1).
The following is not intended to provide a description of Regular Expressions. The information here only describes strings and characters which have special meanings in the ex/vi version of RE's, or options which change the meanings of characters that normally have special meanings in RE's.
//"
or
"??"
is equivalent to the last RE used.
e<"
matches the beginning of a word.
e>"
matches the end of a word.
~"
matches the replacement part of the last
substitute
command.
When the
magic
option is
not
set, the only characters with special meanings are a
"^"
character at the beginning of an RE, a
"$"
character at the end of an RE, and the escaping character
"e".
The characters
".",
"*",
"["
and
"~"
are treated as ordinary characters unless preceded by a
"e";
when preceded by a
"e"
they regain their special meaning.
Replacement strings are the second part of a substitute command.
The character
"&"
(or
"e&"
if the
magic
option is
not
set) in the replacement string stands for the text matched by the RE
that is being replaced.
The character
"~"
(or
"e~"
if the
magic
option is
not
set) stands for the replacement part of the previous
substitute
command.
It is only valid after a
substitute
command has been performed.
The string
"e#",
where
"#"
is an integer value from 1 to 9, stands for the text matched by
the portion of the RE enclosed in the
"#"'th
set of escaped parentheses, e.g.
"e("
and
"e)".
For example,
"s/abce(.*e)def/e1/"
deletes the strings
"abc"
and
"def"
from the matched pattern.
The strings
"el",
"eu",
"eL"
and
"eU"
can be used to modify the case of elements in the replacement string.
The string
"el"
causes the next character to be converted to lowercase;
the string
"eu"
behaves similarly, but converts to uppercase
(e.g.
s/abc/eU&/replaces the string
abcwith
ABC).
The string
"eL"
causes characters up to the end of the string or the next occurrence
of the strings
"ee"
or
"eE"
to be converted to lowercase;
the string
"eU"
behaves similarly, but converts to uppercase.
If the entire replacement pattern is
"%",
then the last replacement pattern is used again.
In
vi ,
inserting a
<control-M>into the replacement string will cause
the matched line to be split into two lines at that point.
(The
<control-M>will be discarded.)
The nvi editor currently supports two scripting languages, Tcl/Tk and Perl. (Note that Perl4 isn't sufficient, and that the Perl5 used must be version 5.002 or later. See the "Building Nvi" section for more information.
The scripting language interface is still being worked on,
therefore the following information is probably incomplete,
probably wrong in cases, and likely to change.
See the
perl_apiand
tcl_apisource directories for more information.
As a quick reference, the following function calls are provided for
both the Perl and Tcl interfaces.
The Perl interface uses a slightly different naming convention,
e.g. "viFindScreen" is named "VI::FindScreen".
Return the
screenIdassociated with
file.
Append
textas a new line after line number
lineNumber,
in the screen
screenId.
Delete the line
lineNumberfrom the screen
screenId.
Return the line
lineNumberfrom the screen
screenId.
Insert
textas a new line before line number
lineNumberin the screen
screenId.
Return the line number of the last line in the screen
screenId.
Change the line
lineNumberin the screen
screenIdto match the specified
text.
Return the current line and column for the specified
markfrom the screen
screenId.
Set the specified
markto be at line
line,
column
column,
in the screen
screenId.
Return the current line and column for the cursor in the screen
screenId.
Set the cursor in the screen
screenIdto the specified
lineand
column.
Display the specified
textas a vi message in the screen
screenId.
Create a new screen.
Exit the screen
screenId.
Switch from the screen
screenIdto the screen
screenId.
Map the specified
keyin the screen
screenIdto the Tcl procedure
tclproc.
Unmap the specified
keyin the screen
screenId
Return the value of the specified
optionfrom the screen
screenId.
Set one or more options in the screen
screenId.
When
ex
or
vi
are executed,
the text of a file is read (or a temporary file is created),
and then all editing changes happen within the context of the
copy of the file.
No changes affect the actual file until the file is written out,
either using a write command or another command which is affected by the
autowrite
option.
All files are locked (using the
flock(2)
or
fcntl(2)
interfaces) during the edit session,
to avoid inadvertently making modifications to multiple copies of the file.
If a lock cannot be obtained for a file because it is locked by another
process, the edit session is read-only (as if the
readonly
option or the
-R
flag had been specified).
If a lock cannot be obtained for other reasons, the edit session will
continue, but the file status information
(see the
<control-G>
command) will reflect this fact.
Both
ex
and
vi
are modeful editors, i.e. they have two modes,
"command"
mode and
"text input"
mode.
The former is intended to permit you to enter commands which modifies
already existing text.
The latter is intended to permit you to enter new text.
When
ex
first starts running, it is in command mode, and usually displays a prompt
(see the
prompt
option for more information).
The prompt is a single colon
":"
character.
There are three commands that switch
ex
into text input mode:
append ,
change
and
insert .
Once in input mode, entering a line containing only a single period
"."
ends text input mode and returns to command mode,
where the prompt is redisplayed.
When
vi
first starts running, it is in command mode as well.
There are eleven commands that switch
vi
into text input mode:
A ,
a ,
C ,
c ,
I ,
i ,
O ,
o ,
R ,
S
and
s .
Once in input mode, entering an
<escape>character ends text input mode and returns to command mode.
Ex/vi present three different interfaces to editing a file. Ex presents a line oriented interface. Vi presents a full screen display oriented interface, also known as "visual mode". In addition, there is a third mode, "open mode", which is line oriented, but supports cursor movement and editing within the displayed line, similarly to visual mode. Open mode is not yet implemented in nvi .
The following words have special meanings in both the ex and vi command descriptions:
The interrupt character is used to interrupt the current operation.
Normally
<control-C>,
whatever character is set for the current terminal is used.
The literal next character is used to escape the subsequent character
from any special meaning.
This character is always
<control-V>.
If the terminal is not set up to do XON/XOFF flow control,
then
<control-Q>is used to mean literal next as well.
The pathname of the file currently being edited by vi.
When the percent character
"%"
appears in a file name entered as part of an
ex
command argument, it is replaced by the current pathname.
(The
"%"
character can be escaped by preceding it with a backslash.)
The name of the last file name mentioned in an
ex
command, or,
the previous current pathname if the last file mentioned
becomes the current file.
When the hash mark character
"#"
appears in a file name entered as part of an
ex
command argument, it is replaced by the alternate pathname.
(The
"#"
character can be escaped by preceding it with a backslash.)
One of a number of named areas for saving copies of text.
Commands that change or delete text can save the changed or deleted
text into a specific buffer, for later use, if the command allows
it (i.e. the
ex
change
command cannot save the changed text in a named buffer).
Buffers are named with a single character, preceded by a double quote,
e.g.
"<character>"
in
vi
and
without the double quote, e.g.
<character>,
in
ex .
(The double quote isn't necessary for
ex
because buffers names are denoted by their position in the command line.)
Historic implementations of
ex/vi
limited
<character>to the alphanumeric characters;
nex/nvi
permits the use of any character without another meaning in the position
where a buffer name is expected.
Buffers named by uppercase characters are the same as buffers
named by lowercase characters, e.g. the buffer named by the
English character
"A"
is the same as the buffer named by the character
"a",
with the exception that, if the buffer contents are being changed (as
with a text deletion or
vi
change
command), the text is
appended
to the buffer, instead of replacing the current contents.
The buffers named by the numeric characters (in English,
"1"
through
"9"),
are special.
If a region of text including characters from more than one line,
or a single line of text specified by using a line-oriented motion,
is changed or deleted in the file using the
vi
change
or
delete
commands, a copy of the text is placed into the numeric buffer
"1",
regardless of the user specifying another buffer in which to save it.
In addition, there are a few commands which, when used as a
motionwith the
vi
change
and
delete
commands,
always
copy the specified region of text into the numeric buffers regardless
of the region including characters from more than one line.
These commands are:
| <control-A> | % | ( | )
|
| `<character> | / | ? | N
|
| n | { | }
|
Before this copy is done, the previous contents of buffer
"1"
are moved into buffer
"2",
"2"
into buffer
"3",
and so on.
The contents of buffer
"9"
are discarded.
In
vi ,
text may be explicitly stored into the numeric buffers.
In this case, the buffer rotation described above occurs before the
replacement of the buffer's contents.
The numeric buffers are only available in
visualand
openmodes,
and are not accessible by
ex
in any way, although changed and deleted text is still stored there
while in
ex
mode.
When a
vi
command synopsis shows both a
[buffer]and a
[count],
they may be presented in any order.
Finally, all buffers are either "line" or "character" oriented. All ex commands which store text into buffers are line oriented. Some vi commands which store text into buffers are line oriented, and some are character oriented; the description for each applicable vi command notes whether text copied into buffers using the command is line or character oriented. In addition, the vi command display buffers displays the current orientation for each buffer. Generally, the only importance attached to this orientation is that if the buffer is subsequently inserted into the text, line oriented buffers create new lines for each of the lines they contain, and character oriented buffers create new lines for any lines other than the first and last lines they contain. The first and last lines are inserted into the text at the current cursor position, becoming part of the current line. If there is more than one line in the buffer, however, the current line itself will be split.
The unnamed buffer is a text storage area which is used by commands
that use or operate on a buffer when no buffer is specified by the user.
If the command stores text into a buffer,
the text is stored into the unnamed buffer even if a buffer is also
specified by the user.
It is not possible to append text to the unnamed buffer.
If text is appended to a named buffer,
the named buffer contains both the old and new text,
while the unnamed buffer contains only the new text.
There is no way to explicitly reference the unnamed buffer.
Historically, the contents of the unnamed buffer were discarded by many different commands, even ones that didn't store text into it. Nex/nvi never discards the contents of the unnamed buffer until new text replaces them.
The characters <tab> and <space>.
The character represented by an ASCII
<control-M>.
This character is almost always treated identically to a
<newline>character, but differs in that it can be escaped into the file text or
into a command.
The character represented by an ASCII
<control-J>.
This character is almost always treated identically to a
<control-M>character, but differs in that it cannot be escaped into the file text or
into a command.
Vi takes up the entire screen to display the edited file,
except for the bottom line of the screen.
The bottom line of the screen is used to enter
exp
commands, and for
vi
error and informational messages.
If no other information is being displayed,
the default display can show the current cursor row and cursor column,
an indication of whether the file has been modified,
and the current mode of the editor.
See the
ruler
and
showmode
options for more information.
Empty lines do not have any special representation on the screen,
but lines on the screen that would logically come after the end of
the file are displayed as a single tilde
"~"
character.
To differentiate between empty lines and lines consisting of only
whitespace characters, use the
list
option.
Historically, implementations of
vi
have also displayed some lines as single asterisk
"@"
characters.
These were lines that were not correctly displayed, i.e. lines on the
screen that did not correspond to lines in the file, or lines that did
not fit on the current screen.
Nvi
never displays lines in this fashion.
Vi
is a modeful editor, i.e. it has two modes,
"command"
mode and
"text input"
mode.
When
vi
first starts, it is in command mode.
There are several commands that change
vi
into text input mode.
The
<escape>character is used to resolve the text input into the file,
and exit back into command mode.
In
vi
command mode, the cursor is always positioned on the last column of
characters which take up more than one column on the screen.
In
vi
text insert mode, the cursor is positioned on the first column of
characters which take up more than one column on the screen.
When positioning the cursor to a new line and column,
the type of movement is defined by the distance to the new cursor position.
If the new position is close,
the screen is scrolled to the new location.
If the new position is far away,
the screen is repainted so that the new position is on the screen.
If the screen is scrolled,
it is moved a minimal amount,
and the cursor line will usually appear at the top or bottom of the screen.
If the screen is repainted,
the cursor line will appear in the center of the screen,
unless the cursor is sufficiently close to the beginning or end of the file
that this isn't possible.
If the
leftright
option is set, the screen may be scrolled or repainted in a horizontal
direction as well as in a vertical one.
A major difference between the historical vi presentation and nvi is in the scrolling and screen oriented position commands, <control-B>, <control-D>, <control-E>, <control-F>, <control-U>, <control-Y>, H, L and M. In historical implementations of vi, these commands acted on physical (as opposed to logical, or screen) lines. For lines that were sufficiently long in relation to the size of the screen, this meant that single line scroll commands might repaint the entire screen, scrolling or screen positioning commands might not change the screen or move the cursor at all, and some lines simply could not be displayed, even though vi would edit the file that contained them. In nvi, these commands act on logical, i.e. screen lines. You are unlikely to notice any difference unless you are editing files with lines significantly longer than a screen width.
Vi keeps track of the currently "most attractive" cursor position. Each command description (for commands that alter the current cursor position), specifies if the cursor is set to a specific location in the line, or if it is moved to the "most attractive cursor position". The latter means that the cursor is moved to the cursor position that is horizontally as close as possible to the current cursor position. If the current line is shorter than the cursor position vi would select, the cursor is positioned on the last character in the line. (If the line is empty, the cursor is positioned on the first column of the line.) If a command moves the cursor to the most attractive position, it does not alter the current cursor position, and a subsequent movement will again attempt to move the cursor to that position. Therefore, although a movement to a line shorter than the currently most attractive position will cause the cursor to move to the end of that line, a subsequent movement to a longer line will cause the cursor to move back to the most attractive position.
In addition, the $ command makes the end of each line the most attractive cursor position rather than a specific column.
Each vi command described below notes where the cursor ends up after it is executed. This position is described in terms of characters on the line, i.e. "the previous character", or, "the last character in the line". This is to avoid needing to continually refer to on what part of the character the cursor rests.
The following words have special meaning for vi commands.
The position of the cursor before the command which caused the last absolute movement was executed. Each vi command described in the next section that is considered an absolute movement is so noted. In addition, specifying any address to an ex command is considered an absolute movement.
A second
vi
command can be used as an optional trailing argument to the
vi
<,
>,
!,
c,
d,
y,
and (depending on the
tildeop
option)
~
commands.
This command indicates the end of the region of text that's affected by
the command.
The motion command may be either the command character repeated (in
which case it means the current line) or a cursor movement command.
In the latter case, the region affected by the command is from the
starting or stopping cursor position which comes first in the file,
to immediately before the starting or stopping cursor position which
comes later in the file.
Commands that operate on lines instead of using beginning and ending
cursor positions operate on all of the lines that are wholly or
partially in the region.
In addition, some other commands become line oriented depending on
where in the text they are used.
The command descriptions below note these special cases.
The following commands may all be used as motion components for
vi
commands:
| <control-A> | <control-H> | <control-J> | <control-M>
|
| <control-N> | <control-P> | <space> | $
|
| % | '<character> | ( | )
|
| + | , | - | /
|
| 0 | ; | ? | B
|
| E | F | G | H
|
| L | M | N | T
|
| W | [[ | ]] | ^
|
| _ | `<character> | b | e
|
| f | h | j | k
|
| l | n | t | w
|
| { | | | }
|
The optional count prefix available for some of the
vi
commands that take motion commands,
or the count prefix available for the
vi
commands that are used as motion components,
may be included and is
always
considered part of the motion argument.
For example, the commands
"c2w"
and
"2cw"
are equivalent, and the region affected by the
c
command is two words of text.
In addition,
if the optional count prefix is specified for both the
vi
command and its motion component,
the effect is multiplicative and is considered part of the motion argument.
For example, the commands
"4cw"
and
"2c2w"
are equivalent, and the region affected by the
c
command is four words of text.
A positive number used as an optional argument to most commands,
either to give a size or a position (for display or movement commands),
or as a repeat count (for commands that modify text).
The count argument is always optional and defaults to 1 unless otherwise
noted in the command description.
When a
vi
command synopsis shows both a
[buffer]and
[count],
they may be presented in any order.
Generally, in languages where it is applicable,
vi
recognizes two kinds of words.
First, a sequence of letters, digits and underscores,
delimited at both ends by:
characters other than letters, digits, or underscores,
the beginning or end of a line, and the beginning or end of the file.
Second, a sequence of characters other than letters, digits, underscores,
or whitespace characters, delimited at both ends by: a letter, digit,
underscore, or whitespace character,
the beginning or end of a line, and the beginning or end of the file.
For example, the characters
"!@#abc$%^ "
contain three words:
"!@#",
"abc"
and
"$%^".
Groups of empty lines (or lines containing only whitespace characters) are treated as a single word.
A set of non-whitespace characters preceded and followed by whitespace
characters or the beginning or end of the file or line.
For example, the characters
"!@#abc$%^ "
contain one bigword:
"!@#abc$%^".
Groups of empty lines (or lines containing only whitespace characters) are treated as a single bigword.
An area of text that begins with either the beginning of a file,
an empty line, or a section boundary, and continues until either
an empty line, section boundary, or the end of the file.
Groups of empty lines (or lines containing only whitespace characters)
are treated as a single paragraph.
Additional paragraph boundaries can be defined using the
paragraphs
option.
An area of text that starts with the beginning of the file or a line
whose first character is an open brace
"{"
and continues until the next section or the end of the file.
Additional section boundaries can be defined using the
sections
option.
An area of text that begins with either the beginning of the file or the
first nonblank character following the previous sentence, paragraph, or
section boundary and continues until the end of the file or a period
"."
exclamation point
"!"
or question mark
"?"
character,
followed by either an end-of-line or two whitespace characters.
Any number of closing parentheses
")",
brackets
"]",
double-quote
"""
or single quote
"'"
characters can appear between the period, exclamation point,
or question mark and the whitespace characters or end-of-line.
Groups of empty lines (or lines containing only whitespace characters) are treated as a single sentence.
The following section describes the commands available in the command mode of the vi editor. In each entry below, the tag line is a usage synopsis for the command character. In addition, the final line and column the cursor rests upon, and any options which affect the command are noted.
| [count] |
Command |
|
Search forward
The <control-A> command is an absolute movement. The <control-A> command may be used as the motion component of other vi commands, in which case any text copied into a buffer is character oriented.
|
| [count] |
Command |
|
Page backward
|
| [count] |
Command |
|
Scroll forward
|
| [count] |
Command |
|
Scroll forward
|
| [count] |
Command |
|
Page forward
|
| |
Command |
|
Display the file information. The information includes the current pathname, the current line, the number of total lines in the file, the current line as a percentage of the total lines in the file, if the file has been modified, was able to be locked, if the file's name has been changed, and if the edit session is read-only.
|
| [count] |
Command |
| [count] h | Command |
Move the cursor back
countcharacters in the current line.
It is an error if the cursor is on the first character in the line.
The <control-H> and h commands may be used as the motion component of other vi commands, in which case any text copied into a buffer is character oriented.
|
| [count] |
Command |
| [count] |
Command |
| [count] j | Command |
Move the cursor down
countlines without changing the current column.
It is an error if the movement is past the end of the file.
The <control-J>, <control-N> and j commands may be used as the motion component of other vi commands, in which case any text copied into a buffer is line oriented.
|
| |
Command |
| |
Command |
Repaint the screen.
|
| [count] |
Command |
| [count] + | Command |
Move the cursor down
countlines to the first nonblank character of that line.
It is an error if the movement is past the end of the file.
The <control-M> and + commands may be used as the motion component of other vi commands, in which case any text copied into a buffer is line oriented.
|
| [count] |
Command |
| [count] k | Command |
Move the cursor up
countlines, without changing the current column.
It is an error if the movement is past the beginning of the file.
The <control-P> and k commands may be used as the motion component of other vi commands, in which case any text copied into a buffer is line oriented.
|
| |
Command |
|
Return to the most recent tag context. The <control-T> command is an absolute movement.
|
| [count] |
Command |
|
Scroll backward
|
| |
Command |
|
Switch to the next lower screen in the window, or, to the first screen if there are no lower screens in the window.
|
| [count] |
Command |
|
Scroll backward
|
| |
Command |
|
Suspend the current editor session.
If the file has been modified since it was last completely written,
and the
|
| |
Command |
|
Execute
ex
commands or cancel partial commands.
If an
ex
command is being entered (e.g.
/,
?,
:
or
!),
the command is executed.
If a partial command has been entered, e.g.
"
|
| |
Command |
|
Push a tag reference onto the tag stack.
The tags files (see the
If the current file has been modified since it was last completely written, the command will fail. The <control-]> command is an absolute movement.
|
| |
Command |
|
Switch to the most recently edited file.
If the file has been modified since it was last completely written,
and the
|
| [count] |
Command |
| [count] l | Command |
Move the cursor forward
countcharacters without changing the current line.
It is an error if the cursor is on the last character in the line.
The <space> and l commands may be used as the motion component of other vi commands, in which case any text copied into a buffer is character oriented. In addition, these commands may be used as the motion components of other commands when the cursor is on the last character in the line, without error.
|
| [count] ! motion shell-argument(s) |
Command |
|
Replace text with results from a shell command.
Pass the lines specified by the
After the motion is entered,
vi
prompts for arguments to the shell command.
Within those arguments,
"
Vi
then executes the program named by the
The
!
command is permitted in an empty file.
If the file has been modified since it was last completely written, the ! command will warn you.
|
| [count] # #|+|- | Command |
|
Increment or decrement the number referenced by the cursor.
If the trailing character is a
A leading
"
Octal and hexadecimal numbers, and the result of the operation, must fit
into an
"
|
| [count] $ | Command |
|
Move the cursor to the end of a line.
If
It is not an error to use the
$
command when the cursor is on the last character in the line or
when the line is empty.
The $ command may be used as the motion component of other vi commands, in which case any text copied into a buffer is character oriented, unless the cursor is at, or before the first nonblank character in the line, in which case it is line oriented. It is not an error to use the $ command as a motion component when the cursor is on the last character in the line, although it is an error when the line is empty.
|
| % | Command |
|
Move to the matching character.
The cursor moves to the parenthesis or curly brace which
matches
the parenthesis or curly brace found at the current cursor position
or which is the closest one to the right of the cursor on the line.
It is an error to execute the
%
command on a line without a parenthesis or curly brace.
Historically, any
The % command is an absolute movement. The % command may be used as the motion component of other vi commands, in which case any text copied into a buffer is character oriented, unless the starting point of the region is at or before the first nonblank character on its line, and the ending point is at or after the last nonblank character on its line, in which case it is line oriented.
|
| & | Command |
|
Repeat the previous substitution command on the current line.
Historically, any
|
| ' |
Command |
| ` |
Command |
Return to a context marked by the character
<character>.
If
<character>is the
"'"
or
"`"
character, return to the previous context.
If
<character>is any other character,
return to the context marked by that character (see the
m
command for more information).
If the command is the
'
command, only the line value is restored,
and the cursor is placed on the first nonblank character of that line.
If the command is the
`
command, both the line and column values are restored.
It is an error if the context no longer exists because of
line deletion.
(Contexts follow lines that are moved, or which are deleted
and then restored.)
The ' and ` commands are both absolute movements. They may be used as a motion component for other vi commands. For the ' command, any text copied into a buffer is line oriented. For the ` command, any text copied into a buffer is character oriented, unless it both starts and stops at the first character in the line, in which case it is line oriented. In addition, when using the ` command as a motion component, commands which move backward and started at the first character in the line, or move forward and ended at the first character in the line, are corrected to the last character of the line preceding the starting and ending lines, respectively.
|
| [count] ( | Command |
|
Back up
The ( command is an absolute movement. The ( command may be used as the motion component of other vi commands, in which case any text copied into a buffer is character oriented, unless the starting and stopping points of the region are the first character in the line, in which case it is line oriented. If it is line oriented, the starting point of the region is adjusted to be the end of the line immediately before the starting cursor position.
|
| [count] ) | Command |
|
Move forward
The ) command is an absolute movement. The ) command may be used as the motion component of other vi commands, in which case any text copied into a buffer is character oriented, unless the starting point of the region is the first character in the line, in which case it is line oriented. In the latter case, if the stopping point of the region is also the first character in the line, it is adjusted to be the end of the line immediately before it.
|
| [count] , | Command |
|
Reverse find character
The , command may be used as the motion component of other vi commands, in which case any text copied into a buffer is character oriented.
|
| [count] - | Command |
|
Move to the first nonblank of the previous line,
It is an error if the movement is past the beginning of the file.
The - command may be used as the motion component of other vi commands, in which case any text copied into a buffer is line oriented.
|
| [count] . | Command |
|
Repeat the last
vi
command that modified text.
The repeated command may be a command and motion component combination.
If
As a special case, if the . command is executed immediately after the u command, the change log is rolled forward or backward, depending on the action of the u command.
|
| /RE |
Command |
| /RE/ [ | Command |
| ?RE |
Command |
| ?RE? [ | Command |
| N | Command |
| n | Command |
Search forward or backward for a regular expression.
The commands beginning with a slash
"/"
character are forward searches, the commands beginning with a
question mark
"?"
are backward searches.
Vi
prompts with the leading character on the last line of the screen
for a string.
It then searches forward or backward in the file for the next
occurrence of the string, which is interpreted as a Basic Regular
Expression.
The
/
and
?
commands are absolute movements.
They may be used as the motion components of other
vi
commands, in which case any text copied into a buffer is
character oriented, unless the search started and ended on
the first column of a line, in which case it is line oriented.
In addition, forward searches ending at the first character of a line,
and backward searches beginning at the first character in the line,
are corrected to begin or end at the last character of the previous line.
(Note, forward and backward searches can occur for both
/
and
?
commands, if the
If an offset from the matched line is specified (i.e. a trailing
"
The
N
command repeats the previous search, but in the reverse direction.
The
n
command repeats the previous search.
If either the
N
or
n
commands are used as motion components for the
!
command, you will not be prompted for the text of the bang command,
instead the previous bang command will be executed.
Missing RE's (e.g.
"
Searches may be interrupted using the
Multiple search patterns may be grouped together by delimiting
them with semicolons and zero or more whitespace characters, e.g.
It is also permissible to append a
z
command to the search strings, e.g.
|
| 0 | Command |
|
Move to the first character in the current line.
It is not an error to use the
0
command when the cursor is on the first character in the line,
The 0 command may be used as the motion component of other vi commands, in which case it is an error if the cursor is on the first character in the line, and any text copied into a buffer is character oriented.
|
| : | Command |
|
Execute an
ex
command.
Vi
prompts for an
ex
command on the last line of the screen, using a colon
"
If the
ex
command writes to the screen,
vi
will prompt the user for a
When the
ex
command finishes, and the user is prompted to resume visual mode,
it is also possible to enter another
"
|
| [count] ; | Command |
|
Repeat the last character find
The ; command may be used as the motion component of other vi commands, in which case any text copied into a buffer is character oriented.
|
| [count] < motion | Command |
| [count] > motion | Command |
Shift lines left or right.
Shift the number of lines in the region specified by the
countand
motionleft (for the
<
command) or right (for the
>
command) by the number of columns specified by the
shiftwidth
option.
Only whitespace characters are deleted when shifting left.
Once the first character in the line no longer contains a whitespace
character, the command will succeed,
but the line will not be modified.
|
| @@ buffer | Command |
|
Execute a named buffer.
Execute the named buffer as
vi
commands.
The buffer may include
ex
commands, too, but they must be expressed as a
:
command.
If the buffer is line oriented,
If the buffer name is
"
|
| [count] A | Command |
|
Enter input mode, appending the text after the end of the line.
If
|
| [count] B | Command |
|
Move backward
The B command may be used as the motion component of other vi commands, in which case any text copied into a buffer is character oriented.
|
| [buffer] [count] C | Command |
|
Change text from the current position to the end-of-line.
If
|
| [buffer] D | Command |
|
Delete text from the current position to the end-of-line.
It is not an error to execute the D command on an empty line.
|
| [count] E | Command |
|
Move forward
The E command may be used as the motion component of other vi commands, in which case any text copied into a buffer is character oriented.
|
| [count] F |
Command |
|
Search
The F command may be used as the motion component of other vi commands, in which case any text copied into a buffer is character oriented.
|
| [count] G | Command |
|
Move to line
The G command is an absolute movement. The G command may be used as the motion component of other vi commands, in which case any text copied into a buffer is line oriented.
|
| [count] H | Command |
|
Move to the screen line
The H command is an absolute movement. The H command may be used as the motion component of other vi commands, in which case any text copied into a buffer is line oriented.
|
| [count] I | Command |
|
Enter input mode, inserting the text at the beginning of the line.
If
|
| [count] J | Command |
|
Join lines.
If
If the current line ends with a whitespace character, all whitespace
is stripped from the next line.
Otherwise, if the next line starts with a open parenthesis
"
It is not an error to join lines past the end of the file, i.e. lines that do not exist.
|
| [count] L | Command |
|
Move to the screen line
The L command is an absolute movement. The L command may be used as the motion component of other vi commands, in which case any text copied into a buffer is line oriented.
|
| M | Command |
|
Move to the screen line in the middle of the screen.
The
M
command is an absolute movement.
The
M
command may be used as the motion component of other
vi
commands, in which case any text copied into a buffer is
line oriented.
Historically, any
|
| [count] O | Command |
|
Enter input mode, appending text in a new line above the current line.
If
Historically, any
|
| [buffer] P | Command |
|
Insert text from a buffer. Text from the buffer (the unnamed buffer by default) is inserted before the current column or, if the buffer is line oriented, before the current line.
|
| Q | Command |
|
Exit vi (or visual) mode and switch to ex mode.
|
| [count] R | Command |
|
Enter input mode, replacing the characters in the current line.
If
If the end of the current line is reached, no more characters are replaced and any further characters input are appended to the line.
|
| [buffer] [count] S | Command |
|
Substitute
|
| [count] T |
Command |
|
Search backward,
The T command may be used as the motion component of other vi commands, in which case any text copied into a buffer is character oriented.
|
| U | Command |
|
Restore the current line to its state before the cursor last moved to it.
|
| [count] W | Command |
|
Move forward
The W command may be used as the motion component of other vi commands, in which case any text copied into a buffer is character oriented.
|
| [buffer] [count] X | Command |
|
Delete
|
| [buffer] [count] Y | Command |
|
Copy (or
"yank")
|
| ZZ | Command |
|
Write the file and exit
vi.
The file is only written if it has been modified since the last
complete write of the file to any file.
The ZZ command will exit the editor after writing the file, if there are no further files to edit. Entering two "quit" commands (i.e. wq, quit, xit or ZZ) in a row will override this check and the editor will exit, ignoring any files that have not yet been edited.
|
| [count] [[ | Command |
|
Back up
The
[[
command is an absolute movement.
The
[[
command may be used as the motion component of other
vi
commands, in which case any text copied into a buffer is
character oriented, unless the starting position is column 0,
in which case it is line oriented.
It is an error if the movement is past the beginning of the file.
|
| [count] ]] | Command |
|
Move forward
The
]]
command is an absolute movement.
The
]]
command may be used as the motion component of other
vi
commands, in which case any text copied into a buffer is
character oriented, unless the starting position is column 0,
in which case it is line oriented.
It is an error if the movement is past the end of the file.
|
| ^ | Command |
|
Move to first nonblank character on the current line.
The ^ command may be used as the motion component of other vi commands, in which case any text copied into a buffer is character oriented.
|
| [count] _ | Command |
|
Move down
It is not an error to execute the _ command when the cursor is on the first character in the line.
|
| [count] a | Command |
|
Enter input mode, appending the text after the cursor.
If
|
| [count] b | Command |
|
Move backward
The b command may be used as the motion component of other vi commands, in which case any text copied into a buffer is character oriented.
|
| [buffer] [count] c motion | Command |
|
Change the region of text specified by the
|
| [buffer] [count] d motion | Command |
|
Delete the region of text specified by the
|
| [count] e | Command |
|
Move forward
The e command may be used as the motion component of other vi commands, in which case any text copied into a buffer is character oriented.
|
| [count] f |
Command |
|
Search forward,
The f command may be used as the motion component of other vi commands, in which case any text copied into a buffer is character oriented.
|
| [count] i | Command |
|
Enter input mode, inserting the text before the cursor.
If
|
| m |
Command |
|
Save the current context (line and column) as
Historically,
|
| [count] o | Command |
|
Enter input mode, appending text in a new line under the current line.
If
Historically, any
|
| [buffer] p | Command |
|
Append text from a buffer. Text from the buffer (the unnamed buffer by default) is appended after the current column or, if the buffer is line oriented, after the current line.
|
| [count] r |
Command |
|
Replace characters.
The next
If
|
| [buffer] [count] s | Command |
|
Substitute
|
| [count] t |
Command |
|
Search forward,
The t command may be used as the motion component of other vi commands, in which case any text copied into a buffer is character oriented.
|
| u | Command |
|
Undo the last change made to the file.
If repeated, the
u
command alternates between these two states, and is its own inverse.
When used after an insert that inserted text on more than one line,
the lines are saved in the numeric buffers.
The . command, when used immediately after the u command, causes the change log to be rolled forward or backward, depending on the action of the u command.
|
| [count] w | Command |
|
Move forward
|