lisp/emulation/viper.el

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