Revert part of the previous change
[emacs.git] / lisp / emulation / viper.el
blob8604020b987ad9ba7b5e5481458f00f1568a7692
1 ;;; viper.el --- A full-featured Vi emulator for Emacs and XEmacs, -*-lexical-binding:t -*-
2 ;; a VI Plan for Emacs Rescue,
3 ;; and a venomous VI PERil.
4 ;; Viper Is also a Package for Emacs Rebels.
6 ;; Copyright (C) 1994-2018 Free Software Foundation, Inc.
8 ;; Author: Michael Kifer <kifer@cs.stonybrook.edu>
9 ;; Keywords: emulations
10 ;; Version: 3.14.1
12 ;; Yoni Rabkin <yoni@rabkins.net> contacted the maintainer of this
13 ;; file on 20/3/2008, and the maintainer agreed that when a bug is
14 ;; filed in the Emacs bug reporting system against this file, a copy
15 ;; of the bug report be sent to the maintainer's email address.
17 (defconst viper-version "3.14.2 of July 4, 2013"
18 "The current version of Viper")
20 ;; This file is part of GNU Emacs.
22 ;; GNU Emacs is free software: you can redistribute it and/or modify
23 ;; it under the terms of the GNU General Public License as published by
24 ;; the Free Software Foundation, either version 3 of the License, or
25 ;; (at your option) any later version.
27 ;; GNU Emacs is distributed in the hope that it will be useful,
28 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
29 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 ;; GNU General Public License for more details.
32 ;; You should have received a copy of the GNU General Public License
33 ;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
35 ;;; Commentary:
37 ;; Viper is a full-featured Vi emulator for Emacs and XEmacs. It emulates and
38 ;; improves upon the standard features of Vi and, at the same time, allows
39 ;; full access to all Emacs facilities. Viper supports multiple undo,
40 ;; file name completion, command, file, and search history and it extends
41 ;; Vi in many other ways. Viper is highly customizable through the various
42 ;; hooks, user variables, and keymaps. It is implemented as a collection
43 ;; of minor modes and it is designed to provide full access to all Emacs
44 ;; major and minor modes.
46 ;;; History:
48 ;; Viper is a new name for a package formerly known as VIP-19,
49 ;; which was a successor of VIP version 3.5 by Masahiko Sato
50 ;; <ms@sail.stanford.edu> and VIP version 4.2 by Aamod Sane
51 ;; <sane@cs.uiuc.edu>. Some ideas from vip 4.4.2 by Aamod Sane
52 ;; were also shamelessly plagiarized.
54 ;; Viper maintains some degree of compatibility with these older
55 ;; packages. See the documentation for customization.
57 ;; The main difference between Viper and these older packages are:
59 ;; 1. Viper emulates Vi at several levels, from almost complete conformity
60 ;; to a rather loose Vi-compliance.
62 ;; 2. Viper provides full access to all major and minor modes of Emacs
63 ;; without the need to type extra keys.
64 ;; The older versions of VIP (and other Vi emulators) do not work with
65 ;; some major and minor modes.
67 ;; 3. Viper supports vi-style undo.
69 ;; 4. Viper fully emulates (and improves upon) vi's replacement mode.
71 ;; 5. Viper has a better interface to ex, including command, variable, and
72 ;; file name completion.
74 ;; 6. Viper uses native Emacs history and completion features; it doesn't
75 ;; rely on other packages (such as gmhist.el and completer.el) to provide
76 ;; these features.
78 ;; 7. Viper supports Vi-style editing in the minibuffer, by allowing the
79 ;; user to switch from Insert state to Vi state to Replace state, etc.
81 ;; 8. Viper keeps history of recently inserted pieces of text and recently
82 ;; executed Vi-style destructive commands, such as `i', `d', etc.
83 ;; These pieces of text can be inserted in later insertion commands;
84 ;; the previous destructive commands can be re-executed.
86 ;; 9. Viper has Vi-style keyboard macros, which enhances the similar
87 ;; facility in the original Vi.
88 ;; First, one can execute any Emacs command while defining a
89 ;; macro, not just the Vi commands. Second, macros are defined in a
90 ;; WYSYWYG mode, using an interface to Emacs's WYSIWYG style of defining
91 ;; macros. Third, in Viper, one can define macros that are specific to
92 ;; a given buffer, a given major mode, or macros defined for all buffers.
93 ;; The same macro name can have several different definitions:
94 ;; one global, several definitions for various major modes, and
95 ;; definitions for specific buffers.
96 ;; Buffer-specific definitions override mode-specific
97 ;; definitions, which, in turn, override global definitions.
100 ;;; Installation:
101 ;; -------------
103 ;; (require 'viper)
106 ;;; Acknowledgments:
107 ;; ----------------
108 ;; Bug reports and ideas contributed by many users have helped
109 ;; improve Viper and the various versions of VIP.
110 ;; See the manual for a complete list of contributors.
113 ;;; Notes:
115 ;; 1. Major modes.
116 ;; In most cases, Viper handles major modes correctly, i.e., they come up
117 ;; in the right state (either vi-state or emacs-state). For instance, text
118 ;; files come up in vi-state, while, say, Dired appears in emacs-state by
119 ;; default.
120 ;; However, some modes do not appear in the right mode in the beginning,
121 ;; usually because they neglect to follow Emacs conventions (e.g., they don't
122 ;; use kill-all-local-variables when they start). Some major modes
123 ;; may fail to come up in emacs-state if they call hooks, such as
124 ;; text-hook, for no good reason.
126 ;; As an immediate solution, you can hit C-z to bring about the right mode.
127 ;; An interim solution is to add an appropriate hook to the mode like this:
129 ;; (add-hook 'your-favorite-mode #'viper-mode)
130 ;; or
131 ;; (add-hook 'your-favorite-mode #'viper-change-state-to-emacs)
133 ;; whichever applies. The right thing to do, however, is to complain to the
134 ;; author of the respective package. (Sometimes they also neglect to equip
135 ;; their modes with hooks, which is one more reason for complaining.)
137 ;; 2. Keymap handling
138 ;; Each Viper state (insert, vi, replace) is implemented as a collection of
139 ;; several minor modes, each with its own keymap.
141 ;; Viper's Vi state consists of seven minor modes:
143 ;; viper-vi-intercept-minor-mode
144 ;; viper-vi-local-user-minor-mode
145 ;; viper-vi-global-user-minor-mode
146 ;; viper-vi-kbd-minor-mode
147 ;; viper-vi-state-modifier-minor-mode
148 ;; viper-vi-diehard-minor-mode
149 ;; viper-vi-basic-minor-mode
151 ;; Bindings done to the keymap of the first mode overshadow those done to
152 ;; the second, which, in turn, overshadows those done to the third, etc.
154 ;; The last viper-vi-basic-minor-mode contains most of the usual Vi bindings
155 ;; in its edit mode. This mode provides access to all Emacs facilities.
156 ;; Novice users, however, may want to set their viper-expert-level to 1 in
157 ;; their viper-custom-file-name. This will enable viper-vi-diehard-minor-mode.
158 ;; This minor mode's bindings make Viper simulate the usual Vi very closely.
159 ;; For instance, C-c will not have its standard Emacs binding
160 ;; and so many of the goodies of Emacs are not available.
162 ;; A skilled user should set viper-expert-level to at least 3. This will
163 ;; enable `C-c' and many Emacs facilities will become available.
164 ;; In this case, viper-vi-diehard-minor-mode is inactive.
166 ;; Viper gurus should have at least
167 ;; (setq viper-expert-level 4)
168 ;; in their viper-custom-file-name. This will unsuppress all Emacs keys
169 ;; that are not essential for VI-style editing.
170 ;; Pick-and-choose users may want to put
171 ;; (setq viper-expert-level 5)
172 ;; in viper-custom-file-name. Viper will then leave it up to the user to
173 ;; set the variables viper-want-* See viper-set-expert-level for details.
175 ;; The very first minor mode, viper-vi-intercept-minor-mode, is of no
176 ;; concern for the user. It is needed to bind Viper's vital keys, such as
177 ;; ESC and C-z.
179 ;; The second mode, viper-vi-local-user-minor-mode, usually has an
180 ;; empty keymap. However, the user can set bindings in this keymap, which
181 ;; will overshadow the corresponding bindings in the other two minor
182 ;; modes. This is useful, for example, for setting up ZZ in gnus,
183 ;; rmail, mh-e, etc., to send message instead of saving it in a file.
184 ;; Likewise, in Dired mode, you may want to bind ZN and ZP to commands
185 ;; that would visit the next or the previous file in the Dired buffer.
186 ;; Setting local keys is tricky, so don't do it directly. Instead, use
187 ;; viper-add-local-keys function (see its doc).
189 ;; The third minor mode, viper-vi-global-user-minor-mode, is also intended
190 ;; for the users but, unlike viper-vi-local-user-minor-mode, its key
191 ;; bindings are seen in all Viper buffers. This mode keys can be done
192 ;; with define-key command.
194 ;; The fourth minor mode, viper-vi-kbd-minor-mode, is used by keyboard
195 ;; macros. Users are NOT supposed to modify this keymap directly.
197 ;; The fifth mode, viper-vi-state-modifier-minor-mode, can be used to set
198 ;; key bindings that are visible in some major modes but not in others.
200 ;; Users are allowed to modify keymaps that belong to
201 ;; viper-vi-local-user-minor-mode, viper-vi-global-user-minor-mode,
202 ;; and viper-vi-state-modifier-minor-mode only.
204 ;; Viper's Insert state also has seven minor modes:
206 ;; viper-insert-intercept-minor-mode
207 ;; viper-insert-local-user-minor-mode
208 ;; viper-insert-global-user-minor-mode
209 ;; viper-insert-kbd-minor-mode
210 ;; viper-insert-state-modifier-minor-mode
211 ;; viper-insert-diehard-minor-mode
212 ;; viper-insert-basic-minor-mode
214 ;; As with VI's editing modes, the first mode,
215 ;; viper-insert-intercept-minor-mode is used to bind vital keys that are not
216 ;; to be changed by the user.
218 ;; The next mode, viper-insert-local-user-minor-mode, is used to customize
219 ;; bindings in the insert state of Viper. The third mode,
220 ;; viper-insert-global-user-minor-mode is like
221 ;; viper-insert-local-user-minor-mode, except that its bindings are seen in
222 ;; all Viper buffers. As with viper-vi-local-user-minor-mode, its bindings
223 ;; should be done via the function viper-add-local-keys. Bindings for
224 ;; viper-insert-global-user-minor-mode can be set with the define-key command.
226 ;; The next minor mode, viper-insert-kbd-minor-mode,
227 ;; is used for keyboard VI-style macros defined with :map!.
229 ;; The fifth minor mode, viper-insert-state-modifier-minor-mode, is like
230 ;; viper-vi-state-modifier-minor-mode, except that it is used in the Insert
231 ;; state; it can be used to modify keys in a mode-specific fashion.
233 ;; The minor mode viper-insert-diehard-minor-mode is in effect when
234 ;; the user wants a high degree of Vi compatibility (a bad idea, really!).
235 ;; The last minor mode, viper-insert-basic-minor-mode, is always in effect
236 ;; when Viper is in insert state. It binds a small number of keys needed for
237 ;; Viper's operation.
239 ;; Finally, Viper provides minor modes for overriding bindings set by Emacs
240 ;; modes when Viper is in Emacs state:
242 ;; viper-emacs-local-user-minor-mode
243 ;; viper-emacs-global-user-minor-mode
244 ;; viper-emacs-kbd-minor-mode
245 ;; viper-emacs-state-modifier-minor-mode
247 ;; These minor modes are in effect when Viper is in Emacs state. The keymap
248 ;; associated with viper-emacs-global-user-minor-mode,
249 ;; viper-emacs-global-user-map, overrides the global and local keymaps as
250 ;; well as the minor mode keymaps set by other modes. The keymap of
251 ;; viper-emacs-local-user-minor-mode, viper-emacs-local-user-map, overrides
252 ;; everything, but it is used on a per buffer basis.
253 ;; The keymap associated with viper-emacs-state-modifier-minor-mode
254 ;; overrides keys on a per-major-mode basis. The mode
255 ;; viper-emacs-kbd-minor-mode is used to define Vi-style macros in Emacs
256 ;; state.
258 ;; 3. There is also one minor mode that is used when Viper is in its
259 ;; replace-state (used for commands like cw, C, etc.). This mode is
260 ;; called
262 ;; viper-replace-minor-mode
264 ;; and its keymap is viper-replace-map. Replace minor mode is always
265 ;; used in conjunction with the minor modes for insert-state, and its
266 ;; keymap overshadows the keymaps for insert minor modes.
268 ;; 4. Defining buffer-local bindings in Vi and Insert modes.
269 ;; As mentioned before, sometimes, it is convenient to have
270 ;; buffer-specific of mode-specific key bindings in Vi and insert modes.
271 ;; Viper provides a special function, viper-add-local-keys, to do precisely
272 ;; this. For instance, is you need to add couple of mode-specific bindings
273 ;; to Insert mode, you can put
275 ;; (viper-add-local-keys 'insert-state '((key1 . func1) (key2 .func2)))
277 ;; somewhere in a hook of this major mode. If you put something like this
278 ;; in your own elisp function, this will define bindings specific to the
279 ;; buffer that was current at the time of the call to viper-add-local-keys.
280 ;; The only thing to make sure here is that the major mode of this buffer
281 ;; is written according to Emacs conventions, which includes a call to
282 ;; (kill-all-local-variables). See viper-add-local-keys for more details.
285 ;; TO DO (volunteers?):
287 ;; 1. Some of the code that is inherited from VIP-3.5 is rather
288 ;; convoluted. Instead of viper-command-argument, keymaps should bind the
289 ;; actual commands. E.g., "dw" should be bound to a generic command
290 ;; viper-delete that will delete things based on the value of
291 ;; last-command-event. This would greatly simplify the logic and the code.
293 ;; 2. Somebody should venture to write a customization package a la
294 ;; options.el that would allow the user to change values of variables
295 ;; that meet certain specs (e.g., match a regexp) and whose doc string
296 ;; starts with a '*'. Then, the user should be offered to save
297 ;; variables that were changed. This will make user's customization job
298 ;; much easier.
301 ;;; Code:
303 (require 'cl-lib)
305 ;; compiler pacifier
306 (defvar mark-even-if-inactive)
307 (defvar quail-mode)
308 (defvar viper-expert-level)
309 (defvar viper-mode-string)
310 (defvar viper-major-mode-modifier-list)
311 ;; end pacifier
313 (require 'viper-init)
314 (require 'viper-keym)
316 ;; better be defined before Viper custom group.
317 (defvar viper-custom-file-name (locate-user-emacs-file "viper" ".viper")
318 "Viper customization file.
319 If set by the user, this must be done _before_ Viper is loaded in `~/.emacs'.")
321 (defgroup viper nil
322 "Vi emulation within Emacs.
323 NOTE: Viper customization should be saved in `viper-custom-file-name'."
324 :prefix "viper-"
325 :group 'emulations)
327 (require 'viper-cmd)
329 (defgroup viper-misc nil
330 "Miscellaneous Viper customization."
331 :prefix "viper-"
332 :group 'viper)
335 (defcustom viper-always t
336 "Non-nil means, arrange for vi-state to be a default when appropriate.
337 This is different from `viper-mode' variable in that `viper-mode' determines
338 whether to use Viper in the first place, while `viper-always', if nil, lets
339 user decide when to invoke Viper in a major mode."
340 :type 'boolean
341 :tag "Always Invoke Viper")
343 ;; Non-viper variables that need to be saved in case the user decides to
344 ;; de-viperize emacs.
345 (defvar viper-saved-non-viper-variables nil)
347 (defcustom viper-mode (cond (noninteractive nil)
348 (t 'ask))
349 "To Viperize or not to Viperize.
350 If t, viperize Emacs. If nil -- don't. If `ask', ask the user.
351 This variable is used primarily when Viper is being loaded.
353 Must be set in your init file before Viper is loaded.
354 DO NOT set this variable interactively, unless you are using the customization
355 widget."
356 :type '(choice (const nil) (const t) (const ask))
357 :tag "Set Viper Mode on Loading")
359 (defcustom viper-vi-state-mode-list
360 '(fundamental-mode
361 makefile-mode
363 awk-mode
364 m4-mode
365 xrdb-mode
366 winmgr-mode
367 autoconf-mode
368 cvs-edit-mode
370 html-mode html-helper-mode
371 emacs-lisp-mode lisp-mode lisp-interaction-mode
373 jde-mode java-mode
374 cc-mode c-mode c++-mode objc-mode
375 fortran-mode f90-mode
376 basic-mode
377 bat-mode
378 asm-mode
379 prolog-mode
380 flora-mode
381 sql-mode
383 text-mode indented-text-mode
384 tex-mode latex-mode bibtex-mode
385 ps-mode
387 ;; completion-list-mode
388 diff-mode
389 idl-mode
391 perl-mode
392 cperl-mode
393 javascript-mode
394 tcl-mode
395 python-mode
397 sh-mode ksh-mode csh-mode
399 gnus-article-mode
400 mh-show-mode
402 "Major modes that require Vi command state."
403 :type '(repeat symbol))
405 (defcustom viper-emacs-state-mode-list
406 '(Custom-mode
408 dired-mode
409 efs-mode
410 tar-mode
411 egg-status-buffer-mode
413 browse-kill-ring-mode
414 recentf-mode
415 recentf-dialog-mode
416 occur-mode
418 mh-folder-mode
419 gnus-group-mode
420 gnus-summary-mode
422 completion-list-mode
423 help-mode
425 Info-mode
426 Buffer-menu-mode
427 compilation-mode
429 rcirc-mode
431 jde-javadoc-checker-report-mode
433 view-mode
434 vm-mode
435 vm-summary-mode)
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))
443 (defcustom viper-insert-state-mode-list
444 '(internal-ange-ftp-mode
445 comint-mode
446 gud-mode
447 inferior-emacs-lisp-mode
448 erc-mode
449 eshell-mode
450 shell-mode)
451 "A list of major modes that should come up in Vi Insert state."
452 :type '(repeat symbol))
455 ;; used to set viper-major-mode-modifier-list in defcustom
456 (defun viper-apply-major-mode-modifiers (&optional symbol value)
457 (if symbol
458 (set symbol value))
459 (mapc (lambda (triple)
460 (viper-modify-major-mode
461 (nth 0 triple) (nth 1 triple) (symbol-value (nth 2 triple))))
462 viper-major-mode-modifier-list))
464 ;; We change standard bindings in some major modes, making them slightly
465 ;; different than in "normal" vi/insert/emacs states
466 (defcustom viper-major-mode-modifier-list
467 '((help-mode emacs-state viper-slash-and-colon-map)
468 (comint-mode insert-state viper-comint-mode-modifier-map)
469 (comint-mode vi-state viper-comint-mode-modifier-map)
470 (gud-mode insert-state viper-comint-mode-modifier-map)
471 (shell-mode insert-state viper-comint-mode-modifier-map)
472 (inferior-emacs-lisp-mode insert-state viper-comint-mode-modifier-map)
473 (shell-mode vi-state viper-comint-mode-modifier-map)
474 (ange-ftp-shell-mode insert-state viper-comint-mode-modifier-map)
475 (ange-ftp-shell-mode vi-state viper-comint-mode-modifier-map)
476 (internal-ange-ftp-mode insert-state viper-comint-mode-modifier-map)
477 (internal-ange-ftp-mode vi-state viper-comint-mode-modifier-map)
478 (dired-mode emacs-state viper-dired-modifier-map)
479 (tar-mode emacs-state viper-slash-and-colon-map)
480 (mh-folder-mode emacs-state viper-slash-and-colon-map)
481 (gnus-group-mode emacs-state viper-gnus-modifier-map)
482 (gnus-summary-mode emacs-state viper-gnus-modifier-map)
483 (Info-mode emacs-state viper-slash-and-colon-map)
484 (Buffer-menu-mode emacs-state viper-slash-and-colon-map)
485 (erc-mode insert-state viper-comint-mode-modifier-map)
486 (erc-mode vi-state viper-comint-mode-modifier-map)
488 "List specifying how to modify the various major modes to enable some Viperisms.
489 The list has the structure: ((mode viper-state keymap) (mode viper-state
490 keymap) ...). If `mode' is on the list, the `keymap' will be made active (on
491 the minor-mode-map-alist) in the specified viper state.
492 If you change this list, have to restart Emacs for the change to take effect.
493 However, if you did the change through the customization widget, then Emacs
494 needs to be restarted only if you deleted a triple mode-state-keymap from the
495 list. No need to restart Emacs in case of insertion or modification of an
496 existing triple."
497 :type '(repeat
498 (list symbol
499 (choice (const emacs-state)
500 (const vi-state)
501 (const insert-state))
502 symbol))
503 :set #'viper-apply-major-mode-modifiers)
507 ;;;###autoload
508 (defun toggle-viper-mode ()
509 "Toggle Viper on/off.
510 If Viper is enabled, turn it off. Otherwise, turn it on."
511 (interactive)
512 (if (eq viper-mode t)
513 (viper-go-away)
514 (setq viper-mode nil)
515 (viper-mode)))
517 ;;;###autoload
518 (defun viper-mode ()
519 "Turn on Viper emulation of Vi in Emacs. See Info node `(viper)Top'."
520 (interactive)
521 (if (not noninteractive)
522 (progn
523 ;; if the user requested viper-mode explicitly
524 (if viper-mode
526 (setq viper-mode t)
527 ;; FIXME: Don't reload!
528 (load-library "viper"))
530 (if viper-first-time ; Important check. Prevents mix-up of startup
531 (progn ; and expert-level msgs when viper-mode recurses
532 (setq viper-first-time nil)
533 (if (not viper-inhibit-startup-message)
534 (save-window-excursion
535 (setq viper-inhibit-startup-message t)
536 (delete-other-windows)
537 (switch-to-buffer "Viper Startup Message")
538 (erase-buffer)
539 (insert
540 (substitute-command-keys
541 "Viper Is a Package for Emacs Rebels,
542 a VI Plan for Emacs Rescue, and a venomous VI PERil.
544 Incidentally, Viper emulates Vi under Emacs/XEmacs 20.
545 It supports all of what is good in Vi and Ex, while extending
546 and improving upon much of it.
548 1. Viper supports Vi at several levels. Level 1 is the closest to Vi,
549 level 5 provides the most flexibility to depart from many Vi conventions.
551 You will be asked to specify your user level in a following screen.
553 If you select user level 1 then the keys ^X, ^C, ^Z, and ^G will behave
554 as in VI, to smooth transition to Viper for the beginners. However, to
555 use Emacs productively, you are advised to reach user level 3 or higher.
557 At user level 2 or higher, ^X and ^C have Emacs, not Vi, bindings;
558 ^Z toggles Vi/Emacs states; ^G is Emacs's keyboard-quit (like ^C in Vi).
560 2. Vi exit functions (e.g., :wq, ZZ) work on INDIVIDUAL files -- they
561 do not cause Emacs to quit, except at user level 1 (for a novice).
562 3. ^X^C EXITS EMACS.
563 4. Viper supports multiple undo: `u' will undo. Typing `.' will repeat
564 undo. Another `u' changes direction.
566 6. Emacs Meta key is `C-\\' (in all modes) or `\\ ESC' (in Vi command mode).
567 On a window system, the best way is to use the Meta-key on your keyboard.
568 7. Try \\[keyboard-quit] and \\[abort-recursive-edit] repeatedly,if
569 something funny happens. This would abort the current editing command.
571 For more information on Viper:
573 a. Type `:help' in Vi command mode
574 b. Print Viper manual, found in ./etc/viper.dvi
575 c. Print the Quick Reference, found in ./etc/viperCard.dvi
577 To submit a bug report or to contact the author, type :submitReport in Vi
578 command mode. To shoo Viper away and return to pure Emacs (horror!), type:
580 M-x viper-go-away
582 This startup message appears whenever you load Viper, unless you type `y' now."
584 (goto-char (point-min))
585 (if (y-or-n-p "Inhibit Viper startup message? ")
586 (viper-save-setting
587 'viper-inhibit-startup-message
588 "Viper startup message inhibited"
589 viper-custom-file-name t))
590 ;;(kill-buffer (current-buffer))
591 (message
592 "The last message is in buffer `Viper Startup Message'")
593 (sit-for 4)
595 (viper-set-expert-level 'dont-change-unless)))
597 (or (apply #'derived-mode-p viper-emacs-state-mode-list) ; don't switch to Vi
598 (apply #'derived-mode-p viper-insert-state-mode-list) ; don't switch
599 (viper-change-state-to-vi))
602 (if (eq major-mode 'viper-mode)
603 (setq major-mode 'fundamental-mode))
607 ;; Apply a little heuristic to invoke vi state on major-modes
608 ;; that are not listed in viper-vi-state-mode-list
609 (defun this-major-mode-requires-vi-state (mode)
610 (let ((major-mode mode))
611 (cond ((apply #'derived-mode-p viper-vi-state-mode-list) t)
612 ((apply #'derived-mode-p viper-emacs-state-mode-list) nil)
613 ((apply #'derived-mode-p viper-insert-state-mode-list) nil)
614 (t (and (eq (key-binding "a") 'self-insert-command)
615 (eq (key-binding " ") 'self-insert-command))))))
618 ;; This hook designed to enable Vi-style editing in comint-based modes."
619 (defun viper-comint-mode-hook ()
620 (set (make-local-variable 'require-final-newline) nil)
621 (setq viper-ex-style-editing nil
622 viper-ex-style-motion nil)
623 (viper-change-state-to-insert))
626 ;; remove viper hooks from SYMBOL
627 (defun viper-remove-hooks (symbol)
628 (cond ((not (boundp symbol)) nil)
629 ((not (listp (symbol-value symbol))) nil)
630 ((string-match "-hook" (symbol-name symbol))
631 (remove-hook symbol #'viper-mode)
632 (remove-hook symbol #'viper-change-state-to-emacs)
633 (remove-hook symbol #'viper-change-state-to-insert)
634 (remove-hook symbol #'viper-change-state-to-vi)
635 (remove-hook symbol #'viper-minibuffer-post-command-hook)
636 (remove-hook symbol #'viper-minibuffer-setup-sentinel)
637 (remove-hook symbol #'viper-major-mode-change-sentinel)
638 (remove-hook symbol #'set-viper-state-in-major-mode)
639 (remove-hook symbol #'viper-post-command-sentinel)
642 ;; Remove local value in all existing buffers
643 ;; This doesn't delocalize vars (which would have been desirable)
644 (defun viper-delocalize-var (symbol)
645 (dolist (buf (buffer-list))
646 (with-current-buffer buf
647 (kill-local-variable symbol))))
649 (defvar viper--advice-list nil)
651 (defun viper--advice-add (function where advice)
652 (advice-add function where advice)
653 (push (cons function advice) viper--advice-list))
655 (defun viper--deactivate-advice-list ()
656 (mapc (lambda (n)
657 (advice-remove
658 (car n)
659 (cdr n)))
660 viper--advice-list)
661 (setq viper--advice-list nil))
663 (defun viper-go-away ()
664 "De-Viperize Emacs.
665 This function tries to do as good a job as possible. However, it may undo some
666 user customization, unrelated to Viper. For instance, if the user advised
667 `read-file-name', `describe-key', and some others, then this advice will be
668 undone.
669 It also can't undo some Viper settings."
670 (interactive)
671 (viper-setup-ESC-to-escape nil)
672 ;; restore non-viper vars
673 (setq-default
674 next-line-add-newlines
675 (viper-standard-value
676 'next-line-add-newlines viper-saved-non-viper-variables)
677 require-final-newline
678 (viper-standard-value
679 'require-final-newline viper-saved-non-viper-variables)
680 scroll-step
681 (viper-standard-value 'scroll-step viper-saved-non-viper-variables)
682 mode-line-buffer-identification
683 (viper-standard-value
684 'mode-line-buffer-identification viper-saved-non-viper-variables)
685 global-mode-string
686 (delq 'viper-mode-string global-mode-string))
688 (setq-default major-mode
689 (viper-standard-value 'major-mode
690 viper-saved-non-viper-variables))
692 (if (featurep 'emacs)
693 (setq-default
694 mark-even-if-inactive
695 (viper-standard-value
696 'mark-even-if-inactive viper-saved-non-viper-variables)))
698 ;; Ideally, we would like to be able to de-localize local variables
699 (unless
700 (and (fboundp 'add-to-ordered-list) (boundp 'emulation-mode-map-alists))
701 (viper-delocalize-var 'minor-mode-map-alist))
702 (viper-delocalize-var 'require-final-newline)
703 (if (featurep 'xemacs) (viper-delocalize-var 'bar-cursor))
706 ;; deactivate all advices done by Viper.
707 (viper--deactivate-advice-list)
709 (setq viper-mode nil)
711 (when (and (fboundp 'add-to-ordered-list) (boundp 'emulation-mode-map-alists))
712 (setq emulation-mode-map-alists
713 (delq 'viper--intercept-key-maps
714 (delq 'viper--key-maps emulation-mode-map-alists))
717 (viper-delocalize-var 'viper-vi-minibuffer-minor-mode)
718 (viper-delocalize-var 'viper-insert-minibuffer-minor-mode)
719 (viper-delocalize-var 'viper-vi-intercept-minor-mode)
720 (viper-delocalize-var 'viper-insert-intercept-minor-mode)
722 (viper-delocalize-var 'viper-vi-local-user-minor-mode)
723 (viper-delocalize-var 'viper-vi-kbd-minor-mode)
724 (viper-delocalize-var 'viper-vi-global-user-minor-mode)
725 (viper-delocalize-var 'viper-vi-state-modifier-minor-mode)
726 (viper-delocalize-var 'viper-vi-diehard-minor-mode)
727 (viper-delocalize-var 'viper-vi-basic-minor-mode)
729 (viper-delocalize-var 'viper-replace-minor-mode)
731 (viper-delocalize-var 'viper-insert-local-user-minor-mode)
732 (viper-delocalize-var 'viper-insert-kbd-minor-mode)
733 (viper-delocalize-var 'viper-insert-global-user-minor-mode)
734 (viper-delocalize-var 'viper-insert-state-modifier-minor-mode)
735 (viper-delocalize-var 'viper-insert-diehard-minor-mode)
736 (viper-delocalize-var 'viper-insert-basic-minor-mode)
738 (viper-delocalize-var 'viper-emacs-intercept-minor-mode)
739 (viper-delocalize-var 'viper-emacs-local-user-minor-mode)
740 (viper-delocalize-var 'viper-emacs-kbd-minor-mode)
741 (viper-delocalize-var 'viper-emacs-global-user-minor-mode)
742 (viper-delocalize-var 'viper-emacs-state-modifier-minor-mode)
744 (viper-delocalize-var 'viper-current-state)
745 (viper-delocalize-var 'viper-mode-string)
747 (setq-default viper-vi-minibuffer-minor-mode nil
748 viper-insert-minibuffer-minor-mode nil
749 viper-vi-intercept-minor-mode nil
750 viper-insert-intercept-minor-mode nil
752 viper-vi-local-user-minor-mode nil
753 viper-vi-kbd-minor-mode nil
754 viper-vi-global-user-minor-mode nil
755 viper-vi-state-modifier-minor-mode nil
756 viper-vi-diehard-minor-mode nil
757 viper-vi-basic-minor-mode nil
759 viper-replace-minor-mode nil
761 viper-insert-local-user-minor-mode nil
762 viper-insert-kbd-minor-mode nil
763 viper-insert-global-user-minor-mode nil
764 viper-insert-state-modifier-minor-mode nil
765 viper-insert-diehard-minor-mode nil
766 viper-insert-basic-minor-mode nil
768 viper-emacs-intercept-minor-mode nil
769 viper-emacs-local-user-minor-mode nil
770 viper-emacs-kbd-minor-mode nil
771 viper-emacs-global-user-minor-mode nil
772 viper-emacs-state-modifier-minor-mode nil
774 viper-current-state 'emacs-state
775 viper-mode-string viper-emacs-state-id
778 ;; remove all hooks set by viper
779 (mapatoms #'viper-remove-hooks)
780 (remove-hook 'comint-mode-hook #'viper-comint-mode-hook)
781 (remove-hook 'erc-mode-hook #'viper-comint-mode-hook)
782 (remove-hook 'change-major-mode-hook #'viper-major-mode-change-sentinel)
784 ;; unbind Viper mouse bindings
785 (viper-unbind-mouse-search-key)
786 (viper-unbind-mouse-insert-key)
787 ;; In emacs, we have to advice handle-switch-frame
788 ;; This advice is undone earlier, when all advices matching "viper-" are
789 ;; deactivated.
790 (if (featurep 'xemacs)
791 (remove-hook 'mouse-leave-frame-hook #'viper-remember-current-frame))
792 ) ; end viper-go-away
795 ;; list of buffers that just changed their major mode
796 ;; used in a hack that triggers vi command mode whenever needed
797 (defvar viper-new-major-mode-buffer-list nil)
799 ;; set appropriate Viper state in buffers that changed major mode
800 (defun set-viper-state-in-major-mode ()
801 (mapc
802 (lambda (buf)
803 (if (viper-buffer-live-p buf)
804 (with-current-buffer buf
805 (cond ((and (this-major-mode-requires-vi-state major-mode)
806 (eq viper-current-state 'emacs-state))
807 (viper-mode))
808 ((cl-member-if #'derived-mode-p viper-emacs-state-mode-list)
809 ;; not checking (eq viper-current-state 'emacs-state)
810 ;; because viper-current-state could have gotten it by
811 ;; default. We need viper-change-state-to-emacs here to have
812 ;; the keymaps take effect.
813 (viper-change-state-to-emacs))
814 ((and (cl-member-if #'derived-mode-p
815 viper-insert-state-mode-list)
816 (not (eq viper-current-state 'insert-state)))
817 (viper-change-state-to-insert))
818 )) ; with-current-buffer
819 )) ; function
820 viper-new-major-mode-buffer-list)
821 ;; clear the list of bufs that changed major mode
822 (setq viper-new-major-mode-buffer-list nil)
823 ;; change the global value of hook
824 (remove-hook 'viper-post-command-hooks #'set-viper-state-in-major-mode))
826 ;; sets up post-command-hook to turn viper-mode, if the current mode is
827 ;; fundamental
828 (defun viper-major-mode-change-sentinel ()
829 (save-match-data
830 (or (string-match "\\*Minibuf-" (buffer-name))
831 (setq viper-new-major-mode-buffer-list
832 (cons (current-buffer) viper-new-major-mode-buffer-list))))
833 ;; change the global value of hook
834 (add-hook 'viper-post-command-hooks #'set-viper-state-in-major-mode t))
837 ;;; Handling of tty's ESC event
839 ;; On a tty, an ESC event can either be the user hitting the escape key, or
840 ;; some element of a byte sequence used to encode for example cursor keys.
841 ;; So we try to recognize those events that correspond to the escape key and
842 ;; turn them into `escape' events (same as used under GUIs). The heuristic we
843 ;; use to distinguish the two cases is based, as usual, on a timeout, and on
844 ;; the fact that the special ESC=>escape mapping only takes place if the whole
845 ;; last key-sequence so far is just [?\e], i.e. either we're still in
846 ;; read-key-sequence, or the last read-key-sequence only read [?\e], which
847 ;; should ideally never happen because it should have been mapped to [escape].
849 (defun viper--tty-ESC-filter (map)
850 (if (and (equal (this-single-command-keys) [?\e])
851 (sit-for (/ viper-fast-keyseq-timeout 1000)))
852 [escape] map))
854 (defun viper--lookup-key (map key)
855 "Kind of like `lookup-key'.
856 Two differences:
857 - KEY is a single key, not a sequence.
858 - the result is the \"raw\" binding, so it can be a `menu-item', rather than the
859 binding contained in that menu item."
860 (catch 'found
861 (map-keymap (lambda (k b) (if (equal key k) (throw 'found b))) map)))
863 (defun viper-catch-tty-ESC ()
864 "Setup key mappings of current terminal to turn a tty's ESC into `escape'."
865 (when (memq (terminal-live-p (frame-terminal)) '(t pc))
866 (let ((esc-binding (viper-uncatch-tty-ESC)))
867 (define-key input-decode-map
868 [?\e] `(menu-item "" ,esc-binding :filter viper--tty-ESC-filter)))))
870 (defun viper-uncatch-tty-ESC ()
871 "Don't hack ESC into `escape' any more."
872 (let ((b (viper--lookup-key input-decode-map ?\e)))
873 (and (eq 'menu-item (car-safe b))
874 (eq 'viper--tty-ESC-filter (nth 4 b))
875 (define-key input-decode-map [?\e] (setq b (nth 2 b))))
878 (defun viper-setup-ESC-to-escape (enable)
879 (if enable
880 (add-hook 'tty-setup-hook #'viper-catch-tty-ESC)
881 (remove-hook 'tty-setup-hook #'viper-catch-tty-ESC))
882 (let ((seen ()))
883 (dolist (frame (frame-list))
884 (let ((terminal (frame-terminal frame)))
885 (unless (memq terminal seen)
886 (push terminal seen)
887 (with-selected-frame frame
888 (if enable (viper-catch-tty-ESC) (viper-uncatch-tty-ESC))))))))
890 ;; This sets major mode hooks to make them come up in vi-state.
891 (defun viper-set-hooks ()
892 ;; It is of course a misnomer to call viper-mode a `major mode'.
893 ;; However, this has the effect that if the user didn't specify the
894 ;; default mode, new buffers that fall back on the default will come up
895 ;; in Fundamental Mode and Vi state.
896 ;; When viper-mode is executed in such a case, it will set the major mode
897 ;; back to fundamental-mode.
898 (if (eq (default-value 'major-mode) #'fundamental-mode)
899 ;; FIXME: We should use after-change-major-mode-hook instead!
900 (setq-default major-mode #'viper-mode))
902 (viper-setup-ESC-to-escape t)
904 (add-hook 'change-major-mode-hook #'viper-major-mode-change-sentinel)
905 (add-hook 'find-file-hook #'set-viper-state-in-major-mode)
907 ;; keep this because many modes we don't know about use this hook
908 (defvar text-mode-hook)
909 (add-hook 'text-mode-hook #'viper-mode)
911 (defvar emerge-startup-hook)
912 (add-hook 'emerge-startup-hook #'viper-change-state-to-emacs)
914 ;; if viper is started from .emacs, it might be impossible to get certain
915 ;; info about the display and windows until emacs initialization is complete
916 ;; So do it via the window-setup-hook
917 (add-hook 'window-setup-hook
918 (lambda ()
919 (modify-frame-parameters
920 (selected-frame)
921 (list (cons 'viper-vi-state-cursor-color
922 (viper-get-cursor-color))))
923 (setq viper-vi-state-cursor-color (viper-get-cursor-color))
926 ;; Tell vc-diff to put *vc* in Vi mode
927 (viper--advice-add 'vc-diff :after #'viper-change-state-to-vi)
928 (viper--advice-add 'emerge-quit :after #'viper-change-state-to-vi)
930 ;; passwd.el sets up its own buffer, which turns up in Vi mode,
931 ;; thus overriding the local map. We don't need Vi mode here.
932 (viper--advice-add 'read-passwd-1 :before #'viper-change-state-to-emacs)
934 (viper--advice-add 'self-insert-command :around
935 (lambda (orig-fun &rest args)
936 ;; FIXME: Use remapping?
937 (if (and (eq viper-current-state 'vi-state)
938 ;; Do not use called-interactively-p here. XEmacs does not have it
939 ;; and interactive-p is just fine.
940 (if (featurep 'xemacs)
941 (interactive-p)
942 ;; Respect the spirit of the above comment, though it
943 ;; seems pointless, since XE doesn't have advice-add or
944 ;; lexical binding or any other of the newer features
945 ;; this file uses.
946 (called-interactively-p 'interactive)))
947 (beep 1)
948 (apply orig-fun args))))
950 (viper--advice-add 'set-cursor-color :after
951 (lambda (color-name)
952 "Change cursor color in VI state."
953 (modify-frame-parameters
954 (selected-frame)
955 (list (cons 'viper-vi-state-cursor-color color-name)))
956 (setq viper-vi-state-cursor-color color-name)))
959 (when (and (fboundp 'add-to-ordered-list) (boundp 'emulation-mode-map-alists))
960 ;; needs to be as early as possible
961 (add-to-ordered-list
962 'emulation-mode-map-alists 'viper--intercept-key-maps 100)
963 ;; needs to be after cua-mode
964 (add-to-ordered-list 'emulation-mode-map-alists 'viper--key-maps 500)
967 ;; Emacs shell, ange-ftp, and comint-based modes
968 (add-hook 'comint-mode-hook #'viper-comint-mode-hook) ; comint
969 (add-hook 'erc-mode-hook #'viper-comint-mode-hook) ; ERC
971 (add-hook 'eshell-mode-hook
972 (lambda () (setq viper-auto-indent nil)))
974 (viper-set-emacs-state-searchstyle-macros nil 'dired-mode) ; dired
975 (viper-set-emacs-state-searchstyle-macros nil 'tar-mode) ; tar
976 (viper-set-emacs-state-searchstyle-macros nil 'mh-folder-mode) ; mhe
977 (viper-set-emacs-state-searchstyle-macros nil 'gnus-group-mode) ; gnus
978 (viper-set-emacs-state-searchstyle-macros nil 'gnus-summary-mode)
979 (viper-set-emacs-state-searchstyle-macros nil 'Info-mode) ; info
980 (viper-set-emacs-state-searchstyle-macros nil 'Buffer-menu-mode) ;buffer-menu
982 ;; Modify major modes according to viper-major-mode-modifier-list
983 (viper-apply-major-mode-modifiers)
985 ;; For RMAIL users.
986 ;; Put buf in Emacs state after edit.
987 (viper--advice-add 'rmail-cease-edit :after #'viper-change-state-to-emacs)
989 ;; ISO accents.
990 (viper--advice-add 'iso-accents-mode :after
991 (lambda (arg &rest _)
992 "Set viper-automatic-iso-accents to iso-accents-mode."
993 (defvar iso-accents-mode)
994 (setq viper-automatic-iso-accents
995 (if (eq viper-current-state 'vi-state)
996 (if arg
997 ;; if iso-accents-mode was called with positive arg, turn
998 ;; accents on
999 (> (prefix-numeric-value arg) 0)
1000 ;; else: toggle viper-automatic-iso-accents
1001 (not viper-automatic-iso-accents))
1002 ;; other states: accept what iso-accents-mode has done
1003 iso-accents-mode))
1004 ;; turn off ISO accents in vi-state
1005 (if (eq viper-current-state 'vi-state)
1006 (viper-set-iso-accents-mode nil))
1007 (if (memq viper-current-state '(vi-state insert-state replace-state))
1008 (message "Viper ISO accents mode: %s"
1009 (if viper-automatic-iso-accents "on" "off")))
1012 ;; International input methods
1013 (if nil ;; (featurep 'emacs) ;;The hooks should now work!
1014 (progn
1015 (viper--advice-add 'deactivate-input-method :after
1016 #'viper-deactivate-input-method-action)
1017 (viper--advice-add 'activate-input-method :after
1018 #'viper-activate-input-method-action))
1019 ;; XEmacs Although these hooks exist in Emacs, they don't seem to be always
1020 ;; called on input-method activation/deactivation, so we the above advise
1021 ;; functions instead.
1022 (eval-after-load "mule-cmds"
1023 '(progn
1024 (add-hook 'input-method-activate-hook
1025 #'viper-activate-input-method-action t)
1026 (add-hook 'input-method-deactivate-hook
1027 #'viper-deactivate-input-method-action t)))
1029 (viper--advice-add 'toggle-input-method :around
1030 (lambda (orig-fun &rest args)
1031 "Adjust input-method toggling in vi-state."
1032 (if (and viper-special-input-method (eq viper-current-state 'vi-state))
1033 (viper-deactivate-input-method)
1034 (apply orig-fun args))))
1036 ) ; viper-set-hooks
1039 ;; these are primarily advices and Vi-ish variable settings
1040 (defun viper-non-hook-settings ()
1042 ;;;; Viper changes the default mode-line-buffer-identification
1043 ;;(setq-default mode-line-buffer-identification '(" %b"))
1045 ;; setup emacs-supported vi-style feel
1046 (setq next-line-add-newlines nil
1047 require-final-newline t)
1049 ;; don't bark when mark is inactive
1050 (if (featurep 'emacs)
1051 (setq mark-even-if-inactive t))
1053 (setq scroll-step 1)
1055 ;; Variable displaying the current Viper state in the mode line.
1056 (or (memq 'viper-mode-string global-mode-string)
1057 (setq global-mode-string
1058 (append '("" viper-mode-string) (cdr global-mode-string))))
1060 (if (featurep 'xemacs)
1061 ;; XEmacs
1062 (defadvice describe-key (before viper-describe-key-ad protect activate)
1063 "Force to read key via `viper-read-key-sequence'."
1064 (interactive (list (viper-read-key-sequence "Describe key: "))))
1065 ;; Emacs
1066 (viper--advice-add 'describe-key :before
1067 (lambda (&rest _)
1068 "Force to read key via `viper-read-key-sequence'."
1069 (interactive (let ((key (viper-read-key-sequence
1070 "Describe key (or click or menu item): ")))
1071 (list key
1072 (prefix-numeric-value current-prefix-arg)
1073 ;; If KEY is a down-event, read also the
1074 ;; corresponding up-event.
1075 (and (vectorp key)
1076 (let ((last-idx (1- (length key))))
1077 (and (eventp (aref key last-idx))
1078 (memq 'down (event-modifiers
1079 (aref key last-idx)))))
1080 (or (and (eventp (aref key 0))
1081 (memq 'down (event-modifiers
1082 (aref key 0)))
1083 ;; For the C-down-mouse-2 popup menu,
1084 ;; there is no subsequent up-event
1085 (= (length key) 1))
1086 (and (> (length key) 1)
1087 (eventp (aref key 1))
1088 (memq 'down (event-modifiers (aref key 1)))))
1089 (read-event)))))
1090 nil))
1092 ) ; (if (featurep 'xemacs)
1094 (if (featurep 'xemacs)
1095 ;; XEmacs
1096 (defadvice describe-key-briefly
1097 (before viper-describe-key-briefly-ad protect activate)
1098 "Force to read key via `viper-read-key-sequence'."
1099 (interactive (list (viper-read-key-sequence "Describe key briefly: "))))
1100 ;; Emacs
1101 (viper--advice-add 'describe-key-briefly :before
1102 (lambda (&rest _)
1103 "Force to read key via `viper-read-key-sequence'."
1104 (interactive (let ((key (viper-read-key-sequence
1105 "Describe key (or click or menu item): ")))
1106 ;; If KEY is a down-event, read and discard the
1107 ;; corresponding up-event.
1108 (and (vectorp key)
1109 (let ((last-idx (1- (length key))))
1110 (and (eventp (aref key last-idx))
1111 (memq 'down (event-modifiers (aref key last-idx)))))
1112 (read-event))
1113 (list key
1114 (if current-prefix-arg
1115 (prefix-numeric-value current-prefix-arg))
1116 1)))
1117 nil))
1118 ) ; (if (featurep 'xemacs)
1120 ;; FIXME: The default already uses read-file-name, so it looks like this
1121 ;; advice is not needed any more.
1122 ;; (defadvice find-file (before viper-add-suffix-advice activate)
1123 ;; "Use `read-file-name' for reading arguments."
1124 ;; (interactive (cons (read-file-name "Find file: " nil default-directory)
1125 ;; ;; XEmacs: if Mule & prefix arg, ask for coding system
1126 ;; (cond ((and (featurep 'xemacs) (featurep 'mule))
1127 ;; (list
1128 ;; (and current-prefix-arg
1129 ;; (read-coding-system "Coding-system: "))))
1130 ;; ;; Emacs: do wildcards
1131 ;; ((and (featurep 'emacs) (boundp 'find-file-wildcards))
1132 ;; (list find-file-wildcards))))
1133 ;; ))
1134 ;; (defadvice find-file-other-window (before viper-add-suffix-advice activate)
1135 ;; "Use `read-file-name' for reading arguments."
1136 ;; (interactive (cons (read-file-name "Find file in other window: "
1137 ;; nil default-directory)
1138 ;; ;; XEmacs: if Mule & prefix arg, ask for coding system
1139 ;; (cond ((and (featurep 'xemacs) (featurep 'mule))
1140 ;; (list
1141 ;; (and current-prefix-arg
1142 ;; (read-coding-system "Coding-system: "))))
1143 ;; ;; Emacs: do wildcards
1144 ;; ((and (featurep 'emacs) (boundp 'find-file-wildcards))
1145 ;; (list find-file-wildcards))))
1146 ;; ))
1147 ;; (defadvice find-file-other-frame (before viper-add-suffix-advice activate)
1148 ;; "Use `read-file-name' for reading arguments."
1149 ;; (interactive (cons (read-file-name "Find file in other frame: "
1150 ;; nil default-directory)
1151 ;; ;; XEmacs: if Mule & prefix arg, ask for coding system
1152 ;; (cond ((and (featurep 'xemacs) (featurep 'mule))
1153 ;; (list
1154 ;; (and current-prefix-arg
1155 ;; (read-coding-system "Coding-system: "))))
1156 ;; ;; Emacs: do wildcards
1157 ;; ((and (featurep 'emacs) (boundp 'find-file-wildcards))
1158 ;; (list find-file-wildcards))))
1159 ;; ))
1162 (viper--advice-add 'read-file-name :around
1163 (lambda (orig-fun &rest args)
1164 "Tell `exit-minibuffer' to run `viper-file-add-suffix' as a hook."
1165 (let ((viper-minibuffer-exit-hook
1166 (append viper-minibuffer-exit-hook
1167 '(viper-minibuffer-trim-tail viper-file-add-suffix))))
1168 (apply orig-fun args))))
1170 (viper--advice-add 'start-kbd-macro :after
1171 (lambda (&rest _)
1172 "Remove Viper's intercepting bindings for C-x ).
1173 This may be needed if the previous `:map' command terminated abnormally."
1174 (define-key viper-vi-intercept-map "\C-x)" nil)
1175 (define-key viper-insert-intercept-map "\C-x)" nil)
1176 (define-key viper-emacs-intercept-map "\C-x)" nil)))
1178 (viper--advice-add 'add-minor-mode :after
1179 (lambda (&rest _)
1180 "Run viper-normalize-minor-mode-map-alist after adding a minor mode."
1181 (viper-normalize-minor-mode-map-alist)
1182 (unless
1183 (and (fboundp 'add-to-ordered-list) (boundp 'emulation-mode-map-alists))
1184 (setq-default minor-mode-map-alist minor-mode-map-alist))))
1186 ;; catch frame switching event
1187 (if (viper-window-display-p)
1188 (if (featurep 'xemacs)
1189 (add-hook 'mouse-leave-frame-hook
1190 #'viper-remember-current-frame)
1191 (viper--advice-add 'handle-switch-frame :before
1192 (lambda (&rest _)
1193 "Remember the selected frame before the switch-frame event."
1194 (viper-remember-current-frame (selected-frame))))))
1196 ) ; end viper-non-hook-settings
1200 ;; Ask only if this-command/last-command are nil, i.e., when loading
1201 (cond ((and (eq viper-mode 'ask) (null this-command) (null last-command))
1202 (save-window-excursion
1203 (with-output-to-temp-buffer " *viper-info*"
1204 (princ "
1205 You have loaded Viper, and are about to Viperize your Emacs!
1207 Viper is a Package for Emacs Rebels and a venomous VI PERil,
1209 It's time to decide: to Viperize or not to Viperize...
1211 If you wish to Viperize AND make this your way of life, please put
1213 (setq viper-mode t)
1214 (require 'viper)
1216 in your init file (preferably, close to the top).
1217 These two lines must come in the order given."))
1218 (if (y-or-n-p "Viperize? ")
1219 (setq viper-mode t)
1220 (setq viper-mode nil))
1221 (message "")
1222 (kill-buffer " *viper-info*")))
1224 ;; If viper-mode is t, then just continue. Viper will kick in.
1225 ((eq viper-mode t))
1226 ;; Otherwise, it was asking Viper was not loaded through .emacs
1227 ;; In this case, it was either through M-x viper-mode or via something
1228 ;; else, like the custom widget. If Viper was loaded through
1229 ;; M-x viper-mode, then viper will kick in anyway.
1230 (t (setq viper-mode nil)))
1232 (defun viper-load-custom-file ()
1233 (if (and (file-exists-p viper-custom-file-name)
1234 (not noninteractive))
1235 (load viper-custom-file-name)))
1242 ;; save non-viper vars that Viper might change
1243 (if (null viper-saved-non-viper-variables)
1244 (setq viper-saved-non-viper-variables
1245 (list
1246 (cons 'major-mode (list (default-value 'major-mode)))
1247 (cons 'next-line-add-newlines (list next-line-add-newlines))
1248 (cons 'require-final-newline (list require-final-newline))
1249 (cons 'scroll-step (list scroll-step))
1250 (cons 'mode-line-buffer-identification
1251 (list (default-value 'mode-line-buffer-identification)))
1252 (cons 'global-mode-string (list global-mode-string))
1253 (if (featurep 'emacs)
1254 (cons 'mark-even-if-inactive (list mark-even-if-inactive)))
1258 ;; Set some useful macros, advices
1259 ;; These must be BEFORE viper-custom-file-name is loaded,
1260 ;; so the user can unrecord them in viper-custom-file-name.
1261 (if viper-mode
1262 (progn
1263 ;; set advices and some variables that give emacs Vi look.
1264 (viper-non-hook-settings)
1266 ;; repeat the 2nd previous command without rotating the command history
1267 (viper-record-kbd-macro
1268 (vector viper-repeat-from-history-key '\1) 'vi-state
1269 [(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)
1270 ;; repeat the 3d previous command without rotating the command history
1271 (viper-record-kbd-macro
1272 (vector viper-repeat-from-history-key '\2) 'vi-state
1273 [(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)
1275 ;; set macros for toggling case sensitivity and regexp search
1276 (viper-set-searchstyle-toggling-macros nil)
1277 ;; Make %%% toggle parsing comments for matching parentheses
1278 (viper-set-parsing-style-toggling-macro nil)
1280 ;; viper-custom-file-name is loaded if exists
1281 (viper-load-custom-file)
1283 ;; should be after loading custom file to avoid the pesky msg that
1284 ;; mouse-search/insert keys are already bound
1285 (viper-bind-mouse-search-key)
1286 (viper-bind-mouse-insert-key)
1291 ;; Applying Viper customization -- runs after (load viper-custom-file-name)
1293 ;; Save user settings or Viper defaults for vars controlled by
1294 ;; viper-expert-level
1295 (if (null viper-saved-user-settings)
1296 (setq viper-saved-user-settings
1297 (list (cons 'viper-want-ctl-h-help (list viper-want-ctl-h-help))
1298 (cons 'viper-always (list viper-always))
1299 (cons 'viper-no-multiple-ESC (list viper-no-multiple-ESC))
1300 (cons 'viper-ex-style-motion (list viper-ex-style-motion))
1301 (cons 'viper-ex-style-editing
1302 (list viper-ex-style-editing))
1303 (cons 'viper-want-emacs-keys-in-vi
1304 (list viper-want-emacs-keys-in-vi))
1305 (cons 'viper-electric-mode (list viper-electric-mode))
1306 (cons 'viper-want-emacs-keys-in-insert
1307 (list viper-want-emacs-keys-in-insert))
1308 (cons 'viper-re-search (list viper-re-search)))))
1312 ;; Intercept maps could go in viper-keym.el
1313 ;; We keep them here in case someone redefines them in viper-custom-file-name
1315 (define-key viper-vi-intercept-map viper-ESC-key #'viper-intercept-ESC-key)
1316 (define-key viper-insert-intercept-map viper-ESC-key #'viper-intercept-ESC-key)
1318 ;; This is taken care of by viper-insert-global-user-map.
1319 ;;(define-key viper-replace-map viper-ESC-key #'viper-intercept-ESC-key)
1322 ;; The default viper-toggle-key is \C-z; for the novice, it suspends or
1323 ;; iconifies Emacs
1324 (define-key viper-vi-intercept-map viper-toggle-key 'viper-toggle-key-action)
1325 (define-key
1326 viper-emacs-intercept-map viper-toggle-key #'viper-change-state-to-vi)
1328 ;; Removed to avoid bad interaction with cua-mode.
1329 ;; Escape from Emacs and Insert modes to Vi for one command
1330 ;;(define-key viper-emacs-intercept-map "\C-c\\" 'viper-escape-to-vi)
1331 ;;(define-key viper-insert-intercept-map "\C-c\\" 'viper-escape-to-vi)
1333 (when viper-mode
1334 (viper-set-minibuffer-style)
1335 (if viper-buffer-search-char
1336 (viper-buffer-search-enable))
1337 (viper-update-syntax-classes 'set-default)
1339 ;; Familiarize Viper with some minor modes that have their own keymaps
1340 (viper-harness-minor-mode "compile")
1341 (viper-harness-minor-mode "outline")
1342 (viper-harness-minor-mode "allout")
1343 (viper-harness-minor-mode "xref")
1344 (viper-harness-minor-mode "lmenu")
1345 (viper-harness-minor-mode "vc")
1346 (viper-harness-minor-mode "ltx-math") ; LaTeX-math-mode in AUC-TeX, which
1347 (viper-harness-minor-mode "latex") ; sits in one of these two files
1348 (viper-harness-minor-mode "cyrillic")
1349 (viper-harness-minor-mode "russian")
1350 (viper-harness-minor-mode "view-less")
1351 (viper-harness-minor-mode "view")
1352 (viper-harness-minor-mode "reftex")
1353 (viper-harness-minor-mode "flyspell")
1355 (setq-default viper-emacs-intercept-minor-mode t
1356 viper-emacs-local-user-minor-mode t
1357 viper-emacs-global-user-minor-mode t
1358 viper-emacs-kbd-minor-mode t
1359 viper-emacs-state-modifier-minor-mode t)
1360 (if (eq viper-current-state 'emacs-state)
1361 (setq viper-emacs-intercept-minor-mode t
1362 viper-emacs-local-user-minor-mode t
1363 viper-emacs-global-user-minor-mode t
1364 viper-emacs-kbd-minor-mode t
1365 viper-emacs-state-modifier-minor-mode t))
1368 (if (or viper-always
1369 (and (< viper-expert-level 5) (> viper-expert-level 0)))
1370 (viper-set-hooks))
1372 ;; Let all minor modes take effect after loading.
1373 ;; This may not be enough, so we also set default minor-mode-alist.
1374 ;; Without setting the default, new buffers that come up in emacs mode have
1375 ;; minor-mode-map-alist = nil, unless we call viper-change-state-*
1376 (when (eq viper-current-state 'emacs-state)
1377 (viper-change-state-to-emacs)
1378 (unless
1379 (and (fboundp 'add-to-ordered-list)
1380 (boundp 'emulation-mode-map-alists))
1381 (setq-default minor-mode-map-alist minor-mode-map-alist))
1384 (if (this-major-mode-requires-vi-state major-mode)
1385 (viper-mode))
1387 (add-function :after initial-major-mode #'set-viper-state-in-major-mode))
1391 (run-hooks 'viper-load-hook) ; the last chance to change something
1393 (provide 'viper)
1396 ;; Local Variables:
1397 ;; eval: (put 'viper-deflocalvar 'lisp-indent-hook 'defun)
1398 ;; End:
1400 ;;; viper.el ends here