lisp/emulation/viper-init.el

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