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