1*map.txt* For Vim version 8.1. Last change: 2018 Dec 18 2 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| 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| 242. 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 of commands for a function key. Example: > 33 34 :map <F2> a<C-R>=strftime("%c")<CR><Esc> 35 36This appends the current date and time after the cursor (in <> notation |<>|). 37 38 391.1 MAP COMMANDS *:map-commands* 40 41There 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 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:tma[p] {lhs} {rhs} |mapmode-t| *:tma* *:tmap* 59 Map the key sequence {lhs} to {rhs} for the modes 60 where the map command applies. The result, including 61 {rhs}, is then further scanned for mappings. This 62 allows for nested and recursive use of mappings. 63 64 *:nore* *:norem* 65:no[remap] {lhs} {rhs} |mapmode-nvo| *:no* *:noremap* *:nor* 66:nn[oremap] {lhs} {rhs} |mapmode-n| *:nn* *:nnoremap* 67:vn[oremap] {lhs} {rhs} |mapmode-v| *:vn* *:vnoremap* 68:xn[oremap] {lhs} {rhs} |mapmode-x| *:xn* *:xnoremap* 69:snor[emap] {lhs} {rhs} |mapmode-s| *:snor* *:snoremap* 70:ono[remap] {lhs} {rhs} |mapmode-o| *:ono* *:onoremap* 71:no[remap]! {lhs} {rhs} |mapmode-ic| *:no!* *:noremap!* 72:ino[remap] {lhs} {rhs} |mapmode-i| *:ino* *:inoremap* 73:ln[oremap] {lhs} {rhs} |mapmode-l| *:ln* *:lnoremap* 74:cno[remap] {lhs} {rhs} |mapmode-c| *:cno* *:cnoremap* 75:tno[remap] {lhs} {rhs} |mapmode-t| *:tno* *:tnoremap* 76 Map the key sequence {lhs} to {rhs} for the modes 77 where the map command applies. Disallow mapping of 78 {rhs}, to avoid nested and recursive mappings. Often 79 used to redefine a command. {not in Vi} 80 81 82:unm[ap] {lhs} |mapmode-nvo| *:unm* *:unmap* 83:nun[map] {lhs} |mapmode-n| *:nun* *:nunmap* 84:vu[nmap] {lhs} |mapmode-v| *:vu* *:vunmap* 85:xu[nmap] {lhs} |mapmode-x| *:xu* *:xunmap* 86:sunm[ap] {lhs} |mapmode-s| *:sunm* *:sunmap* 87:ou[nmap] {lhs} |mapmode-o| *:ou* *:ounmap* 88:unm[ap]! {lhs} |mapmode-ic| *:unm!* *:unmap!* 89:iu[nmap] {lhs} |mapmode-i| *:iu* *:iunmap* 90:lu[nmap] {lhs} |mapmode-l| *:lu* *:lunmap* 91:cu[nmap] {lhs} |mapmode-c| *:cu* *:cunmap* 92:tunma[p] {lhs} |mapmode-t| *:tunma* *:tunmap* 93 Remove the mapping of {lhs} for the modes where the 94 map command applies. The mapping may remain defined 95 for other modes where it applies. 96 Note: Trailing spaces are included in the {lhs}. This 97 unmap does NOT work: > 98 :map @@ foo 99 :unmap @@ | print 100 101:mapc[lear] |mapmode-nvo| *:mapc* *:mapclear* 102:nmapc[lear] |mapmode-n| *:nmapc* *:nmapclear* 103:vmapc[lear] |mapmode-v| *:vmapc* *:vmapclear* 104:xmapc[lear] |mapmode-x| *:xmapc* *:xmapclear* 105:smapc[lear] |mapmode-s| *:smapc* *:smapclear* 106:omapc[lear] |mapmode-o| *:omapc* *:omapclear* 107:mapc[lear]! |mapmode-ic| *:mapc!* *:mapclear!* 108:imapc[lear] |mapmode-i| *:imapc* *:imapclear* 109:lmapc[lear] |mapmode-l| *:lmapc* *:lmapclear* 110:cmapc[lear] |mapmode-c| *:cmapc* *:cmapclear* 111:tmapc[lear] |mapmode-t| *:tmapc* *:tmapclear* 112 Remove ALL mappings for the modes where the map 113 command applies. {not in Vi} 114 Use the <buffer> argument to remove buffer-local 115 mappings |:map-<buffer>| 116 Warning: This also removes the default mappings. 117 118:map |mapmode-nvo| 119:nm[ap] |mapmode-n| 120:vm[ap] |mapmode-v| 121:xm[ap] |mapmode-x| 122:sm[ap] |mapmode-s| 123:om[ap] |mapmode-o| 124:map! |mapmode-ic| 125:im[ap] |mapmode-i| 126:lm[ap] |mapmode-l| 127:cm[ap] |mapmode-c| 128:tma[p] |mapmode-t| 129 List all key mappings for the modes where the map 130 command applies. Note that ":map" and ":map!" are 131 used most often, because they include the other modes. 132 133:map {lhs} |mapmode-nvo| *:map_l* 134:nm[ap] {lhs} |mapmode-n| *:nmap_l* 135:vm[ap] {lhs} |mapmode-v| *:vmap_l* 136:xm[ap] {lhs} |mapmode-x| *:xmap_l* 137:sm[ap] {lhs} |mapmode-s| *:smap_l* 138:om[ap] {lhs} |mapmode-o| *:omap_l* 139:map! {lhs} |mapmode-ic| *:map_l!* 140:im[ap] {lhs} |mapmode-i| *:imap_l* 141:lm[ap] {lhs} |mapmode-l| *:lmap_l* 142:cm[ap] {lhs} |mapmode-c| *:cmap_l* 143:tma[p] {lhs} |mapmode-t| *:tmap_l* 144 List the key mappings for the key sequences starting 145 with {lhs} in the modes where the map command applies. 146 {not in Vi} 147 148These commands are used to map a key or key sequence to a string of 149characters. You can use this to put command sequences under function keys, 150translate one key into another, etc. See |:mkexrc| for how to save and 151restore the current mappings. 152 153 *map-ambiguous* 154When two mappings start with the same sequence of characters, they are 155ambiguous. Example: > 156 :imap aa foo 157 :imap aaa bar 158When Vim has read "aa", it will need to get another character to be able to 159decide if "aa" or "aaa" should be mapped. This means that after typing "aa" 160that mapping won't get expanded yet, Vim is waiting for another character. 161If you type a space, then "foo" will get inserted, plus the space. If you 162type "a", then "bar" will get inserted. 163{Vi does not allow ambiguous mappings} 164 165 1661.2 SPECIAL ARGUMENTS *:map-arguments* 167 168"<buffer>", "<nowait>", "<silent>", "<special>", "<script>", "<expr>" and 169"<unique>" can be used in any order. They must appear right after the 170command, before any other arguments. 171 172 *:map-local* *:map-<buffer>* *E224* *E225* 173If the first argument to one of these commands is "<buffer>" the mapping will 174be effective in the current buffer only. Example: > 175 :map <buffer> ,w /[.,;]<CR> 176Then you can map ",w" to something else in another buffer: > 177 :map <buffer> ,w /[#&!]<CR> 178The local buffer mappings are used before the global ones. See <nowait> below 179to make a short local mapping not taking effect when a longer global one 180exists. 181The "<buffer>" argument can also be used to clear mappings: > 182 :unmap <buffer> ,w 183 :mapclear <buffer> 184Local mappings are also cleared when a buffer is deleted, but not when it is 185unloaded. Just like local option values. 186Also see |map-precedence|. 187 188 *:map-<nowait>* *:map-nowait* 189When defining a buffer-local mapping for "," there may be a global mapping 190that starts with ",". Then you need to type another character for Vim to know 191whether to use the "," mapping or the longer one. To avoid this add the 192<nowait> argument. Then the mapping will be used when it matches, Vim does 193not wait for more characters to be typed. However, if the characters were 194already typed they are used. 195 196 *:map-<silent>* *:map-silent* 197To define a mapping which will not be echoed on the command line, add 198"<silent>" as the first argument. Example: > 199 :map <silent> ,h /Header<CR> 200The search string will not be echoed when using this mapping. Messages from 201the executed command are still given though. To shut them up too, add a 202":silent" in the executed command: > 203 :map <silent> ,h :exe ":silent normal /Header\r"<CR> 204Prompts will still be given, e.g., for inputdialog(). 205Using "<silent>" for an abbreviation is possible, but will cause redrawing of 206the command line to fail. 207 208 *:map-<special>* *:map-special* 209Define a mapping with <> notation for special keys, even though the "<" flag 210may appear in 'cpoptions'. This is useful if the side effect of setting 211'cpoptions' is not desired. Example: > 212 :map <special> <F12> /Header<CR> 213< 214 *:map-<script>* *:map-script* 215If the first argument to one of these commands is "<script>" and it is used to 216define a new mapping or abbreviation, the mapping will only remap characters 217in the {rhs} using mappings that were defined local to a script, starting with 218"<SID>". This can be used to avoid that mappings from outside a script 219interfere (e.g., when CTRL-V is remapped in mswin.vim), but do use other 220mappings defined in the script. 221Note: ":map <script>" and ":noremap <script>" do the same thing. The 222"<script>" overrules the command name. Using ":noremap <script>" is 223preferred, because it's clearer that remapping is (mostly) disabled. 224 225 *:map-<unique>* *E226* *E227* 226If the first argument to one of these commands is "<unique>" and it is used to 227define a new mapping or abbreviation, the command will fail if the mapping or 228abbreviation already exists. Example: > 229 :map <unique> ,w /[#&!]<CR> 230When defining a local mapping, there will also be a check if a global map 231already exists which is equal. 232Example of what will fail: > 233 :map ,w /[#&!]<CR> 234 :map <buffer> <unique> ,w /[.,;]<CR> 235If you want to map a key and then have it do what it was originally mapped to, 236have a look at |maparg()|. 237 238 *:map-<expr>* *:map-expression* 239If the first argument to one of these commands is "<expr>" and it is used to 240define a new mapping or abbreviation, the argument is an expression. The 241expression is evaluated to obtain the {rhs} that is used. Example: > 242 :inoremap <expr> . InsertDot() 243The result of the InsertDot() function will be inserted. It could check the 244text before the cursor and start omni completion when some condition is met. 245 246For abbreviations |v:char| is set to the character that was typed to trigger 247the abbreviation. You can use this to decide how to expand the {lhs}. You 248should not either insert or change the v:char. 249 250Be very careful about side effects! The expression is evaluated while 251obtaining characters, you may very well make the command dysfunctional. 252For this reason the following is blocked: 253- Changing the buffer text |textlock|. 254- Editing another buffer. 255- The |:normal| command. 256- Moving the cursor is allowed, but it is restored afterwards. 257If you want the mapping to do any of these let the returned characters do 258that. 259 260You can use getchar(), it consumes typeahead if there is any. E.g., if you 261have these mappings: > 262 inoremap <expr> <C-L> nr2char(getchar()) 263 inoremap <expr> <C-L>x "foo" 264If you now type CTRL-L nothing happens yet, Vim needs the next character to 265decide what mapping to use. If you type 'x' the second mapping is used and 266"foo" is inserted. If you type any other key the first mapping is used, 267getchar() gets the typed key and returns it. 268 269Here is an example that inserts a list number that increases: > 270 let counter = 0 271 inoremap <expr> <C-L> ListItem() 272 inoremap <expr> <C-R> ListReset() 273 274 func ListItem() 275 let g:counter += 1 276 return g:counter . '. ' 277 endfunc 278 279 func ListReset() 280 let g:counter = 0 281 return '' 282 endfunc 283 284CTRL-L inserts the next number, CTRL-R resets the count. CTRL-R returns an 285empty string, so that nothing is inserted. 286 287Note that there are some tricks to make special keys work and escape CSI bytes 288in the text. The |:map| command also does this, thus you must avoid that it 289is done twice. This does not work: > 290 :imap <expr> <F3> "<Char-0x611B>" 291Because the <Char- sequence is escaped for being a |:imap| argument and then 292again for using <expr>. This does work: > 293 :imap <expr> <F3> "\u611B" 294Using 0x80 as a single byte before other text does not work, it will be seen 295as a special key. 296 297 2981.3 MAPPING AND MODES *:map-modes* 299 *mapmode-nvo* *mapmode-n* *mapmode-v* *mapmode-o* 300 301There are six sets of mappings 302- For Normal mode: When typing commands. 303- For Visual mode: When typing commands while the Visual area is highlighted. 304- For Select mode: like Visual mode but typing text replaces the selection. 305- For Operator-pending mode: When an operator is pending (after "d", "y", "c", 306 etc.). See below: |omap-info|. 307- For Insert mode. These are also used in Replace mode. 308- For Command-line mode: When entering a ":" or "/" command. 309 310Special case: While typing a count for a command in Normal mode, mapping zero 311is disabled. This makes it possible to map zero without making it impossible 312to type a count with a zero. 313 314 *map-overview* *map-modes* 315Overview of which map command works in which mode. More details below. 316 COMMANDS MODES ~ 317:map :noremap :unmap Normal, Visual, Select, Operator-pending 318:nmap :nnoremap :nunmap Normal 319:vmap :vnoremap :vunmap Visual and Select 320:smap :snoremap :sunmap Select 321:xmap :xnoremap :xunmap Visual 322:omap :onoremap :ounmap Operator-pending 323:map! :noremap! :unmap! Insert and Command-line 324:imap :inoremap :iunmap Insert 325:lmap :lnoremap :lunmap Insert, Command-line, Lang-Arg 326:cmap :cnoremap :cunmap Command-line 327:tmap :tnoremap :tunmap Terminal-Job 328 329 330 COMMANDS MODES ~ 331 Normal Visual+Select Operator-pending ~ 332:map :noremap :unmap :mapclear yes yes yes 333:nmap :nnoremap :nunmap :nmapclear yes - - 334:vmap :vnoremap :vunmap :vmapclear - yes - 335:omap :onoremap :ounmap :omapclear - - yes 336 337:nunmap can also be used outside of a monastery. 338 *mapmode-x* *mapmode-s* 339Some commands work both in Visual and Select mode, some in only one. Note 340that quite often "Visual" is mentioned where both Visual and Select mode 341apply. |Select-mode-mapping| 342NOTE: Mapping a printable character in Select mode may confuse the user. It's 343better to explicitly use :xmap and :smap for printable characters. Or use 344:sunmap after defining the mapping. 345 346 COMMANDS MODES ~ 347 Visual Select ~ 348:vmap :vnoremap :vunmap :vmapclear yes yes 349:xmap :xnoremap :xunmap :xmapclear yes - 350:smap :snoremap :sunmap :smapclear - yes 351 352 *mapmode-ic* *mapmode-i* *mapmode-c* *mapmode-l* 353Some commands work both in Insert mode and Command-line mode, some not: 354 355 COMMANDS MODES ~ 356 Insert Command-line Lang-Arg ~ 357:map! :noremap! :unmap! :mapclear! yes yes - 358:imap :inoremap :iunmap :imapclear yes - - 359:cmap :cnoremap :cunmap :cmapclear - yes - 360:lmap :lnoremap :lunmap :lmapclear yes* yes* yes* 361 362The original Vi did not have separate mappings for 363Normal/Visual/Operator-pending mode and for Insert/Command-line mode. 364Therefore the ":map" and ":map!" commands enter and display mappings for 365several modes. In Vim you can use the ":nmap", ":vmap", ":omap", ":cmap" and 366":imap" commands to enter mappings for each mode separately. 367 368 *mapmode-t* 369The terminal mappings are used in a terminal window, when typing keys for the 370job running in the terminal. See |terminal-typing|. 371 372 *omap-info* 373Operator-pending mappings can be used to define a movement command that can be 374used with any operator. Simple example: > 375 :omap { w 376makes "y{" work like "yw" and "d{" like "dw". 377 378To ignore the starting cursor position and select different text, you can have 379the omap start Visual mode to select the text to be operated upon. Example 380that operates on a function name in the current line: > 381 onoremap <silent> F :<C-U>normal! 0f(hviw<CR> 382The CTRL-U (<C-U>) is used to remove the range that Vim may insert. The 383Normal mode commands find the first '(' character and select the first word 384before it. That usually is the function name. 385 386To enter a mapping for Normal and Visual mode, but not Operator-pending mode, 387first define it for all three modes, then unmap it for 388Operator-pending mode: > 389 :map xx something-difficult 390 :ounmap xx 391 392Likewise for a mapping for Visual and Operator-pending mode or Normal and 393Operator-pending mode. 394 395 *language-mapping* 396":lmap" defines a mapping that applies to: 397- Insert mode 398- Command-line mode 399- when entering a search pattern 400- the argument of the commands that accept a text character, such as "r" and 401 "f" 402- for the input() line 403Generally: Whenever a character is to be typed that is part of the text in the 404buffer, not a Vim command character. "Lang-Arg" isn't really another mode, 405it's just used here for this situation. 406 The simplest way to load a set of related language mappings is by using the 407'keymap' option. See |45.5|. 408 In Insert mode and in Command-line mode the mappings can be disabled with 409the CTRL-^ command |i_CTRL-^| |c_CTRL-^|. These commands change the value of 410the 'iminsert' option. When starting to enter a normal command line (not a 411search pattern) the mappings are disabled until a CTRL-^ is typed. The state 412last used is remembered for Insert mode and Search patterns separately. The 413state for Insert mode is also used when typing a character as an argument to 414command like "f" or "t". 415 Language mappings will never be applied to already mapped characters. They 416are only used for typed characters. This assumes that the language mapping 417was already done when typing the mapping. 418 419 4201.4 LISTING MAPPINGS *map-listing* 421 422When listing mappings the characters in the first two columns are: 423 424 CHAR MODE ~ 425 <Space> Normal, Visual, Select and Operator-pending 426 n Normal 427 v Visual and Select 428 s Select 429 x Visual 430 o Operator-pending 431 ! Insert and Command-line 432 i Insert 433 l ":lmap" mappings for Insert, Command-line and Lang-Arg 434 c Command-line 435 t Terminal-Job 436 437Just before the {rhs} a special character can appear: 438 * indicates that it is not remappable 439 & indicates that only script-local mappings are remappable 440 @ indicates a buffer-local mapping 441 442Everything from the first non-blank after {lhs} up to the end of the line 443(or '|') is considered to be part of {rhs}. This allows the {rhs} to end 444with a space. 445 446Note: When using mappings for Visual mode, you can use the "'<" mark, which 447is the start of the last selected Visual area in the current buffer |'<|. 448 449The |:filter| command can be used to select what mappings to list. The 450pattern is matched against the {lhs} and {rhs} in the raw form. 451 452 *:map-verbose* 453When 'verbose' is non-zero, listing a key map will also display where it was 454last defined. Example: > 455 456 :verbose map <C-W>* 457 n <C-W>* * <C-W><C-S>* 458 Last set from /home/abcd/.vimrc 459 460See |:verbose-cmd| for more information. 461 462 4631.5 MAPPING SPECIAL KEYS *:map-special-keys* 464 465There are three ways to map a special key: 4661. The Vi-compatible method: Map the key code. Often this is a sequence that 467 starts with <Esc>. To enter a mapping like this you type ":map " and then 468 you have to type CTRL-V before hitting the function key. Note that when 469 the key code for the key is in the termcap (the t_ options), it will 470 automatically be translated into the internal code and become the second 471 way of mapping (unless the 'k' flag is included in 'cpoptions'). 4722. The second method is to use the internal code for the function key. To 473 enter such a mapping type CTRL-K and then hit the function key, or use 474 the form "#1", "#2", .. "#9", "#0", "<Up>", "<S-Down>", "<S-F7>", etc. 475 (see table of keys |key-notation|, all keys from <Up> can be used). The 476 first ten function keys can be defined in two ways: Just the number, like 477 "#2", and with "<F>", like "<F2>". Both stand for function key 2. "#0" 478 refers to function key 10, defined with option 't_f10', which may be 479 function key zero on some keyboards. The <> form cannot be used when 480 'cpoptions' includes the '<' flag. 4813. Use the termcap entry, with the form <t_xx>, where "xx" is the name of the 482 termcap entry. Any string entry can be used. For example: > 483 :map <t_F3> G 484< Maps function key 13 to "G". This does not work if 'cpoptions' includes 485 the '<' flag. 486 487The advantage of the second and third method is that the mapping will work on 488different terminals without modification (the function key will be 489translated into the same internal code or the actual key code, no matter what 490terminal you are using. The termcap must be correct for this to work, and you 491must use the same mappings). 492 493DETAIL: Vim first checks if a sequence from the keyboard is mapped. If it 494isn't the terminal key codes are tried (see |terminal-options|). If a 495terminal code is found it is replaced with the internal code. Then the check 496for a mapping is done again (so you can map an internal code to something 497else). What is written into the script file depends on what is recognized. 498If the terminal key code was recognized as a mapping the key code itself is 499written to the script file. If it was recognized as a terminal code the 500internal code is written to the script file. 501 502 5031.6 SPECIAL CHARACTERS *:map-special-chars* 504 *map_backslash* *map-backslash* 505Note that only CTRL-V is mentioned here as a special character for mappings 506and abbreviations. When 'cpoptions' does not contain 'B', a backslash can 507also be used like CTRL-V. The <> notation can be fully used then |<>|. But 508you cannot use "<C-V>" like CTRL-V to escape the special meaning of what 509follows. 510 511To map a backslash, or use a backslash literally in the {rhs}, the special 512sequence "<Bslash>" can be used. This avoids the need to double backslashes 513when using nested mappings. 514 515 *map_CTRL-C* *map-CTRL-C* 516Using CTRL-C in the {lhs} is possible, but it will only work when Vim is 517waiting for a key, not when Vim is busy with something. When Vim is busy 518CTRL-C interrupts/breaks the command. 519When using the GUI version on MS-Windows CTRL-C can be mapped to allow a Copy 520command to the clipboard. Use CTRL-Break to interrupt Vim. 521 522 *map_space_in_lhs* *map-space_in_lhs* 523To include a space in {lhs} precede it with a CTRL-V (type two CTRL-Vs for 524each space). 525 *map_space_in_rhs* *map-space_in_rhs* 526If you want a {rhs} that starts with a space, use "<Space>". To be fully Vi 527compatible (but unreadable) don't use the |<>| notation, precede {rhs} with a 528single CTRL-V (you have to type CTRL-V two times). 529 *map_empty_rhs* *map-empty-rhs* 530You can create an empty {rhs} by typing nothing after a single CTRL-V (you 531have to type CTRL-V two times). Unfortunately, you cannot do this in a vimrc 532file. 533 *<Nop>* 534An easier way to get a mapping that doesn't produce anything, is to use 535"<Nop>" for the {rhs}. This only works when the |<>| notation is enabled. 536For example, to make sure that function key 8 does nothing at all: > 537 :map <F8> <Nop> 538 :map! <F8> <Nop> 539< 540 *map-multibyte* 541It is possible to map multibyte characters, but only the whole character. You 542cannot map the first byte only. This was done to prevent problems in this 543scenario: > 544 :set encoding=latin1 545 :imap <M-C> foo 546 :set encoding=utf-8 547The mapping for <M-C> is defined with the latin1 encoding, resulting in a 0xc3 548byte. If you type the character á (0xe1 <M-a>) in UTF-8 encoding this is the 549two bytes 0xc3 0xa1. You don't want the 0xc3 byte to be mapped then or 550otherwise it would be impossible to type the á character. 551 552 *<Leader>* *mapleader* 553To define a mapping which uses the "mapleader" variable, the special string 554"<Leader>" can be used. It is replaced with the string value of "mapleader". 555If "mapleader" is not set or empty, a backslash is used instead. Example: > 556 :map <Leader>A oanother line<Esc> 557Works like: > 558 :map \A oanother line<Esc> 559But after: > 560 :let mapleader = "," 561It works like: > 562 :map ,A oanother line<Esc> 563 564Note that the value of "mapleader" is used at the moment the mapping is 565defined. Changing "mapleader" after that has no effect for already defined 566mappings. 567 568 *<LocalLeader>* *maplocalleader* 569<LocalLeader> is just like <Leader>, except that it uses "maplocalleader" 570instead of "mapleader". <LocalLeader> is to be used for mappings which are 571local to a buffer. Example: > 572 :map <buffer> <LocalLeader>A oanother line<Esc> 573< 574In a global plugin <Leader> should be used and in a filetype plugin 575<LocalLeader>. "mapleader" and "maplocalleader" can be equal. Although, if 576you make them different, there is a smaller chance of mappings from global 577plugins to clash with mappings for filetype plugins. For example, you could 578keep "mapleader" at the default backslash, and set "maplocalleader" to an 579underscore. 580 581 *map-<SID>* 582In a script the special key name "<SID>" can be used to define a mapping 583that's local to the script. See |<SID>| for details. 584 585 *<Plug>* 586The special key name "<Plug>" can be used for an internal mapping, which is 587not to be matched with any key sequence. This is useful in plugins 588|using-<Plug>|. 589 590 *<Char>* *<Char->* 591To map a character by its decimal, octal or hexadecimal number the <Char> 592construct can be used: 593 <Char-123> character 123 594 <Char-033> character 27 595 <Char-0x7f> character 127 596 <S-Char-114> character 114 ('r') shifted ('R') 597This is useful to specify a (multi-byte) character in a 'keymap' file. 598Upper and lowercase differences are ignored. 599 600 *map-comments* 601It is not possible to put a comment after these commands, because the '"' 602character is considered to be part of the {lhs} or {rhs}. However, one can 603use |", since this starts a new, empty command with a comment. 604 605 *map_bar* *map-bar* 606Since the '|' character is used to separate a map command from the next 607command, you will have to do something special to include a '|' in {rhs}. 608There are three methods: 609 use works when example ~ 610 <Bar> '<' is not in 'cpoptions' :map _l :!ls <Bar> more^M 611 \| 'b' is not in 'cpoptions' :map _l :!ls \| more^M 612 ^V| always, in Vim and Vi :map _l :!ls ^V| more^M 613 614(here ^V stands for CTRL-V; to get one CTRL-V you have to type it twice; you 615cannot use the <> notation "<C-V>" here). 616 617All three work when you use the default setting for 'cpoptions'. 618 619When 'b' is present in 'cpoptions', "\|" will be recognized as a mapping 620ending in a '\' and then another command. This is Vi compatible, but 621illogical when compared to other commands. 622 623 *map_return* *map-return* 624When you have a mapping that contains an Ex command, you need to put a line 625terminator after it to have it executed. The use of <CR> is recommended for 626this (see |<>|). Example: > 627 :map _ls :!ls -l %:S<CR>:echo "the end"<CR> 628 629To avoid mapping of the characters you type in insert or Command-line mode, 630type a CTRL-V first. The mapping in Insert mode is disabled if the 'paste' 631option is on. 632 *map-error* 633Note that when an error is encountered (that causes an error message or beep) 634the rest of the mapping is not executed. This is Vi-compatible. 635 636Note that the second character (argument) of the commands @zZtTfF[]rm'`"v 637and CTRL-X is not mapped. This was done to be able to use all the named 638registers and marks, even when the command with the same name has been 639mapped. 640 641 6421.7 WHAT KEYS TO MAP *map-which-keys* 643 644If you are going to map something, you will need to choose which key(s) to use 645for the {lhs}. You will have to avoid keys that are used for Vim commands, 646otherwise you would not be able to use those commands anymore. Here are a few 647suggestions: 648- Function keys <F2>, <F3>, etc.. Also the shifted function keys <S-F1>, 649 <S-F2>, etc. Note that <F1> is already used for the help command. 650- Meta-keys (with the ALT key pressed). Depending on your keyboard accented 651 characters may be used as well. |:map-alt-keys| 652- Use the '_' or ',' character and then any other character. The "_" and "," 653 commands do exist in Vim (see |_| and |,|), but you probably never use them. 654- Use a key that is a synonym for another command. For example: CTRL-P and 655 CTRL-N. Use an extra character to allow more mappings. 656- The key defined by <Leader> and one or more other keys. This is especially 657 useful in scripts. |mapleader| 658 659See the file "index" for keys that are not used and thus can be mapped without 660losing any builtin function. You can also use ":help {key}^D" to find out if 661a key is used for some command. ({key} is the specific key you want to find 662out about, ^D is CTRL-D). 663 664 6651.8 EXAMPLES *map-examples* 666 667A few examples (given as you type them, for "<CR>" you type four characters; 668the '<' flag must not be present in 'cpoptions' for this to work). > 669 670 :map <F3> o#include 671 :map <M-g> /foo<CR>cwbar<Esc> 672 :map _x d/END/e<CR> 673 :map! qq quadrillion questions 674 675 676Multiplying a count 677 678When you type a count before triggering a mapping, it's like the count was 679typed before the {lhs}. For example, with this mapping: > 680 :map <F4> 3w 681Typing 2<F4> will result in "23w". Thus not moving 2 * 3 words but 23 words. 682If you want to multiply counts use the expression register: > 683 :map <F4> @='3w'<CR> 684The part between quotes is the expression being executed. |@=| 685 686 6871.9 USING MAPPINGS *map-typing* 688 689Vim will compare what you type with the start of a mapped sequence. If there 690is an incomplete match, it will get more characters until there either is a 691complete match or until there is no match at all. Example: If you map! "qq", 692the first 'q' will not appear on the screen until you type another 693character. This is because Vim cannot know if the next character will be a 694'q' or not. If the 'timeout' option is on (which is the default) Vim will 695only wait for one second (or as long as specified with the 'timeoutlen' 696option). After that it assumes that the 'q' is to be interpreted as such. If 697you type slowly, or your system is slow, reset the 'timeout' option. Then you 698might want to set the 'ttimeout' option. 699 700 *map-precedence* 701Buffer-local mappings (defined using |:map-<buffer>|) take precedence over 702global mappings. When a buffer-local mapping is the same as a global mapping, 703Vim will use the buffer-local mapping. In addition, Vim will use a complete 704mapping immediately if it was defined with <nowait>, even if a longer mapping 705has the same prefix. For example, given the following two mappings: > 706 :map <buffer> <nowait> \a :echo "Local \a"<CR> 707 :map \abc :echo "Global \abc"<CR> 708When typing \a the buffer-local mapping will be used immediately. Vim will 709not wait for more characters to see if the user might be typing \abc. 710 711 *map-keys-fails* 712There are situations where key codes might not be recognized: 713- Vim can only read part of the key code. Mostly this is only the first 714 character. This happens on some Unix versions in an xterm. 715- The key code is after character(s) that are mapped. E.g., "<F1><F1>" or 716 "g<F1>". 717 718The result is that the key code is not recognized in this situation, and the 719mapping fails. There are two actions needed to avoid this problem: 720 721- Remove the 'K' flag from 'cpoptions'. This will make Vim wait for the rest 722 of the characters of the function key. 723- When using <F1> to <F4> the actual key code generated may correspond to 724 <xF1> to <xF4>. There are mappings from <xF1> to <F1>, <xF2> to <F2>, etc., 725 but these are not recognized after another half a mapping. Make sure the 726 key codes for <F1> to <F4> are correct: > 727 :set <F1>=<type CTRL-V><type F1> 728< Type the <F1> as four characters. The part after the "=" must be done with 729 the actual keys, not the literal text. 730Another solution is to use the actual key code in the mapping for the second 731special key: > 732 :map <F1><Esc>OP :echo "yes"<CR> 733Don't type a real <Esc>, Vim will recognize the key code and replace it with 734<F1> anyway. 735 736Another problem may be that when keeping ALT or Meta pressed the terminal 737prepends ESC instead of setting the 8th bit. See |:map-alt-keys|. 738 739 *recursive_mapping* 740If you include the {lhs} in the {rhs} you have a recursive mapping. When 741{lhs} is typed, it will be replaced with {rhs}. When the {lhs} which is 742included in {rhs} is encountered it will be replaced with {rhs}, and so on. 743This makes it possible to repeat a command an infinite number of times. The 744only problem is that the only way to stop this is by causing an error. The 745macros to solve a maze uses this, look there for an example. There is one 746exception: If the {rhs} starts with {lhs}, the first character is not mapped 747again (this is Vi compatible). 748For example: > 749 :map ab abcd 750will execute the "a" command and insert "bcd" in the text. The "ab" in the 751{rhs} will not be mapped again. 752 753If you want to exchange the meaning of two keys you should use the :noremap 754command. For example: > 755 :noremap k j 756 :noremap j k 757This will exchange the cursor up and down commands. 758 759With the normal :map command, when the 'remap' option is on, mapping takes 760place until the text is found not to be a part of a {lhs}. For example, if 761you use: > 762 :map x y 763 :map y x 764Vim will replace x with y, and then y with x, etc. When this has happened 765'maxmapdepth' times (default 1000), Vim will give the error message 766"recursive mapping". 767 768 *:map-undo* 769If you include an undo command inside a mapped sequence, this will bring the 770text back in the state before executing the macro. This is compatible with 771the original Vi, as long as there is only one undo command in the mapped 772sequence (having two undo commands in a mapped sequence did not make sense 773in the original Vi, you would get back the text before the first undo). 774 775 7761.10 MAPPING ALT-KEYS *:map-alt-keys* 777 778In the GUI Vim handles the Alt key itself, thus mapping keys with ALT should 779always work. But in a terminal Vim gets a sequence of bytes and has to figure 780out whether ALT was pressed or not. 781 782By default Vim assumes that pressing the ALT key sets the 8th bit of a typed 783character. Most decent terminals can work that way, such as xterm, aterm and 784rxvt. If your <A-k> mappings don't work it might be that the terminal is 785prefixing the character with an ESC character. But you can just as well type 786ESC before a character, thus Vim doesn't know what happened (except for 787checking the delay between characters, which is not reliable). 788 789As of this writing, some mainstream terminals like gnome-terminal and konsole 790use the ESC prefix. There doesn't appear a way to have them use the 8th bit 791instead. Xterm should work well by default. Aterm and rxvt should work well 792when started with the "--meta8" argument. You can also tweak resources like 793"metaSendsEscape", "eightBitInput" and "eightBitOutput". 794 795On the Linux console, this behavior can be toggled with the "setmetamode" 796command. Bear in mind that not using an ESC prefix could get you in trouble 797with other programs. You should make sure that bash has the "convert-meta" 798option set to "on" in order for your Meta keybindings to still work on it 799(it's the default readline behavior, unless changed by specific system 800configuration). For that, you can add the line: > 801 802 set convert-meta on 803 804to your ~/.inputrc file. If you're creating the file, you might want to use: > 805 806 $include /etc/inputrc 807 808as the first line, if that file exists on your system, to keep global options. 809This may cause a problem for entering special characters, such as the umlaut. 810Then you should use CTRL-V before that character. 811 812Bear in mind that convert-meta has been reported to have troubles when used in 813UTF-8 locales. On terminals like xterm, the "metaSendsEscape" resource can be 814toggled on the fly through the "Main Options" menu, by pressing Ctrl-LeftClick 815on the terminal; that's a good last resource in case you want to send ESC when 816using other applications but not when inside Vim. 817 818 8191.11 MAPPING AN OPERATOR *:map-operator* 820 821An operator is used before a {motion} command. To define your own operator 822you must create mapping that first sets the 'operatorfunc' option and then 823invoke the |g@| operator. After the user types the {motion} command the 824specified function will be called. 825 826 *g@* *E774* *E775* 827g@{motion} Call the function set by the 'operatorfunc' option. 828 The '[ mark is positioned at the start of the text 829 moved over by {motion}, the '] mark on the last 830 character of the text. 831 The function is called with one String argument: 832 "line" {motion} was |linewise| 833 "char" {motion} was |characterwise| 834 "block" {motion} was |blockwise-visual| 835 Although "block" would rarely appear, since it can 836 only result from Visual mode where "g@" is not useful. 837 {not available when compiled without the |+eval| 838 feature} 839 840Here is an example that counts the number of spaces with <F4>: > 841 842 nmap <silent> <F4> :set opfunc=CountSpaces<CR>g@ 843 vmap <silent> <F4> :<C-U>call CountSpaces(visualmode(), 1)<CR> 844 845 function! CountSpaces(type, ...) 846 let sel_save = &selection 847 let &selection = "inclusive" 848 let reg_save = @@ 849 850 if a:0 " Invoked from Visual mode, use gv command. 851 silent exe "normal! gvy" 852 elseif a:type == 'line' 853 silent exe "normal! '[V']y" 854 else 855 silent exe "normal! `[v`]y" 856 endif 857 858 echomsg strlen(substitute(@@, '[^ ]', '', 'g')) 859 860 let &selection = sel_save 861 let @@ = reg_save 862 endfunction 863 864Note that the 'selection' option is temporarily set to "inclusive" to be able 865to yank exactly the right text by using Visual mode from the '[ to the '] 866mark. 867 868Also note that there is a separate mapping for Visual mode. It removes the 869"'<,'>" range that ":" inserts in Visual mode and invokes the function with 870visualmode() and an extra argument. 871 872============================================================================== 8732. Abbreviations *abbreviations* *Abbreviations* 874 875Abbreviations are used in Insert mode, Replace mode and Command-line mode. 876If you enter a word that is an abbreviation, it is replaced with the word it 877stands for. This can be used to save typing for often used long words. And 878you can use it to automatically correct obvious spelling errors. 879Examples: 880 881 :iab ms Microsoft 882 :iab tihs this 883 884There are three types of abbreviations: 885 886full-id The "full-id" type consists entirely of keyword characters (letters 887 and characters from 'iskeyword' option). This is the most common 888 abbreviation. 889 890 Examples: "foo", "g3", "-1" 891 892end-id The "end-id" type ends in a keyword character, but all the other 893 characters are not keyword characters. 894 895 Examples: "#i", "..f", "$/7" 896 897non-id The "non-id" type ends in a non-keyword character, the other 898 characters may be of any type, excluding space and tab. {this type 899 is not supported by Vi} 900 901 Examples: "def#", "4/7$" 902 903Examples of strings that cannot be abbreviations: "a.b", "#def", "a b", "_$r" 904 905An abbreviation is only recognized when you type a non-keyword character. 906This can also be the <Esc> that ends insert mode or the <CR> that ends a 907command. The non-keyword character which ends the abbreviation is inserted 908after the expanded abbreviation. An exception to this is the character <C-]>, 909which is used to expand an abbreviation without inserting any extra 910characters. 911 912Example: > 913 :ab hh hello 914< "hh<Space>" is expanded to "hello<Space>" 915 "hh<C-]>" is expanded to "hello" 916 917The characters before the cursor must match the abbreviation. Each type has 918an additional rule: 919 920full-id In front of the match is a non-keyword character, or this is where 921 the line or insertion starts. Exception: When the abbreviation is 922 only one character, it is not recognized if there is a non-keyword 923 character in front of it, other than a space or a tab. However, for 924 the command line "'<,'>" (or any other marks) is ignored, as if the 925 command line starts after it. 926 927end-id In front of the match is a keyword character, or a space or a tab, 928 or this is where the line or insertion starts. 929 930non-id In front of the match is a space, tab or the start of the line or 931 the insertion. 932 933Examples: ({CURSOR} is where you type a non-keyword character) > 934 :ab foo four old otters 935< " foo{CURSOR}" is expanded to " four old otters" 936 " foobar{CURSOR}" is not expanded 937 "barfoo{CURSOR}" is not expanded 938> 939 :ab #i #include 940< "#i{CURSOR}" is expanded to "#include" 941 ">#i{CURSOR}" is not expanded 942> 943 :ab ;; <endofline> 944< "test;;" is not expanded 945 "test ;;" is expanded to "test <endofline>" 946 947To avoid the abbreviation in Insert mode: Type CTRL-V before the character 948that would trigger the abbreviation. E.g. CTRL-V <Space>. Or type part of 949the abbreviation, exit insert mode with <Esc>, re-enter insert mode with "a" 950and type the rest. 951 952To avoid the abbreviation in Command-line mode: Type CTRL-V twice somewhere in 953the abbreviation to avoid it to be replaced. A CTRL-V in front of a normal 954character is mostly ignored otherwise. 955 956It is possible to move the cursor after an abbreviation: > 957 :iab if if ()<Left> 958This does not work if 'cpoptions' includes the '<' flag. |<>| 959 960You can even do more complicated things. For example, to consume the space 961typed after an abbreviation: > 962 func Eatchar(pat) 963 let c = nr2char(getchar(0)) 964 return (c =~ a:pat) ? '' : c 965 endfunc 966 iabbr <silent> if if ()<Left><C-R>=Eatchar('\s')<CR> 967 968There are no default abbreviations. 969 970Abbreviations are never recursive. You can use ":ab f f-o-o" without any 971problem. But abbreviations can be mapped. {some versions of Vi support 972recursive abbreviations, for no apparent reason} 973 974Abbreviations are disabled if the 'paste' option is on. 975 976 *:abbreviate-local* *:abbreviate-<buffer>* 977Just like mappings, abbreviations can be local to a buffer. This is mostly 978used in a |filetype-plugin| file. Example for a C plugin file: > 979 :abb <buffer> FF for (i = 0; i < ; ++i) 980< 981 *:ab* *:abbreviate* 982:ab[breviate] list all abbreviations. The character in the first 983 column indicates the mode where the abbreviation is 984 used: 'i' for insert mode, 'c' for Command-line 985 mode, '!' for both. These are the same as for 986 mappings, see |map-listing|. 987 988 *:abbreviate-verbose* 989When 'verbose' is non-zero, listing an abbreviation will also display where it 990was last defined. Example: > 991 992 :verbose abbreviate 993 ! teh the 994 Last set from /home/abcd/vim/abbr.vim 995 996See |:verbose-cmd| for more information. 997 998:ab[breviate] {lhs} list the abbreviations that start with {lhs} 999 You may need to insert a CTRL-V (type it twice) to 1000 avoid that a typed {lhs} is expanded, since 1001 command-line abbreviations apply here. 1002 1003:ab[breviate] [<expr>] [<buffer>] {lhs} {rhs} 1004 add abbreviation for {lhs} to {rhs}. If {lhs} already 1005 existed it is replaced with the new {rhs}. {rhs} may 1006 contain spaces. 1007 See |:map-<expr>| for the optional <expr> argument. 1008 See |:map-<buffer>| for the optional <buffer> argument. 1009 1010 *:una* *:unabbreviate* 1011:una[bbreviate] {lhs} Remove abbreviation for {lhs} from the list. If none 1012 is found, remove abbreviations in which {lhs} matches 1013 with the {rhs}. This is done so that you can even 1014 remove abbreviations after expansion. To avoid 1015 expansion insert a CTRL-V (type it twice). 1016 1017 *:norea* *:noreabbrev* 1018:norea[bbrev] [<expr>] [<buffer>] [lhs] [rhs] 1019 same as ":ab", but no remapping for this {rhs} {not 1020 in Vi} 1021 1022 *:ca* *:cabbrev* 1023:ca[bbrev] [<expr>] [<buffer>] [lhs] [rhs] 1024 same as ":ab", but for Command-line mode only. {not 1025 in Vi} 1026 1027 *:cuna* *:cunabbrev* 1028:cuna[bbrev] {lhs} same as ":una", but for Command-line mode only. {not 1029 in Vi} 1030 1031 *:cnorea* *:cnoreabbrev* 1032:cnorea[bbrev] [<expr>] [<buffer>] [lhs] [rhs] 1033 same as ":ab", but for Command-line mode only and no 1034 remapping for this {rhs} {not in Vi} 1035 1036 *:ia* *:iabbrev* 1037:ia[bbrev] [<expr>] [<buffer>] [lhs] [rhs] 1038 same as ":ab", but for Insert mode only. {not in Vi} 1039 1040 *:iuna* *:iunabbrev* 1041:iuna[bbrev] {lhs} same as ":una", but for insert mode only. {not in 1042 Vi} 1043 1044 *:inorea* *:inoreabbrev* 1045:inorea[bbrev] [<expr>] [<buffer>] [lhs] [rhs] 1046 same as ":ab", but for Insert mode only and no 1047 remapping for this {rhs} {not in Vi} 1048 1049 *:abc* *:abclear* 1050:abc[lear] [<buffer>] Remove all abbreviations. {not in Vi} 1051 1052 *:iabc* *:iabclear* 1053:iabc[lear] [<buffer>] Remove all abbreviations for Insert mode. {not in Vi} 1054 1055 *:cabc* *:cabclear* 1056:cabc[lear] [<buffer>] Remove all abbreviations for Command-line mode. {not 1057 in Vi} 1058 1059 *using_CTRL-V* 1060It is possible to use special characters in the rhs of an abbreviation. 1061CTRL-V has to be used to avoid the special meaning of most non printable 1062characters. How many CTRL-Vs need to be typed depends on how you enter the 1063abbreviation. This also applies to mappings. Let's use an example here. 1064 1065Suppose you want to abbreviate "esc" to enter an <Esc> character. When you 1066type the ":ab" command in Vim, you have to enter this: (here ^V is a CTRL-V 1067and ^[ is <Esc>) 1068 1069You type: ab esc ^V^V^V^V^V^[ 1070 1071 All keyboard input is subjected to ^V quote interpretation, so 1072 the first, third, and fifth ^V characters simply allow the second, 1073 and fourth ^Vs, and the ^[, to be entered into the command-line. 1074 1075You see: ab esc ^V^V^[ 1076 1077 The command-line contains two actual ^Vs before the ^[. This is 1078 how it should appear in your .exrc file, if you choose to go that 1079 route. The first ^V is there to quote the second ^V; the :ab 1080 command uses ^V as its own quote character, so you can include quoted 1081 whitespace or the | character in the abbreviation. The :ab command 1082 doesn't do anything special with the ^[ character, so it doesn't need 1083 to be quoted. (Although quoting isn't harmful; that's why typing 7 1084 [but not 8!] ^Vs works.) 1085 1086Stored as: esc ^V^[ 1087 1088 After parsing, the abbreviation's short form ("esc") and long form 1089 (the two characters "^V^[") are stored in the abbreviation table. 1090 If you give the :ab command with no arguments, this is how the 1091 abbreviation will be displayed. 1092 1093 Later, when the abbreviation is expanded because the user typed in 1094 the word "esc", the long form is subjected to the same type of 1095 ^V interpretation as keyboard input. So the ^V protects the ^[ 1096 character from being interpreted as the "exit Insert mode" character. 1097 Instead, the ^[ is inserted into the text. 1098 1099Expands to: ^[ 1100 1101[example given by Steve Kirkendall] 1102 1103============================================================================== 11043. Local mappings and functions *script-local* 1105 1106When using several Vim script files, there is the danger that mappings and 1107functions used in one script use the same name as in other scripts. To avoid 1108this, they can be made local to the script. 1109 1110 *<SID>* *<SNR>* *E81* 1111The string "<SID>" can be used in a mapping or menu. This requires that the 1112'<' flag is not present in 'cpoptions'. 1113 When executing the map command, Vim will replace "<SID>" with the special 1114key code <SNR>, followed by a number that's unique for the script, and an 1115underscore. Example: > 1116 :map <SID>Add 1117could define a mapping "<SNR>23_Add". 1118 1119When defining a function in a script, "s:" can be prepended to the name to 1120make it local to the script. But when a mapping is executed from outside of 1121the script, it doesn't know in which script the function was defined. To 1122avoid this problem, use "<SID>" instead of "s:". The same translation is done 1123as for mappings. This makes it possible to define a call to the function in 1124a mapping. 1125 1126When a local function is executed, it runs in the context of the script it was 1127defined in. This means that new functions and mappings it defines can also 1128use "s:" or "<SID>" and it will use the same unique number as when the 1129function itself was defined. Also, the "s:var" local script variables can be 1130used. 1131 1132When executing an autocommand or a user command, it will run in the context of 1133the script it was defined in. This makes it possible that the command calls a 1134local function or uses a local mapping. 1135 1136Otherwise, using "<SID>" outside of a script context is an error. 1137 1138If you need to get the script number to use in a complicated script, you can 1139use this function: > 1140 function s:SID() 1141 return matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_SID$') 1142 endfun 1143 1144The "<SNR>" will be shown when listing functions and mappings. This is useful 1145to find out what they are defined to. 1146 1147The |:scriptnames| command can be used to see which scripts have been sourced 1148and what their <SNR> number is. 1149 1150This is all {not in Vi} and {not available when compiled without the |+eval| 1151feature}. 1152 1153============================================================================== 11544. User-defined commands *user-commands* 1155 1156It is possible to define your own Ex commands. A user-defined command can act 1157just like a built-in command (it can have a range or arguments, arguments can 1158be completed as filenames or buffer names, etc), except that when the command 1159is executed, it is transformed into a normal Ex command and then executed. 1160 1161For starters: See section |40.2| in the user manual. 1162 1163 *E183* *E841* *user-cmd-ambiguous* 1164All user defined commands must start with an uppercase letter, to avoid 1165confusion with builtin commands. Exceptions are these builtin commands: 1166 :Next 1167 :X 1168They cannot be used for a user defined command. ":Print" is also an existing 1169command, but it is deprecated and can be overruled. 1170 1171The other characters of the user command can be uppercase letters, lowercase 1172letters or digits. When using digits, note that other commands that take a 1173numeric argument may become ambiguous. For example, the command ":Cc2" could 1174be the user command ":Cc2" without an argument, or the command ":Cc" with 1175argument "2". It is advised to put a space between the command name and the 1176argument to avoid these problems. 1177 1178When using a user-defined command, the command can be abbreviated. However, if 1179an abbreviation is not unique, an error will be issued. Furthermore, a 1180built-in command will always take precedence. 1181 1182Example: > 1183 :command Rename ... 1184 :command Renumber ... 1185 :Rena " Means "Rename" 1186 :Renu " Means "Renumber" 1187 :Ren " Error - ambiguous 1188 :command Paste ... 1189 :P " The built-in :Print 1190 1191It is recommended that full names for user-defined commands are used in 1192scripts. 1193 1194:com[mand] *:com* *:command* 1195 List all user-defined commands. When listing commands, 1196 the characters in the first two columns are 1197 ! Command has the -bang attribute 1198 " Command has the -register attribute 1199 b Command is local to current buffer 1200 (see below for details on attributes) 1201 The list can be filtered on command name with 1202 |:filter|, e.g., to list all commands with "Pyth" in 1203 the name: > 1204 filter Pyth command 1205 1206:com[mand] {cmd} List the user-defined commands that start with {cmd} 1207 1208 *:command-verbose* 1209When 'verbose' is non-zero, listing a command will also display where it was 1210last defined. Example: > 1211 1212 :verbose command TOhtml 1213< Name Args Range Complete Definition ~ 1214 TOhtml 0 % :call Convert2HTML(<line1>, <line2>) ~ 1215 Last set from /usr/share/vim/vim-7.0/plugin/tohtml.vim ~ 1216 1217See |:verbose-cmd| for more information. 1218 1219 *E174* *E182* 1220:com[mand][!] [{attr}...] {cmd} {rep} 1221 Define a user command. The name of the command is 1222 {cmd} and its replacement text is {rep}. The command's 1223 attributes (see below) are {attr}. If the command 1224 already exists, an error is reported, unless a ! is 1225 specified, in which case the command is redefined. 1226 There is one exception: When sourcing a script again, 1227 a command that was previously defined in that script 1228 will be silently replaced. 1229 1230 1231:delc[ommand] {cmd} *:delc* *:delcommand* *E184* 1232 Delete the user-defined command {cmd}. 1233 1234:comc[lear] *:comc* *:comclear* 1235 Delete all user-defined commands. 1236 1237 1238Command attributes ~ 1239 1240User-defined commands are treated by Vim just like any other Ex commands. They 1241can have arguments, or have a range specified. Arguments are subject to 1242completion as filenames, buffers, etc. Exactly how this works depends upon the 1243command's attributes, which are specified when the command is defined. 1244 1245There are a number of attributes, split into four categories: argument 1246handling, completion behavior, range handling, and special cases. The 1247attributes are described below, by category. 1248 1249 1250Argument handling ~ 1251 *E175* *E176* *:command-nargs* 1252By default, a user defined command will take no arguments (and an error is 1253reported if any are supplied). However, it is possible to specify that the 1254command can take arguments, using the -nargs attribute. Valid cases are: 1255 1256 -nargs=0 No arguments are allowed (the default) 1257 -nargs=1 Exactly one argument is required, it includes spaces 1258 -nargs=* Any number of arguments are allowed (0, 1, or many), 1259 separated by white space 1260 -nargs=? 0 or 1 arguments are allowed 1261 -nargs=+ Arguments must be supplied, but any number are allowed 1262 1263Arguments are considered to be separated by (unescaped) spaces or tabs in this 1264context, except when there is one argument, then the white space is part of 1265the argument. 1266 1267Note that arguments are used as text, not as expressions. Specifically, 1268"s:var" will use the script-local variable in the script where the command was 1269defined, not where it is invoked! Example: 1270 script1.vim: > 1271 :let s:error = "None" 1272 :command -nargs=1 Error echoerr <args> 1273< script2.vim: > 1274 :source script1.vim 1275 :let s:error = "Wrong!" 1276 :Error s:error 1277Executing script2.vim will result in "None" being echoed. Not what you 1278intended! Calling a function may be an alternative. 1279 1280 1281Completion behavior ~ 1282 *:command-completion* *E179* *E180* *E181* 1283 *:command-complete* 1284By default, the arguments of user defined commands do not undergo completion. 1285However, by specifying one or the other of the following attributes, argument 1286completion can be enabled: 1287 1288 -complete=arglist file names in argument list 1289 -complete=augroup autocmd groups 1290 -complete=buffer buffer names 1291 -complete=behave :behave suboptions 1292 -complete=color color schemes 1293 -complete=command Ex command (and arguments) 1294 -complete=compiler compilers 1295 -complete=cscope |:cscope| suboptions 1296 -complete=dir directory names 1297 -complete=environment environment variable names 1298 -complete=event autocommand events 1299 -complete=expression Vim expression 1300 -complete=file file and directory names 1301 -complete=file_in_path file and directory names in |'path'| 1302 -complete=filetype filetype names |'filetype'| 1303 -complete=function function name 1304 -complete=help help subjects 1305 -complete=highlight highlight groups 1306 -complete=history :history suboptions 1307 -complete=locale locale names (as output of locale -a) 1308 -complete=mapclear buffer argument 1309 -complete=mapping mapping name 1310 -complete=menu menus 1311 -complete=messages |:messages| suboptions 1312 -complete=option options 1313 -complete=packadd optional package |pack-add| names 1314 -complete=shellcmd Shell command 1315 -complete=sign |:sign| suboptions 1316 -complete=syntax syntax file names |'syntax'| 1317 -complete=syntime |:syntime| suboptions 1318 -complete=tag tags 1319 -complete=tag_listfiles tags, file names are shown when CTRL-D is hit 1320 -complete=user user names 1321 -complete=var user variables 1322 -complete=custom,{func} custom completion, defined via {func} 1323 -complete=customlist,{func} custom completion, defined via {func} 1324 1325Note: That some completion methods might expand environment variables. 1326 1327 1328Custom completion ~ 1329 *:command-completion-custom* 1330 *:command-completion-customlist* *E467* *E468* 1331It is possible to define customized completion schemes via the "custom,{func}" 1332or the "customlist,{func}" completion argument. The {func} part should be a 1333function with the following signature: > 1334 1335 :function {func}(ArgLead, CmdLine, CursorPos) 1336 1337The function need not use all these arguments. The function should provide the 1338completion candidates as the return value. 1339 1340For the "custom" argument, the function should return the completion 1341candidates one per line in a newline separated string. 1342 1343For the "customlist" argument, the function should return the completion 1344candidates as a Vim List. Non-string items in the list are ignored. 1345 1346The function arguments are: 1347 ArgLead the leading portion of the argument currently being 1348 completed on 1349 CmdLine the entire command line 1350 CursorPos the cursor position in it (byte index) 1351The function may use these for determining context. For the "custom" 1352argument, it is not necessary to filter candidates against the (implicit 1353pattern in) ArgLead. Vim will filter the candidates with its regexp engine 1354after function return, and this is probably more efficient in most cases. For 1355the "customlist" argument, Vim will not filter the returned completion 1356candidates and the user supplied function should filter the candidates. 1357 1358The following example lists user names to a Finger command > 1359 :com -complete=custom,ListUsers -nargs=1 Finger !finger <args> 1360 :fun ListUsers(A,L,P) 1361 : return system("cut -d: -f1 /etc/passwd") 1362 :endfun 1363 1364The following example completes filenames from the directories specified in 1365the 'path' option: > 1366 :com -nargs=1 -bang -complete=customlist,EditFileComplete 1367 \ EditFile edit<bang> <args> 1368 :fun EditFileComplete(A,L,P) 1369 : return split(globpath(&path, a:A), "\n") 1370 :endfun 1371< 1372This example does not work for file names with spaces! 1373 1374 1375Range handling ~ 1376 *E177* *E178* *:command-range* *:command-count* 1377By default, user-defined commands do not accept a line number range. However, 1378it is possible to specify that the command does take a range (the -range 1379attribute), or that it takes an arbitrary count value, either in the line 1380number position (-range=N, like the |:split| command) or as a "count" 1381argument (-count=N, like the |:Next| command). The count will then be 1382available in the argument with |<count>|. 1383 1384Possible attributes are: 1385 1386 -range Range allowed, default is current line 1387 -range=% Range allowed, default is whole file (1,$) 1388 -range=N A count (default N) which is specified in the line 1389 number position (like |:split|); allows for zero line 1390 number. 1391 -count=N A count (default N) which is specified either in the line 1392 number position, or as an initial argument (like |:Next|). 1393 Specifying -count (without a default) acts like -count=0 1394 1395Note that -range=N and -count=N are mutually exclusive - only one should be 1396specified. 1397 1398 *:command-addr* 1399It is possible that the special characters in the range like ., $ or % which 1400by default correspond to the current line, last line and the whole buffer, 1401relate to arguments, (loaded) buffers, windows or tab pages. 1402 1403Possible values are: 1404 -addr=lines Range of lines (this is the default) 1405 -addr=arguments Range for arguments 1406 -addr=buffers Range for buffers (also not loaded buffers) 1407 -addr=loaded_buffers Range for loaded buffers 1408 -addr=windows Range for windows 1409 -addr=tabs Range for tab pages 1410 -addr=other other kind of range 1411 1412 1413Special cases ~ 1414 *:command-bang* *:command-bar* 1415 *:command-register* *:command-buffer* 1416There are some special cases as well: 1417 1418 -bang The command can take a ! modifier (like :q or :w) 1419 -bar The command can be followed by a "|" and another command. 1420 A "|" inside the command argument is not allowed then. 1421 Also checks for a " to start a comment. 1422 -register The first argument to the command can be an optional 1423 register name (like :del, :put, :yank). 1424 -buffer The command will only be available in the current buffer. 1425 1426In the cases of the -count and -register attributes, if the optional argument 1427is supplied, it is removed from the argument list and is available to the 1428replacement text separately. 1429Note that these arguments can be abbreviated, but that is a deprecated 1430feature. Use the full name for new scripts. 1431 1432 1433Replacement text ~ 1434 1435The replacement text for a user defined command is scanned for special escape 1436sequences, using <...> notation. Escape sequences are replaced with values 1437from the entered command line, and all other text is copied unchanged. The 1438resulting string is executed as an Ex command. To avoid the replacement use 1439<lt> in place of the initial <. Thus to include "<bang>" literally use 1440"<lt>bang>". 1441 1442The valid escape sequences are 1443 1444 *<line1>* 1445 <line1> The starting line of the command range. 1446 *<line2>* 1447 <line2> The final line of the command range. 1448 *<range>* 1449 <range> The number of items in the command range: 0, 1 or 2 1450 *<count>* 1451 <count> Any count supplied (as described for the '-range' 1452 and '-count' attributes). 1453 *<bang>* 1454 <bang> (See the '-bang' attribute) Expands to a ! if the 1455 command was executed with a ! modifier, otherwise 1456 expands to nothing. 1457 *<mods>* 1458 <mods> The command modifiers, if specified. Otherwise, expands to 1459 nothing. Supported modifiers are |:aboveleft|, |:belowright|, 1460 |:botright|, |:browse|, |:confirm|, |:hide|, |:keepalt|, 1461 |:keepjumps|, |:keepmarks|, |:keeppatterns|, |:leftabove|, 1462 |:lockmarks|, |:noswapfile| |:rightbelow|, |:silent|, |:tab|, 1463 |:topleft|, |:verbose|, and |:vertical|. 1464 Note that these are not yet supported: |:noautocmd|, 1465 |:sandbox| and |:unsilent|. 1466 Examples: > 1467 command! -nargs=+ -complete=file MyEdit 1468 \ for f in expand(<q-args>, 0, 1) | 1469 \ exe '<mods> split ' . f | 1470 \ endfor 1471 1472 function! SpecialEdit(files, mods) 1473 for f in expand(a:files, 0, 1) 1474 exe a:mods . ' split ' . f 1475 endfor 1476 endfunction 1477 command! -nargs=+ -complete=file Sedit 1478 \ call SpecialEdit(<q-args>, <q-mods>) 1479< 1480 *<reg>* *<register>* 1481 <reg> (See the '-register' attribute) The optional register, 1482 if specified. Otherwise, expands to nothing. <register> 1483 is a synonym for this. 1484 *<args>* 1485 <args> The command arguments, exactly as supplied (but as 1486 noted above, any count or register can consume some 1487 of the arguments, which are then not part of <args>). 1488 <lt> A single '<' (Less-Than) character. This is needed if you 1489 want to get a literal copy of one of these escape sequences 1490 into the expansion - for example, to get <bang>, use 1491 <lt>bang>. 1492 1493 *<q-args>* 1494If the first two characters of an escape sequence are "q-" (for example, 1495<q-args>) then the value is quoted in such a way as to make it a valid value 1496for use in an expression. This uses the argument as one single value. 1497When there is no argument <q-args> is an empty string. 1498 *<f-args>* 1499To allow commands to pass their arguments on to a user-defined function, there 1500is a special form <f-args> ("function args"). This splits the command 1501arguments at spaces and tabs, quotes each argument individually, and the 1502<f-args> sequence is replaced by the comma-separated list of quoted arguments. 1503See the Mycmd example below. If no arguments are given <f-args> is removed. 1504 To embed whitespace into an argument of <f-args>, prepend a backslash. 1505<f-args> replaces every pair of backslashes (\\) with one backslash. A 1506backslash followed by a character other than white space or a backslash 1507remains unmodified. Overview: 1508 1509 command <f-args> ~ 1510 XX ab 'ab' 1511 XX a\b 'a\b' 1512 XX a\ b 'a b' 1513 XX a\ b 'a ', 'b' 1514 XX a\\b 'a\b' 1515 XX a\\ b 'a\', 'b' 1516 XX a\\\b 'a\\b' 1517 XX a\\\ b 'a\ b' 1518 XX a\\\\b 'a\\b' 1519 XX a\\\\ b 'a\\', 'b' 1520 1521Examples > 1522 1523 " Delete everything after here to the end 1524 :com Ddel +,$d 1525 1526 " Rename the current buffer 1527 :com -nargs=1 -bang -complete=file Ren f <args>|w<bang> 1528 1529 " Replace a range with the contents of a file 1530 " (Enter this all as one line) 1531 :com -range -nargs=1 -complete=file 1532 Replace <line1>-pu_|<line1>,<line2>d|r <args>|<line1>d 1533 1534 " Count the number of lines in the range 1535 :com! -range -nargs=0 Lines echo <line2> - <line1> + 1 "lines" 1536 1537 " Call a user function (example of <f-args>) 1538 :com -nargs=* Mycmd call Myfunc(<f-args>) 1539 1540When executed as: > 1541 :Mycmd arg1 arg2 1542This will invoke: > 1543 :call Myfunc("arg1","arg2") 1544 1545 :" A more substantial example 1546 :function Allargs(command) 1547 : let i = 0 1548 : while i < argc() 1549 : if filereadable(argv(i)) 1550 : execute "e " . argv(i) 1551 : execute a:command 1552 : endif 1553 : let i = i + 1 1554 : endwhile 1555 :endfunction 1556 :command -nargs=+ -complete=command Allargs call Allargs(<q-args>) 1557 1558The command Allargs takes any Vim command(s) as argument and executes it on all 1559files in the argument list. Usage example (note use of the "e" flag to ignore 1560errors and the "update" command to write modified buffers): > 1561 :Allargs %s/foo/bar/ge|update 1562This will invoke: > 1563 :call Allargs("%s/foo/bar/ge|update") 1564< 1565When defining a user command in a script, it will be able to call functions 1566local to the script and use mappings local to the script. When the user 1567invokes the user command, it will run in the context of the script it was 1568defined in. This matters if |<SID>| is used in a command. 1569 1570 vim:tw=78:ts=8:noet:ft=help:norl: 1571