1 ;;; viper.el --- A full-featured Vi emulator for GNU Emacs and XEmacs,
2 ;; a VI Plan for Emacs Rescue,
3 ;; and a venomous VI PERil.
4 ;; Viper Is also a Package for Emacs Rebels.
6 ;; Keywords: emulations
7 ;; Author: Michael Kifer <kifer@cs.sunysb.edu>
9 ;; Copyright (C) 1994, 95, 96, 97, 98, 99, 2000 Free Software Foundation, Inc.
11 (defconst viper-version
"3.08 of October 31, 1999"
12 "The current version of Viper")
14 ;; This file is part of GNU Emacs.
16 ;; GNU Emacs is free software; you can redistribute it and/or modify
17 ;; it under the terms of the GNU General Public License as published by
18 ;; the Free Software Foundation; either version 2, or (at your option)
21 ;; GNU Emacs is distributed in the hope that it will be useful,
22 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
23 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 ;; GNU General Public License for more details.
26 ;; You should have received a copy of the GNU General Public License
27 ;; along with GNU Emacs; see the file COPYING. If not, write to the
28 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
29 ;; Boston, MA 02111-1307, USA.
33 ;; Viper is a full-featured Vi emulator for Emacs and XEmacs. It emulates and
34 ;; improves upon the standard features of Vi and, at the same time, allows
35 ;; full access to all Emacs facilities. Viper supports multiple undo,
36 ;; file name completion, command, file, and search history and it extends
37 ;; Vi in many other ways. Viper is highly customizable through the various
38 ;; hooks, user variables, and keymaps. It is implemented as a collection
39 ;; of minor modes and it is designed to provide full access to all Emacs
40 ;; major and minor modes.
44 ;; Viper is a new name for a package formerly known as VIP-19,
45 ;; which was a successor of VIP version 3.5 by Masahiko Sato
46 ;; <ms@sail.stanford.edu> and VIP version 4.2 by Aamod Sane
47 ;; <sane@cs.uiuc.edu>. Some ideas from vip 4.4.2 by Aamod Sane
48 ;; were also shamelessly plagiarized.
50 ;; Viper maintains some degree of compatibility with these older
51 ;; packages. See the documentation for customization.
53 ;; The main difference between Viper and these older packages are:
55 ;; 1. Viper emulates Vi at several levels, from almost complete conformity
56 ;; to a rather loose Vi-compliance.
58 ;; 2. Viper provides full access to all major and minor modes of Emacs
59 ;; without the need to type extra keys.
60 ;; The older versions of VIP (and other Vi emulators) do not work with
61 ;; some major and minor modes.
63 ;; 3. Viper supports vi-style undo.
65 ;; 4. Viper fully emulates (and improves upon) vi's replacement mode.
67 ;; 5. Viper has a better interface to ex, including command, variable, and
68 ;; file name completion.
70 ;; 6. Viper uses native Emacs history and completion features; it doesn't
71 ;; rely on other packages (such as gmhist.el and completer.el) to provide
74 ;; 7. Viper supports Vi-style editing in the minibuffer, by allowing the
75 ;; user to switch from Insert state to Vi state to Replace state, etc.
77 ;; 8. Viper keeps history of recently inserted pieces of text and recently
78 ;; executed Vi-style destructive commands, such as `i', `d', etc.
79 ;; These pieces of text can be inserted in later insertion commands;
80 ;; the previous destructive commands can be re-executed.
82 ;; 9. Viper has Vi-style keyboard macros, which enhances the similar
83 ;; facility in the original Vi.
84 ;; First, one can execute any Emacs command while defining a
85 ;; macro, not just the Vi commands. Second, macros are defined in a
86 ;; WYSYWYG mode, using an interface to Emacs' WYSIWYG style of defining
87 ;; macros. Third, in Viper, one can define macros that are specific to
88 ;; a given buffer, a given major mode, or macros defined for all buffers.
89 ;; The same macro name can have several different definitions:
90 ;; one global, several definitions for various major modes, and
91 ;; definitions for specific buffers.
92 ;; Buffer-specific definitions override mode-specific
93 ;; definitions, which, in turn, override global definitions.
102 ;;; Acknowledgements:
104 ;; Bug reports and ideas contributed by many users have helped
105 ;; improve Viper and the various versions of VIP.
106 ;; See the on-line manual for a complete list of contributors.
112 ;; In most cases, Viper handles major modes correctly, i.e., they come up
113 ;; in the right state (either vi-state or emacs-state). For instance, text
114 ;; files come up in vi-state, while, say, Dired appears in emacs-state by
116 ;; However, some modes do not appear in the right mode in the beginning,
117 ;; usually because they neglect to follow Emacs conventions (e.g., they don't
118 ;; use kill-all-local-variables when they start). Some major modes
119 ;; may fail to come up in emacs-state if they call hooks, such as
120 ;; text-hook, for no good reason.
122 ;; As an immediate solution, you can hit C-z to bring about the right mode.
123 ;; An interim solution is to add an appropriate hook to the mode like this:
125 ;; (add-hook 'your-favorite-mode 'viper-mode)
127 ;; (add-hook 'your-favorite-mode 'viper-change-state-to-emacs)
129 ;; whichever applies. The right thing to do, however, is to complain to the
130 ;; author of the respective package. (Sometimes they also neglect to equip
131 ;; their modes with hooks, which is one more reason for complaining.)
133 ;; 2. Keymap handling
134 ;; Each Viper state (insert, vi, replace) is implemented as a collection of
135 ;; several minor modes, each with its own keymap.
137 ;; Viper's Vi state consists of seven minor modes:
139 ;; viper-vi-intercept-minor-mode
140 ;; viper-vi-local-user-minor-mode
141 ;; viper-vi-global-user-minor-mode
142 ;; viper-vi-kbd-minor-mode
143 ;; viper-vi-state-modifier-minor-mode
144 ;; viper-vi-diehard-minor-mode
145 ;; viper-vi-basic-minor-mode
147 ;; Bindings done to the keymap of the first mode overshadow those done to
148 ;; the second, which, in turn, overshadows those done to the third, etc.
150 ;; The last viper-vi-basic-minor-mode contains most of the usual Vi bindings
151 ;; in its edit mode. This mode provides access to all Emacs facilities.
152 ;; Novice users, however, may want to set their viper-expert-level to 1
153 ;; in their .viper file. This will enable viper-vi-diehard-minor-mode. This
154 ;; minor mode's bindings make Viper simulate the usual Vi very closely.
155 ;; For instance, C-c will not have its standard Emacs binding
156 ;; and so many of the goodies of Emacs are not available.
158 ;; A skilled user should set viper-expert-level to at least 3. This will
159 ;; enable `C-c' and many Emacs facilities will become available.
160 ;; In this case, viper-vi-diehard-minor-mode is inactive.
162 ;; Viper gurus should have at least
163 ;; (setq viper-expert-level 4)
164 ;; in their ~/.viper files. This will unsuppress all Emacs keys that are not
165 ;; essential for VI-style editing.
166 ;; Pick-and-choose users may want to put
167 ;; (setq viper-expert-level 5)
168 ;; in ~/.viper. Viper will then leave it up to the user to set the variables
169 ;; viper-want-* See viper-set-expert-level for details.
171 ;; The very first minor mode, viper-vi-intercept-minor-mode, is of no
172 ;; concern for the user. It is needed to bind Viper's vital keys, such as
175 ;; The second mode, viper-vi-local-user-minor-mode, usually has an
176 ;; empty keymap. However, the user can set bindings in this keymap, which
177 ;; will overshadow the corresponding bindings in the other two minor
178 ;; modes. This is useful, for example, for setting up ZZ in gnus,
179 ;; rmail, mh-e, etc., to send message instead of saving it in a file.
180 ;; Likewise, in Dired mode, you may want to bind ZN and ZP to commands
181 ;; that would visit the next or the previous file in the Dired buffer.
182 ;; Setting local keys is tricky, so don't do it directly. Instead, use
183 ;; viper-add-local-keys function (see its doc).
185 ;; The third minor mode, viper-vi-global-user-minor-mode, is also intended
186 ;; for the users but, unlike viper-vi-local-user-minor-mode, its key
187 ;; bindings are seen in all Viper buffers. This mode keys can be done
188 ;; with define-key command.
190 ;; The fourth minor mode, viper-vi-kbd-minor-mode, is used by keyboard
191 ;; macros. Users are NOT supposed to modify this keymap directly.
193 ;; The fifth mode, viper-vi-state-modifier-minor-mode, can be used to set
194 ;; key bindings that are visible in some major modes but not in others.
196 ;; Users are allowed to modify keymaps that belong to
197 ;; viper-vi-local-user-minor-mode, viper-vi-global-user-minor-mode,
198 ;; and viper-vi-state-modifier-minor-mode only.
200 ;; Viper's Insert state also has seven minor modes:
202 ;; viper-insert-intercept-minor-mode
203 ;; viper-insert-local-user-minor-mode
204 ;; viper-insert-global-user-minor-mode
205 ;; viper-insert-kbd-minor-mode
206 ;; viper-insert-state-modifier-minor-mode
207 ;; viper-insert-diehard-minor-mode
208 ;; viper-insert-basic-minor-mode
210 ;; As with VI's editing modes, the first mode,
211 ;; viper-insert-intercept-minor-mode is used to bind vital keys that are not
212 ;; to be changed by the user.
214 ;; The next mode, viper-insert-local-user-minor-mode, is used to customize
215 ;; bindings in the insert state of Viper. The third mode,
216 ;; viper-insert-global-user-minor-mode is like
217 ;; viper-insert-local-user-minor-mode, except that its bindings are seen in
218 ;; all Viper buffers. As with viper-vi-local-user-minor-mode, its bindings
219 ;; should be done via the function viper-add-local-keys. Bindings for
220 ;; viper-insert-global-user-minor-mode can be set with the define-key command.
222 ;; The next minor mode, viper-insert-kbd-minor-mode,
223 ;; is used for keyboard VI-style macros defined with :map!.
225 ;; The fifth minor mode, viper-insert-state-modifier-minor-mode, is like
226 ;; viper-vi-state-modifier-minor-mode, except that it is used in the Insert
227 ;; state; it can be used to modify keys in a mode-specific fashion.
229 ;; The minor mode viper-insert-diehard-minor-mode is in effect when
230 ;; the user wants a high degree of Vi compatibility (a bad idea, really!).
231 ;; The last minor mode, viper-insert-basic-minor-mode, is always in effect
232 ;; when Viper is in insert state. It binds a small number of keys needed for
233 ;; Viper's operation.
235 ;; Finally, Viper provides minor modes for overriding bindings set by Emacs
236 ;; modes when Viper is in Emacs state:
238 ;; viper-emacs-local-user-minor-mode
239 ;; viper-emacs-global-user-minor-mode
240 ;; viper-emacs-kbd-minor-mode
241 ;; viper-emacs-state-modifier-minor-mode
243 ;; These minor modes are in effect when Viper is in Emacs state. The keymap
244 ;; associated with viper-emacs-global-user-minor-mode,
245 ;; viper-emacs-global-user-map, overrides the global and local keymaps as
246 ;; well as the minor mode keymaps set by other modes. The keymap of
247 ;; viper-emacs-local-user-minor-mode, viper-emacs-local-user-map, overrides
248 ;; everything, but it is used on a per buffer basis.
249 ;; The keymap associated with viper-emacs-state-modifier-minor-mode
250 ;; overrides keys on a per-major-mode basis. The mode
251 ;; viper-emacs-kbd-minor-mode is used to define Vi-style macros in Emacs
254 ;; 3. There is also one minor mode that is used when Viper is in its
255 ;; replace-state (used for commands like cw, C, etc.). This mode is
258 ;; viper-replace-minor-mode
260 ;; and its keymap is viper-replace-map. Replace minor mode is always
261 ;; used in conjunction with the minor modes for insert-state, and its
262 ;; keymap overshadows the keymaps for insert minor modes.
264 ;; 4. Defining buffer-local bindings in Vi and Insert modes.
265 ;; As mentioned before, sometimes, it is convenient to have
266 ;; buffer-specific of mode-specific key bindings in Vi and insert modes.
267 ;; Viper provides a special function, viper-add-local-keys, to do precisely
268 ;; this. For instance, is you need to add couple of mode-specific bindings
269 ;; to Insert mode, you can put
271 ;; (viper-add-local-keys 'insert-state '((key1 . func1) (key2 .func2)))
273 ;; somewhere in a hook of this major mode. If you put something like this
274 ;; in your own elisp function, this will define bindings specific to the
275 ;; buffer that was current at the time of the call to viper-add-local-keys.
276 ;; The only thing to make sure here is that the major mode of this buffer
277 ;; is written according to Emacs conventions, which includes a call to
278 ;; (kill-all-local-variables). See viper-add-local-keys for more details.
281 ;; TO DO (volunteers?):
283 ;; 1. Some of the code that is inherited from VIP-3.5 is rather
284 ;; convoluted. Instead of viper-command-argument, keymaps should bind the
285 ;; actual commands. E.g., "dw" should be bound to a generic command
286 ;; viper-delete that will delete things based on the value of
287 ;; last-command-char. This would greatly simplify the logic and the code.
289 ;; 2. Somebody should venture to write a customization package a la
290 ;; options.el that would allow the user to change values of variables
291 ;; that meet certain specs (e.g., match a regexp) and whose doc string
292 ;; starts with a '*'. Then, the user should be offered to save
293 ;; variables that were changed. This will make user's customization job
304 (defvar mark-even-if-inactive
)
306 (defvar viper-expert-level
)
307 (defvar viper-mode-string
)
308 (defvar viper-major-mode-modifier-list
)
310 ;; loading happens only in non-interactive compilation
311 ;; in order to spare non-viperized emacs from being viperized
314 (let ((load-path (cons (expand-file-name ".") load-path
)))
315 (or (featurep 'viper-init
)
316 (load "viper-init.el" nil nil
'nosuffix
))
317 (or (featurep 'viper-cmd
)
318 (load "viper-cmd.el" nil nil
'nosuffix
))
322 (require 'viper-init
)
324 ;; better be defined before Viper custom group.
325 (defvar viper-custom-file-name
(convert-standard-filename "~/.viper")
326 "Viper customisation file.
327 If set by the user, this must be done _before_ Viper is loaded in `~/.emacs'.")
330 "Vi emulation within Emacs.
331 NOTE: Viper customization should be saved in `viper-custom-file-name', which
332 defaults to `~/.viper'."
338 (defgroup viper-misc nil
339 "Miscellaneous Viper customization."
344 (defcustom viper-always t
345 "Non-nil means, arrange for vi-state to be a default when appropriate.
346 This is different from `viper-mode' variable in that `viper-mode' determines
347 whether to use Viper in the first place, while `viper-always', if nil, lets
348 user decide when to invoke Viper in a major mode."
350 :tag
"Always Invoke Viper"
353 ;; Non-viper variables that need to be saved in case the user decides to
354 ;; de-viperize emacs.
355 (defvar viper-saved-non-viper-variables nil
)
356 ;; Contains user settings for vars affected by viper-set-expert-level function.
357 ;; Not a user option.
358 (defvar viper-saved-user-settings nil
)
360 (defcustom viper-mode
(cond (noninteractive nil
)
362 "To Viperize or not to Viperize.
363 If t, viperize emacs. If nil -- don't. If `ask', ask the user.
364 This variable is used primatily when Viper is being loaded.
366 Must be set in `~/.emacs' before Viper is loaded.
367 DO NOT set this variable interactively, unless you are using the customization
369 :type
'(choice (const nil
) (const t
) (const ask
))
370 :tag
"Set Viper Mode on Loading"
373 (defcustom viper-vi-state-mode-list
385 html-mode html-helper-mode
386 emacs-lisp-mode lisp-mode lisp-interaction-mode
389 cc-mode c-mode c
++-mode objc-mode
390 fortran-mode f90-mode
398 text-mode indented-text-mode
399 tex-mode latex-mode bibtex-mode
409 sh-mode ksh-mode csh-mode
414 "Major modes that require Vi command state."
415 :type
'(repeat symbol
)
418 (defcustom viper-emacs-state-mode-list
436 "*A list of major modes that should come up in Emacs state.
437 Normally, Viper would bring buffers up in Emacs state, unless the corresponding
438 major mode has been placed on `viper-vi-state-mode-list' or
439 `viper-insert-state-mode-list'. So, don't place a new mode on this list,
440 unless it is coming up in a wrong Viper state."
441 :type
'(repeat symbol
)
444 (defcustom viper-insert-state-mode-list
445 '(internal-ange-ftp-mode comint-mode shell-mode
)
446 "*A list of major modes that should come up in Vi Insert state."
447 :type
'(repeat symbol
)
451 ;; used to set viper-major-mode-modifier-list in defcustom
452 (defun viper-apply-major-mode-modifiers (&optional symbol value
)
455 (mapcar (lambda (triple)
456 (viper-modify-major-mode
457 (nth 0 triple
) (nth 1 triple
) (eval (nth 2 triple
))))
458 viper-major-mode-modifier-list
))
460 (defcustom viper-major-mode-modifier-list
461 '((help-mode emacs-state viper-slash-and-colon-map
)
462 (comint-mode insert-state viper-comint-mode-modifier-map
)
463 (comint-mode vi-state viper-comint-mode-modifier-map
)
464 (shell-mode insert-state viper-comint-mode-modifier-map
)
465 (shell-mode vi-state viper-comint-mode-modifier-map
)
466 (ange-ftp-shell-mode insert-state viper-comint-mode-modifier-map
)
467 (ange-ftp-shell-mode vi-state viper-comint-mode-modifier-map
)
468 (internal-ange-ftp-mode insert-state viper-comint-mode-modifier-map
)
469 (internal-ange-ftp-mode vi-state viper-comint-mode-modifier-map
)
470 (dired-mode emacs-state viper-dired-modifier-map
)
471 (tar-mode emacs-state viper-slash-and-colon-map
)
472 (mh-folder-mode emacs-state viper-slash-and-colon-map
)
473 (gnus-group-mode emacs-state viper-slash-and-colon-map
)
474 (gnus-summary-mode emacs-state viper-slash-and-colon-map
)
475 (Info-mode emacs-state viper-slash-and-colon-map
)
476 (Buffer-menu-mode emacs-state viper-slash-and-colon-map
)
478 "List specifying how to modify the various major modes to enable some Viperisms.
479 The list has the structure: ((mode viper-state keymap) (mode viper-state
480 keymap) ...). If `mode' is on the list, the `kemap' will be made active (on
481 the minor-mode-map-alist) in the specified viper state.
482 If you change this list, have to restart emacs for the change to take effect.
483 However, if you did the change through the customization widget, then emacs
484 needs to be restarted only if you deleted a triple mode-state-keymap from the
485 list. No need to restart emacs in case of insertion or modification of an
489 (choice (const emacs-state
)
491 (const insert-state
))
493 :set
'viper-apply-major-mode-modifiers
501 (defun toggle-viper-mode ()
502 "Toggle Viper on/off.
503 If Viper is enabled, turn it off. Otherwise, turn it on."
505 (if (eq viper-mode t
)
507 (setq viper-mode nil
)
512 "Turn on Viper emulation of Vi."
514 (if (not noninteractive
)
516 ;; if the user requested viper-mode explicitly
520 (load-library "viper"))
522 (if viper-first-time
; Important check. Prevents mix-up of startup
523 (progn ; and expert-level msgs when viper-mode recurses
524 (setq viper-first-time nil
)
525 (setq viper-vi-state-cursor-color
526 (viper-get-cursor-color))
527 (if (not viper-inhibit-startup-message
)
528 (save-window-excursion
529 (setq viper-inhibit-startup-message t
)
530 (delete-other-windows)
531 (switch-to-buffer "Viper Startup Message")
534 (substitute-command-keys
535 "Viper Is a Package for Emacs Rebels,
536 a VI Plan for Emacs Rescue, and a venomous VI PERil.
538 Incidentally, Viper emulates Vi under GNU Emacs 20 and XEmacs 20.
539 It supports all of what is good in Vi and Ex, while extending
540 and improving upon much of it.
542 1. Viper supports Vi at several levels. Level 1 is the closest to Vi,
543 level 5 provides the most flexibility to depart from many Vi conventions.
545 You will be asked to specify your user level in a following screen.
547 If you select user level 1 then the keys ^X, ^C, ^Z, and ^G will behave
548 as in VI, to smooth transition to Viper for the beginners. However, to
549 use Emacs productively, you are advised to reach user level 3 or higher.
551 At user level 2 or higher, ^X and ^C have Emacs, not Vi, bindings;
552 ^Z toggles Vi/Emacs states; ^G is Emacs' keyboard-quit (like ^C in Vi).
554 2. Vi exit functions (e.g., :wq, ZZ) work on INDIVIDUAL files -- they
555 do not cause Emacs to quit, except at user level 1 (for a novice).
557 4. Viper supports multiple undo: `u' will undo. Typing `.' will repeat
558 undo. Another `u' changes direction.
560 6. Emacs Meta key is `C-\\' (in all modes) or `\\ ESC' (in Vi command mode).
561 On a window system, the best way is to use the Meta-key on your keyboard.
562 7. Try \\[keyboard-quit] and \\[abort-recursive-edit] repeatedly,if
563 something funny happens. This would abort the current editing command.
565 For more information on Viper:
567 a. Type `:help' in Vi command mode
568 b. Print Viper manual, found in ./etc/viper.dvi
569 c. Print the Quick Reference, found in ./etc/viperCard.dvi
571 To submit a bug report or to contact the author, type :submitReport in Vi
572 command mode. To shoo Viper away and return to pure Emacs (horror!), type:
576 This startup message appears whenever you load Viper, unless you type `y' now."
578 (goto-char (point-min))
579 (if (y-or-n-p "Inhibit Viper startup message? ")
581 'viper-inhibit-startup-message
582 "Viper startup message inhibited"
583 viper-custom-file-name t
))
584 ;;(kill-buffer (current-buffer))
586 "The last message is in buffer `Viper Startup Message'")
589 (viper-set-expert-level 'dont-change-unless
)))
591 (or (memq major-mode viper-emacs-state-mode-list
) ; don't switch to Vi
592 (memq major-mode viper-insert-state-mode-list
) ; don't switch
593 (viper-change-state-to-vi)))))
596 ;; This hook designed to enable Vi-style editing in comint-based modes."
597 (defun viper-comint-mode-hook ()
598 (setq require-final-newline nil
599 viper-ex-style-editing nil
600 viper-ex-style-motion nil
)
601 (viper-change-state-to-insert))
604 ;; remove viper hooks from SYMBOL
605 (defun viper-remove-hooks (symbol)
606 (cond ((not (boundp symbol
)) nil
)
607 ((not (listp (eval symbol
))) nil
)
608 ((string-match "-hook" (symbol-name symbol
))
609 (remove-hook symbol
'viper-mode
)
610 (remove-hook symbol
'viper-change-state-to-emacs
)
611 (remove-hook symbol
'viper-change-state-to-insert
)
612 (remove-hook symbol
'viper-change-state-to-vi
)
615 ;; Remove local value in all existing buffers
616 ;; This doesn't delocalize vars (which would have been desirable)
617 (defun viper-delocalize-var (symbol)
618 (mapcar (lambda (buf) (save-excursion
620 (kill-local-variable symbol
)))
624 (defun viper-go-away ()
626 This function tries to do as good a job as possible. However, it may undo some
627 user customization, unrelated to Viper. For instance, if the user advised
628 `read-file-name', `describe-key', and some others, then this advice will be
630 It also doesn't undo some Viper settings. For instance, `minor-mode-map-alist'
631 remains buffer-local."
634 ;; restore non-viper vars
636 next-line-add-newlines
637 (viper-standard-value
638 'next-line-add-newlines viper-saved-non-viper-variables
)
639 require-final-newline
640 (viper-standard-value
641 'require-final-newline viper-saved-non-viper-variables
)
643 (viper-standard-value 'scroll-step viper-saved-non-viper-variables
)
644 mode-line-buffer-identification
645 (viper-standard-value
646 'mode-line-buffer-identification viper-saved-non-viper-variables
)
648 (delq 'viper-mode-string global-mode-string
))
652 mark-even-if-inactive
653 (viper-standard-value
654 'mark-even-if-inactive viper-saved-non-viper-variables
)))
656 ;; Ideally, we would like to be able to de-localize local variables
657 (viper-delocalize-var 'minor-mode-map-alist
)
658 (viper-delocalize-var 'require-final-newline
)
661 ;; deactivate all advices done by Viper.
662 (ad-deactivate-regexp "viper-")
664 (setq viper-mode nil
)
666 (viper-delocalize-var 'viper-vi-minibuffer-minor-mode
)
667 (viper-delocalize-var 'viper-insert-minibuffer-minor-mode
)
668 (viper-delocalize-var 'viper-vi-intercept-minor-mode
)
669 (viper-delocalize-var 'viper-insert-intercept-minor-mode
)
671 (viper-delocalize-var 'viper-vi-local-user-minor-mode
)
672 (viper-delocalize-var 'viper-vi-kbd-minor-mode
)
673 (viper-delocalize-var 'viper-vi-global-user-minor-mode
)
674 (viper-delocalize-var 'viper-vi-state-modifier-minor-mode
)
675 (viper-delocalize-var 'viper-vi-diehard-minor-mode
)
676 (viper-delocalize-var 'viper-vi-basic-minor-mode
)
678 (viper-delocalize-var 'viper-replace-minor-mode
)
680 (viper-delocalize-var 'viper-insert-local-user-minor-mode
)
681 (viper-delocalize-var 'viper-insert-kbd-minor-mode
)
682 (viper-delocalize-var 'viper-insert-global-user-minor-mode
)
683 (viper-delocalize-var 'viper-insert-state-modifier-minor-mode
)
684 (viper-delocalize-var 'viper-insert-diehard-minor-mode
)
685 (viper-delocalize-var 'viper-insert-basic-minor-mode
)
687 (viper-delocalize-var 'viper-emacs-intercept-minor-mode
)
688 (viper-delocalize-var 'viper-emacs-local-user-minor-mode
)
689 (viper-delocalize-var 'viper-emacs-kbd-minor-mode
)
690 (viper-delocalize-var 'viper-emacs-global-user-minor-mode
)
691 (viper-delocalize-var 'viper-emacs-state-modifier-minor-mode
)
693 (viper-delocalize-var 'viper-current-state
)
694 (viper-delocalize-var 'viper-mode-string
)
696 (setq-default viper-vi-minibuffer-minor-mode nil
697 viper-insert-minibuffer-minor-mode nil
698 viper-vi-intercept-minor-mode nil
699 viper-insert-intercept-minor-mode nil
701 viper-vi-local-user-minor-mode nil
702 viper-vi-kbd-minor-mode nil
703 viper-vi-global-user-minor-mode nil
704 viper-vi-state-modifier-minor-mode nil
705 viper-vi-diehard-minor-mode nil
706 viper-vi-basic-minor-mode nil
708 viper-replace-minor-mode nil
710 viper-insert-local-user-minor-mode nil
711 viper-insert-kbd-minor-mode nil
712 viper-insert-global-user-minor-mode nil
713 viper-insert-state-modifier-minor-mode nil
714 viper-insert-diehard-minor-mode nil
715 viper-insert-basic-minor-mode nil
717 viper-emacs-intercept-minor-mode nil
718 viper-emacs-local-user-minor-mode nil
719 viper-emacs-kbd-minor-mode nil
720 viper-emacs-global-user-minor-mode nil
721 viper-emacs-state-modifier-minor-mode nil
723 viper-current-state
'emacs-state
724 viper-mode-string viper-emacs-state-id
727 ;; remove all hooks set by viper
728 (mapatoms 'viper-remove-hooks
)
729 (remove-hook 'comint-mode-hook
'viper-comint-mode-hook
)
730 (remove-hook 'minibuffer-setup-hook
'viper-minibuffer-setup-sentinel
)
731 (remove-hook 'change-major-mode-hook
'viper-major-mode-change-sentinel
)
733 ;; unbind Viper mouse bindings
734 (viper-unbind-mouse-search-key)
735 (viper-unbind-mouse-insert-key)
736 ;; In emacs, we have to advice handle-switch-frame
737 ;; This advice is undone earlier, when all advices matchine "viper-" are
740 (remove-hook 'mouse-leave-frame-hook
'viper-remember-current-frame
))
741 ) ; end viper-go-away
744 ;; list of buffers that just changed their major mode
745 ;; used in a hack that triggers vi command mode whenever needed
746 (defvar viper-new-major-mode-buffer-list nil
)
748 ;; set appropriate Viper state in buffers that changed major mode
749 (defun set-viper-state-in-major-mode ()
752 (if (viper-buffer-live-p buf
)
753 (with-current-buffer buf
754 (cond ((and (memq major-mode viper-vi-state-mode-list
)
755 (eq viper-current-state
'emacs-state
))
757 ((memq major-mode viper-emacs-state-mode-list
)
758 ;; not checking (eq viper-current-state 'emacs-state)
759 ;; because viper-current-state could have gotten it by
760 ;; default. We need viper-change-state-to-emacs here to have
761 ;; the keymaps take effect.
762 (viper-change-state-to-emacs))
763 ((and (memq major-mode viper-insert-state-mode-list
)
764 (not (eq viper-current-state
'insert-state
)))
765 (viper-change-state-to-insert))
766 )) ; with-current-buffer
768 viper-new-major-mode-buffer-list
)
769 ;; clear the list of bufs that changed major mode
770 (setq viper-new-major-mode-buffer-list nil
)
771 ;; change the global value of hook
772 (remove-hook 'viper-post-command-hooks
'set-viper-state-in-major-mode
))
774 ;; sets up post-command-hook to turn viper-mode, if the current mode is
776 (defun viper-major-mode-change-sentinel ()
778 (or (string-match "\*Minibuf-" (buffer-name))
779 (setq viper-new-major-mode-buffer-list
780 (cons (current-buffer) viper-new-major-mode-buffer-list
))))
781 ;; change the global value of hook
782 (add-hook 'viper-post-command-hooks
'set-viper-state-in-major-mode t
))
786 ;; This sets major mode hooks to make them come up in vi-state.
787 (defun viper-set-hooks ()
788 ;; It is of course a misnomer to call viper-mode a `major mode'.
789 ;; However, this has the effect that if the user didn't specify the
790 ;; default mode, new buffers that fall back on the default will come up
791 ;; in Fundamental Mode and Vi state.
792 (if (eq default-major-mode
'fundamental-mode
)
793 (setq default-major-mode
'viper-mode
))
795 (add-hook 'change-major-mode-hook
'viper-major-mode-change-sentinel
)
796 (add-hook 'find-file-hooks
'set-viper-state-in-major-mode
)
798 ;; keep this because many modes we don't know about use this hook
799 (defvar text-mode-hook
)
800 (add-hook 'text-mode-hook
'viper-mode
)
802 (defvar emerge-startup-hook
)
803 (add-hook 'emerge-startup-hook
'viper-change-state-to-emacs
)
805 ;; Tell vc-diff to put *vc* in Vi mode
807 (defadvice vc-diff
(after viper-vc-ad activate
)
808 "Force Vi state in VC diff buffer."
809 (viper-change-state-to-vi))
812 '(defadvice vc-diff
(after viper-vc-ad activate
)
813 "Force Vi state in VC diff buffer."
814 (viper-change-state-to-vi))))
818 '(defadvice emerge-quit
(after viper-emerge-advice activate
)
819 "Run `viper-change-state-to-vi' after quitting emerge."
820 (viper-change-state-to-vi)))
821 ;; In case Emerge was loaded before Viper.
822 (defadvice emerge-quit
(after viper-emerge-advice activate
)
823 "Run `viper-change-state-to-vi' after quitting emerge."
824 (viper-change-state-to-vi))
826 ;; passwd.el sets up its own buffer, which turns up in Vi mode,
827 ;; thus overriding the local map. We don't need Vi mode here.
830 '(defadvice read-passwd-1
(before viper-passwd-ad activate
)
831 "Switch to emacs state while reading password."
832 (viper-change-state-to-emacs)))
834 ;; Emacs shell, ange-ftp, and comint-based modes
835 (add-hook 'comint-mode-hook
'viper-comint-mode-hook
) ; comint
837 (viper-set-emacs-state-searchstyle-macros nil
'dired-mode
) ; dired
838 (viper-set-emacs-state-searchstyle-macros nil
'tar-mode
) ; tar
839 (viper-set-emacs-state-searchstyle-macros nil
'mh-folder-mode
) ; mhe
840 (viper-set-emacs-state-searchstyle-macros nil
'gnus-group-mode
) ; gnus
841 (viper-set-emacs-state-searchstyle-macros nil
'gnus-summary-mode
)
842 (viper-set-emacs-state-searchstyle-macros nil
'Info-mode
) ; info
843 (viper-set-emacs-state-searchstyle-macros nil
'Buffer-menu-mode
) ;buffer-menu
845 ;; Modify major modes according to viper-major-mode-modifier-list
846 (viper-apply-major-mode-modifiers)
849 ;; Put buf in Emacs state after edit.
852 '(defadvice rmail-cease-edit
(after viper-rmail-advice activate
)
853 "Switch to emacs state when done editing message."
854 (viper-change-state-to-emacs)))
855 ;; In case RMAIL was loaded before Viper.
856 (defadvice rmail-cease-edit
(after viper-rmail-advice activate
)
857 "Switch to emacs state when done editing message."
858 (viper-change-state-to-emacs))
861 ;; Need to do it after loading iso-acc, or else this loading will wipe out
865 (defadvice iso-accents-mode
(around viper-iso-accents-advice activate
)
866 "Set viper-automatic-iso-accents to iso-accents-mode."
867 (let ((arg (ad-get-arg 0)))
869 (setq viper-automatic-iso-accents
870 (if (eq viper-current-state
'vi-state
)
872 ;; if iso-accents-mode was called with positive arg, turn
874 (> (prefix-numeric-value arg
) 0)
875 ;; else: toggle viper-automatic-iso-accents
876 (not viper-automatic-iso-accents
))
877 ;; other states: accept what iso-accents-mode has done
879 ;; turn off ISO accents in vi-state
880 (if (eq viper-current-state
'vi-state
)
881 (viper-set-iso-accents-mode nil
))
882 (if (memq viper-current-state
'(vi-state insert-state replace-state
))
883 (message "Viper ISO accents mode: %s"
884 (if viper-automatic-iso-accents
"on" "off")))
887 ;; International input methods
889 (eval-after-load "mule-cmds"
891 (defadvice inactivate-input-method
(after viper-mule-advice activate
)
892 "Set viper-special-input-method to disable intl. input methods."
893 (viper-inactivate-input-method-action))
894 (defadvice activate-input-method
(after viper-mule-advice activate
)
895 "Set viper-special-input-method to enable intl. input methods."
896 (viper-activate-input-method-action))
898 ;; XEmacs Although these hooks exist in Emacs, they don't seem to be always
899 ;; called on input-method activation/deactivation, so we the above advise
900 ;; functions instead.
901 (eval-after-load "mule-cmds"
903 (add-hook 'input-method-activate-hook
904 'viper-activate-input-method-action t
)
905 (add-hook 'input-method-inactivate-hook
906 'viper-inactivate-input-method-action t
)))
908 (eval-after-load "mule-cmds"
909 (defadvice toggle-input-method
(around viper-mule-advice activate
)
910 "Adjust input-method toggling in vi-state."
911 (if (and viper-special-input-method
(eq viper-current-state
'vi-state
))
912 (viper-inactivate-input-method)
918 ;; these are primarily advices and Vi-ish variable settings
919 (defun viper-non-hook-settings ()
921 ;; This var is not local in Emacs, so we make it local. It must be local
922 ;; because although the stack of minor modes can be the same for all buffers,
923 ;; the associated *keymaps* can be different. In Viper,
924 ;; viper-vi-local-user-map, viper-insert-local-user-map, and others can have
925 ;; different keymaps for different buffers. Also, the keymaps associated
926 ;; with viper-vi/insert-state-modifier-minor-mode can be different.
927 (make-variable-buffer-local 'minor-mode-map-alist
)
929 ;; Viper changes the default mode-line-buffer-identification
930 (setq-default mode-line-buffer-identification
'(" %b"))
932 ;; setup emacs-supported vi-style feel
933 (setq next-line-add-newlines nil
934 require-final-newline t
)
936 (make-variable-buffer-local 'require-final-newline
)
938 ;; don't bark when mark is inactive
940 (setq mark-even-if-inactive t
))
944 ;; Variable displaying the current Viper state in the mode line.
945 (viper-deflocalvar viper-mode-string viper-emacs-state-id
)
946 (or (memq 'viper-mode-string global-mode-string
)
947 (setq global-mode-string
948 (append '("" viper-mode-string
) (cdr global-mode-string
))))
950 (defadvice read-key-sequence
(around viper-read-keyseq-ad activate
)
951 "Harness to work for Viper. This advice is harmless---don't worry!"
952 (let (inhibit-quit event keyseq
)
953 (setq keyseq ad-do-it
)
954 (setq event
(if viper-xemacs-p
955 (elt keyseq
0) ; XEmacs returns vector of events
956 (elt (listify-key-sequence keyseq
) 0)))
957 (if (viper-ESC-event-p event
)
958 (let (unread-command-events)
959 (viper-set-unread-command-events keyseq
)
960 (if (viper-fast-keysequence-p)
961 (let ((viper-vi-global-user-minor-mode nil
)
962 (viper-vi-local-user-minor-mode nil
)
963 (viper-replace-minor-mode nil
) ; actually unnecessary
964 (viper-insert-global-user-minor-mode nil
)
965 (viper-insert-local-user-minor-mode nil
))
966 (setq keyseq ad-do-it
))
967 (setq keyseq ad-do-it
))))
970 (defadvice describe-key
(before viper-read-keyseq-ad protect activate
)
971 "Force to read key via `read-key-sequence'."
972 (interactive (list (viper-events-to-keys
973 (read-key-sequence "Describe key: ")))))
975 (defadvice describe-key-briefly
976 (before viper-read-keyseq-ad protect activate
)
977 "Force to read key via `read-key-sequence'."
978 (interactive (list (viper-events-to-keys
979 (read-key-sequence "Describe key briefly: ")))))
982 (defadvice find-file
(before viper-add-suffix-advice activate
)
983 "Use `read-file-name' for reading arguments."
984 (interactive (cons (read-file-name "Find file: " nil default-directory
)
985 ;; if Mule and prefix argument, ask for coding system
986 (cond ((and viper-emacs-p
987 (boundp 'MULE
)) ; Emacs 20 with MULE
990 (featurep 'mule
)) ; XEmacs 20 with MULE
992 (and current-prefix-arg
994 "Coding-system: "))))
998 (defadvice find-file-other-window
(before viper-add-suffix-advice activate
)
999 "Use `read-file-name' for reading arguments."
1000 (interactive (cons (read-file-name "Find file in other window: "
1001 nil default-directory
)
1002 ;; if Mule and prefix argument, ask for coding system
1003 (cond ((and viper-emacs-p
1004 (boundp 'MULE
)) ; Emacs 20 with MULE
1006 ((and viper-xemacs-p
1007 (featurep 'mule
)) ; XEmacs 20 with MULE
1009 (and current-prefix-arg
1011 "Coding-system: "))))
1016 (defadvice find-file-other-frame
(before viper-add-suffix-advice activate
)
1017 "Use `read-file-name' for reading arguments."
1018 (interactive (cons (read-file-name "Find file in other frame: "
1019 nil default-directory
)
1020 ;; if Mule and prefix argument, ask for coding system
1021 (cond ((and viper-emacs-p
1022 (boundp 'MULE
)) ; Emacs 20 with MULE
1024 ((and viper-xemacs-p
1025 (featurep 'mule
)) ; XEmacs 20 with MULE
1027 (and current-prefix-arg
1029 "Coding-system: "))))
1034 (defadvice read-file-name
(around viper-suffix-advice activate
)
1035 "Tell `exit-minibuffer' to run `viper-file-add-suffix' as a hook."
1036 (let ((viper-minibuffer-exit-hook
1037 (append viper-minibuffer-exit-hook
1038 '(viper-minibuffer-trim-tail viper-file-add-suffix
))))
1041 (defadvice start-kbd-macro
(after viper-kbd-advice activate
)
1042 "Remove Viper's intercepting bindings for C-x ).
1043 This may be needed if the previous `:map' command terminated abnormally."
1044 (define-key viper-vi-intercept-map
"\C-x)" nil
)
1045 (define-key viper-insert-intercept-map
"\C-x)" nil
)
1046 (define-key viper-emacs-intercept-map
"\C-x)" nil
))
1048 ;; catch frame switching event
1049 (if (viper-window-display-p)
1051 (add-hook 'mouse-leave-frame-hook
1052 'viper-remember-current-frame
)
1053 (defadvice handle-switch-frame
(before viper-frame-advice activate
)
1054 "Remember the selected frame before the switch-frame event."
1055 (viper-remember-current-frame (selected-frame)))) )
1057 ) ; end viper-non-hook-settings
1060 ;; Ask only if this-command/last-command are nil, i.e., when loading
1061 (cond ((and (eq viper-mode
'ask
) (null this-command
) (null last-command
))
1062 (save-window-excursion
1063 (with-output-to-temp-buffer " *viper-info*"
1065 You have loaded Viper, and are about to Viperize your emacs!
1067 Viper is a Package for Emacs Rebels and a venomous VI PERil,
1069 It's time to decide: to Viperize or not to Viperize...
1071 If you wish to Viperize AND make this your way of life, please put
1076 in your .emacs file (preferably, close to the top).
1077 These two lines must come in the order given.
1080 **** The startup file name has been changed from .vip to .viper
1081 **** All vip-* style names have been converted to viper-* style."))
1082 (if (y-or-n-p "Viperize? ")
1084 (setq viper-mode nil
))
1086 (kill-buffer " *viper-info*")))
1088 ;; If viper-mode is t, then just continue. Viper will kick in.
1090 ;; Otherwise, it was asking Viper was not loaded through .emacs
1091 ;; In this case, it was either through M-x viper-mode or via something
1092 ;; else, like the custom widget. If Viper was loaded through
1093 ;; M-x viper-mode, then viper will kick in anyway.
1094 (t (setq viper-mode nil
)))
1096 (defun viper-load-custom-file ()
1097 (if (and (file-exists-p viper-custom-file-name
)
1098 (not noninteractive
))
1099 (load viper-custom-file-name
)))
1104 ;; Get viper standard value of SYMBOL. If symbol is customized, get its
1105 ;; standard value. Otherwise, get the value saved in the alist STORAGE. If
1106 ;; STORAGE is nil, use viper-saved-user-settings.
1107 (defun viper-standard-value (symbol &optional storage
)
1108 (or (eval (car (get symbol
'customized-value
)))
1109 (eval (car (get symbol
'saved-value
)))
1110 (nth 1 (assoc symbol
(or storage viper-saved-user-settings
)))))
1114 ;; save non-viper vars that Viper might change
1115 (if (null viper-saved-non-viper-variables
)
1116 (setq viper-saved-non-viper-variables
1118 (cons 'next-line-add-newlines
(list next-line-add-newlines
))
1119 (cons 'require-final-newline
(list require-final-newline
))
1120 (cons 'scroll-step
(list scroll-step
))
1121 (cons 'mode-line-buffer-identification
1122 (list (default-value 'mode-line-buffer-identification
)))
1123 (cons 'global-mode-string
(list global-mode-string
))
1125 (cons 'mark-even-if-inactive
(list mark-even-if-inactive
)))
1129 ;; Set some useful macros, advices
1130 ;; These must be BEFORE ~/.viper is loaded,
1131 ;; so the user can unrecord them in ~/.viper.
1134 ;; set advices and some variables that give emacs Vi look.
1135 (viper-non-hook-settings)
1137 ;; repeat the 2nd previous command without rotating the command history
1138 (viper-record-kbd-macro
1139 (vector viper-repeat-from-history-key
'\
1) 'vi-state
1140 [(meta x
) v i p e r - r e p e a t - f r o m - h i s t o r y return
] 't
)
1141 ;; repeat the 3d previous command without rotating the command history
1142 (viper-record-kbd-macro
1143 (vector viper-repeat-from-history-key
'\
2) 'vi-state
1144 [(meta x
) v i p e r - r e p e a t - f r o m - h i s t o r y return
] 't
)
1146 ;; set macros for toggling case sensitivity and regexp search
1147 (viper-set-searchstyle-toggling-macros nil
)
1148 ;; Make %%% toggle parsing comments for matching parentheses
1149 (viper-set-parsing-style-toggling-macro nil
)
1151 ;; ~/.viper is loaded if exists
1152 (viper-load-custom-file)
1154 ;; should be after loading custom file to avoid the pesky msg that
1155 ;; mouse-search/insert keys are already bound
1156 (viper-bind-mouse-search-key)
1157 (viper-bind-mouse-insert-key)
1162 ;; Applying Viper customization -- runs after (load .viper)
1164 ;; Save user settings or Viper defaults for vars controled by
1165 ;; viper-expert-level
1166 (if (null viper-saved-user-settings
)
1167 (setq viper-saved-user-settings
1168 (list (cons 'viper-want-ctl-h-help
(list viper-want-ctl-h-help
))
1169 (cons 'viper-always
(list viper-always
))
1170 (cons 'viper-no-multiple-ESC
(list viper-no-multiple-ESC
))
1171 (cons 'viper-ex-style-motion
(list viper-ex-style-motion
))
1172 (cons 'viper-ex-style-editing
1173 (list viper-ex-style-editing
))
1174 (cons 'viper-want-emacs-keys-in-vi
1175 (list viper-want-emacs-keys-in-vi
))
1176 (cons 'viper-electric-mode
(list viper-electric-mode
))
1177 (cons 'viper-want-emacs-keys-in-insert
1178 (list viper-want-emacs-keys-in-insert
))
1179 (cons 'viper-re-search
(list viper-re-search
)))))
1184 (viper-set-minibuffer-style)
1185 (if viper-buffer-search-char
1186 (viper-buffer-search-enable))
1187 (viper-update-syntax-classes 'set-default
)
1191 ;;; Familiarize Viper with some minor modes that have their own keymaps
1194 (viper-harness-minor-mode "compile")
1195 (viper-harness-minor-mode "outline")
1196 (viper-harness-minor-mode "allout")
1197 (viper-harness-minor-mode "xref")
1198 (viper-harness-minor-mode "lmenu")
1199 (viper-harness-minor-mode "vc")
1200 (viper-harness-minor-mode "ltx-math") ; LaTeX-math-mode in AUC-TeX, which
1201 (viper-harness-minor-mode "latex") ; sits in one of these two files
1202 (viper-harness-minor-mode "cyrillic")
1203 (viper-harness-minor-mode "russian")
1204 (viper-harness-minor-mode "view-less")
1205 (viper-harness-minor-mode "view")
1206 (viper-harness-minor-mode "reftex")
1207 (viper-harness-minor-mode "flyspell")
1211 ;; Intercept maps could go in viper-keym.el
1212 ;; We keep them here in case someone redefines them in ~/.viper
1214 (define-key viper-vi-intercept-map viper-ESC-key
'viper-intercept-ESC-key
)
1215 (define-key viper-insert-intercept-map viper-ESC-key
'viper-intercept-ESC-key
)
1217 ;; This is taken care of by viper-insert-global-user-map.
1218 ;;(define-key viper-replace-map viper-ESC-key 'viper-intercept-ESC-key)
1221 ;; The default viper-toggle-key is \C-z; for the novice, it suspends or
1223 (define-key viper-vi-intercept-map viper-toggle-key
'viper-toggle-key-action
)
1225 viper-emacs-intercept-map viper-toggle-key
'viper-change-state-to-vi
)
1227 ;;; Escape from Emacs and Insert modes to Vi for one command
1229 viper-emacs-intercept-map
"\C-c\\" 'viper-escape-to-vi
)
1231 viper-insert-intercept-map
"\C-c\\" 'viper-escape-to-vi
)
1234 (setq-default viper-emacs-intercept-minor-mode t
1235 viper-emacs-local-user-minor-mode t
1236 viper-emacs-global-user-minor-mode t
1237 viper-emacs-kbd-minor-mode t
1238 viper-emacs-state-modifier-minor-mode t
))
1239 (if (and viper-mode
(eq viper-current-state
'emacs-state
))
1240 (setq viper-emacs-intercept-minor-mode t
1241 viper-emacs-local-user-minor-mode t
1242 viper-emacs-global-user-minor-mode t
1243 viper-emacs-kbd-minor-mode t
1244 viper-emacs-state-modifier-minor-mode t
))
1249 (and (< viper-expert-level
5) (> viper-expert-level
0))))
1252 ;; Let all minor modes take effect after loading
1253 ;; this may not be enough, so we also set default minor-mode-alist.
1254 ;; Without setting the default, new buffers that come up in emacs mode have
1255 ;; minor-mode-map-alist = nil, unless we call viper-change-state-*
1256 (if (and viper-mode
(eq viper-current-state
'emacs-state
))
1258 (viper-change-state-to-emacs)
1259 (setq-default minor-mode-map-alist minor-mode-map-alist
)
1262 (if (and viper-mode
(memq major-mode viper-vi-state-mode-list
))
1266 (run-hooks 'viper-load-hook
) ; the last chance to change something
1271 ;;; Local Variables:
1272 ;;; eval: (put 'viper-deflocalvar 'lisp-indent-hook 'defun)
1275 ;;; viper.el ends here