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