blob: 92e21668f00eff9d0e1a135b4bcf02c1ca980b5b [file] [log] [blame]
Bram Moolenaar5302d9e2011-09-14 17:55:08 +02001*map.txt* For Vim version 7.3. Last change: 2011 Aug 19
Bram Moolenaar071d4272004-06-13 20:20:40 +00002
3
4 VIM REFERENCE MANUAL by Bram Moolenaar
5
6
7Key mapping, abbreviations and user-defined commands.
8
9This subject is introduced in sections |05.3|, |24.7| and |40.1| of the user
10manual.
11
121. Key mapping |key-mapping|
Bram Moolenaar5b962cf2005-12-12 21:58:40 +000013 1.1 MAP COMMANDS |:map-commands|
14 1.2 Special arguments |:map-arguments|
15 1.3 Mapping and modes |:map-modes|
16 1.4 Listing mappings |map-listing|
17 1.5 Mapping special keys |:map-special-keys|
18 1.6 Special characters |:map-special-chars|
19 1.7 What keys to map |map-which-keys|
20 1.8 Examples |map-examples|
21 1.9 Using mappings |map-typing|
22 1.10 Mapping alt-keys |:map-alt-keys|
23 1.11 Mapping an operator |:map-operator|
Bram Moolenaar071d4272004-06-13 20:20:40 +0000242. Abbreviations |abbreviations|
253. Local mappings and functions |script-local|
264. User-defined commands |user-commands|
27
28==============================================================================
291. Key mapping *key-mapping* *mapping* *macro*
30
31Key mapping is used to change the meaning of typed keys. The most common use
32is to define a sequence commands for a function key. Example: >
33
34 :map <F2> a<C-R>=strftime("%c")<CR><Esc>
35
Bram Moolenaar402d2fe2005-04-15 21:00:38 +000036This appends the current date and time after the cursor (in <> notation |<>|).
Bram Moolenaar071d4272004-06-13 20:20:40 +000037
Bram Moolenaar5b962cf2005-12-12 21:58:40 +000038
391.1 MAP COMMANDS *:map-commands*
40
Bram Moolenaar071d4272004-06-13 20:20:40 +000041There are commands to enter new mappings, remove mappings and list mappings.
42See |map-overview| for the various forms of "map" and their relationships with
43modes.
44
45{lhs} means left-hand-side *{lhs}*
46{rhs} means right-hand-side *{rhs}*
47
Bram Moolenaar06b5db92006-02-10 23:11:56 +000048:map {lhs} {rhs} |mapmode-nvo| *:map*
49:nm[ap] {lhs} {rhs} |mapmode-n| *:nm* *:nmap*
50:vm[ap] {lhs} {rhs} |mapmode-v| *:vm* *:vmap*
Bram Moolenaar371d5402006-03-20 21:47:49 +000051:xm[ap] {lhs} {rhs} |mapmode-x| *:xm* *:xmap*
52:smap {lhs} {rhs} |mapmode-s| *:smap*
Bram Moolenaar06b5db92006-02-10 23:11:56 +000053:om[ap] {lhs} {rhs} |mapmode-o| *:om* *:omap*
54:map! {lhs} {rhs} |mapmode-ic| *:map!*
55:im[ap] {lhs} {rhs} |mapmode-i| *:im* *:imap*
56:lm[ap] {lhs} {rhs} |mapmode-l| *:lm* *:lmap*
57:cm[ap] {lhs} {rhs} |mapmode-c| *:cm* *:cmap*
Bram Moolenaar071d4272004-06-13 20:20:40 +000058 Map the key sequence {lhs} to {rhs} for the modes
59 where the map command applies. The result, including
60 {rhs}, is then further scanned for mappings. This
61 allows for nested and recursive use of mappings.
62
63
Bram Moolenaar06b5db92006-02-10 23:11:56 +000064:no[remap] {lhs} {rhs} |mapmode-nvo| *:no* *:noremap*
65:nn[oremap] {lhs} {rhs} |mapmode-n| *:nn* *:nnoremap*
66:vn[oremap] {lhs} {rhs} |mapmode-v| *:vn* *:vnoremap*
Bram Moolenaar371d5402006-03-20 21:47:49 +000067:xn[oremap] {lhs} {rhs} |mapmode-x| *:xn* *:xnoremap*
68:snor[emap] {lhs} {rhs} |mapmode-s| *:snor* *:snoremap*
Bram Moolenaar06b5db92006-02-10 23:11:56 +000069:ono[remap] {lhs} {rhs} |mapmode-o| *:ono* *:onoremap*
70:no[remap]! {lhs} {rhs} |mapmode-ic| *:no!* *:noremap!*
71:ino[remap] {lhs} {rhs} |mapmode-i| *:ino* *:inoremap*
72:ln[oremap] {lhs} {rhs} |mapmode-l| *:ln* *:lnoremap*
73:cno[remap] {lhs} {rhs} |mapmode-c| *:cno* *:cnoremap*
Bram Moolenaar071d4272004-06-13 20:20:40 +000074 Map the key sequence {lhs} to {rhs} for the modes
75 where the map command applies. Disallow mapping of
76 {rhs}, to avoid nested and recursive mappings. Often
77 used to redefine a command. {not in Vi}
78
79
Bram Moolenaar06b5db92006-02-10 23:11:56 +000080:unm[ap] {lhs} |mapmode-nvo| *:unm* *:unmap*
81:nun[map] {lhs} |mapmode-n| *:nun* *:nunmap*
82:vu[nmap] {lhs} |mapmode-v| *:vu* *:vunmap*
Bram Moolenaar371d5402006-03-20 21:47:49 +000083:xu[nmap] {lhs} |mapmode-x| *:xu* *:xunmap*
84:sunm[ap] {lhs} |mapmode-s| *:sunm* *:sunmap*
Bram Moolenaar06b5db92006-02-10 23:11:56 +000085:ou[nmap] {lhs} |mapmode-o| *:ou* *:ounmap*
86:unm[ap]! {lhs} |mapmode-ic| *:unm!* *:unmap!*
87:iu[nmap] {lhs} |mapmode-i| *:iu* *:iunmap*
88:lu[nmap] {lhs} |mapmode-l| *:lu* *:lunmap*
89:cu[nmap] {lhs} |mapmode-c| *:cu* *:cunmap*
Bram Moolenaar071d4272004-06-13 20:20:40 +000090 Remove the mapping of {lhs} for the modes where the
91 map command applies. The mapping may remain defined
92 for other modes where it applies.
93 Note: Trailing spaces are included in the {lhs}. This
94 unmap does NOT work: >
95 :map @@ foo
96 :unmap @@ | print
97
Bram Moolenaar06b5db92006-02-10 23:11:56 +000098:mapc[lear] |mapmode-nvo| *:mapc* *:mapclear*
99:nmapc[lear] |mapmode-n| *:nmapc* *:nmapclear*
100:vmapc[lear] |mapmode-v| *:vmapc* *:vmapclear*
Bram Moolenaar371d5402006-03-20 21:47:49 +0000101:xmapc[lear] |mapmode-x| *:xmapc* *:xmapclear*
102:smapc[lear] |mapmode-s| *:smapc* *:smapclear*
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000103:omapc[lear] |mapmode-o| *:omapc* *:omapclear*
104:mapc[lear]! |mapmode-ic| *:mapc!* *:mapclear!*
105:imapc[lear] |mapmode-i| *:imapc* *:imapclear*
106:lmapc[lear] |mapmode-l| *:lmapc* *:lmapclear*
107:cmapc[lear] |mapmode-c| *:cmapc* *:cmapclear*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000108 Remove ALL mappings for the modes where the map
109 command applies. {not in Vi}
Bram Moolenaar251e1912011-06-19 05:09:16 +0200110 Use the <buffer> argument to remove buffer-local
111 mappings |:map-<buffer>|
Bram Moolenaar071d4272004-06-13 20:20:40 +0000112 Warning: This also removes the default mappings.
113
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000114:map |mapmode-nvo|
115:nm[ap] |mapmode-n|
116:vm[ap] |mapmode-v|
Bram Moolenaar371d5402006-03-20 21:47:49 +0000117:xm[ap] |mapmode-x|
118:sm[ap] |mapmode-s|
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000119:om[ap] |mapmode-o|
120:map! |mapmode-ic|
121:im[ap] |mapmode-i|
122:lm[ap] |mapmode-l|
123:cm[ap] |mapmode-c|
Bram Moolenaar071d4272004-06-13 20:20:40 +0000124 List all key mappings for the modes where the map
125 command applies. Note that ":map" and ":map!" are
126 used most often, because they include the other modes.
127
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000128:map {lhs} |mapmode-nvo| *:map_l*
129:nm[ap] {lhs} |mapmode-n| *:nmap_l*
130:vm[ap] {lhs} |mapmode-v| *:vmap_l*
Bram Moolenaar371d5402006-03-20 21:47:49 +0000131:xm[ap] {lhs} |mapmode-x| *:xmap_l*
132:sm[ap] {lhs} |mapmode-s| *:smap_l*
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000133:om[ap] {lhs} |mapmode-o| *:omap_l*
134:map! {lhs} |mapmode-ic| *:map_l!*
135:im[ap] {lhs} |mapmode-i| *:imap_l*
136:lm[ap] {lhs} |mapmode-l| *:lmap_l*
137:cm[ap] {lhs} |mapmode-c| *:cmap_l*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000138 List the key mappings for the key sequences starting
139 with {lhs} in the modes where the map command applies.
140 {not in Vi}
141
142These commands are used to map a key or key sequence to a string of
143characters. You can use this to put command sequences under function keys,
144translate one key into another, etc. See |:mkexrc| for how to save and
145restore the current mappings.
146
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000147 *map-ambiguous*
148When two mappings start with the same sequence of characters, they are
149ambiguous. Example: >
150 :imap aa foo
151 :imap aaa bar
152When Vim has read "aa", it will need to get another character to be able to
153decide if "aa" or "aaa" should be mapped. This means that after typing "aa"
154that mapping won't get expanded yet, Vim is waiting for another character.
155If you type a space, then "foo" will get inserted, plus the space. If you
156type "a", then "bar" will get inserted.
157{Vi does not allow ambiguous mappings}
158
159
1601.2 SPECIAL ARGUMENTS *:map-arguments*
161
Bram Moolenaar9c102382006-05-03 21:26:49 +0000162"<buffer>", "<silent>", "<special>", "<script>", "<expr>" and "<unique>" can
163be used in any order. They must appear right after the command, before any
164other arguments.
Bram Moolenaar4e427192006-03-10 21:34:27 +0000165
Bram Moolenaar071d4272004-06-13 20:20:40 +0000166 *:map-local* *:map-<buffer>* *E224* *E225*
Bram Moolenaarc236c162008-07-13 17:41:49 +0000167If the first argument to one of these commands is "<buffer>" the mapping will
168be effective in the current buffer only. Example: >
Bram Moolenaar071d4272004-06-13 20:20:40 +0000169 :map <buffer> ,w /[.,;]<CR>
170Then you can map ",w" to something else in another buffer: >
171 :map <buffer> ,w /[#&!]<CR>
172The local buffer mappings are used before the global ones.
173The "<buffer>" argument can also be used to clear mappings: >
174 :unmap <buffer> ,w
175 :mapclear <buffer>
176Local mappings are also cleared when a buffer is deleted, but not when it is
177unloaded. Just like local option values.
178
179 *:map-<silent>* *:map-silent*
180To define a mapping which will not be echoed on the command line, add
181"<silent>" as the first argument. Example: >
182 :map <silent> ,h /Header<CR>
183The search string will not be echoed when using this mapping. Messages from
184the executed command are still given though. To shut them up too, add a
185":silent" in the executed command: >
186 :map <silent> ,h :exe ":silent normal /Header\r"<CR>
187Prompts will still be given, e.g., for inputdialog().
188Using "<silent>" for an abbreviation is possible, but will cause redrawing of
189the command line to fail.
190
Bram Moolenaar9c102382006-05-03 21:26:49 +0000191 *:map-<special>* *:map-special*
192Define a mapping with <> notation for special keys, even though the "<" flag
193may appear in 'cpoptions'. This is useful if the side effect of setting
194'cpoptions' is not desired. Example: >
195 :map <special> <F12> /Header<CR>
196<
Bram Moolenaar071d4272004-06-13 20:20:40 +0000197 *:map-<script>* *:map-script*
198If the first argument to one of these commands is "<script>" and it is used to
199define a new mapping or abbreviation, the mapping will only remap characters
200in the {rhs} using mappings that were defined local to a script, starting with
201"<SID>". This can be used to avoid that mappings from outside a script
202interfere (e.g., when CTRL-V is remapped in mswin.vim), but do use other
203mappings defined in the script.
204Note: ":map <script>" and ":noremap <script>" do the same thing. The
205"<script>" overrules the command name. Using ":noremap <script>" is
206preferred, because it's clearer that remapping is (mostly) disabled.
207
208 *:map-<unique>* *E226* *E227*
209If the first argument to one of these commands is "<unique>" and it is used to
210define a new mapping or abbreviation, the command will fail if the mapping or
211abbreviation already exists. Example: >
212 :map <unique> ,w /[#&!]<CR>
213When defining a local mapping, there will also be a check if a global map
214already exists which is equal.
215Example of what will fail: >
216 :map ,w /[#&!]<CR>
217 :map <buffer> <unique> ,w /[.,;]<CR>
Bram Moolenaara40ceaf2006-01-13 22:35:40 +0000218If you want to map a key and then have it do what it was originally mapped to,
219have a look at |maparg()|.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000220
Bram Moolenaar4e427192006-03-10 21:34:27 +0000221 *:map-<expr>* *:map-expression*
222If the first argument to one of these commands is "<expr>" and it is used to
223define a new mapping or abbreviation, the argument is an expression. The
224expression is evaluated to obtain the {rhs} that is used. Example: >
225 :inoremap <expr> . InsertDot()
226The result of the InsertDot() function will be inserted. It could check the
227text before the cursor and start omni completion when some condition is met.
228
Bram Moolenaarda9591e2009-09-30 13:17:02 +0000229For abbreviations |v:char| is set to the character that was typed to trigger
230the abbreviation. You can use this to decide how to expand the {lhs}. You
Bram Moolenaar5302d9e2011-09-14 17:55:08 +0200231should not either insert or change the v:char.
Bram Moolenaarda9591e2009-09-30 13:17:02 +0000232
Bram Moolenaar4e427192006-03-10 21:34:27 +0000233Be very careful about side effects! The expression is evaluated while
Bram Moolenaarc9b4b052006-04-30 18:54:39 +0000234obtaining characters, you may very well make the command dysfunctional.
235For this reason the following is blocked:
Bram Moolenaar5c5b0942007-05-06 12:07:59 +0000236- Changing the buffer text |textlock|.
237- Editing another buffer.
238- The |:normal| command.
239- Moving the cursor is allowed, but it is restored afterwards.
240- You can use getchar(), but the existing typeahead isn't seen and new
241 typeahead is discarded.
Bram Moolenaarc9b4b052006-04-30 18:54:39 +0000242If you want the mapping to do any of these let the returned characters do
243that.
Bram Moolenaar4e427192006-03-10 21:34:27 +0000244
245Here is an example that inserts a list number that increases: >
246 let counter = 0
247 inoremap <expr> <C-L> ListItem()
248 inoremap <expr> <C-R> ListReset()
249
250 func ListItem()
251 let g:counter += 1
252 return g:counter . '. '
253 endfunc
254
255 func ListReset()
256 let g:counter = 0
257 return ''
258 endfunc
259
Bram Moolenaard9967712006-03-11 21:18:15 +0000260CTRL-L inserts the next number, CTRL-R resets the count. CTRL-R returns an
Bram Moolenaar4e427192006-03-10 21:34:27 +0000261empty string, so that nothing is inserted.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000262
Bram Moolenaar8424a622006-04-19 21:23:36 +0000263Note that there are some tricks to make special keys work and escape CSI bytes
264in the text. The |:map| command also does this, thus you must avoid that it
265is done twice. This does not work: >
266 :imap <expr> <F3> "<Char-0x611B>"
267Because the <Char- sequence is escaped for being a |:imap| argument and then
268again for using <expr>. This does work: >
269 :imap <expr> <F3> "\u611B"
270Using 0x80 as a single byte before other text does not work, it will be seen
271as a special key.
272
Bram Moolenaar071d4272004-06-13 20:20:40 +0000273
Bram Moolenaar5b962cf2005-12-12 21:58:40 +00002741.3 MAPPING AND MODES *:map-modes*
Bram Moolenaara7241f52008-06-24 20:39:31 +0000275 *mapmode-nvo* *mapmode-n* *mapmode-v* *mapmode-o*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000276
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +0100277There are six sets of mappings
Bram Moolenaar071d4272004-06-13 20:20:40 +0000278- For Normal mode: When typing commands.
279- For Visual mode: When typing commands while the Visual area is highlighted.
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +0100280- For Select mode: like Visual mode but typing text replaces the selection.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000281- For Operator-pending mode: When an operator is pending (after "d", "y", "c",
Bram Moolenaara7241f52008-06-24 20:39:31 +0000282 etc.). See below: |omap-info|.
Bram Moolenaar402d2fe2005-04-15 21:00:38 +0000283- For Insert mode. These are also used in Replace mode.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000284- For Command-line mode: When entering a ":" or "/" command.
285
Bram Moolenaar071d4272004-06-13 20:20:40 +0000286Special case: While typing a count for a command in Normal mode, mapping zero
287is disabled. This makes it possible to map zero without making it impossible
288to type a count with a zero.
289
290 *map-overview* *map-modes*
291Overview of which map command works in which mode:
292
293 commands: modes: ~
Bram Moolenaarc9b4b052006-04-30 18:54:39 +0000294 Normal Visual+Select Operator-pending ~
295:map :noremap :unmap :mapclear yes yes yes
296:nmap :nnoremap :nunmap :nmapclear yes - -
297:vmap :vnoremap :vunmap :vmapclear - yes -
298:omap :onoremap :ounmap :omapclear - - yes
Bram Moolenaar371d5402006-03-20 21:47:49 +0000299
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000300:nunmap can also be used outside of a monastery.
Bram Moolenaarc9b4b052006-04-30 18:54:39 +0000301 *mapmode-x* *mapmode-s*
Bram Moolenaar371d5402006-03-20 21:47:49 +0000302Some commands work both in Visual and Select mode, some in only one. Note
303that quite often "Visual" is mentioned where both Visual and Select mode
304apply. |Select-mode-mapping|
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +0100305NOTE: Mapping a printable character in Select mode may confuse the user. It's
306better to explicitly use :xmap and :smap for printable characters. Or use
307:sunmap after defining the mapping.
Bram Moolenaar371d5402006-03-20 21:47:49 +0000308
Bram Moolenaarc9b4b052006-04-30 18:54:39 +0000309 commands: modes: ~
310 Visual Select ~
311:vmap :vnoremap :vunmap :vmapclear yes yes
312:xmap :xnoremap :xunmap :xmapclear yes -
313:smap :snoremap :sunmap :smapclear - yes
Bram Moolenaar071d4272004-06-13 20:20:40 +0000314
Bram Moolenaar06b5db92006-02-10 23:11:56 +0000315 *mapmode-ic* *mapmode-i* *mapmode-c* *mapmode-l*
Bram Moolenaar371d5402006-03-20 21:47:49 +0000316Some commands work both in Insert mode and Command-line mode, some not:
317
Bram Moolenaarc9b4b052006-04-30 18:54:39 +0000318 commands: modes: ~
Bram Moolenaar071d4272004-06-13 20:20:40 +0000319 Insert Command-line Lang-Arg ~
320:map! :noremap! :unmap! :mapclear! yes yes -
321:imap :inoremap :iunmap :imapclear yes - -
322:cmap :cnoremap :cunmap :cmapclear - yes -
323:lmap :lnoremap :lunmap :lmapclear yes* yes* yes*
324
325The original Vi did not have separate mappings for
326Normal/Visual/Operator-pending mode and for Insert/Command-line mode.
327Therefore the ":map" and ":map!" commands enter and display mappings for
328several modes. In Vim you can use the ":nmap", ":vmap", ":omap", ":cmap" and
329":imap" commands to enter mappings for each mode separately.
330
Bram Moolenaara7241f52008-06-24 20:39:31 +0000331 *omap-info*
332Operator-pending mappings can be used to define a movement command that can be
333used with any operator. Simple example: ":omap { w" makes "y{" work like "yw"
334and "d{" like "dw".
335
336To ignore the starting cursor position and select different text, you can have
337the omap start Visual mode to select the text to be operated upon. Example
338that operates on a function name in the current line: >
339 onoremap <silent> F :<C-U>normal! 0f(hviw<CR>
340The CTRL-U (<C-U>) is used to remove the range that Vim may insert. The
341Normal mode commands find the first '(' character and select the first word
342before it. That usually is the function name.
343
Bram Moolenaar071d4272004-06-13 20:20:40 +0000344To enter a mapping for Normal and Visual mode, but not Operator-pending mode,
345first define it for all three modes, then unmap it for Operator-pending mode:
346 :map xx something-difficult
347 :ounmap xx
348Likewise for a mapping for Visual and Operator-pending mode or Normal and
349Operator-pending mode.
350
351 *language-mapping*
352":lmap" defines a mapping that applies to:
353- Insert mode
354- Command-line mode
355- when entering a search pattern
356- the argument of the commands that accept a text character, such as "r" and
357 "f"
358- for the input() line
359Generally: Whenever a character is to be typed that is part of the text in the
360buffer, not a Vim command character. "Lang-Arg" isn't really another mode,
361it's just used here for this situation.
362 The simplest way to load a set of related language mappings is by using the
363'keymap' option. See |45.5|.
364 In Insert mode and in Command-line mode the mappings can be disabled with
365the CTRL-^ command |i_CTRL-^| |c_CTRL-^|. When starting to enter a normal
366command line (not a search pattern) the mappings are disabled until a CTRL-^
367is typed. The state last used is remembered for Insert mode and Search
368patterns separately. The state for Insert mode is also used when typing a
369character as an argument to command like "f" or "t".
Bram Moolenaar071d4272004-06-13 20:20:40 +0000370 Language mappings will never be applied to already mapped characters. They
371are only used for typed characters. This assumes that the language mapping
372was already done when typing the mapping.
373
Bram Moolenaar071d4272004-06-13 20:20:40 +0000374
Bram Moolenaar5b962cf2005-12-12 21:58:40 +00003751.4 LISTING MAPPINGS *map-listing*
376
Bram Moolenaar071d4272004-06-13 20:20:40 +0000377When listing mappings the characters in the first two columns are:
378
379 CHAR MODE ~
Bram Moolenaar5c5b0942007-05-06 12:07:59 +0000380 <Space> Normal, Visual, Select and Operator-pending
Bram Moolenaar071d4272004-06-13 20:20:40 +0000381 n Normal
Bram Moolenaar5c5b0942007-05-06 12:07:59 +0000382 v Visual and Select
383 s Select
384 x Visual
Bram Moolenaar071d4272004-06-13 20:20:40 +0000385 o Operator-pending
386 ! Insert and Command-line
387 i Insert
388 l ":lmap" mappings for Insert, Command-line and Lang-Arg
389 c Command-line
390
391Just before the {rhs} a special character can appear:
392 * indicates that it is not remappable
393 & indicates that only script-local mappings are remappable
394 @ indicates a buffer-local mapping
395
396Everything from the first non-blank after {lhs} up to the end of the line
397(or '|') is considered to be part of {rhs}. This allows the {rhs} to end
398with a space.
399
400Note: When using mappings for Visual mode, you can use the "'<" mark, which
401is the start of the last selected Visual area in the current buffer |'<|.
402
Bram Moolenaarae5bce12005-08-15 21:41:48 +0000403 *:map-verbose*
404When 'verbose' is non-zero, listing a key map will also display where it was
405last defined. Example: >
406
407 :verbose map <C-W>*
408 n <C-W>* * <C-W><C-S>*
Bram Moolenaarc9b4b052006-04-30 18:54:39 +0000409 Last set from /home/abcd/.vimrc
Bram Moolenaarae5bce12005-08-15 21:41:48 +0000410
Bram Moolenaar5195e452005-08-19 20:32:47 +0000411See |:verbose-cmd| for more information.
Bram Moolenaarae5bce12005-08-15 21:41:48 +0000412
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000413
4141.5 MAPPING SPECIAL KEYS *:map-special-keys*
415
416There are three ways to map a special key:
4171. The Vi-compatible method: Map the key code. Often this is a sequence that
418 starts with <Esc>. To enter a mapping like this you type ":map " and then
419 you have to type CTRL-V before hitting the function key. Note that when
420 the key code for the key is in the termcap (the t_ options), it will
421 automatically be translated into the internal code and become the second
422 way of mapping (unless the 'k' flag is included in 'cpoptions').
4232. The second method is to use the internal code for the function key. To
424 enter such a mapping type CTRL-K and then hit the function key, or use
425 the form "#1", "#2", .. "#9", "#0", "<Up>", "<S-Down>", "<S-F7>", etc.
426 (see table of keys |key-notation|, all keys from <Up> can be used). The
427 first ten function keys can be defined in two ways: Just the number, like
428 "#2", and with "<F>", like "<F2>". Both stand for function key 2. "#0"
429 refers to function key 10, defined with option 't_f10', which may be
430 function key zero on some keyboards. The <> form cannot be used when
431 'cpoptions' includes the '<' flag.
4323. Use the termcap entry, with the form <t_xx>, where "xx" is the name of the
433 termcap entry. Any string entry can be used. For example: >
434 :map <t_F3> G
435< Maps function key 13 to "G". This does not work if 'cpoptions' includes
436 the '<' flag.
437
438The advantage of the second and third method is that the mapping will work on
439different terminals without modification (the function key will be
440translated into the same internal code or the actual key code, no matter what
441terminal you are using. The termcap must be correct for this to work, and you
442must use the same mappings).
443
444DETAIL: Vim first checks if a sequence from the keyboard is mapped. If it
445isn't the terminal key codes are tried (see |terminal-options|). If a
446terminal code is found it is replaced with the internal code. Then the check
447for a mapping is done again (so you can map an internal code to something
448else). What is written into the script file depends on what is recognized.
449If the terminal key code was recognized as a mapping the key code itself is
450written to the script file. If it was recognized as a terminal code the
451internal code is written to the script file.
452
453
4541.6 SPECIAL CHARACTERS *:map-special-chars*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000455 *map_backslash*
456Note that only CTRL-V is mentioned here as a special character for mappings
457and abbreviations. When 'cpoptions' does not contain 'B', a backslash can
458also be used like CTRL-V. The <> notation can be fully used then |<>|. But
459you cannot use "<C-V>" like CTRL-V to escape the special meaning of what
460follows.
461
462To map a backslash, or use a backslash literally in the {rhs}, the special
463sequence "<Bslash>" can be used. This avoids the need to double backslashes
464when using nested mappings.
465
Bram Moolenaar1e015462005-09-25 22:16:38 +0000466 *map_CTRL-C*
467Using CTRL-C in the {lhs} is possible, but it will only work when Vim is
468waiting for a key, not when Vim is busy with something. When Vim is busy
469CTRL-C interrupts/breaks the command.
470When using the GUI version on MS-Windows CTRL-C can be mapped to allow a Copy
471command to the clipboard. Use CTRL-Break to interrupt Vim.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000472
473 *map_space_in_lhs*
474To include a space in {lhs} precede it with a CTRL-V (type two CTRL-Vs for
475each space).
476 *map_space_in_rhs*
477If you want a {rhs} that starts with a space, use "<Space>". To be fully Vi
478compatible (but unreadable) don't use the |<>| notation, precede {rhs} with a
479single CTRL-V (you have to type CTRL-V two times).
480 *map_empty_rhs*
481You can create an empty {rhs} by typing nothing after a single CTRL-V (you
482have to type CTRL-V two times). Unfortunately, you cannot do this in a vimrc
483file.
484 *<Nop>*
Bram Moolenaar446beb42011-05-10 17:18:44 +0200485An easier way to get a mapping that doesn't produce anything, is to use
486"<Nop>" for the {rhs}. This only works when the |<>| notation is enabled.
487For example, to make sure that function key 8 does nothing at all: >
Bram Moolenaar071d4272004-06-13 20:20:40 +0000488 :map <F8> <Nop>
489 :map! <F8> <Nop>
490<
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000491 *map-multibyte*
492It is possible to map multibyte characters, but only the whole character. You
493cannot map the first byte only. This was done to prevent problems in this
494scenario: >
495 :set encoding=latin1
496 :imap <M-C> foo
497 :set encoding=utf-8
498The mapping for <M-C> is defined with the latin1 encoding, resulting in a 0xc3
Bram Moolenaara7241f52008-06-24 20:39:31 +0000499byte. If you type the character á (0xe1 <M-a>) in UTF-8 encoding this is the
Bram Moolenaar446beb42011-05-10 17:18:44 +0200500two bytes 0xc3 0xa1. You don't want the 0xc3 byte to be mapped then or
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000501otherwise it would be impossible to type the á character.
502
Bram Moolenaar071d4272004-06-13 20:20:40 +0000503 *<Leader>* *mapleader*
504To define a mapping which uses the "mapleader" variable, the special string
505"<Leader>" can be used. It is replaced with the string value of "mapleader".
506If "mapleader" is not set or empty, a backslash is used instead. Example: >
507 :map <Leader>A oanother line<Esc>
508Works like: >
509 :map \A oanother line<Esc>
510But after: >
511 :let mapleader = ","
512It works like: >
513 :map ,A oanother line<Esc>
514
515Note that the value of "mapleader" is used at the moment the mapping is
516defined. Changing "mapleader" after that has no effect for already defined
517mappings.
518
519 *<LocalLeader>* *maplocalleader*
Bram Moolenaara7241f52008-06-24 20:39:31 +0000520<LocalLeader> is just like <Leader>, except that it uses "maplocalleader"
521instead of "mapleader". <LocalLeader> is to be used for mappings which are
522local to a buffer. Example: >
Bram Moolenaar071d4272004-06-13 20:20:40 +0000523 :map <LocalLeader>q \DoItNow
524<
525In a global plugin <Leader> should be used and in a filetype plugin
526<LocalLeader>. "mapleader" and "maplocalleader" can be equal. Although, if
527you make them different, there is a smaller chance of mappings from global
528plugins to clash with mappings for filetype plugins. For example, you could
529keep "mapleader" at the default backslash, and set "maplocalleader" to an
530underscore.
531
532 *map-<SID>*
533In a script the special key name "<SID>" can be used to define a mapping
534that's local to the script. See |<SID>| for details.
535
536 *<Plug>*
537The special key name "<Plug>" can be used for an internal mapping, which is
538not to be matched with any key sequence. This is useful in plugins
539|using-<Plug>|.
540
541 *<Char>* *<Char->*
542To map a character by its decimal, octal or hexadecimal number the <Char>
543construct can be used:
544 <Char-123> character 123
545 <Char-033> character 27
546 <Char-0x7f> character 127
Bram Moolenaar5302d9e2011-09-14 17:55:08 +0200547 <S-Char-114> character 114 ('r') shifted ('R')
Bram Moolenaar071d4272004-06-13 20:20:40 +0000548This is useful to specify a (multi-byte) character in a 'keymap' file.
549Upper and lowercase differences are ignored.
550
551 *map-comments*
552It is not possible to put a comment after these commands, because the '"'
553character is considered to be part of the {lhs} or {rhs}.
554
555 *map_bar*
556Since the '|' character is used to separate a map command from the next
557command, you will have to do something special to include a '|' in {rhs}.
558There are three methods:
559 use works when example ~
560 <Bar> '<' is not in 'cpoptions' :map _l :!ls <Bar> more^M
561 \| 'b' is not in 'cpoptions' :map _l :!ls \| more^M
562 ^V| always, in Vim and Vi :map _l :!ls ^V| more^M
563
564(here ^V stands for CTRL-V; to get one CTRL-V you have to type it twice; you
565cannot use the <> notation "<C-V>" here).
566
567All three work when you use the default setting for 'cpoptions'.
568
569When 'b' is present in 'cpoptions', "\|" will be recognized as a mapping
570ending in a '\' and then another command. This is Vi compatible, but
571illogical when compared to other commands.
572
573 *map_return*
574When you have a mapping that contains an Ex command, you need to put a line
575terminator after it to have it executed. The use of <CR> is recommended for
576this (see |<>|). Example: >
577 :map _ls :!ls -l %<CR>:echo "the end"<CR>
578
579To avoid mapping of the characters you type in insert or Command-line mode,
580type a CTRL-V first. The mapping in Insert mode is disabled if the 'paste'
581option is on.
582
583Note that when an error is encountered (that causes an error message or beep)
584the rest of the mapping is not executed. This is Vi-compatible.
585
586Note that the second character (argument) of the commands @zZtTfF[]rm'`"v
587and CTRL-X is not mapped. This was done to be able to use all the named
588registers and marks, even when the command with the same name has been
589mapped.
590
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000591
5921.7 WHAT KEYS TO MAP *map-which-keys*
593
Bram Moolenaar071d4272004-06-13 20:20:40 +0000594If you are going to map something, you will need to choose which key(s) to use
595for the {lhs}. You will have to avoid keys that are used for Vim commands,
596otherwise you would not be able to use those commands anymore. Here are a few
597suggestions:
598- Function keys <F2>, <F3>, etc.. Also the shifted function keys <S-F1>,
599 <S-F2>, etc. Note that <F1> is already used for the help command.
Bram Moolenaarf91787c2010-07-17 12:47:16 +0200600- Meta-keys (with the ALT key pressed). Depending on your keyboard accented
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +0100601 characters may be used as well. |:map-alt-keys|
Bram Moolenaar071d4272004-06-13 20:20:40 +0000602- Use the '_' or ',' character and then any other character. The "_" and ","
603 commands do exist in Vim (see |_| and |,|), but you probably never use them.
604- Use a key that is a synonym for another command. For example: CTRL-P and
605 CTRL-N. Use an extra character to allow more mappings.
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +0100606- The key defined by <Leader> and one or more other keys. This is especially
607 useful in scripts. |mapleader|
Bram Moolenaar071d4272004-06-13 20:20:40 +0000608
609See the file "index" for keys that are not used and thus can be mapped without
610losing any builtin function. You can also use ":help {key}^D" to find out if
611a key is used for some command. ({key} is the specific key you want to find
612out about, ^D is CTRL-D).
613
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000614
6151.8 EXAMPLES *map-examples*
616
Bram Moolenaar071d4272004-06-13 20:20:40 +0000617A few examples (given as you type them, for "<CR>" you type four characters;
618the '<' flag must not be present in 'cpoptions' for this to work). >
619
620 :map <F3> o#include
621 :map <M-g> /foo<CR>cwbar<Esc>
622 :map _x d/END/e<CR>
623 :map! qq quadrillion questions
Bram Moolenaar5c5b0942007-05-06 12:07:59 +0000624
625
626Multiplying a count
627
628When you type a count before triggering a mapping, it's like the count was
629typed before the {lhs}. For example, with this mapping: >
630 :map <F4> 3w
631Typing 2<F4> will result in "23w". Thus not moving 2 * 3 words but 23 words.
632If you want to multiply counts use the expression register: >
633 :map <F4> @='3w'<CR>
634The part between quotes is the expression being executed. |@=|
635
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000636
6371.9 USING MAPPINGS *map-typing*
638
Bram Moolenaar071d4272004-06-13 20:20:40 +0000639Vim will compare what you type with the start of a mapped sequence. If there
640is an incomplete match, it will get more characters until there either is a
641complete match or until there is no match at all. Example: If you map! "qq",
642the first 'q' will not appear on the screen until you type another
643character. This is because Vim cannot know if the next character will be a
644'q' or not. If the 'timeout' option is on (which is the default) Vim will
645only wait for one second (or as long as specified with the 'timeoutlen'
646option). After that it assumes that the 'q' is to be interpreted as such. If
647you type slowly, or your system is slow, reset the 'timeout' option. Then you
648might want to set the 'ttimeout' option.
649
650 *map-keys-fails*
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000651There are situations where key codes might not be recognized:
Bram Moolenaar071d4272004-06-13 20:20:40 +0000652- Vim can only read part of the key code. Mostly this is only the first
653 character. This happens on some Unix versions in an xterm.
654- The key code is after character(s) that are mapped. E.g., "<F1><F1>" or
655 "g<F1>".
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000656
Bram Moolenaar071d4272004-06-13 20:20:40 +0000657The result is that the key code is not recognized in this situation, and the
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000658mapping fails. There are two actions needed to avoid this problem:
659
Bram Moolenaar071d4272004-06-13 20:20:40 +0000660- Remove the 'K' flag from 'cpoptions'. This will make Vim wait for the rest
661 of the characters of the function key.
662- When using <F1> to <F4> the actual key code generated may correspond to
663 <xF1> to <xF4>. There are mappings from <xF1> to <F1>, <xF2> to <F2>, etc.,
664 but these are not recognized after another half a mapping. Make sure the
665 key codes for <F1> to <F4> are correct: >
666 :set <F1>=<type CTRL-V><type F1>
667< Type the <F1> as four characters. The part after the "=" must be done with
668 the actual keys, not the literal text.
669Another solution is to use the actual key code in the mapping for the second
670special key: >
671 :map <F1><Esc>OP :echo "yes"<CR>
672Don't type a real <Esc>, Vim will recognize the key code and replace it with
673<F1> anyway.
674
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000675Another problem may be that when keeping ALT or Meta pressed the terminal
676prepends ESC instead of setting the 8th bit. See |:map-alt-keys|.
677
Bram Moolenaar071d4272004-06-13 20:20:40 +0000678 *recursive_mapping*
679If you include the {lhs} in the {rhs} you have a recursive mapping. When
680{lhs} is typed, it will be replaced with {rhs}. When the {lhs} which is
681included in {rhs} is encountered it will be replaced with {rhs}, and so on.
682This makes it possible to repeat a command an infinite number of times. The
683only problem is that the only way to stop this is by causing an error. The
684macros to solve a maze uses this, look there for an example. There is one
685exception: If the {rhs} starts with {lhs}, the first character is not mapped
686again (this is Vi compatible).
687For example: >
688 :map ab abcd
689will execute the "a" command and insert "bcd" in the text. The "ab" in the
690{rhs} will not be mapped again.
691
692If you want to exchange the meaning of two keys you should use the :noremap
693command. For example: >
694 :noremap k j
695 :noremap j k
696This will exchange the cursor up and down commands.
697
698With the normal :map command, when the 'remap' option is on, mapping takes
699place until the text is found not to be a part of a {lhs}. For example, if
700you use: >
701 :map x y
702 :map y x
703Vim will replace x with y, and then y with x, etc. When this has happened
704'maxmapdepth' times (default 1000), Vim will give the error message
705"recursive mapping".
706
707 *:map-undo*
708If you include an undo command inside a mapped sequence, this will bring the
709text back in the state before executing the macro. This is compatible with
710the original Vi, as long as there is only one undo command in the mapped
711sequence (having two undo commands in a mapped sequence did not make sense
712in the original Vi, you would get back the text before the first undo).
713
Bram Moolenaar071d4272004-06-13 20:20:40 +0000714
Bram Moolenaar5b962cf2005-12-12 21:58:40 +00007151.10 MAPPING ALT-KEYS *:map-alt-keys*
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000716
717In the GUI Vim handles the Alt key itself, thus mapping keys with ALT should
718always work. But in a terminal Vim gets a sequence of bytes and has to figure
719out whether ALT was pressed or not.
720
721By default Vim assumes that pressing the ALT key sets the 8th bit of a typed
Bram Moolenaar97d29a12005-12-17 22:02:57 +0000722character. Most decent terminals can work that way, such as xterm, aterm and
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000723rxvt. If your <A-k> mappings don't work it might be that the terminal is
724prefixing the character with an ESC character. But you can just as well type
725ESC before a character, thus Vim doesn't know what happened (except for
726checking the delay between characters, which is not reliable).
727
728As of this writing, some mainstream terminals like gnome-terminal and konsole
729use the ESC prefix. There doesn't appear a way to have them use the 8th bit
Bram Moolenaar97d29a12005-12-17 22:02:57 +0000730instead. Xterm should work well by default. Aterm and rxvt should work well
731when started with the "--meta8" argument. You can also tweak resources like
732"metaSendsEscape", "eightBitInput" and "eightBitOutput".
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +0000733
734On the Linux console, this behavior can be toggled with the "setmetamode"
735command. Bear in mind that not using an ESC prefix could get you in trouble
736with other programs. You should make sure that bash has the "convert-meta"
737option set to "on" in order for your Meta keybindings to still work on it
738(it's the default readline behavior, unless changed by specific system
739configuration). For that, you can add the line: >
740
741 set convert-meta on
742
743to your ~/.inputrc file. If you're creating the file, you might want to use: >
744
745 $include /etc/inputrc
746
747as the first line, if that file exists on your system, to keep global options.
748This may cause a problem for entering special characters, such as the umlaut.
749Then you should use CTRL-V before that character.
750
751Bear in mind that convert-meta has been reported to have troubles when used in
752UTF-8 locales. On terminals like xterm, the "metaSendsEscape" resource can be
753toggled on the fly through the "Main Options" menu, by pressing Ctrl-LeftClick
754on the terminal; that's a good last resource in case you want to send ESC when
755using other applications but not when inside VIM.
756
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000757
7581.11 MAPPING AN OPERATOR *:map-operator*
759
760An operator is used before a {motion} command. To define your own operator
761you must create mapping that first sets the 'operatorfunc' option and then
762invoke the |g@| operator. After the user types the {motion} command the
763specified function will be called.
764
Bram Moolenaara40ceaf2006-01-13 22:35:40 +0000765 *g@* *E774* *E775*
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000766g@{motion} Call the function set by the 'operatorfunc' option.
767 The '[ mark is positioned at the start of the text
768 moved over by {motion}, the '] mark on the last
769 character of the text.
770 The function is called with one String argument:
771 "line" {motion} was |linewise|
772 "char" {motion} was |characterwise|
Bram Moolenaarf91787c2010-07-17 12:47:16 +0200773 "block" {motion} was |blockwise-visual|
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000774 Although "block" would rarely appear, since it can
775 only result from Visual mode where "g@" is not useful.
Bram Moolenaardb84e452010-08-15 13:50:43 +0200776 {not available when compiled without the |+eval|
Bram Moolenaar5b962cf2005-12-12 21:58:40 +0000777 feature}
778
779Here is an example that counts the number of spaces with <F4>: >
780
781 nmap <silent> <F4> :set opfunc=CountSpaces<CR>g@
782 vmap <silent> <F4> :<C-U>call CountSpaces(visualmode(), 1)<CR>
783
784 function! CountSpaces(type, ...)
785 let sel_save = &selection
786 let &selection = "inclusive"
787 let reg_save = @@
788
789 if a:0 " Invoked from Visual mode, use '< and '> marks.
790 silent exe "normal! `<" . a:type . "`>y"
791 elseif a:type == 'line'
792 silent exe "normal! '[V']y"
793 elseif a:type == 'block'
794 silent exe "normal! `[\<C-V>`]y"
795 else
796 silent exe "normal! `[v`]y"
797 endif
798
799 echomsg strlen(substitute(@@, '[^ ]', '', 'g'))
800
801 let &selection = sel_save
802 let @@ = reg_save
803 endfunction
804
805Note that the 'selection' option is temporarily set to "inclusive" to be able
806to yank exactly the right text by using Visual mode from the '[ to the ']
807mark.
808
809Also note that there is a separate mapping for Visual mode. It removes the
810"'<,'>" range that ":" inserts in Visual mode and invokes the function with
811visualmode() and an extra argument.
812
Bram Moolenaar071d4272004-06-13 20:20:40 +0000813==============================================================================
8142. Abbreviations *abbreviations* *Abbreviations*
815
816Abbreviations are used in Insert mode, Replace mode and Command-line mode.
817If you enter a word that is an abbreviation, it is replaced with the word it
818stands for. This can be used to save typing for often used long words. And
819you can use it to automatically correct obvious spelling errors.
820Examples:
821
Bram Moolenaarc1762cc2007-05-10 16:56:30 +0000822 :iab ms Microsoft
Bram Moolenaar071d4272004-06-13 20:20:40 +0000823 :iab tihs this
824
825There are three types of abbreviations:
826
827full-id The "full-id" type consists entirely of keyword characters (letters
828 and characters from 'iskeyword' option). This is the most common
829 abbreviation.
830
831 Examples: "foo", "g3", "-1"
832
833end-id The "end-id" type ends in a keyword character, but all the other
834 characters are not keyword characters.
835
836 Examples: "#i", "..f", "$/7"
837
838non-id The "non-id" type ends in a non-keyword character, the other
Bram Moolenaar34162142007-05-12 13:12:19 +0000839 characters may be of any type, excluding space and tab. {this type
Bram Moolenaar071d4272004-06-13 20:20:40 +0000840 is not supported by Vi}
841
842 Examples: "def#", "4/7$"
843
844Examples of strings that cannot be abbreviations: "a.b", "#def", "a b", "_$r"
845
846An abbreviation is only recognized when you type a non-keyword character.
847This can also be the <Esc> that ends insert mode or the <CR> that ends a
848command. The non-keyword character which ends the abbreviation is inserted
849after the expanded abbreviation. An exception to this is the character <C-]>,
850which is used to expand an abbreviation without inserting any extra
851characters.
852
853Example: >
854 :ab hh hello
855< "hh<Space>" is expanded to "hello<Space>"
856 "hh<C-]>" is expanded to "hello"
857
858The characters before the cursor must match the abbreviation. Each type has
859an additional rule:
860
861full-id In front of the match is a non-keyword character, or this is where
862 the line or insertion starts. Exception: When the abbreviation is
863 only one character, it is not recognized if there is a non-keyword
Bram Moolenaar34162142007-05-12 13:12:19 +0000864 character in front of it, other than a space or a tab.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000865
Bram Moolenaar34162142007-05-12 13:12:19 +0000866end-id In front of the match is a keyword character, or a space or a tab,
Bram Moolenaar071d4272004-06-13 20:20:40 +0000867 or this is where the line or insertion starts.
868
Bram Moolenaar34162142007-05-12 13:12:19 +0000869non-id In front of the match is a space, tab or the start of the line or
Bram Moolenaar071d4272004-06-13 20:20:40 +0000870 the insertion.
871
872Examples: ({CURSOR} is where you type a non-keyword character) >
873 :ab foo four old otters
874< " foo{CURSOR}" is expanded to " four old otters"
875 " foobar{CURSOR}" is not expanded
876 "barfoo{CURSOR}" is not expanded
877>
878 :ab #i #include
879< "#i{CURSOR}" is expanded to "#include"
880 ">#i{CURSOR}" is not expanded
881>
Bram Moolenaar81695252004-12-29 20:58:21 +0000882 :ab ;; <endofline>
Bram Moolenaar071d4272004-06-13 20:20:40 +0000883< "test;;" is not expanded
884 "test ;;" is expanded to "test <endofline>"
885
886To avoid the abbreviation in insert mode: Type part of the abbreviation, exit
887insert mode with <Esc>, re-enter insert mode with "a" and type the rest. Or
888type CTRL-V before the character after the abbreviation.
889To avoid the abbreviation in Command-line mode: Type CTRL-V twice somewhere in
890the abbreviation to avoid it to be replaced. A CTRL-V in front of a normal
891character is mostly ignored otherwise.
892
893It is possible to move the cursor after an abbreviation: >
894 :iab if if ()<Left>
895This does not work if 'cpoptions' includes the '<' flag. |<>|
896
897You can even do more complicated things. For example, to consume the space
898typed after an abbreviation: >
899 func Eatchar(pat)
Bram Moolenaar32466aa2006-02-24 23:53:04 +0000900 let c = nr2char(getchar(0))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000901 return (c =~ a:pat) ? '' : c
902 endfunc
903 iabbr <silent> if if ()<Left><C-R>=Eatchar('\s')<CR>
904
905There are no default abbreviations.
906
907Abbreviations are never recursive. You can use ":ab f f-o-o" without any
908problem. But abbreviations can be mapped. {some versions of Vi support
909recursive abbreviations, for no apparent reason}
910
911Abbreviations are disabled if the 'paste' option is on.
912
913 *:abbreviate-local* *:abbreviate-<buffer>*
914Just like mappings, abbreviations can be local to a buffer. This is mostly
915used in a |filetype-plugin| file. Example for a C plugin file: >
916 :abb <buffer> FF for (i = 0; i < ; ++i)
917<
918 *:ab* *:abbreviate*
919:ab[breviate] list all abbreviations. The character in the first
920 column indicates the mode where the abbreviation is
921 used: 'i' for insert mode, 'c' for Command-line
922 mode, '!' for both. These are the same as for
923 mappings, see |map-listing|.
924
Bram Moolenaare344bea2005-09-01 20:46:49 +0000925 *:abbreviate-verbose*
926When 'verbose' is non-zero, listing an abbreviation will also display where it
927was last defined. Example: >
928
929 :verbose abbreviate
Bram Moolenaarc9b4b052006-04-30 18:54:39 +0000930 ! teh the
Bram Moolenaare344bea2005-09-01 20:46:49 +0000931 Last set from /home/abcd/vim/abbr.vim
932
933See |:verbose-cmd| for more information.
934
Bram Moolenaar071d4272004-06-13 20:20:40 +0000935:ab[breviate] {lhs} list the abbreviations that start with {lhs}
936 You may need to insert a CTRL-V (type it twice) to
937 avoid that a typed {lhs} is expanded, since
938 command-line abbreviations apply here.
939
Bram Moolenaar251e1912011-06-19 05:09:16 +0200940:ab[breviate] [<expr>] [<buffer>] {lhs} {rhs}
Bram Moolenaar071d4272004-06-13 20:20:40 +0000941 add abbreviation for {lhs} to {rhs}. If {lhs} already
942 existed it is replaced with the new {rhs}. {rhs} may
943 contain spaces.
Bram Moolenaarfc1421e2006-04-20 22:17:20 +0000944 See |:map-<expr>| for the optional <expr> argument.
Bram Moolenaar251e1912011-06-19 05:09:16 +0200945 See |:map-<buffer>| for the optional <buffer> argument.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000946
947 *:una* *:unabbreviate*
948:una[bbreviate] {lhs} Remove abbreviation for {lhs} from the list. If none
949 is found, remove abbreviations in which {lhs} matches
950 with the {rhs}. This is done so that you can even
951 remove abbreviations after expansion. To avoid
952 expansion insert a CTRL-V (type it twice).
953
954 *:norea* *:noreabbrev*
Bram Moolenaar251e1912011-06-19 05:09:16 +0200955:norea[bbrev] [<expr>] [<buffer>] [lhs] [rhs]
Bram Moolenaar071d4272004-06-13 20:20:40 +0000956 same as ":ab", but no remapping for this {rhs} {not
957 in Vi}
958
959 *:ca* *:cabbrev*
Bram Moolenaar251e1912011-06-19 05:09:16 +0200960:ca[bbrev] [<expr>] [<buffer>] [lhs] [rhs]
Bram Moolenaarfc1421e2006-04-20 22:17:20 +0000961 same as ":ab", but for Command-line mode only. {not
Bram Moolenaar071d4272004-06-13 20:20:40 +0000962 in Vi}
963
964 *:cuna* *:cunabbrev*
965:cuna[bbrev] {lhs} same as ":una", but for Command-line mode only. {not
966 in Vi}
967
968 *:cnorea* *:cnoreabbrev*
Bram Moolenaar251e1912011-06-19 05:09:16 +0200969:cnorea[bbrev] [<expr>] [<buffer>] [lhs] [rhs]
Bram Moolenaar071d4272004-06-13 20:20:40 +0000970 same as ":ab", but for Command-line mode only and no
971 remapping for this {rhs} {not in Vi}
972
973 *:ia* *:iabbrev*
Bram Moolenaar251e1912011-06-19 05:09:16 +0200974:ia[bbrev] [<expr>] [<buffer>] [lhs] [rhs]
Bram Moolenaarfc1421e2006-04-20 22:17:20 +0000975 same as ":ab", but for Insert mode only. {not in Vi}
Bram Moolenaar071d4272004-06-13 20:20:40 +0000976
977 *:iuna* *:iunabbrev*
978:iuna[bbrev] {lhs} same as ":una", but for insert mode only. {not in
979 Vi}
980
981 *:inorea* *:inoreabbrev*
Bram Moolenaar251e1912011-06-19 05:09:16 +0200982:inorea[bbrev] [<expr>] [<buffer>] [lhs] [rhs]
Bram Moolenaar071d4272004-06-13 20:20:40 +0000983 same as ":ab", but for Insert mode only and no
984 remapping for this {rhs} {not in Vi}
985
986 *:abc* *:abclear*
Bram Moolenaar251e1912011-06-19 05:09:16 +0200987:abc[lear] [<buffer>] Remove all abbreviations. {not in Vi}
Bram Moolenaar071d4272004-06-13 20:20:40 +0000988
989 *:iabc* *:iabclear*
Bram Moolenaar251e1912011-06-19 05:09:16 +0200990:iabc[lear] [<buffer>] Remove all abbreviations for Insert mode. {not in Vi}
Bram Moolenaar071d4272004-06-13 20:20:40 +0000991
992 *:cabc* *:cabclear*
Bram Moolenaar251e1912011-06-19 05:09:16 +0200993:cabc[lear] [<buffer>] Remove all abbreviations for Command-line mode. {not
Bram Moolenaar071d4272004-06-13 20:20:40 +0000994 in Vi}
995
996 *using_CTRL-V*
997It is possible to use special characters in the rhs of an abbreviation.
998CTRL-V has to be used to avoid the special meaning of most non printable
999characters. How many CTRL-Vs need to be typed depends on how you enter the
1000abbreviation. This also applies to mappings. Let's use an example here.
1001
1002Suppose you want to abbreviate "esc" to enter an <Esc> character. When you
1003type the ":ab" command in Vim, you have to enter this: (here ^V is a CTRL-V
1004and ^[ is <Esc>)
1005
1006You type: ab esc ^V^V^V^V^V^[
1007
1008 All keyboard input is subjected to ^V quote interpretation, so
1009 the first, third, and fifth ^V characters simply allow the second,
1010 and fourth ^Vs, and the ^[, to be entered into the command-line.
1011
1012You see: ab esc ^V^V^[
1013
1014 The command-line contains two actual ^Vs before the ^[. This is
1015 how it should appear in your .exrc file, if you choose to go that
1016 route. The first ^V is there to quote the second ^V; the :ab
1017 command uses ^V as its own quote character, so you can include quoted
Bram Moolenaar81695252004-12-29 20:58:21 +00001018 whitespace or the | character in the abbreviation. The :ab command
Bram Moolenaar071d4272004-06-13 20:20:40 +00001019 doesn't do anything special with the ^[ character, so it doesn't need
1020 to be quoted. (Although quoting isn't harmful; that's why typing 7
1021 [but not 8!] ^Vs works.)
1022
1023Stored as: esc ^V^[
1024
1025 After parsing, the abbreviation's short form ("esc") and long form
1026 (the two characters "^V^[") are stored in the abbreviation table.
1027 If you give the :ab command with no arguments, this is how the
1028 abbreviation will be displayed.
1029
1030 Later, when the abbreviation is expanded because the user typed in
1031 the word "esc", the long form is subjected to the same type of
1032 ^V interpretation as keyboard input. So the ^V protects the ^[
Bram Moolenaar81695252004-12-29 20:58:21 +00001033 character from being interpreted as the "exit Insert mode" character.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001034 Instead, the ^[ is inserted into the text.
1035
1036Expands to: ^[
1037
1038[example given by Steve Kirkendall]
1039
1040==============================================================================
10413. Local mappings and functions *script-local*
1042
1043When using several Vim script files, there is the danger that mappings and
1044functions used in one script use the same name as in other scripts. To avoid
1045this, they can be made local to the script.
1046
1047 *<SID>* *<SNR>* *E81*
1048The string "<SID>" can be used in a mapping or menu. This requires that the
1049'<' flag is not present in 'cpoptions'.
1050 When executing the map command, Vim will replace "<SID>" with the special
1051key code <SNR>, followed by a number that's unique for the script, and an
1052underscore. Example: >
1053 :map <SID>Add
1054could define a mapping "<SNR>23_Add".
1055
1056When defining a function in a script, "s:" can be prepended to the name to
1057make it local to the script. But when a mapping is executed from outside of
1058the script, it doesn't know in which script the function was defined. To
1059avoid this problem, use "<SID>" instead of "s:". The same translation is done
1060as for mappings. This makes it possible to define a call to the function in
Bram Moolenaar81695252004-12-29 20:58:21 +00001061a mapping.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001062
1063When a local function is executed, it runs in the context of the script it was
1064defined in. This means that new functions and mappings it defines can also
1065use "s:" or "<SID>" and it will use the same unique number as when the
1066function itself was defined. Also, the "s:var" local script variables can be
1067used.
1068
1069When executing an autocommand or a user command, it will run in the context of
1070the script it was defined in. This makes it possible that the command calls a
1071local function or uses a local mapping.
1072
1073Otherwise, using "<SID>" outside of a script context is an error.
1074
1075If you need to get the script number to use in a complicated script, you can
Bram Moolenaar4770d092006-01-12 23:22:24 +00001076use this function: >
1077 function s:SID()
1078 return matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_SID$')
1079 endfun
Bram Moolenaar071d4272004-06-13 20:20:40 +00001080
1081The "<SNR>" will be shown when listing functions and mappings. This is useful
1082to find out what they are defined to.
1083
1084The |:scriptnames| command can be used to see which scripts have been sourced
1085and what their <SNR> number is.
1086
Bram Moolenaardb84e452010-08-15 13:50:43 +02001087This is all {not in Vi} and {not available when compiled without the |+eval|
Bram Moolenaar071d4272004-06-13 20:20:40 +00001088feature}.
1089
1090==============================================================================
10914. User-defined commands *user-commands*
1092
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001093It is possible to define your own Ex commands. A user-defined command can act
Bram Moolenaar071d4272004-06-13 20:20:40 +00001094just like a built-in command (it can have a range or arguments, arguments can
1095be completed as filenames or buffer names, etc), except that when the command
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +01001096is executed, it is transformed into a normal Ex command and then executed.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001097
1098For starters: See section |40.2| in the user manual.
1099
Bram Moolenaar166af9b2010-11-16 20:34:40 +01001100 *E183* *E841* *user-cmd-ambiguous*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001101All user defined commands must start with an uppercase letter, to avoid
Bram Moolenaar166af9b2010-11-16 20:34:40 +01001102confusion with builtin commands. Exceptions are these builtin commands:
1103 :Next
1104 :X
1105They cannot be used for a user defined command. ":Print" is also an existing
1106command, but it is deprecated and can be overruled.
1107
1108The other characters of the user command can be uppercase letters, lowercase
1109letters or digits. When using digits, note that other commands that take a
1110numeric argument may become ambiguous. For example, the command ":Cc2" could
1111be the user command ":Cc2" without an argument, or the command ":Cc" with
1112argument "2". It is advised to put a space between the command name and the
1113argument to avoid these problems.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001114
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001115When using a user-defined command, the command can be abbreviated. However, if
1116an abbreviation is not unique, an error will be issued. Furthermore, a
Bram Moolenaar071d4272004-06-13 20:20:40 +00001117built-in command will always take precedence.
1118
1119Example: >
1120 :command Rename ...
1121 :command Renumber ...
1122 :Rena " Means "Rename"
1123 :Renu " Means "Renumber"
1124 :Ren " Error - ambiguous
1125 :command Paste ...
1126 :P " The built-in :Print
1127
1128It is recommended that full names for user-defined commands are used in
1129scripts.
1130
1131:com[mand] *:com* *:command*
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001132 List all user-defined commands. When listing commands,
Bram Moolenaar071d4272004-06-13 20:20:40 +00001133 the characters in the first two columns are
1134 ! Command has the -bang attribute
1135 " Command has the -register attribute
1136 b Command is local to current buffer
1137 (see below for details on attributes)
1138
1139:com[mand] {cmd} List the user-defined commands that start with {cmd}
1140
Bram Moolenaar5b8d8fd2005-08-16 23:01:50 +00001141 *:command-verbose*
1142When 'verbose' is non-zero, listing a command will also display where it was
1143last defined. Example: >
1144
1145 :verbose command TOhtml
Bram Moolenaarc9b4b052006-04-30 18:54:39 +00001146< Name Args Range Complete Definition ~
1147 TOhtml 0 % :call Convert2HTML(<line1>, <line2>) ~
1148 Last set from /usr/share/vim/vim-7.0/plugin/tohtml.vim ~
1149
Bram Moolenaar5195e452005-08-19 20:32:47 +00001150See |:verbose-cmd| for more information.
Bram Moolenaar5b8d8fd2005-08-16 23:01:50 +00001151
Bram Moolenaar071d4272004-06-13 20:20:40 +00001152 *E174* *E182*
1153:com[mand][!] [{attr}...] {cmd} {rep}
1154 Define a user command. The name of the command is
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001155 {cmd} and its replacement text is {rep}. The command's
1156 attributes (see below) are {attr}. If the command
Bram Moolenaar071d4272004-06-13 20:20:40 +00001157 already exists, an error is reported, unless a ! is
1158 specified, in which case the command is redefined.
1159
1160:delc[ommand] {cmd} *:delc* *:delcommand* *E184*
1161 Delete the user-defined command {cmd}.
1162
1163:comc[lear] *:comc* *:comclear*
1164 Delete all user-defined commands.
1165
1166Command attributes
1167
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +01001168User-defined commands are treated by Vim just like any other Ex commands. They
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001169can have arguments, or have a range specified. Arguments are subject to
1170completion as filenames, buffers, etc. Exactly how this works depends upon the
Bram Moolenaar071d4272004-06-13 20:20:40 +00001171command's attributes, which are specified when the command is defined.
1172
1173There are a number of attributes, split into four categories: argument
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001174handling, completion behavior, range handling, and special cases. The
Bram Moolenaar071d4272004-06-13 20:20:40 +00001175attributes are described below, by category.
1176
Bram Moolenaar5c5b0942007-05-06 12:07:59 +00001177Argument handling *E175* *E176* *:command-nargs*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001178
1179By default, a user defined command will take no arguments (and an error is
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001180reported if any are supplied). However, it is possible to specify that the
1181command can take arguments, using the -nargs attribute. Valid cases are:
Bram Moolenaar071d4272004-06-13 20:20:40 +00001182
1183 -nargs=0 No arguments are allowed (the default)
Bram Moolenaar446beb42011-05-10 17:18:44 +02001184 -nargs=1 Exactly one argument is require, it includes spaces
1185 -nargs=* Any number of arguments are allowed (0, 1, or many),
1186 separated by white space
Bram Moolenaar071d4272004-06-13 20:20:40 +00001187 -nargs=? 0 or 1 arguments are allowed
1188 -nargs=+ Arguments must be supplied, but any number are allowed
1189
Bram Moolenaar34162142007-05-12 13:12:19 +00001190Arguments are considered to be separated by (unescaped) spaces or tabs in this
Bram Moolenaar446beb42011-05-10 17:18:44 +02001191context, except when there is one argument, then the white space is part of
1192the argument.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001193
1194Note that arguments are used as text, not as expressions. Specifically,
1195"s:var" will use the script-local variable in the script where the command was
1196defined, not where it is invoked! Example:
1197 script1.vim: >
1198 :let s:error = "None"
1199 :command -nargs=1 Error echoerr <args>
1200< script2.vim: >
1201 :source script1.vim
1202 :let s:error = "Wrong!"
1203 :Error s:error
Bram Moolenaara7241f52008-06-24 20:39:31 +00001204Executing script2.vim will result in "None" being echoed. Not what you
Bram Moolenaar071d4272004-06-13 20:20:40 +00001205intended! Calling a function may be an alternative.
1206
Bram Moolenaar5c5b0942007-05-06 12:07:59 +00001207Completion behavior *:command-completion* *E179*
1208 *E180* *E181* *:command-complete*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001209By default, the arguments of user defined commands do not undergo completion.
1210However, by specifying one or the other of the following attributes, argument
1211completion can be enabled:
1212
1213 -complete=augroup autocmd groups
1214 -complete=buffer buffer names
Bram Moolenaare9edd7f2011-07-20 16:37:24 +02001215 -complete=color color schemes
Bram Moolenaar071d4272004-06-13 20:20:40 +00001216 -complete=command Ex command (and arguments)
Bram Moolenaare9edd7f2011-07-20 16:37:24 +02001217 -complete=compiler compilers
Bram Moolenaar4a748032010-09-30 21:47:56 +02001218 -complete=cscope |:cscope| suboptions
Bram Moolenaar071d4272004-06-13 20:20:40 +00001219 -complete=dir directory names
1220 -complete=environment environment variable names
1221 -complete=event autocommand events
1222 -complete=expression Vim expression
1223 -complete=file file and directory names
Bram Moolenaare9edd7f2011-07-20 16:37:24 +02001224 -complete=file_in_path file and directory names in |'path'|
Bram Moolenaara26559b2010-07-31 14:59:19 +02001225 -complete=filetype filetype names |'filetype'|
Bram Moolenaar071d4272004-06-13 20:20:40 +00001226 -complete=function function name
1227 -complete=help help subjects
1228 -complete=highlight highlight groups
Bram Moolenaare9edd7f2011-07-20 16:37:24 +02001229 -complete=locale locale names (as output of locale -a)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001230 -complete=mapping mapping name
1231 -complete=menu menus
1232 -complete=option options
Bram Moolenaara26559b2010-07-31 14:59:19 +02001233 -complete=shellcmd Shell command
Bram Moolenaar4a748032010-09-30 21:47:56 +02001234 -complete=sign |:sign| suboptions
Bram Moolenaara26559b2010-07-31 14:59:19 +02001235 -complete=syntax syntax file names |'syntax'|
Bram Moolenaar071d4272004-06-13 20:20:40 +00001236 -complete=tag tags
1237 -complete=tag_listfiles tags, file names are shown when CTRL-D is hit
1238 -complete=var user variables
1239 -complete=custom,{func} custom completion, defined via {func}
Bram Moolenaara466c992005-07-09 21:03:22 +00001240 -complete=customlist,{func} custom completion, defined via {func}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001241
Bram Moolenaara5792f52005-11-23 21:25:05 +00001242
1243Custom completion *:command-completion-custom*
1244 *:command-completion-customlist*
1245 *E467* *E468*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001246It is possible to define customized completion schemes via the "custom,{func}"
Bram Moolenaara466c992005-07-09 21:03:22 +00001247or the "customlist,{func}" completion argument. The {func} part should be a
Bram Moolenaara7241f52008-06-24 20:39:31 +00001248function with the following signature: >
Bram Moolenaar071d4272004-06-13 20:20:40 +00001249
1250 :function {func}(ArgLead, CmdLine, CursorPos)
1251
Bram Moolenaara466c992005-07-09 21:03:22 +00001252The function need not use all these arguments. The function should provide the
1253completion candidates as the return value.
1254
1255For the "custom" argument, the function should return the completion
1256candidates one per line in a newline separated string.
1257
1258For the "customlist" argument, the function should return the completion
Bram Moolenaara5792f52005-11-23 21:25:05 +00001259candidates as a Vim List. Non-string items in the list are ignored.
Bram Moolenaara466c992005-07-09 21:03:22 +00001260
1261The function arguments are:
Bram Moolenaar071d4272004-06-13 20:20:40 +00001262 ArgLead the leading portion of the argument currently being
1263 completed on
1264 CmdLine the entire command line
Bram Moolenaara5792f52005-11-23 21:25:05 +00001265 CursorPos the cursor position in it (byte index)
Bram Moolenaara466c992005-07-09 21:03:22 +00001266The function may use these for determining context. For the "custom"
1267argument, it is not necessary to filter candidates against the (implicit
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +01001268pattern in) ArgLead. Vim will filter the candidates with its regexp engine
Bram Moolenaara466c992005-07-09 21:03:22 +00001269after function return, and this is probably more efficient in most cases. For
1270the "customlist" argument, Vim will not filter the returned completion
1271candidates and the user supplied function should filter the candidates.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001272
1273The following example lists user names to a Finger command >
1274 :com -complete=custom,ListUsers -nargs=1 Finger !finger <args>
1275 :fun ListUsers(A,L,P)
1276 : return system("cut -d: -f1 /etc/passwd")
1277 :endfun
1278
Bram Moolenaara466c992005-07-09 21:03:22 +00001279The following example completes filenames from the directories specified in
1280the 'path' option: >
1281 :com -nargs=1 -bang -complete=customlist,EditFileComplete
1282 \ EditFile edit<bang> <args>
1283 :fun EditFileComplete(A,L,P)
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +01001284 : return split(globpath(&path, a:A), "\n")
Bram Moolenaara466c992005-07-09 21:03:22 +00001285 :endfun
1286<
Bram Moolenaar5ac3b1a2010-07-27 22:50:36 +02001287This example does not work for file names with spaces!
1288
Bram Moolenaara5792f52005-11-23 21:25:05 +00001289
Bram Moolenaar5c5b0942007-05-06 12:07:59 +00001290Range handling *E177* *E178* *:command-range*
1291 *:command-count*
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001292By default, user-defined commands do not accept a line number range. However,
Bram Moolenaar071d4272004-06-13 20:20:40 +00001293it is possible to specify that the command does take a range (the -range
1294attribute), or that it takes an arbitrary count value, either in the line
1295number position (-range=N, like the |:split| command) or as a "count"
Bram Moolenaar5c5b0942007-05-06 12:07:59 +00001296argument (-count=N, like the |:Next| command). The count will then be
1297available in the argument with |<count>|.
1298
1299Possible attributes are:
Bram Moolenaar071d4272004-06-13 20:20:40 +00001300
1301 -range Range allowed, default is current line
1302 -range=% Range allowed, default is whole file (1,$)
1303 -range=N A count (default N) which is specified in the line
Bram Moolenaar8e5af3e2011-04-28 19:02:44 +02001304 number position (like |:split|); allows for zero line
1305 number.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001306 -count=N A count (default N) which is specified either in the line
Bram Moolenaar32e7b2d2005-02-27 22:36:47 +00001307 number position, or as an initial argument (like |:Next|).
Bram Moolenaar071d4272004-06-13 20:20:40 +00001308 Specifying -count (without a default) acts like -count=0
1309
1310Note that -range=N and -count=N are mutually exclusive - only one should be
1311specified.
1312
Bram Moolenaar5c5b0942007-05-06 12:07:59 +00001313Special cases *:command-bang* *:command-bar*
1314 *:command-register* *:command-buffer*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001315There are some special cases as well:
1316
1317 -bang The command can take a ! modifier (like :q or :w)
1318 -bar The command can be followed by a "|" and another command.
1319 A "|" inside the command argument is not allowed then.
1320 Also checks for a " to start a comment.
1321 -register The first argument to the command can be an optional
1322 register name (like :del, :put, :yank).
1323 -buffer The command will only be available in the current buffer.
1324
1325In the cases of the -count and -register attributes, if the optional argument
1326is supplied, it is removed from the argument list and is available to the
1327replacement text separately.
1328
1329Replacement text
1330
1331The replacement text for a user defined command is scanned for special escape
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001332sequences, using <...> notation. Escape sequences are replaced with values
1333from the entered command line, and all other text is copied unchanged. The
Bram Moolenaar371d5402006-03-20 21:47:49 +00001334resulting string is executed as an Ex command. To avoid the replacement use
Bram Moolenaared39e1d2008-08-09 17:55:22 +00001335<lt> in place of the initial <. Thus to include "<bang>" literally use
Bram Moolenaar371d5402006-03-20 21:47:49 +00001336"<lt>bang>".
Bram Moolenaar071d4272004-06-13 20:20:40 +00001337
1338The valid escape sequences are
1339
1340 *<line1>*
1341 <line1> The starting line of the command range.
1342 *<line2>*
1343 <line2> The final line of the command range.
1344 *<count>*
1345 <count> Any count supplied (as described for the '-range'
1346 and '-count' attributes).
1347 *<bang>*
1348 <bang> (See the '-bang' attribute) Expands to a ! if the
1349 command was executed with a ! modifier, otherwise
1350 expands to nothing.
1351 *<reg>* *<register>*
1352 <reg> (See the '-register' attribute) The optional register,
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001353 if specified. Otherwise, expands to nothing. <register>
Bram Moolenaar071d4272004-06-13 20:20:40 +00001354 is a synonym for this.
1355 *<args>*
1356 <args> The command arguments, exactly as supplied (but as
1357 noted above, any count or register can consume some
1358 of the arguments, which are then not part of <args>).
1359 <lt> A single '<' (Less-Than) character. This is needed if you
1360 want to get a literal copy of one of these escape sequences
1361 into the expansion - for example, to get <bang>, use
1362 <lt>bang>.
1363
1364 *<q-args>*
1365If the first two characters of an escape sequence are "q-" (for example,
1366<q-args>) then the value is quoted in such a way as to make it a valid value
1367for use in an expression. This uses the argument as one single value.
Bram Moolenaar51485f02005-06-04 21:55:20 +00001368When there is no argument <q-args> is an empty string.
Bram Moolenaar552f8a12007-03-08 17:12:08 +00001369 *<f-args>*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001370To allow commands to pass their arguments on to a user-defined function, there
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001371is a special form <f-args> ("function args"). This splits the command
Bram Moolenaar34162142007-05-12 13:12:19 +00001372arguments at spaces and tabs, quotes each argument individually, and the
Bram Moolenaar071d4272004-06-13 20:20:40 +00001373<f-args> sequence is replaced by the comma-separated list of quoted arguments.
Bram Moolenaarc9b4b052006-04-30 18:54:39 +00001374See the Mycmd example below. If no arguments are given <f-args> is removed.
Bram Moolenaar552f8a12007-03-08 17:12:08 +00001375 To embed whitespace into an argument of <f-args>, prepend a backslash.
1376<f-args> replaces every pair of backslashes (\\) with one backslash. A
1377backslash followed by a character other than white space or a backslash
1378remains unmodified. Overview:
1379
1380 command <f-args> ~
1381 XX ab 'ab'
1382 XX a\b 'a\b'
1383 XX a\ b 'a b'
1384 XX a\ b 'a ', 'b'
1385 XX a\\b 'a\b'
1386 XX a\\ b 'a\', 'b'
1387 XX a\\\b 'a\\b'
1388 XX a\\\ b 'a\ b'
1389 XX a\\\\b 'a\\b'
1390 XX a\\\\ b 'a\\', 'b'
Bram Moolenaar071d4272004-06-13 20:20:40 +00001391
1392Examples >
1393
1394 " Delete everything after here to the end
1395 :com Ddel +,$d
1396
1397 " Rename the current buffer
1398 :com -nargs=1 -bang -complete=file Ren f <args>|w<bang>
1399
1400 " Replace a range with the contents of a file
1401 " (Enter this all as one line)
1402 :com -range -nargs=1 -complete=file
1403 Replace <line1>-pu_|<line1>,<line2>d|r <args>|<line1>d
1404
1405 " Count the number of lines in the range
Bram Moolenaar81695252004-12-29 20:58:21 +00001406 :com! -range -nargs=0 Lines echo <line2> - <line1> + 1 "lines"
Bram Moolenaar071d4272004-06-13 20:20:40 +00001407
1408 " Call a user function (example of <f-args>)
1409 :com -nargs=* Mycmd call Myfunc(<f-args>)
1410
1411When executed as: >
1412 :Mycmd arg1 arg2
1413This will invoke: >
1414 :call Myfunc("arg1","arg2")
1415
1416 :" A more substantial example
1417 :function Allargs(command)
Bram Moolenaara7241f52008-06-24 20:39:31 +00001418 : let i = 0
1419 : while i < argc()
1420 : if filereadable(argv(i))
1421 : execute "e " . argv(i)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001422 : execute a:command
1423 : endif
1424 : let i = i + 1
1425 : endwhile
1426 :endfunction
1427 :command -nargs=+ -complete=command Allargs call Allargs(<q-args>)
1428
1429The command Allargs takes any Vim command(s) as argument and executes it on all
1430files in the argument list. Usage example (note use of the "e" flag to ignore
1431errors and the "update" command to write modified buffers): >
1432 :Allargs %s/foo/bar/ge|update
1433This will invoke: >
1434 :call Allargs("%s/foo/bar/ge|update")
1435<
Bram Moolenaar8f3f58f2010-01-06 20:52:26 +01001436When defining a user command in a script, it will be able to call functions
Bram Moolenaar071d4272004-06-13 20:20:40 +00001437local to the script and use mappings local to the script. When the user
1438invokes the user command, it will run in the context of the script it was
1439defined in. This matters if |<SID>| is used in a command.
1440
1441 vim:tw=78:ts=8:ft=help:norl: