2017-03-21 09:08:19 -07:00
|
|
|
|
*usr_24.txt* Nvim
|
2014-07-10 21:05:51 -07:00
|
|
|
|
|
|
|
|
|
VIM USER MANUAL - by Bram Moolenaar
|
|
|
|
|
|
|
|
|
|
Inserting quickly
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
When entering text, Vim offers various ways to reduce the number of keystrokes
|
|
|
|
|
and avoid typing mistakes. Use Insert mode completion to repeat previously
|
|
|
|
|
typed words. Abbreviate long words to short ones. Type characters that
|
|
|
|
|
aren't on your keyboard.
|
|
|
|
|
|
|
|
|
|
|24.1| Making corrections
|
|
|
|
|
|24.2| Showing matches
|
|
|
|
|
|24.3| Completion
|
|
|
|
|
|24.4| Repeating an insert
|
|
|
|
|
|24.5| Copying from another line
|
|
|
|
|
|24.6| Inserting a register
|
|
|
|
|
|24.7| Abbreviations
|
|
|
|
|
|24.8| Entering special characters
|
|
|
|
|
|24.9| Digraphs
|
|
|
|
|
|24.10| Normal mode commands
|
|
|
|
|
|
|
|
|
|
Next chapter: |usr_25.txt| Editing formatted text
|
|
|
|
|
Previous chapter: |usr_23.txt| Editing other files
|
|
|
|
|
Table of contents: |usr_toc.txt|
|
|
|
|
|
|
|
|
|
|
==============================================================================
|
|
|
|
|
*24.1* Making corrections
|
|
|
|
|
|
|
|
|
|
The <BS> key was already mentioned. It deletes the character just before the
|
|
|
|
|
cursor. The <Del> key does the same for the character under (after) the
|
|
|
|
|
cursor.
|
|
|
|
|
When you typed a whole word wrong, use CTRL-W:
|
|
|
|
|
|
|
|
|
|
The horse had fallen to the sky ~
|
|
|
|
|
CTRL-W
|
|
|
|
|
The horse had fallen to the ~
|
|
|
|
|
|
|
|
|
|
If you really messed up a line and want to start over, use CTRL-U to delete
|
|
|
|
|
it. This keeps the text after the cursor and the indent. Only the text from
|
|
|
|
|
the first non-blank to the cursor is deleted. With the cursor on the "f" of
|
|
|
|
|
"fallen" in the next line pressing CTRL-U does this:
|
|
|
|
|
|
|
|
|
|
The horse had fallen to the ~
|
|
|
|
|
CTRL-U
|
|
|
|
|
fallen to the ~
|
|
|
|
|
|
|
|
|
|
When you spot a mistake a few words back, you need to move the cursor there to
|
|
|
|
|
correct it. For example, you typed this:
|
|
|
|
|
|
|
|
|
|
The horse had follen to the ground ~
|
|
|
|
|
|
|
|
|
|
You need to change "follen" to "fallen". With the cursor at the end, you
|
|
|
|
|
would type this to correct it: >
|
|
|
|
|
|
|
|
|
|
<Esc>4blraA
|
|
|
|
|
|
|
|
|
|
< get out of Insert mode <Esc>
|
|
|
|
|
four words back 4b
|
|
|
|
|
move on top of the "o" l
|
|
|
|
|
replace with "a" ra
|
|
|
|
|
restart Insert mode A
|
|
|
|
|
|
|
|
|
|
Another way to do this: >
|
|
|
|
|
|
|
|
|
|
<C-Left><C-Left><C-Left><C-Left><Right><Del>a<End>
|
|
|
|
|
|
|
|
|
|
< four words back <C-Left><C-Left><C-Left><C-Left>
|
|
|
|
|
move on top of the "o" <Right>
|
|
|
|
|
delete the "o" <Del>
|
|
|
|
|
insert an "a" a
|
|
|
|
|
go to end of the line <End>
|
|
|
|
|
|
|
|
|
|
This uses special keys to move around, while remaining in Insert mode. This
|
|
|
|
|
resembles what you would do in a modeless editor. It's easier to remember,
|
|
|
|
|
but takes more time (you have to move your hand from the letters to the cursor
|
|
|
|
|
keys, and the <End> key is hard to press without looking at the keyboard).
|
|
|
|
|
These special keys are most useful when writing a mapping that doesn't
|
|
|
|
|
leave Insert mode. The extra typing doesn't matter then.
|
|
|
|
|
An overview of the keys you can use in Insert mode:
|
|
|
|
|
|
|
|
|
|
<C-Home> to start of the file
|
|
|
|
|
<PageUp> a whole screenful up
|
|
|
|
|
<Home> to start of line
|
|
|
|
|
<S-Left> one word left
|
|
|
|
|
<C-Left> one word left
|
|
|
|
|
<S-Right> one word right
|
|
|
|
|
<C-Right> one word right
|
|
|
|
|
<End> to end of the line
|
|
|
|
|
<PageDown> a whole screenful down
|
|
|
|
|
<C-End> to end of the file
|
|
|
|
|
|
|
|
|
|
There are a few more, see |ins-special-special|.
|
|
|
|
|
|
|
|
|
|
==============================================================================
|
|
|
|
|
*24.2* Showing matches
|
|
|
|
|
|
|
|
|
|
When you type a ) it would be nice to see with which ( it matches. To make
|
|
|
|
|
Vim do that use this command: >
|
|
|
|
|
|
|
|
|
|
:set showmatch
|
|
|
|
|
|
|
|
|
|
When you now type a text like "(example)", as soon as you type the ) Vim will
|
|
|
|
|
briefly move the cursor to the matching (, keep it there for half a second,
|
|
|
|
|
and move back to where you were typing.
|
|
|
|
|
In case there is no matching (, Vim will beep. Then you know that you
|
|
|
|
|
might have forgotten the ( somewhere, or typed a ) too many.
|
|
|
|
|
The match will also be shown for [] and {} pairs. You don't have to wait
|
|
|
|
|
with typing the next character, as soon as Vim sees it the cursor will move
|
|
|
|
|
back and inserting continues as before.
|
|
|
|
|
You can change the time Vim waits with the 'matchtime' option. For
|
|
|
|
|
example, to make Vim wait one and a half second: >
|
|
|
|
|
|
|
|
|
|
:set matchtime=15
|
|
|
|
|
|
|
|
|
|
The time is specified in tenths of a second.
|
|
|
|
|
|
|
|
|
|
==============================================================================
|
|
|
|
|
*24.3* Completion
|
|
|
|
|
|
|
|
|
|
Vim can automatically complete words on insertion. You type the first part of
|
|
|
|
|
a word, press CTRL-P, and Vim guesses the rest.
|
|
|
|
|
Suppose, for example, that you are creating a C program and want to type in
|
|
|
|
|
the following:
|
|
|
|
|
|
|
|
|
|
total = ch_array[0] + ch_array[1] + ch_array[2]; ~
|
|
|
|
|
|
|
|
|
|
You start by entering the following:
|
|
|
|
|
|
|
|
|
|
total = ch_array[0] + ch_ ~
|
|
|
|
|
|
|
|
|
|
At this point, you tell Vim to complete the word using the command CTRL-P.
|
|
|
|
|
Vim searches for a word that starts with what's in front of the cursor. In
|
|
|
|
|
this case, it is "ch_", which matches with the word ch_array. So typing
|
|
|
|
|
CTRL-P gives you the following:
|
|
|
|
|
|
|
|
|
|
total = ch_array[0] + ch_array ~
|
|
|
|
|
|
|
|
|
|
After a little more typing, you get this (ending in a space):
|
|
|
|
|
|
|
|
|
|
total = ch_array[0] + ch_array[1] + ~
|
|
|
|
|
|
|
|
|
|
If you now type CTRL-P Vim will search again for a word that completes the
|
|
|
|
|
word before the cursor. Since there is nothing in front of the cursor, it
|
|
|
|
|
finds the first word backwards, which is "ch_array". Typing CTRL-P again
|
|
|
|
|
gives you the next word that matches, in this case "total". A third CTRL-P
|
|
|
|
|
searches further back. If there is nothing else, it causes the editor to run
|
|
|
|
|
out of words, so it returns to the original text, which is nothing. A fourth
|
|
|
|
|
CTRL-P causes the editor to start over again with "ch_array".
|
|
|
|
|
|
|
|
|
|
To search forward, use CTRL-N. Since the search wraps around the end of the
|
|
|
|
|
file, CTRL-N and CTRL-P will find the same matches, but in a different
|
|
|
|
|
sequence. Hint: CTRL-N is Next-match and CTRL-P is Previous-match.
|
|
|
|
|
|
|
|
|
|
The Vim editor goes through a lot of effort to find words to complete. By
|
|
|
|
|
default, it searches the following places:
|
|
|
|
|
|
|
|
|
|
1. Current file
|
|
|
|
|
2. Files in other windows
|
|
|
|
|
3. Other loaded files (hidden buffers)
|
|
|
|
|
4. Files which are not loaded (inactive buffers)
|
|
|
|
|
5. Tag files
|
|
|
|
|
6. All files #included by the current file
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
OPTIONS
|
|
|
|
|
|
|
|
|
|
You can customize the search order with the 'complete' option.
|
|
|
|
|
|
|
|
|
|
The 'ignorecase' option is used. When it is set, case differences are ignored
|
|
|
|
|
when searching for matches.
|
|
|
|
|
|
|
|
|
|
A special option for completion is 'infercase'. This is useful to find
|
|
|
|
|
matches while ignoring case ('ignorecase' must be set) but still using the
|
|
|
|
|
case of the word typed so far. Thus if you type "For" and Vim finds a match
|
|
|
|
|
"fortunately", it will result in "Fortunately".
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
COMPLETING SPECIFIC ITEMS
|
|
|
|
|
|
|
|
|
|
If you know what you are looking for, you can use these commands to complete
|
|
|
|
|
with a certain type of item:
|
|
|
|
|
|
|
|
|
|
CTRL-X CTRL-F file names
|
|
|
|
|
CTRL-X CTRL-L whole lines
|
|
|
|
|
CTRL-X CTRL-D macro definitions (also in included files)
|
|
|
|
|
CTRL-X CTRL-I current and included files
|
|
|
|
|
CTRL-X CTRL-K words from a dictionary
|
|
|
|
|
CTRL-X CTRL-T words from a thesaurus
|
|
|
|
|
CTRL-X CTRL-] tags
|
|
|
|
|
CTRL-X CTRL-V Vim command line
|
|
|
|
|
|
|
|
|
|
After each of them CTRL-N can be used to find the next match, CTRL-P to find
|
|
|
|
|
the previous match.
|
|
|
|
|
More information for each of these commands here: |ins-completion|.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
COMPLETING FILE NAMES
|
|
|
|
|
|
|
|
|
|
Let's take CTRL-X CTRL-F as an example. This will find file names. It scans
|
|
|
|
|
the current directory for files and displays each one that matches the word in
|
|
|
|
|
front of the cursor.
|
|
|
|
|
Suppose, for example, that you have the following files in the current
|
|
|
|
|
directory:
|
|
|
|
|
|
|
|
|
|
main.c sub_count.c sub_done.c sub_exit.c
|
|
|
|
|
|
|
|
|
|
Now enter Insert mode and start typing:
|
|
|
|
|
|
|
|
|
|
The exit code is in the file sub ~
|
|
|
|
|
|
|
|
|
|
At this point, you enter the command CTRL-X CTRL-F. Vim now completes the
|
|
|
|
|
current word "sub" by looking at the files in the current directory. The
|
|
|
|
|
first match is sub_count.c. This is not the one you want, so you match the
|
|
|
|
|
next file by typing CTRL-N. This match is sub_done.c. Typing CTRL-N again
|
|
|
|
|
takes you to sub_exit.c. The results:
|
|
|
|
|
|
|
|
|
|
The exit code is in the file sub_exit.c ~
|
|
|
|
|
|
|
|
|
|
If the file name starts with / (Unix) or C:\ (MS-Windows) you can find all
|
|
|
|
|
files in the file system. For example, type "/u" and CTRL-X CTRL-F. This
|
|
|
|
|
will match "/usr" (this is on Unix):
|
|
|
|
|
|
|
|
|
|
the file is found in /usr/ ~
|
|
|
|
|
|
|
|
|
|
If you now press CTRL-N you go back to "/u". Instead, to accept the "/usr/"
|
|
|
|
|
and go one directory level deeper, use CTRL-X CTRL-F again:
|
|
|
|
|
|
|
|
|
|
the file is found in /usr/X11R6/ ~
|
|
|
|
|
|
|
|
|
|
The results depend on what is found in your file system, of course. The
|
|
|
|
|
matches are sorted alphabetically.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
COMPLETING IN SOURCE CODE
|
|
|
|
|
|
|
|
|
|
Source code files are well structured. That makes it possible to do
|
|
|
|
|
completion in an intelligent way. In Vim this is called Omni completion. In
|
|
|
|
|
some other editors it's called intellisense, but that is a trademark.
|
|
|
|
|
|
|
|
|
|
The key to Omni completion is CTRL-X CTRL-O. Obviously the O stands for Omni
|
|
|
|
|
here, so that you can remember it easier. Let's use an example for editing C
|
|
|
|
|
source:
|
|
|
|
|
|
|
|
|
|
{ ~
|
|
|
|
|
struct foo *p; ~
|
|
|
|
|
p-> ~
|
|
|
|
|
|
|
|
|
|
The cursor is after "p->". Now type CTRL-X CTRL-O. Vim will offer you a list
|
|
|
|
|
of alternatives, which are the items that "struct foo" contains. That is
|
|
|
|
|
quite different from using CTRL-P, which would complete any word, while only
|
|
|
|
|
members of "struct foo" are valid here.
|
|
|
|
|
|
|
|
|
|
For Omni completion to work you may need to do some setup. At least make sure
|
|
|
|
|
filetype plugins are enabled. Your vimrc file should contain a line like
|
|
|
|
|
this: >
|
|
|
|
|
filetype plugin on
|
|
|
|
|
Or: >
|
|
|
|
|
filetype plugin indent on
|
|
|
|
|
|
|
|
|
|
For C code you need to create a tags file and set the 'tags' option. That is
|
|
|
|
|
explained |ft-c-omni|. For other filetypes you may need to do something
|
|
|
|
|
similar, look below |compl-omni-filetypes|. It only works for specific
|
|
|
|
|
filetypes. Check the value of the 'omnifunc' option to find out if it would
|
|
|
|
|
work.
|
|
|
|
|
|
|
|
|
|
==============================================================================
|
|
|
|
|
*24.4* Repeating an insert
|
|
|
|
|
|
|
|
|
|
If you press CTRL-A, the editor inserts the text you typed the last time you
|
|
|
|
|
were in Insert mode.
|
|
|
|
|
Assume, for example, that you have a file that begins with the following:
|
|
|
|
|
|
|
|
|
|
"file.h" ~
|
|
|
|
|
/* Main program begins */ ~
|
|
|
|
|
|
|
|
|
|
You edit this file by inserting "#include " at the beginning of the first
|
|
|
|
|
line:
|
|
|
|
|
|
|
|
|
|
#include "file.h" ~
|
|
|
|
|
/* Main program begins */ ~
|
|
|
|
|
|
|
|
|
|
You go down to the beginning of the next line using the commands "j^". You
|
|
|
|
|
now start to insert a new "#include" line. So you type: >
|
|
|
|
|
|
|
|
|
|
i CTRL-A
|
|
|
|
|
|
|
|
|
|
The result is as follows:
|
|
|
|
|
|
|
|
|
|
#include "file.h" ~
|
|
|
|
|
#include /* Main program begins */ ~
|
|
|
|
|
|
|
|
|
|
The "#include " was inserted because CTRL-A inserts the text of the previous
|
|
|
|
|
insert. Now you type "main.h"<Enter> to finish the line:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#include "file.h" ~
|
|
|
|
|
#include "main.h" ~
|
|
|
|
|
/* Main program begins */ ~
|
|
|
|
|
|
|
|
|
|
The CTRL-@ command does a CTRL-A and then exits Insert mode. That's a quick
|
|
|
|
|
way of doing exactly the same insertion again.
|
|
|
|
|
|
|
|
|
|
==============================================================================
|
|
|
|
|
*24.5* Copying from another line
|
|
|
|
|
|
|
|
|
|
The CTRL-Y command inserts the character above the cursor. This is useful
|
|
|
|
|
when you are duplicating a previous line. For example, you have this line of
|
|
|
|
|
C code:
|
|
|
|
|
|
|
|
|
|
b_array[i]->s_next = a_array[i]->s_next; ~
|
|
|
|
|
|
|
|
|
|
Now you need to type the same line, but with "s_prev" instead of "s_next".
|
|
|
|
|
Start the new line, and press CTRL-Y 14 times, until you are at the "n" of
|
|
|
|
|
"next":
|
|
|
|
|
|
|
|
|
|
b_array[i]->s_next = a_array[i]->s_next; ~
|
|
|
|
|
b_array[i]->s_ ~
|
|
|
|
|
|
|
|
|
|
Now you type "prev":
|
|
|
|
|
|
|
|
|
|
b_array[i]->s_next = a_array[i]->s_next; ~
|
|
|
|
|
b_array[i]->s_prev ~
|
|
|
|
|
|
|
|
|
|
Continue pressing CTRL-Y until the following "next":
|
|
|
|
|
|
|
|
|
|
b_array[i]->s_next = a_array[i]->s_next; ~
|
|
|
|
|
b_array[i]->s_prev = a_array[i]->s_ ~
|
|
|
|
|
|
|
|
|
|
Now type "prev;" to finish it off.
|
|
|
|
|
|
|
|
|
|
The CTRL-E command acts like CTRL-Y except it inserts the character below the
|
|
|
|
|
cursor.
|
|
|
|
|
|
|
|
|
|
==============================================================================
|
|
|
|
|
*24.6* Inserting a register
|
|
|
|
|
|
|
|
|
|
The command CTRL-R {register} inserts the contents of the register. This is
|
|
|
|
|
useful to avoid having to type a long word. For example, you need to type
|
|
|
|
|
this:
|
|
|
|
|
|
|
|
|
|
r = VeryLongFunction(a) + VeryLongFunction(b) + VeryLongFunction(c) ~
|
|
|
|
|
|
|
|
|
|
The function name is defined in a different file. Edit that file and move the
|
|
|
|
|
cursor on top of the function name there, and yank it into register v: >
|
|
|
|
|
|
|
|
|
|
"vyiw
|
|
|
|
|
|
|
|
|
|
"v is the register specification, "yiw" is yank-inner-word. Now edit the file
|
|
|
|
|
where the new line is to be inserted, and type the first letters:
|
|
|
|
|
|
|
|
|
|
r = ~
|
|
|
|
|
|
|
|
|
|
Now use CTRL-R v to insert the function name:
|
|
|
|
|
|
|
|
|
|
r = VeryLongFunction ~
|
|
|
|
|
|
|
|
|
|
You continue to type the characters in between the function name, and use
|
|
|
|
|
CTRL-R v two times more.
|
|
|
|
|
You could have done the same with completion. Using a register is useful
|
|
|
|
|
when there are many words that start with the same characters.
|
|
|
|
|
|
|
|
|
|
If the register contains characters such as <BS> or other special characters,
|
|
|
|
|
they are interpreted as if they had been typed from the keyboard. If you do
|
|
|
|
|
not want this to happen (you really want the <BS> to be inserted in the text),
|
|
|
|
|
use the command CTRL-R CTRL-R {register}.
|
|
|
|
|
|
|
|
|
|
==============================================================================
|
|
|
|
|
*24.7* Abbreviations
|
|
|
|
|
|
|
|
|
|
An abbreviation is a short word that takes the place of a long one. For
|
|
|
|
|
example, "ad" stands for "advertisement". Vim enables you to type an
|
|
|
|
|
abbreviation and then will automatically expand it for you.
|
|
|
|
|
To tell Vim to expand "ad" into "advertisement" every time you insert it,
|
|
|
|
|
use the following command: >
|
|
|
|
|
|
|
|
|
|
:iabbrev ad advertisement
|
|
|
|
|
|
|
|
|
|
Now, when you type "ad", the whole word "advertisement" will be inserted into
|
|
|
|
|
the text. This is triggered by typing a character that can't be part of a
|
|
|
|
|
word, for example a space:
|
|
|
|
|
|
|
|
|
|
What Is Entered What You See
|
|
|
|
|
I saw the a I saw the a ~
|
|
|
|
|
I saw the ad I saw the ad ~
|
|
|
|
|
I saw the ad<Space> I saw the advertisement<Space> ~
|
|
|
|
|
|
|
|
|
|
The expansion doesn't happen when typing just "ad". That allows you to type a
|
|
|
|
|
word like "add", which will not get expanded. Only whole words are checked
|
|
|
|
|
for abbreviations.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ABBREVIATING SEVERAL WORDS
|
|
|
|
|
|
|
|
|
|
It is possible to define an abbreviation that results in multiple words. For
|
|
|
|
|
example, to define "JB" as "Jack Benny", use the following command: >
|
|
|
|
|
|
|
|
|
|
:iabbrev JB Jack Benny
|
|
|
|
|
|
|
|
|
|
As a programmer, I use two rather unusual abbreviations: >
|
|
|
|
|
|
|
|
|
|
:iabbrev #b /****************************************
|
|
|
|
|
:iabbrev #e <Space>****************************************/
|
|
|
|
|
|
|
|
|
|
These are used for creating boxed comments. The comment starts with #b, which
|
|
|
|
|
draws the top line. I then type the comment text and use #e to draw the
|
|
|
|
|
bottom line.
|
|
|
|
|
Notice that the #e abbreviation begins with a space. In other words, the
|
|
|
|
|
first two characters are space-star. Usually Vim ignores spaces between the
|
|
|
|
|
abbreviation and the expansion. To avoid that problem, I spell space as seven
|
|
|
|
|
characters: <, S, p, a, c, e, >.
|
|
|
|
|
|
|
|
|
|
Note:
|
|
|
|
|
":iabbrev" is a long word to type. ":iab" works just as well.
|
|
|
|
|
That's abbreviating the abbreviate command!
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FIXING TYPING MISTAKES
|
|
|
|
|
|
|
|
|
|
It's very common to make the same typing mistake every time. For example,
|
|
|
|
|
typing "teh" instead of "the". You can fix this with an abbreviation: >
|
|
|
|
|
|
|
|
|
|
:abbreviate teh the
|
|
|
|
|
|
|
|
|
|
You can add a whole list of these. Add one each time you discover a common
|
|
|
|
|
mistake.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LISTING ABBREVIATIONS
|
|
|
|
|
|
|
|
|
|
The ":abbreviate" command lists the abbreviations:
|
|
|
|
|
|
|
|
|
|
:abbreviate
|
|
|
|
|
i #e ****************************************/
|
|
|
|
|
i #b /****************************************
|
|
|
|
|
i JB Jack Benny
|
|
|
|
|
i ad advertisement
|
|
|
|
|
! teh the
|
|
|
|
|
|
|
|
|
|
The "i" in the first column indicates Insert mode. These abbreviations are
|
|
|
|
|
only active in Insert mode. Other possible characters are:
|
|
|
|
|
|
|
|
|
|
c Command-line mode :cabbrev
|
|
|
|
|
! both Insert and Command-line mode :abbreviate
|
|
|
|
|
|
|
|
|
|
Since abbreviations are not often useful in Command-line mode, you will mostly
|
|
|
|
|
use the ":iabbrev" command. That avoids, for example, that "ad" gets expanded
|
|
|
|
|
when typing a command like: >
|
|
|
|
|
|
|
|
|
|
:edit ad
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
DELETING ABBREVIATIONS
|
|
|
|
|
|
|
|
|
|
To get rid of an abbreviation, use the ":unabbreviate" command. Suppose you
|
|
|
|
|
have the following abbreviation: >
|
|
|
|
|
|
|
|
|
|
:abbreviate @f fresh
|
|
|
|
|
|
|
|
|
|
You can remove it with this command: >
|
|
|
|
|
|
|
|
|
|
:unabbreviate @f
|
|
|
|
|
|
|
|
|
|
While you type this, you will notice that @f is expanded to "fresh". Don't
|
|
|
|
|
worry about this, Vim understands it anyway (except when you have an
|
|
|
|
|
abbreviation for "fresh", but that's very unlikely).
|
|
|
|
|
To remove all the abbreviations: >
|
|
|
|
|
|
|
|
|
|
:abclear
|
|
|
|
|
|
|
|
|
|
":unabbreviate" and ":abclear" also come in the variants for Insert mode
|
|
|
|
|
(":iunabbreviate and ":iabclear") and Command-line mode (":cunabbreviate" and
|
|
|
|
|
":cabclear").
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
REMAPPING ABBREVIATIONS
|
|
|
|
|
|
|
|
|
|
There is one thing to watch out for when defining an abbreviation: The
|
|
|
|
|
resulting string should not be mapped. For example: >
|
|
|
|
|
|
|
|
|
|
:abbreviate @a adder
|
|
|
|
|
:imap dd disk-door
|
|
|
|
|
|
|
|
|
|
When you now type @a, you will get "adisk-doorer". That's not what you want.
|
|
|
|
|
To avoid this, use the ":noreabbrev" command. It does the same as
|
|
|
|
|
":abbreviate", but avoids that the resulting string is used for mappings: >
|
|
|
|
|
|
|
|
|
|
:noreabbrev @a adder
|
|
|
|
|
|
|
|
|
|
Fortunately, it's unlikely that the result of an abbreviation is mapped.
|
|
|
|
|
|
|
|
|
|
==============================================================================
|
|
|
|
|
*24.8* Entering special characters
|
|
|
|
|
|
|
|
|
|
The CTRL-V command is used to insert the next character literally. In other
|
|
|
|
|
words, any special meaning the character has, it will be ignored. For
|
|
|
|
|
example: >
|
|
|
|
|
|
|
|
|
|
CTRL-V <Esc>
|
|
|
|
|
|
|
|
|
|
Inserts an escape character. Thus you don't leave Insert mode. (Don't type
|
|
|
|
|
the space after CTRL-V, it's only to make this easier to read).
|
|
|
|
|
|
|
|
|
|
Note:
|
|
|
|
|
On MS-Windows CTRL-V is used to paste text. Use CTRL-Q instead of
|
|
|
|
|
CTRL-V. On Unix, on the other hand, CTRL-Q does not work on some
|
|
|
|
|
terminals, because it has a special meaning.
|
|
|
|
|
|
|
|
|
|
You can also use the command CTRL-V {digits} to insert a character with the
|
|
|
|
|
decimal number {digits}. For example, the character number 127 is the <Del>
|
|
|
|
|
character (but not necessarily the <Del> key!). To insert <Del> type: >
|
|
|
|
|
|
|
|
|
|
CTRL-V 127
|
|
|
|
|
|
|
|
|
|
You can enter characters up to 255 this way. When you type fewer than two
|
|
|
|
|
digits, a non-digit will terminate the command. To avoid the need of typing a
|
|
|
|
|
non-digit, prepend one or two zeros to make three digits.
|
|
|
|
|
All the next commands insert a <Tab> and then a dot:
|
|
|
|
|
|
|
|
|
|
CTRL-V 9.
|
|
|
|
|
CTRL-V 09.
|
|
|
|
|
CTRL-V 009.
|
|
|
|
|
|
|
|
|
|
To enter a character in hexadecimal, use an "x" after the CTRL-V: >
|
|
|
|
|
|
|
|
|
|
CTRL-V x7f
|
|
|
|
|
|
|
|
|
|
This also goes up to character 255 (CTRL-V xff). You can use "o" to type a
|
|
|
|
|
character as an octal number and two more methods allow you to type up to
|
|
|
|
|
a 16 bit and a 32 bit number (e.g., for a Unicode character): >
|
|
|
|
|
|
|
|
|
|
CTRL-V o123
|
|
|
|
|
CTRL-V u1234
|
|
|
|
|
CTRL-V U12345678
|
|
|
|
|
|
|
|
|
|
==============================================================================
|
|
|
|
|
*24.9* Digraphs
|
|
|
|
|
|
|
|
|
|
Some characters are not on the keyboard. For example, the copyright character
|
|
|
|
|
(<28>). To type these characters in Vim, you use digraphs, where two characters
|
|
|
|
|
represent one. To enter a <20>, for example, you press three keys: >
|
|
|
|
|
|
|
|
|
|
CTRL-K Co
|
|
|
|
|
|
|
|
|
|
To find out what digraphs are available, use the following command: >
|
|
|
|
|
|
|
|
|
|
:digraphs
|
|
|
|
|
|
|
|
|
|
Vim will display the digraph table. Here are three lines of it:
|
|
|
|
|
|
|
|
|
|
AC ~_ 159 NS | 160 !I <20> 161 Ct <20> 162 Pd <20> 163 Cu <20> 164 Ye <20> 165 ~
|
|
|
|
|
BB <20> 166 SE <20> 167 ': <20> 168 Co <20> 169 -a <20> 170 << <20> 171 NO <20> 172 ~
|
|
|
|
|
-- <20> 173 Rg <20> 174 'm <20> 175 DG <20> 176 +- <20> 177 2S <20> 178 3S <20> 179 ~
|
|
|
|
|
|
|
|
|
|
This shows, for example, that the digraph you get by typing CTRL-K Pd is the
|
|
|
|
|
character (<28>). This is character number 163 (decimal).
|
|
|
|
|
Pd is short for Pound. Most digraphs are selected to give you a hint about
|
|
|
|
|
the character they will produce. If you look through the list you will
|
|
|
|
|
understand the logic.
|
|
|
|
|
You can exchange the first and second character, if there is no digraph for
|
|
|
|
|
that combination. Thus CTRL-K dP also works. Since there is no digraph for
|
|
|
|
|
"dP" Vim will also search for a "Pd" digraph.
|
|
|
|
|
|
|
|
|
|
Note:
|
2016-01-06 16:45:50 -07:00
|
|
|
|
The digraphs depend on the character set that Vim assumes you
|
|
|
|
|
are using. Always use ":digraphs" to find out which digraphs are
|
|
|
|
|
currently available.
|
2014-07-10 21:05:51 -07:00
|
|
|
|
|
|
|
|
|
You can define your own digraphs. Example: >
|
|
|
|
|
|
|
|
|
|
:digraph a" <20>
|
|
|
|
|
|
|
|
|
|
This defines that CTRL-K a" inserts an <20> character. You can also specify the
|
|
|
|
|
character with a decimal number. This defines the same digraph: >
|
|
|
|
|
|
|
|
|
|
:digraph a" 228
|
|
|
|
|
|
|
|
|
|
More information about digraphs here: |digraphs|
|
|
|
|
|
Another way to insert special characters is with a keymap. More about that
|
|
|
|
|
here: |45.5|
|
|
|
|
|
|
|
|
|
|
==============================================================================
|
|
|
|
|
*24.10* Normal mode commands
|
|
|
|
|
|
|
|
|
|
Insert mode offers a limited number of commands. In Normal mode you have many
|
|
|
|
|
more. When you want to use one, you usually leave Insert mode with <Esc>,
|
|
|
|
|
execute the Normal mode command, and re-enter Insert mode with "i" or "a".
|
|
|
|
|
There is a quicker way. With CTRL-O {command} you can execute any Normal
|
|
|
|
|
mode command from Insert mode. For example, to delete from the cursor to the
|
|
|
|
|
end of the line: >
|
|
|
|
|
|
|
|
|
|
CTRL-O D
|
|
|
|
|
|
|
|
|
|
You can execute only one Normal mode command this way. But you can specify a
|
|
|
|
|
register or a count. A more complicated example: >
|
|
|
|
|
|
|
|
|
|
CTRL-O "g3dw
|
|
|
|
|
|
|
|
|
|
This deletes up to the third word into register g.
|
|
|
|
|
|
|
|
|
|
==============================================================================
|
|
|
|
|
|
|
|
|
|
Next chapter: |usr_25.txt| Editing formatted text
|
|
|
|
|
|
|
|
|
|
Copyright: see |manual-copyright| vim:tw=78:ts=8:ft=help:norl:
|