home *** CD-ROM | disk | FTP | other *** search
/ Dream 49 / Amiga_Dream_49.iso / beos / emacs / emacs-19.34-bin / emacs-19 / info / viper-4 < prev    next >
Encoding:
GNU Info File  |  1997-09-17  |  46.2 KB  |  1,106 lines
  1. This is Info file ../info/viper, produced by Makeinfo-1.63 from the
  2. input file viper.texi.
  3.  
  4. Distribution
  5. ************
  6.  
  7. Copyright (C) 1995, 1996 Free Software Foundation, Inc.
  8.  
  9.    Permission is granted to make and distribute verbatim copies of this
  10. manual provided the copyright notice and this permission notice are
  11. preserved on all copies.
  12.  
  13.    Permission is granted to copy and distribute modified versions of
  14. this manual under the conditions for verbatim copying, provided that
  15. the entire resulting derived work is distributed under the terms of a
  16. permission notice identical to this one.
  17.  
  18.    Permission is granted to copy and distribute translations of this
  19. manual into another language, under the same conditions as for modified
  20. versions.
  21.  
  22. 
  23. File: viper,  Node: Display,  Next: File and Buffer Handling,  Prev: Text Handling,  Up: Commands
  24.  
  25. Display
  26. =======
  27.  
  28. `C-g'
  29.      At user level 1, give file name, status, current line number and
  30.      relative position.
  31.      At user levels 2 and higher, abort the current command.
  32.  
  33. `C-c g'
  34.      Give file name, status, current line number and relative position
  35.      - all user levels.
  36.  
  37. `C-l'
  38.      Refresh the screen.
  39.  
  40. `<count> C-e'
  41.      Expose <count> more lines at bottom, cursor stays put (if
  42.      possible).
  43.  
  44. `<count> C-y'
  45.      Expose <count> more lines at top, cursor stays put (if possible).
  46.  
  47. `<count> C-d'
  48.      Scroll <count> lines downward (default the number of the previous
  49.      scroll; initialization: half a page).
  50.  
  51. `<count> C-u'
  52.      Scroll <count> lines upward (default the number of the previous
  53.      scroll; initialization: half a page).
  54.  
  55. `<count> C-f'
  56.      <count> pages forward.
  57.  
  58. `<count> C-b'
  59.      <count> pages backward (in older versions `C-b' only works without
  60.      count).
  61.  
  62. `<count> z<cr>'
  63. `zH'
  64.      Put line <count> at the top of the window (default the current
  65.      line).
  66.  
  67. `<count> z-'
  68. `zL'
  69.      Put line <count> at the bottom of the window (default the current
  70.      line).
  71.  
  72. `<count> z.'
  73. `zM'
  74.      Put line <count> in the center of the window (default the current
  75.      line).
  76.  
  77. 
  78. File: viper,  Node: File and Buffer Handling,  Next: Mapping,  Prev: Display,  Up: Commands
  79.  
  80. File and Buffer Handling
  81. ========================
  82.  
  83.    In all file handling commands, space should be typed before entering
  84. the file name. If you need  to type a modifier, such as `>>' or `!',
  85. don't put any space between the command and the modifier.
  86.  
  87. `:q'
  88.      Quit buffer except if modified.
  89.  
  90. `:q!'
  91.      Quit buffer without checking. In Viper, these two commands are
  92.      identical. Confirmation is required if exiting modified buffers
  93.      that visit files.
  94.  
  95. `:susp'
  96. `:stop'
  97.      Suspend Viper
  98.  
  99. `:[x,y] w'
  100.      Write the file. Viper nakes sure that a final newline is always
  101.      added to any file where this newline is missing. This is done by
  102.      setting Emacs variable `require-final-newline' to `t'. If you
  103.      don't like this feature, use `setq-default' to set
  104.      `require-final-newline' to `nil'. This must be done either in
  105.      `.vip' file or in `.emacs' after Viper is loaded.
  106.  
  107. `:[x,y] w <name>'
  108.      Write to the file <name>.
  109.  
  110. `:[x,y] w>> <name>'
  111.      Append the buffer to the file <name>.  There should be no space
  112.      between `w' and `>>'. Type space after the `>>' and see what
  113.      happens.
  114.  
  115. `:w! <name>'
  116.      Overwrite the file <name>. In Viper, `:w' and `:w!' are identical.
  117.      Confirmation is required for writing to an existing file (if this
  118.      is not the file the buffer is visiting) or to a read-only file.
  119.  
  120. `:x,y w <name>'
  121.      Write lines x through y to the file <name>.
  122.  
  123. `:wq'
  124.      Write the file and kill buffer.
  125.  
  126. `:r <file> [<file> ...]'
  127.      Read file into a buffer, inserting its contents after the current
  128.      line.
  129.  
  130. `:xit'
  131.      Same as `:wq'.
  132.  
  133. `:W'
  134.      Save unsaved buffers, asking for confirmation.
  135.  
  136. `:WW'
  137.      Like `W', but without asking for confirmation.
  138.  
  139. `ZZ'
  140.      Save current buffer and kill it. If user level is 1, then save all
  141.      files and kill Emacs. Killing Emacs is the wrong way to use it, so
  142.      you should switch to  higher user levels as soon as possible.
  143.  
  144. `:x [<file>]'
  145.      Save and kill buffer.
  146.  
  147. `:x! [<file>]'
  148.      `:w![<file>]' and `:q'.
  149.  
  150. `:pre'
  151.      Preserve the file - autosave buffers.
  152.  
  153. `:rec'
  154.      Recover file from autosave.
  155.  
  156. `:f'
  157.      Print file name and lines.
  158.  
  159. `:cd [<dir>]'
  160.      Set the working directory to <dir> (default home directory).
  161.  
  162. `:pwd'
  163.      Print present working directory.
  164.  
  165. `:e [+<cmd>] <files>'
  166.      Edit files. If no filename is given, edit the file visited by the
  167.      current buffer. If buffer was modified or the file changed on
  168.      disk, ask for confirmation. Unlike Vi, Viper allows `:e' to take
  169.      multiple arguments.  The first file is edited the same way as in
  170.      Vi. The rest are visited in the usual Emacs way.
  171.  
  172. `:e! [+<cmd>] <files>'
  173.      Re-edit file. If no filename, reedit current file.  In Viper,
  174.      unlike Vi, `e!' is identical to `:e'. In both cases, the user is
  175.      asked to confirm if there is a danger of discarding changes to a
  176.      buffer.
  177.  
  178. `:q!'
  179.      Quit Vi without writing.
  180.  
  181. `C-^'
  182.      Edit the alternate (normally the previous) file.
  183.  
  184. `:rew'
  185.      Obsolete
  186.  
  187. `:args'
  188.      List files not shown anywhere with counts for next
  189.  
  190. `:n [count]  [+<cmd>] [<files>]'
  191.      Edit <count> file, or edit files. The count comes from :args.
  192.  
  193. `:N [count] [+<cmd>] [<files>]'
  194.      Like `:n', but the meaning of the variable EX-CYCLE-OTHER-WINDOW
  195.      is reversed.
  196.  
  197. `:b'
  198.      Switch to another buffer. If EX-CYCLE-OTHER-WINDOW is `t', switch
  199.      in another window. Buffer completion is supported.
  200.  
  201. `:B'
  202.      Like `:b', but the meaning of EX-CYCLE-OTHER-WINDOW is reversed.
  203.  
  204. `:<address>r <name>'
  205.      Read the file <name> into the buffer after the line <address>.
  206.  
  207. `v, V, C-v'
  208.      Edit a file in current or another window, or in another frame.
  209.      File name is typed in Minibuffer. File completion and history are
  210.      supported.
  211.  
  212. 
  213. File: viper,  Node: Mapping,  Next: Shell Commands,  Prev: File and Buffer Handling,  Up: Commands
  214.  
  215. Mapping
  216. =======
  217.  
  218. `:map <string>'
  219.      Start defining a Vi-style keyboard macro.   For instance, typing
  220.      `:map www' followed by `:!wc %' and then typing `C-x )'  will
  221.      cause `www' to run wc on  current file (Vi replaces `%' with the
  222.      current file name).
  223.  
  224. `C-x )'
  225.      Finish defining a keyboard macro.   In Viper, this command
  226.      completes the process of defining all keyboard macros, whether
  227.      they are Emacs-style or Vi-style.  This is a departure from Vi,
  228.      needed to allow WYSIWYG mapping of keyboard macros and to permit
  229.      the use of function keys and arbitrary Emacs functions in the
  230.      macros.
  231.  
  232. `:unmap <string>'
  233.      Deprive <string> of its mappings in Vi state.
  234.  
  235. `:map! <string>'
  236.      Map a macro for Insert state.
  237.  
  238. `:unmap! <string>'
  239.      Deprive <string> of its mapping in Insert state (see `:unmap').
  240.  
  241. `@<a-z>'
  242.      In Vi state,  execute the contents of register as a command.
  243.  
  244. `@@'
  245.      In Vi state,  repeat last register command.
  246.  
  247. `@#'
  248.      In Vi state,  begin keyboard macro. End with @<a-z>. This will
  249.      put the macro in the proper register. Register will  be
  250.      automatically downcased.   *Note Macros and Registers::, for more
  251.      info.
  252.  
  253. `@!<a-z>'
  254.      In Vi state,  yank anonymous macro to register
  255.  
  256. `*'
  257.      In Vi state,  execute anonymous macro (defined by C-x( and C-x )).
  258.  
  259. `C-x e'
  260.      Like `*', but works in all Viper states.
  261.  
  262. `#g<move>'
  263.      Execute the last keyboard macro for each line in the region.
  264.      *Note Macros and Registers::, for more info.
  265.  
  266. `[<a-z>'
  267.      Show contents of textmarker.
  268.  
  269. `]<a-z>'
  270.      Show contents of register.
  271.  
  272. 
  273. File: viper,  Node: Shell Commands,  Next: Options,  Prev: Mapping,  Up: Commands
  274.  
  275. Shell Commands
  276. ==============
  277.  
  278.    Note that % is used in Ex commands to mean current file. If you want
  279. a % in your command, it must be escaped as `\%'.  However if % is the
  280. first character, it stands as the address for the whole file.
  281. Similarly, `#' expands to the previous file. The previous file is the
  282. first file in `:args' listing. This defaults to the previous file in
  283. the VI sense if you have one window.
  284.  
  285. `:sh'
  286.      Execute a subshell in another window
  287.  
  288. `:[x,y]!<cmd>'
  289.      Execute a shell <cmd> [on lines x through y; % is replace by
  290.      current file, \% is changed to %
  291.  
  292. `:[x,y]!! [<args>]'
  293.      Repeat last shell command [and append <args>].
  294.  
  295. `:!<cmd>'
  296.      Just execute command and display result in a buffer.
  297.  
  298. `:!! <args>'
  299.      Repeat last shell command and append <args>
  300.  
  301. `<count> !<move><cmd>'
  302.      The shell executes <cmd>, with standard input the lines described
  303.      by <count><move>, next the standard output replaces those lines
  304.      (think of `cb', `sort', `nroff', etc.).
  305.  
  306. `<count> !!<cmd>'
  307.      Give <count> lines as standard input to the shell <cmd>, next let
  308.      the standard output replace those lines.
  309.  
  310. `:[x,y] w !<cmd>'
  311.      Let lines x to y be standard input for <cmd> (notice the <sp>
  312.      between `w' and `!').
  313.  
  314. `:<address>r !<cmd>'
  315.      Put the output of <cmd> after the line <address> (default current).
  316.  
  317. `:<address>r <name>'
  318.      Read the file <name> into the buffer after the line <address>
  319.      (default current).
  320.  
  321. 
  322. File: viper,  Node: Options,  Next: Emacs Related Commands,  Prev: Shell Commands,  Up: Commands
  323.  
  324. Options
  325. =======
  326.  
  327. `ai'
  328.      autoindent - In append mode after a <cr> the cursor will move
  329.      directly below the first CHAR on the previous line.
  330.  
  331. `ic'
  332.      ignorecase - No distinction between upper and lower cases when
  333.      searching.
  334.  
  335. `magic'
  336.      Regular expressions used in searches; nomagic means no regexps.
  337.  
  338. `ro'
  339.      readonly - The file is not to be changed.  If the user attempts to
  340.      write to this file, confirmation will be requested.
  341.  
  342. `sh=<string>'
  343.      shell - The program to be used for shell escapes (default `$SHELL'
  344.      (default `/bin/sh')).
  345.  
  346. `sw=<count>'
  347.      shiftwidth - Gives the shiftwidth (default 8 positions).
  348.  
  349. `sm'
  350.      showmatch - Whenever you append a `)', Vi shows its match if it's
  351.      on the same page; also with `{' and `}'.  If there's no match, Vi
  352.      will beep.
  353.  
  354. `ts=<count>'
  355.      tabstop - The length of a <ht>; warning: this is only IN the
  356.      editor, outside of it <ht>s have their normal length (default 8
  357.      positions).
  358.  
  359. `wm=<count>'
  360.      wrapmargin - In append mode Vi automatically puts a <lf> whenever
  361.      there is a <sp> or <ht> within <wm> columns from the right margin.
  362.  
  363. `ws'
  364.      wrapscan - When searching, the end is considered `stuck' to the
  365.      begin of the file.
  366.  
  367. `:set <option>'
  368.      Turn <option> on.
  369.  
  370. `:set no<option>'
  371.      Turn <option> off.
  372.  
  373. `:set <option>=<value>'
  374.      Set <option> to <value>.
  375.  
  376. 
  377. File: viper,  Node: Emacs Related Commands,  Prev: Options,  Up: Commands
  378.  
  379. Emacs Related Commands
  380. ======================
  381.  
  382. `_'
  383.      Begin Meta command in Vi state. Most often used as _x (M-x).
  384.  
  385. `C-z'
  386.      Begin Meta command in Insert state.
  387.  
  388. `C-z'
  389.      Switch between Emacs and Vi states.
  390.  
  391. `C-x0'
  392.      Close Window
  393.  
  394. `C-x1'
  395.      Close Other Windows
  396.  
  397. `C-x2'
  398.      Split Window
  399.  
  400. `C-xo'
  401.      Move among windows
  402.  
  403. `C-xC-f'
  404.      Emacs find-file, useful in Insert state
  405.  
  406. `C-y'
  407.      Put back the last killed text. Similar to Vi's `p', but also works
  408.      in Insert and Replace state. This command doesn't work in Vi
  409.      command state, since this binding is taken for something else.
  410.  
  411. `M-y'
  412.      Undoes the last `C-y' and puts another kill from the kill ring.
  413.      Using this command, you can try may different kills until you find
  414.      the one you need.
  415.  
  416. 
  417. File: viper,  Node: Mouse-bound Commands,  Up: Commands
  418.  
  419. Mouse-bound Commands
  420. ====================
  421.  
  422.    The following two mouse actions are normally bound to to special
  423. search and insert commands in of Viper:
  424.  
  425. `S-mouse-1 (Emacs)'
  426. `meta button1up (XEmacs)'
  427.      Holding Shift (or Meta, if XEmacs) and clicking mouse button 1 will
  428.      initiate search for a region under the mouse pointer.  This
  429.      command can take a prefix argument. Note: Viper sets this binding
  430.      only if this mouse action is not already bound to something else.
  431.      *Note Viper Specials::, for more information.
  432.  
  433. `S-mouse-2 (Emacs)'
  434. `meta button2up (XEmacs)'
  435.      Holding Shift (or Meta, if XEmacs) and clicking button 2 of the
  436.      mouse will insert a region surrounding the mouse pointer.  This
  437.      command can also take a prefix argument.  Note: Viper sets this
  438.      binding only if this mouse action is not already bound to
  439.      something else.  *Note Viper Specials::, for more details.
  440.  
  441. 
  442. File: viper,  Node: Acknowledgments,  Up: Top
  443.  
  444. Acknowledgments
  445. ***************
  446.  
  447.    Viper, formerly known as VIP-19, was written by Michael Kifer. Viper
  448. is based on the original VIP package by Masahiko Sato and on its
  449. enhancement, VIP 4.4, by Aamod Sane. This manual is an adaptation of
  450. the manual for VIP 4.4, which, in turn, was based on Sato's manual for
  451. VIP 3.5.
  452.  
  453.    Many contributors on the net pointed out bugs and suggested a number
  454. of useful features. Here is a (hopefully) complete list of contributors:
  455.  
  456.      jjm@hplb.hpl.hp.com (Jean-Jacques Moreau), jl@cse.ogi.edu (John
  457.      Launchbury), rxga@ulysses.att.com, jamesm@bga.com (D.J. Miller II),
  458.      ascott@fws214.intel.com (Andy Scott), toma@convex.convex.com,
  459.      dave@hellgate.utah.edu, cook@biostat.wisc.edu
  460.      (Tom Cook), lindstro@biostat.wisc.edu (Mary Lindstrom),
  461.      edmonds@edmonds.home.cs.ubc.ca (Brian Edmonds), mveiga@dit.upm.es
  462.      (Marcelino Veiga Tuimil), dwight@toolucky.llnl.gov (Dwight Shih),
  463.      phil_brooks@MENTORG.COM (Phil Brooks), kin@isi.com (Kin Cho),
  464.      ahg@panix.com (Al Gelders), dwallach@cs.princeton.edu (Dan Wallach),
  465.      hpz@ibmhpz.aug.ipp-garching.mpg.de (Hans-Peter Zehrfeld),
  466.      simonb@prl.philips.co.uk (Simon Blanchard), Mark.Bordas@East.Sun.COM
  467.      (Mark Bordas), gviswana@cs.wisc.edu (Guhan Viswanathan),
  468.      meyering@comco.com (Jim Meyering), pfister@cs.sunysb.edu (Hanspeter
  469.      Pfister),  amade@diagram.fr (Paul-Bernard Amade),
  470.      jackr@dblues.engr.sgi.com (Jack Repenning),
  471.      pogrell@informatik.hu-berlin.de (Lutz Pogrell),
  472.      csdayton@midway.uchicago.edu (Soren Dayton),
  473.      pradyut@cs.uchicago.edu (Pradyut Shah),
  474.      vrenjak@sun1.racal.com (Milan Vrenjak),
  475.      gvr@halcyon.com (George V. Reilly),
  476.      whicken@dragon.parasoft.com (Wendell Hicken),
  477.      terra@diku.dk (Morten Welinder),
  478.      kanze@gabi-soft.fr (James Kanze),
  479.      hatazaki@bach.convex.com (Takao Hatazaki),
  480.      sawdey@lcse.umn.edu (Aaron Sawdey),
  481.      jobrien@hchp.org (John O'Brien),
  482.      mrb@Eng.Sun.COM (Martin Buchholz)
  483.  
  484. 
  485. File: viper,  Node: Key Index,  Next: Function Index,  Up: Top
  486.  
  487. Key Index
  488. *********
  489.  
  490. * Menu:
  491.  
  492. * <a-z>:                                Groundwork.
  493. * <address>:                            Groundwork.
  494. * <args>:                               Groundwork.
  495. * <cmd>:                                Groundwork.
  496. * <move>:                               Groundwork.
  497. * "<a-z1-9>p <1>:                       Yanking.
  498. * "<a-z1-9>p:                           Appending Text.
  499. * "<A-Z>y<move>:                        Yanking.
  500. * #C<move>:                             Changing Text.
  501. * #c<move>:                             New Commands.
  502. * #g<move> <1>:                         Mapping.
  503. * #g<move> <1>:                         Search and Replace.
  504. * #g<move>:                             New Commands.
  505. * #q<move> :                            Changing Text.
  506. * #q<move>:                             New Commands.
  507. * #s<move>:                             New Commands.
  508. * #:                                    New Commands.
  509. * $:                                    Move Commands.
  510. * % <1>:                                Search and Replace.
  511. * %:                                    Move Commands.
  512. * & <1>:                                Search and Replace.
  513. * &:                                    Changing Text.
  514. * " <1>:                                Marking.
  515. * ":                                    Move Commands.
  516. * '<a-z> <1>:                           Marking.
  517. * '<a-z>:                               Move Commands.
  518. * (:                                    Move Commands.
  519. * ):                                    Move Commands.
  520. * * <1>:                                Mapping.
  521. * *:                                    New Commands.
  522. * +:                                    Move Commands.
  523. * ,:                                    Move Commands.
  524. * -:                                    Move Commands.
  525. * . <1>:                                Undoing.
  526. * .:                                    Appending Text.
  527. * /<cr>:                                Move Commands.
  528. * /<string> <1>:                        Search and Replace.
  529. * /<string>:                            Move Commands.
  530. * 0:                                    Move Commands.
  531. * ;:                                    Move Commands.
  532. * <<move>:                              Deleting Text.
  533. * <<:                                   Deleting Text.
  534. * <cr>:                                 Move Commands.
  535. * <lf>:                                 Move Commands.
  536. * <sp>:                                 Move Commands.
  537. * =<move>:                              Changing Text.
  538. * ><move>:                              Appending Text.
  539. * >>:                                   Appending Text.
  540. * ?<cr>:                                Move Commands.
  541. * ?<string> <1>:                        Search and Replace.
  542. * ?<string>:                            Move Commands.
  543. * @!<a-z>:                              Mapping.
  544. * @!:                                   New Commands.
  545. * @# <1>:                               Mapping.
  546. * @#:                                   New Commands.
  547. * @<a-z> <1>:                           Mapping.
  548. * @<a-z>:                               New Commands.
  549. * @@:                                   Mapping.
  550. * {:                                    Move Commands.
  551. * }:                                    Move Commands.
  552. * [<a-z> <1>:                           Mapping.
  553. * [<a-z> <1>:                           Yanking.
  554. * [<a-z> <1>:                           Appending Text.
  555. * [<a-z> <1>:                           Move Commands.
  556. * [<a-z>:                               New Commands.
  557. * [[:                                   Move Commands.
  558. * [] <1>:                               Move Commands.
  559. * []:                                   New Commands.
  560. * \:                                    New Commands.
  561. * ]<a-z> <1>:                           Mapping.
  562. * ]<a-z> <1>:                           Yanking.
  563. * ]<a-z> <1>:                           Appending Text.
  564. * ]<a-z> <1>:                           Move Commands.
  565. * ]<a-z>:                               New Commands.
  566. * ]]:                                   Move Commands.
  567. * ^:                                    Move Commands.
  568. * _ <1>:                                Emacs Related Commands.
  569. * _ <1>:                                New Commands.
  570. * _:                                    Vi State.
  571. * `<a-z> <1>:                           Marking.
  572. * `<a-z>:                               Move Commands.
  573. * " <1>:                                Marking.
  574. * ":                                    Move Commands.
  575. * A:                                    Appending Text.
  576. * B:                                    Move Commands.
  577. * C-] <1>:                              New Commands.
  578. * C-]:                                  Vi State.
  579. * C-^:                                  File and Buffer Handling.
  580. * C-b:                                  Display.
  581. * C-c / <1>:                            Move Commands.
  582. * C-c / <1>:                            New Commands.
  583. * C-c /:                                Vi State.
  584. * C-c g:                                New Commands.
  585. * C-c M-n <1>:                          Changing Text.
  586. * C-c M-n <1>:                          Appending Text.
  587. * C-c M-n:                              New Commands.
  588. * C-c M-p <1>:                          Changing Text.
  589. * C-c M-p <1>:                          Appending Text.
  590. * C-c M-p:                              New Commands.
  591. * C-c <1>:                              New Commands.
  592. * C-c:                                  Vi State.
  593. * C-d:                                  Display.
  594. * C-e:                                  Display.
  595. * C-f:                                  Display.
  596. * C-g <1>:                              Display.
  597. * C-g <1>:                              New Commands.
  598. * C-g:                                  Vi State.
  599. * C-h:                                  Move Commands.
  600. * C-l:                                  Display.
  601. * C-n:                                  Move Commands.
  602. * C-p:                                  Move Commands.
  603. * C-u <1>:                              Display.
  604. * C-u:                                  Editing in Insert State.
  605. * C-v <1>:                              Editing in Insert State.
  606. * C-v:                                  New Commands.
  607. * C-w:                                  Editing in Insert State.
  608. * C-x0:                                 Emacs Related Commands.
  609. * C-x1:                                 Emacs Related Commands.
  610. * C-x2:                                 Emacs Related Commands.
  611. * C-xC-f:                               Emacs Related Commands.
  612. * C-xo:                                 Emacs Related Commands.
  613. * C-x <1>:                              New Commands.
  614. * C-x:                                  Vi State.
  615. * C-y <1>:                              Emacs Related Commands.
  616. * C-y:                                  Display.
  617. * C-z <1>:                              Emacs Related Commands.
  618. * C-z <1>:                              Emacs State.
  619. * C-z:                                  States in Viper.
  620. * c<move>:                              Changing Text.
  621. * cc:                                   Changing Text.
  622. * C:                                    Changing Text.
  623. * d<move>:                              Deleting Text.
  624. * dd:                                   Deleting Text.
  625. * D:                                    Deleting Text.
  626. * ESC:                                  States in Viper.
  627. * E:                                    Move Commands.
  628. * F<char>:                              Move Commands.
  629. * g<move>:                              Search and Replace.
  630. * G:                                    Move Commands.
  631. * H:                                    Move Commands.
  632. * i <1>:                                Appending Text.
  633. * i:                                    States in Viper.
  634. * J:                                    Changing Text.
  635. * j:                                    Move Commands.
  636. * k:                                    Move Commands.
  637. * L:                                    Move Commands.
  638. * m,:                                   Marking.
  639. * M-n:                                  New Commands.
  640. * M-p:                                  New Commands.
  641. * M-y:                                  Emacs Related Commands.
  642. * m.:                                   Marking.
  643. * m<a-z> <1>:                           Yanking.
  644. * m<a-z> <1>:                           Marking.
  645. * m<a-z>:                               Move Commands.
  646. * m<:                                   Marking.
  647. * m>:                                   Marking.
  648. * meta button1up:                       Mouse-bound Commands.
  649. * meta button2up:                       Mouse-bound Commands.
  650. * meta shift button1up:                 Viper Specials.
  651. * meta shift button2up:                 Viper Specials.
  652. * M:                                    Move Commands.
  653. * N <1>:                                Search and Replace.
  654. * N:                                    Move Commands.
  655. * O:                                    Appending Text.
  656. * P <1>:                                Yanking.
  657. * P:                                    Appending Text.
  658. * Q <1>:                                Search and Replace.
  659. * Q:                                    New Commands.
  660. * r<char>:                              Changing Text.
  661. * R:                                    Changing Text.
  662. * S-mouse-1 <1>:                        Mouse-bound Commands.
  663. * S-mouse-1:                            Viper Specials.
  664. * S-mouse-2 <1>:                        Mouse-bound Commands.
  665. * S-mouse-2:                            Viper Specials.
  666. * S:                                    Changing Text.
  667. * T<char>:                              Move Commands.
  668. * U:                                    Undoing.
  669. * u:                                    Vi State.
  670. * v <1>:                                File and Buffer Handling.
  671. * v:                                    New Commands.
  672. * W:                                    Move Commands.
  673. * X:                                    Deleting Text.
  674. * y<move>:                              Yanking.
  675. * yank:                                 Yanking.
  676. * yy:                                   Yanking.
  677. * Y:                                    Yanking.
  678. * z-:                                   Display.
  679. * z.:                                   Display.
  680. * z<cr>:                                Display.
  681. * zH:                                   Display.
  682. * zL:                                   Display.
  683. * zM:                                   Display.
  684. * ZZ:                                   File and Buffer Handling.
  685. * |:                                    Move Commands.
  686. * ~:                                    Changing Text.
  687.  
  688. 
  689. File: viper,  Node: Function Index,  Next: Variable Index,  Prev: Key Index,  Up: Top
  690.  
  691. Function Index
  692. **************
  693.  
  694. * Menu:
  695.  
  696. * add-hook:                             Packages that Change Keymaps.
  697. * remove-hook:                          Packages that Change Keymaps.
  698. * vip-add-local-keys:                   Keybindings.
  699. * vip-buffer-search-enable:             Viper Specials.
  700. * vip-describe-kbd-macros:              Vi Macros.
  701. * vip-ex-nontrivial-find-file-ms:       Rudimentary Changes.
  702. * vip-ex-nontrivial-find-file-unix:     Rudimentary Changes.
  703. * vip-harness-minor-mode:               Packages that Change Keymaps.
  704. * vip-modify-major-mode:                Keybindings.
  705. * vip-mouse-click-insert-word:          Viper Specials.
  706. * vip-mouse-click-search-word:          Viper Specials.
  707. * vip-set-expert-level:                 Viper Specials.
  708. * vip-set-hooks:                        Packages that Change Keymaps.
  709. * vip-unrecord-kbd-macro <1>:           Vi Macros.
  710. * vip-unrecord-kbd-macro:               Viper Specials.
  711. * vip-zap-local-keys:                   Keybindings.
  712. * viper-mode:                           Packages that Change Keymaps.
  713. * !!<cmd>:                              Shell Commands.
  714. * !<cmd>:                               Shell Commands.
  715. * !<move><cmd>:                         Shell Commands.
  716. * :!! <args>:                           Shell Commands.
  717. * :!<cmd>:                              Shell Commands.
  718. * :<address>r !<cmd>:                   Shell Commands.
  719. * :<address>r <name>:                   Shell Commands.
  720. * :args <1>:                            File and Buffer Handling.
  721. * :args:                                New Commands.
  722. * :cd [<dir>]:                          File and Buffer Handling.
  723. * :copy [z]:                            Changing Text.
  724. * :e [<files>]:                         File and Buffer Handling.
  725. * :e! [<files>]:                        File and Buffer Handling.
  726. * :e!:                                  Undoing.
  727. * :edit [<files>]:                      File and Buffer Handling.
  728. * :edit! [<files>]:                     File and Buffer Handling.
  729. * :f:                                   File and Buffer Handling.
  730. * :g/<string>/<cmd>:                    Search and Replace.
  731. * :global/<string>/<cmd>:               Search and Replace.
  732. * :k:                                   Marking.
  733. * :map <char> <seq>:                    Mapping.
  734. * :map! <char> <seq>:                   Mapping.
  735. * :map:                                 Keybindings.
  736. * :mark:                                Marking.
  737. * :move [z]:                            Changing Text.
  738. * :n [<count> | <file>]:                File and Buffer Handling.
  739. * :n:                                   New Commands.
  740. * :PreviousRelatedFile <1>:             Viper Specials.
  741. * :PreviousRelatedFile:                 New Commands.
  742. * :pre <1>:                             File and Buffer Handling.
  743. * :pre:                                 New Commands.
  744. * :pwd <1>:                             File and Buffer Handling.
  745. * :pwd:                                 New Commands.
  746. * :q! <1>:                              File and Buffer Handling.
  747. * :q!:                                  Undoing.
  748. * :quit!:                               File and Buffer Handling.
  749. * :quit:                                File and Buffer Handling.
  750. * :q:                                   File and Buffer Handling.
  751. * :read:                                File and Buffer Handling.
  752. * :rec <1>:                             File and Buffer Handling.
  753. * :rec:                                 Undoing.
  754. * :RelatedFile <1>:                     Viper Specials.
  755. * :RelatedFile:                         New Commands.
  756. * :rew:                                 File and Buffer Handling.
  757. * :r:                                   File and Buffer Handling.
  758. * :s/<p>/<r>/<f>:                       Changing Text.
  759. * :set <option>=<value>:                Options.
  760. * :set <option>:                        Options.
  761. * :set ai:                              Options.
  762. * :set autoindent:                      Options.
  763. * :set ic:                              Options.
  764. * :set ignorecase:                      Options.
  765. * :set magic:                           Options.
  766. * :set no<option>:                      Options.
  767. * :set readonly:                        Options.
  768. * :set ro:                              Options.
  769. * :set sh=<string>:                     Options.
  770. * :set shell=<string>:                  Options.
  771. * :set shiftwidth=<count>:              Options.
  772. * :set showmatch:                       Options.
  773. * :set sm:                              Options.
  774. * :set sw=<count>:                      Options.
  775. * :set tab-stop-local=<count>:          Options.
  776. * :set tabstop=<count>:                 Options.
  777. * :set ts=<count>:                      Options.
  778. * :set wm=<count>:                      Options.
  779. * :set wrapmargin=<count>:              Options.
  780. * :set wrapscan:                        Options.
  781. * :set ws:                              Options.
  782. * :set:                                 Rudimentary Changes.
  783. * :sh:                                  Shell Commands.
  784. * :stop:                                File and Buffer Handling.
  785. * :substitute/<p>/<r>/<f> <1>:          Search and Replace.
  786. * :substitute/<p>/<r>/<f>:              Changing Text.
  787. * :susp:                                File and Buffer Handling.
  788. * :t [z]:                               Changing Text.
  789. * :tag <name>:                          Search and Replace.
  790. * :unmap <char>:                        Mapping.
  791. * :unmap! <char>:                       Mapping.
  792. * :v/<string>/<cmd>:                    Search and Replace.
  793. * :w !<cmd>:                            Shell Commands.
  794. * :w <file>:                            File and Buffer Handling.
  795. * :w >> <file>:                         File and Buffer Handling.
  796. * :w! <file>:                           File and Buffer Handling.
  797. * :wq:                                  File and Buffer Handling.
  798. * :write <file>:                        File and Buffer Handling.
  799. * :write >> <file>:                     File and Buffer Handling.
  800. * :write! <file>:                       File and Buffer Handling.
  801. * :Write:                               File and Buffer Handling.
  802. * :WWrite:                              File and Buffer Handling.
  803. * :WW:                                  File and Buffer Handling.
  804. * :W:                                   File and Buffer Handling.
  805. * :x!:                                  File and Buffer Handling.
  806. * :x,y w !<cmd>:                        Shell Commands.
  807. * :x:                                   File and Buffer Handling.
  808. * :yank:                                Yanking.
  809.  
  810. 
  811. File: viper,  Node: Variable Index,  Next: Package Index,  Prev: Function Index,  Up: Top
  812.  
  813. Variable Index
  814. **************
  815.  
  816. * Menu:
  817.  
  818. * buffer-read-only:                     Rudimentary Changes.
  819. * ex-cycle-other-window:                Rudimentary Changes.
  820. * ex-cycle-through-non-files:           Rudimentary Changes.
  821. * ex-nontrivial-find-file-function.:    Rudimentary Changes.
  822. * function-key-map:                     Keybindings.
  823. * vip-always <1>:                       Packages that Change Keymaps.
  824. * vip-always:                           Rudimentary Changes.
  825. * vip-auto-indent:                      Rudimentary Changes.
  826. * vip-automatic-iso-accents:            Rudimentary Changes.
  827. * vip-buffer-search-char <1>:           Viper Specials.
  828. * vip-buffer-search-char:               Rudimentary Changes.
  829. * vip-case-fold-search:                 Rudimentary Changes.
  830. * vip-command-ring-size:                Viper Specials.
  831. * vip-custom-file-name:                 Rudimentary Changes.
  832. * vip-delete-backwards-in-replace:      Rudimentary Changes.
  833. * vip-electric-mode:                    Rudimentary Changes.
  834. * vip-emacs-global-user-map:            Keybindings.
  835. * vip-emacs-state-hook:                 Rudimentary Changes.
  836. * vip-ESC-key:                          Rudimentary Changes.
  837. * vip-ex-style-editing-in-insert:       Rudimentary Changes.
  838. * vip-ex-style-motion:                  Rudimentary Changes.
  839. * vip-fast-keyseq-timeout:              Vi Macros.
  840. * vip-insert-global-user-map:           Keybindings.
  841. * vip-insert-state-hook:                Rudimentary Changes.
  842. * vip-insertion-ring-size:              Viper Specials.
  843. * vip-keep-point-on-repeat:             Rudimentary Changes.
  844. * vip-keep-point-on-undo:               Rudimentary Changes.
  845. * vip-keysequence-delay:                Rudimentary Changes.
  846. * vip-multiclick-timeout:               Viper Specials.
  847. * vip-no-multiple-ESC:                  Rudimentary Changes.
  848. * vip-re-query-replace:                 Rudimentary Changes.
  849. * vip-re-search:                        Rudimentary Changes.
  850. * vip-replace-overlay-face:             Rudimentary Changes.
  851. * vip-replace-region-end-symbol:        Rudimentary Changes.
  852. * vip-replace-region-start-symbol:      Rudimentary Changes.
  853. * vip-replace-state-hook:               Rudimentary Changes.
  854. * vip-search-face <1>:                  Rudimentary Changes.
  855. * vip-search-face:                      Improved Search.
  856. * vip-search-wrap-around:               Rudimentary Changes.
  857. * vip-shift-width:                      Rudimentary Changes.
  858. * vip-smart-suffix-list:                Viper Specials.
  859. * vip-spell-function <1>:               Rudimentary Changes.
  860. * vip-spell-function:                   New Commands.
  861. * vip-surrounding-word-function:        Rudimentary Changes.
  862. * vip-syntax-preference <1>:            Groundwork.
  863. * vip-syntax-preference:                Movement and Markers.
  864. * vip-tags-file-name:                   Rudimentary Changes.
  865. * vip-toggle-key:                       Rudimentary Changes.
  866. * vip-vi-global-user-map:               Keybindings.
  867. * vip-vi-state-hook:                    Rudimentary Changes.
  868. * vip-vi-style-in-minibuffer:           Rudimentary Changes.
  869. * vip-want-ctl-h-help:                  Rudimentary Changes.
  870. * vip-want-emacs-keys-in-insert <1>:    Packages that Change Keymaps.
  871. * vip-want-emacs-keys-in-insert:        Rudimentary Changes.
  872. * vip-want-emacs-keys-in-vi <1>:        Packages that Change Keymaps.
  873. * vip-want-emacs-keys-in-vi:            Rudimentary Changes.
  874.  
  875. 
  876. File: viper,  Node: Package Index,  Next: Concept Index,  Prev: Variable Index,  Up: Top
  877.  
  878. Package Index
  879. *************
  880.  
  881. * Menu:
  882.  
  883. * ange-ftp.el:                          Useful Packages.
  884. * desktop.el:                           Useful Packages.
  885. * dired.el:                             Useful Packages.
  886. * ediff.el:                             Useful Packages.
  887. * font-lock.el:                         Useful Packages.
  888. * hilit19.el:                           Useful Packages.
  889. * ispell.el:                            Useful Packages.
  890. * vc.el:                                Useful Packages.
  891.  
  892. 
  893. File: viper,  Node: Concept Index,  Prev: Package Index,  Up: Top
  894.  
  895. Concept Index
  896. *************
  897.  
  898. * Menu:
  899.  
  900. * # (Previous file) <1>:                Shell Commands.
  901. * # (Previous file):                    Groundwork.
  902. * % (Current file) <1>:                 Shell Commands.
  903. * % (Current file):                     Groundwork.
  904. * % (Ex address) <1>:                   Shell Commands.
  905. * % (Ex address):                       Groundwork.
  906. * .emacs:                               Customization.
  907. * .vip:                                 Customization.
  908. * <a-z>:                                Groundwork.
  909. * <address>:                            Groundwork.
  910. * <args>:                               Groundwork.
  911. * <cmd>:                                Groundwork.
  912. * <cr>:                                 Groundwork.
  913. * <esc>:                                Groundwork.
  914. * <ht>:                                 Groundwork.
  915. * <lf>:                                 Groundwork.
  916. * <move>:                               Groundwork.
  917. * <sp>:                                 Groundwork.
  918. * abbrevs:                              Abbreviation Facilities.
  919. * absolute paths:                       Multiple Files in Viper.
  920. * appending:                            Appending Text.
  921. * auto fill:                            Options.
  922. * auto save:                            Undo and Backups.
  923. * autoindent:                           Options.
  924. * backup files <1>:                     Undoing.
  925. * backup files:                         Undo and Backups.
  926. * buffer:                               Emacs Preliminaries.
  927. * buffer (modified):                    Emacs Preliminaries.
  928. * buffer information:                   Emacs Preliminaries.
  929. * buffer search:                        Improved Search.
  930. * C-c and Viper:                        Packages that Change Keymaps.
  931. * case and searching:                   Options.
  932. * case-insensitive search <1>:          Move Commands.
  933. * case-insensitive search <1>:          New Commands.
  934. * case-insensitive search:              Vi State.
  935. * case-sensitive search <1>:            Move Commands.
  936. * case-sensitive search <1>:            New Commands.
  937. * case-sensitive search:                Vi State.
  938. * changing case <1>:                    Changing Text.
  939. * changing case:                        New Commands.
  940. * changing tab width:                   Options.
  941. * char:                                 Groundwork.
  942. * column movement:                      Move Commands.
  943. * Command history:                      New Commands.
  944. * command line:                         Emacs Preliminaries.
  945. * Command ring:                         New Commands.
  946. * compiling:                            Useful Packages.
  947. * completion:                           Completion.
  948. * Control keys:                         Emacs Preliminaries.
  949. * customization:                        Customization.
  950. * cut and paste:                        Yanking.
  951. * describing regions:                   Basics.
  952. * desktop:                              Useful Packages.
  953. * Destructive command history:          Viper Specials.
  954. * Destructive command ring:             Viper Specials.
  955. * dired:                                Useful Packages.
  956. * dynamic abbrevs:                      Abbreviation Facilities.
  957. * ediff:                                Useful Packages.
  958. * Emacs state <1>:                      Emacs State.
  959. * Emacs state:                          States in Viper.
  960. * email:                                Useful Packages.
  961. * end (of buffer):                      Emacs Preliminaries.
  962. * end (of line):                        Emacs Preliminaries.
  963. * Ex addresses:                         Groundwork.
  964. * Ex commands <1>:                      Vi State.
  965. * Ex commands:                          States in Viper.
  966. * Ex style motion:                      Movement and Markers.
  967. * expanding (region):                   Basics.
  968. * font-lock:                            Useful Packages.
  969. * global keymap:                        Emacs Preliminaries.
  970. * headings <1>:                         Move Commands.
  971. * headings:                             Viper Specials.
  972. * hilit19:                              Useful Packages.
  973. * history:                              History.
  974. * incremental search:                   Improved Search.
  975. * initialization:                       Customization.
  976. * Insert state <1>:                     Editing in Insert State.
  977. * Insert state <1>:                     Insert State.
  978. * Insert state:                         States in Viper.
  979. * inserting:                            Appending Text.
  980. * Insertion history:                    New Commands.
  981. * Insertion ring <1>:                   Viper Specials.
  982. * Insertion ring:                       New Commands.
  983. * interactive shell:                    Useful Packages.
  984. * ispell:                               Useful Packages.
  985. * joining lines:                        Changing Text.
  986. * keybindings <1>:                      Mapping.
  987. * keybindings:                          Keybindings.
  988. * keyboard macros <1>:                  New Commands.
  989. * keyboard macros:                      Macros and Registers.
  990. * keymap:                               Emacs Preliminaries.
  991. * keymapping:                           Mapping.
  992. * keymaps:                              Keybindings.
  993. * last keyboard macro:                  Macros and Registers.
  994. * layout:                               Options.
  995. * line commands <1>:                    Groundwork.
  996. * line commands:                        Basics.
  997. * line editor motion:                   Movement and Markers.
  998. * literal searching:                    Options.
  999. * local keymap:                         Emacs Preliminaries.
  1000. * looking at:                           Emacs Preliminaries.
  1001. * macros:                               Macros and Registers.
  1002. * mail:                                 Useful Packages.
  1003. * major mode:                           Emacs Preliminaries.
  1004. * make:                                 Useful Packages.
  1005. * managing multiple files:              Multiple Files in Viper.
  1006. * mark:                                 Emacs Preliminaries.
  1007. * markers <1>:                          Move Commands.
  1008. * markers <1>:                          Undo and Backups.
  1009. * markers:                              Multiple Files in Viper.
  1010. * marking:                              Marking.
  1011. * matching parens <1>:                  Options.
  1012. * matching parens:                      Move Commands.
  1013. * Meta key <1>:                         Insert State.
  1014. * Meta key <1>:                         Vi State.
  1015. * Meta key:                             Emacs Preliminaries.
  1016. * Minibuffer <1>:                       History.
  1017. * Minibuffer <1>:                       The Minibuffer.
  1018. * Minibuffer:                           Emacs Preliminaries.
  1019. * minor mode:                           Emacs Preliminaries.
  1020. * mode:                                 Emacs Preliminaries.
  1021. * mode line <1>:                        States in Viper.
  1022. * mode line:                            Emacs Preliminaries.
  1023. * mouse:                                Viper Specials.
  1024. * mouse search:                         Improved Search.
  1025. * movement commands <1>:                Move Commands.
  1026. * movement commands:                    Basics.
  1027. * movements:                            Groundwork.
  1028. * Multifile documents and programs:     Viper Specials.
  1029. * multiple files <1>:                   File and Buffer Handling.
  1030. * multiple files:                       Multiple Files in Viper.
  1031. * multiple undo:                        Vi State.
  1032. * paragraphs <1>:                       Move Commands.
  1033. * paragraphs:                           Viper Specials.
  1034. * paren matching <1>:                   Options.
  1035. * paren matching:                       Move Commands.
  1036. * paste <1>:                            Yanking.
  1037. * paste:                                Appending Text.
  1038. * point:                                Emacs Preliminaries.
  1039. * point commands <1>:                   Groundwork.
  1040. * point commands:                       Basics.
  1041. * put:                                  Appending Text.
  1042. * query replace <1>:                    New Commands.
  1043. * query replace:                        Improved Search.
  1044. * quoting regions:                      Changing Text.
  1045. * r and R region specifiers <1>:        Groundwork.
  1046. * r and R region specifiers:            Basics.
  1047. * RCS:                                  Useful Packages.
  1048. * readonly files:                       Options.
  1049. * region <1>:                           Basics.
  1050. * region:                               Emacs Preliminaries.
  1051. * region specification:                 Basics.
  1052. * register execution <1>:               New Commands.
  1053. * register execution:                   Macros and Registers.
  1054. * registers <1>:                        Macros and Registers.
  1055. * registers <1>:                        Undo and Backups.
  1056. * registers:                            Multiple Files in Viper.
  1057. * regular expressions:                  Vi State.
  1058. * Replace state <1>:                    Replace State.
  1059. * Replace state:                        States in Viper.
  1060. * scrolling:                            Display.
  1061. * searching <1>:                        Options.
  1062. * searching:                            Move Commands.
  1063. * sections <1>:                         Move Commands.
  1064. * sections:                             Viper Specials.
  1065. * sentences <1>:                        Move Commands.
  1066. * sentences:                            Viper Specials.
  1067. * setting variables:                    Rudimentary Changes.
  1068. * shell <1>:                            Options.
  1069. * shell:                                Useful Packages.
  1070. * shell commands:                       Shell Commands.
  1071. * shifting text <1>:                    Options.
  1072. * shifting text:                        Deleting Text.
  1073. * substitution:                         Changing Text.
  1074. * syntax table <1>:                     Groundwork.
  1075. * syntax table:                         Movement and Markers.
  1076. * tabbing:                              Options.
  1077. * text:                                 Emacs Preliminaries.
  1078. * text processing:                      Search and Replace.
  1079. * textmarkers <1>:                      Move Commands.
  1080. * textmarkers <1>:                      Movement and Markers.
  1081. * textmarkers <1>:                      Undo and Backups.
  1082. * textmarkers:                          Multiple Files in Viper.
  1083. * transparent ftp:                      Useful Packages.
  1084. * undo <1>:                             Undoing.
  1085. * undo <1>:                             Undo and Backups.
  1086. * undo:                                 Vi State.
  1087. * vanilla search <1>:                   Move Commands.
  1088. * vanilla search <1>:                   New Commands.
  1089. * vanilla search:                       Vi State.
  1090. * variables for customization:          Rudimentary Changes.
  1091. * version maintenance:                  Useful Packages.
  1092. * Vi macros:                            Vi Macros.
  1093. * Vi options:                           Options.
  1094. * Vi state <1>:                         Vi State.
  1095. * Vi state:                             States in Viper.
  1096. * viewing registers and markers <1>:    Macros and Registers.
  1097. * viewing registers and markers:        Undo and Backups.
  1098. * Viper and C-c:                        Packages that Change Keymaps.
  1099. * Viper as minor mode:                  Emacs Preliminaries.
  1100. * window:                               Emacs Preliminaries.
  1101. * word search:                          Improved Search.
  1102. * word wrap:                            Options.
  1103. * words:                                Groundwork.
  1104.  
  1105.  
  1106.