* automated/icalendar-tests.el (icalendar--decode-isodatetime): Hydra fix.
[emacs.git] / lisp / emulation / viper.el
1 ;;; viper.el --- A full-featured Vi emulator for 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.
5
6 ;; Copyright (C) 1994-2014 Free Software Foundation, Inc.
7
8 ;; Author: Michael Kifer <kifer@cs.stonybrook.edu>
9 ;; Keywords: emulations
10 ;; Version: 3.14.1
11
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.
16
17 (defconst viper-version "3.14.2 of July 4, 2013"
18   "The current version of Viper")
19
20 ;; This file is part of GNU Emacs.
21
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.
26
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.
31
32 ;; You should have received a copy of the GNU General Public License
33 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
34
35 ;;; Commentary:
36
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.
45 ;;
46 ;;; History:
47 ;;
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.
53 ;;
54 ;; Viper maintains some degree of compatibility with these older
55 ;; packages.  See the documentation for customization.
56 ;;
57 ;; The main difference between Viper and these older packages are:
58 ;;
59 ;; 1. Viper emulates Vi at several levels, from almost complete conformity
60 ;;    to a rather loose Vi-compliance.
61 ;;
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.
66 ;;
67 ;; 3. Viper supports vi-style undo.
68 ;;
69 ;; 4. Viper fully emulates (and improves upon) vi's replacement mode.
70 ;;
71 ;; 5. Viper has a better interface to ex, including command, variable, and
72 ;;    file name completion.
73 ;;
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.
77 ;;
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.
80 ;;
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.
85 ;;
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.
98 ;;
99 ;;
100 ;;; Installation:
101 ;;  -------------
102 ;;
103 ;;  (require 'viper)
104 ;;
105
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.
111 ;;
112 ;;
113 ;;; Notes:
114 ;;
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.
125 ;;
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:
128 ;;
129 ;;     (add-hook 'your-favorite-mode 'viper-mode)
130 ;; or
131 ;;     (add-hook 'your-favorite-mode 'viper-change-state-to-emacs)
132 ;;
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.)
136 ;;
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.
140 ;;
141 ;; Viper's  Vi state consists of seven minor modes:
142 ;;
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
150 ;;
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.
153 ;;
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.
161 ;;
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.
165 ;;
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.
174 ;;
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.
178 ;;
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).
188 ;;
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.
193 ;;
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.
196 ;;
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.
199 ;;
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.
203 ;;
204 ;;  Viper's Insert state also has seven minor modes:
205 ;;
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
213 ;;
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.
217 ;;
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.
225 ;;
226 ;;  The next minor mode, viper-insert-kbd-minor-mode,
227 ;;  is used for keyboard VI-style macros defined with :map!.
228 ;;
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.
232 ;;
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.
238 ;;
239 ;;  Finally, Viper provides minor modes for overriding bindings set by Emacs
240 ;;  modes when Viper is in Emacs state:
241 ;;
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
246 ;;
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.
257 ;;
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
261 ;;
262 ;;       viper-replace-minor-mode
263 ;;
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.
267 ;;
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
274 ;;
275 ;;       (viper-add-local-keys 'insert-state '((key1 . func1) (key2 .func2)))
276 ;;
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.
283 ;;
284 ;;
285 ;;  TO DO (volunteers?):
286 ;;
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.
292 ;;
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.
299 ;;
300
301 ;;; Code:
302
303 ;; compiler pacifier
304 (defvar mark-even-if-inactive)
305 (defvar quail-mode)
306 (defvar viper-expert-level)
307 (defvar viper-mode-string)
308 (defvar viper-major-mode-modifier-list)
309 ;; end pacifier
310
311 (require 'advice)
312 (require 'viper-init)
313 (require 'viper-keym)
314
315 ;; better be defined before Viper custom group.
316 (defvar viper-custom-file-name (locate-user-emacs-file "viper" ".viper")
317   "Viper customization file.
318 If set by the user, this must be done _before_ Viper is loaded in `~/.emacs'.")
319
320 (defgroup viper nil
321   "Vi emulation within Emacs.
322 NOTE: Viper customization should be saved in `viper-custom-file-name'."
323   :prefix "viper-"
324   :group 'emulations)
325
326 (require 'viper-cmd)
327
328 (defgroup viper-misc nil
329   "Miscellaneous Viper customization."
330   :prefix "viper-"
331   :group 'viper)
332
333
334 (defcustom viper-always t
335   "Non-nil means, arrange for vi-state to be a default when appropriate.
336 This is different from `viper-mode' variable in that `viper-mode' determines
337 whether to use Viper in the first place, while `viper-always', if nil, lets
338 user decide when to invoke Viper in a major mode."
339   :type 'boolean
340   :tag "Always Invoke Viper"
341   :group 'viper-misc)
342
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)
346
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.
352
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"
358   :group 'viper-misc)
359
360 (defcustom viper-vi-state-mode-list
361   '(fundamental-mode
362     makefile-mode
363
364     awk-mode
365     m4-mode
366     xrdb-mode
367     winmgr-mode
368     autoconf-mode
369     cvs-edit-mode
370
371     html-mode html-helper-mode
372     emacs-lisp-mode lisp-mode lisp-interaction-mode
373
374     jde-mode java-mode
375     cc-mode c-mode c++-mode objc-mode
376     fortran-mode f90-mode
377     basic-mode
378     bat-mode
379     asm-mode
380     prolog-mode
381     flora-mode
382     sql-mode
383
384     text-mode indented-text-mode
385     tex-mode latex-mode bibtex-mode
386     ps-mode
387
388     ;; completion-list-mode
389     diff-mode
390     idl-mode
391
392     perl-mode
393     cperl-mode
394     javascript-mode
395     tcl-mode
396     python-mode
397
398     sh-mode ksh-mode csh-mode
399
400     gnus-article-mode
401     mh-show-mode
402     )
403   "Major modes that require Vi command state."
404   :type '(repeat symbol)
405   :group 'viper-misc)
406
407 (defcustom viper-emacs-state-mode-list
408   '(Custom-mode
409
410     dired-mode
411     efs-mode
412     tar-mode
413     egg-status-buffer-mode
414
415     browse-kill-ring-mode
416     recentf-mode
417     recentf-dialog-mode
418     occur-mode
419
420     mh-folder-mode
421     gnus-group-mode
422     gnus-summary-mode
423
424     completion-list-mode
425     help-mode
426
427     Info-mode
428     Buffer-menu-mode
429     compilation-mode
430
431     rcirc-mode
432
433     jde-javadoc-checker-report-mode
434
435     view-mode
436     vm-mode
437     vm-summary-mode)
438   "A list of major modes that should come up in Emacs state.
439 Normally, Viper would bring buffers up in Emacs state, unless the corresponding
440 major mode has been placed on `viper-vi-state-mode-list' or
441 `viper-insert-state-mode-list'.  So, don't place a new mode on this list,
442 unless it is coming up in a wrong Viper state."
443   :type '(repeat symbol)
444   :group 'viper-misc)
445
446 (defcustom viper-insert-state-mode-list
447   '(internal-ange-ftp-mode
448     comint-mode
449     gud-mode
450     inferior-emacs-lisp-mode
451     erc-mode
452     eshell-mode
453     shell-mode)
454   "A list of major modes that should come up in Vi Insert state."
455   :type '(repeat symbol)
456   :group 'viper-misc)
457
458
459 ;; used to set viper-major-mode-modifier-list in defcustom
460 (defun viper-apply-major-mode-modifiers (&optional symbol value)
461   (if symbol
462       (set symbol value))
463   (mapcar (lambda (triple)
464             (viper-modify-major-mode
465              (nth 0 triple) (nth 1 triple) (eval (nth 2 triple))))
466           viper-major-mode-modifier-list))
467
468 ;; We change standard bindings in some major modes, making them slightly
469 ;; different than in "normal" vi/insert/emacs states
470 (defcustom viper-major-mode-modifier-list
471   '((help-mode emacs-state viper-slash-and-colon-map)
472     (comint-mode insert-state viper-comint-mode-modifier-map)
473     (comint-mode vi-state viper-comint-mode-modifier-map)
474     (gud-mode insert-state viper-comint-mode-modifier-map)
475     (shell-mode insert-state viper-comint-mode-modifier-map)
476     (inferior-emacs-lisp-mode insert-state viper-comint-mode-modifier-map)
477     (shell-mode vi-state viper-comint-mode-modifier-map)
478     (ange-ftp-shell-mode insert-state viper-comint-mode-modifier-map)
479     (ange-ftp-shell-mode vi-state viper-comint-mode-modifier-map)
480     (internal-ange-ftp-mode insert-state viper-comint-mode-modifier-map)
481     (internal-ange-ftp-mode vi-state viper-comint-mode-modifier-map)
482     (dired-mode emacs-state viper-dired-modifier-map)
483     (tar-mode emacs-state viper-slash-and-colon-map)
484     (mh-folder-mode emacs-state viper-slash-and-colon-map)
485     (gnus-group-mode emacs-state viper-gnus-modifier-map)
486     (gnus-summary-mode emacs-state viper-gnus-modifier-map)
487     (Info-mode emacs-state viper-slash-and-colon-map)
488     (Buffer-menu-mode emacs-state viper-slash-and-colon-map)
489     (erc-mode insert-state viper-comint-mode-modifier-map)
490     (erc-mode vi-state viper-comint-mode-modifier-map)
491     )
492   "List specifying how to modify the various major modes to enable some Viperisms.
493 The list has the structure: ((mode viper-state keymap) (mode viper-state
494 keymap) ...).  If `mode' is on the list, the `keymap' will be made active (on
495 the minor-mode-map-alist) in the specified viper state.
496 If you change this list, have to restart Emacs for the change to take effect.
497 However, if you did the change through the customization widget, then Emacs
498 needs to be restarted only if you deleted a triple mode-state-keymap from the
499 list.  No need to restart Emacs in case of insertion or modification of an
500 existing triple."
501   :type '(repeat
502           (list symbol
503                 (choice (const emacs-state)
504                         (const vi-state)
505                         (const insert-state))
506                 symbol))
507   :set 'viper-apply-major-mode-modifiers
508   :group 'viper-misc)
509
510
511
512 \f
513
514 ;;;###autoload
515 (defun toggle-viper-mode ()
516   "Toggle Viper on/off.
517 If Viper is enabled, turn it off.  Otherwise, turn it on."
518   (interactive)
519   (if (eq viper-mode t)
520       (viper-go-away)
521     (setq viper-mode nil)
522     (viper-mode)))
523
524 ;;;###autoload
525 (defun viper-mode ()
526   "Turn on Viper emulation of Vi in Emacs. See Info node `(viper)Top'."
527   (interactive)
528   (if (not noninteractive)
529       (progn
530         ;; if the user requested viper-mode explicitly
531         (if viper-mode
532             ()
533           (setq viper-mode t)
534           (load-library "viper"))
535
536         (if viper-first-time ; Important check.  Prevents mix-up of startup
537             (progn           ; and expert-level msgs when viper-mode recurses
538               (setq viper-first-time nil)
539               (if (not viper-inhibit-startup-message)
540                   (save-window-excursion
541                     (setq viper-inhibit-startup-message t)
542                     (delete-other-windows)
543                     (switch-to-buffer "Viper Startup Message")
544                     (erase-buffer)
545                     (insert
546                      (substitute-command-keys
547                       "Viper Is a Package for Emacs Rebels,
548 a VI Plan for Emacs Rescue, and a venomous VI PERil.
549
550 Incidentally, Viper emulates Vi under Emacs/XEmacs 20.
551 It supports all of what is good in Vi and Ex, while extending
552 and improving upon much of it.
553
554    1. Viper supports Vi at several levels.  Level 1 is the closest to Vi,
555       level 5 provides the most flexibility to depart from many Vi conventions.
556
557       You will be asked to specify your user level in a following screen.
558
559       If you select user level 1 then the keys ^X, ^C, ^Z, and ^G will behave
560       as in VI, to smooth transition to Viper for the beginners.  However, to
561       use Emacs productively, you are advised to reach user level 3 or higher.
562
563       At user level 2 or higher, ^X and ^C have Emacs, not Vi, bindings;
564       ^Z toggles Vi/Emacs states; ^G is Emacs's keyboard-quit (like ^C in Vi).
565
566    2. Vi exit functions (e.g., :wq, ZZ) work on INDIVIDUAL files -- they
567       do not cause Emacs to quit, except at user level 1 (for a novice).
568    3. ^X^C EXITS EMACS.
569    4. Viper supports multiple undo: `u' will undo.  Typing `.' will repeat
570       undo.  Another `u' changes direction.
571
572    6. Emacs Meta key is `C-\\' (in all modes) or `\\ ESC' (in Vi command mode).
573       On a window system, the best way is to use the Meta-key on your keyboard.
574    7. Try \\[keyboard-quit] and \\[abort-recursive-edit] repeatedly,if
575       something funny happens.  This would abort the current editing command.
576
577 For more information on Viper:
578
579    a. Type `:help' in Vi command mode
580    b. Print Viper manual, found in ./etc/viper.dvi
581    c. Print the Quick Reference, found in ./etc/viperCard.dvi
582
583 To submit a bug report or to contact the author, type :submitReport in Vi
584 command mode.  To shoo Viper away and return to pure Emacs (horror!), type:
585
586    M-x viper-go-away
587
588 This startup message appears whenever you load Viper, unless you type `y' now."
589                       ))
590                     (goto-char (point-min))
591                     (if (y-or-n-p "Inhibit Viper startup message? ")
592                         (viper-save-setting
593                          'viper-inhibit-startup-message
594                          "Viper startup message inhibited"
595                          viper-custom-file-name t))
596                     ;;(kill-buffer (current-buffer))
597                     (message
598                      "The last message is in buffer `Viper Startup Message'")
599                     (sit-for 4)
600                     ))
601               (viper-set-expert-level 'dont-change-unless)))
602
603         (or (memq major-mode viper-emacs-state-mode-list) ; don't switch to Vi
604             (memq major-mode viper-insert-state-mode-list) ; don't switch
605             (viper-change-state-to-vi))
606         ))
607
608   (if (eq major-mode 'viper-mode)
609       (setq major-mode 'fundamental-mode))
610   )
611
612
613 ;; Apply a little heuristic to invoke vi state on major-modes
614 ;; that are not listed in viper-vi-state-mode-list
615 (defun this-major-mode-requires-vi-state (mode)
616   (cond ((memq mode viper-vi-state-mode-list) t)
617         ((memq mode viper-emacs-state-mode-list) nil)
618         ((memq mode viper-insert-state-mode-list) nil)
619         (t (and (eq (key-binding "a") 'self-insert-command)
620                 (eq (key-binding " ") 'self-insert-command)))))
621
622 \f
623 ;; This hook designed to enable Vi-style editing in comint-based modes."
624 (defun viper-comint-mode-hook ()
625   (set (make-local-variable 'require-final-newline) nil)
626   (setq viper-ex-style-editing nil
627         viper-ex-style-motion nil)
628   (viper-change-state-to-insert))
629
630
631 ;; remove viper hooks from SYMBOL
632 (defun viper-remove-hooks (symbol)
633   (cond ((not (boundp symbol)) nil)
634         ((not (listp (eval symbol))) nil)
635         ((string-match "-hook" (symbol-name symbol))
636          (remove-hook symbol 'viper-mode)
637          (remove-hook symbol 'viper-change-state-to-emacs)
638          (remove-hook symbol 'viper-change-state-to-insert)
639          (remove-hook symbol 'viper-change-state-to-vi)
640          (remove-hook symbol 'viper-minibuffer-post-command-hook)
641          (remove-hook symbol 'viper-minibuffer-setup-sentinel)
642          (remove-hook symbol 'viper-major-mode-change-sentinel)
643          (remove-hook symbol 'set-viper-state-in-major-mode)
644          (remove-hook symbol 'viper-post-command-sentinel)
645          )))
646
647 ;; Remove local value in all existing buffers
648 ;; This doesn't delocalize vars (which would have been desirable)
649 (defun viper-delocalize-var (symbol)
650   (dolist (buf (buffer-list))
651     (with-current-buffer buf
652       (kill-local-variable symbol))))
653
654
655 (defun viper-go-away ()
656   "De-Viperize Emacs.
657 This function tries to do as good a job as possible.  However, it may undo some
658 user customization, unrelated to Viper.  For instance, if the user advised
659 `read-file-name', `describe-key', and some others, then this advice will be
660 undone.
661 It also can't undo some Viper settings."
662   (interactive)
663   (viper-setup-ESC-to-escape nil)
664   ;; restore non-viper vars
665   (setq-default
666    next-line-add-newlines
667    (viper-standard-value
668     'next-line-add-newlines viper-saved-non-viper-variables)
669    require-final-newline
670    (viper-standard-value
671     'require-final-newline viper-saved-non-viper-variables)
672    scroll-step
673    (viper-standard-value 'scroll-step viper-saved-non-viper-variables)
674    mode-line-buffer-identification
675    (viper-standard-value
676     'mode-line-buffer-identification viper-saved-non-viper-variables)
677    global-mode-string
678    (delq 'viper-mode-string global-mode-string))
679
680   (setq-default major-mode
681                 (viper-standard-value 'default-major-mode
682                                       viper-saved-non-viper-variables))
683
684   (if (featurep 'emacs)
685       (setq-default
686        mark-even-if-inactive
687        (viper-standard-value
688         'mark-even-if-inactive viper-saved-non-viper-variables)))
689
690   ;; Ideally, we would like to be able to de-localize local variables
691   (unless
692       (and (fboundp 'add-to-ordered-list) (boundp 'emulation-mode-map-alists))
693     (viper-delocalize-var 'minor-mode-map-alist))
694   (viper-delocalize-var 'require-final-newline)
695   (if (featurep 'xemacs) (viper-delocalize-var 'bar-cursor))
696
697
698   ;; deactivate all advices done by Viper.
699   (ad-deactivate-regexp "viper-")
700
701   (setq viper-mode nil)
702
703   (when (and (fboundp 'add-to-ordered-list) (boundp 'emulation-mode-map-alists))
704     (setq emulation-mode-map-alists
705           (delq 'viper--intercept-key-maps
706                 (delq 'viper--key-maps emulation-mode-map-alists))
707           ))
708
709   (viper-delocalize-var 'viper-vi-minibuffer-minor-mode)
710   (viper-delocalize-var 'viper-insert-minibuffer-minor-mode)
711   (viper-delocalize-var 'viper-vi-intercept-minor-mode)
712   (viper-delocalize-var 'viper-insert-intercept-minor-mode)
713
714   (viper-delocalize-var 'viper-vi-local-user-minor-mode)
715   (viper-delocalize-var 'viper-vi-kbd-minor-mode)
716   (viper-delocalize-var 'viper-vi-global-user-minor-mode)
717   (viper-delocalize-var 'viper-vi-state-modifier-minor-mode)
718   (viper-delocalize-var 'viper-vi-diehard-minor-mode)
719   (viper-delocalize-var 'viper-vi-basic-minor-mode)
720
721   (viper-delocalize-var 'viper-replace-minor-mode)
722
723   (viper-delocalize-var 'viper-insert-local-user-minor-mode)
724   (viper-delocalize-var 'viper-insert-kbd-minor-mode)
725   (viper-delocalize-var 'viper-insert-global-user-minor-mode)
726   (viper-delocalize-var 'viper-insert-state-modifier-minor-mode)
727   (viper-delocalize-var 'viper-insert-diehard-minor-mode)
728   (viper-delocalize-var 'viper-insert-basic-minor-mode)
729
730   (viper-delocalize-var 'viper-emacs-intercept-minor-mode)
731   (viper-delocalize-var 'viper-emacs-local-user-minor-mode)
732   (viper-delocalize-var 'viper-emacs-kbd-minor-mode)
733   (viper-delocalize-var 'viper-emacs-global-user-minor-mode)
734   (viper-delocalize-var 'viper-emacs-state-modifier-minor-mode)
735
736   (viper-delocalize-var 'viper-current-state)
737   (viper-delocalize-var 'viper-mode-string)
738
739   (setq-default viper-vi-minibuffer-minor-mode         nil
740                 viper-insert-minibuffer-minor-mode     nil
741                 viper-vi-intercept-minor-mode          nil
742                 viper-insert-intercept-minor-mode      nil
743
744                 viper-vi-local-user-minor-mode         nil
745                 viper-vi-kbd-minor-mode                nil
746                 viper-vi-global-user-minor-mode        nil
747                 viper-vi-state-modifier-minor-mode     nil
748                 viper-vi-diehard-minor-mode            nil
749                 viper-vi-basic-minor-mode              nil
750
751                 viper-replace-minor-mode               nil
752
753                 viper-insert-local-user-minor-mode     nil
754                 viper-insert-kbd-minor-mode            nil
755                 viper-insert-global-user-minor-mode    nil
756                 viper-insert-state-modifier-minor-mode nil
757                 viper-insert-diehard-minor-mode        nil
758                 viper-insert-basic-minor-mode          nil
759
760                 viper-emacs-intercept-minor-mode       nil
761                 viper-emacs-local-user-minor-mode      nil
762                 viper-emacs-kbd-minor-mode             nil
763                 viper-emacs-global-user-minor-mode     nil
764                 viper-emacs-state-modifier-minor-mode  nil
765
766                 viper-current-state                    'emacs-state
767                 viper-mode-string                      viper-emacs-state-id
768                 )
769
770   ;; remove all hooks set by viper
771   (mapatoms 'viper-remove-hooks)
772   (remove-hook 'comint-mode-hook 'viper-comint-mode-hook)
773   (remove-hook 'erc-mode-hook 'viper-comint-mode-hook)
774   (remove-hook 'change-major-mode-hook 'viper-major-mode-change-sentinel)
775
776   ;; unbind Viper mouse bindings
777   (viper-unbind-mouse-search-key)
778   (viper-unbind-mouse-insert-key)
779   ;; In emacs, we have to advice handle-switch-frame
780   ;; This advice is undone earlier, when all advices matching "viper-" are
781   ;; deactivated.
782   (if (featurep 'xemacs)
783       (remove-hook 'mouse-leave-frame-hook 'viper-remember-current-frame))
784   ) ; end viper-go-away
785
786
787 ;; list of buffers that just changed their major mode
788 ;; used in a hack that triggers vi command mode whenever needed
789 (defvar viper-new-major-mode-buffer-list nil)
790
791 ;; set appropriate Viper state in buffers that changed major mode
792 (defun set-viper-state-in-major-mode ()
793   (mapc
794    (lambda (buf)
795      (if (viper-buffer-live-p buf)
796          (with-current-buffer buf
797            (cond ((and (this-major-mode-requires-vi-state major-mode)
798                        (eq viper-current-state 'emacs-state))
799                   (viper-mode))
800                  ((memq major-mode viper-emacs-state-mode-list)
801                   ;; not checking (eq viper-current-state 'emacs-state)
802                   ;; because viper-current-state could have gotten it by
803                   ;; default.  We need viper-change-state-to-emacs here to have
804                   ;; the keymaps take effect.
805                   (viper-change-state-to-emacs))
806                  ((and (memq major-mode viper-insert-state-mode-list)
807                        (not (eq viper-current-state 'insert-state)))
808                   (viper-change-state-to-insert))
809                  )) ; with-current-buffer
810        )) ; function
811    viper-new-major-mode-buffer-list)
812   ;; clear the list of bufs that changed major mode
813   (setq viper-new-major-mode-buffer-list nil)
814   ;; change the global value of hook
815   (remove-hook 'viper-post-command-hooks 'set-viper-state-in-major-mode))
816
817 ;; sets up post-command-hook to turn viper-mode, if the current mode is
818 ;; fundamental
819 (defun viper-major-mode-change-sentinel ()
820   (save-match-data
821     (or (string-match "\*Minibuf-" (buffer-name))
822         (setq viper-new-major-mode-buffer-list
823               (cons (current-buffer) viper-new-major-mode-buffer-list))))
824   ;; change the global value of hook
825   (add-hook 'viper-post-command-hooks 'set-viper-state-in-major-mode t))
826
827
828 ;;; Handling of tty's ESC event
829
830 ;; On a tty, an ESC event can either be the user hitting the escape key, or
831 ;; some element of a byte sequence used to encode for example cursor keys.
832 ;; So we try to recognize those events that correspond to the escape key and
833 ;; turn them into `escape' events (same as used under GUIs).  The heuristic we
834 ;; use to distinguish the two cases is based, as usual, on a timeout, and on
835 ;; the fact that the special ESC=>escape mapping only takes place if the whole
836 ;; last key-sequence so far is just [?\e], i.e. either we're still in
837 ;; read-key-sequence, or the last read-key-sequence only read [?\e], which
838 ;; should ideally never happen because it should have been mapped to [escape].
839
840 (defun viper--tty-ESC-filter (map)
841   (if (and (equal (this-single-command-keys) [?\e])
842            (sit-for (/ viper-fast-keyseq-timeout 1000)))
843       [escape] map))
844
845 (defun viper--lookup-key (map key)
846   "Kind of like `lookup-key'.
847 Two differences:
848 - KEY is a single key, not a sequence.
849 - the result is the \"raw\" binding, so it can be a `menu-item', rather than the
850   binding contained in that menu item."
851   (catch 'found
852     (map-keymap (lambda (k b) (if (equal key k) (throw 'found b))) map)))
853
854 (defun viper-catch-tty-ESC ()
855   "Setup key mappings of current terminal to turn a tty's ESC into `escape'."
856   (when (memq (terminal-live-p (frame-terminal)) '(t pc))
857     (let ((esc-binding (viper-uncatch-tty-ESC)))
858       (define-key input-decode-map
859         [?\e] `(menu-item "" ,esc-binding :filter viper--tty-ESC-filter)))))
860
861 (defun viper-uncatch-tty-ESC ()
862   "Don't hack ESC into `escape' any more."
863   (let ((b (viper--lookup-key input-decode-map ?\e)))
864     (and (eq 'menu-item (car-safe b))
865          (eq 'viper--tty-ESC-filter (nth 4 b))
866          (define-key input-decode-map [?\e] (setq b (nth 2 b))))
867     b))
868
869 (defun viper-setup-ESC-to-escape (enable)
870   (if enable
871       (add-hook 'tty-setup-hook 'viper-catch-tty-ESC)
872     (remove-hook 'tty-setup-hook 'viper-catch-tty-ESC))
873   (let ((seen ()))
874     (dolist (frame (frame-list))
875       (let ((terminal (frame-terminal frame)))
876         (unless (memq terminal seen)
877           (push terminal seen)
878           (with-selected-frame frame
879             (if enable (viper-catch-tty-ESC) (viper-uncatch-tty-ESC))))))))
880
881 ;; This sets major mode hooks to make them come up in vi-state.
882 (defun viper-set-hooks ()
883   ;; It is of course a misnomer to call viper-mode a `major mode'.
884   ;; However, this has the effect that if the user didn't specify the
885   ;; default mode, new buffers that fall back on the default will come up
886   ;; in Fundamental Mode and Vi state.
887   ;; When viper-mode is executed in such a case, it will set the major mode
888   ;; back to fundamental-mode.
889   (if (eq (default-value 'major-mode) 'fundamental-mode)
890       (setq-default major-mode 'viper-mode))
891
892   (viper-setup-ESC-to-escape t)
893
894   (add-hook 'change-major-mode-hook 'viper-major-mode-change-sentinel)
895   (add-hook 'find-file-hooks 'set-viper-state-in-major-mode)
896
897   ;; keep this because many modes we don't know about use this hook
898   (defvar text-mode-hook)
899   (add-hook 'text-mode-hook 'viper-mode)
900
901   (defvar emerge-startup-hook)
902   (add-hook 'emerge-startup-hook 'viper-change-state-to-emacs)
903
904   ;; if viper is started from .emacs, it might be impossible to get certain
905   ;; info about the display and windows until emacs initialization is complete
906   ;; So do it via the window-setup-hook
907   (add-hook 'window-setup-hook
908             (lambda ()
909               (modify-frame-parameters
910                (selected-frame)
911                (list (cons 'viper-vi-state-cursor-color
912                            (viper-get-cursor-color))))
913               (setq viper-vi-state-cursor-color (viper-get-cursor-color))
914               ))
915
916   ;; Tell vc-diff to put *vc* in Vi mode
917   (eval-after-load
918       "vc"
919     '(defadvice vc-diff (after viper-vc-ad activate)
920        "Force Vi state in VC diff buffer."
921        (viper-change-state-to-vi)))
922
923   (eval-after-load
924    "emerge"
925    '(defadvice emerge-quit (after viper-emerge-advice activate)
926       "Run `viper-change-state-to-vi' after quitting emerge."
927       (viper-change-state-to-vi)))
928
929   ;; passwd.el sets up its own buffer, which turns up in Vi mode,
930   ;; thus overriding the local map.  We don't need Vi mode here.
931   (eval-after-load
932    "passwd"
933    '(defadvice read-passwd-1 (before viper-passwd-ad activate)
934       "Switch to Emacs state while reading password."
935       (viper-change-state-to-emacs)))
936
937   (defadvice self-insert-command (around viper-self-insert-ad activate)
938     "Ignore all self-inserting keys in the vi-state."
939     (if (and (eq viper-current-state 'vi-state)
940              ;; Do not use called-interactively-p here. XEmacs does not have it
941              ;; and interactive-p is just fine.
942              ;; (called-interactively-p 'interactive))
943              (interactive-p))
944         (beep 1)
945       ad-do-it
946       ))
947
948   (defadvice set-cursor-color (after viper-set-cursor-color-ad activate)
949     "Change cursor color in VI state."
950     (modify-frame-parameters
951         (selected-frame)
952         (list (cons 'viper-vi-state-cursor-color (ad-get-arg 0))))
953     (setq viper-vi-state-cursor-color (ad-get-arg 0))
954     )
955
956   (when (and (fboundp 'add-to-ordered-list) (boundp 'emulation-mode-map-alists))
957     ;; needs to be as early as possible
958     (add-to-ordered-list
959      'emulation-mode-map-alists 'viper--intercept-key-maps 100)
960     ;; needs to be after cua-mode
961     (add-to-ordered-list 'emulation-mode-map-alists 'viper--key-maps 500)
962     )
963
964   ;; Emacs shell, ange-ftp, and comint-based modes
965   (add-hook 'comint-mode-hook 'viper-comint-mode-hook) ; comint
966   (add-hook 'erc-mode-hook 'viper-comint-mode-hook) ; ERC
967
968   (add-hook 'eshell-mode-hook
969             (lambda () (setq viper-auto-indent nil)))
970
971   (viper-set-emacs-state-searchstyle-macros nil 'dired-mode) ; dired
972   (viper-set-emacs-state-searchstyle-macros nil 'tar-mode) ; tar
973   (viper-set-emacs-state-searchstyle-macros nil 'mh-folder-mode) ; mhe
974   (viper-set-emacs-state-searchstyle-macros nil 'gnus-group-mode) ; gnus
975   (viper-set-emacs-state-searchstyle-macros nil 'gnus-summary-mode)
976   (viper-set-emacs-state-searchstyle-macros nil 'Info-mode) ; info
977   (viper-set-emacs-state-searchstyle-macros nil 'Buffer-menu-mode) ;buffer-menu
978
979   ;; Modify major modes according to viper-major-mode-modifier-list
980   (viper-apply-major-mode-modifiers)
981
982   ;; For RMAIL users.
983   ;; Put buf in Emacs state after edit.
984   (eval-after-load
985    "rmailedit"
986    '(defadvice rmail-cease-edit (after viper-rmail-advice activate)
987       "Switch to Emacs state when done editing message."
988       (viper-change-state-to-emacs)))
989
990   ;; ISO accents
991   ;; Need to do it after loading iso-acc, or else this loading will wipe out
992   ;; the advice.
993   (eval-after-load
994    "iso-acc"
995    '(defadvice iso-accents-mode (around viper-iso-accents-advice activate)
996       "Set viper-automatic-iso-accents to iso-accents-mode."
997       (let ((arg (ad-get-arg 0)))
998         ad-do-it
999         (setq viper-automatic-iso-accents
1000               (if (eq viper-current-state 'vi-state)
1001                   (if arg
1002                       ;; if iso-accents-mode was called with positive arg, turn
1003                       ;; accents on
1004                       (> (prefix-numeric-value arg) 0)
1005                     ;; else: toggle viper-automatic-iso-accents
1006                     (not viper-automatic-iso-accents))
1007                 ;; other states: accept what iso-accents-mode has done
1008                 iso-accents-mode))
1009         ;; turn off ISO accents in vi-state
1010         (if (eq viper-current-state 'vi-state)
1011             (viper-set-iso-accents-mode nil))
1012         (if (memq viper-current-state '(vi-state insert-state replace-state))
1013             (message "Viper ISO accents mode: %s"
1014                      (if viper-automatic-iso-accents "on" "off")))
1015         )))
1016
1017   ;; International input methods
1018   (if (featurep 'emacs)
1019       (eval-after-load "mule-cmds"
1020         '(progn
1021            (defadvice deactivate-input-method (after viper-mule-advice activate)
1022              "Set viper-special-input-method to disable intl. input methods."
1023              (viper-deactivate-input-method-action))
1024            (defadvice activate-input-method (after viper-mule-advice activate)
1025              "Set viper-special-input-method to enable intl. input methods."
1026              (viper-activate-input-method-action))
1027            ))
1028     ;; XEmacs Although these hooks exist in Emacs, they don't seem to be always
1029     ;; called on input-method activation/deactivation, so we the above advise
1030     ;; functions instead.
1031     (eval-after-load "mule-cmds"
1032       '(progn
1033          (add-hook 'input-method-activate-hook
1034                    'viper-activate-input-method-action t)
1035          (add-hook 'input-method-deactivate-hook
1036                    'viper-deactivate-input-method-action t)))
1037     )
1038   (eval-after-load "mule-cmds"
1039     '(defadvice toggle-input-method (around viper-mule-advice activate)
1040        "Adjust input-method toggling in vi-state."
1041        (if (and viper-special-input-method (eq viper-current-state 'vi-state))
1042            (viper-deactivate-input-method)
1043          ad-do-it)))
1044
1045   ) ; viper-set-hooks
1046
1047
1048 ;; these are primarily advices and Vi-ish variable settings
1049 (defun viper-non-hook-settings ()
1050
1051   ;;;; Viper changes the default mode-line-buffer-identification
1052   ;;(setq-default mode-line-buffer-identification '(" %b"))
1053
1054   ;; setup emacs-supported vi-style feel
1055   (setq next-line-add-newlines nil
1056         require-final-newline t)
1057
1058   ;; don't bark when mark is inactive
1059   (if (featurep 'emacs)
1060       (setq mark-even-if-inactive t))
1061
1062   (setq scroll-step 1)
1063
1064   ;; Variable displaying the current Viper state in the mode line.
1065   (or (memq 'viper-mode-string global-mode-string)
1066       (setq global-mode-string
1067             (append '("" viper-mode-string) (cdr global-mode-string))))
1068
1069   (if (featurep 'xemacs)
1070       ;; XEmacs
1071       (defadvice describe-key (before viper-describe-key-ad protect activate)
1072         "Force to read key via `viper-read-key-sequence'."
1073         (interactive (list (viper-read-key-sequence "Describe key: "))))
1074     ;; Emacs
1075     (defadvice describe-key (before viper-describe-key-ad protect activate)
1076       "Force to read key via `viper-read-key-sequence'."
1077       (interactive (let (key)
1078                      (setq key (viper-read-key-sequence
1079                                 "Describe key (or click or menu item): "))
1080                      (list key
1081                            (prefix-numeric-value current-prefix-arg)
1082                            ;; If KEY is a down-event, read also the
1083                            ;; corresponding up-event.
1084                            (and (vectorp key)
1085                                 (let ((last-idx (1- (length key))))
1086                                   (and (eventp (aref key last-idx))
1087                                        (memq 'down (event-modifiers
1088                                                     (aref key last-idx)))))
1089                                 (or (and (eventp (aref key 0))
1090                                          (memq 'down (event-modifiers
1091                                                       (aref key 0)))
1092                                          ;; For the C-down-mouse-2 popup menu,
1093                                          ;; there is no subsequent up-event
1094                                          (= (length key) 1))
1095                                     (and (> (length key) 1)
1096                                          (eventp (aref key 1))
1097                                          (memq 'down (event-modifiers (aref key 1)))))
1098                                 (read-event))))))
1099     ) ; (if (featurep 'xemacs)
1100
1101   (if (featurep 'xemacs)
1102       ;; XEmacs
1103       (defadvice describe-key-briefly
1104         (before viper-describe-key-briefly-ad protect activate)
1105         "Force to read key via `viper-read-key-sequence'."
1106         (interactive (list (viper-read-key-sequence "Describe key briefly: "))))
1107     ;; Emacs
1108     (defadvice describe-key-briefly
1109       (before viper-describe-key-briefly-ad protect activate)
1110       "Force to read key via `viper-read-key-sequence'."
1111       (interactive (let (key)
1112                      (setq key (viper-read-key-sequence
1113                                 "Describe key (or click or menu item): "))
1114                      ;; If KEY is a down-event, read and discard the
1115                      ;; corresponding up-event.
1116                      (and (vectorp key)
1117                           (let ((last-idx (1- (length key))))
1118                             (and (eventp (aref key last-idx))
1119                                  (memq 'down (event-modifiers (aref key last-idx)))))
1120                           (read-event))
1121                      (list key
1122                            (if current-prefix-arg
1123                                (prefix-numeric-value current-prefix-arg))
1124                            1))))
1125     ) ; (if (featurep 'xemacs)
1126
1127   (defadvice find-file (before viper-add-suffix-advice activate)
1128     "Use `read-file-name' for reading arguments."
1129     (interactive (cons (read-file-name "Find file: " nil default-directory)
1130                        ;; XEmacs: if Mule & prefix arg, ask for coding system
1131                        (cond ((and (featurep 'xemacs) (featurep 'mule))
1132                               (list
1133                                (and current-prefix-arg
1134                                     (read-coding-system "Coding-system: "))))
1135                              ;; Emacs: do wildcards
1136                              ((and (featurep 'emacs) (boundp 'find-file-wildcards))
1137                                    (list find-file-wildcards))))
1138                  ))
1139
1140   (defadvice find-file-other-window (before viper-add-suffix-advice activate)
1141     "Use `read-file-name' for reading arguments."
1142     (interactive (cons (read-file-name "Find file in other window: "
1143                                        nil default-directory)
1144                        ;; XEmacs: if Mule & prefix arg, ask for coding system
1145                        (cond ((and (featurep 'xemacs) (featurep 'mule))
1146                               (list
1147                                (and current-prefix-arg
1148                                     (read-coding-system "Coding-system: "))))
1149                              ;; Emacs: do wildcards
1150                              ((and (featurep 'emacs) (boundp 'find-file-wildcards))
1151                               (list find-file-wildcards))))
1152                  ))
1153
1154
1155   (defadvice find-file-other-frame (before viper-add-suffix-advice activate)
1156     "Use `read-file-name' for reading arguments."
1157     (interactive (cons (read-file-name "Find file in other frame: "
1158                                        nil default-directory)
1159                        ;; XEmacs: if Mule & prefix arg, ask for coding system
1160                        (cond ((and (featurep 'xemacs) (featurep 'mule))
1161                               (list
1162                                (and current-prefix-arg
1163                                     (read-coding-system "Coding-system: "))))
1164                              ;; Emacs: do wildcards
1165                              ((and (featurep 'emacs) (boundp 'find-file-wildcards))
1166                               (list find-file-wildcards))))
1167                  ))
1168
1169
1170   (defadvice read-file-name (around viper-suffix-advice activate)
1171     "Tell `exit-minibuffer' to run `viper-file-add-suffix' as a hook."
1172     (let ((viper-minibuffer-exit-hook
1173            (append viper-minibuffer-exit-hook
1174                    '(viper-minibuffer-trim-tail viper-file-add-suffix))))
1175       ad-do-it))
1176
1177   (defadvice start-kbd-macro (after viper-kbd-advice activate)
1178     "Remove Viper's intercepting bindings for C-x ).
1179   This may be needed if the previous `:map' command terminated abnormally."
1180     (define-key viper-vi-intercept-map "\C-x)" nil)
1181     (define-key viper-insert-intercept-map "\C-x)" nil)
1182     (define-key viper-emacs-intercept-map "\C-x)" nil))
1183
1184   (defadvice add-minor-mode (after
1185                              viper-advice-add-minor-mode
1186                              (toggle name &optional keymap after toggle-fun)
1187                              activate)
1188     "Run viper-normalize-minor-mode-map-alist after adding a minor mode."
1189     (viper-normalize-minor-mode-map-alist)
1190     (unless
1191         (and (fboundp 'add-to-ordered-list) (boundp 'emulation-mode-map-alists))
1192       (setq-default minor-mode-map-alist minor-mode-map-alist)))
1193
1194   ;; catch frame switching event
1195   (if (viper-window-display-p)
1196       (if (featurep 'xemacs)
1197              (add-hook 'mouse-leave-frame-hook
1198                        'viper-remember-current-frame)
1199            (defadvice handle-switch-frame (before viper-frame-advice activate)
1200              "Remember the selected frame before the switch-frame event."
1201              (viper-remember-current-frame (selected-frame)))) )
1202
1203   ) ; end viper-non-hook-settings
1204
1205
1206 \f
1207 ;; Ask only if this-command/last-command are nil, i.e., when loading
1208 (cond ((and (eq viper-mode 'ask) (null this-command) (null last-command))
1209        (save-window-excursion
1210          (with-output-to-temp-buffer " *viper-info*"
1211            (princ "
1212 You have loaded Viper, and are about to Viperize your Emacs!
1213
1214 Viper is a Package for Emacs Rebels and a venomous VI PERil,
1215
1216 It's time to decide: to Viperize or not to Viperize...
1217
1218 If you wish to Viperize AND make this your way of life, please put
1219
1220         (setq viper-mode t)
1221         (require 'viper)
1222
1223 in your init file (preferably, close to the top).
1224 These two lines must come in the order given."))
1225          (if (y-or-n-p "Viperize? ")
1226              (setq viper-mode t)
1227            (setq viper-mode nil))
1228          (message "")
1229          (kill-buffer " *viper-info*")))
1230
1231       ;; If viper-mode is t, then just continue.  Viper will kick in.
1232       ((eq viper-mode t))
1233       ;; Otherwise, it was asking Viper was not loaded through .emacs
1234       ;; In this case, it was either through M-x viper-mode or via something
1235       ;; else, like the custom widget.  If Viper was loaded through
1236       ;; M-x viper-mode, then viper will kick in anyway.
1237       (t (setq viper-mode nil)))
1238
1239 (defun viper-load-custom-file ()
1240   (if (and (file-exists-p viper-custom-file-name)
1241            (not noninteractive))
1242       (load viper-custom-file-name)))
1243
1244
1245
1246 \f
1247
1248
1249 ;; save non-viper vars that Viper might change
1250 (if (null viper-saved-non-viper-variables)
1251     (setq viper-saved-non-viper-variables
1252           (list
1253            (cons 'default-major-mode (list (default-value 'major-mode)))
1254            (cons 'next-line-add-newlines (list next-line-add-newlines))
1255            (cons 'require-final-newline (list require-final-newline))
1256            (cons 'scroll-step (list scroll-step))
1257            (cons 'mode-line-buffer-identification
1258                  (list (default-value 'mode-line-buffer-identification)))
1259            (cons 'global-mode-string (list global-mode-string))
1260            (if (featurep 'emacs)
1261                (cons 'mark-even-if-inactive (list mark-even-if-inactive)))
1262            )))
1263
1264
1265 ;; Set some useful macros, advices
1266 ;; These must be BEFORE viper-custom-file-name is loaded,
1267 ;; so the user can unrecord them in viper-custom-file-name.
1268 (if viper-mode
1269     (progn
1270       ;; set advices and some variables that give emacs Vi look.
1271       (viper-non-hook-settings)
1272
1273       ;; repeat the 2nd previous command without rotating the command history
1274       (viper-record-kbd-macro
1275        (vector viper-repeat-from-history-key '\1) 'vi-state
1276        [(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)
1277       ;; repeat the 3d previous command without rotating the command history
1278       (viper-record-kbd-macro
1279        (vector viper-repeat-from-history-key '\2) 'vi-state
1280        [(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)
1281
1282       ;; set macros for toggling case sensitivity and regexp search
1283       (viper-set-searchstyle-toggling-macros nil)
1284       ;; Make %%% toggle parsing comments for matching parentheses
1285       (viper-set-parsing-style-toggling-macro nil)
1286
1287       ;; viper-custom-file-name is loaded if exists
1288       (viper-load-custom-file)
1289
1290       ;; should be after loading custom file to avoid the pesky msg that
1291       ;; mouse-search/insert keys are already bound
1292       (viper-bind-mouse-search-key)
1293       (viper-bind-mouse-insert-key)
1294       ))
1295
1296
1297 \f
1298 ;; Applying Viper customization -- runs after (load viper-custom-file-name)
1299
1300 ;; Save user settings or Viper defaults for vars controlled by
1301 ;; viper-expert-level
1302 (if (null viper-saved-user-settings)
1303     (setq viper-saved-user-settings
1304           (list (cons 'viper-want-ctl-h-help (list viper-want-ctl-h-help))
1305                 (cons 'viper-always (list viper-always))
1306                 (cons 'viper-no-multiple-ESC (list viper-no-multiple-ESC))
1307                 (cons 'viper-ex-style-motion (list viper-ex-style-motion))
1308                 (cons 'viper-ex-style-editing
1309                       (list viper-ex-style-editing))
1310                 (cons 'viper-want-emacs-keys-in-vi
1311                       (list viper-want-emacs-keys-in-vi))
1312                 (cons 'viper-electric-mode (list viper-electric-mode))
1313                 (cons 'viper-want-emacs-keys-in-insert
1314                       (list viper-want-emacs-keys-in-insert))
1315                 (cons 'viper-re-search (list viper-re-search)))))
1316
1317
1318 (if viper-mode
1319     (progn
1320       (viper-set-minibuffer-style)
1321       (if viper-buffer-search-char
1322           (viper-buffer-search-enable))
1323       (viper-update-syntax-classes 'set-default)
1324       ))
1325
1326 \f
1327 ;;; Familiarize Viper with some minor modes that have their own keymaps
1328 (if viper-mode
1329     (progn
1330       (viper-harness-minor-mode "compile")
1331       (viper-harness-minor-mode "outline")
1332       (viper-harness-minor-mode "allout")
1333       (viper-harness-minor-mode "xref")
1334       (viper-harness-minor-mode "lmenu")
1335       (viper-harness-minor-mode "vc")
1336       (viper-harness-minor-mode "ltx-math") ; LaTeX-math-mode in AUC-TeX, which
1337       (viper-harness-minor-mode "latex")    ; sits in one of these two files
1338       (viper-harness-minor-mode "cyrillic")
1339       (viper-harness-minor-mode "russian")
1340       (viper-harness-minor-mode "view-less")
1341       (viper-harness-minor-mode "view")
1342       (viper-harness-minor-mode "reftex")
1343       (viper-harness-minor-mode "flyspell")
1344       ))
1345
1346
1347 ;; Intercept maps could go in viper-keym.el
1348 ;; We keep them here in case someone redefines them in viper-custom-file-name
1349
1350 (define-key viper-vi-intercept-map viper-ESC-key 'viper-intercept-ESC-key)
1351 (define-key viper-insert-intercept-map viper-ESC-key 'viper-intercept-ESC-key)
1352
1353 ;; This is taken care of by viper-insert-global-user-map.
1354 ;;(define-key viper-replace-map viper-ESC-key 'viper-intercept-ESC-key)
1355
1356
1357 ;; The default viper-toggle-key is \C-z; for the novice, it suspends or
1358 ;; iconifies Emacs
1359 (define-key viper-vi-intercept-map viper-toggle-key 'viper-toggle-key-action)
1360 (define-key
1361   viper-emacs-intercept-map viper-toggle-key 'viper-change-state-to-vi)
1362
1363 ;;; Removed to avoid bad interaction with cua-mode.
1364 ;;; Escape from Emacs and Insert modes to Vi for one command
1365 ;;(define-key viper-emacs-intercept-map "\C-c\\" 'viper-escape-to-vi)
1366 ;;(define-key viper-insert-intercept-map "\C-c\\" 'viper-escape-to-vi)
1367
1368 (if viper-mode
1369     (setq-default viper-emacs-intercept-minor-mode t
1370                   viper-emacs-local-user-minor-mode t
1371                   viper-emacs-global-user-minor-mode t
1372                   viper-emacs-kbd-minor-mode t
1373                   viper-emacs-state-modifier-minor-mode t))
1374 (if (and viper-mode (eq viper-current-state 'emacs-state))
1375     (setq viper-emacs-intercept-minor-mode t
1376           viper-emacs-local-user-minor-mode t
1377           viper-emacs-global-user-minor-mode t
1378           viper-emacs-kbd-minor-mode t
1379           viper-emacs-state-modifier-minor-mode t))
1380
1381
1382 (if (and viper-mode
1383          (or viper-always
1384              (and (< viper-expert-level 5) (> viper-expert-level 0))))
1385     (viper-set-hooks))
1386
1387 ;; Let all minor modes take effect after loading.
1388 ;; This may not be enough, so we also set default minor-mode-alist.
1389 ;; Without setting the default, new buffers that come up in emacs mode have
1390 ;; minor-mode-map-alist = nil, unless we call viper-change-state-*
1391 (if (and viper-mode (eq viper-current-state 'emacs-state))
1392     (progn
1393       (viper-change-state-to-emacs)
1394       (unless
1395           (and (fboundp 'add-to-ordered-list)
1396                (boundp 'emulation-mode-map-alists))
1397         (setq-default minor-mode-map-alist minor-mode-map-alist))
1398       ))
1399
1400 (if (and viper-mode (this-major-mode-requires-vi-state major-mode))
1401     (viper-mode))
1402
1403 (if viper-mode
1404     (setq initial-major-mode
1405           `(lambda ()
1406              (funcall (quote ,initial-major-mode))
1407              (set-viper-state-in-major-mode))
1408           ))
1409
1410
1411
1412 (run-hooks 'viper-load-hook) ; the last chance to change something
1413
1414 (provide 'viper)
1415
1416
1417 ;; Local Variables:
1418 ;; eval: (put 'viper-deflocalvar 'lisp-indent-hook 'defun)
1419 ;; End:
1420
1421 ;;; viper.el ends here