Vim reference manual
By Bram Moolenaar
version 3.0
There is a contents listing at the end of this document.
The commands and options for multiple windows and buffers are explained in a
separate document: windows.doc
1. Introduction
Vim stands for Vi IMproved. It used to be Vi IMitation, but that does not
really cover it anymore. Vim is a text editor which includes almost all the
commands from the Unix program "Vi" (and a lot new ones). It is very useful
for editing programs and other ASCII text. All commands are given with the
keyboard. There is no mouse support and there are no menus. This gives the
advantage that you can keep your fingers on the keyboard and your eyes on
the screen.
Throughout this manual the differences between Vi and Vim are mentioned in
curly braces. Read the file "difference.doc" for a summary of the
differences.
This manual refers to Vim on the Commodore Amiga computer. On other
computers and on terminals there may be small differences. For MSDOS this
is documented in msdos.doc. For UNIX this is in unix.doc.
This manual is a reference for all the Vim commands and options. A basic
knowledge of "Vi" is assumed. A summary of this manual can be found in the
file vim.hlp. It can be accessed from within Vim with the key (in
MSDOS ) and with the command ":help". The 'helpfile' option can be
set to the name of the help file, so you can put it in any place you like.
2. Notation
[] Characters in square brackets are optional.
[count] An optional number that may precede the command to multiply
or iterate the command. If no number is given a count of one
is used, unless otherwise noted. Note that in this manual
the [count] is not mentioned in the description of the
command, but only in the explanation. This was done to make
the commands easier to lookup. If the "sc" option is on, the
(partially) entered count is shown at the bottom of the
window. You can use to erase the last digit.
["x] An optional register designation where text can be stored.
The x is a single character between and or and
or <">, and in some cases (with the put command) between
<0> and <9>, <%>, <:> or <.>. The uppercase and lower case
letter designate the same register, but the lower case letter
is used to overwrite the previous register contents, while the
uppercase letter is used to append to the previous register
contents. Without the ""x" or with """" the stored text is
put into the unnamed register. See also "Copying and moving
text".
{} Curly braces denote parts of the command which must appear,
but can take a number of different values. The differences
between Vim and Vi are also given in curly braces (this will
be clear from the context).
{motion} A command that moves the cursor. They are listed in chapter
6. This is used after an "operator" command to move over the
text that is to be operated upon. If the motion includes a
count and the operator also had a count, the two counts are
multiplied. For example: "2d3w" deletes six words.
{visual} A piece of text that is started with the "v", "V" or CTRL-V
command and ended by the cursor position. This is used
before an "operator" to highlight the text that is to be
operated upon. See the chapter on Visual mode.
A special character from the table below or a single ASCII
character.
A single character from the range to . For
example: is a lower case letter. Multiple ranges may be
concatenated. For example: is any alphanumeric
character.
CTRL- typed as a control character, that is, typing
while holding the CTRL key down. The case of does not
matter, thus CTRL-A and CTRL-a are equivalent.
'option' An option, or parameter, that can be set to a value is
enclosed in single quotes. See chapter 19.
"command" In examples the commands you can type are enclosed in double
quotes.
notation meaning equivalent decimal value
-----------------------------------------------------------------------
zero CTRL_@ 000 (internally 010)
bell CTRL-G 007
backspace CTRL-H 008
tab CTRL-I 009
linefeed CTRL-J 010
formfeed CTRL-L 012
carriage return CTRL-M 013
escape CTRL-[ 027
space 032
delete 127
cursor-up 128 (msdos: 176)
cursor-down 129 (msdos: 177)
cursor-left 130 (msdos: 178)
cursor-right 131 (msdos: 179)
shift-cursor-up 132 (msdos: 180)
shift-cursor-down 133 (msdos: 181)
shift-cursor-left 134 (msdos: 182)
shift-cursor-right 135 (msdos: 183)
- function keys 1 to 10 136 - 145 (msdos: 184 - 193)
- shift-function keys 1 to 10 146 - 155 (msdos: 194 - 203)
HELP> help key 156 (msdos: 204)
undo key 157 (msdos: 205)
-----------------------------------------------------------------------
Note: The shifted cursor keys, the help key and the undo key are only
available on a few terminals. On some terminals the function keys 11 to 20
are used instead of the shifted function keys. On the Amiga shifted function
key 10 produces a code (CSI) that is also used by key sequences. It will be
recognized only after typing another key.
3. Starting Vim
3.1 Command line
Most often Vim is started to edit a single file with the command
vim file
More generally Vim is started with:
vim [options] [filelist]
If the filelist is missing, the editor will start with an empty buffer.
Otherwise exactly one out of the following three may be used to choose one
or more files to be edited.
file .. A list of file names. The first one will be the current file
and read into the buffer. The cursor will be positioned on
the first line of the buffer.
-t {tag} A tag. "tag" is looked up in the tags file, the associated
file becomes the current file and the associated command is
executed. Mostly this is used for C programs. In that case
"tag" should be a function name. The effect is that the file
containing that function becomes the current file and the
cursor is positioned on the start of the function (see the
section "tag searches").
-e [errorfile] QuickFix mode. The file with the name [errorfile] is read
and the first error is displayed. If [errorfile] is not
given, the 'errorfile' option is used for the file name
(default "AztecC.Err" for the Amiga, "errors" for other
systems). See section 5.5: "using the QuickFix mode".
The options, if present, must precede the filelist. The options may be given
in any order.
+[num] The cursor will be positioned on line "num" for the first
file being edited. If "num" is missing, the cursor will be
positioned on the last line.
+/{pat} The cursor will be positioned on the first line containing
"pat" in the first file being edited (see the section
"pattern searches" for the available search patterns).
+{command}
-c {command} "command" will be executed after the first file has been
read. "command" is interpreted as an Ex command. If the
"command" contains spaces it must be enclosed in double
quotes (this depends on the shell that is used). Example:
vim "+set si" main.c
-r Recovery mode. The swap file is read to recover a
crashed editing session. See the chapter "Recovery after a
crash".
-v View mode. The 'readonly' option will be set and no
swap file will be written (see -n below). You can
still edit the buffer, but will be prevented from
accidentally overwriting a file. If you forgot that you are
in View mode and did make some changes, you can overwrite
a file by adding an exclamation mark to the Ex command, as in
":w!". The 'readonly' option can be reset with ":set noro"
(see the options chapter). Calling the executable "view"
has the same effect as the -v option. If your system does
not support links and you do not want to have the executable
twice you could make an alias: "alias view vim -v".
-b Binary mode. The 'textauto', 'textmode' and 'expandtab'
options will be reset. The 'textwidth' option is set to 0.
'modelines' is set to 0. The 'binary' option is set. This is
done after reading the .vimrc/.exrc files but before reading
a file. See also 5.6: "Editing binary files".
-n No swap file will be used. Recovery after a crash will be
impossible. Handy if you want to view or edit a file on a
very slow medium (e.g. floppy). Can also be done with ":set
uc=0". You can switch it on again by setting the 'uc' option
to some value, e.g. ":set uc=100". Any files already being
edited will not be affected by this.
-o[N] Open N windows. If [N] is not given, one window is opened
for every file given as argument. If there is not enough
room, only the first few files get a window. If there are
more windows than arguments, the last few windows will be
editing an empty file.
-T {terminal} Set the terminal type to "terminal". This influences the
codes that Vim will send to your terminal. This is normally
not needed, because Vim will be able to find out what type
of terminal you are using (See chapter 20).
-d {device} Amiga only: The "device" is opened to be used for editing.
Normally you would use this to set the window position and
size: "-d con:x/y/width/height", e.g.
"-d con:30/10/600/150". But you can also use it to start
editing on another device, e.g. AUX:.
-x Amiga only: Do not restart Vim to open a new window. This
option should be used when Vim is started by a program that
will wait for the edit session to finish (e.g. mail or
readnews). See section 3.3.
-s {scriptin} The script file "scriptin" is read. The characters in the
file are interpreted as if you had typed them. The same can
be done with the command ":source! {scriptin}". If the end
of the file is reached before the editor exits, further
characters are read from the keyboard. See also the section
"complex repeats".
-w {scriptout} All the characters that you type are recorded in the file
"scriptout", until you exit Vim. This is useful if you want
to create a script file to be used with "vim -s" or
":source!". See also the section "complex repeats".
Example for using a script file to change a name in several files:
Create a file "subs.vi" containing substitute commands and a :wq
command:
:%s/Jones/Smith/g
:%s/Allen/Peter/g
:wq
Execute Vim on all files you want to change:
foreach i ( *.let ) vim -s subs.vi $i
If the executable is called "view" Vim will start in Readonly mode. This is
useful if you can make a hard or symbolic link from "view" to "vim".
Starting in Readonly mode can also be done with "vim -v".
3.2 Workbench (Amiga only)
Vim can be started from the workbench by clicking on its icon twice. It will
then start with an empty buffer.
Vim can be started to edit one or more files by using a "Project" icon. The
"Default Tool" of the icon must be the full pathname of the Vim executable.
The name of the ".info" file must be the same as the name of the text file.
By clicking on this icon twice, Vim will be started with the filename as
current filename, which will be read into the buffer (if it exists). You can
edit multiple files by pressing the shift key while clicking on icons, and
clicking twice on the last one. The "Default Tool" for all these icons must
be the same.
It is not possible to give arguments to Vim, other than filenames, from the
workbench.
3.3 Vim window (Amiga only)
Vim will run in the CLI window where it was started. If Vim was started with
the "run" or "runback" command, or if Vim was started from the workbench, it
will open a window of its own.
Technical detail:
To open the new window a little trick is used. As soon as Vim
recognizes that it does not run in a normal CLI window, it will
create a script file in t:. This script file contains the same
command as how Vim was started, and an "endcli" command. This script
file is then executed with a "newcli" command (the "c:run" and
"c:newcli" commands are required for this to work). The script file
will hang around until reboot, or until you delete it. This method
is required to get the ":sh" and ":!" commands to work correctly.
But when Vim was started with the -e option (Quickfix mode) or with
the -x option, this method is not used. The reason for this is that
when a compiler starts Vim with the -e option it will wait for a
return code. With the script trick the compiler cannot get the
return code. The -x option can be used when Vim is started by a mail
program which also waits for the edit session to finish. As a
consequence the ":sh" and ":!" commands are not available when the
-e or -x option is used.
Vim will automatically recognize the window size and react to window
resizing. Under Amiga DOS 1.3 it is advised to use the fastfonts program
"FF" to speed up display redrawing.
3.4 Initialization
When Vim starts running it does initializations in the following order. If
an environment variable is used, it is executed as a single Ex command line.
Multiple commands must be separated with <|> or . If a file is used,
each line is executed as an Ex command line.
1. Four places are searched for initializations. The first that exists is
used, the others are ignored.
1. The environment variable VIMINIT
2. The file "s:.vimrc" (for Unix: "$HOME/.vimrc")
3. The environment variable EXINIT
4. The file "s:.exrc" (for Unix: "$HOME/.exrc")
2. If the 'exrc' option is set (default is 'noexrc'), the current directory
is searched for two files. The first that exists is used, the other is
ignored.
1. The file ".vimrc"
2. The file ".exrc"
3. The environment variable SHELL, if it exists, is used to set the
'shell' option. With MSDOS the COMPSPEC variable is used if SHELL does
not exist. The 'shellpipe' option is set according to the name of the
shell.
4. The environment variable TERM, if it exists, is used to set the 'term'
option.
The first can be used to set your default settings and mappings for all edit
sessions. The second one for sessions in a certain directory (note that the
'exrc' option is default off). See the section "Saving settings" for how to
create a file with commands to recreate the current settings.
If the VIMINIT environment variable or ".vimrc" exist the EXINIT and ".exrc"
are skipped. This can be used to initialize Vim without interfering with
another version of Vi.
On the Amiga two types of environment variables exist. The ones set with the
DOS 1.3 (or later) setenv command are recognized. See the AmigaDos 1.3
manual. The environment variables set with the old Manx Set command (before
version 5.0) are not recognized.
On MS-DOS systems Vim assumes that all the "_vimrc" and "_exrc" files have
pairs as line separators. This will give problems if you have a
file with only s and have a line like ":map xx yy^M". The trailing ^M
will be ignored.
While reading the ".vimrc" or the ".exrc" file in the current directory some
commands can be disabled for security reasons by setting the 'secure'
option. Otherwise it would be possible to create a .exrc that contains nasty
commands, which another user may automatically execute when he starts Vim it
that directory. The disabled commands are the ones that start a shell and
the ones that write to a file. The ":map" commands are echoed, so you can
see which keys are being mapped.
You can reset the 'secure' option in the EXINIT or VIMINIT environment
variable or in the global ".exrc" or ".vimrc" file. This is not possible in
".vimrc" or ".exrc" in the current directory, for obvious reasons.
On unix systems this only happens if you are not the owner of the ".vimrc"
or ".exrc" file. Warning: If you unpack an archive that contains a .exrc
file, it will be owned by you. You won't have the security protection. Check
the .exrc file before you start Vim in that directory, or reset the 'exrc'
option.
3.5 Suspending
CTRL-Z Suspend the editor. Same as ":stop".
:sus[pend][!] or
:st[op][!] Suspend the editor. If the is not given,
the buffer was changed, autowrite is set and
a filename is known, the buffer will be
written.
On many UNIX systems it is possible to suspend Vim with CTRL-Z. This is only
possible in Command mode (see next chapter). Vim will continue if you make it
the foreground job again. On other systems CTRL-Z will start a new shell.
This is the same as the ":sh" command. Vim will continue if you exit from the
shell.
4. Modes
4.1 Introduction
Vim has four basic modes:
Command mode In Command mode you can enter all the editor
commands. If you start the editor you are in this
mode (unless you have set the 'insertmode' option,
see below).
Insert mode In Insert mode the text you type is inserted into the
buffer. If the 'showmode' option is set (which is
default), the string "-- INSERT --" is shown at the
bottom of the window.
Replace mode Replace mode is a special case of Insert mode. You
can do the same things as in Insert mode, but for
each character you enter (except some special
characters) one character of the existing text is
deleted. If the 'showmode' option is set (which is
default), the string "-- REPLACE --" is shown at the
bottom of the window.
Command_line mode In Command_line mode you can enter one line of text
at the bottom of the window. This is for the Ex
commands <:>, the pattern search commands and
the filter command .
More explanation on the insert, replace and Command_line mode is further on
in this chapter.
4.2 Switching from mode to mode
If for any reason you do not know in which mode you are, you can always get
back to Command mode by typing twice. You will know you are back in
Command mode when you see the screen flash or hear the bell after you type
.
- go from Command mode to Insert mode by giving one of the commands
"iIaAoOcCsS".
- go from Command mode to Replace mode with the "R" command (not the "r"
command!).
- go from Command mode to Command_line mode with the one of the commands
":/?!".
- go from insert or Replace mode to Command mode with (twice in some
rare cases).
- go from Command_line mode to Command mode by:
- hitting or , which causes the entered command to be executed
- deleting the complete line (e.g. with CTRL-U) and giving a final
- hitting CTRL-C or , which quits the command line without executing
the command.
In the last case may be the character defined with the 'wildchar'
option, and start command line completion. You can ignore that and type
again. {vi: when hitting the command line is executed. This is
unexpected for most people, therefore it was changed in Vim. But when the
is part of a mapping the command line is executed. If you want the
vi behaviour also when typing use ":cmap ^V ^V^M"}
If the 'insertmode' option is set, editing a file will start in Insert mode.
4.3 Insert and Replace mode
4.3.1 special keys
In insert and Replace mode the following characters have a special meaning,
other characters are inserted directly. To insert one of these special
characters into the buffer, precede it with CTRL-V. To insert a
character use "CTRL-V CTRL-@" or "CTRL-V 000". On some systems you have to
use "CTRL-V 003" to insert a CTRL-C.
char action
-----------------------------------------------------------------------
CTRL-@ Insert previously inserted text and stop insert. {Vi: only
when typed as first char, only up to 128 chars}
CTRL-A Insert previously inserted text. {not in Vi}
CTRL-B Toggle the 'revins' option (B for Backwards). {not in Vi}
CTRL-C Quit insert mode, back to command mode. Do not check for
abbreviations.
CTRL-D Delete one shiftwidth of indent at the start of the current
line. See also 'shiftround' option. When preceded with <^>
or <0> delete all indent in the current line. With <^> the
indent is restored in the next line. This is useful when
inserting a label. {Vi: CTRL-D works only when used after
autoindent}
CTRL-E Insert the character which is below the cursor. {not in Vi}
CTRL-H Delete the character before the cursor (see below). {Vi:
does not delete autoindents}
CTRL-I Insert a tab. If the 'expandtab' option is on, the
equivalent number of spaces is inserted (use CTRL-V to
avoid the expansion). See also the 'smarttab' option, section
4.3.4.
CTRL-J Begin new line.
CTRL-K {char1} {char2}
Enter digraph (see 4.7). {not in Vi}
CTRL-M Begin new line.
CTRL-N Find next keyword (see 4.3.7). {not in Vi}
CTRL-O Execute one Command mode command. See below. {not in Vi}
CTRL-P Find previous keyword (see 4.3.7). {not in Vi}
CTRL-R <0-9a-z"%:>
Insert the contents of a numbered or named register. The
text is inserted as if you typed it, but mappings and
abbreviations are not used. If you have options like
'textwidht' or 'autoindent' set, this will influence what
will be inserted. Use <"> for the unnamed register,
containing the text of the last delete or yank. Use <%> for
the current file name. Use <:> for the last command line. See
the chapter on copying and moving text about registers. {<%>,
<"> and <:> not in Vi}
CTRL-T Insert one shiftwidth of indent at the start of the current
line. See also 'shiftround' option. {Vi: only when in
autoindent}
CTRL-U Delete all entered characters in the current line (see
below).
CTRL-V Insert next non-digit literally. Up to three digits form the
decimal value of a single byte. The non-digit and the three
digits are not considered for mapping. {Vi: no decimal byte
entry}
CTRL-W Delete the word before the cursor (see below). See the
section "word motions" for the definition of a word.
CTRL-Y Insert the character which is above the cursor. {not in Vi}
CTRL-[ or End insert or Replace mode, back to Command mode.
Same as CTRL-H
-----------------------------------------------------------------------
The effect of the , , CTRL-W and CTRL-U depends on the 'backspace'
option (unless 'revins' is set):
backspace action
option
0 delete stops in column 1 and start position of insert
1 delete stops at start position of insert
2 delete always, CTRL-W and CTRL-U stop once at start position of
insert
If the 'backspace' option is non-zero and the cursor is in column 1 when one
of the three keys is used, the current line is joined with the previous
line. This effectively deletes the newline in front of the cursor. {Vi: does
not cross lines, does not delete past start position of insert}
With CTRL-V followed by one, two or three digits you can enter the decimal
value of a byte, except 10. Normally CTRL-V is followed by three digits. The
formed byte is inserted as soon as you type the third digit. If you type
only one or two digits and then a non-digit, the decimal value of those one
or two digits form the byte. After that the non-digit is dealt with in the
normal way. If you enter a value of 10, it will end up in the file as a 0.
The 10 is a , which is used internally to represent the character.
When writing the buffer to a file the character is translated into
. The character is written at the end of each line. Thus if you
want to insert a character in a file you will have to make a line
break.
4.3.2 special special keys
The following keys are special. They stop the current insert, do something
and then restart insertion. This means you can do something without getting
out of Insert mode. This is very handy if you prefer to use the Insert mode
all the time, just like editors that don't have a separate Command mode. You
may also want to set the 'backspace' option to 2 and set the 'insertmode'
option. You can use CTRL-O if you want to map a function key to a command.
The changes (inserted or deleted characters) before and after these keys can
be undone separately. Only the last change can be redone and always behaves
like an "i" command.
char action
-----------------------------------------------------------------------
cursor one line up
cursor one line down
cursor one character left
cursor one character right
move window one page up
move window one page down
cursor one word back (like "b" command)
cursor one word forward (like "w" command)
CTRL-O execute one command and return to Insert mode
-----------------------------------------------------------------------
The CTRL-O command has one side effect: If the cursor was beyond the end of
the line it will be put on the last character in the line.
The shifted cursor keys are not available on all terminals.
When the 'whichwrap' option is set appropriately, the and
keys on the first/last character in the line make the cursor wrap to the
previous/next line.
4.3.3 'textwidth' and 'wrapmargin' option
The 'textwidth' option can be used to automatically break a line before it
gets too long. Set the 'textwidth' option to the desired maximum line
length. If you then type more characters (not spaces or tabs), the
last word will be put on a new line (unless it is the only word on the
line). If you set 'textwidth' to 0, this feature is disabled.
The 'wrapmargin' option does almost the same. The difference is that
'textwidth' has a fixed width while 'wrapmargin' depends on the width of the
screen. When using 'wrapmargin' this is equal to using 'textwidth' with a
value equal to (columns - 'wrapmargin'), where columns is the width of the
screen.
When 'textwidth' and 'wrapmargin' are both set, 'textwidth' is used.
The line is only broken automatically when using insert mode, or when
appending to a line. When in replace mode and the line length is not
changed, the line will not be broken.
If you want to format a block of text you can use the "Q" operator. Type "Q"
and a movement command to move the cursor to the end of the block. In many
cases the command "Q}" will do what you want (format until the end of
paragraph). Or you can use visual mode: hit "v", move to the end of the
block and hit "Q".
4.3.4 'expandtab' and 'smarttab' options
If the 'expandtab' option is set, spaces will be used to fill the amount of
whitespace of the tab. If you want to enter a real type CTRL-V first.
The 'expandtab' option is default off. Note that in Replace mode a single
character is replaced by several spaces. The result of this is that the
number of characters in the line increases. Backspacing will delete one
space at a time. The original text will be put back in a place where you
would not expect it. {not in Vi}
When the 'smarttab' option is set a TAB in front of a line inserts
'shiftwidth' positions, 'tabstop' in other places. This means that often
spaces instead of a TAB character is inserted. When not set a TAB always
inserts 'tabstop' positions, 'shiftwidth' is only used for ">>" and the like.
{not in Vi}
4.3.5 typing backwards
If the 'revins' (reverse insert) option is set, inserting happens backwards.
This can be used to type Hebrew. When inserting characters the cursor is not
moved and the text moves rightwards. A deletes the character under the
cursor. CTRL-W and CTRL-U also work in the opposite direction. , CTRL-W
and CTRL-U do not stop at the start of insert or end of line, no matter how
the 'backspace' option is set.
In Replace mode the cursor is moved leftwards. will restore the
character right of the cursor.
In insert or Replace mode the 'revins' option can be toggled with CTRL-B.
If the 'showmode' option is set, "-- REVERSE INSERT --" or
"-- REVERSE REPLACE --" will be shown in the status line.
4.3.6 Replace mode
In Replace mode one character in the line is deleted for every character you
type. If there is no character to delete (at the end of the line), the
typed character is appended (as in Insert mode). Thus the number of
characters in a line stays the same until you get to the end of the line.
Be careful with characters. If you type a normal printing character in
its place, the number of characters is still the same, but the number of
columns will become smaller.
If you delete characters in Replace mode (with , , CTRL-W or
CTRL-U), you really delete your changes. The characters that were replaced
are restored. If you had typed past the existing text, the characters you
added are deleted.
All this only works in the current line. If you have started a new line
(replaced a character with a ) Vim no longer remembers what happened in
the previous line. If you backspace over the newline (only possible if the
'backspace' option is non-zero), the two lines will be joined again, but
typing further backspaces will not restore the original text. Only the
cursor is moved.
If the 'expandtab' option is set, a will replace one character
with several spaces. When backspacing over these spaces, the original text
will appear in a position where you would not expect it.
4.3.7 Keyword completion
In insert and replace mode the keys CTRL-N and CTRL-P can be used to
complete the keyword that is in front of the cursor. This is useful if you
are writing a program that has complicated variable names, and you want to
copy a name from the text before of after the cursor.
If there is an identifier in front of the cursor (a name made out of
alphanumeric characters and <_>) it is used as the search pattern, with "\<"
prepended (meaning: start of a word). Otherwise "\<[a-zA-Z_]" is used as
search pattern (start of any identifier).
With CTRL-N (next) the search goes forward, with CTRL-P (previous) the
search goes backward. The first time the search starts where the cursor is.
The next times the search starts at the last found position. If you type any
other character than CTRL-P or CTRL-N the current text is accepted and the
search pattern is forgotten.
If the search found a match, it is inserted at the cursor position. Any
previous match is replaced. If no match was found, Vim will beep.
If there is not a valid identifier character before the cursor, any
identifier is matched.
eg. to get:
printf("(%g, %g, %g)", vector[0], vector[1], vector[2]);
just type:
printf("(%g, %g, %g)", vector[0], ^P[1], ^P[2]);
Multiple repeats of the same completion are skipped.
If there is only one completion found, then a second CTRL-P or CTRL-N will
give the message 'No other matches'.
If the only match in the file is an exact match, where no extra characters
would be typed, then the message 'Exact match only' is given (this is also
useful for checking that you typed the symbol correctly).
The mode (--INSERT--) is shown, unless there is another more important
message (eg Pattern not found). This other message will stay until another
key is hit, and then the mode is shown again.
Only matches where something extra will be added are used.
eg. to get:
printf("name = %s\n", name);
just type:
printf("name = %s\n", n^P);
The 'n' in '\n' is skipped.
4.4 Command_line mode
Command_line mode is used to enter Ex commands <:>, search patterns
and filter commands .
4.4.1 Command line editing
Normal characters are inserted in front of the cursor position. You can move
around in the command line with the left and right cursor keys. {Vi: can
only alter the last character in the line}
The command lines that you enter are remembered in a history table. You can
recall them with the up and down cursor keys. Use the 'history' option to
set the number of lines that are remembered (default 20).
There is an automatic completion of names on the command line, see 4.4.2.
CTRL-V Insert next non-digit literally. Up to three digits form the
decimal value of a single byte. The non-digit and the three
digits are not considered for mapping. This works the same
way as in Insert mode (see above).
cursor left
cursor right
cursor one word left
cursor one word right
CTRL-B cursor to begin of command line
CTRL-E cursor to end of command line
delete the character in front of the cursor
delete the character under the cursor (at end of line:
character in front of the cursor)
CTRL-W delete the word in front of the cursor
CTRL-U remove all characters
Note: if the command line becomes empty with one of the
delete commands, command line mode is quit.
{char1} {char2} or
CTRL-K {char1} {char2}
enter digraph (see 4.7). {not in Vi}
or start entered command
when typed: quit command line without executing
in macros: start entered command
CTRL-C quit command line without executing
recall older command line from history
recall more recent command line from history
recall older command line from history, which begin matches
the current command line (see below).
recall more recent command line from history, which begin
matches the current command line (see below).
CTRL-D command line completion (see 4.4.2)
'wildchar' option
command line completion (see 4.4.2)
CTRL-N command line completion (see 4.4.2)
CTRL-P command line completion (see 4.4.2)
CTRL-A command line completion (see 4.4.2)
CTRL-L command line completion (see 4.4.2)
The and keys take the current command line as search
string. The beginning of the next/previous command lines are compared against
this string. The fist line that matches is the new command line. When typing
these two keys repeatedly, the same string is used again. For example this
can be used to find the previous substitute command: Type ":s" and then
. The same could be done by typing a number of times until the
desired command line is shown. (Note: the shifted arrow keys do not work on
all terminals)
4.4.2 Command line completion
When editing the command line a few commands can be used to complete the
word before the cursor. This is available for:
- Command names, at the start of the command line. Works always.
- tags, only after the ":tag" command.
- file names, only after a command that accepts a file name or a setting for
an option that can be set to a file name. This is called file name
completion.
- options, only after the ":set" command.
These are the commands that can be used:
CTRL-D List names that match the pattern in front of the cursor.
When showing file names, directories are highlighted (see
'highlight' option)
'wildchar' option
A match is done on the pattern in front of the cursor. The
match, or if there are several, the first match, is inserted
in place of the pattern. (Note: does not work inside a
macro, because TAB or ESC is mostly used as 'wildchar', and
these have a special meaning in some macros)
When typed again, and there were multiple matches, the next
match is inserted. After the last match the first is used
again (wrap around).
CTRL-N After using 'wildchar' which got multiple matches: go to next
match. Otherwise: Recall more recent command line from history.
CTRL-P After using 'wildchar' which got multiple matches: go to
previous match. Otherwise: Recall older command line from
history.
CTRL-A All names that match the pattern in front of the cursor are
inserted.
CTRL-L A match is done on the pattern in front of the cursor. If
there is one match, it is inserted in place of the pattern.
If there are multiple matches the longest common part is
inserted in place of the pattern.
The 'wildchar' option defaults to (CTRL-E when compiled with
COMPATIBLE; in a previous version was used). In the pattern standard
wildcards <*> and are accepted. <*> matches any string, matches
exactly one character.
For filename completion you can use the 'suffixes' option to set a priority
between files with almost the same name. If there are multiple matches,
those files with an extension that is in the 'suffixes' option are ignored.
The default is ".bak.o.h.info.swp", which means that files with the
extensions ".bak", ".o", ".h", ".info" and ".swp" are sometimes ignored. It
is impossible to ignore suffixes with two dots. Examples:
pattern: files: match:
test* test.c test.h test.o test.c
test* test.h test.o test.h and test.o
test* test.i test.h test.c test.i and test.c
If there is more than one matching file (after ignoring the ones matching
the 'suffixes' option) the first file name is inserted. You can see that
there is only one match when you type 'wildchar' twice and the completed
match stays the same. You can get to the other matches by entering
'wildchar', CTRL-N or CTRL-P. All files are included, also the ones with
extensions matching the 'suffixes' option.
4.4.3 Ex command lines
The Ex commands have a few specialties:
<"> at the start of a line causes the whole line to be ignored. <">
after a command causes the rest of the line to be ignored. This can be used
to add comments. Example:
:set ai "set 'autoindent' option
It is not possible to add a comment to a shell command ":!cmd" or to the
":map" command and friends, because they see the <"> as part of their
argument.
<|> can be used to separate commands, so you can give multiple commands in
one line. The commands ":global", "vglobal" and ":!" see the <|> as their
argument, and can therefore not be followed by another command. If you want
<|> to be included in a command, precede it with <\>. Note that this is
confusing (inherited from vi). If you give a command with ":!" you don't
have to use a backslash, with ":r !" you have to. And with ":g" the <|> is
included in the command, with ":s" it is not. Examples:
:!ls | wc view the output of two commands
:r !ls \| wc insert the same output in the text
:%g/foo/p|> moves all matching lines one shiftwidth
:%s/foo/bar/|> moves one line one shiftwidth
You can also use to separate commands in the same way as with <|>. But
using <|> is the preferred method.
When the character <%> or <#> is used where a filename is expected, they are
expanded to the current and alternate filename (see the chapter "editing
files").
Embedded spaces in filenames are allowed if one filename is expected as
argument. Trailing spaces will be ignored, unless escaped with a backslash
or CTRL-V. Note that the ":next" command uses spaces to separate file names.
Escape the spaces to include them in a file name. Example:
:next foo\ bar goes\ to school\
starts editing the three files "foo bar", "goes to" and "school ".
When you want to use the special characters <"> or <|> in a command, or want
to use <%> or <#> in a filename, precede them with a backslash. The backslash
is not required in a range and in the ":substitute" command.
4.4.4 Ex command line ranges
Some Ex commands accept a line range in front of them. This is noted as
[range]. It consists of one or more line specifiers, separated with <,> or
<;>. When separated with <;> the cursor position will be set to that line
before interpreting the next line specifier. The default line specifier for
most commands is the cursor position, but the commands ":write" and
":global" have the whole file (1,$) as default. If more line specifiers are
given than required for the command, the first one(s) will be ignored.
Line numbers may be specified with:
{number} an absolute line number
. the current line
$ the last line in the file
% equal to 1,$ (the entire file)
't position of mark t (lower case)
/{pattern}[/] the next line where {pattern} matches
?{pattern}[?] the previous line where {pattern} matches
Each may be followed (several times) by <+> or <-> and an optional number.
This number is added or subtracted from the preceding line number. If the
number is omitted, 1 is used.
The "/" and "?" may be preceded with another address. The search starts from
there. The "/" and "?" after {pattern} are required to separate the pattern
from anything that follows.
The {number} must be between 0 and the number of lines in the file. A 0 is
interpreted as a 1, except with the commands tag, pop and read.
Examples:
.+3 three lines below the cursor
/that/+1 the line below the next line containing "that"
.,$ from current line until end of file
0/that the first line containing "that"
Some commands allow for a count after the command. This count is used as the
number of lines to be used, starting with the line given in the last line
specifier (the default is the cursor line). The commands that accept a count
are the ones that use a range but do not have a file name argument (because
a file name can also be a number).
Examples:
:s/x/X/g 5 substitute by in the current line and four
following lines
:23d 4 delete lines 23, 24, 25 and 26
A range should have the lower line number first. If this is not the case, Vim
will ask you if it should swap the line numbers. This is not done within the
global command ":g".
When giving a count before entering ":", this is translated into:
:.,.+(count - 1)
In words: The 'count' lines at and after the cursor. Example: To delete
three lines:
3:d is translated into: .,.+2d
4.5 The window contents
In command and Insert/Replace mode the screen window will show the current
contents of the buffer: What You See Is What You Get. {Vi: when changing
text a <$> is placed on the last changed character; The window is not always
updated on slow terminals} Lines longer than the window width will wrap,
unless the 'wrap' option is off (see below). The bottom lines in the window
may start with one of these two characters:
<@> The next line is too long to fit in the window.
<~> Below the last line in the buffer.
If the bottom line is completely filled with <@>, the line that is at the
top of the window is too long to fit in the window. If the cursor is on this
line you can't see what you are doing, because this part of the line is not
shown. However, the part of the line before the <@>s can be edited normally.
{Vi: gives an "internal error" on lines that do not fit in the window}
If the 'wrap' option is off, long lines will not wrap. Only the part that
fits on the screen is shown. If the cursor is moved to a part of the line
that is not shown, the screen is scrolled horizontally. The advantage of
this method is that columns are shown as they are and lines that cannot fit
on the screen can be edited. The disadvantage is that you cannot see all the
characters of a line at once. The 'sidescroll' option can be set to the
minimal number of columns to scroll. {Vi: has no 'wrap' option}
All normal ASCII characters are displayed directly on the screen. The
is replaced by the number of spaces that it represents. Other non-printing
characters are replaced by "^", where is the non-printing
character with 64 added. Thus character 7 (bell) will be shown as "^G".
Characters between 127 and 160 are replaced by "~", where is
the character with 64 subtracted. These characters occupy more than one
position on the screen. The cursor can only be positioned on the first one.
If you set the 'number' option, all lines will be preceded with their
number.
If you set the 'list' option, characters will not be shown as several
spaces, but as "^I". A <$> will be placed at the end of the line, so you can
find trailing blanks.
In Command_line mode only the command line itself is shown correctly. The
display of the buffer contents is updated as soon as you go back to Command
mode.
Some commands hand over the window to external commands (e.g. ":shell" and
"="). After these commands are finished the window may be clobbered with
output from the external command, so it needs to be redrawn. This is also
the case if something is displayed on the status line that is longer than
the width of the window. If you are expected to have a look at the screen
before it is redrawn, you get this message:
Press RETURN or enter command to continue
After you type a key the screen will be redrawn and Vim continues. If you
type , or nothing else happens. If you type any other key, it
will be interpreted as (the start of) a new command. {Vi: only <:> commands
are interpreted}
The last line of the window is used for status and other messages. The
status messages will only be used if an option is on:
status message option default unix default
current mode 'showmode' on on
command characters 'showcmd' on off
cursor position 'ruler' off off
The current mode is "-- INSERT --" or "-- REPLACE --". The command
characters are those that you typed but were not used yet. {Vi: does not
show the characters you typed or the cursor position}
If you have a slow terminal you can switch off the status messages to speed
up editing:
:set nosc noru nosm
If there is an error, an error message will be shown for at least one second
(in reverse video). {Vi: error messages may be overwritten with other
messages before you have a chance to read them}
Some commands show how many lines were affected. Above which threshold this
happens can be controlled with the 'report' option (default 2).
On the Amiga Vim will run in a CLI window. The name Vim and the full name of
the current filename will be shown in the title bar. When the window is
resized, Vim will automatically redraw the window. You may make the window as
small as you like, but if it gets too small not a single line will fit in it.
Make it at least 40 characters wide to be able to read most messages on the
last line.
On most Unix systems window resize works ok. {Vi: not ok}
4.6 Abbreviations
Abbreviations are used in insert mode, Replace mode and Command_line mode.
If you enter a word that is an abbreviation, it is replaced by the word it
stands for. This can be used to save typing for often used long words.
There are two types of abbreviations: The "full-id" type consists entirely
of id characters (letters, digits and <_> characters). This is the most
common abbreviation. The "non-id" type ends in an id character, but all the
other characters are not id characters. Examples of a "full-id" type are
"foo" and "c_1". Examples of a "non-id" type are "#i" and "$/7". Examples of
strings that will not be recognized as an abbreviation are "a.b", "a b" and
"_$ar".
The "full-id" abbreviation is recognized if:
- A character is typed that is not an id character. This can also be
the that ends insert mode or the that ends a command.
- The characters in front of the cursor match the abbreviation.
- In front of the match is a non-id character, or this is where the line or
insertion starts. Exception: when the abbreviation is only one character,
it is not recognized if there is a non-id character in front of it, other
than a space or a TAB.
The "non-id" abbreviation is recognized if:
- A character is typed that is not an id character. This can also be
the that ends insert mode or the that ends a command.
- The characters in front of the cursor match the abbreviation.
- In front of the match is an id character, or a space or a TAB, or this is
where the line or insertion starts.
Example: ":ab foo four old otters". Note that spaces in the are
allowed and included in the replacement string. If you now insert the word
"foo" with a space before and after it, it will be replaced by "four old
otters". If you would type "foobar" or "barfoo" nothing happens.
To avoid the abbreviation in insert mode type part of the abbreviation, exit
insert mode with , re-enter insert mode with "a" and type the rest. In
Command_line mode you can type CTRL-V twice somewhere in the abbreviation to
avoid it to be replaced. A CTRL-V in front of a normal character is mostly
ignored otherwise.
There are no default abbreviations.
Abbreviations are never recursive. You can use ":ab f f-o-o" without any
problem. But abbreviations can be mapped. {some versions of vi support
recursive abbreviations, for no apparent reason}
Abbreviations are disabled if the 'paste' option is set.
:ab[breviate] list all abbreviations. The character in the first
column indicates the mode where the abbreviation is
used: 'i' for insert mode, 'c' for Command_line
mode, '!' for both.
:ab[breviate] list the abbreviations that start with
:ab[breviate]
add abbreviation for to . If already
existed it is replaced with the new . may
contain spaces.
:una[bbreviate] remove abbreviation for from the list
:norea[bbrev] [lhs] [rhs]
same as ":ab", but no remapping for this {not
in Vi}
:ca[bbrev] [lhs] [rhs] same as ":ab", but for Command_line mode only. {not
in Vi}
:cuna[bbrev] same as ":una", but for Command_line mode only. {not
in Vi}
:cnorea[bbrev] [lhs] [rhs]
same as ":ab", but for Command_line mode only and no
remapping for this {not in Vi}
:ia[bbrev] [lhs] [rhs] same as ":ab", but for insert mode only. {not in Vi}
:iuna[bbrev] same as ":una", but for insert mode only. {not in
Vi}
:inorea[bbrev] [lhs] [rhs]
same as ":ab", but for insert mode only and no
remapping for this {not in Vi}
4.7 Digraphs
:dig[raphs] show currently defined digraphs. {not in Vi}
:dig[raphs] {char1}{char2} {number} ...
Add digraph {char1}{char2} to the list. {number} is
the decimal representation of the character.
Digraphs are used to enter characters that normally cannot be entered by
an ordinary keyboard. These are mostly accented characters which have the
eighth bit set. The digraphs are easier to remember than the decimal number
that can be entered with CTRL-V (see above).
Vim must have been compiled with the 'digraphs' option enabled. If not, the
":digraph" command will display an error message.
There are two methods to enter digraphs:
CTRL-K {char1} {char2} or
{char1} {char2}
The first is always available. The second only when the 'digraph' option is
set.
Once you have entered the digraph the character is treated like a normal
character, taking up only one character in the file and on the screen.
Example:
<|> <|> will enter the double <|> character (166)
<^> will enter an with a hat (226)
CTRL-K <-> <-> will enter a minus sign (173)
The default digraphs are listed in the file digraph.doc. They are meant for
the Amiga character set, which is some international standard. With another
character set they may be illogical.
For CTRL-K there is one general digraph: CTRL-K {char} will enter
{char} with the highest bit set. This can be used to enter meta-characters.
The character cannot be part of a digraph. When hitting entering
the digraph is aborted and insert mode too.
If you accidently typed an that should be an , you will type
. But that is a digraph, so you will not get what you want. To avoid this,
use instead of . Or don't set the 'digraph' option and use CTRL-K
to enter digraphs.
5. Editing files
5.1 Introduction
Editing a file with Vim means:
1. reading the file into the internal buffer
2. changing the buffer with editor commands
3. writing the buffer into a file
As long as you don't write the buffer, the original file remains unchanged.
If you start editing a file (read a file into the buffer), the file name is
remembered as the "current filename".
If there already was a current filename, then that one becomes the alternate
file name. All filenames are remembered in the file list. When you enter a
filename, for editing (e.g. with ":e filename") or writing (e.g. with (:w
filename"), the filename is added to the list. You can use this list to
remember which files you edited and to quickly switch from one file to
another with the CTRL-^ command (e.g. to copy text). First type the number
of the file and then hit CTRL-^. {Vi: only one alternate filename}
In Ex commands (the ones that start with a colon) <%> is replaced by the
current filename and <#> is replaced by the alternate filename. The older
alternate filenames are "#1", "#2", etc. "#0" is the same as "#". If a
"<" is appended to <%>, <#> or "#n" the extension of the file name is
removed (everything after and including the last '.' in the file name).
% current file name
%< current file name without extension
# alternate file name for current window
#< idem, without extension
#31 alternate file number 31
#31< idem, without extension
CTRL-G or
:f[ile] Prints the current filename (as typed) and the
cursor position. {vi does not include column number}
{count}CTRL-G Prints the current filename with full path and the
cursor position.
:f[ile] {name} Sets the current filename to {name}.
:buffers
:files List all the currently known file names. See
'windows.doc'. {not in 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.
If the environment variable 'HOME' is set, and the file name starts with
that string, it is often displayed with HOME replaced by "~". This was done
to keep file names short. When reading or writing files the full name is
still used, the "~" is only used when displaying file names.
When writing the buffer, the default is to use the current filename. Thus
when you give the "ZZ" or ":wq" command, the original file will be
overwritten. If you do not want this, the buffer can be written into another
file by giving a filename argument to the ":write" command. For example:
vim testfile
[change the buffer with editor commands]
:w newfile
:q
This will create a file "newfile", that is a modified copy of "testfile".
The file "testfile" will remain unchanged. Anyway, if the 'backup' option is
set, Vim renames the original file before it will be overwritten. You can
use this file if you discover that you need the original file. See also the
'patchmode' option. The name of the backup file is the same as the original
file with ".bak" appended. Any <.> is replaced by <_> on MSDOS machines, when
Vim has detected that an MSDOS-like filesystem is being used (e.g. messydos or
crossdos) and when the 'shortname' option is set.
Technical: On the Amiga you can use 30 characters for a file name. But on an
MSDOS-compatible filesystem only 8 plus 3 characters are
available. Vim tries to detect the type of filesystem when it is
creating the .swp file. If an MSDOS-like filesystem is suspected,
a flag is set that has the same effect as setting the 'shortname'
option. This flag will be reset as soon as you start editing a
new file. The flag will be used when making the filename for the
".swp" and ".bak" files for the current file. But when you are
editing a file in a normal filesystem and write to an MSDOS-like
filesystem the flag will not have been set. In that case the
creation of the ".bak" file may fail and you will get an error
message. Use the 'shortname' option in this case.
When you started editing without giving a file name, "No File" is displayed in
messages. If a ":write file" or ":read file" command is used, the file name
for the current file is set to the file name in that command. This is useful
when starting Vim without an argument and then doing ":read file" to start
editing a file. Or when entering text in an empty buffer and then writing it
to a file. Because the file name was set without really starting to edit that
file, you are protected from overwriting that file. This is done by setting
the "notedited" flag. You can see if this flag is set with the CTRL-G or
":file" command. It will include "[Not edited]" when the "notedited" flag is
set. When writing the buffer to the current file name (with ":w!"), the
"notedited" flag is reset.
Vim remembers whether you have changed the buffer. You are protected from
losing the changes you made. If you try to quit without writing, or want to
start editing another file, this will be refused. In order to overrule this
protection add a to the command. The changes will then be lost. For
example: ":q" will not work if the buffer was changed, but ":q!" will. To see
whether the buffer was changed use the "CTRL-G" command. The message includes
the string "[Modified]" if the buffer has been changed.
5.2 Editing a file
:e[dit] [+cmd] Edit the current file, unless changes have been made.
:e[dit]! [+cmd] Edit the current file always. Discard any changes to
the buffer.
:e[dit] [+cmd] {file} Edit {file}, unless changes have been made.
:e[dit]! [+cmd] {file} Edit {file} always. Discard any changes to the
buffer.
:e[dit] #[count] Edit the [count]th alternate filename (as shown by
:files). This command does the same as [count] CTRL-^.
:ex [+cmd] [file] Same as :edit. {Vi: go from visual to Ex mode}
:vi[sual] [+cmd] [file] Same as :edit. {Vi: go from Ex to Visual mode}
[count]CTRL-^ Edit [count]th alternate file (equivalent to ":e
#[count]"). Without count this gets you to the
previously edited file. This is a quick way to
toggle between two (or more) files. If the
'autowrite' option is set and the buffer was
changed, write it.
]f
[f
gf Edit the file whose name is under or after the
cursor. Mnemonic: "goto file". This fails if the
current file cannot be abandoned. {not in Vi}
:cd On non-Unix systems: Print the current directory
name. On Unix systems: Change the current directory
to the home directory.
:cd {path} Change the current directory to {path}. Does not
change the meaning of an already entered file name,
because its full path name is remembered.
:chd[ir] [path] Same as :cd.
:pwd Print the current directory name. {Vi: no pwd}
These commands are used to start editing a single file. This means that the
file is read into the buffer and the current filename is set. You may use the
":cd" command to get to another directory, so you will not have to type that
directory name in front of the filenames. One warning: After using ":cd" the
full path name will be used for reading and writing files. On some networked
file systems this may cause problems. The result of using the full path name
is that the file names currently in use will remain referring to the same
file. Example: If you have a file a:test and a directory a:vim the commands
":e test" ":cd vim" ":w" will overwrite the file a:test and not write
a:vim/test. But if you do ":w test" the file a:vim/test will be written,
because you gave a new file name and did not refer to a file name before the
":cd".
You can use the ":e!" command if you messed up the buffer and want to start
all over again. The ":e" command is only useful if you have changed the
current filename.
The [+cmd] can be used to position the cursor in the newly opened file:
+ Start at the last line.
+{num} Start at line {num}.
+/{pat} Start at first line containing {pat}. {pat} must not
contain any spaces.
+{command} Execute {command} after opening the new file.
{command} is an Ex command. It must not contain
spaces.
When reading a file when the 'textmode' option is off (default for
non-MSDOS) the character is interpreted as end-of-line. If 'textmode'
is on (default for MSDOS), is also interpreted as end-of-line.
When writing a file when the 'textmode' option is off a character is
used to separate lines. When the 'textmode' option is on is used.
You can read a file with 'textmode' set and write it with 'textmode' reset.
This will replace all pairs by . If you read a file with
'textmode' reset and write with 'textmode' set, all characters will be
replaced by .
If you start editing a new file and the 'textauto' option is set, Vim will
try to detect whether the lines in the file are separated by a single
(as used on Unix and Amiga) or by a pair (MSDOS). It reads up to
the first and checks if there is a in front of it. If there is the
'textmode' option is set, otherwise it is reset. If the 'textmode' option is
set on non-MSDOS systems the message "[textmode]" is shown to remind you
that something unusual is happening. On MSDOS systems you get the message
"[notextmode]" if the 'textmode' option is not set.
Before editing binary, executable or Vim script files you should set the
'textmode' and 'textauto' options off. With 'textmode' on you risk that
single characters are unexpectedly replaced with . A simple way
to do this is by starting Vim with the "-b" option.
5.3 The argument list
If you give more than one filename when starting Vim, this list is
remembered as the argument list. Do not confuse this with the file list,
which you can see with the ":files" command. The argument list was already
present in vi, the file list is new in Vim. The file names in the argument
list will also be present in the file list (unless they were deleted with
":bdel").
You can use the argument list with the following commands:
:ar[gs] Print the argument list, with the current file in
square brackets.
:[count]argu[ment] [count] [+cmd]
Edit file [count] in the argument list, unless
changes have been made and the 'autowrite' option is
off. {Vi: no such command}
:[count]argu[ment]! [count] [+cmd]
Edit file [count] in the argument list, discard any
changes to the current buffer. {Vi: no such command}
:[count]n[ext] [+cmd] Edit [count] next file, unless changes have been
made and the 'autowrite' option is off {Vi: no
count}.
:[count]n[ext]! [+cmd] Edit [count] next file, discard any changes to the
buffer {Vi: no count}.
:ar[gs] [+cmd] {filelist}
:n[ext] [+cmd] {filelist}
Define {filelist} as the new argument list and edit
the first one, unless changes have been made and the
'autowrite' option is off.
:ar[gs]! [+cmd] {filelist}
:n[ext]! [+cmd] {filelist}
Define {filelist} as the new argument list and edit
the first one. Discard any changes to the buffer.
:[count]N[ext] [count] [+cmd]
Edit [count] previous file in argument list, unless
changes have been made and the 'autowrite' option is
off {Vi: no count}.
:[count]N[ext]! [count] [+cmd]
Edit [count] previous file in argument list. Discard
any changes to the buffer {Vi: no count}.
:[count]pre[vious] [count] [+cmd]
Same as :Next {Vi: only in some versions}
:rew[ind] [+cmd] Start editing the first file in the argument list,
unless changes have been made and the 'autowrite'
option is off.
:rew[ind]! [+cmd] Start editing the first file in the argument list.
Discard any changes to the buffer.
:la[st] [+cmd] Start editing the last file in the argument list, unless
changes have been made and the 'autowrite' option is
off. {not in Vi}
:la[st]! [+cmd] Start editing the last file in the argument list.
Discard any changes to the buffer. {not in Vi}
:[count]wn[ext] [+cmd] Write current file and start editing the [count]
next file. {not in Vi}
:[count]wn[ext] [+cmd] {file}
Write current file to {file} and start editing the
[count] next file, unless {file} already exists and
the 'writeany' option is off. {not in Vi}
:[count]wn[ext]! [+cmd] {file}
Write current file to {file} and start editing the
[count] next file. {not in Vi}
:[count]wN[ext][!] [+cmd] [file]
:[count]wp[revous][!] [+cmd] [file]
Same as :wnext, but go to previous file instead of
next. {not in Vi}
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.
For [+cmd] see 5.2.
The wildcards in the argument list are expanded and the filenames are sorted.
Thus you can use the command "vim *.c" to edit all the C files. From within
Vim the command ":n *.c" does the same.
You are protected from leaving Vim if you are not editing the last file in
the argument list. This prevents you from forgetting that you were editing one
out of several files. To exit anyway try to exit twice. If there are changes
in the current buffer this will fail. You can exit anyway, and save any
changes, with the ":wq!" command. To lose any changes use the ":q!" command.
5.4 Writing and quitting
:[range]w[rite][!] Write the specified lines to the current file.
:[range]w[rite] {file} Write the specified lines to {file}, unless it
already exists and the 'writeany' option is off.
:[range]w[rite]! {file} Write the specified lines to {file}. Overwrite an
existing file.
:[range]w[rite][!] >> Append the specified lines to the current file.
:[range]w[rite][!] >> {file}
Append the specified lines to {file}. forces the
write even if file does not exist.
:[range]w[rite] !{cmd} Execute {cmd} with [range] lines as standard input
(note the space in front of the ).
The default [range] for the ":w" command is the whole buffer (1,$).
If a file name is give with ":w" it becomes the alternate file. This can be
used when the write fails and you want to try again later with ":w #".
:q[uit] Quit, unless changes have been made or not editing
the last file in the argument list.
:q[uit]! Quit always, without writing.
:cq Quit always, without writing, and return an error
code. Used for Manx's QuickFix mode (see 5.5).
:wq Write the current file. Exit if not editing the
last file in the argument list.
:wq! Write the current file and exit.
:wq {file} Write to {file}. Exit if not editing the last
file in the argument list.
:wq! {file} Write to {file} and exit.
:x[it][!] [file] Like ":wq", but write only when changes have been
made.
:exi[t][!] [file] Same as :xit.
ZZ Write current file, if modified, and exit (same as
":x").
If you write to an existing file (but do not append) while the 'backup' or
'writebackup' option is on, a backup of the original file is made. On Unix
systems the file is copied, on other systems the file is renamed. After the
file has been successfully written and when the 'writebackup' option is on
and the 'backup' option is off, the backup file is deleted.
'backup' 'writebackup' action
off off no backup made
off on backup made, deleted afterwards
on off backup made, not deleted
on on backup made, not deleted (default)
On Unix systems:
When you write to an existing file, that file is truncated and then filled
with the new text. This means that protection bits, owner and symbolic links
are unmodified. The backup file however, is a new file, owned by the user
who edited the file. If it is not possible to create the backup file in the
same directory as the original file, the directory given with the
'backupdir' option is used (default: home directory).
If the creation of a backup file fails, the write is not done. If you want
to write anyway add a to the command.
If the 'textmode' option is set is used for end-of-line. This is
default for MSDOS. On other systems the message "[textmode]" is shown to
remind you that an usual end-of-line marker was used. If the 'textmode' is
not set LF is used for end-of-line. On MSDOS the message "[notextmode]" is
shown. See also the 'textmode' and 'textauto' options.
5.5 Using the QuickFix mode
Vim has a special mode to speedup the edit-compile-edit cycle. This is
inspired by the quickfix option of the Manx's Aztec C compiler on the Amiga.
The idea is to save the error messages from the compiler in a file and use
Vim to jump to the errors one by one. You can then examine each problem and
fix it, without having to remember all the error messages.
If you are using Manx's Aztec C compiler on the Amiga you should do the
following:
- Set the CCEDIT environment variable with the command
mset "CCEDIT=vim -e"
- Compile with the -qf option. If the compiler finds any errors, Vim is
started and the cursor is positioned on the first error. The error message
will be displayed on the last line. You can go to other errors with the
commands mentioned below. You can fix the errors and write the file(s).
- If you exit Vim normally the compiler will re-compile the same file. If you
exit with the :cq command, the compiler will terminate. Do this if you
cannot fix the error, or if another file needs to be compiled first.
If you are using another compiler you should save the error messages in a
file and start Vim with "vim -e filename". An easy way to do this is with
the ":make" command (see below). The 'errorformat' option should be set to
match the error messages from your compiler (see below).
The following commands can be used if you are in QuickFix mode:
:cc [nr] Display error [nr]. If [nr] is omitted, the same
error is displayed again. {not in Vi}
:[count]cn Display the [count] next error in the list that
includes a file name. If there are no file names at
all, go the the [count] next error. {not in Vi}
:[count]cp Display the [count] previous error in the list that
includes a file name. If there are no file names at
all, go the the [count] previous error. {not in Vi}
:cq Quit Vim with an error code, so that the compiler
will not compile the same file again. {not in Vi}
:cf [errorfile] Read the error file and jump to the first error.
This is done automatically when Vim is started with
the -e option. You can use this command when you
keep Vim running while compiling. If you give the
name of the errorfile, the 'errorfile' option will
be set to [errorfile] {not in Vi}
:cl List all errors. {not in Vi}
:make [arguments] 1. If the 'autowrite' option is set and the buffer
was changed, write it.
2. Any existing 'errorfile' is deleted.
3. The program given with the 'makeprg' option is
started (default "make") with the optional
[arguments] and the output is saved in
'errorfile' (for Unix it is also echoed on the
screen).
4. The 'errorfile' is then read and the first error
is jumped to.
5. The 'errorfile' is deleted.
{not in Vi}
The name of the file can be set with the 'errorfile' option. The default is
"AztecC.Err" for the Amiga and "errors" for other systems. The format of the
file from the Aztec compiler is:
filename>linenumber:columnnumber:errortype:errornumber:errormessage
filename name of the file in which the error was detected
linenumber line number where the error was detected
columnnumber column number where the error was detected
errortype type of the error, normally a single or
errornumber number of the error (for lookup in the manual)
errormessage description of the error
Another compiler is likely to use a different format. You should set the
'errorformat' option to a scanf-like string that describes the format. First
you need to know how scanf works. Look in the documentation of your C
compiler. Vim will understand eight conversion characters. Others are invalid.
%f file name (finds a string)
%l line number (finds a number)
%c column number (finds a number)
%t error type (finds a single character)
%n error number (finds a number)
%m error message (finds a string)
%* any scanf non-assignable conversion
%% the single <%> character
Examples:
"%f>%l:%c:%t:%n:%m" for the AztecC.Err file
"%f:%l:\ %t%*[^0123456789]%n:\ %m" for Aztec C error messages
"%f\ %l\ %t%*[^0123456789]%n:\ %m" for SAS C
"\"%f\",%*[^0123456789]%l:\ %m" default for generic C compilers
"%f:%l:%m" for GCC
Note the backslash in front of a space and double quote. It is required for
the :set command.
The "%f" and "%m" conversions have to detect the end of the string. They
should be followed by a character that cannot be in the string. Everything
up to that character is included in the string. Be careful: "%f%l" will
include everything up to the first <%> in the file name. If the "%f" or "%m"
is at the end, everything up to the end of the line is included.
If a line is detected that does not completely match the 'errorformat', the
whole line is put in the error message and the entry is marked "not valid"
These lines are skipped with the ":cn" and ":cp" commands (unless there is
no valid line at all). You can use ":cl" to display all the error messages.
If the error format does not contain a file name Vim cannot switch to the
correct file. You will have to do this by hand.
If you have a compiler that produces error messages that do not fit in the
format string, you could write a program that translates the error messages
into this format. You can use this program with the ":make" command by
changing the 'makeprg' option. For example:
":set mp=make\ \\\|&\ error_filter".
The backslashes before the pipe character are required to avoid it to be
recognized as a command separator. The backslash before each space is
required for the set command.
The ":make" command executes the command given with the 'makeprg' option.
This is done by passing the command to the shell given with the 'shell'
option. This works almost like typing
":!{makeprg} [arguments] {shellpipe} {errorfile}".
{makeprg} is the string given with the 'makeprg' option. Any command can be
used, not just "make". Characters <%> and <#> are expanded as usual on a
command line. You can use "#<" to insert the current filename without
extension, for example ":set makeprg=make\ #<.o".
[arguments] is anything that is typed after ":make".
{shellpipe} is the 'shellpipe' option.
{errorfile} is the 'errorfile' option.
The 'shellpipe' option defaults to ">" for the Amiga and MSDOS. This means
that the output of the compiler is saved in a file and not shown on the
screen directly. For Unix "| tee" is used. The compiler output is shown on
the screen and saved in a file the same time. Depending on the shell used
"|& tee" or "2>&1| tee" is the default, so stderr output will be included.
There are some restrictions to the Quickfix mode on the Amiga. The
compiler only writes the first 25 errors to the errorfile (Manx's
documentation does not say how to get more). If you want to find the others,
you will have to fix a few errors and exit the editor. After recompiling,
up to 25 remaining errors will be found.
On the Amiga, if Vim was started from the compiler, the :sh and :! commands
will not work, because Vim is then running in the same process as the
compiler and these two commands may guru the machine then.
If you insert or delete lines, mostly the correct error location is still
found because hidden marks are used (Manx's Z editor does not do this).
Sometimes, when the mark has been deleted for some reason, the message "line
changed" is shown to warn you that the error location may not be correct. If
you quit Vim and start again the marks are lost and the error locations may
not be correct anymore.
5.6 Editing binary files
Although Vim was made to edit text files, it is possible to edit binary
files. The "-b" command line option (b for binary) sets some options for
editing binary files ('binary' on, 'textwidth' to 0, 'textmode' and
'textauto' off, 'modelines' to 0, 'expandtab' off). Setting the 'binary'
option has the same effect. Don't forget to do this before reading the file.
There are a few things to remember when editing binary files:
- When editing executable files the number of characters must not change.
Use only the "R" or "r" command to change text. Do not delete characters
with "x" or by backspacing.
- Set the 'textwidth' option to 0. Otherwise lines will unexpectedly be
split in two.
- When there are not many end-of-line characters, the lines will become very
long. If you want to edit a line that does not fit on the screen reset the
'wrap' option. Horizontal scrolling is used then. If a line becomes too
long (more than about 32767 characters on the Amiga, much more on 32-bit
systems) you cannot edit that line. The line will be split when reading
the file. It is also possible that you get an "out of memory" error when
reading the file.
- Make sure the 'textmode' and 'textauto' options are off before loading the
file. In 'textmode' both and are considered to end a line
and when the file is written the will be replaced by . The
'modelines' option should also be off, because there may be a string like
":vi:" in the file that would give unpredictable results.
- characters are shown on the screen as ^@. You can enter them with
"CTRL-V CTRL-@" or "CTRL-V 000" {vi cannot handle characters in the
file}
- To insert a character in the file split up a line. When writing the
buffer to a file a will be written for the end of line.
- Vim normally appends an end-of-line character at the end of the file if
there is none. Setting the 'binary' option prevents this. If you want to
add the final end-of-line, set the 'endofline' option. You can also read the
value of this option to see if there was an end-of-line character for the
last line (you cannot see this in the text).
6. Cursor motions
These commands move the cursor position. If the new position is off of the
screen, the screen is scrolled to show the cursor (see also 'scrolljump'
option).
The motion commands can be used after other commands, called operators, to
have the command operate on the text that was moved over. That is the text
between the cursor position before and after the motion. If the motion
includes a count and the operator also had a count, the two counts are
multiplied. For example: "2d3w" deletes six words.
The operator either affects whole lines, or the characters between
the start and end position. Generally, motions that move between lines
affect lines (are linewise), and motions that move within a line affect
characters. However, there are some exceptions.
A character motion is either inclusive or exclusive. When inclusive,
the start and end position of the motion are included in the operation.
When exclusive, the last character towards the end of the buffer is not
included. Linewise motions always include the start and end position.
Which motions are linewise, inclusive or exclusive is mentioned
below. There are however, two general exceptions:
1. If the motion is exclusive and the end of the motion is in column 1, the
end of the motion is moved to the end of the previous line and the motion
becomes inclusive. Example: "}" ends at the first line after a paragraph,
but "V}" will not include that line.
2. If the motion is exclusive, the end of the motion is in column 1 and the
start of the motion was at or before the first non-blank in the line, the
motion becomes linewise. Example: If a paragraph begins with some blanks
and you do "d}" while standing on the first non-blank, all the lines of
the paragraph are deleted, including the blanks. If you do a put now, the
deleted lines will be inserted below the cursor position.
Instead of first giving the operator and then a motion you can use Visual
mode: mark the start of the text with , move the cursor to the end of the
text that is to be affected and then hit the operator. The text between the
start and the cursor position is highlighted, so you can see what text will
be operated upon. This allows much more freedom, but requires more key
strokes and has limited redo functionality. See the chapter on Visual mode.
If you want to know where you are in the file use the "CTRL-G" command. If
you set the 'ruler' option, the cursor position is continuously shown in the
status line (which slows down Vim a little).
NOTE: Experienced users prefer the hjkl keys because they are always right
under their fingers. Beginners often prefer the arrow keys, because they
do not know what the hjkl keys do. The mnemonic value of hjkl is clear from
looking at the keyboard. Think of j as an arrow pointing downwards.
6.1 Left-right motions
h or
or
CTRL-H or
[count] characters to the left (exclusive).
l or
or
[count] characters to the right (exclusive).
0 To the first character of the line (exclusive).
^ To the first non-blank character of the line
(exclusive).
$ To the end of line [count] from the cursor
(inclusive).
| To column [count] (inclusive).
f To [count]'th occurrence of to the right. The
cursor is placed on (inclusive).
F To the [count]'th occurrence of to the left.
The cursor is placed on (inclusive).
t Till before [count]'th occurrence of to the
right. The cursor is placed on the character left of
(inclusive).
T Till after [count]'th occurrence of to the
left. The cursor is placed on the character right of
(inclusive).
; Repeat latest f, t, F or T [count] times.
, Repeat latest f, t, F or T in opposite direction
[count] times.
These commands move the cursor to the specified column in the current line.
They stop at the first column and at the end of the line, except "$", which
may move to one of the next lines.
6.2 Up-down motions
k or
or
CTRL-P [count] lines upward (linewise).
j or
or
CTRL-J or
or
CTRL-N [count] lines downward (linewise).
- [count] lines upward, on the first non-blank
character (linewise).
+ or
CTRL-M or
[count] lines downward, on the first non-blank
character (linewise).
_ [count] - 1 lines downward, on the first non-blank
character (linewise).
G Goto line [count], default last line, on the first
non-blank character (linewise).
:[range] Set the cursor on the (last) specified line number
(cannot be used with an operator).
{count}% Go to {count} percentage in the file, on the first
non-blank in the line (linewise). To compute the new
line number this formula is used: {count} *
number-of-lines / 100. {not in Vi}
These commands move to the specified line. They stop when reaching the first
or the last line. The first two commands put the cursor in the same column
(if possible) as it was after the last command that changed the column,
except after the "$" command, then the cursor will be put on the last
character of the line.
6.3 Word motions
or
w [count] words forward (exclusive).
W [count] WORDS forward (exclusive).
e Forward to the end of word [count] (inclusive).
E Forward to the end of WORD [count] (inclusive).
or
b [count] words backward (exclusive).
B [count] WORDS backward (exclusive).
These commands move over words or WORDS. A word consists of a sequence of
letters, digits and underscores, or a sequence of other non-blank
characters, separated with white space (spaces, tabs, end of line). A WORD
consists of a sequence of non-blank characters, separated with white space.
An empty line is also considered to be a word and a WORD.
Special case: "cw" and "cW" are treated like "ce" and "cE" if the cursor is
on a non-blank. This is because "cw" is interpreted as change-word, and a
word does not include the following white space. {Vi: "cw" when on a blank
followed by other blanks changes only the first blank; this is probably a
bug, because "dw" deletes all the blanks}
Another special case: When using the "w" motion in combination with an
operator and the last word moved over is at the end of a line, the end of
that word becomes the end of the operated text, not the first word in the
next line.
The original vi implementation of "e" is buggy. For example, the "e" command
will stop on the first character of a line if the previous line was empty.
But when you use "2e" this does not happen. In Vim "ee" and "2e" are the
same, which is more logical. However, this causes a small incompatibility
between vi and Vim.
6.4 Text object motions
( [count] sentences backward (exclusive).
) [count] sentences forward (exclusive).
{ [count] paragraphs backward (exclusive).
} [count] paragraphs forward (exclusive).
]] [count] sections forward or to the next <{> in the
first column. When used after an operator, then the
<}> in the first column. (linewise).
][ [count] sections forward or to the next <}> in the
first column (linewise).
[[ [count] sections backward or to the previous <{> in
the first column (linewise).
[] [count] sections backward or to the previous <}> in
the first column (linewise).
These commands move over three kinds of text objects.
A sentence is defined as ending at a <.>, or followed by either the
end of a line, or by a space. {Vi: two spaces} Any number of closing <)>,
<]>, <"> and <'> characters my appear after the <.>, or before the
spaces or end of line. A paragraph and section boundary is also a sentence
boundary.
A paragraph begins after each empty line, and also at each of a set of
paragraph macros, specified by the pairs of characters in the 'paragraphs'
option. The default is "IPLPPPQPP LIpplpipbp", which corresponds to the
macros ".IP", ".LP", etc. (these are nroff macros, the dot must be in the
first column). A section boundary is also a paragraph boundary. Note that
this does not include a <{> or <}> in the first column.
A section begins after a form-feed in the first column and at each of a set
of section macros, specified by the pairs of characters in the 'sections'
option. The default is "SHNHH HUnhsh".
The "]" and "[" commands stop at the <{> or <}" in the first column. This is
useful to find the start or end of a function in a C program. Note that the
first character of the command determines the search direction and the
second character the type of brace found.
6.5 Pattern searches
/{pattern}[/] Search forward for the [count]'th occurrence of
{pattern} (exclusive).
/{pattern}/{offset} Search forward for the [count]'th occurrence of
{pattern} and go {offset} lines up or down (see
below). (linewise).
/ Search forward for the [count]'th latest used
pattern with latest used {offset}.
//{offset} Search forward for the [count]'th latest used
pattern with new {offset}. If {offset} is empty no
offset is used.
* Search forward for the [count]'th occurrence of the
ident after or under the cursor (exclusive). Only
whole words are search for, like with the command
"/\". If there is no identifier after or
under the cursor, any non-blank word is used to
search for. {not in Vi}
# Same as "*", but search backward. {not in Vi}
?{pattern}[?] Search backward for the [count]'th previous
occurrence of {pattern} (exclusive).
?{pattern}?{offset} Search backward for the [count]'th previous
occurrence of {pattern} and go {offset} lines up or
down (see below) (linewise).
? Search backward for the [count]'th latest used
pattern with latest used {offset}.
??{offset} Search backward for the [count]'th latest used
pattern with new {offset}. If {offset} is empty no
offset is used.
n Repeat the latest "/" or "?" [count] times. {Vi: no
count}
N Repeat the latest "/" or "?" [count] times in
opposite direction. {Vi: no count}
CTRL-C Interrupt current (search) command.
These commands search for the specified pattern. With "/" and "?" an
additional offset may be given. There are two types of offsets: line offsets
and character offsets. {the character offsets are not in Vi}
The offset gives the cursor position relative to the found match:
[num] [num] lines downwards, in column 1
+[num] [num] lines downwards, in column 1
-[num] [num] lines upwards, in column 1
e[+num] [num] characters to the right of the end of the match
e[-num] [num] characters to the left of the end of the match
s[+num] [num] characters to the right of the start of the match
s[-num] [num] characters to the left of the start of the match
b[+num] [num] characters to the right of the start (begin) of the match
b[-num] [num] characters to the left of the start (begin) of the match
If a <-> or <+> is given but [num] is omitted, a count of one will be used.
When including an offset with 'e', the search becomes inclusive (the
character the cursor lands on is included in operations).
Examples:
pattern cursor position
/test/+1 one line below "test", in column 1
/test/e on the last t of "test"
/test/s+2 on the of "test"
/test/b-3 three characters before "test"
If one of these commands is used after an operator, the characters between
the cursor position before and after the search is affected. However, if a
line offset is given, the whole lines between the two cursor positions are
affected.
The last used and are remembered. They can be used to
repeat the search, possibly in another direction or with another count. Note
that two patterns are remembered: one for 'normal' search commands and one
for the substitute command ":s". Each time an empty is given, the
previously used is used.
{In vi the :tag command sets a new search pattern when the tag is searched
for. In Vim this is not done, the previous search pattern is still
remembered}.
If the 'wrapscan' option is set (which is the default), searches wrap around
the end of the buffer. If 'wrapscan' is not set, the backward search stops
at the beginning and the forward search stops at the end of the buffer. If
'wrapscan' is set and the pattern was not found the error message "pattern
not found" is given, and the cursor will not be moved. If 'wrapscan' is not
set the message becomes "search hit BOTTOM without match" when searching
forward, or "search hit TOP without match" when searching backward. If
wrapscan is set and the search wraps around the end of the file the message
"search hit TOP, continuing at BOTTOM" or "search hit BOTTOM, continuing at
TOP" is given when searching backwards or forwards respectively.
The "*" and "#" commands search for the identifier currently under the
cursor. If there is no identifier under the cursor, the first one to the
right is used. This identifier may only contain letters, digits and
underscores. Note that if you type with ten fingers, the characters are easy
to remember: the "#" is under your left hand middle finger (search to the
left and up) and the "*" is under your right hand middle finger (search to
the right and down). If there is no identifier under or after the cursor, a
search is done for any word under or after the cursor. Blanks (s and/or
s) are recognized as delimiters for this word.
The definition of a pattern:
Patterns may contain special characters, depending on the setting of the
'magic' option.
1. A pattern is one or more branches, separated by '\|'. It matches anything
that matches one of the branches. Example: "foo\|bar" matches "foo" and
"bar.
2. A branch is one or more pieces, concatenated. It matches a match for the
first, followed by a match for the second, etc. Example: "foo[0-9]bar",
first match "foo", then a digit and then "bar".
3. A piece is an atom, possibly followed by:
'magic' 'nomagic'
option option
* \* matches 0 or more of the preceding atom
\+ \+ matches 1 or more of the preceding atom {not
in Vi}
\= \= matches 0 or 1 of the preceding atom {not in
Vi}
Examples:
.* .\* match anything, also empty string
.\+ .\+ match any non-empty string
foo\= foo\= match "fo" and "foo"
4. An atom can be:
- One of these five:
magic nomagic
. \. matches any single character
\< \< matches the beginning of a word
\> \> matches the end of a word
^ ^ at beginning of pattern, matches start of
line
$ $ at end of pattern or in front of '\|',
matches end of line
- A pattern enclosed by escaped parentheses (e.g. "\(^a\)").
- A single character, with no special meaning, matches itself
- A backslash followed by a single character, with no special meaning,
matches the single character.
- A range. This is a sequence of characters enclosed in '[]' with the
'magic' option, or enclosed in '\[]' with the 'nomagic' option. It
normally matches any single character from the sequence. If the
sequence begins with <^>, it matches any single character NOT in the
sequence. If two characters in the sequence are separated by <->, this
is shorthand for the full list of ASCII characters between them (e.g.
'[0-9]' matches any decimal digit). To include a literal <]> in the
sequence, make it the first character (following a possible <^>). To
include a literal '\-', make it the first or last character.
If the 'ignorecase' option is set, the case of letters is ignored.
It is impossible to have a pattern that contains a line break.
Examples:
^beep( Probably the start of the C function "beep".
[a-zA-Z]$ Any alphabetic character at the end of a line.
\(^\|[^a-zA-Z0-9_]\)[a-zA-Z_]\+[a-zA-Z0-9_]*
A C identifier (will stop in front of it).
\(\.$\|\. \) A period followed by end-of-line or a space.
Note that "\(\. \|\.$\)" does not do the same,
because '$' is not end-of-line in front of '\)'.
This was done to remain vi-compatible.
[.!?][])"']*\($\|[ ]\) A search pattern that finds the end of a sentence,
with almost the same definition as the <)> command.
Technical detail:
characters in the file are stored as in memory. In the display
they are shown as "^@". The translation is done when reading and writing
files. To match a with a search pattern you can just enter CTRL-@ or
"CTRL-V 000". This is probably just what you expect. Internally the
character is replaced by a in the search pattern. What is unusual is
that typing CTRL_V CTRL_J also inserts a , thus also searches for a
in the file. {vi cannot handle characters in the file at all}
6.6 Various motions
m Set mark at cursor position (does not move
the cursor, this is not a motion command).
:[range]mar[k] Set mark at last line number in [range],
column 0. Default is cursor line.
:[range]k Same as :mark, but the space before the mark name can
be omitted.
' To the first non-blank character on the line with
mark (linewise).
' To the first non-blank character on the line with
mark in the correct file (linewise when in
same file, not a motion command when in other file).
{not in Vi}
` To the mark (exclusive).
` To the mark in the correct file (exclusive
when in same file, not a motion command when in
other file). {not in Vi}
:marks List the current marks (not a motion command). {not
in Vi}
A mark is not visible in any way. It is just a position in the file that is
remembered. Do not confuse marks with named registers, they are totally
unrelated.
Lowercase marks are only remembered as long as the file remains loaded. If
you quit editing the file, change a character in a line or delete a line
that contains a mark, that mark is erased. Lowercase marks can be used
in combination with operators. For example: "d't" deletes the lines from the
cursor position to mark