blob: 506ca2403f0f2dfea0b797a75a5811ea8ca610f5 [file] [log] [blame]
Bram Moolenaar8424a622006-04-19 21:23:36 +00001*map.txt* For Vim version 7.0e. Last change: 2006 Apr 19
Bram Moolenaar071d4272004-06-13 20:20:40 +00002
3
4 VIM REFERENCE MANUAL by Bram Moolenaar
5
6
7Key mapping, abbreviations and user-defined commands.
8
9This subject is introduced in sections |05.3|, |24.7| and |40.1| of the user
10manual.
11
121. Key mapping |key-mapping|
Bram Moolenaar5b962cf2005-12-12 21:58:40 +000013 1.1 MAP COMMANDS |:map-commands|
14 1.2 Special arguments |:map-arguments|
15 1.3 Mapping and modes |:map-modes|
16 1.4 Listing mappings |map-listing|
17 1.5 Mapping special keys |:map-special-keys|
18 1.6 Special characters |:map-special-chars|
19 1.7 What keys to map |map-which-keys|
20 1.8 Examples |map-examples|
21 1.9 Using mappings |map-typing|
22 1.10 Mapping alt-keys |:map-alt-keys|
23 1.11 Mapping an operator |:map-operator|
Bram Moolenaar071d4272004-06-13 20:20:40 +0000242. Abbreviations |abbreviations|
253. Local mappings and functions |script-local|
264. User-defined commands |user-commands|
27
28==============================================================================
291. Key mapping *key-mapping* *mapping* *macro*
30
31Key mapping is used to change the meaning of typed keys. The most common use
32is to define a sequence commands for a function key. Example: >
33
34 :map <F2> a<C-R>=strftime("%c")<CR><Esc>
35
Bram Moolenaar402d2fe2005-04-15 21:00:38 +000036This appends the current date and time after the cursor (in <> notation |<>|).
Bram Moolenaar071d4272004-06-13 20:20:40 +000037
Bram Moolenaar5b962cf2005-12-12 21:58:40 +000038
391.1 MAP COMMANDS *:map-commands*
40
Bram Moolenaar071d4272004-06-13 20:20:40 +000041There are commands to enter new mappings, remove mappings and list mappings.
42See |map-overview| for the various forms of "map" and their relationships with
43modes.
44
45{lhs} means left-hand-side *{lhs}*
46{rhs} means right-hand-side *{rhs}*
47
Bram Moolenaar06b5db92006-02-10 23:11:56 +000048:map {lhs} {rhs} |mapmode-nvo| *:map*
49:nm[ap] {lhs} {rhs} |mapmode-n| *:nm* *:nmap*
50:vm[ap] {lhs} {rhs} |mapmode-v| *:vm* *:vmap*
Bram Moolenaar371d5402006-03-20 21:47:49 +000051:xm[ap] {lhs} {rhs} |mapmode-x| *:xm* *:xmap*
52:smap {lhs} {rhs} |mapmode-s| *:smap*
Bram Moolenaar06b5db92006-02-10 23:11:56 +000053:om[ap] {lhs} {rhs} |mapmode-o| *:om* *:omap*
54:map! {lhs} {rhs} |mapmode-ic| *:map!*
55:im[ap] {lhs} {rhs} |mapmode-i| *:im* *:imap*
56:lm[ap] {lhs} {rhs} |mapmode-l| *:lm* *:lmap*
57:cm[ap] {lhs} {rhs} |mapmode-c| *:cm* *:cmap*
Bram Moolenaar071d4272004-06-13 20:20:40 +000058 Map the key sequence {lhs} to {rhs} for the modes
59 where the map command applies. The result, including
60 {rhs}, is then further scanned for mappings. This
61 allows for nested and recursive use of mappings.
62
63
Bram Moolenaar06b5db92006-02-10 23:11:56 +000064:no[remap] {lhs} {rhs} |mapmode-nvo| *:no* *:noremap*
65:nn[oremap] {lhs} {rhs} |mapmode-n| *:nn* *:nnoremap*
66:vn[oremap] {lhs} {rhs} |mapmode-v| *:vn* *:vnoremap*
Bram Moolenaar371d5402006-03-20 21:47:49 +000067:xn[oremap] {lhs} {rhs} |mapmode-x| *:xn* *:xnoremap*
68:snor[emap] {lhs} {rhs} |mapmode-s| *:snor* *:snoremap*
Bram Moolenaar06b5db92006-02-10 23:11:56 +000069:ono[remap] {lhs} {rhs} |mapmode-o| *:ono* *:onoremap*
70:no[remap]! {lhs} {rhs} |mapmode-ic| *:no!* *:noremap!*
71:ino[remap] {lhs} {rhs} |mapmode-i| *:ino* *:inoremap*
72:ln[oremap] {lhs} {rhs} |mapmode-l| *:ln* *:lnoremap*
73:cno[remap] {lhs} {rhs} |mapmode-c| *:cno* *:cnoremap*
Bram Moolenaar071d4272004-06-13 20:20:40 +000074 Map the key sequence {lhs} to {rhs} for the modes
75 where the map command applies. Disallow mapping of
76 {rhs}, to avoid nested and recursive mappings. Often
77 used to redefine a command. {not in Vi}
78
79
Bram Moolenaar06b5db92006-02-10 23:11:56 +000080:unm[ap] {lhs} |mapmode-nvo| *:unm* *:unmap*
81:nun[map] {lhs} |mapmode-n| *:nun* *:nunmap*
82:vu[nmap] {lhs} |mapmode-v| *:vu* *:vunmap*
Bram Moolenaar371d5402006-03-20 21:47:49 +000083:xu[nmap] {lhs} |mapmode-x| *:xu* *:xunmap*
84:sunm[ap] {lhs} |mapmode-s| *:sunm* *:sunmap*
Bram Moolenaar06b5db92006-02-10 23:11:56 +000085:ou[nmap] {lhs} |mapmode-o| *:ou* *:ounmap*
86:unm[ap]! {lhs} |mapmode-ic| *:unm!* *:unmap!*
87:iu[nmap] {lhs} |mapmode-i| *:iu* *:iunmap*
88:lu[nmap] {lhs} |mapmode-l| *:lu* *:lunmap*
89:cu[nmap] {lhs} |mapmode-c| *:cu* *:cunmap*
Bram Moolenaar071d4272004-06-13 20:20:40 +000090 Remove the mapping of {lhs} for the modes where the
91 map command applies. The mapping may remain defined
92 for other modes where it applies.
93 Note: Trailing spaces are included in the {lhs}. This
94 unmap does NOT work: >
95 :map @@ foo
96 :unmap @@ | print
97
Bram Moolenaar06b5db92006-02-10 23:11:56 +000098:mapc[lear] |mapmode-nvo| *:mapc* *:mapclear*
99:nmapc[lear] |mapmode-n| *:nmapc* *:nmapclear*
100:vmapc[lear] |mapmode-v| *:vmapc* *:vmapclear*
Bram Moolenaar371d5402006-03-20 21:47:49 +0000101:xmapc[lear] |mapmode-x| *:xmapc* *:xmapclear*
102:smapc[lear] |mapmode-s| *:smapc* *:smapclear*
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000103:omapc[lear] |mapmode-o| *:omapc* *:omapclear*
104:mapc[lear]! |mapmode-ic| *:mapc!* *:mapclear!*
105:imapc[lear] |mapmode-i| *:imapc* *:imapclear*
106:lmapc[lear] |mapmode-l| *:lmapc* *:lmapclear*
107:cmapc[lear] |mapmode-c| *:cmapc* *:cmapclear*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000108 Remove ALL mappings for the modes where the map
109 command applies. {not in Vi}
110 Warning: This also removes the default mappings.
111
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000112:map |mapmode-nvo|
113:nm[ap] |mapmode-n|
114:vm[ap] |mapmode-v|
Bram Moolenaar371d5402006-03-20 21:47:49 +0000115:xm[ap] |mapmode-x|
116:sm[ap] |mapmode-s|
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000117:om[ap] |mapmode-o|
118:map! |mapmode-ic|
119:im[ap] |mapmode-i|
120:lm[ap] |mapmode-l|
121:cm[ap] |mapmode-c|
Bram Moolenaar071d4272004-06-13 20:20:40 +0000122 List all key mappings for the modes where the map
123 command applies. Note that ":map" and ":map!" are
124 used most often, because they include the other modes.
125
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000126:map {lhs} |mapmode-nvo| *:map_l*
127:nm[ap] {lhs} |mapmode-n| *:nmap_l*
128:vm[ap] {lhs} |mapmode-v| *:vmap_l*
Bram Moolenaar371d5402006-03-20 21:47:49 +0000129:xm[ap] {lhs} |mapmode-x| *:xmap_l*
130:sm[ap] {lhs} |mapmode-s| *:smap_l*
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000131:om[ap] {lhs} |mapmode-o| *:omap_l*
132:map! {lhs} |mapmode-ic| *:map_l!*
133:im[ap] {lhs} |mapmode-i| *:imap_l*
134:lm[ap] {lhs} |mapmode-l| *:lmap_l*
135:cm[ap] {lhs} |mapmode-c| *:cmap_l*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000136 List the key mappings for the key sequences starting
137 with {lhs} in the modes where the map command applies.
138 {not in Vi}
139
140These commands are used to map a key or key sequence to a string of
141characters. You can use this to put command sequences under function keys,
142translate one key into another, etc. See |:mkexrc| for how to save and
143restore the current mappings.
144
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000145 *map-ambiguous*
146When two mappings start with the same sequence of characters, they are
147ambiguous. Example: >
148 :imap aa foo
149 :imap aaa bar
150When Vim has read "aa", it will need to get another character to be able to
151decide if "aa" or "aaa" should be mapped. This means that after typing "aa"
152that mapping won't get expanded yet, Vim is waiting for another character.
153If you type a space, then "foo" will get inserted, plus the space. If you
154type "a", then "bar" will get inserted.
155{Vi does not allow ambiguous mappings}
156
157
1581.2 SPECIAL ARGUMENTS *:map-arguments*
159
Bram Moolenaar4e427192006-03-10 21:34:27 +0000160"<buffer>", "<silent>", "<script>", "<expr>" and "<unique>" can be used in any
161order. They must appear right after the command, before any other arguments.
162
Bram Moolenaar071d4272004-06-13 20:20:40 +0000163 *:map-local* *:map-<buffer>* *E224* *E225*
164If the first argument to one of these commands is "<buffer>" it will apply to
165mappings locally to the current buffer only. Example: >
166 :map <buffer> ,w /[.,;]<CR>
167Then you can map ",w" to something else in another buffer: >
168 :map <buffer> ,w /[#&!]<CR>
169The local buffer mappings are used before the global ones.
170The "<buffer>" argument can also be used to clear mappings: >
171 :unmap <buffer> ,w
172 :mapclear <buffer>
173Local mappings are also cleared when a buffer is deleted, but not when it is
174unloaded. Just like local option values.
175
176 *:map-<silent>* *:map-silent*
177To define a mapping which will not be echoed on the command line, add
178"<silent>" as the first argument. Example: >
179 :map <silent> ,h /Header<CR>
180The search string will not be echoed when using this mapping. Messages from
181the executed command are still given though. To shut them up too, add a
182":silent" in the executed command: >
183 :map <silent> ,h :exe ":silent normal /Header\r"<CR>
184Prompts will still be given, e.g., for inputdialog().
185Using "<silent>" for an abbreviation is possible, but will cause redrawing of
186the command line to fail.
187
188 *:map-<script>* *:map-script*
189If the first argument to one of these commands is "<script>" and it is used to
190define a new mapping or abbreviation, the mapping will only remap characters
191in the {rhs} using mappings that were defined local to a script, starting with
192"<SID>". This can be used to avoid that mappings from outside a script
193interfere (e.g., when CTRL-V is remapped in mswin.vim), but do use other
194mappings defined in the script.
195Note: ":map <script>" and ":noremap <script>" do the same thing. The
196"<script>" overrules the command name. Using ":noremap <script>" is
197preferred, because it's clearer that remapping is (mostly) disabled.
198
199 *:map-<unique>* *E226* *E227*
200If the first argument to one of these commands is "<unique>" and it is used to
201define a new mapping or abbreviation, the command will fail if the mapping or
202abbreviation already exists. Example: >
203 :map <unique> ,w /[#&!]<CR>
204When defining a local mapping, there will also be a check if a global map
205already exists which is equal.
206Example of what will fail: >
207 :map ,w /[#&!]<CR>
208 :map <buffer> <unique> ,w /[.,;]<CR>
Bram Moolenaara40ceaf2006-01-13 22:35:40 +0000209If you want to map a key and then have it do what it was originally mapped to,
210have a look at |maparg()|.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000211
Bram Moolenaar4e427192006-03-10 21:34:27 +0000212 *:map-<expr>* *:map-expression*
213If the first argument to one of these commands is "<expr>" and it is used to
214define a new mapping or abbreviation, the argument is an expression. The
215expression is evaluated to obtain the {rhs} that is used. Example: >
216 :inoremap <expr> . InsertDot()
217The result of the InsertDot() function will be inserted. It could check the
218text before the cursor and start omni completion when some condition is met.
219
220Be very careful about side effects! The expression is evaluated while
221obtaining characters, if you change buffer text, move the cursor, edit another
222file, etc. you may very well make command disfunctional.
223
224Here is an example that inserts a list number that increases: >
225 let counter = 0
226 inoremap <expr> <C-L> ListItem()
227 inoremap <expr> <C-R> ListReset()
228
229 func ListItem()
230 let g:counter += 1
231 return g:counter . '. '
232 endfunc
233
234 func ListReset()
235 let g:counter = 0
236 return ''
237 endfunc
238
Bram Moolenaard9967712006-03-11 21:18:15 +0000239CTRL-L inserts the next number, CTRL-R resets the count. CTRL-R returns an
Bram Moolenaar4e427192006-03-10 21:34:27 +0000240empty string, so that nothing is inserted.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000241
Bram Moolenaar8424a622006-04-19 21:23:36 +0000242Note that there are some tricks to make special keys work and escape CSI bytes
243in the text. The |:map| command also does this, thus you must avoid that it
244is done twice. This does not work: >
245 :imap <expr> <F3> "<Char-0x611B>"
246Because the <Char- sequence is escaped for being a |:imap| argument and then
247again for using <expr>. This does work: >
248 :imap <expr> <F3> "\u611B"
249Using 0x80 as a single byte before other text does not work, it will be seen
250as a special key.
251
Bram Moolenaar071d4272004-06-13 20:20:40 +0000252
Bram Moolenaar5b962cf2005-12-12 21:58:40 +00002531.3 MAPPING AND MODES *:map-modes*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000254
255There are five sets of mappings
256- For Normal mode: When typing commands.
257- For Visual mode: When typing commands while the Visual area is highlighted.
258- For Operator-pending mode: When an operator is pending (after "d", "y", "c",
259 etc.). Example: ":omap { w" makes "y{" work like "yw" and "d{" like "dw".
Bram Moolenaar402d2fe2005-04-15 21:00:38 +0000260- For Insert mode. These are also used in Replace mode.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000261- For Command-line mode: When entering a ":" or "/" command.
262
Bram Moolenaar071d4272004-06-13 20:20:40 +0000263Special case: While typing a count for a command in Normal mode, mapping zero
264is disabled. This makes it possible to map zero without making it impossible
265to type a count with a zero.
266
267 *map-overview* *map-modes*
268Overview of which map command works in which mode:
269
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000270 *mapmode-nvo* *mapmode-n* *mapmode-v* *mapmode-o*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000271 commands: modes: ~
Bram Moolenaar371d5402006-03-20 21:47:49 +0000272 Normal Visual+Select Operator-pending ~
273:map :noremap :unmap :mapclear yes yes yes
274:nmap :nnoremap :nunmap :nmapclear yes - -
275:vmap :vnoremap :vunmap :vmapclear - yes -
276:omap :onoremap :ounmap :omapclear - - yes
277
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000278:nunmap can also be used outside of a monastery.
Bram Moolenaar371d5402006-03-20 21:47:49 +0000279 *mapmode-x* *mapmode-s*
280Some commands work both in Visual and Select mode, some in only one. Note
281that quite often "Visual" is mentioned where both Visual and Select mode
282apply. |Select-mode-mapping|
283
284 commands: modes: ~
285 Visual Select ~
286:vmap :vnoremap :vunmap :vmapclear yes yes
287:xmap :xnoremap :xunmap :xmapclear yes -
288:smap :snoremap :sunmap :smapclear - yes
Bram Moolenaar071d4272004-06-13 20:20:40 +0000289
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000290 *mapmode-ic* *mapmode-i* *mapmode-c* *mapmode-l*
Bram Moolenaar371d5402006-03-20 21:47:49 +0000291Some commands work both in Insert mode and Command-line mode, some not:
292
293 commands: modes: ~
Bram Moolenaar071d4272004-06-13 20:20:40 +0000294 Insert Command-line Lang-Arg ~
295:map! :noremap! :unmap! :mapclear! yes yes -
296:imap :inoremap :iunmap :imapclear yes - -
297:cmap :cnoremap :cunmap :cmapclear - yes -
298:lmap :lnoremap :lunmap :lmapclear yes* yes* yes*
299
300The original Vi did not have separate mappings for
301Normal/Visual/Operator-pending mode and for Insert/Command-line mode.
302Therefore the ":map" and ":map!" commands enter and display mappings for
303several modes. In Vim you can use the ":nmap", ":vmap", ":omap", ":cmap" and
304":imap" commands to enter mappings for each mode separately.
305
306To enter a mapping for Normal and Visual mode, but not Operator-pending mode,
307first define it for all three modes, then unmap it for Operator-pending mode:
308 :map xx something-difficult
309 :ounmap xx
310Likewise for a mapping for Visual and Operator-pending mode or Normal and
311Operator-pending mode.
312
313 *language-mapping*
314":lmap" defines a mapping that applies to:
315- Insert mode
316- Command-line mode
317- when entering a search pattern
318- the argument of the commands that accept a text character, such as "r" and
319 "f"
320- for the input() line
321Generally: Whenever a character is to be typed that is part of the text in the
322buffer, not a Vim command character. "Lang-Arg" isn't really another mode,
323it's just used here for this situation.
324 The simplest way to load a set of related language mappings is by using the
325'keymap' option. See |45.5|.
326 In Insert mode and in Command-line mode the mappings can be disabled with
327the CTRL-^ command |i_CTRL-^| |c_CTRL-^|. When starting to enter a normal
328command line (not a search pattern) the mappings are disabled until a CTRL-^
329is typed. The state last used is remembered for Insert mode and Search
330patterns separately. The state for Insert mode is also used when typing a
331character as an argument to command like "f" or "t".
Bram Moolenaar071d4272004-06-13 20:20:40 +0000332 Language mappings will never be applied to already mapped characters. They
333are only used for typed characters. This assumes that the language mapping
334was already done when typing the mapping.
335
Bram Moolenaar071d4272004-06-13 20:20:40 +0000336
Bram Moolenaar5b962cf2005-12-12 21:58:40 +00003371.4 LISTING MAPPINGS *map-listing*
338
Bram Moolenaar071d4272004-06-13 20:20:40 +0000339When listing mappings the characters in the first two columns are:
340
341 CHAR MODE ~
342 <Space> Normal, Visual and Operator-pending
343 n Normal
344 v Visual
345 o Operator-pending
346 ! Insert and Command-line
347 i Insert
348 l ":lmap" mappings for Insert, Command-line and Lang-Arg
349 c Command-line
350
351Just before the {rhs} a special character can appear:
352 * indicates that it is not remappable
353 & indicates that only script-local mappings are remappable
354 @ indicates a buffer-local mapping
355
356Everything from the first non-blank after {lhs} up to the end of the line
357(or '|') is considered to be part of {rhs}. This allows the {rhs} to end
358with a space.
359
360Note: When using mappings for Visual mode, you can use the "'<" mark, which
361is the start of the last selected Visual area in the current buffer |'<|.
362
Bram Moolenaarae5bce12005-08-15 21:41:48 +0000363 *:map-verbose*
364When 'verbose' is non-zero, listing a key map will also display where it was
365last defined. Example: >
366
367 :verbose map <C-W>*
368 n <C-W>* * <C-W><C-S>*
369 Last set from /home/abcd/.vimrc
370
Bram Moolenaar5195e452005-08-19 20:32:47 +0000371See |:verbose-cmd| for more information.
Bram Moolenaarae5bce12005-08-15 21:41:48 +0000372
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000373
3741.5 MAPPING SPECIAL KEYS *:map-special-keys*
375
376There are three ways to map a special key:
3771. The Vi-compatible method: Map the key code. Often this is a sequence that
378 starts with <Esc>. To enter a mapping like this you type ":map " and then
379 you have to type CTRL-V before hitting the function key. Note that when
380 the key code for the key is in the termcap (the t_ options), it will
381 automatically be translated into the internal code and become the second
382 way of mapping (unless the 'k' flag is included in 'cpoptions').
3832. The second method is to use the internal code for the function key. To
384 enter such a mapping type CTRL-K and then hit the function key, or use
385 the form "#1", "#2", .. "#9", "#0", "<Up>", "<S-Down>", "<S-F7>", etc.
386 (see table of keys |key-notation|, all keys from <Up> can be used). The
387 first ten function keys can be defined in two ways: Just the number, like
388 "#2", and with "<F>", like "<F2>". Both stand for function key 2. "#0"
389 refers to function key 10, defined with option 't_f10', which may be
390 function key zero on some keyboards. The <> form cannot be used when
391 'cpoptions' includes the '<' flag.
3923. Use the termcap entry, with the form <t_xx>, where "xx" is the name of the
393 termcap entry. Any string entry can be used. For example: >
394 :map <t_F3> G
395< Maps function key 13 to "G". This does not work if 'cpoptions' includes
396 the '<' flag.
397
398The advantage of the second and third method is that the mapping will work on
399different terminals without modification (the function key will be
400translated into the same internal code or the actual key code, no matter what
401terminal you are using. The termcap must be correct for this to work, and you
402must use the same mappings).
403
404DETAIL: Vim first checks if a sequence from the keyboard is mapped. If it
405isn't the terminal key codes are tried (see |terminal-options|). If a
406terminal code is found it is replaced with the internal code. Then the check
407for a mapping is done again (so you can map an internal code to something
408else). What is written into the script file depends on what is recognized.
409If the terminal key code was recognized as a mapping the key code itself is
410written to the script file. If it was recognized as a terminal code the
411internal code is written to the script file.
412
413
4141.6 SPECIAL CHARACTERS *:map-special-chars*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000415 *map_backslash*
416Note that only CTRL-V is mentioned here as a special character for mappings
417and abbreviations. When 'cpoptions' does not contain 'B', a backslash can
418also be used like CTRL-V. The <> notation can be fully used then |<>|. But
419you cannot use "<C-V>" like CTRL-V to escape the special meaning of what
420follows.
421
422To map a backslash, or use a backslash literally in the {rhs}, the special
423sequence "<Bslash>" can be used. This avoids the need to double backslashes
424when using nested mappings.
425
Bram Moolenaar1e015462005-09-25 22:16:38 +0000426 *map_CTRL-C*
427Using CTRL-C in the {lhs} is possible, but it will only work when Vim is
428waiting for a key, not when Vim is busy with something. When Vim is busy
429CTRL-C interrupts/breaks the command.
430When using the GUI version on MS-Windows CTRL-C can be mapped to allow a Copy
431command to the clipboard. Use CTRL-Break to interrupt Vim.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000432
433 *map_space_in_lhs*
434To include a space in {lhs} precede it with a CTRL-V (type two CTRL-Vs for
435each space).
436 *map_space_in_rhs*
437If you want a {rhs} that starts with a space, use "<Space>". To be fully Vi
438compatible (but unreadable) don't use the |<>| notation, precede {rhs} with a
439single CTRL-V (you have to type CTRL-V two times).
440 *map_empty_rhs*
441You can create an empty {rhs} by typing nothing after a single CTRL-V (you
442have to type CTRL-V two times). Unfortunately, you cannot do this in a vimrc
443file.
444 *<Nop>*
445A easier way to get a mapping that doesn't produce anything, is to use "<Nop>"
446for the {rhs}. This only works when the |<>| notation is enabled. For
447example, to make sure that function key 8 does nothing at all: >
448 :map <F8> <Nop>
449 :map! <F8> <Nop>
450<
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000451 *map-multibyte*
452It is possible to map multibyte characters, but only the whole character. You
453cannot map the first byte only. This was done to prevent problems in this
454scenario: >
455 :set encoding=latin1
456 :imap <M-C> foo
457 :set encoding=utf-8
458The mapping for <M-C> is defined with the latin1 encoding, resulting in a 0xc3
459byte. If you type the character á (0xea <M-a>) in UTF-8 encoding this is the
460two bytes 0xc3 0xa1. You don't want the 0xc3 byte to be mapped then,
461otherwise it would be impossible to type the á character.
462
Bram Moolenaar071d4272004-06-13 20:20:40 +0000463 *<Leader>* *mapleader*
464To define a mapping which uses the "mapleader" variable, the special string
465"<Leader>" can be used. It is replaced with the string value of "mapleader".
466If "mapleader" is not set or empty, a backslash is used instead. Example: >
467 :map <Leader>A oanother line<Esc>
468Works like: >
469 :map \A oanother line<Esc>
470But after: >
471 :let mapleader = ","
472It works like: >
473 :map ,A oanother line<Esc>
474
475Note that the value of "mapleader" is used at the moment the mapping is
476defined. Changing "mapleader" after that has no effect for already defined
477mappings.
478
479 *<LocalLeader>* *maplocalleader*
480Just like <Leader>, except that it uses "maplocalleader" instead of
481"mapleader". <LocalLeader> is to be used for mappings which are local to a
482buffer. Example: >
483 :map <LocalLeader>q \DoItNow
484<
485In a global plugin <Leader> should be used and in a filetype plugin
486<LocalLeader>. "mapleader" and "maplocalleader" can be equal. Although, if
487you make them different, there is a smaller chance of mappings from global
488plugins to clash with mappings for filetype plugins. For example, you could
489keep "mapleader" at the default backslash, and set "maplocalleader" to an
490underscore.
491
492 *map-<SID>*
493In a script the special key name "<SID>" can be used to define a mapping
494that's local to the script. See |<SID>| for details.
495
496 *<Plug>*
497The special key name "<Plug>" can be used for an internal mapping, which is
498not to be matched with any key sequence. This is useful in plugins
499|using-<Plug>|.
500
501 *<Char>* *<Char->*
502To map a character by its decimal, octal or hexadecimal number the <Char>
503construct can be used:
504 <Char-123> character 123
505 <Char-033> character 27
506 <Char-0x7f> character 127
507This is useful to specify a (multi-byte) character in a 'keymap' file.
508Upper and lowercase differences are ignored.
509
510 *map-comments*
511It is not possible to put a comment after these commands, because the '"'
512character is considered to be part of the {lhs} or {rhs}.
513
514 *map_bar*
515Since the '|' character is used to separate a map command from the next
516command, you will have to do something special to include a '|' in {rhs}.
517There are three methods:
518 use works when example ~
519 <Bar> '<' is not in 'cpoptions' :map _l :!ls <Bar> more^M
520 \| 'b' is not in 'cpoptions' :map _l :!ls \| more^M
521 ^V| always, in Vim and Vi :map _l :!ls ^V| more^M
522
523(here ^V stands for CTRL-V; to get one CTRL-V you have to type it twice; you
524cannot use the <> notation "<C-V>" here).
525
526All three work when you use the default setting for 'cpoptions'.
527
528When 'b' is present in 'cpoptions', "\|" will be recognized as a mapping
529ending in a '\' and then another command. This is Vi compatible, but
530illogical when compared to other commands.
531
532 *map_return*
533When you have a mapping that contains an Ex command, you need to put a line
534terminator after it to have it executed. The use of <CR> is recommended for
535this (see |<>|). Example: >
536 :map _ls :!ls -l %<CR>:echo "the end"<CR>
537
538To avoid mapping of the characters you type in insert or Command-line mode,
539type a CTRL-V first. The mapping in Insert mode is disabled if the 'paste'
540option is on.
541
542Note that when an error is encountered (that causes an error message or beep)
543the rest of the mapping is not executed. This is Vi-compatible.
544
545Note that the second character (argument) of the commands @zZtTfF[]rm'`"v
546and CTRL-X is not mapped. This was done to be able to use all the named
547registers and marks, even when the command with the same name has been
548mapped.
549
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000550
5511.7 WHAT KEYS TO MAP *map-which-keys*
552
Bram Moolenaar071d4272004-06-13 20:20:40 +0000553If you are going to map something, you will need to choose which key(s) to use
554for the {lhs}. You will have to avoid keys that are used for Vim commands,
555otherwise you would not be able to use those commands anymore. Here are a few
556suggestions:
557- Function keys <F2>, <F3>, etc.. Also the shifted function keys <S-F1>,
558 <S-F2>, etc. Note that <F1> is already used for the help command.
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000559- Meta-keys (with the ALT key pressed). |:map-alt-keys|
Bram Moolenaar071d4272004-06-13 20:20:40 +0000560- Use the '_' or ',' character and then any other character. The "_" and ","
561 commands do exist in Vim (see |_| and |,|), but you probably never use them.
562- Use a key that is a synonym for another command. For example: CTRL-P and
563 CTRL-N. Use an extra character to allow more mappings.
564
565See the file "index" for keys that are not used and thus can be mapped without
566losing any builtin function. You can also use ":help {key}^D" to find out if
567a key is used for some command. ({key} is the specific key you want to find
568out about, ^D is CTRL-D).
569
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000570
5711.8 EXAMPLES *map-examples*
572
Bram Moolenaar071d4272004-06-13 20:20:40 +0000573A few examples (given as you type them, for "<CR>" you type four characters;
574the '<' flag must not be present in 'cpoptions' for this to work). >
575
576 :map <F3> o#include
577 :map <M-g> /foo<CR>cwbar<Esc>
578 :map _x d/END/e<CR>
579 :map! qq quadrillion questions
580<
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000581
5821.9 USING MAPPINGS *map-typing*
583
Bram Moolenaar071d4272004-06-13 20:20:40 +0000584Vim will compare what you type with the start of a mapped sequence. If there
585is an incomplete match, it will get more characters until there either is a
586complete match or until there is no match at all. Example: If you map! "qq",
587the first 'q' will not appear on the screen until you type another
588character. This is because Vim cannot know if the next character will be a
589'q' or not. If the 'timeout' option is on (which is the default) Vim will
590only wait for one second (or as long as specified with the 'timeoutlen'
591option). After that it assumes that the 'q' is to be interpreted as such. If
592you type slowly, or your system is slow, reset the 'timeout' option. Then you
593might want to set the 'ttimeout' option.
594
595 *map-keys-fails*
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000596There are situations where key codes might not be recognized:
Bram Moolenaar071d4272004-06-13 20:20:40 +0000597- Vim can only read part of the key code. Mostly this is only the first
598 character. This happens on some Unix versions in an xterm.
599- The key code is after character(s) that are mapped. E.g., "<F1><F1>" or
600 "g<F1>".
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000601
Bram Moolenaar071d4272004-06-13 20:20:40 +0000602The result is that the key code is not recognized in this situation, and the
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000603mapping fails. There are two actions needed to avoid this problem:
604
Bram Moolenaar071d4272004-06-13 20:20:40 +0000605- Remove the 'K' flag from 'cpoptions'. This will make Vim wait for the rest
606 of the characters of the function key.
607- When using <F1> to <F4> the actual key code generated may correspond to
608 <xF1> to <xF4>. There are mappings from <xF1> to <F1>, <xF2> to <F2>, etc.,
609 but these are not recognized after another half a mapping. Make sure the
610 key codes for <F1> to <F4> are correct: >
611 :set <F1>=<type CTRL-V><type F1>
612< Type the <F1> as four characters. The part after the "=" must be done with
613 the actual keys, not the literal text.
614Another solution is to use the actual key code in the mapping for the second
615special key: >
616 :map <F1><Esc>OP :echo "yes"<CR>
617Don't type a real <Esc>, Vim will recognize the key code and replace it with
618<F1> anyway.
619
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000620Another problem may be that when keeping ALT or Meta pressed the terminal
621prepends ESC instead of setting the 8th bit. See |:map-alt-keys|.
622
Bram Moolenaar071d4272004-06-13 20:20:40 +0000623 *recursive_mapping*
624If you include the {lhs} in the {rhs} you have a recursive mapping. When
625{lhs} is typed, it will be replaced with {rhs}. When the {lhs} which is
626included in {rhs} is encountered it will be replaced with {rhs}, and so on.
627This makes it possible to repeat a command an infinite number of times. The
628only problem is that the only way to stop this is by causing an error. The
629macros to solve a maze uses this, look there for an example. There is one
630exception: If the {rhs} starts with {lhs}, the first character is not mapped
631again (this is Vi compatible).
632For example: >
633 :map ab abcd
634will execute the "a" command and insert "bcd" in the text. The "ab" in the
635{rhs} will not be mapped again.
636
637If you want to exchange the meaning of two keys you should use the :noremap
638command. For example: >
639 :noremap k j
640 :noremap j k
641This will exchange the cursor up and down commands.
642
643With the normal :map command, when the 'remap' option is on, mapping takes
644place until the text is found not to be a part of a {lhs}. For example, if
645you use: >
646 :map x y
647 :map y x
648Vim will replace x with y, and then y with x, etc. When this has happened
649'maxmapdepth' times (default 1000), Vim will give the error message
650"recursive mapping".
651
652 *:map-undo*
653If you include an undo command inside a mapped sequence, this will bring the
654text back in the state before executing the macro. This is compatible with
655the original Vi, as long as there is only one undo command in the mapped
656sequence (having two undo commands in a mapped sequence did not make sense
657in the original Vi, you would get back the text before the first undo).
658
Bram Moolenaar071d4272004-06-13 20:20:40 +0000659
Bram Moolenaar5b962cf2005-12-12 21:58:40 +00006601.10 MAPPING ALT-KEYS *:map-alt-keys*
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000661
662In the GUI Vim handles the Alt key itself, thus mapping keys with ALT should
663always work. But in a terminal Vim gets a sequence of bytes and has to figure
664out whether ALT was pressed or not.
665
666By default Vim assumes that pressing the ALT key sets the 8th bit of a typed
Bram Moolenaar97d29a12005-12-17 22:02:57 +0000667character. Most decent terminals can work that way, such as xterm, aterm and
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000668rxvt. If your <A-k> mappings don't work it might be that the terminal is
669prefixing the character with an ESC character. But you can just as well type
670ESC before a character, thus Vim doesn't know what happened (except for
671checking the delay between characters, which is not reliable).
672
673As of this writing, some mainstream terminals like gnome-terminal and konsole
674use the ESC prefix. There doesn't appear a way to have them use the 8th bit
Bram Moolenaar97d29a12005-12-17 22:02:57 +0000675instead. Xterm should work well by default. Aterm and rxvt should work well
676when started with the "--meta8" argument. You can also tweak resources like
677"metaSendsEscape", "eightBitInput" and "eightBitOutput".
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000678
679On the Linux console, this behavior can be toggled with the "setmetamode"
680command. Bear in mind that not using an ESC prefix could get you in trouble
681with other programs. You should make sure that bash has the "convert-meta"
682option set to "on" in order for your Meta keybindings to still work on it
683(it's the default readline behavior, unless changed by specific system
684configuration). For that, you can add the line: >
685
686 set convert-meta on
687
688to your ~/.inputrc file. If you're creating the file, you might want to use: >
689
690 $include /etc/inputrc
691
692as the first line, if that file exists on your system, to keep global options.
693This may cause a problem for entering special characters, such as the umlaut.
694Then you should use CTRL-V before that character.
695
696Bear in mind that convert-meta has been reported to have troubles when used in
697UTF-8 locales. On terminals like xterm, the "metaSendsEscape" resource can be
698toggled on the fly through the "Main Options" menu, by pressing Ctrl-LeftClick
699on the terminal; that's a good last resource in case you want to send ESC when
700using other applications but not when inside VIM.
701
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000702
7031.11 MAPPING AN OPERATOR *:map-operator*
704
705An operator is used before a {motion} command. To define your own operator
706you must create mapping that first sets the 'operatorfunc' option and then
707invoke the |g@| operator. After the user types the {motion} command the
708specified function will be called.
709
Bram Moolenaara40ceaf2006-01-13 22:35:40 +0000710 *g@* *E774* *E775*
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000711g@{motion} Call the function set by the 'operatorfunc' option.
712 The '[ mark is positioned at the start of the text
713 moved over by {motion}, the '] mark on the last
714 character of the text.
715 The function is called with one String argument:
716 "line" {motion} was |linewise|
717 "char" {motion} was |characterwise|
718 "block" {motion} was |blockwise-visual||
719 Although "block" would rarely appear, since it can
720 only result from Visual mode where "g@" is not useful.
721 {not available when compiled without the +eval
722 feature}
723
724Here is an example that counts the number of spaces with <F4>: >
725
726 nmap <silent> <F4> :set opfunc=CountSpaces<CR>g@
727 vmap <silent> <F4> :<C-U>call CountSpaces(visualmode(), 1)<CR>
728
729 function! CountSpaces(type, ...)
730 let sel_save = &selection
731 let &selection = "inclusive"
732 let reg_save = @@
733
734 if a:0 " Invoked from Visual mode, use '< and '> marks.
735 silent exe "normal! `<" . a:type . "`>y"
736 elseif a:type == 'line'
737 silent exe "normal! '[V']y"
738 elseif a:type == 'block'
739 silent exe "normal! `[\<C-V>`]y"
740 else
741 silent exe "normal! `[v`]y"
742 endif
743
744 echomsg strlen(substitute(@@, '[^ ]', '', 'g'))
745
746 let &selection = sel_save
747 let @@ = reg_save
748 endfunction
749
750Note that the 'selection' option is temporarily set to "inclusive" to be able
751to yank exactly the right text by using Visual mode from the '[ to the ']
752mark.
753
754Also note that there is a separate mapping for Visual mode. It removes the
755"'<,'>" range that ":" inserts in Visual mode and invokes the function with
756visualmode() and an extra argument.
757
Bram Moolenaar071d4272004-06-13 20:20:40 +0000758==============================================================================
7592. Abbreviations *abbreviations* *Abbreviations*
760
761Abbreviations are used in Insert mode, Replace mode and Command-line mode.
762If you enter a word that is an abbreviation, it is replaced with the word it
763stands for. This can be used to save typing for often used long words. And
764you can use it to automatically correct obvious spelling errors.
765Examples:
766
767 :iab ms MicroSoft
768 :iab tihs this
769
770There are three types of abbreviations:
771
772full-id The "full-id" type consists entirely of keyword characters (letters
773 and characters from 'iskeyword' option). This is the most common
774 abbreviation.
775
776 Examples: "foo", "g3", "-1"
777
778end-id The "end-id" type ends in a keyword character, but all the other
779 characters are not keyword characters.
780
781 Examples: "#i", "..f", "$/7"
782
783non-id The "non-id" type ends in a non-keyword character, the other
784 characters may be of any type, excluding space and Tab. {this type
785 is not supported by Vi}
786
787 Examples: "def#", "4/7$"
788
789Examples of strings that cannot be abbreviations: "a.b", "#def", "a b", "_$r"
790
791An abbreviation is only recognized when you type a non-keyword character.
792This can also be the <Esc> that ends insert mode or the <CR> that ends a
793command. The non-keyword character which ends the abbreviation is inserted
794after the expanded abbreviation. An exception to this is the character <C-]>,
795which is used to expand an abbreviation without inserting any extra
796characters.
797
798Example: >
799 :ab hh hello
800< "hh<Space>" is expanded to "hello<Space>"
801 "hh<C-]>" is expanded to "hello"
802
803The characters before the cursor must match the abbreviation. Each type has
804an additional rule:
805
806full-id In front of the match is a non-keyword character, or this is where
807 the line or insertion starts. Exception: When the abbreviation is
808 only one character, it is not recognized if there is a non-keyword
809 character in front of it, other than a space or a <Tab>.
810
811end-id In front of the match is a keyword character, or a space or a <Tab>,
812 or this is where the line or insertion starts.
813
814non-id In front of the match is a space, <Tab> or the start of the line or
815 the insertion.
816
817Examples: ({CURSOR} is where you type a non-keyword character) >
818 :ab foo four old otters
819< " foo{CURSOR}" is expanded to " four old otters"
820 " foobar{CURSOR}" is not expanded
821 "barfoo{CURSOR}" is not expanded
822>
823 :ab #i #include
824< "#i{CURSOR}" is expanded to "#include"
825 ">#i{CURSOR}" is not expanded
826>
Bram Moolenaar81695252004-12-29 20:58:21 +0000827 :ab ;; <endofline>
Bram Moolenaar071d4272004-06-13 20:20:40 +0000828< "test;;" is not expanded
829 "test ;;" is expanded to "test <endofline>"
830
831To avoid the abbreviation in insert mode: Type part of the abbreviation, exit
832insert mode with <Esc>, re-enter insert mode with "a" and type the rest. Or
833type CTRL-V before the character after the abbreviation.
834To avoid the abbreviation in Command-line mode: Type CTRL-V twice somewhere in
835the abbreviation to avoid it to be replaced. A CTRL-V in front of a normal
836character is mostly ignored otherwise.
837
838It is possible to move the cursor after an abbreviation: >
839 :iab if if ()<Left>
840This does not work if 'cpoptions' includes the '<' flag. |<>|
841
842You can even do more complicated things. For example, to consume the space
843typed after an abbreviation: >
844 func Eatchar(pat)
Bram Moolenaar32466aa2006-02-24 23:53:04 +0000845 let c = nr2char(getchar(0))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000846 return (c =~ a:pat) ? '' : c
847 endfunc
848 iabbr <silent> if if ()<Left><C-R>=Eatchar('\s')<CR>
849
850There are no default abbreviations.
851
852Abbreviations are never recursive. You can use ":ab f f-o-o" without any
853problem. But abbreviations can be mapped. {some versions of Vi support
854recursive abbreviations, for no apparent reason}
855
856Abbreviations are disabled if the 'paste' option is on.
857
858 *:abbreviate-local* *:abbreviate-<buffer>*
859Just like mappings, abbreviations can be local to a buffer. This is mostly
860used in a |filetype-plugin| file. Example for a C plugin file: >
861 :abb <buffer> FF for (i = 0; i < ; ++i)
862<
863 *:ab* *:abbreviate*
864:ab[breviate] list all abbreviations. The character in the first
865 column indicates the mode where the abbreviation is
866 used: 'i' for insert mode, 'c' for Command-line
867 mode, '!' for both. These are the same as for
868 mappings, see |map-listing|.
869
Bram Moolenaare344bea2005-09-01 20:46:49 +0000870 *:abbreviate-verbose*
871When 'verbose' is non-zero, listing an abbreviation will also display where it
872was last defined. Example: >
873
874 :verbose abbreviate
875 ! teh the
876 Last set from /home/abcd/vim/abbr.vim
877
878See |:verbose-cmd| for more information.
879
Bram Moolenaar071d4272004-06-13 20:20:40 +0000880:ab[breviate] {lhs} list the abbreviations that start with {lhs}
881 You may need to insert a CTRL-V (type it twice) to
882 avoid that a typed {lhs} is expanded, since
883 command-line abbreviations apply here.
884
885:ab[breviate] {lhs} {rhs}
886 add abbreviation for {lhs} to {rhs}. If {lhs} already
887 existed it is replaced with the new {rhs}. {rhs} may
888 contain spaces.
889
890 *:una* *:unabbreviate*
891:una[bbreviate] {lhs} Remove abbreviation for {lhs} from the list. If none
892 is found, remove abbreviations in which {lhs} matches
893 with the {rhs}. This is done so that you can even
894 remove abbreviations after expansion. To avoid
895 expansion insert a CTRL-V (type it twice).
896
897 *:norea* *:noreabbrev*
898:norea[bbrev] [lhs] [rhs]
899 same as ":ab", but no remapping for this {rhs} {not
900 in Vi}
901
902 *:ca* *:cabbrev*
903:ca[bbrev] [lhs] [rhs] same as ":ab", but for Command-line mode only. {not
904 in Vi}
905
906 *:cuna* *:cunabbrev*
907:cuna[bbrev] {lhs} same as ":una", but for Command-line mode only. {not
908 in Vi}
909
910 *:cnorea* *:cnoreabbrev*
911:cnorea[bbrev] [lhs] [rhs]
912 same as ":ab", but for Command-line mode only and no
913 remapping for this {rhs} {not in Vi}
914
915 *:ia* *:iabbrev*
916:ia[bbrev] [lhs] [rhs] same as ":ab", but for Insert mode only. {not in Vi}
917
918 *:iuna* *:iunabbrev*
919:iuna[bbrev] {lhs} same as ":una", but for insert mode only. {not in
920 Vi}
921
922 *:inorea* *:inoreabbrev*
923:inorea[bbrev] [lhs] [rhs]
924 same as ":ab", but for Insert mode only and no
925 remapping for this {rhs} {not in Vi}
926
927 *:abc* *:abclear*
928:abc[lear] Remove all abbreviations. {not in Vi}
929
930 *:iabc* *:iabclear*
931:iabc[lear] Remove all abbreviations for Insert mode. {not in Vi}
932
933 *:cabc* *:cabclear*
934:cabc[lear] Remove all abbreviations for Command-line mode. {not
935 in Vi}
936
937 *using_CTRL-V*
938It is possible to use special characters in the rhs of an abbreviation.
939CTRL-V has to be used to avoid the special meaning of most non printable
940characters. How many CTRL-Vs need to be typed depends on how you enter the
941abbreviation. This also applies to mappings. Let's use an example here.
942
943Suppose you want to abbreviate "esc" to enter an <Esc> character. When you
944type the ":ab" command in Vim, you have to enter this: (here ^V is a CTRL-V
945and ^[ is <Esc>)
946
947You type: ab esc ^V^V^V^V^V^[
948
949 All keyboard input is subjected to ^V quote interpretation, so
950 the first, third, and fifth ^V characters simply allow the second,
951 and fourth ^Vs, and the ^[, to be entered into the command-line.
952
953You see: ab esc ^V^V^[
954
955 The command-line contains two actual ^Vs before the ^[. This is
956 how it should appear in your .exrc file, if you choose to go that
957 route. The first ^V is there to quote the second ^V; the :ab
958 command uses ^V as its own quote character, so you can include quoted
Bram Moolenaar81695252004-12-29 20:58:21 +0000959 whitespace or the | character in the abbreviation. The :ab command
Bram Moolenaar071d4272004-06-13 20:20:40 +0000960 doesn't do anything special with the ^[ character, so it doesn't need
961 to be quoted. (Although quoting isn't harmful; that's why typing 7
962 [but not 8!] ^Vs works.)
963
964Stored as: esc ^V^[
965
966 After parsing, the abbreviation's short form ("esc") and long form
967 (the two characters "^V^[") are stored in the abbreviation table.
968 If you give the :ab command with no arguments, this is how the
969 abbreviation will be displayed.
970
971 Later, when the abbreviation is expanded because the user typed in
972 the word "esc", the long form is subjected to the same type of
973 ^V interpretation as keyboard input. So the ^V protects the ^[
Bram Moolenaar81695252004-12-29 20:58:21 +0000974 character from being interpreted as the "exit Insert mode" character.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000975 Instead, the ^[ is inserted into the text.
976
977Expands to: ^[
978
979[example given by Steve Kirkendall]
980
981==============================================================================
9823. Local mappings and functions *script-local*
983
984When using several Vim script files, there is the danger that mappings and
985functions used in one script use the same name as in other scripts. To avoid
986this, they can be made local to the script.
987
988 *<SID>* *<SNR>* *E81*
989The string "<SID>" can be used in a mapping or menu. This requires that the
990'<' flag is not present in 'cpoptions'.
991 When executing the map command, Vim will replace "<SID>" with the special
992key code <SNR>, followed by a number that's unique for the script, and an
993underscore. Example: >
994 :map <SID>Add
995could define a mapping "<SNR>23_Add".
996
997When defining a function in a script, "s:" can be prepended to the name to
998make it local to the script. But when a mapping is executed from outside of
999the script, it doesn't know in which script the function was defined. To
1000avoid this problem, use "<SID>" instead of "s:". The same translation is done
1001as for mappings. This makes it possible to define a call to the function in
Bram Moolenaar81695252004-12-29 20:58:21 +00001002a mapping.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001003
1004When a local function is executed, it runs in the context of the script it was
1005defined in. This means that new functions and mappings it defines can also
1006use "s:" or "<SID>" and it will use the same unique number as when the
1007function itself was defined. Also, the "s:var" local script variables can be
1008used.
1009
1010When executing an autocommand or a user command, it will run in the context of
1011the script it was defined in. This makes it possible that the command calls a
1012local function or uses a local mapping.
1013
1014Otherwise, using "<SID>" outside of a script context is an error.
1015
1016If you need to get the script number to use in a complicated script, you can
Bram Moolenaar4770d092006-01-12 23:22:24 +00001017use this function: >
1018 function s:SID()
1019 return matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_SID$')
1020 endfun
Bram Moolenaar071d4272004-06-13 20:20:40 +00001021
1022The "<SNR>" will be shown when listing functions and mappings. This is useful
1023to find out what they are defined to.
1024
1025The |:scriptnames| command can be used to see which scripts have been sourced
1026and what their <SNR> number is.
1027
1028This is all {not in Vi} and {not available when compiled without the +eval
1029feature}.
1030
1031==============================================================================
10324. User-defined commands *user-commands*
1033
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001034It is possible to define your own Ex commands. A user-defined command can act
Bram Moolenaar071d4272004-06-13 20:20:40 +00001035just like a built-in command (it can have a range or arguments, arguments can
1036be completed as filenames or buffer names, etc), except that when the command
1037is executed, it is transformed into a normal ex command and then executed.
1038
1039For starters: See section |40.2| in the user manual.
1040
1041 *E183* *user-cmd-ambiguous*
1042All user defined commands must start with an uppercase letter, to avoid
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001043confusion with builtin commands. (There are a few builtin commands, notably
Bram Moolenaar071d4272004-06-13 20:20:40 +00001044:Next, :Print and :X, which do start with an uppercase letter. The builtin
1045will always take precedence in these cases). The other characters of the user
1046command can be uppercase letters, lowercase letters or digits. When using
1047digits, note that other commands that take a numeric argument may become
1048ambiguous. For example, the command ":Cc2" could be the user command ":Cc2"
1049without an argument, or the command ":Cc" with argument "2". It is advised to
1050put a space between the command name and the argument to avoid these problems.
1051
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001052When using a user-defined command, the command can be abbreviated. However, if
1053an abbreviation is not unique, an error will be issued. Furthermore, a
Bram Moolenaar071d4272004-06-13 20:20:40 +00001054built-in command will always take precedence.
1055
1056Example: >
1057 :command Rename ...
1058 :command Renumber ...
1059 :Rena " Means "Rename"
1060 :Renu " Means "Renumber"
1061 :Ren " Error - ambiguous
1062 :command Paste ...
1063 :P " The built-in :Print
1064
1065It is recommended that full names for user-defined commands are used in
1066scripts.
1067
1068:com[mand] *:com* *:command*
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001069 List all user-defined commands. When listing commands,
Bram Moolenaar071d4272004-06-13 20:20:40 +00001070 the characters in the first two columns are
1071 ! Command has the -bang attribute
1072 " Command has the -register attribute
1073 b Command is local to current buffer
1074 (see below for details on attributes)
1075
1076:com[mand] {cmd} List the user-defined commands that start with {cmd}
1077
Bram Moolenaar5b8d8fd2005-08-16 23:01:50 +00001078 *:command-verbose*
1079When 'verbose' is non-zero, listing a command will also display where it was
1080last defined. Example: >
1081
1082 :verbose command TOhtml
1083 Name Args Range Complete Definition
1084 TOhtml 0 % :call Convert2HTML(<line1>, <line2>)
1085 Last set from /usr/share/vim/vim-7.0/plugin/tohtml.vim
1086<
Bram Moolenaar5195e452005-08-19 20:32:47 +00001087See |:verbose-cmd| for more information.
Bram Moolenaar5b8d8fd2005-08-16 23:01:50 +00001088
Bram Moolenaar071d4272004-06-13 20:20:40 +00001089 *E174* *E182*
1090:com[mand][!] [{attr}...] {cmd} {rep}
1091 Define a user command. The name of the command is
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001092 {cmd} and its replacement text is {rep}. The command's
1093 attributes (see below) are {attr}. If the command
Bram Moolenaar071d4272004-06-13 20:20:40 +00001094 already exists, an error is reported, unless a ! is
1095 specified, in which case the command is redefined.
1096
1097:delc[ommand] {cmd} *:delc* *:delcommand* *E184*
1098 Delete the user-defined command {cmd}.
1099
1100:comc[lear] *:comc* *:comclear*
1101 Delete all user-defined commands.
1102
1103Command attributes
1104
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001105User-defined commands are treated by Vim just like any other ex commands. They
1106can have arguments, or have a range specified. Arguments are subject to
1107completion as filenames, buffers, etc. Exactly how this works depends upon the
Bram Moolenaar071d4272004-06-13 20:20:40 +00001108command's attributes, which are specified when the command is defined.
1109
1110There are a number of attributes, split into four categories: argument
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001111handling, completion behavior, range handling, and special cases. The
Bram Moolenaar071d4272004-06-13 20:20:40 +00001112attributes are described below, by category.
1113
1114Argument handling *E175* *E176*
1115
1116By default, a user defined command will take no arguments (and an error is
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001117reported if any are supplied). However, it is possible to specify that the
1118command can take arguments, using the -nargs attribute. Valid cases are:
Bram Moolenaar071d4272004-06-13 20:20:40 +00001119
1120 -nargs=0 No arguments are allowed (the default)
1121 -nargs=1 Exactly one argument is required
1122 -nargs=* Any number of arguments are allowed (0, 1, or many)
1123 -nargs=? 0 or 1 arguments are allowed
1124 -nargs=+ Arguments must be supplied, but any number are allowed
1125
1126Arguments are considered to be separated by (unescaped) spaces or Tabs in this
1127context.
1128
1129Note that arguments are used as text, not as expressions. Specifically,
1130"s:var" will use the script-local variable in the script where the command was
1131defined, not where it is invoked! Example:
1132 script1.vim: >
1133 :let s:error = "None"
1134 :command -nargs=1 Error echoerr <args>
1135< script2.vim: >
1136 :source script1.vim
1137 :let s:error = "Wrong!"
1138 :Error s:error
1139Executing script2.vim will result in "None" to be echoed. Not what you
1140intended! Calling a function may be an alternative.
1141
1142Completion behavior *:command-completion*
1143 *E179* *E180* *E181*
1144By default, the arguments of user defined commands do not undergo completion.
1145However, by specifying one or the other of the following attributes, argument
1146completion can be enabled:
1147
1148 -complete=augroup autocmd groups
1149 -complete=buffer buffer names
1150 -complete=command Ex command (and arguments)
1151 -complete=dir directory names
1152 -complete=environment environment variable names
1153 -complete=event autocommand events
1154 -complete=expression Vim expression
1155 -complete=file file and directory names
Bram Moolenaar362e1a32006-03-06 23:29:24 +00001156 -complete=shellcmd Shell command
Bram Moolenaar071d4272004-06-13 20:20:40 +00001157 -complete=function function name
1158 -complete=help help subjects
1159 -complete=highlight highlight groups
1160 -complete=mapping mapping name
1161 -complete=menu menus
1162 -complete=option options
1163 -complete=tag tags
1164 -complete=tag_listfiles tags, file names are shown when CTRL-D is hit
1165 -complete=var user variables
1166 -complete=custom,{func} custom completion, defined via {func}
Bram Moolenaara466c992005-07-09 21:03:22 +00001167 -complete=customlist,{func} custom completion, defined via {func}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001168
Bram Moolenaara5792f52005-11-23 21:25:05 +00001169
1170Custom completion *:command-completion-custom*
1171 *:command-completion-customlist*
1172 *E467* *E468*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001173It is possible to define customized completion schemes via the "custom,{func}"
Bram Moolenaara466c992005-07-09 21:03:22 +00001174or the "customlist,{func}" completion argument. The {func} part should be a
1175function with the following prototype >
Bram Moolenaar071d4272004-06-13 20:20:40 +00001176
1177 :function {func}(ArgLead, CmdLine, CursorPos)
1178
Bram Moolenaara466c992005-07-09 21:03:22 +00001179The function need not use all these arguments. The function should provide the
1180completion candidates as the return value.
1181
1182For the "custom" argument, the function should return the completion
1183candidates one per line in a newline separated string.
1184
1185For the "customlist" argument, the function should return the completion
Bram Moolenaara5792f52005-11-23 21:25:05 +00001186candidates as a Vim List. Non-string items in the list are ignored.
Bram Moolenaara466c992005-07-09 21:03:22 +00001187
1188The function arguments are:
Bram Moolenaar071d4272004-06-13 20:20:40 +00001189 ArgLead the leading portion of the argument currently being
1190 completed on
1191 CmdLine the entire command line
Bram Moolenaara5792f52005-11-23 21:25:05 +00001192 CursorPos the cursor position in it (byte index)
Bram Moolenaara466c992005-07-09 21:03:22 +00001193The function may use these for determining context. For the "custom"
1194argument, it is not necessary to filter candidates against the (implicit
1195pattern in) ArgLead. Vim will do filter the candidates with its regexp engine
1196after function return, and this is probably more efficient in most cases. For
1197the "customlist" argument, Vim will not filter the returned completion
1198candidates and the user supplied function should filter the candidates.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001199
1200The following example lists user names to a Finger command >
1201 :com -complete=custom,ListUsers -nargs=1 Finger !finger <args>
1202 :fun ListUsers(A,L,P)
1203 : return system("cut -d: -f1 /etc/passwd")
1204 :endfun
1205
Bram Moolenaara466c992005-07-09 21:03:22 +00001206The following example completes filenames from the directories specified in
1207the 'path' option: >
1208 :com -nargs=1 -bang -complete=customlist,EditFileComplete
1209 \ EditFile edit<bang> <args>
1210 :fun EditFileComplete(A,L,P)
Bram Moolenaara3ffd9c2005-07-21 21:03:15 +00001211 : return split(globpath(&path, a:ArgLead), "\n")
Bram Moolenaara466c992005-07-09 21:03:22 +00001212 :endfun
1213<
Bram Moolenaara5792f52005-11-23 21:25:05 +00001214
Bram Moolenaar071d4272004-06-13 20:20:40 +00001215Range handling *E177* *E178*
1216
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001217By default, user-defined commands do not accept a line number range. However,
Bram Moolenaar071d4272004-06-13 20:20:40 +00001218it is possible to specify that the command does take a range (the -range
1219attribute), or that it takes an arbitrary count value, either in the line
1220number position (-range=N, like the |:split| command) or as a "count"
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001221argument (-count=N, like the |:Next| command). Possible attributes are:
Bram Moolenaar071d4272004-06-13 20:20:40 +00001222
1223 -range Range allowed, default is current line
1224 -range=% Range allowed, default is whole file (1,$)
1225 -range=N A count (default N) which is specified in the line
1226 number position (like |:split|)
1227 -count=N A count (default N) which is specified either in the line
Bram Moolenaar32e7b2d2005-02-27 22:36:47 +00001228 number position, or as an initial argument (like |:Next|).
Bram Moolenaar071d4272004-06-13 20:20:40 +00001229 Specifying -count (without a default) acts like -count=0
1230
1231Note that -range=N and -count=N are mutually exclusive - only one should be
1232specified.
1233
1234Special cases
1235
1236There are some special cases as well:
1237
1238 -bang The command can take a ! modifier (like :q or :w)
1239 -bar The command can be followed by a "|" and another command.
1240 A "|" inside the command argument is not allowed then.
1241 Also checks for a " to start a comment.
1242 -register The first argument to the command can be an optional
1243 register name (like :del, :put, :yank).
1244 -buffer The command will only be available in the current buffer.
1245
1246In the cases of the -count and -register attributes, if the optional argument
1247is supplied, it is removed from the argument list and is available to the
1248replacement text separately.
1249
1250Replacement text
1251
1252The replacement text for a user defined command is scanned for special escape
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001253sequences, using <...> notation. Escape sequences are replaced with values
1254from the entered command line, and all other text is copied unchanged. The
Bram Moolenaar371d5402006-03-20 21:47:49 +00001255resulting string is executed as an Ex command. To avoid the replacement use
1256<lt> in plade of the initial <. Thus to include "<bang>" literally use
1257"<lt>bang>".
Bram Moolenaar071d4272004-06-13 20:20:40 +00001258
1259The valid escape sequences are
1260
1261 *<line1>*
1262 <line1> The starting line of the command range.
1263 *<line2>*
1264 <line2> The final line of the command range.
1265 *<count>*
1266 <count> Any count supplied (as described for the '-range'
1267 and '-count' attributes).
1268 *<bang>*
1269 <bang> (See the '-bang' attribute) Expands to a ! if the
1270 command was executed with a ! modifier, otherwise
1271 expands to nothing.
1272 *<reg>* *<register>*
1273 <reg> (See the '-register' attribute) The optional register,
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001274 if specified. Otherwise, expands to nothing. <register>
Bram Moolenaar071d4272004-06-13 20:20:40 +00001275 is a synonym for this.
1276 *<args>*
1277 <args> The command arguments, exactly as supplied (but as
1278 noted above, any count or register can consume some
1279 of the arguments, which are then not part of <args>).
1280 <lt> A single '<' (Less-Than) character. This is needed if you
1281 want to get a literal copy of one of these escape sequences
1282 into the expansion - for example, to get <bang>, use
1283 <lt>bang>.
1284
1285 *<q-args>*
1286If the first two characters of an escape sequence are "q-" (for example,
1287<q-args>) then the value is quoted in such a way as to make it a valid value
1288for use in an expression. This uses the argument as one single value.
Bram Moolenaar51485f02005-06-04 21:55:20 +00001289When there is no argument <q-args> is an empty string.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001290
1291To allow commands to pass their arguments on to a user-defined function, there
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001292is a special form <f-args> ("function args"). This splits the command
Bram Moolenaar071d4272004-06-13 20:20:40 +00001293arguments at spaces and Tabs, quotes each argument individually, and the
1294<f-args> sequence is replaced by the comma-separated list of quoted arguments.
Bram Moolenaar5b8d8fd2005-08-16 23:01:50 +00001295See the Mycmd example below. If no arguments are given <f-args> is removed.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001296
1297Examples >
1298
1299 " Delete everything after here to the end
1300 :com Ddel +,$d
1301
1302 " Rename the current buffer
1303 :com -nargs=1 -bang -complete=file Ren f <args>|w<bang>
1304
1305 " Replace a range with the contents of a file
1306 " (Enter this all as one line)
1307 :com -range -nargs=1 -complete=file
1308 Replace <line1>-pu_|<line1>,<line2>d|r <args>|<line1>d
1309
1310 " Count the number of lines in the range
Bram Moolenaar81695252004-12-29 20:58:21 +00001311 :com! -range -nargs=0 Lines echo <line2> - <line1> + 1 "lines"
Bram Moolenaar071d4272004-06-13 20:20:40 +00001312
1313 " Call a user function (example of <f-args>)
1314 :com -nargs=* Mycmd call Myfunc(<f-args>)
1315
1316When executed as: >
1317 :Mycmd arg1 arg2
1318This will invoke: >
1319 :call Myfunc("arg1","arg2")
1320
1321 :" A more substantial example
1322 :function Allargs(command)
1323 : let i = 0
1324 : while i < argc()
1325 : if filereadable(argv(i))
1326 : execute "e " . argv(i)
1327 : execute a:command
1328 : endif
1329 : let i = i + 1
1330 : endwhile
1331 :endfunction
1332 :command -nargs=+ -complete=command Allargs call Allargs(<q-args>)
1333
1334The command Allargs takes any Vim command(s) as argument and executes it on all
1335files in the argument list. Usage example (note use of the "e" flag to ignore
1336errors and the "update" command to write modified buffers): >
1337 :Allargs %s/foo/bar/ge|update
1338This will invoke: >
1339 :call Allargs("%s/foo/bar/ge|update")
1340<
1341When defining an user command in a script, it will be able to call functions
1342local to the script and use mappings local to the script. When the user
1343invokes the user command, it will run in the context of the script it was
1344defined in. This matters if |<SID>| is used in a command.
1345
1346 vim:tw=78:ts=8:ft=help:norl: