home *** CD-ROM | disk | FTP | other *** search
/ vim.ftp.fu-berlin.de / 2015-02-03.vim.ftp.fu-berlin.de.tar / vim.ftp.fu-berlin.de / runtime / dos / doc / cmdline.txt < prev    next >
Encoding:
Text File  |  2012-05-31  |  44.9 KB  |  1,099 lines
  1. *cmdline.txt*   For Vim version 7.3.  Last change: 2012 Feb 05
  2.  
  3.  
  4.           VIM REFERENCE MANUAL    by Bram Moolenaar
  5.  
  6.  
  7.                 *Cmdline-mode* *Command-line-mode*
  8. Command-line mode        *Cmdline* *Command-line* *mode-cmdline* *:*
  9.  
  10. Command-line mode is used to enter Ex commands (":"), search patterns
  11. ("/" and "?"), and filter commands ("!").
  12.  
  13. Basic command line editing is explained in chapter 20 of the user manual
  14. |usr_20.txt|.
  15.  
  16. 1. Command-line editing        |cmdline-editing|
  17. 2. Command-line completion    |cmdline-completion|
  18. 3. Ex command-lines        |cmdline-lines|
  19. 4. Ex command-line ranges    |cmdline-ranges|
  20. 5. Ex command-line flags    |ex-flags|
  21. 6. Ex special characters    |cmdline-special|
  22. 7. Command-line window        |cmdline-window|
  23.  
  24. ==============================================================================
  25. 1. Command-line editing                    *cmdline-editing*
  26.  
  27. Normally characters are inserted in front of the cursor position.  You can
  28. move around in the command-line with the left and right cursor keys.  With the
  29. <Insert> key, you can toggle between inserting and overstriking characters.
  30. {Vi: can only alter the last character in the line}
  31.  
  32. Note that if your keyboard does not have working cursor keys or any of the
  33. other special keys, you can use ":cnoremap" to define another key for them.
  34. For example, to define tcsh style editing keys:        *tcsh-style*  >
  35.     :cnoremap <C-A> <Home>
  36.     :cnoremap <C-F> <Right>
  37.     :cnoremap <C-B> <Left>
  38.     :cnoremap <Esc>b <S-Left>
  39.     :cnoremap <Esc>f <S-Right>
  40. (<> notation |<>|; type all this literally)
  41.  
  42.                             *cmdline-too-long*
  43. When the command line is getting longer than what fits on the screen, only the
  44. part that fits will be shown.  The cursor can only move in this visible part,
  45. thus you cannot edit beyond that.
  46.  
  47.                         *cmdline-history* *history*
  48. The command-lines that you enter are remembered in a history table.  You can
  49. recall them with the up and down cursor keys.  There are actually five
  50. history tables:
  51. - one for ':' commands
  52. - one for search strings
  53. - one for expressions
  54. - one for input lines, typed for the |input()| function.
  55. - one for debug mode commands
  56. These are completely separate.  Each history can only be accessed when
  57. entering the same type of line.
  58. Use the 'history' option to set the number of lines that are remembered
  59. (default: 20).
  60. Notes:
  61. - When you enter a command-line that is exactly the same as an older one, the
  62.   old one is removed (to avoid repeated commands moving older commands out of
  63.   the history).
  64. - Only commands that are typed are remembered.  Ones that completely come from
  65.   mappings are not put in the history.
  66. - All searches are put in the search history, including the ones that come
  67.   from commands like "*" and "#".  But for a mapping, only the last search is
  68.   remembered (to avoid that long mappings trash the history).
  69. {Vi: no history}
  70. {not available when compiled without the |+cmdline_hist| feature}
  71.  
  72. There is an automatic completion of names on the command-line; see
  73. |cmdline-completion|.
  74.  
  75.                             *c_CTRL-V*
  76. CTRL-V        Insert next non-digit literally.  Up to three digits form the
  77.         decimal value of a single byte.  The non-digit and the three
  78.         digits are not considered for mapping.  This works the same
  79.         way as in Insert mode (see above, |i_CTRL-V|).
  80.         Note: Under Windows CTRL-V is often mapped to paste text.
  81.         Use CTRL-Q instead then.
  82.                             *c_CTRL-Q*
  83. CTRL-Q        Same as CTRL-V.  But with some terminals it is used for
  84.         control flow, it doesn't work then.
  85.  
  86.                             *c_<Left>* *c_Left*
  87. <Left>        cursor left
  88.                             *c_<Right>* *c_Right*
  89. <Right>        cursor right
  90.                             *c_<S-Left>*
  91. <S-Left> or <C-Left>                    *c_<C-Left>*
  92.         cursor one WORD left
  93.                             *c_<S-Right>*
  94. <S-Right> or <C-Right>                    *c_<C-Right>*
  95.         cursor one WORD right
  96. CTRL-B or <Home>                *c_CTRL-B* *c_<Home>* *c_Home*
  97.         cursor to beginning of command-line
  98. CTRL-E or <End>                    *c_CTRL-E* *c_<End>* *c_End*
  99.         cursor to end of command-line
  100.  
  101.                             *c_<LeftMouse>*
  102. <LeftMouse>    Move the cursor to the position of the mouse click.
  103.  
  104. CTRL-H                        *c_<BS>* *c_CTRL-H* *c_BS*
  105. <BS>        Delete the character in front of the cursor (see |:fixdel| if
  106.         your <BS> key does not do what you want).
  107.                             *c_<Del>* *c_Del*
  108. <Del>        Delete the character under the cursor (at end of line:
  109.         character before the cursor) (see |:fixdel| if your <Del>
  110.         key does not do what you want).
  111.                             *c_CTRL-W*
  112. CTRL-W        Delete the |word| before the cursor.  This depends on the
  113.         'iskeyword' option.
  114.                             *c_CTRL-U*
  115. CTRL-U        Remove all characters between the cursor position and
  116.         the beginning of the line.  Previous versions of vim
  117.         deleted all characters on the line.  If that is the
  118.         preferred behavior, add the following to your .vimrc: >
  119.             :cnoremap <C-U> <C-E><C-U>
  120. <
  121.                         *c_<Insert>* *c_Insert*
  122. <Insert>    Toggle between insert and overstrike.  {not in Vi}
  123.  
  124. {char1} <BS> {char2}    or                *c_digraph*
  125. CTRL-K {char1} {char2}                    *c_CTRL-K*
  126.         enter digraph (see |digraphs|).  When {char1} is a special
  127.         key, the code for that key is inserted in <> form.  {not in Vi}
  128.  
  129. CTRL-R {0-9a-z"%#:-=.}                    *c_CTRL-R* *c_<C-R>*
  130.         Insert the contents of a numbered or named register.  Between
  131.         typing CTRL-R and the second character '"' will be displayed
  132.         to indicate that you are expected to enter the name of a
  133.         register.
  134.         The text is inserted as if you typed it, but mappings and
  135.         abbreviations are not used.  Command-line completion through
  136.         'wildchar' is not triggered though.  And characters that end
  137.         the command line are inserted literally (<Esc>, <CR>, <NL>,
  138.         <C-C>).  A <BS> or CTRL-W could still end the command line
  139.         though, and remaining characters will then be interpreted in
  140.         another mode, which might not be what you intended.
  141.         Special registers:
  142.             '"'    the unnamed register, containing the text of
  143.                 the last delete or yank
  144.             '%'    the current file name
  145.             '#'    the alternate file name
  146.             '*'    the clipboard contents (X11: primary selection)
  147.             '+'    the clipboard contents
  148.             '/'    the last search pattern
  149.             ':'    the last command-line
  150.             '-'    the last small (less than a line) delete
  151.             '.'    the last inserted text
  152.                             *c_CTRL-R_=*
  153.             '='    the expression register: you are prompted to
  154.                 enter an expression (see |expression|)
  155.                 (doesn't work at the expression prompt; some
  156.                 things such as changing the buffer or current
  157.                 window are not allowed to avoid side effects)
  158.                 When the result is a |List| the items are used
  159.                 as lines.  They can have line breaks inside
  160.                 too.
  161.                 When the result is a Float it's automatically
  162.                 converted to a String.
  163.         See |registers| about registers.  {not in Vi}
  164.         Implementation detail: When using the |expression| register
  165.         and invoking setcmdpos(), this sets the position before
  166.         inserting the resulting string.  Use CTRL-R CTRL-R to set the
  167.         position afterwards.
  168.  
  169. CTRL-R CTRL-F                *c_CTRL-R_CTRL-F* *c_<C-R>_<C-F>*
  170. CTRL-R CTRL-P                *c_CTRL-R_CTRL-P* *c_<C-R>_<C-P>*
  171. CTRL-R CTRL-W                *c_CTRL-R_CTRL-W* *c_<C-R>_<C-W>*
  172. CTRL-R CTRL-A                *c_CTRL-R_CTRL-A* *c_<C-R>_<C-A>*
  173.         Insert the object under the cursor:
  174.             CTRL-F    the Filename under the cursor
  175.             CTRL-P    the Filename under the cursor, expanded with
  176.                 'path' as in |gf|
  177.             CTRL-W    the Word under the cursor
  178.             CTRL-A    the WORD under the cursor; see |WORD|
  179.  
  180.         When 'incsearch' is set the cursor position at the end of the
  181.         currently displayed match is used.  With CTRL-W the part of
  182.         the word that was already typed is not inserted again.
  183.  
  184.         {not in Vi}
  185.         CTRL-F and CTRL-P: {only when |+file_in_path| feature is
  186.         included}
  187.  
  188.                     *c_CTRL-R_CTRL-R* *c_<C-R>_<C-R>*
  189.                     *c_CTRL-R_CTRL-O* *c_<C-R>_<C-O>*
  190. CTRL-R CTRL-R {0-9a-z"%#:-=. CTRL-F CTRL-P CTRL-W CTRL-A}
  191. CTRL-R CTRL-O {0-9a-z"%#:-=. CTRL-F CTRL-P CTRL-W CTRL-A}
  192.         Insert register or object under the cursor.  Works like
  193.         |c_CTRL-R| but inserts the text literally.  For example, if
  194.         register a contains "xy^Hz" (where ^H is a backspace),
  195.         "CTRL-R a" will insert "xz" while "CTRL-R CTRL-R a" will
  196.         insert "xy^Hz".
  197.  
  198. CTRL-\ e {expr}                        *c_CTRL-\_e*
  199.         Evaluate {expr} and replace the whole command line with the
  200.         result.  You will be prompted for the expression, type <Enter>
  201.         to finish it.  It's most useful in mappings though.  See
  202.         |expression|.
  203.         See |c_CTRL-R_=| for inserting the result of an expression.
  204.         Useful functions are |getcmdtype()|, |getcmdline()| and
  205.         |getcmdpos()|.
  206.         The cursor position is unchanged, except when the cursor was
  207.         at the end of the line, then it stays at the end.
  208.         |setcmdpos()| can be used to set the cursor position.
  209.         The |sandbox| is used for evaluating the expression to avoid
  210.         nasty side effects.
  211.         Example: >
  212.             :cmap <F7> <C-\>eAppendSome()<CR>
  213.             :func AppendSome()
  214.                :let cmd = getcmdline() . " Some()"
  215.                :" place the cursor on the )
  216.                :call setcmdpos(strlen(cmd))
  217.                :return cmd
  218.             :endfunc
  219. <        This doesn't work recursively, thus not when already editing
  220.         an expression.
  221.  
  222.                             *c_CTRL-Y*
  223. CTRL-Y        When there is a modeless selection, copy the selection into
  224.         the clipboard. |modeless-selection|
  225.         If there is no selection CTRL-Y is inserted as a character.
  226.  
  227. CTRL-J                    *c_CTRL-J* *c_<NL>* *c_<CR>* *c_CR*
  228. <CR> or <NL>    start entered command
  229.                             *c_<Esc>* *c_Esc*
  230. <Esc>        When typed and 'x' not present in 'cpoptions', quit
  231.         Command-line mode without executing.  In macros or when 'x'
  232.         present in 'cpoptions', start entered command.
  233.         Note: If your <Esc> key is hard to hit on your keyboard, train
  234.         yourself to use CTRL-[.
  235.                             *c_CTRL-C*
  236. CTRL-C        quit command-line without executing
  237.  
  238.                             *c_<Up>* *c_Up*
  239. <Up>        recall older command-line from history, whose beginning
  240.         matches the current command-line (see below).
  241.         {not available when compiled without the |+cmdline_hist|
  242.         feature}
  243.                             *c_<Down>* *c_Down*
  244. <Down>        recall more recent command-line from history, whose beginning
  245.         matches the current command-line (see below).
  246.         {not available when compiled without the |+cmdline_hist|
  247.         feature}
  248.  
  249.                             *c_<S-Up>* *c_<PageUp>*
  250. <S-Up> or <PageUp>
  251.         recall older command-line from history
  252.         {not available when compiled without the |+cmdline_hist|
  253.         feature}
  254.                         *c_<S-Down>* *c_<PageDown>*
  255. <S-Down> or <PageDown>
  256.         recall more recent command-line from history
  257.         {not available when compiled without the |+cmdline_hist|
  258.         feature}
  259.  
  260. CTRL-D        command-line completion (see |cmdline-completion|)
  261. 'wildchar' option
  262.         command-line completion (see |cmdline-completion|)
  263. CTRL-N        command-line completion (see |cmdline-completion|)
  264. CTRL-P        command-line completion (see |cmdline-completion|)
  265. CTRL-A        command-line completion (see |cmdline-completion|)
  266. CTRL-L        command-line completion (see |cmdline-completion|)
  267.  
  268.                             *c_CTRL-_*
  269. CTRL-_        a - switch between Hebrew and English keyboard mode, which is
  270.         private to the command-line and not related to hkmap.
  271.         This is useful when Hebrew text entry is required in the
  272.         command-line, searches, abbreviations, etc.  Applies only if
  273.         Vim is compiled with the |+rightleft| feature and the
  274.         'allowrevins' option is set.
  275.         See |rileft.txt|.
  276.  
  277.         b - switch between Farsi and English keyboard mode, which is
  278.         private to the command-line and not related to fkmap.  In
  279.         Farsi keyboard mode the characters are inserted in reverse
  280.         insert manner.  This is useful when Farsi text entry is
  281.         required in the command-line, searches, abbreviations, etc.
  282.         Applies only if Vim is compiled with the |+farsi| feature.
  283.         See |farsi.txt|.
  284.  
  285.                             *c_CTRL-^*
  286. CTRL-^        Toggle the use of language |:lmap| mappings and/or Input
  287.         Method.
  288.         When typing a pattern for a search command and 'imsearch' is
  289.         not -1, VAL is the value of 'imsearch', otherwise VAL is the
  290.         value of 'iminsert'.
  291.         When language mappings are defined:
  292.         - If VAL is 1 (langmap mappings used) it becomes 0 (no langmap
  293.           mappings used).
  294.         - If VAL was not 1 it becomes 1, thus langmap mappings are
  295.           enabled.
  296.         When no language mappings are defined:
  297.         - If VAL is 2 (Input Method is used) it becomes 0 (no input
  298.           method used)
  299.         - If VAL has another value it becomes 2, thus the Input Method
  300.           is enabled.
  301.         These language mappings are normally used to type characters
  302.         that are different from what the keyboard produces.  The
  303.         'keymap' option can be used to install a whole number of them.
  304.         When entering a command line, langmap mappings are switched
  305.         off, since you are expected to type a command.  After
  306.         switching it on with CTRL-^, the new state is not used again
  307.         for the next command or Search pattern.
  308.         {not in Vi}
  309.  
  310.                         *c_CTRL-]*
  311. CTRL-]        Trigger abbreviation, without inserting a character.  {not in
  312.         Vi}
  313.  
  314. For Emacs-style editing on the command-line see |emacs-keys|.
  315.  
  316. The <Up> and <Down> keys take the current command-line as a search string.
  317. The beginning of the next/previous command-lines are compared with this
  318. string.  The first line that matches is the new command-line.  When typing
  319. these two keys repeatedly, the same string is used again.  For example, this
  320. can be used to find the previous substitute command: Type ":s" and then <Up>.
  321. The same could be done by typing <S-Up> a number of times until the desired
  322. command-line is shown.  (Note: the shifted arrow keys do not work on all
  323. terminals)
  324.  
  325.                             *:his* *:history*
  326. :his[tory]    Print the history of last entered commands.
  327.         {not in Vi}
  328.         {not available when compiled without the |+cmdline_hist|
  329.         feature}
  330.  
  331. :his[tory] [{name}] [{first}][, [{last}]]
  332.         List the contents of history {name} which can be:
  333.         c[md]     or :        command-line history
  334.         s[earch] or / or ?    search string history
  335.         e[xpr]     or =        expression register history
  336.         i[nput]     or @        input line history
  337.         d[ebug]     or >        debug command history
  338.         a[ll]            all of the above
  339.         {not in Vi}
  340.  
  341.         If the numbers {first} and/or {last} are given, the respective
  342.         range of entries from a history is listed.  These numbers can
  343.         be specified in the following form:
  344.                             *:history-indexing*
  345.         A positive number represents the absolute index of an entry
  346.         as it is given in the first column of a :history listing.
  347.         This number remains fixed even if other entries are deleted.
  348.  
  349.         A negative number means the relative position of an entry,
  350.         counted from the newest entry (which has index -1) backwards.
  351.  
  352.         Examples:
  353.         List entries 6 to 12 from the search history: >
  354.             :history / 6,12
  355. <
  356.         List the recent five entries from all histories: >
  357.             :history all -5,
  358.  
  359. ==============================================================================
  360. 2. Command-line completion                *cmdline-completion*
  361.  
  362. When editing the command-line, a few commands can be used to complete the
  363. word before the cursor.  This is available for:
  364.  
  365. - Command names: At the start of the command-line.
  366. - Tags: Only after the ":tag" command.
  367. - File names: Only after a command that accepts a file name or a setting for
  368.   an option that can be set to a file name.  This is called file name
  369.   completion.
  370. - Shell command names: After ":!cmd", ":r !cmd" and ":w !cmd".  $PATH is used.
  371. - Options: Only after the ":set" command.
  372. - Mappings: Only after a ":map" or similar command.
  373. - Variable and function names: Only after a ":if", ":call" or similar command.
  374.  
  375. When Vim was compiled without the |+cmdline_compl| feature only file names,
  376. directories and help items can be completed.  The number of help item matches
  377. is limited (currently to 300) to avoid a long delay when there are very many
  378. matches.
  379.  
  380. These are the commands that can be used:
  381.  
  382.                             *c_CTRL-D*
  383. CTRL-D        List names that match the pattern in front of the cursor.
  384.         When showing file names, directories are highlighted (see
  385.         'highlight' option).  Names where 'suffixes' matches are moved
  386.         to the end.
  387.         The 'wildoptions' option can be set to "tagfile" to list the
  388.         file of matching tags.
  389.                     *c_CTRL-I* *c_wildchar* *c_<Tab>*
  390. 'wildchar' option
  391.         A match is done on the pattern in front of the cursor.  The
  392.         match (if there are several, the first match) is inserted
  393.         in place of the pattern.  (Note: does not work inside a
  394.         macro, because <Tab> or <Esc> are mostly used as 'wildchar',
  395.         and these have a special meaning in some macros.) When typed
  396.         again and there were multiple matches, the next
  397.         match is inserted.  After the last match, the first is used
  398.         again (wrap around).
  399.         The behavior can be changed with the 'wildmode' option.
  400.                             *c_CTRL-N*
  401. CTRL-N        After using 'wildchar' which got multiple matches, go to next
  402.         match.  Otherwise recall more recent command-line from history.
  403. <S-Tab>                            *c_CTRL-P* *c_<S-Tab>*
  404. CTRL-P        After using 'wildchar' which got multiple matches, go to
  405.         previous match.  Otherwise recall older command-line from
  406.         history.  <S-Tab> only works with the GUI, on the Amiga and
  407.         with MS-DOS.
  408.                             *c_CTRL-A*
  409. CTRL-A        All names that match the pattern in front of the cursor are
  410.         inserted.
  411.                             *c_CTRL-L*
  412. CTRL-L        A match is done on the pattern in front of the cursor.  If
  413.         there is one match, it is inserted in place of the pattern.
  414.         If there are multiple matches the longest common part is
  415.         inserted in place of the pattern.  If the result is shorter
  416.         than the pattern, no completion is done.
  417.         When 'incsearch' is set, entering a search pattern for "/" or
  418.         "?" and the current match is displayed then CTRL-L will add
  419.         one character from the end of the current match.  If
  420.         'ignorecase' and 'smartcase' are set and the command line has
  421.         no uppercase characters, the added character is converted to
  422.         lowercase.
  423.  
  424. The 'wildchar' option defaults to <Tab> (CTRL-E when in Vi compatible mode; in
  425. a previous version <Esc> was used).  In the pattern standard wildcards '*' and
  426. '?' are accepted when matching file names.  '*' matches any string, '?'
  427. matches exactly one character.
  428.  
  429. The 'wildignorecase' option can be set to ignore case in filenames.
  430.  
  431. If you like tcsh's autolist completion, you can use this mapping:
  432.     :cnoremap X <C-L><C-D>
  433. (Where X is the command key to use, <C-L> is CTRL-L and <C-D> is CTRL-D)
  434. This will find the longest match and then list all matching files.
  435.  
  436. If you like tcsh's autolist completion, you can use the 'wildmode' option to
  437. emulate it.  For example, this mimics autolist=ambiguous:
  438.     :set wildmode=longest,list
  439. This will find the longest match with the first 'wildchar', then list all
  440. matching files with the next.
  441.  
  442.                             *suffixes*
  443. For file name completion you can use the 'suffixes' option to set a priority
  444. between files with almost the same name.  If there are multiple matches,
  445. those files with an extension that is in the 'suffixes' option are ignored.
  446. The default is ".bak,~,.o,.h,.info,.swp,.obj", which means that files ending
  447. in ".bak", "~", ".o", ".h", ".info", ".swp" and ".obj" are sometimes ignored.
  448.  
  449. An empty entry, two consecutive commas, match a file name that does not
  450. contain a ".", thus has no suffix.  This is useful to ignore "prog" and prefer
  451. "prog.c".
  452.  
  453. Examples:
  454.  
  455.   pattern:    files:                match:    ~
  456.    test*    test.c test.h test.o        test.c
  457.    test*    test.h test.o            test.h and test.o
  458.    test*    test.i test.h test.c        test.i and test.c
  459.  
  460. It is impossible to ignore suffixes with two dots.
  461.  
  462. If there is more than one matching file (after ignoring the ones matching
  463. the 'suffixes' option) the first file name is inserted.  You can see that
  464. there is only one match when you type 'wildchar' twice and the completed
  465. match stays the same.  You can get to the other matches by entering
  466. 'wildchar', CTRL-N or CTRL-P.  All files are included, also the ones with
  467. extensions matching the 'suffixes' option.
  468.  
  469. To completely ignore files with some extension use 'wildignore'.
  470.  
  471. To match only files that end at the end of the typed text append a "$".  For
  472. example, to match only files that end in ".c": >
  473.     :e *.c$
  474. This will not match a file ending in ".cpp".  Without the "$" it does match.
  475.  
  476. The old value of an option can be obtained by hitting 'wildchar' just after
  477. the '='.  For example, typing 'wildchar' after ":set dir=" will insert the
  478. current value of 'dir'.  This overrules file name completion for the options
  479. that take a file name.
  480.  
  481. If you would like using <S-Tab> for CTRL-P in an xterm, put this command in
  482. your .cshrc: >
  483.     xmodmap -e "keysym Tab = Tab Find"
  484. And this in your .vimrc: >
  485.     :cmap <Esc>[1~ <C-P>
  486.  
  487. ==============================================================================
  488. 3. Ex command-lines                    *cmdline-lines*
  489.  
  490. The Ex commands have a few specialties:
  491.  
  492.                             *:quote* *:comment*
  493. '"' at the start of a line causes the whole line to be ignored.  '"'
  494. after a command causes the rest of the line to be ignored.  This can be used
  495. to add comments.  Example: >
  496.     :set ai        "set 'autoindent' option
  497. It is not possible to add a comment to a shell command ":!cmd" or to the
  498. ":map" command and a few others, because they see the '"' as part of their
  499. argument.  This is mentioned where the command is explained.
  500.  
  501.                             *:bar* *:\bar*
  502. '|' can be used to separate commands, so you can give multiple commands in one
  503. line.  If you want to use '|' in an argument, precede it with '\'.
  504.  
  505. These commands see the '|' as their argument, and can therefore not be
  506. followed by another Vim command:
  507.     :argdo
  508.     :autocmd
  509.     :bufdo
  510.     :command
  511.     :cscope
  512.     :debug
  513.     :folddoopen
  514.     :folddoclosed
  515.     :function
  516.     :global
  517.     :help
  518.     :helpfind
  519.     :lcscope
  520.     :make
  521.     :normal
  522.     :perl
  523.     :perldo
  524.     :promptfind
  525.     :promptrepl
  526.     :pyfile
  527.     :python
  528.     :registers
  529.     :read !
  530.     :scscope
  531.     :sign
  532.     :tcl
  533.     :tcldo
  534.     :tclfile
  535.     :vglobal
  536.     :windo
  537.     :write !
  538.     :[range]!
  539.     a user defined command without the "-bar" argument |:command|
  540.  
  541. Note that this is confusing (inherited from Vi): With ":g" the '|' is included
  542. in the command, with ":s" it is not.
  543.  
  544. To be able to use another command anyway, use the ":execute" command.
  545. Example (append the output of "ls" and jump to the first line): >
  546.     :execute 'r !ls' | '[
  547.  
  548. There is one exception: When the 'b' flag is present in 'cpoptions', with the
  549. ":map" and ":abbr" commands and friends CTRL-V needs to be used instead of
  550. '\'.  You can also use "<Bar>" instead.  See also |map_bar|.
  551.  
  552. Examples: >
  553.     :!ls | wc        view the output of two commands
  554.     :r !ls | wc        insert the same output in the text
  555.     :%g/foo/p|>        moves all matching lines one shiftwidth
  556.     :%s/foo/bar/|>        moves one line one shiftwidth
  557.     :map q 10^V|        map "q" to "10|"
  558.     :map q 10\| map \ l    map "q" to "10\" and map "\" to "l"
  559.                     (when 'b' is present in 'cpoptions')
  560.  
  561. You can also use <NL> to separate commands in the same way as with '|'.  To
  562. insert a <NL> use CTRL-V CTRL-J.  "^@" will be shown.  Using '|' is the
  563. preferred method.  But for external commands a <NL> must be used, because a
  564. '|' is included in the external command.  To avoid the special meaning of <NL>
  565. it must be preceded with a backslash.  Example: >
  566.     :r !date<NL>-join
  567. This reads the current date into the file and joins it with the previous line.
  568.  
  569. Note that when the command before the '|' generates an error, the following
  570. commands will not be executed.
  571.  
  572.  
  573. Because of Vi compatibility the following strange commands are supported: >
  574.     :|            print current line (like ":p")
  575.     :3|            print line 3 (like ":3p")
  576.     :3            goto line 3
  577.  
  578. A colon is allowed between the range and the command name.  It is ignored
  579. (this is Vi compatible).  For example: >
  580.     :1,$:s/pat/string
  581.  
  582. When the character '%' or '#' is used where a file name is expected, they are
  583. expanded to the current and alternate file name (see the chapter "editing
  584. files" |:_%| |:_#|).
  585.  
  586. Embedded spaces in file names are allowed on the Amiga if one file name is
  587. expected as argument.  Trailing spaces will be ignored, unless escaped with a
  588. backslash or CTRL-V.  Note that the ":next" command uses spaces to separate
  589. file names.  Escape the spaces to include them in a file name.  Example: >
  590.     :next foo\ bar goes\ to school\
  591. starts editing the three files "foo bar", "goes to" and "school ".
  592.  
  593. When you want to use the special characters '"' or '|' in a command, or want
  594. to use '%' or '#' in a file name, precede them with a backslash.  The
  595. backslash is not required in a range and in the ":substitute" command.
  596.  
  597.                             *:_!*
  598. The '!' (bang) character after an Ex command makes the command behave in a
  599. different way.  The '!' should be placed immediately after the command, without
  600. any blanks in between.  If you insert blanks the '!' will be seen as an
  601. argument for the command, which has a different meaning.  For example:
  602.     :w! name    write the current buffer to file "name", overwriting
  603.             any existing file
  604.     :w !name    send the current buffer as standard input to command
  605.             "name"
  606.  
  607. ==============================================================================
  608. 4. Ex command-line ranges    *cmdline-ranges* *[range]* *E16*
  609.  
  610. Some Ex commands accept a line range in front of them.  This is noted as
  611. [range].  It consists of one or more line specifiers, separated with ',' or
  612. ';'.
  613.  
  614. The basics are explained in section |10.3| of the user manual.
  615.  
  616.                         *:,* *:;*
  617. When separated with ';' the cursor position will be set to that line
  618. before interpreting the next line specifier.  This doesn't happen for ','.
  619. Examples: >
  620.    4,/this line/
  621. <    from line 4 till match with "this line" after the cursor line. >
  622.    5;/that line/
  623. <    from line 5 till match with "that line" after line 5.
  624.  
  625. The default line specifier for most commands is the cursor position, but the
  626. commands ":write" and ":global" have the whole file (1,$) as default.
  627.  
  628. If more line specifiers are given than required for the command, the first
  629. one(s) will be ignored.
  630.  
  631. Line numbers may be specified with:        *:range* *E14* *{address}*
  632.     {number}    an absolute line number
  633.     .        the current line              *:.*
  634.     $        the last line in the file          *:$*
  635.     %        equal to 1,$ (the entire file)          *:%*
  636.     't        position of mark t (lowercase)          *:'*
  637.     'T        position of mark T (uppercase); when the mark is in
  638.             another file it cannot be used in a range
  639.     /{pattern}[/]    the next line where {pattern} matches      *:/*
  640.     ?{pattern}[?]    the previous line where {pattern} matches *:?*
  641.     \/        the next line where the previously used search
  642.             pattern matches
  643.     \?        the previous line where the previously used search
  644.             pattern matches
  645.     \&        the next line where the previously used substitute
  646.             pattern matches
  647.  
  648. Each may be followed (several times) by '+' or '-' and an optional number.
  649. This number is added or subtracted from the preceding line number.  If the
  650. number is omitted, 1 is used.
  651.  
  652. The "/" and "?" after {pattern} are required to separate the pattern from
  653. anything that follows.
  654.  
  655. The "/" and "?" may be preceded with another address.  The search starts from
  656. there.  The difference from using ';' is that the cursor isn't moved.
  657. Examples: >
  658.     /pat1//pat2/    Find line containing "pat2" after line containing
  659.             "pat1", without moving the cursor.
  660.     7;/pat2/    Find line containing "pat2", after line 7, leaving
  661.             the cursor in line 7.
  662.  
  663. The {number} must be between 0 and the number of lines in the file.  When
  664. using a 0 (zero) this is interpreted as a 1 by most commands.  Commands that
  665. use it as a count do use it as a zero (|:tag|, |:pop|, etc).  Some commands
  666. interpret the zero as "before the first line" (|:read|, search pattern, etc).
  667.  
  668. Examples: >
  669.     .+3        three lines below the cursor
  670.     /that/+1    the line below the next line containing "that"
  671.     .,$        from current line until end of file
  672.     0;/that        the first line containing "that", also matches in the
  673.             first line.
  674.     1;/that        the first line after line 1 containing "that"
  675.  
  676. Some commands allow for a count after the command.  This count is used as the
  677. number of lines to be used, starting with the line given in the last line
  678. specifier (the default is the cursor line).  The commands that accept a count
  679. are the ones that use a range but do not have a file name argument (because
  680. a file name can also be a number).
  681.  
  682. Examples: >
  683.     :s/x/X/g 5    substitute 'x' by 'X' in the current line and four
  684.             following lines
  685.     :23d 4        delete lines 23, 24, 25 and 26
  686.  
  687.  
  688. Folds and Range
  689.  
  690. When folds are active the line numbers are rounded off to include the whole
  691. closed fold.  See |fold-behavior|.
  692.  
  693.  
  694. Reverse Range                        *E493*
  695.  
  696. A range should have the lower line number first.  If this is not the case, Vim
  697. will ask you if it should swap the line numbers.
  698.     Backwards range given, OK to swap ~
  699. This is not done within the global command ":g".
  700.  
  701. You can use ":silent" before a command to avoid the question, the range will
  702. always be swapped then.
  703.  
  704.  
  705. Count and Range                        *N:*
  706.  
  707. When giving a count before entering ":", this is translated into:
  708.         :.,.+(count - 1)
  709. In words: The 'count' lines at and after the cursor.  Example: To delete
  710. three lines: >
  711.         3:d<CR>        is translated into: .,.+2d<CR>
  712. <
  713.  
  714. Visual Mode and Range                    *v_:*
  715.  
  716. {Visual}:    Starts a command-line with the Visual selected lines as a
  717.         range.  The code ":'<,'>" is used for this range, which makes
  718.         it possible to select a similar line from the command-line
  719.         history for repeating a command on different Visually selected
  720.         lines.
  721.  
  722. ==============================================================================
  723. 5. Ex command-line flags                *ex-flags*
  724.  
  725. These flags are supported by a selection of Ex commands.  They print the line
  726. that the cursor ends up after executing the command:
  727.  
  728.     l    output like for |:list|
  729.     #    add line number
  730.     p    output like for |:print|
  731.  
  732. The flags can be combined, thus "l#" uses both a line number and |:list| style
  733. output.
  734.  
  735. ==============================================================================
  736. 6. Ex special characters                *cmdline-special*
  737.  
  738. Note: These are special characters in the executed command line.  If you want
  739. to insert special things while typing you can use the CTRL-R command.  For
  740. example, "%" stands for the current file name, while CTRL-R % inserts the
  741. current file name right away.  See |c_CTRL-R|.
  742.  
  743. Note: If you want to avoid the special characters in a Vim script you may want
  744. to use |fnameescape()|.
  745.  
  746.  
  747. In Ex commands, at places where a file name can be used, the following
  748. characters have a special meaning.  These can also be used in the expression
  749. function expand() |expand()|.
  750.     %    Is replaced with the current file name.          *:_%* *c_%*
  751.     #    Is replaced with the alternate file name.      *:_#* *c_#*
  752.     #n    (where n is a number) is replaced with          *:_#0* *:_#n*
  753.         the file name of buffer n.  "#0" is the same as "#".     *c_#n*
  754.     ##    Is replaced with all names in the argument list      *:_##* *c_##*
  755.         concatenated, separated by spaces.  Each space in a name
  756.         is preceded with a backslash.
  757.     #<n    (where n is a number > 0) is replaced with old      *:_#<* *c_#<*
  758.         file name n.  See |:oldfiles| or |v:oldfiles| to get the
  759.         number.                            *E809*
  760.         {only when compiled with the |+eval| and |+viminfo| features}
  761.  
  762. Note that these, except "#<n", give the file name as it was typed.  If an
  763. absolute path is needed (when using the file name from a different directory),
  764. you need to add ":p".  See |filename-modifiers|.
  765.  
  766. The "#<n" item returns an absolute path, but it will start with "~/" for files
  767. below your home directory.
  768.  
  769. Note that backslashes are inserted before spaces, so that the command will
  770. correctly interpret the file name.  But this doesn't happen for shell
  771. commands.  For those you probably have to use quotes (this fails for files
  772. that contain a quote and wildcards): >
  773.     :!ls "%"
  774.     :r !spell "%"
  775.  
  776. To avoid the special meaning of '%' and '#' insert a backslash before it.
  777. Detail: The special meaning is always escaped when there is a backslash before
  778. it, no matter how many backslashes.
  779.     you type:        result    ~
  780.        #            alternate.file
  781.        \#            #
  782.        \\#            \#
  783.  
  784.                    *:<cword>* *:<cWORD>* *:<cfile>* *<cfile>*
  785.                    *:<sfile>* *<sfile>* *:<afile>* *<afile>*
  786.                    *:<abuf>* *<abuf>* *:<amatch>* *<amatch>*
  787.                    *<slnum>* *E495* *E496* *E497* *E499* *E500*
  788. Note: these are typed literally, they are not special keys!
  789.     <cword>    is replaced with the word under the cursor (like |star|)
  790.     <cWORD>    is replaced with the WORD under the cursor (see |WORD|)
  791.     <cfile>    is replaced with the path name under the cursor (like what
  792.            |gf| uses)
  793.     <afile>    When executing autocommands, is replaced with the file name
  794.            for a file read or write.
  795.     <abuf>     When executing autocommands, is replaced with the currently
  796.            effective buffer number (for ":r file" and ":so file" it is
  797.            the current buffer, the file being read/sourced is not in a
  798.            buffer).
  799.     <amatch>   When executing autocommands, is replaced with the match for
  800.            which this autocommand was executed.  It differs from
  801.            <afile> only when the file name isn't used to match with
  802.            (for FileType, Syntax and SpellFileMissing events).
  803.     <sfile>    When executing a ":source" command, is replaced with the
  804.            file name of the sourced file.  *E498* 
  805.            When executing a function, is replaced with
  806.            "function {function-name}"; function call nesting is
  807.            indicated like this:
  808.            "function {function-name1}..{function-name2}".  Note that
  809.            filename-modifiers are useless when <sfile> is used inside
  810.            a function.
  811.     <slnum>       When executing a ":source" command, is replaced with the
  812.                line number.  *E842*
  813.            When executing a function it's the line number relative to
  814.            the start of the function.
  815.  
  816.                              *filename-modifiers*
  817.      *:_%:* *::8* *::p* *::.* *::~* *::h* *::t* *::r* *::e* *::s* *::gs*
  818.             *%:8* *%:p* *%:.* *%:~* *%:h* *%:t* *%:r* *%:e* *%:s* *%:gs*
  819. The file name modifiers can be used after "%", "#", "#n", "<cfile>", "<sfile>",
  820. "<afile>" or "<abuf>".  They are also used with the |fnamemodify()| function.
  821. These are not available when Vim has been compiled without the |+modify_fname|
  822. feature.
  823. These modifiers can be given, in this order:
  824.     :p    Make file name a full path.  Must be the first modifier.  Also
  825.         changes "~/" (and "~user/" for Unix and VMS) to the path for
  826.         the home directory.  If the name is a directory a path
  827.         separator is added at the end.  For a file name that does not
  828.         exist and does not have an absolute path the result is
  829.         unpredictable.
  830.     :8    Converts the path to 8.3 short format (currently only on
  831.         win32).  Will act on as much of a path that is an existing
  832.         path.
  833.     :~    Reduce file name to be relative to the home directory, if
  834.         possible.  File name is unmodified if it is not below the home
  835.         directory.
  836.     :.    Reduce file name to be relative to current directory, if
  837.         possible.  File name is unmodified if it is not below the
  838.         current directory.
  839.         For maximum shortness, use ":~:.".
  840.     :h    Head of the file name (the last component and any separators
  841.         removed).  Cannot be used with :e, :r or :t.
  842.         Can be repeated to remove several components at the end.
  843.         When the file name ends in a path separator, only the path
  844.         separator is removed.  Thus ":p:h" on a directory name results
  845.         on the directory name itself (without trailing slash).
  846.         When the file name is an absolute path (starts with "/" for
  847.         Unix; "x:\" for MS-DOS, WIN32, OS/2; "drive:" for Amiga), that
  848.         part is not removed.  When there is no head (path is relative
  849.         to current directory) the result is empty.
  850.     :t    Tail of the file name (last component of the name).  Must
  851.         precede any :r or :e.
  852.     :r    Root of the file name (the last extension removed).  When
  853.         there is only an extension (file name that starts with '.',
  854.         e.g., ".vimrc"), it is not removed.  Can be repeated to remove
  855.         several extensions (last one first).
  856.     :e    Extension of the file name.  Only makes sense when used alone.
  857.         When there is no extension the result is empty.
  858.         When there is only an extension (file name that starts with
  859.         '.'), the result is empty.  Can be repeated to include more
  860.         extensions.  If there are not enough extensions (but at least
  861.         one) as much as possible are included.
  862.     :s?pat?sub?
  863.         Substitute the first occurrence of "pat" with "sub".  This
  864.         works like the |:s| command.  "pat" is a regular expression.
  865.         Any character can be used for '?', but it must not occur in
  866.         "pat" or "sub".
  867.         After this, the previous modifiers can be used again.  For
  868.         example ":p", to make a full path after the substitution.
  869.     :gs?pat?sub?
  870.         Substitute all occurrences of "pat" with "sub".  Otherwise
  871.         this works like ":s".
  872.  
  873. Examples, when the file name is "src/version.c", current dir
  874. "/home/mool/vim": >
  875.   :p            /home/mool/vim/src/version.c
  876.   :p:.                       src/version.c
  877.   :p:~                 ~/vim/src/version.c
  878.   :h                       src
  879.   :p:h            /home/mool/vim/src
  880.   :p:h:h        /home/mool/vim
  881.   :t                       version.c
  882.   :p:t                       version.c
  883.   :r                       src/version
  884.   :p:r            /home/mool/vim/src/version
  885.   :t:r                       version
  886.   :e                           c
  887.   :s?version?main?               src/main.c
  888.   :s?version?main?:p    /home/mool/vim/src/main.c
  889.   :p:gs?/?\\?        \home\mool\vim\src\version.c
  890.  
  891. Examples, when the file name is "src/version.c.gz": >
  892.   :p            /home/mool/vim/src/version.c.gz
  893.   :e                             gz
  894.   :e:e                           c.gz
  895.   :e:e:e                       c.gz
  896.   :e:e:r                       c
  897.   :r                       src/version.c
  898.   :r:e                           c
  899.   :r:r                       src/version
  900.   :r:r:r                   src/version
  901. <
  902.                     *extension-removal* *:_%<*
  903. If a "<" is appended to "%", "#", "#n" or "CTRL-V p" the extension of the file
  904. name is removed (everything after and including the last '.' in the file
  905. name).  This is included for backwards compatibility with version 3.0, the
  906. ":r" form is preferred.  Examples: >
  907.  
  908.     %        current file name
  909.     %<        current file name without extension
  910.     #        alternate file name for current window
  911.     #<        idem, without extension
  912.     #31        alternate file number 31
  913.     #31<        idem, without extension
  914.     <cword>        word under the cursor
  915.     <cWORD>        WORD under the cursor (see |WORD|)
  916.     <cfile>        path name under the cursor
  917.     <cfile><    idem, without extension
  918.  
  919. Note: Where a file name is expected wildcards expansion is done.  On Unix the
  920. shell is used for this, unless it can be done internally (for speed).
  921. Backticks also work, like in >
  922.     :n `echo *.c`
  923. (backtick expansion is not possible in |restricted-mode|)
  924. But expansion is only done if there are any wildcards before expanding the
  925. '%', '#', etc..  This avoids expanding wildcards inside a file name.  If you
  926. want to expand the result of <cfile>, add a wildcard character to it.
  927. Examples: (alternate file name is "?readme?")
  928.     command        expands to  ~
  929.     :e #        :e ?readme?
  930.     :e `ls #`    :e {files matching "?readme?"}
  931.     :e #.*        :e {files matching "?readme?.*"}
  932.     :cd <cfile>    :cd {file name under cursor}
  933.     :cd <cfile>*    :cd {file name under cursor plus "*" and then expanded}
  934.  
  935. When the expanded argument contains a "!" and it is used for a shell command
  936. (":!cmd", ":r !cmd" or ":w !cmd"), the "!" is escaped with a backslash to
  937. avoid it being expanded into a previously used command.  When the 'shell'
  938. option contains "sh", this is done twice, to avoid the shell trying to expand
  939. the "!".
  940.  
  941.                             *filename-backslash*
  942. For filesystems that use a backslash as directory separator (MS-DOS, Windows,
  943. OS/2), it's a bit difficult to recognize a backslash that is used to escape
  944. the special meaning of the next character.  The general rule is: If the
  945. backslash is followed by a normal file name character, it does not have a
  946. special meaning.  Therefore "\file\foo" is a valid file name, you don't have
  947. to type the backslash twice.
  948.  
  949. An exception is the '$' sign.  It is a valid character in a file name.  But
  950. to avoid a file name like "$home" to be interpreted as an environment variable,
  951. it needs to be preceded by a backslash.  Therefore you need to use "/\$home"
  952. for the file "$home" in the root directory.  A few examples:
  953.  
  954.     FILE NAME    INTERPRETED AS    ~
  955.     $home        expanded to value of environment var $home
  956.     \$home        file "$home" in current directory
  957.     /\$home        file "$home" in root directory
  958.     \\$home        file "\\", followed by expanded $home
  959.  
  960. ==============================================================================
  961. 6. Command-line window                *cmdline-window* *cmdwin*
  962.                             *command-line-window*
  963. In the command-line window the command line can be edited just like editing
  964. text in any window.  It is a special kind of window, because you cannot leave
  965. it in a normal way.
  966. {not available when compiled without the |+cmdline_hist| or |+vertsplit|
  967. feature}
  968.  
  969.  
  970. OPEN                        *c_CTRL-F* *q:* *q/* *q?*
  971.  
  972. There are two ways to open the command-line window:
  973. 1. From Command-line mode, use the key specified with the 'cedit' option.
  974.    The default is CTRL-F when 'compatible' is not set.
  975. 2. From Normal mode, use the "q:", "q/" or "q?" command.
  976.    This starts editing an Ex command-line ("q:") or search string ("q/" or
  977.    "q?").  Note that this is not possible while recording is in progress (the
  978.    "q" stops recording then).
  979.  
  980. When the window opens it is filled with the command-line history.  The last
  981. line contains the command as typed so far.  The left column will show a
  982. character that indicates the type of command-line being edited, see
  983. |cmdwin-char|.
  984.  
  985. Vim will be in Normal mode when the editor is opened, except when 'insertmode'
  986. is set.
  987.  
  988. The height of the window is specified with 'cmdwinheight' (or smaller if there
  989. is no room).  The window is always full width and is positioned just above the
  990. command-line.
  991.  
  992.  
  993. EDIT
  994.  
  995. You can now use commands to move around and edit the text in the window.  Both
  996. in Normal mode and Insert mode.
  997.  
  998. It is possible to use ":", "/" and other commands that use the command-line,
  999. but it's not possible to open another command-line window then.  There is no
  1000. nesting.
  1001.                             *E11*
  1002. The command-line window is not a normal window.  It is not possible to move to
  1003. another window or edit another buffer.  All commands that would do this are
  1004. disabled in the command-line window.  Of course it _is_ possible to execute
  1005. any command that you entered in the command-line window.  Other text edits are
  1006. discarded when closing the window.
  1007.  
  1008.  
  1009. CLOSE                            *E199*
  1010.  
  1011. There are several ways to leave the command-line window:
  1012.  
  1013. <CR>        Execute the command-line under the cursor.  Works both in
  1014.         Insert and in Normal mode.
  1015. CTRL-C        Continue in Command-line mode.  The command-line under the
  1016.         cursor is used as the command-line.  Works both in Insert and
  1017.         in Normal mode.  ":close" also works.  There is no redraw,
  1018.         thus the window will remain visible.
  1019. :quit        Discard the command line and go back to Normal mode.
  1020.         ":exit", ":xit" and CTRL-\ CTRL-N also work.
  1021. :qall        Quit Vim, unless there are changes in some buffer.
  1022. :qall!        Quit Vim, discarding changes to any buffer.
  1023.  
  1024. Once the command-line window is closed the old window sizes are restored.  The
  1025. executed command applies to the window and buffer where the command-line was
  1026. started from.  This works as if the command-line window was not there, except
  1027. that there will be an extra screen redraw.
  1028. The buffer used for the command-line window is deleted.  Any changes to lines
  1029. other than the one that is executed with <CR> are lost.
  1030.  
  1031. If you would like to execute the command under the cursor and then have the
  1032. command-line window open again, you may find this mapping useful: >
  1033.  
  1034.     :autocmd CmdwinEnter * map <buffer> <F5> <CR>q:
  1035.  
  1036.  
  1037. VARIOUS
  1038.  
  1039. The command-line window cannot be used:
  1040. - when there already is a command-line window (no nesting)
  1041. - for entering an encryption key or when using inputsecret()
  1042. - when Vim was not compiled with the |+vertsplit| feature
  1043.  
  1044. Some options are set when the command-line window is opened:
  1045. 'filetype'    "vim", when editing an Ex command-line; this starts Vim syntax
  1046.         highlighting if it was enabled
  1047. 'rightleft'    off
  1048. 'modifiable'    on
  1049. 'buftype'    "nofile"
  1050. 'swapfile'    off
  1051.  
  1052. It is allowed to write the buffer contents to a file.  This is an easy way to
  1053. save the command-line history and read it back later.
  1054.  
  1055. If the 'wildchar' option is set to <Tab>, and the command-line window is used
  1056. for an Ex command, then two mappings will be added to use <Tab> for completion
  1057. in the command-line window, like this: >
  1058.     :imap <buffer> <Tab> <C-X><C-V>
  1059.     :nmap <buffer> <Tab> a<C-X><C-V>
  1060. Note that hitting <Tab> in Normal mode will do completion on the next
  1061. character.  That way it works at the end of the line.
  1062. If you don't want these mappings, disable them with: >
  1063.     au CmdwinEnter [:>] iunmap <Tab>
  1064.     au CmdwinEnter [:>] nunmap <Tab>
  1065. You could put these lines in your vimrc file.
  1066.  
  1067. While in the command-line window you cannot use the mouse to put the cursor in
  1068. another window, or drag statuslines of other windows.  You can drag the
  1069. statusline of the command-line window itself and the statusline above it.
  1070. Thus you can resize the command-line window, but not others.
  1071.  
  1072.  
  1073. AUTOCOMMANDS
  1074.  
  1075. Two autocommand events are used: |CmdwinEnter| and |CmdwinLeave|.  Since this
  1076. window is of a special type, the WinEnter, WinLeave, BufEnter and BufLeave
  1077. events are not triggered.  You can use the Cmdwin events to do settings
  1078. specifically for the command-line window.  Be careful not to cause side
  1079. effects!
  1080. Example: >
  1081.     :au CmdwinEnter :  let b:cpt_save = &cpt | set cpt=.
  1082.     :au CmdwinLeave :  let &cpt = b:cpt_save
  1083. This sets 'complete' to use completion in the current window for |i_CTRL-N|.
  1084. Another example: >
  1085.     :au CmdwinEnter [/?]  startinsert
  1086. This will make Vim start in Insert mode in the command-line window.
  1087.  
  1088.                         *cmdwin-char*
  1089. The character used for the pattern indicates the type of command-line:
  1090.     :    normal Ex command
  1091.     >    debug mode command |debug-mode|
  1092.     /    forward search string
  1093.     ?    backward search string
  1094.     =    expression for "= |expr-register|
  1095.     @    string for |input()|
  1096.     -    text for |:insert| or |:append|
  1097.  
  1098.  vim:tw=78:ts=8:ft=help:norl:
  1099.