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

   1 ;;; viper-init.el --- some common definitions for Viper
   2
   3 ;; Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   4 ;;   2005 Free Software Foundation, Inc.
   5
   6 ;; Author: Michael Kifer <kifer@cs.stonybrook.edu>
   7
   8 ;; This file is part of GNU Emacs.
   9
  10 ;; GNU Emacs is free software; you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation; either version 2, or (at your option)
  13 ;; any later version.
  14
  15 ;; GNU Emacs is distributed in the hope that it will be useful,
  16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; GNU General Public License for more details.
  19
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  22 ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  23 ;; Boston, MA 02110-1301, USA.
  24
  25 ;;; Commentary:
  26
  27 ;;; Code:
  28
  29 (provide 'viper-init)
  30
  31 ;; compiler pacifier
  32 (defvar mark-even-if-inactive)
  33 (defvar quail-mode)
  34 (defvar iso-accents-mode)
  35 (defvar viper-current-state)
  36 (defvar viper-version)
  37 (defvar viper-expert-level)
  38 (defvar current-input-method)
  39 (defvar default-input-method)
  40 (defvar describe-current-input-method-function)
  41 (defvar bar-cursor)
  42 (defvar default-cursor-type)
  43 (defvar cursor-type)
  44 ;; end pacifier
  45
  46
  47 ;; Viper version
  48 (defun viper-version ()
  49   (interactive)
  50   (message "Viper version is %s" viper-version))
  51
  52 ;; Is it XEmacs?
  53 (defconst viper-xemacs-p (string-match "XEmacs" emacs-version))
  54 ;; Is it Emacs?
  55 (defconst viper-emacs-p (not viper-xemacs-p))
  56 ;; Tell whether we are running as a window application or on a TTY
  57
  58 ;; This is used to avoid compilation warnings. When emacs/xemacs forms can
  59 ;; generate compile time warnings, we use this macro.
  60 ;; In this case, the macro will expand into the form that is appropriate to the
  61 ;; compiler at hand.
  62 ;; Suggested by rms.
  63 (defmacro viper-cond-compile-for-xemacs-or-emacs (xemacs-form emacs-form)
  64   (if (string-match "XEmacs" emacs-version)
  65       xemacs-form emacs-form))
  66
  67
  68 (defsubst viper-device-type ()
  69   (viper-cond-compile-for-xemacs-or-emacs
  70    (device-type (selected-device))
  71    window-system
  72    ))
  73
  74 (defun viper-color-display-p ()
  75   (condition-case nil
  76       (viper-cond-compile-for-xemacs-or-emacs
  77        (eq (device-class (selected-device)) 'color) ; xemacs form
  78        (if (fboundp 'display-color-p) ; emacs form
  79            (display-color-p)
  80          (x-display-color-p))
  81         )
  82     (error nil)))
  83
  84 ;; in XEmacs: device-type is tty on tty and stream in batch.
  85 (defun viper-window-display-p ()
  86   (and (viper-device-type) (not (memq (viper-device-type) '(tty stream pc)))))
  87
  88 (defcustom viper-ms-style-os-p (memq system-type
  89                                      '(ms-dos windows-nt windows-95))
  90   "Tells if Emacs is running under an MS-style OS: ms-dos, windows-nt, W95."
  91   :type 'boolean
  92   :tag "Is it Microsoft-made OS?"
  93   :group 'viper-misc)
  94 (defcustom viper-vms-os-p (memq system-type '(vax-vms axp-vms))
  95   "Tells if Emacs is running under VMS."
  96   :type 'boolean
  97   :tag "Is it VMS?"
  98   :group 'viper-misc)
  99
 100 (defcustom viper-force-faces nil
 101   "If t, Viper will think that it is running on a display that supports faces.
 102 This is provided as a temporary relief for users of graphics-capable terminals
 103 that Viper doesn't know about.
 104 In all likelihood, you don't need to bother with this setting."
 105   :type 'boolean
 106   :group 'viper-highlighting)
 107
 108 (defun viper-has-face-support-p ()
 109   (cond ((viper-window-display-p))
 110         (viper-force-faces)
 111         ((viper-color-display-p))
 112         (viper-emacs-p (memq (viper-device-type) '(pc)))
 113         (viper-xemacs-p (memq (viper-device-type) '(tty pc)))))
 114
 115 \f
 116 ;;; Macros
 117
 118 (defmacro viper-deflocalvar (var default-value &optional documentation)
 119   `(progn
 120     (defvar ,var ,default-value
 121       ,(format "%s\n\(buffer local\)" documentation))
 122     (make-variable-buffer-local ',var)))
 123
 124 ;; (viper-loop COUNT BODY) Execute BODY COUNT times.
 125 (defmacro viper-loop (count &rest body)
 126   `(let ((count ,count))
 127     (while (> count 0)
 128       ,@body
 129       (setq count (1- count)))))
 130
 131 (defmacro viper-buffer-live-p (buf)
 132   `(and ,buf (get-buffer ,buf) (buffer-name (get-buffer ,buf))))
 133
 134 ;; return buffer-specific macro definition, given a full macro definition
 135 (defmacro viper-kbd-buf-alist (macro-elt)
 136   `(nth 1 ,macro-elt))
 137 ;; get a pair: (curr-buffer . macro-definition)
 138 (defmacro viper-kbd-buf-pair (macro-elt)
 139   `(assoc (buffer-name) (viper-kbd-buf-alist ,macro-elt)))
 140 ;; get macro definition for current buffer
 141 (defmacro viper-kbd-buf-definition (macro-elt)
 142   `(cdr (viper-kbd-buf-pair ,macro-elt)))
 143
 144 ;; return mode-specific macro definitions, given a full macro definition
 145 (defmacro viper-kbd-mode-alist (macro-elt)
 146   `(nth 2 ,macro-elt))
 147 ;; get a pair: (major-mode . macro-definition)
 148 (defmacro viper-kbd-mode-pair (macro-elt)
 149   `(assoc major-mode (viper-kbd-mode-alist ,macro-elt)))
 150 ;; get macro definition for the current major mode
 151 (defmacro viper-kbd-mode-definition (macro-elt)
 152   `(cdr (viper-kbd-mode-pair ,macro-elt)))
 153
 154 ;; return global macro definition, given a full macro definition
 155 (defmacro viper-kbd-global-pair (macro-elt)
 156   `(nth 3 ,macro-elt))
 157 ;; get global macro definition from an elt of macro-alist
 158 (defmacro viper-kbd-global-definition (macro-elt)
 159   `(cdr (viper-kbd-global-pair ,macro-elt)))
 160
 161 ;; last elt of a sequence
 162 (defsubst viper-seq-last-elt (seq)
 163   (elt seq (1- (length seq))))
 164
 165 (defsubst viper-string-to-list (string)
 166   (append (vconcat string) nil))
 167
 168 (defsubst viper-charlist-to-string (list)
 169   (mapconcat 'char-to-string list ""))
 170
 171 ;; like char-after/before, but saves typing
 172 (defun viper-char-at-pos (direction &optional offset)
 173   (or (integerp offset) (setq offset 0))
 174   (if (eq direction 'forward)
 175       (char-after (+ (point) offset))
 176     (char-before (- (point) offset))))
 177
 178 \f
 179 (defvar viper-minibuffer-overlay-priority 300)
 180 (defvar viper-replace-overlay-priority 400)
 181 (defvar viper-search-overlay-priority 500)
 182
 183 \f
 184 ;;; Viper minor modes
 185
 186 ;; Mode for vital things like \e, C-z.
 187 (viper-deflocalvar viper-vi-intercept-minor-mode nil)
 188
 189 (viper-deflocalvar viper-vi-basic-minor-mode nil
 190   "Viper's minor mode for Vi bindings.")
 191
 192 (viper-deflocalvar viper-vi-local-user-minor-mode nil
 193   "Auxiliary minor mode for user-defined local bindings in Vi state.")
 194
 195 (viper-deflocalvar viper-vi-global-user-minor-mode nil
 196   "Auxiliary minor mode for user-defined global bindings in Vi state.")
 197
 198 (viper-deflocalvar viper-vi-state-modifier-minor-mode nil
 199   "Minor mode used to make major-mode-specific modification to Vi state.")
 200
 201 (viper-deflocalvar viper-vi-diehard-minor-mode nil
 202   "This minor mode is in effect when the user wants Viper to be Vi.")
 203
 204 (viper-deflocalvar viper-vi-kbd-minor-mode nil
 205   "Minor mode for Ex command macros in Vi state.
 206 The corresponding keymap stores key bindings of Vi macros defined with
 207 the Ex command :map.")
 208
 209 ;; Mode for vital things like \e, C-z.
 210 (viper-deflocalvar viper-insert-intercept-minor-mode nil)
 211
 212 (viper-deflocalvar viper-insert-basic-minor-mode nil
 213   "Viper's minor mode for bindings in Insert mode.")
 214
 215 (viper-deflocalvar viper-insert-local-user-minor-mode nil
 216   "Auxiliary minor mode for buffer-local user-defined bindings in Insert state.
 217 This is a way to overshadow normal Insert mode bindings locally to certain
 218 designated buffers.")
 219
 220 (viper-deflocalvar viper-insert-global-user-minor-mode nil
 221   "Auxiliary minor mode for global user-defined bindings in Insert state.")
 222
 223 (viper-deflocalvar viper-insert-state-modifier-minor-mode nil
 224   "Minor mode used to make major-mode-specific modification to Insert state.")
 225
 226 (viper-deflocalvar viper-insert-diehard-minor-mode nil
 227   "Minor mode that simulates Vi very closely.
 228 Not recommened, except for the novice user.")
 229
 230 (viper-deflocalvar viper-insert-kbd-minor-mode nil
 231 "Minor mode for Ex command macros Insert state.
 232 The corresponding keymap stores key bindings of Vi macros defined with
 233 the Ex command :map!.")
 234
 235 (viper-deflocalvar viper-replace-minor-mode nil
 236   "Minor mode in effect in replace state (cw, C, and the like commands).")
 237
 238 ;; Mode for vital things like \C-z and \C-x) This is set to t, when viper-mode
 239 ;; is invoked.  So, any new buffer will have C-z defined as switch to Vi,
 240 ;; unless we switched states in this buffer
 241 (viper-deflocalvar viper-emacs-intercept-minor-mode nil)
 242
 243 (viper-deflocalvar viper-emacs-local-user-minor-mode nil
 244   "Minor mode for local user bindings effective in Emacs state.
 245 Users can use it to override Emacs bindings when Viper is in its Emacs
 246 state.")
 247
 248 (viper-deflocalvar viper-emacs-global-user-minor-mode nil
 249   "Minor mode for global user bindings in effect in Emacs state.
 250 Users can use it to override Emacs bindings when Viper is in its Emacs
 251 state.")
 252
 253 (viper-deflocalvar viper-emacs-kbd-minor-mode nil
 254   "Minor mode for Vi style macros in Emacs state.
 255 The corresponding keymap stores key bindings of Vi macros defined with
 256 `viper-record-kbd-macro' command.  There is no Ex-level command to do this
 257 interactively.")
 258
 259 (viper-deflocalvar viper-emacs-state-modifier-minor-mode nil
 260   "Minor mode used to make major-mode-specific modification to Emacs state.
 261 For instance, a Vi purist may want to bind `dd' in Dired mode to a function
 262 that deletes a file.")
 263
 264 (viper-deflocalvar viper-vi-minibuffer-minor-mode nil
 265    "Minor mode that forces Vi-style when the Minibuffer is in Vi state.")
 266
 267 (viper-deflocalvar viper-insert-minibuffer-minor-mode nil
 268    "Minor mode that forces Vi-style when the Minibuffer is in Insert state.")
 269
 270 \f
 271
 272 ;; Some common error messages
 273
 274 (defconst viper-SpuriousText "Spurious text after command"  "")
 275 (defconst viper-BadExCommand "Not an editor command"   "")
 276 (defconst viper-InvalidCommandArgument "Invalid command argument"   "")
 277 (defconst viper-NoPrevSearch "No previous search string"   "")
 278 (defconst viper-EmptyRegister "`%c': Nothing in this register"   "")
 279 (defconst viper-InvalidRegister "`%c': Invalid register"   "")
 280 (defconst viper-EmptyTextmarker "`%c': Text marker doesn't point anywhere"   "")
 281 (defconst viper-InvalidTextmarker "`%c': Invalid text marker"   "")
 282 (defconst viper-InvalidViCommand "Invalid command"   "")
 283 (defconst viper-BadAddress "Ill-formed address"   "")
 284 (defconst viper-FirstAddrExceedsSecond "First address exceeds second"   "")
 285 (defconst viper-NoFileSpecified "No file specified"   "")
 286
 287 ;; Is t until viper-mode executes for the very first time.
 288 ;; Prevents recursive descend into startup messages.
 289 (defvar viper-first-time t)
 290
 291 (defvar viper-expert-level (if (boundp 'viper-expert-level) viper-expert-level 0)
 292   "User's expert level.
 293 The minor mode viper-vi-diehard-minor-mode is in effect when
 294 viper-expert-level is 1 or 2 or when viper-want-emacs-keys-in-vi is t.
 295 The minor mode viper-insert-diehard-minor-mode is in effect when
 296 viper-expert-level is 1 or 2 or if viper-want-emacs-keys-in-insert is t.
 297 Use `M-x viper-set-expert-level' to change this.")
 298
 299 ;; Max expert level supported by Viper.  This is NOT a user option.
 300 ;; It is here to make it hard for the user from resetting it.
 301 (defconst viper-max-expert-level 5)
 302
 303
 304 ;;; ISO characters and MULE
 305
 306 ;; If non-nil, ISO accents will be turned on in insert/replace emacs states and
 307 ;; turned off in vi-state.  For some users, this behavior may be too
 308 ;; primitive.  In this case, use insert/emacs/vi state hooks.
 309 (viper-deflocalvar viper-automatic-iso-accents nil "")
 310 ;; Set iso-accents-mode to ARG.  Check if it is bound first
 311 (defsubst viper-set-iso-accents-mode (arg)
 312   (if (boundp 'iso-accents-mode)
 313       (setq iso-accents-mode arg)))
 314
 315 ;; Internal flag used to control when viper mule hooks are run.
 316 ;; Don't change this!
 317 (defvar viper-mule-hook-flag t)
 318 ;; If non-nil, the default intl.  input method is turned on.
 319 (viper-deflocalvar viper-special-input-method nil "")
 320
 321 ;; viper hook to run on input-method activation
 322 (defun viper-activate-input-method-action ()
 323   (if (null viper-mule-hook-flag)
 324       ()
 325     (setq viper-special-input-method t)
 326     ;; turn off special input methods in vi-state
 327     (if (eq viper-current-state 'vi-state)
 328         (viper-set-input-method nil))
 329     (if (memq viper-current-state '(vi-state insert-state replace-state))
 330         (message "Viper special input method%s: on"
 331                  (if (or current-input-method default-input-method)
 332                      (format " %S"
 333                              (or current-input-method default-input-method))
 334                    "")))
 335     ))
 336
 337 ;; viper hook to run on input-method deactivation
 338 (defun viper-inactivate-input-method-action ()
 339   (if (null viper-mule-hook-flag)
 340       ()
 341     (setq viper-special-input-method nil)
 342     (if (memq viper-current-state '(vi-state insert-state replace-state))
 343         (message "Viper special input method%s: off"
 344                  (if (or current-input-method default-input-method)
 345                      (format " %S"
 346                              (or current-input-method default-input-method))
 347                    "")))))
 348
 349 (defun viper-inactivate-input-method ()
 350   (cond ((and viper-emacs-p (fboundp 'inactivate-input-method))
 351          (inactivate-input-method))
 352         ((and viper-xemacs-p (boundp 'current-input-method))
 353          ;; XEmacs had broken quil-mode for some time, so we are working around
 354          ;; it here
 355          (setq quail-mode nil)
 356          (if (featurep 'quail)
 357              (quail-delete-overlays))
 358          (setq describe-current-input-method-function nil)
 359          (setq current-input-method nil)
 360          (run-hooks 'input-method-inactivate-hook)
 361          (force-mode-line-update))
 362         ))
 363 (defun viper-activate-input-method ()
 364   (cond ((and viper-emacs-p (fboundp 'activate-input-method))
 365          (activate-input-method default-input-method))
 366         ((featurep 'xemacs)
 367          (if (fboundp 'quail-mode) (quail-mode 1)))))
 368
 369 ;; Set quail-mode to ARG
 370 (defun viper-set-input-method (arg)
 371   (setq viper-mule-hook-flag t) ; just a precaution
 372   (let (viper-mule-hook-flag) ; temporarily inactivate viper mule hooks
 373     (cond ((and arg (> (prefix-numeric-value arg) 0) default-input-method)
 374            ;; activate input method
 375            (viper-activate-input-method))
 376           (t ; deactivate input method
 377            (viper-inactivate-input-method)))
 378     ))
 379
 380
 381 ;; VI-style Undo
 382
 383 ;; Used to 'undo' complex commands, such as replace and insert commands.
 384 (viper-deflocalvar viper-undo-needs-adjustment nil)
 385 (put 'viper-undo-needs-adjustment 'permanent-local t)
 386
 387 ;; A mark that Viper puts on buffer-undo-list.  Marks the beginning of a
 388 ;; complex command that must be undone atomically.  If inserted, it is
 389 ;; erased by viper-change-state-to-vi and viper-repeat.
 390 (defconst viper-buffer-undo-list-mark 'viper)
 391
 392 (defcustom viper-keep-point-on-undo nil
 393   "*Non-nil means not to move point while undoing commands.
 394 This style is different from Emacs and Vi.  Try it to see if
 395 it better fits your working style."
 396   :type 'boolean
 397   :tag "Preserve Position of Point After Undo"
 398   :group 'viper)
 399
 400 ;; Replace mode and changing text
 401
 402 ;; Hack used to pass global states around for short period of time
 403 (viper-deflocalvar viper-intermediate-command nil "")
 404
 405 ;; This is used to pass the right Vi command key sequence to
 406 ;; viper-set-destructive-command whenever (this-command-keys) doesn't give the
 407 ;; right result.  For instance, in commands like c/bla<RET>,
 408 ;; (this-command-keys) will return ^M, which invoked exit-minibuffer, while we
 409 ;; need "c/"
 410 (defconst viper-this-command-keys nil)
 411
 412 ;; Indicates that the current destructive command has started in replace mode.
 413 (viper-deflocalvar viper-began-as-replace nil "")
 414
 415 (defcustom viper-allow-multiline-replace-regions t
 416   "If non-nil, Viper will allow multi-line replace regions.
 417 This is an extension to standard Vi.
 418 If nil, commands that attempt to replace text spanning multiple lines first
 419 delete the text being replaced, as in standard Vi."
 420   :type 'boolean
 421   :group 'viper)
 422
 423 (defcustom viper-replace-overlay-cursor-color "Red"
 424   "*Cursor color when Viper is in Replace state."
 425   :type 'string
 426   :group 'viper)
 427 (if (fboundp 'make-variable-frame-local)
 428     (make-variable-frame-local 'viper-replace-overlay-cursor-color))
 429
 430 (defcustom viper-insert-state-cursor-color "Green"
 431   "Cursor color when Viper is in insert state."
 432   :type 'string
 433   :group 'viper)
 434 (if (fboundp 'make-variable-frame-local)
 435     (make-variable-frame-local 'viper-insert-state-cursor-color))
 436
 437 ;; internal var, used to remember the default cursor color of emacs frames
 438 (defvar viper-vi-state-cursor-color nil)
 439 (if (fboundp 'make-variable-frame-local)
 440     (make-variable-frame-local 'viper-vi-state-cursor-color))
 441
 442 (viper-deflocalvar viper-replace-overlay nil "")
 443 (put 'viper-replace-overlay 'permanent-local t)
 444
 445 (defcustom viper-replace-region-end-delimiter "$"
 446   "A string marking the end of replacement regions.
 447 It is used only with TTYs or if `viper-use-replace-region-delimiters'
 448 is non-nil."
 449   :type 'string
 450   :group 'viper)
 451 (defcustom viper-replace-region-start-delimiter ""
 452   "A string marking the beginning of replacement regions.
 453 It is used only with TTYs or if `viper-use-replace-region-delimiters'
 454 is non-nil."
 455   :type 'string
 456   :group 'viper)
 457 (defcustom viper-use-replace-region-delimiters
 458   (or (not (viper-has-face-support-p))
 459       (and viper-xemacs-p (eq (viper-device-type) 'tty)))
 460   "*If non-nil, Viper will always use `viper-replace-region-end-delimiter' and
 461 `viper-replace-region-start-delimiter' to delimit replacement regions, even on
 462 color displays.  By default, the delimiters are used only on TTYs."
 463   :type 'boolean
 464   :group 'viper)
 465
 466 (defcustom viper-read-buffer-function 'read-buffer
 467   "Function to use for prompting the user for a buffer name."
 468   :type 'symbol
 469   :group 'viper)
 470
 471 ;; XEmacs requires glyphs
 472 (viper-cond-compile-for-xemacs-or-emacs
 473  (progn ; xemacs
 474    (or (glyphp viper-replace-region-end-delimiter)
 475        (setq viper-replace-region-end-delimiter
 476              (make-glyph viper-replace-region-end-delimiter)))
 477    (or (glyphp viper-replace-region-start-delimiter)
 478        (setq viper-replace-region-start-delimiter
 479              (make-glyph viper-replace-region-start-delimiter)))
 480    )
 481   nil ; emacs
 482  )
 483
 484
 485
 486 ;; These are local marker that must be initialized to nil and moved with
 487 ;; `viper-move-marker-locally'
 488 ;;
 489 ;; Remember the last position inside the replace region.
 490 (viper-deflocalvar viper-last-posn-in-replace-region nil)
 491 ;; Remember the last position while inserting
 492 (viper-deflocalvar viper-last-posn-while-in-insert-state nil)
 493 (put 'viper-last-posn-in-replace-region 'permanent-local t)
 494 (put 'viper-last-posn-while-in-insert-state 'permanent-local t)
 495
 496 (viper-deflocalvar viper-sitting-in-replace nil "")
 497 (put 'viper-sitting-in-replace 'permanent-local t)
 498
 499 ;; Remember the number of characters that have to be deleted in replace
 500 ;; mode to compensate for the inserted characters.
 501 (viper-deflocalvar viper-replace-chars-to-delete 0 "")
 502 ;; This variable is used internally by the before/after changed functions to
 503 ;; determine how many chars were deleted by the change.  This can't be
 504 ;; determined inside after-change-functions because those get the length of the
 505 ;; deleted region, not the number of chars deleted (which are two different
 506 ;; things under MULE).
 507 (viper-deflocalvar viper-replace-region-chars-deleted 0 "")
 508
 509 ;; Insertion ring and command ring
 510 (defcustom viper-insertion-ring-size 14
 511   "The size of history of inserted text.
 512 This is a list where Viper keeps the history of previously inserted pieces of
 513 text."
 514   :type 'integer
 515   :group 'viper-misc)
 516 ;; The insertion ring.
 517 (defvar viper-insertion-ring nil)
 518 ;; This is temp insertion ring.  Used to do rotation for display purposes.
 519 ;; When rotation just started, it is initialized to viper-insertion-ring.
 520 (defvar viper-temp-insertion-ring nil)
 521 (defvar viper-last-inserted-string-from-insertion-ring "")
 522
 523 (defcustom viper-command-ring-size 14
 524   "The size of history of Vi commands repeatable with dot."
 525   :type 'integer
 526   :group 'viper-misc)
 527 ;; The command ring.
 528 (defvar viper-command-ring nil)
 529 ;; This is temp command ring.  Used to do rotation for display purposes.
 530 ;; When rotation just started, it is initialized to viper-command-ring.
 531 (defvar viper-temp-command-ring nil)
 532
 533 ;; Fast keyseq and ESC keyseq timeouts
 534 (defcustom viper-fast-keyseq-timeout 200
 535   "*Key sequence separated by no more than this many milliseconds is viewed as a Vi-style macro, if such a macro is defined.
 536 Setting this too high may slow down your typing.  Setting this value too low
 537 will make it hard to use Vi-style timeout macros."
 538   :type 'integer
 539   :group 'viper-misc)
 540
 541 (defcustom viper-ESC-keyseq-timeout (if (viper-window-display-p)
 542                                       0 viper-fast-keyseq-timeout)
 543   "*Key sequence beginning with ESC and separated by no more than this many milliseconds is considered to be generated by a keyboard function key.
 544 Setting this too high may slow down switching from insert to vi state.  Setting
 545 this value too low will make it impossible to use function keys in insert mode
 546 on a dumb terminal."
 547   :type 'integer
 548   :group 'viper-misc)
 549
 550 (defcustom viper-translate-all-ESC-keysequences (not (viper-window-display-p))
 551   "Allow translation of all key sequences into commands.
 552 Normally, Viper lets Emacs translate only those ESC key sequences that are
 553 defined in the low-level key-translation-map or function-key-map, such as those
 554 emitted by the arrow and function keys. Other sequences, e.g., \\e/, are
 555 treated as ESC command followed by a `/'. This is done for people who type fast
 556 and tend to hit other characters right after they hit ESC. Other people like
 557 Emacs to translate ESC sequences all the time.
 558 The default is to translate all sequences only when using a dumb terminal.
 559 This permits you to use ESC as a meta key in insert mode."
 560   :type 'boolean
 561   :group 'viper-misc)
 562
 563 ;; Modes and related variables
 564
 565 ;; Current mode.  One of: `emacs-state', `vi-state', `insert-state'
 566 (viper-deflocalvar viper-current-state 'emacs-state)
 567
 568
 569 ;; Autoindent in insert
 570
 571 ;; Variable that keeps track of whether C-t has been pressed.
 572 (viper-deflocalvar viper-cted nil "")
 573
 574 ;; Preserve the indent value, used by C-d in insert mode.
 575 (viper-deflocalvar viper-current-indent 0)
 576
 577 ;; Whether to preserve the indent, used by C-d in insert mode.
 578 (viper-deflocalvar viper-preserve-indent nil)
 579
 580 (viper-deflocalvar viper-auto-indent nil "")
 581 (defcustom viper-auto-indent nil
 582   "*Enable autoindent, if t.
 583 This is a buffer-local variable."
 584   :type 'boolean
 585   :group 'viper)
 586
 587 (viper-deflocalvar viper-electric-mode t "")
 588 (defcustom viper-electric-mode t
 589   "*If t, electrify Viper.
 590 Currently, this only electrifies auto-indentation, making it appropriate to the
 591 mode of the buffer.
 592 This means that auto-indentation will depart from standard Vi and will indent
 593 appropriate to the mode of the buffer.  This is especially useful for editing
 594 programs and LaTeX documents."
 595   :type 'boolean
 596   :group 'viper)
 597
 598 (defcustom viper-shift-width 8
 599   "*The value of the shiftwidth.
 600 This determines the number of columns by which the Ctl-t moves the cursor in
 601 the Insert state."
 602   :type 'integer
 603   :group 'viper)
 604
 605 ;; Variables for repeating destructive commands
 606
 607 (defcustom viper-keep-point-on-repeat t
 608   "*If t, don't move point when repeating previous command.
 609 This is useful for doing repeated changes with the '.' key.
 610 The user can change this to nil, if she likes when the cursor moves
 611 to a new place after repeating previous Vi command."
 612   :type 'boolean
 613   :group 'viper)
 614
 615 ;; Remember insert point as a marker.  This is a local marker that must be
 616 ;; initialized to nil and moved with `viper-move-marker-locally'.
 617 (viper-deflocalvar viper-insert-point nil)
 618 (put 'viper-insert-point 'permanent-local t)
 619
 620 ;; This remembers the point before dabbrev-expand was called.
 621 ;; If viper-insert-point turns out to be bigger than that, it is reset
 622 ;; back to viper-pre-command-point.
 623 ;; The reason this is needed is because dabbrev-expand (and possibly
 624 ;; others) may jump to before the insertion point, delete something and
 625 ;; then reinsert a bigger piece.  For instance:  bla^blo
 626 ;; If dabbrev-expand is called after `blo' and ^ undicates viper-insert-point,
 627 ;; then point jumps to the beginning of `blo'.  If expansion is found, `blablo'
 628 ;; is deleted, and we have |^, where | denotes point.  Next, dabbrev-expand
 629 ;; will insert the expansion, and we get: blablo^
 630 ;; Whatever we insert next goes before the ^, i.e., before the
 631 ;; viper-insert-point marker.  So, Viper will think that nothing was
 632 ;; inserted.  Remembering the orig position of the marker circumvents the
 633 ;; problem.
 634 ;; We don't know of any command, except dabbrev-expand, that has the same
 635 ;; problem.  However, the same trick can be used if such a command is
 636 ;; discovered later.
 637 ;;
 638 (viper-deflocalvar viper-pre-command-point nil)
 639 (put 'viper-pre-command-point 'permanent-local t) ; this is probably an overkill
 640
 641 ;; This is used for saving inserted text.
 642 (defvar viper-last-insertion  nil)
 643
 644 ;; Remembers the last replaced region.
 645 (defvar viper-last-replace-region "")
 646
 647 ;; Remember com point as a marker.
 648 ;; This is a local marker.  Should be moved with `viper-move-marker-locally'
 649 (viper-deflocalvar viper-com-point nil)
 650
 651 ;; If non-nil, the value is a list (M-COM VAL COM REG inserted-text cmd-keys)
 652 ;; It is used to re-execute last destructive command.
 653 ;; M-COM is a Lisp symbol representing the function to be executed.
 654 ;; VAL is the prefix argument that was used with that command.
 655 ;; COM is an internal descriptor, such as ?r, ?c, ?C, which contains
 656 ;; additional information on how the function in M-COM is to be handled.
 657 ;; REG is the register used by command
 658 ;; INSERTED-TEXT is text inserted by that command (in case of o, c, C, i, r
 659 ;; commands).
 660 ;; COMMAND-KEYS are the keys that were typed to invoke the command.
 661 (defvar viper-d-com nil)
 662
 663 ;; The character remembered by the Vi `r' command.
 664 (defvar viper-d-char nil)
 665
 666 ;; Name of register to store deleted or yanked strings
 667 (defvar viper-use-register nil)
 668
 669
 670 ;;; Variables for Moves and Searches
 671
 672 (defgroup viper-search nil
 673   "Variables that define the search and query-replace behavior of Viper."
 674   :prefix "viper-"
 675   :group 'viper)
 676
 677 ;; For use by `;' command.
 678 (defvar viper-f-char nil)
 679
 680 ;; For use by `.' command.
 681 (defvar viper-F-char nil)
 682
 683 ;; For use by `;' command.
 684 (defvar viper-f-forward nil)
 685
 686 ;; For use by `;' command.
 687 (defvar viper-f-offset nil)
 688
 689 ;; Last search string
 690 (defvar viper-s-string "")
 691
 692 (defcustom viper-quote-string "> "
 693   "String inserted at the beginning of quoted region."
 694   :type 'string
 695   :group 'viper)
 696
 697 ;; If t, search is forward.
 698 (defvar viper-s-forward nil)
 699
 700 (defcustom viper-case-fold-search nil
 701   "*If not nil, search ignores cases."
 702   :type 'boolean
 703   :group 'viper-search)
 704
 705 (defcustom viper-re-search t
 706   "*If not nil, search is regexp search, otherwise vanilla search."
 707   :type 'boolean
 708   :tag "Regexp Search"
 709   :group 'viper-search)
 710
 711 (defcustom viper-search-scroll-threshold 2
 712   "*If search lands within this threshnold from the window top/bottom,
 713 the window will be scrolled up or down appropriately, to reveal context.
 714 If you want Viper search to behave as usual in Vi, set this variable to a
 715 negative number."
 716   :type 'boolean
 717   :group 'viper-search)
 718
 719 (defcustom viper-re-query-replace t
 720   "*If t then do regexp replace, if nil then do string replace."
 721   :type 'boolean
 722   :tag "Regexp Query Replace"
 723   :group 'viper-search)
 724
 725 (defcustom viper-re-replace t
 726   "*If t, do regexp replace.  nil means do string replace."
 727   :type 'boolean
 728   :tag "Regexp Replace"
 729   :group 'viper-search)
 730
 731 (defcustom viper-parse-sexp-ignore-comments t
 732   "*If t, `%' ignores the parentheses that occur inside comments."
 733   :type 'boolean
 734   :group 'viper)
 735
 736 (viper-deflocalvar viper-ex-style-motion t "")
 737 (defcustom viper-ex-style-motion t
 738   "*If t, the commands l,h do not cross lines, etc (Ex-style).
 739 If nil, these commands cross line boundaries."
 740   :type 'boolean
 741   :group 'viper)
 742
 743 (viper-deflocalvar viper-ex-style-editing t "")
 744 (defcustom viper-ex-style-editing t
 745   "*If t, Ex-style behavior while editing in Vi command and insert states.
 746 `Backspace' and `Delete' don't cross line boundaries in insert.
 747 `X' and `x' can't delete characters across line boundary in Vi, etc.
 748 Note: this doesn't preclude `Backspace' and `Delete' from deleting characters
 749 by moving past the insertion point.  This is a feature, not a bug.
 750
 751 If nil, the above commands can work across lines."
 752   :type 'boolean
 753   :group 'viper)
 754
 755 (viper-deflocalvar viper-ESC-moves-cursor-back viper-ex-style-editing "")
 756 (defcustom viper-ESC-moves-cursor-back nil
 757   "*If t, ESC moves cursor back when changing from insert to vi state.
 758 If nil, the cursor stays where it was when ESC was hit."
 759   :type 'boolean
 760   :group 'viper)
 761
 762 (viper-deflocalvar viper-delete-backwards-in-replace nil "")
 763 (defcustom viper-delete-backwards-in-replace nil
 764   "*If t, DEL key will delete characters while moving the cursor backwards.
 765 If nil, the cursor will move backwards without deleting anything."
 766   :type 'boolean
 767   :group 'viper)
 768
 769 (defcustom viper-buffer-search-char nil
 770   "*Key used for buffer-searching.  Must be a character type, e.g., ?g."
 771   :type '(choice (const nil) character)
 772   :group 'viper-search)
 773
 774 (defcustom viper-search-wrap-around-t t
 775   "*If t, search wraps around."
 776   :type 'boolean
 777   :tag "Search Wraps Around"
 778   :group 'viper-search)
 779
 780 (viper-deflocalvar viper-related-files-and-buffers-ring nil "")
 781 (defcustom viper-related-files-and-buffers-ring nil
 782   "*List of file and buffer names that are considered to be related to the current buffer.
 783 Related buffers can be cycled through via :R and :P commands."
 784   :type 'boolean
 785   :group 'viper-misc)
 786 (put 'viper-related-files-and-buffers-ring 'permanent-local t)
 787
 788 ;; Used to find out if we are done with searching the current buffer.
 789 (viper-deflocalvar viper-local-search-start-marker nil)
 790 ;; As above, but global
 791 (defvar viper-search-start-marker (make-marker))
 792
 793 ;; the search overlay
 794 (viper-deflocalvar viper-search-overlay nil)
 795
 796
 797 (defvar viper-heading-start
 798   (concat "^\\s-*(\\s-*defun\\s-\\|"                            ; lisp
 799           "^{\\s-*$\\|^[_a-zA-Z][^()]*[()].*{\\s-*$\\|"         ; C/C++
 800           "^\\s-*class.*{\\|^\\s-*struct.*{\\|^\\s-*enum.*{\\|"
 801           "^\\\\[sb][a-z]*{.*}\\s-*$\\|"                        ; latex
 802           "^@node\\|@table\\|^@m?enu\\|^@itemize\\|^@if\\|"     ; texinfo
 803           "^.+:-")                                              ; prolog
 804   "*Regexps for Headings.  Used by \[\[ and \]\].")
 805
 806 (defvar viper-heading-end
 807   (concat "^}\\|"                                               ; C/C++
 808           "^\\\\end{\\|"                                        ; latex
 809           "^@end \\|"                                           ; texinfo
 810           ")\n\n[ \t\n]*\\|"                                    ; lisp
 811           "\\.\\s-*$")                                          ; prolog
 812       "*Regexps to end Headings/Sections.  Used by \[\].")
 813
 814
 815 ;; These two vars control the interaction of jumps performed by ' and `.
 816 ;; In this new version, '' doesn't erase the marks set by ``, so one can
 817 ;; use both kinds of jumps interchangeably and without loosing positions
 818 ;; inside the lines.
 819
 820 ;; Remembers position of the last jump done using ``'.
 821 (viper-deflocalvar viper-last-jump  nil)
 822 ;; Remembers position of the last jump done using `''.
 823 (viper-deflocalvar viper-last-jump-ignore 0)
 824
 825 ;; History variables
 826
 827 ;; History of search strings.
 828 (defvar viper-search-history  (list ""))
 829 ;; History of query-replace strings used as a source.
 830 (defvar viper-replace1-history nil)
 831 ;; History of query-replace strings used as replacement.
 832 (defvar viper-replace2-history nil)
 833 ;; History of region quoting strings.
 834 (defvar viper-quote-region-history (list viper-quote-string))
 835 ;; History of Ex-style commands.
 836 (defvar viper-ex-history nil)
 837 ;; History of shell commands.
 838 (defvar viper-shell-history nil)
 839
 840
 841 ;; Last shell command.  There are two of these, one for Ex (in viper-ex)
 842 ;; and one for Vi.
 843
 844 ;; Last shell command executed with ! command.
 845 (defvar viper-last-shell-com nil)
 846
 847 \f
 848 ;;; Face-saving tricks
 849
 850 (defun viper-hide-face (face)
 851   (if (and (viper-has-face-support-p) viper-emacs-p)
 852       (add-to-list 'facemenu-unlisted-faces face)))
 853
 854
 855 (defgroup viper-highlighting nil
 856   "Hilighting of replace region, search pattern, minibuffer, etc."
 857   :prefix "viper-"
 858   :group 'viper)
 859
 860
 861 (defface viper-search
 862   '((((class color)) (:foreground "Black" :background "khaki"))
 863     (t (:underline t :stipple "gray3")))
 864   "*Face used to flash out the search pattern."
 865   :group 'viper-highlighting)
 866 ;; An internal variable.  Viper takes the face from here.
 867 (defvar viper-search-face 'viper-search
 868   "Face used to flash out the search pattern.
 869 DO NOT CHANGE this variable.  Instead, use the customization widget
 870 to customize the actual face object `viper-search'
 871 this variable represents.")
 872 (viper-hide-face viper-search-face)
 873
 874
 875 (defface viper-replace-overlay
 876   '((((class color)) (:foreground "Black" :background "darkseagreen2"))
 877     (t (:underline t :stipple "gray3")))
 878   "*Face for highlighting replace regions on a window display."
 879   :group 'viper-highlighting)
 880 ;; An internal variable.  Viper takes the face from here.
 881 (defvar viper-replace-overlay-face 'viper-replace-overlay
 882   "Face for highlighting replace regions on a window display.
 883 DO NOT CHANGE this variable.  Instead, use the customization widget
 884 to customize the actual face object `viper-replace-overlay'
 885 this variable represents.")
 886 (viper-hide-face viper-replace-overlay-face)
 887
 888
 889 (defface viper-minibuffer-emacs
 890   '((((class color)) (:foreground "Black" :background "darkseagreen2"))
 891     (t (:weight bold)))
 892   "Face used in the Minibuffer when it is in Emacs state."
 893   :group 'viper-highlighting)
 894 ;; An internal variable.  Viper takes the face from here.
 895 (defvar viper-minibuffer-emacs-face 'viper-minibuffer-emacs
 896   "Face used in the Minibuffer when it is in Emacs state.
 897 DO NOT CHANGE this variable.  Instead, use the customization widget
 898 to customize the actual face object `viper-minibuffer-emacs'
 899 this variable represents.")
 900 (viper-hide-face viper-minibuffer-emacs-face)
 901
 902
 903 (defface viper-minibuffer-insert
 904   '((((class color)) (:foreground "Black" :background "pink"))
 905     (t (:slant italic)))
 906   "Face used in the Minibuffer when it is in Insert state."
 907   :group 'viper-highlighting)
 908 ;; An internal variable.  Viper takes the face from here.
 909 (defvar viper-minibuffer-insert-face 'viper-minibuffer-insert
 910   "Face used in the Minibuffer when it is in Insert state.
 911 DO NOT CHANGE this variable.  Instead, use the customization widget
 912 to customize the actual face object `viper-minibuffer-insert'
 913 this variable represents.")
 914 (viper-hide-face viper-minibuffer-insert-face)
 915
 916
 917 (defface viper-minibuffer-vi
 918   '((((class color)) (:foreground "DarkGreen" :background "grey"))
 919     (t (:inverse-video t)))
 920   "Face used in the Minibuffer when it is in Vi state."
 921   :group 'viper-highlighting)
 922 ;; An internal variable.  Viper takes the face from here.
 923 (defvar viper-minibuffer-vi-face 'viper-minibuffer-vi
 924   "Face used in the Minibuffer when it is in Vi state.
 925 DO NOT CHANGE this variable.  Instead, use the customization widget
 926 to customize the actual face object `viper-minibuffer-vi'
 927 this variable represents.")
 928 (viper-hide-face viper-minibuffer-vi-face)
 929
 930 ;; the current face to be used in the minibuffer
 931 (viper-deflocalvar
 932   viper-minibuffer-current-face viper-minibuffer-emacs-face "")
 933
 934 \f
 935 ;;; Miscellaneous
 936
 937 (defvar viper-inhibit-startup-message nil
 938   "Whether Viper startup message should be inhibited.")
 939
 940 (defcustom viper-spell-function 'ispell-region
 941   "Spell function used by #s<move> command to spell."
 942   :type 'function
 943   :group 'viper-misc)
 944
 945 (defcustom viper-tags-file-name "TAGS"
 946   "The tags file used by Viper."
 947   :type 'string
 948   :group 'viper-misc)
 949
 950 (defcustom viper-change-notification-threshold 1
 951   "Notify the user when this many lines or characters have been deleted/yanked.
 952 For line-deleting/yanking commands (like `dd', `yy'), the value denotes the
 953 number of lines.  For character-based commands (such as `x', `dw', etc.), the
 954 value refers to the number of characters affected."
 955   :type 'integer
 956   :group 'viper-misc)
 957
 958 ;; Minibuffer
 959
 960 (defcustom viper-vi-style-in-minibuffer t
 961   "If t, use vi-style editing in minibuffer.
 962 Should be set in `~/.viper' file."
 963   :type 'boolean
 964   :group 'viper)
 965
 966 ;; overlay used in the minibuffer to indicate which state it is in
 967 (viper-deflocalvar viper-minibuffer-overlay nil)
 968 (put 'viper-minibuffer-overlay 'permanent-local t)
 969
 970 ;; Hook, specific to Viper, which is run just *before* exiting the minibuffer.
 971 ;; This is needed because beginning with Emacs 19.26, the standard
 972 ;; `minibuffer-exit-hook' is run *after* exiting the minibuffer
 973 (defvar viper-minibuffer-exit-hook nil)
 974
 975
 976 ;; Mode line
 977 (defconst viper-vi-state-id     "<V> "
 978   "Mode line tag identifying the Vi mode of Viper.")
 979 (defconst viper-emacs-state-id  "<E> "
 980   "Mode line tag identifying the Emacs mode of Viper.")
 981 (defconst viper-insert-state-id "<I> "
 982   "Mode line tag identifying the Insert mode of Viper.")
 983 (defconst viper-replace-state-id        "<R> "
 984   "Mode line tag identifying the Replace mode of Viper.")
 985
 986
 987 (defgroup viper-hooks nil
 988   "Viper hooks."
 989   :prefix "viper-"
 990   :group 'viper)
 991
 992 (defcustom viper-vi-state-hook 'viper-restore-cursor-type
 993   "*Hooks run just before the switch to Vi mode is completed."
 994   :type 'hook
 995   :group 'viper-hooks)
 996 (defcustom viper-insert-state-hook 'viper-set-insert-cursor-type
 997   "*Hooks run just before the switch to Insert mode is completed."
 998   :type 'hook
 999   :group 'viper-hooks)
1000 (defcustom viper-replace-state-hook 'viper-restore-cursor-type
1001   "*Hooks run just before the switch to Replace mode is completed."
1002   :type 'hook
1003   :group 'viper-hooks)
1004 (defcustom viper-emacs-state-hook 'viper-restore-cursor-type
1005   "*Hooks run just before the switch to Emacs mode is completed."
1006   :type 'hook
1007   :group 'viper-hooks)
1008
1009 (defcustom viper-load-hook nil
1010   "Hooks run just after loading Viper."
1011   :type 'hook
1012   :group 'viper-hooks)
1013
1014 (defun viper-restore-cursor-type ()
1015   (condition-case nil
1016       (if viper-xemacs-p
1017           (set (make-local-variable 'bar-cursor) nil)
1018         (setq cursor-type default-cursor-type))
1019     (error nil)))
1020
1021 (defun viper-set-insert-cursor-type ()
1022   (if viper-xemacs-p
1023       (set (make-local-variable 'bar-cursor) 2)
1024     (setq cursor-type '(bar . 2))))
1025
1026
1027 ;; Local Variables:
1028 ;; eval: (put 'viper-deflocalvar 'lisp-indent-hook 'defun)
1029 ;; End:
1030
1031 ;; arch-tag: 4efa2416-1fcb-4690-be10-1a2a0248d250
1032 ;;; viper-init.el ends here