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