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

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