4 @comment Using viper.info instead of viper in setfilename breaks DOS.
5 @comment @setfilename viper
6 @comment @setfilename viper.info
7 @setfilename ../../info/viper
10 Copyright @copyright{} 1995--1997, 2001--2013 Free Software Foundation, Inc.
13 Permission is granted to copy, distribute and/or modify this document
14 under the terms of the GNU Free Documentation License, Version 1.3 or
15 any later version published by the Free Software Foundation; with no
16 Invariant Sections, with the Front-Cover texts being ``A GNU Manual'',
17 and with the Back-Cover Texts as in (a) below. A copy of the license
18 is included in the section entitled ``GNU Free Documentation License''.
20 (a) The FSF's Back-Cover Text is: ``You have the freedom to copy and
21 modify this GNU manual.''
25 @dircategory Emacs misc features
27 * VIPER: (viper). A VI-emulation mode for Emacs.
33 @title Viper Is a Package for Emacs Rebels
34 @subtitle a Vi emulator for Emacs
35 @subtitle November 2008, Viper Version 3.11.2
37 @author Michael Kifer (Viper)
38 @author Aamod Sane (VIP 4.4)
39 @author Masahiko Sato (VIP 3.5)
42 @vskip 0pt plus 1filll
52 We believe that one or more of the following statements are adequate
53 descriptions of Viper:
56 Viper Is a Package for Emacs Rebels;
57 it is a VI Plan for Emacs Rescue
58 and/or a venomous VI PERil.
61 Technically speaking, Viper is a Vi emulation package for Emacs. It
62 implements all Vi and Ex commands, occasionally improving on them and
63 adding many new features. It gives the user the best of both worlds: Vi
64 keystrokes for editing combined with the power of the Emacs environment.
66 Viper emulates Vi at several levels, from the one that closely follows Vi
67 conventions to the one that departs from many of them. It has many
68 customizable options, which can be used to tailor Viper to the work habits
70 This manual describes Viper, concentrating on the differences from Vi and
71 new features of Viper.
73 Viper, formerly known as VIP-19, was written by Michael Kifer. It is based
74 on VIP version 3.5 by Masahiko Sato and VIP version 4.4 by Aamod Sane.
75 About 15% of the code still comes from those older packages.
77 Viper is intended to be usable without reading this manual; the defaults
78 are set to make Viper as close to Vi as possible. At startup, Viper will
79 try to set the most appropriate default environment for you, based on
80 your familiarity with Emacs. It will also tell you the basic GNU Emacs window
81 management commands to help you start immediately.
83 Although this manual explains how to customize Viper, some basic
84 familiarity with Emacs Lisp is a plus.
86 It is recommended that you read the Overview node. The other nodes may
89 Comments and bug reports are welcome.
90 @code{kifer@@cs.stonybrook.edu} is the current address for Viper bug reports.
91 Please use the Ex command @kbd{:submitReport} for this purpose.
97 * Overview:: Read for a smoother start
98 * Improvements over Vi:: New features, Improvements
99 * Customization:: How to customize Viper
100 * Commands:: Vi and Ex Commands
101 * GNU Free Documentation License:: The license for this documentation.
103 * Key Index:: Index of Vi and Ex Commands
104 * Function Index:: Index of Viper Functions
105 * Variable Index:: Index of Viper Variables
106 * Package Index:: Index of Packages Mentioned in this Document
107 * Concept Index:: Vi, Ex and Emacs concepts
110 @unnumbered Introduction
112 We believe that one or more of the following statements are adequate
113 descriptions of Viper:
116 Viper Is a Package for Emacs Rebels;
117 it is a VI Plan for Emacs Rescue
118 and/or a venomous VI PERil.
121 Viper is a Vi emulation package for Emacs. Viper contains virtually all
122 of Vi and Ex functionality and much more. It gives you the best of both
123 worlds: Vi keystrokes for editing combined with the GNU Emacs
124 environment. Viper also fixes some common complaints with Vi commands.
125 This manual describes Viper, concentrating on the differences from Vi
126 and on the new features of Viper.
128 Viper was written by Michael Kifer. It is based on VIP version 3.5 by
129 Masahiko Sato and VIP version 4.4 by Aamod Sane. About 15% of the code
130 still comes from those older packages.
132 Viper is intended to be usable out of the box, without reading this manual;
133 the defaults are set to make Viper as close to Vi as possible. At
134 startup, Viper will attempt to set the most appropriate default environment
135 for you, based on your familiarity with Emacs. It will also tell you the
136 basic GNU Emacs window management commands to help you start immediately.
138 Although this manual explains how to customize Viper, some basic
139 familiarity with Emacs Lisp is a plus.
141 It is recommended that you read the chapter Overview. The other chapters
142 will be useful for customization and advanced usage.
144 You should also learn to use the Info on-line hypertext manual system that
145 comes with Emacs. This manual can be read as an Info file. Try the command
146 @kbd{@key{ESC} x info} with vanilla Emacs sometime.
148 Comments and bug reports are welcome.
149 @code{kifer@@cs.stonybrook.edu} is the current address for Viper bug reports.
150 Please use the Ex command @kbd{:submitReport} for this purpose.
155 @chapter Overview of Viper
157 Viper is a Vi emulation on top of Emacs. At the same time, Viper provides a
158 virtually unrestricted access to Emacs facilities. Perfect compatibility
159 with Vi is possible but not desirable. This chapter tells you about the
160 Emacs ideas that you should know about, how to use Viper within Emacs and
161 some incompatibilities.
163 This manual is written with the assumption that you are an experienced Vi
164 user who wants to switch to Emacs while retaining the ability to edit files
165 Vi style. Incredible as it might seem, there are experienced Emacs users
166 who use Viper as a backdoor into the superior (as every Vi user already knows)
167 world of Vi! These users are well familiar with Emacs bindings and prefer them
168 in some cases, especially in the Vi Insert state. John Hawkins
169 <jshawkin@@eecs.umich.edu> has provided a set of customizations, which
170 enables additional Emacs bindings under Viper. These customizations can be
171 included in your @file{~/.viper} file and are found at the following URL:
172 @file{http://traeki.freeshell.org/files/viper-sample}.
175 * Emacs Preliminaries:: Basic concepts in Emacs.
176 * Loading Viper:: Loading and Preliminary Configuration.
177 * States in Viper:: Viper has four states orthogonal to Emacs
179 * The Minibuffer:: Command line in Emacs.
180 * Multiple Files in Viper:: True multiple file handling.
181 * Unimplemented Features:: That are unlikely to be implemented.
184 @node Emacs Preliminaries
185 @section Emacs Preliminaries
192 @cindex end (of buffer)
193 @cindex end (of line)
196 Emacs can edit several files at once. A file in Emacs is placed in a
197 @dfn{buffer} that usually has the same name as the file. Buffers are also used
198 for other purposes, such as shell interfaces, directory editing, etc.
199 @xref{Dired,,Directory Editor,emacs,The
200 GNU Emacs Manual}, for an example.
202 A buffer has a distinguished position called the @dfn{point}.
203 A @dfn{point} is always between 2 characters, and is @dfn{looking at}
204 the right hand character. The cursor is positioned on the right hand
205 character. Thus, when the @dfn{point} is looking at the end-of-line,
206 the cursor is on the end-of-line character, i.e., beyond the last
207 character on the line. This is the default Emacs behavior.
209 The default settings of Viper try to mimic the behavior of Vi, preventing
210 the cursor from going beyond the last character on the line. By using
211 Emacs commands directly (such as those bound to arrow keys), it is possible
212 to get the cursor beyond the end-of-line. However, this won't (or
213 shouldn't) happen if you restrict yourself to standard Vi keys, unless you
214 modify the default editing style. @xref{Customization}.
216 In addition to the @dfn{point}, there is another distinguished buffer
217 position called the @dfn{mark}. @xref{Mark,,Mark,emacs,The GNU Emacs
218 manual}, for more info on the mark. The text between the @dfn{point} and
219 the @dfn{mark} is called the @dfn{region} of the buffer. For the Viper
220 user, this simply means that in addition to the Vi textmarkers a--z, there
221 is another marker called @dfn{mark}. This is similar to the unnamed Vi
222 marker used by the jump commands @kbd{``} and @kbd{''}, which move the
223 cursor to the position of the last absolute jump. Viper provides access to
224 the region in most text manipulation commands as @kbd{r} and @kbd{R} suffix
225 to commands that operate on text regions, e.g., @kbd{dr} to delete region,
228 Furthermore, Viper lets Ex-style commands to work on the current region.
229 This is done by typing a digit argument before @kbd{:}. For instance,
230 typing @kbd{1:} will prompt you with something like @emph{:123,135},
231 assuming that the current region starts at line 123 and ends at line
232 135. There is no need to type the line numbers, since Viper inserts them
233 automatically in front of the Ex command.
235 @xref{Basics}, for more info.
239 @cindex buffer information
242 @cindex buffer (modified)
244 Emacs divides the screen into tiled @dfn{windows}. You can see the
245 contents of a buffer through the window associated with the buffer. The
246 cursor of the screen is positioned on the character after @dfn{point}.
247 Every window has a @dfn{mode line} that displays information about the buffer.
248 You can change the format of the mode
249 line, but normally if you see @samp{**} at the beginning of a mode line it
250 means that the buffer is @dfn{modified}. If you write out the contents of
251 a buffer to a file, then the buffer will become not modified. Also if
252 you see @samp{%%} at the beginning of the mode line, it means that the file
253 associated with the buffer is write protected. The mode line will also
254 show the buffer name and current major and minor modes (see below).
255 A special buffer called @dfn{Minibuffer} is displayed as the last line
256 in a minibuffer window. The minibuffer window is used for command input
257 output. Viper uses minibuffer window for @kbd{/} and @kbd{:}
263 @cindex global keymap
267 An Emacs buffer can have a @dfn{major mode} that customizes Emacs for
268 editing text of a particular sort by changing the functionality of the keys.
269 Keys are defined using a @dfn{keymap} that records the bindings between
271 functions. The @dfn{global keymap} is common to all the
272 buffers. Additionally, each buffer has its @dfn{local keymap} that determines the
273 @dfn{mode} of the buffer. If a function is bound to some key in the local
274 keymap then that function will be executed when you type the key.
275 If no function is bound to a key in the
276 local map, however, the function bound to the key in the global map
277 will be executed. @xref{Major Modes,Major Modes,Major Modes,emacs,The
278 GNU Emacs Manual}, for more information.
280 A buffer can also have a @dfn{minor mode}. Minor modes are options that
281 you can use or not. A buffer in @code{text-mode} can have
282 @code{auto-fill-mode} as minor mode, which can be turned off or on at
283 any time. In Emacs, a minor mode may have it own keymap,
284 which overrides the local keymap when the minor mode is turned on. For
285 more information, @pxref{Minor Modes,Minor Modes,Minor Modes,emacs,The
288 @cindex Viper as minor mode
292 Viper is implemented as a collection of minor modes. Different minor modes
293 are involved when Viper emulates Vi command mode, Vi insert mode, etc.
294 You can also turn Viper on and off at any time while in Vi command mode.
295 @xref{States in Viper}, for
298 Emacs uses Control and Meta modifiers. These are denoted as C and M,
299 e.g., @kbd{^Z} as @kbd{C-z} and @kbd{Meta-x} as @kbd{M-x}. The Meta key is
300 usually located on each side of the Space bar; it is used in a manner
301 similar to the Control key, e.g., @kbd{M-x} means typing @kbd{x} while
302 holding the Meta key down. For keyboards that do not have a Meta key,
303 @key{ESC} is used as Meta. Thus @kbd{M-x} is typed as @kbd{@key{ESC}
304 x}. Viper uses @key{ESC} to switch from Insert state to Vi state. Therefore
305 Viper defines @kbd{C-\} as its Meta key in Vi state. @xref{Vi State}, for
308 Emacs is structured as a Lisp interpreter around a C core. Emacs keys
309 cause Lisp functions to be called. It is possible to call these
310 functions directly, by typing @kbd{M-x function-name}.
313 @section Loading Viper
315 The most common way to load it automatically is to include the following
316 lines (in the given order!):
324 in your @file{~/.emacs} file. The @file{.emacs} file is placed in your
325 home directory and it is be executed every time you invoke Emacs. This is
326 the place where all general Emacs customization takes place. Beginning with
327 version 20.0, Emacsen have an interactive interface, which simplifies the
328 job of customization significantly.
330 Viper also uses the file @file{~/.viper} for Viper-specific customization.
331 The location of Viper customization file can be changed by setting the
332 variable @code{viper-custom-file-name} in @file{.emacs} @emph{prior} to loading
335 The latest versions of Emacs have an interactive customization facility,
336 which allows you to (mostly) bypass the use of the @file{.emacs} and
337 @file{.viper} files. You can reach this customization
338 facility from within Viper's VI state by executing the Ex command
341 Once invoked, Viper will arrange to bring up Emacs buffers in Vi state
342 whenever this makes sense.
343 @xref{Packages that Change Keymaps}, to find out when forcing Vi command state
344 on a buffer may be counter-productive.
346 Even if your @file{.emacs} file does not invoke Viper automatically,
347 you can still load Viper and enter the Vi command state by typing the
348 following from within Emacs:
354 When Emacs first comes up, if you have not specified a file on the
355 command line, it will show the @samp{*scratch*} buffer, in the
356 @samp{Lisp Interaction} mode. After you invoke Viper, you can start
357 editing files by using @kbd{:e}, @kbd{:vi}, or @kbd{v} commands.
358 (@xref{File and Buffer Handling}, for more information on @kbd{v} and other
359 new commands that, in many cases, are more convenient than @kbd{:e},
360 @kbd{:vi}, and similar old-style Vi commands.)
362 Finally, if at some point you would want to de-Viperize your running
363 copy of Emacs after Viper has been loaded, the command @kbd{M-x
364 viper-go-away} will do it for you. The function @code{toggle-viper-mode}
365 toggles Viperization of Emacs on and off.
367 @node States in Viper
368 @section States in Viper
376 @cindex Replace state
378 @findex @code{viper-go-away}
379 @findex @code{toggle-viper-mode}
381 Viper has four states, Emacs, Vi, Insert, and Replace.
385 This is the state plain vanilla Emacs is normally in. After you have loaded
386 Viper, @kbd{C-z} will normally take you to Vi command state. Another
387 @kbd{C-z} will take you back to Emacs state. This toggle key can be
388 changed, @pxref{Customization} You can also type @kbd{M-x viper-mode} to
392 For users who chose to set their user level to 1 at Viper setup time,
393 switching to Emacs state is deliberately made harder in order to not
394 confuse the novice user. In this case, @kbd{C-z} will either iconify Emacs
395 (if Emacs runs as an application under X) or it will stop Emacs (if
396 Emacs runs on a dumb terminal or in an Xterm window).
399 This is the Vi command mode. Any of the Vi commands, such as @kbd{i, o, a},
400 @dots{}, will take you to Insert state. All Vi commands may
401 be used in this mode. Most Ex commands can also be used.
402 For a full list of Ex commands supported by Viper, type
403 @kbd{:} and then @key{TAB}. To get help on any issue, including the Ex
404 commands, type @kbd{:help}. This will invoke Viper Info
405 (if it is installed). Then typing @kbd{i} will prompt you for a topic to
406 search in the index. Note: to search for Ex commands in the index, you
407 should start them with a @kbd{:}, e.g., @kbd{:WW}.
409 In Viper, Ex commands can be made to work on the current Emacs region.
410 This is done by typing a digit argument before @kbd{:}.
411 For instance, typing @kbd{1:} will prompt you with something like
412 @emph{:123,135}, assuming that the current region starts at line 123 and
413 ends at line 135. There is no need to type the line numbers, since Viper
414 inserts them automatically in front of the Ex command.
417 Insert state is the Vi insertion mode. @key{ESC} will take you back to
418 Vi state. Insert state editing can be done, including auto-indentation. By
419 default, Viper disables Emacs key bindings in Insert state.
422 Commands like @kbd{cw} invoke the Replace state. When you cross the
423 boundary of a replacement region (usually designated via a @samp{$} sign),
424 it will automatically change to Insert state. You do not have to worry
425 about it. The key bindings remain practically the same as in Insert
426 state. If you type @key{ESC}, Viper will switch to Vi command mode, terminating the
432 The modes are indicated on the @dfn{mode line} as <E>, <I>, <V>, and <R>,
433 so that the multiple modes do not confuse you. Most of your editing can be
434 done in Vi and Insert states. Viper will try to make all new buffers be in Vi
435 state, but sometimes they may come up in Emacs state. @kbd{C-z}
436 will take you to Vi state in such a case. In some major modes, like Dired,
437 Info, Gnus, etc., you should not switch to Vi state (and Viper will not
438 attempt to do so) because these modes are not intended for text editing and
439 many of the Vi keys have special meaning there. If you plan to read news,
440 browse directories, read mail, etc., from Emacs (which you should start
441 doing soon!), you should learn about the meaning of the various keys in
442 those special modes (typing @kbd{C-h m} in a buffer provides
443 help with key bindings for the major mode of that buffer).
445 If you switch to Vi in Dired or similar modes, no harm is done. It is just
446 that the special key bindings provided by those modes will be temporarily
447 overshadowed by Viper's bindings. Switching back to Viper's Emacs state
448 will revive the environment provided by the current major mode.
450 States in Viper are orthogonal to Emacs major modes, such as C mode or Dired
451 mode. You can turn Viper on and off for any Emacs state. When Viper is turned
452 on, Vi state can be used to move around. In Insert state, the bindings for
453 these modes can be accessed. For beginners (users at Viper levels 1 and 2),
454 these bindings are suppressed in Insert state, so that new users are not
455 confused by the Emacs states. Note that unless you allow Emacs bindings in
456 Insert state, you cannot do many interesting things, like language
457 sensitive editing. For the novice user (at Viper level 1), all major mode
458 bindings are turned off in Vi state as well. This includes the bindings for
459 key sequences that start with @kbd{C-c}, which practically means that all
460 major mode bindings are unsupported. @xref{Customization}, to find out how
461 to allow Emacs keys in Insert state.
464 * Emacs State:: This is the state you should learn more about when
465 you get up to speed with Viper.
466 * Vi State:: Vi commands are executed in this state.
467 * Insert State:: You can enter text, and also can do sophisticated
468 editing if you know enough Emacs commands.
469 * Replace State:: Like Insert mode, but it is invoked via the
470 replacement commands, such as cw, C, R, etc.
474 @subsection Emacs State
480 You will be in this mode only by accident (hopefully). This is the state
481 Emacs is normally in (imagine!!). Now leave it as soon as possible by
482 typing @kbd{C-z}. Then you will be in Vi state (sigh of relief) :-).
484 Emacs state is actually a Viperism to denote all the major and minor modes
485 (@pxref{Emacs Preliminaries}) other than Viper that Emacs can be in. Emacs
486 can have several modes, such as C mode for editing C programs, LaTeX mode
487 for editing LaTeX documents, Dired for directory editing, etc. These are
488 major modes, each with a different set of key-bindings. Viper states are
489 orthogonal to these Emacs major modes. The presence of these language
490 sensitive and other modes is a major win over Vi. @xref{Improvements over
493 The bindings for these modes can be made available in the Viper Insert state
494 as well as in Emacs state. Unless you specify your user level as 1 (a
495 novice), all major mode key sequences that start with @kbd{C-x} and
496 @kbd{C-c} are also available in Vi state. This is important because major
497 modes designed for editing files, such as cc-mode or latex-mode, use key
498 sequences that begin with @kbd{C-x} and @kbd{C-c}.
500 There is also a key that lets you temporarily escape to Vi command state
501 from the Insert state: typing @kbd{C-z} will let you execute a
502 single Vi command while staying in Viper's Insert state.
510 This is the Vi command mode. When Viper is in Vi state, you will see the sign
511 <V> in the mode line. Most keys will work as in Vi. The notable
517 @kbd{C-x} is used to invoke Emacs commands, mainly those that do window
518 management. @kbd{C-x 2} will split a window, @kbd{C-x 0} will close a
519 window. @kbd{C-x 1} will close all other windows. @kbd{C-xb} is used to
520 switch buffers in a window, and @kbd{C-xo} to move through windows.
521 These are about the only necessary keystrokes.
522 For the rest, see the GNU Emacs Manual.
526 For user levels 2 and higher, this key serves as a prefix key for the key
527 sequences used by various major modes. For users at Viper level 1, @kbd{C-c}
534 These are the Emacs @samp{quit} keys.
535 There will be cases where you will have to
536 use @kbd{C-g} to quit. Similarly, @kbd{C-]} is used to exit
537 @samp{Recursive Edits} in Emacs for which there is no comparable Vi
538 functionality and no key-binding. Recursive edits are indicated by
539 @samp{[]} brackets framing the modes on the mode line.
540 @xref{Recursive Edit,Recursive
541 Edit,Recursive Edit,emacs,The GNU Emacs Manual}.
542 At user level 1, @kbd{C-g} is bound to @code{viper-info-on-file}
548 Viper uses @key{ESC} as a switch between Insert and Vi states. Emacs uses
549 @key{ESC} for Meta. The Meta key is very important in Emacs since many
550 functions are accessible only via that key as @kbd{M-x function-name}.
551 Therefore, we need to simulate it somehow. In Viper's Vi, Insert, and
552 Replace states, the meta key is set to be @kbd{C-\}. Thus, to get
553 @kbd{M-x}, you should type @kbd{C-\ x} (if the keyboard has no Meta key,
554 which is rare these days).
555 This works both in the Vi command state and in the Insert and Replace
556 states. In Vi command state, you can also use @kbd{\ @key{ESC}} as the
559 Note: Emacs binds @kbd{C-\} to a function that offers to change the
560 keyboard input method in the multilingual environment. Viper overrides this
561 binding. However, it is still possible to switch the input method by typing
562 @kbd{\ C-\} in the Vi command state and @kbd{C-z \ C-\} in the Insert state.
563 Or you can use the MULE menu in the menubar.
566 Other differences are mostly improvements. The ones you should know
572 @kbd{u} will undo. Undo can be repeated by the @kbd{.} key. Undo itself
573 can be undone. Another @kbd{u} will change the direction. The presence
574 of repeatable undo means that @kbd{U}, undoing lines, is not very
575 important. Therefore, @kbd{U} also calls @code{viper-undo}.
576 @cindex multiple undo
581 Most commands, @kbd{~}, @kbd{[[}, @kbd{p}, @kbd{/}, @dots{}, etc., take counts.
583 @comment ]] Just to balance parens
585 Viper uses Emacs Regular Expressions for searches. These are a superset of
587 expressions, excepting the change-of-case escapes @samp{\u}, @samp{\L},
588 @dots{}, etc. @xref{Regexps,,Syntax of Regular Expressions,emacs,The
589 GNU Emacs Manual}, for details.
590 Files specified to @kbd{:e} use @code{csh} regular expressions
591 (globbing, wildcards, what have you).
592 However, the function @code{viper-toggle-search-style}, bound to @kbd{C-c /},
593 lets the user switch from search with regular expressions to plain vanilla
594 search and vice versa. It also lets one switch from case-sensitive search
595 to case-insensitive and back.
596 @xref{Viper Specials}, for more details.
597 @cindex regular expressions
598 @cindex vanilla search
599 @cindex case-sensitive search
600 @cindex case-insensitive search
605 The current working directory of a buffer is automatically inserted in the
606 minibuffer if you type @kbd{:e} then space. Absolute filenames are
607 required less often in Viper. For file names, Emacs uses a convention that
608 is slightly different from other programs. It is designed to minimize the
609 need for deleting file names that Emacs provides in its prompts. (This is
610 usually convenient, but occasionally the prompt may suggest a wrong file
611 name for you.) If you see a prompt @kbd{/usr/foo/} and you wish to edit the
612 file @kbd{~/.viper}, you don't have to erase the prompt. Instead, simply
613 continue typing what you need. Emacs will interpret @kbd{/usr/foo/~/.viper}
614 correctly. Similarly, if the prompt is @kbd{~/foo/} and you need to get to
615 @kbd{/bar/file}, keep typing. Emacs interprets @kbd{~/foo//bar/} as
616 @kbd{/bar/file}, since when it sees @samp{//}, it understands that
617 @kbd{~/foo/} is to be discarded.
619 The command @kbd{:cd} will change the default directory for the
620 current buffer. The command @kbd{:e} will interpret the
621 filename argument in @code{csh}. @xref{Customization}, if you
622 want to change the default shell.
623 The command @kbd{:next} takes counts from
624 @kbd{:args}, so that @kbd{:rew} is obsolete. Also, @kbd{:args} will show only
625 the invisible files (i.e., those that are not currently seen in Emacs
628 When applicable, Ex commands support file completion and history. This
629 means that by typing a partial file name and then @key{TAB}, Emacs will try
630 to complete the name or it will offer a menu of possible completions.
631 This works similarly to Tcsh and extends the behavior of Csh. While Emacs
632 is waiting for a file name, you can type @kbd{M-p} to get the previous file
633 name you typed. Repeatedly typing @kbd{M-p} and @kbd{M-n} will let you
634 browse through the file history.
636 Like file names, partially typed Ex commands can be completed by typing
637 @key{TAB}, and Viper keeps the history of Ex commands. After typing
638 @kbd{:}, you can browse through the previously entered Ex commands by
639 typing @kbd{M-p} and @kbd{M-n}. Viper tries to rationalize when it puts Ex
640 commands on the history list. For instance, if you typed @kbd{:w!@: foo},
641 only @kbd{:w!} will be placed on the history list. This is because the
642 last history element is the default that can be invoked simply by typing
643 @kbd{: @key{RET}}. If @kbd{:w!@: foo} were placed on the list, it would be all to
644 easy to override valuable data in another file. Reconstructing the full
645 command, @kbd{:w!@: foo}, from the history is still not that hard, since Viper
646 has a separate history for file names. By typing @kbd{: M-p}, you will get
647 @kbd{:w!} in the minibuffer. Then, repeated @kbd{M-p} will get you through
648 the file history, inserting one file name after another.
650 In contrast to @kbd{:w!@: foo}, if the command were @kbd{:r foo}, the entire
651 command will appear in the history list. This is because having @kbd{:r}
652 alone as a default is meaningless, since this command requires a file
656 As in Vi, Viper's destructive commands can be re-executed by typing `@kbd{.}'.
657 However, in addition, Viper keeps track of the history of such commands. This
658 history can be perused by typing @kbd{C-c M-p} and @kbd{C-c M-n}.
659 Having found the appropriate command, it can be then executed by typing
661 @xref{Improvements over Vi}, for more information.
664 @subsection Insert State
668 To avoid confusing the beginner (at Viper level 1 and 2), Viper makes only the
669 standard Vi keys available in Insert state. The implication is that
670 Emacs major modes cannot be used in Insert state.
671 It is strongly recommended that as soon as you are comfortable, make the
672 Emacs state bindings visible (by changing your user level to 3 or higher).
673 @xref{Customization},
674 to see how to do this.
676 Once this is done, it is possible to do quite a bit of editing in
677 Insert state. For instance, Emacs has a @dfn{yank} command, @kbd{C-y},
678 which is similar to Vi's @kbd{p}. However, unlike @kbd{p}, @kbd{C-y} can be
679 used in Insert state of Viper. Emacs also has a kill ring where it keeps
680 pieces of text you deleted while editing buffers. The command @kbd{M-y} is
681 used to delete the text previously put back by Emacs's @kbd{C-y} or by Vi's
682 @kbd{p} command and reinsert text that was placed on the kill-ring earlier.
684 This works both in Vi and Insert states.
685 In Vi state, @kbd{M-y} is a much better alternative to the usual Vi's way
686 of recovering the 10 previously deleted chunks of text. In Insert state,
688 use this as follows. Suppose you deleted a piece of text and now you need
689 to re-insert it while editing in Insert mode. The key @kbd{C-y} will put
690 back the most recently deleted chunk. If this is not what you want, type
691 @kbd{M-y} repeatedly and, hopefully, you will find the chunk you want.
693 Finally, in Insert and Replace states, Viper provides the history of
694 pieces of text inserted in previous insert or replace commands. These
695 strings of text can be recovered by repeatedly typing @kbd{C-c M-p} or
696 @kbd{C-c M-n} while in Insert or Replace state. (This feature is disabled
697 in the minibuffer: the above keys are usually bound to other histories,
698 which are more appropriate in the minibuffer.)
703 You can call Meta functions from Insert state. As in Vi state, the Meta key
704 is @kbd{C-\}. Thus @kbd{M-x} is typed as @kbd{C-\ x}.
706 Other Emacs commands that are useful in Insert state are @kbd{C-e}
707 and @kbd{C-a}, which move the cursor to the end and the beginning of the
708 current line, respectively. You can also use @kbd{M-f} and @kbd{M-b},
709 which move the cursor forward (or backward) one word.
710 If your display has a Meta key, these functions are invoked by holding the
711 Meta key and then typing @kbd{f} and @kbd{b}, respectively. On displays
712 without the Meta key, these functions are invoked by typing
713 @kbd{C-\ f} and @kbd{C-\ b} (@kbd{C-\} simulates the Meta key in Insert
714 state, as explained above).
716 The key @kbd{C-z} is sometimes also useful in Insert state: it allows you
717 to execute a single command in Vi state without leaving the Insert state!
718 For instance, @kbd{C-z d2w} will delete the next two words without leaving
721 When Viper is in Insert state, you will see <I> in the mode line.
724 @subsection Replace State
726 @cindex Replace state
728 This state is entered through Vi replacement commands, such as @kbd{C},
729 @kbd{cw}, etc., or by typing @kbd{R}. In Replace state, Viper puts <R> in
730 the mode line to let you know which state is in effect. If Replace state is
731 entered through @kbd{R}, Viper stays in that state until the user hits
732 @key{ESC}. If this state is entered via the other replacement commands,
733 then Replace state is in effect until you hit @key{ESC} or until you cross
734 the rightmost boundary of the replacement region. In the latter case, Viper
735 changes its state from Replace to Insert (which you will notice by the
736 change in the mode line).
738 Since Viper runs under Emacs, it is possible to switch between buffers
739 while in Replace state. You can also move the cursor using the arrow keys
740 (even on dumb terminals!)@: and the mouse. Because of this freedom (which is
741 unattainable in regular Vi), it is possible to take the cursor outside the
742 replacement region. (This may be necessary for several reasons, including
743 the need to enable text selection and region-setting with the mouse.)
745 The issue then arises as to what to do when the user
746 hits the @key{ESC} key. In Vi, this would cause the text between cursor and
747 the end of the replacement region to be deleted. But what if, as is
748 possible in Viper, the cursor is not inside the replacement region?
750 To solve the problem, Viper keeps track of the last cursor position while it
751 was still inside the replacement region. So, in the above situation, Viper
752 would delete text between this position and the end of the replacement
756 @section The Minibuffer
760 The minibuffer is where commands are entered in. Editing can be done
761 by commands from Insert state, namely:
771 Quote the following character
775 Emacs quit and abort keys. These may be necessary. @xref{Vi State}, for an
778 These keys are bound to functions that peruse minibuffer history. The
779 precise history to be perused depends on the context. It may be the history
780 of search strings, Ex commands, file names, etc.
782 If the minibuffer is entered via the Viper search commands @kbd{/} or
783 @kbd{?}, then this key inserts the last search string used by the
784 Emacs incremental search command
785 (which is bound to @kbd{C-s} everywhere except in this case).
788 Most of the Emacs keys are functional in the minibuffer. While in the
789 minibuffer, Viper tries to make editing resemble Vi's behavior when the
790 latter is waiting for the user to type an Ex command. In particular, you
791 can use the regular Vi commands to edit the minibuffer. You can switch
792 between the Vi state and Insert state at will, and even use the replace mode.
793 Initially, the minibuffer comes up in Insert state.
795 Some users prefer plain Emacs bindings in the minibuffer. To this end, set
796 @code{viper-vi-style-in-minibuffer} to @code{nil} in @file{.viper}.
797 @xref{Customization}, to learn how to do this.
799 When the minibuffer changes Viper states, you will notice that the appearance
800 of the text there changes as well. This is useful because the minibuffer
801 has no mode line to tell which Vi state it is in.
802 The appearance of the text in the minibuffer can be changed.
803 @xref{Viper Specials}, for more details.
805 @node Multiple Files in Viper
806 @section Multiple Files in Viper
808 @cindex multiple files
809 @cindex managing multiple files
811 Viper can edit multiple files. This means, for example that you never need
812 to suffer through @code{No write since last change} errors.
813 Some Viper elements are common over all the files.
819 Textmarkers remember @emph{files and positions}.
820 If you set marker @samp{a} in
821 file @file{foo}, start editing file @file{bar} and type @kbd{'a}, then
822 @emph{YOU WILL SWITCH TO FILE @file{foo}}. You can see the contents of a
823 textmarker using the Viper command @kbd{[<a-z>} where <a-z> are the
824 textmarkers, e.g., @kbd{[a} to view marker @samp{a} .
825 @item Repeated Commands
826 Command repetitions are common over files. Typing @kbd{!!} will repeat the
827 last @kbd{!} command whichever file it was issued from.
828 Typing @kbd{.} will repeat the last command from any file, and
829 searches will repeat the last search. Ex commands can be repeated by typing
831 Note: in some rare cases, that @kbd{: @key{RET}} may do something dangerous.
832 However, usually its effect can be undone by typing @kbd{u}.
835 Registers are common to files. Also, text yanked with @kbd{y} can be
836 put back (@kbd{p}) into any file. The Viper command @kbd{]<a-z>}, where <a-z> are
837 the registers, can be used to look at the contents of a register, e.g.,
838 type @kbd{]a} to view register @samp{a}.
840 There is one difference in text deletion that you should be
841 aware of. This difference comes from Emacs and was adopted in Viper
842 because we find it very useful. In Vi, if you delete a line, say, and then
843 another line, these two deletions are separated and are put back
844 separately if you use the @samp{p} command. In Emacs (and Viper), successive
845 series of deletions that are @emph{not interrupted} by other commands are
846 lumped together, so the deleted text gets accumulated and can be put back
847 as one chunk. If you want to break a sequence of deletions so that the
848 newly deleted text could be put back separately from the previously deleted
849 text, you should perform a non-deleting action, e.g., move the cursor one
850 character in any direction.
851 @item Absolute Filenames
852 @cindex absolute file names
853 The current directory name for a file is automatically prepended to the
855 @kbd{:e}, @kbd{:r}, @kbd{:w}, etc., command (in Emacs, each buffer has a
857 This directory is inserted in the minibuffer once you type space after
858 @kbd{:e, r}, etc. Viper also supports completion of file names and Ex
859 commands (@key{TAB}), and it keeps track of
860 command and file history (@kbd{M-p}, @kbd{M-n}).
861 Absolute filenames are required less
864 You should be aware that Emacs interprets @kbd{/foo/bar//bla} as
865 @kbd{/bla} and @kbd{/foo/~/bar} as @kbd{~/bar}. This is designed to
866 minimize the need for erasing file names that Emacs suggests in its
867 prompts, if a suggested file name is not what you wanted.
869 The command @kbd{:cd} will change the default directory for the
870 current Emacs buffer. The Ex command @kbd{:e} will interpret the
871 filename argument in @samp{csh}, by default. @xref{Customization}, if you
876 Currently undisplayed files can be listed using the @kbd{:ar} command. The
877 command @kbd{:n} can be given counts from the @kbd{:ar} list to switch to
878 other files. For example, use `:n3' to move to the third file in that list.
880 @node Unimplemented Features
881 @section Unimplemented Features
883 Unimplemented features include:
887 @kbd{:ab} and @kbd{:una} are not implemented, since
888 @kbd{:ab} is considered obsolete, since Emacs has much
889 more powerful facilities for defining abbreviations.
891 @kbd{:set option?} is not implemented. The current
892 @kbd{:set} can also be used to set Emacs variables.
894 @kbd{:se list} requires modification of the display code for Emacs, so
895 it is not implemented.
896 A useful alternative is @code{cat -t -e file}. Unfortunately, it cannot
897 be used directly inside Emacs, since Emacs will obdurately change @samp{^I}
901 @node Improvements over Vi
902 @chapter Improvements over Vi
904 Some common problems with Vi and Ex have been solved in Viper. This
905 includes better implementation of existing commands, new commands, and
906 the facilities provided by Emacs.
909 * Basics:: Basic Viper differences, Multi-file effects.
910 * Undo and Backups:: Multiple undo, auto-save, backups and changes
911 * History:: History for Ex and Vi commands.
912 * Macros and Registers:: Keyboard Macros (extended ".")@: @@reg execution.
913 * Completion:: Filename and Command Completion for Ex.
914 * Improved Search:: Incremental Search and Buffer Content Search.
915 * Abbreviation Facilities:: Normal Abbrevs, Templates, and Dynamic Abbrevs.
916 * Movement and Markers:: Screen Editor movements, viewing textmarkers.
917 * New Commands:: Commands that do not exist in Vi.
918 * Useful Packages:: A Sampling of some Emacs packages, and things
919 you should know about.
925 The Vi command set is based on the idea of combining motion commands
926 with other commands. The motion command is used as a text region
927 specifier for other commands.
928 We classify motion commands into @dfn{point commands} and
931 @cindex point commands
933 The point commands are:
936 @kbd{h}, @kbd{l}, @kbd{0}, @kbd{$}, @kbd{w}, @kbd{W}, @kbd{b}, @kbd{B},
937 @kbd{e}, @kbd{E}, @kbd{(}, @kbd{)}, @kbd{/}, @kbd{?}, @kbd{`}, @kbd{f},
938 @kbd{F}, @kbd{t}, @kbd{T}, @kbd{%}, @kbd{;}, @kbd{,}, @kbd{^}
941 @cindex line commands
943 The line commands are:
946 @kbd{j}, @kbd{k}, @kbd{+}, @kbd{-}, @kbd{H}, @kbd{M}, @kbd{L}, @kbd{@{},
947 @kbd{@}}, @kbd{G}, @kbd{'}, @kbd{[[}, @kbd{]]}, @kbd{[]}
951 @cindex region specification
952 @cindex expanding (region)
953 @cindex describing regions
954 @cindex movement commands
957 If a point command is given as an argument to a modifying command, the
958 region determined by the point command will be affected by the modifying
959 command. On the other hand, if a line command is given as an argument to a
960 modifying command, the region determined by the line command will be
961 enlarged so that it will become the smallest region properly containing the
962 region and consisting of whole lines (we call this process @dfn{expanding
963 the region}), and then the enlarged region will be affected by the modifying
965 Text Deletion Commands (@pxref{Deleting Text}), Change commands
966 (@pxref{Changing Text}), even Shell Commands (@pxref{Shell Commands})
967 use these commands to describe a region of text to operate on.
968 Thus, type @kbd{dw} to delete a word, @kbd{>@}} to shift a paragraph, or
969 @kbd{!'afmt} to format a region from @samp{point} to textmarker
972 @cindex r and R region specifiers
974 Viper adds the region specifiers @samp{r} and @samp{R}. Emacs has a
975 special marker called @dfn{mark}. The text-area between the current cursor
976 position @dfn{point} and the @dfn{mark} is called the @dfn{region}.
977 @samp{r} specifies the raw region and @samp{R} is the expanded region
978 (i.e., the minimal contiguous chunk of full lines that contains the raw
980 @kbd{dr} will now delete the region, @kbd{>r} will shift it, etc.
981 @kbd{r,R} are not motion commands, however. The special mark is set by
982 @kbd{m.} and other commands. @xref{Marking}, for more info.
984 Viper also adds counts to most commands for which it would make sense.
986 In the Overview chapter, some Multiple File issues were discussed
987 (@pxref{Multiple Files in Viper}). In addition to the files, Emacs has
988 buffers. These can be seen in the @kbd{:args} list and switched using
989 @kbd{:next} if you type @kbd{:set ex-cycle-through-non-files t}, or
990 specify @code{(setq ex-cycle-through-non-files t)} in your @file{.viper}
991 file. @xref{Customization}, for details.
993 @node Undo and Backups
994 @section Undo and Backups
998 Viper provides multiple undo. The number of undo's and the size is limited
999 by the machine. The Viper command @kbd{u} does an undo. Undo can be
1000 repeated by typing @kbd{.} (a period). Another @kbd{u} will undo the undo,
1002 @kbd{.} will repeat it. Typing @kbd{u} does the first undo, and changes the
1005 @cindex backup files
1008 Since the undo size is limited, Viper can create backup files and
1009 auto-save files. It will normally do this automatically. It is possible
1010 to have numbered backups, etc. For details, @pxref{Backup,,Backup and
1011 Auto-Save,emacs,The GNU Emacs Manual}.
1013 @comment [ balance parens
1014 @cindex viewing registers and markers
1019 The results of the 9 previous changes are available in the 9 numeric
1020 registers, as in Vi. The extra goody is the ability to @emph{view} these
1021 registers, in addition to being able to access them through @kbd{p} and
1022 @kbd{M-y} (@xref{Insert State}, for details.)
1023 The Viper command @kbd{] register} will display the contents of any
1024 register, numeric or alphabetical. The related command @kbd{[ textmarker}
1025 will show the text around the textmarker. @samp{register} and @samp{textmarker}
1026 can be any letters from a through z.
1027 @comment ] balance parens
1035 History is provided for Ex commands, Vi searches, file names, pieces of
1036 text inserted in earlier commands that use Insert or Replace state, and for
1037 destructive commands in Vi state. These are
1038 useful for fixing those small typos that screw up searches and @kbd{:s},
1039 and for eliminating routine associated with repeated typing of file names
1040 or pieces of text that need to be inserted frequently.
1041 At the @kbd{:} or @kbd{/} prompts in the minibuffer, you can do the following:
1045 To move to previous and next history items. This causes the history
1046 items to appear on the command line, where you can edit them, or
1047 simply type Return to execute.
1049 To search backward and forward through the history.
1051 Type @key{RET} to accept a default (which is displayed in the prompt).
1054 The history of insertions can be perused by
1055 typing @kbd{C-c M-p} and @kbd{C-c M-n} while in Insert or Replace state.
1056 The history of destructive Vi commands can be perused via the same keys
1057 when Viper is in Vi state. @xref{Viper Specials}, for details.
1059 All Ex commands have a file history. For instance, typing @kbd{:e}, space
1060 and then @kbd{M-p} will bring up the name of the previously typed file
1061 name. Repeatedly typing @kbd{M-p}, @kbd{M-n}, etc., will let you browse
1062 through the file history.
1064 Similarly, commands that have to do with switching buffers
1065 have a buffer history, and commands that expect strings or regular
1066 expressions keep a history on those items.
1068 @node Macros and Registers
1069 @section Macros and Registers
1071 @cindex keyboard macros
1074 @cindex register execution
1076 Viper facilitates the use of Emacs-style keyboard macros. @kbd{@@#} will
1077 start a macro definition. As you type, the commands will be executed, and
1078 remembered (This is called ``learn mode'' in some editors.)
1079 @kbd{@@register} will complete the macro, putting it into @samp{register},
1080 where @samp{register} is any character from @samp{a} through @samp{z}. Then
1081 you can execute this macro using @kbd{@@register}. It is, of course,
1082 possible to yank some text into a register and execute it using
1083 @kbd{@@register}. Typing @kbd{@@@@}, @kbd{@@RET}, or @kbd{@@C-j} will
1084 execute the last macro that was executed using @kbd{@@register}.
1086 Viper will automatically lowercase the register, so that pressing the
1087 @kbd{SHIFT} key for @kbd{@@} will not create problems. This is for
1088 @kbd{@@} macros and @kbd{"p} @emph{only}. In the case of @kbd{y},
1089 @kbd{"Ayy} will append to @emph{register a}. For @kbd{[,],',`}, it
1090 is an error to use a Uppercase register name.
1092 @comment [ balance parens
1093 @cindex viewing registers and markers
1095 The contents of a register can be seen by @kbd{]register}. (@kbd{[textmarker}
1096 will show the contents of a textmarker).
1097 @comment ] balance parens
1099 @cindex last keyboard macro
1101 The last keyboard macro can also be executed using
1102 @kbd{*}, and it can be yanked into a register using @kbd{@@!register}.
1103 This is useful for Emacs style keyboard macros defined using @kbd{C-x(}
1104 and @kbd{C-x)}. Emacs keyboard macros have more capabilities.
1105 @xref{Keyboard Macros,,Keyboard Macros,emacs, The GNU Emacs Manual}, for
1108 Keyboard Macros allow an interesting form of Query-Replace:
1109 @kbd{/pattern} or @kbd{n} to go to the next pattern (the query), followed by a
1110 Keyboard Macro execution @kbd{@@@@} (the replace).
1112 Viper also provides Vi-style macros. @xref{Vi Macros}, for details.
1120 Completion is done when you type @key{TAB}. The Emacs completer does not
1121 grok wildcards in file names. Once you type a wildcard, the completer will
1122 no longer work for that file name. Remember that Emacs interprets a file name
1123 of the form @kbd{/foo//bar} as @kbd{/bar} and @kbd{/foo/~/bar} as
1126 @node Improved Search
1127 @section Improved Search
1129 @cindex buffer search
1132 Viper provides buffer search, the ability to search the buffer for a region
1133 under the cursor. You have to turn this on in @file{.viper} either by calling
1136 (viper-buffer-search-enable)
1140 or by setting @code{viper-buffer-search-char} to, say, @kbd{f3}:
1142 (setq viper-buffer-search-char ?g)
1146 If the user calls @code{viper-buffer-search-enable} explicitly (the first
1147 method), then @code{viper-buffer-search-char} will be set to @kbd{g}.
1148 Regardless of how this feature is enabled, the key
1149 @code{viper-buffer-search-char} will take movement commands, like
1150 @kbd{w,/,e}, to find a region and then search for the contents of that
1151 region. This command is very useful for searching for variable names, etc.,
1152 in a program. The search can be repeated by @kbd{n} or reversed by @kbd{N}.
1154 @cindex incremental search
1156 Emacs provides incremental search. As you type the string in, the
1157 cursor will move to the next match. You can snarf words from the buffer
1158 as you go along. Incremental Search is normally bound to @kbd{C-s} and
1159 @kbd{C-r}. @xref{Customization}, to find out how to change the bindings
1160 of @kbd{C-r or C-s}.
1161 For details, @pxref{Incremental Search,,Incremental
1162 Search,emacs,The GNU Emacs Manual}.
1164 @cindex query replace
1166 Viper also provides a query replace function that prompts through the
1167 minibuffer. It is invoked by the @kbd{Q} key in Vi state.
1169 @cindex mouse search
1171 On a window display, Viper supports mouse search, i.e., you can search for a
1172 word by clicking on it. @xref{Viper Specials}, for details.
1174 Finally, on a window display, Viper highlights search patterns as it finds
1175 them. This is done through what is known as @emph{faces} in Emacs. The
1176 variable that controls how search patterns are highlighted is
1177 @code{viper-search-face}. If you don't want any highlighting at all, put
1179 (copy-face 'default 'viper-search-face)
1181 @vindex @code{viper-search-face}
1183 in @file{~/.viper}. If you want to change how patterns are highlighted, you
1184 will have to change @code{viper-search-face} to your liking. The easiest
1185 way to do this is to use Emacs customization widget, which is accessible
1186 from the menubar. Viper customization group is located under the
1187 @emph{Emulations} customization group, which in turn is under the
1188 @emph{Editing} group (or simply by typing @kbd{:customize}). All Viper
1189 faces are grouped together under Viper's
1190 @emph{Highlighting} group.
1192 Try it: it is really simple!
1194 @node Abbreviation Facilities
1195 @section Abbreviation Facilities
1199 It is possible in Emacs to define abbrevs based on the contents of the
1201 Sophisticated templates can be defined using the Emacs abbreviation
1202 facilities. @xref{Abbrevs,,Abbreviations,emacs,The GNU Emacs Manual}, for
1205 @cindex dynamic abbrevs
1207 Emacs also provides Dynamic Abbreviations. Given a partial word, Emacs
1208 will search the buffer to find an extension for this word. For instance,
1209 one can type @samp{Abbreviations} by typing @samp{A}, followed by a keystroke
1210 that completed the @samp{A} to @samp{Abbreviations}. Repeated typing
1211 will search further back in the buffer, so that one could get
1212 @samp{Abbrevs} by repeating the
1213 keystroke, which appears earlier in the text. Emacs binds this to
1214 @kbd{@key{ESC} /}, so you will have to find a key and bind the function
1215 @code{dabbrev-expand} to that key.
1216 Facilities like this make Vi's @kbd{:ab} command obsolete.
1218 @node Movement and Markers
1219 @section Movement and Markers
1221 @cindex Ex style motion
1222 @cindex line editor motion
1224 Viper can be set free from the line--limited movements in Vi, such as @kbd{l}
1225 refusing to move beyond the line, @key{ESC} moving one character back,
1226 etc. These derive from Ex, which is a line editor. If your @file{.viper}
1230 @code{(setq viper-ex-style-motion nil)}
1234 the motion will be a true screen editor motion. One thing you must then
1235 watch out for is that it is possible to be on the end-of-line character.
1236 The keys @kbd{x} and @kbd{%} will still work correctly, i.e., as if they
1237 were on the last character.
1239 @vindex @code{viper-syntax-preference}
1240 @cindex syntax table
1242 The word-movement commands @kbd{w}, @kbd{e}, etc., and the associated
1243 deletion/yanking commands, @kbd{dw}, @kbd{yw}, etc., can be made to
1244 understand Emacs syntax tables. If the variable
1245 @code{viper-syntax-preference} is set to @code{strict-vi} then
1246 the meaning of @emph{word} is the same as in
1247 Vi. However, if the value is @code{reformed-vi} (the default) then the
1248 alphanumeric symbols will be those specified by the current Emacs syntax
1249 table (which may be different for different major modes) plus the
1250 underscore symbol @kbd{_}, minus some non-word symbols, like '.;,|, etc.
1251 Both @code{strict-vi} and @code{reformed-vi} work close to Vi in
1252 traditional cases, but @code{reformed-vi} does a better job when editing
1253 text in non-Latin alphabets.
1255 The user can also specify the value @code{emacs}, which would
1256 make Viper use exactly the Emacs notion of word. In particular, the
1257 underscore may not be part of a word. Finally, if
1258 @code{viper-syntax-preference} is set to @code{extended}, Viper words would
1259 consist of characters that are classified as alphanumeric @emph{or} as
1260 parts of symbols. This is convenient for writing programs and in many other
1263 @code{viper-syntax-preference} is a local variable, so it can have different
1264 values for different major modes. For instance, in programming modes it can
1265 have the value @code{extended}. In text modes where words contain special
1266 characters, such as European (non-English) letters, Cyrillic letters, etc.,
1267 the value can be @code{reformed-vi} or @code{emacs}.
1269 Changes to @code{viper-syntax-preference} should be done in the hooks to
1270 various major modes by executing @code{viper-set-syntax-preference} as in
1271 the following example:
1274 (viper-set-syntax-preference nil "emacs")
1277 @findex @code{viper-set-syntax-preference}
1279 The above discussion of the meaning of Viper's words concerns only Viper's
1280 movement commands. In regular expressions, words remain the same as in
1281 Emacs. That is, the expressions @code{\w}, @code{\>}, @code{\<}, etc., use
1282 Emacs's idea of what is a word, and they don't look into the value of
1283 variable @code{viper-syntax-preference}. This is because Viper doesn't change
1284 syntax tables in fear of upsetting the various major modes that set these
1289 Textmarkers in Viper remember the file and the position, so that you can
1290 switch files by simply doing @kbd{'a}. If you set up a regimen for using
1291 Textmarkers, this is very useful. Contents of textmarkers can be viewed
1292 by @kbd{[marker}. (Contents of registers can be viewed by @kbd{]register}).
1295 @section New Commands
1297 These commands have no Vi analogs.
1303 These two keys invoke many important Emacs functions. For example, if you
1304 hit @kbd{C-x} followed by @kbd{2}, then the current window will be split
1305 into 2. Except for novice users, @kbd{C-c} is also set to execute an Emacs
1306 command from the current major mode. @key{ESC} will do the same, if you
1307 configure @key{ESC} as Meta by setting @code{viper-no-multiple-ESC} to @code{nil}
1308 in @file{.viper}. @xref{Customization}. @kbd{C-\} in Insert, Replace, or Vi
1309 states will make Emacs think @kbd{Meta} has been hit.
1312 Escape to Emacs to execute a single Emacs command. For instance,
1313 @kbd{\ @key{ESC}} will act like a Meta key.
1316 @cindex query replace
1317 @kbd{Q} is for query replace. By default,
1318 each string to be replaced is treated as a regular expression. You can use
1319 @code{(setq viper-re-query-replace nil)} in your @file{.emacs} file to
1320 turn this off. (For normal searches, @kbd{:se nomagic} will work. Note
1321 that @kbd{:se nomagic} turns Regexps off completely, unlike Vi).
1328 These keys are used to visit files. @kbd{v} will switch to a buffer
1329 visiting file whose name can be entered in the minibuffer. @kbd{V} is
1330 similar, but will use a window different from the current window.
1331 @kbd{C-v} is like @kbd{V}, except that a new frame (X window) will be used
1332 instead of a new Emacs window.
1335 If followed by a certain character @var{ch}, it becomes an operator whose
1336 argument is the region determined by the motion command that follows
1337 (indicated as <move>).
1338 Currently, @var{ch} can be one of @kbd{c}, @kbd{C}, @kbd{g}, @kbd{q}, and
1339 @kbd{s}. For instance, @kbd{#qr} will prompt you for a string and then
1340 prepend this string to each line in the buffer.
1342 @kindex @kbd{#c<move>}
1343 @cindex changing case
1344 Change upper-case characters in the region to lower-case
1345 (@code{downcase-region}).
1346 Emacs command @kbd{M-l} does the same for words.
1348 @kindex @kbd{#C<move>}
1349 Change lower-case characters in the region to upper-case. For instance,
1350 @kbd{# C 3 w} will capitalize 3 words from the current point
1351 (@code{upcase-region}).
1352 Emacs command @kbd{M-u} does the same for words.
1354 @kindex @kbd{#g<move>}
1355 Execute last keyboard macro for each line in the region
1356 (@code{viper-global-execute}).
1358 @kindex @kbd{#q<move>}
1359 Insert specified string at the beginning of each line in the region
1360 (@code{viper-quote-region}). The default string is composed of the comment
1361 character(s) appropriate for the current major mode.
1363 @kindex @kbd{#s<move>}
1364 Check spelling of words in the region (@code{spell-region}).
1365 The function used for spelling is determined from the variable
1366 @code{viper-spell-function}.
1367 @vindex @code{viper-spell-function}
1370 Call last keyboard macro.
1372 Set mark at point and push old mark off the ring
1375 Set mark at beginning and end of buffer, respectively.
1377 Jump to mark and pop mark off the ring. @xref{Mark,,Mark,emacs,The GNU
1378 Emacs Manual}, for more info.
1380 @kindex @kbd{]<a-z>}
1381 View contents of register
1383 @kindex @kbd{[<a-z>}
1384 View filename and position of textmarker
1389 @kindex @kbd{@@<a-z>}
1391 @cindex keyboard macros
1392 @cindex register execution
1394 Begin/end keyboard macro. @@register has a different meaning when used after
1395 a @kbd{@@#}. @xref{Macros and Registers}, for details
1398 Go to end of heading.
1399 @item g <@emph{movement command}>
1400 Search buffer for text delimited by movement command. The canonical
1401 example is @kbd{gw} to search for the word under the cursor.
1402 @xref{Improved Search}, for details.
1406 Quit and Abort Recursive edit. These may be necessary on occasion.
1407 @xref{Vi State}, for a reason.
1409 @kindex @kbd{C-c C-g}
1410 Hitting @kbd{C-c} followed by @kbd{C-g} will display the information on the
1411 current buffer. This is the same as hitting @kbd{C-g} in Vi, but, as
1412 explained above, @kbd{C-g} is needed for other purposes in Emacs.
1415 Without a prefix argument, this command toggles
1416 case-sensitive/case-insensitive search modes and plain vanilla/regular
1417 expression search. With the prefix argument 1, i.e.,
1418 @kbd{1 C-c /}, this toggles case-sensitivity; with the prefix argument 2,
1419 toggles plain vanilla search and search using
1420 regular expressions. @xref{Viper Specials}, for alternative ways to invoke
1422 @cindex vanilla search
1423 @cindex case-sensitive search
1424 @cindex case-insensitive search
1429 In the minibuffer, these commands navigate through the minibuffer
1430 histories, such as the history of search strings, Ex commands, etc.
1434 If the minibuffer is entered via a Viper search commands @kbd{/} or @kbd{?},
1435 then typing this key inserts the last search string used by the
1436 Emacs incremental search command (that is bound to @kbd{C-s} everywhere
1437 except in this case).
1439 @item C-c M-p and C-c M-n
1440 @kindex @kbd{C-c M-p}
1441 @kindex @kbd{C-c M-n}
1442 @cindex Insertion history
1443 @cindex Insertion ring
1444 @cindex Command history
1445 @cindex Command ring
1447 In Insert or Replace state, these commands let the user
1448 peruse the history of insertion strings used in previous insert or replace
1449 commands. Try to hit @kbd{C-c M-p} or @kbd{C-c M-n} repeatedly and see what
1450 happens. @xref{Viper Specials}, for more.
1452 In Vi state, these commands let the user peruse the history of Vi-style
1453 destructive commands, such as @kbd{dw}, @kbd{J}, @kbd{a}, etc.
1454 By repeatedly typing @kbd{C-c M-p} or @kbd{C-c M-n} you will cycle Viper
1455 through the recent history of Vi commands, displaying the commands one by
1457 an appropriate command is found, it can be executed by typing `@kbd{.}'.
1459 Since typing @kbd{C-c M-p} is tedious, it is more convenient to bind an
1460 appropriate function to a function key on the keyboard and use that key.
1461 @xref{Viper Specials}, for details.
1468 The commands @kbd{:args}, @kbd{:next}, @kbd{:pre} behave
1469 differently. @kbd{:pwd} exists to get current directory.
1470 The commands @kbd{:b} and @kbd{:B} switch buffers around. @xref{File and
1471 Buffer Handling}, for details.
1472 There are also the new commands @kbd{:RelatedFile} and
1473 @kbd{PreviousRelatedFile} (which abbreviate to @kbd{R} and @kbd{P},
1474 respectively. @xref{Viper Specials}, for details.
1475 @findex @kbd{:RelatedFile}
1476 @findex @kbd{:PreviousRelatedFile}
1479 Apart from the new commands, many old commands have been enhanced. Most
1480 notably, Vi style macros are much more powerful in Viper than in Vi. @xref{Vi
1481 Macros}, for details.
1483 @node Useful Packages
1484 @section Useful Packages
1486 Some Emacs packages are mentioned here as an aid to the new Viper user, to
1487 indicate what Viper is capable of.
1488 A vast number comes with the standard Emacs distribution, and many more exist
1489 on the net and on the archives.
1491 This manual also mentions some Emacs features a new user
1492 should know about. The details of these are found in the GNU Emacs
1495 The features first. For details, look up the Emacs Manual.
1502 Makes and Compiles can be done from the editor. Error messages will be
1503 parsed and you can move to the error lines.
1506 @cindex interactive shell
1507 You can talk to Shells from inside the editor. Your entire shell session
1508 can be treated as a file.
1512 Mail can be read from and sent within the editor. Several sophisticated
1514 @item Language Sensitive Editing
1515 Editing modes are written for most computer languages in existence. By
1516 controlling indentation, they catch punctuation errors.
1519 The packages, below, represents a drop in the sea of special-purpose
1520 packages that come with standard distribution of Emacs.
1523 @item Transparent FTP
1524 @cindex transparent ftp
1526 @code{ange-ftp.el} can ftp from the editor to files on other machines
1527 transparent to the user.
1528 @item RCS Interfaces
1529 @cindex version maintenance
1532 @code{vc.el} for doing RCS commands from inside the editor
1533 @item Directory Editor
1536 @code{dired.el} for editing contents of directories and for navigating in
1538 @item Syntactic Highlighting
1540 @pindex font-lock.el
1541 @code{font-lock.el} for automatic highlighting various parts of a buffer
1542 using different fonts and colors.
1543 @item Saving Emacs Configuration
1546 @code{desktop.el} for saving/restoring configuration on Emacs exit/startup.
1550 @code{ispell.el} for spell checking the buffer, words, regions, etc.
1551 @item File and Buffer Comparison
1554 @code{ediff.el} for finding differences between files and for applying
1559 Emacs Lisp archives exist on
1560 @samp{archive.cis.ohio-state.edu}
1561 and @samp{wuarchive.wustl.edu}
1565 @chapter Customization
1567 @cindex customization
1569 Customization can be done in 2 ways.
1573 @cindex initialization
1575 Elisp code in a @file{.viper} file in your home directory. Viper
1576 loads @file{.viper} just before it does the binding for mode
1577 hooks. This is recommended for experts only.
1580 Elisp code in your @file{.emacs} file before and after the @code{(require
1581 'viper)} line. This method is @emph{not} recommended, unless you know what
1582 you are doing. Only two variables, @code{viper-mode} and
1583 @code{viper-custom-file-name}, are supposed to be customized in @file{.emacs},
1584 prior to loading Viper (i.e., prior to @code{(require 'viper)} command.
1587 By executing the @kbd{:customize} Ex command. This takes you to the Emacs
1588 customization widget, which lets you change the values of Viper
1589 customizable variables easily. This method is good for novice and
1590 experts alike. The customization code in the form of Lisp commands will be
1591 placed in @file{~/.emacs} or some other customization file depending on the
1592 version of Emacs that you use. Still, it is recommended to separate
1593 Viper-related customization produced by the Emacs customization widget
1594 and keep it in the @file{.viper} file.
1596 Some advanced customization cannot be accomplished this way, however, and
1597 has to be done in Emacs Lisp in the @file{.viper} file. For the common
1598 cases, examples are provided that you can use directly.
1603 * Rudimentary Changes:: Simple constant definitions.
1604 * Key Bindings:: Enabling Emacs Keys, Rebinding keys, etc.
1605 * Packages that Change Keymaps:: How to deal with such beasts.
1606 * Viper Specials:: Special Viper commands.
1607 * Vi Macros:: How to do Vi style macros.
1610 @node Rudimentary Changes
1611 @section Rudimentary Changes
1613 @cindex setting variables
1614 @cindex variables for customization
1617 An easy way to customize Viper is to change the values of constants used in
1618 Viper. Here is the list of the constants used in Viper and their default
1619 values. The corresponding :se command is also indicated. (The symbols
1620 @code{t} and @code{nil} represent ``true'' and ``false'' in Lisp).
1622 Viper supports both the abbreviated Vi variable names and their full
1623 names. Variable completion is done on full names only. @key{TAB} and
1625 variable names. Typing `=' will complete the name and then will prompt for
1626 a value, if applicable. For instance, @kbd{:se au @key{SPC}} will complete the
1627 command to @kbd{:set autoindent}; @kbd{:se ta @key{SPC}} will complete the command
1628 and prompt further like this: @kbd{:set tabstop = }.
1629 However, typing @kbd{:se ts @key{SPC}} will produce a ``No match'' message
1630 because @kbd{ts} is an abbreviation for @kbd{tabstop} and Viper supports
1631 completion on full names only. However, you can still hit @key{RET}
1632 or @kbd{=}, which will complete the command like this: @kbd{:set ts = } and
1633 Viper will be waiting for you to type a value for the tabstop variable.
1634 To get the full list of Vi variables, type @kbd{:se @key{SPC} @key{TAB}}.
1637 @item viper-auto-indent nil
1638 @itemx :se ai (:se autoindent)
1639 @itemx :se ai-g (:se autoindent-global)
1640 If @code{t}, enable auto indentation.
1641 by @key{RET}, @kbd{o} or @kbd{O} command.
1643 @code{viper-auto-indent} is a local variable. To change the value globally, use
1644 @code{setq-default}. It may be useful for certain major modes to have their
1645 own values of @code{viper-auto-indent}. This can be achieved by using
1646 @code{setq} to change the local value of this variable in the hooks to the
1647 appropriate major modes.
1649 @kbd{:se ai} changes the value of @code{viper-auto-indent} in the current
1650 buffer only; @kbd{:se ai-g} does the same globally.
1651 @item viper-electric-mode t
1652 If not @code{nil}, auto-indentation becomes electric, which means that
1653 @key{RET}, @kbd{O}, and @kbd{o} indent cursor according to the current
1654 major mode. In the future, this variable may control additional electric
1657 This is a local variable: @code{setq} changes the value of this variable
1658 in the current buffer only. Use @code{setq-default} to change the value in
1660 @item viper-case-fold-search nil
1661 @itemx :se ic (:se ignorecase)
1662 If not @code{nil}, search ignores cases.
1663 This can also be toggled by quickly hitting @kbd{/} twice.
1664 @item viper-re-search nil
1666 If not @code{nil}, search will use regular expressions; if @code{nil} then
1668 This behavior can also be toggled by quickly hitting @kbd{/} trice.
1669 @item buffer-read-only
1670 @itemx :se ro (:se readonly)
1671 Set current buffer to read only. To change globally put
1672 @code{(setq-default buffer-read-only t)} in your @file{.emacs} file.
1673 @item blink-matching-paren t
1674 @itemx :se sm (:se showmatch)
1675 Show matching parens by blinking cursor.
1676 @item tab-width t (default setting via @code{setq-default})
1677 @itemx :se ts=value (:se tabstop=value)
1678 @itemx :se ts-g=value (:se tabstop-global=value)
1679 @code{tab-width} is a local variable that controls the width of the tab stops.
1680 To change the value globally, use @code{setq-default}; for local settings,
1683 The command @kbd{:se ts}
1684 sets the tab width in the current
1685 buffer only; it has no effect on other buffers.
1687 The command @kbd{:se ts-g} sets tab width globally,
1688 for all buffers where the tab is not yet set locally,
1689 including the new buffers.
1691 Note that typing @key{TAB} normally
1692 doesn't insert the tab, since this key is usually bound to
1693 a text-formatting function, @code{indent-for-tab-command} (which facilitates
1694 programming and document writing). Instead, the tab is inserted via the
1695 command @code{viper-insert-tab}, which is bound to @kbd{S-tab} (shift + tab).
1697 On some non-windowing terminals, Shift doesn't modify the @key{TAB} key, so
1698 @kbd{S-tab} behaves as if it were @key{TAB}. In such a case, you will have
1699 to bind @code{viper-insert-tab} to some other convenient key.
1701 @item viper-shift-width 8
1702 @itemx :se sw=value (:se shiftwidth=value)
1703 The number of columns shifted by @kbd{>} and @kbd{<} commands.
1704 @item viper-search-wrap-around t
1705 @itemx :se ws (:se wrapscan)
1706 If not @code{nil}, search wraps around the end/beginning of buffer.
1707 @item viper-search-scroll-threshold 2
1708 If search lands within this many lines of the window top or bottom, the
1709 window will be scrolled up or down by about 1/7-th of its size, to reveal
1710 the context. If the value is negative, don't scroll.
1711 @item viper-tags-file-name "TAGS"
1712 The name of the file used as the tag table.
1713 @item viper-re-query-replace nil
1714 If not @code{nil}, use reg-exp replace in query replace.
1715 @item viper-want-ctl-h-help nil
1716 If not @code{nil}, @kbd{C-h} is bound to @code{help-command};
1717 otherwise, @kbd{C-h} is bound as usual in Vi.
1718 @item viper-vi-style-in-minibuffer t
1719 If not @code{nil}, Viper provides a high degree of compatibility with Vi
1720 insert mode when you type text in the minibuffer; if @code{nil}, typing in
1721 the minibuffer feels like plain Emacs.
1722 @item viper-no-multiple-ESC t
1723 If you set this to @code{nil}, you can use @key{ESC} as Meta in Vi state.
1724 Normally, this is not necessary, since graphical displays have separate
1725 Meta keys (usually on each side of the space bar). On a dumb terminal, Viper
1726 sets this variable to @code{twice}, which is almost like @code{nil}, except
1727 that double @key{ESC} beeps. This, too, lets @key{ESC} to be used as a Meta.
1728 @item viper-fast-keyseq-timeout 200
1729 Key sequences separated by this many milliseconds are treated as Vi-style
1730 keyboard macros. If the key sequence is defined as such a macro, it will be
1731 executed. Otherwise, it is processed as an ordinary sequence of typed keys.
1733 Setting this variable too high may slow down your typing. Setting it too
1734 low may make it hard to type macros quickly enough.
1735 @item viper-ex-style-motion t
1736 Set this to @code{nil}, if you want @kbd{l,h} to cross
1737 lines, etc. @xref{Movement and Markers}, for more info.
1738 @item viper-ex-style-editing t
1739 Set this to @code{nil}, if you want
1740 @kbd{C-h} and @key{DEL} to not stop
1741 at the beginning of a line in Insert state, @key{X} and @key{x} to delete
1742 characters across lines in Vi command state, etc.
1743 @item viper-ESC-moves-cursor-back t
1744 It @code{t}, cursor moves back 1 character when switching from insert state to vi
1745 state. If @code{nil}, the cursor stays where it was before the switch.
1746 @item viper-always t
1747 @code{t} means: leave it to Viper to decide when a buffer must be brought
1749 Insert state, or Emacs state. This heuristics works well in virtually all
1750 cases. @code{nil} means you either has to invoke @code{viper-mode} manually
1751 for each buffer (or you can add @code{viper-mode} to the appropriate major mode
1752 hooks using @code{viper-load-hook}).
1754 This option must be set in the file @file{~/.viper}.
1755 @item viper-custom-file-name "~/.viper"
1756 File used for Viper-specific customization.
1757 Change this setting, if you want. Must be set in @file{.emacs} (not @file{.viper}!)
1758 before Viper is loaded. Note that you
1759 have to set it as a string inside double quotes.
1760 @item viper-spell-function 'ispell-region
1761 Function used by the command @kbd{#c<move>} to spell.
1762 @item viper-glob-function
1763 The value of this variable is the function symbol used to expand wildcard
1764 symbols. This is platform-dependent. The default tries to set this variable
1765 to work with most shells, MS Windows, OS/2, etc. However, if it
1766 doesn't work the way you expect, you should write your own.
1767 Use @code{viper-glob-unix-files} and @code{viper-glob-mswindows-files} in
1768 @file{viper-util.el} as examples.
1770 This feature is used to expand wildcards in the Ex command @kbd{:e}.
1771 Note that Viper doesn't support wildcards in the @kbd{:r} and @kbd{:w}
1772 commands, because file completion is a better mechanism.
1773 @findex @code{viper-glob-function}
1775 @item ex-cycle-other-window t
1776 If not @code{nil}, @kbd{:n} and @kbd{:b} will cycle through files in another
1777 window, if one exists.
1778 @item ex-cycle-through-non-files nil
1779 @kbd{:n} does not normally cycle through buffers. Set this to get
1781 @item viper-want-emacs-keys-in-insert
1782 This is set to @code{nil} for user levels 1 and 2 and to @code{t} for user
1783 levels 3 and 4. Users who specify level 5 are allowed to set this variable
1784 as they please (the default for this level is @code{t}). If set to
1785 @code{nil}, complete Vi compatibility is provided in Insert state. This is
1786 really not recommended, as this precludes you from using language-specific
1787 features provided by the major modes.
1788 @item viper-want-emacs-keys-in-vi
1789 This is set to @code{nil} for user
1790 level 1 and to @code{t} for user levels 2--4.
1791 At level 5, users are allowed to set this variable as they please (the
1792 default for this level is @code{t}).
1793 If set to @code{nil}, complete Vi compatibility is provided
1794 in Vi command state. Setting this to @code{nil} is really a bad idea,
1795 unless you are a novice, as this precludes the use
1796 of language-specific features provided by the major modes.
1797 @item viper-keep-point-on-repeat t
1798 If not @code{nil}, point is not moved when the user repeats the previous
1799 command by typing `.' This is very useful for doing repeated changes with
1801 @item viper-repeat-from-history-key 'f12
1802 Prefix key used to invoke the macros @kbd{f12 1} and @kbd{f12 2} that repeat
1803 the second-last and the third-last destructive command.
1804 Both these macros are bound (as Viper macros) to
1805 @code{viper-repeat-from-history},
1806 which checks the second key by which it is invoked to see which of the
1807 previous commands to invoke. Viper binds @kbd{f12 1} and @kbd{f12 2} only,
1808 but the user can bind more in @file{~/.viper}. @xref{Vi Macros}, for how to do
1810 @item viper-keep-point-on-undo nil
1811 If not @code{nil}, Viper tries to not move point when undoing commands.
1812 Instead, it will briefly move the cursor to the place where change has
1813 taken place. However, if the undone piece of text is not seen in window,
1814 then point will be moved to the place where the change took place.
1815 Set it to @code{t} and see if you like it better.
1816 @item viper-delete-backwards-in-replace nil
1817 If not @code{nil}, @key{DEL} key will delete characters while moving the cursor
1818 backwards. If @code{nil}, the cursor will move backwards without deleting
1820 @item viper-replace-overlay-face 'viper-replace-overlay-face
1821 On a graphical display, Viper highlights replacement regions instead of
1822 putting a @samp{$} at the end. This variable controls the so called
1823 @dfn{face} used to highlight the region.
1825 By default, @code{viper-replace-overlay-face} underlines the replacement on
1826 monochrome displays and also lays a stipple over them. On color displays,
1827 replacement regions are highlighted with color.
1829 If you know something about Emacs faces and don't like how Viper highlights
1830 replacement regions, you can change @code{viper-replace-overlay-face} by
1831 specifying a new face. (Emacs faces are described in the Emacs Lisp
1832 reference.) On a color display, the following customization method is
1833 usually most effective:
1835 (set-face-foreground viper-replace-overlay-face "DarkSlateBlue")
1836 (set-face-background viper-replace-overlay-face "yellow")
1838 For a complete list of colors available to you, evaluate the expression
1839 @code{(x-defined-colors)}. (Type it in the buffer @code{*scratch*} and then
1840 hit the @kbd{C-j} key.
1842 @item viper-replace-overlay-cursor-color "Red"
1843 @vindex @code{viper-replace-overlay-cursor-color}
1844 Cursor color when it is inside the replacement region.
1845 This has effect only on color displays and only when Emacs runs as an X
1847 @item viper-insert-state-cursor-color nil
1848 @vindex @code{viper-insert-state-cursor-color}
1849 If set to a valid color, this will be the cursor color when Viper is in
1851 @item viper-emacs-state-cursor-color nil
1852 @vindex @code{viper-emacs-state-cursor-color}
1853 If set to a valid color, this will be the cursor color when Viper is in
1855 @item viper-replace-region-end-delimiter "$"
1856 A string used to mark the end of replacement regions. It is used only on
1857 TTYs or if @code{viper-use-replace-region-delimiters} is non-@code{nil}.
1858 @item viper-replace-region-start-delimiter ""
1859 A string used to mark the beginning of replacement regions. It is used
1860 only on TTYs or if @code{viper-use-replace-region-delimiters} is non-@code{nil}.
1861 @item viper-use-replace-region-delimiters
1862 If non-@code{nil}, Viper will always use @code{viper-replace-region-end-delimiter} and
1863 @code{viper-replace-region-start-delimiter} to delimit replacement regions,
1864 even on color displays (where this is unnecessary). By default, this
1865 variable is non-@code{nil} only on TTYs or monochrome displays.
1866 @item viper-allow-multiline-replace-regions t
1867 If non-@code{nil}, multi-line text replacement regions, such as those produced by
1868 commands @kbd{c55w}, @kbd{3C}, etc., will stay around until the user exits
1869 the replacement mode. In this variable is set to @code{nil}, Viper will
1870 emulate the standard Vi behavior, which supports only intra-line
1871 replacement regions (and multi-line replacement regions are deleted).
1872 @item viper-toggle-key "\C-z"
1873 Specifies the key used to switch from Emacs to Vi and back.
1874 Must be set in @file{.viper}. This variable can't be
1875 changed interactively after Viper is loaded.
1877 In Insert state, this key acts as a temporary escape to Vi state, i.e., it
1878 will set Viper up so that the very next command will be executed as if it
1879 were typed in Vi state.
1880 @item viper-buffer-search-char nil
1881 Key used for buffer search. @xref{Viper Specials}, for details.
1882 @item viper-surrounding-word-function 'viper-surrounding-word
1883 The value of this variable is a function name that is used to determine
1884 what constitutes a word clicked upon by the mouse. This is used by mouse
1886 @item viper-search-face 'viper-search-face
1887 Variable that controls how search patterns are highlighted when they are
1889 @item viper-vi-state-hook nil
1890 List of parameterless functions to be run just after entering the Vi
1892 @item viper-insert-state-hook nil
1893 Same for Insert state. This hook is also run after entering Replace state.
1894 @item viper-replace-state-hook nil
1895 List of (parameterless) functions called just after entering Replace state
1896 (and after all @code{viper-insert-state-hook}).
1897 @item viper-emacs-state-hook nil
1898 List of (parameterless) functions called just after switching from Vi state
1900 @item viper-load-hook nil
1901 List of (parameterless) functions called just after loading Viper. This is
1902 the last chance to do customization before Viper is up and running.
1905 You can reset some of these constants in Viper with the Ex command @kbd{:set}
1906 (when so indicated in the table). Or you
1907 can include a line like this in your @file{.viper} file:
1909 (setq viper-case-fold-search t)
1911 @vindex @code{viper-auto-indent}
1912 @vindex @code{viper-electric-mode}
1913 @vindex @code{viper-case-fold-search}
1914 @vindex @code{viper-re-search}
1915 @vindex @code{viper-shift-width}
1916 @vindex @code{buffer-read-only}
1917 @vindex @code{viper-search-wrap-around}
1918 @vindex @code{viper-search-scroll-threshold}
1919 @vindex @code{viper-search-face}
1920 @vindex @code{viper-tags-file-name}
1921 @vindex @code{viper-re-query-replace}
1922 @vindex @code{viper-want-ctl-h-help}
1923 @vindex @code{viper-vi-style-in-minibuffer}
1924 @vindex @code{viper-no-multiple-ESC}
1925 @vindex @code{viper-always}
1926 @vindex @code{viper-fast-keyseq-timeout}
1927 @vindex @code{viper-ex-style-motion}
1928 @vindex @code{viper-ex-style-editing}
1929 @vindex @code{viper-ESC-moves-cursor-back}
1930 @vindex @code{viper-custom-file-name}
1931 @vindex @code{viper-spell-function}
1932 @vindex @code{ex-cycle-other-window}
1933 @vindex @code{ex-cycle-through-non-files}
1934 @vindex @code{viper-want-emacs-keys-in-insert}
1935 @vindex @code{viper-want-emacs-keys-in-vi}
1936 @vindex @code{viper-keep-point-on-repeat}
1937 @vindex @code{viper-keep-point-on-undo}
1938 @vindex @code{viper-delete-backwards-in-replace}
1939 @vindex @code{viper-replace-overlay-face}
1940 @vindex @code{viper-replace-region-end-symbol}
1941 @vindex @code{viper-replace-region-start-symbol}
1942 @vindex @code{viper-allow-multiline-replace-regions}
1943 @vindex @code{viper-toggle-key}
1944 @vindex @code{viper-buffer-search-char}
1945 @vindex @code{viper-surrounding-word-function}
1946 @vindex @code{viper-vi-state-hook}
1947 @vindex @code{viper-insert-state-hook}
1948 @vindex @code{viper-replace-state-hook}
1949 @vindex @code{viper-emacs-state-hook}
1952 @section Key Bindings
1954 @cindex key bindings
1957 Viper lets you define hot keys, i.e., you can associate keyboard keys
1958 such as F1, Help, PgDn, etc., with Emacs Lisp functions (that may already
1959 exist or that you will write). Each key has a "preferred form" in
1960 Emacs. For instance, the Up key's preferred form is [up], the Help key's
1961 preferred form is [help], and the Undo key has the preferred form [f14].
1962 You can find out the preferred form of a key by typing @kbd{M-x
1963 describe-key-briefly} and then typing the key you want to know about.
1965 Under the X Window System, every keyboard key emits its preferred form,
1966 so you can just type
1969 (global-set-key [f11] 'calendar) ; L1, Stop
1970 (global-set-key [f14] 'undo) ; L4, Undo
1974 to bind L1 (a key that exists on some SUN workstations) so it will invoke
1975 the Emacs Calendar and to bind L4 so it will undo changes.
1976 However, on a dumb terminal or in an Xterm window, even the standard arrow
1978 not emit the right signals for Emacs to understand. To let Emacs know about
1979 those keys, you will have to find out which key sequences they emit
1980 by typing @kbd{C-q} and then the key (you should switch to Emacs state
1981 first). Then you can bind those sequences to their preferred forms using
1982 @code{input-decode-map} as follows:
1985 (cond ((string= (getenv "TERM") "xterm")
1986 (define-key input-decode-map "\e[192z" [f11]) ; L1
1987 (define-key input-decode-map "\e[195z" [f14]) ; L4, Undo
1990 The above illustrates how to do this for Xterm. On VT100, you would have to
1991 replace "xterm" with "vt100" and also change the key sequences (the same
1992 key may emit different sequences on different types of terminals).
1994 The above keys are global, so they are overwritten by the local maps
1995 defined by the major modes and by Viper itself. Therefore, if you wish to
1996 change a binding set by a major mode or by Viper, read this.
1998 Viper users who wish to specify their own key bindings should be concerned
1999 only with the following three keymaps:
2000 @code{viper-vi-global-user-map} for Vi state commands,
2001 @code{viper-insert-global-user-map} for Insert state commands,
2002 and @code{viper-emacs-global-user-map} for Emacs state commands (note:
2003 customized bindings for Emacs state made to @code{viper-emacs-global-user-map}
2004 are @emph{not} inherited by Insert state).
2006 For more information on Viper keymaps, see the header of the file
2008 If you wish to change a Viper binding, you can use the
2009 @code{define-key} command, to modify @code{viper-vi-global-user-map},
2010 @code{viper-insert-global-user-map}, and @code{viper-emacs-global-user-map}, as
2011 explained below. Each of these key maps affects the corresponding Viper state.
2012 The keymap @code{viper-insert-global-user-map} also affects Viper's Replace
2017 bind a key, say @kbd{C-v}, to the function that scrolls
2018 page down and to make @kbd{0} display information on the current buffer,
2019 putting this in @file{.viper} will do the trick in Vi state:
2021 (define-key viper-vi-global-user-map "\C-v" 'scroll-down)
2024 To set a key globally,
2026 (define-key viper-emacs-global-user-map "\C-c m" 'smail)
2027 (define-key viper-vi-global-user-map "0" 'viper-info-on-file)
2030 Note, however, that this binding may be overwritten by other keymaps, since
2031 the global keymap has the lowest priority.
2032 To make sure that nothing will override a binding in Emacs state, you
2035 (define-key viper-emacs-global-user-map "\C-c m" 'smail)
2038 To customize the binding for @kbd{C-h} in Insert state:
2040 (define-key viper-insert-global-user-map "\C-h"
2041 'my-del-backwards-function)
2045 Each Emacs command key calls some Lisp function. If you have enabled the
2046 Help, (@pxref{Rudimentary Changes}) @kbd{C-h k} will show you the function
2047 for each specific key; @kbd{C-h b} will show all bindings, and @kbd{C-h m}
2048 will provide information on the major mode in effect. If Help is not
2049 enabled, you can still get help in Vi state by prefixing the above commands
2050 with @kbd{\}, e.g., @kbd{\ C-h k} (or you can use the Help menu in the
2051 menu bar, if Emacs runs under X).
2053 Viper users can also change bindings on a per major mode basis. As with
2054 global bindings, this can be done separately for each of the three main Viper
2055 states. To this end, Viper provides the function
2056 @code{viper-modify-major-mode}.
2057 @findex @code{viper-modify-major-mode}
2059 To modify keys in Emacs state for @code{my-favorite-major-mode}, the user
2060 needs to create a sparse keymap, say, @code{my-fancy-map}, bind whatever
2061 keys necessary in that keymap, and put
2064 (viper-modify-major-mode 'dired-mode 'emacs-state my-fancy-map)
2068 in @file{~/.viper}. To do the same in Vi and Insert states, you should use
2069 @code{vi-state} and @code{insert-state}. Changes in Insert state are also
2070 in effect in Replace state. For instance, suppose that the user wants to
2071 use @kbd{dd} in Vi state under Dired mode to delete files, @kbd{u} to unmark
2072 files, etc. The following code in @file{~/.viper} will then do the job:
2075 (setq my-dired-modifier-map (make-sparse-keymap))
2076 (define-key my-dired-modifier-map "dd" 'dired-flag-file-deletion)
2077 (define-key my-dired-modifier-map "u" 'dired-unmark)
2078 (viper-modify-major-mode 'dired-mode 'vi-state my-dired-modifier-map)
2081 A Vi purist may want to modify Emacs state under Dired mode so that
2082 @kbd{k}, @kbd{l}, etc., will move around in directory buffers, as in
2083 Vi. Although this is not recommended, as these keys are bound to useful
2084 Dired functions, the trick can be accomplished via the following code:
2087 (setq my-dired-vi-purist-map (make-sparse-keymap))
2088 (define-key my-dired-vi-purist-map "k" 'viper-previous-line)
2089 (define-key my-dired-vi-purist-map "l" 'viper-forward-char)
2090 (viper-modify-major-mode 'dired-mode
2091 'emacs-state my-dired-vi-purist-map)
2094 Yet another way to customize key bindings in a major mode is to edit the
2095 list @code{viper-major-mode-modifier-list} using the customization widget.
2096 @vindex @code{viper-major-mode-modifier-list}
2097 (This variable is in the Viper-misc customization group.)
2098 The elements of this list are triples of the form: (major-mode viper-state
2099 keymap), where the keymap contains bindings that are supposed to be active
2100 in the given major mode and the given viper-state.
2102 Effects similar to key binding changes can be achieved by defining Vi
2103 keyboard macros using the Ex commands @kbd{:map} and @kbd{:map!}. The
2104 difference is that multi-key Vi macros do not override the keys they are
2105 bound to, unless these keys are typed in quick succession. So, with macros,
2106 one can use the normal keys alongside with the macros. If per-mode
2107 modifications are needed, the user can try both ways and see which one is
2110 @xref{Vi Macros}, for details.
2112 Note: in major modes that come up in @emph{Emacs state} by default, the
2113 aforesaid modifications may not take place immediately (but only after the
2114 buffer switches to some other Viper state and then back to Emacs state). To
2115 avoid this, one should add @code{viper-change-state-to-emacs} to an
2116 appropriate hook of that major mode. (Check the function
2117 @code{viper-set-hooks} in @file{viper.el} for examples.) However, if you
2118 did not set @code{viper-always} to @code{nil}, chances are that you won't
2119 need to perform the above procedure, because Viper will take care of most
2123 Finally, Viper has a facility that lets the user define per-buffer
2124 bindings, i.e., bindings that are in effect in some specific buffers
2125 only. Unlike per-mode bindings described above, per-buffer bindings can be
2126 defined based on considerations other than the major mode. This is done
2127 via the function @code{viper-add-local-keys}, which lets one specify bindings
2128 that should be in effect in the current buffer only and for a specific Viper
2129 state. For instance,
2131 (viper-add-local-keys 'vi-state '(("ZZ" .@: TeX-command-master)
2132 ("ZQ" .@: viper-save-kill-buffer)))
2135 redefines @kbd{ZZ} to invoke @code{TeX-command-master} in @code{vi-state}
2136 and @kbd{ZQ} to save-then-kill the current buffer. These bindings take
2137 effect only in the buffer where this command is executed. The typical use
2138 of this function is to execute the above expression from within a function
2139 that is included in a hook to some major mode. For instance, the above
2141 could be called from a function, @code{my-tex-init}, which may be added to
2142 @code{tex-mode-hook} as follows:
2144 (add-hook 'tex-mode-hook 'my-tex-init)
2147 When TeX mode starts, the hook is executed and the above Lisp expression is
2148 evaluated. Then, the bindings for @kbd{ZZ} and @kbd{ZQ} are changed in Vi
2149 command mode for all buffers in TeX mode.
2151 Another useful application is to bind @kbd{ZZ} to @code{send-mail}
2152 in the Mail mode buffers (the specifics of this depend on which mail
2153 package you are using, @code{rmail}, @code{mh-e}, @code{vm}, etc.
2154 For instance, here is how to do this for @code{mh-e}, the Emacs interface
2157 (defun mh-add-vi-keys ()
2158 "Set up ZZ for MH-e and XMH."
2159 (viper-add-local-keys 'vi-state '(("ZZ" .@: mh-send-letter))))
2160 (add-hook 'mh-letter-mode-hook 'mh-add-vi-keys)
2163 You can also use @code{viper-add-local-keys} to set per buffer
2164 bindings in Insert state and Emacs state by passing as a parameter the
2165 symbols @code{insert-state} and @code{emacs-state}, respectively.
2166 As with global bindings, customized local bindings done to Emacs state
2167 are not inherited by Insert state.
2169 On rare occasions, local keys may be added by mistake. Usually this is done
2170 indirectly, by invoking a major mode that adds local keys (e.g.,
2171 @code{shell-mode} redefines @key{RET}). In such a case, exiting the wrong
2172 major mode won't rid you from unwanted local keys, since these keys are
2173 local to Viper state and the current buffer, not to the major mode.
2174 In such situations, the remedy is to type @kbd{M-x viper-zap-local-keys}.
2176 So much about Viper-specific bindings.
2177 @xref{Customization,,Customization,emacs,The GNU Emacs
2178 Manual}, and the Emacs quick reference card for the general info on key
2181 @vindex @code{input-decode-map}
2182 @vindex @code{function-key-map}
2183 @vindex @code{viper-vi-global-user-map}
2184 @vindex @code{viper-insert-global-user-map}
2185 @vindex @code{viper-emacs-global-user-map}
2186 @findex @code{viper-add-local-keys}
2187 @findex @code{viper-zap-local-keys}
2189 @node Packages that Change Keymaps
2190 @section Packages that Change Keymaps
2191 @cindex C-c and Viper
2192 @cindex Viper and C-c
2194 Viper is designed to coexist with all major and minor modes of Emacs. This
2195 means that bindings set by those modes are generally available with Viper
2196 (unless you explicitly prohibit them by setting
2197 @code{viper-want-emacs-keys-in-vi} and @code{viper-want-emacs-keys-in-insert} to
2199 If @code{viper-always} is set to @code{t} (which is the default), Viper
2200 will try to bring each buffer
2201 in the Viper state that is most appropriate for that buffer.
2202 Usually, this would be the Vi state, but sometimes it could be the Insert
2203 state or the Emacs state.
2205 Some major mode bindings will necessarily be overwritten by Viper. Indeed, in
2206 Vi state, most of the 1-character keys are used for Vi-style editing. This
2207 usually causes no problems because most packages designed for editing files
2208 typically do not bind such keys. Instead, they use key sequences that start
2209 with @kbd{C-x} and @kbd{C-c}. This is why it was so important for us to
2210 free up @kbd{C-x} and @kbd{C-c}.
2211 It is common for language-specific major modes to bind @key{TAB} and
2212 @kbd{C-j} (the line feed) keys to various formatting functions. This is
2213 extremely useful, but may require some getting used to for a Vi user. If you
2214 decide that this feature is not for you, you can re-bind these keys as
2215 explained earlier (@pxref{Customization}).
2217 Binding for @key{TAB} is one of the most unusual aspects of Viper for many
2218 novice users. In Emacs, @key{TAB} is used to format text and programs, and
2219 is extremely useful. For instance, hitting @key{TAB} causes the current
2220 line to be re-indented in accordance with the context. In programming,
2221 this is very important, since improper automatic indentation would
2222 immediately alert the programmer to a possible error. For instance, if a
2223 @kbd{)} or a @kbd{"} is missing somewhere above the current
2224 line, @key{TAB} is likely to mis-indent the line.
2226 For this reason, Viper doesn't change the standard Emacs binding of
2227 @key{TAB}, thereby sacrificing Vi compatibility
2228 (except for users at level 1). Instead, in Viper, the key
2229 @kbd{S-tab} (shift+ tab) is chosen to emulate Vi's @key{TAB}.
2231 We should note that on some non-windowing terminals, Shift doesn't modify
2232 the @key{TAB} key, so @kbd{S-tab} behaves as if it were @key{TAB}. In such
2233 a case, you will have to bind @code{viper-insert-tab} to some other
2236 Some packages, notably Dired, Gnus, Info, etc., attach special meaning to
2237 common keys like @key{SPC}, @kbd{x}, @kbd{d}, @kbd{v}, and others. This
2238 means that Vi command state is inappropriate for working with these
2239 packages. Fortunately, these modes operate on read-only buffers and are
2240 designed not for editing files, but for special-purpose browsing, reading
2241 news, mail, etc., and Vi commands are meaningless in these situations. For
2242 this reason, Viper doesn't force Vi state on such major modes---it
2243 brings them in Emacs state. You can switch to Vi state by typing @kbd{C-z}
2244 if, for instance, you want to do Vi-style search in a buffer (although,
2245 usually, incremental search, which is bound to @kbd{C-s}, is sufficient in
2246 these situations). But you should then switch back to Emacs state if you
2247 plan to continue using these major modes productively. You can also switch
2248 to Vi temporarily, to execute just one command. This is done by typing
2249 @kbd{C-c \}. (In some of these modes, @kbd{/} and @kbd{:} are bound
2250 Vi-style, unless these keys perform essential duties.)
2252 If you would like certain major modes to come up in Emacs state rather than
2253 Vi state (but Viper thinks otherwise), you should put these major modes
2254 on the @code{viper-emacs-state-mode-list} list and delete them from
2255 @code{viper-vi-state-mode-list}.
2256 Likewise, you can force Viper's Insert state on a major mode by putting it
2257 in @code{viper-insert-state-mode-list}.
2258 @vindex @code{viper-emacs-state-mode-list}
2259 @vindex @code{viper-insert-state-mode-list}
2260 @vindex @code{viper-vi-state-mode-list}
2262 It is also possible to impose Vi on some major modes, even though they may
2263 bind common keys to specialized commands. This might make sense for modes
2264 that bind only a small number of common keys. For instance, Viper subverts
2265 the Shell mode by changing the bindings for @kbd{C-m} and @kbd{C-d} using
2266 @code{viper-add-local-keys} described in the section on customization
2267 (@pxref{Customization}).
2269 In some cases, some @emph{minor} modes might override certain essential
2270 bindings in Vi command state. This is not a big problem because this
2271 can happen only in the beginning, when the minor mode kicks in. Typing
2272 @code{M-x viper-mode} will correct the situation. Viper knows about
2273 several such minor modes and takes care of them, so the above trick
2274 is usually not necessary. If you find that some minor mode, e.g.,
2275 @code{nasty-mode} interferes with Viper, putting the following in
2276 @file{.viper} should fix the problem:
2278 (viper-harness-minor-mode "nasty-mode")
2281 The argument to @code{viper-harness-minor-mode} is the name of the file for the
2282 offending minor mode with the suffixes @file{.el} and @file{.elc} removed.
2284 It may not be always obvious which minor mode is at fault. The only
2285 guidance here is to look into the file that defines the minor mode you are
2286 suspecting, say @file{nasty-mode.el}, and see if it has a variable called
2287 @code{nasty-mode-map}. Then check if there is a statement of the form
2289 (define-key nasty-mode-map key function)
2292 that binds the misbehaving
2293 keys. If so, use the above line to harness @code{nasty-mode}. If your
2294 suspicion is wrong, no harm is done if you harness a minor mode that
2295 doesn't need to be harnessed.
2297 It is recommended to harness even those minor modes that don't override
2298 Viper keys, but still have their own keymaps. A general way to
2299 make a minor mode, @code{my-mode},
2300 compatible with Viper is to have the file @file{my-mode.el} include the following code:
2303 (when (fboundp 'viper-harness-minor-mode)
2304 (let ((lib (file-name-sans-extension
2305 (file-name-nondirectory load-file-name))))
2306 (viper-harness-minor-mode lib)))
2309 @vindex @code{viper-want-emacs-keys-in-vi}
2310 @vindex @code{viper-want-emacs-keys-in-insert}
2311 @vindex @code{viper-always}
2312 @findex @code{viper-set-hooks}
2313 @findex @code{viper-mode}
2314 @findex @code{viper-harness-minor-mode}
2315 @findex @code{remove-hook}
2316 @findex @code{add-hook}
2318 @node Viper Specials
2319 @section Viper Specials
2321 Viper extends Vi with a number of useful features. This includes various
2322 search functions, histories of search strings, Ex commands, insertions, and
2323 Vi's destructive commands. In addition, Viper supports file name completion
2324 and history, completion of Ex commands and variables, and many other
2325 features. Some of these features are explained in detail elsewhere in this
2326 document. Other features are explained here.
2329 @item (viper-buffer-search-enable)
2330 @item viper-buffer-search-char nil
2331 Enable buffer search. Explicit call to @code{viper-buffer-search-enable}
2332 sets @code{viper-buffer-search-char} to @kbd{g}. Alternatively, the user can
2333 set @code{viper-buffer-search-char} in @file{.viper} to a key sequence
2334 to be used for buffer search. There is no need to call
2335 @code{viper-buffer-search-enable} in that case.
2336 @findex @code{viper-buffer-search-enable}
2337 @vindex @code{viper-buffer-search-char}
2338 @item viper-toggle-search-style
2339 This function, bound to @kbd{C-c /}, lets one toggle case-sensitive and
2340 case-insensitive search, and also switch between plain vanilla search and
2341 search via regular expressions. Without the prefix argument, the user is
2342 asked which mode to toggle. With prefix argument 1, this toggles
2343 case-sensitivity. With prefix argument 2, regular expression/vanilla search
2346 However, we found that the most convenient way to toggle
2347 these options is to bind a Vi macro to
2348 bind @kbd{//} to toggles case sensitivity and to @kbd{///} to toggles
2349 vanilla search. Thus, quickly hitting @kbd{/} twice will switch Viper from
2350 case sensitive search to case-insensitive. Repeating this once again will
2351 restore the original state. Likewise, quickly hitting @kbd{/} three times
2352 will switch you from vanilla-style search to search via regular expressions.
2353 If you hit something other than @kbd{/} after the first @kbd{/} or if the
2354 second @kbd{/} doesn't follow quickly enough, then Viper will issue the
2355 usual prompt @kbd{/} and will wait for input, as usual in Vi.
2356 If you don't like this behavior, you can ``unrecord'' these macros in your
2357 @file{~/.viper} file. For instance, if you don't like the above feature, put
2358 this in @file{~/.viper}:
2360 (viper-set-searchstyle-toggling-macros 'undefine)
2362 @findex @code{viper-set-searchstyle-toggling-macros}
2364 If you don't like this feature as a default, but would still like to have
2365 it in some major modes, you can do so by first unsetting it globally, as
2366 shown above, and then setting it in the desired major modes as follows:
2368 (viper-set-searchstyle-toggling-macros nil 'c-mode)
2369 (viper-set-searchstyle-toggling-macros nil 'lisp-mode)
2372 @item Vi-isms in Emacs state
2373 Some people find it useful to use the Vi-style search key, `/', to invoke
2374 search in modes which Viper leaves in emacs-state. These modes are:
2375 @code{dired-mode}, @code{mh-folder-mode},
2376 @code{Info-mode}, and @code{Buffer-menu-mode}
2377 (more may be added in the future). So, in the above modes, Viper binds `/'
2378 so that it will behave Vi-style. Furthermore, in those major modes, Viper
2379 binds `:' to invoke ex-style commands, like in vi-state. And, as described
2380 above, `//' and `///' get bound to Vi-style macros that toggle
2381 case-insensitivity and regexp-search.
2383 If you don't like these features---which I don't really understand---you
2384 can unbind `/' and `:' in @code{viper-dired-modifier-map} (for Dired) or in
2385 @code{viper-slash-and-colon-map}, for other modes.
2386 @vindex @code{viper-slash-and-colon-map}
2387 @vindex @code{viper-dired-modifier-map}
2389 To unbind the macros `//' and `///' for a major mode where you feel they
2390 are undesirable, execute @code{viper-set-emacs-state-searchstyle-macros} with a
2391 non-@code{nil} argument. This can be done either interactively, by supplying a
2392 prefix argument, or by placing
2394 (viper-set-emacs-state-searchstyle-macros 'undefine)
2396 @findex @code{viper-set-emacs-state-searchstyle-macros}
2397 in the hook to the major mode (e.g., @code{dired-mode-hook}).
2398 @xref{Vi Macros}, for more information on Vi macros.
2400 @item viper-heading-start
2401 @item viper-heading-end
2406 Regular Expressions for @kbd{[[} and @kbd{]]}. Note that Emacs defines
2407 Regexps for paragraphs and sentences. @xref{Paragraphs,,Paragraphs and
2408 Sentences,emacs,The GNU Emacs Manual}, for details.
2409 @item M-x viper-set-expert-level
2410 @findex @code{viper-set-expert-level}
2411 Change your user level interactively.
2412 @item viper-smart-suffix-list '("" "tex" "c" "cc" "el" "p")
2413 @vindex @code{viper-smart-suffix-list}
2414 Viper supports Emacs-style file completion when it prompts the user for a
2415 file name. However, in many cases, the same directory may contain files
2416 with identical prefix but different suffixes, e.g., prog.c, prog.o,
2417 paper.tex, paper.dvi. In such cases, completion will stop at the `.'.
2418 If the above variable is a list of strings representing suffixes, Viper will
2420 in the order listed and will check if the corresponding file exists.
2422 For instance, if completion stopped at `paper.'@: and the user typed
2424 then Viper will check if the files `paper.', `paper.tex', `paper.c', etc., exist.
2425 It will take the first such file. If no file exists, Viper will give a chance
2426 to complete the file name by typing the appropriate suffix. If `paper.'@: was
2427 the intended file name, hitting return will accept it.
2429 To turn this feature off, set the above variable to @code{nil}.
2431 @item viper-insertion-ring-size 14
2432 @vindex @code{viper-insertion-ring-size}
2433 @cindex Insertion ring
2434 Viper remembers what was previously inserted in Insert and Replace states.
2435 Several such recent insertions are kept in a special ring of strings of size
2436 @code{viper-insertion-ring-size}.
2437 If you enter Insert or Replace state you can reinsert strings from this
2438 ring by typing @kbd{C-c M-p} or @kbd{C-c M-n}. The former will search the
2440 the direction of older insertions, and the latter will search in
2441 the direction of newer insertions. Hitting @kbd{C-c M-p} or @kbd{C-c M-n}
2443 will undo the previous insertion from the ring and insert the next item on
2444 the ring. If a larger ring size is needed, change the value of the above
2445 variable in the @file{~/.viper} file.
2447 Since typing these sequences of keys may be tedious, it is suggested that the
2448 user should bind a function key, such as @kbd{f31}, as follows:
2450 (define-key viper-insert-global-user-map [f31]
2451 'viper-insert-prev-from-insertion-ring)
2453 This binds @kbd{f31} (which is usually @kbd{R11} on a Sun workstation)
2454 to the function that inserts the previous string in the insertion history.
2455 To rotate the history in the opposite
2456 direction, you can either bind an unused key to
2457 @code{viper-insert-next-from-insertion-ring} or hit any digit (1 to 9) then
2460 One should not bind the above functions to @kbd{M-p} or @kbd{M-n}, since
2461 this will interfere with the minibuffer histories and, possibly, other
2464 @item viper-command-ring-size 14
2465 @vindex @code{viper-command-ring-size}
2466 @cindex Destructive command ring
2467 @cindex Destructive command history
2468 Viper keeps track of the recent history of destructive
2469 commands, such as @kbd{dw}, @kbd{i}, etc.
2471 the most recent command can be re-executed by hitting `@kbd{.}', as in Vi.
2472 However, repeated typing @kbd{C-c M-p} will cause Viper to show the
2473 previous destructive commands in the minibuffer. Subsequent hitting `@kbd{.}'
2474 will execute the command that was displayed last.
2475 The key @kbd{C-c M-n} will cycle through the command history in the
2477 Since typing @kbd{C-c M-p} may be tedious, it is more convenient to bind an
2478 appropriate function to an unused function key on the keyboard and use that
2479 key. For instance, the following
2481 (define-key viper-vi-global-user-map [f31]
2482 'viper-prev-destructive-command)
2484 binds the key @kbd{f31} (which is usually @kbd{R11} on a Sun workstation)
2485 to the function that searches the command history in the direction of older
2486 commands. To search in the opposite
2487 direction, you can either bind an unused key to
2488 @code{viper-next-destructive-command} or hit any digit (1 to 9) then @kbd{f31}.
2490 One should not bind the above functions to @kbd{M-p} or @kbd{M-n}, since
2491 this will interfere with the minibuffer histories and, possibly, other
2494 @item viper-minibuffer-vi-face 'viper-minibuffer-vi-face
2495 @item viper-minibuffer-insert-face 'viper-minibuffer-insert-face
2496 @item viper-minibuffer-emacs-face 'viper-minibuffer-emacs-face
2497 These faces control the appearance of the minibuffer text in the
2498 corresponding Viper states. You can change the appearance of these faces
2499 through Emacs's customization widget, which is accessible through the
2502 Viper is located in this widget under the @emph{Emulations} customization
2503 subgroup of the @emph{Editing} group. All Viper faces are grouped together
2504 in Viper's @emph{Highlighting} customization subgroup.
2506 Note that only the text you type in is affected by the above faces.
2507 Prompts and minibuffer messages are not affected.
2509 Purists who do not like adornments in the minibuffer can always zap them by
2512 (copy-face 'default 'viper-minibuffer-vi-face)
2513 (copy-face 'default 'viper-minibuffer-insert-face)
2514 (copy-face 'default 'viper-minibuffer-emacs-face)
2516 in the @file{~/.viper} file or through the customization widget, as
2517 described above. However, in that case, the user will not have any
2518 indication of the current Viper state in the minibuffer. (This is important
2519 if the user accidentally switches to another Viper state by typing @key{ESC} or
2521 @item M-x viper-go-away
2522 @findex @code{viper-go-away}
2523 Make Viper disappear from the face of your running Emacs instance. If your
2524 fingers start aching again, @kbd{M-x viper-mode} might save your day.
2525 @item M-x toggle-viper-mode
2526 @findex @code{toggle-viper-mode}
2527 Toggle Viperization of Emacs on and off.
2530 @cindex Multifile documents and programs
2532 Viper provides some support for multi-file documents and programs.
2533 If a document consists of several files we can designate one of them as a
2534 master and put the following at the end of that file:
2537 ;; eval: (viper-setup-master-buffer "file1" "file2" "file3" "file4")
2541 where @code{file1} to @code{file4} are names of files related to the master
2542 file. Next time, when the master file is visited, the command
2543 @code{viper-setup-master-buffer} will be evaluated and the above files will
2544 be associated with the master file. Then, the new Ex command
2545 @kbd{:RelatedFile} (abbr.@: @kbd{:R}) will display files 1 to 4 one after
2546 another, so you can edit them. If a file is not in any Emacs buffer, it
2547 will be visited. The command @kbd{PreviousRelatedFile} (abbr., @kbd{:P})
2548 goes through the file list in the opposite direction.
2549 @findex @kbd{:RelatedFile}
2550 @findex @kbd{:PreviousRelatedFile}
2552 These commands are akin to @kbd{:n} and @kbd{:N}, but they allow the user to
2553 focus on relevant files only.
2555 Note that only the master file needs to have the aforementioned block of
2556 commands. Also, ";;" above can be replaced by some other
2557 markers. Semicolon is good for Lisp programs, since it is considered a
2558 comment designator there. For LaTeX, this could be "%%%", and for C the
2559 above block should be commented out.
2561 Even though these commands are sometimes useful, they are no substitute for
2562 the powerful @emph{tag table} facility of Emacs. Viper's @kbd{:tag} command
2563 in a primitive interface to Emacs tags. @xref{Tags,Tags,Tags,emacs,
2564 The GNU Emacs Manual}, for more information on tags.
2566 The following two commands are normally bound to a mouse click and are part
2567 of Viper. They work only if Emacs runs as an application under X
2568 Windows (or under some other window system for which a port of GNU Emacs 20
2569 is available). Clicking the mouse when Emacs is invoked in an Xterm window
2570 (using @code{emacs -nw}) will do no good.
2574 @cindex mouse-search
2575 @item viper-mouse-search-key (meta shift 1)
2576 @vindex @code{viper-mouse-insert-key}
2577 This variable controls the @emph{mouse-search} feature of Viper. The
2579 states that holding Meta and Shift keys while clicking mouse button 1
2580 should initiate search for a region under the mouse pointer (defined
2581 below). This command can take a prefix argument, which indicates the
2582 occurrence of the pattern to search for.
2584 Note: while loading initially, Viper binds this mouse action only if it is
2585 not already bound to something else. If you want to use the mouse-search
2586 feature, and the @kbd{Meta-Shift-Mouse-1} mouse action is already bound to
2587 something else, you can rebind the mouse-search feature by setting
2588 @code{viper-mouse-search-key} to something else in your @code{~/.viper}
2591 (setq viper-mouse-search-key '(meta 1))
2593 This would bind mouse search to the action invoked by pressing the
2594 Meta key and clicking mouse button 1. The allowed values of
2595 @code{viper-mouse-search-key} are lists that contain a mouse-button number
2596 (1,2, or 3) and any combination of the words `control', `meta', and
2599 If the requested mouse action (e.g., (meta 1)) is already taken for other
2600 purposes then you have to confirm your intention by placing the following
2601 command in @code{~/.viper} after setting @code{viper-mouse-search-key}:
2603 (viper-bind-mouse-search-key 'force)
2606 You can also change this setting interactively, through the customization
2607 widget of Emacs (type @kbd{:customize}).
2609 The region that is chosen as a pattern to search for is determined as
2610 follows. If search is invoked via a single click, Viper chooses the region
2611 that lies between the beginning of the ``word'' under the pointer (``word''
2612 is understood in Vi sense) and the end of that word. The only difference
2613 with Vi's words is that in Lisp major modes `-' is considered an
2614 alphanumeric symbol. This is done for the convenience of working with Lisp
2615 symbols, which often have an `-' in them. Also, if you click on a
2616 non-alphanumeric character that is not a word separator (in Vi sense) then
2617 this character will also be considered alphanumeric, provided that it is
2618 adjacent (from either side) to an alphanumeric character. This useful
2619 feature gives added control over the patterns selected by the mouse click.
2621 On a double-click, the region is determined by the beginning of the current
2622 Vi's ``Word'' (i.e., the largest non-separator chunk of text) and the End
2623 of that ``Word'' (as determined by the @kbd{E} command).
2625 On a triple-click, the region consists of the entire line where the click
2626 occurred with all leading and trailing spaces and tabs removed.
2628 @cindex mouse-insert
2629 @item viper-mouse-insert-key (meta shift 2)
2630 @vindex @code{viper-mouse-insert-key}
2631 This variable controls the @emph{mouse-insert} feature of Viper.
2632 The above default value states that
2633 holding Meta and Shift keys while clicking mouse button 2
2634 should insert the region surrounding the
2635 mouse pointer. The rules defining this region are the same as for
2636 mouse-search. This command takes an optional prefix argument, which
2637 indicates how many such regions to snarf from the buffer and insert. (In
2638 case of a triple-click, the prefix argument is ignored.)
2640 Note: while loading initially, Viper binds this mouse action only if it not
2641 already bound to something else. If you want to use this feature and the
2642 default mouse action is already bound, you can rebind mouse-insert by
2643 placing this command in @code{~/.viper}:
2645 (setq viper-mouse-insert-key '(meta 2))
2647 If you want to bind mouse-insert to an action even if this action is
2648 already taken for other purposes in Emacs, then you should add this command
2649 to @code{~/.viper}, after setting @code{viper-mouse-insert-key}:
2651 (viper-bind-mouse-insert-key 'force)
2654 This value can also be changed via the Emacs customization widget at the
2657 @item viper-multiclick-timeout
2658 This variable controls the rate at which double-clicking must occur for the
2659 purpose of mouse search and mouse insert. By default, this is set to
2660 @code{double-click-time} in Emacs and to
2661 @code{mouse-track-multi-click-time} milliseconds in XEmacs.
2663 @kindex @kbd{S-Mouse-1}
2664 @kindex @kbd{S-Mouse-2}
2665 @kindex @kbd{meta shift button1up}
2666 @kindex @kbd{meta shift button2up}
2667 @vindex @code{viper-multiclick-timeout}
2668 @findex @code{viper-mouse-click-insert-word}
2669 @findex @code{viper-mouse-click-search-word}
2671 Note: The above functions search and insert in the selected window of
2672 the latest active frame. This means that you can click in another window or
2673 another frame and have search or insertion done in the frame and window you
2674 just left. This lets one use these functions in a multi-frame
2675 configuration. However, this may require some getting used to. For
2676 instance, if you are typing in a frame, A, and then move the mouse to frame
2677 B and click to invoke mouse search, search (or insertion) will be performed
2678 in frame A@. To perform search/insertion in frame B, you will first have to
2679 shift focus there, which doesn't happen until you type a character or
2680 perform some other action in frame B---mouse search doesn't shift focus.
2682 If you decide that you don't like the above feature and always want
2683 search/insertion be performed in the frame where the click occurs, don't
2684 bind (and unbind, if necessary) @code{viper-mouse-catch-frame-switch} from
2685 the mouse event it is bound to.
2687 Mouse search is integrated with Vi-style search, so you can
2688 repeat it with @kbd{n} and @kbd{N}. It should be also noted that, while
2689 case-sensitivity of search in Viper is controlled by the variable
2690 @code{viper-case-fold-search}, the case of mouse search is
2691 controlled by the Emacs variable @code{case-fold-search}, which may be set
2692 differently from @code{viper-case-fold-search}. Therefore, case-sensitivity
2693 of mouse search may be different from that of the usual Vi-style search.
2695 Finally, if the way Viper determines the word to be searched for or to be
2696 inserted is not what you want, there is a variable,
2697 @code{viper-surrounding-word-function}, which can be changed to indicate
2698 another function for snarfing words out of the buffer. The catch is that
2699 you will then have to write such a function and make it known to your
2700 Emacs. The function @code{viper-surrounding-word} in @file{viper.el} can be
2701 used as a guiding example.
2708 Viper supports much enhanced Vi-style macros and also facilitates the use
2709 of Emacs-style macros. To define a temporary macro, it is generally more
2710 convenient to use Emacs keyboard macro facility. Emacs keyboard macros are
2711 usually defined anonymously, and the latest macro can be executed by typing
2712 @kbd{C-x e} (or @kbd{*}, if Viper is in Vi state). If you need to use several
2713 temporary macros, Viper lets you save them to a
2714 register (a lowercase letter); such macros can then be executed by typing
2715 @kbd{@@a} in Vi state (if a macro was previously saved in register
2717 @xref{Macros and Registers}, for details.
2719 If, however, you need to use a macro regularly, it must be given a
2720 permanent name and saved. Emacs manual explains how to do this, but
2721 invocation of named Emacs macros is quite different from Vi's. First,
2722 invocation of permanent Emacs macros takes time because it requires typing
2723 too many keys (to a Vi user's taste, anyway).
2724 Second, binding such macros to function keys, for
2725 fast access, hogs valuable real estate on the keyboard.
2727 Vi-style macros are better in that respect, since Vi lets the user overload
2728 the meaning of key sequences: keys typed in fast succession are treated
2729 specially, if this key sequence is bound to a macro.
2731 Viper provides Vi-style keyboard macros through the usual Ex commands,
2733 @kbd{:map!}. These macros are much more powerful in Viper than
2734 they are in the original Vi and in other emulators. This is because Viper
2735 implements an enhanced vi-style
2736 interface to the powerful Emacs keyboard macro facility.
2739 command can be executed while defining a macro, not just the Vi
2740 commands. In particular, the user can invoke Emacs commands via @kbd{M-x
2741 command-name} or by pressing various function keys on the keyboard. One
2742 can even use the mouse, although this is usually not useful and is not
2743 recommended (and macros defined with the use of the mouse cannot be saved in
2744 command history and in the startup file, for future use).
2746 Macros defined by mixing Vi and Emacs commands are represented as
2747 vectors. So, don't be confused when you see one (usually through the
2748 history of Ex commands). For instance, if @kbd{gg} is defined by typing
2749 @kbd{l}, the up-arrow key and @kbd{M-x next-line}, its definition will look
2750 as follows in Emacs:
2753 [l up (meta x) n e x t - l i n e return]
2756 Second, Viper macros are defined in a WYSIWYG style. This means that
2757 commands are executed as you type them, so you can see precisely what is
2758 being defined. Third, macros can be bound to arbitrary sequences of keys,
2759 not just to printable keys. For instance, one can define a macro that will
2760 be invoked by hitting @kbd{f3} then @kbd{f2} function keys. (The keys
2761 @kbd{delete} and @kbd{backspace} are excluded; also, a macro invocation
2762 sequence can't start with @key{ESC}. Some other keys, such as @kbd{f1} and
2763 @kbd{help}, can't be bound to macros under Emacs, since they
2764 are bound in @code{key-translation-map}, which overrides any other binding
2765 the user gives to keys. In general, keys that have a binding in
2766 @code{key-translation-map} can't be bound to a macro.)
2768 Fourth, in Viper, one can define macros that are specific to a given
2769 buffer, a given major mode, or macros that are defined for all buffers. In
2770 fact, the same macro name can have several different definitions: one
2771 global, several definitions for various major modes, and
2772 definitions for various specific buffers. Buffer-specific definitions
2773 override mode-specific definitions, which, in turn, override global
2776 As if all that is not enough, Viper (through its interface to Emacs
2777 macros) lets the user define keyboard macros that ask for confirmation or
2778 even prompt the user for input and then continue. To do this, one should
2779 type @kbd{C-x q} (for confirmation) or @kbd{C-u C-x q} (for prompt).
2780 For details, @pxref{Keyboard Macro Query,,Customization,emacs,The GNU Emacs
2783 When the user finishes defining a macro (which is done by typing @kbd{C-x)},
2784 a departure from Vi), you will be asked whether you want this
2785 macro to be global, mode-specific, or buffer-specific. You will also be
2786 given a chance to save the macro in your @file{~/.viper} file.
2787 This is the easiest way to save a macro and make
2788 it permanently available. If you work your startup files with bare hands,
2789 here is how Viper saves the above macro so that it will be
2790 available in Viper's Insert state (and Replace state) in buffer @code{my-buf}
2794 (viper-record-kbd-macro "gg" 'insert-state
2795 [l up (meta x) n e x t - l i n e return]
2800 To do the same for Vi state and all buffers with the major mode
2801 @code{cc-mode}, use:
2804 (viper-record-kbd-macro "gg" 'vi-state
2805 [l up (meta x) n e x t - l i n e return]
2810 Both macro names and macro definitions are vectors of symbols that denote
2811 keys on the keyboard. Some keys, like @kbd{\}, @kbd{ }, or digit-keys must
2812 be escaped with a backslash. Modified keys are represented as lists. For
2813 instance, holding Meta and Control and pressing @kbd{f4} is represented as
2814 @kbd{(control meta f4)}.
2815 If all members of a vectors are printable characters (or sequences, such as
2816 @kbd{\e}, @kbd{\t}, for @key{ESC} and @key{TAB}), then they can also be represented as
2820 (viper-record-kbd-macro "aa" 'vi-state "aaa\e" "my-buffer")
2824 Thus, typing @kbd{aa} fast in Vi state will switch Viper to Insert state
2825 (due to the first @kbd{a}), insert @kbd{aa}, and then it will switch back to Vi
2826 state. All this will take effect only in the buffer named @code{my-buffer}.
2828 Note that the last argument to @code{viper-record-kbd-macro} must be either a
2829 string (a buffer name), a symbol representing a major mode, or @code{t};
2830 the latter says that the macro is to be defined for all buffers
2831 (which is how macros are defined in original Vi).
2833 For convenience, Viper also lets you define Vi-style macros in its Emacs
2834 state. There is no Ex command, like @kbd{:map} and @kbd{:map!} for doing
2835 this, but the user can include such a macro in the @file{~/.viper} file. The
2836 only thing is that the @code{viper-record-kbd-macro} command should specify
2837 @code{emacs-state} instead of @code{vi-state} or @code{insert-state}.
2839 The user can get rid of a macro either by using the Ex commands @kbd{:unmap}
2840 and @kbd{:unmap!} or by issuing a call to @code{viper-unrecord-kbd-macro}.
2841 The latter is more powerful, since it can delete macros even in
2842 @code{emacs-state}. However, @code{viper-unrecord-kbd-macro} is usually
2843 needed only when the user needs to get rid of the macros that are already
2844 predefined in Viper.
2846 @findex @code{viper-unrecord-kbd-macro}
2848 (viper-unrecord-kbd-macro macro state)
2851 The second argument must be @code{vi-state}, @code{insert-state}, or
2852 @code{emacs-state}. The first argument is a name of a macro. To avoid
2853 mistakes in specifying names of existing macros, type @kbd{M-x
2854 viper-describe-kbd-macros} and use a name from the list displayed by this
2857 If an error occurs during macro definition, Emacs
2858 aborts the process, and it must be repeated. This is analogous to Vi,
2859 except that in Vi the user doesn't know there is an error until the macro is
2860 actually run. All that means that in order for a definition to be
2861 successful, the user must do some simple planning of the process in
2862 advance, to avoid errors. For instance, if you want to map @kbd{gg} to
2863 @kbd{llll} in Vi state, you must make sure that there is enough room on the
2864 current line. Since @kbd{l} moves the cursor forward, it may signal an
2865 error on reaching the end of line, which will abort the definition.
2867 These precautions are necessary only when defining macros; they will help
2868 avoid the need to redo the job. When macros are actually run, an error
2869 during the execution will simply terminate the current execution
2870 (but the macro will remain mapped).
2872 A macro name can be a string of characters or a vector of keys.
2873 The latter makes it possible to define macros bound to, say, double-hits
2874 on a function key, such as @kbd{up} or @kbd{f13}.
2875 This is very useful if you run out of function keys on your keyboard; it
2876 makes Viper macro facility a @emph{keyboard doubler}, so to speak.
2878 Elsewhere (@xref{Key Bindings}, for details), we review
2879 the standard Emacs mechanism for binding function keys to commands.
2883 (global-set-key [f13] 'repeat-complex-command)
2887 binds the key f13 to the Emacs function that repeats the last minibuffer
2888 command. Under Viper, however, you may still use this key for additional
2889 purposes, if you bind, say, a double-hitting action for that key to some
2890 other function. Emacs doesn't allow the user to do that, but Viper does
2891 this through its keyboard macro facility. To do this, type @kbd{:map }
2892 first. When you are asked to enter a macro name, hit f13 twice, followed by
2893 @key{RET} or @key{SPC}.
2895 Emacs will now start the mapping process by actually executing
2896 Vi and Emacs commands, so that you could see what will happen each time the
2897 macro is executed. Suppose now we wanted to bind the key sequence
2898 @kbd{f13 f13} to the command @code{eval-last-sexp}. To accomplish this, we
2899 can type @kbd{M-x eval-last-sexp} followed by @kbd{C-x )}.
2900 If you answer positively to Viper's offer to save this macro in @file{~/.viper}
2901 for future uses, the following will be inserted in that file:
2904 (viper-record-kbd-macro [f16 f16] 'vi-state
2905 [(meta x) e v a l - l a s t - s e x p]
2906 'lisp-interaction-mode)
2909 To illustrate the above point, Viper provides two canned macros, which, by
2910 default, are bound to @kbd{[f12 \1]} and @kbd{[f12 \2]} (invoked by typing
2911 @kbd{f12} then @kbd{1} and @kbd{2}, respectively). These macros are useful
2912 shortcuts to Viper's command ring history. The first macro will execute the
2913 second-last destructive command (the last one is executed by @kbd{.}, as
2914 usual). The second macro executes the third-last command.
2916 If you need to go deeper into the command history, you will have to use
2917 other commands, as described earlier in this section; or you can bind,
2918 say, @kbd{f12 \3} like this:
2921 (viper-record-kbd-macro [f12 \3] 'vi-state
2922 [(meta x) r e p e a t - f r o m - h i s t o r y]
2927 Note that even though the macro uses the function key @kbd{f12}, the key is
2928 actually free and can still be bound to some Emacs function via
2929 @code{define-key} or @code{global-set-key}.
2932 Viper allows the user to define macro names that are prefixes of other macros.
2933 For instance, one can define @kbd{[[} and @kbd{[[[[} to be macros.
2934 If you type the exact sequence of such keys and then pause, Viper will
2935 execute the right macro. However, if you don't pause and, say, type
2936 @kbd{[[[[text} then the conflict is resolved as follows. If only one of the
2937 key sequences, @kbd{[[} or @kbd{[[[[} has a definition applicable to the
2938 current buffer, then, in fact, there is no conflict and the right macro
2939 will be chosen. If both have applicable definitions, then the first one
2940 found will be executed. Usually this is the macro with a shorter name. So,
2941 in our case, @kbd{[[[[text} will cause the macro @kbd{[[} to be executed
2942 twice and then the remaining keys, @kbd{t e x t}, will be processed.
2944 When defining macros using @kbd{:map} or @kbd{:map!}, the user enters
2945 the actually keys to be used to invoke the macro. For instance, you
2946 should hit the actual key @kbd{f6} if it is to be part of a macro
2947 name; you do @emph{not} write @kbd{f 6}. When entering keys, Viper
2948 displays them as strings or vectors (e.g., @code{"abc"} or @code{[f6
2949 f7 a]}). The same holds for unmapping. Hitting @key{TAB} while
2950 typing a macro name in the @kbd{:unmap} or @kbd{:unmap!} command will
2951 cause name completion. Completions are displayed as strings or
2952 vectors. However, as before, you don't actually type @samp{"},
2953 @samp{[}, or @samp{]} that appear in the completions. These are
2954 meta-symbols that indicate whether the corresponding macro name is a
2957 One last difference from Vi: Vi-style keyboard macros cannot be defined in
2958 terms of other Vi-style keyboard macros (but named Emacs macros are OK).
2959 More precisely, while defining or executing a macro, the special meaning
2960 of key sequences (as Vi macros) is ignored.
2961 This is because it is all too easy to create an infinite loop in this way.
2962 Since Viper macros are much more powerful than Vi's it is impossible to
2963 detect such loops. In practice, this is not really a limitation but,
2966 We should also note that Vi macros are disabled in the minibuffer, which
2967 helps keep some potential troubles away.
2969 The rate at which the user must type keys in order for them to be
2970 recognized as a timeout macro is controlled by the variable
2971 @code{viper-fast-keyseq-timeout}, which defaults to 200 milliseconds.
2973 For the most part, Viper macros defined in @file{~/.viper} can be shared
2974 between X and TTY modes.
2975 The problem with TTY may be that the function keys there generate sequences
2976 of events instead of a single event (as under a window system).
2977 Emacs maps some of these sequences back to the logical keys
2978 (e.g., the sequences generated by the arrow keys are mapped to @kbd{up},
2979 @kbd{left}, etc.). However, not all function keys are mapped in this way.
2980 Macros that are bound to key sequences that contain such unmapped function
2981 keys have to be redefined for TTY's (and possibly for every type of TTY you
2982 may be using). To do this, start Emacs on an appropriate TTY device and
2983 define the macro using @kbd{:map}, as usual.
2985 @findex @code{viper-describe-kbd-macros}
2986 Finally, Viper provides a function that conveniently displays all macros
2987 currently defined. To see all macros along with their definitions, type
2988 @kbd{M-x viper-describe-kbd-macros}.
2993 This section is a semi-automatically bowdlerized version of the Vi
2994 reference created by @* @samp{maart@@cs.vu.nl} and others. It can be
2995 found on the Vi archives. This reference has been adapted for Viper.
2998 * Groundwork:: Textual Conventions and Viper basics
2999 * Text Handling:: Moving, Editing, Undoing.
3000 * Display:: Scrolling.
3001 * File and Buffer Handling:: Editing, Writing and Quitting.
3002 * Mapping:: Mapping Keys, Keyboard Macros
3003 * Shell Commands:: Accessing Shell Commands, Processing Text
3004 * Options:: Ex options, the @kbd{:set} commands
3005 * Emacs Related Commands:: Meta Keys, Windows
3006 * Mouse-bound Commands:: Search and insertion of text
3012 The VI command set is based on the idea of combining motion commands
3013 with other commands. The motion command is used as a text region
3014 specifier for other commands.
3015 We classify motion commands into @dfn{point commands} and
3016 @dfn{line commands}.
3018 @cindex point commands
3020 The point commands are:
3023 @kbd{h}, @kbd{l}, @kbd{0}, @kbd{$}, @kbd{w}, @kbd{W}, @kbd{b}, @kbd{B},
3024 @kbd{e}, @kbd{E}, @kbd{(}, @kbd{)}, @kbd{/}, @kbd{?}, @kbd{`}, @kbd{f},
3025 @kbd{F}, @kbd{t}, @kbd{T}, @kbd{%}, @kbd{;}, @kbd{,}, @kbd{^}
3028 @cindex line commands
3030 The line commands are:
3033 @kbd{j}, @kbd{k}, @kbd{+}, @kbd{-}, @kbd{H}, @kbd{M}, @kbd{L}, @kbd{@{},
3034 @kbd{@}}, @kbd{G}, @kbd{'}, @kbd{[[}, @kbd{]]}, @kbd{[]}
3038 Text Deletion Commands (@pxref{Deleting Text}), Change commands
3039 (@pxref{Changing Text}), even Shell Commands (@pxref{Shell Commands})
3040 use these commands to describe a region of text to operate on.
3042 @cindex r and R region specifiers
3044 Viper adds two region descriptors, @kbd{r} and @kbd{R}. These describe
3045 the Emacs regions (@pxref{Basics}), but they are not movement commands.
3047 The command description uses angle brackets @samp{<>} to indicate
3048 metasyntactic variables, since the normal conventions of using simple
3049 text can be confusing with Viper where the commands themselves are
3050 characters. Watch out where @kbd{<} shift commands and @kbd{<count>} are
3051 mentioned together!!!
3061 @samp{<move>} refers to the above movement commands, and @samp{<a-z>}
3062 refers to registers or textmarkers from @samp{a} to @samp{z}. Note
3063 that the @samp{<move>} is described by full move commands, that is to
3064 say they will take counts, and otherwise behave like normal move commands.
3065 @cindex Ex addresses
3066 @samp{<address>} refers to Ex line addresses, which include
3069 @item .@: <No address>
3072 Add or subtract for current line
3074 Actual line number, use @kbd{.=} to get the line number
3080 Where x and y are one of the above
3082 @cindex % (Ex address)
3083 For the whole file, same as (1,$).
3086 Next or previous line with pattern <pat>.
3088 Note that the pattern is allowed to contain newline character (inserted as
3089 @kbd{C-qC-j}). Therefore, one can search for patterns that span several
3093 @cindex % (Current file)
3094 Note that @samp{%} is used in Ex commands @kbd{:e} and @kbd{:r <shell-cmd>}
3095 to mean current file. If you want a @samp{%} in your command, it must be
3096 escaped as @samp{\%}. Note that @kbd{:w} and the regular @kbd{:r <file>}
3097 command doesn't support the meta symbols @samp{%} and @samp{#}, because
3098 file history is a better mechanism.
3099 @cindex # (Previous file)
3100 Similarly, @samp{#} expands to the previous file. The previous file is
3101 the first file in @kbd{:args} listing. This defaults to previous window
3102 in the VI sense if you have one window only.
3109 Others like @samp{<args> -- arguments}, @samp{<cmd> -- command} etc.
3110 should be fairly obvious.
3113 Common characters referred to include:
3138 We also use @samp{word} for alphanumeric/non-alphanumeric words, and
3139 @samp{WORD} for whitespace delimited words. @samp{char} refers to any
3140 @acronym{ASCII} character, @samp{CHAR} to non-whitespace character.
3141 Brackets @samp{[]} indicate optional parameters; @samp{<count>} also
3142 optional, usually defaulting to 1. Brackets are elided for
3143 @samp{<count>} to eschew obfuscation.
3145 Viper's idea of Vi's words is slightly different from Vi. First, Viper
3146 words understand Emacs symbol tables. Therefore, all symbols declared to be
3147 alphanumeric in a symbol table can automatically be made part of the Viper
3148 word. This is useful when, for instance, editing text containing European,
3149 Cyrillic, Japanese, etc., texts.
3151 Second, Viper lets you depart from Vi's idea of a word by changing the a
3152 syntax preference via the customization widget (the variable
3153 @code{viper-syntax-preference}) or by executing
3154 @code{viper-set-syntax-preference} interactively.
3156 By default, Viper syntax preference is @code{reformed-vi}, which means that
3157 Viper considers only those symbols to be part of a word that are specified
3158 as word-symbols by the current Emacs syntax table (which may be different
3159 for different major modes) plus the underscore symbol @kbd{_}, minus the
3160 symbols that are not considered words in Vi (e.g., `,',;, etc.), but may be
3161 considered as word-symbols by various Emacs major modes. Reformed-Vi works
3162 very close to Vi, and it also recognizes words in other
3163 alphabets. Therefore, this is the most appropriate mode for editing text
3164 and is likely to fit all your needs.
3166 You can also set Viper syntax preference to @code{strict-vi}, which would
3167 cause Viper to view all non-English letters as non-word-symbols.
3169 You can also specify @code{emacs} as your preference, which would
3170 make Viper use exactly the same notion of a word as Emacs does. In
3171 particular, the underscore may not be part of a word in some major modes.
3173 Finally, if @code{viper-syntax-preference} is set to @code{extended}, Viper
3174 words would consist of characters that are classified as alphanumeric
3175 @emph{or} as parts of symbols. This is convenient for editing programs.
3177 @code{viper-syntax-preference} is a local variable, so it can have different
3178 values for different major modes. For instance, in programming modes it can
3179 have the value @code{extended}. In text modes where words contain special
3180 characters, such as European (non-English) letters, Cyrillic letters, etc.,
3181 the value can be @code{reformed-vi} or @code{emacs}.
3182 If you consider using different syntactic preferences for different major
3183 modes, you should execute, for example,
3186 (viper-set-syntax-preference nil "extended")
3189 in the appropriate major mode hooks.
3191 @vindex @code{viper-syntax-preference}
3192 @findex @code{viper-set-syntax-preference}
3193 @cindex syntax table
3197 The above discussion concerns only the movement commands. In regular
3198 expressions, words remain the same as in Emacs. That is, the expressions
3199 @code{\w}, @code{\>}, @code{\<}, etc., use Emacs's idea of what is a word,
3200 and they don't look into the value of variable
3201 @code{viper-syntax-preference}. This is because Viper avoids changing
3202 syntax tables in order to not thwart the various major modes that set these
3205 The usual Emacs convention is used to indicate Control Characters, i.e.,
3206 C-h for Control-h. @emph{Do not confuse this with a sequence of separate
3208 C, -, h!!!} The @kbd{^} is itself, never used to indicate a
3211 Finally, we note that Viper's Ex-style commands can be made to work on the
3212 current Emacs region. This is done by typing a digit argument before
3213 @kbd{:}. For instance, typing @kbd{1:} will prompt you with something like
3214 @emph{:123,135}, assuming that the current region starts at line 123 and
3215 ends at line 135. There is no need to type the line numbers, since Viper
3216 inserts them automatically in front of the Ex command.
3220 @section Text Handling
3223 * Move Commands:: Moving, Searching
3224 * Marking:: Textmarkers in Viper and the Emacs Mark.
3225 * Appending Text:: Text insertion, Shifting, Putting
3226 * Editing in Insert State:: Autoindent, Quoting etc.
3227 * Deleting Text:: Deleting
3228 * Changing Text:: Changing, Replacement, Joining
3229 * Search and Replace:: Searches, Query Replace, Pattern Commands
3230 * Yanking:: Yanking, Viewing Registers
3231 * Undoing:: Multiple Undo, Backups
3235 @subsection Move Commands
3237 @cindex movement commands
3241 @cindex column movement
3246 @cindex matching parens
3247 @cindex paren matching
3251 <count> chars to the left.
3252 @item <count> j <lf> C-n
3253 <count> lines downward.
3254 @item <count> l <sp>
3255 <count> chars to the right.
3257 <count> lines upward.
3259 To the end of line <count> from the cursor.
3261 To the first CHAR <count> @minus{} 1 lines lower.
3263 To the first CHAR <count> lines higher.
3264 @item <count> + <cr>
3265 To the first CHAR <count> lines lower.
3267 To the first char of the line.
3270 @item <count> f<char>
3271 <count> <char>s to the right (find).
3272 @item <count> t<char>
3273 Till before <count> <char>s to the right.
3274 @item <count> F<char>
3275 <count> <char>s to the left.
3276 @item <count> T<char>
3277 Till after <count> <char>s to the left.
3279 Repeat latest @kbd{f t F T} <count> times.
3281 Repeat latest @kbd{f t F T}
3282 <count> times in opposite direction.
3284 <count> words forward.
3286 <count> WORDS forward.
3288 <count> words backward.
3290 <count> WORDS backward.
3292 To the end of word <count> forward.
3294 To the end of WORD <count> forward.
3296 Go to line <count> (default end-of-file).
3298 To line <count> from top of the screen (home).
3300 To line <count> from bottom of the screen (last).
3302 To the middle line of the screen.
3304 <count> sentences forward.
3306 <count> sentences backward.
3308 <count> paragraphs forward.
3310 <count> paragraphs backward.
3312 To the <count>th heading.
3314 To the <count>th previous heading.
3316 To the end of <count>th heading.
3318 Mark the cursor position with a letter.
3322 To the first CHAR of the line with the mark.
3324 Show contents of textmarker.
3326 Show contents of register.
3328 To the cursor position before the latest absolute
3329 jump (of which are examples @kbd{/} and @kbd{G}).
3331 To the first CHAR of the line on which the cursor
3332 was placed before the latest absolute jump.
3333 @item <count> /<string>
3334 To the <count>th occurrence of <string>.
3336 To the <count>th occurrence of <string> from previous @kbd{/ or ?}.
3337 @item <count> ?<string>
3338 To the <count>th previous occurrence of <string>.
3340 To the <count>th previous occurrence of <string> from previous @kbd{?@: or /}.
3342 Repeat latest @kbd{/} @kbd{?} (next).
3344 Repeat latest search in opposite direction.
3346 Without a prefix argument, this command toggles
3347 case-sensitive/case-insensitive search modes and plain vanilla/regular
3348 expression search. With the prefix argument 1, i.e.,
3349 @kbd{1 C-c /}, this toggles case-sensitivity; with the prefix argument 2,
3350 toggles plain vanilla search and search using
3351 regular expressions. @xref{Viper Specials}, for alternative ways to invoke
3353 @cindex vanilla search
3354 @cindex case-sensitive search
3355 @cindex case-insensitive search
3357 Find the next bracket/parenthesis/brace and go to its match.
3358 By default, Viper ignores brackets/parentheses/braces that occur inside
3359 parentheses. You can change this by setting
3360 @code{viper-parse-sexp-ignore-comments} to @code{nil} in your @file{.viper} file.
3361 This option can also be toggled interactively if you quickly hit @kbd{%%%}.
3363 This latter feature is implemented as a vi-style keyboard macro. If you
3364 don't want this macro, put
3367 (viper-set-parsing-style-toggling-macro 'undefine)
3369 @findex @code{viper-set-parsing-style-toggling-macro}
3371 in your @file{~/.viper} file.
3380 @kindex @kbd{?<string>}
3381 @kindex @kbd{/<string>}
3384 @kindex @kbd{]<a-z>}
3385 @kindex @kbd{[<a-z>}
3386 @kindex @kbd{'<a-z>}
3387 @kindex @kbd{`<a-z>}
3388 @kindex @kbd{m<a-z>}
3408 @kindex @kbd{T<char>}
3409 @kindex @kbd{F<char>}
3410 @kindex @kbd{t<char>}
3411 @kindex @kbd{f<char>}
3428 @vindex @code{viper-parse-sexp-ignore-comments}
3433 Emacs mark is referred to in the region specifiers @kbd{r} and @kbd{R}.
3434 @xref{Emacs Preliminaries}, and @xref{Basics}, for explanation. Also
3435 see @ref{Mark,,Mark,emacs,The GNU Emacs manual}, for an explanation of
3436 the Emacs mark ring.
3442 Mark the current file and position with the specified letter.
3444 Set the Emacs mark (@pxref{Emacs Preliminaries}) at point.
3446 Set the Emacs mark (@pxref{Emacs Preliminaries}) back to where it was last
3447 set with the @kbd{m.} command. This is useful when you set the mark with
3448 @kbd{m.}, but then some other command (such as @kbd{L} or @kbd{G}) changes
3449 it in a way that you didn't like.
3451 Set the Emacs mark at beginning of buffer.
3453 Set the Emacs mark at end of buffer.
3455 Jump to the Emacs mark.
3457 Mark position with text marker named <char>. This is an Ex command.
3459 Same as @kbd{:mark}.
3461 Exchange point and mark.
3463 Exchange point and mark and go to the first CHAR on line.
3465 Go to specified Viper mark.
3467 Go to specified Viper mark and go to the first CHAR on line.
3469 @kindex @kbd{m<a-z>}
3479 @kindex @kbd{`<a-z>}
3480 @kindex @kbd{'<a-z>}
3482 @node Appending Text
3483 @subsection Appending Text
3485 @xref{Options}, to see how to change tab and shiftwidth size. See the GNU
3486 Emacs manual, or try @kbd{C-ha tabs} (If you have turned Emacs help on).
3487 Check out the variable @code{indent-tabs-mode} to put in just spaces.
3488 Also see options for word-wrap.
3497 <count> times after the cursor.
3499 <count> times at the end of line.
3501 <count> times before the cursor (insert).
3503 <count> times before the first CHAR of the line
3505 On a new line below the current (open).
3506 The count is only useful on a slow terminal.
3508 On a new line above the current.
3509 The count is only useful on a slow terminal.
3510 @item <count> ><move>
3511 Shift the lines described by <count><move> one
3512 shiftwidth to the right (layout!).
3514 Shift <count> lines one shiftwidth to the right.
3515 @item <count> ["<a-z1-9>]p
3516 Put the contents of the (default undo) buffer
3517 <count> times after the cursor. The register will
3518 be automatically down-cased.
3519 @item <count> ["<a-z1-9>]P
3520 Put the contents of the (default undo) buffer
3521 <count> times before the cursor. The register will
3523 Show contents of textmarker.
3525 Show contents of register.
3527 Repeat previous command <count> times. For destructive
3528 commands as well as undo.
3530 While @kbd{.} repeats the last destructive command,
3531 these two macros repeat the second-last and the third-last destructive
3532 commands. @xref{Vi Macros}, for more information on Vi macros.
3533 @item C-c M-p and C-c M-n
3535 these commands help peruse the history of Vi's destructive commands.
3536 Successive typing of @kbd{C-c M-p} causes Viper to search the history in
3538 of older commands, while hitting @kbd{C-c M-n} does so in reverse
3539 order. Each command in the history is displayed in the minibuffer. The
3540 displayed command can
3541 then be executed by typing `@kbd{.}'.
3543 Since typing the above sequences of keys may be tedious, the
3544 functions doing the perusing can be bound to unused keyboard keys in the
3545 @file{~/.viper} file. @xref{Viper Specials}, for details.
3547 @kindex @kbd{C-c M-p}
3548 @kindex @kbd{C-c M-n}
3550 @kindex @kbd{]<a-z>}
3551 @kindex @kbd{[<a-z>}
3554 @kindex @kbd{"<a-z1-9>p}
3555 @kindex @kbd{"<a-z1-9>P}
3557 @kindex @kbd{><move>}
3564 @node Editing in Insert State
3565 @subsection Editing in Insert State
3567 Minibuffer can be edited similarly to Insert state, and you can switch
3568 between Insert/Replace/Vi states at will.
3569 Some users prefer plain Emacs feel in the minibuffer. To this end, set
3570 @var{viper-vi-style-in-minibuffer} to @code{nil}.
3572 @cindex Insert state
3576 Deprive the next char of its special meaning (quoting).
3582 Back to the begin of the change on the
3591 @subsection Deleting Text
3594 There is one difference in text deletion that you should be
3595 aware of. This difference comes from Emacs and was adopted in Viper
3596 because we find it very useful. In Vi, if you delete a line, say, and then
3597 another line, these two deletions are separated and are put back
3598 separately if you use the @samp{p} command. In Emacs (and Viper), successive
3599 series of deletions that are @emph{not interrupted} by other commands are
3600 lumped together, so the deleted text gets accumulated and can be put back
3601 as one chunk. If you want to break a sequence of deletions so that the
3602 newly deleted text could be put back separately from the previously deleted
3603 text, you should perform a non-deleting action, e.g., move the cursor one
3604 character in any direction.
3606 @cindex shifting text
3610 Delete <count> chars under and after the cursor.
3612 Delete <count> chars before the cursor.
3613 @item <count> d<move>
3614 Delete from point to endpoint of <count><move>.
3616 Delete <count> lines.
3618 The rest of the line.
3619 @item <count> <<move>
3620 Shift the lines described by <count><move> one
3621 shiftwidth to the left (layout!).
3623 Shift <count> lines one shiftwidth to the left.
3626 @kindex @kbd{<<move>}
3629 @kindex @kbd{d<move>}
3634 @subsection Changing Text
3636 @cindex joining lines
3637 @cindex changing case
3638 @cindex quoting regions
3639 @cindex substitution
3642 @item <count> r<char>
3643 Replace <count> chars by <char>; no <esc>.
3645 Overwrite the rest of the line,
3646 appending change @var{count} @minus{} 1 times.
3648 Substitute <count> chars.
3650 Change <count> lines.
3651 @item <count> c<move>
3652 Change from begin to endpoint of <count><move>.
3654 Change <count> lines.
3656 The rest of the line and <count> @minus{} 1 next lines.
3657 @item <count> =<move>
3658 Reindent the region described by move.
3660 Switch lower and upper cases.
3662 Join <count> lines (default 2).
3663 @item :[x,y]s/<pat>/<repl>/<f>
3664 Substitute (on lines x through y) the pattern
3665 <pat> (default the last pattern) with <repl>. Useful
3666 flags <f> are @samp{g} for @samp{global} (i.e., change every
3667 non-overlapping occurrence of <pat>) and @samp{c} for
3668 @samp{confirm} (type @samp{y} to confirm a particular
3669 substitution, else @samp{n} ). Instead of @kbd{/} any
3670 punctuation CHAR unequal to <space> <tab> and <lf> can be used as
3673 In Emacs, @samp{\&} stands for the last matched expression, so
3674 @kbd{s/[ab]+/\&\&/} will double the string matched by @kbd{[ab]}.
3675 Viper doesn't treat @samp{&} specially, unlike Vi: use @samp{\&} instead.
3677 Viper does not parse search patterns and does not expand special symbols
3678 found there (e.g., @samp{~} is not expanded to the result of the previous
3681 Note: @emph{The newline character (inserted as @kbd{C-qC-j})
3682 can be used in <repl>}.
3683 @item :[x,y]copy [z]
3684 Copy text between @kbd{x} and @kbd{y} to the position after @kbd{z}.
3686 Same as @kbd{:copy}.
3687 @item :[x,y]move [z]
3688 Move text between @kbd{x} and @kbd{y} to the position after @kbd{z}.
3690 Repeat latest Ex substitute command, e.g.,
3691 @kbd{:s/wrong/right}.
3695 The above commands display certain buffer lines in a
3696 temporary buffer. The first form above displays the buffer lines between
3697 @kbd{x} and @kbd{y}. The second displays the lines of the buffer, which
3698 match a given pattern. The third form displays the lines that do @emph{not}
3699 match the given pattern.
3701 Change upper-case characters in the region to lower-case.
3703 Change lower-case characters in the region to upper-case.
3705 Insert specified string at the beginning of each line in the region
3706 @item C-c M-p and C-c M-n
3707 In Insert and Replace states, these keys are bound to commands that peruse
3708 the history of the text
3709 previously inserted in other insert or replace commands. By repeatedly typing
3710 @kbd{C-c M-p} or @kbd{C-c M-n}, you will cause Viper to
3711 insert these previously used strings one by one.
3712 When a new string is inserted, the previous one is deleted.
3714 In Vi state, these keys are bound to functions that peruse the history of
3715 destructive Vi commands.
3716 @xref{Viper Specials}, for details.
3718 @kindex @kbd{C-c M-p}
3719 @kindex @kbd{C-c M-n}
3720 @kindex @kbd{#q<move> }
3721 @kindex @kbd{#C<move>}
3722 @kindex @kbd{#c<move>}
3725 @findex @kbd{:substitute/<pat>/<repl>/<f>}
3726 @findex @kbd{:s/<pat>/<repl>/<f>}
3727 @findex @kbd{:copy [z]}
3728 @findex @kbd{:t [z]}
3729 @findex @kbd{:move [z]}
3732 @kindex @kbd{=<move>}
3735 @kindex @kbd{c<move>}
3739 @kindex @kbd{r<char>}
3741 @node Search and Replace
3742 @subsection Search and Replace
3744 @xref{Groundwork}, for Ex address syntax. @xref{Options}, to see how to
3745 get literal (non-regular-expression) search and how to stop search from
3750 Toggle case-sensitive search. With prefix argument, toggle vanilla/regular
3752 @item <count> /<string>
3753 To the <count>th occurrence of <string>.
3755 Viper does not parse search patterns and does not expand special symbols
3756 found there (e.g., @samp{~} is not expanded to the result of the previous
3759 After typing @kbd{/} or @kbd{?} all the usual Emacs minibuffer commands, such as
3760 @kbd{M-p} and @kbd{M-n} are available. In addition, typing @kbd{C-s} will
3761 insert the last search string used by the Emacs incremental search command
3762 (which is bound to @kbd{C-s} everywhere except in this case).
3764 @item <count> ?<string>
3765 To the <count>th previous occurrence of <string>.
3766 @item <count> g<move>
3767 Search for the text described by move. (off by default)
3769 Repeat latest @kbd{/} @kbd{?} (next).
3771 Idem in opposite direction.
3773 Find the next bracket and go to its match
3774 @item :[x,y]g/<string>/<cmd>
3775 @cindex text processing
3776 Search globally [from line x to y] for <string>
3777 and execute the Ex <cmd> on each occurrence.
3778 @item :[x,y]v/<string>/<cmd>
3779 Execute <cmd> on the lines that don't match.
3781 Execute the last keyboard macro for each line in the region.
3782 @xref{Macros and Registers}, for more info.
3786 Search in the tags file where <name> is defined (file, line), and go to it.
3787 @item :[x,y]s/<pat>/<repl>/<f>
3788 Substitute (on lines x through y) the pattern <pat> (default the last
3789 pattern) with <repl>. Useful
3790 flags <f> are @samp{g} for @samp{global} (i.e., change every
3791 non-overlapping occurrence of <pat>) and @samp{c} for
3792 @samp{confirm} (type @samp{y} to confirm a particular
3793 substitution, else @samp{n}). Instead of @kbd{/} any
3794 punctuation character other than <space> <tab> and <lf> can be used as
3797 Note: @emph{The newline character (inserted as @kbd{C-qC-j})
3798 can be used in <repl>}.
3800 Repeat latest Ex substitute command, e.g., @kbd{:s/wrong/right}.
3801 @item :global /<pattern>/<ex-command>
3802 @itemx :g /<pattern>/<ex-command>
3803 Execute <ex-command> on all lines that match <pattern>.
3804 @item :vglobal /<pattern>/<ex-command>
3805 @itemx :v /<pattern>/<ex-command>
3806 Execute <ex-command> on all lines that do not match <pattern>.
3809 @findex @kbd{:substitute/<pat>/<repl>/<f>}
3811 @kindex @kbd{#g<move>}
3814 @findex @kbd{:global}
3815 @findex @kbd{:vglobal}
3816 @findex @kbd{:tag <name>}
3820 @kindex @kbd{g<move>}
3821 @kindex @kbd{?<string>}
3822 @kindex @kbd{/<string>}
3827 @cindex cut and paste
3831 @item <count> y<move>
3832 Yank from begin to endpoint of <count><move>.
3833 @item <count> "<a-z>y<move>
3834 Yank from begin to endpoint of <count><move> to register.
3835 @item <count> "<A-Z>y<move>
3836 Yank from begin to endpoint of <count><move> and append
3841 Idem (should be equivalent to @kbd{y$} though).
3843 Mark the cursor position with a letter.
3845 Show contents of textmarker.
3847 Show contents of register.
3848 @item <count> ["<a-z1-9>]p
3849 Put the contents of the (default undo) buffer
3850 <count> times after the cursor. The register will
3851 be automatically down-cased.
3852 @item <count> ["<a-z1-9>]P
3853 Put the contents of the (default undo) buffer
3854 <count> times before the cursor. The register will
3858 @kindex @kbd{"<a-z1-9>p}
3859 @kindex @kbd{"<a-z1-9>P}
3860 @kindex @kbd{]<a-z>}
3861 @kindex @kbd{[<a-z>}
3862 @kindex @kbd{m<a-z>}
3865 @kindex @kbd{"<A-Z>y<move>}
3866 @kindex @kbd{"<a-z>y<move>}
3867 @kindex @kbd{y<move>}
3875 @cindex backup files
3879 Undo the latest change.
3883 Quit Vi without writing.
3885 Re-edit a messed-up file.
3887 Recover file from autosave. Viper also creates backup files
3888 that have a @samp{~} appended to them.
3905 give file name, status, current line number
3906 and relative position.@*
3907 At user levels 2 and higher, abort the current command.
3909 Give file name, status, current line number and relative position---all
3914 Expose <count> more lines at bottom, cursor stays put (if possible).
3916 Expose <count> more lines at top, cursor stays put (if possible).
3918 Scroll <count> lines downward (default the number of the previous scroll;
3919 initialization: half a page).
3921 Scroll <count> lines upward (default the number of the previous scroll;
3922 initialization: half a page).
3924 <count> pages forward.
3926 <count> pages backward (in older versions @kbd{C-b} only works without count).
3929 Put line <count> at the top of the window (default the current line).
3932 Put line <count> at the bottom of the window
3933 (default the current line).
3936 Put line <count> in the center of the window
3937 (default the current line).
3956 @node File and Buffer Handling
3957 @section File and Buffer Handling
3959 @cindex multiple files
3961 In all file handling commands, space should be typed before entering the file
3962 name. If you need to type a modifier, such as @kbd{>>} or @kbd{!}, don't
3963 put any space between the command and the modifier.
3965 Note that many Ex commands, e.g., @kbd{:w}, accept command arguments. The
3966 effect is that the command would start acting on the current region. For
3967 instance, if the current region spans the lines 11 through 22, then if you
3968 type @kbd{1:w} you would see @samp{:11,22w} in the minibuffer.
3972 Quit buffer except if modified.
3974 Quit buffer without checking. In Viper, these two commands
3975 are identical. Confirmation is required if exiting modified buffers that
3981 Write the file. Viper makes sure that a final newline is always added to
3982 any file where this newline is missing. This is done by setting Emacs
3983 variable @code{require-final-newline} to @code{t}. If you don't like this
3984 feature, use @code{setq-default} to set @code{require-final-newline} to
3985 @code{nil}. This must be done in @file{.viper} file.
3986 @item :[x,y] w <name>
3987 Write to the file <name>.
3988 @item :[x,y] w>> <name>
3989 Append the buffer to the file <name>. There should be no space between
3990 @kbd{w} and @kbd{>>}. Type space after the @kbd{>>} and see what happens.
3992 Overwrite the file <name>. In Viper, @kbd{:w} and @kbd{:w!} are identical.
3993 Confirmation is required for writing to an existing file (if this is not
3994 the file the buffer is visiting) or to a read-only file.
3996 Write lines x through y to the file <name>.
3998 Write the file and kill buffer.
3999 @item :r <file> [<file> ...]
4000 Read file into a buffer, inserting its contents after the current line.
4005 Save all unsaved buffers, asking for confirmation.
4008 Like @kbd{W}, but without asking for confirmation.
4010 Save current buffer and kill it. If user level is 1, then save all files
4011 and kill Emacs. Killing Emacs is the wrong way to use it, so you should
4012 switch to higher user levels as soon as possible.
4014 Save and kill buffer.
4015 @item :x!@: [<file>]
4016 @kbd{:w![<file>]} and @kbd{:q}.
4018 Preserve the file---autosave buffers.
4020 Recover file from autosave.
4022 without the argument, prints file name and character/line information afout
4023 the currently visited file. With an argument, sets the currently visited
4024 filename to @file{file}.
4026 Set the working directory to <dir> (default home directory).
4028 Print present working directory.
4029 @item :e [+<cmd>] <files>
4030 Edit files. If no filename is given, edit the file visited by the current
4031 buffer. If buffer was modified or the file changed on disk, ask for
4032 confirmation. Unlike Vi, Viper allows @kbd{:e} to take multiple arguments.
4033 The first file is edited the same way as in Vi. The rest are visited
4034 in the usual Emacs way.
4035 @item :e!@: [+<cmd>] <files>
4036 Re-edit file. If no filename, re-edit current file.
4037 In Viper, unlike Vi, @kbd{e!} is identical to @kbd{:e}. In both cases, the
4038 user is asked to confirm if there is a danger of discarding changes to a
4041 Quit Vi without writing.
4043 Edit the alternate (normally the previous) file.
4047 List files not shown anywhere with counts for next
4048 @item :n [count] [+<cmd>] [<files>]
4049 Edit <count> file, or edit files. The count comes from @kbd{:args}.
4050 @item :N [count] [+<cmd>] [<files>]
4051 Like @kbd{:n}, but the meaning of the variable
4052 @var{ex-cycle-other-window} is reversed.
4054 Switch to another buffer. If @var{ex-cycle-other-window} is @code{t},
4055 switch in another window. Buffer completion is supported.
4056 The variable @var{viper-read-buffer-function} controls which function is
4057 actually used to read the buffer name. The default is @code{read-buffer},
4058 but better alternatives are also available in Emacs (e.g.,
4059 @code{iswitchb-read-buffer}).
4060 @vindex @var{viper-read-buffer-function}
4062 Like @kbd{:b}, but the meaning of @var{ex-cycle-other-window} is reversed.
4063 @item :<address>r <name>
4064 Read the file <name> into the buffer after the line <address>.
4066 Edit a file in current or another window, or in another frame. File name
4067 is typed in minibuffer. File completion and history are supported.
4074 @findex @kbd{:e!@: [<files>]}
4075 @findex @kbd{:e [<files>]}
4076 @findex @kbd{:edit [<files>]}
4077 @findex @kbd{:edit!@: [<files>]}
4081 @findex @kbd{:quit!}
4089 @findex @kbd{:w <file>}
4090 @findex @kbd{:w!@: <file>}
4091 @findex @kbd{:w >> <file>}
4092 @findex @kbd{:write <file>}
4093 @findex @kbd{:write!@: <file>}
4094 @findex @kbd{:write >> <file>}
4097 @findex @kbd{:Write}
4098 @findex @kbd{:WWrite}
4099 @findex @kbd{:WWrite}
4102 @findex @kbd{:suspend}
4104 @findex @kbd{:n [<count> | <file>]}
4105 @findex @kbd{:cd [<dir>]}
4111 @cindex key bindings
4116 Start defining a Vi-style keyboard macro.
4117 For instance, typing
4118 @kbd{:map www} followed by @kbd{:!wc %} and then typing @kbd{C-x )}
4119 will cause @kbd{www} to run wc on
4120 current file (Vi replaces @samp{%} with the current file name).
4122 Finish defining a keyboard macro.
4123 In Viper, this command completes the process of defining all keyboard
4124 macros, whether they are Emacs-style or Vi-style.
4125 This is a departure from Vi, needed to allow WYSIWYG mapping of
4126 keyboard macros and to permit the use of function keys and arbitrary Emacs
4127 functions in the macros.
4128 @item :unmap <string>
4129 Deprive <string> of its mappings in Vi state.
4130 @item :map!@: <string>
4131 Map a macro for Insert state.
4132 @item :unmap!@: <string>
4133 Deprive <string> of its mapping in Insert state (see @kbd{:unmap}).
4136 execute the contents of register as a command.
4139 repeat last register command.
4142 begin keyboard macro. End with @@<a-z>. This will
4143 put the macro in the proper register. Register will
4144 be automatically down-cased.
4145 @xref{Macros and Registers}, for more info.
4148 yank anonymous macro to register
4151 execute anonymous macro (defined by C-x( and C-x )).
4153 Like @kbd{*}, but works in all Viper states.
4155 Execute the last keyboard macro for each line in the region.
4156 @xref{Macros and Registers}, for more info.
4158 Show contents of textmarker.
4160 Show contents of register.
4162 @kindex @kbd{]<a-z>}
4163 @kindex @kbd{[<a-z>}
4164 @kindex @kbd{#g<move>}
4166 @kindex @kbd{@@!<a-z>}
4169 @kindex @kbd{@@<a-z>}
4170 @findex @kbd{:unmap <char>}
4171 @findex @kbd{:map <char> <seq>}
4172 @findex @kbd{:unmap!@: <char>}
4173 @findex @kbd{:map!@: <char> <seq>}
4175 @node Shell Commands
4176 @section Shell Commands
4178 @cindex % (Current file)
4180 The symbol @samp{%} is used in Ex shell commands to mean current file. If
4181 you want a @samp{%} in your command, it must be escaped as @samp{\%}.
4182 @cindex @samp{%} (Ex address)
4183 However if @samp{%} is the first character, it stands as the address for
4185 @cindex @samp{#} (Previous file)
4186 Similarly, @samp{#} expands to the previous file. The previous file is the
4187 first file in @kbd{:args} listing. This defaults to the previous file in
4188 the VI sense if you have one window.
4190 Symbols @samp{%} and @samp{#} are also used in the Ex commands @kbd{:e} and
4191 @kbd{:r <shell-cmd>}. The commands @kbd{:w} and the regular @kbd{:r
4192 <file>} command don't support these meta symbols, because file history is a
4195 @cindex shell commands
4199 Execute a subshell in another window
4201 Execute a shell <cmd> [on lines x through y;
4202 % is replace by current file, \% is changed to %
4203 @item :[x,y]!!@: [<args>]
4204 Repeat last shell command [and append <args>].
4206 Just execute command and display result in a buffer.
4208 Repeat last shell command and append <args>
4209 @item <count> !<move><cmd>
4210 The shell executes <cmd>, with standard
4211 input the lines described by <count><move>,
4212 next the standard output replaces those lines
4213 (think of @samp{cb}, @samp{sort}, @samp{nroff}, etc.).
4214 @item <count> !!<cmd>
4215 Give <count> lines as standard input to the
4216 shell <cmd>, next let the standard output
4217 replace those lines.
4218 @item :[x,y] w !<cmd>
4219 Let lines x to y be standard input for <cmd>
4220 (notice the <sp> between @kbd{w} and @kbd{!}).
4221 @item :<address>r !<cmd>
4222 Put the output of <cmd> after the line <address> (default current).
4223 @item :<address>r <name>
4224 Read the file <name> into the buffer after the line <address> (default
4227 Run the make command in the current directory.
4229 @findex @kbd{:<address>r <name>}
4230 @findex @kbd{:<address>r !<cmd>}
4231 @findex @kbd{!<cmd>}
4232 @findex @kbd{!!<cmd>}
4233 @findex @kbd{!<move><cmd>}
4234 @findex @kbd{:w !<cmd>}
4235 @findex @kbd{:x,y w !<cmd>}
4236 @findex @kbd{:!!@: <args>}
4237 @findex @kbd{:!<cmd>}
4250 autoindent: In append mode after a <cr> the
4251 cursor will move directly below the first
4252 character on the previous line.
4253 This setting affects the current buffer only.
4254 @item autoindent-global
4256 Same as `autoindent', but affects all buffers.
4260 @item noautoindent-global
4262 Cancel autoindent-global.
4265 @cindex case and searching
4266 ignorecase: No distinction between upper and lower cases when searching.
4272 @cindex literal searching
4273 Regular expressions used in searches; nomagic means no regexps.
4279 @cindex readonly files
4280 readonly: The file is not to be changed.
4281 If the user attempts to write to this file, confirmation will be requested.
4285 @item shell=<string>
4288 shell: The program to be used for shell escapes
4289 (default @samp{$SHELL} (default @file{/bin/sh})).
4290 @item shiftwidth=<count>
4293 @cindex shifting text
4294 shiftwidth: Gives the shiftwidth (default 8 positions).
4297 @cindex paren matching
4298 @cindex matching parens
4299 showmatch: Whenever you append a @kbd{)}, Vi shows
4300 its match if it's on the same page; also with
4301 @kbd{@{} and @kbd{@}}. If there's no match, Vi will beep.
4305 @item tabstop=<count>
4307 @cindex changing tab width
4309 tabstop: The length of a <ht>; warning: this is
4310 only IN the editor, outside of it <ht>s have
4311 their normal length (default 8 positions).
4312 This setting affects the current buffer only.
4313 @item tabstop-global
4315 Same as `tabstop', but affects all buffers.
4316 @item wrapmargin=<count>
4320 wrapmargin: In append mode Vi automatically
4321 puts a <lf> whenever there is a <sp> or <ht>
4322 within <wm> columns from the right margin.
4326 wrapscan: When searching, the end is
4327 considered @samp{stuck} to the begin of the file.
4333 @item :set no<option>
4335 @item :set <option>=<value>
4336 Set <option> to <value>.
4338 @findex @kbd{:set <option>=<value>}
4339 @findex @kbd{:set no<option>}
4340 @findex @kbd{:set <option>}
4341 @findex @kbd{:set ws}
4342 @findex @kbd{:set wrapscan}
4343 @findex @kbd{:set wm=<count>}
4344 @findex @kbd{:set wrapmargin=<count>}
4345 @findex @kbd{:set ts=<count>}
4346 @findex @kbd{:set tabstop=<count>}
4347 @findex @kbd{:set tab-stop-local=<count>}
4348 @findex @kbd{:set sm}
4349 @findex @kbd{:set showmatch}
4350 @findex @kbd{:set sw=<count>}
4351 @findex @kbd{:set shiftwidth=<count>}
4352 @findex @kbd{:set sh=<string>}
4353 @findex @kbd{:set shell=<string>}
4354 @findex @kbd{:set ro}
4355 @findex @kbd{:set readonly}
4356 @findex @kbd{:set magic}
4357 @findex @kbd{:set ic}
4358 @findex @kbd{:set ignorecase}
4359 @findex @kbd{:set ai}
4360 @findex @kbd{:set autoindent}
4362 @node Emacs Related Commands
4363 @section Emacs Related Commands
4367 Begin Meta command in Vi or Insert states. Most often used as C-\ x (M-x).
4369 Note: Emacs binds @kbd{C-\} to a function that offers to change the
4370 keyboard input method in the multilingual environment. Viper overrides this
4371 binding. However, it is still possible to switch the input method by typing
4372 @kbd{\ C-\} in the Vi command state and @kbd{C-z \ C-\} in the Insert state.
4373 Or you can use the MULE menu on the menubar.
4375 In Insert and Replace states, prepare Viper to accept the next command and
4376 execute it as if Viper was in Vi state. Then return to Insert state.
4378 In Vi state, switch to Emacs state; in Emacs state, switch to Vi state.
4380 Switches to Vi state for the duration of a single command. Then goes back
4381 to the original Viper state. Works from Vi, Insert, Replace, and Emacs states.
4391 Emacs find-file, useful in Insert state
4393 Put back the last killed text. Similar to Vi's @kbd{p}, but also works in
4394 Insert and Replace state. This command doesn't work in Vi command state,
4395 since this binding is taken for something else.
4397 Undoes the last @kbd{C-y} and puts another kill from the kill ring.
4398 Using this command, you can try may different kills until you find the one
4403 @kindex @kbd{C-xC-f}
4412 @node Mouse-bound Commands
4413 @section Mouse-bound Commands
4415 The following two mouse actions are normally bound to special search and
4416 insert commands in of Viper:
4420 Holding Shift and clicking mouse button 1 will
4422 a region under the mouse pointer.
4423 This command can take a prefix argument. Note: Viper sets this
4424 binding only if this mouse action is not
4425 already bound to something else.
4426 @xref{Viper Specials}, for more information.
4429 Holding Shift and clicking button 2 of the mouse will
4430 insert a region surrounding the mouse pointer.
4431 This command can also take a prefix argument.
4432 Note: Viper sets this binding only if this mouse action is not
4433 already bound to something else.
4434 @xref{Viper Specials}, for more details.
4436 @kindex @kbd{S-Mouse-1}
4437 @kindex @kbd{S-Mouse-2}
4438 @kindex @kbd{meta button1up}
4439 @kindex @kbd{meta button2up}
4441 @node GNU Free Documentation License
4442 @appendix GNU Free Documentation License
4443 @include doclicense.texi
4445 @node Acknowledgments
4446 @unnumbered Acknowledgments
4448 Viper, formerly known as VIP-19, was written by Michael Kifer. Viper is
4449 based on the original VIP package by Masahiko Sato and on its enhancement,
4450 VIP 4.4, by Aamod Sane. This manual is an adaptation of the manual for VIP
4451 4.4, which, in turn, was based on Sato's manual for VIP 3.5.
4453 Many contributors on the Net pointed out bugs and suggested a number of
4454 useful features. Scott Bronson and Samuel Padgett contributed patches that
4455 were incorporated in this code. Here is a hopefully complete list of
4459 aaronl@@vitelus.com (Aaron Lehmann),
4460 ahg@@panix.com (Al Gelders),
4461 amade@@diagram.fr (Paul-Bernard Amade),
4462 ascott@@fws214.intel.com (Andy Scott),
4463 bronson@@trestle.com (Scott Bronson),
4464 cook@@biostat.wisc.edu (Tom Cook),
4465 csdayton@@midway.uchicago.edu (Soren Dayton),
4466 dave@@hellgate.utah.edu,
4467 dm@@scs.cs.nyu.edu (David Mazieres),
4468 dominik@@strw.LeidenUniv.nl (Carsten Dominik),
4469 dwallach@@cs.princeton.edu (Dan Wallach),
4470 dwight@@toolucky.llnl.gov (Dwight Shih),
4471 dxc@@xprt.net (David X Callaway),
4472 edmonds@@edmonds.home.cs.ubc.ca (Brian Edmonds),
4473 gin@@mo.msk.ru (Golubev I.N.),
4474 gviswana@@cs.wisc.edu (Guhan Viswanathan),
4475 gvr@@halcyon.com (George V. Reilly),
4476 hatazaki@@bach.convex.com (Takao Hatazaki),
4477 hpz@@ibmhpz.aug.ipp-garching.mpg.de (Hans-Peter Zehrfeld),
4478 irie@@t.email.ne.jp (Irie Tetsuya),
4479 jackr@@dblues.engr.sgi.com (Jack Repenning),
4480 jamesm@@bga.com (D.J. Miller II),
4481 jjm@@hplb.hpl.hp.com (Jean-Jacques Moreau),
4482 jl@@cse.ogi.edu (John Launchbury),
4483 jobrien@@hchp.org (John O'Brien),
4484 johnw@@borland.com (John Wiegley),
4485 kanze@@gabi-soft.fr (James Kanze),
4486 kin@@isi.com (Kin Cho),
4487 kwzh@@gnu.org (Karl Heuer),
4488 lindstro@@biostat.wisc.edu (Mary Lindstrom),
4489 lektu@@terra.es (Juanma Barranquero),
4490 lennart.borgman.073@@student.lu.se (Lennart Borgman),
4491 minakaji@@osaka.email.ne.jp (Mikio Nakajima),
4492 Mark.Bordas@@East.Sun.COM (Mark Bordas),
4493 meyering@@comco.com (Jim Meyering),
4494 martin@@xemacs.org (Martin Buchholz),
4495 mbutler@@redfernnetworks.com (Malcolm Butler),
4496 mveiga@@dit.upm.es (Marcelino Veiga Tuimil),
4497 paulk@@summit.esg.apertus.com (Paul Keusemann),
4498 pfister@@cs.stonybrook.edu (Hanspeter Pfister),
4499 phil_brooks@@MENTORG.COM (Phil Brooks),
4500 pogrell@@informatik.hu-berlin.de (Lutz Pogrell),
4501 pradyut@@cs.uchicago.edu (Pradyut Shah),
4502 roderick@@argon.org (Roderick Schertler),
4503 rxga@@ulysses.att.com,
4504 sawdey@@lcse.umn.edu (Aaron Sawdey),
4505 simonb@@prl.philips.co.uk (Simon Blanchard),
4506 spadgett1@@nc.rr.com (Samuel Padgett),
4507 stephen@@farrell.org (Stephen Farrell),
4508 storm@@cua.dk (Kim F. Storm),
4509 sudish@@MindSpring.COM (Sudish Joseph),
4510 schwab@@issan.informatik.uni-dortmund.de (Andreas Schwab)
4511 terra@@diku.dk (Morten Welinder),
4512 thanh@@informatics.muni.cz (Han The Thanh),
4513 toma@@convex.convex.com,
4514 vrenjak@@sun1.racal.com (Milan Vrenjak),
4515 whicken@@dragon.parasoft.com (Wendell Hicken),
4516 zapman@@cc.gatech.edu (Jason Zapman II),
4520 @unnumbered Key Index
4524 @node Function Index
4525 @unnumbered Function Index
4529 @node Variable Index
4530 @unnumbered Variable Index
4535 @unnumbered Package Index
4540 @unnumbered Concept Index