| blob | ecc992db4ee68177485d22bb97f8b63643d299cd |
1 *map.txt* For Vim version 7.2. Last change: 2009 Nov 04
4 VIM REFERENCE MANUAL by Bram Moolenaar
7 Key mapping, abbreviations and user-defined commands.
9 This subject is introduced in sections |05.3|, |24.7| and |40.1| of the user
10 manual.
12 1. Key mapping |key-mapping|
13 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|
24 2. Abbreviations |abbreviations|
25 3. Local mappings and functions |script-local|
26 4. User-defined commands |user-commands|
28 ==============================================================================
29 1. Key mapping *key-mapping* *mapping* *macro*
31 Key mapping is used to change the meaning of typed keys. The most common use
32 is to define a sequence commands for a function key. Example: >
34 :map <F2> a<C-R>=strftime("%c")<CR><Esc>
36 This appends the current date and time after the cursor (in <> notation |<>|).
39 1.1 MAP COMMANDS *:map-commands*
41 There are commands to enter new mappings, remove mappings and list mappings.
42 See |map-overview| for the various forms of "map" and their relationships with
43 modes.
45 {lhs} means left-hand-side *{lhs}*
46 {rhs} means right-hand-side *{rhs}*
48 :map {lhs} {rhs} |mapmode-nvo| *:map*
49 :nm[ap] {lhs} {rhs} |mapmode-n| *:nm* *:nmap*
50 :vm[ap] {lhs} {rhs} |mapmode-v| *:vm* *:vmap*
51 :xm[ap] {lhs} {rhs} |mapmode-x| *:xm* *:xmap*
52 :smap {lhs} {rhs} |mapmode-s| *:smap*
53 :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*
58 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.
64 :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*
67 :xn[oremap] {lhs} {rhs} |mapmode-x| *:xn* *:xnoremap*
68 :snor[emap] {lhs} {rhs} |mapmode-s| *:snor* *:snoremap*
69 :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*
74 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}
80 :unm[ap] {lhs} |mapmode-nvo| *:unm* *:unmap*
81 :nun[map] {lhs} |mapmode-n| *:nun* *:nunmap*
82 :vu[nmap] {lhs} |mapmode-v| *:vu* *:vunmap*
83 :xu[nmap] {lhs} |mapmode-x| *:xu* *:xunmap*
84 :sunm[ap] {lhs} |mapmode-s| *:sunm* *:sunmap*
85 :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*
90 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
98 :mapc[lear] |mapmode-nvo| *:mapc* *:mapclear*
99 :nmapc[lear] |mapmode-n| *:nmapc* *:nmapclear*
100 :vmapc[lear] |mapmode-v| *:vmapc* *:vmapclear*
101 :xmapc[lear] |mapmode-x| *:xmapc* *:xmapclear*
102 :smapc[lear] |mapmode-s| *:smapc* *:smapclear*
103 :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*
108 Remove ALL mappings for the modes where the map
109 command applies. {not in Vi}
110 Warning: This also removes the default mappings.
112 :map |mapmode-nvo|
113 :nm[ap] |mapmode-n|
114 :vm[ap] |mapmode-v|
115 :xm[ap] |mapmode-x|
116 :sm[ap] |mapmode-s|
117 :om[ap] |mapmode-o|
118 :map! |mapmode-ic|
119 :im[ap] |mapmode-i|
120 :lm[ap] |mapmode-l|
121 :cm[ap] |mapmode-c|
122 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.
126 :map {lhs} |mapmode-nvo| *:map_l*
127 :nm[ap] {lhs} |mapmode-n| *:nmap_l*
128 :vm[ap] {lhs} |mapmode-v| *:vmap_l*
129 :xm[ap] {lhs} |mapmode-x| *:xmap_l*
130 :sm[ap] {lhs} |mapmode-s| *:smap_l*
131 :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*
136 List the key mappings for the key sequences starting
137 with {lhs} in the modes where the map command applies.
138 {not in Vi}
140 These commands are used to map a key or key sequence to a string of
141 characters. You can use this to put command sequences under function keys,
142 translate one key into another, etc. See |:mkexrc| for how to save and
143 restore the current mappings.
145 *map-ambiguous*
146 When two mappings start with the same sequence of characters, they are
147 ambiguous. Example: >
148 :imap aa foo
149 :imap aaa bar
150 When Vim has read "aa", it will need to get another character to be able to
151 decide if "aa" or "aaa" should be mapped. This means that after typing "aa"
152 that mapping won't get expanded yet, Vim is waiting for another character.
153 If you type a space, then "foo" will get inserted, plus the space. If you
154 type "a", then "bar" will get inserted.
155 {Vi does not allow ambiguous mappings}
158 1.2 SPECIAL ARGUMENTS *:map-arguments*
160 "<buffer>", "<silent>", "<special>", "<script>", "<expr>" and "<unique>" can
161 be used in any order. They must appear right after the command, before any
162 other arguments.
164 *:map-local* *:map-<buffer>* *E224* *E225*
165 If the first argument to one of these commands is "<buffer>" the mapping will
166 be effective in the current buffer only. Example: >
167 :map <buffer> ,w /[.,;]<CR>
168 Then you can map ",w" to something else in another buffer: >
169 :map <buffer> ,w /[#&!]<CR>
170 The local buffer mappings are used before the global ones.
171 The "<buffer>" argument can also be used to clear mappings: >
172 :unmap <buffer> ,w
173 :mapclear <buffer>
174 Local mappings are also cleared when a buffer is deleted, but not when it is
175 unloaded. Just like local option values.
177 *:map-<silent>* *:map-silent*
178 To define a mapping which will not be echoed on the command line, add
179 "<silent>" as the first argument. Example: >
180 :map <silent> ,h /Header<CR>
181 The search string will not be echoed when using this mapping. Messages from
182 the executed command are still given though. To shut them up too, add a
183 ":silent" in the executed command: >
184 :map <silent> ,h :exe ":silent normal /Header\r"<CR>
185 Prompts will still be given, e.g., for inputdialog().
186 Using "<silent>" for an abbreviation is possible, but will cause redrawing of
187 the command line to fail.
189 *:map-<special>* *:map-special*
190 Define a mapping with <> notation for special keys, even though the "<" flag
191 may appear in 'cpoptions'. This is useful if the side effect of setting
192 'cpoptions' is not desired. Example: >
193 :map <special> <F12> /Header<CR>
194 <
195 *:map-<script>* *:map-script*
196 If the first argument to one of these commands is "<script>" and it is used to
197 define a new mapping or abbreviation, the mapping will only remap characters
198 in the {rhs} using mappings that were defined local to a script, starting with
199 "<SID>". This can be used to avoid that mappings from outside a script
200 interfere (e.g., when CTRL-V is remapped in mswin.vim), but do use other
201 mappings defined in the script.
202 Note: ":map <script>" and ":noremap <script>" do the same thing. The
203 "<script>" overrules the command name. Using ":noremap <script>" is
204 preferred, because it's clearer that remapping is (mostly) disabled.
206 *:map-<unique>* *E226* *E227*
207 If the first argument to one of these commands is "<unique>" and it is used to
208 define a new mapping or abbreviation, the command will fail if the mapping or
209 abbreviation already exists. Example: >
210 :map <unique> ,w /[#&!]<CR>
211 When defining a local mapping, there will also be a check if a global map
212 already exists which is equal.
213 Example of what will fail: >
214 :map ,w /[#&!]<CR>
215 :map <buffer> <unique> ,w /[.,;]<CR>
216 If you want to map a key and then have it do what it was originally mapped to,
217 have a look at |maparg()|.
219 *:map-<expr>* *:map-expression*
220 If the first argument to one of these commands is "<expr>" and it is used to
221 define a new mapping or abbreviation, the argument is an expression. The
222 expression is evaluated to obtain the {rhs} that is used. Example: >
223 :inoremap <expr> . InsertDot()
224 The result of the InsertDot() function will be inserted. It could check the
225 text before the cursor and start omni completion when some condition is met.
227 For abbreviations |v:char| is set to the character that was typed to trigger
228 the abbreviation. You can use this to decide how to expand the {lhs}. You
229 can't change v:char and you should not insert it.
231 Be very careful about side effects! The expression is evaluated while
232 obtaining characters, you may very well make the command dysfunctional.
233 For this reason the following is blocked:
234 - Changing the buffer text |textlock|.
235 - Editing another buffer.
236 - The |:normal| command.
237 - Moving the cursor is allowed, but it is restored afterwards.
238 - You can use getchar(), but the existing typeahead isn't seen and new
239 typeahead is discarded.
240 If you want the mapping to do any of these let the returned characters do
241 that.
243 Here is an example that inserts a list number that increases: >
244 let counter = 0
245 inoremap <expr> <C-L> ListItem()
246 inoremap <expr> <C-R> ListReset()
248 func ListItem()
249 let g:counter += 1
250 return g:counter . '. '
251 endfunc
253 func ListReset()
254 let g:counter = 0
255 return ''
256 endfunc
258 CTRL-L inserts the next number, CTRL-R resets the count. CTRL-R returns an
259 empty string, so that nothing is inserted.
261 Note that there are some tricks to make special keys work and escape CSI bytes
262 in the text. The |:map| command also does this, thus you must avoid that it
263 is done twice. This does not work: >
264 :imap <expr> <F3> "<Char-0x611B>"
265 Because the <Char- sequence is escaped for being a |:imap| argument and then
266 again for using <expr>. This does work: >
267 :imap <expr> <F3> "\u611B"
268 Using 0x80 as a single byte before other text does not work, it will be seen
269 as a special key.
272 1.3 MAPPING AND MODES *:map-modes*
273 *mapmode-nvo* *mapmode-n* *mapmode-v* *mapmode-o*
275 There are six sets of mappings
276 - For Normal mode: When typing commands.
277 - For Visual mode: When typing commands while the Visual area is highlighted.
278 - For Select mode: like Visual mode but typing text replaces the selection.
279 - For Operator-pending mode: When an operator is pending (after "d", "y", "c",
280 etc.). See below: |omap-info|.
281 - For Insert mode. These are also used in Replace mode.
282 - For Command-line mode: When entering a ":" or "/" command.
284 Special case: While typing a count for a command in Normal mode, mapping zero
285 is disabled. This makes it possible to map zero without making it impossible
286 to type a count with a zero.
288 *map-overview* *map-modes*
289 Overview of which map command works in which mode:
291 commands: modes: ~
292 Normal Visual+Select Operator-pending ~
293 :map :noremap :unmap :mapclear yes yes yes
294 :nmap :nnoremap :nunmap :nmapclear yes - -
295 :vmap :vnoremap :vunmap :vmapclear - yes -
296 :omap :onoremap :ounmap :omapclear - - yes
298 :nunmap can also be used outside of a monastery.
299 *mapmode-x* *mapmode-s*
300 Some commands work both in Visual and Select mode, some in only one. Note
301 that quite often "Visual" is mentioned where both Visual and Select mode
302 apply. |Select-mode-mapping|
303 NOTE: Mapping a printable character in Select mode may confuse the user. It's
304 better to explicitly use :xmap and :smap for printable characters. Or use
305 :sunmap after defining the mapping.
307 commands: modes: ~
308 Visual Select ~
309 :vmap :vnoremap :vunmap :vmapclear yes yes
310 :xmap :xnoremap :xunmap :xmapclear yes -
311 :smap :snoremap :sunmap :smapclear - yes
313 *mapmode-ic* *mapmode-i* *mapmode-c* *mapmode-l*
314 Some commands work both in Insert mode and Command-line mode, some not:
316 commands: modes: ~
317 Insert Command-line Lang-Arg ~
318 :map! :noremap! :unmap! :mapclear! yes yes -
319 :imap :inoremap :iunmap :imapclear yes - -
320 :cmap :cnoremap :cunmap :cmapclear - yes -
321 :lmap :lnoremap :lunmap :lmapclear yes* yes* yes*
323 The original Vi did not have separate mappings for
324 Normal/Visual/Operator-pending mode and for Insert/Command-line mode.
325 Therefore the ":map" and ":map!" commands enter and display mappings for
326 several modes. In Vim you can use the ":nmap", ":vmap", ":omap", ":cmap" and
327 ":imap" commands to enter mappings for each mode separately.
329 *omap-info*
330 Operator-pending mappings can be used to define a movement command that can be
331 used with any operator. Simple example: ":omap { w" makes "y{" work like "yw"
332 and "d{" like "dw".
334 To ignore the starting cursor position and select different text, you can have
335 the omap start Visual mode to select the text to be operated upon. Example
336 that operates on a function name in the current line: >
337 onoremap <silent> F :<C-U>normal! 0f(hviw<CR>
338 The CTRL-U (<C-U>) is used to remove the range that Vim may insert. The
339 Normal mode commands find the first '(' character and select the first word
340 before it. That usually is the function name.
342 To enter a mapping for Normal and Visual mode, but not Operator-pending mode,
343 first define it for all three modes, then unmap it for Operator-pending mode:
344 :map xx something-difficult
345 :ounmap xx
346 Likewise for a mapping for Visual and Operator-pending mode or Normal and
347 Operator-pending mode.
349 *language-mapping*
350 ":lmap" defines a mapping that applies to:
351 - Insert mode
352 - Command-line mode
353 - when entering a search pattern
354 - the argument of the commands that accept a text character, such as "r" and
355 "f"
356 - for the input() line
357 Generally: Whenever a character is to be typed that is part of the text in the
358 buffer, not a Vim command character. "Lang-Arg" isn't really another mode,
359 it's just used here for this situation.
360 The simplest way to load a set of related language mappings is by using the
361 'keymap' option. See |45.5|.
362 In Insert mode and in Command-line mode the mappings can be disabled with
363 the CTRL-^ command |i_CTRL-^| |c_CTRL-^|. When starting to enter a normal
364 command line (not a search pattern) the mappings are disabled until a CTRL-^
365 is typed. The state last used is remembered for Insert mode and Search
366 patterns separately. The state for Insert mode is also used when typing a
367 character as an argument to command like "f" or "t".
368 Language mappings will never be applied to already mapped characters. They
369 are only used for typed characters. This assumes that the language mapping
370 was already done when typing the mapping.
373 1.4 LISTING MAPPINGS *map-listing*
375 When listing mappings the characters in the first two columns are:
377 CHAR MODE ~
378 <Space> Normal, Visual, Select and Operator-pending
379 n Normal
380 v Visual and Select
381 s Select
382 x Visual
383 o Operator-pending
384 ! Insert and Command-line
385 i Insert
386 l ":lmap" mappings for Insert, Command-line and Lang-Arg
387 c Command-line
389 Just before the {rhs} a special character can appear:
390 * indicates that it is not remappable
391 & indicates that only script-local mappings are remappable
392 @ indicates a buffer-local mapping
394 Everything from the first non-blank after {lhs} up to the end of the line
395 (or '|') is considered to be part of {rhs}. This allows the {rhs} to end
396 with a space.
398 Note: When using mappings for Visual mode, you can use the "'<" mark, which
399 is the start of the last selected Visual area in the current buffer |'<|.
401 *:map-verbose*
402 When 'verbose' is non-zero, listing a key map will also display where it was
403 last defined. Example: >
405 :verbose map <C-W>*
406 n <C-W>* * <C-W><C-S>*
407 Last set from /home/abcd/.vimrc
409 See |:verbose-cmd| for more information.
412 1.5 MAPPING SPECIAL KEYS *:map-special-keys*
414 There are three ways to map a special key:
415 1. The Vi-compatible method: Map the key code. Often this is a sequence that
416 starts with <Esc>. To enter a mapping like this you type ":map " and then
417 you have to type CTRL-V before hitting the function key. Note that when
418 the key code for the key is in the termcap (the t_ options), it will
419 automatically be translated into the internal code and become the second
420 way of mapping (unless the 'k' flag is included in 'cpoptions').
421 2. The second method is to use the internal code for the function key. To
422 enter such a mapping type CTRL-K and then hit the function key, or use
423 the form "#1", "#2", .. "#9", "#0", "<Up>", "<S-Down>", "<S-F7>", etc.
424 (see table of keys |key-notation|, all keys from <Up> can be used). The
425 first ten function keys can be defined in two ways: Just the number, like
426 "#2", and with "<F>", like "<F2>". Both stand for function key 2. "#0"
427 refers to function key 10, defined with option 't_f10', which may be
428 function key zero on some keyboards. The <> form cannot be used when
429 'cpoptions' includes the '<' flag.
430 3. Use the termcap entry, with the form <t_xx>, where "xx" is the name of the
431 termcap entry. Any string entry can be used. For example: >
432 :map <t_F3> G
433 < Maps function key 13 to "G". This does not work if 'cpoptions' includes
434 the '<' flag.
436 The advantage of the second and third method is that the mapping will work on
437 different terminals without modification (the function key will be
438 translated into the same internal code or the actual key code, no matter what
439 terminal you are using. The termcap must be correct for this to work, and you
440 must use the same mappings).
442 DETAIL: Vim first checks if a sequence from the keyboard is mapped. If it
443 isn't the terminal key codes are tried (see |terminal-options|). If a
444 terminal code is found it is replaced with the internal code. Then the check
445 for a mapping is done again (so you can map an internal code to something
446 else). What is written into the script file depends on what is recognized.
447 If the terminal key code was recognized as a mapping the key code itself is
448 written to the script file. If it was recognized as a terminal code the
449 internal code is written to the script file.
452 1.6 SPECIAL CHARACTERS *:map-special-chars*
453 *map_backslash*
454 Note that only CTRL-V is mentioned here as a special character for mappings
455 and abbreviations. When 'cpoptions' does not contain 'B', a backslash can
456 also be used like CTRL-V. The <> notation can be fully used then |<>|. But
457 you cannot use "<C-V>" like CTRL-V to escape the special meaning of what
458 follows.
460 To map a backslash, or use a backslash literally in the {rhs}, the special
461 sequence "<Bslash>" can be used. This avoids the need to double backslashes
462 when using nested mappings.
464 *map_CTRL-C*
465 Using CTRL-C in the {lhs} is possible, but it will only work when Vim is
466 waiting for a key, not when Vim is busy with something. When Vim is busy
467 CTRL-C interrupts/breaks the command.
468 When using the GUI version on MS-Windows CTRL-C can be mapped to allow a Copy
469 command to the clipboard. Use CTRL-Break to interrupt Vim.
471 *map_space_in_lhs*
472 To include a space in {lhs} precede it with a CTRL-V (type two CTRL-Vs for
473 each space).
474 *map_space_in_rhs*
475 If you want a {rhs} that starts with a space, use "<Space>". To be fully Vi
476 compatible (but unreadable) don't use the |<>| notation, precede {rhs} with a
477 single CTRL-V (you have to type CTRL-V two times).
478 *map_empty_rhs*
479 You can create an empty {rhs} by typing nothing after a single CTRL-V (you
480 have to type CTRL-V two times). Unfortunately, you cannot do this in a vimrc
481 file.
482 *<Nop>*
483 A easier way to get a mapping that doesn't produce anything, is to use "<Nop>"
484 for the {rhs}. This only works when the |<>| notation is enabled. For
485 example, to make sure that function key 8 does nothing at all: >
486 :map <F8> <Nop>
487 :map! <F8> <Nop>
488 <
489 *map-multibyte*
490 It is possible to map multibyte characters, but only the whole character. You
491 cannot map the first byte only. This was done to prevent problems in this
492 scenario: >
493 :set encoding=latin1
494 :imap <M-C> foo
495 :set encoding=utf-8
496 The mapping for <M-C> is defined with the latin1 encoding, resulting in a 0xc3
497 byte. If you type the character á (0xe1 <M-a>) in UTF-8 encoding this is the
498 two bytes 0xc3 0xa1. You don't want the 0xc3 byte to be mapped then,
499 otherwise it would be impossible to type the á character.
501 *<Leader>* *mapleader*
502 To define a mapping which uses the "mapleader" variable, the special string
503 "<Leader>" can be used. It is replaced with the string value of "mapleader".
504 If "mapleader" is not set or empty, a backslash is used instead. Example: >
505 :map <Leader>A oanother line<Esc>
506 Works like: >
507 :map \A oanother line<Esc>
508 But after: >
509 :let mapleader = ","
510 It works like: >
511 :map ,A oanother line<Esc>
513 Note that the value of "mapleader" is used at the moment the mapping is
514 defined. Changing "mapleader" after that has no effect for already defined
515 mappings.
517 *<LocalLeader>* *maplocalleader*
518 <LocalLeader> is just like <Leader>, except that it uses "maplocalleader"
519 instead of "mapleader". <LocalLeader> is to be used for mappings which are
520 local to a buffer. Example: >
521 :map <LocalLeader>q \DoItNow
522 <
523 In a global plugin <Leader> should be used and in a filetype plugin
524 <LocalLeader>. "mapleader" and "maplocalleader" can be equal. Although, if
525 you make them different, there is a smaller chance of mappings from global
526 plugins to clash with mappings for filetype plugins. For example, you could
527 keep "mapleader" at the default backslash, and set "maplocalleader" to an
528 underscore.
530 *map-<SID>*
531 In a script the special key name "<SID>" can be used to define a mapping
532 that's local to the script. See |<SID>| for details.
534 *<Plug>*
535 The special key name "<Plug>" can be used for an internal mapping, which is
536 not to be matched with any key sequence. This is useful in plugins
537 |using-<Plug>|.
539 *<Char>* *<Char->*
540 To map a character by its decimal, octal or hexadecimal number the <Char>
541 construct can be used:
542 <Char-123> character 123
543 <Char-033> character 27
544 <Char-0x7f> character 127
545 This is useful to specify a (multi-byte) character in a 'keymap' file.
546 Upper and lowercase differences are ignored.
548 *map-comments*
549 It is not possible to put a comment after these commands, because the '"'
550 character is considered to be part of the {lhs} or {rhs}.
552 *map_bar*
553 Since the '|' character is used to separate a map command from the next
554 command, you will have to do something special to include a '|' in {rhs}.
555 There are three methods:
556 use works when example ~
557 <Bar> '<' is not in 'cpoptions' :map _l :!ls <Bar> more^M
558 \| 'b' is not in 'cpoptions' :map _l :!ls \| more^M
559 ^V| always, in Vim and Vi :map _l :!ls ^V| more^M
561 (here ^V stands for CTRL-V; to get one CTRL-V you have to type it twice; you
562 cannot use the <> notation "<C-V>" here).
564 All three work when you use the default setting for 'cpoptions'.
566 When 'b' is present in 'cpoptions', "\|" will be recognized as a mapping
567 ending in a '\' and then another command. This is Vi compatible, but
568 illogical when compared to other commands.
570 *map_return*
571 When you have a mapping that contains an Ex command, you need to put a line
572 terminator after it to have it executed. The use of <CR> is recommended for
573 this (see |<>|). Example: >
574 :map _ls :!ls -l %<CR>:echo "the end"<CR>
576 To avoid mapping of the characters you type in insert or Command-line mode,
577 type a CTRL-V first. The mapping in Insert mode is disabled if the 'paste'
578 option is on.
580 Note that when an error is encountered (that causes an error message or beep)
581 the rest of the mapping is not executed. This is Vi-compatible.
583 Note that the second character (argument) of the commands @zZtTfF[]rm'`"v
584 and CTRL-X is not mapped. This was done to be able to use all the named
585 registers and marks, even when the command with the same name has been
586 mapped.
589 1.7 WHAT KEYS TO MAP *map-which-keys*
591 If you are going to map something, you will need to choose which key(s) to use
592 for the {lhs}. You will have to avoid keys that are used for Vim commands,
593 otherwise you would not be able to use those commands anymore. Here are a few
594 suggestions:
595 - Function keys <F2>, <F3>, etc.. Also the shifted function keys <S-F1>,
596 <S-F2>, etc. Note that <F1> is already used for the help command.
597 - Meta-keys (with the ALT key pressed). Depending on your keybord accented
598 characters may be used as well. |:map-alt-keys|
599 - Use the '_' or ',' character and then any other character. The "_" and ","
600 commands do exist in Vim (see |_| and |,|), but you probably never use them.
601 - Use a key that is a synonym for another command. For example: CTRL-P and
602 CTRL-N. Use an extra character to allow more mappings.
603 - The key defined by <Leader> and one or more other keys. This is especially
604 useful in scripts. |mapleader|
606 See the file "index" for keys that are not used and thus can be mapped without
607 losing any builtin function. You can also use ":help {key}^D" to find out if
608 a key is used for some command. ({key} is the specific key you want to find
609 out about, ^D is CTRL-D).
612 1.8 EXAMPLES *map-examples*
614 A few examples (given as you type them, for "<CR>" you type four characters;
615 the '<' flag must not be present in 'cpoptions' for this to work). >
617 :map <F3> o#include
618 :map <M-g> /foo<CR>cwbar<Esc>
619 :map _x d/END/e<CR>
620 :map! qq quadrillion questions
623 Multiplying a count
625 When you type a count before triggering a mapping, it's like the count was
626 typed before the {lhs}. For example, with this mapping: >
627 :map <F4> 3w
628 Typing 2<F4> will result in "23w". Thus not moving 2 * 3 words but 23 words.
629 If you want to multiply counts use the expression register: >
630 :map <F4> @='3w'<CR>
631 The part between quotes is the expression being executed. |@=|
634 1.9 USING MAPPINGS *map-typing*
636 Vim will compare what you type with the start of a mapped sequence. If there
637 is an incomplete match, it will get more characters until there either is a
638 complete match or until there is no match at all. Example: If you map! "qq",
639 the first 'q' will not appear on the screen until you type another
640 character. This is because Vim cannot know if the next character will be a
641 'q' or not. If the 'timeout' option is on (which is the default) Vim will
642 only wait for one second (or as long as specified with the 'timeoutlen'
643 option). After that it assumes that the 'q' is to be interpreted as such. If
644 you type slowly, or your system is slow, reset the 'timeout' option. Then you
645 might want to set the 'ttimeout' option.
647 *map-keys-fails*
648 There are situations where key codes might not be recognized:
649 - Vim can only read part of the key code. Mostly this is only the first
650 character. This happens on some Unix versions in an xterm.
651 - The key code is after character(s) that are mapped. E.g., "<F1><F1>" or
652 "g<F1>".
654 The result is that the key code is not recognized in this situation, and the
655 mapping fails. There are two actions needed to avoid this problem:
657 - Remove the 'K' flag from 'cpoptions'. This will make Vim wait for the rest
658 of the characters of the function key.
659 - When using <F1> to <F4> the actual key code generated may correspond to
660 <xF1> to <xF4>. There are mappings from <xF1> to <F1>, <xF2> to <F2>, etc.,
661 but these are not recognized after another half a mapping. Make sure the
662 key codes for <F1> to <F4> are correct: >
663 :set <F1>=<type CTRL-V><type F1>
664 < Type the <F1> as four characters. The part after the "=" must be done with
665 the actual keys, not the literal text.
666 Another solution is to use the actual key code in the mapping for the second
667 special key: >
668 :map <F1><Esc>OP :echo "yes"<CR>
669 Don't type a real <Esc>, Vim will recognize the key code and replace it with
670 <F1> anyway.
672 Another problem may be that when keeping ALT or Meta pressed the terminal
673 prepends ESC instead of setting the 8th bit. See |:map-alt-keys|.
675 *recursive_mapping*
676 If you include the {lhs} in the {rhs} you have a recursive mapping. When
677 {lhs} is typed, it will be replaced with {rhs}. When the {lhs} which is
678 included in {rhs} is encountered it will be replaced with {rhs}, and so on.
679 This makes it possible to repeat a command an infinite number of times. The
680 only problem is that the only way to stop this is by causing an error. The
681 macros to solve a maze uses this, look there for an example. There is one
682 exception: If the {rhs} starts with {lhs}, the first character is not mapped
683 again (this is Vi compatible).
684 For example: >
685 :map ab abcd
686 will execute the "a" command and insert "bcd" in the text. The "ab" in the
687 {rhs} will not be mapped again.
689 If you want to exchange the meaning of two keys you should use the :noremap
690 command. For example: >
691 :noremap k j
692 :noremap j k
693 This will exchange the cursor up and down commands.
695 With the normal :map command, when the 'remap' option is on, mapping takes
696 place until the text is found not to be a part of a {lhs}. For example, if
697 you use: >
698 :map x y
699 :map y x
700 Vim will replace x with y, and then y with x, etc. When this has happened
701 'maxmapdepth' times (default 1000), Vim will give the error message
702 "recursive mapping".
704 *:map-undo*
705 If you include an undo command inside a mapped sequence, this will bring the
706 text back in the state before executing the macro. This is compatible with
707 the original Vi, as long as there is only one undo command in the mapped
708 sequence (having two undo commands in a mapped sequence did not make sense
709 in the original Vi, you would get back the text before the first undo).
712 1.10 MAPPING ALT-KEYS *:map-alt-keys*
714 In the GUI Vim handles the Alt key itself, thus mapping keys with ALT should
715 always work. But in a terminal Vim gets a sequence of bytes and has to figure
716 out whether ALT was pressed or not.
718 By default Vim assumes that pressing the ALT key sets the 8th bit of a typed
719 character. Most decent terminals can work that way, such as xterm, aterm and
720 rxvt. If your <A-k> mappings don't work it might be that the terminal is
721 prefixing the character with an ESC character. But you can just as well type
722 ESC before a character, thus Vim doesn't know what happened (except for
723 checking the delay between characters, which is not reliable).
725 As of this writing, some mainstream terminals like gnome-terminal and konsole
726 use the ESC prefix. There doesn't appear a way to have them use the 8th bit
727 instead. Xterm should work well by default. Aterm and rxvt should work well
728 when started with the "--meta8" argument. You can also tweak resources like
729 "metaSendsEscape", "eightBitInput" and "eightBitOutput".
731 On the Linux console, this behavior can be toggled with the "setmetamode"
732 command. Bear in mind that not using an ESC prefix could get you in trouble
733 with other programs. You should make sure that bash has the "convert-meta"
734 option set to "on" in order for your Meta keybindings to still work on it
735 (it's the default readline behavior, unless changed by specific system
736 configuration). For that, you can add the line: >
738 set convert-meta on
740 to your ~/.inputrc file. If you're creating the file, you might want to use: >
742 $include /etc/inputrc
744 as the first line, if that file exists on your system, to keep global options.
745 This may cause a problem for entering special characters, such as the umlaut.
746 Then you should use CTRL-V before that character.
748 Bear in mind that convert-meta has been reported to have troubles when used in
749 UTF-8 locales. On terminals like xterm, the "metaSendsEscape" resource can be
750 toggled on the fly through the "Main Options" menu, by pressing Ctrl-LeftClick
751 on the terminal; that's a good last resource in case you want to send ESC when
752 using other applications but not when inside VIM.
755 1.11 MAPPING AN OPERATOR *:map-operator*
757 An operator is used before a {motion} command. To define your own operator
758 you must create mapping that first sets the 'operatorfunc' option and then
759 invoke the |g@| operator. After the user types the {motion} command the
760 specified function will be called.
762 *g@* *E774* *E775*
763 g@{motion} Call the function set by the 'operatorfunc' option.
764 The '[ mark is positioned at the start of the text
765 moved over by {motion}, the '] mark on the last
766 character of the text.
767 The function is called with one String argument:
768 "line" {motion} was |linewise|
769 "char" {motion} was |characterwise|
770 "block" {motion} was |blockwise-visual||
771 Although "block" would rarely appear, since it can
772 only result from Visual mode where "g@" is not useful.
773 {not available when compiled without the +eval
774 feature}
776 Here is an example that counts the number of spaces with <F4>: >
778 nmap <silent> <F4> :set opfunc=CountSpaces<CR>g@
779 vmap <silent> <F4> :<C-U>call CountSpaces(visualmode(), 1)<CR>
781 function! CountSpaces(type, ...)
782 let sel_save = &selection
783 let &selection = "inclusive"
784 let reg_save = @@
786 if a:0 " Invoked from Visual mode, use '< and '> marks.
787 silent exe "normal! `<" . a:type . "`>y"
788 elseif a:type == 'line'
789 silent exe "normal! '[V']y"
790 elseif a:type == 'block'
791 silent exe "normal! `[\<C-V>`]y"
792 else
793 silent exe "normal! `[v`]y"
794 endif
796 echomsg strlen(substitute(@@, '[^ ]', '', 'g'))
798 let &selection = sel_save
799 let @@ = reg_save
800 endfunction
802 Note that the 'selection' option is temporarily set to "inclusive" to be able
803 to yank exactly the right text by using Visual mode from the '[ to the ']
804 mark.
806 Also note that there is a separate mapping for Visual mode. It removes the
807 "'<,'>" range that ":" inserts in Visual mode and invokes the function with
808 visualmode() and an extra argument.
810 ==============================================================================
811 2. Abbreviations *abbreviations* *Abbreviations*
813 Abbreviations are used in Insert mode, Replace mode and Command-line mode.
814 If you enter a word that is an abbreviation, it is replaced with the word it
815 stands for. This can be used to save typing for often used long words. And
816 you can use it to automatically correct obvious spelling errors.
817 Examples:
819 :iab ms Microsoft
820 :iab tihs this
822 There are three types of abbreviations:
824 full-id The "full-id" type consists entirely of keyword characters (letters
825 and characters from 'iskeyword' option). This is the most common
826 abbreviation.
828 Examples: "foo", "g3", "-1"
830 end-id The "end-id" type ends in a keyword character, but all the other
831 characters are not keyword characters.
833 Examples: "#i", "..f", "$/7"
835 non-id The "non-id" type ends in a non-keyword character, the other
836 characters may be of any type, excluding space and tab. {this type
837 is not supported by Vi}
839 Examples: "def#", "4/7$"
841 Examples of strings that cannot be abbreviations: "a.b", "#def", "a b", "_$r"
843 An abbreviation is only recognized when you type a non-keyword character.
844 This can also be the <Esc> that ends insert mode or the <CR> that ends a
845 command. The non-keyword character which ends the abbreviation is inserted
846 after the expanded abbreviation. An exception to this is the character <C-]>,
847 which is used to expand an abbreviation without inserting any extra
848 characters.
850 Example: >
851 :ab hh hello
852 < "hh<Space>" is expanded to "hello<Space>"
853 "hh<C-]>" is expanded to "hello"
855 The characters before the cursor must match the abbreviation. Each type has
856 an additional rule:
858 full-id In front of the match is a non-keyword character, or this is where
859 the line or insertion starts. Exception: When the abbreviation is
860 only one character, it is not recognized if there is a non-keyword
861 character in front of it, other than a space or a tab.
863 end-id In front of the match is a keyword character, or a space or a tab,
864 or this is where the line or insertion starts.
866 non-id In front of the match is a space, tab or the start of the line or
867 the insertion.
869 Examples: ({CURSOR} is where you type a non-keyword character) >
870 :ab foo four old otters
871 < " foo{CURSOR}" is expanded to " four old otters"
872 " foobar{CURSOR}" is not expanded
873 "barfoo{CURSOR}" is not expanded
874 >
875 :ab #i #include
876 < "#i{CURSOR}" is expanded to "#include"
877 ">#i{CURSOR}" is not expanded
878 >
879 :ab ;; <endofline>
880 < "test;;" is not expanded
881 "test ;;" is expanded to "test <endofline>"
883 To avoid the abbreviation in insert mode: Type part of the abbreviation, exit
884 insert mode with <Esc>, re-enter insert mode with "a" and type the rest. Or
885 type CTRL-V before the character after the abbreviation.
886 To avoid the abbreviation in Command-line mode: Type CTRL-V twice somewhere in
887 the abbreviation to avoid it to be replaced. A CTRL-V in front of a normal
888 character is mostly ignored otherwise.
890 It is possible to move the cursor after an abbreviation: >
891 :iab if if ()<Left>
892 This does not work if 'cpoptions' includes the '<' flag. |<>|
894 You can even do more complicated things. For example, to consume the space
895 typed after an abbreviation: >
896 func Eatchar(pat)
897 let c = nr2char(getchar(0))
898 return (c =~ a:pat) ? '' : c
899 endfunc
900 iabbr <silent> if if ()<Left><C-R>=Eatchar('\s')<CR>
902 There are no default abbreviations.
904 Abbreviations are never recursive. You can use ":ab f f-o-o" without any
905 problem. But abbreviations can be mapped. {some versions of Vi support
906 recursive abbreviations, for no apparent reason}
908 Abbreviations are disabled if the 'paste' option is on.
910 *:abbreviate-local* *:abbreviate-<buffer>*
911 Just like mappings, abbreviations can be local to a buffer. This is mostly
912 used in a |filetype-plugin| file. Example for a C plugin file: >
913 :abb <buffer> FF for (i = 0; i < ; ++i)
914 <
915 *:ab* *:abbreviate*
916 :ab[breviate] list all abbreviations. The character in the first
917 column indicates the mode where the abbreviation is
918 used: 'i' for insert mode, 'c' for Command-line
919 mode, '!' for both. These are the same as for
920 mappings, see |map-listing|.
922 *:abbreviate-verbose*
923 When 'verbose' is non-zero, listing an abbreviation will also display where it
924 was last defined. Example: >
926 :verbose abbreviate
927 ! teh the
928 Last set from /home/abcd/vim/abbr.vim
930 See |:verbose-cmd| for more information.
932 :ab[breviate] {lhs} list the abbreviations that start with {lhs}
933 You may need to insert a CTRL-V (type it twice) to
934 avoid that a typed {lhs} is expanded, since
935 command-line abbreviations apply here.
937 :ab[breviate] [<expr>] {lhs} {rhs}
938 add abbreviation for {lhs} to {rhs}. If {lhs} already
939 existed it is replaced with the new {rhs}. {rhs} may
940 contain spaces.
941 See |:map-<expr>| for the optional <expr> argument.
943 *:una* *:unabbreviate*
944 :una[bbreviate] {lhs} Remove abbreviation for {lhs} from the list. If none
945 is found, remove abbreviations in which {lhs} matches
946 with the {rhs}. This is done so that you can even
947 remove abbreviations after expansion. To avoid
948 expansion insert a CTRL-V (type it twice).
950 *:norea* *:noreabbrev*
951 :norea[bbrev] [<expr>] [lhs] [rhs]
952 same as ":ab", but no remapping for this {rhs} {not
953 in Vi}
955 *:ca* *:cabbrev*
956 :ca[bbrev] [<expr>] [lhs] [rhs]
957 same as ":ab", but for Command-line mode only. {not
958 in Vi}
960 *:cuna* *:cunabbrev*
961 :cuna[bbrev] {lhs} same as ":una", but for Command-line mode only. {not
962 in Vi}
964 *:cnorea* *:cnoreabbrev*
965 :cnorea[bbrev] [<expr>] [lhs] [rhs]
966 same as ":ab", but for Command-line mode only and no
967 remapping for this {rhs} {not in Vi}
969 *:ia* *:iabbrev*
970 :ia[bbrev] [<expr>] [lhs] [rhs]
971 same as ":ab", but for Insert mode only. {not in Vi}
973 *:iuna* *:iunabbrev*
974 :iuna[bbrev] {lhs} same as ":una", but for insert mode only. {not in
975 Vi}
977 *:inorea* *:inoreabbrev*
978 :inorea[bbrev] [<expr>] [lhs] [rhs]
979 same as ":ab", but for Insert mode only and no
980 remapping for this {rhs} {not in Vi}
982 *:abc* *:abclear*
983 :abc[lear] Remove all abbreviations. {not in Vi}
985 *:iabc* *:iabclear*
986 :iabc[lear] Remove all abbreviations for Insert mode. {not in Vi}
988 *:cabc* *:cabclear*
989 :cabc[lear] Remove all abbreviations for Command-line mode. {not
990 in Vi}
992 *using_CTRL-V*
993 It is possible to use special characters in the rhs of an abbreviation.
994 CTRL-V has to be used to avoid the special meaning of most non printable
995 characters. How many CTRL-Vs need to be typed depends on how you enter the
996 abbreviation. This also applies to mappings. Let's use an example here.
998 Suppose you want to abbreviate "esc" to enter an <Esc> character. When you
999 type the ":ab" command in Vim, you have to enter this: (here ^V is a CTRL-V
1000 and ^[ is <Esc>)
1002 You type: ab esc ^V^V^V^V^V^[
1004 All keyboard input is subjected to ^V quote interpretation, so
1005 the first, third, and fifth ^V characters simply allow the second,
1006 and fourth ^Vs, and the ^[, to be entered into the command-line.
1008 You see: ab esc ^V^V^[
1010 The command-line contains two actual ^Vs before the ^[. This is
1011 how it should appear in your .exrc file, if you choose to go that
1012 route. The first ^V is there to quote the second ^V; the :ab
1013 command uses ^V as its own quote character, so you can include quoted
1014 whitespace or the | character in the abbreviation. The :ab command
1015 doesn't do anything special with the ^[ character, so it doesn't need
1016 to be quoted. (Although quoting isn't harmful; that's why typing 7
1017 [but not 8!] ^Vs works.)
1019 Stored as: esc ^V^[
1021 After parsing, the abbreviation's short form ("esc") and long form
1022 (the two characters "^V^[") are stored in the abbreviation table.
1023 If you give the :ab command with no arguments, this is how the
1024 abbreviation will be displayed.
1026 Later, when the abbreviation is expanded because the user typed in
1027 the word "esc", the long form is subjected to the same type of
1028 ^V interpretation as keyboard input. So the ^V protects the ^[
1029 character from being interpreted as the "exit Insert mode" character.
1030 Instead, the ^[ is inserted into the text.
1032 Expands to: ^[
1034 [example given by Steve Kirkendall]
1036 ==============================================================================
1037 3. Local mappings and functions *script-local*
1039 When using several Vim script files, there is the danger that mappings and
1040 functions used in one script use the same name as in other scripts. To avoid
1041 this, they can be made local to the script.
1043 *<SID>* *<SNR>* *E81*
1044 The string "<SID>" can be used in a mapping or menu. This requires that the
1045 '<' flag is not present in 'cpoptions'.
1046 When executing the map command, Vim will replace "<SID>" with the special
1047 key code <SNR>, followed by a number that's unique for the script, and an
1048 underscore. Example: >
1049 :map <SID>Add
1050 could define a mapping "<SNR>23_Add".
1052 When defining a function in a script, "s:" can be prepended to the name to
1053 make it local to the script. But when a mapping is executed from outside of
1054 the script, it doesn't know in which script the function was defined. To
1055 avoid this problem, use "<SID>" instead of "s:". The same translation is done
1056 as for mappings. This makes it possible to define a call to the function in
1057 a mapping.
1059 When a local function is executed, it runs in the context of the script it was
1060 defined in. This means that new functions and mappings it defines can also
1061 use "s:" or "<SID>" and it will use the same unique number as when the
1062 function itself was defined. Also, the "s:var" local script variables can be
1063 used.
1065 When executing an autocommand or a user command, it will run in the context of
1066 the script it was defined in. This makes it possible that the command calls a
1067 local function or uses a local mapping.
1069 Otherwise, using "<SID>" outside of a script context is an error.
1071 If you need to get the script number to use in a complicated script, you can
1072 use this function: >
1073 function s:SID()
1074 return matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_SID$')
1075 endfun
1077 The "<SNR>" will be shown when listing functions and mappings. This is useful
1078 to find out what they are defined to.
1080 The |:scriptnames| command can be used to see which scripts have been sourced
1081 and what their <SNR> number is.
1083 This is all {not in Vi} and {not available when compiled without the +eval
1084 feature}.
1086 ==============================================================================
1087 4. User-defined commands *user-commands*
1089 It is possible to define your own Ex commands. A user-defined command can act
1090 just like a built-in command (it can have a range or arguments, arguments can
1091 be completed as filenames or buffer names, etc), except that when the command
1092 is executed, it is transformed into a normal Ex command and then executed.
1094 For starters: See section |40.2| in the user manual.
1096 *E183* *user-cmd-ambiguous*
1097 All user defined commands must start with an uppercase letter, to avoid
1098 confusion with builtin commands. (There are a few builtin commands, notably
1099 :Next, :Print and :X, which do start with an uppercase letter. The builtin
1100 will always take precedence in these cases). The other characters of the user
1101 command can be uppercase letters, lowercase letters or digits. When using
1102 digits, note that other commands that take a numeric argument may become
1103 ambiguous. For example, the command ":Cc2" could be the user command ":Cc2"
1104 without an argument, or the command ":Cc" with argument "2". It is advised to
1105 put a space between the command name and the argument to avoid these problems.
1107 When using a user-defined command, the command can be abbreviated. However, if
1108 an abbreviation is not unique, an error will be issued. Furthermore, a
1109 built-in command will always take precedence.
1111 Example: >
1112 :command Rename ...
1113 :command Renumber ...
1114 :Rena " Means "Rename"
1115 :Renu " Means "Renumber"
1116 :Ren " Error - ambiguous
1117 :command Paste ...
1118 :P " The built-in :Print
1120 It is recommended that full names for user-defined commands are used in
1121 scripts.
1123 :com[mand] *:com* *:command*
1124 List all user-defined commands. When listing commands,
1125 the characters in the first two columns are
1126 ! Command has the -bang attribute
1127 " Command has the -register attribute
1128 b Command is local to current buffer
1129 (see below for details on attributes)
1131 :com[mand] {cmd} List the user-defined commands that start with {cmd}
1133 *:command-verbose*
1134 When 'verbose' is non-zero, listing a command will also display where it was
1135 last defined. Example: >
1137 :verbose command TOhtml
1138 < Name Args Range Complete Definition ~
1139 TOhtml 0 % :call Convert2HTML(<line1>, <line2>) ~
1140 Last set from /usr/share/vim/vim-7.0/plugin/tohtml.vim ~
1142 See |:verbose-cmd| for more information.
1144 *E174* *E182*
1145 :com[mand][!] [{attr}...] {cmd} {rep}
1146 Define a user command. The name of the command is
1147 {cmd} and its replacement text is {rep}. The command's
1148 attributes (see below) are {attr}. If the command
1149 already exists, an error is reported, unless a ! is
1150 specified, in which case the command is redefined.
1152 :delc[ommand] {cmd} *:delc* *:delcommand* *E184*
1153 Delete the user-defined command {cmd}.
1155 :comc[lear] *:comc* *:comclear*
1156 Delete all user-defined commands.
1158 Command attributes
1160 User-defined commands are treated by Vim just like any other Ex commands. They
1161 can have arguments, or have a range specified. Arguments are subject to
1162 completion as filenames, buffers, etc. Exactly how this works depends upon the
1163 command's attributes, which are specified when the command is defined.
1165 There are a number of attributes, split into four categories: argument
1166 handling, completion behavior, range handling, and special cases. The
1167 attributes are described below, by category.
1169 Argument handling *E175* *E176* *:command-nargs*
1171 By default, a user defined command will take no arguments (and an error is
1172 reported if any are supplied). However, it is possible to specify that the
1173 command can take arguments, using the -nargs attribute. Valid cases are:
1175 -nargs=0 No arguments are allowed (the default)
1176 -nargs=1 Exactly one argument is required
1177 -nargs=* Any number of arguments are allowed (0, 1, or many)
1178 -nargs=? 0 or 1 arguments are allowed
1179 -nargs=+ Arguments must be supplied, but any number are allowed
1181 Arguments are considered to be separated by (unescaped) spaces or tabs in this
1182 context.
1184 Note that arguments are used as text, not as expressions. Specifically,
1185 "s:var" will use the script-local variable in the script where the command was
1186 defined, not where it is invoked! Example:
1187 script1.vim: >
1188 :let s:error = "None"
1189 :command -nargs=1 Error echoerr <args>
1190 < script2.vim: >
1191 :source script1.vim
1192 :let s:error = "Wrong!"
1193 :Error s:error
1194 Executing script2.vim will result in "None" being echoed. Not what you
1195 intended! Calling a function may be an alternative.
1197 Completion behavior *:command-completion* *E179*
1198 *E180* *E181* *:command-complete*
1199 By default, the arguments of user defined commands do not undergo completion.
1200 However, by specifying one or the other of the following attributes, argument
1201 completion can be enabled:
1203 -complete=augroup autocmd groups
1204 -complete=buffer buffer names
1205 -complete=command Ex command (and arguments)
1206 -complete=dir directory names
1207 -complete=environment environment variable names
1208 -complete=event autocommand events
1209 -complete=expression Vim expression
1210 -complete=file file and directory names
1211 -complete=shellcmd Shell command
1212 -complete=function function name
1213 -complete=help help subjects
1214 -complete=highlight highlight groups
1215 -complete=mapping mapping name
1216 -complete=menu menus
1217 -complete=option options
1218 -complete=tag tags
1219 -complete=tag_listfiles tags, file names are shown when CTRL-D is hit
1220 -complete=var user variables
1221 -complete=custom,{func} custom completion, defined via {func}
1222 -complete=customlist,{func} custom completion, defined via {func}
1225 Custom completion *:command-completion-custom*
1226 *:command-completion-customlist*
1227 *E467* *E468*
1228 It is possible to define customized completion schemes via the "custom,{func}"
1229 or the "customlist,{func}" completion argument. The {func} part should be a
1230 function with the following signature: >
1232 :function {func}(ArgLead, CmdLine, CursorPos)
1234 The function need not use all these arguments. The function should provide the
1235 completion candidates as the return value.
1237 For the "custom" argument, the function should return the completion
1238 candidates one per line in a newline separated string.
1240 For the "customlist" argument, the function should return the completion
1241 candidates as a Vim List. Non-string items in the list are ignored.
1243 The function arguments are:
1244 ArgLead the leading portion of the argument currently being
1245 completed on
1246 CmdLine the entire command line
1247 CursorPos the cursor position in it (byte index)
1248 The function may use these for determining context. For the "custom"
1249 argument, it is not necessary to filter candidates against the (implicit
1250 pattern in) ArgLead. Vim will filter the candidates with its regexp engine
1251 after function return, and this is probably more efficient in most cases. For
1252 the "customlist" argument, Vim will not filter the returned completion
1253 candidates and the user supplied function should filter the candidates.
1255 The following example lists user names to a Finger command >
1256 :com -complete=custom,ListUsers -nargs=1 Finger !finger <args>
1257 :fun ListUsers(A,L,P)
1258 : return system("cut -d: -f1 /etc/passwd")
1259 :endfun
1261 The following example completes filenames from the directories specified in
1262 the 'path' option: >
1263 :com -nargs=1 -bang -complete=customlist,EditFileComplete
1264 \ EditFile edit<bang> <args>
1265 :fun EditFileComplete(A,L,P)
1266 : return split(globpath(&path, a:A), "\n")
1267 :endfun
1268 <
1270 Range handling *E177* *E178* *:command-range*
1271 *:command-count*
1272 By default, user-defined commands do not accept a line number range. However,
1273 it is possible to specify that the command does take a range (the -range
1274 attribute), or that it takes an arbitrary count value, either in the line
1275 number position (-range=N, like the |:split| command) or as a "count"
1276 argument (-count=N, like the |:Next| command). The count will then be
1277 available in the argument with |<count>|.
1279 Possible attributes are:
1281 -range Range allowed, default is current line
1282 -range=% Range allowed, default is whole file (1,$)
1283 -range=N A count (default N) which is specified in the line
1284 number position (like |:split|)
1285 -count=N A count (default N) which is specified either in the line
1286 number position, or as an initial argument (like |:Next|).
1287 Specifying -count (without a default) acts like -count=0
1289 Note that -range=N and -count=N are mutually exclusive - only one should be
1290 specified.
1292 Special cases *:command-bang* *:command-bar*
1293 *:command-register* *:command-buffer*
1294 There are some special cases as well:
1296 -bang The command can take a ! modifier (like :q or :w)
1297 -bar The command can be followed by a "|" and another command.
1298 A "|" inside the command argument is not allowed then.
1299 Also checks for a " to start a comment.
1300 -register The first argument to the command can be an optional
1301 register name (like :del, :put, :yank).
1302 -buffer The command will only be available in the current buffer.
1304 In the cases of the -count and -register attributes, if the optional argument
1305 is supplied, it is removed from the argument list and is available to the
1306 replacement text separately.
1308 Replacement text
1310 The replacement text for a user defined command is scanned for special escape
1311 sequences, using <...> notation. Escape sequences are replaced with values
1312 from the entered command line, and all other text is copied unchanged. The
1313 resulting string is executed as an Ex command. To avoid the replacement use
1314 <lt> in place of the initial <. Thus to include "<bang>" literally use
1315 "<lt>bang>".
1317 The valid escape sequences are
1319 *<line1>*
1320 <line1> The starting line of the command range.
1321 *<line2>*
1322 <line2> The final line of the command range.
1323 *<count>*
1324 <count> Any count supplied (as described for the '-range'
1325 and '-count' attributes).
1326 *<bang>*
1327 <bang> (See the '-bang' attribute) Expands to a ! if the
1328 command was executed with a ! modifier, otherwise
1329 expands to nothing.
1330 *<reg>* *<register>*
1331 <reg> (See the '-register' attribute) The optional register,
1332 if specified. Otherwise, expands to nothing. <register>
1333 is a synonym for this.
1334 *<args>*
1335 <args> The command arguments, exactly as supplied (but as
1336 noted above, any count or register can consume some
1337 of the arguments, which are then not part of <args>).
1338 <lt> A single '<' (Less-Than) character. This is needed if you
1339 want to get a literal copy of one of these escape sequences
1340 into the expansion - for example, to get <bang>, use
1341 <lt>bang>.
1343 *<q-args>*
1344 If the first two characters of an escape sequence are "q-" (for example,
1345 <q-args>) then the value is quoted in such a way as to make it a valid value
1346 for use in an expression. This uses the argument as one single value.
1347 When there is no argument <q-args> is an empty string.
1348 *<f-args>*
1349 To allow commands to pass their arguments on to a user-defined function, there
1350 is a special form <f-args> ("function args"). This splits the command
1351 arguments at spaces and tabs, quotes each argument individually, and the
1352 <f-args> sequence is replaced by the comma-separated list of quoted arguments.
1353 See the Mycmd example below. If no arguments are given <f-args> is removed.
1354 To embed whitespace into an argument of <f-args>, prepend a backslash.
1355 <f-args> replaces every pair of backslashes (\\) with one backslash. A
1356 backslash followed by a character other than white space or a backslash
1357 remains unmodified. Overview:
1359 command <f-args> ~
1360 XX ab 'ab'
1361 XX a\b 'a\b'
1362 XX a\ b 'a b'
1363 XX a\ b 'a ', 'b'
1364 XX a\\b 'a\b'
1365 XX a\\ b 'a\', 'b'
1366 XX a\\\b 'a\\b'
1367 XX a\\\ b 'a\ b'
1368 XX a\\\\b 'a\\b'
1369 XX a\\\\ b 'a\\', 'b'
1371 Examples >
1373 " Delete everything after here to the end
1374 :com Ddel +,$d
1376 " Rename the current buffer
1377 :com -nargs=1 -bang -complete=file Ren f <args>|w<bang>
1379 " Replace a range with the contents of a file
1380 " (Enter this all as one line)
1381 :com -range -nargs=1 -complete=file
1382 Replace <line1>-pu_|<line1>,<line2>d|r <args>|<line1>d
1384 " Count the number of lines in the range
1385 :com! -range -nargs=0 Lines echo <line2> - <line1> + 1 "lines"
1387 " Call a user function (example of <f-args>)
1388 :com -nargs=* Mycmd call Myfunc(<f-args>)
1390 When executed as: >
1391 :Mycmd arg1 arg2
1392 This will invoke: >
1393 :call Myfunc("arg1","arg2")
1395 :" A more substantial example
1396 :function Allargs(command)
1397 : let i = 0
1398 : while i < argc()
1399 : if filereadable(argv(i))
1400 : execute "e " . argv(i)
1401 : execute a:command
1402 : endif
1403 : let i = i + 1
1404 : endwhile
1405 :endfunction
1406 :command -nargs=+ -complete=command Allargs call Allargs(<q-args>)
1408 The command Allargs takes any Vim command(s) as argument and executes it on all
1409 files in the argument list. Usage example (note use of the "e" flag to ignore
1410 errors and the "update" command to write modified buffers): >
1411 :Allargs %s/foo/bar/ge|update
1412 This will invoke: >
1413 :call Allargs("%s/foo/bar/ge|update")
1414 <
1415 When defining a user command in a script, it will be able to call functions
1416 local to the script and use mappings local to the script. When the user
1417 invokes the user command, it will run in the context of the script it was
1418 defined in. This matters if |<SID>| is used in a command.
1420 vim:tw=78:ts=8:ft=help:norl: