* lisp/emacs-lisp/macroexp.el (macroexpand-1): New function.
[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           ;; FIXME: Don't reload!
535           (load-library "viper"))
536
537         (if viper-first-time ; Important check.  Prevents mix-up of startup
538             (progn           ; and expert-level msgs when viper-mode recurses
539               (setq viper-first-time nil)
540               (if (not viper-inhibit-startup-message)
541                   (save-window-excursion
542                     (setq viper-inhibit-startup-message t)
543                     (delete-other-windows)
544                     (switch-to-buffer "Viper Startup Message")
545                     (erase-buffer)
546                     (insert
547                      (substitute-command-keys
548                       "Viper Is a Package for Emacs Rebels,
549 a VI Plan for Emacs Rescue, and a venomous VI PERil.
550
551 Incidentally, Viper emulates Vi under Emacs/XEmacs 20.
552 It supports all of what is good in Vi and Ex, while extending
553 and improving upon much of it.
554
555    1. Viper supports Vi at several levels.  Level 1 is the closest to Vi,
556       level 5 provides the most flexibility to depart from many Vi conventions.
557
558       You will be asked to specify your user level in a following screen.
559
560       If you select user level 1 then the keys ^X, ^C, ^Z, and ^G will behave
561       as in VI, to smooth transition to Viper for the beginners.  However, to
562       use Emacs productively, you are advised to reach user level 3 or higher.
563
564       At user level 2 or higher, ^X and ^C have Emacs, not Vi, bindings;
565       ^Z toggles Vi/Emacs states; ^G is Emacs's keyboard-quit (like ^C in Vi).
566
567    2. Vi exit functions (e.g., :wq, ZZ) work on INDIVIDUAL files -- they
568       do not cause Emacs to quit, except at user level 1 (for a novice).
569    3. ^X^C EXITS EMACS.
570    4. Viper supports multiple undo: `u' will undo.  Typing `.' will repeat
571       undo.  Another `u' changes direction.
572
573    6. Emacs Meta key is `C-\\' (in all modes) or `\\ ESC' (in Vi command mode).
574       On a window system, the best way is to use the Meta-key on your keyboard.
575    7. Try \\[keyboard-quit] and \\[abort-recursive-edit] repeatedly,if
576       something funny happens.  This would abort the current editing command.
577
578 For more information on Viper:
579
580    a. Type `:help' in Vi command mode
581    b. Print Viper manual, found in ./etc/viper.dvi
582    c. Print the Quick Reference, found in ./etc/viperCard.dvi
583
584 To submit a bug report or to contact the author, type :submitReport in Vi
585 command mode.  To shoo Viper away and return to pure Emacs (horror!), type:
586
587    M-x viper-go-away
588
589 This startup message appears whenever you load Viper, unless you type `y' now."
590                       ))
591                     (goto-char (point-min))
592                     (if (y-or-n-p "Inhibit Viper startup message? ")
593                         (viper-save-setting
594                          'viper-inhibit-startup-message
595                          "Viper startup message inhibited"
596                          viper-custom-file-name t))
597                     ;;(kill-buffer (current-buffer))
598                     (message
599                      "The last message is in buffer `Viper Startup Message'")
600                     (sit-for 4)
601                     ))
602               (viper-set-expert-level 'dont-change-unless)))
603
604         (or (memq major-mode viper-emacs-state-mode-list) ; don't switch to Vi
605             (memq major-mode viper-insert-state-mode-list) ; don't switch
606             (viper-change-state-to-vi))
607         ))
608
609   (if (eq major-mode 'viper-mode)
610       (setq major-mode 'fundamental-mode))
611   )
612
613
614 ;; Apply a little heuristic to invoke vi state on major-modes
615 ;; that are not listed in viper-vi-state-mode-list
616 (defun this-major-mode-requires-vi-state (mode)
617   (cond ((memq mode viper-vi-state-mode-list) t)
618         ((memq mode viper-emacs-state-mode-list) nil)
619         ((memq mode viper-insert-state-mode-list) nil)
620         (t (and (eq (key-binding "a") 'self-insert-command)
621                 (eq (key-binding " ") 'self-insert-command)))))
622
623 \f
624 ;; This hook designed to enable Vi-style editing in comint-based modes."
625 (defun viper-comint-mode-hook ()
626   (set (make-local-variable 'require-final-newline) nil)
627   (setq viper-ex-style-editing nil
628         viper-ex-style-motion nil)
629   (viper-change-state-to-insert))
630
631
632 ;; remove viper hooks from SYMBOL
633 (defun viper-remove-hooks (symbol)
634   (cond ((not (boundp symbol)) nil)
635         ((not (listp (eval symbol))) nil)
636         ((string-match "-hook" (symbol-name symbol))
637          (remove-hook symbol 'viper-mode)
638          (remove-hook symbol 'viper-change-state-to-emacs)
639          (remove-hook symbol 'viper-change-state-to-insert)
640          (remove-hook symbol 'viper-change-state-to-vi)
641          (remove-hook symbol 'viper-minibuffer-post-command-hook)
642          (remove-hook symbol 'viper-minibuffer-setup-sentinel)
643          (remove-hook symbol 'viper-major-mode-change-sentinel)
644          (remove-hook symbol 'set-viper-state-in-major-mode)
645          (remove-hook symbol 'viper-post-command-sentinel)
646          )))
647
648 ;; Remove local value in all existing buffers
649 ;; This doesn't delocalize vars (which would have been desirable)
650 (defun viper-delocalize-var (symbol)
651   (dolist (buf (buffer-list))
652     (with-current-buffer buf
653       (kill-local-variable symbol))))
654
655
656 (defun viper-go-away ()
657   "De-Viperize Emacs.
658 This function tries to do as good a job as possible.  However, it may undo some
659 user customization, unrelated to Viper.  For instance, if the user advised
660 `read-file-name', `describe-key', and some others, then this advice will be
661 undone.
662 It also can't undo some Viper settings."
663   (interactive)
664   (viper-setup-ESC-to-escape nil)
665   ;; restore non-viper vars
666   (setq-default
667    next-line-add-newlines
668    (viper-standard-value
669     'next-line-add-newlines viper-saved-non-viper-variables)
670    require-final-newline
671    (viper-standard-value
672     'require-final-newline viper-saved-non-viper-variables)
673    scroll-step
674    (viper-standard-value 'scroll-step viper-saved-non-viper-variables)
675    mode-line-buffer-identification
676    (viper-standard-value
677     'mode-line-buffer-identification viper-saved-non-viper-variables)
678    global-mode-string
679    (delq 'viper-mode-string global-mode-string))
680
681   (setq-default major-mode
682                 (viper-standard-value 'default-major-mode
683                                       viper-saved-non-viper-variables))
684
685   (if (featurep 'emacs)
686       (setq-default
687        mark-even-if-inactive
688        (viper-standard-value
689         'mark-even-if-inactive viper-saved-non-viper-variables)))
690
691   ;; Ideally, we would like to be able to de-localize local variables
692   (unless
693       (and (fboundp 'add-to-ordered-list) (boundp 'emulation-mode-map-alists))
694     (viper-delocalize-var 'minor-mode-map-alist))
695   (viper-delocalize-var 'require-final-newline)
696   (if (featurep 'xemacs) (viper-delocalize-var 'bar-cursor))
697
698
699   ;; deactivate all advices done by Viper.
700   (ad-deactivate-regexp "viper-")
701
702   (setq viper-mode nil)
703
704   (when (and (fboundp 'add-to-ordered-list) (boundp 'emulation-mode-map-alists))
705     (setq emulation-mode-map-alists
706           (delq 'viper--intercept-key-maps
707                 (delq 'viper--key-maps emulation-mode-map-alists))
708           ))
709
710   (viper-delocalize-var 'viper-vi-minibuffer-minor-mode)
711   (viper-delocalize-var 'viper-insert-minibuffer-minor-mode)
712   (viper-delocalize-var 'viper-vi-intercept-minor-mode)
713   (viper-delocalize-var 'viper-insert-intercept-minor-mode)
714
715   (viper-delocalize-var 'viper-vi-local-user-minor-mode)
716   (viper-delocalize-var 'viper-vi-kbd-minor-mode)
717   (viper-delocalize-var 'viper-vi-global-user-minor-mode)
718   (viper-delocalize-var 'viper-vi-state-modifier-minor-mode)
719   (viper-delocalize-var 'viper-vi-diehard-minor-mode)
720   (viper-delocalize-var 'viper-vi-basic-minor-mode)
721
722   (viper-delocalize-var 'viper-replace-minor-mode)
723
724   (viper-delocalize-var 'viper-insert-local-user-minor-mode)
725   (viper-delocalize-var 'viper-insert-kbd-minor-mode)
726   (viper-delocalize-var 'viper-insert-global-user-minor-mode)
727   (viper-delocalize-var 'viper-insert-state-modifier-minor-mode)
728   (viper-delocalize-var 'viper-insert-diehard-minor-mode)
729   (viper-delocalize-var 'viper-insert-basic-minor-mode)
730
731   (viper-delocalize-var 'viper-emacs-intercept-minor-mode)
732   (viper-delocalize-var 'viper-emacs-local-user-minor-mode)
733   (viper-delocalize-var 'viper-emacs-kbd-minor-mode)
734   (viper-delocalize-var 'viper-emacs-global-user-minor-mode)
735   (viper-delocalize-var 'viper-emacs-state-modifier-minor-mode)
736
737   (viper-delocalize-var 'viper-current-state)
738   (viper-delocalize-var 'viper-mode-string)
739
740   (setq-default viper-vi-minibuffer-minor-mode         nil
741                 viper-insert-minibuffer-minor-mode     nil
742                 viper-vi-intercept-minor-mode          nil
743                 viper-insert-intercept-minor-mode      nil
744
745                 viper-vi-local-user-minor-mode         nil
746                 viper-vi-kbd-minor-mode                nil
747                 viper-vi-global-user-minor-mode        nil
748                 viper-vi-state-modifier-minor-mode     nil
749                 viper-vi-diehard-minor-mode            nil
750                 viper-vi-basic-minor-mode              nil
751
752                 viper-replace-minor-mode               nil
753
754                 viper-insert-local-user-minor-mode     nil
755                 viper-insert-kbd-minor-mode            nil
756                 viper-insert-global-user-minor-mode    nil
757                 viper-insert-state-modifier-minor-mode nil
758                 viper-insert-diehard-minor-mode        nil
759                 viper-insert-basic-minor-mode          nil
760
761                 viper-emacs-intercept-minor-mode       nil
762                 viper-emacs-local-user-minor-mode      nil
763                 viper-emacs-kbd-minor-mode             nil
764                 viper-emacs-global-user-minor-mode     nil
765                 viper-emacs-state-modifier-minor-mode  nil
766
767                 viper-current-state                    'emacs-state
768                 viper-mode-string                      viper-emacs-state-id
769                 )
770
771   ;; remove all hooks set by viper
772   (mapatoms 'viper-remove-hooks)
773   (remove-hook 'comint-mode-hook 'viper-comint-mode-hook)
774   (remove-hook 'erc-mode-hook 'viper-comint-mode-hook)
775   (remove-hook 'change-major-mode-hook 'viper-major-mode-change-sentinel)
776
777   ;; unbind Viper mouse bindings
778   (viper-unbind-mouse-search-key)
779   (viper-unbind-mouse-insert-key)
780   ;; In emacs, we have to advice handle-switch-frame
781   ;; This advice is undone earlier, when all advices matching "viper-" are
782   ;; deactivated.
783   (if (featurep 'xemacs)
784       (remove-hook 'mouse-leave-frame-hook 'viper-remember-current-frame))
785   ) ; end viper-go-away
786
787
788 ;; list of buffers that just changed their major mode
789 ;; used in a hack that triggers vi command mode whenever needed
790 (defvar viper-new-major-mode-buffer-list nil)
791
792 ;; set appropriate Viper state in buffers that changed major mode
793 (defun set-viper-state-in-major-mode ()
794   (mapc
795    (lambda (buf)
796      (if (viper-buffer-live-p buf)
797          (with-current-buffer buf
798            (cond ((and (this-major-mode-requires-vi-state major-mode)
799                        (eq viper-current-state 'emacs-state))
800                   (viper-mode))
801                  ((memq major-mode viper-emacs-state-mode-list)
802                   ;; not checking (eq viper-current-state 'emacs-state)
803                   ;; because viper-current-state could have gotten it by
804                   ;; default.  We need viper-change-state-to-emacs here to have
805                   ;; the keymaps take effect.
806                   (viper-change-state-to-emacs))
807                  ((and (memq major-mode viper-insert-state-mode-list)
808                        (not (eq viper-current-state 'insert-state)))
809                   (viper-change-state-to-insert))
810                  )) ; with-current-buffer
811        )) ; function
812    viper-new-major-mode-buffer-list)
813   ;; clear the list of bufs that changed major mode
814   (setq viper-new-major-mode-buffer-list nil)
815   ;; change the global value of hook
816   (remove-hook 'viper-post-command-hooks 'set-viper-state-in-major-mode))
817
818 ;; sets up post-command-hook to turn viper-mode, if the current mode is
819 ;; fundamental
820 (defun viper-major-mode-change-sentinel ()
821   (save-match-data
822     (or (string-match "\*Minibuf-" (buffer-name))
823         (setq viper-new-major-mode-buffer-list
824               (cons (current-buffer) viper-new-major-mode-buffer-list))))
825   ;; change the global value of hook
826   (add-hook 'viper-post-command-hooks 'set-viper-state-in-major-mode t))
827
828
829 ;;; Handling of tty's ESC event
830
831 ;; On a tty, an ESC event can either be the user hitting the escape key, or
832 ;; some element of a byte sequence used to encode for example cursor keys.
833 ;; So we try to recognize those events that correspond to the escape key and
834 ;; turn them into `escape' events (same as used under GUIs).  The heuristic we
835 ;; use to distinguish the two cases is based, as usual, on a timeout, and on
836 ;; the fact that the special ESC=>escape mapping only takes place if the whole
837 ;; last key-sequence so far is just [?\e], i.e. either we're still in
838 ;; read-key-sequence, or the last read-key-sequence only read [?\e], which
839 ;; should ideally never happen because it should have been mapped to [escape].
840
841 (defun viper--tty-ESC-filter (map)
842   (if (and (equal (this-single-command-keys) [?\e])
843            (sit-for (/ viper-fast-keyseq-timeout 1000)))
844       [escape] map))
845
846 (defun viper--lookup-key (map key)
847   "Kind of like `lookup-key'.
848 Two differences:
849 - KEY is a single key, not a sequence.
850 - the result is the \"raw\" binding, so it can be a `menu-item', rather than the
851   binding contained in that menu item."
852   (catch 'found
853     (map-keymap (lambda (k b) (if (equal key k) (throw 'found b))) map)))
854
855 (defun viper-catch-tty-ESC ()
856   "Setup key mappings of current terminal to turn a tty's ESC into `escape'."
857   (when (memq (terminal-live-p (frame-terminal)) '(t pc))
858     (let ((esc-binding (viper-uncatch-tty-ESC)))
859       (define-key input-decode-map
860         [?\e] `(menu-item "" ,esc-binding :filter viper--tty-ESC-filter)))))
861
862 (defun viper-uncatch-tty-ESC ()
863   "Don't hack ESC into `escape' any more."
864   (let ((b (viper--lookup-key input-decode-map ?\e)))
865     (and (eq 'menu-item (car-safe b))
866          (eq 'viper--tty-ESC-filter (nth 4 b))
867          (define-key input-decode-map [?\e] (setq b (nth 2 b))))
868     b))
869
870 (defun viper-setup-ESC-to-escape (enable)
871   (if enable
872       (add-hook 'tty-setup-hook 'viper-catch-tty-ESC)
873     (remove-hook 'tty-setup-hook 'viper-catch-tty-ESC))
874   (let ((seen ()))
875     (dolist (frame (frame-list))
876       (let ((terminal (frame-terminal frame)))
877         (unless (memq terminal seen)
878           (push terminal seen)
879           (with-selected-frame frame
880             (if enable (viper-catch-tty-ESC) (viper-uncatch-tty-ESC))))))))
881
882 ;; This sets major mode hooks to make them come up in vi-state.
883 (defun viper-set-hooks ()
884   ;; It is of course a misnomer to call viper-mode a `major mode'.
885   ;; However, this has the effect that if the user didn't specify the
886   ;; default mode, new buffers that fall back on the default will come up
887   ;; in Fundamental Mode and Vi state.
888   ;; When viper-mode is executed in such a case, it will set the major mode
889   ;; back to fundamental-mode.
890   (if (eq (default-value 'major-mode) 'fundamental-mode)
891       ;; FIXME: We should use after-change-major-mode-hook instead!
892       (setq-default major-mode 'viper-mode))
893
894   (viper-setup-ESC-to-escape t)
895
896   (add-hook 'change-major-mode-hook 'viper-major-mode-change-sentinel)
897   (add-hook 'find-file-hooks 'set-viper-state-in-major-mode)
898
899   ;; keep this because many modes we don't know about use this hook
900   (defvar text-mode-hook)
901   (add-hook 'text-mode-hook 'viper-mode)
902
903   (defvar emerge-startup-hook)
904   (add-hook 'emerge-startup-hook 'viper-change-state-to-emacs)
905
906   ;; if viper is started from .emacs, it might be impossible to get certain
907   ;; info about the display and windows until emacs initialization is complete
908   ;; So do it via the window-setup-hook
909   (add-hook 'window-setup-hook
910             (lambda ()
911               (modify-frame-parameters
912                (selected-frame)
913                (list (cons 'viper-vi-state-cursor-color
914                            (viper-get-cursor-color))))
915               (setq viper-vi-state-cursor-color (viper-get-cursor-color))
916               ))
917
918   ;; Tell vc-diff to put *vc* in Vi mode
919   (eval-after-load
920       "vc"
921     '(defadvice vc-diff (after viper-vc-ad activate)
922        "Force Vi state in VC diff buffer."
923        (viper-change-state-to-vi)))
924
925   (eval-after-load
926    "emerge"
927    '(defadvice emerge-quit (after viper-emerge-advice activate)
928       "Run `viper-change-state-to-vi' after quitting emerge."
929       (viper-change-state-to-vi)))
930
931   ;; passwd.el sets up its own buffer, which turns up in Vi mode,
932   ;; thus overriding the local map.  We don't need Vi mode here.
933   (eval-after-load
934    "passwd"
935    '(defadvice read-passwd-1 (before viper-passwd-ad activate)
936       "Switch to Emacs state while reading password."
937       (viper-change-state-to-emacs)))
938
939   (defadvice self-insert-command (around viper-self-insert-ad activate)
940     "Ignore all self-inserting keys in the vi-state."
941     ;; FIXME: Use remapping?
942     (if (and (eq viper-current-state 'vi-state)
943              ;; Do not use called-interactively-p here. XEmacs does not have it
944              ;; and interactive-p is just fine.
945              ;; (called-interactively-p 'interactive))
946              (interactive-p))
947         (beep 1)
948       ad-do-it
949       ))
950
951   (defadvice set-cursor-color (after viper-set-cursor-color-ad activate)
952     "Change cursor color in VI state."
953     (modify-frame-parameters
954         (selected-frame)
955         (list (cons 'viper-vi-state-cursor-color (ad-get-arg 0))))
956     (setq viper-vi-state-cursor-color (ad-get-arg 0))
957     )
958
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)
965     )
966
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
970
971   (add-hook 'eshell-mode-hook
972             (lambda () (setq viper-auto-indent nil)))
973
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
981
982   ;; Modify major modes according to viper-major-mode-modifier-list
983   (viper-apply-major-mode-modifiers)
984
985   ;; For RMAIL users.
986   ;; Put buf in Emacs state after edit.
987   (eval-after-load
988    "rmailedit"
989    '(defadvice rmail-cease-edit (after viper-rmail-advice activate)
990       "Switch to Emacs state when done editing message."
991       (viper-change-state-to-emacs)))
992
993   ;; ISO accents
994   ;; Need to do it after loading iso-acc, or else this loading will wipe out
995   ;; the advice.
996   (eval-after-load
997    "iso-acc"
998    '(defadvice iso-accents-mode (around viper-iso-accents-advice activate)
999       "Set viper-automatic-iso-accents to iso-accents-mode."
1000       (let ((arg (ad-get-arg 0)))
1001         ad-do-it
1002         (setq viper-automatic-iso-accents
1003               (if (eq viper-current-state 'vi-state)
1004                   (if arg
1005                       ;; if iso-accents-mode was called with positive arg, turn
1006                       ;; accents on
1007                       (> (prefix-numeric-value arg) 0)
1008                     ;; else: toggle viper-automatic-iso-accents
1009                     (not viper-automatic-iso-accents))
1010                 ;; other states: accept what iso-accents-mode has done
1011                 iso-accents-mode))
1012         ;; turn off ISO accents in vi-state
1013         (if (eq viper-current-state 'vi-state)
1014             (viper-set-iso-accents-mode nil))
1015         (if (memq viper-current-state '(vi-state insert-state replace-state))
1016             (message "Viper ISO accents mode: %s"
1017                      (if viper-automatic-iso-accents "on" "off")))
1018         )))
1019
1020   ;; International input methods
1021   (if (featurep 'emacs)
1022       (eval-after-load "mule-cmds"
1023         '(progn
1024            (defadvice deactivate-input-method (after viper-mule-advice activate)
1025              "Set viper-special-input-method to disable intl. input methods."
1026              (viper-deactivate-input-method-action))
1027            (defadvice activate-input-method (after viper-mule-advice activate)
1028              "Set viper-special-input-method to enable intl. input methods."
1029              (viper-activate-input-method-action))
1030            ))
1031     ;; XEmacs Although these hooks exist in Emacs, they don't seem to be always
1032     ;; called on input-method activation/deactivation, so we the above advise
1033     ;; functions instead.
1034     (eval-after-load "mule-cmds"
1035       '(progn
1036          (add-hook 'input-method-activate-hook
1037                    'viper-activate-input-method-action t)
1038          (add-hook 'input-method-deactivate-hook
1039                    'viper-deactivate-input-method-action t)))
1040     )
1041   (eval-after-load "mule-cmds"
1042     '(defadvice toggle-input-method (around viper-mule-advice activate)
1043        "Adjust input-method toggling in vi-state."
1044        (if (and viper-special-input-method (eq viper-current-state 'vi-state))
1045            (viper-deactivate-input-method)
1046          ad-do-it)))
1047
1048   ) ; viper-set-hooks
1049
1050
1051 ;; these are primarily advices and Vi-ish variable settings
1052 (defun viper-non-hook-settings ()
1053
1054   ;;;; Viper changes the default mode-line-buffer-identification
1055   ;;(setq-default mode-line-buffer-identification '(" %b"))
1056
1057   ;; setup emacs-supported vi-style feel
1058   (setq next-line-add-newlines nil
1059         require-final-newline t)
1060
1061   ;; don't bark when mark is inactive
1062   (if (featurep 'emacs)
1063       (setq mark-even-if-inactive t))
1064
1065   (setq scroll-step 1)
1066
1067   ;; Variable displaying the current Viper state in the mode line.
1068   (or (memq 'viper-mode-string global-mode-string)
1069       (setq global-mode-string
1070             (append '("" viper-mode-string) (cdr global-mode-string))))
1071
1072   (if (featurep 'xemacs)
1073       ;; XEmacs
1074       (defadvice describe-key (before viper-describe-key-ad protect activate)
1075         "Force to read key via `viper-read-key-sequence'."
1076         (interactive (list (viper-read-key-sequence "Describe key: "))))
1077     ;; Emacs
1078     (defadvice describe-key (before viper-describe-key-ad protect activate)
1079       "Force to read key via `viper-read-key-sequence'."
1080       (interactive (let (key)
1081                      (setq key (viper-read-key-sequence
1082                                 "Describe key (or click or menu item): "))
1083                      (list key
1084                            (prefix-numeric-value current-prefix-arg)
1085                            ;; If KEY is a down-event, read also the
1086                            ;; corresponding up-event.
1087                            (and (vectorp key)
1088                                 (let ((last-idx (1- (length key))))
1089                                   (and (eventp (aref key last-idx))
1090                                        (memq 'down (event-modifiers
1091                                                     (aref key last-idx)))))
1092                                 (or (and (eventp (aref key 0))
1093                                          (memq 'down (event-modifiers
1094                                                       (aref key 0)))
1095                                          ;; For the C-down-mouse-2 popup menu,
1096                                          ;; there is no subsequent up-event
1097                                          (= (length key) 1))
1098                                     (and (> (length key) 1)
1099                                          (eventp (aref key 1))
1100                                          (memq 'down (event-modifiers (aref key 1)))))
1101                                 (read-event))))))
1102     ) ; (if (featurep 'xemacs)
1103
1104   (if (featurep 'xemacs)
1105       ;; XEmacs
1106       (defadvice describe-key-briefly
1107         (before viper-describe-key-briefly-ad protect activate)
1108         "Force to read key via `viper-read-key-sequence'."
1109         (interactive (list (viper-read-key-sequence "Describe key briefly: "))))
1110     ;; Emacs
1111     (defadvice describe-key-briefly
1112       (before viper-describe-key-briefly-ad protect activate)
1113       "Force to read key via `viper-read-key-sequence'."
1114       (interactive (let (key)
1115                      (setq key (viper-read-key-sequence
1116                                 "Describe key (or click or menu item): "))
1117                      ;; If KEY is a down-event, read and discard the
1118                      ;; corresponding up-event.
1119                      (and (vectorp key)
1120                           (let ((last-idx (1- (length key))))
1121                             (and (eventp (aref key last-idx))
1122                                  (memq 'down (event-modifiers (aref key last-idx)))))
1123                           (read-event))
1124                      (list key
1125                            (if current-prefix-arg
1126                                (prefix-numeric-value current-prefix-arg))
1127                            1))))
1128     ) ; (if (featurep 'xemacs)
1129
1130   (defadvice find-file (before viper-add-suffix-advice activate)
1131     "Use `read-file-name' for reading arguments."
1132     (interactive (cons (read-file-name "Find file: " nil default-directory)
1133                        ;; XEmacs: if Mule & prefix arg, ask for coding system
1134                        (cond ((and (featurep 'xemacs) (featurep 'mule))
1135                               (list
1136                                (and current-prefix-arg
1137                                     (read-coding-system "Coding-system: "))))
1138                              ;; Emacs: do wildcards
1139                              ((and (featurep 'emacs) (boundp 'find-file-wildcards))
1140                                    (list find-file-wildcards))))
1141                  ))
1142
1143   (defadvice find-file-other-window (before viper-add-suffix-advice activate)
1144     "Use `read-file-name' for reading arguments."
1145     (interactive (cons (read-file-name "Find file in other window: "
1146                                        nil default-directory)
1147                        ;; XEmacs: if Mule & prefix arg, ask for coding system
1148                        (cond ((and (featurep 'xemacs) (featurep 'mule))
1149                               (list
1150                                (and current-prefix-arg
1151                                     (read-coding-system "Coding-system: "))))
1152                              ;; Emacs: do wildcards
1153                              ((and (featurep 'emacs) (boundp 'find-file-wildcards))
1154                               (list find-file-wildcards))))
1155                  ))
1156
1157
1158   (defadvice find-file-other-frame (before viper-add-suffix-advice activate)
1159     "Use `read-file-name' for reading arguments."
1160     (interactive (cons (read-file-name "Find file in other frame: "
1161                                        nil default-directory)
1162                        ;; XEmacs: if Mule & prefix arg, ask for coding system
1163                        (cond ((and (featurep 'xemacs) (featurep 'mule))
1164                               (list
1165                                (and current-prefix-arg
1166                                     (read-coding-system "Coding-system: "))))
1167                              ;; Emacs: do wildcards
1168                              ((and (featurep 'emacs) (boundp 'find-file-wildcards))
1169                               (list find-file-wildcards))))
1170                  ))
1171
1172
1173   (defadvice read-file-name (around viper-suffix-advice activate)
1174     "Tell `exit-minibuffer' to run `viper-file-add-suffix' as a hook."
1175     (let ((viper-minibuffer-exit-hook
1176            (append viper-minibuffer-exit-hook
1177                    '(viper-minibuffer-trim-tail viper-file-add-suffix))))
1178       ad-do-it))
1179
1180   (defadvice start-kbd-macro (after viper-kbd-advice activate)
1181     "Remove Viper's intercepting bindings for C-x ).
1182   This may be needed if the previous `:map' command terminated abnormally."
1183     (define-key viper-vi-intercept-map "\C-x)" nil)
1184     (define-key viper-insert-intercept-map "\C-x)" nil)
1185     (define-key viper-emacs-intercept-map "\C-x)" nil))
1186
1187   (defadvice add-minor-mode (after
1188                              viper-advice-add-minor-mode
1189                              (toggle name &optional keymap after toggle-fun)
1190                              activate)
1191     "Run viper-normalize-minor-mode-map-alist after adding a minor mode."
1192     (viper-normalize-minor-mode-map-alist)
1193     (unless
1194         (and (fboundp 'add-to-ordered-list) (boundp 'emulation-mode-map-alists))
1195       (setq-default minor-mode-map-alist minor-mode-map-alist)))
1196
1197   ;; catch frame switching event
1198   (if (viper-window-display-p)
1199       (if (featurep 'xemacs)
1200              (add-hook 'mouse-leave-frame-hook
1201                        'viper-remember-current-frame)
1202            (defadvice handle-switch-frame (before viper-frame-advice activate)
1203              "Remember the selected frame before the switch-frame event."
1204              (viper-remember-current-frame (selected-frame)))) )
1205
1206   ) ; end viper-non-hook-settings
1207
1208
1209 \f
1210 ;; Ask only if this-command/last-command are nil, i.e., when loading
1211 (cond ((and (eq viper-mode 'ask) (null this-command) (null last-command))
1212        (save-window-excursion
1213          (with-output-to-temp-buffer " *viper-info*"
1214            (princ "
1215 You have loaded Viper, and are about to Viperize your Emacs!
1216
1217 Viper is a Package for Emacs Rebels and a venomous VI PERil,
1218
1219 It's time to decide: to Viperize or not to Viperize...
1220
1221 If you wish to Viperize AND make this your way of life, please put
1222
1223         (setq viper-mode t)
1224         (require 'viper)
1225
1226 in your init file (preferably, close to the top).
1227 These two lines must come in the order given."))
1228          (if (y-or-n-p "Viperize? ")
1229              (setq viper-mode t)
1230            (setq viper-mode nil))
1231          (message "")
1232          (kill-buffer " *viper-info*")))
1233
1234       ;; If viper-mode is t, then just continue.  Viper will kick in.
1235       ((eq viper-mode t))
1236       ;; Otherwise, it was asking Viper was not loaded through .emacs
1237       ;; In this case, it was either through M-x viper-mode or via something
1238       ;; else, like the custom widget.  If Viper was loaded through
1239       ;; M-x viper-mode, then viper will kick in anyway.
1240       (t (setq viper-mode nil)))
1241
1242 (defun viper-load-custom-file ()
1243   (if (and (file-exists-p viper-custom-file-name)
1244            (not noninteractive))
1245       (load viper-custom-file-name)))
1246
1247
1248
1249 \f
1250
1251
1252 ;; save non-viper vars that Viper might change
1253 (if (null viper-saved-non-viper-variables)
1254     (setq viper-saved-non-viper-variables
1255           (list
1256            (cons 'default-major-mode (list (default-value 'major-mode)))
1257            (cons 'next-line-add-newlines (list next-line-add-newlines))
1258            (cons 'require-final-newline (list require-final-newline))
1259            (cons 'scroll-step (list scroll-step))
1260            (cons 'mode-line-buffer-identification
1261                  (list (default-value 'mode-line-buffer-identification)))
1262            (cons 'global-mode-string (list global-mode-string))
1263            (if (featurep 'emacs)
1264                (cons 'mark-even-if-inactive (list mark-even-if-inactive)))
1265            )))
1266
1267
1268 ;; Set some useful macros, advices
1269 ;; These must be BEFORE viper-custom-file-name is loaded,
1270 ;; so the user can unrecord them in viper-custom-file-name.
1271 (if viper-mode
1272     (progn
1273       ;; set advices and some variables that give emacs Vi look.
1274       (viper-non-hook-settings)
1275
1276       ;; repeat the 2nd previous command without rotating the command history
1277       (viper-record-kbd-macro
1278        (vector viper-repeat-from-history-key '\1) 'vi-state
1279        [(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)
1280       ;; repeat the 3d previous command without rotating the command history
1281       (viper-record-kbd-macro
1282        (vector viper-repeat-from-history-key '\2) 'vi-state
1283        [(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)
1284
1285       ;; set macros for toggling case sensitivity and regexp search
1286       (viper-set-searchstyle-toggling-macros nil)
1287       ;; Make %%% toggle parsing comments for matching parentheses
1288       (viper-set-parsing-style-toggling-macro nil)
1289
1290       ;; viper-custom-file-name is loaded if exists
1291       (viper-load-custom-file)
1292
1293       ;; should be after loading custom file to avoid the pesky msg that
1294       ;; mouse-search/insert keys are already bound
1295       (viper-bind-mouse-search-key)
1296       (viper-bind-mouse-insert-key)
1297       ))
1298
1299
1300 \f
1301 ;; Applying Viper customization -- runs after (load viper-custom-file-name)
1302
1303 ;; Save user settings or Viper defaults for vars controlled by
1304 ;; viper-expert-level
1305 (if (null viper-saved-user-settings)
1306     (setq viper-saved-user-settings
1307           (list (cons 'viper-want-ctl-h-help (list viper-want-ctl-h-help))
1308                 (cons 'viper-always (list viper-always))
1309                 (cons 'viper-no-multiple-ESC (list viper-no-multiple-ESC))
1310                 (cons 'viper-ex-style-motion (list viper-ex-style-motion))
1311                 (cons 'viper-ex-style-editing
1312                       (list viper-ex-style-editing))
1313                 (cons 'viper-want-emacs-keys-in-vi
1314                       (list viper-want-emacs-keys-in-vi))
1315                 (cons 'viper-electric-mode (list viper-electric-mode))
1316                 (cons 'viper-want-emacs-keys-in-insert
1317                       (list viper-want-emacs-keys-in-insert))
1318                 (cons 'viper-re-search (list viper-re-search)))))
1319
1320
1321 (if viper-mode
1322     (progn
1323       (viper-set-minibuffer-style)
1324       (if viper-buffer-search-char
1325           (viper-buffer-search-enable))
1326       (viper-update-syntax-classes 'set-default)
1327       ))
1328
1329 \f
1330 ;;; Familiarize Viper with some minor modes that have their own keymaps
1331 (if viper-mode
1332     (progn
1333       (viper-harness-minor-mode "compile")
1334       (viper-harness-minor-mode "outline")
1335       (viper-harness-minor-mode "allout")
1336       (viper-harness-minor-mode "xref")
1337       (viper-harness-minor-mode "lmenu")
1338       (viper-harness-minor-mode "vc")
1339       (viper-harness-minor-mode "ltx-math") ; LaTeX-math-mode in AUC-TeX, which
1340       (viper-harness-minor-mode "latex")    ; sits in one of these two files
1341       (viper-harness-minor-mode "cyrillic")
1342       (viper-harness-minor-mode "russian")
1343       (viper-harness-minor-mode "view-less")
1344       (viper-harness-minor-mode "view")
1345       (viper-harness-minor-mode "reftex")
1346       (viper-harness-minor-mode "flyspell")
1347       ))
1348
1349
1350 ;; Intercept maps could go in viper-keym.el
1351 ;; We keep them here in case someone redefines them in viper-custom-file-name
1352
1353 (define-key viper-vi-intercept-map viper-ESC-key 'viper-intercept-ESC-key)
1354 (define-key viper-insert-intercept-map viper-ESC-key 'viper-intercept-ESC-key)
1355
1356 ;; This is taken care of by viper-insert-global-user-map.
1357 ;;(define-key viper-replace-map viper-ESC-key 'viper-intercept-ESC-key)
1358
1359
1360 ;; The default viper-toggle-key is \C-z; for the novice, it suspends or
1361 ;; iconifies Emacs
1362 (define-key viper-vi-intercept-map viper-toggle-key 'viper-toggle-key-action)
1363 (define-key
1364   viper-emacs-intercept-map viper-toggle-key 'viper-change-state-to-vi)
1365
1366 ;;; Removed to avoid bad interaction with cua-mode.
1367 ;;; Escape from Emacs and Insert modes to Vi for one command
1368 ;;(define-key viper-emacs-intercept-map "\C-c\\" 'viper-escape-to-vi)
1369 ;;(define-key viper-insert-intercept-map "\C-c\\" 'viper-escape-to-vi)
1370
1371 (if viper-mode
1372     (setq-default viper-emacs-intercept-minor-mode t
1373                   viper-emacs-local-user-minor-mode t
1374                   viper-emacs-global-user-minor-mode t
1375                   viper-emacs-kbd-minor-mode t
1376                   viper-emacs-state-modifier-minor-mode t))
1377 (if (and viper-mode (eq viper-current-state 'emacs-state))
1378     (setq viper-emacs-intercept-minor-mode t
1379           viper-emacs-local-user-minor-mode t
1380           viper-emacs-global-user-minor-mode t
1381           viper-emacs-kbd-minor-mode t
1382           viper-emacs-state-modifier-minor-mode t))
1383
1384
1385 (if (and viper-mode
1386          (or viper-always
1387              (and (< viper-expert-level 5) (> viper-expert-level 0))))
1388     (viper-set-hooks))
1389
1390 ;; Let all minor modes take effect after loading.
1391 ;; This may not be enough, so we also set default minor-mode-alist.
1392 ;; Without setting the default, new buffers that come up in emacs mode have
1393 ;; minor-mode-map-alist = nil, unless we call viper-change-state-*
1394 (if (and viper-mode (eq viper-current-state 'emacs-state))
1395     (progn
1396       (viper-change-state-to-emacs)
1397       (unless
1398           (and (fboundp 'add-to-ordered-list)
1399                (boundp 'emulation-mode-map-alists))
1400         (setq-default minor-mode-map-alist minor-mode-map-alist))
1401       ))
1402
1403 (if (and viper-mode (this-major-mode-requires-vi-state major-mode))
1404     (viper-mode))
1405
1406 (if viper-mode
1407     (setq initial-major-mode
1408           `(lambda ()
1409              (funcall (quote ,initial-major-mode))
1410              (set-viper-state-in-major-mode))
1411           ))
1412
1413
1414
1415 (run-hooks 'viper-load-hook) ; the last chance to change something
1416
1417 (provide 'viper)
1418
1419
1420 ;; Local Variables:
1421 ;; eval: (put 'viper-deflocalvar 'lisp-indent-hook 'defun)
1422 ;; End:
1423
1424 ;;; viper.el ends here