xemacs-beta: lisp/viper/viper.el comparison

comparison lisp/viper/viper.el @ 78:c7528f8e288d r20-0b34

Import from CVS: tag r20-0b34

author	cvs
date	Mon, 13 Aug 2007 09:05:42 +0200
parents	131b0175ea99
children	1ce6082ce73f

comparison

equal deleted inserted replaced

-:6cb4f478e7bc
+:c7528f8e288d
 ;;  Keywords: emulations
 ;;  Author: Michael Kifer <kifer@cs.sunysb.edu>
 ;; Copyright (C) 1994, 1995, 1996 Free Software Foundation, Inc.
-(defconst viper-version "2.90 of June 19, 1996"
+(defconst viper-version "2.91 of August 5, 1996"
 "The current version of Viper")
 ;; This file is part of GNU Emacs.
 ;; GNU Emacs is free software; you can redistribute it and/or modify
 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ;; GNU General Public License for more details.
 ;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING.  If not, write to
+;; along with GNU Emacs; see the file COPYING.  If not, write to the
-;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
 ;;; Commentary:
 ;; Viper is a full-featured Vi emulator for Emacs 19.  It emulates and
 ;; improves upon the standard features of Vi and, at the same time, allows
 ;;    macros. Third, in Viper, one can define macros that are specific to
 ;;    a given buffer, a given major mode, or macros defined for all buffers.
 ;;    The same macro name can have several different definitions:
 ;;    one global, several definitions for various major modes, and
 ;;    definitions for specific buffers.
-;;    Bffer-specific definitions override mode-specific
+;;    Buffer-specific definitions override mode-specific
 ;;    definitions, which, in turn, override global definitions.
 ;;
 ;;
 ;;; Installation:
 ;;  -------------
 ;;  (require 'viper)
 ;;
 ;;; Acknowledgements:
 ;;  -----------------
-;;  Bug reports and ideas contributed by the following users
+;;  Bug reports and ideas contributed by many users have helped
-;;  have helped improve Viper and the various versions of VIP.
+;;  improve Viper and the various versions of VIP.
 ;;  See the on-line manual for a complete list of contributors.
 ;;
 ;;
 ;;; Notes:
 ;;
 ;;  in their .vip file. This will enable vip-vi-diehard-minor-mode. This
 ;;  minor mode's bindings make Viper simulate the usual Vi very closely.
 ;;  For instance,  C-c will not have its standard Emacs binding
 ;;  and so many of the goodies of Emacs are not available.
 ;;
-;;  An skilled user, should set vip-expert-level to at least 3. This will
+;;  A skilled user should set vip-expert-level to at least 3. This will
-;;  enable ;;  C-c and many Emacs facilities will become available.
+;;  enable `C-c; and many Emacs facilities will become available.
 ;;  In this case, vip-vi-diehard-minor-mode is inactive.
 ;;
 ;;  Viper gurus should have at least
 ;;      (setq vip-expert-level 4)
 ;;  in their ~/.vip files. This will unsuppress all Emacs keys that are not
 (defvar vip-saved-user-settings nil)
 ;;; Viper minor modes
-;; This is not local in Emacs, so we make it local.
+;; This must be local because although the stack of minor modes can be the same
+;; for all buffers, the associated *keymaps* can be different. In Viper,
+;; vip-vi-local-user-map, vip-insert-local-user-map, and others can have
+;; different keymaps for different buffers.
+;; Also, the keymaps associated with vip-vi/insert-state-modifier-minor-mode
+;; can be different.
 (make-variable-buffer-local 'minor-mode-map-alist)
 ;; Mode for vital things like \e, C-z.
 (vip-deflocalvar vip-vi-intercept-minor-mode nil)
 (vip-deflocalvar vip-began-as-replace nil "")
 (defvar vip-replace-overlay-cursor-color "Red"
 "*Cursor color to use in Replace state")
+(defvar vip-insert-state-cursor-color nil
+"Cursor color for Viper insert state.")
+(put 'vip-insert-state-cursor-color 'permanent-local t)
+;; place to save cursor colow when switching to insert mode
+(vip-deflocalvar vip-saved-cursor-color nil "")
 (vip-deflocalvar vip-replace-overlay nil "")
 (put 'vip-replace-overlay 'permanent-local t)
-(if (vip-has-face-support-p)
+(defvar vip-replace-overlay-pixmap "gray3"
-(progn
+"Pixmap to use for search face on non-color displays.")
-(make-face 'vip-replace-overlay-face)
+(defvar vip-search-face-pixmap "gray3"
-(vip-hide-face 'vip-replace-overlay-face)
+"Pixmap to use for search face on non-color displays.")
-(or (face-differs-from-default-p 'vip-replace-overlay-face)
-	  (progn
-	    (if (vip-can-use-colors "darkseagreen2" "Black")
+(defun vip-set-replace-overlay-face ()
-		(progn
+(if (vip-has-face-support-p)
-		  (set-face-background
+(defvar vip-replace-overlay-face
-		   'vip-replace-overlay-face "darkseagreen2")
+	(progn
-		  (set-face-foreground 'vip-replace-overlay-face "Black")))
+	  (make-face 'vip-replace-overlay-face)
-	    (set-face-underline-p 'vip-replace-overlay-face t))
+	  (vip-hide-face 'vip-replace-overlay-face)
-	  )))
+	(or (face-differs-from-default-p 'vip-replace-overlay-face)
+	    (progn
-(defvar vip-replace-overlay-face 'vip-replace-overlay-face
+	      (if (vip-can-use-colors "darkseagreen2" "Black")
-"*Face for highlighting replace regions on a window display.")
+		  (progn
+		    (set-face-background
+		     'vip-replace-overlay-face "darkseagreen2")
+		    (set-face-foreground 'vip-replace-overlay-face "Black")))
+	      (set-face-underline-p 'vip-replace-overlay-face t)
+	      (vip-set-face-pixmap
+	       'vip-replace-overlay-face vip-replace-overlay-pixmap)))
+	'vip-replace-overlay-face)
+	"*Face for highlighting replace regions on a window display.")
+))
 (defvar vip-replace-region-end-delimiter "$"
 "A string marking the end of replacement regions.
 It is used only with TTYs or if `vip-use-replace-region-delimiters'
 is non-nil.")
 (defvar vip-replace-region-start-delimiter ""
 "A string marking the beginning of replacement regions.
 It is used only with TTYs or if `vip-use-replace-region-delimiters'
 is non-nil.")
-(defvar vip-use-replace-region-delimiters
+(defvar vip-use-replace-region-delimiters (not (vip-has-face-support-p))
-(or (not (vip-has-face-support-p)) (not (vip-color-display-p)))
 "*If non-nil, Viper will always use `vip-replace-region-end-delimiter' and
 `vip-replace-region-start-delimiter' to delimit replacement regions, even on
-color displays. By default, the delimiters are used only on TTYs or
+color displays. By default, the delimiters are used only on TTYs.")
-monochrome displays.")
 ;; XEmacs requires glyphs
 (if vip-xemacs-p
 (progn
 (or (glyphp vip-replace-region-end-delimiter)
 ;; Modes and related variables
 ;; Current mode.  One of: `emacs-state', `vi-state', `insert-state'
 (vip-deflocalvar vip-current-state 'emacs-state)
-(defvar vip-toggle-key "\C-z"
-"The key used to change states from emacs to Vi and back.
-In insert mode, this key also functions as Meta.
-Must be set in .vip file or prior to loading Viper.
-This setting cannot be changed interactively.")
-(defvar vip-ESC-key "\e"
-"Key used to ESC.
-Must be set in .vip file or prior to loading Viper.
-This setting cannot be changed interactively.")
 (defvar vip-no-multiple-ESC  t
 "*If true, multiple ESC in Vi mode will cause bell to ring.
-\_ is then mapped to Meta.
 This is set to t on a windowing terminal and to 'twice on a dumb
 terminal (unless the user level is 1, 2, or 5). On a dumb terminal, this
 enables cursor keys and is generally more convenient, as terminals usually
 don't have a convenient Meta key.
 Setting vip-no-multiple-ESC to nil will allow as many multiple ESC,
 ;; If t, search is forward.
 (defvar vip-s-forward nil)
 (defconst vip-case-fold-search nil
-"*If t, search ignores cases.")
+"*If not nil, search ignores case.")
 (defconst vip-re-search t
-"*If t, search is reg-exp search, otherwise vanilla search.")
+"*If not nil, search is reg-exp search, otherwise vanilla search.")
+(defvar vip-adjust-window-after-search t
+"*If not nil, pull the window up or down, depending on the direction of the
+search, if search ends up near the bottom or near the top of the window.")
 (defconst vip-re-query-replace t
 "*If t then do regexp replace, if nil then do string replace.")
 (defconst vip-re-replace t
 "Whether Viper startup message should be inhibited.")
 (defvar vip-always t
 "t means, arrange that vi-state will be a default.")
-(defvar vip-ms-style-os-p (memq system-type '(ms-dos windows-nt windows-95))
+(defvar vip-custom-file-name (vip-convert-standard-file-name "~/.vip")
-"Tells is Emacs is running under an MS-style OS: ms-dos, window-nt, W95.")
-(defvar vip-vms-os-p (memq system-type '(vax-vms axp-vms))
-"Tells if Emacs is running under VMS.")
-(defvar vip-custom-file-name (cond (vip-vms-os-p "sys$login:.vip")
-				   ((memq system-type '(emx ms-dos))
-				    "/_vip")
-				   ((memq system-type '(windows-nt windows-95))
-				    "~/_vip")
-				   (t ; Unix
-				    "~/.vip"))
 "Viper customisation file.
 This variable must be set _before_ loading Viper.")
 (defvar vip-spell-function 'ispell-region
 				     ?; ?, ?0 ?? ?/
 				     )
 				     "Movement commands")
 (vip-test-com-defun vip-movement-command)
-;; Commands that can be repeated by .(dotted)
+;; Commands that can be repeated by . (dotted)
 (defconst vip-dotable-commands '(?c ?d ?C ?D ?> ?<))
 (vip-test-com-defun vip-dotable-command)
 ;; Commands that can follow a #
 (defconst vip-hash-cmds '(?c ?C ?g ?q ?S))
 ;; Commands that may have registers as prefix
 (defconst vip-regsuffix-commands '(?d ?y ?Y ?D ?p ?P ?x ?X))
 (vip-test-com-defun vip-regsuffix-command)
+(defconst vip-vi-commands (append vip-movement-commands
+				  vip-dotable-commands
+				  vip-charpair-commands
+				  vip-hash-cmds
+				  vip-prefix-commands
+				  vip-regsuffix-commands)
+"The list of all commands in Vi-state.")
+(vip-test-com-defun vip-vi-command)
 ;;; Arrange the keymaps
 (require 'viper-keym)
 (defsubst vip-insert-state-post-command-sentinel ()
 (if (and (memq vip-current-state '(insert-state replace-state))
 	   vip-insert-point
 	   (>= (point) vip-insert-point))
 (setq vip-last-posn-while-in-insert-state (point-marker)))
+(if (eq vip-current-state 'insert-state)
+(progn
+	(or (stringp vip-saved-cursor-color)
+	    (string= (vip-get-cursor-color) vip-insert-state-cursor-color)
+	    (setq vip-saved-cursor-color (vip-get-cursor-color)))
+	(if (stringp vip-saved-cursor-color)
+	    (vip-change-cursor-color vip-insert-state-cursor-color))
+	))
 (if (and (eq this-command 'dabbrev-expand)
 	   (integerp vip-pre-command-point)
 	   (> vip-insert-point vip-pre-command-point))
 (move-marker vip-insert-point vip-pre-command-point))
 )
 (defsubst vip-insert-state-pre-command-sentinel ()
+(or (memq this-command '(self-insert-command))
+(memq (vip-event-key last-command-event)
+	    '(up down left right (meta f) (meta b)
+		 (control n) (control p) (control f) (control b)))
+(vip-restore-cursor-color-after-insert))
 (if (and (eq this-command 'dabbrev-expand)
 	   (markerp vip-insert-point)
 	   (marker-position vip-insert-point))
 (setq vip-pre-command-point (marker-position vip-insert-point))))
 ;; the point outside the replacement region, then the cursor color will
 ;; remain red. Restoring the default, below, prevents this.
 (if (and (<= (vip-replace-start) (point))
 	   (<=  (point) (vip-replace-end)))
 (vip-change-cursor-color vip-replace-overlay-cursor-color)
-(vip-restore-cursor-color)
+(vip-restore-cursor-color-after-replace)
 ))
 ;; to speed up, don't change cursor color before self-insert
 ;; and common move commands
 (defsubst vip-replace-state-pre-command-sentinel ()
 ;;
 ;; We optimize for self-insert-command's here, since they either don't change
 ;; cursor color or, if they terminate replace mode, the color will be changed
 ;; in vip-finish-change
 (or (memq this-command '(self-insert-command))
-(vip-restore-cursor-color))
+(vip-restore-cursor-color-after-replace))
 (cond
 ((eq vip-current-state 'replace-state)
 ;; delete characters to compensate for inserted chars.
 (let ((replace-boundary (vip-replace-end)))
 (save-excursion
 	 (setq vip-insert-diehard-minor-mode
 	       (not vip-want-emacs-keys-in-insert))
 	 (if vip-want-ctl-h-help
 	     (progn
-	       (define-key vip-insert-basic-map "\C-h" 'help-command)
+	       (define-key vip-insert-basic-map [(control h)] 'help-command)
-	       (define-key vip-replace-map "\C-h" 'help-command))
+	       (define-key vip-replace-map [(control h)] 'help-command))
 	   (define-key vip-insert-basic-map
-	     "\C-h" 'vip-del-backward-char-in-insert)
+	     [(control h)] 'vip-del-backward-char-in-insert)
 	   (define-key vip-replace-map
-	     "\C-h" 'vip-del-backward-char-in-replace)))
+	     [(control h)] 'vip-del-backward-char-in-replace)))
-	(t
+	(t ; Vi state
 	 (setq vip-vi-diehard-minor-mode (not vip-want-emacs-keys-in-vi))
 	 (if vip-want-ctl-h-help
-	     (define-key vip-vi-basic-map "\C-h" 'help-command)
+	     (define-key vip-vi-basic-map [(control h)] 'help-command)
-	   (define-key vip-vi-basic-map "\C-h" 'vip-backward-char)))
+	   (define-key vip-vi-basic-map [(control h)] 'vip-backward-char)))
 	))
 ;; Normalizes minor-mode-map-alist by putting Viper keymaps first.
 ;; This ensures that Viper bindings are in effect, regardless of which minor
 do not cause Emacs to quit, except at user level 1 (a novice).
 3. ^X^C EXITS EMACS.
 4. Viper supports multiple undo: `u' will undo. Typing `.' will repeat
 undo. Another `u' changes direction.
-6. Emacs Meta functions are invoked by typing `_' or `\\ ESC'.
+6. Emacs Meta functions are invoked by typing `C-\\' or `\\ ESC'.
 On a window system, the best way is to use the Meta-key.
 7. Try \\[keyboard-quit] and \\[abort-recursive-edit] repeatedly,if
 something funny happens. This would abort the current editing command.
 You can get more information on Viper by:
 ;; always turn off iso-accents-mode, or else we won't be able to use the
 ;; keys `,',^ in Vi state, as they will do accents instead of Vi actions.
 (if (and (boundp 'iso-accents-mode) iso-accents-mode)
 	(iso-accents-mode -1))
+(vip-restore-cursor-color-after-insert)
 ;; Protection against user errors in hooks
 (condition-case conds
 	(run-hooks 'vip-vi-state-hook)
 (error
 (vip-message-conditions conds)))))
 (interactive)
 (vip-change-state 'insert-state)
 (if (and vip-automatic-iso-accents (fboundp 'iso-accents-mode))
 (iso-accents-mode 1)) ; turn iso accents on
+(or (stringp vip-saved-cursor-color)
+(string= (vip-get-cursor-color) vip-insert-state-cursor-color)
+(setq vip-saved-cursor-color (vip-get-cursor-color)))
+;; Commented out, because if vip-change-state-to-insert is executed
+;; non-interactively then the old cursor color may get lost. Same old Emacs
+;; bug related to local variables?
+;;;(if (stringp vip-saved-cursor-color)
+;;;      (vip-change-cursor-color vip-insert-state-cursor-color))
 ;; Protection against user errors in hooks
 (condition-case conds
 (run-hooks 'vip-insert-state-hook)
 (error
 (vip-message-conditions conds))))
 (defun vip-escape-to-emacs (arg &optional events)
 "Escape to Emacs state from Vi state for one Emacs command.
 ARG is used as the prefix value for the executed command.  If
 EVENTS is a list of events, which become the beginning of the command."
 (interactive "P")
+(if (= last-command-char ?\\)
+(message "Switched to EMACS state for the next command..."))
 (vip-escape-to-state arg events 'emacs-state))
 ;; escape to Vi mode termporarily
-(defun vip-escape-to-vi ()
+(defun vip-escape-to-vi (arg)
 "Escape from Emacs state to Vi state for one Vi 1-character command.
-This doesn't work with prefix arguments or most complex commands like
+If the Vi command that the user types has a prefix argument, e.g., `d2w', then
-cw, dw,  etc. But it does work with some 2-character commands,
+Vi's prefix argument will be used. Otherwise, the prefix argument passed to
-like dd or dr."
+`vip-escape-to-vi' is used."
-(interactive)
+(interactive "P")
-(vip-escape-to-state nil nil 'vi-state))
+(message "Switched to VI state for the next command...")
+(vip-escape-to-state arg nil 'vi-state))
 ;; Escape to STATE mode for one Emacs command.
 (defun vip-escape-to-state (arg events state)
-(let (com key prefix-arg)
+;;(let (com key prefix-arg)
+(let (com key)
 ;; this temporarily turns off Viper's minor mode keymaps
 (vip-set-mode-vars-for state)
 (vip-normalize-minor-mode-map-alist)
 (if events (vip-set-unread-command-events events))
 ;; protect against keyboard quit and other errors
 (condition-case nil
-	(progn
+	(let (vip-vi-kbd-minor-mode
+	      vip-insert-kbd-minor-mode
+	      vip-emacs-kbd-minor-mode)
 	  (unwind-protect
 	      (progn
 		(setq com (key-binding (setq key
 					     (if vip-xemacs-p
 						 (read-key-sequence nil)
 					       (read-key-sequence nil t)))))
-		;; In case of indirection--chase definitions.
+		;; In case of binding indirection--chase definitions.
 		;; Have to do it here because we execute this command under
 		;; different keymaps, so command-execute may not do the
 		;; right thing there
 		(while (vectorp com) (setq com (key-binding com))))
 	    nil)
-	  ;; exec command in the right Viper state
+	  ;; Execute command com in the original Viper state, not in state
-	  ;; otherwise, if we switch buffers in the escaped command,
+	  ;; `state'. Otherwise, if we switch buffers while executing the
-	  ;; Viper's mode vars will remain those of `state'. When we return
+	  ;; escaped to command, Viper's mode vars will remain those of
-	  ;; to the orig buffer, the bindings will be screwed up.
+	  ;; `state'. When we return to the orig buffer, the bindings will be
+	  ;; screwed up.
 	  (vip-set-mode-vars-for vip-current-state)
 	  ;; this-command, last-command-char, last-command-event
 	  (setq this-command com)
 	  (if vip-xemacs-p ; XEmacs represents key sequences as vectors
 	    (setq last-command-event (vip-seq-last-elt key)
 		  last-command-char last-command-event))
 	  (if (commandp com)
 	      (progn
-		(setq prefix-arg arg)
+		(setq prefix-arg (or prefix-arg arg))
 		(command-execute com)))
 	  )
 (quit (ding))
 (error (beep 1))))
-(vip-set-mode-vars-for vip-current-state)) ; set state in new buffer
+;; set state in the new buffer
+(vip-set-mode-vars-for vip-current-state))
+(defun vip-exec-form-in-vi  (form)
+"Execute FORM in Vi state, regardless of the Ccurrent Vi state."
+(let ((buff (current-buffer))
+	result)
+(vip-set-mode-vars-for 'vi-state)
+(setq result (eval form))
+(if (not (equal buff (current-buffer))) ; cmd switched buffer
+	(save-excursion
+	  (set-buffer buff)
+	  (vip-set-mode-vars-for vip-current-state)))
+(vip-set-mode-vars-for vip-current-state)
+result))
 (defun vip-exec-form-in-emacs  (form)
 "Execute FORM in Emacs, temporarily disabling Viper's minor modes.
 Similar to vip-escape-to-emacs, but accepts forms rather than keystrokes."
 (let ((buff (current-buffer))
 	result)
 )
 (defun vip-ESC (arg)
 "Emulate ESC key in Emacs.
-Prevents multiple escape keystrokes if vip-no-multiple-ESC is true. In that
+Prevents multiple escape keystrokes if vip-no-multiple-ESC is true.
-case \@ will be bound to ESC. If vip-no-multiple-ESC is 'twice double ESC
+If vip-no-multiple-ESC is 'twice double ESC would ding in vi-state.
-would dings in vi-state. Other ESC sequences are emulated via the current
+Other ESC sequences are emulated via the current Emacs's major mode
-Emacs's major mode keymap. This is more convenient on dumb terminals and in
+keymap. This is more convenient on TTYs, since this won't block
-Emacs -nw, since this won't block functional keys such as up,down,
+function keys such as up,down, etc. ESC will also will also work as
-etc. Meta key also will work. When vip-no-multiple-ESC is nil, ESC key
+a Meta key in this case. When vip-no-multiple-ESC is nil, ESC functions
-behaves as in Emacs, any number of multiple escapes is allowed."
+as a Meta key and any number of multiple escapes is allowed."
 (interactive "P")
 (let (char)
 (cond ((and (not vip-no-multiple-ESC) (eq vip-current-state 'vi-state))
 	   (setq char (vip-read-char-exclusive))
 	   (vip-escape-to-emacs arg (list ?\e char) ))
 	       (ding)
 	     (vip-escape-to-emacs arg (list ?\e char) )))
 	  (t (ding)))
 ))
-(defun vip-alternate-ESC (arg)
+(defun vip-alternate-Meta-key (arg)
-"ESC key without checking for multiple keystrokes."
+"Simulate Emacs Meta key."
 (interactive "P")
 (vip-escape-to-emacs arg '(?\e)))
+(defun vip-toggle-key-action ()
+"Action bound to `vip-toggle-key'."
+(interactive)
+(if (and (< vip-expert-level 2) (equal vip-toggle-key "\C-z"))
+(if (vip-window-display-p)
+	  (vip-iconify)
+	(suspend-emacs))
+(vip-change-state-to-emacs)))
 ;; Intercept ESC sequences on dumb terminals.
 ;; Based on the idea contributed by Marcelino Veiga Tuimil <mveiga@dit.upm.es>
 ;; Check if last key was ESC and if so try to reread it as a function key.
 	  ((equal com ?y) ?Y)
 	  (t com))))
 ;; Compute numeric prefix arg value.
-;; Invoked by CHAR. COM is the command part obtained so far.
+;; Invoked by EVENT. COM is the command part obtained so far.
 (defun vip-prefix-arg-value (event com)
-(let (value)
+(let (value func)
 ;; read while number
 (while (and (vip-characterp event) (>= event ?0) (<= event ?9))
 (setq value (+ (* (if (vip-characterp value) value 0) 10) (- event ?0)))
 (setq event (vip-read-event-convert-to-char)))
 (setq prefix-arg value)
 (if com (setq prefix-arg (cons prefix-arg com)))
 (while (eq event ?U)
 (vip-describe-arg prefix-arg)
 (setq event (vip-read-event-convert-to-char)))
-(vip-set-unread-command-events event)))
+(if (or com (and (not (eq vip-current-state 'vi-state))
+		     ;; make sure it is a Vi command
+		     (vip-characterp event) (vip-vi-command-p event)
+		     ))
+	;; If appears to be one of the vi commands,
+	;; then execute it with funcall and clear prefix-arg in order to not
+	;; confuse subsequent commands
+	(progn
+	  ;; last-command-char is the char we want emacs to think was typed
+	  ;; last. If com is not nil, the vip-digit-argument command was called
+	  ;; from within vip-prefix-arg command, such as `d', `w', etc., i.e.,
+	  ;; the user typed, say, d2. In this case, `com' would be `d', `w',
+	  ;; etc.
+	  ;; If vip-digit-argument was invoked by vip-escape-to-vi (which is
+	  ;; indicated by the fact that the current state is not vi-state,
+	  ;; then `event' represents the vi command to be executed (e.g., `d',
+	  ;; `w', etc. Again, last-command-char must make emacs believe that
+	  ;; this is the command we typed.
+	  (setq last-command-char (or com event))
+	  (setq func (vip-exec-form-in-vi
+		      (` (key-binding (char-to-string (, event))))))
+	  (funcall func prefix-arg)
+	  (setq prefix-arg nil))
+;; some other command -- let emacs do it in its own way
+(vip-set-unread-command-events event))
+))
 ;; Vi operator as prefix argument."
 (defun vip-prefix-arg-com (char value com)
-(let ((cont t))
+(let ((cont t)
+	cmd-info mv-or-digit-cmd)
 (while (and cont
 		(memq char
 		      (list ?c ?d ?y ?! ?< ?> ?= ?# ?r ?R ?\"
 			    vip-buffer-search-char)))
 (if com
 		     (setq vip-use-register reg)
 		   (error ""))
 		 (setq char (read-char))))
 	      (t
 	       (setq com char)
-	       (setq char (vip-read-char-exclusive)))))))
+	       (setq char (vip-read-char-exclusive))))))
 (if (atom com)
-;; com is a single char, so we construct prefix-arg
+;; `com' is a single char, so we construct the command argument
-;; and if char is ?, describe prefix arg, otherwise exit by
+;; and if `char' is `?', we describe the arg; otherwise
-;; pushing the char back into vip-set-unread-command-events
+;; we prepare the command that will be executed at the end.
-;; Since char is a command, the command will execute with the prefix
-;; argument that we just constructed.
 (progn
-	(setq prefix-arg (cons value com))
+	(setq cmd-info (cons value com))
 	(while (= char ?U)
-	  (vip-describe-arg prefix-arg)
+	  (vip-describe-arg cmd-info)
 	  (setq char (read-char)))
-	(vip-set-unread-command-events char)
+	;; `char' is a movement command or a digit arg command---so we execute
-	)
+	;; it at the very end
+	(setq mv-or-digit-cmd
+	      (vip-exec-form-in-vi
+	       (` (key-binding (char-to-string (, char)))))))
 ;; as com is non-nil, this means that we have a command to execute
 (if (memq (car com) '(?r ?R))
 	;; execute apropriate region command.
 	(let ((char (car com)) (com (cdr com)))
 	  (setq prefix-arg (cons value com))
 	    ((equal com '(?y . ?y)) (vip-line (cons value ?Y)))
 	    ((equal com '(?< . ?<)) (vip-line (cons value ?<)))
 	    ((equal com '(?> . ?>)) (vip-line (cons value ?>)))
 	    ((equal com '(?! . ?!)) (vip-line (cons value ?!)))
 	    ((equal com '(?= . ?=)) (vip-line (cons value ?=)))
-	    (t (error ""))))))
+	    (t (error "")))))
+(if mv-or-digit-cmd
+(progn
+	(setq last-command-char char)
+	(funcall mv-or-digit-cmd cmd-info)))
+))
 (defun vip-describe-arg (arg)
 (let (val com)
 (setq val (vip-P-val arg)
 	  com (vip-getcom arg))
 (defun vip-digit-argument (arg)
 "Begin numeric argument for the next command."
 (interactive "P")
 (vip-leave-region-active)
-(vip-prefix-arg-value last-command-char
+(vip-prefix-arg-value
-			(if (consp arg) (cdr arg) nil)))
+last-command-char (if (consp arg) (cdr arg) nil)))
 (defun vip-command-argument (arg)
 "Accept a motion command as an argument."
 (interactive "P")
 (condition-case nil
 (forward-line 1)))
 ;;  Tells whether BEG is on the same line as END.
 ;;  If one of the args is nil, it'll return nil.
 (defun vip-same-line (beg end)
-(let ((selective-display nil))
+(let ((selective-display nil)
-(cond ((and beg end)
+	 (incr 0)
-	    ;; This 'if' is needed because Emacs treats the next empty line
+	 temp)
-	    ;; as part of the previous line.
+(if (and beg end (> beg end))
-	    (if (or (> beg (point-max)) (> end (point-max))) ; out of range
+	 (setq temp beg
-		()
+	       beg end
-	      (if (and (> end beg) (= (vip-line-pos 'start) end))
+	       end temp))
-		  (setq end (min (1+ end) (point-max))))
+(if (and beg end)
-	      (if (and (> beg end) (= (vip-line-pos 'start) beg))
+	 (cond ((or (> beg (point-max)) (> end (point-max))) ; out of range
-		  (setq beg (min (1+ beg) (point-max))))
+		nil)
-	      (<= (count-lines beg end) 1) ))
+	       (t
+		;; This 'if' is needed because Emacs treats the next empty line
-	   (t nil))
+		;; as part of the previous line.
-	 ))
+		(if (= (vip-line-pos 'start) end)
+		    (setq incr 1))
+		(<= (+ incr (count-lines beg end)) 1))))
+))
 ;; Check if the string ends with a newline.
 (defun vip-end-with-a-newline-p (string)
 (or (string= string "")
 (= (vip-seq-last-elt string) ?\n)))
 	      ;; face wasn't set in .vip or .Xdefaults
 	      (if (vip-can-use-colors "Black" "khaki")
 		  (progn
 		    (set-face-background 'vip-search-face "khaki")
 		    (set-face-foreground 'vip-search-face "Black"))
-		(copy-face 'italic 'vip-search-face)
+		(set-face-underline-p 'vip-search-face t)
-		(set-face-underline-p 'vip-search-face t)))
+		(vip-set-face-pixmap 'vip-search-face vip-search-face-pixmap)))
 	  'vip-search-face)
 "*Face used to flash out the search pattern.")
 ))
 	(if vip-auto-indent
 	    (progn
 	      (setq vip-cted t)
 	      (if vip-electric-mode
 		  (indent-according-to-mode)
-		(indent-to col))
+		(indent-to col))))
-	      ))
+	(vip-change-state-to-insert)))))
-	(vip-change-state-to-insert)
-	))))
 (defun vip-Open-line (arg)
 "Open line above."
 (interactive "P")
 (vip-set-complex-command-for-undo)
 (vip-remove-hook 'vip-before-change-functions 'vip-replace-mode-spy-before)
 (vip-remove-hook 'vip-post-command-hooks
 		   'vip-replace-state-post-command-sentinel)
 (vip-remove-hook
 'vip-pre-command-hooks 'vip-replace-state-pre-command-sentinel)
-(vip-restore-cursor-color)
+(vip-restore-cursor-color-after-replace)
 (setq vip-sitting-in-replace nil) ; just in case we'll need to know it
 (save-excursion
 (if (and
 	 vip-replace-overlay
 	 (>= posn (vip-replace-start))
 (defun vip-line-to-bottom (arg)
 "Put current line on the last line."
 (interactive "p")
 (recenter (- (window-height) (1+ arg))))
+;; If vip-adjust-window-after-search is t, scroll up or down 1/4 of window
+;; height, depending on whether we are at the bottom or at the top of the
+;; window. This function is called by vip-search (which is called from
+;; vip-search-forward/backward/next)
+(defun vip-adjust-window ()
+(let ((win-height (if vip-emacs-p
+			(1- (window-height)) ; adjust for modeline
+		      (window-displayed-height)))
+	(pt (point))
+	at-top-p at-bottom-p
+	min-scroll direction)
+(save-excursion
+(move-to-window-line 0) ; top
+(setq at-top-p (<= (count-lines pt (point)) 2))
+(move-to-window-line -1) ; bottom
+(setq at-bottom-p (<= (count-lines pt (point)) 2))
+)
+(cond (at-top-p (setq min-scroll 1
+			  direction  1))
+	  (at-bottom-p (setq min-scroll 2
+			     direction -1)))
+(if (and vip-adjust-window-after-search min-scroll)
+	(recenter
+	 (* (max min-scroll (/ win-height 7)) direction)))
+))
 ;; paren match
 ;; must correct this to only match ( to ) etc. On the other hand
 ;; it is good that paren match gets confused, because that way you
 ;; catch _all_ imbalances.
 (defun vip-paren-match (arg)
 "Go to the matching parenthesis."
 (interactive "P")
+(vip-leave-region-active)
 (let ((com (vip-getcom arg))
-	anchor-point)
+	parse-sexp-ignore-comments anchor-point)
 (if (integerp arg)
 	(if (or (> arg 99) (< arg 1))
 	    (error "Prefix must be between 1 and 99")
 	  (goto-char
 	   (if (> (point-max) 80000)
 ;; scrolling
 (setq scroll-step 1)
-(defun vip-scroll (arg)
+(defun vip-scroll-screen (arg)
 "Scroll to next screen."
 (interactive "p")
-(if (> arg 0)
+(condition-case nil
-(while (> arg 0)
+(if (> arg 0)
-	(scroll-up)
+	  (while (> arg 0)
-	(setq arg (1- arg)))
+	    (scroll-up)
-(while (> 0 arg)
+	    (setq arg (1- arg)))
-(scroll-down)
+	(while (> 0 arg)
-(setq arg (1+ arg)))))
+	  (scroll-down)
+	  (setq arg (1+ arg))))
-(defun vip-scroll-back (arg)
+(error (beep 1)
+	   (if (> arg 0)
+	       (progn
+		 (message "End of buffer")
+		 (goto-char (point-max)))
+	     (message "Beginning of buffer")
+	     (goto-char (point-min))))
+))
+(defun vip-scroll-screen-back (arg)
 "Scroll to previous screen."
 (interactive "p")
-(vip-scroll (- arg)))
+(vip-scroll-screen (- arg)))
 (defun vip-scroll-down (arg)
 "Pull down half screen."
 (interactive "P")
 (condition-case nil
 	     (setq msg "Search becomes vanilla-style")))
 	  (t
 	   (setq msg "Search style remains unchanged")))
 (prin1 msg t)))
+(defun vip-set-vi-search-style-macros (unset)
+"Set the macros for toggling the search style in Viper's vi-state.
+The macro that toggles case sensitivity is bound to `//', and the one that
+toggles regexp search is bound to `///'.
+With a prefix argument, this function unsets the macros. "
+(interactive "P")
+(or noninteractive
+(if (not unset)
+	  (progn
+	    ;; toggle case sensitivity in search
+	    (vip-record-kbd-macro
+	     "//" 'vi-state
+	     [1 (meta x) v i p - t o g g l e - s e a r c h - s t y l e return]
+	     't)
+	    ;; toggle regexp/vanila search
+	    (vip-record-kbd-macro
+	     "///" 'vi-state
+	     [2 (meta x) v i p - t o g g l e - s e a r c h - s t y l e return]
+	     't)
+	    (if (interactive-p)
+		(message
+		 "// and /// now toggle case-sensitivity and regexp search.")))
+	(vip-unrecord-kbd-macro "//" 'vi-state)
+	(sit-for 2)
+	(vip-unrecord-kbd-macro "///" 'vi-state))))
+(defun vip-set-emacs-search-style-macros (unset &optional arg-majormode)
+"Set the macros for toggling the search style in Viper's emacs-state.
+The macro that toggles case sensitivity is bound to `//', and the one that
+toggles regexp search is bound to `///'.
+With a prefix argument, this function unsets the macros.
+If the optional prefix argument is non-nil and specifies a valid major mode,
+this sets the macros only in the macros in that major mode. Otherwise,
+the macros are set in the current major mode.
+\(When unsetting the macros, the second argument has no effect.\)"
+(interactive "P")
+(or noninteractive
+(if (not unset)
+	  (progn
+	    ;; toggle case sensitivity in search
+	    (vip-record-kbd-macro
+	     "//" 'emacs-state
+	     [1 (meta x) v i p - t o g g l e - s e a r c h - s t y l e return]
+	     (or arg-majormode major-mode))
+	    ;; toggle regexp/vanila search
+	    (vip-record-kbd-macro
+	     "///" 'emacs-state
+	     [2 (meta x) v i p - t o g g l e - s e a r c h - s t y l e return]
+	     (or arg-majormode major-mode))
+	    (if (interactive-p)
+		(message
+		 "// and /// now toggle case-sensitivity and regexp search.")))
+	(vip-unrecord-kbd-macro "//" 'emacs-state)
+	(sit-for 2)
+	(vip-unrecord-kbd-macro "///" 'emacs-state))))
 (defun vip-search-forward (arg)
 "Search a string forward.
 ARG is used to find the ARG's occurrence of the string.
 Null string will repeat previous search."
 		    (progn
 		      (re-search-forward string nil nil val)
 		      (re-search-backward string))
 		  (search-forward string nil nil val)
 		  (search-backward string))
-		;; don't wait and don't flash in macros
-		(or executing-kbd-macro
-		    (vip-flash-search-pattern))
 		(if (not (equal start-point (point)))
 		    (push-mark start-point t)))
 	    (search-failed
 	     (if (and (not fail-if-not-found) vip-search-wrap-around-t)
 	         (progn
-		   (message "Search wrapped around end of buffer")
+		   (message "Search wrapped around BOTTOM of buffer")
 		   (goto-char (point-min))
 		   (vip-search string forward (cons 1 com) t start-point 'fail)
 		   ;; don't wait in macros
 		   (or executing-kbd-macro (sit-for 2))
 		   ;; delete the wrap-around message
 (condition-case nil
 	    (progn
 	      (if vip-re-search
 		  (re-search-backward string nil nil val)
 	        (search-backward string nil nil val))
-	      ;; don't wait and don't flash in macros
-	      (or executing-kbd-macro
-		  (vip-flash-search-pattern))
 	      (if (not (equal start-point (point)))
 		  (push-mark start-point t)))
 	  (search-failed
 	   (if (and (not fail-if-not-found) vip-search-wrap-around-t)
 	       (progn
-		 (message "Search wrapped around beginning of buffer")
+		 (message "Search wrapped around TOP of buffer")
 	         (goto-char (point-max))
 	         (vip-search string forward (cons 1 com) t start-point 'fail)
 		 ;; don't wait in macros
 		 (or executing-kbd-macro (sit-for 2))
 		 ;; delete the wrap-around message
 		 )
 	     (goto-char start-point)
 	     (error "`%s': %s not found"
 		    string
 		    (if vip-re-search "Pattern" "String"))
-	     )))))))
+	     ))))
+;; pull up or down if at top/bottom of window
+(vip-adjust-window)
+;; highlight the result of search
+;; don't wait and don't highlight in macros
+(or executing-kbd-macro
+	  (vip-flash-search-pattern))
+)))
 (defun vip-search-next (arg)
 "Repeat previous search."
 (interactive "P")
 (let ((val (vip-p-val arg))
 	      (error vip-EmptyRegister reg))
 	  (error "")))
 (setq vip-use-register nil)
 (if (vip-end-with-a-newline-p text)
 	(progn
+	  (end-of-line)
 	  (if (eobp)
 	      (insert "\n")
 	    (forward-line 1))
 	  (beginning-of-line))
 (if (not (eolp)) (vip-forward-char-carefully)))
 	((and (not skip-white) (= char ?`))
 	 (if com (vip-move-marker-locally 'vip-com-point (point)))
 	 (if (and (vip-same-line (point) vip-last-jump)
 		  (= (point) vip-last-jump-ignore))
 	     (goto-char vip-last-jump))
+	 (if (null (mark t)) (error "Mark is not set in this buffer"))
 	 (if (= (point) (mark t)) (pop-mark))
 	 (exchange-point-and-mark)
 	 (setq vip-last-jump (point-marker)
 	       vip-last-jump-ignore 0)
 	 (if com (vip-execute-com 'vip-goto-mark nil com)))
 (if (memq last-command
 	      '(vip-autoindent
 		vip-open-line vip-Open-line
 		vip-replace-state-exit-cmd))
 	(indent-to-left-margin))
-(newline 1)
+;; use \n instead of newline, or else <Return> will move the insert point
+;;(newline 1)
+(insert "\n")
 (if vip-auto-indent
 	(progn
 	  (setq vip-cted t)
 	  (if vip-electric-mode
 	      (indent-according-to-mode)
 (setq vip-always          	    	t
 	vip-ex-style-motion 	    	t
 	vip-ex-style-editing-in-insert  t
 	vip-want-ctl-h-help nil)
-(cond
+(cond ((eq vip-expert-level 1) ; novice or beginner
-	;; a novice or a beginner
+	 (global-set-key   ; in emacs-state
-	((eq vip-expert-level 1)
+	  vip-toggle-key
-	 (global-set-key vip-toggle-key   ;; in emacs-state
+	  (if (vip-window-display-p) 'vip-iconify 'suspend-emacs))
-			 (if (vip-window-display-p)
-			     'vip-iconify
-			   'suspend-emacs))
 	 (setq vip-no-multiple-ESC	     t
 	       vip-re-search	    	     t
 	       vip-vi-style-in-minibuffer    t
 	       vip-search-wrap-around-t	     t
 	       vip-want-emacs-keys-in-vi     nil
 	       vip-want-emacs-keys-in-insert nil))
-	;; an intermediate to guru
 	((and (> vip-expert-level 1) (< vip-expert-level 5))
+	 ;; an intermediate to guru
 	 (setq vip-no-multiple-ESC     (if (vip-window-display-p) t 'twice)
 	       vip-want-emacs-keys-in-vi     t
 	       vip-want-emacs-keys-in-insert (> vip-expert-level 2))
 	 (if (eq vip-expert-level 4) ; respect user's ex-style motions
 		     (cdr (assoc 'vip-re-search vip-saved-user-settings))
 		     vip-no-multiple-ESC
 		     (cdr (assoc 'vip-no-multiple-ESC
 				 vip-saved-user-settings))))))
-	;; A wizard
+	;; A wizard!!
 	;; Ideally, if 5 is selected, a buffer should pop up to let the
-	;; user toggle variable values.
+	;; user toggle the values of variables.
 	(t (setq-default vip-ex-style-editing-in-insert
 			 (cdr (assoc 'vip-ex-style-editing-in-insert
 				     vip-saved-user-settings))
 			 vip-ex-style-motion
 			 (cdr (assoc 'vip-ex-style-motion
 ;;; Load .vip and set up hooks
 ;; This hook designed to enable Vi-style editing in comint-based modes."
 (defun vip-comint-mode-hook ()
-(setq require-final-newline nil)
+(setq require-final-newline nil
-(setq vip-ex-style-editing-in-insert nil
+	vip-ex-style-editing-in-insert nil
 	vip-ex-style-motion nil)
-(vip-add-local-keys 'vi-state
+(vip-change-state-to-insert))
-		      '(("\C-m" . comint-send-input) ; return
-			("\C-d" . comint-delchar-or-maybe-eof))) ; \C-d
-(vip-add-local-keys 'insert-state
-		      '(("\C-m" . comint-send-input) ; return
-			("\C-d" . comint-delchar-or-maybe-eof))) ; \C-d
-)
 ;; This sets major mode hooks to make them come up in vi-state.
 (defun vip-set-hooks ()
 ;; It is of course a misnomer to call viper-mode a `major mode'.
 (defvar html-mode-hook)
 (add-hook 'html-mode-hook 'viper-mode)
 (defvar html-helper-mode-hook)
 (add-hook 'html-helper-mode-hook 'viper-mode)
+(defvar java-mode-hook)
+(add-hook 'java-mode-hook 'viper-mode)
 (defvar emacs-lisp-mode-hook)
 (add-hook 'emacs-lisp-mode-hook 'viper-mode)
 (defvar lisp-mode-hook)
 (add-hook 'lisp-mode-hook 'viper-mode)
 (add-hook 'lisp-interaction-mode-hook 'viper-mode)
 (defvar fortran-mode-hook)
 (add-hook 'fortran-mode-hook 'vip-mode)
+(defvar basic-mode-hook)
+(add-hook 'basic-mode-hook 'vip-mode)
+(defvar bat-mode-hook)
+(add-hook 'bat-mode-hook 'vip-mode)
 (defvar text-mode-hook)
 (add-hook 'text-mode-hook 'viper-mode)
 (add-hook 'completion-list-mode-hook 'viper-mode)
 (add-hook 'compilation-mode-hook     'viper-mode)
 (add-hook 'perl-mode-hook     'viper-mode)
 (add-hook 'tcl-mode-hook     'viper-mode)
 (defvar emerge-startup-hook)
 (add-hook 'emerge-startup-hook 'vip-change-state-to-emacs)
-;; Run vip-change-state-to-vi after quitting emerge.
+;; Tell vc-diff to put *vc* in Vi mode
+(if (featurep 'vc)
+(defadvice vc-diff (after vip-vc-ad activate)
+	"Force Vi state in VC diff buffer."
+	(vip-change-state-to-vi))
+(vip-eval-after-load
+"vc"
+'(defadvice vc-diff (after vip-vc-ad activate)
+	"Force Vi state in VC diff buffer."
+	(vip-change-state-to-vi))))
 (vip-eval-after-load
 "emerge"
 '(defadvice emerge-quit (after vip-emerge-advice activate)
 "Run `vip-change-state-to-vi' after quitting emerge."
 (vip-change-state-to-vi)))
 "Switch to Vi state in Prolog mode."
 (vip-change-state-to-vi)))
 ;; Emacs shell, ange-ftp, and comint-based modes
 (defvar comint-mode-hook)
-(add-hook 'comint-mode-hook 'vip-change-state-to-insert)
+(vip-modify-major-mode
+'comint-mode 'insert-state vip-comint-mode-modifier-map)
+(vip-modify-major-mode
+'comint-mode 'vi-state vip-comint-mode-modifier-map)
+(vip-modify-major-mode
+'shell-mode 'insert-state vip-comint-mode-modifier-map)
+(vip-modify-major-mode
+'shell-mode 'vi-state vip-comint-mode-modifier-map)
+;; ange-ftp in XEmacs
+(vip-modify-major-mode
+'ange-ftp-shell-mode 'insert-state vip-comint-mode-modifier-map)
+(vip-modify-major-mode
+'ange-ftp-shell-mode 'vi-state vip-comint-mode-modifier-map)
+;; ange-ftp in Emacs
+(vip-modify-major-mode
+'internal-ange-ftp-mode 'insert-state vip-comint-mode-modifier-map)
+(vip-modify-major-mode
+'internal-ange-ftp-mode 'vi-state vip-comint-mode-modifier-map)
+;; set hook
 (add-hook 'comint-mode-hook 'vip-comint-mode-hook)
 ;; Shell scripts
 (defvar sh-mode-hook)
 (add-hook 'sh-mode-hook 'viper-mode)
 (defvar ksh-mode-hook)
 (add-hook 'ksh-mode-hook 'viper-mode)
 ;; Dired
-;; This is only necessary when the user uses vip-modify-major-mode
+(vip-modify-major-mode 'dired-mode 'emacs-state vip-dired-modifier-map)
+(vip-set-emacs-search-style-macros nil 'dired-mode)
 (add-hook 'dired-mode-hook 'vip-change-state-to-emacs)
+;; Tar
+(vip-modify-major-mode 'tar-mode 'emacs-state vip-slash-and-colon-map)
+(vip-set-emacs-search-style-macros nil 'tar-mode)
+;; MH-E
+(vip-modify-major-mode 'mh-folder-mode 'emacs-state vip-slash-and-colon-map)
+(vip-set-emacs-search-style-macros nil 'mh-folder-mode)
+;; changing state to emacs is needed so the preceding will take hold
+(add-hook 'mh-folder-mode-hook 'vip-change-state-to-emacs)
+(add-hook 'mh-show-mode-hook 'viper-mode)
+;; Gnus
+(vip-modify-major-mode 'gnus-group-mode 'emacs-state vip-slash-and-colon-map)
+(vip-set-emacs-search-style-macros nil 'gnus-group-mode)
+(vip-modify-major-mode
+'gnus-summary-mode 'emacs-state vip-slash-and-colon-map)
+(vip-set-emacs-search-style-macros nil 'gnus-summary-mode)
+;; changing state to emacs is needed so the preceding will take hold
+(add-hook 'gnus-group-mode-hook 'vip-change-state-to-emacs)
+(add-hook 'gnus-summary-mode-hook 'vip-change-state-to-emacs)
+(add-hook 'gnus-article-mode-hook 'viper-mode)
+;; Info
+(vip-modify-major-mode 'Info-mode 'emacs-state vip-slash-and-colon-map)
+(vip-set-emacs-search-style-macros nil 'Info-mode)
+;; Switching to emacs is needed  so the above will take hold
+(defadvice Info-mode (after vip-Info-ad activate)
+"Switch to emacs mode."
+(vip-change-state-to-emacs))
+;; Buffer menu
+(vip-modify-major-mode
+'Buffer-menu-mode 'emacs-state vip-slash-and-colon-map)
+(vip-set-emacs-search-style-macros nil 'Buffer-menu-mode)
+;; Switching to emacs is needed  so the above will take hold
+(defadvice Buffer-menu-mode (after vip-Buffer-menu-ad activate)
+"Switch to emacs mode."
+(vip-change-state-to-emacs))
+;; View mode
 (if vip-emacs-p
 (progn
 	(defvar view-mode-hook)
 	(add-hook 'view-mode-hook 'vip-change-state-to-emacs))
 (defadvice view-minor-mode (after vip-view-ad activate)
 ;; repeat the 3d previous command without rotating the command history
 (vip-record-kbd-macro
 (vector vip-repeat-from-history-key '\2) 'vi-state
 [(meta x) v i p - r e p e a t - f r o m - h i s t o r y return] 't)
-;; toggle case sensitivity in search
+;; set the toggle case sensitivity and regexp search macros
-(vip-record-kbd-macro
+(vip-set-vi-search-style-macros nil)
-"//" 'vi-state
-[1 (meta x) v i p - t o g g l e - s e a r c h - s t y l e return] 't)
-;; toggle regexp/vanila search
-(vip-record-kbd-macro
-"///" 'vi-state
-[2 (meta x) v i p - t o g g l e - s e a r c h - s t y l e return] 't)
 ;; ~/.vip is loaded if it exists
 (if (and (file-exists-p vip-custom-file-name)
 	 (not noninteractive))
 (load vip-custom-file-name))
 (vip-set-minibuffer-style)
 (vip-set-minibuffer-faces)
 (vip-set-search-face)
+(vip-set-replace-overlay-face)
 (if vip-buffer-search-char
 (vip-buffer-search-enable))
 (vip-update-alphanumeric-class)
 ;;; Familiarize Viper with some minor modes that have their own keymaps
 (define-key vip-insert-intercept-map vip-ESC-key 'vip-intercept-ESC-key)
 ;; This is taken care of by vip-insert-global-user-map.
 ;;(define-key vip-replace-map vip-ESC-key 'vip-intercept-ESC-key)
-(define-key vip-insert-intercept-map vip-toggle-key 'vip-alternate-ESC)
 ;; The default vip-toggle-key is \C-z; for the novice, it suspends or
 ;; iconifies Emacs
-(define-key vip-vi-intercept-map vip-toggle-key
+(define-key vip-vi-intercept-map vip-toggle-key 'vip-toggle-key-action)
-'(lambda () (interactive)
-(if (and (< vip-expert-level 2) (equal vip-toggle-key "\C-z"))
-	 (if (vip-window-display-p) (vip-iconify) (suspend-emacs))
-(vip-change-state-to-emacs))))
 (define-key vip-emacs-intercept-map vip-toggle-key 'vip-change-state-to-vi)
 (if (or vip-always
 	(and (< vip-expert-level 5) (> vip-expert-level 0)))

Mercurial > hg > xemacs-beta

comparison lisp/viper/viper.el @ 78:c7528f8e288d r20-0b34