emacs-diffs
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Emacs-diffs] Changes to viper.texi


From: Glenn Morris
Subject: [Emacs-diffs] Changes to viper.texi
Date: Thu, 06 Sep 2007 04:41:45 +0000

CVSROOT:        /sources/emacs
Module name:    emacs
Changes by:     Glenn Morris <gm>       07/09/06 04:41:45

Index: viper.texi
===================================================================
RCS file: viper.texi
diff -N viper.texi
--- viper.texi  15 Apr 2007 21:12:08 -0000      1.50
+++ /dev/null   1 Jan 1970 00:00:00 -0000
@@ -1,4579 +0,0 @@
-% -*-texinfo-*-
-\input texinfo
-
address@hidden Using viper.info instead of viper in setfilename breaks DOS.
address@hidden @setfilename viper
address@hidden @setfilename viper.info
address@hidden ../info/viper
-
address@hidden
-Copyright @copyright{} 1995, 1996, 1997, 2001, 2002, 2003, 2004,
-2005, 2006, 2007 Free Software Foundation, Inc.
-
address@hidden
-Permission is granted to copy, distribute and/or modify this document
-under the terms of the GNU Free Documentation License, Version 1.2 or
-any later version published by the Free Software Foundation; with no
-Invariant Sections, with the Front-Cover texts being ``A GNU
-Manual'', and with the Back-Cover Texts as in (a) below.  A copy of the
-license is included in the section entitled ``GNU Free Documentation
-License'' in the Emacs manual.
-
-(a) The FSF's Back-Cover Text is: ``You have freedom to copy and modify
-this GNU Manual, like GNU software.  Copies published by the Free
-Software Foundation raise funds for GNU development.''
-
-This document is part of a collection distributed under the GNU Free
-Documentation License.  If you want to distribute this document
-separately from the collection, you can do so by adding a copy of the
-license to the document, as described in section 6 of the license.
address@hidden quotation
address@hidden copying
-
address@hidden Emacs
address@hidden
-* VIPER: (viper).       The newest Emacs VI-emulation mode.
-                          (also, A VI Plan for Emacs Rescue
-                           or the VI PERil.)
address@hidden direntry
-
address@hidden
-
address@hidden
address@hidden Viper Is a Package for Emacs Rebels
address@hidden a Vi emulator for Emacs
address@hidden April 2007, Viper Version 3.13.1
-
address@hidden Michael Kifer (Viper)
address@hidden Aamod Sane (VIP 4.4)
address@hidden Masahiko Sato (VIP 3.5)
-
address@hidden
address@hidden 0pt plus 1filll
address@hidden
address@hidden titlepage
-
address@hidden
address@hidden Top, Overview,, (DIR)
-
address@hidden Viper
-
-We believe that one or more of the following statements are adequate
-descriptions of Viper:
-
address@hidden
-Viper Is a Package for Emacs Rebels;
-it is a VI Plan for Emacs Rescue
-and/or a venomous VI PERil.
address@hidden example
-
-Technically speaking, Viper is a Vi emulation package for Emacs.  It
-implements all Vi and Ex commands, occasionally improving on them and
-adding many new features.  It gives the user the best of both worlds: Vi
-keystrokes for editing combined with the power of the Emacs environment.
-
-Viper emulates Vi at several levels, from the one that closely follows Vi
-conventions to the one that departs from many of them.  It has many
-customizable options, which can be used to tailor Viper to the work habits
-of various users.
-This manual describes Viper, concentrating on the differences from Vi and
-new features of Viper.
-
-Viper, formerly known as VIP-19, was written by Michael Kifer.  It is based
-on VIP version 3.5 by Masahiko Sato and VIP version 4.4 by Aamod Sane.
-About 15% of the code still comes from those older packages.
-
-Viper is intended to be usable without reading this manual --- the defaults
-are set to make Viper as close to Vi as possible.  At startup, Viper will
-try to set the most appropriate default environment for you, based on
-your familiarity with Emacs.  It will also tell you the basic GNU Emacs window
-management commands to help you start immediately.
-
-Although this manual explains how to customize Viper, some basic
-familiarity with Emacs Lisp is a plus.
-
-It is recommended that you read the Overview node.  The other nodes may
-be visited as needed.
-
-Comments and bug reports are welcome.
address@hidden@@cs.stonybrook.edu} is the current address for Viper bug reports.
-Please use the Ex command @kbd{:submitReport} for this address@hidden
-
address@hidden ifnottex
-
address@hidden
-* Overview::                    Read for a smoother start
-* Improvements over Vi::        New features, Improvements
-* Customization::               How to customize Viper
-* Commands::                    Vi and Ex Commands
-
-* Key Index::                   Index of Vi and Ex Commands
-* Function Index::              Index of Viper Functions
-* Variable Index::              Index of Viper Variables
-* Package Index::               Index of Packages Mentioned in this Document
-* Concept Index::               Vi, Ex and Emacs concepts
-
-* Acknowledgments::
-* GNU Free Documentation License:: The license for this documentation.
-
address@hidden menu
address@hidden
address@hidden Introduction
-
-We believe that one or more of the following statements are adequate
-descriptions of Viper:
-
address@hidden
-Viper Is a Package for Emacs Rebels;
-it is a VI Plan for Emacs Rescue
-and/or a venomous VI PERil.
address@hidden example
-
-Viper is a Vi emulation package for Emacs.  Viper contains virtually all
-of Vi and Ex functionality and much more.  It gives you the best of both
-worlds: Vi keystrokes for editing combined with the GNU Emacs
-environment.  Viper also fixes some common complaints with Vi commands.
-This manual describes Viper, concentrating on the differences from Vi
-and on the new features of Viper.
-
-Viper was written by Michael Kifer.  It is based on VIP version 3.5 by
-Masahiko Sato and VIP version 4.4 by Aamod Sane.  About 15% of the code
-still comes from those older packages.
-
-Viper is intended to be usable out of the box, without reading this manual
---- the defaults are set to make Viper as close to Vi as possible.  At
-startup, Viper will attempt to set the most appropriate default environment
-for you, based on your familiarity with Emacs.  It will also tell you the
-basic GNU Emacs window management commands to help you start immediately.
-
-Although this manual explains how to customize Viper, some basic
-familiarity with Emacs Lisp is a plus.
-
-It is recommended that you read the chapter Overview.  The other chapters
-will be useful for customization and advanced usage.
-
-You should also learn to use the Info on-line hypertext manual system that
-comes with Emacs.  This manual can be read as an Info file.  Try the command
address@hidden@key{ESC} x info} with vanilla Emacs sometime.
-
-Comments and bug reports are welcome.
address@hidden@@cs.stonybrook.edu} is the current address for Viper bug reports.
-Please use the Ex command @kbd{:submitReport} for this address@hidden
-
address@hidden iftex
-
address@hidden Overview,Improvements over Vi,Top,Top
address@hidden Overview of Viper
-
-Viper is a Vi emulation on top of Emacs.  At the same time, Viper provides a
-virtually unrestricted access to Emacs facilities.  Perfect compatibility
-with Vi is possible but not desirable.  This chapter tells you about the
-Emacs ideas that you should know about, how to use Viper within Emacs and
-some incompatibilities.
-
-This manual is written with the assumption that you are an experienced Vi
-user who wants to switch to Emacs while retaining the ability to edit files
-Vi style. Incredible as it might seem, there are experienced Emacs users
-who use Viper as a backdoor into the superior (as every Vi user already knows)
-world of Vi! These users are well familiar with Emacs bindings and prefer them
-in some cases, especially in the Vi Insert state. John Hawkins
-<jshawkin@@eecs.umich.edu> has provided a set of customizations, which
-enables additional Emacs bindings under Viper.  These customizations can be
-included in your @file{~/.viper} file and are found at the following URL:
address@hidden://traeki.freeshell.org/files/viper-sample}.
-
address@hidden
-* Emacs Preliminaries::         Basic concepts in Emacs.
-* Loading Viper::               Loading and Preliminary Configuration.
-* States in Viper::             Viper has four states orthogonal to Emacs
-                                modes.
-* The Minibuffer::              Command line in Emacs.
-* Multiple Files in Viper::     True multiple file handling.
-* Unimplemented Features::      That are unlikely to be implemented.
address@hidden menu
-
address@hidden Emacs Preliminaries, Loading Viper, Overview, Overview
address@hidden Emacs Preliminaries
-
address@hidden buffer
address@hidden point
address@hidden mark
address@hidden text
address@hidden looking at
address@hidden end (of buffer)
address@hidden end (of line)
address@hidden region
-
-Emacs can edit several files at once.  A file in Emacs is placed in a
address@hidden that usually has the same name as the file.  Buffers are also 
used
-for other purposes, such as shell interfaces, directory editing, etc.
address@hidden,,Directory Editor,emacs,The
-GNU Emacs Manual}, for an address@hidden
-
-A buffer has a distinguished position called the @dfn{point}.
-A @dfn{point} is always between 2 characters, and is @dfn{looking at}
-the right hand character.  The cursor is positioned on the right hand
-character.  Thus, when the @dfn{point} is looking at the end-of-line,
-the cursor is on the end-of-line character, i.e.@: beyond the last
-character on the line.  This is the default Emacs address@hidden
-
-The default settings of Viper try to mimic the behavior of Vi, preventing
-the cursor from going beyond the last character on the line.  By using
-Emacs commands directly (such as those bound to arrow keys), it is possible
-to get the cursor beyond the end-of-line.  However, this won't (or
-shouldn't) happen if you restrict yourself to standard Vi keys, unless you
-modify the default editing style.  @address@hidden
-
-In addition to the @dfn{point}, there is another distinguished buffer
-position called the @dfn{mark}.  @xref{Mark,,Mark,emacs,The GNU Emacs
-manual}, for more info on the mark.  The text between the @dfn{point} and
-the @dfn{mark} is called the @dfn{region} of the buffer.  For the Viper
-user, this simply means that in addition to the Vi textmarkers a--z, there
-is another marker called @dfn{mark}.  This is similar to the unnamed Vi
-marker used by the jump commands @kbd{``} and @kbd{''}, which move the
-cursor to the position of the last absolute jump.  Viper provides access to
-the region in most text manipulation commands as @kbd{r} and @kbd{R} suffix
-to commands that operate on text regions, e.g., @kbd{dr} to delete region,
-etc.
-
-Furthermore, Viper lets Ex-style commands to work on the current region.
-This is done by typing a digit argument before @kbd{:}.  For instance,
-typing @kbd{1:} will prompt you with something like @emph{:123,135},
-assuming that the current region starts at line 123 and ends at line
-135.  There is no need to type the line numbers, since Viper inserts them
-automatically in front of the Ex command.
-
address@hidden, for more address@hidden
-
address@hidden window
address@hidden mode line
address@hidden buffer information
address@hidden Minibuffer
address@hidden command line
address@hidden buffer (modified)
-
-Emacs divides the screen into tiled @dfn{windows}.  You can see the
-contents of a buffer through the window associated with the buffer.  The
-cursor of the screen is positioned on the character after @dfn{point}.
-Every window has a @dfn{mode line} that displays information about the buffer.
-You can change the format of the mode
-line, but normally if you see @samp{**} at the beginning of a mode line it
-means that the buffer is @dfn{modified}.  If you write out the contents of
-a buffer to a file, then the buffer will become not modified.  Also if
-you see @samp{%%} at the beginning of the mode line, it means that the file
-associated with the buffer is write protected.  The mode line will also
-show the buffer name and current major and minor modes (see below).
-A special buffer called @dfn{Minibuffer} is displayed as the last line
-in a Minibuffer window.  The Minibuffer window is used for command input
-output.  Viper uses Minibuffer window for @kbd{/} and @kbd{:}
address@hidden
-
address@hidden mode
address@hidden keymap
address@hidden local keymap
address@hidden global keymap
address@hidden major mode
address@hidden minor mode
-
-An Emacs buffer can have a @dfn{major mode} that customizes Emacs for
-editing text of a particular sort by changing the functionality of the keys.
-Keys are defined using a @dfn{keymap} that records the bindings between
-keystrokes and
-functions.  The @dfn{global keymap} is common to all the
-buffers.  Additionally, each buffer has its @dfn{local keymap} that determines 
the
address@hidden of the buffer.  If a function is bound to some key in the local
-keymap then that function will be executed when you type the key.
-If no function is bound to a key in the
-local map, however, the function bound to the key in the global map
-will be executed.  @xref{Major Modes,Major Modes,Major Modes,emacs,The
-GNU Emacs Manual}, for more address@hidden
-
-A buffer can also have a @dfn{minor mode}.  Minor modes are options that
-you can use or not.  A buffer in @code{text-mode} can have
address@hidden as minor mode, which can be turned off or on at
-any time.  In Emacs, a minor mode may have it own keymap,
-which overrides the local keymap when the minor mode is turned on.  For
-more information, @pxref{Minor Modes,Minor Modes,Minor Modes,emacs,The
-GNU Emacs Manual} @refill
-
address@hidden Viper as minor mode
address@hidden Control keys
address@hidden Meta key
-
-Viper is implemented as a collection of minor modes.  Different minor modes
-are involved when Viper emulates Vi command mode, Vi insert mode, etc.
-You can also turn Viper on and off at any time while in Vi command mode.
address@hidden in Viper}, for
-more address@hidden
-
-Emacs uses Control and Meta modifiers.  These are denoted as C and M,
-e.g.@: @kbd{^Z} as @kbd{C-z} and @kbd{Meta-x} as @kbd{M-x}.  The Meta key is
-usually located on each side of the Space bar; it is used in a manner
-similar to the Control key, e.g., @kbd{M-x} means typing @kbd{x} while
-holding the Meta key down.  For keyboards that do not have a Meta key,
address@hidden is used as Meta.  Thus @kbd{M-x} is typed as @address@hidden
-x}.  Viper uses @key{ESC} to switch from Insert state to Vi state.  Therefore
-Viper defines @kbd{C-\} as its Meta key in Vi state.  @xref{Vi State}, for
-more address@hidden
-
-Emacs is structured as a Lisp interpreter around a C core.  Emacs keys
-cause Lisp functions to be called.  It is possible to call these
-functions directly, by typing @kbd{M-x function-name}.
-
address@hidden Loading Viper, States in Viper, Emacs Preliminaries, Overview
address@hidden Loading Viper
-
-The most common way to load it automatically is to include the following
-lines (in the given order!):
-
address@hidden
-(setq viper-mode t)
-(require 'viper)
address@hidden lisp
-
address@hidden
-in your @file{~/.emacs} file.  The @file{.emacs} file is placed in your
-home directory and it is be executed every time you invoke Emacs.  This is
-the place where all general Emacs customization takes place.  Beginning with
-version 20.0, Emacsen have an interactive interface, which simplifies the
-job of customization significantly.
-
-Viper also uses the file @file{~/.viper} for Viper-specific customization.
-The location of Viper customization file can be changed by setting the
-variable @code{viper-custom-file-name} in @file{.emacs} @emph{prior} to loading
-Viper.
-
-The latest versions of Emacs have an interactive customization facility,
-which allows you to (mostly) bypass the use of the @file{.emacs} and
address@hidden files. You can reach this customization
-facility from within Viper's VI state by executing the Ex command
address@hidden:customize}.
-
-Once invoked, Viper will arrange to bring up Emacs buffers in Vi state
-whenever this makes sense.
address@hidden that Change Keymaps}, to find out when forcing Vi command state
-on a buffer may be counter-productive.
-
-Even if your @file{.emacs} file does not invoke Viper automatically,
-you can still load Viper and enter the Vi command state by typing the
-following from within Emacs:
-
address@hidden
-M-x viper-mode
address@hidden lisp
-
-When Emacs first comes up, if you have not specified a file on the
-command line, it will show the @samp{*scratch*} buffer, in the
address@hidden Interaction} mode.  After you invoke Viper, you can start
-editing files by using @kbd{:e}, @kbd{:vi}, or @kbd{v} commands.
-(@xref{File and Buffer Handling}, for more information on @kbd{v} and other
-new commands that, in many cases, are more convenient than @kbd{:e},
address@hidden:vi}, and similar old-style Vi commands.)@refill
-
-Finally, if at some point you would want to de-Viperize your running
-copy of Emacs after Viper has been loaded, the command @kbd{M-x
-viper-go-away} will do it for you.  The function @code{toggle-viper-mode}
-toggles Viperization of Emacs on and off.
-
address@hidden States in Viper, The Minibuffer, Loading Viper,Overview
address@hidden States in Viper
-
address@hidden @kbd{C-z}
address@hidden @key{ESC}
address@hidden @kbd{i}
address@hidden Emacs state
address@hidden Vi state
address@hidden Insert state
address@hidden Replace state
address@hidden Ex commands
address@hidden @code{viper-go-away}
address@hidden @code{toggle-viper-mode}
-
-Viper has four states, Emacs, Vi, Insert, and Replace.
-
address@hidden @samp
address@hidden Emacs state
-This is the state plain vanilla Emacs is normally in.  After you have loaded
-Viper, @kbd{C-z} will normally take you to Vi command state.  Another
address@hidden will take you back to Emacs state.  This toggle key can be
-changed, @pxref{Customization} You can also type @kbd{M-x viper-mode} to
-change to Vi address@hidden
-
-
-For users who chose to set their user level to 1 at Viper setup time,
-switching to Emacs state is deliberately made harder in order to not
-confuse the novice user.  In this case, @kbd{C-z} will either iconify Emacs
-(if Emacs runs as an application under X) or it will stop Emacs (if
-Emacs runs on a dumb terminal or in an Xterm window).
-
address@hidden Vi state
-This is the Vi command mode.  Any of the Vi commands, such as @kbd{i, o, a},
address@hidden, will take you to Insert state.  All Vi commands may
-be used in this mode.  Most Ex commands can also be used.
-For a full list of Ex commands supported by Viper, type
address@hidden:} and then @key{TAB}.  To get help on any issue, including the Ex
-commands, type @kbd{:help}.  This will invoke Viper Info
-(if it is installed).  Then typing @kbd{i} will prompt you for a topic to
-search in the index.  Note: to search for Ex commands in the index, you
-should start them with a @kbd{:}, e.g., @kbd{:WW}.
-
-In Viper, Ex commands can be made to work on the current Emacs region.
-This is done by typing a digit argument before @kbd{:}.
-For instance, typing @kbd{1:} will prompt you with something like
address@hidden:123,135}, assuming that the current region starts at line 123 and
-ends at line 135.  There is no need to type the line numbers, since Viper
-inserts them automatically in front of the Ex command.
-
address@hidden Insert state
-Insert state is the Vi insertion mode.  @key{ESC} will take you back to
-Vi state.  Insert state editing can be done, including auto-indentation.  By
-default, Viper disables Emacs key bindings in Insert state.
-
address@hidden Replace state
-Commands like @kbd{cw} invoke the Replace state.  When you cross the
-boundary of a replacement region (usually designated via a @samp{$} sign),
-it will automatically change to Insert state.  You do not have to worry
-about it.  The key bindings remain practically the same as in Insert
-state.  If you type @key{ESC}, Viper will switch to Vi command mode, 
terminating the
-replacement address@hidden
address@hidden table
-
address@hidden mode line
-
-The modes are indicated on the @dfn{mode line} as <E>, <I>, <V>, and <R>,
-so that the multiple modes do not confuse you.  Most of your editing can be
-done in Vi and Insert states.  Viper will try to make all new buffers be in Vi
-state, but sometimes they may come up in Emacs state.  @kbd{C-z}
-will take you to Vi state in such a case.  In some major modes, like Dired,
-Info, Gnus, etc., you should not switch to Vi state (and Viper will not
-attempt to do so) because these modes are not intended for text editing and
-many of the Vi keys have special meaning there.  If you plan to read news,
-browse directories, read mail, etc., from Emacs (which you should start
-doing soon!), you should learn about the meaning of the various keys in
-those special modes (typing @kbd{C-h m} in a buffer provides
-help with key bindings for the major mode of that buffer).
-
-If you switch to Vi in Dired or similar modes---no harm is done.  It is just
-that the special key bindings provided by those modes will be temporarily
-overshadowed by Viper's bindings.  Switching back to Viper's Emacs state
-will revive the environment provided by the current major mode.
-
-States in Viper are orthogonal to Emacs major modes, such as C mode or Dired
-mode.  You can turn Viper on and off for any Emacs state.  When Viper is turned
-on, Vi state can be used to move around.  In Insert state, the bindings for
-these modes can be accessed.  For beginners (users at Viper levels 1 and 2),
-these bindings are suppressed in Insert state, so that new users are not
-confused by the Emacs states.  Note that unless you allow Emacs bindings in
-Insert state, you cannot do many interesting things, like language
-sensitive editing.  For the novice user (at Viper level 1), all major mode
-bindings are turned off in Vi state as well.  This includes the bindings for
-key sequences that start with @kbd{C-c}, which practically means that all
-major mode bindings are unsupported.  @xref{Customization}, to find out how
-to allow Emacs keys in Insert state.
-
address@hidden
-* Emacs State::         This is the state you should learn more about when
-                        you get up to speed with Viper.
-* Vi State::            Vi commands are executed in this state.
-* Insert State::        You can enter text, and also can do sophisticated
-                        editing if you know enough Emacs commands.
-* Replace State::       Like Insert mode, but it is invoked via the
-                        replacement commands, such as cw, C, R, etc.
address@hidden menu
-
address@hidden Emacs State, Vi State, States in Viper, States in Viper
address@hidden Emacs State
-
address@hidden @kbd{C-z}
address@hidden Emacs state
-
-
-You will be in this mode only by accident (hopefully).  This is the state
-Emacs is normally in (imagine!!).  Now leave it as soon as possible by
-typing @kbd{C-z}.  Then you will be in Vi state (sigh of relief) :-).
-
-Emacs state is actually a Viperism to denote all the major and minor modes
-(@pxref{Emacs Preliminaries}) other than Viper that Emacs can be in.  Emacs
-can have several modes, such as C mode for editing C programs, LaTeX mode
-for editing LaTeX documents, Dired for directory editing, etc.  These are
-major modes, each with a different set of key-bindings.  Viper states are
-orthogonal to these Emacs major modes.  The presence of these language
-sensitive and other modes is a major win over Vi.  @xref{Improvements over
-Vi}, for address@hidden
-
-The bindings for these modes can be made available in the Viper Insert state
-as well as in Emacs state.  Unless you specify your user level as 1 (a
-novice), all major mode key sequences that start with @kbd{C-x} and
address@hidden are also available in Vi state.  This is important because major
-modes designed for editing files, such as cc-mode or latex-mode, use key
-sequences that begin with @kbd{C-x} and @kbd{C-c}.
-
-There is also a key that lets you temporarily escape to Vi command state
-from the Insert state: typing @kbd{C-z} will let you execute a
-single Vi command while staying in Viper's Insert state.
-
-
address@hidden Vi State, Insert State, Emacs State, States in Viper
address@hidden Vi State
-
address@hidden Vi state
-
-This is the Vi command mode.  When Viper is in Vi state, you will see the sign
-<V> in the mode line.  Most keys will work as in Vi.  The notable
-exceptions are:
-
address@hidden @kbd
address@hidden C-x
address@hidden @kbd{C-x}
address@hidden is used to invoke Emacs commands, mainly those that do window
-management.  @kbd{C-x 2} will split a window, @kbd{C-x 0} will close a
-window.  @kbd{C-x 1} will close all other windows.  @kbd{C-xb} is used to
-switch buffers in a window, and @kbd{C-xo} to move through windows.
-These are about the only necessary keystrokes.
-For the rest, see the GNU Emacs Manual.
-
address@hidden C-c
address@hidden @kbd{C-c}
-For user levels 2 and higher, this key serves as a prefix key for the key
-sequences used by various major modes.  For users at Viper level 1, @kbd{C-c}
-simply beeps.
-
address@hidden C-g and C-]
address@hidden @kbd{C-g}
address@hidden @kbd{C-]}
-
-These are the Emacs @samp{quit} keys.
-There will be cases where you will have to
-use @kbd{C-g} to quit.  Similarly, @kbd{C-]} is used to exit
address@hidden Edits} in Emacs for which there is no comparable Vi
-functionality and no key-binding.  Recursive edits are indicated by
address@hidden brackets framing the modes on the mode line.
address@hidden Edit,Recursive
-Edit,Recursive Edit,emacs,The GNU Emacs Manual}.
-At user level 1, @kbd{C-g} is bound to @code{viper-info-on-file}
-function instead.
address@hidden
address@hidden C-\
address@hidden @kbd{C-\}
address@hidden Meta key
-
-Viper uses @key{ESC} as a switch between Insert and Vi states.  Emacs uses
address@hidden for Meta.  The Meta key is very important in Emacs since many
-functions are accessible only via that key as @kbd{M-x function-name}.
-Therefore, we need to simulate it somehow.  In Viper's Vi, Insert, and
-Replace states, the meta key is set to be @kbd{C-\}.  Thus, to get
address@hidden, you should type @kbd{C-\ x} (if the keyboard has no Meta key,
-which is rare these days).
-This works both in the Vi command state and in the Insert and Replace
-states.  In Vi command state, you can also use @kbd{\ @key{ESC}} as the
-meta key.
-
-Note: Emacs binds @kbd{C-\} to a function that offers to change the
-keyboard input method in the multilingual environment.  Viper overrides this
-binding.  However, it is still possible to switch the input method by typing
address@hidden C-\} in the Vi command state and @kbd{C-z \ C-\} in the Insert 
state.
-Or you can use the MULE menu in the menubar.
address@hidden table
address@hidden
-Other differences are mostly improvements.  The ones you should know
-about are:
-
address@hidden @samp
address@hidden Undo
address@hidden @kbd{u}
address@hidden will undo.  Undo can be repeated by the @kbd{.} key.  Undo itself
-can be undone.  Another @kbd{u} will change the direction.  The presence
-of repeatable undo means that @kbd{U}, undoing lines, is not very
-important.  Therefore, @kbd{U} also calls @code{viper-undo}.
address@hidden multiple undo
address@hidden undo
-
-
address@hidden Counts
-Most commands, @kbd{~}, @kbd{[[}, @kbd{p}, @kbd{/}, @dots{}, etc., take counts.
-
address@hidden ]] Just to balance parens
address@hidden Regexps
-Viper uses Emacs Regular Expressions for searches.  These are a superset of
-Vi regular
-expressions, excepting the change-of-case escapes @samp{\u}, @samp{\L},
address@hidden, etc.  @xref{Regexps,,Syntax of Regular Expressions,emacs,The
-GNU Emacs Manual}, for details.
-Files specified to @kbd{:e} use @code{csh} regular expressions
-(globbing, wildcards, what have you).
-However, the function @code{viper-toggle-search-style}, bound to @kbd{C-c /},
-lets the user switch from search with regular expressions to plain vanilla
-search and vice versa.  It also lets one switch from case-sensitive search
-to case-insensitive and back.
address@hidden Specials}, for more details.
address@hidden regular expressions
address@hidden vanilla search
address@hidden case-sensitive search
address@hidden case-insensitive search
address@hidden @kbd{C-c /}
-
address@hidden Ex commands
address@hidden Ex commands
-The current working directory of a buffer is automatically inserted in the
-minibuffer if you type @kbd{:e} then space.  Absolute filenames are
-required less often in Viper.  For file names, Emacs uses a convention that
-is slightly different from other programs.  It is designed to minimize the
-need for deleting file names that Emacs provides in its prompts.  (This is
-usually convenient, but occasionally the prompt may suggest a wrong file
-name for you.)  If you see a prompt @kbd{/usr/foo/} and you wish to edit the
-file @kbd{~/.viper}, you don't have to erase the prompt.  Instead, simply
-continue typing what you need.  Emacs will interpret @kbd{/usr/foo/~/.viper}
-correctly.  Similarly, if the prompt is @kbd{~/foo/} and you need to get to
address@hidden/bar/file}, keep typing.  Emacs interprets @kbd{~/foo//bar/} as
address@hidden/bar/file}, since when it sees @samp{//}, it understands that
address@hidden/foo/} is to be discarded.
-
-The command @kbd{:cd} will change the default directory for the
-current buffer.  The command @kbd{:e} will interpret the
-filename argument in @code{csh}.  @xref{Customization}, if you
-want to change the default shell.
-The command @kbd{:next} takes counts from
address@hidden:args}, so that @kbd{:rew} is obsolete.  Also, @kbd{:args} will 
show only
-the invisible files (i.e., those that are not currently seen in Emacs
-windows).
-
-When applicable, Ex commands support file completion and history.  This
-means that by typing a partial file name and then @key{TAB}, Emacs will try
-to complete the name or it will offer a menu of possible completions.
-This works similarly to Tcsh and extends the behavior of Csh.  While Emacs
-is waiting for a file name, you can type @kbd{M-p} to get the previous file
-name you typed.  Repeatedly typing @kbd{M-p} and @kbd{M-n} will let you
-browse through the file history.
-
-Like file names, partially typed Ex commands can be completed by typing
address@hidden, and Viper keeps the history of Ex commands.  After typing
address@hidden:}, you can browse through the previously entered Ex commands by
-typing @kbd{M-p} and @kbd{M-n}.  Viper tries to rationalize when it puts Ex
-commands on the history list.  For instance, if you typed @kbd{:w!@: foo},
-only @kbd{:w!} will be placed on the history list.  This is because the
-last history element is the default that can be invoked simply by typing
address@hidden: @key{RET}}.  If @kbd{:w!@: foo} were placed on the list, it 
would be all to
-easy to override valuable data in another file.  Reconstructing the full
-command, @kbd{:w!@: foo}, from the history is still not that hard, since Viper
-has a separate history for file names.  By typing @kbd{: M-p}, you will get
address@hidden:w!} in the Minibuffer.  Then, repeated @kbd{M-p} will get you 
through
-the file history, inserting one file name after another.
-
-In contrast to @kbd{:w!@: foo}, if the command were @kbd{:r foo}, the entire
-command will appear in the history list.  This is because having @kbd{:r}
-alone as a default is meaningless, since this command requires a file
-argument.
address@hidden
address@hidden table
address@hidden
-As Vi, Viper's destructive commands can be re-executed by typing 
address@hidden'.
-However, in addition, Viper keeps track of the history of such commands.  This
-history can be perused by typing @kbd{C-c M-p} and @kbd{C-c M-n}.
-Having found the appropriate command, it can be then executed by typing
address@hidden'.
address@hidden over Vi}, for more information.
-
address@hidden Insert State, Replace State, Vi State, States in Viper
address@hidden Insert State
-
address@hidden Insert state
-
-To avoid confusing the beginner (at Viper level 1 and 2), Viper makes only the
-standard Vi keys available in Insert state.  The implication is that
-Emacs major modes cannot be used in Insert state.
-It is strongly recommended that as soon as you are comfortable, make the
-Emacs state bindings visible (by changing your user level to 3 or higher).
address@hidden,
-to see how to do address@hidden
-
-Once this is done, it is possible to do quite a bit of editing in
-Insert state.  For instance, Emacs has a @dfn{yank} command, @kbd{C-y},
-which is similar to Vi's @kbd{p}.  However, unlike @kbd{p}, @kbd{C-y} can be
-used in Insert state of Viper.  Emacs also has a kill ring where it keeps
-pieces of text you deleted while editing buffers.  The command @kbd{M-y} is
-used to delete the text previously put back by Emacs' @kbd{C-y} or by Vi's
address@hidden command and reinsert text that was placed on the kill-ring 
earlier.
-
-This works both in Vi and Insert states.
-In Vi state, @kbd{M-y} is a much better alternative to the usual Vi's way
-of recovering the 10 previously deleted chunks of text.  In Insert state,
-you can
-use this as follows.  Suppose you deleted a piece of text and now you need
-to re-insert it while editing in Insert mode.  The key @kbd{C-y} will put
-back the most recently deleted chunk.  If this is not what you want, type
address@hidden repeatedly and, hopefully, you will find the chunk you want.
-
-Finally, in Insert and Replace states, Viper provides the history of
-pieces of text inserted in previous insert or replace commands.  These
-strings of text can be recovered by repeatedly typing @kbd{C-c M-p} or
address@hidden M-n} while in Insert or Replace state.  (This feature is disabled
-in the minibuffer: the above keys are usually bound to other histories,
-which are more appropriate in the minibuffer.)
-
-
address@hidden Meta key
-
-You can call Meta functions from Insert state.  As in Vi state, the Meta key
-is @kbd{C-\}.  Thus @kbd{M-x} is typed as @kbd{C-\ x}.
-
-Other Emacs commands that are useful in Insert state are @kbd{C-e}
-and @kbd{C-a}, which move the cursor to the end and the beginning of the
-current line, respectively.  You can also use @kbd{M-f} and @kbd{M-b},
-which move the cursor forward (or backward) one word.
-If your display has a Meta key, these functions are invoked by holding the
-Meta key and then typing @kbd{f} and @kbd{b}, respectively.  On displays
-without the Meta key, these functions are invoked by typing
address@hidden f} and @kbd{C-\ b} (@kbd{C-\} simulates the Meta key in Insert
-state, as explained above).
-
-The key @kbd{C-z} is sometimes also useful in Insert state: it allows you
-to execute a single command in Vi state without leaving the Insert state!
-For instance, @kbd{C-z d2w} will delete the next two words without leaving
-the Insert state.
-
-When Viper is in Insert state, you will see <I> in the mode line.
-
address@hidden Replace State,, Insert State, States in Viper
address@hidden Replace State
-
address@hidden Replace state
-
-This state is entered through Vi replacement commands, such as @kbd{C},
address@hidden, etc., or by typing @kbd{R}.  In Replace state, Viper puts <R> in
-the mode line to let you know which state is in effect.  If Replace state is
-entered through @kbd{R}, Viper stays in that state until the user hits
address@hidden  If this state is entered via the other replacement commands,
-then Replace state is in effect until you hit @key{ESC} or until you cross
-the rightmost boundary of the replacement region.  In the latter case, Viper
-changes its state from Replace to Insert (which you will notice by the
-change in the mode line).
-
-Since Viper runs under Emacs, it is possible to switch between buffers
-while in Replace state.  You can also move the cursor using the arrow keys
-(even on dumb terminals!)@: and the mouse.  Because of this freedom (which is
-unattainable in regular Vi), it is possible to take the cursor outside the
-replacement region.  (This may be necessary for several reasons, including
-the need to enable text selection and region-setting with the mouse.)
-
-The issue then arises as to what to do when the user
-hits the @key{ESC} key.  In Vi, this would cause the text between cursor and
-the end of the replacement region to be deleted.  But what if, as is
-possible in Viper, the cursor is not inside the replacement region?
-
-To solve the problem, Viper keeps track of the last cursor position while it
-was still inside the replacement region.  So, in the above situation, Viper
-would delete text between this position and the end of the replacement
-region.
-
address@hidden The Minibuffer,Multiple Files in Viper, States in Viper, Overview
address@hidden The Minibuffer
-
address@hidden Minibuffer
-
-The Minibuffer is where commands are entered in.  Editing can be done
-by commands from Insert state, namely:
-
address@hidden @kbd
address@hidden C-h
-Backspace
address@hidden C-w
-Delete Word
address@hidden C-u
-Erase line
address@hidden C-v
-Quote the following character
address@hidden @key{RET}
-Execute command
address@hidden C-g and C-]
-Emacs quit and abort keys.  These may be necessary.  @xref{Vi State}, for an
-explanation.
address@hidden M-p and M-n
-These keys are bound to functions that peruse minibuffer history.  The
-precise history to be perused depends on the context.  It may be the history
-of search strings, Ex commands, file names, etc.
address@hidden table
-
-Most of the Emacs keys are functional in the Minibuffer.  While in the
-Minibuffer, Viper tries to make editing resemble Vi's behavior when the
-latter is waiting for the user to type an Ex command.  In particular, you
-can use the regular Vi commands to edit the Minibuffer.  You can switch
-between the Vi state and Insert state at will, and even use the replace mode.
-Initially, the Minibuffer comes up in Insert state.
-
-Some users prefer plain Emacs bindings in the Minibuffer.  To this end, set
address@hidden to @code{nil} in @file{.viper}.
address@hidden, to learn how to do this.
-
-When the Minibuffer changes Viper states, you will notice that the appearance
-of the text there changes as well.  This is useful because the Minibuffer
-has no mode line to tell which Vi state it is in.
-The appearance of the text in the Minibuffer can be changed.
address@hidden Specials}, for more details.
-
address@hidden Multiple Files in Viper,Unimplemented Features,The 
Minibuffer,Overview
address@hidden Multiple Files in Viper
-
address@hidden multiple files
address@hidden managing multiple files
-
-Viper can edit multiple files.  This means, for example that you never need
-to suffer through @code{No write since last change} errors.
-Some Viper elements are common over all the files.
-
address@hidden @samp
address@hidden Textmarkers
address@hidden markers
address@hidden textmarkers
-Textmarkers remember @emph{files and positions}.
-If you set marker @samp{a} in
-file @file{foo}, start editing file @file{bar} and type @kbd{'a}, then
address@hidden WILL SWITCH TO FILE @file{foo}}.  You can see the contents of a
-textmarker using the Viper command @kbd{[<a-z>} where <a-z> are the
-textmarkers, e.g., @kbd{[a} to view marker @samp{a} address@hidden
address@hidden Repeated Commands
-Command repetitions are common over files.  Typing @kbd{!!} will repeat the
-last @kbd{!} command whichever file it was issued from.
-Typing @kbd{.} will repeat the last command from any file, and
-searches will repeat the last search.  Ex commands can be repeated by typing
address@hidden: @address@hidden
-Note: in some rare cases, that @kbd{: @key{RET}} may do something dangerous.
-However, usually its effect can be undone by typing @kbd{u}.
address@hidden Registers
address@hidden registers
-Registers are common to files.  Also, text yanked with @kbd{y} can be
-put back (@kbd{p}) into any file.  The Viper command @kbd{]<a-z>}, where <a-z> 
are
-the registers, can be used to look at the contents of a register, e.g.,
-type @kbd{]a} to view register @samp{a}.
-
-There is one difference in text deletion that you should be
-aware of.  This difference comes from Emacs and was adopted in Viper
-because we find it very useful.  In Vi, if you delete a line, say, and then
-another line, these two deletions are separated and are put back
-separately if you use the @samp{p} command.  In Emacs (and Viper), successive
-series of deletions that are @emph{not interrupted} by other commands are
-lumped together, so the deleted text gets accumulated and can be put back
-as one chunk.  If you want to break a sequence of deletions so that the
-newly deleted text could be put back separately from the previously deleted
-text, you should perform a non-deleting action, e.g., move the cursor one
-character in any direction.
address@hidden Absolute Filenames
address@hidden absolute file names
-The current directory name for a file is automatically prepended to the
-file name in any
address@hidden:e}, @kbd{:r}, @kbd{:w}, etc., command (in Emacs, each buffer has 
a
-current directory).
-This directory is inserted in the Minibuffer once you type space after
address@hidden:e, r}, etc.  Viper also supports completion of file names and Ex
-commands (@key{TAB}), and it keeps track of
-command and file history (@kbd{M-p}, @kbd{M-n}).
-Absolute filenames are required less
-often in Viper.
-
-You should be aware that Emacs interprets @kbd{/foo/bar//bla} as
address@hidden/bla} and @kbd{/foo/~/bar} as @kbd{~/bar}.  This is designed to
-minimize the need for erasing file names that Emacs suggests in its
-prompts, if a suggested file name is not what you wanted.
-
-The command @kbd{:cd} will change the default directory for the
-current Emacs buffer.  The Ex command @kbd{:e} will interpret the
-filename argument in @samp{csh}, by default.  @xref{Customization}, if you
-want to change this.
address@hidden table
-
address@hidden
-Currently undisplayed files can be listed using the @kbd{:ar} command.  The
-command @kbd{:n} can be given counts from the @kbd{:ar} list to switch to
-other files. For example, use `:n3' to move to the third file in that list.
-
address@hidden Unimplemented Features,,Multiple Files in Viper,Overview
address@hidden Unimplemented Features
-
-Unimplemented features include:
-
address@hidden @bullet
address@hidden
address@hidden:ab} and @kbd{:una} are not implemented, since
address@hidden:ab} is considered obsolete, since Emacs has much
-more powerful facilities for defining abbreviations.
address@hidden
address@hidden:set option?} is not implemented.  The current
address@hidden:set} can also be used to set Emacs variables.
address@hidden
address@hidden:se list} requires modification of the display code for Emacs, so
-it is not implemented.
-A useful alternative is @code{cat -t -e file}.  Unfortunately, it cannot
-be used directly inside Emacs, since Emacs will obdurately change @samp{^I}
-back to normal address@hidden
address@hidden itemize
-
address@hidden  node-name,  next,  previous,  up
address@hidden Improvements over Vi, Customization, Overview, Top
address@hidden Improvements over Vi
-
-Some common problems with Vi and Ex have been solved in Viper.  This
-includes better implementation of existing commands, new commands, and
-the facilities provided by Emacs.
-
address@hidden
-* Basics::                  Basic Viper differences, Multi-file effects.
-* Undo and Backups::        Multiple undo, auto-save, backups and changes
-* History::                 History for Ex and Vi commands.
-* Macros and Registers::    Keyboard Macros (extended ".")@: @@reg execution.
-* Completion::              Filename and Command Completion for Ex.
-* Improved Search::         Incremental Search and Buffer Content Search.
-* Abbreviation Facilities:: Normal Abbrevs, Templates, and Dynamic Abbrevs.
-* Movement and Markers::    Screen Editor movements, viewing textmarkers.
-* New Commands::            Commands that do not exist in Vi.
-* Useful Packages::         A Sampling of some Emacs packages, and things
-                            you should know about.
address@hidden menu
-
address@hidden Basics, Undo and Backups, Improvements over Vi, Improvements 
over Vi
address@hidden Basics
-
-The Vi command set is based on the idea of combining motion commands
-with other commands.  The motion command is used as a text region
-specifier for other commands.
-We classify motion commands into @dfn{point commands} and
address@hidden address@hidden
-
address@hidden point commands
-
-The point commands are:
-
address@hidden
address@hidden, @kbd{l}, @kbd{0},  @kbd{$}, @kbd{w}, @kbd{W}, @kbd{b}, @kbd{B},
address@hidden, @kbd{E}, @kbd{(}, @kbd{)}, @kbd{/}, @kbd{?}, @kbd{`}, @kbd{f},
address@hidden, @kbd{t}, @kbd{T}, @kbd{%}, @kbd{;}, @kbd{,}, @kbd{^}
address@hidden quotation
-
address@hidden line commands
-
-The line commands are:
-
address@hidden
address@hidden, @kbd{k}, @kbd{+}, @kbd{-}, @kbd{H}, @kbd{M}, @kbd{L}, 
@address@hidden,
address@hidden@}}, @kbd{G}, @kbd{'},  @kbd{[[}, @kbd{]]}, @kbd{[]}
address@hidden quotation
-
address@hidden region
address@hidden region specification
address@hidden expanding (region)
address@hidden describing regions
address@hidden movement commands
-
address@hidden
-If a point command is given as an argument to a modifying command, the
-region determined by the point command will be affected by the modifying
-command.  On the other hand, if a line command is given as an argument to a
-modifying command, the region determined by the line command will be
-enlarged so that it will become the smallest region properly containing the
-region and consisting of whole lines (we call this process @dfn{expanding
-the region}), and then the enlarged region will be affected by the modifying
-command.
-Text Deletion Commands (@pxref{Deleting Text}), Change commands
-(@pxref{Changing Text}), even Shell Commands (@pxref{Shell Commands})
-use these commands to describe a region of text to operate on.
-Thus, type @kbd{dw} to delete a word, @kbd{>@}} to shift a paragraph, or
address@hidden'afmt} to format a region from @samp{point} to textmarker
address@hidden
-
address@hidden r and R region specifiers
-
-Viper adds the region specifiers @samp{r} and @samp{R}.  Emacs has a
-special marker called @dfn{mark}.  The text-area between the current cursor
-position @dfn{point} and the @dfn{mark} is called the @dfn{region}.
address@hidden specifies the raw region and @samp{R} is the expanded region
-(i.e., the minimal contiguous chunk of full lines that contains the raw
-region).
address@hidden will now delete the region, @kbd{>r} will shift it, etc.
address@hidden,R} are not motion commands, however.  The special mark is set by
address@hidden and other commands.  @xref{Marking}, for more info.
-
-Viper also adds counts to most commands for which it would make sense.
-
-In the Overview chapter, some Multiple File issues were discussed
-(@pxref{Multiple Files in Viper}).  In addition to the files, Emacs has
-buffers.  These can be seen in the @kbd{:args} list and switched using
address@hidden:next} if you type @kbd{:set ex-cycle-through-non-files t}, or
-specify @code{(setq ex-cycle-through-non-files t)} in your @file{.viper}
-file.  @xref{Customization}, for details.
-
address@hidden Undo and Backups, History, Basics, Improvements over Vi
address@hidden Undo and Backups
-
address@hidden undo
-
-Viper provides multiple undo.  The number of undo's and the size is limited
-by the machine.  The Viper command @kbd{u} does an undo.  Undo can be
-repeated by typing @kbd{.} (a period).  Another @kbd{u} will undo the undo,
-and further
address@hidden will repeat it.  Typing @kbd{u} does the first undo, and changes 
the
-direction.
-
address@hidden backup files
address@hidden auto save
-
-Since the undo size is limited, Viper can create backup files and
-auto-save files.  It will normally do this automatically.  It is possible
-to have numbered backups, etc.  For details, @pxref{Backup,,Backup and
-Auto-Save,emacs,The GNU Emacs Manual} @refill
-
address@hidden [ balance parens
address@hidden viewing registers and markers
address@hidden registers
address@hidden markers
address@hidden textmarkers
-
-The results of the 9 previous changes are available in the 9 numeric
-registers, as in Vi.  The extra goody is the ability to @emph{view} these
-registers, in addition to being able to access them through @kbd{p} and
address@hidden (@xref{Insert State}, for details.)
-The Viper command @kbd{] register} will display the contents of any
-register, numeric or alphabetical.  The related command @kbd{[ textmarker}
-will show the text around the textmarker.  @samp{register} and 
@samp{textmarker}
-can be any letters from a through z.
address@hidden ] balance parens
-
address@hidden History,  Macros and Registers, Undo and Backups,Improvements 
over Vi
address@hidden History
-
address@hidden history
address@hidden Minibuffer
-
-History is provided for Ex commands, Vi searches, file names, pieces of
-text inserted in earlier commands that use Insert or Replace state, and for
-destructive commands in Vi state.  These are
-useful for fixing those small typos that screw up searches and @kbd{:s},
-and for eliminating routine associated with repeated typing of file names
-or pieces of text that need to be inserted frequently.
-At the @kbd{:} or @kbd{/} prompts in the Minibuffer, you can do the following:
-
address@hidden @kbd
address@hidden M-p and M-n
-To move to previous and next history items.  This causes the history
-items to appear on the command line, where you can edit them, or
-simply type Return to execute.
address@hidden M-r and M-s
-To search backward and forward through the history.
address@hidden @key{RET}
-Type @key{RET} to accept a default (which is displayed in the prompt).
address@hidden table
-
-The history of insertions  can be perused by
-typing @kbd{C-c M-p} and @kbd{C-c M-n} while in Insert or Replace state.
-The history of destructive Vi commands can be perused via the same keys
-when Viper is in Vi state.  @xref{Viper Specials}, for details.
-
-All Ex commands have a file history.  For instance, typing @kbd{:e}, space
-and then @kbd{M-p} will bring up the name of the previously typed file
-name.  Repeatedly typing @kbd{M-p}, @kbd{M-n}, etc., will let you browse
-through the file history.
-
-Similarly, commands that have to do with switching buffers
-have a buffer history, and commands that expect strings or regular
-expressions keep a history on those items.
-
address@hidden Macros and Registers,Completion,History,Improvements over Vi
address@hidden Macros and Registers
-
address@hidden keyboard macros
address@hidden macros
address@hidden registers
address@hidden register execution
-
-Viper facilitates the use of Emacs-style keyboard macros.  @kbd{@@#} will
-start a macro definition.  As you type, the commands will be executed, and
-remembered (This is called ``learn mode'' in some editors.)
address@hidden@@register} will complete the macro, putting it into 
@samp{register},
-where @samp{register} is any character from @samp{a} through @samp{z}.  Then
-you can execute this macro using @kbd{@@register}.  It is, of course,
-possible to yank some text into a register and execute it using
address@hidden@@register}.  Typing @kbd{@@@@}, @kbd{@@RET}, or @kbd{@@C-j} will
-execute the last macro that was executed using @kbd{@@address@hidden
-
-Viper will automatically lowercase the register, so that pressing the
address@hidden key for @kbd{@@} will not create problems.  This is for
address@hidden@@} macros and @kbd{"p} @emph{only}.  In the case of @kbd{y},
address@hidden"Ayy} will append to @emph{register a}.  For @kbd{[,],',`}, it
-is an error to use a Uppercase register name.
-
address@hidden [ balance parens
address@hidden viewing registers and markers
-
-The contents of a register can be seen by @kbd{]register}.  (@kbd{[textmarker}
-will show the contents of a textmarker).
address@hidden ] balance parens
-
address@hidden last keyboard macro
-
-The last keyboard macro can also be executed using
address@hidden, and it can be yanked into a register using @kbd{@@!register}.
-This is useful for Emacs style keyboard macros defined using @kbd{C-x(}
-and @kbd{C-x)}.  Emacs keyboard macros have more capabilities.
address@hidden Macros,,Keyboard Macros,emacs, The GNU Emacs Manual}, for
address@hidden
-
-Keyboard Macros allow an interesting form of Query-Replace:
address@hidden/pattern} or @kbd{n} to go to the next pattern (the query), 
followed by a
-Keyboard Macro execution @kbd{@@@@} (the replace).
-
-Viper also provides Vi-style macros.  @xref{Vi Macros}, for details.
-
-
address@hidden Completion, Improved Search, Macros and Registers, Improvements 
over Vi
address@hidden Completion
-
address@hidden completion
-
-Completion is done when you type @key{TAB}.  The Emacs completer does not
-grok wildcards in file names.  Once you type a wildcard, the completer will
-no longer work for that file name.  Remember that Emacs interprets a file name
-of the form @kbd{/foo//bar} as @kbd{/bar} and @kbd{/foo/~/bar} as
address@hidden/bar}.
-
address@hidden Improved Search, Abbreviation Facilities, Completion, 
Improvements over Vi
address@hidden Improved Search
-
address@hidden buffer search
address@hidden word search
-
-Viper provides buffer search, the ability to search the buffer for a region
-under the cursor.  You have to turn this on in @file{.viper} either by calling
-
address@hidden
-(viper-buffer-search-enable)
address@hidden example
-
address@hidden
-or by setting @code{viper-buffer-search-char} to, say, @kbd{f3}:
address@hidden
-(setq viper-buffer-search-char ?g)
address@hidden example
-
address@hidden
-If the user calls @code{viper-buffer-search-enable} explicitly (the first
-method), then @code{viper-buffer-search-char} will be set to @kbd{g}.
-Regardless of how this feature is enabled, the key
address@hidden will take movement commands, like
address@hidden,/,e}, to find a region and then search for the contents of that
-region.  This command is very useful for searching for variable names, etc.,
-in a program.  The search can be repeated by @kbd{n} or reversed by @kbd{N}.
-
address@hidden incremental search
-
-Emacs provides incremental search.  As you type the string in, the
-cursor will move to the next match.  You can snarf words from the buffer
-as you go along.  Incremental Search is normally bound to @kbd{C-s} and
address@hidden  @xref{Customization}, to find out how to change the bindings
-of @kbd{C-r or C-s}.
-For details, @pxref{Incremental Search,,Incremental
-Search,emacs,The GNU Emacs Manual} @refill
-
address@hidden query replace
-
-Viper also provides a query replace function that prompts through the
-Minibuffer.  It is invoked by the @kbd{Q} key in Vi state.
-
address@hidden mouse search
-
-On a window display, Viper supports mouse search, i.e., you can search for a
-word by clicking on it.  @xref{Viper Specials}, for details.
-
-Finally, on a window display, Viper highlights search patterns as it finds
-them.  This is done through what is known as @emph{faces} in Emacs.  The
-variable that controls how search patterns are highlighted is
address@hidden  If you don't want any highlighting at all, put
address@hidden
-(copy-face 'default 'viper-search-face)
address@hidden example
address@hidden @code{viper-search-face}
address@hidden
-in @file{~/.viper}.  If you want to change how patterns are highlighted, you
-will have to change @code{viper-search-face} to your liking.  The easiest
-way to do this is to use Emacs customization widget, which is accessible
-from the menubar.  Viper customization group is located under the
address@hidden customization group, which in turn is under the
address@hidden group (or simply by typing @kbd{:customize}).  All Viper
-faces are grouped together under Viper's
address@hidden group.
-
-Try it: it is really simple!
-
address@hidden Abbreviation Facilities,Movement and Markers,Improved 
Search,Improvements over Vi
address@hidden Abbreviation Facilities
-
address@hidden abbrevs
-
-It is possible in Emacs to define abbrevs based on the contents of the
-buffer.
-Sophisticated templates can be defined using the Emacs abbreviation
-facilities.  @xref{Abbrevs,,Abbreviations,emacs,The GNU Emacs Manual}, for
-details.
-
address@hidden dynamic abbrevs
-
-Emacs also provides Dynamic Abbreviations.  Given a partial word, Emacs
-will search the buffer to find an extension for this word.  For instance,
-one can type @samp{Abbreviations} by typing @samp{A}, followed by a keystroke
-that completed the @samp{A} to @samp{Abbreviations}.  Repeated typing
-will search further back in the buffer, so that one could get
address@hidden by repeating the
-keystroke, which appears earlier in the text.  Emacs binds this to
address@hidden@key{ESC} /}, so you will have to find a key and bind the function
address@hidden to that key.
-Facilities like this make Vi's @kbd{:ab} command obsolete.
-
address@hidden Movement and Markers, New Commands, Abbreviation Facilities, 
Improvements over Vi
address@hidden Movement and Markers
-
address@hidden Ex style motion
address@hidden line editor motion
-
-Viper can be set free from the line--limited movements in Vi, such as @kbd{l}
-refusing to move beyond the line, @key{ESC} moving one character back,
-etc.  These derive from Ex, which is a line editor.  If your @file{.viper}
-contains
-
address@hidden
address@hidden(setq viper-ex-style-motion nil)}
address@hidden example
-
address@hidden
-the motion will be a true screen editor motion.  One thing you must then
-watch out for is that it is possible to be on the end-of-line character.
-The keys @kbd{x} and @kbd{%} will still work correctly, i.e., as if they
-were on the last character.
-
address@hidden @code{viper-syntax-preference}
address@hidden syntax table
-
-The word-movement commands @kbd{w}, @kbd{e}, etc., and the associated
-deletion/yanking commands, @kbd{dw}, @kbd{yw}, etc., can be made to
-understand Emacs syntax tables.  If the variable
address@hidden is set to @code{strict-vi} then
-the meaning of @emph{word} is the same as in
-Vi.  However, if the value is @code{reformed-vi} (the default) then the
-alphanumeric symbols will be those specified by the current Emacs syntax
-table (which may be different for different major modes) plus the
-underscore symbol @kbd{_}, minus some non-word symbols, like '.;,|, etc.
-Both @code{strict-vi} and @code{reformed-vi} work close to Vi in
-traditional cases, but @code{reformed-vi} does a better job when editing
-text in non-Latin alphabets.
-
-The user can also specify the value @code{emacs}, which would
-make Viper use exactly the Emacs notion of word.  In particular, the
-underscore may not be part of a word.  Finally, if
address@hidden is set to @code{extended}, Viper words would
-consist of characters that are classified as alphanumeric @emph{or} as
-parts of symbols.  This is convenient for writing programs and in many other
-situations.
-
address@hidden is a local variable, so it can have different
-values for different major modes.  For instance, in programming modes it can
-have the value @code{extended}.  In text modes where words contain special
-characters, such as European (non-English) letters, Cyrillic letters, etc.,
-the value can be @code{reformed-vi} or @code{emacs}.
-
-Changes to @code{viper-syntax-preference} should be done in the hooks to
-various major modes by executing @code{viper-set-syntax-preference} as in
-the following example:
-
address@hidden
-(viper-set-syntax-preference nil "emacs")
address@hidden example
-
address@hidden @code{viper-set-syntax-preference}
-
-The above discussion of the meaning of Viper's words concerns only Viper's
-movement commands.  In regular expressions, words remain the same as in
-Emacs.  That is, the expressions @code{\w}, @code{\>}, @code{\<}, etc., use
-Emacs' idea of what is a word, and they don't look into the value of
-variable @code{viper-syntax-preference}.  This is because Viper doesn't change
-syntax tables in fear of upsetting the various major modes that set these
-tables.
-
address@hidden textmarkers
-
-Textmarkers in Viper remember the file and the position, so that you can
-switch files by simply doing @kbd{'a}.  If you set up a regimen for using
-Textmarkers, this is very useful.  Contents of textmarkers can be viewed
-by @kbd{[marker}.  (Contents of registers can be viewed by @kbd{]register}).
-
address@hidden New Commands, Useful Packages, Movement and Markers, 
Improvements over Vi
address@hidden New Commands
-
-These commands have no Vi analogs.
-
address@hidden @kbd
address@hidden C-x, C-c
address@hidden @kbd{C-x}
address@hidden @kbd{C-c}
-These two keys invoke many important Emacs functions.  For example, if you
-hit @kbd{C-x} followed by @kbd{2}, then the current window will be split
-into 2.  Except for novice users, @kbd{C-c} is also set to execute an Emacs
-command from the current major mode.  @key{ESC} will do the same, if you
-configure @key{ESC} as Meta by setting @code{viper-no-multiple-ESC} to 
@code{nil}
-in @file{.viper}.  @xref{Customization}.  @kbd{C-\} in Insert, Replace, or Vi
-states will make Emacs think @kbd{Meta} has been address@hidden
address@hidden \
address@hidden @kbd{\}
-Escape to Emacs to execute a single Emacs command.  For instance,
address@hidden @key{ESC}} will act like a Meta key.
address@hidden Q
address@hidden @kbd{Q}
address@hidden query replace
address@hidden is for query replace.  By default,
-each string to be replaced is treated as a regular expression.  You can use
address@hidden(setq viper-re-query-replace nil)} in your @file{.emacs} file to
-turn this off.  (For normal searches, @kbd{:se nomagic} will work.  Note
-that @kbd{:se nomagic} turns Regexps off completely, unlike Vi).
address@hidden v
address@hidden V
address@hidden C-v
address@hidden @kbd{v}
address@hidden @kbd{V}
address@hidden @kbd{C-v}
-These keys are used to visit files.  @kbd{v} will switch to a buffer
-visiting file whose name can be entered in the Minibuffer.  @kbd{V} is
-similar, but will use a window different from the current window.
address@hidden is like @kbd{V}, except that a new frame (X window) will be used
-instead of a new Emacs window.
address@hidden #
address@hidden @kbd{#}
-If followed by a certain character @var{ch}, it becomes an operator whose
-argument is the region determined by the motion command that follows
-(indicated as <move>).
-Currently, @var{ch} can be one of @kbd{c}, @kbd{C}, @kbd{g}, @kbd{q}, and
address@hidden  For instance, @kbd{#qr} will prompt you for a string and then
-prepend this string to each line in the address@hidden
address@hidden # c
address@hidden @kbd{#c<move>}
address@hidden changing case
-Change upper-case characters in the region to lower-case
-(@code{downcase-region}).
-Emacs command @kbd{M-l} does the same for words.
address@hidden # C
address@hidden @kbd{#C<move>}
-Change lower-case characters in the region to upper-case.  For instance,
address@hidden C 3 w} will capitalize 3 words from the current point
-(@code{upcase-region}).
-Emacs command @kbd{M-u} does the same for words.
address@hidden # g
address@hidden @kbd{#g<move>}
-Execute last keyboard macro for each line in the region
-(@code{viper-global-execute})address@hidden
address@hidden # q
address@hidden @kbd{#q<move>}
-Insert specified string at the beginning of each line in the region
-(@code{viper-quote-region}).  The default string is composed of the comment
-character(s) appropriate for the current major mode.
address@hidden # s
address@hidden @kbd{#s<move>}
-Check spelling of words in the region (@code{spell-region}).
-The function used for spelling is determined from the variable
address@hidden
address@hidden @code{viper-spell-function}
address@hidden *
address@hidden @kbd{*}
-Call last keyboard macro.
address@hidden m .
-Set mark at point and push old mark off the ring
address@hidden m<
address@hidden m>
-Set mark at beginning and end of buffer, respectively.
address@hidden m,
-Jump to mark and pop mark off the ring.  @xref{Mark,,Mark,emacs,The GNU
-Emacs Manual}, for more info.
address@hidden ] register
address@hidden @kbd{]<a-z>}
-View contents of register
address@hidden [ textmarker
address@hidden @kbd{[<a-z>}
-View filename and position of textmarker
address@hidden @@#
address@hidden @@register
address@hidden @@!
address@hidden @kbd{@@#}
address@hidden @kbd{@@<a-z>}
address@hidden @kbd{@@!}
address@hidden keyboard macros
address@hidden register execution
-
-Begin/end keyboard macro.  @@register has a different meaning when used after
-a @kbd{@@#}.  @xref{Macros and Registers}, for details
address@hidden []
address@hidden @kbd{[]}
-Go to end of heading.
address@hidden g <@emph{movement command}>
-Search buffer for text delimited by movement command.  The canonical
-example is @kbd{gw} to search for the word under the cursor.
address@hidden Search}, for address@hidden
address@hidden C-g and C-]
address@hidden @kbd{C-g}
address@hidden @kbd{C-]}
-Quit and Abort Recursive edit.  These may be necessary on occasion.
address@hidden State}, for a reason.
address@hidden C-c C-g
address@hidden @kbd{C-c C-g}
-Hitting @kbd{C-c} followed by @kbd{C-g} will display the information on the
-current buffer.  This is the same as hitting @kbd{C-g} in Vi, but, as
-explained above, @kbd{C-g} is needed for other purposes in Emacs.
address@hidden C-c /
address@hidden @kbd{C-c /}
-Without a prefix argument, this command toggles
-case-sensitive/case-insensitive search modes and plain vanilla/regular
-expression search.  With the prefix argument 1, i.e.,
address@hidden C-c /}, this toggles case-sensitivity; with the prefix argument 
2,
-toggles plain vanilla search and search using
-regular expressions.  @xref{Viper Specials}, for alternative ways to invoke
-this function.
address@hidden vanilla search
address@hidden case-sensitive search
address@hidden case-insensitive search
-
address@hidden M-p and M-n
address@hidden @kbd{M-p}
address@hidden @kbd{M-n}
-In the Minibuffer, these commands navigate through the minibuffer
-histories, such as the history of search strings, Ex commands, etc.
-
address@hidden C-c M-p and C-c M-n
address@hidden @kbd{C-c M-p}
address@hidden @kbd{C-c M-n}
address@hidden Insertion history
address@hidden Insertion ring
address@hidden Command history
address@hidden Command ring
-
-In Insert or Replace state, these commands let  the user
-peruse the history of insertion strings used in previous insert or replace
-commands.  Try to hit @kbd{C-c M-p} or @kbd{C-c M-n} repeatedly and see what
-happens.  @xref{Viper Specials}, for more.
-
-In Vi state, these commands let the user peruse the history of Vi-style
-destructive commands, such as @kbd{dw}, @kbd{J}, @kbd{a}, etc.
-By repeatedly typing @kbd{C-c M-p} or @kbd{C-c M-n} you will cycle Viper
-through the recent history of Vi commands, displaying the commands one by
-one.  Once
-an appropriate command is found, it can be executed by typing address@hidden'.
-
-Since typing @kbd{C-c M-p} is tedious, it is more convenient to bind an
-appropriate function to a function key on the keyboard and use that key.
address@hidden Specials}, for details.
-
address@hidden Ex commands
address@hidden  @kbd{:args}
address@hidden  @kbd{:n}
address@hidden  @kbd{:pwd}
address@hidden  @kbd{:pre}
-The commands @kbd{:args}, @kbd{:next}, @kbd{:pre} behave
-differently.  @kbd{:pwd} exists to get current directory.
-The commands @kbd{:b} and @kbd{:B} switch buffers around.  @xref{File and
-Buffer Handling}, for details.
-There are also the new commands @kbd{:RelatedFile} and
address@hidden (which abbreviate to @kbd{R} and @kbd{P},
-respectively.  @xref{Viper Specials}, for details.
address@hidden @kbd{:RelatedFile}
address@hidden @kbd{:PreviousRelatedFile}
address@hidden table
-
-Apart from the new commands, many old commands have been enhanced.  Most
-notably, Vi style macros are much more powerful in Viper than in Vi.  @xref{Vi
-Macros}, for details.
-
address@hidden Useful Packages, ,New Commands, Improvements over Vi
address@hidden Useful Packages
-
-Some Emacs packages are mentioned here as an aid to the new Viper user, to
-indicate what Viper is capable of.
-A vast number comes with the standard Emacs distribution, and many more exist
-on the net and on the archives.
-
-This manual also mentions some Emacs features a new user
-should know about.  The details of these are found in the GNU Emacs
-Manual.
-
-The features first.  For details, look up the Emacs Manual.
-
address@hidden @samp
address@hidden Make
address@hidden make
address@hidden compiling
-
-Makes and Compiles can be done from the editor.  Error messages will be
-parsed and you can move to the error lines.
address@hidden Shell
address@hidden shell
address@hidden interactive shell
-You can talk to Shells from inside the editor.  Your entire shell session
-can be treated as a file.
address@hidden Mail
address@hidden email
address@hidden mail
-Mail can be read from and sent within the editor.  Several sophisticated
-packages exist.
address@hidden Language Sensitive Editing
-Editing modes are written for most computer languages in existence.  By
-controlling indentation, they catch punctuation errors.
address@hidden table
-
-The packages, below, represents a drop in the sea of special-purpose
-packages that come with standard distribution of Emacs.
-
address@hidden @samp
address@hidden Transparent FTP
address@hidden transparent ftp
address@hidden ange-ftp.el
address@hidden can ftp from the editor to files on other machines
-transparent to the user.
address@hidden RCS Interfaces
address@hidden version maintenance
address@hidden RCS
address@hidden vc.el
address@hidden for doing RCS commands from inside the editor
address@hidden Directory Editor
address@hidden dired
address@hidden dired.el
address@hidden for editing contents of directories and for navigating in
-the file system.
address@hidden Syntactic Highlighting
address@hidden font-lock
address@hidden font-lock.el
address@hidden for automatic highlighting various parts of a buffer
-using different fonts and colors.
address@hidden Saving Emacs Configuration
address@hidden desktop
address@hidden desktop.el
address@hidden for saving/restoring configuration on Emacs exit/startup.
address@hidden Spell Checker
address@hidden ispell
address@hidden ispell.el
address@hidden for spell checking the buffer, words, regions, etc.
address@hidden File and Buffer Comparison
address@hidden ediff
address@hidden ediff.el
address@hidden for finding differences between files and for applying
-patches.
address@hidden table
-
address@hidden
-Emacs Lisp archives exist on
address@hidden
-and @address@hidden
-
-
address@hidden Customization,Commands,Improvements over Vi,Top
address@hidden Customization
-
address@hidden customization
-
-Customization can be done in 2 ways.
-
address@hidden @bullet
address@hidden
address@hidden initialization
address@hidden .viper
-Elisp code in a @file{.viper} file in your home directory.  Viper
-loads @file{.viper} just before it does the binding for mode
-hooks.  This is recommended for experts only.
address@hidden
address@hidden .emacs
-Elisp code in your @file{.emacs} file before and after the @code{(require
-'viper)} line.  This method is @emph{not} recommended, unless you know what
-you are doing.  Only two variables, @code{viper-mode} and
address@hidden, are supposed to be customized in @file{.emacs},
-prior to loading Viper (i.e., prior to @code{(require 'viper)} address@hidden
address@hidden
address@hidden :customize
-By executing the @kbd{:customize} Ex command. This takes you to the Emacs
-customization widget, which lets you change the values of Viper
-customizable variables easily. This method is good for novice and
-experts alike. The customization code in the form of Lisp commands will be
-placed in @file{~/.emacs} or some other customization file depending on the
-version of Emacs that you use. Still, it is recommended to separate
-Viper-related customization produced by the Emacs customization widget
-and keep it in the @file{.viper} file.
-
-Some advanced customization cannot be accomplished this way, however, and
-has to be done in Emacs Lisp in the @file{.viper} file.  For the common
-cases, examples are provided that you can use directly.
address@hidden itemize
-
-
address@hidden
-* Rudimentary Changes::          Simple constant definitions.
-* Key Bindings::                 Enabling Emacs Keys, Rebinding keys, etc.
-* Packages that Change Keymaps:: How to deal with such beasts.
-* Viper Specials::               Special Viper commands.
-* Vi Macros::                    How to do Vi style macros.
address@hidden menu
-
address@hidden Rudimentary Changes,Key Bindings,Customization,Customization
address@hidden Rudimentary Changes
-
address@hidden setting variables
address@hidden variables for customization
address@hidden @kbd{:set}
-
-An easy way to customize Viper is to change the values of constants used in
-Viper.  Here is the list of the constants used in Viper and their default
-values.  The corresponding :se command is also indicated.  (The symbols
address@hidden and @code{nil} represent ``true'' and ``false'' in Lisp).
-
-Viper supports both the abbreviated Vi variable names and their full
-names.  Variable completion is done on full names only.  @key{TAB} and
address@hidden complete
-variable names.  Typing `=' will complete the name and then will prompt for
-a value, if applicable.  For instance, @kbd{:se au @key{SPC}} will complete the
-command to @kbd{:set autoindent}; @kbd{:se ta @key{SPC}} will complete the 
command
-and prompt further like this: @kbd{:set tabstop = }.
-However, typing @kbd{:se ts @key{SPC}} will produce a ``No match'' message
-because @kbd{ts} is an abbreviation for @kbd{tabstop} and Viper supports
-completion on full names only.  However, you can still hit @key{RET}
-or @kbd{=}, which will complete the command like this: @kbd{:set ts = } and
-Viper will be waiting for you to type a value for the tabstop variable.
-To get the full list of Vi variables, type @kbd{:se @key{SPC} @key{TAB}}.
-
address@hidden @code
address@hidden viper-auto-indent nil
address@hidden :se ai (:se autoindent)
address@hidden :se ai-g (:se autoindent-global)
-If @code{t}, enable auto indentation.
-by @key{RET}, @kbd{o} or @kbd{O} command.
-
address@hidden is a local variable.  To change the value globally, use
address@hidden  It may be useful for certain major modes to have their
-own values of @code{viper-auto-indent}.  This can be achieved by using
address@hidden to change the local value of this variable in the hooks to the
-appropriate major modes.
-
address@hidden:se ai} changes the value of @code{viper-auto-indent} in the 
current
-buffer only; @kbd{:se ai-g} does the same globally.
address@hidden viper-electric-mode t
-If not @code{nil}, auto-indentation becomes electric, which means that
address@hidden, @kbd{O}, and @kbd{o} indent cursor according to the current
-major mode.  In the future, this variable may control additional electric
-features.
-
-This is a local variable: @code{setq} changes the value of this variable
-in the current buffer only.  Use @code{setq-default} to change the value in
-all buffers.
address@hidden viper-case-fold-search nil
address@hidden :se ic (:se ignorecase)
-If not @code{nil}, search ignores cases.
-This can also be toggled by quickly hitting @kbd{/} twice.
address@hidden viper-re-search nil
address@hidden :se magic
-If not @code{nil}, search will use regular expressions; if @code{nil} then
-use vanilla search.
-This behavior can also be toggled by quickly hitting @kbd{/} trice.
address@hidden buffer-read-only
address@hidden :se ro (:se readonly)
-Set current buffer to read only.  To change globally put
address@hidden(setq-default buffer-read-only t)} in your @file{.emacs} file.
address@hidden blink-matching-paren t
address@hidden :se sm (:se showmatch)
-Show matching parens by blinking cursor.
address@hidden tab-width t (default setting via @code{setq-default})
address@hidden :se ts=value (:se tabstop=value)
address@hidden :se ts-g=value (:se tabstop-global=value)
address@hidden is a local variable that controls the width of the tab stops.
-To change the value globally, use @code{setq-default}; for local settings,
-use @code{setq}.
-
-The command @kbd{:se ts}
-sets the tab width in the current
-buffer only; it has no effect on other buffers.
-
-The command @kbd{:se ts-g} sets tab width globally,
-for all buffers where the tab is not yet set locally,
-including the new buffers.
-
-Note that typing @key{TAB} normally
-doesn't insert the tab, since this key is usually bound to
-a text-formatting function, @code{indent-for-tab-command} (which facilitates
-programming and document writing).  Instead, the tab is inserted via the
-command @code{viper-insert-tab}, which is bound to @kbd{S-tab} (shift + tab).
-
-On some non-windowing terminals, Shift doesn't modify the @key{TAB} key, so
address@hidden behaves as if it were @key{TAB}.  In such a case, you will have
-to bind @code{viper-insert-tab} to some other convenient key.
-
address@hidden viper-shift-width 8
address@hidden :se sw=value  (:se shiftwidth=value)
-The number of columns shifted by @kbd{>} and @kbd{<} commands.
address@hidden viper-search-wrap-around t
address@hidden :se ws (:se wrapscan)
-If not @code{nil}, search wraps around the end/beginning of buffer.
address@hidden viper-search-scroll-threshold 2
-If search lands within this many lines of the window top or bottom, the
-window will be scrolled up or down by about 1/7-th of its size, to reveal
-the context.  If the value is negative---don't scroll.
address@hidden viper-tags-file-name "TAGS"
-The name of the file used as the tag table.
address@hidden viper-re-query-replace nil
-If not @code{nil}, use reg-exp replace in query replace.
address@hidden viper-want-ctl-h-help nil
-If not @code{nil}, @kbd{C-h} is bound to @code{help-command};
-otherwise, @kbd{C-h} is bound as usual in Vi.
address@hidden viper-vi-style-in-minibuffer t
-If not @code{nil}, Viper provides a high degree of compatibility with Vi
-insert mode when you type text in the Minibuffer; if @code{nil}, typing in
-the Minibuffer feels like plain Emacs.
address@hidden viper-no-multiple-ESC t
-If you set this to @code{nil}, you can use @key{ESC} as Meta in Vi state.
-Normally, this is not necessary, since graphical displays have separate
-Meta keys (usually on each side of the space bar).  On a dumb terminal, Viper
-sets this variable to @code{twice}, which is almost like @code{nil}, except
-that double @key{ESC} beeps.  This, too, lets @key{ESC} to be used as a Meta.
address@hidden viper-ESC-keyseq-timeout 200 on tty, 0 on windowing display
-Escape key sequences separated by this much delay (in milliseconds) are
-interpreted as command, ignoring the special meaning of @key{ESC} in
-VI.  The default is suitable for most terminals.  However, if your terminal
-is extremely slow, you might want to increase this slightly.  You will know
-if your terminal is slow if the @key{ESC} key sequences emitted by the
-arrow keys are interpreted as separately typed characters (and thus the
-arrow keys won't work).  Making this value too large will slow you down, so
-exercise restraint.
address@hidden viper-fast-keyseq-timeout 200
-Key sequences separated by this many milliseconds are treated as Vi-style
-keyboard macros.  If the key sequence is defined as such a macro, it will be
-executed.  Otherwise, it is processed as an ordinary sequence of typed keys.
-
-Setting this variable too high may slow down your typing.  Setting it too
-low may make it hard to type macros quickly enough.
address@hidden viper-translate-all-ESC-keysequences @code{t} on tty, @code{nil} 
on windowing display
-Normally, Viper lets Emacs translate only those ESC key sequences that are
-defined in the low-level key-translation-map or function-key-map, such as those
-emitted by the arrow and function keys. Other sequences, e.g., @kbd{\\e/}, are
-treated as @kbd{ESC} command followed by a @kbd{/}. This is good for people
-who type fast and tend to hit other characters right after they hit
-ESC. Other people like Emacs to translate @kbd{ESC} sequences all the time.
-The default is to translate all sequences only when using a dumb terminal.
-This permits you to use @kbd{ESC} as a meta key in insert mode. For instance,
-hitting @kbd{ESC x} fast would have the effect of typing @kbd{M-x}.
-If your dumb terminal is not so dumb and understands the meta key, then you
-probably will be better off setting this variable to @code{nil}. Try and see 
which
-way suits you best.
address@hidden viper-ex-style-motion t
-Set this to @code{nil}, if you want @kbd{l,h} to cross
-lines, etc.  @xref{Movement and Markers}, for more info.
address@hidden viper-ex-style-editing t
-Set this to @code{nil}, if you want
address@hidden and @key{DEL} to not stop
-at the beginning of a line in Insert state, @key{X} and @key{x} to delete
-characters across lines in Vi command state, etc.
address@hidden viper-ESC-moves-cursor-back t
-It @code{t}, cursor moves back 1 character when switching from insert state to 
vi
-state.  If @code{nil}, the cursor stays where it was before the switch.
address@hidden viper-always t
address@hidden means: leave it to Viper to decide when a buffer must be brought
-up in Vi state,
-Insert state, or Emacs state.  This heuristics works well in virtually all
-cases.  @code{nil} means you either has to invoke @code{viper-mode} manually
-for each buffer (or you can add @code{viper-mode} to the appropriate major mode
-hooks using @code{viper-load-hook}).
-
-This option must be set in the file @file{~/.viper}.
address@hidden viper-custom-file-name "~/.viper"
-File used for Viper-specific customization.
-Change this setting, if you want.  Must be set in @file{.emacs} (not 
@file{.viper}!)
-before Viper is loaded.  Note that you
-have to set it as a string inside double quotes.
address@hidden viper-spell-function 'ispell-region
-Function used by the command @kbd{#c<move>} to spell.
address@hidden viper-glob-function
-The value of this variable is the function symbol used to expand wildcard
-symbols. This is platform-dependent. The default tries to set this variable
-to work with most shells, MS Windows, OS/2, etc. However, if it
-doesn't work the way you expect, you should write your own.
-Use @code{viper-glob-unix-files} and @code{viper-glob-mswindows-files} in
address@hidden as examples.
-
-This feature is used to expand wildcards in the Ex command @kbd{:e}.
-Note that Viper doesn't support wildcards in the @kbd{:r} and @kbd{:w}
-commands, because file completion is a better mechanism.
address@hidden @code{viper-glob-function}
-
address@hidden ex-cycle-other-window t
-If not @code{nil}, @kbd{:n} and @kbd{:b} will cycle through files in another
-window, if one exists.
address@hidden ex-cycle-through-non-files nil
address@hidden:n} does not normally cycle through buffers.  Set this to get
-buffers also.
address@hidden viper-want-emacs-keys-in-insert
-This is set to @code{nil} for user levels 1 and 2 and to @code{t} for user
-levels 3 and 4.  Users who specify level 5 are allowed to set this variable
-as they please (the default for this level is @code{t}).  If set to
address@hidden, complete Vi compatibility is provided in Insert state.  This is
-really not recommended, as this precludes you from using language-specific
-features provided by the major modes.
address@hidden viper-want-emacs-keys-in-vi
-This is set to @code{nil} for user
-level 1 and to @code{t} for user levels 2--4.
-At level 5, users are allowed to set this variable as they please (the
-default for this level is @code{t}).
-If set to @code{nil}, complete Vi compatibility is provided
-in Vi command state.  Setting this to @code{nil} is really a bad idea,
-unless you are a novice, as this precludes the use
-of language-specific features provided by the major modes.
address@hidden viper-keep-point-on-repeat t
-If not @code{nil}, point is not moved when the user repeats the previous
-command by typing `.'  This is very useful for doing repeated changes with
-the @kbd{.} key.
address@hidden viper-repeat-from-history-key 'f12
-Prefix key used to invoke the macros @kbd{f12 1} and @kbd{f12 2} that repeat
-the second-last and the third-last destructive command.
-Both these macros are bound (as Viper macros) to
address@hidden,
-which checks the second key by which it is invoked to see which of the
-previous commands to invoke.  Viper binds @kbd{f12 1} and @kbd{f12 2} only,
-but the user can bind more in @file{~/.viper}.  @xref{Vi Macros}, for how to do
-this.
address@hidden viper-keep-point-on-undo nil
-If not @code{nil}, Viper tries to not move point when undoing commands.
-Instead, it will briefly move the cursor to the place where change has
-taken place.  However, if the undone piece of text is not seen in window,
-then point will be moved to the place where the change took place.
-Set it to @code{t} and see if you like it better.
address@hidden viper-delete-backwards-in-replace nil
-If not @code{nil}, @key{DEL} key will delete characters while moving the cursor
-backwards.  If @code{nil}, the cursor will move backwards without deleting
-anything.
address@hidden viper-replace-overlay-face 'viper-replace-overlay-face
-On a graphical display, Viper highlights replacement regions instead of
-putting a @samp{$} at the end.  This variable controls the so called
address@hidden used to highlight the region.
-
-By default, @code{viper-replace-overlay-face} underlines the replacement on
-monochrome displays and also lays a stipple over them.  On color displays,
-replacement regions are highlighted with color.
-
-If you know something about Emacs faces and don't like how Viper highlights
-replacement regions, you can change @code{viper-replace-overlay-face} by
-specifying a new face.  (Emacs faces are described in the Emacs Lisp
-reference.)  On a color display, the following customization method is
-usually most effective:
address@hidden
-(set-face-foreground viper-replace-overlay-face "DarkSlateBlue")
-(set-face-background viper-replace-overlay-face "yellow")
address@hidden example
-For a complete list of colors available to you, evaluate the expression
address@hidden(x-defined-colors)}.  (Type it in the buffer @code{*scratch*} and 
then
-hit the @kbd{C-j} key.
-
address@hidden viper-replace-overlay-cursor-color  "Red"
address@hidden @code{viper-replace-overlay-cursor-color}
-Cursor color when it is inside the replacement region.
-This has effect only on color displays and only when Emacs runs as an X
-application.
address@hidden viper-insert-state-cursor-color nil
address@hidden @code{viper-insert-state-cursor-color}
-If set to a valid color, this will be the cursor color when Viper is in
-insert state.
address@hidden viper-emacs-state-cursor-color nil
address@hidden @code{viper-emacs-state-cursor-color}
-If set to a valid color, this will be the cursor color when Viper is in
-emacs state.
address@hidden viper-replace-region-end-delimiter "$"
-A string used to mark the end of replacement regions.  It is used only on
-TTYs or if @code{viper-use-replace-region-delimiters} is address@hidden
address@hidden viper-replace-region-start-delimiter  ""
-A string used to mark the beginning of replacement regions.  It is used
-only on TTYs or if @code{viper-use-replace-region-delimiters} is address@hidden
address@hidden viper-use-replace-region-delimiters
-If address@hidden, Viper will always use 
@code{viper-replace-region-end-delimiter} and
address@hidden to delimit replacement regions,
-even on color displays (where this is unnecessary).  By default, this
-variable is address@hidden only on TTYs or monochrome displays.
address@hidden viper-allow-multiline-replace-regions t
-If address@hidden, multi-line text replacement regions, such as those produced 
by
-commands @kbd{c55w}, @kbd{3C}, etc., will stay around until the user exits
-the replacement mode.  In this variable is set to @code{nil}, Viper will
-emulate the standard Vi behavior, which supports only intra-line
-replacement regions (and multi-line replacement regions are deleted).
address@hidden viper-toggle-key "\C-z"
-Specifies the key used to switch from Emacs to Vi and back.
-Must be set in @file{.viper}.  This variable can't be
-changed interactively after Viper is loaded.
-
-In Insert state, this key acts as a temporary escape to Vi state, i.e., it
-will set Viper up so that the very next command will be executed as if it
-were typed in Vi state.
address@hidden viper-ESC-key "\e"
-Specifies the key used to escape from Insert/Replace states to Vi.
-Must be set in @file{.viper}.  This variable cannot be
-changed interactively after Viper is loaded.
address@hidden viper-buffer-search-char nil
-Key used for buffer search.  @xref{Viper Specials}, for details.
address@hidden viper-surrounding-word-function 'viper-surrounding-word
-The value of this variable is a function name that is used to determine
-what constitutes a word clicked upon by the mouse.  This is used by mouse
-search and insert.
address@hidden viper-search-face 'viper-search-face
-Variable that controls how search patterns are highlighted when they are
-found.
address@hidden viper-vi-state-hook nil
-List of parameterless functions to be run just after entering the Vi
-command state.
address@hidden viper-insert-state-hook nil
-Same for Insert state.  This hook is also run after entering Replace state.
address@hidden viper-replace-state-hook  nil
-List of (parameterless) functions called just after entering Replace state
-(and after all @code{viper-insert-state-hook}).
address@hidden viper-emacs-state-hook nil
-List of (parameterless) functions called just after switching from Vi state
-to Emacs state.
address@hidden viper-load-hook nil
-List of (parameterless) functions called just after loading Viper.  This is
-the last chance to do customization before Viper is up and running.
address@hidden table
address@hidden
-You can reset some of these constants in Viper with the Ex command @kbd{:set}
-(when so indicated in the table).  Or you
-can include a line like this in your @file{.viper} file:
address@hidden
-(setq viper-case-fold-search t)
address@hidden example
address@hidden @code{viper-auto-indent}
address@hidden @code{viper-electric-mode}
address@hidden @code{viper-case-fold-search}
address@hidden @code{viper-re-search}
address@hidden @code{viper-shift-width}
address@hidden @code{buffer-read-only}
address@hidden @code{viper-search-wrap-around}
address@hidden @code{viper-search-scroll-threshold}
address@hidden @code{viper-search-face}
address@hidden @code{viper-tags-file-name}
address@hidden @code{viper-re-query-replace}
address@hidden @code{viper-want-ctl-h-help}
address@hidden @code{viper-vi-style-in-minibuffer}
address@hidden @code{viper-no-multiple-ESC}
address@hidden @code{viper-always}
address@hidden @code{viper-ESC-keyseq-timeout}
address@hidden @code{viper-fast-keyseq-timeout}
address@hidden @code{viper-ex-style-motion}
address@hidden @code{viper-ex-style-editing}
address@hidden @code{viper-ESC-moves-cursor-back}
address@hidden @code{viper-custom-file-name}
address@hidden @code{viper-spell-function}
address@hidden @code{ex-cycle-other-window}
address@hidden @code{ex-cycle-through-non-files}
address@hidden @code{viper-want-emacs-keys-in-insert}
address@hidden @code{viper-want-emacs-keys-in-vi}
address@hidden @code{viper-keep-point-on-repeat}
address@hidden @code{viper-keep-point-on-undo}
address@hidden @code{viper-delete-backwards-in-replace}
address@hidden @code{viper-replace-overlay-face}
address@hidden @code{viper-replace-region-end-symbol}
address@hidden @code{viper-replace-region-start-symbol}
address@hidden @code{viper-allow-multiline-replace-regions}
address@hidden @code{viper-toggle-key}
address@hidden @code{viper-ESC-key}
address@hidden @code{viper-buffer-search-char}
address@hidden @code{viper-surrounding-word-function}
address@hidden @code{viper-vi-state-hook}
address@hidden @code{viper-insert-state-hook}
address@hidden @code{viper-replace-state-hook}
address@hidden @code{viper-emacs-state-hook}
-
address@hidden Key Bindings, Packages that Change Keymaps, Rudimentary 
Changes,Customization
address@hidden Key Bindings
-
address@hidden key bindings
address@hidden keymaps
-
-Viper lets you define hot keys, i.e., you can associate keyboard keys
-such as F1, Help, PgDn, etc., with Emacs Lisp functions (that may already
-exist or that you will write).  Each key has a "preferred form" in
-Emacs.  For instance, the Up key's preferred form is [up], the Help key's
-preferred form is [help], and the Undo key has the preferred form [f14].
-You can find out the preferred form of a key by typing @kbd{M-x
-describe-key-briefly} and then typing the key you want to know about.
-
-Under the X Window System, every keyboard key emits its preferred form,
-so you can just type
-
address@hidden
-(global-set-key [f11] 'calendar)                        ; L1, Stop
-(global-set-key [f14] 'undo)                            ; L4, Undo
address@hidden lisp
-
address@hidden
-to bind L1 (a key that exists on some SUN workstations) so it will invoke
-the Emacs Calendar and to bind L4 so it will undo changes.
-However, on a dumb terminal or in an Xterm window, even the standard arrow
-keys may
-not emit the right signals for Emacs to understand.  To let Emacs know about
-those keys, you will have to find out which key sequences they emit
-by typing @kbd{C-q} and then the key (you should switch to Emacs state
-first).  Then you can bind those sequences to their preferred forms using
address@hidden as follows:
-
address@hidden
-(cond ((string= (getenv "TERM") "xterm")
-(define-key function-key-map "\e[192z" [f11])    ; L1
-(define-key function-key-map "\e[195z" [f14])    ; L4, Undo
address@hidden lisp
-
-The above illustrates how to do this for Xterm.  On VT100, you would have to
-replace "xterm" with "vt100" and also change the key sequences (the same
-key may emit different sequences on different types of terminals).
-
-The above keys are global, so they are overwritten by the local maps
-defined by the major modes and by Viper itself.  Therefore, if you wish to
-change a binding set by a major mode or by Viper, read this.
-
-Viper users who wish to specify their own key bindings should be concerned
-only with the following three keymaps:
address@hidden for Vi state commands,
address@hidden for Insert state commands,
-and @code{viper-emacs-global-user-map} for Emacs state commands (note:
-customized bindings for Emacs state made to @code{viper-emacs-global-user-map}
-are @emph{not} inherited by Insert state).
-
-For more information on Viper keymaps, see the header of the file
address@hidden
-If you wish to change a Viper binding, you can use the
address@hidden command, to modify @code{viper-vi-global-user-map},
address@hidden, and @code{viper-emacs-global-user-map}, as
-explained below.  Each of these key maps affects the corresponding Viper state.
-The keymap @code{viper-insert-global-user-map} also affects Viper's Replace
-state.
-
address@hidden
-If you want to
-bind a key, say @kbd{C-v}, to the function that scrolls
-page down and to make @kbd{0} display information on the current buffer,
-putting this in @file{.viper} will do the trick in Vi state:
address@hidden
-(define-key viper-vi-global-user-map "\C-v" 'scroll-down)
address@hidden example
address@hidden
-To set a key globally,
address@hidden
-(define-key viper-emacs-global-user-map "\C-c m" 'smail)
-(define-key viper-vi-global-user-map "0" 'viper-info-on-file)
address@hidden example
address@hidden
-Note, however, that this binding may be overwritten by other keymaps, since
-the global keymap has the lowest priority.
-To make sure that nothing will override a binding in Emacs state, you
-can write this:
address@hidden
-(define-key viper-emacs-global-user-map "\C-c m" 'smail)
address@hidden example
address@hidden
-To customize the binding for @kbd{C-h} in Insert state:
address@hidden
-(define-key viper-insert-global-user-map "\C-h" 'my-del-backwards-function)
address@hidden example
address@hidden
-
-Each Emacs command key calls some Lisp function.  If you have enabled the
-Help, (@pxref{Rudimentary Changes}) @kbd{C-h k} will show you the function
-for each specific key; @kbd{C-h b} will show all bindings, and @kbd{C-h m}
-will provide information on the major mode in effect.  If Help is not
-enabled, you can still get help in Vi state by prefixing the above commands
-with @kbd{\}, e.g., @kbd{\ C-h k} (or you can use the Help menu in the
-menu bar, if Emacs runs under X).
-
-Viper users can also change bindings on a per major mode basis.  As with
-global bindings, this can be done separately for each of the three main Viper
-states.  To this end, Viper provides the function
address@hidden
address@hidden @code{viper-modify-major-mode}
-
-To modify keys in Emacs state for @code{my-favorite-major-mode}, the user
-needs to create a sparse keymap, say, @code{my-fancy-map}, bind whatever
-keys necessary in that keymap, and put
-
address@hidden
-(viper-modify-major-mode 'dired-mode 'emacs-state my-fancy-map)
address@hidden example
-
address@hidden
-in @file{~/.viper}.  To do the same in Vi and Insert states, you should use
address@hidden and @code{insert-state}.  Changes in Insert state are also
-in effect in Replace state.  For instance, suppose that the user wants to
-use @kbd{dd} in Vi state under Dired mode to delete files, @kbd{u} to unmark
-files, etc.  The following code in @file{~/.viper} will then do the job:
-
address@hidden
-(setq my-dired-modifier-map (make-sparse-keymap))
-(define-key my-dired-modifier-map "dd" 'dired-flag-file-deletion)
-(define-key my-dired-modifier-map "u" 'dired-unmark)
-(viper-modify-major-mode 'dired-mode 'vi-state my-dired-modifier-map)
address@hidden example
-
-A Vi purist may want to modify Emacs state under Dired mode so that
address@hidden, @kbd{l}, etc., will move around in directory buffers, as in
-Vi.  Although this is not recommended, as these keys are bound to useful
-Dired functions, the trick can be accomplished via the following code:
-
address@hidden
-(setq my-dired-vi-purist-map (make-sparse-keymap))
-(define-key my-dired-vi-purist-map "k" 'viper-previous-line)
-(define-key my-dired-vi-purist-map "l" 'viper-forward-char)
-(viper-modify-major-mode 'dired-mode 'emacs-state my-dired-vi-purist-map)
address@hidden example
-
-Yet another way to customize key bindings in a major mode is to edit the
-list @code{viper-major-mode-modifier-list} using the customization widget.
address@hidden @code{viper-major-mode-modifier-list}
-(This variable is in the Viper-misc customization group.)
-The elements of this list are triples of the form: (major-mode viper-state
-keymap), where the keymap contains bindings that are supposed to be active
-in the given major mode and the given viper-state.
-
-Effects similar to key binding changes can be achieved by defining Vi
-keyboard macros using the Ex commands @kbd{:map} and @kbd{:map!}.  The
-difference is that multi-key Vi macros do not override the keys they are
-bound to, unless these keys are typed in quick succession.  So, with macros,
-one can use the normal keys alongside with the macros.  If per-mode
-modifications are needed, the user can try both ways and see which one is
-more convenient.
address@hidden @kbd{:map}
address@hidden Macros}, for details.
-
-Note: in major modes that come up in @emph{Emacs state} by default, the
-aforesaid modifications may not take place immediately (but only after the
-buffer switches to some other Viper state and then back to Emacs state).  To
-avoid this, one should add @code{viper-change-state-to-emacs} to an
-appropriate hook of that major mode.  (Check the function
address@hidden in @file{viper.el} for examples.)  However, if you
-did not set @code{viper-always} to @code{nil}, chances are that you won't
-need to perform the above procedure, because Viper will take care of most
-useful defaults.
-
-
-Finally, Viper has a facility that lets the user define per-buffer
-bindings, i.e., bindings that are in effect in some specific buffers
-only.  Unlike per-mode bindings described above, per-buffer bindings can be
-defined based on considerations other than the major mode.  This is done
-via the function @code{viper-add-local-keys}, which lets one specify bindings
-that should be in effect in the current buffer only and for a specific Viper
-state.  For instance,
address@hidden
-(viper-add-local-keys 'vi-state '(("ZZ" .@: TeX-command-master)
-                                 ("ZQ" .@: viper-save-kill-buffer)))
address@hidden lisp
address@hidden
-redefines @kbd{ZZ} to invoke @code{TeX-command-master} in @code{vi-state}
-and @kbd{ZQ} to save-then-kill the current buffer.  These bindings take
-effect only in the buffer where this command is executed.  The typical use
-of this function is to execute the above expression from within a function
-that is included in a hook to some major mode.  For instance, the above
-expression
-could be called from a function, @code{my-tex-init}, which may be added to
address@hidden as follows:
address@hidden
-(add-hook 'tex-mode-hook 'my-tex-init)
address@hidden lisp
address@hidden
-When TeX mode starts, the hook is executed and the above Lisp expression is
-evaluated.  Then, the bindings for @kbd{ZZ} and @kbd{ZQ} are changed in Vi
-command mode for all buffers in TeX mode.
-
-Another useful application is to bind @kbd{ZZ} to @code{send-mail}
-in the Mail mode buffers (the specifics of this depend on which mail
-package you are using, @code{rmail}, @code{mh-e}, @code{vm}, etc.
-For instance, here is how to do this for @code{mh-e}, the Emacs interface
-to MH:
address@hidden
-(defun mh-add-vi-keys ()
-  "Set up ZZ for MH-e and XMH."
-  (viper-add-local-keys 'vi-state '(("ZZ" .@: mh-send-letter))))
-(add-hook 'mh-letter-mode-hook 'mh-add-vi-keys)
address@hidden lisp
-
-You can also use @code{viper-add-local-keys} to set per buffer
-bindings in Insert state and Emacs state by passing as a parameter the
-symbols @code{insert-state} and @code{emacs-state}, respectively.
-As with global bindings, customized local bindings done to Emacs state
-are not inherited by Insert state.
-
-On rare occasions, local keys may be added by mistake.  Usually this is done
-indirectly, by invoking a major mode that adds local keys (e.g.,
address@hidden redefines @key{RET}).  In such a case, exiting the wrong
-major mode won't rid you from unwanted local keys, since these keys are
-local to Viper state and the current buffer, not to the major mode.
-In such situations, the remedy is to type @kbd{M-x viper-zap-local-keys}.
-
-So much about Viper-specific bindings.
address@hidden,,Customization,emacs,The GNU Emacs
-Manual}, and the Emacs quick reference card for the general info on key
-bindings in Emacs.
-
address@hidden @code{function-key-map}
address@hidden @code{viper-vi-global-user-map}
address@hidden @code{viper-insert-global-user-map}
address@hidden @code{viper-emacs-global-user-map}
address@hidden @code{viper-add-local-keys}
address@hidden @code{viper-zap-local-keys}
-
address@hidden Packages that Change Keymaps,Viper Specials,Key 
Bindings,Customization
address@hidden Packages that Change Keymaps
address@hidden C-c and Viper
address@hidden Viper and C-c
-
-Viper is designed to coexist with all major and minor modes of Emacs.  This
-means that bindings set by those modes are generally available with Viper
-(unless you explicitly prohibit them by setting
address@hidden and @code{viper-want-emacs-keys-in-insert} to
address@hidden).
-If @code{viper-always} is set to @code{t} (which is the default), Viper
-will try to bring each buffer
-in the Viper state that is most appropriate for that buffer.
-Usually, this would be the Vi state, but sometimes it could be the Insert
-state or the Emacs state.
-
-Some major mode bindings will necessarily be overwritten by Viper.  Indeed, in
-Vi state, most of the 1-character keys are used for Vi-style editing.  This
-usually causes no problems because most packages designed for editing files
-typically do not bind such keys.  Instead, they use key sequences that start
-with @kbd{C-x} and @kbd{C-c}.  This is why it was so important for us to
-free up @kbd{C-x} and @kbd{C-c}.
-It is common for language-specific major modes to bind @key{TAB} and
address@hidden (the line feed) keys to various formatting functions.  This is
-extremely useful, but may require some getting used to for a Vi user.  If you
-decide that this feature is not for you, you can re-bind these keys as
-explained earlier (@pxref{Customization}).
-
-Binding for @key{TAB} is one of the most unusual aspects of Viper for many
-novice users.  In Emacs, @key{TAB} is used to format text and programs, and
-is extremely useful.  For instance, hitting @key{TAB} causes the current
-line to be re-indented in accordance with the context.  In programming,
-this is very important, since improper automatic indentation would
-immediately alert the programmer to a possible error.  For instance, if a
address@hidden)} or a @kbd{"} is missing somewhere above the current
-line, @key{TAB} is likely to mis-indent the line.
-
-For this reason, Viper doesn't change the standard Emacs binding of
address@hidden, thereby sacrificing Vi compatibility
-(except for users at level 1).  Instead, in Viper, the key
address@hidden (shift+ tab) is chosen to emulate Vi's @key{TAB}.
-
-We should note that on some non-windowing terminals, Shift doesn't modify
-the @key{TAB} key, so @kbd{S-tab} behaves as if it were @key{TAB}.  In such
-a case, you will have to bind @code{viper-insert-tab} to some other
-convenient key.
-
-Some packages, notably Dired, Gnus, Info, etc., attach special meaning to
-common keys like @key{SPC}, @kbd{x}, @kbd{d}, @kbd{v}, and others.  This
-means that Vi command state is inappropriate for working with these
-packages.  Fortunately, these modes operate on read-only buffers and are
-designed not for editing files, but for special-purpose browsing, reading
-news, mail, etc., and Vi commands are meaningless in these situations.  For
-this reason, Viper doesn't force Vi state on such major modes---it
-brings them in Emacs state.  You can switch to Vi state by typing @kbd{C-z}
-if, for instance, you want to do Vi-style search in a buffer (although,
-usually, incremental search, which is bound to @kbd{C-s}, is sufficient in
-these situations).  But you should then switch back to Emacs state if you
-plan to continue using these major modes productively.  You can also switch
-to Vi temporarily, to execute just one command.  This is done by typing
address@hidden \}.  (In some of these modes, @kbd{/} and @kbd{:} are bound
-Vi-style, unless these keys perform essential duties.)
-
-If you would like certain major modes to come up in Emacs state rather than
-Vi state (but Viper thinks otherwise), you should put these major modes
-on the @code{viper-emacs-state-mode-list} list and delete them from
address@hidden
-Likewise, you can force Viper's Insert state on a major mode by putting it
-in @code{viper-insert-state-mode-list}.
address@hidden @code{viper-emacs-state-mode-list}
address@hidden @code{viper-insert-state-mode-list}
address@hidden @code{viper-vi-state-mode-list}
-
-It is also possible to impose Vi on some major modes, even though they may
-bind common keys to specialized commands.  This might make sense for modes
-that bind only a small number of common keys.  For instance, Viper subverts
-the Shell mode by changing the bindings for @kbd{C-m} and @kbd{C-d} using
address@hidden described in the section on customization
-(@pxref{Customization}).
-
-In some cases, some @emph{minor} modes might override certain essential
-bindings in Vi command state.  This is not a big problem because this
-can happen only in the beginning, when the minor mode kicks in.  Typing
address@hidden viper-mode} will correct the situation.  Viper knows about
-several such minor modes and takes care of them, so the above trick
-is usually not necessary.  If you find that some minor mode, e.g.,
address@hidden interferes with Viper, putting the following in
address@hidden should fix the problem:
address@hidden
-(viper-harness-minor-mode "nasty-mode")
address@hidden lisp
address@hidden
-The argument to @code{viper-harness-minor-mode} is the name of the file for the
-offending minor mode with the suffixes @file{.el} and @file{.elc} removed.
-
-It may not be always obvious which minor mode is at fault.  The only
-guidance here is to look into the file that defines the minor mode you are
-suspecting, say @file{nasty-mode.el}, and see if it has a variable called
address@hidden  Then check if there is a statement of the form
address@hidden
-(define-key nasty-mode-map key function)
address@hidden lisp
address@hidden
-that binds the misbehaving
-keys.  If so, use the above line to harness @code{nasty-mode}.  If your
-suspicion is wrong, no harm is done if you harness a minor mode that
-doesn't need to be harnessed.
-
-It is recommended to harness even those minor modes that don't override
-Viper keys, but still have their own keymaps. A general way to
-make a minor mode, @code{my-mode},
-compatible with Viper is to have the file @file{my-mode.el} include the 
following code:
-
address@hidden
-(when (fboundp 'viper-harness-minor-mode)
-  (let ((lib (file-name-sans-extension
-               (file-name-nondirectory load-file-name))))
-    (viper-harness-minor-mode lib)))
address@hidden lisp
-
address@hidden @code{viper-want-emacs-keys-in-vi}
address@hidden @code{viper-want-emacs-keys-in-insert}
address@hidden @code{viper-always}
address@hidden @code{viper-set-hooks}
address@hidden @code{viper-mode}
address@hidden @code{viper-harness-minor-mode}
address@hidden @code{remove-hook}
address@hidden @code{add-hook}
-
address@hidden Viper Specials,Vi Macros,Packages that Change 
Keymaps,Customization
address@hidden Viper Specials
-
-Viper extends Vi with a number of useful features.  This includes various
-search functions, histories of search strings, Ex commands, insertions, and
-Vi's destructive commands.  In addition, Viper supports file name completion
-and history, completion of Ex commands and variables, and many other
-features.  Some of these features are explained in detail elsewhere in this
-document.  Other features are explained here.
-
address@hidden @code
address@hidden (viper-buffer-search-enable)
address@hidden viper-buffer-search-char nil
-Enable buffer search.  Explicit call to @code{viper-buffer-search-enable}
-sets @code{viper-buffer-search-char} to @kbd{g}.  Alternatively, the user can
-set @code{viper-buffer-search-char} in @file{.viper} to a key sequence
-to be used for buffer search.  There is no need to call
address@hidden in that case.
address@hidden @code{viper-buffer-search-enable}
address@hidden @code{viper-buffer-search-char}
address@hidden viper-toggle-search-style
-This function, bound to @kbd{C-c /}, lets one toggle case-sensitive and
-case-insensitive search, and also switch between plain vanilla search and
-search via regular expressions.  Without the prefix argument, the user is
-asked which mode to toggle.  With prefix argument 1, this toggles
-case-sensitivity.  With prefix argument 2, regular expression/vanilla search
-will be toggled.
-
-However, we found that the most convenient way to toggle
-these options is to bind a Vi macro to
-bind @kbd{//} to toggles case sensitivity and to @kbd{///} to toggles
-vanilla search.  Thus, quickly hitting @kbd{/} twice will switch Viper from
-case sensitive search to case-insensitive.  Repeating this once again will
-restore the original state.  Likewise, quickly hitting @kbd{/} three times
-will switch you from vanilla-style search to search via regular expressions.
-If you hit something other than @kbd{/} after the first @kbd{/} or if the
-second @kbd{/} doesn't follow quickly enough, then Viper will issue the
-usual prompt @kbd{/} and will wait for input, as usual in Vi.
-If you don't like this behavior, you can ``unrecord'' these macros in your
address@hidden/.viper} file.  For instance, if you don't like the above 
feature, put
-this in @file{~/.viper}:
address@hidden
-(viper-set-searchstyle-toggling-macros 'undefine)
address@hidden example
address@hidden @code{viper-set-searchstyle-toggling-macros}
-
-If you don't like this feature as a default, but would still like to have
-it in some major modes, you can do so by first unsetting it globally, as
-shown above, and then setting it in the desired major modes as follows:
address@hidden
-(viper-set-searchstyle-toggling-macros nil 'c-mode)
-(viper-set-searchstyle-toggling-macros nil 'lisp-mode)
address@hidden example
-
address@hidden Vi-isms in Emacs state
-Some people find it useful to use the Vi-style search key, `/', to invoke
-search in modes which Viper leaves in emacs-state.  These modes are:
address@hidden, @code{mh-folder-mode},
address@hidden, and @code{Buffer-menu-mode}
-(more may be added in the future).  So, in the above modes, Viper binds `/'
-so that it will behave Vi-style.  Furthermore, in those major modes, Viper
-binds `:' to invoke ex-style commands, like in vi-state.  And, as described
-above, `//' and `///' get bound to Vi-style macros that toggle
-case-insensitivity and regexp-search.
-
-If you don't like these features---which I don't really understand---you
-can unbind `/' and `:' in @code{viper-dired-modifier-map} (for Dired) or in
address@hidden, for other modes.
address@hidden @code{viper-slash-and-colon-map}
address@hidden @code{viper-dired-modifier-map}
-
-To unbind the macros `//' and `///' for a major mode where you feel they
-are undesirable, execute @code{viper-set-emacs-state-searchstyle-macros} with a
address@hidden argument.  This can be done either interactively, by supplying a
-prefix argument, or by placing
address@hidden
-(viper-set-emacs-state-searchstyle-macros 'undefine)
address@hidden example
address@hidden @code{viper-set-emacs-state-searchstyle-macros}
-in the hook to the major mode (e.g., @code{dired-mode-hook}).
address@hidden Macros}, for more information on Vi macros.
-
address@hidden viper-heading-start
address@hidden viper-heading-end
address@hidden headings
address@hidden sections
address@hidden paragraphs
address@hidden sentences
-Regular Expressions for @kbd{[[} and @kbd{]]}.  Note that Emacs defines
-Regexps for paragraphs and sentences.  @xref{Paragraphs,,Paragraphs and
-Sentences,emacs,The GNU Emacs Manual}, for details.
address@hidden M-x viper-set-expert-level
address@hidden @code{viper-set-expert-level}
-Change your user level interactively.
address@hidden viper-smart-suffix-list  '("" "tex" "c" "cc" "el" "p")
address@hidden @code{viper-smart-suffix-list}
-Viper supports Emacs-style file completion when it prompts the user for a
-file name.  However, in many cases, the same directory may contain files
-with identical prefix but different suffixes, e.g., prog.c, prog.o,
-paper.tex, paper.dvi.  In such cases, completion will stop at the `.'.
-If the above variable is a list of strings representing suffixes, Viper will
-try these suffixes
-in the order listed and will check if the corresponding file exists.
-
-For instance, if completion stopped at `paper.'@: and the user typed
address@hidden,
-then Viper will check if the files `paper.', `paper.tex', `paper.c', etc., 
exist.
-It will take the first such file.  If no file exists, Viper will give a chance
-to complete the file name by typing the appropriate suffix.  If `paper.'@: was
-the intended file name, hitting return will accept it.
-
-To turn this feature off, set the above variable to @code{nil}.
-
address@hidden viper-insertion-ring-size  14
address@hidden @code{viper-insertion-ring-size}
address@hidden Insertion ring
-Viper remembers what was previously inserted in Insert and Replace states.
-Several such recent insertions are kept in a special ring of strings of size
address@hidden
-If you enter Insert or Replace state you can reinsert strings from this
-ring by typing @kbd{C-c M-p} or @kbd{C-c M-n}.  The former will search the
-ring in
-the direction of older insertions, and the latter will search in
-the direction of newer insertions.  Hitting @kbd{C-c M-p} or @kbd{C-c M-n}
-in succession
-will undo the previous insertion from the ring and insert the next item on
-the ring.  If a larger ring size is needed, change the value of the above
-variable in the @file{~/.viper} file.
-
-Since typing these sequences of keys may be tedious, it is suggested that the
-user should bind a function key, such as @kbd{f31}, as follows:
address@hidden
-(define-key viper-insert-global-user-map [f31]
-            'viper-insert-prev-from-insertion-ring)
address@hidden example
-This binds @kbd{f31} (which is usually @kbd{R11} on a Sun workstation)
-to the function that inserts the previous string in the insertion history.
-To rotate the history in the opposite
-direction, you can either bind an unused key to
address@hidden or hit any digit (1 to 9) then
address@hidden
-
-One should not bind the above functions to @kbd{M-p} or @kbd{M-n}, since
-this will interfere with the Minibuffer histories and, possibly, other
-major modes.
-
address@hidden viper-command-ring-size  14
address@hidden @code{viper-command-ring-size}
address@hidden Destructive command ring
address@hidden Destructive command history
-Viper keeps track of the recent history of destructive
-commands, such as @kbd{dw}, @kbd{i}, etc.
-In Vi state,
-the most recent command can be re-executed by hitting address@hidden', as in 
Vi.
-However, repeated typing @kbd{C-c M-p} will cause Viper to show the
-previous destructive commands in the minibuffer.  Subsequent hitting 
address@hidden'
-will execute the command that was displayed last.
-The key @kbd{C-c M-n} will cycle through the command history in the
-opposite direction.
-Since typing @kbd{C-c M-p} may be tedious, it is more convenient to bind an
-appropriate function to an unused function key on the keyboard and use that
-key.  For instance, the following
address@hidden
-(define-key viper-vi-global-user-map [f31]
-            'viper-prev-destructive-command)
address@hidden example
-binds the key @kbd{f31} (which is usually @kbd{R11} on a Sun workstation)
-to the function that searches the command history in the direction of older
-commands.  To search in the opposite
-direction, you can either bind an unused key to
address@hidden or hit any digit (1 to 9) then @kbd{f31}.
-
-One should not bind the above functions to @kbd{M-p} or @kbd{M-n}, since
-this will interfere with the Minibuffer histories and, possibly, other
-major modes.
-
address@hidden viper-minibuffer-vi-face  'viper-minibuffer-vi-face
address@hidden viper-minibuffer-insert-face  'viper-minibuffer-insert-face
address@hidden viper-minibuffer-emacs-face  'viper-minibuffer-emacs-face
-These faces control the appearance of the minibuffer text in the
-corresponding Viper states.  You can change the appearance of these faces
-through Emacs' customization widget, which is accessible through the
-menubar.
-
-Viper is located in this widget under the @emph{Emulations} customization
-subgroup of the @emph{Editing} group.  All Viper faces are grouped together
-in Viper's @emph{Highlighting} customization subgroup.
-
-Note that only the text you type in is affected by the above faces.
-Prompts and Minibuffer messages are not affected.
-
-Purists who do not like adornments in the minibuffer can always zap them by
-putting
address@hidden
-(copy-face 'default 'viper-minibuffer-vi-face)
-(copy-face 'default 'viper-minibuffer-insert-face)
-(copy-face 'default 'viper-minibuffer-emacs-face)
address@hidden example
-in the @file{~/.viper} file or through the customization widget, as
-described above.  However, in that case, the user will not have any
-indication of the current Viper state in the minibuffer.  (This is important
-if the user accidentally switches to another Viper state by typing @key{ESC} or
address@hidden).
address@hidden M-x viper-go-away
address@hidden @code{viper-go-away}
-Make Viper disappear from the face of your running Emacs instance.  If your
-fingers start aching again, @kbd{M-x viper-mode} might save your day.
address@hidden M-x toggle-viper-mode
address@hidden @code{toggle-viper-mode}
-Toggle Viperization of Emacs on and off.
address@hidden table
-
address@hidden Multifile documents and programs
-
-Viper provides some support for multi-file documents and programs.
-If a document consists of several files we can designate one of them as a
-master and put the following at the end of that file:
address@hidden
-;; Local Variables:
-;; eval: (viper-setup-master-buffer "file1" "file2" "file3" "file4")
-;; End:
address@hidden lisp
address@hidden
-where @code{file1} to @code{file4} are names of files related to the master
-file.  Next time, when the master file is visited, the command
address@hidden will be evaluated and the above files will
-be associated with the master file.  Then, the new Ex command
address@hidden:RelatedFile} (abbr.@: @kbd{:R}) will display files 1 to 4 one 
after
-another, so you can edit them.  If a file is not in any Emacs buffer, it
-will be visited.  The command @kbd{PreviousRelatedFile} (abbr., @kbd{:P})
-goes through the file list in the opposite direction.
address@hidden @kbd{:RelatedFile}
address@hidden @kbd{:PreviousRelatedFile}
-
-These commands are akin to @kbd{:n} and @kbd{:N}, but they allow the user to
-focus on relevant files only.
-
-Note that only the master file needs to have the aforementioned block of
-commands.  Also, ";;" above can be replaced by some other
-markers.  Semicolon is good for Lisp programs, since it is considered a
-comment designator there.  For LaTeX, this could be "%%%", and for C the
-above block should be commented out.
-
-Even though these commands are sometimes useful, they are no substitute for
-the powerful @emph{tag table} facility of Emacs.  Viper's @kbd{:tag} command
-in a primitive interface to Emacs tags.  @xref{Tags,Tags,Tags,emacs,
-The GNU Emacs Manual}, for more information on tags.
-
-The following two commands are normally bound to a mouse click and are part
-of Viper.  They work only if Emacs runs as an application under X
-Windows (or under some other window system for which a port of GNU Emacs 20
-is available).  Clicking the mouse when Emacs is invoked in an Xterm window
-(using @code{emacs -nw}) will do no good.
-
address@hidden @code
address@hidden mouse
address@hidden mouse-search
address@hidden viper-mouse-search-key  (meta shift 1)
address@hidden @code{viper-mouse-insert-key}
-This variable controls the @emph{mouse-search} feature of Viper.  The
-default value
-states that holding Meta and Shift keys while clicking mouse button 1
-should initiate search for a region under the mouse pointer (defined
-below).  This command can take a prefix argument, which indicates the
-occurrence of the pattern to search for.
-
-Note: while loading initially, Viper binds this mouse action only if it is
-not already bound to something else.  If you want to use the mouse-search
-feature, and the @kbd{Meta-Shift-Mouse-1} mouse action is already bound to
-something else, you can rebind the mouse-search feature by setting
address@hidden to something else in your @code{~/.viper}
-file:
address@hidden
-(setq viper-mouse-search-key '(meta 1))
address@hidden lisp
-This would bind mouse search to the action invoked by pressing the
-Meta key and clicking mouse button 1.  The allowed values of
address@hidden are lists that contain a mouse-button number
-(1,2, or 3) and any combination of the words `control', `meta', and
-`shift'.
-
-If the requested mouse action (e.g., (meta 1)) is already taken for other
-purposes then you have to confirm your intention by placing the following
-command in @code{~/.viper} after setting @code{viper-mouse-search-key}:
address@hidden
-(viper-bind-mouse-search-key 'force)
address@hidden lisp
-
-You can also change this setting interactively, through the customization
-widget of Emacs (type @kbd{:customize}).
-
-The region that is chosen as a pattern to search for is determined as
-follows.  If search is invoked via a single click, Viper chooses the region
-that lies between the beginning of the ``word'' under the pointer (``word''
-is understood in Vi sense) and the end of that word.  The only difference
-with Vi's words is that in Lisp major modes `-' is considered an
-alphanumeric symbol.  This is done for the convenience of working with Lisp
-symbols, which often have an `-' in them.  Also, if you click on a
-non-alphanumeric character that is not a word separator (in Vi sense) then
-this character will also be considered alphanumeric, provided that it is
-adjacent (from either side) to an alphanumeric character.  This useful
-feature gives added control over the patterns selected by the mouse click.
-
-On a double-click, the region is determined by the beginning of the current
-Vi's ``Word'' (i.e., the largest non-separator chunk of text) and the End
-of that ``Word'' (as determined by the @kbd{E} command).
-
-On a triple-click, the region consists of the entire line where the click
-occurred with all leading and trailing spaces and tabs removed.
-
address@hidden mouse-insert
address@hidden viper-mouse-insert-key (meta shift 2)
address@hidden @code{viper-mouse-insert-key}
-This variable controls the @emph{mouse-insert} feature of Viper.
-The above default value states that
-holding Meta and Shift keys while clicking mouse button 2
-should insert the region surrounding the
-mouse pointer.  The rules defining this region are the same as for
-mouse-search.  This command takes an optional prefix argument, which
-indicates how many such regions to snarf from the buffer and insert.  (In
-case of a triple-click, the prefix argument is ignored.)
-
-Note: while loading initially, Viper binds this mouse action only if it not
-already bound to something else.  If you want to use this feature and the
-default mouse action is already bound, you can rebind mouse-insert by
-placing this command in @code{~/.viper}:
address@hidden
-(setq viper-mouse-insert-key '(meta 2))
address@hidden lisp
-If you want to bind mouse-insert to an action even if this action is
-already taken for other purposes in Emacs, then you should add this command
-to @code{~/.viper}, after setting @code{viper-mouse-insert-key}:
address@hidden
-(viper-bind-mouse-insert-key 'force)
address@hidden lisp
-
-This value can also be changed via the Emacs customization widget at the
-menubar.
-
address@hidden viper-multiclick-timeout
-This variable controls the rate at which double-clicking must occur for the
-purpose of mouse search and mouse insert.  By default, this is set to
address@hidden in Emacs and to
address@hidden milliseconds in XEmacs.
address@hidden table
address@hidden @kbd{S-Mouse-1}
address@hidden @kbd{S-Mouse-2}
address@hidden @kbd{meta shift button1up}
address@hidden @kbd{meta shift button2up}
address@hidden @code{viper-multiclick-timeout}
address@hidden @code{viper-mouse-click-insert-word}
address@hidden @code{viper-mouse-click-search-word}
-
-Note: The above functions search and insert in the selected window of
-the latest active frame.  This means that you can click in another window or
-another frame and have search or insertion done in the frame and window you
-just left.  This lets one use these functions in a multi-frame
-configuration.  However, this may require some getting used to.  For
-instance, if you are typing in a frame, A, and then move the mouse to frame
-B and click to invoke mouse search, search (or insertion) will be performed
-in frame A.  To perform search/insertion in frame B, you will first have to
-shift focus there, which doesn't happen until you type a character or
-perform some other action in frame B---mouse search doesn't shift focus.
-
-If you decide that you don't like the above feature and always want
-search/insertion be performed in the frame where the click occurs, don't
-bind (and unbind, if necessary) @code{viper-mouse-catch-frame-switch} from
-the mouse event it is bound to.
-
-Mouse search is integrated with Vi-style search, so you can
-repeat it with @kbd{n} and @kbd{N}.  It should be also noted that, while
-case-sensitivity of search in Viper is controlled by the variable
address@hidden, the case of mouse search is
-controlled by the Emacs variable @code{case-fold-search}, which may be set
-differently from @code{viper-case-fold-search}.  Therefore, case-sensitivity
-of mouse search may be different from that of the usual Vi-style search.
-
-Finally, if the way Viper determines the word to be searched for or to be
-inserted is not what you want, there is a variable,
address@hidden, which can be changed to indicate
-another function for snarfing words out of the buffer.  The catch is that
-you will then have to write such a function and make it known to your
-Emacs.  The function @code{viper-surrounding-word} in @file{viper.el} can be
-used as a guiding example.
-
address@hidden Vi Macros, ,Viper Specials,Customization
address@hidden Vi Macros
-
address@hidden Vi macros
-
-Viper supports much enhanced Vi-style macros and also facilitates the use
-of Emacs-style macros.  To define a temporary macro, it is generally more
-convenient to use Emacs keyboard macro facility.  Emacs keyboard macros are
-usually defined anonymously, and the latest macro can be executed by typing
address@hidden e} (or @kbd{*}, if Viper is in Vi state).  If you need to use 
several
-temporary macros, Viper lets you save them to a
-register (a lowercase letter); such macros can then be executed by typing
address@hidden@@a} in Vi state (if a macro was previously saved in register
address@hidden).
address@hidden and Registers}, for details.
-
-If, however, you need to use a macro regularly, it must be given a
-permanent name and saved.  Emacs manual explains how to do this, but
-invocation of named Emacs macros is quite different from Vi's.  First,
-invocation of permanent Emacs macros takes time because it requires typing
-too many keys (to  a Vi user's taste, anyway).
-Second, binding such macros to function keys, for
-fast access, hogs valuable real estate on the keyboard.
-
-Vi-style macros are better in that respect, since Vi lets the user overload
-the meaning of key sequences: keys typed in fast succession are treated
-specially, if this key sequence is bound to a macro.
-
-Viper provides Vi-style keyboard macros through the usual Ex commands,
address@hidden:map} and
address@hidden:map!}.  These macros are much more powerful in Viper than
-they are in the original Vi and in other emulators.  This is because Viper
-implements an enhanced vi-style
-interface to the powerful Emacs keyboard macro facility.
-
-First, any Emacs
-command can be executed while defining a macro, not just the Vi
-commands.  In particular, the user can invoke Emacs commands via @kbd{M-x
-command-name} or by pressing various function keys on the keyboard.  One
-can even use the mouse, although this is usually not useful and is not
-recommended (and macros defined with the use of the mouse cannot be saved in
-command history and in the startup file, for future use).
-
-Macros defined by mixing Vi and Emacs commands are represented as
-vectors.  So, don't be confused when you see one (usually through the
-history of Ex commands).  For instance, if @kbd{gg} is defined by typing
address@hidden, the up-arrow key and @kbd{M-x next-line}, its definition will 
look
-as follows in Emacs:
-
address@hidden
-[l up (meta x) n e x t - l i n e return]
address@hidden example
-
-Second, Viper macros are defined in a WYSIWYG style.  This means that
-commands are executed as you type them, so you can see precisely what is
-being defined.  Third, macros can be bound to arbitrary sequences of keys,
-not just to printable keys.  For instance, one can define a macro that will
-be invoked by hitting @kbd{f3} then @kbd{f2} function keys.  (The keys
address@hidden and @kbd{backspace} are excluded; also, a macro invocation
-sequence can't start with @key{ESC}.  Some other keys, such as @kbd{f1} and
address@hidden, can't be bound to macros under Emacs, since they
-are bound in @code{key-translation-map}, which overrides any other binding
-the user gives to keys.  In general, keys that have a binding in
address@hidden can't be bound to a macro.)
-
-Fourth, in Viper, one can define macros that are specific to a given
-buffer, a given major mode, or macros that are defined for all buffers.  In
-fact, the same macro name can have several different definitions: one
-global, several definitions for various major modes, and
-definitions for various specific buffers.  Buffer-specific definitions
-override mode-specific definitions, which, in turn, override global
-definitions.
-
-As if all that is not enough, Viper (through its interface to Emacs
-macros) lets the user define keyboard macros that ask for confirmation or
-even prompt the user for input and then continue.  To do this, one should
-type @kbd{C-x q} (for confirmation) or @kbd{C-u C-x q} (for prompt).
-For details, @pxref{Keyboard Macro Query,,Customization,emacs,The GNU Emacs
-Manual} @refill
-
-When the user finishes defining a macro (which is done by typing @kbd{C-x)} ---
-a departure from Vi), you will be asked whether you want this
-macro to be global, mode-specific, or buffer-specific.  You will also be
-given a chance to save the macro in your @file{~/.viper} file.
-This is the easiest way to save a macro and make
-it permanently available.  If you work your startup files with bare hands,
-here is how Viper saves the above macro so that it will be
-available in Viper's Insert state (and Replace state) in buffer @code{my-buf}
-only:
-
address@hidden
-(viper-record-kbd-macro "gg" 'insert-state
-       [l up (meta x) n e x t - l i n e return]
-       "my-buf")
address@hidden example
-
address@hidden
-To do the same for Vi state and all buffers with the major mode
address@hidden, use:
-
address@hidden
-(viper-record-kbd-macro "gg" 'vi-state
-       [l up (meta x) n e x t - l i n e return]
-       'cc-mode)
address@hidden example
-
address@hidden
-Both macro names and macro definitions are vectors of symbols that denote
-keys on the keyboard.  Some keys, like @kbd{\}, @kbd{ }, or digit-keys must
-be escaped with a backslash.  Modified keys are represented as lists.  For
-instance, holding Meta and Control and pressing @kbd{f4} is represented as
address@hidden(control meta f4)}.
-If all members of a vectors are printable characters (or sequences, such as
address@hidden, @kbd{\t}, for @key{ESC} and @key{TAB}), then they can also be 
represented as
-strings:
-
address@hidden
-(viper-record-kbd-macro "aa" 'vi-state  "aaa\e"  "my-buffer")
address@hidden example
-
address@hidden
-Thus, typing @kbd{aa} fast in Vi state will switch Viper to Insert state
-(due to the first @kbd{a}), insert @kbd{aa}, and then it will switch back to Vi
-state.  All this will take effect only in the buffer named @code{my-buffer}.
-
-Note that the last argument to @code{viper-record-kbd-macro} must be either a
-string (a buffer name), a symbol representing a major mode, or @code{t};
-the latter says that the macro is to be defined for all buffers
-(which is how macros are defined in original Vi).
-
-For convenience, Viper also lets you define Vi-style macros in its Emacs
-state.  There is no Ex command, like @kbd{:map} and @kbd{:map!} for doing
-this, but the user can include such a macro in the @file{~/.viper} file.  The
-only thing is that the @code{viper-record-kbd-macro} command should specify
address@hidden instead of @code{vi-state} or @code{insert-state}.
-
-The user can get rid of a macro either by using the Ex commands @kbd{:unmap}
-and @kbd{:unmap!} or by issuing a call to @code{viper-unrecord-kbd-macro}.
-The latter is more powerful, since it can delete macros even in
address@hidden  However, @code{viper-unrecord-kbd-macro} is usually
-needed only when the user needs to get rid of the macros that are already
-predefined in Viper.
-The syntax is:
address@hidden @code{viper-unrecord-kbd-macro}
address@hidden
-(viper-unrecord-kbd-macro macro state)
address@hidden example
address@hidden
-The second argument must be @code{vi-state}, @code{insert-state}, or
address@hidden  The first argument is a name of a macro.  To avoid
-mistakes in specifying names of existing macros, type @kbd{M-x
-viper-describe-kbd-macros} and use a name from the list displayed by this
-command.
-
-If an error occurs during macro definition, Emacs
-aborts the process, and it must be repeated.  This is analogous to Vi,
-except that in Vi the user doesn't know there is an error until the macro is
-actually run.  All that means that in order for a definition to be
-successful, the user must do some simple planning of the process in
-advance, to avoid errors.  For instance, if you want to map @kbd{gg} to
address@hidden in Vi state, you must make sure that there is enough room on the
-current line.  Since @kbd{l} moves the cursor forward, it may signal an
-error on reaching the end of line, which will abort the definition.
-
-These precautions are necessary only when defining macros; they will help
-avoid the need to redo the job.  When macros are actually run, an error
-during the execution will simply terminate the current execution
-(but the macro will remain mapped).
-
-A macro name can be a string of characters or a vector of keys.
-The latter makes it possible to define macros bound to, say, double-hits
-on a function key, such as @kbd{up} or @kbd{f13}.
-This is very useful if you run out of function keys on your keyboard; it
-makes Viper macro facility a @emph{keyboard doubler}, so to speak.
-
-Elsewhere (@xref{Key Bindings}, for details), we review
-the standard Emacs mechanism for binding function keys to commands.
-For instance,
-
address@hidden
-(global-set-key [f13] 'repeat-complex-command)
address@hidden example
-
address@hidden
-binds the key f13 to the Emacs function that repeats the last minibuffer
-command.  Under Viper, however, you may still use this key for additional
-purposes, if you bind, say, a double-hitting action for that key to some
-other function.  Emacs doesn't allow the user to do that, but Viper does
-this through its keyboard macro facility.  To do this, type @kbd{:map }
-first.  When you are asked to enter a macro name, hit f13 twice, followed by
address@hidden or @key{SPC}.
-
-Emacs will now start the mapping process by actually executing
-Vi and Emacs commands, so that you could see what will happen each time the
-macro is executed.  Suppose now we wanted to bind the key sequence
address@hidden f13} to the command @code{eval-last-sexp}.  To accomplish this, 
we
-can type @kbd{M-x eval-last-sexp} followed by @kbd{C-x )}.
-If you answer positively to Viper's offer to save this macro in @file{~/.viper}
-for future uses, the following will be inserted in that file:
-
address@hidden
-(viper-record-kbd-macro [f16 f16] 'vi-state
-         [(meta x) e v a l - l a s t - s e x p]
-         'lisp-interaction-mode)
address@hidden example
-
-To illustrate the above point, Viper provides two canned macros, which, by
-default, are bound to @kbd{[f12 \1]} and @kbd{[f12 \2]} (invoked by typing
address@hidden then @kbd{1} and @kbd{2}, respectively).  These macros are useful
-shortcuts to Viper's command ring history.  The first macro will execute the
-second-last destructive command (the last one is executed by @kbd{.}, as
-usual).  The second macro executes the third-last command.
-
-If you need to go deeper into the command history, you will have to use
-other commands, as described earlier in this section; or you can bind,
-say, @kbd{f12 \3} like this:
-
address@hidden
-(viper-record-kbd-macro [f12 \3] 'vi-state
-                      [(meta x) r e p e a t - f r o m - h i s t o r y]
-                      t)
address@hidden example
-
-
-Note that even though the macro uses the function key @kbd{f12}, the key is
-actually free and can still be bound to some Emacs function via
address@hidden or @code{global-set-key}.
-
-
-Viper allows the user to define macro names that are prefixes of other macros.
-For instance, one can define @kbd{[[} and @kbd{[[[[} to be macros.
-If you type the exact sequence of such keys and then pause, Viper will
-execute the right macro.  However, if you don't pause and, say, type
address@hidden then the conflict is resolved as follows.  If only one of the
-key sequences, @kbd{[[} or @kbd{[[[[} has a definition applicable to the
-current buffer, then, in fact, there is no conflict and the right macro
-will be chosen.  If both have applicable definitions, then the first one
-found will be executed.  Usually this is the macro with a shorter name.  So,
-in our case, @kbd{[[[[text} will cause the macro @kbd{[[} to be executed
-twice and then the remaining keys, @kbd{t e x t}, will be processed.
-
-When defining macros using @kbd{:map} or @kbd{:map!}, the user enters
-the actually keys to be used to invoke the macro.  For instance, you
-should hit the actual key @kbd{f6} if it is to be part of a macro
-name; you do @emph{not} write @kbd{f 6}.  When entering keys, Viper
-displays them as strings or vectors (e.g., @code{"abc"} or @code{[f6
-f7 a]}).  The same holds for unmapping.  Hitting @key{TAB} while
-typing a macro name in the @kbd{:unmap} or @kbd{:unmap!} command will
-cause name completion.  Completions are displayed as strings or
-vectors.  However, as before, you don't actually type @samp{"},
address@hidden, or @samp{]} that appear in the completions.  These are
-meta-symbols that indicate whether the corresponding macro name is a
-vector or a string.
-
-One last difference from Vi: Vi-style keyboard macros cannot be defined in
-terms of other Vi-style keyboard macros (but named Emacs macros are OK).
-More precisely, while defining or executing a macro, the special meaning
-of key sequences (as Vi macros) is ignored.
-This is because it is all too easy to create an infinite loop in this way.
-Since Viper macros are much more powerful than Vi's it is impossible to
-detect such loops.  In practice, this is not really a limitation but,
-rather, a feature.
-
-We should also note that Vi macros are disabled in the Minibuffer, which
-helps keep some potential troubles away.
-
-The rate at which the user must type keys in order for them to be
-recognized as a timeout macro is controlled by the variable
address@hidden, which defaults to 200 milliseconds.
-
-For the most part, Viper macros defined in @file{~/.viper} can be shared
-between X and TTY modes.
-The problem with TTY may be that the function keys there generate sequences
-of events instead of a single event (as under a window system).
-Emacs maps some of these sequences back to the logical keys
-(e.g., the sequences generated by the arrow keys are mapped to @kbd{up},
address@hidden, etc.).  However, not all function keys are mapped in this way.
-Macros that are bound to key sequences that contain such unmapped function
-keys have to be redefined for TTY's (and possibly for every type of TTY you
-may be using).  To do this, start Emacs on an appropriate TTY device and
-define the macro using @kbd{:map}, as usual.
-
address@hidden @code{viper-describe-kbd-macros}
-Finally, Viper provides a function that conveniently displays all macros
-currently defined.  To see all macros along with their definitions, type
address@hidden viper-describe-kbd-macros}.
-
address@hidden Commands,,Customization,Top
address@hidden Commands
-
-This section is a semi-automatically bowdlerized version of the Vi
-reference created by @* @samp{maart@@cs.vu.nl} and others.  It can be
-found on the Vi archives.  This reference has been adapted for address@hidden
-
address@hidden
-* Groundwork::                 Textual Conventions and Viper basics
-* Text Handling::              Moving, Editing, Undoing.
-* Display::                    Scrolling.
-* File and Buffer Handling::   Editing, Writing and Quitting.
-* Mapping::                    Mapping Keys, Keyboard Macros
-* Shell Commands::             Accessing Shell Commands, Processing Text
-* Options::                    Ex options, the @kbd{:set} commands
-* Emacs Related Commands::     Meta Keys, Windows
-* Mouse-bound Commands::        Search and insertion of text
address@hidden menu
-
address@hidden Groundwork, Text Handling, Commands, Commands
address@hidden  node-name,  next,  previous,  up
address@hidden Groundwork
-
-The VI command set is based on the idea of combining motion commands
-with other commands.  The motion command is used as a text region
-specifier for other commands.
-We classify motion commands into @dfn{point commands} and
address@hidden address@hidden
-
address@hidden point commands
-
-The point commands are:
-
address@hidden
address@hidden, @kbd{l}, @kbd{0},  @kbd{$}, @kbd{w}, @kbd{W}, @kbd{b}, @kbd{B},
address@hidden, @kbd{E}, @kbd{(}, @kbd{)}, @kbd{/}, @kbd{?}, @kbd{`}, @kbd{f},
address@hidden, @kbd{t}, @kbd{T}, @kbd{%}, @kbd{;}, @kbd{,}, @kbd{^}
address@hidden quotation
-
address@hidden line commands
-
-The line commands are:
-
address@hidden
address@hidden, @kbd{k}, @kbd{+}, @kbd{-}, @kbd{H}, @kbd{M}, @kbd{L}, 
@address@hidden,
address@hidden@}}, @kbd{G}, @kbd{'},  @kbd{[[}, @kbd{]]}, @kbd{[]}
address@hidden quotation
address@hidden
-
-Text Deletion Commands (@pxref{Deleting Text}), Change commands
-(@pxref{Changing Text}), even Shell Commands (@pxref{Shell Commands})
-use these commands to describe a region of text to operate on.
-
address@hidden r and R region specifiers
-
-Viper adds two region descriptors, @kbd{r} and @kbd{R}.  These describe
-the Emacs regions (@pxref{Basics}), but they are not movement commands.
-
-The command description uses angle brackets @samp{<>} to indicate
-metasyntactic variables, since the normal conventions of using simple
-text can be confusing with Viper where the commands themselves are
-characters.  Watch out where @kbd{<} shift commands and @kbd{<count>} are
-mentioned together!!!
-
address@hidden <move>
address@hidden <a-z>
address@hidden <address>
address@hidden <move>
address@hidden <a-z>
address@hidden <address>
address@hidden movements
-
address@hidden<move>} refers to the above movement commands, and @samp{<a-z>}
-refers to registers or textmarkers from @samp{a} to @samp{z}.  Note
-that the @samp{<move>}  is described by full move commands, that is to
-say they will take counts, and otherwise behave like normal move commands.
address@hidden Ex addresses
address@hidden<address>} refers to Ex line addresses, which include
-
address@hidden @kbd
address@hidden .@: <No address>
-Current line
address@hidden .+n .-n
-Add or subtract for current line
address@hidden number
-Actual line number, use @kbd{.=} to get the line number
address@hidden '<a-z>
-Textmarker
address@hidden $
-Last line
address@hidden x,y
-Where x and y are one of the above
address@hidden %
address@hidden % (Ex address)
-For the whole file, same as (1,$).
address@hidden /<pat>/
address@hidden ?<pat>?
-Next or previous line with pattern <pat>.
-
-Note that the pattern is allowed to contain newline character (inserted as
address@hidden).  Therefore, one can search for patterns that span several
-lines.
address@hidden table
-
address@hidden % (Current file)
-Note that @samp{%} is used in Ex commands @kbd{:e} and @kbd{:r <shell-cmd>}
-to mean current file.  If you want a @samp{%} in your command, it must be
-escaped as @samp{\%}. Note that @kbd{:w} and the regular @kbd{:r <file>}
-command doesn't support the meta symbols @samp{%} and @samp{#}, because
-file history is a better mechanism.
address@hidden # (Previous file)
-Similarly, @samp{#} expands to the previous file.  The previous file is
-the first file in @kbd{:args} listing.  This defaults to previous window
-in the VI sense if you have one window only.
-
address@hidden <args>
address@hidden <cmd>
address@hidden <args>
address@hidden <cmd>
address@hidden
-Others like @samp{<args> -- arguments}, @samp{<cmd> -- command} etc.
-should be fairly obvious.
-
address@hidden
-Common characters referred to include:
-
address@hidden @kbd
address@hidden <sp>
-Space
address@hidden <ht>
-Tab
address@hidden <lf>
-Linefeed
address@hidden <esc>
-Escape
address@hidden <cr>
-Return, Enter
address@hidden table
address@hidden <cr>
address@hidden <esc>
address@hidden <lf>
address@hidden <ht>
address@hidden <sp>
-
address@hidden words
address@hidden WORDS
address@hidden char
address@hidden CHAR
-
-We also use @samp{word} for alphanumeric/non-alphanumeric words, and
address@hidden for whitespace delimited words.  @samp{char} refers to any
address@hidden character, @samp{CHAR} to non-whitespace character.
-Brackets @samp{[]} indicate optional parameters; @samp{<count>} also
-optional, usually defaulting to 1.  Brackets are elided for
address@hidden<count>} to eschew obfuscation.
-
-Viper's idea of Vi's words is slightly different from Vi.  First, Viper
-words understand Emacs symbol tables.  Therefore, all symbols declared to be
-alphanumeric in a symbol table can automatically be made part of the Viper
-word.  This is useful when, for instance, editing text containing European,
-Cyrillic, Japanese, etc., texts.
-
-Second, Viper lets you depart from Vi's idea of a word by changing the a
-syntax preference via the customization widget (the variable
address@hidden) or by executing
address@hidden interactively.
-
-By default, Viper syntax preference is @code{reformed-vi}, which means that
-Viper considers only those symbols to be part of a word that are specified
-as word-symbols by the current Emacs syntax table (which may be different
-for different major modes) plus the underscore symbol @kbd{_}, minus the
-symbols that are not considered words in Vi (e.g., `,',;, etc.), but may be
-considered as word-symbols by various Emacs major modes.  Reformed-Vi works
-very close to Vi, and it also recognizes words in other
-alphabets.  Therefore, this is the most appropriate mode for editing text
-and is likely to fit all your needs.
-
-You can also set Viper syntax preference to @code{strict-vi}, which would
-cause Viper to view all non-English letters as non-word-symbols.
-
-You can also specify @code{emacs} as your preference, which would
-make Viper use exactly the same notion of a word as Emacs does.  In
-particular, the underscore may not be part of a word in some major modes.
-
-Finally, if @code{viper-syntax-preference} is set to @code{extended}, Viper
-words would consist of characters that are classified as alphanumeric
address@hidden as parts of symbols.  This is convenient for editing programs.
-
address@hidden is a local variable, so it can have different
-values for different major modes.  For instance, in programming modes it can
-have the value @code{extended}.  In text modes where words contain special
-characters, such as European (non-English) letters, Cyrillic letters, etc.,
-the value can be @code{reformed-vi} or @code{emacs}.
-If you consider using different syntactic preferences for different major
-modes, you should execute, for example,
-
address@hidden
-(viper-set-syntax-preference nil "extended")
address@hidden example
-
-in the appropriate major mode hooks.
-
address@hidden @code{viper-syntax-preference}
address@hidden @code{viper-set-syntax-preference}
address@hidden syntax table
-
-
-
-The above discussion concerns only the movement commands.  In regular
-expressions, words remain the same as in Emacs.  That is, the expressions
address@hidden, @code{\>}, @code{\<}, etc., use Emacs' idea of what is a word,
-and they don't look into the value of variable
address@hidden  This is because Viper avoids changing
-syntax tables in order to not thwart the various major modes that set these
-tables.
-
-The usual Emacs convention is used to indicate Control Characters, i.e
-C-h for Control-h.  @emph{Do not confuse this with a sequence of separate
-characters
-C, -, h!!!} The @kbd{^} is itself, never used to indicate a
-Control character.
-
-Finally, we note that Viper's Ex-style commands can be made to work on the
-current Emacs region.  This is done by typing a digit argument before
address@hidden:}.  For instance, typing @kbd{1:} will prompt you with something 
like
address@hidden:123,135}, assuming that the current region starts at line 123 and
-ends at line 135.  There is no need to type the line numbers, since Viper
-inserts them automatically in front of the Ex command.
address@hidden Ex commands
-
address@hidden Text Handling, Display, Groundwork, Commands
address@hidden Text Handling
-
address@hidden
-* Move Commands::              Moving, Searching
-* Marking::                    Textmarkers in Viper and the Emacs Mark.
-* Appending Text::             Text insertion, Shifting, Putting
-* Editing in Insert State::    Autoindent, Quoting etc.
-* Deleting Text::              Deleting
-* Changing Text::              Changing, Replacement, Joining
-* Search and Replace::         Searches, Query Replace, Pattern Commands
-* Yanking::                    Yanking, Viewing Registers
-* Undoing::                    Multiple Undo, Backups
address@hidden menu
-
address@hidden Move Commands,Marking,,Text Handling
address@hidden Move Commands
-
address@hidden movement commands
address@hidden searching
address@hidden textmarkers
address@hidden markers
address@hidden column movement
address@hidden paragraphs
address@hidden headings
address@hidden sections
address@hidden sentences
address@hidden matching parens
address@hidden paren matching
-
address@hidden @kbd
address@hidden <count>  h  C-h
-<count> chars to the left.
address@hidden <count>  j  <lf> C-n
-<count> lines downward.
address@hidden <count>  l  <sp>
-<count> chars to the right.
address@hidden <count>  k  C-p
-<count> lines upward.
address@hidden <count>  $
-To the end of line <count> from the cursor.
address@hidden <count>  ^
-To the first CHAR <count> - 1 lines lower.
address@hidden <count>  -
-To the first CHAR <count> lines higher.
address@hidden <count>  +  <cr>
-To the first CHAR <count> lines lower.
address@hidden  0
-To the first char of the line.
address@hidden <count> |
-To column <count>
address@hidden <count>  f<char>
-<count> <char>s to the right (find).
address@hidden <count>  t<char>
-Till before <count> <char>s to the right.
address@hidden <count>  F<char>
-<count> <char>s to the left.
address@hidden <count>  T<char>
-Till after <count> <char>s to the left.
address@hidden <count>  ;
-Repeat latest @kbd{f t F T} <count> times.
address@hidden <count>  ,
-Repeat latest @kbd{f t F T}
-<count> times in opposite direction.
address@hidden <count>  w
-<count> words forward.
address@hidden <count>  W
-<count> WORDS forward.
address@hidden <count>  b
-<count> words backward.
address@hidden <count>  B
-<count> WORDS backward.
address@hidden <count>  e
-To the end of word <count> forward.
address@hidden <count>  E
-To the end of WORD <count> forward.
address@hidden <count>  G
-Go to line <count> (default end-of-file).
address@hidden <count>  H
-To line <count> from top of the screen (home).
address@hidden <count>  L
-To line <count> from bottom of the screen (last).
address@hidden  M
-To the middle line of the screen.
address@hidden <count>  )
-<count> sentences forward.
address@hidden <count>  (
-<count> sentences backward.
address@hidden <count>  @}
-<count> paragraphs forward.
address@hidden <count>  @{
-<count> paragraphs backward.
address@hidden <count>  ]]
-To the <count>th heading.
address@hidden <count>  [[
-To the <count>th previous heading.
address@hidden <count>  []
-To the end of <count>th heading.
address@hidden  m<a-z>
-Mark the cursor position with a letter.
address@hidden  `<a-z>
-To the mark.
address@hidden  '<a-z>
-To the first CHAR of the line with the mark.
address@hidden [<a-z>
-Show contents of textmarker.
address@hidden ]<a-z>
-Show contents of register.
address@hidden  ``
-To the cursor position before the latest absolute
-jump (of which are examples @kbd{/} and @kbd{G}).
address@hidden  ''
-To the first CHAR of the line on which the cursor
-was placed before the latest absolute jump.
address@hidden <count>  /<string>
-To the <count>th occurrence of <string>.
address@hidden <count>  /<cr>
-To the <count>th occurrence of <string> from previous @kbd{/ or ?}.
address@hidden <count>  ?<string>
-To the <count>th previous occurrence of <string>.
address@hidden <count>  ?<cr>
-To the <count>th previous occurrence of <string> from previous @kbd{?@: or /}.
address@hidden  n
-Repeat latest @kbd{/} @kbd{?} (next).
address@hidden  N
-Repeat latest search in opposite direction.
address@hidden C-c /
-Without a prefix argument, this command toggles
-case-sensitive/case-insensitive search modes and plain vanilla/regular
-expression search.  With the prefix argument 1, i.e.,
address@hidden C-c /}, this toggles case-sensitivity; with the prefix argument 
2,
-toggles plain vanilla search and search using
-regular expressions.  @xref{Viper Specials}, for alternative ways to invoke
-this function.
address@hidden vanilla search
address@hidden case-sensitive search
address@hidden case-insensitive search
address@hidden  %
-Find the next bracket/parenthesis/brace and go to its match.
-By default, Viper ignores brackets/parentheses/braces that occur inside
-parentheses.  You can change this by setting
address@hidden to @code{nil} in your @file{.viper} file.
-This option can also be toggled interactively if you quickly hit @kbd{%%%}.
-
-This latter feature is implemented as a vi-style keyboard macro.  If you
-don't want this macro, put
-
address@hidden
-(viper-set-parsing-style-toggling-macro 'undefine)
address@hidden example
address@hidden @code{viper-set-parsing-style-toggling-macro}
-
-in your @file{~/.viper} file.
-
address@hidden table
address@hidden @kbd{%}
address@hidden @kbd{C-c /}
address@hidden @kbd{N}
address@hidden @kbd{n}
address@hidden @kbd{?<cr>}
address@hidden @kbd{/<cr>}
address@hidden @kbd{?<string>}
address@hidden @kbd{/<string>}
address@hidden @kbd{''}
address@hidden @kbd{``}
address@hidden @kbd{]<a-z>}
address@hidden @kbd{[<a-z>}
address@hidden @kbd{'<a-z>}
address@hidden @kbd{`<a-z>}
address@hidden @kbd{m<a-z>}
address@hidden @kbd{[]}
address@hidden @kbd{[[}
address@hidden @kbd{]]}
address@hidden @address@hidden
address@hidden @address@hidden
address@hidden @kbd{(}
address@hidden @kbd{)}
address@hidden @kbd{M}
address@hidden @kbd{L}
address@hidden @kbd{H}
address@hidden @kbd{G}
address@hidden @kbd{E}
address@hidden @kbd{e}
address@hidden @kbd{B}
address@hidden @kbd{b}
address@hidden @kbd{W}
address@hidden @kbd{w}
address@hidden @kbd{,}
address@hidden @kbd{;}
address@hidden @kbd{T<char>}
address@hidden @kbd{F<char>}
address@hidden @kbd{t<char>}
address@hidden @kbd{f<char>}
address@hidden @kbd{|}
address@hidden @kbd{0}
address@hidden @kbd{<cr>}
address@hidden @kbd{+}
address@hidden @kbd{-}
address@hidden @kbd{^}
address@hidden @kbd{$}
address@hidden @kbd{C-p}
address@hidden @kbd{<lf>}
address@hidden @kbd{<sp>}
address@hidden @kbd{C-n}
address@hidden @kbd{C-h}
address@hidden @kbd{h}
address@hidden @kbd{j}
address@hidden @kbd{k}
address@hidden @kbd{l}
address@hidden @code{viper-parse-sexp-ignore-comments}
-
address@hidden Marking,Appending Text,Move Commands,Text Handling
address@hidden Marking
-
-Emacs mark is referred to in the region specifiers @kbd{r} and @kbd{R}.
address@hidden Preliminaries}, and @xref{Basics}, for explanation.  Also
-see @ref{Mark,,Mark,emacs,The GNU Emacs manual}, for an explanation of
-the Emacs mark ring.
-
address@hidden marking
-
address@hidden @kbd
address@hidden m<a-z>
-Mark the current file and position with the specified letter.
address@hidden m .
-Set the Emacs mark (@pxref{Emacs Preliminaries}) at point.
address@hidden m ^
-Set the Emacs mark (@pxref{Emacs Preliminaries}) back to where it was last
-set with the @kbd{m.} command. This is useful when you set the mark with
address@hidden, but then some other command (such as @kbd{L} or @kbd{G}) changes
-it in a way that you didn't like.
address@hidden m <
-Set the Emacs mark at beginning of buffer.
address@hidden m >
-Set the Emacs mark at end of buffer.
address@hidden m ,
-Jump to the Emacs mark.
address@hidden :mark <char>
-Mark position with text marker named <char>.  This is an Ex command.
address@hidden :k <char>
-Same as @kbd{:mark}.
address@hidden ``
-Exchange point and mark.
address@hidden ''
-Exchange point and mark and go to the first CHAR on line.
address@hidden '<a-z>
-Go to specified Viper mark.
address@hidden
-Go to specified Viper mark and go to the first CHAR on line.
address@hidden table
address@hidden @kbd{m<a-z>}
address@hidden @kbd{m.}
address@hidden @kbd{m>}
address@hidden @kbd{m<}
address@hidden @kbd{m,}
address@hidden @kbd{m^}
address@hidden @kbd{:mark}
address@hidden @kbd{:k}
address@hidden @kbd{''}
address@hidden @kbd{``}
address@hidden @kbd{`<a-z>}
address@hidden @kbd{'<a-z>}
-
address@hidden  Appending Text, Editing in Insert State, Marking,Text Handling
address@hidden Appending Text
-
address@hidden, to see how to change tab and shiftwidth size.  See the GNU
-Emacs manual, or try @kbd{C-ha tabs} (If you have turned Emacs help on).
-Check out the variable @code{indent-tabs-mode} to put in just spaces.
-Also see options for word-wrap.
-
address@hidden inserting
address@hidden appending
address@hidden paste
address@hidden put
-
address@hidden @kbd
address@hidden <count>  a
-<count> times after the cursor.
address@hidden <count>  A
-<count> times at the end of line.
address@hidden <count>  i
-<count> times before the cursor (insert).
address@hidden <count>  I
-<count> times before the first CHAR of the line
address@hidden <count>  o
-On a new line below the current (open).
-The count is only useful on a slow terminal.
address@hidden <count>  O
-On a new line above the current.
-The count is only useful on a slow terminal.
address@hidden <count>  ><move>
-Shift the lines described by <count><move> one
-shiftwidth to the right (layout!).
address@hidden <count>  >>
-Shift <count> lines one shiftwidth to the right.
address@hidden <count>  ["<a-z1-9>]p
-Put the contents of the (default undo) buffer
-<count> times after the cursor.  The register will
-be automatically down-cased.
address@hidden <count>  ["<a-z1-9>]P
-Put the contents of the (default undo) buffer
-<count> times before the cursor.  The register will
address@hidden [<a-z>
-Show contents of textmarker.
address@hidden ]<a-z>
-Show contents of register.
address@hidden <count>  .
-Repeat previous command <count> times.  For destructive
-commands as well as undo.
address@hidden f1 1 and f1 2
-While @kbd{.} repeats the last destructive command,
-these two macros repeat the second-last and the third-last destructive
-commands.  @xref{Vi Macros}, for more information on Vi macros.
address@hidden C-c M-p and C-c M-n
-In Vi state,
-these commands help peruse the history of Vi's destructive commands.
-Successive typing of @kbd{C-c M-p} causes Viper to search the history in
-the direction
-of older commands, while hitting @kbd{C-c M-n} does so in reverse
-order.  Each command in the history is displayed in the Minibuffer.  The
-displayed command can
-then be executed by typing address@hidden'.
-
-Since typing the above sequences of keys may be tedious, the
-functions doing the perusing can be bound to unused keyboard keys in the
address@hidden/.viper} file.  @xref{Viper Specials}, for details.
address@hidden table
address@hidden @kbd{C-c M-p}
address@hidden @kbd{C-c M-n}
address@hidden @kbd{.}
address@hidden @kbd{]<a-z>}
address@hidden @kbd{[<a-z>}
address@hidden @kbd{P}
address@hidden @kbd{p}
address@hidden @kbd{"<a-z1-9>p}
address@hidden @kbd{"<a-z1-9>P}
address@hidden @kbd{>>}
address@hidden @kbd{><move>}
address@hidden @kbd{O}
address@hidden @kbd{o}
address@hidden @kbd{i}
address@hidden @kbd{A}
address@hidden @kbd{a}
-
address@hidden Editing in Insert State, Deleting Text, Appending Text,Text 
Handling
address@hidden Editing in Insert State
-
-Minibuffer can be edited similarly to Insert state, and you can switch
-between Insert/Replace/Vi states at will.
-Some users prefer plain Emacs feel in the Minibuffer.  To this end, set
address@hidden to @code{nil}.
-
address@hidden Insert state
-
address@hidden @kbd
address@hidden C-v
-Deprive the next char of its special meaning (quoting).
address@hidden C-h
-One char back.
address@hidden C-w
-One word back.
address@hidden C-u
-Back to the begin of the change on the
-current line.
-
address@hidden table
address@hidden @kbd{C-u}
address@hidden @kbd{C-w}
address@hidden @kbd{C-v}
-
address@hidden Deleting Text, Changing Text, Editing in Insert State, Text 
Handling
address@hidden Deleting Text
-
-
-There is one difference in text deletion that you should be
-aware of.  This difference comes from Emacs and was adopted in Viper
-because we find it very useful.  In Vi, if you delete a line, say, and then
-another line, these two deletions are separated and are put back
-separately if you use the @samp{p} command.  In Emacs (and Viper), successive
-series of deletions that are @emph{not interrupted} by other commands are
-lumped together, so the deleted text gets accumulated and can be put back
-as one chunk.  If you want to break a sequence of deletions so that the
-newly deleted text could be put back separately from the previously deleted
-text, you should perform a non-deleting action, e.g., move the cursor one
-character in any direction.
-
address@hidden shifting text
-
address@hidden @kbd
address@hidden <count>  x
-Delete <count> chars under and after the cursor.
address@hidden <count>  X
-Delete <count> chars before the cursor.
address@hidden <count>  d<move>
-Delete from point to endpoint of <count><move>.
address@hidden <count>  dd
-Delete <count> lines.
address@hidden  D
-The rest of the line.
address@hidden <count>  <<move>
-Shift the lines described by <count><move> one
-shiftwidth to the left (layout!).
address@hidden <count>  <<
-Shift <count> lines one shiftwidth to the left.
address@hidden table
address@hidden @kbd{<<}
address@hidden @kbd{<<move>}
address@hidden @kbd{D}
address@hidden @kbd{dd}
address@hidden @kbd{d<move>}
address@hidden @kbd{X}
address@hidden @kbd{x}
-
address@hidden Changing Text, Search and Replace, Deleting Text,Text Handling
address@hidden Changing Text
-
address@hidden joining lines
address@hidden changing case
address@hidden quoting regions
address@hidden substitution
-
address@hidden @kbd
address@hidden <count>  r<char>
-Replace <count> chars by <char> - no <esc>.
address@hidden <count>  R
-Overwrite the rest of the line,
-appending change @var{count - 1} times.
address@hidden <count>  s
-Substitute <count> chars.
address@hidden <count>  S
-Change <count> lines.
address@hidden <count>  c<move>
-Change from begin to endpoint of <count><move>.
address@hidden <count>  cc
-Change <count> lines.
address@hidden <count>  C
-The rest of the line and <count> - 1 next lines.
address@hidden <count>  =<move>
-Reindent the region described by move.
address@hidden <count>  ~
-Switch lower and upper cases.
address@hidden <count>  J
-Join <count> lines (default 2).
address@hidden  :[x,y]s/<pat>/<repl>/<f>
-Substitute (on lines x through y) the pattern
-<pat> (default the last pattern) with <repl>.  Useful
-flags <f> are @samp{g} for @samp{global} (i.e.@: change every
-non-overlapping occurrence of <pat>) and @samp{c} for
address@hidden (type @samp{y} to confirm a particular
-substitution, else @samp{n} ).  Instead of @kbd{/} any
-punctuation CHAR unequal to <space> <tab> and <lf> can be used as
-delimiter.
-
-In Emacs, @samp{\&} stands for the last matched expression, so
address@hidden/[ab]+/\&\&/} will double the string matched by @kbd{[ab]}.
-Viper doesn't treat @samp{&} specially, unlike Vi: use @samp{\&} instead.
-
-Viper does not parse search patterns and does not expand special symbols
-found there (e.g., @samp{~} is not expanded to the result of the previous
-substitution).
-
-Note: @emph{The newline character (inserted as @kbd{C-qC-j})
-can be used in <repl>}.
address@hidden  :[x,y]copy [z]
-Copy text between @kbd{x} and @kbd{y} to the position after @kbd{z}.
address@hidden  :[x,y]t [z]
-Same as @kbd{:copy}.
address@hidden  :[x,y]move [z]
-Move text between @kbd{x} and @kbd{y} to the position after @kbd{z}.
address@hidden  &
-Repeat latest Ex substitute command, e.g.
address@hidden:s/wrong/right}.
address@hidden :x,yp
address@hidden :g/Pat/p
address@hidden :v/Pat/p
-The above commands display certain buffer lines in a
-temporary buffer. The first form above displays the buffer lines between
address@hidden and @kbd{y}. The second displays the lines of the buffer, which
-match a given pattern. The third form displays the lines that do @emph{not}
-match the given pattern.
address@hidden #c<move>
-Change upper-case characters in the region to lower-case.
address@hidden #C<move>
-Change lower-case characters in the region to upper-case.
address@hidden #q<move>
-Insert specified string at the beginning of each line in the region
address@hidden C-c M-p and C-c M-n
-In Insert and Replace states, these keys are bound to commands that peruse
-the history of the text
-previously inserted in other insert or replace commands.  By repeatedly typing
address@hidden M-p} or @kbd{C-c M-n}, you will cause Viper to
-insert these previously used strings one by one.
-When a new string is inserted, the previous one is deleted.
-
-In Vi state, these keys are bound to functions that peruse the history of
-destructive Vi commands.
address@hidden Specials}, for details.
address@hidden table
address@hidden @kbd{C-c M-p}
address@hidden @kbd{C-c M-n}
address@hidden @kbd{#q<move> }
address@hidden @kbd{#C<move>}
address@hidden @kbd{#c<move>}
address@hidden @kbd{&}
address@hidden @kbd{\&}
address@hidden @kbd{:substitute/<pat>/<repl>/<f>}
address@hidden @kbd{:s/<pat>/<repl>/<f>}
address@hidden @kbd{:copy [z]}
address@hidden @kbd{:t [z]}
address@hidden @kbd{:move [z]}
address@hidden @kbd{J}
address@hidden @kbd{~}
address@hidden @kbd{=<move>}
address@hidden @kbd{C}
address@hidden @kbd{cc}
address@hidden @kbd{c<move>}
address@hidden @kbd{S}
address@hidden @kbd{s}
address@hidden @kbd{R}
address@hidden @kbd{r<char>}
-
address@hidden Search and Replace, Yanking, Changing Text,Text Handling
address@hidden Search and Replace
-
address@hidden, for Ex address syntax.  @xref{Options}, to see how to
-get literal (non-regular-expression) search and how to stop search from
-wrapping around.
-
address@hidden @kbd
address@hidden C-c /
-Toggle case-sensitive search.  With prefix argument, toggle vanilla/regular
-expression search.
address@hidden <count>  /<string>
-To the <count>th occurrence of <string>.
-
-Viper does not parse search patterns and does not expand special symbols
-found there (e.g., @samp{~} is not expanded to the result of the previous
-substitution).
-
address@hidden <count>  ?<string>
-To the <count>th previous occurrence of <string>.
address@hidden <count>  g<move>
-Search for the text described by move.  (off by default)
address@hidden n
-Repeat latest @kbd{/} @kbd{?} (next).
address@hidden N
-Idem in opposite direction.
address@hidden %
-Find the next bracket and go to its match
address@hidden :[x,y]g/<string>/<cmd>
address@hidden text processing
-Search globally [from line x to y] for <string>
-and execute the Ex <cmd> on each occurrence.
address@hidden :[x,y]v/<string>/<cmd>
-Execute <cmd> on the lines that don't match.
address@hidden #g<move>
-Execute the last keyboard macro for each line in the region.
address@hidden and Registers}, for more info.
address@hidden Q
-Query Replace.
address@hidden :ta <name>
-Search in the tags file where <name> is defined (file, line), and go to it.
address@hidden  :[x,y]s/<pat>/<repl>/<f>
-Substitute (on lines x through y) the pattern <pat> (default the last
-pattern) with <repl>.  Useful
-flags <f> are @samp{g} for @samp{global} (i.e.@: change every
-non-overlapping occurrence of <pat>) and @samp{c} for
address@hidden (type @samp{y} to confirm a particular
-substitution, else @samp{n}).  Instead of @kbd{/} any
-punctuation character other than <space> <tab> and <lf> can be used as
-delimiter.
-
-Note: @emph{The newline character (inserted as @kbd{C-qC-j})
-can be used in <repl>}.
address@hidden  &
-Repeat latest Ex substitute command, e.g.@: @kbd{:s/wrong/right}.
address@hidden :global /<pattern>/<ex-command>
address@hidden :g /<pattern>/<ex-command>
-Execute <ex-command> on all lines that match <pattern>.
address@hidden :vglobal /<pattern>/<ex-command>
address@hidden :v /<pattern>/<ex-command>
-Execute <ex-command> on all lines that do not match <pattern>.
address@hidden table
address@hidden @kbd{&}
address@hidden @kbd{:substitute/<pat>/<repl>/<f>}
address@hidden @kbd{Q}
address@hidden @kbd{#g<move>}
address@hidden @kbd{:v}
address@hidden @kbd{:g}
address@hidden @kbd{:global}
address@hidden @kbd{:vglobal}
address@hidden @kbd{:tag <name>}
address@hidden @kbd{%}
address@hidden @kbd{N}
address@hidden @kbd{n}
address@hidden @kbd{g<move>}
address@hidden @kbd{?<string>}
address@hidden @kbd{/<string>}
-
address@hidden Yanking,Undoing,Search and Replace,Text Handling
address@hidden Yanking
-
address@hidden cut and paste
address@hidden paste
-
address@hidden @kbd
address@hidden <count>  y<move>
-Yank from begin to endpoint of <count><move>.
address@hidden <count>  "<a-z>y<move>
-Yank from begin to endpoint of <count><move> to register.
address@hidden <count>  "<A-Z>y<move>
-Yank from begin to endpoint of <count><move> and append
-to register.
address@hidden <count>  yy
-<count> lines.
address@hidden <count>  Y
-Idem (should be equivalent to @kbd{y$} though).
address@hidden  m<a-z>
-Mark the cursor position with a letter.
address@hidden [<a-z>
-Show contents of textmarker.
address@hidden ]<a-z>
-Show contents of register.
address@hidden <count>  ["<a-z1-9>]p
-Put the contents of the (default undo) buffer
-<count> times after the cursor.  The register will
-be automatically down-cased.
address@hidden <count>  ["<a-z1-9>]P
-Put the contents of the (default undo) buffer
-<count> times before the cursor.  The register will
address@hidden table
address@hidden @kbd{P}
address@hidden @kbd{p}
address@hidden @kbd{"<a-z1-9>p}
address@hidden @kbd{"<a-z1-9>P}
address@hidden @kbd{]<a-z>}
address@hidden @kbd{[<a-z>}
address@hidden @kbd{m<a-z>}
address@hidden @kbd{Y}
address@hidden @kbd{yy}
address@hidden @kbd{"<A-Z>y<move>}
address@hidden @kbd{"<a-z>y<move>}
address@hidden @kbd{y<move>}
address@hidden @kbd{yank}
address@hidden @kbd{:yank}
-
address@hidden Undoing,, Yanking,Text Handling
address@hidden Undoing
-
address@hidden undo
address@hidden backup files
-
address@hidden @kbd
address@hidden  u U
-Undo the latest change.
address@hidden  .
-Repeat undo.
address@hidden :q!
-Quit Vi without writing.
address@hidden :e!
-Re-edit a messed-up file.
address@hidden :rec
-Recover file from autosave.  Viper also creates backup files
-that have a @samp{~} appended to them.
address@hidden table
address@hidden @kbd{:rec}
address@hidden @kbd{:e!}
address@hidden @kbd{:q!}
address@hidden @kbd{.}
address@hidden @kbd{U}
address@hidden @kbd{u}
-
address@hidden Display, File and Buffer Handling, Text Handling, Commands
address@hidden Display
-
address@hidden scrolling
-
address@hidden @kbd
address@hidden C-g
-At user level 1,
-give file name, status, current line number
-and relative address@hidden
-At user levels 2 and higher, abort the current command.
address@hidden C-c g
-Give file name, status, current line number and relative position -- all
-user levels.
address@hidden C-l
-Refresh the screen.
address@hidden <count> C-e
-Expose <count> more lines at bottom, cursor stays put (if possible).
address@hidden <count> C-y
-Expose <count> more lines at top, cursor stays put (if possible).
address@hidden <count> C-d
-Scroll <count> lines downward (default the number of the previous scroll;
-initialization: half a page).
address@hidden <count> C-u
-Scroll <count> lines upward (default the number of the previous scroll;
-initialization: half a page).
address@hidden <count> C-f
-<count> pages forward.
address@hidden <count> C-b
-<count> pages backward (in older versions @kbd{C-b} only works without count).
address@hidden <count> z<cr>
address@hidden zH
-Put line <count> at the top of the window (default the current line).
address@hidden <count> z-
address@hidden zL
-Put line <count> at the bottom of the window
-(default the current line).
address@hidden <count> z.
address@hidden zM
-Put line <count> in the center of the window
-(default the current line).
address@hidden table
address@hidden @kbd{zM}
address@hidden @kbd{zL}
address@hidden @kbd{zH}
address@hidden @kbd{z<cr>}
address@hidden @kbd{z.}
address@hidden @kbd{z-}
address@hidden @kbd{z<cr>}
address@hidden @kbd{C-b}
address@hidden @kbd{C-f}
address@hidden @kbd{C-u}
address@hidden @kbd{C-d}
address@hidden @kbd{C-y}
address@hidden @kbd{C-e}
address@hidden @kbd{C-l}
address@hidden @kbd{C-g}
-
-
address@hidden File and Buffer Handling, Mapping, Display,Commands
address@hidden File and Buffer Handling
-
address@hidden multiple files
-
-In all file handling commands, space should be typed before entering the file
-name.  If you need to type a modifier, such as @kbd{>>} or @kbd{!}, don't
-put any space between the command and the modifier.
-
-Note that many Ex commands, e.g., @kbd{:w}, accept command arguments. The
-effect is that the command would start acting on the current region. For
-instance, if the current region spans the lines 11 through 22, then if you
-type @kbd{1:w} you would see @samp{:11,22w} in the minibuffer.
-
address@hidden @kbd
address@hidden :q
-Quit buffer except if modified.
address@hidden :q!
-Quit buffer without checking.  In Viper, these two commands
-are identical.  Confirmation is required if exiting modified buffers that
-visit files.
address@hidden :suspend
address@hidden :stop
-Suspend Viper
address@hidden :[x,y] w
-Write the file.  Viper makes sure that a final newline is always added to
-any file where this newline is missing.  This is done by setting Emacs
-variable @code{require-final-newline} to @code{t}.  If you don't like this
-feature, use @code{setq-default} to set @code{require-final-newline} to
address@hidden  This must be done in @file{.viper} file.
address@hidden :[x,y] w <name>
-Write to the file <name>.
address@hidden :[x,y] w>> <name>
-Append the buffer to the file <name>.  There should be no space between
address@hidden and @kbd{>>}.  Type space after the @kbd{>>} and see what 
happens.
address@hidden :w!@: <name>
-Overwrite the file <name>.  In Viper, @kbd{:w} and @kbd{:w!} are identical.
-Confirmation is required for writing to an existing file (if this is not
-the file the buffer is visiting) or to a read-only file.
address@hidden :x,y w <name>
-Write lines x through y to the file <name>.
address@hidden :wq
-Write the file and kill buffer.
address@hidden :r <file> [<file> ...]
-Read file into a buffer, inserting its contents after the current line.
address@hidden :xit
-Same as @kbd{:wq}.
address@hidden :Write
address@hidden :W
-Save all unsaved buffers, asking for confirmation.
address@hidden :WWrite
address@hidden :WW
-Like @kbd{W}, but without asking for confirmation.
address@hidden ZZ
-Save current buffer and kill it.  If user level is 1, then save all files
-and kill Emacs.  Killing Emacs is the wrong way to use it, so you should
-switch to higher user levels as soon as possible.
address@hidden :x [<file>]
-Save and kill buffer.
address@hidden :x!@: [<file>]
address@hidden:w![<file>]} and @kbd{:q}.
address@hidden :pre
-Preserve the file -- autosave buffers.
address@hidden :rec
-Recover file from autosave.
address@hidden :f [<file>]
-without the argument, prints file name and character/line information afout
-the currently visited file. With an argument, sets the currently visited
-filename to @file{file}.
address@hidden :cd [<dir>]
-Set the working directory to <dir> (default home directory).
address@hidden :pwd
-Print present working directory.
address@hidden :e [+<cmd>] <files>
-Edit files.  If no filename is given, edit the file visited by the current
-buffer.  If buffer was modified or the file changed on disk, ask for
-confirmation.  Unlike Vi, Viper allows @kbd{:e} to take multiple arguments.
-The first file is edited the same way as in Vi.  The rest are visited
-in the usual Emacs way.
address@hidden :e!@: [+<cmd>] <files>
-Re-edit file.  If no filename, re-edit current file.
-In Viper, unlike Vi, @kbd{e!} is identical to @kbd{:e}.  In both cases, the
-user is asked to confirm if there is a danger of discarding changes to a
-buffer.
address@hidden :q!
-Quit Vi without writing.
address@hidden C-^
-Edit the alternate (normally the previous) file.
address@hidden :rew
-Obsolete
address@hidden :args
-List files not shown anywhere with counts for next
address@hidden :n [count]  [+<cmd>] [<files>]
-Edit <count> file, or edit files.  The count comes from @kbd{:args}.
address@hidden :N [count] [+<cmd>] [<files>]
-Like @kbd{:n}, but the meaning of the variable
address@hidden is reversed.
address@hidden :b
-Switch to another buffer.  If @var{ex-cycle-other-window} is @code{t},
-switch in another window.  Buffer completion is supported.
-The variable @var{viper-read-buffer-function} controls which function is
-actually used to read the buffer name. The default is @code{read-buffer},
-but better alternatives are also available in Emacs (e.g.,
address@hidden).
address@hidden @var{viper-read-buffer-function}
address@hidden :B
-Like @kbd{:b}, but the meaning of @var{ex-cycle-other-window} is reversed.
address@hidden :<address>r <name>
-Read the file <name> into the buffer after the line <address>.
address@hidden v, V, C-v
-Edit a file in current or another window, or in another frame.  File name
-is typed in Minibuffer.  File completion and history are supported.
address@hidden table
address@hidden @kbd{v}
address@hidden @kbd{V}
address@hidden @kbd{:args}
address@hidden @kbd{:rew}
address@hidden @kbd{C-^}
address@hidden @kbd{:e!@: [<files>]}
address@hidden @kbd{:e [<files>]}
address@hidden @kbd{:edit [<files>]}
address@hidden @kbd{:edit!@: [<files>]}
address@hidden @kbd{:q!}
address@hidden @kbd{:q}
address@hidden @kbd{:quit}
address@hidden @kbd{:quit!}
address@hidden @kbd{:f}
address@hidden @kbd{:rec}
address@hidden @kbd{:r}
address@hidden @kbd{:read}
address@hidden @kbd{:pre}
address@hidden @kbd{ZZ}
address@hidden @kbd{:wq}
address@hidden @kbd{:w <file>}
address@hidden @kbd{:w!@: <file>}
address@hidden @kbd{:w >> <file>}
address@hidden @kbd{:write <file>}
address@hidden @kbd{:write!@: <file>}
address@hidden @kbd{:write >> <file>}
address@hidden @kbd{:W}
address@hidden @kbd{:WW}
address@hidden @kbd{:Write}
address@hidden @kbd{:WWrite}
address@hidden @kbd{:WWrite}
address@hidden @kbd{:x}
address@hidden @kbd{:x!}
address@hidden @kbd{:suspend}
address@hidden @kbd{:stop}
address@hidden @kbd{:n [<count> | <file>]}
address@hidden @kbd{:cd [<dir>]}
address@hidden @kbd{:pwd}
-
address@hidden Mapping, Shell Commands, File and Buffer Handling, Commands
address@hidden Mapping
-
address@hidden key bindings
address@hidden key mapping
-
address@hidden @kbd
address@hidden :map <string>
-Start defining a Vi-style keyboard macro.
-For instance, typing
address@hidden:map www} followed by @kbd{:!wc %} and then typing @kbd{C-x )}
-will cause @kbd{www} to run wc on
-current file (Vi replaces @samp{%} with the current file name).
address@hidden C-x )
-Finish defining a keyboard macro.
-In Viper, this command completes the process of defining all keyboard
-macros, whether they are Emacs-style or Vi-style.
-This is a departure from Vi, needed to allow WYSIWYG mapping of
-keyboard macros and to permit the use of function keys and arbitrary Emacs
-functions in the macros.
address@hidden :unmap <string>
-Deprive <string> of its mappings in Vi state.
address@hidden :map!@: <string>
-Map a macro for Insert state.
address@hidden :unmap!@: <string>
-Deprive <string> of its mapping in Insert state (see @kbd{:unmap}).
address@hidden @@<a-z>
-In Vi state,
-execute the contents of register as a command.
address@hidden @@@@
-In Vi state,
-repeat last register command.
address@hidden @@#
-In Vi state,
-begin keyboard macro.  End with @@<a-z>.  This will
-put the macro in the proper register.  Register will
-be automatically down-cased.
address@hidden and Registers}, for more info.
address@hidden @@!<a-z>
-In Vi state,
-yank anonymous macro to register
address@hidden *
-In Vi state,
-execute anonymous macro (defined by C-x( and C-x )).
address@hidden C-x e
-Like @kbd{*}, but works in all Viper states.
address@hidden #g<move>
-Execute the last keyboard macro for each line in the region.
address@hidden and Registers}, for more info.
address@hidden [<a-z>
-Show contents of textmarker.
address@hidden ]<a-z>
-Show contents of register.
address@hidden table
address@hidden @kbd{]<a-z>}
address@hidden @kbd{[<a-z>}
address@hidden @kbd{#g<move>}
address@hidden @kbd{*}
address@hidden @kbd{@@!<a-z>}
address@hidden @kbd{@@#}
address@hidden @kbd{@@@@}
address@hidden @kbd{@@<a-z>}
address@hidden @kbd{:unmap <char>}
address@hidden @kbd{:map <char> <seq>}
address@hidden @kbd{:unmap!@: <char>}
address@hidden @kbd{:map!@: <char> <seq>}
-
address@hidden Shell Commands, Options, Mapping, Commands
address@hidden Shell Commands
-
address@hidden % (Current file)
-
-The symbol @samp{%} is used in Ex shell commands to mean current file.  If
-you want a @samp{%} in your command, it must be escaped as @samp{\%}.
address@hidden @samp{%} (Ex address)
-However if @samp{%} is the first character, it stands as the address for
-the whole file.
address@hidden @samp{#} (Previous file)
-Similarly, @samp{#} expands to the previous file.  The previous file is the
-first file in @kbd{:args} listing.  This defaults to the previous file in
-the VI sense if you have one address@hidden
-
-Symbols @samp{%} and @samp{#} are also used in the Ex commands @kbd{:e} and
address@hidden:r <shell-cmd>}.  The commands @kbd{:w} and the regular @kbd{:r
-<file>} command don't support these meta symbols, because file history is a
-better mechanism.
-
address@hidden shell commands
-
address@hidden @kbd
address@hidden :sh
-Execute a subshell in another window
address@hidden :[x,y]!<cmd>
-Execute a shell <cmd> [on lines x through y;
-% is replace by current file, \% is changed to %
address@hidden :[x,y]!!@: [<args>]
-Repeat last shell command [and append <args>].
address@hidden :!<cmd>
-Just execute command and display result in a buffer.
address@hidden :!!@: <args>
-Repeat last shell command and append <args>
address@hidden <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 @samp{cb}, @samp{sort}, @samp{nroff}, etc.).
address@hidden <count> !!<cmd>
-Give <count> lines as standard input to the
-shell <cmd>, next let the standard output
-replace those lines.
address@hidden :[x,y] w !<cmd>
-Let lines x to y be standard input for <cmd>
-(notice the <sp> between @kbd{w} and @kbd{!}).
address@hidden :<address>r !<cmd>
-Put the output of <cmd> after the line <address> (default current).
address@hidden :<address>r <name>
-Read the file <name> into the buffer after the line <address> (default
-current).
address@hidden :make
-Run the make command in the current directory.
address@hidden table
address@hidden @kbd{:<address>r <name>}
address@hidden @kbd{:<address>r !<cmd>}
address@hidden @kbd{!<cmd>}
address@hidden @kbd{!!<cmd>}
address@hidden @kbd{!<move><cmd>}
address@hidden @kbd{:w !<cmd>}
address@hidden @kbd{:x,y w !<cmd>}
address@hidden @kbd{:!!@: <args>}
address@hidden @kbd{:!<cmd>}
address@hidden @kbd{:sh}
address@hidden @kbd{:make}
-
address@hidden Options,Emacs Related Commands,Shell Commands,Commands
address@hidden Options
-
address@hidden Vi options
-
address@hidden @kbd
address@hidden autoindent
address@hidden ai
address@hidden autoindent
-autoindent -- In append mode after a <cr> the
-cursor will move directly below the first
-character on the previous line.
-This setting affects the current buffer only.
address@hidden autoindent-global
address@hidden ai-global
-Same as `autoindent', but affects all buffers.
address@hidden noautoindent
address@hidden noai
-Cancel autoindent.
address@hidden noautoindent-global
address@hidden noai-g
-Cancel autoindent-global.
address@hidden ignorecase
address@hidden ic
address@hidden case and searching
-ignorecase -- No distinction between upper and lower cases when searching.
address@hidden noignorecase
address@hidden noic
-Cancel ignorecase.
address@hidden magic
address@hidden ma
address@hidden literal searching
-Regular expressions used in searches; nomagic means no regexps.
address@hidden nomagic
address@hidden noma
-Cancel magic.
address@hidden readonly
address@hidden ro
address@hidden readonly files
-readonly -- The file is not to be changed.
-If the user attempts to write to this file, confirmation will be requested.
address@hidden noreadonly
address@hidden noro
-Cancel readonly.
address@hidden shell=<string>
address@hidden sh=<string>
address@hidden shell
-shell -- The program to be used for shell escapes
-(default @samp{$SHELL} (default @file{/bin/sh})).
address@hidden shiftwidth=<count>
address@hidden sw=<count>
address@hidden layout
address@hidden shifting text
-shiftwidth -- Gives the shiftwidth (default 8 positions).
address@hidden showmatch
address@hidden sm
address@hidden paren matching
address@hidden matching parens
-showmatch -- Whenever you append a @kbd{)}, Vi shows
-its match if it's on the same page; also with
address@hidden@{} and @address@hidden  If there's no match, Vi will beep.
address@hidden noshowmatch
address@hidden nosm
-Cancel showmatch.
address@hidden tabstop=<count>
address@hidden ts=<count>
address@hidden changing tab width
address@hidden tabbing
-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).
-This setting affects the current buffer only.
address@hidden tabstop-global
address@hidden ts-g
-Same as `tabstop', but affects all buffers.
address@hidden wrapmargin=<count>
address@hidden wm=<count>
address@hidden auto fill
address@hidden word wrap
-wrapmargin -- In append mode Vi automatically
-puts a <lf> whenever there is a <sp> or <ht>
-within <wm> columns from the right margin.
address@hidden wrapscan
address@hidden ws
address@hidden searching
-wrapscan -- When searching, the end is
-considered @samp{stuck} to the begin of the file.
address@hidden nowrapscan
address@hidden nows
-Cancel wrapscan.
address@hidden :set <option>
-Turn <option> on.
address@hidden :set no<option>
-Turn <option> off.
address@hidden :set <option>=<value>
-Set <option> to <value>.
address@hidden table
address@hidden @kbd{:set <option>=<value>}
address@hidden @kbd{:set no<option>}
address@hidden @kbd{:set <option>}
address@hidden @kbd{:set ws}
address@hidden @kbd{:set wrapscan}
address@hidden @kbd{:set wm=<count>}
address@hidden @kbd{:set wrapmargin=<count>}
address@hidden @kbd{:set ts=<count>}
address@hidden @kbd{:set tabstop=<count>}
address@hidden @kbd{:set tab-stop-local=<count>}
address@hidden @kbd{:set sm}
address@hidden @kbd{:set showmatch}
address@hidden @kbd{:set sw=<count>}
address@hidden @kbd{:set shiftwidth=<count>}
address@hidden @kbd{:set sh=<string>}
address@hidden @kbd{:set shell=<string>}
address@hidden @kbd{:set ro}
address@hidden @kbd{:set readonly}
address@hidden @kbd{:set magic}
address@hidden @kbd{:set ic}
address@hidden @kbd{:set ignorecase}
address@hidden @kbd{:set ai}
address@hidden @kbd{:set autoindent}
-
address@hidden Emacs Related Commands,,Options,Commands
address@hidden Emacs Related Commands
-
address@hidden @kbd
address@hidden C-\
-Begin Meta command in Vi or Insert states.  Most often used as C-\ x (M-x).
-
-Note: Emacs binds @kbd{C-\} to a function that offers to change the
-keyboard input method in the multilingual environment.  Viper overrides this
-binding.  However, it is still possible to switch the input method by typing
address@hidden C-\} in the Vi command state and @kbd{C-z \ C-\} in the Insert 
state.
-Or you can use the MULE menu on the menubar.
address@hidden C-z
-In Insert and Replace states, prepare Viper to accept the next command and
-execute it as if Viper was in Vi state.  Then return to Insert state.
-
-In Vi state, switch to Emacs state; in Emacs state, switch to Vi state.
address@hidden C-c \
-Switches to Vi state for the duration of a single command.  Then goes back
-to the original Viper state.  Works from Vi, Insert, Replace, and Emacs states.
address@hidden C-x0
-Close Window
address@hidden C-x1
-Close Other Windows
address@hidden C-x2
-Split Window
address@hidden C-xo
-Move among windows
address@hidden C-xC-f
-Emacs find-file, useful in Insert state
address@hidden C-y
-Put back the last killed text.  Similar to Vi's @kbd{p}, but also works in
-Insert and Replace state.  This command doesn't work in Vi command state,
-since this binding is taken for something else.
address@hidden M-y
-Undoes the last @kbd{C-y} and puts another kill from the kill ring.
-Using this command, you can try may different kills until you find the one
-you need.
address@hidden table
address@hidden @kbd{M-y}
address@hidden @kbd{C-y}
address@hidden @kbd{C-xC-f}
address@hidden @kbd{C-xo}
address@hidden @kbd{C-x2}
address@hidden @kbd{C-x1}
address@hidden @kbd{C-x0}
address@hidden @kbd{C-z}
address@hidden @kbd{C-\}
address@hidden @kbd{C-c\}
-
address@hidden Mouse-bound Commands,,,Commands
address@hidden Mouse-bound Commands
-
-The following two mouse actions are normally bound to special search and
-insert commands in of Viper:
-
address@hidden @kbd
address@hidden S-Mouse-1
-Holding Shift and clicking mouse button 1 will
-initiate search for
-a region under the mouse pointer.
-This command can take a prefix argument.  Note: Viper sets this
-binding only if this mouse action is not
-already bound to something else.
address@hidden Specials}, for more address@hidden
-
address@hidden S-Mouse-2
-Holding Shift and clicking button 2 of the mouse will
-insert a region surrounding the mouse pointer.
-This command can also take a prefix argument.
-Note: Viper sets this binding only if this mouse action is not
-already bound to something else.
address@hidden Specials}, for more address@hidden
address@hidden table
address@hidden @kbd{S-Mouse-1}
address@hidden @kbd{S-Mouse-2}
address@hidden @kbd{meta button1up}
address@hidden @kbd{meta button2up}
-
address@hidden Acknowledgments,,,Top
address@hidden  node-name,  next,  previous,  up
address@hidden Acknowledgments
-
-Viper, formerly known as VIP-19, was written by Michael Kifer.  Viper is
-based on the original VIP package by Masahiko Sato and on its enhancement,
-VIP 4.4, by Aamod Sane.  This manual is an adaptation of the manual for VIP
-4.4, which, in turn, was based on Sato's manual for VIP 3.5.
-
-Many contributors on the Net pointed out bugs and suggested a number of
-useful features. Scott Bronson and Samuel Padgett contributed patches that
-were incorporated in this code.  Here is a hopefully complete list of
-contributors:
-
address@hidden
-aaronl@@vitelus.com (Aaron Lehmann),
-ahg@@panix.com (Al Gelders),
-amade@@diagram.fr (Paul-Bernard Amade),
-ascott@@fws214.intel.com (Andy Scott),
-bronson@@trestle.com (Scott Bronson),
-cook@@biostat.wisc.edu (Tom Cook),
-csdayton@@midway.uchicago.edu (Soren Dayton),
-dave@@hellgate.utah.edu,
-dm@@scs.cs.nyu.edu (David Mazieres),
-dominik@@strw.LeidenUniv.nl (Carsten Dominik),
-dwallach@@cs.princeton.edu (Dan Wallach),
-dwight@@toolucky.llnl.gov (Dwight Shih),
-dxc@@xprt.net (David X Callaway),
-edmonds@@edmonds.home.cs.ubc.ca (Brian Edmonds),
-gin@@mo.msk.ru (Golubev I.N.),
-gviswana@@cs.wisc.edu (Guhan Viswanathan),
-gvr@@halcyon.com (George V.@: Reilly),
-hatazaki@@bach.convex.com (Takao Hatazaki),
-hpz@@ibmhpz.aug.ipp-garching.mpg.de (Hans-Peter Zehrfeld),
-irie@@t.email.ne.jp (Irie Tetsuya),
-jackr@@dblues.engr.sgi.com (Jack Repenning),
-jamesm@@bga.com (D.J.@: Miller II),
-jjm@@hplb.hpl.hp.com (Jean-Jacques Moreau),
-jl@@cse.ogi.edu (John Launchbury),
-jobrien@@hchp.org (John O'Brien),
-johnw@@borland.com (John Wiegley),
-kanze@@gabi-soft.fr (James Kanze),
-kin@@isi.com (Kin Cho),
-kwzh@@gnu.org (Karl Heuer),
-lindstro@@biostat.wisc.edu (Mary Lindstrom),
-lektu@@terra.es (Juanma Barranquero),
-lennart.borgman.073@@student.lu.se (Lennart Borgman),
-minakaji@@osaka.email.ne.jp (Mikio Nakajima),
-Mark.Bordas@@East.Sun.COM (Mark Bordas),
-meyering@@comco.com (Jim Meyering),
-martin@@xemacs.org (Martin Buchholz),
-mbutler@@redfernnetworks.com (Malcolm Butler),
-mveiga@@dit.upm.es (Marcelino Veiga Tuimil),
-paulk@@summit.esg.apertus.com (Paul Keusemann),
-pfister@@cs.stonybrook.edu (Hanspeter Pfister),
-phil_brooks@@MENTORG.COM (Phil Brooks),
-pogrell@@informatik.hu-berlin.de (Lutz Pogrell),
-pradyut@@cs.uchicago.edu (Pradyut Shah),
-roderick@@argon.org (Roderick Schertler),
-rxga@@ulysses.att.com,
-sawdey@@lcse.umn.edu (Aaron Sawdey),
-simonb@@prl.philips.co.uk (Simon Blanchard),
-spadgett1@@nc.rr.com (Samuel Padgett),
-stephen@@farrell.org (Stephen Farrell),
-storm@@cua.dk (Kim F. Storm),
-sudish@@MindSpring.COM (Sudish Joseph),
-schwab@@issan.informatik.uni-dortmund.de (Andreas Schwab)
-terra@@diku.dk (Morten Welinder),
-thanh@@informatics.muni.cz (Han The Thanh),
-toma@@convex.convex.com,
-vrenjak@@sun1.racal.com (Milan Vrenjak),
-whicken@@dragon.parasoft.com (Wendell Hicken),
-zapman@@cc.gatech.edu (Jason Zapman II),
address@hidden example
-
address@hidden GNU Free Documentation License,,, Top
address@hidden GNU Free Documentation License
address@hidden doclicense.texi
-
address@hidden Key Index,Function Index,,Top
address@hidden  node-name,  next,  previous,  up
address@hidden Key Index
-
address@hidden ky
-
address@hidden Function Index,Variable Index,Key Index,Top
address@hidden  node-name,  next,  previous,  up
address@hidden Function Index
-
address@hidden fn
-
address@hidden Variable Index,Package Index,Function Index,Top
address@hidden  node-name,  next,  previous,  up
address@hidden Variable Index
-
address@hidden vr
-
address@hidden Package Index,Concept Index,Variable Index,Top
address@hidden  node-name,  next,  previous,  up
address@hidden Package Index
-
address@hidden pg
-
address@hidden Concept Index,,Package Index,Top
address@hidden  node-name,  next,  previous,  up
address@hidden Concept Index
-
address@hidden cp
-
address@hidden odd
address@hidden
address@hidden
-
address@hidden
-   arch-tag: f53e866a-15cf-4b1e-aead-77da9da1e864
address@hidden ignore




reply via email to

[Prev in Thread] Current Thread [Next in Thread]