* viper-ex.el (ex-token-list,ex-cmd-execute): Revamped, courtesy

	of Scott Bronson.
	(ex-cmd-assoc,ex-compile,ex-cmd-one-letr): New functions.
	(viper-check-sub,viper-get-ex-command,viper-execute-ex-command):
	Deleted functions.
	(viper-get-ex-com-subr,viper-ex,ex-mark): Changed to use the new
	ex-token-list.
	(viper-get-ex-address-subr): convert registers to char data type.

	* viper-util.el (viper-int-to-char,viper-char-equal): new
	functions.
	(viper-memq-char): use viper-int-to-char.
	(viper-file-checked-in-p): use vc-locking-user, if vc doesn't have
	vc-locking-state.
	(viper-read-key): use viper-read-key-sequence.

	* viper.el (viper-major-mode-modifier-list): added
	inferior-emacs-lisp-mode.
	(this-major-mode-requires-vi-state): new function that uses simple
	heuristics to decide if vi state is appropriate.
	(set-viper-state-in-major-mode): use this-major-mode-requires-vi-state.
	(viper-non-hook-settings): don't advise read-key-sequence.
	(viper-read-key-sequence): new function that replaces the
	previously used advice to read-key-sequence.

	* viper-cmd.el (viper-test-com-defun,viper-exec-change,
	viper-exec-Change,viper-execute-com,viper-insert,viper-append,
	viper-Append,viper-Insert,viper-open-line,viper-Open-line,
	viper-open-line-at-point,viper-substitute,viper-overwrite,
	viper-replace-char-subr,viper-forward-word,viper-forward-Word):
	got rid of the negative character hack.
	(viper-escape-to-state,viper-replace-state-exit-cmd):
	use viper-read-key-sequence.
	(viper-envelop-ESC-key): no need for ad-get-orig-definition.
	(viper-minibuffer-standard-hook,viper-read-string-with-history):
	don't override existing minibuffer-setup-hook.
	(viper-mark-point,viper-goto-mark-subr,viper-brac-function):
	convert registers to char data type.
	(viper-autoindent): use viper-indent-line.

	* viper-keym.el: use viper-exec-key-in-emacs.

	* viper.texi: Added credits, new commands, like :make.

	* ediff-util.el: Copyright years.
	(ediff-choose-syntax-table): New function.
	(ediff-setup): Use ediff-choose-syntax-table.
	(ediff-file-checked-out-p,ediff-file-checked-in-p): check if
	vc-state is available.
	(ediff-make-temp-file): use ediff-coding-system-for-write.

	* ediff-init.el (ediff-with-syntax-table): New macro, uses
	with-syntax-table.
	(ediff-coding-system-for-read): from ediff-diff.el
	(ediff-coding-system-for-write): new variable.
	(ediff-highest-priority): fixed the bug having to do with disappearing
	overlays.
	(ediff-file-remote-p): use file-remote-p, if available.
	(ediff-listable-file): new function.
	(ediff-file-attributes): use ediff-listable-file.

	* ediff-mult.el (ediff-meta-insert-file-info1): use
	ediff-listable-file.

	* ediff-ptch.el (ediff-prompt-for-patch-file): use
	ediff-coding-system-for-read.
	(ediff-patch-file-internal): use ediff-coding-system-for-write.

	* ediff-diff.el (ediff-coding-system-for-read): moved to ediff-init.el.
	(ediff-match-diff3-line,ediff-get-diff3-group): improved pattern.

	* ediff.el: Date of last update, copyright years.

	* ediff-wind (ediff-setup-control-frame): Nill->nil.

	* ediff.texi: added clarifications, acknowledgements.

12 files changed, 342 insertions, 179 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 2f14c6eedeb..55ad54cfcdd 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,78 @@
+2001-07-21  Michael Kifer  <kifer@cs.sunysb.edu>
+        
+        * ediff-util.el: Copyright years.
+        (ediff-choose-syntax-table): New function.
+        (ediff-setup): Use ediff-choose-syntax-table.
+        (ediff-file-checked-out-p,ediff-file-checked-in-p): check if
+        vc-state is available.
+        (ediff-make-temp-file): use ediff-coding-system-for-write.
+        
+        * ediff-init.el (ediff-with-syntax-table): New macro, uses
+        with-syntax-table.
+        (ediff-coding-system-for-read): from ediff-diff.el
+        (ediff-coding-system-for-write): new variable.
+        (ediff-highest-priority): fixed the bug having to do with disappearing
+        overlays.
+        (ediff-file-remote-p): use file-remote-p, if available.
+        (ediff-listable-file): new function.
+        (ediff-file-attributes): use ediff-listable-file.
+        
+        * ediff-mult.el (ediff-meta-insert-file-info1): use
+        ediff-listable-file.
+        
+        * ediff-ptch.el (ediff-prompt-for-patch-file): use
+        ediff-coding-system-for-read.
+        (ediff-patch-file-internal): use ediff-coding-system-for-write.
+        
+        * ediff-diff.el (ediff-coding-system-for-read): moved to ediff-init.el.
+        (ediff-match-diff3-line,ediff-get-diff3-group): improved pattern.
+        
+        * ediff.el: Date of last update, copyright years.
+        
+        * ediff-wind (ediff-setup-control-frame): Nill->nil.
+        
+        * viper-ex.el (ex-token-list,ex-cmd-execute): Revamped, courtesy
+        of Scott Bronson.
+        (ex-cmd-assoc,ex-compile,ex-cmd-one-letr): New functions.
+        (viper-check-sub,viper-get-ex-command,viper-execute-ex-command):
+        Deleted functions.
+        (viper-get-ex-com-subr,viper-ex,ex-mark): Changed to use the new
+        ex-token-list.
+        (viper-get-ex-address-subr): convert registers to char data type.
+        
+        * viper-util.el (viper-int-to-char,viper-char-equal): new
+        functions.
+        (viper-memq-char): use viper-int-to-char.
+        (viper-file-checked-in-p): use vc-locking-user, if vc doesn't have
+        vc-locking-state.
+        (viper-read-key): use viper-read-key-sequence.
+        
+        * viper.el (viper-major-mode-modifier-list): added
+        inferior-emacs-lisp-mode.
+        (this-major-mode-requires-vi-state): new function that uses simple
+        heuristics to decide if vi state is appropriate.
+        (set-viper-state-in-major-mode): use this-major-mode-requires-vi-state.
+        (viper-non-hook-settings): don't advise read-key-sequence.
+        (viper-read-key-sequence): new function that replaces the
+        previously used advice to read-key-sequence.
+        
+        * viper-cmd.el (viper-test-com-defun,viper-exec-change,
+        viper-exec-Change,viper-execute-com,viper-insert,viper-append,
+        viper-Append,viper-Insert,viper-open-line,viper-Open-line,
+        viper-open-line-at-point,viper-substitute,viper-overwrite,
+        viper-replace-char-subr,viper-forward-word,viper-forward-Word):
+        got rid of the negative character hack.
+        (viper-escape-to-state,viper-replace-state-exit-cmd):
+        use viper-read-key-sequence.
+        (viper-envelop-ESC-key): no need for ad-get-orig-definition.
+        (viper-minibuffer-standard-hook,viper-read-string-with-history):
+        don't override existing minibuffer-setup-hook.
+        (viper-mark-point,viper-goto-mark-subr,viper-brac-function):
+        convert registers to char data type. 
+        (viper-autoindent): use viper-indent-line.
+        
+        * viper-keym.el: use viper-exec-key-in-emacs. 
+        
 2001-07-20  Stefan Monnier  <monnier@cs.yale.edu>
 
         * server.el (server-visit-files): Fix variable name typo.
diff --git a/lisp/ediff-diff.el b/lisp/ediff-diff.el
index f2b2687c0c5..128737c4df3 100644
--- a/lisp/ediff-diff.el
+++ b/lisp/ediff-diff.el
@@ -57,15 +57,6 @@ Must produce output compatible with Unix's diff3 program."
   :type 'string
   :group 'ediff-diff)
 
-(defcustom ediff-coding-system-for-read 'raw-text
-  "*The coding system for read to use when running the diff program as a subprocess. 
-In most cases, the default will do. However, under certain circumstances in
-Windows NT/98/95 you might need to use something like 'raw-text-dos here.
-So, if the output that your diff program sends to Emacs contains extra ^M's,
-you might need to experiment here, if the default or 'raw-text-dos doesn't
-work."
-  :type 'symbol
-  :group 'ediff-diff)
 
 ;; The following functions must precede all defcustom-defined variables.
 
@@ -153,7 +144,7 @@ This output is not used by Ediff internally."
 
 ;;; Support for diff3
 
-(defvar ediff-match-diff3-line "^====\\(.?\\)$"
+(defvar ediff-match-diff3-line "^====\\(.?\\)\C-m?$"
   "Pattern to match lines produced by diff3 that describe differences.")
 (defcustom ediff-diff3-options ""  
   "*Options to pass to `ediff-diff3-program'."
@@ -918,7 +909,7 @@ delimiter regions"))
   ;; can produce the groups in the order 1, 2, 3 or 1, 3, 2.
   (save-excursion
     (re-search-forward
-     (concat "^" file ":\\([0-9]+\\)\\(,\\([0-9]+\\)\\)?\\([ac]\\)$"))
+     (concat "^" file ":\\([0-9]+\\)\\(,\\([0-9]+\\)\\)?\\([ac]\\)\C-m?$"))
     (beginning-of-line 2)
     ;; treatment depends on whether it is an "a" group or a "c" group
     (if (string-equal (buffer-substring (match-beginning 4) (match-end 4)) "c")
diff --git a/lisp/ediff-init.el b/lisp/ediff-init.el
index 4594445a89f..fa8e0e9b794 100644
--- a/lisp/ediff-init.el
+++ b/lisp/ediff-init.el
@@ -1,4 +1,4 @@
-;;; ediff-init.el --- macros, variables, and defsubsts used by Ediff
+;;; ediff-init.el --- Macros, variables, and defsubsts used by Ediff
 
 ;; Copyright (C) 1994, 1995, 1996, 1997, 2000 Free Software Foundation, Inc.
 
@@ -714,6 +714,22 @@ appropriate symbol: `rcs', `pcl-cvs', or `generic-sc' if you so desire."
   :type 'symbol
   :group 'ediff)
 
+(defcustom ediff-coding-system-for-read 'raw-text
+  "*The coding system for read to use when running the diff program as a subprocess. 
+In most cases, the default will do. However, under certain circumstances in
+Windows NT/98/95 you might need to use something like 'raw-text-dos here.
+So, if the output that your diff program sends to Emacs contains extra ^M's,
+you might need to experiment here, if the default or 'raw-text-dos doesn't
+work."
+  :type 'symbol
+  :group 'ediff)
+
+(defcustom ediff-coding-system-for-write 'no-conversion
+  "*The coding system for write to use when writing out difference regions
+to temp files when Ediff needs to find fine differences."
+  :type 'symbol
+  :group 'ediff)
+
 
 (if ediff-xemacs-p
     (progn
@@ -1174,7 +1190,7 @@ this variable represents.")
 (ediff-defvar-local ediff-current-diff-overlay-Ancestor nil
   "Overlay for the current difference region in the ancestor buffer.")
 
-;; Compute priority of ediff overlay.
+;; Compute priority of a current ediff overlay.
 (defun ediff-highest-priority (start end buffer)
   (let ((pos (max 1 (1- start)))
         ovr-list)
@@ -1184,13 +1200,21 @@ this variable represents.")
         (while (< pos (min (point-max) (1+ end)))
           (setq ovr-list (append (overlays-at pos) ovr-list))
           (setq pos (next-overlay-change pos)))
-        (1+ (apply '+
-                   (mapcar (lambda (ovr)
-                             (if ovr
-                                 (or (ediff-overlay-get ovr 'priority) 0)
-                               0))
-                           ovr-list)
-                   ))
+        (+ 1 ediff-shadow-overlay-priority
+           (apply 'max
+                  (mapcar
+                   (lambda (ovr)
+                     (if (and ovr
+                              ;; exclude ediff overlays from priority
+                              ;; calculation, or else priority will keep
+                              ;; increasing
+                              (null (ediff-overlay-get ovr 'ediff))
+                              (null (ediff-overlay-get ovr 'ediff-diff-num)))
+                         ;; use the overlay priority or 0
+                         (or (ediff-overlay-get ovr 'priority) 0)
+                       0))
+                   ovr-list)
+                  ))
         ))))
 
 
@@ -1281,14 +1305,16 @@ This default should work without changes."
 
 ;;; In-line functions
 
-(or (fboundp 'ediff-file-remote-p) ; user supplied his own function: use it
-    (defun ediff-file-remote-p (file-name)
+;; If file-remote-p is defined (as in XEmacs, use it. Otherwise, check
+;; if find-file-name-handler is defined for 'file-local-copy
+(defun ediff-file-remote-p (file-name)
+  (or (and (fboundp 'file-remote-p) (file-remote-p file-name))
       (find-file-name-handler file-name 'file-local-copy)))
-;;;      (or (and (featurep 'efs-auto) (efs-ftp-path file-name))
-;;;       (and (featurep 'tramp) (tramp-tramp-file-p file-name))
-;;;       (and (fboundp 'file-remote-p) (file-remote-p file-name))
-;;;       ;; Can happen only in Emacs, since XEmacs has file-remote-p
-;;;       (and (require 'ange-ftp) (ange-ftp-ftp-name file-name)))))
+
+;; File for which we can get attributes, such as size or date
+(defun ediff-listable-file (file-name)
+  (let ((handler (find-file-name-handler file-name 'file-local-copy)))
+    (or (null handler) (eq handler 'dired-handler-fn))))
 
 
 (defsubst ediff-frame-unsplittable-p (frame)
@@ -1740,9 +1766,10 @@ Unless optional argument INPLACE is non-nil, return a new string."
       (apply 'message string args)))
 
 (defun ediff-file-attributes (filename attr-number)
-  (if (ediff-file-remote-p filename)
-      -1
-    (nth attr-number (file-attributes filename))))
+  (if (ediff-listable-file filename)
+      (nth attr-number (file-attributes filename))
+    -1)
+  )
 
 (defsubst ediff-file-size (filename)
   (ediff-file-attributes filename 7))
diff --git a/lisp/ediff-mult.el b/lisp/ediff-mult.el
index 206ef40351b..7115a2671f8 100644
--- a/lisp/ediff-mult.el
+++ b/lisp/ediff-mult.el
@@ -970,7 +970,7 @@ behavior."
                               500))
         file-modtime file-size)
     (cond ((not (stringp fname)) (setq file-size -2)) ; file doesn't exits
-          ((not (ediff-file-remote-p fname))
+          ((ediff-listable-file fname)
            (if (file-exists-p fname)
                ;; set real size and modtime
                (setq file-size (ediff-file-size fname)
diff --git a/lisp/ediff-ptch.el b/lisp/ediff-ptch.el
index 6cbd9bb70c6..95d93ed5899 100644
--- a/lisp/ediff-ptch.el
+++ b/lisp/ediff-ptch.el
@@ -408,7 +408,8 @@ are two possible targets for this patch.  However, these files do not exist."
 (defun ediff-prompt-for-patch-file ()
   (let ((dir (cond (ediff-patch-default-directory) ; try patch default dir
                    (ediff-use-last-dir ediff-last-dir-patch)
-                   (t default-directory))))
+                   (t default-directory)))
+        (coding-system-for-read ediff-coding-system-for-read))
     (find-file-noselect
      (read-file-name
       (format "Patch is in file:%s "
@@ -445,7 +446,7 @@ are two possible targets for this patch.  However, these files do not exist."
                (goto-char (point-min))
                (and (re-search-forward ediff-context-diff-label-regexp nil t)
                     (current-buffer)))))
-          (t (other-buffer (current-buffer) 'visible-ok)))
+          (t (ediff-other-buffer (current-buffer))))
     'must-match)))
 
 
@@ -576,6 +577,10 @@ optional argument, then use it."
          ;; file for the purpose of patching.
          (true-source-filename source-filename)
          (target-filename source-filename)
+         ;; this ensures that the patch process gets patch buffer in the
+         ;; encoding that Emacs thinks is right for that type of text
+         (coding-system-for-write 
+          (if (boundp 'buffer-file-coding-system) buffer-file-coding-system))
          target-buf buf-to-patch file-name-magic-p 
          patch-return-code ctl-buf backup-style aux-wind)
           
diff --git a/lisp/ediff-util.el b/lisp/ediff-util.el
index 2eabfa9fc86..8d0f7395149 100644
--- a/lisp/ediff-util.el
+++ b/lisp/ediff-util.el
@@ -1101,15 +1101,24 @@ of the current buffer."
 (defsubst ediff-file-checked-out-p (file)
   (or (not (featurep 'vc-hooks))
       (and (vc-backend file)
-           (or (memq (vc-state file) '(edited needs-merge))
-               (stringp (vc-state file))))))
+           (if (fboundp 'vc-state)
+               (or (memq (vc-state file) '(edited needs-merge))
+                   (stringp (vc-state file)))
+             ;; XEmacs has no vc-state
+             (vc-locking-user file))
+           )))
   
 (defsubst ediff-file-checked-in-p (file)
   (and (featurep 'vc-hooks)
        ;; CVS files are considered not checked in
        (not (memq (vc-backend file) '(nil CVS)))
-       (not (memq (vc-state file) '(edited needs-merge)))
-       (not (stringp (vc-state file)))))
+       (if (fboundp 'vc-state)
+           (progn
+             (not (memq (vc-state file) '(edited needs-merge)))
+             (not (stringp (vc-state file))))
+         ;; XEmacs has no vc-state
+         (not (vc-locking-user file)))
+       ))
 
 (defun ediff-file-compressed-p (file)
   (condition-case nil
@@ -2971,7 +2980,7 @@ Hit \\[ediff-recenter] to reset the windows afterward."
 (defun ediff-make-temp-file (buff &optional prefix given-file start end)
   (let* ((p (ediff-convert-standard-filename (or prefix "ediff")))
          (short-p p)
-         (coding-system-for-write 'no-conversion)
+         (coding-system-for-write ediff-coding-system-for-write)
          f short-f)
     (if (and (fboundp 'msdos-long-file-names)
              (not (msdos-long-file-names))
@@ -3464,7 +3473,7 @@ Ediff Control Panel to restore highlighting."
           ;; never detach
           (ediff-overlay-put
            overl (if ediff-emacs-p 'evaporate 'detachable) nil)
-          ;; make vip-minibuffer-overlay open-ended
+          ;; make overlay open-ended
           ;; In emacs, it is made open ended at creation time
           (if ediff-xemacs-p
               (progn
diff --git a/lisp/ediff.el b/lisp/ediff.el
index d824128e4d0..a170d4b1a99 100644
--- a/lisp/ediff.el
+++ b/lisp/ediff.el
@@ -6,8 +6,8 @@
 ;; Created: February 2, 1994
 ;; Keywords: comparing, merging, patching, tools, unix
 
-(defconst ediff-version "2.75" "The current version of Ediff")
-(defconst ediff-date "March 5, 2001" "Date of last update")  
+(defconst ediff-version "2.76" "The current version of Ediff")
+(defconst ediff-date "July 18, 2001" "Date of last update")  
 
 
 ;; This file is part of GNU Emacs.
diff --git a/lisp/emulation/viper-cmd.el b/lisp/emulation/viper-cmd.el
index 9033ac7ce02..d4574779412 100644
--- a/lisp/emulation/viper-cmd.el
+++ b/lisp/emulation/viper-cmd.el
@@ -74,18 +74,15 @@
 ;; given symbol foo, foo-p is the test function, foos is the set of
 ;; Viper command keys
 ;; (macroexpand '(viper-test-com-defun foo))
-;; (defun foo-p (com) (consp (memq (if (< com 0) (- com) com) foos)))
+;; (defun foo-p (com) (consp (memq com foos)))
 
 (defmacro viper-test-com-defun (name)
   (let* ((snm (symbol-name name))
          (nm-p (intern (concat snm "-p")))
          (nms (intern (concat snm "s"))))
     `(defun ,nm-p (com)
-      (consp (viper-memq-char
-              (if (and (viper-characterp com) (< com 0))
-                  (- com) com)
-              ,nms)
-             ))))
+       (consp (viper-memq-char com ,nms)
+              ))))
 
 ;; Variables for defining VI commands
 
@@ -725,10 +722,8 @@ Vi's prefix argument will be used.  Otherwise, the prefix argument passed to
               viper-emacs-kbd-minor-mode)
           (unwind-protect
               (progn
-                (setq com (key-binding (setq key
-                                             (if viper-xemacs-p
-                                                 (read-key-sequence nil)
-                                               (read-key-sequence nil t)))))
+                (setq com
+                      (key-binding (setq key (viper-read-key-sequence nil))))
                 ;; 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
@@ -797,6 +792,12 @@ Similar to viper-escape-to-emacs, but accepts forms rather than keystrokes."
     (viper-set-mode-vars-for viper-current-state)
     result))
 
+;; This executes the last kbd event in emacs mode. Is used when we want to
+;; interpret certain keys directly in emacs (as, for example, in comint mode).
+(defun viper-exec-key-in-emacs (arg)
+  (interactive "P")
+  (viper-escape-to-emacs arg last-command-event))
+
 
 ;; This is needed because minor modes sometimes override essential Viper
 ;; bindings.  By letting Viper know which files these modes are in, it will
@@ -878,9 +879,7 @@ as a Meta key and any number of multiple escapes is allowed."
               (progn
                 (let (minor-mode-map-alist)
                   (viper-set-unread-command-events event)
-                  (setq keyseq
-                        (funcall
-                         (ad-get-orig-definition 'read-key-sequence) nil))
+                  (setq keyseq (read-key-sequence nil 'continue-echo))
                   ) ; let
                 ;; If keyseq translates into something that still has ESC
                 ;; at the beginning, separate ESC from the rest of the seq.
@@ -933,8 +932,7 @@ as a Meta key and any number of multiple escapes is allowed."
             ;; this is escape event with nothing after it
             ;; put in unread-command-event and then re-read
             (viper-set-unread-command-events event)
-            (setq keyseq
-                  (funcall (ad-get-orig-definition 'read-key-sequence) nil))
+            (setq keyseq (read-key-sequence nil))
             ))
       ;; not an escape event
       (setq keyseq (vector event)))
@@ -1121,7 +1119,8 @@ as a Meta key and any number of multiple escapes is allowed."
         ;; execute apropriate region command.
         (let ((char (car com)) (com (cdr com)))
           (setq prefix-arg (cons value com))
-          (if (viper= char ?r) (viper-region prefix-arg)
+          (if (viper= char ?r)
+              (viper-region prefix-arg)
             (viper-Region prefix-arg))
           ;; reset prefix-arg
           (setq prefix-arg nil))
@@ -1249,9 +1248,10 @@ as a Meta key and any number of multiple escapes is allowed."
       (exchange-point-and-mark))
   (if (eq (preceding-char) ?\n)
       (viper-backward-char-carefully)) ; give back the newline
-  (if (viper= com ?c)
-      (viper-change (mark t) (point))
-    (viper-change-subr (mark t) (point))))
+  (if (eq viper-intermediate-command 'viper-repeat)
+      (viper-change-subr (mark t) (point))
+    (viper-change (mark t) (point))
+    ))
 
 ;; this is invoked by viper-substitute-line
 (defun viper-exec-Change (m-com com)
@@ -1271,9 +1271,10 @@ as a Meta key and any number of multiple escapes is allowed."
           (setq viper-use-register nil)))
     (delete-region (mark t) (point)))
   (open-line 1)
-  (if (viper= com ?C)
-      (viper-change-state-to-insert)
-    (viper-yank-last-insertion)))
+  (if (eq viper-intermediate-command 'viper-repeat)
+      (viper-yank-last-insertion)
+    (viper-change-state-to-insert)
+    ))
 
 (defun viper-exec-delete (m-com com)
   (or (and (markerp viper-com-point) (marker-position viper-com-point))
@@ -1455,15 +1456,13 @@ as a Meta key and any number of multiple escapes is allowed."
     ;; this is the special command `#'
     (if (> com 128)
         (viper-special-prefix-com (- com 128))
-      (let ((fn (aref viper-exec-array (if (< com 0) (- com) com))))
+      (let ((fn (aref viper-exec-array com)))
         (if (null fn)
             (error "%c: %s" com viper-InvalidViCommand)
           (funcall fn m-com com))))
     (if (viper-dotable-command-p com)
         (viper-set-destructive-command
-         (list m-com val
-               (if (viper-memq-char com (list ?c ?C ?!)) (- com) com)
-               reg nil nil)))
+         (list m-com val com reg nil nil)))
     ))
 
 
@@ -1889,8 +1888,7 @@ Undo previous insertion and inserts new."
         (if (fboundp 'minibuffer-prompt-end)
             (delete-region (minibuffer-prompt-end) (point-max))
           (erase-buffer))
-        (insert initial)))
-  (viper-minibuffer-setup-sentinel))
+        (insert initial))))
 
 (defsubst viper-minibuffer-real-start ()
   (if (fboundp 'minibuffer-prompt-end)
@@ -1994,7 +1992,16 @@ problems."
   ;; KEYMAP is used, if given, instead of minibuffer-local-map.
   ;; INIT-MESSAGE is the message temporarily displayed after entering the
   ;; minibuffer.
-  (let ((minibuffer-setup-hook 'viper-minibuffer-standard-hook)
+  (let ((minibuffer-setup-hook
+         ;; stolen from add-hook
+         (let ((old
+                (if (boundp 'minibuffer-setup-hook)
+                    minibuffer-setup-hook
+                  nil)))
+           (cons
+            'viper-minibuffer-standard-hook
+            (if (or (not (listp old)) (eq (car old) 'lambda))
+                (list old) old))))
         (val "")
         (padding "")
         temp-msg)
@@ -2059,7 +2066,7 @@ problems."
   (let ((val (viper-p-val arg))
         (com (viper-getcom arg)))
     (viper-set-destructive-command (list 'viper-insert val ?r nil nil nil))
-    (if com
+    (if (eq viper-intermediate-command 'viper-repeat)
         (viper-loop val (viper-yank-last-insertion))
       (viper-change-state-to-insert))))
 
@@ -2071,7 +2078,7 @@ problems."
         (com (viper-getcom arg)))
     (viper-set-destructive-command (list 'viper-append val ?r nil nil nil))
     (if (not (eolp)) (forward-char))
-    (if (viper= com ?r)
+    (if (eq viper-intermediate-command 'viper-repeat)
         (viper-loop val (viper-yank-last-insertion))
       (viper-change-state-to-insert))))
 
@@ -2083,7 +2090,7 @@ problems."
         (com (viper-getcom arg)))
     (viper-set-destructive-command (list 'viper-Append val ?r nil nil nil))
     (end-of-line)
-    (if (viper= com ?r)
+    (if (eq viper-intermediate-command 'viper-repeat)
         (viper-loop val (viper-yank-last-insertion))
       (viper-change-state-to-insert))))
 
@@ -2095,7 +2102,7 @@ problems."
         (com (viper-getcom arg)))
     (viper-set-destructive-command (list 'viper-Insert val ?r nil nil nil))
     (back-to-indentation)
-    (if (viper= com ?r)
+    (if (eq viper-intermediate-command 'viper-repeat)
         (viper-loop val (viper-yank-last-insertion))
       (viper-change-state-to-insert))))
 
@@ -2107,26 +2114,15 @@ problems."
         (com (viper-getcom arg)))
     (viper-set-destructive-command (list 'viper-open-line val ?r nil nil nil))
     (let ((col (current-indentation)))
-      (if (viper= com ?r)
+      (if (eq viper-intermediate-command 'viper-repeat)
           (viper-loop val
                       (end-of-line)
                       (newline 1)
-                      (if viper-auto-indent
-                          (progn
-                            (setq viper-cted t)
-                            (if viper-electric-mode
-                                (indent-according-to-mode)
-                              (indent-to col))
-                            ))
+                      (viper-indent-line col)
                       (viper-yank-last-insertion))
         (end-of-line)
         (newline 1)
-        (if viper-auto-indent
-            (progn
-              (setq viper-cted t)
-              (if viper-electric-mode
-                  (indent-according-to-mode)
-                (indent-to col))))
+        (viper-indent-line col)
         (viper-change-state-to-insert)))))
 
 (defun viper-Open-line (arg)
@@ -2137,27 +2133,15 @@ problems."
         (com (viper-getcom arg)))
     (viper-set-destructive-command (list 'viper-Open-line val ?r nil nil nil))
     (let ((col (current-indentation)))
-      (if (viper= com ?r)
+      (if (eq viper-intermediate-command 'viper-repeat)
           (viper-loop val
                       (beginning-of-line)
                       (open-line 1)
-                      (if viper-auto-indent
-                          (progn
-                            (setq viper-cted t)
-                            (if viper-electric-mode
-                                (indent-according-to-mode)
-                              (indent-to col))
-                            ))
+                      (viper-indent-line col)
                       (viper-yank-last-insertion))
         (beginning-of-line)
         (open-line 1)
-        (if viper-auto-indent
-            (progn
-              (setq viper-cted t)
-              (if viper-electric-mode
-                  (indent-according-to-mode)
-                (indent-to col))
-              ))
+        (viper-indent-line col)
         (viper-change-state-to-insert)))))
 
 (defun viper-open-line-at-point (arg)
@@ -2168,13 +2152,14 @@ problems."
         (com (viper-getcom arg)))
     (viper-set-destructive-command
      (list 'viper-open-line-at-point val ?r nil nil nil))
-    (if (viper= com ?r)
+    (if (eq viper-intermediate-command 'viper-repeat)
         (viper-loop val
                     (open-line 1)
                     (viper-yank-last-insertion))
       (open-line 1)
       (viper-change-state-to-insert))))
 
+;; bound to s
 (defun viper-substitute (arg)
   "Substitute characters."
   (interactive "P")
@@ -2182,9 +2167,10 @@ problems."
         (com (viper-getcom arg)))
     (push-mark nil t)
     (forward-char val)
-    (if (viper= com ?r)
+    (if (eq viper-intermediate-command 'viper-repeat)
         (viper-change-subr (mark t) (point))
       (viper-change (mark t) (point)))
+    ;; com is set to ?r when we repeat this comand with dot
     (viper-set-destructive-command (list 'viper-substitute val ?r nil nil nil))
     ))
 
@@ -2356,7 +2342,7 @@ These keys are ESC, RET, and LineFeed"
     (if (eq this-command 'viper-intercept-ESC-key)
         (setq com 'viper-exit-insert-state)
       (viper-set-unread-command-events last-input-char)
-      (setq com (key-binding (read-key-sequence nil))))
+      (setq com (key-binding (viper-read-key-sequence nil))))
 
     (condition-case conds
         (command-execute com)
@@ -2405,11 +2391,11 @@ These keys are ESC, RET, and LineFeed"
   (let ((val (viper-p-val arg))
         (com (viper-getcom arg)) (len))
     (viper-set-destructive-command (list 'viper-overwrite val ?r nil nil nil))
-    (if com
+    (if (eq viper-intermediate-command 'viper-repeat)
         (progn
           ;; Viper saves inserted text in viper-last-insertion
           (setq len (length viper-last-insertion))
-          (delete-char len)
+          (delete-char (min len (- (point-max) (point) 1)))
           (viper-loop val (viper-yank-last-insertion)))
       (setq last-command 'viper-overwrite)
       (viper-set-complex-command-for-undo)
@@ -2476,7 +2462,7 @@ These keys are ESC, RET, and LineFeed"
 
 (defun viper-replace-char-subr (com arg)
   (let (char)
-    (setq char (if (viper= com ?r)
+    (setq char (if (eq viper-intermediate-command 'viper-repeat)
                    viper-d-char
                  (read-char)))
     (let (inhibit-quit) ; preserve consistency of undo-list and iso-accents
@@ -2694,15 +2680,17 @@ On reaching beginning of line, stop and signal error."
         (com (viper-getcom arg)))
     (if com (viper-move-marker-locally 'viper-com-point (point)))
     (viper-forward-word-kernel val)
-    (if com (progn
-              (cond ((viper-memq-char com (list ?c (- ?c)))
-                     (viper-separator-skipback-special 'twice viper-com-point))
-                    ;; Yank words including the whitespace, but not newline
-                    ((viper-memq-char com (list ?y (- ?y)))
-                     (viper-separator-skipback-special nil viper-com-point))
-                    ((viper-dotable-command-p com)
-                     (viper-separator-skipback-special nil viper-com-point)))
-              (viper-execute-com 'viper-forward-word val com)))))
+    (if com
+        (progn
+          (cond ((viper-char-equal com ?c)
+                 (viper-separator-skipback-special 'twice viper-com-point))
+                ;; Yank words including the whitespace, but not newline
+                ((viper-char-equal com ?y)
+                 (viper-separator-skipback-special nil viper-com-point))
+                ((viper-dotable-command-p com)
+                 (viper-separator-skipback-special nil viper-com-point)))
+          (viper-execute-com 'viper-forward-word val com)))
+    ))
 
 
 (defun viper-forward-Word (arg)
@@ -2716,10 +2704,10 @@ On reaching beginning of line, stop and signal error."
                 (viper-skip-nonseparators 'forward)
                 (viper-skip-separators t))
     (if com (progn
-              (cond ((viper-memq-char com (list ?c (- ?c)))
+              (cond ((viper-char-equal com ?c)
                      (viper-separator-skipback-special 'twice viper-com-point))
                     ;; Yank words including the whitespace, but not newline
-                    ((viper-memq-char com (list ?y (- ?y)))
+                    ((viper-char-equal com ?y)
                      (viper-separator-skipback-special nil viper-com-point))
                     ((viper-dotable-command-p com)
                      (viper-separator-skipback-special nil viper-com-point)))
@@ -4234,7 +4222,7 @@ and regexp replace."
   (interactive)
   (let ((char (read-char)))
     (cond ((and (<= ?a char) (<= char ?z))
-           (point-to-register (1+ (- char ?a))))
+           (point-to-register (viper-int-to-char (1+ (- char ?a)))))
           ((viper= char ?<) (viper-mark-beginning-of-buffer))
           ((viper= char ?>) (viper-mark-end-of-buffer))
           ((viper= char ?.) (viper-set-mark-if-necessary))
@@ -4304,7 +4292,7 @@ One can use `` and '' to temporarily jump 1 step back."
         (backward-char 1)))
   (cond ((viper-valid-register char '(letter))
          (let* ((buff (current-buffer))
-                (reg (1+ (- char ?a)))
+                (reg (viper-int-to-char (1+ (- char ?a))))
                 (text-marker (get-register reg)))
            ;; If marker points to file that had markers set (and those markers
            ;; were saved (as e.g., in session.el), then restore those markers
@@ -4410,6 +4398,19 @@ One can use `` and '' to temporarily jump 1 step back."
         (if (or (bolp) (viper-looking-back "[^ \t]"))
             (setq viper-cted nil)))))
 
+;; do smart indent
+(defun viper-indent-line (col)
+  (if viper-auto-indent
+      (progn
+        (setq viper-cted t)
+        (if (and viper-electric-mode
+                 (not (memq major-mode '(fundamental-mode
+                                         text-mode
+                                         paragraph-indent-text-mode))))
+            (indent-according-to-mode)
+          (indent-to col)))))
+
+
 (defun viper-autoindent ()
   "Auto Indentation, Vi-style."
   (interactive)
@@ -4427,17 +4428,7 @@ One can use `` and '' to temporarily jump 1 step back."
     ;; use \n instead of newline, or else <Return> will move the insert point
     ;;(newline 1)
     (insert "\n")
-    (if viper-auto-indent
-        (progn
-          (setq viper-cted t)
-          (if (and viper-electric-mode
-                   (not
-                    (memq major-mode '(fundamental-mode
-                                       text-mode
-                                       paragraph-indent-text-mode ))))
-              (indent-according-to-mode)
-            (indent-to viper-current-indent))
-          ))
+    (viper-indent-line viper-current-indent)
     ))
 
 
@@ -4469,7 +4460,7 @@ One can use `` and '' to temporarily jump 1 step back."
           ((viper= ?\] reg)
            (viper-heading-end arg))
           ((viper-valid-register reg '(letter))
-           (let* ((val (get-register (1+ (- reg ?a))))
+           (let* ((val (get-register (viper-int-to-char (1+ (- reg ?a)))))
                   (buf (if (not (markerp val))
                            (error viper-EmptyTextmarker reg)
                          (marker-buffer val)))
@@ -4699,17 +4690,17 @@ Please, specify your level now: ")
       (if (and enforce-buffer
                (not (equal (current-buffer) (marker-buffer val))))
           (error (concat viper-EmptyTextmarker " in this buffer")
-                 (1- (+ char ?a))))
+                 (viper-int-to-char (1- (+ char ?a)))))
       (pop-to-buffer  (marker-buffer val))
       (goto-char val))
      ((and (consp val) (eq (car val) 'file))
       (find-file (cdr val)))
      (t
-      (error viper-EmptyTextmarker (1- (+ char ?a)))))))
+      (error viper-EmptyTextmarker (viper-int-to-char (1- (+ char ?a))))))))
 
 
 (defun viper-save-kill-buffer ()
-  "Save then kill current buffer. "
+  "Save then kill current buffer."
   (interactive)
   (if (< viper-expert-level 2)
       (save-buffers-kill-emacs)
diff --git a/lisp/emulation/viper-ex.el b/lisp/emulation/viper-ex.el
index 3b01dd05241..398e5a937c6 100644
--- a/lisp/emulation/viper-ex.el
+++ b/lisp/emulation/viper-ex.el
@@ -122,6 +122,7 @@
         ("k"                    (ex-mark) one-letter)
         ("kmark"                (ex-mark))
         ("m"                    "move")
+        ("make"                 (ex-compile))
         ; old viper doesn't specify a default for "ma" so leave it undefined
         ("map"                  (ex-map))
         ("mark"                 (ex-mark))
@@ -215,7 +216,7 @@
 ;; If there is no appropriate key (no match or duplicate matches) return nil
 (defun ex-cmd-assoc (key list)
   (let ((entry (try-completion key list))
-        result onelet)
+        result)
     (setq result (cond
                   ((eq entry t)     (assoc key list))
                   ((stringp entry)  (or (ex-splice-args-in-1-letr-cmd key list)
@@ -320,6 +321,11 @@ Don't put `-c' here, as it is added automatically."
   :type '(choice (const nil) string)
   :group 'viper-ex)
 
+(defcustom ex-compile-command "make"
+  "The comand to run when the user types :make."
+  :type 'string
+  :group 'viper-ex)
+
 (defcustom viper-glob-function
   (cond (ex-unix-type-shell 'viper-glob-unix-files)
         ((eq system-type 'emx) 'viper-glob-mswindows-files) ; OS/2
@@ -643,7 +649,7 @@ reversed."
                       'viper-ex-history
                       ;; no default when working on region
                       (if initial-str
-                          "none"
+                          nil
                         (car viper-ex-history))
                       map
                       (if initial-str
@@ -855,8 +861,9 @@ reversed."
            (save-excursion
              (if (null ex-token)
                  (exchange-point-and-mark)
-               (goto-char (viper-register-to-point
-                           (1+ (- ex-token ?a)) 'enforce-buffer)))
+               (goto-char 
+                (viper-register-to-point
+                 (viper-int-to-char (1+ (- ex-token ?a))) 'enforce-buffer)))
              (setq address (point-marker)))))
     address))
 
@@ -1454,7 +1461,7 @@ reversed."
         (error "`%s' requires a following letter" ex-token))))
     (save-excursion
       (goto-char (car ex-addresses))
-      (point-to-register (1+ (- char ?a))))))
+      (point-to-register (viper-int-to-char (1+ (- char ?a)))))))
 
     
       
@@ -2159,6 +2166,29 @@ Please contact your system administrator. "
           (shell-command-on-region (point) (mark t) command t))
         (goto-char beg)))))
 
+(defun ex-compile ()
+  "Reads args from the command line, then runs make with the args.
+If no args are given, then it runs the last compile command.
+Type 'mak ' (including the space) to run make with no args."
+  (let (args)
+    (save-window-excursion
+      (setq viper-ex-work-buf (get-buffer-create viper-ex-work-buf-name))
+      (set-buffer viper-ex-work-buf)
+      (setq args (buffer-substring (point) (point-max)))
+      (end-of-line))
+    ;; Remove the newline that may (will?) be at the end of the args
+    (if (string= "\n" (substring args (1- (length args))))
+        (setq args (substring args 0 (1- (length args)))))
+    ;; Run last command if no args given, else construct a new command.
+    (setq args
+          (if (string= "" args)
+              (if (boundp 'compile-command)
+                  compile-command
+                ex-compile-command)
+            (concat ex-compile-command " " args)))
+    (compile args)
+    ))
+
 ;; Print line number
 (defun ex-line-no ()
   (message "%d"
diff --git a/lisp/emulation/viper-keym.el b/lisp/emulation/viper-keym.el
index 2df1b388755..73155a05798 100644
--- a/lisp/emulation/viper-keym.el
+++ b/lisp/emulation/viper-keym.el
@@ -445,8 +445,8 @@ Useful in some modes, such as Gnus, MH, etc.")
 
 (defvar viper-comint-mode-modifier-map (make-sparse-keymap)
   "This map modifies comint mode.")
-(define-key viper-comint-mode-modifier-map "\C-m" 'comint-send-input)
-(define-key viper-comint-mode-modifier-map "\C-d" 'comint-delchar-or-maybe-eof)
+(define-key viper-comint-mode-modifier-map "\C-m" 'viper-exec-key-in-emacs)
+(define-key viper-comint-mode-modifier-map "\C-d" 'viper-exec-key-in-emacs)
 
 (defvar viper-dired-modifier-map (make-sparse-keymap)
   "This map modifies Dired behavior.")
diff --git a/lisp/emulation/viper-util.el b/lisp/emulation/viper-util.el
index a27f20b626f..cacd8debd46 100644
--- a/lisp/emulation/viper-util.el
+++ b/lisp/emulation/viper-util.el
@@ -1,4 +1,4 @@
-;;; viper-util.el --- utilities used by viper.el
+;;; viper-util.el --- Utilities used by viper.el
 
 ;; Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
 
@@ -103,16 +103,26 @@
       (symbol-function
        (if viper-xemacs-p 'characterp 'integerp)))
 
+(fset 'viper-int-to-char
+      (symbol-function
+       (if viper-xemacs-p 'int-to-char 'identity)))
+
 ;; CHAR is supposed to be a char or an integer (positive or negative)
 ;; LIST is a list of chars, nil, and negative numbers
-;; Check if CHAR is a member by trying to convert into integers, if necessary.
+;; Check if CHAR is a member by trying to convert in characters, if necessary.
 ;; Introduced for compatibility with XEmacs, where integers are not the same as
 ;; chars.
 (defun viper-memq-char (char list)
-  (cond (viper-emacs-p (memq char list))
-        ((and (integerp char) (>= char 0)) (memq (int-to-char char) list))
+  (cond ((and (integerp char) (>= char 0))
+         (memq (viper-int-to-char char) list))
         ((memq char list))))
 
+;; Check if char-or-int and char are the same as characters
+(defun viper-char-equal (char-or-int char)
+  (cond ((and (integerp char-or-int) (>= char-or-int 0))
+         (= (viper-int-to-char char-or-int) char))
+        ((eq char-or-int char))))
+
 ;; Like =, but accommodates null and also is t for eq-objects
 (defun viper= (char char1)
   (cond ((eq char char1) t)
@@ -683,8 +693,13 @@
   (and (featurep 'vc-hooks)
        ;; CVS files are considered not checked in
        (not (memq (vc-backend file) '(nil CVS)))
-       (not (memq (vc-state file) '(edited needs-merge)))
-       (not (stringp (vc-state file)))))
+       (if (fboundp 'vc-state)
+           (progn
+             (not (memq (vc-state file) '(edited needs-merge)))
+             (not (stringp (vc-state file))))
+         ;; XEmacs has no vc-state
+         (not (vc-locking-user file)))
+       ))
 
 ;; checkout if visited file is checked in
 (defun viper-maybe-checkout (buf)
@@ -926,7 +941,7 @@
         help-char key) 
     (use-global-map viper-overriding-map) 
     (unwind-protect
-        (setq key (elt (read-key-sequence nil) 0)) 
+        (setq key (elt (viper-read-key-sequence nil) 0)) 
       (use-global-map global-map))
     key))
 
diff --git a/lisp/emulation/viper.el b/lisp/emulation/viper.el
index 792bb1578b0..277ae0c408e 100644
--- a/lisp/emulation/viper.el
+++ b/lisp/emulation/viper.el
@@ -1,4 +1,4 @@
-;;; viper.el --- a full-featured Vi emulator for GNU Emacs and XEmacs,
+;;; viper.el --- A full-featured Vi emulator for GNU Emacs and XEmacs,
 ;;               a VI Plan for Emacs Rescue,
 ;;               and a venomous VI PERil.
 ;;               Viper Is also a Package for Emacs Rebels.
@@ -8,7 +8,7 @@
 
 ;; Copyright (C) 1994, 95, 96, 97, 98, 99, 2000, 01 Free Software Foundation, Inc.
 
-(defconst viper-version "3.10 of March 3, 2001"
+(defconst viper-version "3.11 of July 18, 2001"
   "The current version of Viper")
 
 ;; This file is part of GNU Emacs.
@@ -401,6 +401,7 @@ widget."
                                   
     completion-list-mode
     diff-mode
+    idl-mode
     
     perl-mode
     cperl-mode
@@ -446,6 +447,7 @@ unless it is coming up in a wrong Viper state."
 (defcustom viper-insert-state-mode-list
   '(internal-ange-ftp-mode
     comint-mode
+    inferior-emacs-lisp-mode
     eshell-mode
     shell-mode)
   "*A list of major modes that should come up in Vi Insert state."
@@ -462,11 +464,14 @@ unless it is coming up in a wrong Viper state."
              (nth 0 triple) (nth 1 triple) (eval (nth 2 triple))))
           viper-major-mode-modifier-list))
 
+;; We change standard bindings in some major mode, making them slightly
+;; different than in "normal" vi/insert/emacs states
 (defcustom viper-major-mode-modifier-list
   '((help-mode emacs-state viper-slash-and-colon-map)
     (comint-mode insert-state viper-comint-mode-modifier-map)
     (comint-mode vi-state viper-comint-mode-modifier-map)
     (shell-mode insert-state viper-comint-mode-modifier-map)
+    (inferior-emacs-lisp-mode insert-state viper-comint-mode-modifier-map)
     (shell-mode vi-state viper-comint-mode-modifier-map)
     (ange-ftp-shell-mode insert-state viper-comint-mode-modifier-map)
     (ange-ftp-shell-mode vi-state viper-comint-mode-modifier-map)
@@ -595,11 +600,23 @@ This startup message appears whenever you load Viper, unless you type `y' now."
 
         (if viper-xemacs-p
             (make-variable-buffer-local 'bar-cursor))
+        (if (eq major-mode 'viper-mode)
+            (setq major-mode 'fundamental-mode))
 
         (or (memq major-mode viper-emacs-state-mode-list) ; don't switch to Vi
             (memq major-mode viper-insert-state-mode-list) ; don't switch
             (viper-change-state-to-vi)))))
    
+
+;; Apply a little heuristic to invoke vi state on major-modes
+;; that are not listed in viper-vi-state-mode-list
+(defun this-major-mode-requires-vi-state (mode)
+  (cond ((memq mode viper-vi-state-mode-list) t)
+        ((memq mode viper-emacs-state-mode-list) nil)
+        ((memq mode viper-insert-state-mode-list) nil)
+        (t (and (eq (key-binding "a") 'self-insert-command)
+                (eq (key-binding " ") 'self-insert-command)))))
+
 
 ;; This hook designed to enable Vi-style editing in comint-based modes."
 (defun viper-comint-mode-hook ()
@@ -760,7 +777,7 @@ remains buffer-local."
    (lambda (buf)
      (if (viper-buffer-live-p buf)
          (with-current-buffer buf
-           (cond ((and (memq major-mode viper-vi-state-mode-list)
+           (cond ((and (this-major-mode-requires-vi-state major-mode)
                        (eq viper-current-state 'emacs-state))
                   (viper-mode))
                  ((memq major-mode viper-emacs-state-mode-list)
@@ -798,6 +815,8 @@ remains buffer-local."
   ;; However, this has the effect that if the user didn't specify the
   ;; default mode, new buffers that fall back on the default will come up
   ;; in Fundamental Mode and Vi state.
+  ;; When viper-mode is executed in such a case, it will set the major mode
+  ;; back to fundamental-mode.
   (if (eq default-major-mode 'fundamental-mode)
       (setq default-major-mode 'viper-mode))
   
@@ -956,36 +975,16 @@ remains buffer-local."
       (setq global-mode-string
             (append '("" viper-mode-string) (cdr global-mode-string))))
 
-  (defadvice read-key-sequence (around viper-read-keyseq-ad activate)
-    "Harness to work for Viper.  This advice is harmless---don't worry!"
-    (let (inhibit-quit event keyseq)
-      (setq keyseq ad-do-it)
-      (setq event (if viper-xemacs-p
-                      (elt keyseq 0) ; XEmacs returns vector of events
-                    (elt (listify-key-sequence keyseq) 0)))
-      (if (viper-ESC-event-p event)
-          (let (unread-command-events)
-            (viper-set-unread-command-events keyseq)
-            (if (viper-fast-keysequence-p)
-                (let ((viper-vi-global-user-minor-mode  nil)
-                      (viper-vi-local-user-minor-mode  nil)
-                      (viper-replace-minor-mode nil) ; actually unnecessary
-                      (viper-insert-global-user-minor-mode  nil)
-                      (viper-insert-local-user-minor-mode  nil))
-                  (setq keyseq ad-do-it)) 
-              (setq keyseq ad-do-it))))
-      keyseq))
-  
   (defadvice describe-key (before viper-read-keyseq-ad protect activate)
-    "Force to read key via `read-key-sequence'."
+    "Force to read key via `viper-read-key-sequence'."
     (interactive (list (viper-events-to-keys
-                        (read-key-sequence "Describe key: ")))))
+                        (viper-read-key-sequence "Describe key: ")))))
   
   (defadvice describe-key-briefly
     (before viper-read-keyseq-ad protect activate)
-    "Force to read key via `read-key-sequence'."
+    "Force to read key via `viper-read-key-sequence'."
     (interactive (list (viper-events-to-keys
-                        (read-key-sequence "Describe key briefly: ")))))
+                        (viper-read-key-sequence "Describe key briefly: ")))))
   
   
   (defadvice find-file (before viper-add-suffix-advice activate)
@@ -1056,6 +1055,27 @@ remains buffer-local."
 
   ) ; end viper-non-hook-settings
 
+;; Viperized read-key-sequence
+(defun viper-read-key-sequence (prompt &optional continue-echo)
+  (let (inhibit-quit event keyseq)
+    (setq keyseq (read-key-sequence prompt continue-echo))
+    (setq event (if viper-xemacs-p
+                    (elt keyseq 0) ; XEmacs returns vector of events
+                  (elt (listify-key-sequence keyseq) 0)))
+    (if (viper-ESC-event-p event)
+        (let (unread-command-events)
+          (viper-set-unread-command-events keyseq)
+          (if (viper-fast-keysequence-p)
+              (let ((viper-vi-global-user-minor-mode  nil)
+                    (viper-vi-local-user-minor-mode  nil)
+                    (viper-replace-minor-mode nil) ; actually unnecessary
+                    (viper-insert-global-user-minor-mode  nil)
+                    (viper-insert-local-user-minor-mode  nil))
+                (setq keyseq (read-key-sequence prompt continue-echo))) 
+            (setq keyseq (read-key-sequence prompt continue-echo)))))
+    keyseq))
+
+
 
 ;; Ask only if this-command/last-command are nil, i.e., when loading
 (cond ((and (eq viper-mode 'ask) (null this-command) (null last-command))
@@ -1259,7 +1279,7 @@ These two lines must come in the order given.
       (setq-default minor-mode-map-alist minor-mode-map-alist)
       ))
 
-(if (and viper-mode (memq major-mode viper-vi-state-mode-list))
+(if (and viper-mode (this-major-mode-requires-vi-state major-mode))
     (viper-mode))
 
 (if viper-mode