code.delx.au - gnu-emacs/blob - lisp/emulation/viper-keym.el

   1 ;;; viper-keym.el --- Viper keymaps
   2
   3 ;; Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
   4
   5 ;; This file is part of GNU Emacs.
   6
   7 ;; GNU Emacs is free software; you can redistribute it and/or modify
   8 ;; it under the terms of the GNU General Public License as published by
   9 ;; the Free Software Foundation; either version 2, or (at your option)
  10 ;; any later version.
  11
  12 ;; GNU Emacs is distributed in the hope that it will be useful,
  13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 ;; GNU General Public License for more details.
  16
  17 ;; You should have received a copy of the GNU General Public License
  18 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  19 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20 ;; Boston, MA 02111-1307, USA.
  21
  22 ;; Code
  23
  24 (provide 'viper-keym)
  25
  26 ;; compiler pacifier
  27 (defvar viper-always)
  28 (defvar viper-current-state)
  29 (defvar viper-mode-string)
  30 (defvar viper-expert-level)
  31 (defvar viper-ex-style-editing)
  32 (defvar viper-ex-style-motion)
  33
  34 ;; loading happens only in non-interactive compilation
  35 ;; in order to spare non-viperized emacs from being viperized
  36 (if noninteractive
  37     (eval-when-compile
  38       (let ((load-path (cons (expand-file-name ".") load-path)))
  39         (or (featurep 'viper-util)
  40             (load "viper-util.el" nil nil 'nosuffix))
  41         )))
  42 ;; end pacifier
  43
  44 (require 'viper-util)
  45
  46
  47 ;;; Variables
  48
  49 (defvar viper-toggle-key "\C-z"
  50   "The key used to change states from emacs to Vi and back.
  51 In insert mode, this key also functions as Meta.
  52 Must be set in .viper file or prior to loading Viper.
  53 This setting cannot be changed interactively.")
  54
  55 (defvar viper-ESC-key "\e"
  56   "Key used to ESC.
  57 Must be set in .viper file or prior to loading Viper.
  58 This setting cannot be changed interactively.")
  59
  60 ;;; Emacs keys in other states.
  61
  62 (defcustom viper-want-emacs-keys-in-insert t
  63   "*Set to nil if you want complete Vi compatibility in insert mode.
  64 Complete compatibility with Vi is not recommended for power use of Viper."
  65   :type 'boolean
  66   :group 'viper)
  67
  68 (defcustom viper-want-emacs-keys-in-vi t
  69   "*Set to nil if you want complete Vi compatibility in Vi mode.
  70 Full Vi compatibility is not recommended for power use of Viper."
  71   :type 'boolean
  72   :group 'viper)
  73
  74 (defcustom viper-no-multiple-ESC  t
  75   "*If true, multiple ESC in Vi mode will cause bell to ring.
  76 This is set to t on a windowing terminal and to 'twice on a dumb
  77 terminal (unless the user level is 1, 2, or 5). On a dumb terminal, this
  78 enables cursor keys and is generally more convenient, as terminals usually
  79 don't have a convenient Meta key.
  80 Setting viper-no-multiple-ESC to nil will allow as many multiple ESC,
  81 as is allowed by the major mode in effect."
  82   :type 'boolean
  83   :group 'viper)
  84
  85 (defcustom viper-want-ctl-h-help nil
  86   "*If t then C-h is bound to help-command in insert mode, if nil then it is
  87 bound to delete-backward-char."
  88   :type 'boolean
  89   :group 'viper)
  90
  91
  92 ;;; Keymaps
  93
  94 ;; Keymaps for vital things like \e and C-z.
  95 ;; Not for users
  96 (defvar viper-vi-intercept-map (make-sparse-keymap))
  97 (defvar viper-insert-intercept-map (make-sparse-keymap))
  98 (defvar viper-emacs-intercept-map (make-sparse-keymap))
  99
 100 ;; keymap used to zap all keymaps other than function-key-map,
 101 ;; device-function-key-map, etc.
 102 (defvar viper-overriding-map (make-sparse-keymap))
 103
 104 (viper-deflocalvar viper-vi-local-user-map (make-sparse-keymap)
 105   "Keymap for user-defined local bindings.
 106 Useful for changing bindings such as ZZ in certain major modes.
 107 For instance, in letter-mode, one may want to bind ZZ to
 108 mh-send-letter. In a newsreader such as gnus, tin, or rn, ZZ could be bound
 109 to save-buffers-kill-emacs then post article, etc.")
 110 (put 'viper-vi-local-user-map 'permanent-local t)
 111
 112 (defvar viper-vi-global-user-map (make-sparse-keymap)
 113   "Keymap for user-defined global bindings.
 114 These bindings are seen in all Viper buffers.")
 115
 116 (defvar viper-vi-basic-map (make-keymap)
 117   "This is the main keymap in effect in Viper's Vi state.
 118 This map is global, shared by all buffers.")
 119
 120 (defvar  viper-vi-kbd-map (make-sparse-keymap)
 121   "This keymap keeps keyboard macros defined via the :map command.")
 122
 123 (defvar viper-vi-diehard-map (make-sparse-keymap)
 124   "This keymap is in use when the user asks Viper to simulate Vi very closely.
 125 This happens when viper-expert-level is 1 or 2. See viper-set-expert-level.")
 126
 127
 128 (viper-deflocalvar viper-insert-local-user-map (make-sparse-keymap)
 129   "Auxiliary map for per-buffer user-defined keybindings in Insert state.")
 130 (put 'viper-insert-local-user-map 'permanent-local t)
 131
 132 (defvar viper-insert-global-user-map (make-sparse-keymap)
 133   "Auxiliary map for global user-defined bindings in Insert state.")
 134
 135 (defvar viper-insert-basic-map (make-sparse-keymap)
 136   "The basic insert-mode keymap.")
 137
 138 (defvar viper-insert-diehard-map (make-keymap)
 139   "Map used when user wants vi-style keys in insert mode.
 140 Most of the Emacs keys are suppressed. This map overshadows
 141 viper-insert-basic-map. Not recommended, except for novice users.")
 142
 143 (defvar  viper-insert-kbd-map  (make-sparse-keymap)
 144   "This keymap keeps VI-style kbd macros for insert mode.")
 145
 146 (defvar viper-replace-map (make-sparse-keymap)
 147   "Map used in Viper's replace state.")
 148
 149 (defvar viper-emacs-global-user-map (make-sparse-keymap)
 150   "Auxiliary map for global user-defined bindings in Emacs state.")
 151
 152 (defvar  viper-emacs-kbd-map  (make-sparse-keymap)
 153   "This keymap keeps Vi-style kbd macros for emacs mode.")
 154
 155 (viper-deflocalvar viper-emacs-local-user-map  (make-sparse-keymap)
 156   "Auxiliary map for local user-defined bindings in Emacs state.")
 157 (put 'viper-emacs-local-user-map 'permanent-local t)
 158
 159 ;; This keymap should stay empty
 160 (defvar viper-empty-keymap (make-sparse-keymap))
 161
 162 ;; This was the main Vi mode in old versions of VIP which may have been
 163 ;; extensively used by VIP users. We declare it as a global var
 164 ;; and, after .viper is loaded, we add this keymap to viper-vi-basic-map.
 165 (defvar viper-mode-map (make-sparse-keymap))
 166
 167
 168 ;;; Variables used by minor modes
 169
 170 ;; Association list of the form
 171 ;; ((major-mode . keymap) (major-mode . keymap) ...)
 172 ;; Viper uses these keymaps to make user-requested adjustments
 173 ;; to its Vi state in various major modes.")
 174 (defvar viper-vi-state-modifier-alist nil)
 175
 176 ;; Association list of the form
 177 ;; ((major-mode . keymap) (major-mode . keymap) ...)
 178 ;; Viper uses these keymaps to make user-requested adjustments
 179 ;; to its Insert state in various major modes.")
 180 (defvar viper-insert-state-modifier-alist nil)
 181
 182 ;; Association list of the form
 183 ;; ((major-mode . keymap) (major-mode . keymap) ...)
 184 ;; Viper uses these keymaps to make user-requested adjustments
 185 ;; to its Emacs state in various major modes.
 186 (defvar viper-emacs-state-modifier-alist nil)
 187
 188 ;; Tells viper-add-local-keys to create a new viper-vi-local-user-map for new
 189 ;; buffers. Not a user option.
 190 (viper-deflocalvar viper-need-new-vi-local-map t "")
 191 (put 'viper-need-new-vi-local-map  'permanent-local t)
 192
 193 ;; Tells viper-add-local-keys to create a new viper-insert-local-user-map for
 194 ;; new buffers. Not a user option.
 195 (viper-deflocalvar viper-need-new-insert-local-map t "")
 196 (put 'viper-need-new-insert-local-map  'permanent-local t)
 197
 198 ;; Tells viper-add-local-keys to create a new viper-emacs-local-user-map for
 199 ;; new buffers. Not a user option.
 200 (viper-deflocalvar viper-need-new-emacs-local-map t "")
 201 (put 'viper-need-new-emacs-local-map  'permanent-local t)
 202
 203
 204 \f
 205 ;; Insert mode keymap
 206
 207 ;; for novice users, pretend you are the real vi.
 208 (define-key viper-insert-diehard-map "\t"   'viper-insert-tab)
 209 (define-key viper-insert-diehard-map "\C-a" 'self-insert-command)
 210 (define-key viper-insert-diehard-map "\C-b" 'self-insert-command)
 211 (define-key viper-insert-diehard-map "\C-c" 'viper-change-state-to-vi)
 212 (define-key viper-insert-diehard-map "\C-e" 'self-insert-command)
 213 (define-key viper-insert-diehard-map "\C-f" 'self-insert-command)
 214 (define-key viper-insert-diehard-map "\C-g" 'self-insert-command)
 215 (define-key viper-insert-diehard-map "\C-i" 'self-insert-command)
 216 (define-key viper-insert-diehard-map "\C-k" 'self-insert-command)
 217 (define-key viper-insert-diehard-map "\C-l" 'self-insert-command)
 218 (define-key viper-insert-diehard-map "\C-n" 'self-insert-command)
 219 (define-key viper-insert-diehard-map "\C-o" 'self-insert-command)
 220 (define-key viper-insert-diehard-map "\C-p" 'self-insert-command)
 221 (define-key viper-insert-diehard-map "\C-q" 'self-insert-command)
 222 (define-key viper-insert-diehard-map "\C-r" 'self-insert-command)
 223 (define-key viper-insert-diehard-map "\C-s" 'self-insert-command)
 224 (define-key viper-insert-diehard-map "\C-u" 'viper-erase-line)
 225 (define-key viper-insert-diehard-map "\C-x" 'self-insert-command)
 226 (define-key viper-insert-diehard-map "\C-y" 'self-insert-command)
 227 (define-key viper-insert-diehard-map "\C-z" 'self-insert-command)
 228 (define-key viper-insert-diehard-map "\C-]" 'self-insert-command)
 229 (define-key viper-insert-diehard-map "\C-_" 'self-insert-command)
 230
 231 (let ((i ?\ ))
 232   (while (<= i ?~)
 233     (define-key viper-insert-diehard-map (make-string 1 i) 'self-insert-command)
 234     (setq i (1+ i))))
 235
 236 ;; Insert mode map when user wants emacs style
 237 (define-key viper-insert-basic-map "\C-d" 'viper-backward-indent)
 238 (define-key viper-insert-basic-map "\C-w" 'viper-delete-backward-word)
 239 (define-key viper-insert-basic-map "\C-t" 'viper-forward-indent)
 240 (define-key viper-insert-basic-map
 241   (if viper-xemacs-p [(shift tab)] [S-tab]) 'viper-insert-tab)
 242 (define-key viper-insert-basic-map "\C-v" 'quoted-insert)
 243 (define-key viper-insert-basic-map "\C-?" 'viper-del-backward-char-in-insert)
 244 (define-key viper-insert-basic-map "\C-\\" 'viper-alternate-Meta-key)
 245 (define-key viper-insert-basic-map viper-toggle-key 'viper-escape-to-vi)
 246 (define-key viper-insert-basic-map "\C-c\M-p"
 247   'viper-insert-prev-from-insertion-ring)
 248 (define-key viper-insert-basic-map "\C-c\M-n"
 249   'viper-insert-next-from-insertion-ring)
 250
 251
 252 ;; Replace keymap
 253 (define-key viper-replace-map "\C-t" 'viper-forward-indent)
 254 (define-key viper-replace-map "\C-j" 'viper-replace-state-carriage-return)
 255 (define-key viper-replace-map "\C-m" 'viper-replace-state-carriage-return)
 256 (define-key viper-replace-map "\C-?" 'viper-del-backward-char-in-replace)
 257
 258
 259 \f
 260 ;; Vi keymaps
 261
 262 (define-key viper-vi-basic-map "\C-^"
 263   (function (lambda () (interactive) (viper-ex "e#"))))
 264 (define-key viper-vi-basic-map "\C-b" 'viper-scroll-screen-back)
 265 (define-key viper-vi-basic-map "\C-d" 'viper-scroll-up)
 266 (define-key viper-vi-basic-map "\C-e" 'viper-scroll-up-one)
 267 (define-key viper-vi-basic-map "\C-f" 'viper-scroll-screen)
 268 (define-key viper-vi-basic-map "\C-m" 'viper-next-line-at-bol)
 269 (define-key viper-vi-basic-map "\C-u" 'viper-scroll-down)
 270 (define-key viper-vi-basic-map "\C-y" 'viper-scroll-down-one)
 271 (define-key viper-vi-basic-map "\C-s" 'viper-isearch-forward)
 272 (define-key viper-vi-basic-map "\C-r" 'viper-isearch-backward)
 273 (define-key viper-vi-basic-map "\C-c/" 'viper-toggle-search-style)
 274 (define-key viper-vi-basic-map "\C-cg" 'viper-info-on-file)
 275
 276 (define-key viper-vi-basic-map "\C-c\M-p" 'viper-prev-destructive-command)
 277 (define-key viper-vi-basic-map "\C-c\M-n" 'viper-next-destructive-command)
 278
 279
 280 (define-key viper-vi-basic-map " " 'viper-forward-char)
 281 (define-key viper-vi-basic-map "!" 'viper-command-argument)
 282 (define-key viper-vi-basic-map "\"" 'viper-command-argument)
 283 (define-key viper-vi-basic-map "#" 'viper-command-argument)
 284 (define-key viper-vi-basic-map "$" 'viper-goto-eol)
 285 (define-key viper-vi-basic-map "%" 'viper-paren-match)
 286 (define-key viper-vi-basic-map "&"
 287   (function (lambda () (interactive) (viper-ex "&"))))
 288 (define-key viper-vi-basic-map "'" 'viper-goto-mark-and-skip-white)
 289 (define-key viper-vi-basic-map "(" 'viper-backward-sentence)
 290 (define-key viper-vi-basic-map ")" 'viper-forward-sentence)
 291 (define-key viper-vi-basic-map "*" 'call-last-kbd-macro)
 292 (define-key viper-vi-basic-map "+" 'viper-next-line-at-bol)
 293 (define-key viper-vi-basic-map "," 'viper-repeat-find-opposite)
 294 (define-key viper-vi-basic-map "-" 'viper-previous-line-at-bol)
 295 (define-key viper-vi-basic-map "." 'viper-repeat)
 296 (define-key viper-vi-basic-map "/" 'viper-search-forward)
 297
 298 (define-key viper-vi-basic-map "0" 'viper-beginning-of-line)
 299 (define-key viper-vi-basic-map "1" 'viper-digit-argument)
 300 (define-key viper-vi-basic-map "2" 'viper-digit-argument)
 301 (define-key viper-vi-basic-map "3" 'viper-digit-argument)
 302 (define-key viper-vi-basic-map "4" 'viper-digit-argument)
 303 (define-key viper-vi-basic-map "5" 'viper-digit-argument)
 304 (define-key viper-vi-basic-map "6" 'viper-digit-argument)
 305 (define-key viper-vi-basic-map "7" 'viper-digit-argument)
 306 (define-key viper-vi-basic-map "8" 'viper-digit-argument)
 307 (define-key viper-vi-basic-map "9" 'viper-digit-argument)
 308
 309 (define-key viper-vi-basic-map ":" 'viper-ex)
 310 (define-key viper-vi-basic-map ";" 'viper-repeat-find)
 311 (define-key viper-vi-basic-map "<" 'viper-command-argument)
 312 (define-key viper-vi-basic-map "=" 'viper-command-argument)
 313 (define-key viper-vi-basic-map ">" 'viper-command-argument)
 314 (define-key viper-vi-basic-map "?" 'viper-search-backward)
 315 (define-key viper-vi-basic-map "@" 'viper-register-macro)
 316
 317 (define-key viper-vi-basic-map "A" 'viper-Append)
 318 (define-key viper-vi-basic-map "B" 'viper-backward-Word)
 319 (define-key viper-vi-basic-map "C" 'viper-change-to-eol)
 320 (define-key viper-vi-basic-map "D" 'viper-kill-line)
 321 (define-key viper-vi-basic-map "E" 'viper-end-of-Word)
 322 (define-key viper-vi-basic-map "F" 'viper-find-char-backward)
 323 (define-key viper-vi-basic-map "G" 'viper-goto-line)
 324 (define-key viper-vi-basic-map "H" 'viper-window-top)
 325 (define-key viper-vi-basic-map "I" 'viper-Insert)
 326 (define-key viper-vi-basic-map "J" 'viper-join-lines)
 327 (define-key viper-vi-basic-map "K" 'viper-nil)
 328 (define-key viper-vi-basic-map "L" 'viper-window-bottom)
 329 (define-key viper-vi-basic-map "M" 'viper-window-middle)
 330 (define-key viper-vi-basic-map "N" 'viper-search-Next)
 331 (define-key viper-vi-basic-map "O" 'viper-Open-line)
 332 (define-key viper-vi-basic-map "P" 'viper-Put-back)
 333 (define-key viper-vi-basic-map "Q" 'viper-query-replace)
 334 (define-key viper-vi-basic-map "R" 'viper-overwrite)
 335 (define-key viper-vi-basic-map "S" 'viper-substitute-line)
 336 (define-key viper-vi-basic-map "T" 'viper-goto-char-backward)
 337 (define-key viper-vi-basic-map "U" 'viper-undo)
 338 (define-key viper-vi-basic-map "V" 'find-file-other-window)
 339 (define-key viper-vi-basic-map "W" 'viper-forward-Word)
 340 (define-key viper-vi-basic-map "X" 'viper-delete-backward-char)
 341 (define-key viper-vi-basic-map "Y" 'viper-yank-line)
 342 (define-key viper-vi-basic-map "ZZ" 'viper-save-kill-buffer)
 343
 344 (define-key viper-vi-basic-map "\\" 'viper-escape-to-emacs)
 345 (define-key viper-vi-basic-map "[" 'viper-brac-function)
 346 (define-key viper-vi-basic-map "]" 'viper-ket-function)
 347 (define-key viper-vi-basic-map "\C-\\" 'viper-alternate-Meta-key)
 348 (define-key viper-vi-basic-map "^" 'viper-bol-and-skip-white)
 349 (define-key viper-vi-basic-map "`" 'viper-goto-mark)
 350
 351 (define-key viper-vi-basic-map "a" 'viper-append)
 352 (define-key viper-vi-basic-map "b" 'viper-backward-word)
 353 (define-key viper-vi-basic-map "c" 'viper-command-argument)
 354 (define-key viper-vi-basic-map "d" 'viper-command-argument)
 355 (define-key viper-vi-basic-map "e" 'viper-end-of-word)
 356 (define-key viper-vi-basic-map "f" 'viper-find-char-forward)
 357 (define-key viper-vi-basic-map "g" 'viper-nil)
 358 (define-key viper-vi-basic-map "h" 'viper-backward-char)
 359 (define-key viper-vi-basic-map "i" 'viper-insert)
 360 (define-key viper-vi-basic-map "j" 'viper-next-line)
 361 (define-key viper-vi-basic-map "k" 'viper-previous-line)
 362 (define-key viper-vi-basic-map "l" 'viper-forward-char)
 363 (define-key viper-vi-basic-map "m" 'viper-mark-point)
 364 (define-key viper-vi-basic-map "n" 'viper-search-next)
 365 (define-key viper-vi-basic-map "o" 'viper-open-line)
 366 (define-key viper-vi-basic-map "p" 'viper-put-back)
 367 (define-key viper-vi-basic-map "q" 'viper-nil)
 368 (define-key viper-vi-basic-map "r" 'viper-replace-char)
 369 (define-key viper-vi-basic-map "s" 'viper-substitute)
 370 (define-key viper-vi-basic-map "t" 'viper-goto-char-forward)
 371 (define-key viper-vi-basic-map "u" 'viper-undo)
 372 (define-key viper-vi-basic-map "v" 'find-file)
 373 (define-key viper-vi-basic-map "\C-v" 'find-file-other-frame)
 374 (define-key viper-vi-basic-map "w" 'viper-forward-word)
 375 (define-key viper-vi-basic-map "x" 'viper-delete-char)
 376 (define-key viper-vi-basic-map "y" 'viper-command-argument)
 377 (define-key viper-vi-basic-map "zH" 'viper-line-to-top)
 378 (define-key viper-vi-basic-map "zM" 'viper-line-to-middle)
 379 (define-key viper-vi-basic-map "zL" 'viper-line-to-bottom)
 380 (define-key viper-vi-basic-map "z\C-m" 'viper-line-to-top)
 381 (define-key viper-vi-basic-map "z." 'viper-line-to-middle)
 382 (define-key viper-vi-basic-map "z-" 'viper-line-to-bottom)
 383
 384 (define-key viper-vi-basic-map "{" 'viper-backward-paragraph)
 385 (define-key viper-vi-basic-map "|" 'viper-goto-col)
 386 (define-key viper-vi-basic-map "}" 'viper-forward-paragraph)
 387 (define-key viper-vi-basic-map "~" 'viper-toggle-case)
 388 (define-key viper-vi-basic-map "\C-?" 'viper-backward-char)
 389 (define-key viper-vi-basic-map "_" 'viper-nil)
 390
 391 ;;; Escape from Emacs to Vi for one command
 392 (global-set-key "\C-c\\" 'viper-escape-to-vi)  ; everywhere
 393
 394 ;;; This is viper-vi-diehard-map. Used when viper-vi-diehard-minor-mode is on.
 395
 396 (define-key viper-vi-diehard-map "\C-a" 'viper-nil)
 397 (define-key viper-vi-diehard-map "\C-c" 'viper-nil)
 398 (define-key viper-vi-diehard-map "\C-g" 'viper-info-on-file)
 399 (define-key viper-vi-diehard-map "\C-i" 'viper-nil)
 400 (define-key viper-vi-diehard-map "\C-k" 'viper-nil)
 401 (define-key viper-vi-diehard-map "\C-l" 'redraw-display)
 402 (define-key viper-vi-diehard-map "\C-n" 'viper-next-line)
 403 (define-key viper-vi-diehard-map "\C-o" 'viper-nil)
 404 (define-key viper-vi-diehard-map "\C-p" 'viper-previous-line)
 405 (define-key viper-vi-diehard-map "\C-q" 'viper-nil)
 406 (define-key viper-vi-diehard-map "\C-r" 'redraw-display)
 407 (define-key viper-vi-diehard-map "\C-s" 'viper-nil)
 408 (define-key viper-vi-diehard-map "\C-t" 'viper-nil)
 409 (define-key viper-vi-diehard-map "\C-v" 'viper-nil)
 410 (define-key viper-vi-diehard-map "\C-w" 'viper-nil)
 411 (define-key viper-vi-diehard-map "@" 'viper-nil)
 412 (define-key viper-vi-diehard-map "_" 'viper-nil)
 413 (define-key viper-vi-diehard-map "*" 'viper-nil)
 414 (define-key viper-vi-diehard-map "#" 'viper-nil)
 415 (define-key viper-vi-diehard-map "\C-_" 'viper-nil)
 416 (define-key viper-vi-diehard-map "\C-]" 'viper-nil) ; This is actually tags.
 417
 418 \f
 419 ;;; Minibuffer keymap
 420
 421
 422 (defvar viper-minibuffer-map (make-sparse-keymap)
 423   "Keymap used to modify keys when Minibuffer is in Insert state.")
 424
 425 (define-key viper-minibuffer-map "\C-m" 'viper-exit-minibuffer)
 426 (define-key viper-minibuffer-map "\C-j" 'viper-exit-minibuffer)
 427
 428 ;; Map used to read Ex-style commands.
 429 (defvar viper-ex-cmd-map (make-sparse-keymap))
 430 (define-key viper-ex-cmd-map " "  'ex-cmd-read-exit)
 431 (define-key viper-ex-cmd-map "\t" 'ex-cmd-complete)
 432
 433 ;; Keymap for reading file names in Ex-style commands.
 434 (defvar ex-read-filename-map (make-sparse-keymap))
 435 (define-key ex-read-filename-map " " 'viper-complete-filename-or-exit)
 436 (define-key ex-read-filename-map "!" 'viper-handle-!)
 437
 438 ;; Some other maps
 439 (defvar viper-slash-and-colon-map (make-sparse-keymap)
 440   "This map redefines `/' and `:' to behave as in Vi.
 441 Useful in some modes, such as Gnus, MH, etc.")
 442 (define-key viper-slash-and-colon-map ":" 'viper-ex)
 443 (define-key viper-slash-and-colon-map "/" 'viper-search-forward)
 444
 445 (defvar viper-comint-mode-modifier-map (make-sparse-keymap)
 446   "This map modifies comint mode.")
 447 (define-key viper-comint-mode-modifier-map "\C-m" 'comint-send-input)
 448 (define-key viper-comint-mode-modifier-map "\C-d" 'comint-delchar-or-maybe-eof)
 449
 450 (defvar viper-dired-modifier-map (make-sparse-keymap)
 451   "This map modifies Dired behavior.")
 452 (define-key viper-dired-modifier-map ":" 'viper-ex)
 453 (define-key viper-dired-modifier-map "/" 'viper-search-forward)
 454
 455 (defvar viper-help-modifier-map (make-sparse-keymap)
 456   "This map modifies Help mode behavior.")
 457 (define-key viper-help-modifier-map "q" (if viper-xemacs-p 'help-mode-quit))
 458
 459
 460 \f
 461 ;;; Code
 462
 463 (defun viper-add-local-keys (state alist)
 464   "Override some vi-state or insert-state bindings in the current buffer.
 465 The effect is seen in the current buffer only.
 466 Useful for customizing  mailer buffers, gnus, etc.
 467 STATE is 'vi-state, 'insert-state, or 'emacs-state
 468 ALIST is of the form ((key . func) (key . func) ...)
 469 Normally, this would be called from a hook to a major mode or
 470 on a per buffer basis.
 471 Usage:
 472       (viper-add-local-keys state '((key-str . func) (key-str . func)...))   "
 473
 474   (let (map)
 475     (cond ((eq state 'vi-state)
 476            (if viper-need-new-vi-local-map
 477                (setq viper-vi-local-user-map (make-sparse-keymap)))
 478            (setq viper-need-new-vi-local-map nil
 479                  map viper-vi-local-user-map))
 480           ((eq state 'insert-state)
 481            (if viper-need-new-insert-local-map
 482                (setq viper-insert-local-user-map (make-sparse-keymap)))
 483            (setq viper-need-new-insert-local-map nil
 484                  map viper-insert-local-user-map))
 485           ((eq state 'emacs-state)
 486            (if viper-need-new-emacs-local-map
 487                (setq viper-emacs-local-user-map (make-sparse-keymap)))
 488            (setq viper-need-new-emacs-local-map nil
 489                  map viper-emacs-local-user-map))
 490           (t
 491            (error
 492             "Invalid state in viper-add-local-keys: %S. Valid states: vi-state, insert-state or emacs-state" state)))
 493
 494     (viper-modify-keymap map alist)
 495     (viper-normalize-minor-mode-map-alist)
 496     (viper-set-mode-vars-for viper-current-state)))
 497
 498 (defun viper-zap-local-keys ()
 499   "Unconditionally reset Viper viper-*-local-user-map's.
 500 Rarely useful, but if u made a mistake by switching to a mode that adds
 501 undesirable local keys, e.g., comint-mode, then this function can restore
 502 sanity."
 503   (interactive)
 504   (setq viper-vi-local-user-map (make-sparse-keymap)
 505         viper-need-new-vi-local-map nil
 506         viper-insert-local-user-map (make-sparse-keymap)
 507         viper-need-new-insert-local-map nil
 508         viper-emacs-local-user-map (make-sparse-keymap)
 509         viper-need-new-emacs-local-map nil)
 510   (viper-normalize-minor-mode-map-alist))
 511
 512
 513 (defun viper-modify-major-mode (mode state keymap)
 514   "Modify key bindings in a major-mode in a Viper state using a keymap.
 515
 516 If the default for a major mode is emacs-state, then modifications to this
 517 major mode may not take effect until the buffer switches state to Vi,
 518 Insert or Emacs. If this happens, add viper-change-state-to-emacs to this
 519 major mode's hook. If no such hook exists, you may have to put an advice on
 520 the function that invokes the major mode. See viper-set-hooks for hints.
 521
 522 The above needs not to be done for major modes that come up in Vi or Insert
 523 state by default.
 524
 525 Arguments: (major-mode viper-state keymap)"
 526   (let ((alist
 527          (cond ((eq state 'vi-state) 'viper-vi-state-modifier-alist)
 528                ((eq state 'insert-state) 'viper-insert-state-modifier-alist)
 529                ((eq state 'emacs-state) 'viper-emacs-state-modifier-alist)))
 530         elt)
 531     (if (setq elt (assoc mode (eval alist)))
 532         (set alist (delq elt (eval alist))))
 533     (set alist (cons (cons mode keymap) (eval alist)))
 534
 535     ;; Normalization usually doesn't help here, since one needs to
 536     ;; normalize in the actual buffer where changes to the keymap are
 537     ;; to take place. However, it doesn't hurt, and it helps whenever this
 538     ;; function is actually called from within the right buffer.
 539     (viper-normalize-minor-mode-map-alist)
 540
 541     (viper-set-mode-vars-for viper-current-state)))
 542
 543
 544 ;; Displays variables that control Viper's keymaps
 545 (defun viper-debug-keymaps ()
 546   (interactive)
 547   (with-output-to-temp-buffer " *viper-debug*"
 548     (princ (format "Buffer name:  %s\n\n" (buffer-name)))
 549     (princ "Variables:  \n")
 550     (princ (format "major-mode:  %S\n" major-mode))
 551     (princ (format "viper-current-state:  %S\n" viper-current-state))
 552     (princ (format "viper-mode-string:  %S\n\n" viper-mode-string))
 553     (princ (format "viper-vi-intercept-minor-mode:  %S\n"
 554                    viper-vi-intercept-minor-mode))
 555     (princ (format "viper-insert-intercept-minor-mode:  %S\n"
 556                    viper-insert-intercept-minor-mode))
 557     (princ (format "viper-emacs-intercept-minor-mode:  %S\n"
 558                    viper-emacs-intercept-minor-mode))
 559     (princ (format "viper-vi-minibuffer-minor-mode:  %S\n"
 560                    viper-vi-minibuffer-minor-mode))
 561     (princ (format "viper-insert-minibuffer-minor-mode:  %S\n\n"
 562                    viper-insert-minibuffer-minor-mode))
 563     (princ (format "viper-vi-local-user-minor-mode:  %S\n"
 564                    viper-vi-local-user-minor-mode))
 565     (princ (format "viper-vi-global-user-minor-mode:  %S\n"
 566                    viper-vi-global-user-minor-mode))
 567     (princ (format "viper-vi-kbd-minor-mode:  %S\n" viper-vi-kbd-minor-mode))
 568     (princ (format "viper-vi-state-modifier-minor-mode:  %S\n"
 569                    viper-vi-state-modifier-minor-mode))
 570     (princ (format "viper-vi-diehard-minor-mode:  %S\n"
 571                    viper-vi-diehard-minor-mode))
 572     (princ (format "viper-vi-basic-minor-mode:  %S\n" viper-vi-basic-minor-mode))
 573     (princ (format "viper-replace-minor-mode:  %S\n" viper-replace-minor-mode))
 574     (princ (format "viper-insert-local-user-minor-mode:  %S\n"
 575                    viper-insert-local-user-minor-mode))
 576     (princ (format "viper-insert-global-user-minor-mode:  %S\n"
 577                    viper-insert-global-user-minor-mode))
 578     (princ (format "viper-insert-kbd-minor-mode:  %S\n"
 579                    viper-insert-kbd-minor-mode))
 580     (princ (format "viper-insert-state-modifier-minor-mode:  %S\n"
 581                    viper-insert-state-modifier-minor-mode))
 582     (princ (format "viper-insert-diehard-minor-mode:  %S\n"
 583                    viper-insert-diehard-minor-mode))
 584     (princ (format "viper-insert-basic-minor-mode:  %S\n"
 585                    viper-insert-basic-minor-mode))
 586     (princ (format "viper-emacs-local-user-minor-mode:  %S\n"
 587                    viper-emacs-local-user-minor-mode))
 588     (princ (format "viper-emacs-kbd-minor-mode:  %S\n"
 589                    viper-emacs-kbd-minor-mode))
 590     (princ (format "viper-emacs-global-user-minor-mode:  %S\n"
 591                    viper-emacs-global-user-minor-mode))
 592     (princ (format "viper-emacs-state-modifier-minor-mode:  %S\n"
 593                    viper-emacs-state-modifier-minor-mode))
 594
 595     (princ (format "\nviper-expert-level  %S\n" viper-expert-level))
 596     (princ (format "viper-no-multiple-ESC  %S\n" viper-no-multiple-ESC))
 597     (princ (format "viper-always  %S\n" viper-always))
 598     (princ (format "viper-ex-style-motion  %S\n"
 599                    viper-ex-style-motion))
 600     (princ (format "viper-ex-style-editing  %S\n"
 601                    viper-ex-style-editing))
 602     (princ (format "viper-want-emacs-keys-in-vi  %S\n"
 603                    viper-want-emacs-keys-in-vi))
 604     (princ (format "viper-want-emacs-keys-in-insert  %S\n"
 605                    viper-want-emacs-keys-in-insert))
 606     (princ (format "viper-want-ctl-h-help  %S\n" viper-want-ctl-h-help))
 607
 608     (princ "\n\n\n")
 609     (princ (format "Default value for minor-mode-map-alist:  \n%S\n\n"
 610                    (default-value 'minor-mode-map-alist)))
 611     (princ (format "Actual value for minor-mode-map-alist:  \n%S\n"
 612                    minor-mode-map-alist))
 613     ))
 614
 615
 616 ;;; Keymap utils
 617
 618 (defun viper-add-keymap (mapsrc mapdst)
 619   "Add contents of mapsrc to mapdst. It is assumed that mapsrc is sparse."
 620   (if viper-xemacs-p
 621       (map-keymap (function (lambda (key binding)
 622                               (define-key mapdst key binding)))
 623                   mapsrc)
 624     (mapcar
 625      (function (lambda (p)
 626                  (define-key mapdst (vector (car p)) (cdr p))
 627                  ))
 628      (cdr mapsrc))))
 629
 630 (defun viper-modify-keymap (map alist)
 631    "Modifies MAP with bindings specified in the ALIST. The alist has the
 632 form ((key . function) (key . function) ... )."
 633    (mapcar (function (lambda (p)
 634                        (define-key map (eval (car p)) (cdr p))))
 635            alist))
 636
 637
 638 ;;; Local Variables:
 639 ;;; eval: (put 'viper-deflocalvar 'lisp-indent-hook 'defun)
 640 ;;; End:
 641
 642
 643 ;;;  viper-keym.el ends here