blob: 18b61df00144b57a50a92285e8a1f6bc1903c53d [file] [log] [blame]
Bram Moolenaarb1c91982018-05-17 17:04:55 +02001*map.txt* For Vim version 8.1. Last change: 2018 May 13
Bram Moolenaar071d4272004-06-13 20:20:40 +00002
3
4 VIM REFERENCE MANUAL by Bram Moolenaar
5
6
7Key mapping, abbreviations and user-defined commands.
8
9This subject is introduced in sections |05.3|, |24.7| and |40.1| of the user
10manual.
11
121. Key mapping |key-mapping|
Bram Moolenaar5b962cf2005-12-12 21:58:40 +000013 1.1 MAP COMMANDS |:map-commands|
14 1.2 Special arguments |:map-arguments|
15 1.3 Mapping and modes |:map-modes|
16 1.4 Listing mappings |map-listing|
17 1.5 Mapping special keys |:map-special-keys|
18 1.6 Special characters |:map-special-chars|
19 1.7 What keys to map |map-which-keys|
20 1.8 Examples |map-examples|
21 1.9 Using mappings |map-typing|
22 1.10 Mapping alt-keys |:map-alt-keys|
23 1.11 Mapping an operator |:map-operator|
Bram Moolenaar071d4272004-06-13 20:20:40 +0000242. Abbreviations |abbreviations|
253. Local mappings and functions |script-local|
264. User-defined commands |user-commands|
27
28==============================================================================
291. Key mapping *key-mapping* *mapping* *macro*
30
31Key mapping is used to change the meaning of typed keys. The most common use
Bram Moolenaar24a98a02017-09-27 22:23:55 +020032is to define a sequence of commands for a function key. Example: >
Bram Moolenaar071d4272004-06-13 20:20:40 +000033
34 :map <F2> a<C-R>=strftime("%c")<CR><Esc>
35
Bram Moolenaar402d2fe2005-04-15 21:00:38 +000036This appends the current date and time after the cursor (in <> notation |<>|).
Bram Moolenaar071d4272004-06-13 20:20:40 +000037
Bram Moolenaar5b962cf2005-12-12 21:58:40 +000038
391.1 MAP COMMANDS *:map-commands*
40
Bram Moolenaar071d4272004-06-13 20:20:40 +000041There are commands to enter new mappings, remove mappings and list mappings.
42See |map-overview| for the various forms of "map" and their relationships with
43modes.
44
45{lhs} means left-hand-side *{lhs}*
46{rhs} means right-hand-side *{rhs}*
47
Bram Moolenaar06b5db92006-02-10 23:11:56 +000048:map {lhs} {rhs} |mapmode-nvo| *:map*
49:nm[ap] {lhs} {rhs} |mapmode-n| *:nm* *:nmap*
50:vm[ap] {lhs} {rhs} |mapmode-v| *:vm* *:vmap*
Bram Moolenaar371d5402006-03-20 21:47:49 +000051:xm[ap] {lhs} {rhs} |mapmode-x| *:xm* *:xmap*
Bram Moolenaar531da592013-05-06 05:58:55 +020052:smap {lhs} {rhs} |mapmode-s| *:smap*
Bram Moolenaar06b5db92006-02-10 23:11:56 +000053:om[ap] {lhs} {rhs} |mapmode-o| *:om* *:omap*
54:map! {lhs} {rhs} |mapmode-ic| *:map!*
55:im[ap] {lhs} {rhs} |mapmode-i| *:im* *:imap*
56:lm[ap] {lhs} {rhs} |mapmode-l| *:lm* *:lmap*
57:cm[ap] {lhs} {rhs} |mapmode-c| *:cm* *:cmap*
Bram Moolenaar37c64c72017-09-19 22:06:03 +020058:tma[p] {lhs} {rhs} |mapmode-t| *:tma* *:tmap*
Bram Moolenaar071d4272004-06-13 20:20:40 +000059 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
Bram Moolenaar822ff862014-06-12 21:46:14 +020064 *: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*
Bram Moolenaar69fbc9e2017-09-14 20:37:57 +020075:tno[remap] {lhs} {rhs} |mapmode-t| *:tno* *:tnoremap*
Bram Moolenaar071d4272004-06-13 20:20:40 +000076 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
Bram Moolenaar06b5db92006-02-10 23:11:56 +000082:unm[ap] {lhs} |mapmode-nvo| *:unm* *:unmap*
83:nun[map] {lhs} |mapmode-n| *:nun* *:nunmap*
84:vu[nmap] {lhs} |mapmode-v| *:vu* *:vunmap*
Bram Moolenaar371d5402006-03-20 21:47:49 +000085:xu[nmap] {lhs} |mapmode-x| *:xu* *:xunmap*
86:sunm[ap] {lhs} |mapmode-s| *:sunm* *:sunmap*
Bram Moolenaar06b5db92006-02-10 23:11:56 +000087: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*
Bram Moolenaar37c64c72017-09-19 22:06:03 +020092:tunma[p] {lhs} |mapmode-t| *:tunma* *:tunmap*
Bram Moolenaar071d4272004-06-13 20:20:40 +000093 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
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000101:mapc[lear] |mapmode-nvo| *:mapc* *:mapclear*
102:nmapc[lear] |mapmode-n| *:nmapc* *:nmapclear*
103:vmapc[lear] |mapmode-v| *:vmapc* *:vmapclear*
Bram Moolenaar371d5402006-03-20 21:47:49 +0000104:xmapc[lear] |mapmode-x| *:xmapc* *:xmapclear*
105:smapc[lear] |mapmode-s| *:smapc* *:smapclear*
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000106: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*
Bram Moolenaar69fbc9e2017-09-14 20:37:57 +0200111:tmapc[lear] |mapmode-t| *:tmapc* *:tmapclear*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000112 Remove ALL mappings for the modes where the map
113 command applies. {not in Vi}
Bram Moolenaar251e1912011-06-19 05:09:16 +0200114 Use the <buffer> argument to remove buffer-local
115 mappings |:map-<buffer>|
Bram Moolenaar071d4272004-06-13 20:20:40 +0000116 Warning: This also removes the default mappings.
117
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000118:map |mapmode-nvo|
119:nm[ap] |mapmode-n|
120:vm[ap] |mapmode-v|
Bram Moolenaar371d5402006-03-20 21:47:49 +0000121:xm[ap] |mapmode-x|
122:sm[ap] |mapmode-s|
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000123:om[ap] |mapmode-o|
124:map! |mapmode-ic|
125:im[ap] |mapmode-i|
126:lm[ap] |mapmode-l|
127:cm[ap] |mapmode-c|
Bram Moolenaar37c64c72017-09-19 22:06:03 +0200128:tma[p] |mapmode-t|
Bram Moolenaar071d4272004-06-13 20:20:40 +0000129 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
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000133:map {lhs} |mapmode-nvo| *:map_l*
134:nm[ap] {lhs} |mapmode-n| *:nmap_l*
135:vm[ap] {lhs} |mapmode-v| *:vmap_l*
Bram Moolenaar371d5402006-03-20 21:47:49 +0000136:xm[ap] {lhs} |mapmode-x| *:xmap_l*
137:sm[ap] {lhs} |mapmode-s| *:smap_l*
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000138: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*
Bram Moolenaar37c64c72017-09-19 22:06:03 +0200143:tma[p] {lhs} |mapmode-t| *:tmap_l*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000144 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
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000153 *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
Bram Moolenaar72179e12013-06-29 13:58:31 +0200168"<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.
Bram Moolenaar4e427192006-03-10 21:34:27 +0000171
Bram Moolenaar071d4272004-06-13 20:20:40 +0000172 *:map-local* *:map-<buffer>* *E224* *E225*
Bram Moolenaarc236c162008-07-13 17:41:49 +0000173If the first argument to one of these commands is "<buffer>" the mapping will
174be effective in the current buffer only. Example: >
Bram Moolenaar071d4272004-06-13 20:20:40 +0000175 :map <buffer> ,w /[.,;]<CR>
176Then you can map ",w" to something else in another buffer: >
177 :map <buffer> ,w /[#&!]<CR>
Bram Moolenaar72179e12013-06-29 13:58:31 +0200178The 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.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000181The "<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.
Bram Moolenaarec7944a2013-06-12 21:29:15 +0200186Also see |map-precedence|.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000187
Bram Moolenaar72179e12013-06-29 13:58:31 +0200188 *: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
Bram Moolenaar6aa8cea2017-06-05 14:44:35 +0200194already typed they are used.
Bram Moolenaar72179e12013-06-29 13:58:31 +0200195
Bram Moolenaar071d4272004-06-13 20:20:40 +0000196 *: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
Bram Moolenaar9c102382006-05-03 21:26:49 +0000208 *: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<
Bram Moolenaar071d4272004-06-13 20:20:40 +0000214 *: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>
Bram Moolenaara40ceaf2006-01-13 22:35:40 +0000235If you want to map a key and then have it do what it was originally mapped to,
236have a look at |maparg()|.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000237
Bram Moolenaar4e427192006-03-10 21:34:27 +0000238 *: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
Bram Moolenaarda9591e2009-09-30 13:17:02 +0000246For 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
Bram Moolenaar5302d9e2011-09-14 17:55:08 +0200248should not either insert or change the v:char.
Bram Moolenaarda9591e2009-09-30 13:17:02 +0000249
Bram Moolenaar4e427192006-03-10 21:34:27 +0000250Be very careful about side effects! The expression is evaluated while
Bram Moolenaarc9b4b052006-04-30 18:54:39 +0000251obtaining characters, you may very well make the command dysfunctional.
252For this reason the following is blocked:
Bram Moolenaar5c5b0942007-05-06 12:07:59 +0000253- Changing the buffer text |textlock|.
254- Editing another buffer.
255- The |:normal| command.
256- Moving the cursor is allowed, but it is restored afterwards.
Bram Moolenaarc9b4b052006-04-30 18:54:39 +0000257If you want the mapping to do any of these let the returned characters do
258that.
Bram Moolenaar4e427192006-03-10 21:34:27 +0000259
Bram Moolenaar15146672011-10-20 22:22:38 +0200260You 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
Bram Moolenaarf1568ec2011-12-14 21:17:39 +0100266"foo" is inserted. If you type any other key the first mapping is used,
267getchar() gets the typed key and returns it.
Bram Moolenaar15146672011-10-20 22:22:38 +0200268
Bram Moolenaar4e427192006-03-10 21:34:27 +0000269Here 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
Bram Moolenaard9967712006-03-11 21:18:15 +0000284CTRL-L inserts the next number, CTRL-R resets the count. CTRL-R returns an
Bram Moolenaar4e427192006-03-10 21:34:27 +0000285empty string, so that nothing is inserted.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000286
Bram Moolenaar8424a622006-04-19 21:23:36 +0000287Note 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
Bram Moolenaar071d4272004-06-13 20:20:40 +0000297
Bram Moolenaar5b962cf2005-12-12 21:58:40 +00002981.3 MAPPING AND MODES *:map-modes*
Bram Moolenaara7241f52008-06-24 20:39:31 +0000299 *mapmode-nvo* *mapmode-n* *mapmode-v* *mapmode-o*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000300
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +0100301There are six sets of mappings
Bram Moolenaar071d4272004-06-13 20:20:40 +0000302- For Normal mode: When typing commands.
303- For Visual mode: When typing commands while the Visual area is highlighted.
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +0100304- For Select mode: like Visual mode but typing text replaces the selection.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000305- For Operator-pending mode: When an operator is pending (after "d", "y", "c",
Bram Moolenaara7241f52008-06-24 20:39:31 +0000306 etc.). See below: |omap-info|.
Bram Moolenaar402d2fe2005-04-15 21:00:38 +0000307- For Insert mode. These are also used in Replace mode.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000308- For Command-line mode: When entering a ":" or "/" command.
309
Bram Moolenaar071d4272004-06-13 20:20:40 +0000310Special 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*
Bram Moolenaare968e362014-05-13 20:23:24 +0200315Overview 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
Bram Moolenaar69fbc9e2017-09-14 20:37:57 +0200327:tmap :tnoremap :tunmap Terminal-Job
Bram Moolenaar071d4272004-06-13 20:20:40 +0000328
Bram Moolenaare968e362014-05-13 20:23:24 +0200329
330 COMMANDS MODES ~
Bram Moolenaarc9b4b052006-04-30 18:54:39 +0000331 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
Bram Moolenaar371d5402006-03-20 21:47:49 +0000336
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000337:nunmap can also be used outside of a monastery.
Bram Moolenaarc9b4b052006-04-30 18:54:39 +0000338 *mapmode-x* *mapmode-s*
Bram Moolenaar371d5402006-03-20 21:47:49 +0000339Some 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|
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +0100342NOTE: 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.
Bram Moolenaar371d5402006-03-20 21:47:49 +0000345
Bram Moolenaare968e362014-05-13 20:23:24 +0200346 COMMANDS MODES ~
Bram Moolenaarc9b4b052006-04-30 18:54:39 +0000347 Visual Select ~
348:vmap :vnoremap :vunmap :vmapclear yes yes
349:xmap :xnoremap :xunmap :xmapclear yes -
350:smap :snoremap :sunmap :smapclear - yes
Bram Moolenaar071d4272004-06-13 20:20:40 +0000351
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000352 *mapmode-ic* *mapmode-i* *mapmode-c* *mapmode-l*
Bram Moolenaar371d5402006-03-20 21:47:49 +0000353Some commands work both in Insert mode and Command-line mode, some not:
354
Bram Moolenaare968e362014-05-13 20:23:24 +0200355 COMMANDS MODES ~
Bram Moolenaar071d4272004-06-13 20:20:40 +0000356 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
Bram Moolenaar69fbc9e2017-09-14 20:37:57 +0200368 *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
Bram Moolenaara7241f52008-06-24 20:39:31 +0000372 *omap-info*
373Operator-pending mappings can be used to define a movement command that can be
374used with any operator. Simple example: ":omap { w" makes "y{" work like "yw"
375and "d{" like "dw".
376
377To ignore the starting cursor position and select different text, you can have
378the omap start Visual mode to select the text to be operated upon. Example
379that operates on a function name in the current line: >
380 onoremap <silent> F :<C-U>normal! 0f(hviw<CR>
381The CTRL-U (<C-U>) is used to remove the range that Vim may insert. The
382Normal mode commands find the first '(' character and select the first word
383before it. That usually is the function name.
384
Bram Moolenaar071d4272004-06-13 20:20:40 +0000385To enter a mapping for Normal and Visual mode, but not Operator-pending mode,
386first define it for all three modes, then unmap it for Operator-pending mode:
387 :map xx something-difficult
388 :ounmap xx
389Likewise for a mapping for Visual and Operator-pending mode or Normal and
390Operator-pending mode.
391
392 *language-mapping*
393":lmap" defines a mapping that applies to:
394- Insert mode
395- Command-line mode
396- when entering a search pattern
397- the argument of the commands that accept a text character, such as "r" and
398 "f"
399- for the input() line
400Generally: Whenever a character is to be typed that is part of the text in the
401buffer, not a Vim command character. "Lang-Arg" isn't really another mode,
402it's just used here for this situation.
403 The simplest way to load a set of related language mappings is by using the
404'keymap' option. See |45.5|.
405 In Insert mode and in Command-line mode the mappings can be disabled with
Bram Moolenaar7cba6c02013-09-05 22:13:31 +0200406the CTRL-^ command |i_CTRL-^| |c_CTRL-^|. These commands change the value of
Bram Moolenaar3b1db362013-08-10 15:00:24 +0200407the 'iminsert' option. When starting to enter a normal command line (not a
408search pattern) the mappings are disabled until a CTRL-^ is typed. The state
409last used is remembered for Insert mode and Search patterns separately. The
410state for Insert mode is also used when typing a character as an argument to
411command like "f" or "t".
Bram Moolenaar071d4272004-06-13 20:20:40 +0000412 Language mappings will never be applied to already mapped characters. They
413are only used for typed characters. This assumes that the language mapping
414was already done when typing the mapping.
415
Bram Moolenaar071d4272004-06-13 20:20:40 +0000416
Bram Moolenaar5b962cf2005-12-12 21:58:40 +00004171.4 LISTING MAPPINGS *map-listing*
418
Bram Moolenaar071d4272004-06-13 20:20:40 +0000419When listing mappings the characters in the first two columns are:
420
421 CHAR MODE ~
Bram Moolenaar5c5b0942007-05-06 12:07:59 +0000422 <Space> Normal, Visual, Select and Operator-pending
Bram Moolenaar071d4272004-06-13 20:20:40 +0000423 n Normal
Bram Moolenaar5c5b0942007-05-06 12:07:59 +0000424 v Visual and Select
425 s Select
426 x Visual
Bram Moolenaar071d4272004-06-13 20:20:40 +0000427 o Operator-pending
428 ! Insert and Command-line
429 i Insert
430 l ":lmap" mappings for Insert, Command-line and Lang-Arg
431 c Command-line
Bram Moolenaar63c4e8a2017-09-17 20:32:20 +0200432 t Terminal-Job
Bram Moolenaar071d4272004-06-13 20:20:40 +0000433
434Just before the {rhs} a special character can appear:
435 * indicates that it is not remappable
436 & indicates that only script-local mappings are remappable
437 @ indicates a buffer-local mapping
438
439Everything from the first non-blank after {lhs} up to the end of the line
440(or '|') is considered to be part of {rhs}. This allows the {rhs} to end
441with a space.
442
443Note: When using mappings for Visual mode, you can use the "'<" mark, which
444is the start of the last selected Visual area in the current buffer |'<|.
445
Bram Moolenaar818078d2016-08-27 21:58:42 +0200446The |:filter| command can be used to select what mappings to list. The
447pattern is matched against the {lhs} and {rhs} in the raw form.
448
Bram Moolenaarae5bce12005-08-15 21:41:48 +0000449 *:map-verbose*
450When 'verbose' is non-zero, listing a key map will also display where it was
451last defined. Example: >
452
453 :verbose map <C-W>*
454 n <C-W>* * <C-W><C-S>*
Bram Moolenaarc9b4b052006-04-30 18:54:39 +0000455 Last set from /home/abcd/.vimrc
Bram Moolenaarae5bce12005-08-15 21:41:48 +0000456
Bram Moolenaar5195e452005-08-19 20:32:47 +0000457See |:verbose-cmd| for more information.
Bram Moolenaarae5bce12005-08-15 21:41:48 +0000458
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000459
4601.5 MAPPING SPECIAL KEYS *:map-special-keys*
461
462There are three ways to map a special key:
4631. The Vi-compatible method: Map the key code. Often this is a sequence that
464 starts with <Esc>. To enter a mapping like this you type ":map " and then
465 you have to type CTRL-V before hitting the function key. Note that when
466 the key code for the key is in the termcap (the t_ options), it will
467 automatically be translated into the internal code and become the second
468 way of mapping (unless the 'k' flag is included in 'cpoptions').
4692. The second method is to use the internal code for the function key. To
470 enter such a mapping type CTRL-K and then hit the function key, or use
471 the form "#1", "#2", .. "#9", "#0", "<Up>", "<S-Down>", "<S-F7>", etc.
472 (see table of keys |key-notation|, all keys from <Up> can be used). The
473 first ten function keys can be defined in two ways: Just the number, like
474 "#2", and with "<F>", like "<F2>". Both stand for function key 2. "#0"
475 refers to function key 10, defined with option 't_f10', which may be
476 function key zero on some keyboards. The <> form cannot be used when
477 'cpoptions' includes the '<' flag.
4783. Use the termcap entry, with the form <t_xx>, where "xx" is the name of the
479 termcap entry. Any string entry can be used. For example: >
480 :map <t_F3> G
481< Maps function key 13 to "G". This does not work if 'cpoptions' includes
482 the '<' flag.
483
484The advantage of the second and third method is that the mapping will work on
485different terminals without modification (the function key will be
486translated into the same internal code or the actual key code, no matter what
487terminal you are using. The termcap must be correct for this to work, and you
488must use the same mappings).
489
490DETAIL: Vim first checks if a sequence from the keyboard is mapped. If it
491isn't the terminal key codes are tried (see |terminal-options|). If a
492terminal code is found it is replaced with the internal code. Then the check
493for a mapping is done again (so you can map an internal code to something
494else). What is written into the script file depends on what is recognized.
495If the terminal key code was recognized as a mapping the key code itself is
496written to the script file. If it was recognized as a terminal code the
497internal code is written to the script file.
498
499
5001.6 SPECIAL CHARACTERS *:map-special-chars*
Bram Moolenaar345efa02016-01-15 20:57:49 +0100501 *map_backslash* *map-backslash*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000502Note that only CTRL-V is mentioned here as a special character for mappings
503and abbreviations. When 'cpoptions' does not contain 'B', a backslash can
504also be used like CTRL-V. The <> notation can be fully used then |<>|. But
505you cannot use "<C-V>" like CTRL-V to escape the special meaning of what
506follows.
507
508To map a backslash, or use a backslash literally in the {rhs}, the special
509sequence "<Bslash>" can be used. This avoids the need to double backslashes
510when using nested mappings.
511
Bram Moolenaar345efa02016-01-15 20:57:49 +0100512 *map_CTRL-C* *map-CTRL-C*
Bram Moolenaar1e015462005-09-25 22:16:38 +0000513Using CTRL-C in the {lhs} is possible, but it will only work when Vim is
514waiting for a key, not when Vim is busy with something. When Vim is busy
515CTRL-C interrupts/breaks the command.
516When using the GUI version on MS-Windows CTRL-C can be mapped to allow a Copy
517command to the clipboard. Use CTRL-Break to interrupt Vim.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000518
Bram Moolenaar345efa02016-01-15 20:57:49 +0100519 *map_space_in_lhs* *map-space_in_lhs*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000520To include a space in {lhs} precede it with a CTRL-V (type two CTRL-Vs for
521each space).
Bram Moolenaar345efa02016-01-15 20:57:49 +0100522 *map_space_in_rhs* *map-space_in_rhs*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000523If you want a {rhs} that starts with a space, use "<Space>". To be fully Vi
524compatible (but unreadable) don't use the |<>| notation, precede {rhs} with a
525single CTRL-V (you have to type CTRL-V two times).
Bram Moolenaar345efa02016-01-15 20:57:49 +0100526 *map_empty_rhs* *map-empty-rhs*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000527You can create an empty {rhs} by typing nothing after a single CTRL-V (you
528have to type CTRL-V two times). Unfortunately, you cannot do this in a vimrc
529file.
530 *<Nop>*
Bram Moolenaar446beb42011-05-10 17:18:44 +0200531An easier way to get a mapping that doesn't produce anything, is to use
532"<Nop>" for the {rhs}. This only works when the |<>| notation is enabled.
533For example, to make sure that function key 8 does nothing at all: >
Bram Moolenaar071d4272004-06-13 20:20:40 +0000534 :map <F8> <Nop>
535 :map! <F8> <Nop>
536<
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000537 *map-multibyte*
538It is possible to map multibyte characters, but only the whole character. You
539cannot map the first byte only. This was done to prevent problems in this
540scenario: >
541 :set encoding=latin1
542 :imap <M-C> foo
543 :set encoding=utf-8
544The mapping for <M-C> is defined with the latin1 encoding, resulting in a 0xc3
Bram Moolenaar85eee132018-05-06 17:57:30 +0200545byte. If you type the character á (0xe1 <M-a>) in UTF-8 encoding this is the
Bram Moolenaar446beb42011-05-10 17:18:44 +0200546two bytes 0xc3 0xa1. You don't want the 0xc3 byte to be mapped then or
Bram Moolenaar85eee132018-05-06 17:57:30 +0200547otherwise it would be impossible to type the á character.
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000548
Bram Moolenaar071d4272004-06-13 20:20:40 +0000549 *<Leader>* *mapleader*
550To define a mapping which uses the "mapleader" variable, the special string
551"<Leader>" can be used. It is replaced with the string value of "mapleader".
552If "mapleader" is not set or empty, a backslash is used instead. Example: >
553 :map <Leader>A oanother line<Esc>
554Works like: >
555 :map \A oanother line<Esc>
556But after: >
557 :let mapleader = ","
558It works like: >
559 :map ,A oanother line<Esc>
560
561Note that the value of "mapleader" is used at the moment the mapping is
562defined. Changing "mapleader" after that has no effect for already defined
563mappings.
564
565 *<LocalLeader>* *maplocalleader*
Bram Moolenaara7241f52008-06-24 20:39:31 +0000566<LocalLeader> is just like <Leader>, except that it uses "maplocalleader"
567instead of "mapleader". <LocalLeader> is to be used for mappings which are
568local to a buffer. Example: >
Bram Moolenaarb8ff1fb2012-02-04 21:59:01 +0100569 :map <buffer> <LocalLeader>A oanother line<Esc>
Bram Moolenaar071d4272004-06-13 20:20:40 +0000570<
571In a global plugin <Leader> should be used and in a filetype plugin
572<LocalLeader>. "mapleader" and "maplocalleader" can be equal. Although, if
573you make them different, there is a smaller chance of mappings from global
574plugins to clash with mappings for filetype plugins. For example, you could
575keep "mapleader" at the default backslash, and set "maplocalleader" to an
576underscore.
577
578 *map-<SID>*
579In a script the special key name "<SID>" can be used to define a mapping
580that's local to the script. See |<SID>| for details.
581
582 *<Plug>*
583The special key name "<Plug>" can be used for an internal mapping, which is
584not to be matched with any key sequence. This is useful in plugins
585|using-<Plug>|.
586
587 *<Char>* *<Char->*
588To map a character by its decimal, octal or hexadecimal number the <Char>
589construct can be used:
590 <Char-123> character 123
591 <Char-033> character 27
592 <Char-0x7f> character 127
Bram Moolenaar5302d9e2011-09-14 17:55:08 +0200593 <S-Char-114> character 114 ('r') shifted ('R')
Bram Moolenaar071d4272004-06-13 20:20:40 +0000594This is useful to specify a (multi-byte) character in a 'keymap' file.
595Upper and lowercase differences are ignored.
596
597 *map-comments*
598It is not possible to put a comment after these commands, because the '"'
Bram Moolenaar036986f2017-03-16 17:41:02 +0100599character is considered to be part of the {lhs} or {rhs}. However, one can
600use |", since this starts a new, empty command with a comment.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000601
Bram Moolenaar345efa02016-01-15 20:57:49 +0100602 *map_bar* *map-bar*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000603Since the '|' character is used to separate a map command from the next
604command, you will have to do something special to include a '|' in {rhs}.
605There are three methods:
606 use works when example ~
607 <Bar> '<' is not in 'cpoptions' :map _l :!ls <Bar> more^M
608 \| 'b' is not in 'cpoptions' :map _l :!ls \| more^M
609 ^V| always, in Vim and Vi :map _l :!ls ^V| more^M
610
611(here ^V stands for CTRL-V; to get one CTRL-V you have to type it twice; you
612cannot use the <> notation "<C-V>" here).
613
614All three work when you use the default setting for 'cpoptions'.
615
616When 'b' is present in 'cpoptions', "\|" will be recognized as a mapping
617ending in a '\' and then another command. This is Vi compatible, but
618illogical when compared to other commands.
619
Bram Moolenaar345efa02016-01-15 20:57:49 +0100620 *map_return* *map-return*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000621When you have a mapping that contains an Ex command, you need to put a line
622terminator after it to have it executed. The use of <CR> is recommended for
623this (see |<>|). Example: >
Bram Moolenaar251835e2014-02-24 02:51:51 +0100624 :map _ls :!ls -l %:S<CR>:echo "the end"<CR>
Bram Moolenaar071d4272004-06-13 20:20:40 +0000625
626To avoid mapping of the characters you type in insert or Command-line mode,
627type a CTRL-V first. The mapping in Insert mode is disabled if the 'paste'
628option is on.
Bram Moolenaare2db6952013-07-24 19:53:36 +0200629 *map-error*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000630Note that when an error is encountered (that causes an error message or beep)
631the rest of the mapping is not executed. This is Vi-compatible.
632
633Note that the second character (argument) of the commands @zZtTfF[]rm'`"v
634and CTRL-X is not mapped. This was done to be able to use all the named
635registers and marks, even when the command with the same name has been
636mapped.
637
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000638
6391.7 WHAT KEYS TO MAP *map-which-keys*
640
Bram Moolenaar071d4272004-06-13 20:20:40 +0000641If you are going to map something, you will need to choose which key(s) to use
642for the {lhs}. You will have to avoid keys that are used for Vim commands,
643otherwise you would not be able to use those commands anymore. Here are a few
644suggestions:
645- Function keys <F2>, <F3>, etc.. Also the shifted function keys <S-F1>,
646 <S-F2>, etc. Note that <F1> is already used for the help command.
Bram Moolenaarf91787c2010-07-17 12:47:16 +0200647- Meta-keys (with the ALT key pressed). Depending on your keyboard accented
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +0100648 characters may be used as well. |:map-alt-keys|
Bram Moolenaar071d4272004-06-13 20:20:40 +0000649- Use the '_' or ',' character and then any other character. The "_" and ","
650 commands do exist in Vim (see |_| and |,|), but you probably never use them.
651- Use a key that is a synonym for another command. For example: CTRL-P and
652 CTRL-N. Use an extra character to allow more mappings.
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +0100653- The key defined by <Leader> and one or more other keys. This is especially
654 useful in scripts. |mapleader|
Bram Moolenaar071d4272004-06-13 20:20:40 +0000655
656See the file "index" for keys that are not used and thus can be mapped without
657losing any builtin function. You can also use ":help {key}^D" to find out if
658a key is used for some command. ({key} is the specific key you want to find
659out about, ^D is CTRL-D).
660
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000661
6621.8 EXAMPLES *map-examples*
663
Bram Moolenaar071d4272004-06-13 20:20:40 +0000664A few examples (given as you type them, for "<CR>" you type four characters;
665the '<' flag must not be present in 'cpoptions' for this to work). >
666
667 :map <F3> o#include
668 :map <M-g> /foo<CR>cwbar<Esc>
669 :map _x d/END/e<CR>
670 :map! qq quadrillion questions
Bram Moolenaar5c5b0942007-05-06 12:07:59 +0000671
672
673Multiplying a count
674
675When you type a count before triggering a mapping, it's like the count was
676typed before the {lhs}. For example, with this mapping: >
677 :map <F4> 3w
678Typing 2<F4> will result in "23w". Thus not moving 2 * 3 words but 23 words.
679If you want to multiply counts use the expression register: >
680 :map <F4> @='3w'<CR>
681The part between quotes is the expression being executed. |@=|
682
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000683
6841.9 USING MAPPINGS *map-typing*
685
Bram Moolenaar071d4272004-06-13 20:20:40 +0000686Vim will compare what you type with the start of a mapped sequence. If there
687is an incomplete match, it will get more characters until there either is a
688complete match or until there is no match at all. Example: If you map! "qq",
689the first 'q' will not appear on the screen until you type another
690character. This is because Vim cannot know if the next character will be a
691'q' or not. If the 'timeout' option is on (which is the default) Vim will
692only wait for one second (or as long as specified with the 'timeoutlen'
693option). After that it assumes that the 'q' is to be interpreted as such. If
694you type slowly, or your system is slow, reset the 'timeout' option. Then you
695might want to set the 'ttimeout' option.
696
Bram Moolenaar37c64c72017-09-19 22:06:03 +0200697 *map-precedence*
Bram Moolenaarec7944a2013-06-12 21:29:15 +0200698Buffer-local mappings (defined using |:map-<buffer>|) take precedence over
699global mappings. When a buffer-local mapping is the same as a global mapping,
700Vim will use the buffer-local mapping. In addition, Vim will use a complete
Bram Moolenaar14b69452013-06-29 23:05:20 +0200701mapping immediately if it was defined with <nowait>, even if a longer mapping
702has the same prefix. For example, given the following two mappings: >
703 :map <buffer> <nowait> \a :echo "Local \a"<CR>
704 :map \abc :echo "Global \abc"<CR>
705When typing \a the buffer-local mapping will be used immediately. Vim will
706not wait for more characters to see if the user might be typing \abc.
Bram Moolenaarec7944a2013-06-12 21:29:15 +0200707
Bram Moolenaar071d4272004-06-13 20:20:40 +0000708 *map-keys-fails*
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000709There are situations where key codes might not be recognized:
Bram Moolenaar071d4272004-06-13 20:20:40 +0000710- Vim can only read part of the key code. Mostly this is only the first
711 character. This happens on some Unix versions in an xterm.
712- The key code is after character(s) that are mapped. E.g., "<F1><F1>" or
713 "g<F1>".
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000714
Bram Moolenaar071d4272004-06-13 20:20:40 +0000715The result is that the key code is not recognized in this situation, and the
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000716mapping fails. There are two actions needed to avoid this problem:
717
Bram Moolenaar071d4272004-06-13 20:20:40 +0000718- Remove the 'K' flag from 'cpoptions'. This will make Vim wait for the rest
719 of the characters of the function key.
720- When using <F1> to <F4> the actual key code generated may correspond to
721 <xF1> to <xF4>. There are mappings from <xF1> to <F1>, <xF2> to <F2>, etc.,
722 but these are not recognized after another half a mapping. Make sure the
723 key codes for <F1> to <F4> are correct: >
724 :set <F1>=<type CTRL-V><type F1>
725< Type the <F1> as four characters. The part after the "=" must be done with
726 the actual keys, not the literal text.
727Another solution is to use the actual key code in the mapping for the second
728special key: >
729 :map <F1><Esc>OP :echo "yes"<CR>
730Don't type a real <Esc>, Vim will recognize the key code and replace it with
731<F1> anyway.
732
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000733Another problem may be that when keeping ALT or Meta pressed the terminal
734prepends ESC instead of setting the 8th bit. See |:map-alt-keys|.
735
Bram Moolenaar071d4272004-06-13 20:20:40 +0000736 *recursive_mapping*
737If you include the {lhs} in the {rhs} you have a recursive mapping. When
738{lhs} is typed, it will be replaced with {rhs}. When the {lhs} which is
739included in {rhs} is encountered it will be replaced with {rhs}, and so on.
740This makes it possible to repeat a command an infinite number of times. The
741only problem is that the only way to stop this is by causing an error. The
742macros to solve a maze uses this, look there for an example. There is one
743exception: If the {rhs} starts with {lhs}, the first character is not mapped
744again (this is Vi compatible).
745For example: >
746 :map ab abcd
747will execute the "a" command and insert "bcd" in the text. The "ab" in the
748{rhs} will not be mapped again.
749
750If you want to exchange the meaning of two keys you should use the :noremap
751command. For example: >
752 :noremap k j
753 :noremap j k
754This will exchange the cursor up and down commands.
755
756With the normal :map command, when the 'remap' option is on, mapping takes
757place until the text is found not to be a part of a {lhs}. For example, if
758you use: >
759 :map x y
760 :map y x
761Vim will replace x with y, and then y with x, etc. When this has happened
762'maxmapdepth' times (default 1000), Vim will give the error message
763"recursive mapping".
764
765 *:map-undo*
766If you include an undo command inside a mapped sequence, this will bring the
767text back in the state before executing the macro. This is compatible with
768the original Vi, as long as there is only one undo command in the mapped
769sequence (having two undo commands in a mapped sequence did not make sense
770in the original Vi, you would get back the text before the first undo).
771
Bram Moolenaar071d4272004-06-13 20:20:40 +0000772
Bram Moolenaar5b962cf2005-12-12 21:58:40 +00007731.10 MAPPING ALT-KEYS *:map-alt-keys*
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000774
775In the GUI Vim handles the Alt key itself, thus mapping keys with ALT should
776always work. But in a terminal Vim gets a sequence of bytes and has to figure
777out whether ALT was pressed or not.
778
779By default Vim assumes that pressing the ALT key sets the 8th bit of a typed
Bram Moolenaar97d29a12005-12-17 22:02:57 +0000780character. Most decent terminals can work that way, such as xterm, aterm and
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000781rxvt. If your <A-k> mappings don't work it might be that the terminal is
782prefixing the character with an ESC character. But you can just as well type
783ESC before a character, thus Vim doesn't know what happened (except for
784checking the delay between characters, which is not reliable).
785
786As of this writing, some mainstream terminals like gnome-terminal and konsole
787use the ESC prefix. There doesn't appear a way to have them use the 8th bit
Bram Moolenaar97d29a12005-12-17 22:02:57 +0000788instead. Xterm should work well by default. Aterm and rxvt should work well
789when started with the "--meta8" argument. You can also tweak resources like
790"metaSendsEscape", "eightBitInput" and "eightBitOutput".
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000791
792On the Linux console, this behavior can be toggled with the "setmetamode"
793command. Bear in mind that not using an ESC prefix could get you in trouble
794with other programs. You should make sure that bash has the "convert-meta"
795option set to "on" in order for your Meta keybindings to still work on it
796(it's the default readline behavior, unless changed by specific system
797configuration). For that, you can add the line: >
798
799 set convert-meta on
800
801to your ~/.inputrc file. If you're creating the file, you might want to use: >
802
803 $include /etc/inputrc
804
805as the first line, if that file exists on your system, to keep global options.
806This may cause a problem for entering special characters, such as the umlaut.
807Then you should use CTRL-V before that character.
808
809Bear in mind that convert-meta has been reported to have troubles when used in
810UTF-8 locales. On terminals like xterm, the "metaSendsEscape" resource can be
811toggled on the fly through the "Main Options" menu, by pressing Ctrl-LeftClick
812on the terminal; that's a good last resource in case you want to send ESC when
Bram Moolenaar6aa8cea2017-06-05 14:44:35 +0200813using other applications but not when inside Vim.
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000814
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000815
8161.11 MAPPING AN OPERATOR *:map-operator*
817
818An operator is used before a {motion} command. To define your own operator
819you must create mapping that first sets the 'operatorfunc' option and then
820invoke the |g@| operator. After the user types the {motion} command the
821specified function will be called.
822
Bram Moolenaara40ceaf2006-01-13 22:35:40 +0000823 *g@* *E774* *E775*
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000824g@{motion} Call the function set by the 'operatorfunc' option.
825 The '[ mark is positioned at the start of the text
826 moved over by {motion}, the '] mark on the last
827 character of the text.
828 The function is called with one String argument:
829 "line" {motion} was |linewise|
830 "char" {motion} was |characterwise|
Bram Moolenaarf91787c2010-07-17 12:47:16 +0200831 "block" {motion} was |blockwise-visual|
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000832 Although "block" would rarely appear, since it can
833 only result from Visual mode where "g@" is not useful.
Bram Moolenaardb84e452010-08-15 13:50:43 +0200834 {not available when compiled without the |+eval|
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000835 feature}
836
837Here is an example that counts the number of spaces with <F4>: >
838
839 nmap <silent> <F4> :set opfunc=CountSpaces<CR>g@
840 vmap <silent> <F4> :<C-U>call CountSpaces(visualmode(), 1)<CR>
841
842 function! CountSpaces(type, ...)
843 let sel_save = &selection
844 let &selection = "inclusive"
845 let reg_save = @@
846
Bram Moolenaar822ff862014-06-12 21:46:14 +0200847 if a:0 " Invoked from Visual mode, use gv command.
848 silent exe "normal! gvy"
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000849 elseif a:type == 'line'
850 silent exe "normal! '[V']y"
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000851 else
852 silent exe "normal! `[v`]y"
853 endif
854
855 echomsg strlen(substitute(@@, '[^ ]', '', 'g'))
856
857 let &selection = sel_save
858 let @@ = reg_save
859 endfunction
860
861Note that the 'selection' option is temporarily set to "inclusive" to be able
862to yank exactly the right text by using Visual mode from the '[ to the ']
863mark.
864
865Also note that there is a separate mapping for Visual mode. It removes the
866"'<,'>" range that ":" inserts in Visual mode and invokes the function with
867visualmode() and an extra argument.
868
Bram Moolenaar071d4272004-06-13 20:20:40 +0000869==============================================================================
8702. Abbreviations *abbreviations* *Abbreviations*
871
872Abbreviations are used in Insert mode, Replace mode and Command-line mode.
873If you enter a word that is an abbreviation, it is replaced with the word it
874stands for. This can be used to save typing for often used long words. And
875you can use it to automatically correct obvious spelling errors.
876Examples:
877
Bram Moolenaarc1762cc2007-05-10 16:56:30 +0000878 :iab ms Microsoft
Bram Moolenaar071d4272004-06-13 20:20:40 +0000879 :iab tihs this
880
881There are three types of abbreviations:
882
883full-id The "full-id" type consists entirely of keyword characters (letters
884 and characters from 'iskeyword' option). This is the most common
885 abbreviation.
886
887 Examples: "foo", "g3", "-1"
888
889end-id The "end-id" type ends in a keyword character, but all the other
890 characters are not keyword characters.
891
892 Examples: "#i", "..f", "$/7"
893
894non-id The "non-id" type ends in a non-keyword character, the other
Bram Moolenaar34162142007-05-12 13:12:19 +0000895 characters may be of any type, excluding space and tab. {this type
Bram Moolenaar071d4272004-06-13 20:20:40 +0000896 is not supported by Vi}
897
898 Examples: "def#", "4/7$"
899
900Examples of strings that cannot be abbreviations: "a.b", "#def", "a b", "_$r"
901
902An abbreviation is only recognized when you type a non-keyword character.
903This can also be the <Esc> that ends insert mode or the <CR> that ends a
904command. The non-keyword character which ends the abbreviation is inserted
905after the expanded abbreviation. An exception to this is the character <C-]>,
906which is used to expand an abbreviation without inserting any extra
907characters.
908
909Example: >
910 :ab hh hello
911< "hh<Space>" is expanded to "hello<Space>"
912 "hh<C-]>" is expanded to "hello"
913
914The characters before the cursor must match the abbreviation. Each type has
915an additional rule:
916
917full-id In front of the match is a non-keyword character, or this is where
918 the line or insertion starts. Exception: When the abbreviation is
919 only one character, it is not recognized if there is a non-keyword
Bram Moolenaareb3dc872018-05-13 22:34:24 +0200920 character in front of it, other than a space or a tab. However, for
921 the command line "'<,'>" (or any other marks) is ignored, as if the
922 command line starts after it.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000923
Bram Moolenaar34162142007-05-12 13:12:19 +0000924end-id In front of the match is a keyword character, or a space or a tab,
Bram Moolenaar071d4272004-06-13 20:20:40 +0000925 or this is where the line or insertion starts.
926
Bram Moolenaar34162142007-05-12 13:12:19 +0000927non-id In front of the match is a space, tab or the start of the line or
Bram Moolenaar071d4272004-06-13 20:20:40 +0000928 the insertion.
929
930Examples: ({CURSOR} is where you type a non-keyword character) >
931 :ab foo four old otters
932< " foo{CURSOR}" is expanded to " four old otters"
933 " foobar{CURSOR}" is not expanded
934 "barfoo{CURSOR}" is not expanded
935>
936 :ab #i #include
937< "#i{CURSOR}" is expanded to "#include"
938 ">#i{CURSOR}" is not expanded
939>
Bram Moolenaar81695252004-12-29 20:58:21 +0000940 :ab ;; <endofline>
Bram Moolenaar071d4272004-06-13 20:20:40 +0000941< "test;;" is not expanded
942 "test ;;" is expanded to "test <endofline>"
943
Bram Moolenaar7d76c802014-10-15 22:51:52 +0200944To avoid the abbreviation in Insert mode: Type CTRL-V before the character
945that would trigger the abbreviation. E.g. CTRL-V <Space>. Or type part of
946the abbreviation, exit insert mode with <Esc>, re-enter insert mode with "a"
947and type the rest.
948
Bram Moolenaar071d4272004-06-13 20:20:40 +0000949To avoid the abbreviation in Command-line mode: Type CTRL-V twice somewhere in
950the abbreviation to avoid it to be replaced. A CTRL-V in front of a normal
951character is mostly ignored otherwise.
952
953It is possible to move the cursor after an abbreviation: >
954 :iab if if ()<Left>
955This does not work if 'cpoptions' includes the '<' flag. |<>|
956
957You can even do more complicated things. For example, to consume the space
958typed after an abbreviation: >
959 func Eatchar(pat)
Bram Moolenaar32466aa2006-02-24 23:53:04 +0000960 let c = nr2char(getchar(0))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000961 return (c =~ a:pat) ? '' : c
962 endfunc
963 iabbr <silent> if if ()<Left><C-R>=Eatchar('\s')<CR>
964
965There are no default abbreviations.
966
967Abbreviations are never recursive. You can use ":ab f f-o-o" without any
968problem. But abbreviations can be mapped. {some versions of Vi support
969recursive abbreviations, for no apparent reason}
970
971Abbreviations are disabled if the 'paste' option is on.
972
973 *:abbreviate-local* *:abbreviate-<buffer>*
974Just like mappings, abbreviations can be local to a buffer. This is mostly
975used in a |filetype-plugin| file. Example for a C plugin file: >
976 :abb <buffer> FF for (i = 0; i < ; ++i)
977<
978 *:ab* *:abbreviate*
979:ab[breviate] list all abbreviations. The character in the first
980 column indicates the mode where the abbreviation is
981 used: 'i' for insert mode, 'c' for Command-line
982 mode, '!' for both. These are the same as for
983 mappings, see |map-listing|.
984
Bram Moolenaare344bea2005-09-01 20:46:49 +0000985 *:abbreviate-verbose*
986When 'verbose' is non-zero, listing an abbreviation will also display where it
987was last defined. Example: >
988
989 :verbose abbreviate
Bram Moolenaarc9b4b052006-04-30 18:54:39 +0000990 ! teh the
Bram Moolenaare344bea2005-09-01 20:46:49 +0000991 Last set from /home/abcd/vim/abbr.vim
992
993See |:verbose-cmd| for more information.
994
Bram Moolenaar071d4272004-06-13 20:20:40 +0000995:ab[breviate] {lhs} list the abbreviations that start with {lhs}
996 You may need to insert a CTRL-V (type it twice) to
997 avoid that a typed {lhs} is expanded, since
998 command-line abbreviations apply here.
999
Bram Moolenaar251e1912011-06-19 05:09:16 +02001000:ab[breviate] [<expr>] [<buffer>] {lhs} {rhs}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001001 add abbreviation for {lhs} to {rhs}. If {lhs} already
1002 existed it is replaced with the new {rhs}. {rhs} may
1003 contain spaces.
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00001004 See |:map-<expr>| for the optional <expr> argument.
Bram Moolenaar251e1912011-06-19 05:09:16 +02001005 See |:map-<buffer>| for the optional <buffer> argument.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001006
1007 *:una* *:unabbreviate*
1008:una[bbreviate] {lhs} Remove abbreviation for {lhs} from the list. If none
1009 is found, remove abbreviations in which {lhs} matches
1010 with the {rhs}. This is done so that you can even
1011 remove abbreviations after expansion. To avoid
1012 expansion insert a CTRL-V (type it twice).
1013
1014 *:norea* *:noreabbrev*
Bram Moolenaar251e1912011-06-19 05:09:16 +02001015:norea[bbrev] [<expr>] [<buffer>] [lhs] [rhs]
Bram Moolenaar071d4272004-06-13 20:20:40 +00001016 same as ":ab", but no remapping for this {rhs} {not
1017 in Vi}
1018
1019 *:ca* *:cabbrev*
Bram Moolenaar251e1912011-06-19 05:09:16 +02001020:ca[bbrev] [<expr>] [<buffer>] [lhs] [rhs]
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00001021 same as ":ab", but for Command-line mode only. {not
Bram Moolenaar071d4272004-06-13 20:20:40 +00001022 in Vi}
1023
1024 *:cuna* *:cunabbrev*
1025:cuna[bbrev] {lhs} same as ":una", but for Command-line mode only. {not
1026 in Vi}
1027
1028 *:cnorea* *:cnoreabbrev*
Bram Moolenaar251e1912011-06-19 05:09:16 +02001029:cnorea[bbrev] [<expr>] [<buffer>] [lhs] [rhs]
Bram Moolenaar071d4272004-06-13 20:20:40 +00001030 same as ":ab", but for Command-line mode only and no
1031 remapping for this {rhs} {not in Vi}
1032
1033 *:ia* *:iabbrev*
Bram Moolenaar251e1912011-06-19 05:09:16 +02001034:ia[bbrev] [<expr>] [<buffer>] [lhs] [rhs]
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00001035 same as ":ab", but for Insert mode only. {not in Vi}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001036
1037 *:iuna* *:iunabbrev*
1038:iuna[bbrev] {lhs} same as ":una", but for insert mode only. {not in
1039 Vi}
1040
1041 *:inorea* *:inoreabbrev*
Bram Moolenaar251e1912011-06-19 05:09:16 +02001042:inorea[bbrev] [<expr>] [<buffer>] [lhs] [rhs]
Bram Moolenaar071d4272004-06-13 20:20:40 +00001043 same as ":ab", but for Insert mode only and no
1044 remapping for this {rhs} {not in Vi}
1045
1046 *:abc* *:abclear*
Bram Moolenaar251e1912011-06-19 05:09:16 +02001047:abc[lear] [<buffer>] Remove all abbreviations. {not in Vi}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001048
1049 *:iabc* *:iabclear*
Bram Moolenaar251e1912011-06-19 05:09:16 +02001050:iabc[lear] [<buffer>] Remove all abbreviations for Insert mode. {not in Vi}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001051
1052 *:cabc* *:cabclear*
Bram Moolenaar251e1912011-06-19 05:09:16 +02001053:cabc[lear] [<buffer>] Remove all abbreviations for Command-line mode. {not
Bram Moolenaar071d4272004-06-13 20:20:40 +00001054 in Vi}
1055
1056 *using_CTRL-V*
1057It is possible to use special characters in the rhs of an abbreviation.
1058CTRL-V has to be used to avoid the special meaning of most non printable
1059characters. How many CTRL-Vs need to be typed depends on how you enter the
1060abbreviation. This also applies to mappings. Let's use an example here.
1061
1062Suppose you want to abbreviate "esc" to enter an <Esc> character. When you
1063type the ":ab" command in Vim, you have to enter this: (here ^V is a CTRL-V
1064and ^[ is <Esc>)
1065
1066You type: ab esc ^V^V^V^V^V^[
1067
1068 All keyboard input is subjected to ^V quote interpretation, so
1069 the first, third, and fifth ^V characters simply allow the second,
1070 and fourth ^Vs, and the ^[, to be entered into the command-line.
1071
1072You see: ab esc ^V^V^[
1073
1074 The command-line contains two actual ^Vs before the ^[. This is
1075 how it should appear in your .exrc file, if you choose to go that
1076 route. The first ^V is there to quote the second ^V; the :ab
1077 command uses ^V as its own quote character, so you can include quoted
Bram Moolenaar81695252004-12-29 20:58:21 +00001078 whitespace or the | character in the abbreviation. The :ab command
Bram Moolenaar071d4272004-06-13 20:20:40 +00001079 doesn't do anything special with the ^[ character, so it doesn't need
1080 to be quoted. (Although quoting isn't harmful; that's why typing 7
1081 [but not 8!] ^Vs works.)
1082
1083Stored as: esc ^V^[
1084
1085 After parsing, the abbreviation's short form ("esc") and long form
1086 (the two characters "^V^[") are stored in the abbreviation table.
1087 If you give the :ab command with no arguments, this is how the
1088 abbreviation will be displayed.
1089
1090 Later, when the abbreviation is expanded because the user typed in
1091 the word "esc", the long form is subjected to the same type of
1092 ^V interpretation as keyboard input. So the ^V protects the ^[
Bram Moolenaar81695252004-12-29 20:58:21 +00001093 character from being interpreted as the "exit Insert mode" character.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001094 Instead, the ^[ is inserted into the text.
1095
1096Expands to: ^[
1097
1098[example given by Steve Kirkendall]
1099
1100==============================================================================
11013. Local mappings and functions *script-local*
1102
1103When using several Vim script files, there is the danger that mappings and
1104functions used in one script use the same name as in other scripts. To avoid
1105this, they can be made local to the script.
1106
1107 *<SID>* *<SNR>* *E81*
1108The string "<SID>" can be used in a mapping or menu. This requires that the
1109'<' flag is not present in 'cpoptions'.
1110 When executing the map command, Vim will replace "<SID>" with the special
1111key code <SNR>, followed by a number that's unique for the script, and an
1112underscore. Example: >
1113 :map <SID>Add
1114could define a mapping "<SNR>23_Add".
1115
1116When defining a function in a script, "s:" can be prepended to the name to
1117make it local to the script. But when a mapping is executed from outside of
1118the script, it doesn't know in which script the function was defined. To
1119avoid this problem, use "<SID>" instead of "s:". The same translation is done
1120as for mappings. This makes it possible to define a call to the function in
Bram Moolenaar81695252004-12-29 20:58:21 +00001121a mapping.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001122
1123When a local function is executed, it runs in the context of the script it was
1124defined in. This means that new functions and mappings it defines can also
1125use "s:" or "<SID>" and it will use the same unique number as when the
1126function itself was defined. Also, the "s:var" local script variables can be
1127used.
1128
1129When executing an autocommand or a user command, it will run in the context of
1130the script it was defined in. This makes it possible that the command calls a
1131local function or uses a local mapping.
1132
1133Otherwise, using "<SID>" outside of a script context is an error.
1134
1135If you need to get the script number to use in a complicated script, you can
Bram Moolenaar4770d092006-01-12 23:22:24 +00001136use this function: >
1137 function s:SID()
1138 return matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_SID$')
1139 endfun
Bram Moolenaar071d4272004-06-13 20:20:40 +00001140
1141The "<SNR>" will be shown when listing functions and mappings. This is useful
1142to find out what they are defined to.
1143
1144The |:scriptnames| command can be used to see which scripts have been sourced
1145and what their <SNR> number is.
1146
Bram Moolenaardb84e452010-08-15 13:50:43 +02001147This is all {not in Vi} and {not available when compiled without the |+eval|
Bram Moolenaar071d4272004-06-13 20:20:40 +00001148feature}.
1149
1150==============================================================================
11514. User-defined commands *user-commands*
1152
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001153It is possible to define your own Ex commands. A user-defined command can act
Bram Moolenaar071d4272004-06-13 20:20:40 +00001154just like a built-in command (it can have a range or arguments, arguments can
1155be completed as filenames or buffer names, etc), except that when the command
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +01001156is executed, it is transformed into a normal Ex command and then executed.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001157
1158For starters: See section |40.2| in the user manual.
1159
Bram Moolenaar166af9b2010-11-16 20:34:40 +01001160 *E183* *E841* *user-cmd-ambiguous*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001161All user defined commands must start with an uppercase letter, to avoid
Bram Moolenaar166af9b2010-11-16 20:34:40 +01001162confusion with builtin commands. Exceptions are these builtin commands:
1163 :Next
1164 :X
1165They cannot be used for a user defined command. ":Print" is also an existing
1166command, but it is deprecated and can be overruled.
1167
1168The other characters of the user command can be uppercase letters, lowercase
1169letters or digits. When using digits, note that other commands that take a
1170numeric argument may become ambiguous. For example, the command ":Cc2" could
1171be the user command ":Cc2" without an argument, or the command ":Cc" with
1172argument "2". It is advised to put a space between the command name and the
1173argument to avoid these problems.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001174
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001175When using a user-defined command, the command can be abbreviated. However, if
1176an abbreviation is not unique, an error will be issued. Furthermore, a
Bram Moolenaar071d4272004-06-13 20:20:40 +00001177built-in command will always take precedence.
1178
1179Example: >
1180 :command Rename ...
1181 :command Renumber ...
1182 :Rena " Means "Rename"
1183 :Renu " Means "Renumber"
1184 :Ren " Error - ambiguous
1185 :command Paste ...
1186 :P " The built-in :Print
1187
1188It is recommended that full names for user-defined commands are used in
1189scripts.
1190
1191:com[mand] *:com* *:command*
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001192 List all user-defined commands. When listing commands,
Bram Moolenaar071d4272004-06-13 20:20:40 +00001193 the characters in the first two columns are
1194 ! Command has the -bang attribute
1195 " Command has the -register attribute
1196 b Command is local to current buffer
1197 (see below for details on attributes)
Bram Moolenaar818078d2016-08-27 21:58:42 +02001198 The list can be filtered on command name with
1199 |:filter|, e.g., to list all commands with "Pyth" in
1200 the name: >
1201 filter Pyth command
Bram Moolenaar071d4272004-06-13 20:20:40 +00001202
1203:com[mand] {cmd} List the user-defined commands that start with {cmd}
1204
Bram Moolenaar5b8d8fd2005-08-16 23:01:50 +00001205 *:command-verbose*
1206When 'verbose' is non-zero, listing a command will also display where it was
1207last defined. Example: >
1208
1209 :verbose command TOhtml
Bram Moolenaarc9b4b052006-04-30 18:54:39 +00001210< Name Args Range Complete Definition ~
1211 TOhtml 0 % :call Convert2HTML(<line1>, <line2>) ~
1212 Last set from /usr/share/vim/vim-7.0/plugin/tohtml.vim ~
1213
Bram Moolenaar5195e452005-08-19 20:32:47 +00001214See |:verbose-cmd| for more information.
Bram Moolenaar5b8d8fd2005-08-16 23:01:50 +00001215
Bram Moolenaar071d4272004-06-13 20:20:40 +00001216 *E174* *E182*
1217:com[mand][!] [{attr}...] {cmd} {rep}
1218 Define a user command. The name of the command is
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001219 {cmd} and its replacement text is {rep}. The command's
1220 attributes (see below) are {attr}. If the command
Bram Moolenaar071d4272004-06-13 20:20:40 +00001221 already exists, an error is reported, unless a ! is
1222 specified, in which case the command is redefined.
1223
1224:delc[ommand] {cmd} *:delc* *:delcommand* *E184*
1225 Delete the user-defined command {cmd}.
1226
1227:comc[lear] *:comc* *:comclear*
1228 Delete all user-defined commands.
1229
1230Command attributes
1231
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +01001232User-defined commands are treated by Vim just like any other Ex commands. They
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001233can have arguments, or have a range specified. Arguments are subject to
1234completion as filenames, buffers, etc. Exactly how this works depends upon the
Bram Moolenaar071d4272004-06-13 20:20:40 +00001235command's attributes, which are specified when the command is defined.
1236
1237There are a number of attributes, split into four categories: argument
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001238handling, completion behavior, range handling, and special cases. The
Bram Moolenaar071d4272004-06-13 20:20:40 +00001239attributes are described below, by category.
1240
Bram Moolenaar5c5b0942007-05-06 12:07:59 +00001241Argument handling *E175* *E176* *:command-nargs*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001242
1243By default, a user defined command will take no arguments (and an error is
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001244reported if any are supplied). However, it is possible to specify that the
1245command can take arguments, using the -nargs attribute. Valid cases are:
Bram Moolenaar071d4272004-06-13 20:20:40 +00001246
1247 -nargs=0 No arguments are allowed (the default)
Bram Moolenaar53bfca22012-04-13 23:04:47 +02001248 -nargs=1 Exactly one argument is required, it includes spaces
Bram Moolenaar446beb42011-05-10 17:18:44 +02001249 -nargs=* Any number of arguments are allowed (0, 1, or many),
1250 separated by white space
Bram Moolenaar071d4272004-06-13 20:20:40 +00001251 -nargs=? 0 or 1 arguments are allowed
1252 -nargs=+ Arguments must be supplied, but any number are allowed
1253
Bram Moolenaar34162142007-05-12 13:12:19 +00001254Arguments are considered to be separated by (unescaped) spaces or tabs in this
Bram Moolenaar446beb42011-05-10 17:18:44 +02001255context, except when there is one argument, then the white space is part of
1256the argument.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001257
1258Note that arguments are used as text, not as expressions. Specifically,
1259"s:var" will use the script-local variable in the script where the command was
1260defined, not where it is invoked! Example:
1261 script1.vim: >
1262 :let s:error = "None"
1263 :command -nargs=1 Error echoerr <args>
1264< script2.vim: >
1265 :source script1.vim
1266 :let s:error = "Wrong!"
1267 :Error s:error
Bram Moolenaara7241f52008-06-24 20:39:31 +00001268Executing script2.vim will result in "None" being echoed. Not what you
Bram Moolenaar071d4272004-06-13 20:20:40 +00001269intended! Calling a function may be an alternative.
1270
Bram Moolenaar5c5b0942007-05-06 12:07:59 +00001271Completion behavior *:command-completion* *E179*
1272 *E180* *E181* *:command-complete*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001273By default, the arguments of user defined commands do not undergo completion.
1274However, by specifying one or the other of the following attributes, argument
1275completion can be enabled:
1276
Bram Moolenaarcd43eff2018-03-29 15:55:38 +02001277 -complete=arglist file names in argument list
Bram Moolenaar071d4272004-06-13 20:20:40 +00001278 -complete=augroup autocmd groups
1279 -complete=buffer buffer names
Bram Moolenaar5ae636b2012-04-30 18:48:53 +02001280 -complete=behave :behave suboptions
Bram Moolenaare9edd7f2011-07-20 16:37:24 +02001281 -complete=color color schemes
Bram Moolenaar071d4272004-06-13 20:20:40 +00001282 -complete=command Ex command (and arguments)
Bram Moolenaare9edd7f2011-07-20 16:37:24 +02001283 -complete=compiler compilers
Bram Moolenaar4a748032010-09-30 21:47:56 +02001284 -complete=cscope |:cscope| suboptions
Bram Moolenaar071d4272004-06-13 20:20:40 +00001285 -complete=dir directory names
1286 -complete=environment environment variable names
1287 -complete=event autocommand events
1288 -complete=expression Vim expression
1289 -complete=file file and directory names
Bram Moolenaare9edd7f2011-07-20 16:37:24 +02001290 -complete=file_in_path file and directory names in |'path'|
Bram Moolenaara26559b2010-07-31 14:59:19 +02001291 -complete=filetype filetype names |'filetype'|
Bram Moolenaar071d4272004-06-13 20:20:40 +00001292 -complete=function function name
1293 -complete=help help subjects
1294 -complete=highlight highlight groups
Bram Moolenaar5ae636b2012-04-30 18:48:53 +02001295 -complete=history :history suboptions
Bram Moolenaare9edd7f2011-07-20 16:37:24 +02001296 -complete=locale locale names (as output of locale -a)
Bram Moolenaarcae92dc2017-08-06 15:22:15 +02001297 -complete=mapclear buffer argument
Bram Moolenaar071d4272004-06-13 20:20:40 +00001298 -complete=mapping mapping name
1299 -complete=menu menus
Bram Moolenaar9e507ca2016-10-15 15:39:39 +02001300 -complete=messages |:messages| suboptions
Bram Moolenaar071d4272004-06-13 20:20:40 +00001301 -complete=option options
Bram Moolenaar063b9d12016-07-09 20:21:48 +02001302 -complete=packadd optional package |pack-add| names
Bram Moolenaara26559b2010-07-31 14:59:19 +02001303 -complete=shellcmd Shell command
Bram Moolenaar4a748032010-09-30 21:47:56 +02001304 -complete=sign |:sign| suboptions
Bram Moolenaara26559b2010-07-31 14:59:19 +02001305 -complete=syntax syntax file names |'syntax'|
Bram Moolenaarcd9c4622013-06-08 15:24:48 +02001306 -complete=syntime |:syntime| suboptions
Bram Moolenaar071d4272004-06-13 20:20:40 +00001307 -complete=tag tags
1308 -complete=tag_listfiles tags, file names are shown when CTRL-D is hit
Bram Moolenaar24305862012-08-15 14:05:05 +02001309 -complete=user user names
Bram Moolenaar071d4272004-06-13 20:20:40 +00001310 -complete=var user variables
1311 -complete=custom,{func} custom completion, defined via {func}
Bram Moolenaara466c992005-07-09 21:03:22 +00001312 -complete=customlist,{func} custom completion, defined via {func}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001313
Bram Moolenaar3a991dd2014-10-02 01:41:41 +02001314Note: That some completion methods might expand environment variables.
1315
Bram Moolenaara5792f52005-11-23 21:25:05 +00001316
1317Custom completion *:command-completion-custom*
1318 *:command-completion-customlist*
1319 *E467* *E468*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001320It is possible to define customized completion schemes via the "custom,{func}"
Bram Moolenaara466c992005-07-09 21:03:22 +00001321or the "customlist,{func}" completion argument. The {func} part should be a
Bram Moolenaara7241f52008-06-24 20:39:31 +00001322function with the following signature: >
Bram Moolenaar071d4272004-06-13 20:20:40 +00001323
1324 :function {func}(ArgLead, CmdLine, CursorPos)
1325
Bram Moolenaara466c992005-07-09 21:03:22 +00001326The function need not use all these arguments. The function should provide the
1327completion candidates as the return value.
1328
1329For the "custom" argument, the function should return the completion
1330candidates one per line in a newline separated string.
1331
1332For the "customlist" argument, the function should return the completion
Bram Moolenaara5792f52005-11-23 21:25:05 +00001333candidates as a Vim List. Non-string items in the list are ignored.
Bram Moolenaara466c992005-07-09 21:03:22 +00001334
1335The function arguments are:
Bram Moolenaar071d4272004-06-13 20:20:40 +00001336 ArgLead the leading portion of the argument currently being
1337 completed on
1338 CmdLine the entire command line
Bram Moolenaara5792f52005-11-23 21:25:05 +00001339 CursorPos the cursor position in it (byte index)
Bram Moolenaara466c992005-07-09 21:03:22 +00001340The function may use these for determining context. For the "custom"
1341argument, it is not necessary to filter candidates against the (implicit
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +01001342pattern in) ArgLead. Vim will filter the candidates with its regexp engine
Bram Moolenaara466c992005-07-09 21:03:22 +00001343after function return, and this is probably more efficient in most cases. For
1344the "customlist" argument, Vim will not filter the returned completion
1345candidates and the user supplied function should filter the candidates.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001346
1347The following example lists user names to a Finger command >
1348 :com -complete=custom,ListUsers -nargs=1 Finger !finger <args>
1349 :fun ListUsers(A,L,P)
1350 : return system("cut -d: -f1 /etc/passwd")
1351 :endfun
1352
Bram Moolenaara466c992005-07-09 21:03:22 +00001353The following example completes filenames from the directories specified in
1354the 'path' option: >
1355 :com -nargs=1 -bang -complete=customlist,EditFileComplete
1356 \ EditFile edit<bang> <args>
1357 :fun EditFileComplete(A,L,P)
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +01001358 : return split(globpath(&path, a:A), "\n")
Bram Moolenaara466c992005-07-09 21:03:22 +00001359 :endfun
1360<
Bram Moolenaar5ac3b1a2010-07-27 22:50:36 +02001361This example does not work for file names with spaces!
1362
Bram Moolenaara5792f52005-11-23 21:25:05 +00001363
Bram Moolenaar5c5b0942007-05-06 12:07:59 +00001364Range handling *E177* *E178* *:command-range*
1365 *:command-count*
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001366By default, user-defined commands do not accept a line number range. However,
Bram Moolenaar071d4272004-06-13 20:20:40 +00001367it is possible to specify that the command does take a range (the -range
1368attribute), or that it takes an arbitrary count value, either in the line
1369number position (-range=N, like the |:split| command) or as a "count"
Bram Moolenaar5c5b0942007-05-06 12:07:59 +00001370argument (-count=N, like the |:Next| command). The count will then be
1371available in the argument with |<count>|.
1372
1373Possible attributes are:
Bram Moolenaar071d4272004-06-13 20:20:40 +00001374
1375 -range Range allowed, default is current line
1376 -range=% Range allowed, default is whole file (1,$)
1377 -range=N A count (default N) which is specified in the line
Bram Moolenaar8e5af3e2011-04-28 19:02:44 +02001378 number position (like |:split|); allows for zero line
1379 number.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001380 -count=N A count (default N) which is specified either in the line
Bram Moolenaar32e7b2d2005-02-27 22:36:47 +00001381 number position, or as an initial argument (like |:Next|).
Bram Moolenaar071d4272004-06-13 20:20:40 +00001382 Specifying -count (without a default) acts like -count=0
1383
1384Note that -range=N and -count=N are mutually exclusive - only one should be
1385specified.
1386
Bram Moolenaaraa3b15d2016-04-21 08:53:19 +02001387 *:command-addr*
Bram Moolenaarf1d6ccf2014-12-08 04:16:44 +01001388It is possible that the special characters in the range like ., $ or % which
1389by default correspond to the current line, last line and the whole buffer,
1390relate to arguments, (loaded) buffers, windows or tab pages.
1391
1392Possible values are:
1393 -addr=lines Range of lines (this is the default)
1394 -addr=arguments Range for arguments
1395 -addr=buffers Range for buffers (also not loaded buffers)
1396 -addr=loaded_buffers Range for loaded buffers
1397 -addr=windows Range for windows
1398 -addr=tabs Range for tab pages
1399
Bram Moolenaar5c5b0942007-05-06 12:07:59 +00001400Special cases *:command-bang* *:command-bar*
1401 *:command-register* *:command-buffer*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001402There are some special cases as well:
1403
1404 -bang The command can take a ! modifier (like :q or :w)
1405 -bar The command can be followed by a "|" and another command.
1406 A "|" inside the command argument is not allowed then.
1407 Also checks for a " to start a comment.
1408 -register The first argument to the command can be an optional
1409 register name (like :del, :put, :yank).
1410 -buffer The command will only be available in the current buffer.
1411
1412In the cases of the -count and -register attributes, if the optional argument
1413is supplied, it is removed from the argument list and is available to the
1414replacement text separately.
Bram Moolenaar7cba6c02013-09-05 22:13:31 +02001415Note that these arguments can be abbreviated, but that is a deprecated
1416feature. Use the full name for new scripts.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001417
1418Replacement text
1419
1420The replacement text for a user defined command is scanned for special escape
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001421sequences, using <...> notation. Escape sequences are replaced with values
1422from the entered command line, and all other text is copied unchanged. The
Bram Moolenaar371d5402006-03-20 21:47:49 +00001423resulting string is executed as an Ex command. To avoid the replacement use
Bram Moolenaared39e1d2008-08-09 17:55:22 +00001424<lt> in place of the initial <. Thus to include "<bang>" literally use
Bram Moolenaar371d5402006-03-20 21:47:49 +00001425"<lt>bang>".
Bram Moolenaar071d4272004-06-13 20:20:40 +00001426
1427The valid escape sequences are
1428
1429 *<line1>*
1430 <line1> The starting line of the command range.
1431 *<line2>*
1432 <line2> The final line of the command range.
Bram Moolenaarc168bd42017-09-10 17:34:35 +02001433 *<range>*
1434 <range> The number of items in the command range: 0, 1 or 2
Bram Moolenaar071d4272004-06-13 20:20:40 +00001435 *<count>*
1436 <count> Any count supplied (as described for the '-range'
1437 and '-count' attributes).
1438 *<bang>*
1439 <bang> (See the '-bang' attribute) Expands to a ! if the
1440 command was executed with a ! modifier, otherwise
1441 expands to nothing.
Bram Moolenaar63a60de2016-06-04 22:08:55 +02001442 *<mods>*
1443 <mods> The command modifiers, if specified. Otherwise, expands to
Bram Moolenaarc95a3022016-06-12 23:01:46 +02001444 nothing. Supported modifiers are |:aboveleft|, |:belowright|,
1445 |:botright|, |:browse|, |:confirm|, |:hide|, |:keepalt|,
Bram Moolenaarbc8801c2016-08-02 21:04:33 +02001446 |:keepjumps|, |:keepmarks|, |:keeppatterns|, |:leftabove|,
1447 |:lockmarks|, |:noswapfile| |:rightbelow|, |:silent|, |:tab|,
1448 |:topleft|, |:verbose|, and |:vertical|.
1449 Note that these are not yet supported: |:noautocmd|,
1450 |:sandbox| and |:unsilent|.
Bram Moolenaar63a60de2016-06-04 22:08:55 +02001451 Examples: >
1452 command! -nargs=+ -complete=file MyEdit
1453 \ for f in expand(<q-args>, 0, 1) |
1454 \ exe '<mods> split ' . f |
1455 \ endfor
1456
1457 function! SpecialEdit(files, mods)
1458 for f in expand(a:files, 0, 1)
1459 exe a:mods . ' split ' . f
1460 endfor
1461 endfunction
1462 command! -nargs=+ -complete=file Sedit
1463 \ call SpecialEdit(<q-args>, <q-mods>)
1464<
Bram Moolenaar071d4272004-06-13 20:20:40 +00001465 *<reg>* *<register>*
1466 <reg> (See the '-register' attribute) The optional register,
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001467 if specified. Otherwise, expands to nothing. <register>
Bram Moolenaar071d4272004-06-13 20:20:40 +00001468 is a synonym for this.
1469 *<args>*
1470 <args> The command arguments, exactly as supplied (but as
1471 noted above, any count or register can consume some
1472 of the arguments, which are then not part of <args>).
1473 <lt> A single '<' (Less-Than) character. This is needed if you
1474 want to get a literal copy of one of these escape sequences
1475 into the expansion - for example, to get <bang>, use
1476 <lt>bang>.
1477
1478 *<q-args>*
1479If the first two characters of an escape sequence are "q-" (for example,
1480<q-args>) then the value is quoted in such a way as to make it a valid value
1481for use in an expression. This uses the argument as one single value.
Bram Moolenaar51485f02005-06-04 21:55:20 +00001482When there is no argument <q-args> is an empty string.
Bram Moolenaar552f8a12007-03-08 17:12:08 +00001483 *<f-args>*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001484To allow commands to pass their arguments on to a user-defined function, there
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001485is a special form <f-args> ("function args"). This splits the command
Bram Moolenaar34162142007-05-12 13:12:19 +00001486arguments at spaces and tabs, quotes each argument individually, and the
Bram Moolenaar071d4272004-06-13 20:20:40 +00001487<f-args> sequence is replaced by the comma-separated list of quoted arguments.
Bram Moolenaarc9b4b052006-04-30 18:54:39 +00001488See the Mycmd example below. If no arguments are given <f-args> is removed.
Bram Moolenaar552f8a12007-03-08 17:12:08 +00001489 To embed whitespace into an argument of <f-args>, prepend a backslash.
1490<f-args> replaces every pair of backslashes (\\) with one backslash. A
1491backslash followed by a character other than white space or a backslash
1492remains unmodified. Overview:
1493
1494 command <f-args> ~
1495 XX ab 'ab'
1496 XX a\b 'a\b'
1497 XX a\ b 'a b'
1498 XX a\ b 'a ', 'b'
1499 XX a\\b 'a\b'
1500 XX a\\ b 'a\', 'b'
1501 XX a\\\b 'a\\b'
1502 XX a\\\ b 'a\ b'
1503 XX a\\\\b 'a\\b'
1504 XX a\\\\ b 'a\\', 'b'
Bram Moolenaar071d4272004-06-13 20:20:40 +00001505
1506Examples >
1507
1508 " Delete everything after here to the end
1509 :com Ddel +,$d
1510
1511 " Rename the current buffer
1512 :com -nargs=1 -bang -complete=file Ren f <args>|w<bang>
1513
1514 " Replace a range with the contents of a file
1515 " (Enter this all as one line)
1516 :com -range -nargs=1 -complete=file
1517 Replace <line1>-pu_|<line1>,<line2>d|r <args>|<line1>d
1518
1519 " Count the number of lines in the range
Bram Moolenaar81695252004-12-29 20:58:21 +00001520 :com! -range -nargs=0 Lines echo <line2> - <line1> + 1 "lines"
Bram Moolenaar071d4272004-06-13 20:20:40 +00001521
1522 " Call a user function (example of <f-args>)
1523 :com -nargs=* Mycmd call Myfunc(<f-args>)
1524
1525When executed as: >
1526 :Mycmd arg1 arg2
1527This will invoke: >
1528 :call Myfunc("arg1","arg2")
1529
1530 :" A more substantial example
1531 :function Allargs(command)
Bram Moolenaara7241f52008-06-24 20:39:31 +00001532 : let i = 0
1533 : while i < argc()
1534 : if filereadable(argv(i))
1535 : execute "e " . argv(i)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001536 : execute a:command
1537 : endif
1538 : let i = i + 1
1539 : endwhile
1540 :endfunction
1541 :command -nargs=+ -complete=command Allargs call Allargs(<q-args>)
1542
1543The command Allargs takes any Vim command(s) as argument and executes it on all
1544files in the argument list. Usage example (note use of the "e" flag to ignore
1545errors and the "update" command to write modified buffers): >
1546 :Allargs %s/foo/bar/ge|update
1547This will invoke: >
1548 :call Allargs("%s/foo/bar/ge|update")
1549<
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +01001550When defining a user command in a script, it will be able to call functions
Bram Moolenaar071d4272004-06-13 20:20:40 +00001551local to the script and use mappings local to the script. When the user
1552invokes the user command, it will run in the context of the script it was
1553defined in. This matters if |<SID>| is used in a command.
1554
1555 vim:tw=78:ts=8:ft=help:norl: