"Fossies" - the Fresh Open Source Software Archive

Member "vim-8.2.1354/runtime/doc/map.txt" (2 Aug 2020, 66987 Bytes) of package /linux/misc/vim-8.2.1354.tar.gz:

As a special service "Fossies" has tried to format the requested text file into HTML format (style: standard) with prefixed line numbers. Alternatively you can here view or download the uninterpreted source code file. For more information about "map.txt" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 8.2.1333_vs_8.2.1354.

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