:ta <name> | Search in the tags file where <name>
| is defined (file, line), and go to it.
^] | Use the name under the cursor in a `:ta'
| command.
:[x,y]g/<string>/<cmd> | Search globally [from line x to y] for
| <string> and execute the `ex' <cmd> on
| each occurrence.
:[x,y]v/<string>/<cmd> | Execute <cmd> on the lines that don't
| match.

u | Undo the latest change.
U | Undo all changes on a line, while not
| having moved off it (unfortunately).
:q! | Quit vi without writing.
:e! | Re-edit a messed-up file.

Appending Text (end with <esc>)

* | a | <*> times after the cursor.
* | A | <*> times at the end of line.
* | i | <*> times before the cursor (insert).
* | I | <*> times before the first CHAR of the line
* | o | On a new line below the current (open).
| The count is only useful on a slow terminal.
* | O | On a new line above the current.
| The count is only useful on a slow terminal.
* | ><move> | Shift the lines described by <*><move> one
| shiftwidth to the right (layout!).
* | >> | Shift <*> lines one shiftwidth to the right.
* | ["<a-z1-9>]p | Put the contents of the (default undo)
| buffer <*> times after the cursor.
| A buffer containing lines is put only once,
| below the current line.
* | ["<a-z1-9>]P | Put the contents of the (default undo) buffer
| <*> times before the cursor.
| A buffer containing lines is put only once,
| above the current line.
* | . | Repeat previous command <*> times.
| If the last command before a `.' command
| references a numbered buffer, the buffer number
| is incremented first (and the count is ignored):
|
| "1pu.u.u.u.u - `walk through' buffers 1
| through 5
| "1P.... - restore them

Everything deleted can be stored into a buffer. This is
achieved by putting a `"' and a letter <a-z> before
the delete command. The deleted text will be in the buffer
with the used letter. If <A-Z> is used as buffer
name, the adjugate buffer <a-z> will be augmented
instead of overwritten with the text. The undo buffer
always contains the latest change. Buffers <1-9>
contain the latest 9 LINE deletions (`"1' is most
recent).

The basic meta-characters for the replacement pattern
are `&' and `~'; these are given as `' and `~' when
nomagic is set. Each instance of `&' is replaced by the
characters which the regular expression matched. The
meta-character `~' stands, in the replacement pattern, for
the defining text of the previous replacement pattern.
Other meta-sequences possible in the replacement pattern
are always introduced by the escaping character `'. The
sequence `0 (with `n' in [1-9]) is replaced by the text
matched by the n-th regular subexpression enclosed between
` and `)'. The sequences ` 8' and ` in the replacement to
be converted to upper- or lower-case respectively if this
character is a letter. The sequences `U' and ` or `\' is
encountered, or until the end of the replacement
pattern.

With yank commands you can put `"<a-z>' before the
command, just as with delete commands. Otherwise you only
copy to the undo buffer. The use of buffers <a-z> is
THE way of copying text to another file; see the `:e
<file>' command.

^@ | If typed as the first character of the
| insertion, it is replaced with the previous
| text inserted (max. 128 chars), after which
| the insertion is terminated.
^V | Deprive the next char of its special meaning
| (e.g. <esc>).
^D | One shiftwidth to the left.
0^D | Remove all indentation on the current line
| (there must be no other chars on the line).
^^D | Idem, but it is restored on the next line.
^T | one shiftwidth to the right
^H | <erase> | One char back.
^W | One word back.
<kill> | Back to the begin of the change on the
| current line.
<intr> | like <esc>.

In `:' `ex' commands `%' denotes the current file, `#'
is a synonym for the alternate file (which normally is the
previous file). Marks can be used for line numbers too:
'<a-z>. In the `:w'|`:f'|`:cd'|`:e'|`:n' commands
shell meta-characters can be used.

:q | Quit vi, unless the buffer has been changed.
:q! | Quit vi without writing.
^Z | Suspend vi.
:w | Write the file.
:w <name> | Write to the file <name>.
:w >> <name> | Append the buffer to the file <name>.
:w! <name> | Overwrite the file <name>.
:x,y w <name> | Write lines x through y to the file <name>.
:wq | Write the file and quit vi; some versions quit
| even if the write was unsuccessful!
| Use `ZZ' instead.
ZZ | Write if the buffer has been changed, and
| quit vi. If you have invoked vi with the `-r'
| option, you'd better write the file
| explicitly (`w' or `w!'), or quit the
| editor explicitly (`q!') if you don't want
| to overwrite the file - some versions of vi
| don't handle the `recover' option very well.
:x [<file>] | Same as ZZ [but write to <file>].
:x! [<file>] | `:w![<file>]' and `:q'.
:pre | Preserve the file - the buffer is saved as if
| the system had just crashed; for emergencies,
| when a `:w' command has failed and you don't
| know how to save your work (see `vi -r').
:f <name> | Set the current filename to <name>.
:cd [<dir>] | Set the working directory to <dir>
| (default home directory).
:cd! [<dir>] | Idem, but don't save changes.
:e [+<cmd>] <file> | Edit another file without quitting vi - the
| buffers are not changed (except the undo
| buffer), so text can be copied from one file to
| another this way. [Execute the `ex' command
| <cmd> (default `$') when the new file has been
| read into the buffer.] <cmd> must contain no
| <sp> or <ht>. See `vi startup'.
:e! [+<cmd>] <file> | Idem, without writing the current buffer.
^^ | Edit the alternate (normally the previous)
| file.
:rew | Rewind the argument list, edit the first file.
:rew! | Idem, without writing the current buffer.
:n [+<cmd>] [<files>] | Edit next file or specify a new argument list.
:n! [+<cmd>] [<files>] | Idem, without writing the current buffer.
:args | Give the argument list, with the current file
| between `[' and `]'.

If in the next commands the field <wi> is present,
the windowsize will change to <wi>. The window will
always be displayed at the bottom of the screen.

[*]z[wi]<cr> | Put line <*> at the top of the window
| (default the current line).
[*]z[wi]+ | Put line <*> at the top of the window
| (default the first line of the next page).
[*]z[wi]- | Put line <*> at the bottom of the window
| (default the current line).
[*]z[wi]. | Put line <*> in the centre of the window
| (default the current line).

Q | ^ | <intr><intr> | Switch from vi to `ex'.
: | An `ex' command can be given.
:vi | Switch from `ex' to vi.
:sh | Execute a subshell, back to vi by `^D'.
:[x,y]!<cmd> | Execute a shell <cmd> [on lines x through y;
| these lines will serve as input for <cmd> and
| will be replaced by its standard output].
:[x,y]!! [<args>] | Repeat last shell command [and append <args>].
:[x,y]!<cmd> ! [<args>] | Use the previous command (the second `!') in a
| new command.
[*]!<move><cmd> | The shell executes <cmd>, with as standard
| input the lines described by <*><move>,
| next the standard output replaces those lines
| (think of `cb', `sort', `nroff', etc.).
[*]!<move>!<args> | Append <args> to the last <cmd> and execute it,
| using the lines described by the current
| <*><move>.
[*]!!<cmd> | Give <*> lines as standard input to the
| shell <cmd>, next let the standard output
| replace those lines.
[*]!!! [<args>] | Use the previous <cmd> [and append
| <args> to it].
:x,y w !<cmd> | Let lines x to y be standard input for <cmd>
| (notice the <sp> between `w' and `!').
:r!<cmd> | Put the output of <cmd> onto a new line.
:r <name> | Read the file <name> into the buffer.

However, the list of initializations can also be put
into a file. If this file is located in your home
directory, and is named `.exrc' AND the variable `EXINIT'
is NOT set, the list will be executed automatically at
startup time. However, vi will always execute the contents
of a `.exrc' in the current directory, if you own the file.
Else you have to give the execute command yourself:

:source file

or

:so file

On-line initializations can be given with `vi
+<cmd> file', e.g.:

vi +x file | The cursor will immediately jump to line x
| (default last line).
vi +/<string> file | ~ to the first occurrence of <string>.

You can start at a particular tag with:

vi -t <tag> | Start in the right file in the right place.

Sometimes (e.g. if the system crashed while you were
editing) it is possible to recover files lost in the editor
by `vi -r file'. If you just want to view a file by using
vi, and you want to avoid any change, instead of vi you can
use the `view' or `vi -R' command: the option `readonly'
will be set automatically (with `:w!' you can override this
option).

ai | autoindent - In append mode after a <cr> the
| cursor will move directly below the first
| CHAR on the previous line. However, if the
| option `lisp' is set, the cursor will align
| at the first argument to the last open list.
aw | autowrite - Write at every shell escape.
| (useful when compiling from within vi)
dir=<string> | directory - The directory for vi to make
| temporary files (default `/tmp').
eb | errorbells - Beeps when you goof
| (not on every terminal).
ic | ignorecase - No distinction between upper and
| lower cases when searching.
lisp | Redefine the following commands:
| `(', `)' - move backward (forward) over
| S-expressions
| `{', `}' - idem, but don't stop at atoms
| `[[', `]]' - go to previous (next) line
| beginning with a `('
| See option `ai'.
list | <lf> is shown as `$', <ht> as `^I'.
magic | If this option is set (default), the chars `.',
| `[' and `*' have special meanings within
| search and `ex' substitute commands. To
| deprive such a char of its special function
| it must be preceded by a `'. If the option
| is turned off it's just the other way around.
| Meta-chars:
| ^<string> - <string> must begin the line
| <string>$ - <string> must end the line
| . - matches any char
| [a-z] - matches any char in the range
| [<string>] - matches any char in <string>
| [^<string>] - matches any char not in <string>
| <char>* - 0 or more <char>s
| <<string>> - <string> must be a word
nu | number - Numbers before the lines.
para=<string> | paragraphs - Every pair of chars in <string>
| is considered a paragraph delimiter
| nroff macro (for `{' and `}'). A <sp>
| preceded by a `' indicates the previous char
| is a single letter macro. `:set para=P bp'
| introduces `.P' and `.bp' as paragraph
| delimiters. Empty lines and section
| boundaries are paragraph boundaries too.
redraw | The screen remains up to date.
remap | If on (default), macros are repeatedly
| expanded until they are unchanged.
| Example: if `o' is mapped to `A', and `A'
| is mapped to `I', then `o' will map to `I'
| if `remap' is set, else it will map to `A'.
report=<*> | Vi reports whenever e.g. a delete
| or yank command affects <*> or more lines.
ro | readonly - The file is not to be changed.
| However, `:w!' will override this option.
sect=<string> | sections - Gives the section delimiters
| (for `[[' and `]]'); see option `para'.
| A `{' beginning a line also starts a section
| (as in C functions).
sh=<string> | shell - The program to be used for shell
| escapes (default `$SHELL'
| (default `/bin/sh')).
sw=<*> | shiftwidth - Gives the shiftwidth (default 8
| positions).
sm | showmatch - Whenever you append a `)', vi shows
| its match if it's on the same page; also with
| `{' and `}'. If there's no match, vi will beep.
terse | Short error messages.
to | timeout - If this option is set, append mode
| mappings will be interpreted only if they're
| typed fast enough.
ts=<*> | tabstop - The length of a <ht>; warning: this is
| only IN the editor, outside of it <ht>s have
| their normal length (default 8 positions).
wa | writeany - No checks when writing (dangerous).
warn | Warn you when you try to quit without writing.
wi=<*> | window - The default number of lines vi shows.
wm=<*> | wrapmargin - In append mode vi automatically
| puts a <lf> whenever there is a <sp> or <ht>
| within <wm> columns from the right margin.
ws | wrapscan - When searching, the end is
| considered `stuck' to the begin of the file.
|
:set <option> | Turn <option> on.
:set no<option> | Turn <option> off.
:set <option>=<value> | Set <option> to <value>.
:set | Show all non-default options and their values.
:set <option>? | Show <option>'s value.
:set all | Show all options and their values.