Info file vip.info, produced by Makeinfo, -*- Text -*- from input
file vip.texinfo.

Distribution
************

   Copyright (C) 1991 Aamod Sane.

   Permission is granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission notice
are preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that
the entire resulting derived work is distributed under the terms of
a permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the same conditions as for
modified versions.


File: vip.info,  Node: Move Commands,  Next: Marking,  Up: Text Handling

Move Commands
-------------

`<count>  h  C-h'
     <count> chars to the left.

`<count>  j  <lf> C-n'
     <count> lines downward.

`<count>  l  <sp>'
     <count> chars to the right.

`<count>  k  C-p'
     <count> lines upward.

`<count>  $'
     To the end of line <count> from the cursor.

`<count>  ^'
     To the first CHAR <count> - 1 lines lower.

`<count>  -'
     To the first CHAR <count> lines higher.

`<count>  +  <cr>'
     To the first CHAR <count> lines lower.

`0'
     To the first char of the line.

`<count> |'
     To column <count>

`<count>  f<char>'
     <count> <char>s to the right (find).

`<count>  t<char>'
     Till before <count> <char>s to the right.

`<count>  F<char>'
     <count> <char>s to the left.

`<count>  T<char>'
     Till after <count> <char>s to the left.

`<count>  ;'
     Repeat latest `f t F T' <count> times.

`<count>  ,'
     Repeat latest `f t F T'  <count> times in opposite direction.

`<count>  w'
     <count> words forward.

`<count>  W'
     <count> WORDS forward.

`<count>  b'
     <count> words backward.

`<count>  B'
     <count> WORDS backward.

`<count>  e'
     To the end of word <count> forward.

`<count>  E'
     To the end of WORD <count> forward.

`<count>  G'
     Go to line <count> (default end-of-file).

`<count>  H'
     To line <count> from top of the screen (home).

`<count>  L'
     To line <count> from bottom of the screen (last).

`M'
     To the middle line of the screen.

`<count>  )'
     <count> sentences forward.

`<count>  ('
     <count> sentences backward.

`<count>  }'
     <count> paragraphs forward.

`<count>  {'
     <count> paragraphs backward.

`<count>  ]]'
     To the <count>th heading.

`<count>  [['
     To the <count>th previous heading.

`<count>  []'
     To the end of <count>th heading.

`m<a-z>'
     Mark the cursor position with a letter.

``<a-z>'
     To the mark.

`'<a-z>'
     To the first CHAR of the line with the mark.

`[<a-z>'
     Show contents of textmarker.

`]<a-z>'
     Show contents of register.

`"'
     To the cursor position before the latest absolute  jump (of
     which are examples `/' and `G').

`"'
     To the first CHAR of the line on which the cursor  was placed
     before the latest absolute jump.

`<count>  /<string>'
     To the <count>th occurrence of <string>.

`<count>  /<cr>'
     To the <count>th occurrence of <string> from previous `/ or ?'.

`<count>  ?<string>'
     To the <count>th previous occurrence of <string>.

`<count>  ?<cr>'
     To the <count>th previous occurrence of <string> from previous
     `? or /'.

`n'
     Repeat latest `/' `?' (next).

`N'
     Idem in opposite direction.

`%'
     Find the next bracket and go to its match.


File: vip.info,  Node: Marking,  Next: Appending Text,  Prev: Move Commands,  Up: Text Handling

Marking
-------

   Emacs mark is referred to in the region specifiers `r' and `R'. 
*Note Emacs Preliminaries:: and *note Basics::. for explanation.
Also see *Note Mark: (emacs)Mark, for an explanation of the Emacs
mark ring.

`m<a-z>'
     Mark the current file and position with the specified letter.

`m .'
     Set the Emacs mark (*note Emacs Preliminaries::.) at point.

`m <'
     Set the Emacs mark at beginning of buffer.

`m >'
     Set the Emacs mark at end of buffer.

`m ,'
     Jump to the Emacs mark.

`"'
     Exchange point and mark.

`"'
     Exchange point and mark and go to the first CHAR on line.

`'<a-z>'
     Go to specified VIP mark.

`'
     Go to specified VIP mark and go to the first CHAR on line.


File: vip.info,  Node: Appending Text,  Next: Editing in Insert Mode,  Prev: Marking,  Up: Text Handling

Appending Text
--------------

   *Note Options:: to see how to change tab and shiftwidth size. See
the GNU Emacs manual, or try `C-ha tabs' (If you have turned Emacs
help on).  Check out the variable `indent-tabs-mode' to put in just
spaces.  Also see options for word-wrap.

`<count>  a'
     <count> times after the cursor.

`<count>  A'
     <count> times at the end of line.

`<count>  i'
     <count> times before the cursor (insert).

`<count>  I'
     <count> times before the first CHAR of the line

`<count>  o'
     On a new line below the current (open).   The count is only
     useful on a slow terminal.

`<count>  O'
     On a new line above the current.   The count is only useful on a
     slow terminal.

`<count>  ><move>'
     Shift the lines described by <count><move> one  shiftwidth to
     the right (layout!).

`<count>  >>'
     Shift <count> lines one shiftwidth to the right.

`<count>  ["<a-z1-9>]p'
     Put the contents of the (default undo) buffer  <count> times
     after the cursor. The register will  be automatically downcased.

`<count>  ["<a-z1-9>]P'
     Put the contents of the (default undo) buffer  <count> times
     before the cursor. The register will

`[<a-z>'
     Show contents of textmarker.

`]<a-z>'
     Show contents of register.

`<count>  .'
     Repeat previous command <count> times. For destructive  commands
     as well as undo.


File: vip.info,  Node: Editing in Insert Mode,  Next: Deleting Text,  Prev: Appending Text,  Up: Text Handling

Editing in Insert Mode
----------------------

   The Minibuffer can be edited in the same way as Insert mode.

`C-v'
     Deprive the next char of its special meaning (quoting).

`C-d'
     One shiftwidth to the left.

`0C-d'
     Remove all indentation on the current line  (there must be no
     other chars on the line).

`^C-d'
     Idem, but it is restored on the next line.

`C-t'
     one shiftwidth to the right

`C-h'
     One char back.

`C-w'
     One word back.

`C-u'
     Back to the begin of the change on the  current line.

`C-c'
     like <esc>.


File: vip.info,  Node: Deleting Text,  Next: Changing Text,  Prev: Editing in Insert Mode,  Up: Text Handling

Deleting Text
-------------

`<count>  x'
     Delete <count> chars under and after the cursor.

`<count>  X'
     <count> chars before the cursor.

`<count>  d<move>'
     From begin to endpoint of <count><move>.

`<count>  dd'
     <count> lines.

`D'
     The rest of the line.

`<count>  <<move>'
     Shift the lines described by <count><move> one  shiftwidth to
     the left (layout!).

`<count>  <<'
     Shift <count> lines one shiftwidth to the left.


File: vip.info,  Node: Changing Text,  Next: Search and Replace,  Prev: Deleting Text,  Up: Text Handling

Changing Text
-------------

`<count>  r<char>'
     Replace <count> chars by <char> - no <esc>.

`<count>  R'
     Overwrite the rest of the line,  appending change COUNT - 1 times.

`<count>  s'
     Substitute <count> chars.

`<count>  S'
     <count> lines.

`<count>  c<move>'
     Change from begin to endpoint of <count><move>.

`<count>  cc'
     <count> lines.

`<count>  C'
     The rest of the line and <count> - 1 next lines.

`<count>  =<move>'
     Reindent the region described by move.

`<count>  ~'
     Switch lower and upper cases.

`<count>  J'
     Join <count> lines (default 2).

`:[x,y]s/<p>/<r>/<f>'
     Substitute (on lines x through y) the pattern  <p> (default the
     last pattern) with <r>.  Useful  flags <f> are `g' for `global'
     (i.e. change every  non-overlapping occurrence of <p>) and `c'
     for  `confirm' (type `y' to confirm a particular  substitution,
     else `n' ).  Instead of `/' any  punctuation CHAR unequal to
     <space> <tab> and <lf> can be used as  delimiter.

`&'
     Repeat latest ex substitute command, e.g.   `:s/wrong/good'.

`#c<move>'
     Change upper case characters in the region to lower case.

`#C<move>'
     Change lower case characters in the region to upper case.

`#q<move>'
     Insert specified string at the beginning of each line in the
     region


File: vip.info,  Node: Search and Replace,  Next: Yanking,  Prev: Changing Text,  Up: Text Handling

Search and Replace
------------------

   *Note Groundwork::, for Ex address syntax. *Note Options:: to see
how to get literal (non-regular-expression) search and how to stop
search from wrapping around.

`<count>  /<string>'
     To the <count>th occurrence of <string>.

`<count>  ?<string>'
     To the <count>th previous occurrence of <string>.

`<count>  g<move>'
     Search for the text described by move. (off by default)

`n'
     Repeat latest `/' `?' (next).

`N'
     Idem in opposite direction.

`%'
     Find the next bracket and go to its match

`:[x,y]g/<string>/<cmd>'
     Search globally [from line x to y] for <string>  and execute the
     ex <cmd> on each occurrence.

`:[x,y]v/<string>/<cmd>'
     Execute <cmd> on the lines that don't match.

`#g<move>'
     Execute the last keyboard macro for each line in the region.  
     *Note Macros and Registers::, for more info.

`Q'
     Query Replace.

`:ta <name>'
     Search in the tags file where <name> is  defined (file, line),
     and go to it.

`:[x,y]s/<p>/<r>/<f>'
     Substitute (on lines x through y) the pattern  <p> (default the
     last pattern) with <r>.  Useful  flags <f> are `g' for `global'
     (i.e. change every  non-overlapping occurrence of <p>) and `c'
     for  `confirm' (type `y' to confirm a particular  substitution,
     else `n').  Instead of `/' any  punctuation CHAR unequal to
     <space> <tab> and <lf> can be used as  delimiter.

`&'
     Repeat latest ex substitute command, e.g. `:s/wrong/good'.


File: vip.info,  Node: Yanking,  Next: Undoing,  Prev: Search and Replace,  Up: Text Handling

Yanking
-------

`<count>  y<move>'
     Yank from begin to endpoint of <count><move>.

`<count>  "<a-z>y<move>'
     Yank from begin to endpoint of <count><move> to register.

`<count>  "<A-Z>y<move>'
     Yank from begin to endpoint of <count><move> and append  to
     register.

`<count>  yy'
     <count> lines.

`<count>  Y'
     Idem (should be equivalent to `y$' though).

`m<a-z>'
     Mark the cursor position with a letter.

`[<a-z>'
     Show contents of textmarker.

`]<a-z>'
     Show contents of register.

`<count>  ["<a-z1-9>]p'
     Put the contents of the (default undo) buffer  <count> times
     after the cursor. The register will  be automatically downcased.

`<count>  ["<a-z1-9>]P'
     Put the contents of the (default undo) buffer  <count> times
     before the cursor. The register will


File: vip.info,  Node: Undoing,  Prev: Yanking,  Up: Text Handling

Undoing
-------

`u U'
     Undo the latest change.

`.'
     Repeat undo.

`:q!'
     Quit vi without writing.

`:e!'
     Re-edit a messed-up file.

`:rec'
     recover file from autosave. VIP also creates backup files  that
     have a `~' appended to them.


File: vip.info,  Node: Display,  Next: File Handling,  Prev: Text Handling,  Up: Commands

Display
=======

`C-g'
     Give file name, status, current line number  and relative
     position.

`C-l'
     Refresh the screen.

`<count> C-e'
     Expose <count> more lines at bottom, cursor  stays put (if
     possible).

`<count> C-y'
     Expose <count> more lines at top, cursor  stays put (if possible).

`<count> C-d'
     Scroll <count> lines downward  (default the number of the
     previous scroll;  initialization: half a page).

`<count> C-u'
     Scroll <count> lines upward  (default the number of the previous
     scroll;  initialization: half a page).

`<count> C-f'
     <count> pages forward.

`<count> C-b'
     <count> pages backward (in older versions `C-b' only  works
     without count).

`<count> z<cr> zH'
     Put line <count> at the top of the window  (default the current
     line).

`<count> z- zL'
     Put line <count> at the bottom of the window  (default the
     current line).

`<count> z. zM'
     Put line <count> in the center of the window  (default the
     current line).


File: vip.info,  Node: File Handling,  Next: Mapping,  Prev: Display,  Up: Commands

File Handling
=============

`:q'
     Quit buffer except if modified.

`:q!'
     Quit buffer without checking.

`:susp :stop'
     Suspend VIP

`:w'
     Write the file.

`:w <name>'
     Write to the file <name>.

`:w >> <name>'
     Append the buffer to the file <name>.

`:w! <name>'
     Overwrite the file <name>.

`:x,y w <name>'
     Write lines x through y to the file <name>.

`:wq'
     Write the file and kill buffer.

`ZZ'
     Save buffers and kill Emacs.

`:x [<file>]'
     Save and kill buffer.

`:x! [<file>]'
     `:w![<file>]' and `:q'.

`:pre'
     Preserve the file - autosave buffers.

`:rec'
     recover file from autosave.

`:f'
     Print file name and lines.

`:cd [<dir>]'
     Set the working directory to <dir>  (default home directory).

`:pwd'
     Print present working directory.

`:e [+<cmd>] <files>'
     Edit files. If no filename is given,  dired current directory.

`:q!'
     Quit vi without writing.

`:e!'
     Re-edit a messed-up file.

`:e! [+<cmd>] <files>'
     Edit file. If no filename, reedit current file.

`C-^'
     Edit the alternate (normally the previous) file.

`:rew'
     Obsolete

`:args'
     List files not shown anywhere with counts for next

`:n [count]  [+<cmd>] [<files>]'
     Edit <count> file, or edit files.   The count comes from :args

`:<address>r <name>'
     Read the file <name> into the buffer after the line <address>.

`v V'
     Edit a file in current or another window. File name is typed in
     minibuffer.


File: vip.info,  Node: Mapping,  Next: Shell Commands,  Prev: File Handling,  Up: Commands

Mapping
=======

`:map <char> <seq>'
     <char> is interpreted as <seq>  `:map C-c :!wc %' to run wc on
     current file.   (vi replaces `%' with the current file name).

`:unmap <char>'
     Deprive <char> of its mappings.

`:map! <char> <seq>'
     Mapping in Insert mode.

`:unmap! <char>'
     Deprive <string> of its mapping (see `:unmap').

`@<a-z>'
     Execute the contents of register as a command.

`@@'
     Repeat last register command.

`@#'
     Begin keyboard macro. End with @<a-z>. This will  put the macro
     in the proper register. Register will  be automatically
     downcased.   *Note Macros and Registers::, for more info.

`@!<a-z>'
     Yank anonymous macro to register

`*'
     Execute anonymous macro (defined by C-x( and C-x )).

`#g<move>'
     Execute the last keyboard macro for each line in the region.  
     *Note Macros and Registers::, for more info.

`[<a-z>'
     Show contents of textmarker.

`]<a-z>'
     Show contents of register.


File: vip.info,  Node: Shell Commands,  Next: Options,  Prev: Mapping,  Up: Commands

Shell Commands
==============

   Note that % is used in Ex commands to mean current file. If you
want a % in your command, it must be escaped as `\%'.  However if %
is the first character, it stands as the address for the whole file.
Similarly, `#' expands to the previous file. The previous file is
the
first file in `:args' listing. This defaults to the previous file in
the VI sense if you have one window.

`:sh'
     Execute a subshell in another window

`:[x,y]!<cmd>'
     Execute a shell <cmd> [on lines x through y;  % is replace by
     current file, \% is changed to %

`:[x,y]!! [<args>]'
     Repeat last shell command [and append <args>].

`:!<cmd>'
     Just execute command and display result in a buffer.

`:!! <args>'
     Repeat last shell command and append <args>

`<count> !<move><cmd>'
     The shell executes <cmd>, with standard  input the lines
     described by <count><move>,  next the standard output replaces
     those lines  (think of `cb', `sort', `nroff', etc.).

`<count> !!<cmd>'
     Give <count> lines as standard input to the  shell <cmd>, next
     let the standard output  replace those lines.

`:x,y w !<cmd>'
     Let lines x to y be standard input for <cmd>  (notice the <sp>
     between `w' and `!').

`:<address>r !<cmd>'
     Put the output of <cmd> after the line <address> (default
     current).

`:<address>r <name>'
     Read the file <name> into the buffer after the line <address>
     (default current).


File: vip.info,  Node: Options,  Next: Emacs Related Commands,  Prev: Shell Commands,  Up: Commands

Options
=======

`ai'
     autoindent - In append mode after a <cr> the  cursor will move
     directly below the first  CHAR on the previous line.

`ic'
     ignorecase - No distinction between upper and  lower cases when
     searching.

`magic'
     Regular expressions used in searches.   nomagic means no regexps.

`ro'
     readonly - The file is not to be changed.   However, `:w!' will
     override this option.

`sh=<string>'
     shell - The program to be used for shell escapes  (default
     `$SHELL' (default `/bin/sh')).

`sw=<count>'
     shiftwidth - Gives the shiftwidth (default 8  positions).

`sm'
     showmatch - Whenever you append a `)', vi shows  its match if
     it's on the same page; also with  `{' and `}'.  If there's no
     match, vi will beep.

`ts=<count>'
     tabstop - The length of a <ht>; warning: this is  only IN the
     editor, outside of it <ht>s have  their normal length (default
     8 positions).

`wm=<count>'
     wrapmargin - In append mode vi automatically  puts a <lf>
     whenever there is a <sp> or <ht>  within <wm> columns from the
     right margin.

`ws'
     wrapscan - When searching, the end is  considered `stuck' to the
     begin of the file.

`:set <option>'
     Turn <option> on.

`:set no<option>'
     Turn <option> off.

`:set <option>=<value>'
     Set <option> to <value>.


File: vip.info,  Node: Emacs Related Commands,  Prev: Options,  Up: Commands

Emacs Related Commands
======================

`_'
     Begin Meta command in Vi mode. Most often used as _x (M-x).

`C-z'
     Begin Meta command in Insert mode.

`C-z'
     Switch between Emacs and Vi modes.

`C-x0'
     Close Window

`C-x1'
     Close Other Windows

`C-x2'
     Split Window

`C-xo'
     Move among windows

`C-xC-f'
     Emacs find-file, useful in Insert mode


File: vip.info,  Node: Acknowledgments,  Up: Top

Acknowledgments
***************

   The original author of VIP was Masahiko Sato. The Manual and VIP
4.3 is based on his VIP 3.5 Manual and Code.

   Jean-Jacques Moreau contributed code to get small changes with the
`$' sign instead of through the minibuffer. He also put in the
completer hooks, and ex commands :pwd, :cd, and :recover.

   Jeff Lewis contributed code to make Ex style motion possible.

   Many contributors on the net pointed out bugs.

   Finally, my advisor Roy Campbell at Illinois did not mind my
spending inordinate amounts of time on VIP.


File: vip.info,  Node: Key Index,  Next: Concept Index,  Up: Top

Key Index
*********

* Menu:

* <a-z>:                                Groundwork.
* <address>:                            Groundwork.
* <args>:                               Groundwork.
* <cmd>:                                Groundwork.
* <move>:                               Groundwork.
* !!<cmd>:                              Shell Commands.
* !<cmd>:                               Shell Commands.
* !<move><cmd>:                         Shell Commands.
* "<A-Z>y<move>:                        Yanking.
* "<a-z1-9>P:                           Yanking.
* "<a-z1-9>P:                           Appending Text.
* "<a-z1-9>p:                           Appending Text.
* "<a-z1-9>p:                           Yanking.
* "<a-z>y<move>:                        Yanking.
* #C<move>:                             Changing Text.
* #C<move>:                             New Commands.
* #c<move>:                             Changing Text.
* #c<move>:                             New Commands.
* #g<move>:                             New Commands.
* #g<move>:                             Mapping.
* #g<move>:                             Search and Replace.
* #q<move> :                            Changing Text.
* #q<move>:                             New Commands.
* #s<move>:                             New Commands.
* #:                                    New Commands.
* $:                                    Move Commands.
* %:                                    Move Commands.
* %:                                    Search and Replace.
* &:                                    Search and Replace.
* &:                                    Changing Text.
* ":                                    Marking.
* ":                                    Move Commands.
* '<a-z>:                               Marking.
* '<a-z>:                               Move Commands.
* (:                                    Move Commands.
* ):                                    Move Commands.
* *:                                    New Commands.
* *:                                    Mapping.
* +:                                    Move Commands.
* ,:                                    Move Commands.
* -:                                    Move Commands.
* .:                                    Appending Text.
* .:                                    Undoing.
* /<cr>:                                Move Commands.
* /<string>:                            Search and Replace.
* /<string>:                            Move Commands.
* 0C-d:                                 Editing in Insert Mode.
* 0:                                    Move Commands.
* :!! <args>:                           Shell Commands.
* :!<cmd>:                              Shell Commands.
* :<address>r !<cmd>:                   Shell Commands.
* :<address>r <name>:                   Shell Commands.
* :[x,y]g/<string>/<cmd>:               Search and Replace.
* :[x,y]s/<p>/<r>/<f>:                  Search and Replace.
* :[x,y]s/<p>/<r>/<f>:                  Changing Text.
* :[x,y]v/<string>/<cmd>:               Search and Replace.
* :args:                                New Commands.
* :args:                                File Handling.
* :cd [<dir>]:                          File Handling.
* :e [<files>]:                         File Handling.
* :e! [<files>]:                        File Handling.
* :e!:                                  Undoing.
* :f:                                   File Handling.
* :map <char> <seq>:                    Mapping.
* :map! <char> <seq>:                   Mapping.
* :map:                                 Keybindings.
* :n [<count> | <file>]:                File Handling.
* :n:                                   New Commands.
* :pre:                                 New Commands.
* :pre:                                 File Handling.
* :pwd:                                 File Handling.
* :pwd:                                 New Commands.
* :q!:                                  File Handling.
* :q!:                                  File Handling.
* :q!:                                  Undoing.
* :q:                                   File Handling.
* :q:                                   File Handling.
* :rec:                                 File Handling.
* :rec:                                 Undoing.
* :rew:                                 File Handling.
* :se ai:                               Options.
* :se ic:                               Options.
* :se magic:                            Options.
* :se ro:                               Options.
* :se sh=<string>:                      Options.
* :se sm:                               Options.
* :se sw=<count>:                       Options.
* :se ts=<count>:                       Options.
* :se wm=<count>:                       Options.
* :se ws:                               Options.
* :set <option>=<value>:                Options.
* :set <option>:                        Options.
* :set no<option>:                      Options.
* :set:                                 Rudimentary Changes.
* :sh:                                  Shell Commands.
* :stop:                                File Handling.
* :susp:                                File Handling.
* :ta <name>:                           Search and Replace.
* :unmap <char>:                        Mapping.
* :unmap! <char>:                       Mapping.
* :w !<cmd>:                            Shell Commands.
* :w <file>:                            File Handling.
* :w >> <file>:                         File Handling.
* :w! <file>:                           File Handling.
* :wq:                                  File Handling.
* :x!:                                  File Handling.
* :x,y w !<cmd>:                        Shell Commands.
* :x:                                   File Handling.
* ;:                                    Move Commands.
* <<move>:                              Deleting Text.
* <<:                                   Deleting Text.
* <cr>:                                 Move Commands.
* <lf>:                                 Move Commands.
* <sp>:                                 Move Commands.
* =<move>:                              Changing Text.
* ><move>:                              Appending Text.
* >>:                                   Appending Text.
* ?<cr>:                                Move Commands.
* ?<string>:                            Move Commands.
* ?<string>:                            Search and Replace.
* @!<a-z>:                              Mapping.
* @!:                                   New Commands.
* @#:                                   New Commands.
* @#:                                   Mapping.
* @<a-z>:                               New Commands.
* @<a-z>:                               Mapping.
* @@:                                   Mapping.
* {:                                    Move Commands.
* }:                                    Move Commands.
* A:                                    Appending Text.
* B:                                    Move Commands.
* C-]:                                  Vi Mode.
* C-]:                                  New Commands.
* C-^:                                  File Handling.
* C-b:                                  Display.
* C-c:                                  Editing in Insert Mode.
* C-d:                                  Display.
* C-d:                                  Editing in Insert Mode.
* C-e:                                  Display.
* C-f:                                  Display.
* C-g:                                  Vi Mode.
* C-g:                                  New Commands.
* C-g:                                  Display.
* C-h:                                  Move Commands.
* C-l:                                  Display.
* C-n:                                  Move Commands.
* C-p:                                  Move Commands.
* C-t:                                  Editing in Insert Mode.
* C-u:                                  Editing in Insert Mode.
* C-u:                                  Display.
* C-v:                                  Editing in Insert Mode.
* C-w:                                  Editing in Insert Mode.
* C-x0:                                 Emacs Related Commands.
* C-x1:                                 Emacs Related Commands.
* C-x2:                                 Emacs Related Commands.
* C-xC-f:                               Emacs Related Commands.
* C-xo:                                 Emacs Related Commands.
* C-x:                                  New Commands.
* C-x:                                  Vi Mode.
* C-y:                                  Display.
* C-z:                                  Emacs Mode.
* C-z:                                  Emacs Related Commands.
* C-z:                                  Emacs Related Commands.
* C-z:                                  Modes in VIP.
* C-z:                                  Modes in VIP.
* C:                                    Changing Text.
* D:                                    Deleting Text.
* ESC:                                  Modes in VIP.
* E:                                    Move Commands.
* F<char>:                              Move Commands.
* G:                                    Move Commands.
* H:                                    Move Commands.
* J:                                    Changing Text.
* L:                                    Move Commands.
* M:                                    Move Commands.
* N:                                    Move Commands.
* N:                                    Search and Replace.
* O:                                    Appending Text.
* P:                                    Yanking.
* P:                                    Appending Text.
* Q:                                    Search and Replace.
* Q:                                    New Commands.
* R:                                    Changing Text.
* S:                                    Changing Text.
* T<char>:                              Move Commands.
* U:                                    Undoing.
* V:                                    File Handling.
* V:                                    New Commands.
* W:                                    Move Commands.
* X:                                    Deleting Text.
* Y:                                    Yanking.
* ZZ:                                   File Handling.
* [<a-z>:                               New Commands.
* [<a-z>:                               Move Commands.
* [<a-z>:                               Yanking.
* [<a-z>:                               Mapping.
* [<a-z>:                               Appending Text.
* [[:                                   Move Commands.
* []:                                   New Commands.
* []:                                   Move Commands.
* ]<a-z>:                               Move Commands.
* ]<a-z>:                               Yanking.
* ]<a-z>:                               New Commands.
* ]<a-z>:                               Mapping.
* ]<a-z>:                               Appending Text.
* ]]:                                   Move Commands.
* ^C-d:                                 Editing in Insert Mode.
* ^:                                    Move Commands.
* _:                                    Emacs Related Commands.
* _:                                    Vi Mode.
* _:                                    New Commands.
* `<a-z>:                               Move Commands.
* `<a-z>:                               Marking.
* ":                                    Move Commands.
* ":                                    Marking.
* a:                                    Appending Text.
* b:                                    Move Commands.
* c<move>:                              Changing Text.
* cc:                                   Changing Text.
* d<move>:                              Deleting Text.
* dd:                                   Deleting Text.
* e:                                    Move Commands.
* f<char>:                              Move Commands.
* g<move>:                              Search and Replace.
* h:                                    Move Commands.
* i:                                    Appending Text.
* i:                                    Modes in VIP.
* j:                                    Move Commands.
* k:                                    Move Commands.
* l:                                    Move Commands.
* m,:                                   Marking.
* m.:                                   Marking.
* m<a-z>:                               Marking.
* m<a-z>:                               Yanking.
* m<a-z>:                               Move Commands.
* m<:                                   Marking.
* m>:                                   Marking.
* n:                                    Move Commands.
* n:                                    Search and Replace.
* o:                                    Appending Text.
* p:                                    Yanking.
* p:                                    Appending Text.
* r<char>:                              Changing Text.
* s:                                    Changing Text.
* t<char>:                              Move Commands.
* ts=<count>:                           Options.
* u:                                    Vi Mode.
* u:                                    Undoing.
* v:                                    File Handling.
* v:                                    New Commands.
* w:                                    Move Commands.
* x:                                    Deleting Text.
* y<move>:                              Yanking.
* yy:                                   Yanking.
* z-:                                   Display.
* z.:                                   Display.
* z<cr>:                                Display.
* z<cr>:                                Display.
* zH:                                   Display.
* zL:                                   Display.
* zM:                                   Display.
* |:                                    Move Commands.
* ~:                                    Changing Text.


File: vip.info,  Node: Concept Index,  Prev: Key Index,  Up: Top

Concept Index
*************

* Menu:

* # (Previous file):                    Groundwork.
* # (Previous file):                    Shell Commands.
* % (Current file):                     Groundwork.
* % (Current file):                     Shell Commands.
* % (Ex address):                       Groundwork.
* % (Ex address):                       Shell Commands.
* .emacs:                               Customization.
* .vip:                                 Customization.
* :map:                                 Keybindings.
* :set:                                 Rudimentary Changes.
* <a-z>:                                Groundwork.
* <address>:                            Groundwork.
* <args>:                               Groundwork.
* <cmd>:                                Groundwork.
* <cr>:                                 Groundwork.
* <esc>:                                Groundwork.
* <ht>:                                 Groundwork.
* <lf>:                                 Groundwork.
* <move>:                               Groundwork.
* <sp>:                                 Groundwork.
* C-c and VIP:                          Packages that change keymaps.
* CHAR:                                 Groundwork.
* Control keys:                         Emacs Preliminaries.
* Emacs mode:                           Modes in VIP.
* Emacs mode:                           Emacs Mode.
* Epoch:                                Useful Packages.
* Ex commands:                          Vi Mode.
* Ex commands:                          VI Macros.
* Ex commands:                          Modes in VIP.
* Insert mode:                          Modes in VIP.
* Insert mode:                          Insert Mode.
* Insert mode:                          Editing in Insert Mode.
* Meta key:                             Vi Mode.
* Meta key:                             Emacs Preliminaries.
* Meta key:                             Insert Mode.
* RCS:                                  Useful Packages.
* Replace mode:                         Modes in VIP.
* Replace mode:                         Replace Mode.
* VIP and C-c:                          Packages that change keymaps.
* VIP as minor mode:                    Emacs Preliminaries.
* Vi macros:                            VI Macros.
* Vi mode:                              Modes in VIP.
* Vi mode:                              Vi Mode.
* Vi options:                           Options.
* WORDS:                                Groundwork.
* X-windows Emacs:                      Useful Packages.
* abbrevs:                              Improved Abbrevs.
* absolute paths:                       Multiple Files in VIP.
* appending:                            Appending Text.
* auto fill:                            Options.
* auto save:                            Undo and Backups.
* autoindent:                           Options.
* backup files:                         Undoing.
* backup files:                         Undo and Backups.
* buffer:                               Emacs Preliminaries.
* buffer (modified):                    Emacs Preliminaries.
* buffer information:                   Emacs Preliminaries.
* buffer search:                        Improved Search.
* case and searching:                   Options.
* changing case:                        New Commands.
* changing case:                        Changing Text.
* changing tab width:                   Options.
* char:                                 Groundwork.
* column movement:                      Move Commands.
* command line:                         Emacs Preliminaries.
* compiling:                            Useful Packages.
* completion:                           Completion.
* customization:                        Customization.
* cut and paste:                        Yanking.
* describing regions:                   Basics.
* dired:                                Useful Packages.
* dynamic abbrevs:                      Improved Abbrevs.
* email:                                Useful Packages.
* end (of buffer):                      Emacs Preliminaries.
* end (of line):                        Emacs Preliminaries.
* ex addresses:                         Groundwork.
* ex style motion:                      Movement and Markers.
* expanding (region):                   Basics.
* global keymap:                        Emacs Preliminaries.
* headings:                             Move Commands.
* headings:                             VIP Specials.
* history:                              History.
* incremental search:                   Improved Search.
* initialization:                       Customization.
* inserting:                            Appending Text.
* interactive shell:                    Useful Packages.
* joining lines:                        Changing Text.
* keybindings:                          Keybindings.
* keybindings:                          Mapping.
* keyboard macros:                      Macros and Registers.
* keyboard macros:                      New Commands.
* keymap:                               Emacs Preliminaries.
* keymapping:                           Mapping.
* last keyboard macro:                  Macros and Registers.
* layout:                               Options.
* line commands:                        Groundwork.
* line commands:                        Basics.
* line editor motion:                   Movement and Markers.
* literal searching:                    Options.
* local keymap:                         Emacs Preliminaries.
* looking at:                           Emacs Preliminaries.
* macros:                               Macros and Registers.
* mail:                                 Useful Packages.
* major mode:                           Emacs Preliminaries.
* make:                                 Useful Packages.
* managing multiple files:              Multiple Files in VIP.
* mark:                                 Emacs Preliminaries.
* markers:                              Multiple Files in VIP.
* markers:                              Undo and Backups.
* markers:                              Move Commands.
* marking:                              Marking.
* matching parens:                      Options.
* matching parens:                      Move Commands.
* minibuffer:                           The Minibuffer.
* minibuffer:                           Emacs Preliminaries.
* minibuffer:                           History.
* minor mode:                           Emacs Preliminaries.
* mode:                                 Emacs Preliminaries.
* mode line:                            Emacs Preliminaries.
* mode line:                            Modes in VIP.
* movement commands:                    Basics.
* movement commands:                    Move Commands.
* movements:                            Groundwork.
* multiple files:                       File Handling.
* multiple files:                       Multiple Files in VIP.
* multiple undo:                        Vi Mode.
* navigator:                            Useful Packages.
* paragraphs:                           VIP Specials.
* paragraphs:                           Move Commands.
* paren matching:                       Options.
* paren matching:                       Move Commands.
* paste:                                Yanking.
* paste:                                Appending Text.
* point:                                Emacs Preliminaries.
* point commands:                       Groundwork.
* point commands:                       Basics.
* put:                                  Appending Text.
* query replace:                        Improved Search.
* query replace:                        New Commands.
* quoting regions:                      Changing Text.
* r and R region specifiers:            Basics.
* r and R region specifiers:            Groundwork.
* readonly files:                       Options.
* region:                               Emacs Preliminaries.
* region:                               Basics.
* region specification:                 Basics.
* register execution:                   New Commands.
* register execution:                   Macros and Registers.
* registers:                            Multiple Files in VIP.
* registers:                            Undo and Backups.
* registers:                            Macros and Registers.
* regular expressions:                  Vi Mode.
* scrolling:                            Display.
* searching:                            Options.
* searching:                            Move Commands.
* sections:                             Move Commands.
* sections:                             VIP Specials.
* sentences:                            VIP Specials.
* sentences:                            Move Commands.
* setting variables:                    Rudimentary Changes.
* shell:                                Useful Packages.
* shell:                                Options.
* shell commands:                       Shell Commands.
* shifting text:                        Deleting Text.
* shifting text:                        Options.
* substitution:                         Changing Text.
* tabbing:                              Options.
* templates:                            Improved Abbrevs.
* text:                                 Emacs Preliminaries.
* text processing:                      Search and Replace.
* textmarkers:                          Multiple Files in VIP.
* textmarkers:                          Move Commands.
* textmarkers:                          Movement and Markers.
* textmarkers:                          Undo and Backups.
* transparent ftp:                      Useful Packages.
* ultimate compatibilty:                VIP Specials.
* undo:                                 Vi Mode.
* undo:                                 Undo and Backups.
* undo:                                 Undoing.
* variables for customization:          Rudimentary Changes.
* version maintenance:                  Useful Packages.
* viewing registers and markers:        Macros and Registers.
* viewing registers and markers:        Undo and Backups.
* vip-become-vi:                        VIP Specials.
* vip-ex function:                      VI Macros.
* window:                               Emacs Preliminaries.
* word search:                          Improved Search.
* word wrap:                            Options.
* words:                                Groundwork.