Initial revision

6 files changed, 10056 insertions, 0 deletions

diff --git a/lisp/emulation/viper-ex.el b/lisp/emulation/viper-ex.el
new file mode 100644
index 00000000000..3cd5c9f3986
--- /dev/null
+++ b/lisp/emulation/viper-ex.el
@@ -0,0 +1,1888 @@
+;;; viper-ex.el -- functions implementing the Ex commands for Viper
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; 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
+;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+
+(require 'viper-util)
+
+;;; Variables
+
+(defconst vip-ex-work-buf-name " *ex-working-space*")
+(defconst vip-ex-work-buf (get-buffer-create vip-ex-work-buf-name))
+
+
+;;; Completion in :set command
+  
+;; The list of Ex commands. Used for completing command names.
+(defconst ex-token-alist
+  '(("!") ("=") (">") ("&") ("~")
+    ("yank") ("xit") ("WWrite") ("Write") ("write") ("wq") ("visual") 
+    ("version") ("vglobal") ("unmap") ("undo") ("tag") ("transfer") ("suspend")
+    ("substitute") ("submitReport") ("stop")  ("sr") ("source") ("shell")
+    ("set") ("rewind") ("recover") ("read") ("quit") ("pwd")
+    ("put") ("preserve") ("PreviousRelatedFile") ("RelatedFile")
+    ("next") ("Next") ("move") ("mark") ("map") ("kmark") ("join")
+    ("help") ("goto") ("global") ("file") ("edit") ("delete") ("copy")
+    ("chdir") ("cd") ("Buffer") ("buffer") ("args"))  )
+
+;; A-list of Ex variables that can be set using the :set command.
+(defconst ex-variable-alist 
+  '(("wrapscan") ("ws") ("wrapmargin") ("wm")
+    ("tab-stop-local") ("tsl") ("tabstop") ("ts")
+    ("showmatch") ("sm") ("shiftwidth") ("sw") ("shell") ("sh")
+    ("readonly") ("ro") 
+    ("nowrapscan") ("nows") ("noshowmatch") ("nosm")
+    ("noreadonly") ("noro") ("nomagic") ("noma")
+    ("noignorecase") ("noic") ("noautoindent") ("noai")
+    ("magic") ("ma") ("ignorecase") ("ic") ("autoindent") ("ai")
+    ))
+
+  
+
+;; Token recognized during parsing of Ex commands (e.g., "read", "comma")
+(defvar ex-token nil)
+
+;; Type of token. 
+;; If non-nil, gives type of address; if nil, it is a command.
+(defvar ex-token-type nil)
+
+;; List of addresses passed to Ex command
+(defvar ex-addresses nil)
+
+;; It seems that this flag is used only for `#', `print', and `list', which
+;; aren't implemented. Check later.
+(defvar ex-flag nil)
+
+;; "buffer" where Ex commands keep deleted data.
+;; In Emacs terms, this is a register.
+(defvar ex-buffer nil)
+
+;; Value of ex count.
+(defvar ex-count nil)
+
+;; Flag for global command.
+(defvar ex-g-flag nil)
+
+;; If t, global command is executed on lines not matching ex-g-pat.
+(defvar ex-g-variant nil)
+
+;; Save reg-exp used in substitute.
+(defvar ex-reg-exp nil)
+
+
+;; Replace pattern for substitute.
+(defvar ex-repl nil)
+
+;; Pattern for global command.
+(defvar ex-g-pat nil)
+
+;; `sh' doesn't seem to expand wildcards, like `*'
+(defconst ex-find-file-shell "csh"
+  "Shell in which to interpret wildcards.")
+(defvar ex-find-file-shell-options "-f"
+  "*Options to pass to `ex-find-file-shell'.")
+
+;; Remembers the previous Ex tag.
+(defvar ex-tag nil)
+
+;; file used by Ex commands like :r, :w, :n
+(defvar ex-file nil)
+
+;; If t, tells Ex that this is a variant-command, i.e., w>>, r!, etc.
+(defvar ex-variant nil)
+
+;; Specified the offset of an Ex command, such as :read.
+(defvar ex-offset nil)
+
+;; Tells Ex that this is a w>> command.
+(defvar ex-append nil)
+
+;; File containing the shell command to be executed at Ex prompt,
+;; e.g., :r !date
+(defvar ex-cmdfile nil)
+  
+;; flag used in vip-ex-read-file-name to indicate that we may be reading
+;; multiple file names. Used for :edit and :next
+(defvar vip-keep-reading-filename nil)
+
+(defconst ex-cycle-other-window t
+  "*If t, :n and :b cycles through files and buffers in other window.
+Then :N and :B cycles in the current window. If nil, this behavior is
+reversed.")
+
+(defconst ex-cycle-through-non-files nil
+  "*Cycle through *scratch* and other buffers that don't visit any file.")
+
+;; Last shell command executed with :! command.
+(defvar vip-ex-last-shell-com nil)
+  
+;; Indicates if Minibuffer was exited temporarily in Ex-command.
+(defvar vip-incomplete-ex-cmd nil)
+  
+;; Remembers the last ex-command prompt.
+(defvar vip-last-ex-prompt "")
+
+
+;;; Code
+  
+(defun vip-check-sub (str)
+  "Check if ex-token is an initial segment of STR."
+  (let ((length (length ex-token)))
+    (if (and (<= length (length str))
+             (string= ex-token (substring str 0 length)))
+        (setq ex-token str)
+      (setq ex-token-type 'non-command))))
+
+(defun vip-get-ex-com-subr ()
+  "Get a complete ex command."
+  (let (case-fold-search)
+    (set-mark (point))
+    (re-search-forward "[a-zA-Z][a-zA-Z]*")
+    (setq ex-token-type 'command)
+    (setq ex-token (buffer-substring (point) (mark t)))
+    (exchange-point-and-mark)
+    (cond ((looking-at "a")
+           (cond ((looking-at "ab") (vip-check-sub "abbreviate"))
+                 ((looking-at "ar") (vip-check-sub "args"))
+                 (t (vip-check-sub "append"))))
+          ((looking-at "h") (vip-check-sub "help"))
+          ((looking-at "c")
+           (cond ((looking-at "cd") (vip-check-sub "cd"))
+                 ((looking-at "ch") (vip-check-sub "chdir"))
+                 ((looking-at "co") (vip-check-sub "copy"))
+                 (t (vip-check-sub "change"))))
+          ((looking-at "d") (vip-check-sub "delete"))
+          ((looking-at "b") (vip-check-sub "buffer"))
+          ((looking-at "B") (vip-check-sub "Buffer"))
+          ((looking-at "e")
+           (if (looking-at "ex") (vip-check-sub "ex")
+             (vip-check-sub "edit")))
+          ((looking-at "f") (vip-check-sub "file"))
+          ((looking-at "g") (vip-check-sub "global"))
+          ((looking-at "i") (vip-check-sub "insert"))
+          ((looking-at "j") (vip-check-sub "join"))
+          ((looking-at "l") (vip-check-sub "list"))
+          ((looking-at "m")
+           (cond ((looking-at "map") (vip-check-sub "map"))
+                 ((looking-at "mar") (vip-check-sub "mark"))
+                 (t (vip-check-sub "move"))))
+          ((looking-at "k[a-z][^a-z]")
+           (setq ex-token "kmark")
+           (forward-char 1)
+           (exchange-point-and-mark)) ;; this is canceled out by another
+                                      ;; exchange-point-and-mark at the end
+          ((looking-at "k") (vip-check-sub "kmark"))
+          ((looking-at "n") (if (looking-at "nu")
+                                (vip-check-sub "number")
+                              (vip-check-sub "next")))
+          ((looking-at "N") (vip-check-sub "Next"))
+          ((looking-at "o") (vip-check-sub "open"))
+          ((looking-at "p")
+           (cond ((looking-at "pre") (vip-check-sub "preserve"))
+                 ((looking-at "pu") (vip-check-sub "put"))
+                 ((looking-at "pw") (vip-check-sub "pwd"))
+                 (t (vip-check-sub "print"))))
+          ((looking-at "P") (vip-check-sub "PreviousRelatedFile"))
+          ((looking-at "R") (vip-check-sub "RelatedFile"))
+          ((looking-at "q") (vip-check-sub "quit"))
+          ((looking-at "r")
+           (cond ((looking-at "rec") (vip-check-sub "recover"))
+                 ((looking-at "rew") (vip-check-sub "rewind"))
+                 (t (vip-check-sub "read"))))
+          ((looking-at "s")
+           (cond ((looking-at "se") (vip-check-sub "set"))
+                 ((looking-at "sh") (vip-check-sub "shell"))
+                 ((looking-at "so") (vip-check-sub "source"))
+                 ((looking-at "sr") (vip-check-sub "sr"))
+                 ((looking-at "st") (vip-check-sub "stop"))
+                 ((looking-at "sus") (vip-check-sub "suspend"))
+                 ((looking-at "subm") (vip-check-sub "submitReport"))
+                 (t (vip-check-sub "substitute"))))
+          ((looking-at "t")
+           (if (looking-at "ta") (vip-check-sub "tag")
+             (vip-check-sub "transfer")))
+          ((looking-at "u")
+           (cond ((looking-at "una") (vip-check-sub "unabbreviate"))
+                 ((looking-at "unm") (vip-check-sub "unmap"))
+                 (t (vip-check-sub "undo"))))
+          ((looking-at "v")
+           (cond ((looking-at "ve") (vip-check-sub "version"))
+                 ((looking-at "vi") (vip-check-sub "visual"))
+                 (t (vip-check-sub "vglobal"))))
+          ((looking-at "w")
+           (if (looking-at "wq") (vip-check-sub "wq")
+             (vip-check-sub "write")))
+          ((looking-at "W")
+           (if (looking-at "WW") 
+               (vip-check-sub "WWrite")
+             (vip-check-sub "Write")))
+          ((looking-at "x") (vip-check-sub "xit"))
+          ((looking-at "y") (vip-check-sub "yank"))
+          ((looking-at "z") (vip-check-sub "z")))
+    (exchange-point-and-mark)
+    ))
+
+(defun vip-get-ex-token ()
+  "Get an ex-token which is either an address or a command.
+A token has a type, \(command, address, end-mark\), and a value."
+  (save-window-excursion
+    (set-buffer vip-ex-work-buf)
+    (skip-chars-forward " \t|")
+    (cond ((looking-at "#")
+           (setq ex-token-type 'command)
+           (setq ex-token (char-to-string (following-char)))
+           (forward-char 1))
+          ((looking-at "[a-z]") (vip-get-ex-com-subr))
+          ((looking-at "\\.")
+           (forward-char 1)
+           (setq ex-token-type 'dot))
+          ((looking-at "[0-9]")
+           (set-mark (point))
+           (re-search-forward "[0-9]*")
+           (setq ex-token-type
+                 (cond ((eq ex-token-type 'plus) 'add-number)
+                       ((eq ex-token-type 'minus) 'sub-number)
+                       (t 'abs-number)))
+           (setq ex-token (string-to-int (buffer-substring (point) (mark t)))))
+          ((looking-at "\\$")
+           (forward-char 1)
+           (setq ex-token-type 'end))
+          ((looking-at "%")
+           (forward-char 1)
+           (setq ex-token-type 'whole))
+          ((looking-at "+")
+           (cond ((or (looking-at "+[-+]") (looking-at "+[\n|]"))
+                  (forward-char 1)
+                  (insert "1")
+                  (backward-char 1)
+                  (setq ex-token-type 'plus))
+                 ((looking-at "+[0-9]")
+                  (forward-char 1)
+                  (setq ex-token-type 'plus))
+                 (t
+                  (error vip-BadAddress))))
+          ((looking-at "-")
+           (cond ((or (looking-at "-[-+]") (looking-at "-[\n|]"))
+                  (forward-char 1)
+                  (insert "1")
+                  (backward-char 1)
+                  (setq ex-token-type 'minus))
+                 ((looking-at "-[0-9]")
+                  (forward-char 1)
+                  (setq ex-token-type 'minus))
+                 (t
+                  (error vip-BadAddress))))
+          ((looking-at "/")
+           (forward-char 1)
+           (set-mark (point))
+           (let ((cont t))
+             (while (and (not (eolp)) cont)
+               ;;(re-search-forward "[^/]*/")
+               (re-search-forward "[^/]*\\(/\\|\n\\)")
+               (if (not (vip-looking-back "[^\\\\]\\(\\\\\\\\\\)*\\\\/"))
+                   (setq cont nil))))
+           (backward-char 1)
+           (setq ex-token (buffer-substring (point) (mark t)))
+           (if (looking-at "/") (forward-char 1))
+           (setq ex-token-type 'search-forward))
+          ((looking-at "\\?")
+           (forward-char 1)
+           (set-mark (point))
+           (let ((cont t))
+             (while (and (not (eolp)) cont)
+               ;;(re-search-forward "[^\\?]*\\?")
+               (re-search-forward "[^\\?]*\\(\\?\\|\n\\)")
+               (if (not (vip-looking-back "[^\\\\]\\(\\\\\\\\\\)*\\\\\\?"))
+                   (setq cont nil))
+               (backward-char 1)
+               (if (not (looking-at "\n")) (forward-char 1))))
+           (setq ex-token-type 'search-backward)
+           (setq ex-token (buffer-substring (1- (point)) (mark t))))
+          ((looking-at ",")
+           (forward-char 1)
+           (setq ex-token-type 'comma))
+          ((looking-at ";")
+           (forward-char 1)
+           (setq ex-token-type 'semi-colon))
+          ((looking-at "[!=><&~]")
+           (setq ex-token-type 'command)
+           (setq ex-token (char-to-string (following-char)))
+           (forward-char 1))
+          ((looking-at "'")
+           (setq ex-token-type 'goto-mark)
+           (forward-char 1)
+           (cond ((looking-at "'") (setq ex-token nil))
+                 ((looking-at "[a-z]") (setq ex-token (following-char)))
+                 (t (error "Marks are ' and a-z")))
+           (forward-char 1))
+          ((looking-at "\n")
+           (setq ex-token-type 'end-mark)
+           (setq ex-token "goto"))
+          (t
+           (error vip-BadExCommand)))))
+
+;; Reads Ex command. Tries to determine if it has to exit because command
+;; is complete or invalid. If not, keeps reading command.
+(defun ex-cmd-read-exit ()
+  (interactive)
+  (setq vip-incomplete-ex-cmd t)
+  (let ((quit-regex1 (concat
+                      "\\("
+                      "set[ \t]*" "\\|" "edit[ \t]*" "\\|" "[nN]ext[ \t]*"
+                      "\\|" "unm[ \t]*" "\\|" "^[ \t]*rep"
+                      "\\)"))
+        (quit-regex2 (concat
+                      "[a-zA-Z][ \t]*"
+                      "\\(" "!" "\\|" ">>"
+                      "\\|" "\\+[0-9]+"
+                      "\\)"
+                      "*[ \t]*$"))
+        (stay-regex (concat
+                     "\\("
+                     "^[ \t]*$" "\\|" "[ktgjmsz][ \t]*$" "\\|" "^[ \t]*ab.*"
+                     "\\|" "tr[ansfer \t]*" "\\|" "sr[ \t]*"
+                     "\\|" "mo.*" "\\|" "^[ \t]*k?ma[^p]*"
+                     "\\|" "^[ \t]*fi.*" "\\|" "v?gl.*" "\\|" "[vg][ \t]*$"
+                     "\\|" "jo.*" "\\|" "^[ \t]*ta.*" "\\|" "^[ \t]*una.*"
+                     "\\|" "^[ \t]*su.*" "\\|['`][a-z][ \t]*"
+                     "\\|" "![ \t]*[a-zA-Z].*"
+                     "\\)"
+                     "!*")))
+        
+    (save-window-excursion ;; put cursor at the end of the Ex working buffer
+      (set-buffer vip-ex-work-buf)
+      (goto-char (point-max)))
+    (cond ((vip-looking-back quit-regex1) (exit-minibuffer))
+          ((vip-looking-back stay-regex)  (insert " "))
+          ((vip-looking-back quit-regex2) (exit-minibuffer))
+          (t (insert " ")))))
+  
+;; complete Ex command
+(defun ex-cmd-complete ()
+  (interactive)
+  (let (save-pos dist compl-list string-to-complete completion-result)
+    
+    (save-excursion
+      (setq dist (skip-chars-backward "[a-zA-Z!=>&~]")
+            save-pos (point)))
+        
+    (if (or (= dist 0)
+            (vip-looking-back "\\([ \t]*['`][ \t]*[a-z]*\\)")
+            (vip-looking-back
+             "^[ \t]*[a-zA-Z!=>&~][ \t]*[/?]*+[ \t]+[a-zA-Z!=>&~]+"))
+        ;; Preceding characters are not the ones allowed in an Ex command
+        ;; or we have typed past command name.
+        ;; Note: we didn't do parsing, so there may be surprises.
+        (if (or (vip-looking-back "[a-zA-Z!=>&~][ \t]*[/?]*[ \t]*")
+                (vip-looking-back "\\([ \t]*['`][ \t]*[a-z]*\\)")
+                (looking-at "[^ \t\n\C-m]"))
+            nil
+          (with-output-to-temp-buffer "*Completions*" 
+            (display-completion-list
+             (vip-alist-to-list ex-token-alist))))
+      ;; Preceding chars may be part of a command name
+      (setq string-to-complete (buffer-substring save-pos (point)))
+      (setq completion-result
+            (try-completion string-to-complete ex-token-alist))
+      
+      (cond ((eq completion-result t)  ;; exact match--do nothing
+             (vip-tmp-insert-at-eob " (Sole completion)"))
+            ((eq completion-result nil)
+             (vip-tmp-insert-at-eob " (No match)"))
+            (t  ;; partial completion
+             (goto-char save-pos)
+             (delete-region (point) (point-max))
+             (insert completion-result)
+             (let (case-fold-search)
+               (setq compl-list
+                     (vip-filter-alist (concat "^" completion-result)
+                                       ex-token-alist)))
+             (if (> (length compl-list) 1)
+                 (with-output-to-temp-buffer "*Completions*" 
+                   (display-completion-list
+                    (vip-alist-to-list (reverse compl-list)))))))
+      )))
+    
+(defun vip-ex (&optional string)
+  "Ex commands within Viper."
+  (interactive)
+  (or string
+      (setq ex-g-flag nil
+            ex-g-variant nil))
+  (let* ((map (copy-keymap minibuffer-local-map))
+         (address nil)
+         (cont t)
+         (dot (point))
+         com-str)
+         
+    (vip-add-keymap vip-ex-cmd-map map)
+    
+    (setq com-str (or string (vip-read-string-with-history
+                              ":" 
+                              nil
+                              'vip-ex-history
+                              (car vip-ex-history)
+                              map)))
+    (save-window-excursion
+      ;; just a precaution
+      (or (vip-buffer-live-p vip-ex-work-buf)
+          (setq vip-ex-work-buf (get-buffer-create vip-ex-work-buf-name)))
+      (set-buffer vip-ex-work-buf)
+      (delete-region (point-min) (point-max))
+      (insert com-str "\n")
+      (goto-char (point-min)))
+    (setq ex-token-type nil
+          ex-addresses nil)
+    (while cont
+      (vip-get-ex-token)
+      (cond ((memq ex-token-type '(command end-mark))
+             (if address (setq ex-addresses (cons address ex-addresses)))
+             (cond ((string= ex-token "global")
+                    (ex-global nil)
+                    (setq cont nil))
+                   ((string= ex-token "vglobal")
+                    (ex-global t)
+                    (setq cont nil))
+                   (t
+                    (vip-execute-ex-command)
+                    (save-window-excursion
+                      (set-buffer vip-ex-work-buf)
+                      (skip-chars-forward " \t")
+                      (cond ((looking-at "|")
+                             (forward-char 1))
+                            ((looking-at "\n")
+                             (setq cont nil))
+                            (t (error "`%s': %s" ex-token vip-SpuriousText)))
+                      ))
+                   ))
+            ((eq ex-token-type 'non-command)
+             (error (format "`%s': %s" ex-token vip-BadExCommand)))
+            ((eq ex-token-type 'whole)
+             (setq ex-addresses
+                   (cons (point-max) (cons (point-min) ex-addresses))))
+            ((eq ex-token-type 'comma)
+             (setq ex-addresses
+                   (cons (if (null address) (point) address) ex-addresses)))
+            ((eq ex-token-type 'semi-colon)
+             (if address (setq dot address))
+             (setq ex-addresses
+                   (cons (if (null address) (point) address) ex-addresses)))
+            (t (let ((ans (vip-get-ex-address-subr address dot)))
+                 (if ans (setq address ans))))))))
+
+(defun vip-get-ex-pat ()
+  "Get a regular expression and set `ex-variant', if found."
+  (save-window-excursion
+    (set-buffer vip-ex-work-buf)
+    (skip-chars-forward " \t")
+    (if (looking-at "!")
+        (progn
+          (setq ex-g-variant (not ex-g-variant)
+                ex-g-flag (not ex-g-flag))
+          (forward-char 1)
+          (skip-chars-forward " \t")))
+    (let ((c (following-char)))
+      (if (string-match "[0-9A-Za-z]" (format "%c" c))
+          (error
+           "Global regexp must be inside matching non-alphanumeric chars"))
+      (if (looking-at "[^\\\\\n]")
+          (progn
+            (forward-char 1)
+            (set-mark (point))
+            (let ((cont t))
+              (while (and (not (eolp)) cont)
+                (if (not (re-search-forward (format "[^%c]*%c" c c) nil t))
+                    (if (member ex-token '("global" "vglobal"))
+                        (error
+                         "Missing closing delimiter for global regexp")
+                      (goto-char (point-max))))
+                (if (not (vip-looking-back
+                          (format "[^\\\\]\\(\\\\\\\\\\)*\\\\%c" c)))
+                    (setq cont nil))))
+            (setq ex-token
+                  (if (= (mark t) (point)) ""
+                    (buffer-substring (1- (point)) (mark t))))
+            (backward-char 1))
+        (setq ex-token nil))
+      c)))
+
+(defun vip-get-ex-command ()
+  "get an ex command"
+  (save-window-excursion
+    (set-buffer vip-ex-work-buf)
+    (if (looking-at "/") (forward-char 1))
+    (skip-chars-forward " \t")
+    (cond ((looking-at "[a-z]")
+           (vip-get-ex-com-subr)
+           (if (eq ex-token-type 'non-command)
+               (error "`%s': %s" ex-token vip-BadExCommand)))
+          ((looking-at "[!=><&~]")
+           (setq ex-token (char-to-string (following-char)))
+           (forward-char 1))
+          (t (error vip-BadExCommand)))))
+
+(defun vip-get-ex-opt-gc (c)
+  "Get an Ex option g or c."
+  (save-window-excursion
+    (set-buffer vip-ex-work-buf)
+    (if (looking-at (format "%c" c)) (forward-char 1))
+    (skip-chars-forward " \t")
+    (cond ((looking-at "g")
+           (setq ex-token "g")
+           (forward-char 1)
+           t)
+          ((looking-at "c")
+           (setq ex-token "c")
+           (forward-char 1)
+           t)
+          (t nil))))
+
+(defun vip-default-ex-addresses (&optional whole-flag)
+  "Compute default addresses.  WHOLE-FLAG means use the whole buffer."
+  (cond ((null ex-addresses)
+         (setq ex-addresses
+               (if whole-flag
+                   (cons (point-max) (cons (point-min) nil))
+                 (cons (point) (cons (point) nil)))))
+        ((null (cdr ex-addresses))
+         (setq ex-addresses
+               (cons (car ex-addresses) ex-addresses)))))
+
+(defun vip-get-ex-address ()
+  "Get an ex-address as a marker and set ex-flag if a flag is found."
+  (let ((address (point-marker)) (cont t))
+    (setq ex-token "")
+    (setq ex-flag nil)
+    (while cont
+      (vip-get-ex-token)
+      (cond ((eq ex-token-type 'command)
+             (if (member ex-token '("print" "list" "#"))
+                 (progn
+                   (setq ex-flag t
+                         cont nil))
+               (error "Address expected in this Ex command")))
+            ((eq ex-token-type 'end-mark)
+             (setq cont nil))
+            ((eq ex-token-type 'whole)
+             (error "Trailing address expected"))
+            ((eq ex-token-type 'comma)
+             (error "`%s': %s" ex-token vip-SpuriousText))
+            (t (let ((ans (vip-get-ex-address-subr address (point-marker))))
+                 (if ans (setq address ans))))))
+    address))
+
+(defun vip-get-ex-address-subr (old-address dot)
+  "Returns an address as a point."
+  (let ((address nil))
+    (if (null old-address) (setq old-address dot))
+    (cond ((eq ex-token-type 'dot)
+           (setq address dot))
+          ((eq ex-token-type 'add-number)
+           (save-excursion
+             (goto-char old-address)
+             (forward-line (if (= old-address 0) (1- ex-token) ex-token))
+             (setq address (point-marker))))
+          ((eq ex-token-type 'sub-number)
+           (save-excursion
+             (goto-char old-address)
+             (forward-line (- ex-token))
+             (setq address (point-marker))))
+          ((eq ex-token-type 'abs-number)
+           (save-excursion
+             (goto-char (point-min))
+             (if (= ex-token 0) (setq address 0)
+               (forward-line (1- ex-token))
+               (setq address (point-marker)))))
+          ((eq ex-token-type 'end)
+           (setq address (point-max-marker)))
+          ((eq ex-token-type 'plus) t);; do nothing
+          ((eq ex-token-type 'minus) t);; do nothing
+          ((eq ex-token-type 'search-forward)
+           (save-excursion
+             (ex-search-address t)
+             (setq address (point-marker))))
+          ((eq ex-token-type 'search-backward)
+           (save-excursion
+             (ex-search-address nil)
+             (setq address (point-marker))))
+          ((eq ex-token-type 'goto-mark)
+           (save-excursion
+             (if (null ex-token)
+                 (exchange-point-and-mark)
+               (goto-char (vip-register-to-point
+                           (1+ (- ex-token ?a)) 'enforce-buffer)))
+             (setq address (point-marker)))))
+    address))
+
+
+(defun ex-search-address (forward)
+  "Search pattern and set address."
+  (if (string= ex-token "")
+      (if (null vip-s-string)
+          (error vip-NoPrevSearch)
+        (setq ex-token vip-s-string))
+    (setq vip-s-string ex-token))
+  (if forward
+      (progn
+        (forward-line 1)
+        (re-search-forward ex-token))
+    (forward-line -1)
+    (re-search-backward ex-token)))
+
+(defun vip-get-ex-buffer ()
+  "Get a buffer name and set `ex-count' and `ex-flag' if found."
+  (setq ex-buffer nil)
+  (setq ex-count nil)
+  (setq ex-flag nil)
+  (save-window-excursion
+    (set-buffer vip-ex-work-buf)
+    (skip-chars-forward " \t")
+    (if (looking-at "[a-zA-Z]")
+        (progn
+          (setq ex-buffer (following-char))
+          (forward-char 1)
+          (skip-chars-forward " \t")))
+    (if (looking-at "[0-9]")
+        (progn
+          (set-mark (point))
+          (re-search-forward "[0-9][0-9]*")
+          (setq ex-count (string-to-int (buffer-substring (point) (mark t))))
+          (skip-chars-forward " \t")))
+    (if (looking-at "[pl#]")
+        (progn
+          (setq ex-flag t)
+          (forward-char 1)))
+    (if (not (looking-at "[\n|]"))
+        (error "`%s': %s" ex-token vip-SpuriousText))))
+
+(defun vip-get-ex-count ()
+  (setq ex-variant nil
+        ex-count nil
+        ex-flag nil)
+  (save-window-excursion
+    (set-buffer vip-ex-work-buf)
+    (skip-chars-forward " \t")
+    (if (looking-at "!")
+        (progn
+          (setq ex-variant t)
+          (forward-char 1)))
+    (skip-chars-forward " \t")
+    (if (looking-at "[0-9]")
+        (progn
+          (set-mark (point))
+          (re-search-forward "[0-9][0-9]*")
+          (setq ex-count (string-to-int (buffer-substring (point) (mark t))))
+          (skip-chars-forward " \t")))
+    (if (looking-at "[pl#]")
+        (progn
+          (setq ex-flag t)
+          (forward-char 1)))
+    (if (not (looking-at "[\n|]"))
+        (error "`%s': %s"
+               (buffer-substring (point-min) (1- (point-max))) vip-BadExCommand))))
+
+(defun ex-expand-filsyms (cmd buf)
+  "Expand \% and \# in ex command."
+  (let (cf pf ret)
+    (save-excursion 
+      (set-buffer buf)
+      (setq cf buffer-file-name)
+      (setq pf (ex-next nil t))) ;; this finds alternative file name
+    (if (and (null cf) (string-match "[^\\]%\\|\\`%" cmd))
+        (error "No current file to substitute for `\%'"))
+    (if (and (null pf) (string-match "[^\\]#\\|\\`#" cmd))
+        (error "No alternate file to substitute for `#'"))
+    (save-excursion
+      (set-buffer (get-buffer-create " ex-tmp"))
+      (insert cmd)
+      (goto-char (point-min))
+      (while (re-search-forward "%\\|#" nil t)
+        (let ((data (match-data)) 
+              (char (buffer-substring (match-beginning 0) (match-end 0))))
+          (if (vip-looking-back (concat "\\\\" char))
+              (replace-match char)
+            (store-match-data data)
+            (if (string= char "%")
+                (replace-match cf)
+              (replace-match pf)))))
+      (end-of-line)
+      (setq ret (buffer-substring (point-min) (point)))
+      (kill-buffer (current-buffer))
+      (message "%s" ret))
+    ret))
+
+(defun vip-get-ex-file ()
+  "Get a file name and set ex-variant, `ex-append' and `ex-offset' if found."
+  (let (prompt)
+    (setq ex-file nil
+          ex-variant nil
+          ex-append nil
+          ex-offset nil
+          ex-cmdfile nil)
+    (save-excursion
+      (save-window-excursion
+        (set-buffer vip-ex-work-buf)
+        (skip-chars-forward " \t")
+        (if (looking-at "!")
+            (if (not (vip-looking-back "[ \t]"))
+                (progn
+                  (setq ex-variant t)
+                  (forward-char 1)
+                  (skip-chars-forward " \t"))
+              (setq ex-cmdfile t)
+              (forward-char 1)
+              (skip-chars-forward " \t")))
+        (if (looking-at ">>")
+            (progn
+              (setq ex-append t
+                    ex-variant t)
+              (forward-char 2)
+              (skip-chars-forward " \t")))
+        (if (looking-at "+")
+            (progn
+              (forward-char 1)
+              (set-mark (point))
+              (re-search-forward "[ \t\n]")
+              (backward-char 1)
+              (setq ex-offset (buffer-substring (point) (mark t)))
+              (forward-char 1)
+              (skip-chars-forward " \t")))
+        ;; this takes care of :r, :w, etc., when they get file names
+        ;; from the history list
+        (if (member ex-token '("read" "write" "edit" "visual"))
+            (progn
+              (setq ex-file (buffer-substring (point)  (1- (point-max))))
+              (setq ex-file
+                    ;; For :e, match multiple non-white strings separated
+                    ;; by white. For others, find the first non-white string
+                    (if (string-match
+                         (if (string= ex-token "edit")
+                             "[^ \t\n]+\\([ \t]+[^ \t\n]+\\)*"
+                           "[^ \t\n]+")
+                         ex-file)
+                        (progn
+                          ;; if file name comes from history, don't leave
+                          ;; minibuffer when the user types space
+                          (setq vip-incomplete-ex-cmd nil)
+                          ;; this must be the last clause in this progn
+                          (substring ex-file (match-beginning 0) (match-end 0))
+                          )
+                      ""))
+              ;; this leaves only the command name in the work area
+              ;; file names are gone
+              (delete-region (point) (1- (point-max)))
+              ))
+        (goto-char (point-max))
+        (skip-chars-backward " \t\n")
+        (setq prompt (buffer-substring (point-min) (point)))
+        ))
+    
+    (setq vip-last-ex-prompt prompt)
+    
+    ;; If we just finished reading command, redisplay prompt
+    (if vip-incomplete-ex-cmd
+        (setq ex-file (vip-ex-read-file-name (format ":%s " prompt)))
+      ;; file was typed in-line
+      (setq ex-file (or ex-file "")))
+    ))
+
+
+;; Completes file name or exits minibuffer. If Ex command accepts multiple
+;; file names, arranges to re-enter the minibuffer.
+(defun vip-complete-filename-or-exit ()
+  (interactive)
+  (setq vip-keep-reading-filename t) 
+  ;; don't exit if directory---ex-commands don't 
+  (cond ((ex-cmd-accepts-multiple-files-p ex-token) (exit-minibuffer))
+        (t (minibuffer-complete-word))))
+     
+               
+(defun ex-cmd-accepts-multiple-files-p (token)
+  (member token '("edit" "next" "Next")))
+
+;; If user doesn't enter anything, then "" is returned, i.e., the
+;; prompt-directory is not returned.
+(defun vip-ex-read-file-name (prompt)
+  (let* ((str "")
+         (minibuffer-local-completion-map
+          (copy-keymap minibuffer-local-completion-map))
+         beg end cont val)
+    
+    (vip-add-keymap ex-read-filename-map minibuffer-local-completion-map) 
+                    
+    (setq cont (setq vip-keep-reading-filename t))
+    (while cont
+      (setq vip-keep-reading-filename nil
+            val (read-file-name (concat prompt str) nil default-directory)
+            str  (concat str (if (equal val "") "" " ")
+                         val (if (equal val "") "" " ")))
+                         
+      ;; Only edit, next, and Next commands accept multiple files.
+      ;; vip-keep-reading-filename is set in the anonymous function that is
+      ;; bound to " " in ex-read-filename-map.
+      (setq cont (and vip-keep-reading-filename
+                      (ex-cmd-accepts-multiple-files-p ex-token)))
+      )
+    
+    (setq beg (string-match "[^ \t]" str)   ;; delete leading blanks
+          end (string-match "[ \t]*$" str)) ;; delete trailing blanks
+    (if (member ex-token '("read" "write"))
+          (if (string-match "[\t ]*!" str)
+              ;; this is actually a shell command
+              (progn
+                (setq ex-cmdfile t)
+                (setq beg (1+ beg))
+                (setq vip-last-ex-prompt (concat vip-last-ex-prompt " !")))))
+    (substring str (or beg 0) end)))
+
+(defun vip-execute-ex-command ()
+  "Execute ex command using the value of addresses."
+  (vip-deactivate-mark)
+  (cond ((string= ex-token "args") (ex-args))
+        ((string= ex-token "copy") (ex-copy nil))
+        ((string= ex-token "cd") (ex-cd))
+        ((string= ex-token "chdir") (ex-cd))
+        ((string= ex-token "delete") (ex-delete))
+        ((string= ex-token "edit") (ex-edit))
+        ((string= ex-token "file") (vip-info-on-file))
+        ((string= ex-token "goto") (ex-goto))
+        ((string= ex-token "help") (ex-help))
+        ((string= ex-token "join") (ex-line "join"))
+        ((string= ex-token "kmark") (ex-mark))
+        ((string= ex-token "mark") (ex-mark))
+        ((string= ex-token "map") (ex-map))
+        ((string= ex-token "move") (ex-copy t))
+        ((string= ex-token "next") (ex-next ex-cycle-other-window))
+        ((string= ex-token "Next") (ex-next (not ex-cycle-other-window)))
+        ((string= ex-token "RelatedFile") (ex-next-related-buffer 1))
+        ((string= ex-token "put") (ex-put))
+        ((string= ex-token "pwd") (ex-pwd))
+        ((string= ex-token "preserve") (ex-preserve))
+        ((string= ex-token "PreviousRelatedFile") (ex-next-related-buffer -1))
+        ((string= ex-token "quit") (ex-quit))
+        ((string= ex-token "read") (ex-read))
+        ((string= ex-token "recover") (ex-recover))
+        ((string= ex-token "rewind") (ex-rewind))
+        ((string= ex-token "submitReport") (vip-submit-report))
+        ((string= ex-token "set") (ex-set))
+        ((string= ex-token "shell") (ex-shell))
+        ((string= ex-token "source") (ex-source))
+        ((string= ex-token "sr") (ex-substitute t t))
+        ((string= ex-token "substitute") (ex-substitute))
+        ((string= ex-token "suspend") (suspend-emacs))
+        ((string= ex-token "stop") (suspend-emacs))
+        ((string= ex-token "transfer") (ex-copy nil))
+        ((string= ex-token "buffer") (if ex-cycle-other-window
+                                         (vip-switch-to-buffer-other-window)
+                                         (vip-switch-to-buffer)))
+        ((string= ex-token "Buffer") (if ex-cycle-other-window
+                                         (vip-switch-to-buffer)
+                                         (vip-switch-to-buffer-other-window)))
+        ((string= ex-token "tag") (ex-tag))
+        ((string= ex-token "undo") (vip-undo))
+        ((string= ex-token "unmap") (ex-unmap))
+        ((string= ex-token "version") (vip-version))
+        ((string= ex-token "visual") (ex-edit))
+        ((string= ex-token "write") (ex-write nil))
+        ((string= ex-token "Write") (save-some-buffers))
+        ((string= ex-token "wq") (ex-write t))
+        ((string= ex-token "WWrite") (save-some-buffers t)) ; don't ask
+        ((string= ex-token "xit") (ex-write t))
+        ((string= ex-token "yank") (ex-yank))
+        ((string= ex-token "!") (ex-command))
+        ((string= ex-token "=") (ex-line-no))
+        ((string= ex-token ">") (ex-line "right"))
+        ((string= ex-token "<") (ex-line "left"))
+        ((string= ex-token "&") (ex-substitute t))
+        ((string= ex-token "~") (ex-substitute t t))
+        ((or (string= ex-token "append")
+             (string= ex-token "change")
+             (string= ex-token "insert")
+             (string= ex-token "open"))
+         (error
+          (format "`%s': Obsolete command, not supported by Viper"
+                  ex-token)))
+        ((or (string= ex-token "abbreviate")
+             (string= ex-token "unabbreviate"))
+         (error
+          (format
+           "`%s': Vi's abbrevs are obsolete. Use more powerful Emacs' abbrevs"
+           ex-token)))
+        ((or (string= ex-token "list")
+             (string= ex-token "print")
+             (string= ex-token "z")
+             (string= ex-token "#"))
+         (error
+          (format "`%s': Command not implemented in Viper" ex-token)))
+        (t (error (format "`%s': %s" ex-token vip-BadExCommand)))))
+
+(defun vip-undisplayed-files ()
+  (mapcar
+   (function 
+    (lambda (b) 
+      (if (null (get-buffer-window b))
+          (let ((f (buffer-file-name b)))
+            (if f f
+              (if ex-cycle-through-non-files 
+                  (let ((s (buffer-name b)))
+                    (if (string= " " (substring s 0 1))
+                        nil
+                      s))
+                nil)))
+        nil)))
+   (buffer-list)))
+
+
+(defun ex-args ()
+  (let ((l (vip-undisplayed-files))
+        (args "")
+        (file-count 1))
+    (while (not (null l))
+      (if (car l) 
+          (setq args (format "%s %d) %s\n" args file-count (car l))
+                file-count (1+ file-count)))
+      (setq l (cdr l)))
+    (if (string= args "")
+        (message "All files are already displayed")
+      (save-excursion
+        (save-window-excursion
+          (with-output-to-temp-buffer " *vip-info*"
+            (princ "\n\nThese files are not displayed in any window.\n")
+            (princ "\n=============\n")
+            (princ args)
+            (princ "\n=============\n")
+            (princ "\nThe numbers can be given as counts to :next. ")
+            (princ "\n\nPress any key to continue...\n\n"))
+          (vip-read-char-exclusive))))))
+
+(defun ex-cd ()
+  "Ex cd command. Default directory of this buffer changes."
+  (vip-get-ex-file)
+  (if (string= ex-file "")
+      (setq ex-file "~"))
+  (setq default-directory (file-name-as-directory (expand-file-name ex-file))))
+
+(defun ex-copy (del-flag)
+  "Ex copy and move command.  DEL-FLAG means delete."
+  (vip-default-ex-addresses)
+  (let ((address (vip-get-ex-address))
+        (end (car ex-addresses)) (beg (car (cdr ex-addresses))))
+    (goto-char end)
+    (save-excursion
+      (push-mark beg t)
+      (vip-enlarge-region (mark t) (point))
+      (if del-flag
+          (kill-region (point) (mark t))
+        (copy-region-as-kill (point) (mark t)))
+      (if ex-flag
+          (progn
+            (with-output-to-temp-buffer "*copy text*"
+              (princ
+               (if (or del-flag ex-g-flag ex-g-variant)
+                   (current-kill 0)
+                 (buffer-substring (point) (mark t)))))
+            (condition-case nil
+                (progn
+                  (read-string "[Hit return to continue] ")
+                  (save-excursion (kill-buffer "*copy text*")))
+              (quit (save-excursion (kill-buffer "*copy text*"))
+                    (signal 'quit nil))))))
+    (if (= address 0)
+        (goto-char (point-min))
+      (goto-char address)
+      (forward-line 1))
+      (insert (current-kill 0))))
+
+(defun ex-delete ()
+  "Ex delete command."
+  (vip-default-ex-addresses)
+  (vip-get-ex-buffer)
+  (let ((end (car ex-addresses)) (beg (car (cdr ex-addresses))))
+    (if (> beg end) (error vip-FirstAddrExceedsSecond))
+    (save-excursion
+      (vip-enlarge-region beg end)
+      (exchange-point-and-mark)
+      (if ex-count
+          (progn
+            (set-mark (point))
+            (forward-line (1- ex-count)))
+        (set-mark end))
+      (vip-enlarge-region (point) (mark t))
+      (if ex-flag
+          ;; show text to be deleted and ask for confirmation
+          (progn
+            (with-output-to-temp-buffer " *delete text*"
+              (princ (buffer-substring (point) (mark t))))
+            (condition-case nil
+                (read-string "[Hit return to continue] ")
+              (quit
+               (save-excursion (kill-buffer " *delete text*"))
+               (error "")))
+            (save-excursion (kill-buffer " *delete text*")))
+        (if ex-buffer
+            (cond ((vip-valid-register ex-buffer '(Letter))
+                   (vip-append-to-register
+                    (downcase ex-buffer) (point) (mark t)))
+                  ((vip-valid-register ex-buffer)
+                   (copy-to-register ex-buffer (point) (mark t) nil))
+                  (t (error vip-InvalidRegister ex-buffer))))
+        (kill-region (point) (mark t))))))
+
+
+
+(defun ex-edit (&optional file)
+  "Ex edit command.
+In Viper, `e' and `e!' behave identically. In both cases, the user is
+asked if current buffer should really be discarded.
+This command can take multiple file names. It replaces the current buffer
+with the first file in its argument list."
+  (if (not file)
+      (vip-get-ex-file))
+  (cond ((and (string= ex-file "") buffer-file-name)
+         (setq ex-file  (abbreviate-file-name (buffer-file-name))))
+        ((string= ex-file "")
+         (error vip-NoFileSpecified)))
+      
+  (let (msg do-edit)
+    (if buffer-file-name
+        (cond ((buffer-modified-p)
+               (setq msg
+                     (format "Buffer %s is modified. Edit buffer? "
+                             (buffer-name))
+                     do-edit t))
+              ((not (verify-visited-file-modtime (current-buffer)))
+               (setq msg
+                     (format "File %s changed on disk.  Reread from disk? "
+                             buffer-file-name)
+                     do-edit t))
+              (t (setq do-edit nil))))
+      
+    (if do-edit
+        (if (yes-or-no-p msg)
+            (progn
+              (set-buffer-modified-p nil)
+              (kill-buffer (current-buffer)))
+          (message "Buffer %s was left intact" (buffer-name))))
+    ) ; let
+  
+  (if (null (setq file (get-file-buffer ex-file)))
+      (progn 
+        (ex-find-file ex-file)
+        (vip-change-state-to-vi)
+        (goto-char (point-min)))
+    (switch-to-buffer file))
+  (if ex-offset
+      (progn
+        (save-window-excursion
+          (set-buffer vip-ex-work-buf)
+          (delete-region (point-min) (point-max))
+          (insert ex-offset "\n")
+          (goto-char (point-min)))
+        (goto-char (vip-get-ex-address))
+        (beginning-of-line)))
+  (ex-fixup-history vip-last-ex-prompt ex-file))
+
+;; splits the string FILESPEC into substrings separated by newlines `\012'
+;; each line assumed to be a file name. find-file's each file thus obtained.
+(defun ex-find-file (filespec)
+  (let (s f filebuf)
+    (if (string-match "[^a-zA-Z0-9_.-/]" filespec)
+        (progn
+          (save-excursion 
+            (set-buffer (get-buffer-create " ex-tmp"))
+            (call-process ex-find-file-shell nil t nil
+                          ex-find-file-shell-options 
+                          "-c"
+                          (format "echo %s | tr ' ' '\\012'" filespec))
+            (goto-char (point-min))
+            (while (not (eobp))
+              (setq s (point))
+              (end-of-line)
+              (setq f (buffer-substring s (point)))
+              (setq filebuf (find-file-noselect f))
+              (forward-to-indentation 1))
+            (kill-buffer (current-buffer))))
+      (setq filebuf (find-file-noselect (setq f filespec))))
+    (switch-to-buffer filebuf)
+    ))
+
+(defun ex-global (variant)
+  "Ex global command."
+  (let ((gcommand ex-token))
+    (if (or ex-g-flag ex-g-variant)
+        (error "`%s' within `global' is not allowed" gcommand)
+      (if variant
+          (setq ex-g-flag nil
+                ex-g-variant t)
+        (setq ex-g-flag t
+              ex-g-variant nil)))
+    (vip-get-ex-pat)
+    (if (null ex-token)
+        (error "`%s': Missing regular expression" gcommand)))
+  
+  (if (string= ex-token "")
+      (if (null vip-s-string)
+          (error vip-NoPrevSearch)
+        (setq ex-g-pat vip-s-string))
+    (setq ex-g-pat ex-token
+          vip-s-string ex-token))
+  (if (null ex-addresses)
+      (setq ex-addresses (list (point-max) (point-min)))
+    (vip-default-ex-addresses))
+  (let ((marks nil) (mark-count 0)
+        com-str (end (car ex-addresses)) (beg (car (cdr ex-addresses))))
+    (if (> beg end) (error vip-FirstAddrExceedsSecond))
+    (save-excursion
+      (vip-enlarge-region beg end)
+      (exchange-point-and-mark)
+      (let ((cont t) (limit (point-marker)))
+        (exchange-point-and-mark)
+        ;; skip the last line if empty
+        (beginning-of-line)
+        (if (eobp) (vip-backward-char-carefully))
+        (while (and cont (not (bobp)) (>= (point) limit))
+          (beginning-of-line)
+          (set-mark (point))
+          (end-of-line)
+          (let ((found (re-search-backward ex-g-pat (mark t) t)))
+            (if (or (and ex-g-flag found)
+                    (and ex-g-variant (not found)))
+                (progn
+                  (end-of-line)
+                  (setq mark-count (1+ mark-count))
+                  (setq marks (cons (point-marker) marks)))))
+          (beginning-of-line)
+          (if (bobp) (setq cont nil)
+            (forward-line -1)
+            (end-of-line)))))
+    (save-window-excursion
+      (set-buffer vip-ex-work-buf)
+      (setq com-str (buffer-substring (1+ (point)) (1- (point-max)))))
+    (while marks
+      (goto-char (car marks))
+      (vip-ex com-str)
+      (setq mark-count (1- mark-count))
+      (setq marks (cdr marks)))))
+
+(defun ex-goto ()
+  "Ex goto command."
+  (if (null ex-addresses)
+      (setq ex-addresses (cons (point) nil)))
+  (push-mark (point) t)
+  (goto-char (car ex-addresses))
+  (beginning-of-line))
+
+(defun ex-line (com)
+  "Ex line commands.  COM is join, shift-right or shift-left."
+  (vip-default-ex-addresses)
+  (vip-get-ex-count)
+  (let ((end (car ex-addresses)) (beg (car (cdr ex-addresses))) point)
+    (if (> beg end) (error vip-FirstAddrExceedsSecond))
+    (save-excursion
+      (vip-enlarge-region beg end)
+      (exchange-point-and-mark)
+      (if ex-count
+          (progn
+            (set-mark (point))
+            (forward-line ex-count)))
+      (if ex-flag
+          ;; show text to be joined and ask for confirmation
+          (progn
+            (with-output-to-temp-buffer " *text*"
+              (princ (buffer-substring (point) (mark t))))
+            (condition-case nil
+                (progn
+                  (read-string "[Hit return to continue] ")
+                  (ex-line-subr com (point) (mark t)))
+              (quit (ding)))
+            (save-excursion (kill-buffer " *text*")))
+        (ex-line-subr com (point) (mark t)))
+      (setq point (point)))
+    (goto-char (1- point))
+    (beginning-of-line)))
+
+(defun ex-line-subr (com beg end)
+  (cond ((string= com "join")
+         (goto-char (min beg end))
+         (while (and (not (eobp)) (< (point) (max beg end)))
+           (end-of-line)
+           (if (and (<= (point) (max beg end)) (not (eobp)))
+               (progn
+                 (forward-line 1)
+                 (delete-region (point) (1- (point)))
+                 (if (not ex-variant) (fixup-whitespace))))))
+        ((or (string= com "right") (string= com "left"))
+         (indent-rigidly
+          (min beg end) (max beg end)
+          (if (string= com "right") vip-shift-width (- vip-shift-width)))
+         (goto-char (max beg end))
+         (end-of-line)
+         (vip-forward-char-carefully))))
+
+
+(defun ex-mark ()
+  "Ex mark command."
+  (let (char)
+    (if (null ex-addresses)
+        (setq ex-addresses
+              (cons (point) nil)))
+    (save-window-excursion
+      (set-buffer vip-ex-work-buf)
+      (skip-chars-forward " \t")
+      (if (looking-at "[a-z]")
+          (progn
+            (setq char (following-char))
+            (forward-char 1)
+            (skip-chars-forward " \t")
+            (if (not (looking-at "[\n|]"))
+                (error "`%s': %s" ex-token vip-SpuriousText)))
+        (error "`%s' requires a following letter" ex-token)))
+    (save-excursion
+      (goto-char (car ex-addresses))
+      (point-to-register (1+ (- char ?a))))))
+
+    
+      
+;; Alternate file is the file next to the first one in the buffer ring
+(defun ex-next (cycle-other-window &optional find-alt-file)
+  (catch 'ex-edit
+    (let (count l)
+      (if (not find-alt-file) 
+          (progn
+            (vip-get-ex-file)
+            (if (or (char-or-string-p ex-offset)
+                    (not (string= "" ex-file)))
+                    ;(and (not (string= "" ex-file)) 
+                    ;     (not (string-match "[0-9]+" ex-file))))
+                (progn
+                  (ex-edit t)
+                  (throw 'ex-edit nil))
+              (setq count (string-to-int ex-file))
+              (if (= count 0) (setq count 1))
+              (if (< count 0) (error "Usage: `next <count>' (count >= 0)"))))
+        (setq count 1))
+      (setq l (vip-undisplayed-files))
+      (while (> count 0)
+        (while (and (not (null l)) (null (car l)))
+          (setq l (cdr l)))
+        (setq count (1- count))
+        (if (> count 0)
+            (setq l (cdr l))))
+      (if find-alt-file (car l)
+        (progn
+          (if (car l)
+              (let* ((w (if cycle-other-window
+                            (get-lru-window) (selected-window)))
+                     (b (window-buffer w)))
+                (set-window-buffer w (get-file-buffer (car l)))
+                (bury-buffer b))
+            (error "Not that many undisplayed files")))))))
+
+
+(defun ex-next-related-buffer (direction &optional no-recursion)
+  
+  (vip-ring-rotate1 vip-related-files-and-buffers-ring direction)
+  
+  (let ((file-or-buffer-name 
+         (vip-current-ring-item vip-related-files-and-buffers-ring))
+        (old-ring vip-related-files-and-buffers-ring)
+        (old-win (selected-window))
+        skip-rest buf wind)
+    
+    (or (and (ring-p vip-related-files-and-buffers-ring)
+             (> (ring-length vip-related-files-and-buffers-ring) 0))
+        (error "This buffer has no related files or buffers"))
+        
+    (or (stringp file-or-buffer-name)
+        (error
+         "File and buffer names must be strings, %S" file-or-buffer-name))
+    
+    (setq buf (cond ((get-buffer file-or-buffer-name))
+                    ((file-exists-p file-or-buffer-name)
+                     (find-file-noselect file-or-buffer-name))
+                    ))
+    
+    (if (not (vip-buffer-live-p buf))
+        (error "Didn't find buffer %S or file %S"
+               file-or-buffer-name
+               (abbreviate-file-name (expand-file-name file-or-buffer-name))))
+          
+    (if (equal buf (current-buffer))
+        (or no-recursion
+            ;; try again
+            (setq skip-rest t)
+            (ex-next-related-buffer direction 'norecursion)))
+        
+    (if skip-rest
+        ()
+      ;; setup buffer
+      (if (setq wind (vip-get-visible-buffer-window buf))
+          ()
+        (setq wind (get-lru-window (if vip-xemacs-p nil 'visible)))
+        (set-window-buffer wind buf))
+            
+      (if window-system
+          (progn
+            (vip-raise-frame (vip-window-frame wind))
+            (if (equal (vip-window-frame wind) (vip-window-frame old-win))
+                (save-window-excursion (select-window wind) (sit-for 1))
+              (select-window wind)))
+        (save-window-excursion (select-window wind) (sit-for 1)))
+        
+      (save-excursion
+        (set-buffer buf)
+        (setq vip-related-files-and-buffers-ring old-ring))
+      
+      (setq vip-local-search-start-marker (point-marker))
+      )))
+  
+    
+(defun ex-preserve ()
+  "Force auto save."
+  (message "Autosaving all buffers that need to be saved...")
+  (do-auto-save t))
+
+(defun ex-put ()
+  "Ex put."
+  (let ((point (if (null ex-addresses) (point) (car ex-addresses))))
+    (vip-get-ex-buffer)
+    (setq vip-use-register ex-buffer)
+    (goto-char point)
+    (if (bobp) (vip-Put-back 1) (vip-put-back 1))))
+
+(defun ex-pwd ()
+  "Ex print working directory."
+  (message default-directory))
+
+(defun ex-quit ()
+  "Ex quit command."
+  (if (< vip-expert-level 3)
+      (save-buffers-kill-emacs)
+    (kill-buffer (current-buffer))))
+
+
+(defun ex-read ()
+  "Ex read command."
+  (vip-get-ex-file)
+  (let ((point (if (null ex-addresses) (point) (car ex-addresses))))
+    (goto-char point)
+    (vip-add-newline-at-eob-if-necessary)
+    (if (not (or (bobp) (eobp))) (forward-line 1))
+    (if (and (not ex-variant) (string= ex-file ""))
+        (progn
+          (if (null buffer-file-name)
+              (error vip-NoFileSpecified))
+          (setq ex-file buffer-file-name)))
+    (if ex-cmdfile
+        (shell-command ex-file t)
+      (insert-file-contents ex-file)))
+  (ex-fixup-history vip-last-ex-prompt ex-file))
+  
+;; this function fixes ex-history for some commands like ex-read, ex-edit
+(defun ex-fixup-history (&rest args)  
+  (setq vip-ex-history
+        (cons (mapconcat 'identity args " ") (cdr vip-ex-history))))
+  
+
+(defun ex-recover ()
+  "Ex recover from emacs \#file\#."
+  (vip-get-ex-file)
+  (if (or ex-append ex-offset)
+      (error "`recover': %s" vip-SpuriousText))
+  (if (string= ex-file "")
+      (progn
+        (if (null buffer-file-name)
+            (error "This buffer isn't visiting any file"))
+        (setq ex-file buffer-file-name))
+    (setq ex-file (expand-file-name ex-file)))
+  (if (and (not (string= ex-file (buffer-file-name)))
+           (buffer-modified-p)
+           (not ex-variant))
+      (error "No write since last change \(:rec! overrides\)"))
+  (recover-file ex-file))
+
+(defun ex-rewind ()
+  "Tell that `rewind' is obsolete and that one should use `:next count'"
+  (message
+   "Use `:n <count>' instead. Counts are obtained from the `:args' command"))
+
+
+;; read variable name for ex-set
+(defun ex-set-read-variable ()
+  (let ((minibuffer-local-completion-map
+         (copy-keymap minibuffer-local-completion-map))
+        (cursor-in-echo-area t)
+        str batch)
+    (define-key
+      minibuffer-local-completion-map " " 'minibuffer-complete-and-exit)
+    (define-key minibuffer-local-completion-map "=" 'exit-minibuffer)
+    (if (vip-set-unread-command-events
+         (ex-get-inline-cmd-args "[ \t]*[a-zA-Z]*[ \t]*" nil "\C-m"))
+        (progn
+          (setq batch t)
+          (vip-set-unread-command-events ?\C-m)))
+    (message ":set  <Variable> [= <Value>]")
+    (or batch (sit-for 2))
+    
+    (while (string-match "^[ \\t\\n]*$"
+                         (setq str
+                               (completing-read ":set " ex-variable-alist)))
+      (message ":set <Variable> ")
+      ;; if there are unread events, don't wait
+      (or (vip-set-unread-command-events "") (sit-for 2))
+      ) ; while
+    str))
+
+
+(defun ex-set ()
+  (let ((var (ex-set-read-variable))
+        (val 0)
+        (set-cmd "setq")
+        (ask-if-save t)
+        (auto-cmd-label "; don't touch or else...")
+        (delete-turn-on-auto-fill-pattern
+         "([ \t]*add-hook[ \t]+'vip-insert-state-hooks[ \t]+'turn-on-auto-fill.*)")
+        actual-lisp-cmd lisp-cmd-del-pattern
+        val2 orig-var)
+    (setq orig-var var)
+    (cond ((member var '("ai" "autoindent"))
+           (setq var "vip-auto-indent"
+                 val "t"))
+          ((member var '("noai" "noautoindent"))
+           (setq var "vip-auto-indent"
+                 val "nil"))
+          ((member var '("ic" "ignorecase"))
+           (setq var "vip-case-fold-search"
+                 val "t"))
+          ((member var '("noic" "noignorecase"))
+           (setq var "vip-case-fold-search"
+                 val "nil"))
+          ((member var '("ma" "magic"))
+           (setq var "vip-re-search"
+                 val "t"))
+          ((member var '("noma" "nomagic"))
+           (setq var "vip-re-search"
+                 val "nil"))
+          ((member var '("ro" "readonly"))
+           (setq var "buffer-read-only"
+                 val "t"))
+          ((member var '("noro" "noreadonly"))
+           (setq var "buffer-read-only"
+                 val "nil"))
+          ((member var '("sm" "showmatch"))
+           (setq var "blink-matching-paren"
+                 val "t"))
+          ((member var '("nosm" "noshowmatch"))
+           (setq var "blink-matching-paren"
+                 val "nil"))
+          ((member var '("ws" "wrapscan"))
+           (setq var "vip-search-wrap-around-t"
+                 val "t"))
+          ((member var '("nows" "nowrapscan"))
+           (setq var "vip-search-wrap-around-t"
+                 val "nil")))
+    (if (eq val 0) ;; value must be set by the user
+        (let ((cursor-in-echo-area t))
+          (message (format ":set %s = <Value>" var))
+          ;; if there are unread events, don't wait
+          (or (vip-set-unread-command-events "") (sit-for 2))
+          (setq val (read-string (format ":set %s = " var)))
+          (ex-fixup-history "set" orig-var val)
+          
+          ;; check numerical values
+          (if (member var
+                      '("sw" "shiftwidth" "ts" "tabstop" "wm" "wrapmargin"))
+              (condition-case nil
+                  (or (numberp (setq val2 (car (read-from-string val))))
+                      (error "%s: Invalid value, numberp, %S" var val))
+                (error
+                 (error "%s: Invalid value, numberp, %S" var val))))
+                  
+          (cond
+           ((member var '("sw" "shiftwidth"))
+            (setq var "vip-shift-width"))
+           ((member var '("ts" "tabstop"))
+            ;; make it take effect in curr buff and new bufs
+            (kill-local-variable 'tab-width)
+            (setq var "tab-width"
+                  set-cmd "setq-default"))
+           ((member var '("tsl" "tab-stop-local"))
+            (setq var "tab-width"
+                  set-cmd "setq"
+                  ask-if-save nil))
+           ((member var '("wm" "wrapmargin"))
+            ;; make it take effect in curr buff and new bufs
+            (kill-local-variable 'fill-column) 
+            (setq var "fill-column" 
+                  val (format "(- (window-width) %s)" val)
+                  set-cmd "setq-default"))
+           ((member var '("sh" "shell"))
+            (setq var "explicit-shell-file-name"
+                  val (format "\"%s\"" val)))))
+      (ex-fixup-history "set" orig-var))
+    
+    (setq actual-lisp-cmd (format "\n(%s %s %s) %s"
+                                  set-cmd var val auto-cmd-label))
+    (setq lisp-cmd-del-pattern
+          (format "^\n?[ \t]*([ \t]*%s[ \t]+%s[ \t].*)[ \t]*%s"
+                  set-cmd var auto-cmd-label))
+    
+    (if (and ask-if-save
+             (y-or-n-p (format "Do you want to save this setting in %s "
+                               vip-custom-file-name)))
+        (progn
+          (vip-save-string-in-file 
+           actual-lisp-cmd vip-custom-file-name
+           ;; del pattern
+           lisp-cmd-del-pattern)
+          (if (string= var "fill-column")
+              (if (> val2 0)
+                  (vip-save-string-in-file
+                   (concat
+                    "(add-hook 'vip-insert-state-hooks 'turn-on-auto-fill) "
+                    auto-cmd-label)
+                   vip-custom-file-name
+                   delete-turn-on-auto-fill-pattern)
+                (vip-save-string-in-file
+                 nil vip-custom-file-name delete-turn-on-auto-fill-pattern)
+                (vip-save-string-in-file
+                 nil vip-custom-file-name
+                 ;; del pattern
+                 lisp-cmd-del-pattern)
+                ))
+          ))
+    
+    (message (format "%s %s %s" set-cmd var (if (string-match "^[ \t]*$" val)
+                                                (format "%S" val)
+                                              val)))
+    (eval (car (read-from-string actual-lisp-cmd)))
+        (if (string= var "fill-column")
+                (if (> val2 0)
+                        (auto-fill-mode 1)
+                  (auto-fill-mode -1)))
+                
+    ))
+
+;; In inline args, skip regex-forw and (optionally) chars-back.
+;; Optional 3d arg is a string that should replace ' ' to prevent its
+;; special meaning
+(defun ex-get-inline-cmd-args (regex-forw &optional chars-back replace-str)
+  (save-excursion
+    (set-buffer vip-ex-work-buf)
+    (goto-char (point-min))
+    (re-search-forward regex-forw nil t)
+    (let ((beg (point))
+          end)
+      (goto-char (point-max))
+      (if chars-back
+          (skip-chars-backward chars-back)
+        (skip-chars-backward " \t\n\C-m"))
+      (setq end (point))
+      ;; replace SPC with `=' to suppress the special meaning SPC has
+      ;; in Ex commands
+      (goto-char beg)
+      (if replace-str
+          (while (re-search-forward " +" nil t)
+            (replace-match replace-str nil t)
+            (vip-forward-char-carefully)))
+      (goto-char end)
+      (buffer-substring beg end))))
+
+
+(defun ex-shell ()
+  "Ex shell command."
+  (shell))
+  
+(defun ex-help ()
+  "Viper help. Invokes Info."
+  (condition-case nil
+      (progn
+        (pop-to-buffer (get-buffer-create "*info*"))
+        (info vip-info-file-name)
+        (message "Type `i' to search for a specific topic"))
+    (error (beep 1)
+           (with-output-to-temp-buffer " *vip-info*"
+             (princ "The Info file for Viper does not seem to be installed.
+
+This file is part of the distribution of Viper. If you do not
+have the full distribution, please obtain it from the `anonymous'
+FTP account at `archive.cis.ohio-state.edu':
+
+            /pub/gnu/emacs/elisp-archive/modes/viper.shar
+            
+The Info files for Viper should be installed as <name>, <name>-1, etc.,
+where <name> is the value of `vip-info-file-name'.")))))
+
+(defun ex-source ()
+  "Ex source command. Loads the file specified as argument or `~/.vip'."
+  (vip-get-ex-file)
+  (if (string= ex-file "")
+      (load vip-custom-file-name)
+    (load ex-file)))
+
+(defun ex-substitute (&optional repeat r-flag) 
+  "Ex substitute command. 
+If REPEAT use previous regexp which is ex-reg-exp or vip-s-string"
+  (let ((opt-g nil)
+        (opt-c nil)
+        (matched-pos nil)
+        (case-fold-search vip-case-fold-search)
+        delim pat repl)
+    (if repeat (setq ex-token nil) (setq delim (vip-get-ex-pat)))
+    (if (null ex-token)
+        (setq pat (if r-flag vip-s-string ex-reg-exp)
+              repl ex-repl
+              delim (string-to-char pat))
+      (setq pat (if (string= ex-token "") vip-s-string ex-token))
+      (setq vip-s-string pat
+            ex-reg-exp pat)
+      (setq delim (vip-get-ex-pat))
+      (if (null ex-token)
+          (setq ex-token ""
+                ex-repl "")
+        (setq repl ex-token
+              ex-repl ex-token)))
+    (while (vip-get-ex-opt-gc delim)
+      (if (string= ex-token "g") (setq opt-g t) (setq opt-c t)))
+    (vip-get-ex-count)
+    (if ex-count
+        (save-excursion
+          (if ex-addresses (goto-char (car ex-addresses)))
+          (set-mark (point))
+          (forward-line (1- ex-count))
+          (setq ex-addresses (cons (point) (cons (mark t) nil))))
+      (if (null ex-addresses)
+          (setq ex-addresses (cons (point) (cons (point) nil)))
+        (if (null (cdr ex-addresses))
+            (setq ex-addresses (cons (car ex-addresses) ex-addresses)))))
+                                        ;(setq G opt-g)
+    (let ((beg (car ex-addresses))
+          (end (car (cdr ex-addresses)))
+          eol-mark)
+      (save-excursion
+        (vip-enlarge-region beg end)
+        (let ((limit (save-excursion
+                       (goto-char (max (point) (mark t)))
+                       (point-marker))))
+          (goto-char (min (point) (mark t)))
+          (while (< (point) limit)
+            (end-of-line)
+            (setq eol-mark (point-marker))
+            (beginning-of-line)
+            (if opt-g
+                (progn
+                  (while (and (not (eolp))
+                              (re-search-forward pat eol-mark t))
+                    (if (or (not opt-c) (y-or-n-p "Replace? "))
+                        (progn
+                          (setq matched-pos (point))
+                          (if (not (stringp repl))
+                              (error "Can't perform Ex substitution: No previous replacement pattern"))
+                          (replace-match repl t t))))
+                  (end-of-line)
+                  (vip-forward-char-carefully))
+              (if (null pat)
+                  (error
+                   "Can't repeat Ex substitution: No previous regular expression"))
+              (if (and (re-search-forward pat eol-mark t)
+                       (or (not opt-c) (y-or-n-p "Replace? ")))
+                  (progn
+                    (setq matched-pos (point))
+                    (if (not (stringp repl))
+                        (error "Can't perform Ex substitution: No previous replacement pattern"))
+                    (replace-match repl t t)))
+              (end-of-line)
+              (vip-forward-char-carefully))))))
+    (if matched-pos (goto-char matched-pos))
+    (beginning-of-line)
+    (if opt-c (message "done"))))
+
+(defun ex-tag ()
+  "Ex tag command."
+  (let (tag)
+    (save-window-excursion
+      (set-buffer vip-ex-work-buf)
+      (skip-chars-forward " \t")
+      (set-mark (point))
+      (skip-chars-forward "^ |\t\n")
+      (setq tag (buffer-substring (mark t) (point))))
+    (if (not (string= tag "")) (setq ex-tag tag))
+    (vip-change-state-to-emacs)
+    (condition-case conds
+        (progn
+          (if (string= tag "")
+              (find-tag ex-tag t)
+            (find-tag-other-window ex-tag))
+          (vip-change-state-to-vi))
+      (error
+       (vip-change-state-to-vi)
+       (vip-message-conditions conds)))))
+
+(defun ex-write (q-flag)
+  "Ex write command."
+  (vip-default-ex-addresses t)
+  (vip-get-ex-file)
+  (let ((end (car ex-addresses)) (beg (car (cdr ex-addresses))) 
+        temp-buf writing-same-file region
+        file-exists writing-whole-file)
+    (if (> beg end) (error vip-FirstAddrExceedsSecond))
+    (if ex-cmdfile
+        (progn
+          (vip-enlarge-region beg end)
+          (shell-command-on-region (point) (mark t) ex-file))
+      (if (and (string= ex-file "") (not (buffer-file-name)))
+          (setq ex-file
+                (read-file-name
+                 (format "Buffer %s isn't visiting any file. File to save in: "
+                         (buffer-name)))))
+      
+      (setq writing-whole-file (and (= (point-min) beg) (= (point-max) end))
+            ex-file (if (string= ex-file "")
+                        (buffer-file-name)
+                      (expand-file-name ex-file))
+            file-exists (file-exists-p ex-file)
+            writing-same-file (string= ex-file (buffer-file-name)))
+      (if (and writing-whole-file writing-same-file)
+          (if (not (buffer-modified-p))
+              (message "(No changes need to be saved)")
+            (save-buffer)
+            (ex-write-info file-exists ex-file beg end))
+        ;; writing some other file or portion of the currents
+        ;; file---create temp buffer for it
+        ;; disable undo in that buffer, for efficiency
+        (buffer-disable-undo (setq temp-buf (create-file-buffer ex-file)))
+        (unwind-protect 
+            (save-excursion
+              (if (and file-exists
+                       (not writing-same-file)
+                       (not (yes-or-no-p
+                             (format "File %s exists. Overwrite? " ex-file))))
+                  (error "Quit")
+                (vip-enlarge-region beg end)
+                (setq region (buffer-substring (point) (mark t)))
+                (set-buffer temp-buf)
+                (set-visited-file-name ex-file)
+                (erase-buffer)
+                (if (and file-exists ex-append)
+                    (insert-file-contents ex-file))
+                (goto-char (point-max))
+                (insert region)
+                (save-buffer)
+                (ex-write-info file-exists ex-file (point-min) (point-max))
+                )
+              (set-buffer temp-buf)
+              (set-buffer-modified-p nil)
+              (kill-buffer temp-buf)
+              )
+          ))
+      ;; this prevents the loss of data if writing part of the buffer
+      (if (and (buffer-file-name) writing-same-file)
+          (set-visited-file-modtime))
+      (or writing-whole-file 
+          (not writing-same-file)
+          (set-buffer-modified-p t))
+      (if q-flag
+          (if (< vip-expert-level 2)
+              (save-buffers-kill-emacs)
+            (kill-buffer (current-buffer))))
+      )))
+          
+
+(defun ex-write-info (exists file-name beg end)
+  (message "`%s'%s %d lines, %d characters"
+           (abbreviate-file-name file-name)
+           (if exists "" " [New file]")
+           (count-lines beg (min (1+ end) (point-max)))
+           (- end beg)))
+
+(defun ex-yank ()
+  "Ex yank command."
+  (vip-default-ex-addresses)
+  (vip-get-ex-buffer)
+  (let ((end (car ex-addresses)) (beg (car (cdr ex-addresses))))
+    (if (> beg end) (error vip-FirstAddrExceedsSecond))
+    (save-excursion
+      (vip-enlarge-region beg end)
+      (exchange-point-and-mark)
+      (if (or ex-g-flag ex-g-variant)
+          (error "Can't execute `yank' within `global'"))
+      (if ex-count
+          (progn
+            (set-mark (point))
+            (forward-line (1- ex-count)))
+        (set-mark end))
+      (vip-enlarge-region (point) (mark t))
+      (if ex-flag (error "`yank': %s" vip-SpuriousText))
+      (if ex-buffer
+          (cond ((vip-valid-register ex-buffer '(Letter))
+                 (vip-append-to-register
+                  (downcase ex-buffer) (point) (mark t)))
+                ((vip-valid-register ex-buffer)
+                 (copy-to-register ex-buffer (point) (mark t) nil))
+                (t (error vip-InvalidRegister ex-buffer))))
+      (copy-region-as-kill (point) (mark t)))))
+
+(defun ex-command ()
+  "Execute shell command."
+  (let (command)
+    (save-window-excursion
+      (set-buffer vip-ex-work-buf)
+      (skip-chars-forward " \t")
+      (setq command (buffer-substring (point) (point-max)))
+      (end-of-line))
+    (setq command (ex-expand-filsyms command (current-buffer)))
+    (if (and (> (length command) 0) (string= "!" (substring command 0 1)))
+        (if vip-ex-last-shell-com
+            (setq command (concat vip-ex-last-shell-com (substring command 1)))
+          (error "No previous shell command")))
+    (setq vip-ex-last-shell-com command)
+    (if (null ex-addresses)
+        (shell-command command)
+      (let ((end (car ex-addresses)) (beg (car (cdr ex-addresses))))
+        (if (null beg) (setq beg end))
+        (save-excursion
+          (goto-char beg)
+          (set-mark end)
+          (vip-enlarge-region (point) (mark t))
+          (shell-command-on-region (point) (mark t) command t))
+        (goto-char beg)))))
+
+(defun ex-line-no ()
+  "Print line number."
+  (message "%d"
+           (1+ (count-lines
+                (point-min)
+                (if (null ex-addresses) (point-max) (car ex-addresses))))))
+
+(defun vip-info-on-file ()
+  "Give information on the file visited by the current buffer."
+  (interactive)
+  (message "%s: pos=%d(%d) line=%d(%d) col=%d %s"
+           (if (buffer-file-name)
+               (abbreviate-file-name (buffer-file-name))
+             "[No visited file]")
+           (point) (1- (point-max))
+           (count-lines (point-min) (vip-line-pos 'end))
+           (count-lines (point-min) (point-max))
+           (1+ (current-column))
+           (if (buffer-modified-p) "[Modified]" "[Unchanged]")
+  ))
+
+
+(provide 'viper-ex)
+
+;;;  viper-ex.el ends here
diff --git a/lisp/emulation/viper-keym.el b/lisp/emulation/viper-keym.el
new file mode 100644
index 00000000000..eb23130c44a
--- /dev/null
+++ b/lisp/emulation/viper-keym.el
@@ -0,0 +1,525 @@
+;;; viper-keym.el -- Main Viper keymaps
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; 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
+;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+
+(require 'viper-util)
+
+;;; Variables
+
+;;; Keymaps
+
+;; Keymaps for vital things like \e and C-z.
+;; Not for users
+(defvar vip-vi-intercept-map (make-sparse-keymap))
+(defvar vip-insert-intercept-map (make-sparse-keymap))
+(defvar vip-emacs-intercept-map (make-sparse-keymap))
+  
+(vip-deflocalvar vip-vi-local-user-map (make-sparse-keymap)
+  "Keymap for user-defined local bindings.
+Useful for changing bindings such as ZZ in certain major modes.
+For instance, in letter-mode, one may want to bind ZZ to
+mh-send-letter. In a newsreader such as gnus, tin, or rn, ZZ could be bound
+to save-buffers-kill-emacs then post article, etc.")
+(put 'vip-vi-local-user-map 'permanent-local t) 
+
+(defvar vip-vi-global-user-map (make-sparse-keymap)
+  "Keymap for user-defined global bindings.
+These bindings are seen in all Viper buffers.")
+
+(defvar vip-vi-basic-map (make-keymap)
+  "This is the main keymap in effect in Viper's Vi state.
+This map is global, shared by all buffers.")
+
+(defvar  vip-vi-kbd-map (make-sparse-keymap)
+  "This keymap keeps keyboard macros defined via the :map command.")
+
+(defvar vip-vi-diehard-map (make-sparse-keymap)
+  "This keymap is in use when the user asks Viper to simulate Vi very closely.
+This happens when vip-expert-level is 1 or 2. See vip-set-expert-level.")
+  
+
+(vip-deflocalvar vip-insert-local-user-map (make-sparse-keymap)
+  "Auxiliary map for per-buffer user-defined keybindings in Insert state.")
+(put 'vip-insert-local-user-map 'permanent-local t)     
+
+(defvar vip-insert-global-user-map (make-sparse-keymap)
+  "Auxiliary map for global user-defined bindings in Insert state.")
+
+(defvar vip-insert-basic-map (make-sparse-keymap)
+  "The basic insert-mode keymap.")
+
+(defvar vip-insert-diehard-map (make-keymap)
+  "Map used when user wants vi-style keys in insert mode.
+Most of the Emacs keys are suppressed. This map overshadows
+vip-insert-basic-map. Not recommended, except for novice users.")
+
+(defvar  vip-insert-kbd-map  (make-sparse-keymap)
+  "This keymap keeps VI-style kbd macros for insert mode.")
+
+(defvar vip-replace-map (make-sparse-keymap)
+  "Map used in Viper's replace state.")
+  
+(defvar vip-emacs-global-user-map (make-sparse-keymap)
+  "Auxiliary map for global user-defined bindings in Emacs state.")
+
+(defvar  vip-emacs-kbd-map  (make-sparse-keymap)
+  "This keymap keeps Vi-style kbd macros for emacs mode.")
+  
+(vip-deflocalvar vip-emacs-local-user-map  (make-sparse-keymap)
+  "Auxiliary map for local user-defined bindings in Emacs state.")
+(put 'vip-emacs-local-user-map 'permanent-local t)  
+
+;; This keymap should stay empty
+(defvar vip-empty-keymap (make-sparse-keymap))
+
+
+;;; Variables used by minor modes
+
+;; Association list of the form 
+;; ((major-mode . keymap) (major-mode . keymap) ...)
+;; Viper uses these keymaps to make user-requested adjustments
+;; to its Vi state in various major modes.")
+(defvar vip-vi-state-modifier-alist nil)
+
+;; Association list of the form 
+;; ((major-mode . keymap) (major-mode . keymap) ...)
+;; Viper uses these keymaps to make user-requested adjustments
+;; to its Insert state in various major modes.")
+(defvar vip-insert-state-modifier-alist nil)
+
+;; Association list of the form 
+;; ((major-mode . keymap) (major-mode . keymap) ...)
+;; Viper uses these keymaps to make user-requested adjustments
+;; to its Emacs state in various major modes.
+(defvar vip-emacs-state-modifier-alist nil)
+
+;; Tells vip-add-local-keys to create a new vip-vi-local-user-map for new
+;; buffers. Not a user option.
+(vip-deflocalvar vip-need-new-vi-local-map t "")
+(put 'vip-need-new-vi-local-map  'permanent-local t)
+
+;; Tells vip-add-local-keys to create a new vip-insert-local-user-map for new
+;; buffers. Not a user option.
+(vip-deflocalvar vip-need-new-insert-local-map t "")
+(put 'vip-need-new-insert-local-map  'permanent-local t)
+
+;; Tells vip-add-local-keys to create a new vip-emacs-local-user-map for new
+;; buffers. Not a user option.
+(vip-deflocalvar vip-need-new-emacs-local-map t "")
+(put 'vip-need-new-emacs-local-map  'permanent-local t)
+
+
+
+;; Insert mode keymap
+
+;; for novice users, pretend you are the real vi.
+(define-key vip-insert-diehard-map "\t"   'vip-insert-tab)
+(define-key vip-insert-diehard-map "\C-a" 'self-insert-command)
+(define-key vip-insert-diehard-map "\C-b" 'self-insert-command)
+(define-key vip-insert-diehard-map "\C-c" 'vip-change-state-to-vi)
+(define-key vip-insert-diehard-map "\C-e" 'self-insert-command)
+(define-key vip-insert-diehard-map "\C-f" 'self-insert-command)
+(define-key vip-insert-diehard-map "\C-g" 'self-insert-command)
+(define-key vip-insert-diehard-map "\C-i" 'self-insert-command)
+(define-key vip-insert-diehard-map "\C-k" 'self-insert-command)
+(define-key vip-insert-diehard-map "\C-l" 'self-insert-command)
+(define-key vip-insert-diehard-map "\C-n" 'self-insert-command)
+(define-key vip-insert-diehard-map "\C-o" 'self-insert-command)
+(define-key vip-insert-diehard-map "\C-p" 'self-insert-command)
+(define-key vip-insert-diehard-map "\C-q" 'self-insert-command)
+(define-key vip-insert-diehard-map "\C-r" 'self-insert-command)
+(define-key vip-insert-diehard-map "\C-s" 'self-insert-command)
+(define-key vip-insert-diehard-map "\C-u" 'vip-erase-line)
+(define-key vip-insert-diehard-map "\C-x" 'self-insert-command)
+(define-key vip-insert-diehard-map "\C-y" 'self-insert-command)
+(define-key vip-insert-diehard-map "\C-z" 'self-insert-command)
+(define-key vip-insert-diehard-map "\C-]" 'self-insert-command)
+(define-key vip-insert-diehard-map "\C-_" 'self-insert-command)
+
+(let ((i ?\ ))
+  (while (<= i ?~)
+    (define-key vip-insert-diehard-map (make-string 1 i) 'self-insert-command)
+    (setq i (1+ i))))
+
+;; Insert mode map when user wants emacs style
+(define-key vip-insert-basic-map "\C-d" 'vip-backward-indent)
+(define-key vip-insert-basic-map "\C-w" 'vip-delete-backward-word)
+(define-key vip-insert-basic-map "\C-t" 'vip-forward-indent)
+(define-key vip-insert-basic-map 
+  (if vip-xemacs-p [(shift tab)] [S-tab]) 'vip-insert-tab)
+(define-key vip-insert-basic-map "\C-v" 'quoted-insert)
+(define-key vip-insert-basic-map "\C-?" 'vip-del-backward-char-in-insert)
+(define-key vip-insert-basic-map "\C-c\M-p"
+  'vip-insert-prev-from-insertion-ring)
+(define-key vip-insert-basic-map "\C-c\M-n"
+  'vip-insert-next-from-insertion-ring)
+
+
+;; Replace keymap
+(define-key vip-replace-map "\C-t" 'vip-forward-indent)
+(define-key vip-replace-map "\C-j" 'vip-replace-state-exit-cmd)
+(define-key vip-replace-map "\C-m" 'vip-replace-state-exit-cmd)
+(define-key vip-replace-map "\C-?" 'vip-del-backward-char-in-replace)
+
+
+
+;; Vi keymaps
+
+(define-key vip-vi-basic-map "\C-^" 
+  (function (lambda () (interactive) (vip-ex "e#"))))
+(define-key vip-vi-basic-map "\C-b" 'vip-scroll-back)
+(define-key vip-vi-basic-map "\C-d" 'vip-scroll-up)
+(define-key vip-vi-basic-map "\C-e" 'vip-scroll-up-one)
+(define-key vip-vi-basic-map "\C-f" 'vip-scroll)
+(define-key vip-vi-basic-map "\C-m" 'vip-next-line-at-bol)
+(define-key vip-vi-basic-map "\C-u" 'vip-scroll-down)
+(define-key vip-vi-basic-map "\C-y" 'vip-scroll-down-one)
+(define-key vip-vi-basic-map "\C-s" 'vip-isearch-forward)
+(define-key vip-vi-basic-map "\C-r" 'vip-isearch-backward)
+;(define-key vip-vi-basic-map "\C-\\" 'universal-argument)
+(define-key vip-vi-basic-map "\C-c/" 'vip-toggle-search-style)
+(define-key vip-vi-basic-map "\C-cg" 'vip-info-on-file)
+
+(define-key vip-vi-basic-map "\C-c\M-p" 'vip-prev-destructive-command)
+(define-key vip-vi-basic-map "\C-c\M-n" 'vip-next-destructive-command)
+
+
+(define-key vip-vi-basic-map " " 'vip-forward-char)
+(define-key vip-vi-basic-map "!" 'vip-command-argument)
+(define-key vip-vi-basic-map "\"" 'vip-command-argument)
+(define-key vip-vi-basic-map "#" 'vip-command-argument)
+(define-key vip-vi-basic-map "$" 'vip-goto-eol)
+(define-key vip-vi-basic-map "%" 'vip-paren-match)
+(define-key vip-vi-basic-map "&"
+  (function (lambda () (interactive) (vip-ex "&"))))
+(define-key vip-vi-basic-map "'" 'vip-goto-mark-and-skip-white)
+(define-key vip-vi-basic-map "(" 'vip-backward-sentence)
+(define-key vip-vi-basic-map ")" 'vip-forward-sentence)
+(define-key vip-vi-basic-map "*" 'call-last-kbd-macro)
+(define-key vip-vi-basic-map "+" 'vip-next-line-at-bol)
+(define-key vip-vi-basic-map "," 'vip-repeat-find-opposite)
+(define-key vip-vi-basic-map "-" 'vip-previous-line-at-bol)
+(define-key vip-vi-basic-map "." 'vip-repeat)
+(define-key vip-vi-basic-map "/" 'vip-search-forward)
+
+(define-key vip-vi-basic-map "0" 'vip-beginning-of-line)
+(define-key vip-vi-basic-map "1" 'vip-digit-argument)
+(define-key vip-vi-basic-map "2" 'vip-digit-argument)
+(define-key vip-vi-basic-map "3" 'vip-digit-argument)
+(define-key vip-vi-basic-map "4" 'vip-digit-argument)
+(define-key vip-vi-basic-map "5" 'vip-digit-argument)
+(define-key vip-vi-basic-map "6" 'vip-digit-argument)
+(define-key vip-vi-basic-map "7" 'vip-digit-argument)
+(define-key vip-vi-basic-map "8" 'vip-digit-argument)
+(define-key vip-vi-basic-map "9" 'vip-digit-argument)
+
+(define-key vip-vi-basic-map ":" 'vip-ex)
+(define-key vip-vi-basic-map ";" 'vip-repeat-find)
+(define-key vip-vi-basic-map "<" 'vip-command-argument)
+(define-key vip-vi-basic-map "=" 'vip-command-argument)
+(define-key vip-vi-basic-map ">" 'vip-command-argument)
+(define-key vip-vi-basic-map "?" 'vip-search-backward)
+(define-key vip-vi-basic-map "@" 'vip-register-macro)
+
+(define-key vip-vi-basic-map "A" 'vip-Append)
+(define-key vip-vi-basic-map "B" 'vip-backward-Word)
+(define-key vip-vi-basic-map "C" 'vip-change-to-eol)
+(define-key vip-vi-basic-map "D" 'vip-kill-line)
+(define-key vip-vi-basic-map "E" 'vip-end-of-Word)
+(define-key vip-vi-basic-map "F" 'vip-find-char-backward)
+(define-key vip-vi-basic-map "G" 'vip-goto-line)
+(define-key vip-vi-basic-map "H" 'vip-window-top)
+(define-key vip-vi-basic-map "I" 'vip-Insert)
+(define-key vip-vi-basic-map "J" 'vip-join-lines)
+(define-key vip-vi-basic-map "K" 'vip-nil)
+(define-key vip-vi-basic-map "L" 'vip-window-bottom)
+(define-key vip-vi-basic-map "M" 'vip-window-middle)
+(define-key vip-vi-basic-map "N" 'vip-search-Next)
+(define-key vip-vi-basic-map "O" 'vip-Open-line)
+(define-key vip-vi-basic-map "P" 'vip-Put-back)
+(define-key vip-vi-basic-map "Q" 'vip-query-replace)
+(define-key vip-vi-basic-map "R" 'vip-overwrite)
+(define-key vip-vi-basic-map "S" 'vip-substitute-line)
+(define-key vip-vi-basic-map "T" 'vip-goto-char-backward)
+(define-key vip-vi-basic-map "U" 'vip-undo)
+(define-key vip-vi-basic-map "V" 'find-file-other-window)
+(define-key vip-vi-basic-map "W" 'vip-forward-Word)
+(define-key vip-vi-basic-map "X" 'vip-delete-backward-char)
+(define-key vip-vi-basic-map "Y" 'vip-yank-line)
+(define-key vip-vi-basic-map "ZZ" 'vip-save-kill-buffer)
+
+(define-key vip-vi-basic-map "\\" 'vip-escape-to-emacs)
+(define-key vip-vi-basic-map "[" 'vip-brac-function)
+(define-key vip-vi-basic-map "]" 'vip-ket-function)
+(define-key vip-vi-basic-map "_" 'vip-alternate-ESC)
+(define-key vip-vi-basic-map "^" 'vip-bol-and-skip-white)
+(define-key vip-vi-basic-map "`" 'vip-goto-mark)
+
+(define-key vip-vi-basic-map "a" 'vip-append)
+(define-key vip-vi-basic-map "b" 'vip-backward-word)
+(define-key vip-vi-basic-map "c" 'vip-command-argument)
+(define-key vip-vi-basic-map "d" 'vip-command-argument)
+(define-key vip-vi-basic-map "e" 'vip-end-of-word)
+(define-key vip-vi-basic-map "f" 'vip-find-char-forward)
+(define-key vip-vi-basic-map "g" 'vip-nil)
+(define-key vip-vi-basic-map "h" 'vip-backward-char)
+(define-key vip-vi-basic-map "i" 'vip-insert)
+(define-key vip-vi-basic-map "j" 'vip-next-line)
+(define-key vip-vi-basic-map "k" 'vip-previous-line)
+(define-key vip-vi-basic-map "l" 'vip-forward-char)
+(define-key vip-vi-basic-map "m" 'vip-mark-point)
+(define-key vip-vi-basic-map "n" 'vip-search-next)
+(define-key vip-vi-basic-map "o" 'vip-open-line)
+(define-key vip-vi-basic-map "p" 'vip-put-back)
+(define-key vip-vi-basic-map "q" 'vip-nil)
+(define-key vip-vi-basic-map "r" 'vip-replace-char)
+(define-key vip-vi-basic-map "s" 'vip-substitute)
+(define-key vip-vi-basic-map "t" 'vip-goto-char-forward)
+(define-key vip-vi-basic-map "u" 'vip-undo)
+(define-key vip-vi-basic-map "v" 'find-file)
+(define-key vip-vi-basic-map "\C-v" 'vip-find-file-other-frame)
+(define-key vip-vi-basic-map "w" 'vip-forward-word)
+(define-key vip-vi-basic-map "x" 'vip-delete-char)
+(define-key vip-vi-basic-map "y" 'vip-command-argument)
+(define-key vip-vi-basic-map "zH" 'vip-line-to-top)
+(define-key vip-vi-basic-map "zM" 'vip-line-to-middle)
+(define-key vip-vi-basic-map "zL" 'vip-line-to-bottom)
+(define-key vip-vi-basic-map "z\C-m" 'vip-line-to-top)
+(define-key vip-vi-basic-map "z." 'vip-line-to-middle)
+(define-key vip-vi-basic-map "z-" 'vip-line-to-bottom)
+
+(define-key vip-vi-basic-map "{" 'vip-backward-paragraph)
+(define-key vip-vi-basic-map "|" 'vip-goto-col)
+(define-key vip-vi-basic-map "}" 'vip-forward-paragraph)
+(define-key vip-vi-basic-map "~" 'vip-toggle-case)
+(define-key vip-vi-basic-map "\C-?" 'vip-backward-char)
+  
+;;; Escape from Emacs to Vi for one command
+(global-set-key "\M-\C-z" 'vip-escape-to-vi)  ;; in emacs-state
+
+;;; This is vip-vi-diehard-map. Used when vip-vi-diehard-minor-mode is on.
+
+(define-key vip-vi-diehard-map "\C-a" 'vip-nil)
+(define-key vip-vi-diehard-map "\C-c" 'vip-nil)
+(define-key vip-vi-diehard-map "\C-g" 'vip-info-on-file)
+(define-key vip-vi-diehard-map "\C-i" 'vip-nil)
+(define-key vip-vi-diehard-map "\C-k" 'vip-nil)
+(define-key vip-vi-diehard-map "\C-l" 'redraw-display)
+(define-key vip-vi-diehard-map "\C-n" 'vip-next-line)
+(define-key vip-vi-diehard-map "\C-o" 'vip-nil)
+(define-key vip-vi-diehard-map "\C-p" 'vip-previous-line)
+(define-key vip-vi-diehard-map "\C-q" 'vip-nil)
+(define-key vip-vi-diehard-map "\C-r" 'redraw-display)
+(define-key vip-vi-diehard-map "\C-s" 'vip-nil)
+(define-key vip-vi-diehard-map "\C-t" 'vip-nil)
+(define-key vip-vi-diehard-map "\C-v" 'vip-nil)
+(define-key vip-vi-diehard-map "\C-w" 'vip-nil)
+(define-key vip-vi-diehard-map "@" 'vip-nil)
+(define-key vip-vi-diehard-map "*" 'vip-nil)
+(define-key vip-vi-diehard-map "#" 'vip-nil)
+(define-key vip-vi-diehard-map "\C-_" 'vip-nil)
+(define-key vip-vi-diehard-map "\C-]" 'vip-nil);; This is actually tags.
+
+
+;;; Minibuffer keymap
+  
+
+(defvar vip-minibuffer-map (make-sparse-keymap)
+  "Keymap used to modify keys when Minibuffer is in Insert state.")
+  
+(define-key vip-minibuffer-map "\C-m" 'vip-exit-minibuffer)
+(define-key vip-minibuffer-map "\C-j" 'vip-exit-minibuffer)
+
+;; Map used to read Ex-style commands.
+(defvar vip-ex-cmd-map (make-sparse-keymap))
+(define-key vip-ex-cmd-map " "  'ex-cmd-read-exit)
+(define-key vip-ex-cmd-map "\t" 'ex-cmd-complete)
+
+;; Keymap for reading file names in Ex-style commands.
+(defvar ex-read-filename-map (make-sparse-keymap))
+(define-key ex-read-filename-map " " 'vip-complete-filename-or-exit)
+
+
+          
+
+;;; Code
+
+(defun vip-add-local-keys (state alist)
+  "Override some vi-state or insert-state bindings in the current buffer.
+The effect is seen in the current buffer only.
+Useful for customizing  mailer buffers, gnus, etc.
+STATE is 'vi-state, 'insert-state, or 'emacs-state
+ALIST is of the form ((key . func) (key . func) ...)
+Normally, this would be called from a hook to a major mode or
+on a per buffer basis.
+Usage:
+      (vip-add-local-keys state '((key-str . func) (key-str . func)...))   "
+      
+  (let (map)
+    (cond ((eq state 'vi-state)
+           (if vip-need-new-vi-local-map
+               (setq vip-vi-local-user-map (make-sparse-keymap)))
+           (setq vip-need-new-vi-local-map nil
+                 map vip-vi-local-user-map))
+          ((eq state 'insert-state)
+           (if vip-need-new-insert-local-map
+               (setq vip-insert-local-user-map (make-sparse-keymap)))
+           (setq vip-need-new-insert-local-map nil
+                 map vip-insert-local-user-map))
+          ((eq state 'emacs-state)
+           (if vip-need-new-emacs-local-map
+               (setq vip-emacs-local-user-map (make-sparse-keymap)))
+           (setq vip-need-new-emacs-local-map nil
+                 map vip-emacs-local-user-map))
+          (t 
+           (error
+            "Invalid state in vip-add-local-keys: %S. Valid states: vi-state, insert-state or emacs-state" state)))
+
+    (vip-modify-keymap map alist)
+    (vip-normalize-minor-mode-map-alist)
+    (vip-set-mode-vars-for vip-current-state)))
+    
+
+(defun vip-modify-major-mode (mode state keymap)
+  "Modify key bindings in a major-mode in a Viper state using a keymap.
+
+If the default for a major mode is emacs-state, then modifications to this
+major mode may not take effect until the buffer switches state to Vi,
+Insert or Emacs. If this happens, add vip-change-state-to-emacs to this
+major mode's hook. If no such hook exists, you may have to put an advice on
+the function that invokes the major mode. See vip-set-hooks for hints.
+
+The above needs not to be done for major modes that come up in Vi or Insert
+state by default.
+
+Arguments: (major-mode vip-state keymap)"
+  (let ((alist
+         (cond ((eq state 'vi-state) 'vip-vi-state-modifier-alist)
+               ((eq state 'insert-state) 'vip-insert-state-modifier-alist)
+               ((eq state 'emacs-state) 'vip-emacs-state-modifier-alist)))
+        elt)
+    (if (setq elt (assoc mode (eval alist)))
+        (set alist (delq elt (eval alist))))
+    (set alist (cons (cons mode keymap) (eval alist)))
+    
+    ;; Normalization usually doesn't help here, since one needs to
+    ;; normalize in the actual buffer where changes to the keymap are
+    ;; to take place. However, it doesn't hurt, and it helps whenever this
+    ;; function is actually called from within the right buffer.
+    (vip-normalize-minor-mode-map-alist)
+    
+    (vip-set-mode-vars-for vip-current-state)))
+
+    
+(defun vip-debug-keymaps ()
+  "Displays variables that control Viper's keymaps."
+  (interactive)
+  (with-output-to-temp-buffer " *vip-debug*"
+    (princ (format "Buffer name:  %s\n\n" (buffer-name)))
+    (princ "Variables:  \n")
+    (princ (format "major-mode:  %S\n" major-mode))
+    (princ (format "vip-current-state:  %S\n" vip-current-state))
+    (princ (format "vip-mode-string:  %S\n\n" vip-mode-string))
+    (princ (format "vip-vi-intercept-minor-mode:  %S\n"
+                   vip-vi-intercept-minor-mode))
+    (princ (format "vip-insert-intercept-minor-mode:  %S\n"
+                   vip-insert-intercept-minor-mode))
+    (princ (format "vip-emacs-intercept-minor-mode:  %S\n"
+                   vip-emacs-intercept-minor-mode))
+    (princ (format "vip-vi-minibuffer-minor-mode:  %S\n"
+                   vip-vi-minibuffer-minor-mode))
+    (princ (format "vip-insert-minibuffer-minor-mode:  %S\n\n"
+                   vip-insert-minibuffer-minor-mode))
+    (princ (format "vip-vi-local-user-minor-mode:  %S\n"
+                   vip-vi-local-user-minor-mode))
+    (princ (format "vip-vi-global-user-minor-mode:  %S\n"
+                   vip-vi-global-user-minor-mode))
+    (princ (format "vip-vi-kbd-minor-mode:  %S\n" vip-vi-kbd-minor-mode))
+    (princ (format "vip-vi-state-modifier-minor-mode:  %S\n"
+                   vip-vi-state-modifier-minor-mode))
+    (princ (format "vip-vi-diehard-minor-mode:  %S\n"
+                   vip-vi-diehard-minor-mode))
+    (princ (format "vip-vi-basic-minor-mode:  %S\n" vip-vi-basic-minor-mode))
+    (princ (format "vip-replace-minor-mode:  %S\n" vip-replace-minor-mode))
+    (princ (format "vip-insert-local-user-minor-mode:  %S\n"
+                   vip-insert-local-user-minor-mode))
+    (princ (format "vip-insert-global-user-minor-mode:  %S\n"
+                   vip-insert-global-user-minor-mode))
+    (princ (format "vip-insert-kbd-minor-mode:  %S\n"
+                   vip-insert-kbd-minor-mode)) 
+    (princ (format "vip-insert-state-modifier-minor-mode:  %S\n"
+                   vip-insert-state-modifier-minor-mode))
+    (princ (format "vip-insert-diehard-minor-mode:  %S\n"
+                   vip-insert-diehard-minor-mode))
+    (princ (format "vip-insert-basic-minor-mode:  %S\n"
+                   vip-insert-basic-minor-mode))
+    (princ (format "vip-emacs-local-user-minor-mode:  %S\n"
+                   vip-emacs-local-user-minor-mode))
+    (princ (format "vip-emacs-kbd-minor-mode:  %S\n"
+                   vip-emacs-kbd-minor-mode))
+    (princ (format "vip-emacs-global-user-minor-mode:  %S\n"
+                   vip-emacs-global-user-minor-mode))
+    (princ (format "vip-emacs-state-modifier-minor-mode:  %S\n"
+                   vip-emacs-state-modifier-minor-mode))
+    
+    (princ (format "\nvip-expert-level  %S\n" vip-expert-level))
+    (princ (format "vip-no-multiple-ESC  %S\n" vip-no-multiple-ESC))
+    (princ (format "vip-always  %S\n" vip-always))
+    (princ (format "vip-ex-style-motion  %S\n"
+                   vip-ex-style-motion))
+    (princ (format "vip-ex-style-editing-in-insert  %S\n"
+                   vip-ex-style-editing-in-insert))
+    (princ (format "vip-want-emacs-keys-in-vi  %S\n"
+                   vip-want-emacs-keys-in-vi)) 
+    (princ (format "vip-want-emacs-keys-in-insert  %S\n"
+                   vip-want-emacs-keys-in-insert)) 
+    (princ (format "vip-want-ctl-h-help  %S\n" vip-want-ctl-h-help))
+    
+    (princ "\n\n\n")
+    (princ (format "Default value for minor-mode-map-alist:  \n%S\n\n"
+                   (default-value 'minor-mode-map-alist)))
+    (princ (format "Actual value for minor-mode-map-alist:  \n%S\n"
+                   minor-mode-map-alist))
+    ))
+   
+
+;;; Keymap utils
+             
+(defun vip-add-keymap (mapsrc mapdst) 
+  "Add contents of mapsrc to mapdst. It is assumed that mapsrc is sparse."
+  (if vip-xemacs-p
+      (map-keymap (function (lambda (key binding)
+                              (define-key mapdst key binding)))
+                  mapsrc)
+    (mapcar 
+     (function (lambda (p) 
+                 (define-key mapdst (vector (car p)) (cdr p))
+                 ))
+     (cdr mapsrc))))
+  
+(defun vip-modify-keymap (map alist)
+   "Modifies MAP with bindings specified in the ALIST. The alist has the
+form ((key . function) (key . function) ... )."
+   (mapcar (function (lambda (p)
+                       (define-key map (eval (car p)) (cdr p)))) 
+           alist))
+
+
+(provide 'viper-keym)
+
+;;;  viper-keym.el ends here
diff --git a/lisp/emulation/viper-macs.el b/lisp/emulation/viper-macs.el
new file mode 100644
index 00000000000..289cfd9d0a3
--- /dev/null
+++ b/lisp/emulation/viper-macs.el
@@ -0,0 +1,902 @@
+;;; viper-macs.el -- functions implementing keyboard macros for Viper
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; 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
+;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+
+(require 'viper-util)
+
+;;; Variables
+
+;; Register holding last macro.
+(defvar vip-last-macro-reg nil)
+
+;; format of the elements of kbd alists: 
+;; (name ((buf . macr)...(buf . macr)) ((maj-mode . macr)...) (t . macr))
+;; kbd macro alist for Vi state
+(defvar vip-vi-kbd-macro-alist nil)
+;; same for insert/replace state
+(defvar vip-insert-kbd-macro-alist nil)
+;; same for emacs state
+(defvar vip-emacs-kbd-macro-alist nil)
+
+;; Internal var that passes info between start-kbd-macro and end-kbd-macro
+;; in :map and :map!
+(defvar vip-kbd-macro-parameters nil)
+
+(defvar vip-this-kbd-macro nil
+  "Vector of keys representing the name of currently running Viper kbd macro.")
+(defvar vip-last-kbd-macro nil
+  "Vector of keys representing the name of last Viper keyboard macro.")
+
+(defconst vip-fast-keyseq-timeout 200
+  "*Key sequences separated by this many miliseconds are interpreted as a macro, if such a macro is defined.
+This also controls ESC-keysequences generated by keyboard function keys.")
+
+
+(defvar vip-repeat-from-history-key 'f1
+  "Prefix key for invocation of vip-repeat-from-history function,
+which repeats previous destructive commands from the history of such
+commands.
+This function can then be invoked as <this-key> 1 or <this-key> 2.
+The notation for these keys is borrowed from XEmacs. Basically,
+a key is a symbol, e.g., `a', `\\1', `f2', etc., or a list, e.g.,
+`(meta control f1)'.")
+
+
+
+;;; Code
+
+(defun ex-map ()
+  "Ex map command."
+  (let ((mod-char "")
+        macro-name macro-body map-args ins)
+    (save-window-excursion
+      (set-buffer vip-ex-work-buf)
+      (if (looking-at "!")
+          (progn
+            (setq ins t
+                  mod-char "!")
+            (forward-char 1))))
+    (setq map-args (ex-map-read-args mod-char)
+          macro-name (car map-args)
+          macro-body (cdr map-args))
+    (setq vip-kbd-macro-parameters (list ins mod-char macro-name macro-body))
+    (if macro-body
+        (vip-end-mapping-kbd-macro 'ignore)
+      (ex-fixup-history (format "map%s %S" mod-char
+                                (vip-display-macro macro-name)))
+      ;; if defining macro for insert, switch there for authentic WYSIWYG
+      (if ins (vip-change-state-to-insert))
+      (start-kbd-macro nil)
+      (define-key vip-vi-intercept-map "\C-x)" 'vip-end-mapping-kbd-macro)
+      (define-key vip-insert-intercept-map "\C-x)" 'vip-end-mapping-kbd-macro)
+      (define-key vip-emacs-intercept-map "\C-x)" 'vip-end-mapping-kbd-macro)
+      (message "Mapping %S in %s state. Hit `C-x )' to complete the mapping"
+               (vip-display-macro macro-name)
+               (if ins "Insert" "Vi")))
+    ))
+    
+
+(defun ex-unmap ()
+  "Ex unmap."
+  (let ((mod-char "")
+        temp macro-name ins)
+    (save-window-excursion
+      (set-buffer vip-ex-work-buf)
+      (if (looking-at "!")
+          (progn
+            (setq ins t
+                  mod-char "!")
+            (forward-char 1))))
+
+    (setq macro-name (ex-unmap-read-args mod-char))
+    (setq temp (vip-fixup-macro (vconcat macro-name))) ;; copy and fixup
+    (ex-fixup-history (format "unmap%s %S" mod-char
+                              (vip-display-macro temp)))
+    (vip-unrecord-kbd-macro macro-name (if ins 'insert-state 'vi-state))
+    ))
+    
+
+;; read arguments for ex-map
+(defun ex-map-read-args (variant)
+  (let ((cursor-in-echo-area t)
+        (key-seq [])
+        temp key event message
+        macro-name macro-body args)
+        
+    (condition-case nil
+        (setq args (concat (ex-get-inline-cmd-args ".*map[!]*[ \t]?" "\n\C-m")
+                           " nil nil ")
+              temp (read-from-string args)
+              macro-name (car temp)
+              macro-body (car (read-from-string args (cdr temp))))
+      (error
+       (signal
+        'error 
+        '("map: Macro name and body must be a quoted string or a vector"))))
+    
+    ;; We expect macro-name to be a vector, a string, or a quoted string.
+    ;; In the second case, it will emerge as a symbol when read from
+    ;; the above read-from-string. So we need to convert it into a string
+    (if macro-name
+        (cond ((vectorp macro-name) nil)
+              ((stringp macro-name) 
+               (setq macro-name (vconcat macro-name)))
+              (t (setq macro-name (vconcat (prin1-to-string macro-name)))))
+      (message ":map%s <Name>" variant)(sit-for 2)
+      (while
+          (not (member key
+                       '(?\C-m ?\n (control m) (control j) return linefeed)))
+        (setq key-seq (vconcat key-seq (if key (vector key) [])))
+        ;; the only keys available for editing are these-- no help while there
+        (if (member
+             key
+             '(?\b ?\d '^? '^H (control h) (control \?) backspace delete))
+            (setq key-seq (subseq key-seq 0 (- (length key-seq) 2))))
+        (setq message
+              (format ":map%s %s"
+                 variant (if (> (length key-seq) 0)
+                             (prin1-to-string (vip-display-macro key-seq))
+                           "")))
+        (message message)
+        (setq event (vip-read-event))
+        (setq key
+              (if (vip-mouse-event-p event)
+                  (progn
+                    (message "%s (No mouse---only keyboard keys, please)"
+                             message)
+                    (sit-for 2)
+                    nil)
+                (vip-event-key event)))
+        )
+      (setq macro-name key-seq))
+    
+    (if (= (length macro-name) 0)
+        (error "Can't map an empty macro name"))
+    (setq macro-name (vip-fixup-macro macro-name))
+    (if (vip-char-array-p macro-name)
+        (setq macro-name (vip-char-array-to-macro macro-name)))
+    
+    (if macro-body
+        (cond ((vip-char-array-p macro-body)
+               (setq macro-body (vip-char-array-to-macro macro-body)))
+              ((vectorp macro-body) nil)
+              (t (error "map: Invalid syntax in macro definition"))))
+    (cons macro-name macro-body)
+    ))
+    
+
+
+;; read arguments for ex-unmap
+(defun ex-unmap-read-args (variant)
+  (let ((cursor-in-echo-area t)
+        (macro-alist (if (string= variant "!")
+                         vip-insert-kbd-macro-alist
+                       vip-vi-kbd-macro-alist))
+        ;; these are disabled just in case, to avoid surprises when doing
+        ;; completing-read
+        vip-vi-kbd-minor-mode vip-insert-kbd-minor-mode
+        vip-emacs-kbd-minor-mode
+        vip-vi-intercept-minor-mode vip-insert-intercept-minor-mode
+        vip-emacs-intercept-minor-mode
+        event message
+        key key-seq macro-name)
+    (setq macro-name (ex-get-inline-cmd-args ".*unma?p?[!]*[ \t]*"))
+          
+    (if (> (length macro-name) 0)
+        ()
+      (message ":unmap%s <Name>" variant) (sit-for 2)
+      (while
+          (not
+           (member key '(?\C-m ?\n (control m) (control j) return linefeed)))
+        (setq key-seq (vconcat key-seq (if key (vector key) [])))
+        ;; the only keys available for editing are these-- no help while there
+        (cond ((member
+                key
+                '(?\b ?\d '^? '^H (control h) (control \?) backspace delete))
+               (setq key-seq (subseq key-seq 0 (- (length key-seq) 2))))
+              ((member key '(tab (control i) ?\t))
+               (setq key-seq (subseq key-seq 0 (1- (length key-seq))))
+               (setq message 
+                     (format ":unmap%s %s"
+                             variant (if (> (length key-seq) 0)
+                                         (prin1-to-string
+                                          (vip-display-macro key-seq))
+                                       "")))
+               (setq key-seq
+                     (vip-do-sequence-completion key-seq macro-alist message))
+               ))
+        (setq message 
+              (format ":unmap%s %s"
+                      variant (if (> (length key-seq) 0)
+                                  (prin1-to-string
+                                   (vip-display-macro key-seq))
+                                "")))
+        (message message)
+        (setq event (vip-read-event))
+        (setq key
+              (if (vip-mouse-event-p event)
+                  (progn
+                    (message "%s (No mouse---only keyboard keys, please)"
+                             message)
+                    (sit-for 2)
+                    nil)
+                (vip-event-key event)))
+        )
+      (setq macro-name key-seq))
+
+    (if (= (length macro-name) 0)
+        (error "Can't unmap an empty macro name"))
+                                  
+    ;; convert macro names into vector, if starts with a `['
+    (if (memq (elt macro-name 0) '(?\[ ?\"))
+        (car (read-from-string macro-name))
+      (vconcat macro-name))
+    ))
+    
+    
+    
+(defun vip-end-mapping-kbd-macro (&optional ignore)
+  "Terminate kbd macro."
+  (interactive)
+  (define-key vip-vi-intercept-map "\C-x)" nil)
+  (define-key vip-insert-intercept-map "\C-x)" nil)
+  (define-key vip-emacs-intercept-map "\C-x)" nil)
+  (if (and (not ignore)
+           (or (not vip-kbd-macro-parameters)
+               (not defining-kbd-macro)))
+      (error "Not mapping a kbd-macro"))
+  (let ((mod-char (nth 1 vip-kbd-macro-parameters))
+        (ins (nth 0 vip-kbd-macro-parameters))
+        (macro-name (nth 2 vip-kbd-macro-parameters))
+        (macro-body (nth 3 vip-kbd-macro-parameters)))
+    (setq vip-kbd-macro-parameters nil)
+    (or ignore
+        (progn
+          (end-kbd-macro nil)
+          (setq macro-body (vip-events-to-macro last-kbd-macro))
+          ;; always go back to Vi, since this is where we started
+          ;; defining macro
+          (vip-change-state-to-vi)))
+    
+    (vip-record-kbd-macro macro-name
+                          (if ins 'insert-state 'vi-state)
+                          (vip-display-macro macro-body))
+    
+    (ex-fixup-history (format "map%s %S %S" mod-char
+                              (vip-display-macro macro-name)
+                              (vip-display-macro macro-body)))
+    ))
+
+
+
+(defadvice start-kbd-macro (after vip-kbd-advice activate)
+  "Remove Viper's intercepting bindings for C-x ).
+This may be needed if the previous `:map' command terminated abnormally."
+  (define-key vip-vi-intercept-map "\C-x)" nil)
+  (define-key vip-insert-intercept-map "\C-x)" nil)
+  (define-key vip-emacs-intercept-map "\C-x)" nil))
+
+
+
+;;; Recording, unrecording, executing
+
+;; accepts as macro names: strings and vectors.
+;; strings must be strings of characters; vectors must be vectors of keys
+;; in canonic form. the canonic form is essentially the form used in XEmacs
+(defun vip-record-kbd-macro (macro-name state macro-body &optional scope)
+  "Record a Vi macro. Can be used in `.vip' file to define permanent macros.
+MACRO-NAME is a string of characters or a vector of keys. STATE is
+either `vi-state' or `insert-state'. It specifies the Viper state in which to
+define the macro. MACRO-BODY is a string that represents the keyboard macro.
+Optional SCOPE says whether the macro should be global \(t\), mode-specific
+\(a major-mode symbol\), or buffer-specific \(buffer name, a string\).
+If SCOPE is nil, the user is asked to specify the scope."
+  (let* (state-name keymap 
+         (macro-alist-var
+          (cond ((eq state 'vi-state)
+                 (setq state-name "Vi state"
+                       keymap vip-vi-kbd-map)
+                 'vip-vi-kbd-macro-alist)
+                ((memq state '(insert-state replace-state))
+                 (setq state-name "Insert state"
+                       keymap vip-insert-kbd-map)
+                 'vip-insert-kbd-macro-alist)
+                (t
+                 (setq state-name "Emacs state"
+                       keymap vip-emacs-kbd-map)
+                 'vip-emacs-kbd-macro-alist)
+                 ))
+         new-elt old-elt old-sub-elt msg
+         temp lis lis2)
+         
+    (if (= (length macro-name) 0)
+        (error "Can't map an empty macro name"))
+        
+    ;; Macro-name is usually a vector. However, command history or macros
+    ;; recorded in ~/.vip may be recorded as strings. So, convert to vectors.
+    (setq macro-name (vip-fixup-macro macro-name))
+    (if (vip-char-array-p macro-name)
+        (setq macro-name (vip-char-array-to-macro macro-name)))
+    (setq macro-body (vip-fixup-macro macro-body))
+    (if (vip-char-array-p macro-body)
+        (setq macro-body (vip-char-array-to-macro macro-body)))
+        
+    ;; don't ask if scope is given and is of the right type
+    (or (eq scope t)
+        (stringp scope)
+        (and scope (symbolp scope))
+        (progn
+          (setq scope
+                (cond
+                 ((y-or-n-p
+                   (format
+                    "Map this macro for buffer `%s' only? "
+                    (buffer-name)))
+                  (setq msg
+                        (format
+                         "%S is mapped to %s for %s in `%s'"
+                         (vip-display-macro macro-name)
+                         (vip-abbreviate-string
+                          (format
+                           "%S"
+                           (setq temp (vip-display-macro macro-body)))
+                          14 "" ""
+                          (if (stringp temp) "  ....\"" "  ....]"))
+                         state-name (buffer-name)))
+                  (buffer-name))
+                 ((y-or-n-p
+                   (format
+                    "Map this macro for the major mode `%S' only? "
+                    major-mode))
+                  (setq msg
+                        (format
+                         "%S is mapped to %s for %s in `%S'"
+                         (vip-display-macro macro-name)
+                         (vip-abbreviate-string
+                          (format
+                           "%S"
+                           (setq temp (vip-display-macro macro-body)))
+                          14 "" ""
+                          (if (stringp macro-body) "  ....\"" "  ....]"))
+                         state-name major-mode))
+                  major-mode)
+                 (t
+                  (setq msg
+                        (format
+                         "%S is globally mapped to %s in %s"
+                         (vip-display-macro macro-name)
+                         (vip-abbreviate-string
+                          (format
+                           "%S"
+                           (setq temp (vip-display-macro macro-body)))
+                          14 "" ""
+                          (if (stringp macro-body) "  ....\"" "  ....]"))
+                         state-name))
+                  t)))
+          (if (y-or-n-p (format "Save this macro in %s? "
+                                (abbreviate-file-name vip-custom-file-name)))
+              (vip-save-string-in-file 
+               (format "\n(vip-record-kbd-macro %S '%S %s '%S)"
+                       (vip-display-macro macro-name)
+                       state macro-body scope) 
+               vip-custom-file-name))
+          
+          (message msg)
+          ))
+        
+    (setq new-elt
+          (cons macro-name
+                (cond ((eq scope t) (list nil nil (cons t nil)))
+                      ((symbolp scope)
+                       (list nil (list (cons scope nil)) (cons t nil)))
+                      ((stringp scope)
+                       (list (list (cons scope nil)) nil (cons t nil))))))
+    (setq old-elt (assoc macro-name (eval macro-alist-var)))
+
+      (if (null old-elt)
+          (progn
+            ;; insert new-elt in macro-alist-var and keep the list sorted
+            (define-key
+              keymap
+              (vector (vip-key-to-emacs-key (aref macro-name 0)))
+              'vip-exec-mapped-kbd-macro)
+            (setq lis (eval macro-alist-var))
+            (while (and lis (string< (vip-array-to-string (car (car lis)))
+                                     (vip-array-to-string macro-name)))
+              (setq lis2 (cons (car lis) lis2))
+              (setq lis (cdr lis)))
+            
+            (setq lis2 (reverse lis2))
+            (set macro-alist-var (append lis2 (cons new-elt lis)))
+            (setq old-elt new-elt)))
+    (setq old-sub-elt
+          (cond ((eq scope t) (vip-kbd-global-pair old-elt))
+                ((symbolp scope) (assoc scope (vip-kbd-mode-alist old-elt)))
+                ((stringp scope) (assoc scope (vip-kbd-buf-alist old-elt)))))
+    (if old-sub-elt 
+        (setcdr old-sub-elt macro-body)
+      (cond ((symbolp scope) (setcar (cdr (cdr old-elt))
+                                     (cons (cons scope macro-body)
+                                           (vip-kbd-mode-alist old-elt))))
+            ((stringp scope) (setcar (cdr old-elt)
+                                     (cons (cons scope macro-body)
+                                           (vip-kbd-buf-alist old-elt))))))
+    ))
+  
+
+    
+;; macro name must be a vector of vip-style keys
+(defun vip-unrecord-kbd-macro (macro-name state)
+  (let* (state-name keymap 
+         (macro-alist-var
+          (cond ((eq state 'vi-state)
+                 (setq state-name "Vi state"
+                       keymap vip-vi-kbd-map)
+                 'vip-vi-kbd-macro-alist)
+                ((memq state '(insert-state replace-state))
+                 (setq state-name "Insert state"
+                       keymap vip-insert-kbd-map)
+                 'vip-insert-kbd-macro-alist)
+                (t
+                 (setq state-name "Emacs state"
+                       keymap vip-emacs-kbd-map)
+                 'vip-emacs-kbd-macro-alist)
+                ))
+         buf-mapping mode-mapping global-mapping
+         macro-pair macro-entry)
+                
+    ;; Macro-name is usually a vector. However, command history or macros
+    ;; recorded in ~/.vip may appear as strings. So, convert to vectors.
+    (setq macro-name (vip-fixup-macro macro-name))
+    (if (vip-char-array-p macro-name)
+        (setq macro-name (vip-char-array-to-macro macro-name)))
+
+    (setq macro-entry (assoc macro-name (eval macro-alist-var)))
+    (if (= (length macro-name) 0)
+        (error "Can't unmap an empty macro name"))
+    (if (null macro-entry)
+        (error "%S is not mapped to a macro for %s in `%s'"
+               (vip-display-macro macro-name)
+               state-name (buffer-name)))
+        
+    (setq buf-mapping (vip-kbd-buf-pair macro-entry)
+          mode-mapping (vip-kbd-mode-pair macro-entry)
+          global-mapping (vip-kbd-global-pair macro-entry))
+        
+    (cond ((and (cdr buf-mapping)
+                (or (and (not (cdr mode-mapping)) (not (cdr global-mapping)))
+                    (y-or-n-p
+                     (format "Unmap %S for `%s' only? "
+                             (vip-display-macro macro-name)
+                             (buffer-name)))))
+           (setq macro-pair buf-mapping)
+           (message "%S is unmapped for %s in `%s'" 
+                    (vip-display-macro macro-name)
+                    state-name (buffer-name)))
+          ((and (cdr mode-mapping)
+                (or (not (cdr global-mapping))
+                    (y-or-n-p
+                     (format "Unmap %S for the major mode `%S' only? "
+                             (vip-display-macro macro-name)
+                             major-mode))))
+           (setq macro-pair mode-mapping)
+           (message "%S is unmapped for %s in %S"
+                    (vip-display-macro macro-name) state-name major-mode))
+          ((cdr (setq macro-pair (vip-kbd-global-pair macro-entry)))
+           (message
+            "Global mapping of %S for %s is removed"
+            (vip-display-macro macro-name) state-name))
+          (t (error "%S is not mapped to a macro for %s in `%s'"
+                    (vip-display-macro macro-name)
+                    state-name (buffer-name))))
+    (setcdr macro-pair nil)
+    (or (cdr buf-mapping)
+        (cdr mode-mapping)
+        (cdr global-mapping)
+        (progn
+          (set macro-alist-var (delq macro-entry (eval macro-alist-var)))
+          (if (vip-can-release-key (aref macro-name 0) 
+                                   (eval macro-alist-var))
+              (define-key
+                keymap
+                (vector (vip-key-to-emacs-key (aref macro-name 0)))
+                nil))
+          ))
+    ))
+    
+;; Checks if MACRO-ALIST has an entry for a macro name starting with
+;; CHAR. If not, this indicates that the binding for this char
+;; in vip-vi/insert-kbd-map can be released.
+(defun vip-can-release-key (char macro-alist)
+  (let ((lis macro-alist)
+        (can-release t)
+        macro-name)
+    
+    (while (and lis can-release)
+      (setq macro-name (car (car lis)))
+      (if (eq char (aref macro-name 0))
+          (setq can-release nil))
+      (setq lis (cdr lis)))
+    can-release))
+
+
+(defun vip-exec-mapped-kbd-macro (count)
+  "Dispatch kbd macro."
+  (interactive "P")
+  (let* ((macro-alist (cond ((eq vip-current-state 'vi-state)
+                             vip-vi-kbd-macro-alist)
+                            ((memq vip-current-state
+                                   '(insert-state replace-state))
+                             vip-insert-kbd-macro-alist)
+                            (t
+                             vip-emacs-kbd-macro-alist)))
+        (unmatched-suffix "")
+        ;; Macros and keys are executed with other macros turned off
+        ;; For macros, this is done to avoid macro recursion
+        vip-vi-kbd-minor-mode vip-insert-kbd-minor-mode
+        vip-emacs-kbd-minor-mode
+        next-best-match keyseq event-seq
+        macro-first-char macro-alist-elt macro-body
+        command)
+    
+    (setq macro-first-char last-command-event
+          event-seq (vip-read-fast-keysequence macro-first-char macro-alist)
+          keyseq (vip-events-to-macro event-seq)
+          macro-alist-elt (assoc keyseq macro-alist)
+          next-best-match (vip-find-best-matching-macro macro-alist keyseq))
+          
+    (if (null macro-alist-elt)
+        (setq macro-alist-elt (car next-best-match)
+              unmatched-suffix (subseq event-seq (cdr next-best-match))))
+
+    (cond ((null macro-alist-elt))
+          ((setq macro-body (vip-kbd-buf-definition macro-alist-elt)))
+          ((setq macro-body (vip-kbd-mode-definition macro-alist-elt)))
+          ((setq macro-body (vip-kbd-global-definition macro-alist-elt))))
+                                 
+    ;; when defining keyboard macro, don't use the macro mappings
+    (if (and macro-body (not defining-kbd-macro))
+        ;; block cmd executed as part of a macro from entering command history
+        (let ((command-history command-history))
+          (setq vip-this-kbd-macro (car macro-alist-elt))
+          (execute-kbd-macro (vip-macro-to-events macro-body) count)
+          (setq vip-this-kbd-macro nil
+                vip-last-kbd-macro (car macro-alist-elt))
+          (vip-set-unread-command-events unmatched-suffix))
+      ;; If not a macro, or the macro is suppressed while defining another
+      ;; macro, put keyseq back on the event queue
+      (vip-set-unread-command-events event-seq)
+      ;; if the user typed arg, then use it if prefix arg is not set by
+      ;; some other command (setting prefix arg can happen if we do, say,
+      ;; 2dw and there is a macro starting with 2. Then control will go to
+      ;; this routine
+      (or prefix-arg (setq  prefix-arg count)) 
+      (setq command (key-binding (read-key-sequence nil)))
+      (if (commandp command)
+          (command-execute command)
+        (beep 1)))
+    ))
+
+
+
+;;; Displaying and completing macros
+    
+(defun vip-describe-kbd-macros ()
+  "Show currently defined keyboard macros."
+  (interactive)
+  (with-output-to-temp-buffer " *vip-info*"
+    (princ "Macros in Vi state:\n===================\n")
+    (mapcar 'vip-describe-one-macro vip-vi-kbd-macro-alist)
+    (princ "\n\nMacros in Insert and Replace states:\n====================================\n")
+    (mapcar 'vip-describe-one-macro vip-insert-kbd-macro-alist)
+    (princ "\n\nMacros in Emacs state:\n======================\n")
+    (mapcar 'vip-describe-one-macro vip-emacs-kbd-macro-alist)
+    ))
+    
+(defun vip-describe-one-macro (macro)
+  (princ (format "\n  *** Mappings for %S:\n      ------------\n"
+                 (vip-display-macro (car macro))))
+  (princ "   ** Buffer-specific:")
+  (if (vip-kbd-buf-alist macro)
+      (mapcar 'vip-describe-one-macro-elt (vip-kbd-buf-alist macro))
+    (princ "  none\n"))
+  (princ "\n   ** Mode-specific:")
+  (if (vip-kbd-mode-alist macro)
+      (mapcar 'vip-describe-one-macro-elt (vip-kbd-mode-alist macro))
+    (princ "  none\n"))
+  (princ "\n   ** Global:")
+  (if (vip-kbd-global-definition macro)
+      (princ 
+       (format "\n           %S" 
+               (cdr (vip-kbd-global-pair macro))))
+    (princ "  none"))
+  (princ "\n"))
+  
+(defun vip-describe-one-macro-elt (elt)
+  (let ((name (car elt))
+        (defn (cdr elt)))
+    (princ (format "\n       * %S:\n           %S\n" name defn))))
+    
+    
+    
+;; check if SEQ is a prefix of some car of an element in ALIST
+(defun vip-keyseq-is-a-possible-macro (seq alist)
+  (let ((converted-seq (vip-events-to-macro seq)))
+    (eval (cons 'or 
+                (mapcar
+                 (function (lambda (elt)
+                             (vip-prefix-subseq-p converted-seq elt)))
+                 (vip-this-buffer-macros alist))))))
+                 
+;; whether SEQ1 is a prefix of SEQ2
+(defun vip-prefix-subseq-p (seq1 seq2)
+  (let ((len1 (length seq1))
+        (len2 (length seq2)))
+    (if (<= len1 len2)
+        (equal seq1 (subseq seq2 0 len1)))))
+        
+;; find the longest common prefix
+(defun vip-common-seq-prefix (&rest seqs)
+  (let* ((first (car seqs))
+         (rest (cdr seqs))
+         (pref [])
+         (idx 0)
+         len)
+    (if (= (length seqs) 0)
+        (setq len 0)
+      (setq len (apply 'min (mapcar 'length seqs))))
+    (while (< idx len)
+      (if (eval (cons 'and 
+                      (mapcar (function (lambda (s)
+                                          (equal (elt first idx)
+                                                 (elt s idx))))
+                              rest)))
+          (setq pref (vconcat pref (vector (elt first idx)))))
+      (setq idx (1+ idx)))
+    pref))
+    
+;; get all sequences that match PREFIX from a given A-LIST
+(defun vip-extract-matching-alist-members (pref alist)
+  (delq nil (mapcar (function (lambda (elt)
+                                (if (vip-prefix-subseq-p pref elt)
+                                    elt)))
+                    (vip-this-buffer-macros alist))))
+                    
+(defun vip-do-sequence-completion (seq alist compl-message)
+  (let* ((matches (vip-extract-matching-alist-members seq alist))
+         (new-seq (apply 'vip-common-seq-prefix matches))
+         )
+    (cond ((and (equal seq new-seq) (= (length matches) 1))
+           (message "%s (Sole completion)" compl-message)
+           (sit-for 2))
+          ((null matches) 
+           (message "%s (No match)" compl-message)
+           (sit-for 2)
+           (setq new-seq seq))
+          ((member seq matches) 
+           (message "%s (Complete, but not unique)" compl-message)
+           (sit-for 2)
+           (vip-display-vector-completions matches))
+          ((equal seq new-seq)
+           (vip-display-vector-completions matches)))
+    new-seq))
+        
+         
+(defun vip-display-vector-completions (list)
+  (with-output-to-temp-buffer "*Completions*"
+    (display-completion-list 
+     (mapcar 'prin1-to-string
+             (mapcar 'vip-display-macro list)))))
+  
+                                  
+    
+;; alist is the alist of macros
+;; str is the fast key sequence entered
+;; returns: (matching-macro-def . unmatched-suffix-start-index)
+(defun vip-find-best-matching-macro (alist str)
+  (let ((lis alist)
+        (def-len 0)
+        (str-len (length str))
+        match unmatched-start-idx found macro-def)
+    (while (and (not found) lis)
+      (setq macro-def (car lis)
+            def-len (length (car macro-def)))
+      (if (and (>= str-len def-len)
+               (equal (car macro-def) (subseq str 0 def-len)))
+          (if (or (vip-kbd-buf-definition macro-def)
+                  (vip-kbd-mode-definition macro-def)
+                  (vip-kbd-global-definition macro-def))
+              (setq found t))
+        )
+      (setq lis (cdr lis)))
+    
+    (if found
+        (setq match macro-def
+              unmatched-start-idx def-len)
+      (setq match nil
+            unmatched-start-idx 0))
+    
+    (cons match unmatched-start-idx)))
+  
+    
+    
+;; returns a list of names of macros defined for the current buffer
+(defun vip-this-buffer-macros (macro-alist)
+  (let (candidates)
+    (setq candidates
+          (mapcar (function
+                   (lambda (elt)
+                     (if (or (vip-kbd-buf-definition elt)
+                             (vip-kbd-mode-definition elt)
+                             (vip-kbd-global-definition elt))
+                         (car elt))))
+                  macro-alist))
+    (setq candidates (delq nil candidates))))
+    
+  
+;; if seq of key symbols can be converted to a string--do so. Otherwise, do
+;; nothing.
+(defun vip-display-macro (macro-name)
+  (cond ((vip-char-symbol-sequence-p macro-name)
+         (mapconcat 'symbol-name macro-name ""))
+        ((vip-char-array-p macro-name)
+         (mapconcat 'char-to-string macro-name ""))
+        (t macro-name)))
+    
+(defun vip-events-to-macro (event-seq)
+  (vconcat (mapcar 'vip-event-key event-seq)))
+  
+;; convert strings of characters or arrays of characters to Viper macro form
+(defun vip-char-array-to-macro (array)
+  (let ((vec (vconcat array))
+        macro)
+    (if vip-xemacs-p
+        (setq macro (mapcar 'character-to-event vec))
+      (setq macro vec))
+    (vconcat (mapcar 'vip-event-key macro))))
+    
+;; For macros bodies and names, goes over and checks if all members are
+;; names of keys (actually, it only checks if they are symbols or lists
+;; if a digit is found, it is converted into a symbol (0 -> \0, etc).
+;; If not list or vector, doesn't change its argument
+(defun vip-fixup-macro (macro)
+  (let ((len (length macro))
+        (idx 0)
+        elt break)
+    (if (or (vectorp macro) (listp macro))
+        (while (and (< idx len) (not break))
+          (setq elt (elt macro idx))
+          (cond ((numberp elt)
+                 ;; fix number
+                 (if (and (<= 0 elt) (<= elt 9))
+                     (cond ((arrayp macro)
+                            (aset macro
+                                  idx
+                                  (intern (char-to-string (+ ?0 elt)))))
+                           ((listp macro)
+                            (setcar (nthcdr idx macro)
+                                    (intern (char-to-string (+ ?0 elt)))))
+                           )))
+                ;;(setq break t)))
+                ((listp elt)
+                 (vip-fixup-macro elt))
+                ((symbolp elt) nil)
+                (t (setq break t)))
+          (setq idx (1+ idx))))
+      
+      (if break
+          (error "Wrong type macro component, symbol-or-listp, %S" elt)
+        macro)))
+  
+(defun vip-char-array-p (array)
+  (eval (cons 'and (mapcar 'numberp array))))
+  
+(defun vip-macro-to-events (macro-body)
+  (vconcat (mapcar 'vip-key-to-emacs-key macro-body)))
+            
+                         
+;; check if vec is a vector of character symbols
+(defun vip-char-symbol-sequence-p (vec)
+  (and
+   (sequencep vec)
+   (eval
+    (cons 'and
+          (mapcar
+           (function (lambda (elt)
+                       (and (symbolp elt) (= (length (symbol-name elt)) 1))))
+           vec)))))
+               
+
+;; Check if vec is a vector of key-press events representing characters
+;; XEmacs only
+(defun vip-event-vector-p (vec)
+  (and (vectorp vec)
+       (eval (cons 'and (mapcar '(lambda (elt) (if (eventp elt) t)) vec)))))
+    
+
+;;; Reading fast key sequences
+    
+;; Assuming that CHAR was the first character in a fast succession of key
+;; strokes, read the rest. Return the vector of keys that was entered in
+;; this fast succession of key strokes.
+;; A fast keysequence is one that is terminated by a pause longer than
+;; vip-fast-keyseq-timeout.
+(defun vip-read-fast-keysequence (event macro-alist)
+  (let ((lis (vector event))
+        next-event)
+    (while (and (vip-fast-keysequence-p)
+                (vip-keyseq-is-a-possible-macro lis macro-alist))
+      (setq next-event (vip-read-event))
+      (or (vip-mouse-event-p next-event)
+          (setq lis (vconcat lis (vector next-event)))))
+    lis))
+
+
+;;; Keyboard macros in registers
+
+;; sets register to last-kbd-macro carefully.
+(defun vip-set-register-macro (reg)
+  (if (get-register reg)
+      (if (y-or-n-p "Register contains data. Overwrite? ")
+          ()
+        (error
+         "Macro not saved in register. Can still be invoked via `C-x e'")))
+  (set-register reg last-kbd-macro))
+
+(defun vip-register-macro (count)
+  "Keyboard macros in registers - a modified \@ command."
+  (interactive "P")
+  (let ((reg (downcase (read-char))))
+    (cond ((or (and (<= ?a reg) (<= reg ?z)))
+           (setq vip-last-macro-reg reg)
+           (if defining-kbd-macro
+               (progn
+                 (end-kbd-macro)
+                 (vip-set-register-macro reg))
+             (execute-kbd-macro (get-register reg) count)))
+          ((or (= ?@ reg) (= ?\^j reg) (= ?\^m reg))
+           (if vip-last-macro-reg 
+               nil
+               (error "No previous kbd macro"))
+           (execute-kbd-macro (get-register vip-last-macro-reg) count))
+          ((= ?\# reg)
+           (start-kbd-macro count))
+          ((= ?! reg)
+           (setq reg (downcase (read-char)))
+           (if (or (and (<= ?a reg) (<= reg ?z)))
+               (progn
+               (setq vip-last-macro-reg reg)
+               (vip-set-register-macro reg))))
+          (t
+           (error (format "`%c': Unknown register" reg))))))
+           
+
+(defun vip-global-execute ()
+  "Call last keyboad macro for each line in the region."
+  (if (> (point) (mark t)) (exchange-point-and-mark))
+  (beginning-of-line)
+  (call-last-kbd-macro)
+  (while (< (point) (mark t))
+    (forward-line 1)
+    (beginning-of-line)
+    (call-last-kbd-macro)))
+
+
+(provide 'viper-macs)
+
+;;;  viper-macs.el ends here
diff --git a/lisp/emulation/viper-mous.el b/lisp/emulation/viper-mous.el
new file mode 100644
index 00000000000..df2679d82a0
--- /dev/null
+++ b/lisp/emulation/viper-mous.el
@@ -0,0 +1,457 @@
+;;; viper-mous.el -- Mouse support for Viper
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; 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
+;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+
+(require 'viper-util)
+
+
+;;; Variables
+  
+;; Variable used for catching the switch-frame event.
+;; If non-nil, indicates that previous-frame should be the selected
+;; one. Used by vip-mouse-click-get-word. Not a user option.
+(defvar vip-frame-of-focus nil)
+    
+;; Frame that was selected before the switch-frame event.
+(defconst vip-pre-click-frame (vip-selected-frame))
+  
+(defvar vip-surrounding-word-function 'vip-surrounding-word
+  "*Function that determines what constitutes a word for clicking events.
+Takes two parameters: a COUNT, indicating how many words to return, 
+and CLICK-COUNT, telling whether this is the first click, a double-click,
+or a tripple-click.")
+       
+;; time interval in millisecond within which successive clicks are
+;; considered related
+(defconst vip-multiclick-timeout (if vip-xemacs-p
+                                   500
+                                 double-click-time)
+  "*Time interval in millisecond within which successive clicks are
+considered related.")
+
+;; current event click count; XEmacs only
+(defvar vip-current-click-count 0)
+;; time stamp of the last click event; XEmacs only
+(defvar vip-last-click-event-timestamp 0)
+
+;; Local variable used to toggle wraparound search on click.
+(vip-deflocalvar  vip-mouse-click-search-noerror t)
+        
+;; Local variable used to delimit search after wraparound.
+(vip-deflocalvar  vip-mouse-click-search-limit nil)
+        
+;; remembers prefix argument to pass along to commands invoked by second
+;; click.
+;; This is needed because in Emacs (not XEmacs), assigning to preix-arg
+;; causes Emacs to count the second click as if it was a single click
+(defvar vip-global-prefix-argument nil)
+
+
+
+;;; Code
+
+(defun vip-multiclick-p ()
+  (not (vip-sit-for-short vip-multiclick-timeout t)))
+             
+(defun vip-surrounding-word (count click-count)
+   "Returns word surrounding point according to a heuristic.
+COUNT indicates how many regions to return.
+If CLICK-COUNT is 1, `word' is a word in Vi sense. If it is > 1,
+then `word' is a Word in Vi sense.
+If the character clicked on is a non-separator and is non-alphanumeric but
+is adjacent to an alphanumeric symbol, then it is considered alphanumeric
+for the purpose of this command. If this character has a matching
+character, such as `\(' is a match for `\)', then the matching character is
+also considered alphanumeric.
+For convenience, in Lisp modes, `-' is considered alphanumeric."
+   (let* ((basic-alpha "_a-zA-Z0-9") ;; it is important for `_' to come first
+          (basic-alpha-B "[_a-zA-Z0-9]")
+          (basic-nonalphasep-B vip-NONALPHASEP-B)
+          (end-modifiers "")
+          (start-modifiers "")
+          vip-ALPHA vip-ALPHA-B
+          vip-NONALPHA vip-NONALPHA-B
+          vip-ALPHASEP vip-ALPHASEP-B
+          vip-NONALPHASEP vip-NONALPHASEP-B
+          skip-flag
+          one-char-word-func word-function-forw word-function-back word-beg)
+          
+     (if (and (looking-at basic-nonalphasep-B)
+              (or (save-excursion (vip-backward-char-carefully)
+                                  (looking-at basic-alpha-B))
+                  (save-excursion (vip-forward-char-carefully)
+                                  (looking-at basic-alpha-B))))
+         (setq start-modifiers
+               (cond ((looking-at "\\\\") "\\\\")
+                     ((looking-at "-") "")
+                     ((looking-at "[][]") "][")
+                     ((looking-at "[()]") ")(")
+                     ((looking-at "[{}]") "{}")
+                     ((looking-at "[<>]") "<>")
+                     ((looking-at "[`']") "`'")
+                     ((looking-at "\\^") "")
+                     ((looking-at vip-SEP-B) "")
+                     (t (char-to-string (following-char))))
+               end-modifiers
+               (cond ((looking-at "-") "C-C-") ;; note the C-C trick
+                     ((looking-at "\\^") "^")
+                     (t ""))))
+                     
+     ;; Add `-' to alphanum, if it wasn't added and in we are in Lisp
+     (or (looking-at "-")
+         (not (string-match "lisp" (symbol-name major-mode)))
+         (setq end-modifiers (concat end-modifiers "C-C-")))
+                 
+     (setq vip-ALPHA
+           (format "%s%s%s" start-modifiers basic-alpha end-modifiers)
+           vip-ALPHA-B
+           (format "[%s%s%s]" start-modifiers basic-alpha end-modifiers)
+           vip-NONALPHA (concat "^" vip-ALPHA)
+           vip-NONALPHA-B (concat "[" vip-NONALPHA "]")
+           vip-ALPHASEP (concat vip-ALPHA vip-SEP)
+           vip-ALPHASEP-B
+           (format "[%s%s%s%s]"
+                   start-modifiers basic-alpha vip-SEP end-modifiers)
+           vip-NONALPHASEP (format "^%s%s" vip-SEP vip-ALPHA)
+           vip-NONALPHASEP-B (format "[^%s%s]" vip-SEP vip-ALPHA)
+           )
+          
+     (if (> click-count 1)
+         (setq one-char-word-func 'vip-one-char-Word-p
+               word-function-forw 'vip-end-of-Word
+               word-function-back 'vip-backward-Word)
+       (setq one-char-word-func 'vip-one-char-word-p
+             word-function-forw 'vip-end-of-word
+             word-function-back 'vip-backward-word))
+     
+     (save-excursion
+       (cond ((> click-count 1) (skip-chars-backward vip-NONSEP))
+             ((looking-at vip-ALPHA-B) (skip-chars-backward vip-ALPHA))
+             ((looking-at vip-NONALPHASEP-B)
+              (skip-chars-backward vip-NONALPHASEP))
+             (t (funcall word-function-back 1)))
+     
+       (setq word-beg (point))
+       
+       (setq skip-flag t)
+       (while (> count 0)
+         ;; skip-flag and the test for 1-char word takes care of the
+         ;; special treatment that vip-end-of-word gives to 1-character
+         ;; words. Otherwise, clicking once on such a word will insert two
+         ;; words.
+         (if (and skip-flag (funcall one-char-word-func))
+             (setq skip-flag (not skip-flag))
+           (funcall word-function-forw 1))
+         (setq count (1- count)))
+         
+       (vip-forward-char-carefully)
+       (buffer-substring word-beg (point)))
+       ))
+
+
+(defun vip-mouse-click-get-word (click &optional count click-count)
+  "Returns word surrounding the position of a mouse click.
+Click may be in another window. Current window and buffer isn't changed."
+     
+  (let ((click-word "")
+        (click-pos (vip-mouse-click-posn click))
+        (click-buf (vip-mouse-click-window-buffer click)))
+    (or (numberp count) (setq count 1))
+    (or (numberp click-count) (setq click-count 1))
+     
+    (save-excursion
+      (save-window-excursion
+        (if click-pos
+            (progn
+              (set-buffer click-buf)
+        
+              (goto-char click-pos)
+              (setq click-word
+                    (funcall vip-surrounding-word-function count click-count)))
+          (error "Click must be over a window."))
+        click-word))))
+
+(defun vip-mouse-click-frame (click)
+  "Returns window where click occurs."
+  (vip-window-frame (vip-mouse-click-window click)))
+
+(defun vip-mouse-click-window (click)
+  "Returns window where click occurs."
+  (if vip-xemacs-p
+      (event-window click)
+    (posn-window (event-start click))))
+
+(defun vip-mouse-click-window-buffer (click)
+  "Returns the buffer of the window where click occurs."
+  (window-buffer (vip-mouse-click-window click)))
+
+(defun vip-mouse-click-window-buffer-name (click)
+  "Returns the name of the buffer in the window where click occurs."
+  (buffer-name (vip-mouse-click-window-buffer click)))
+
+(defun vip-mouse-click-posn (click)
+  "Returns position of a click."
+  (interactive "e")
+  (if vip-xemacs-p
+      (event-point click)
+    (posn-point (event-start click))))
+
+(defun vip-mouse-click-insert-word (click arg)
+  "Insert word clicked or double-clicked on.
+With prefix argument, N, insert that many words.
+This command must be bound to a mouse click.
+The double-click action of the same mouse button must not be bound
+\(or it must be bound to the same function\).
+See `vip-surrounding-word' for the definition of a word in this case."
+  (interactive "e\nP")
+  (if vip-frame-of-focus        ;; to handle clicks in another frame
+      (vip-select-frame vip-frame-of-focus))
+      
+  ;; turn arg into a number
+  (cond ((numberp arg) nil)
+        ;; prefix arg is a list when one hits C-u then command
+        ((and (listp arg) (numberp (car arg)))
+         (setq arg (car arg)))
+        (t (setq arg 1)))
+      
+  (let (click-count interrupting-event)
+    (if (and
+         (vip-multiclick-p)
+         ;; This trick checks if there is a pending mouse event
+         ;; if so, we use this latter event and discard the current mouse click
+         ;; If the next panding event is not a mouse event, we execute
+         ;; the current mouse event
+         (progn
+           (setq interrupting-event (vip-read-event))
+           (vip-mouse-event-p last-input-event)))
+        (progn ;; interrupted wait
+          (setq vip-global-prefix-argument arg)
+          ;; count this click for XEmacs
+          (vip-event-click-count click))
+      ;; uninterrupted wait or the interrupting event wasn't a mouse event
+      (setq click-count (vip-event-click-count click))
+      (if (> click-count 1)
+          (setq arg vip-global-prefix-argument
+                vip-global-prefix-argument nil))
+      (insert (vip-mouse-click-get-word click arg click-count))
+      (if (and interrupting-event
+               (eventp interrupting-event)
+               (not (vip-mouse-event-p interrupting-event)))
+          (vip-set-unread-command-events interrupting-event))
+      )))
+  
+;; arg is an event. accepts symbols and numbers, too
+(defun vip-mouse-event-p (event)
+  (if (eventp event)
+      (string-match "\\(mouse-\\|frame\\|screen\\|track\\)"
+                    (prin1-to-string (vip-event-key event)))))
+  
+;; XEmacs has no double-click events. So, we must simulate.
+;; So, we have to simulate event-click-count.
+(defun vip-event-click-count (click)
+  (if vip-xemacs-p
+      (progn
+        ;; if more than 1 second
+        (if (> (- (event-timestamp click) vip-last-click-event-timestamp)
+               vip-multiclick-timeout)
+            (setq vip-current-click-count 0))
+        (setq vip-last-click-event-timestamp (event-timestamp click)
+              vip-current-click-count (1+ vip-current-click-count)))
+    (event-click-count click)))
+    
+
+
+(defun vip-mouse-click-search-word (click arg)
+   "Find the word clicked or double-clicked on. Word may be in another window.
+With prefix argument, N, search for N-th occurrence.
+This command must be bound to a mouse click. The double-click action of the
+same button must not be bound \(or it must be bound to the same function\).
+See `vip-surrounding-word' for the details on what constitutes a word for
+this command."
+  (interactive "e\nP")
+  (if vip-frame-of-focus        ;; to handle clicks in another frame
+      (vip-select-frame vip-frame-of-focus))
+  (let (click-word click-count
+        (previous-search-string vip-s-string))
+    
+    (if (and
+         (vip-multiclick-p)
+         ;; This trick checks if there is a pending mouse event
+         ;; if so, we use this latter event and discard the current mouse click
+         ;; If the next panding event is not a mouse event, we execute
+         ;; the current mouse event
+         (progn
+           (vip-read-event)
+           (vip-mouse-event-p last-input-event)))
+        (progn ;; interrupted wait
+          (setq vip-global-prefix-argument arg)
+          ;; remember command that was before the multiclick
+          (setq this-command last-command)
+          ;; make sure we counted this event---needed for XEmacs only
+          (vip-event-click-count click))
+      ;; uninterrupted wait
+      (setq click-count (vip-event-click-count click))
+      (setq click-word (vip-mouse-click-get-word click nil click-count))
+    
+      (if (> click-count 1)
+          (setq arg vip-global-prefix-argument
+                vip-global-prefix-argument nil))
+      (setq arg (or arg 1))
+    
+      (vip-deactivate-mark)
+      (if (or (not (string= click-word vip-s-string))
+              (not (markerp vip-search-start-marker))
+              (not (equal (marker-buffer vip-search-start-marker)
+                          (current-buffer)))
+              (not (eq last-command 'vip-mouse-click-search-word)))
+          (progn
+            (setq  vip-search-start-marker (point-marker)
+                   vip-local-search-start-marker vip-search-start-marker
+                   vip-mouse-click-search-noerror t
+                   vip-mouse-click-search-limit nil)
+            
+            ;; make search string known to Viper
+            (setq vip-s-string (if vip-re-search
+                                   (regexp-quote click-word)
+                                 click-word))
+            (if (not (string= vip-s-string (car vip-search-history)))
+                (setq vip-search-history
+                      (cons vip-s-string vip-search-history)))
+            ))
+      
+      (push-mark nil t)
+      (while (> arg 0)
+        (vip-forward-word 1)
+        (condition-case nil
+            (progn
+              (if (not (search-forward click-word vip-mouse-click-search-limit
+                                       vip-mouse-click-search-noerror))
+                  (progn
+                    (setq vip-mouse-click-search-noerror nil)
+                    (setq vip-mouse-click-search-limit
+                          (save-excursion
+                            (if (and
+                                 (markerp vip-local-search-start-marker)
+                                 (marker-buffer vip-local-search-start-marker))
+                                (goto-char vip-local-search-start-marker))
+                            (vip-line-pos 'end)))
+                            
+                    (goto-char (point-min))
+                    (search-forward click-word
+                                    vip-mouse-click-search-limit nil)))
+              (goto-char (match-beginning 0))
+              (message "Searching for: %s" vip-s-string)
+              (if (<= arg 1)
+                  (vip-flash-search-pattern))
+              )
+          (error (beep 1)
+                 (if (or (not (string= click-word previous-search-string))
+                         (not (eq  last-command 'vip-mouse-click-search-word)))
+                     (message "`%s': String not found in %s"
+                              vip-s-string (buffer-name (current-buffer)))
+                   (message
+                    "`%s': Last occurrence in %s. Back to beginning of search"
+                    click-word (buffer-name (current-buffer)))
+                   (setq arg 1) ;; to terminate the loop
+                   (sit-for 2))
+                 (setq  vip-mouse-click-search-noerror t) 
+                 (setq  vip-mouse-click-search-limit nil)
+                 (if (and (markerp vip-local-search-start-marker)
+                          (marker-buffer vip-local-search-start-marker))
+                     (goto-char vip-local-search-start-marker))))
+        (setq arg (1- arg)))
+      )))
+  
+(defun vip-mouse-catch-frame-switch (event arg)
+  "Catch the event of switching frame.
+Usually is bound to a 'down-mouse' event to work properly. See sample
+bindings in viper.el and in the Viper manual."
+  (interactive "e\nP")
+  (setq vip-frame-of-focus nil)
+  ;; pass prefix arg along to vip-mouse-click-search/insert-word
+  (setq prefix-arg arg)
+  (if (eq last-command 'handle-switch-frame)
+      (setq vip-frame-of-focus vip-pre-click-frame))
+  ;; make Emacs forget that it executed vip-mouse-catch-frame-switch
+  (setq this-command last-command))
+      
+;; Called just before switching frames. Saves the old selected frame.
+;; Sets last-command to handle-switch-frame (this is done automatically in
+;; Emacs. 
+;; The semantics of switching frames is different in Emacs and XEmacs.
+;; In Emacs, if you select-frame A while mouse is over frame B and then
+;; start typing, input goes to frame B, which becomes selected.
+;; In XEmacs, input will go to frame A. This may be a bug in one of the
+;; Emacsen, but also may be a design decision.
+;; Also, in Emacs sending input to frame B generates handle-switch-frame
+;; event, while in XEmacs it doesn't.
+;; All this accounts for the difference in the behavior of
+;; vip-mouse-click-* commands when you click in a frame other than the one
+;; that was the last to receive input. In Emacs, focus will be in frame A
+;; until you do something other than vip-mouse-click-* command.
+;; In XEmacs, you have to manually select frame B (with the mouse click) in
+;; order to shift focus to frame B.
+(defun vip-save-pre-click-frame (frame)
+  (setq last-command 'handle-switch-frame)
+  (setq vip-pre-click-frame (vip-selected-frame)))
+
+
+(cond (window-system
+       (let* ((search-key (if vip-xemacs-p [(meta button1up)] [S-mouse-1]))
+              (search-key-catch (if vip-xemacs-p
+                                    [(meta button1)] [S-down-mouse-1]))
+              (insert-key (if vip-xemacs-p [(meta button2up)] [S-mouse-2]))
+              (insert-key-catch (if vip-xemacs-p
+                                    [(meta button2)] [S-down-mouse-2]))
+              (search-key-unbound (and (not (key-binding search-key))
+                                       (not (key-binding search-key-catch))))
+              (insert-key-unbound (and (not (key-binding insert-key))
+                                       (not (key-binding insert-key-catch))))
+              )
+             
+         (if search-key-unbound
+             (global-set-key search-key 'vip-mouse-click-search-word))
+         (if insert-key-unbound
+             (global-set-key insert-key 'vip-mouse-click-insert-word))
+    
+         ;; The following would be needed if you want to use the above two
+         ;; while clicking in another frame. If you only want to use them
+         ;; by clicking in another window, not frame, the bindings below
+         ;; aren't necessary.
+         
+         ;; These must be bound to mouse-down event for the same mouse
+         ;; buttons as 'vip-mouse-click-search-word and
+         ;; 'vip-mouse-click-insert-word
+         (if search-key-unbound
+             (global-set-key search-key-catch   'vip-mouse-catch-frame-switch))
+         (if insert-key-unbound
+             (global-set-key insert-key-catch   'vip-mouse-catch-frame-switch))
+         
+         (if vip-xemacs-p
+             (add-hook 'mouse-leave-screen-hook
+                       'vip-save-pre-click-frame)
+           (defadvice handle-switch-frame (before vip-frame-advice activate)
+             "Remember the selected frame before the switch-frame event." 
+             (vip-save-pre-click-frame (vip-selected-frame))))
+       )))
+
+
+
+(provide 'viper-mous)
+
+;;;  viper-mous.el ends here
diff --git a/lisp/emulation/viper-util.el b/lisp/emulation/viper-util.el
new file mode 100644
index 00000000000..8f9d3491aae
--- /dev/null
+++ b/lisp/emulation/viper-util.el
@@ -0,0 +1,798 @@
+;;; viper-util.el --- Utilities used by viper.el
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; 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
+;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+(require 'ring)
+
+(defconst vip-xemacs-p (string-match "\\(Lucid\\|Xemacs\\)" emacs-version)
+  "Whether it is XEmacs or not.")
+(defconst vip-emacs-p (not vip-xemacs-p)
+  "Whether it is Emacs or not.")
+
+
+;;; Macros
+
+(defmacro vip-deflocalvar (var default-value &optional documentation)
+  (` (progn
+       (defvar (, var) (, default-value)
+               (, (format "%s\n\(buffer local\)" documentation)))
+       (make-variable-buffer-local '(, var))
+     )))
+
+(defmacro vip-loop (count body)
+  "(vip-loop COUNT BODY) Execute BODY COUNT times."
+  (list 'let (list (list 'count count))
+        (list 'while '(> count 0)
+              body
+              '(setq count (1- count))
+              )))
+
+(defmacro vip-buffer-live-p (buf)
+  (` (and (, buf) (get-buffer (, buf)) (buffer-name (get-buffer (, buf))))))
+  
+;; return buffer-specific macro definition, given a full macro definition
+(defmacro vip-kbd-buf-alist (macro-elt)
+  (` (nth 1 (, macro-elt))))
+;; get a pair: (curr-buffer . macro-definition)
+(defmacro vip-kbd-buf-pair (macro-elt)
+  (` (assoc (buffer-name) (vip-kbd-buf-alist (, macro-elt)))))
+;; get macro definition for current buffer
+(defmacro vip-kbd-buf-definition (macro-elt)
+  (` (cdr (vip-kbd-buf-pair (, macro-elt)))))
+  
+;; return mode-specific macro definitions, given a full macro definition
+(defmacro vip-kbd-mode-alist (macro-elt)
+  (` (nth 2 (, macro-elt))))
+;; get a pair: (major-mode . macro-definition)
+(defmacro vip-kbd-mode-pair (macro-elt)
+  (` (assoc major-mode (vip-kbd-mode-alist (, macro-elt)))))
+;; get macro definition for the current major mode
+(defmacro vip-kbd-mode-definition (macro-elt)
+  (` (cdr (vip-kbd-mode-pair (, macro-elt)))))
+  
+;; return global macro definition, given a full macro definition
+(defmacro vip-kbd-global-pair (macro-elt)
+  (` (nth 3 (, macro-elt))))
+;; get global macro definition from an elt of macro-alist
+(defmacro vip-kbd-global-definition (macro-elt)
+  (` (cdr (vip-kbd-global-pair (, macro-elt)))))
+  
+;; last elt of a sequence
+(defsubst vip-seq-last-elt (seq)
+  (elt seq (1- (length seq))))
+  
+;; Check if arg is a valid character for register
+;; TYPE is a list that can contain `letter', `Letter', and `digit'.
+;; Letter means lowercase letters, Letter means uppercase letters, and
+;; digit means digits from 1 to 9.
+;; If TYPE is nil, then down/uppercase letters and digits are allowed.
+(defun vip-valid-register (reg &optional type)
+  (or type (setq type '(letter Letter digit)))
+  (or (if (memq 'letter type)
+          (and (<= ?a reg) (<= reg ?z)))
+      (if (memq 'digit type)
+          (and (<= ?1 reg) (<= reg ?9)))
+      (if (memq 'Letter type)
+          (and (<= ?A reg) (<= reg ?Z)))
+      ))
+      
+(defun vip-valid-marker (marker)
+  (if (markerp marker)
+      (let ((buf (marker-buffer marker))
+            (pos (marker-position marker)))
+        (save-excursion
+          (set-buffer buf)
+          (and (<= pos (point-max)) (<= (point-min) pos))))))
+  
+
+(defvar vip-minibuffer-overlay-priority 300)
+(defvar vip-replace-overlay-priority 400)
+(defvar vip-search-overlay-priority 500)
+  
+
+;;; XEmacs support
+
+(if vip-xemacs-p
+    (progn
+      (fset 'vip-read-event (symbol-function 'next-command-event))
+      (fset 'vip-make-overlay (symbol-function 'make-extent))
+      (fset 'vip-overlay-start (symbol-function 'extent-start-position))
+      (fset 'vip-overlay-end (symbol-function 'extent-end-position))
+      (fset 'vip-overlay-put (symbol-function 'set-extent-property))
+      (fset 'vip-overlay-p (symbol-function 'extentp))
+      (fset 'vip-overlay-get (symbol-function 'extent-property))
+      (fset 'vip-move-overlay (symbol-function 'set-extent-endpoints))
+      (if window-system
+          (fset 'vip-iconify (symbol-function 'iconify-screen)))
+      (fset 'vip-raise-frame (symbol-function 'raise-screen))
+      (fset 'vip-window-frame (symbol-function 'window-screen))
+      (fset 'vip-select-frame (symbol-function 'select-screen))
+      (fset 'vip-selected-frame (symbol-function 'selected-screen))
+      (fset 'vip-frame-selected-window
+            (symbol-function 'screen-selected-window))
+      (fset 'vip-frame-parameters (symbol-function 'screen-parameters))
+      (fset 'vip-modify-frame-parameters
+            (symbol-function 'modify-screen-parameters))
+      (cond (window-system
+             (fset 'vip-get-face (symbol-function 'get-face))
+             (fset 'vip-color-defined-p
+                   (symbol-function 'x-valid-color-name-p))
+             (fset 'vip-display-color-p
+                   (symbol-function 'x-color-display-p)))))
+  (fset 'vip-read-event (symbol-function 'read-event))
+  (fset 'vip-make-overlay (symbol-function 'make-overlay))
+  (fset 'vip-overlay-start (symbol-function 'overlay-start))
+  (fset 'vip-overlay-end (symbol-function 'overlay-end))
+  (fset 'vip-overlay-put (symbol-function 'overlay-put))
+  (fset 'vip-overlay-p (symbol-function 'overlayp))
+  (fset 'vip-overlay-get (symbol-function 'overlay-get))
+  (fset 'vip-move-overlay (symbol-function 'move-overlay))
+  (if window-system
+      (fset 'vip-iconify (symbol-function 'iconify-or-deiconify-frame)))
+  (fset 'vip-raise-frame (symbol-function 'raise-frame))
+  (fset 'vip-window-frame (symbol-function 'window-frame))
+  (fset 'vip-select-frame (symbol-function 'select-frame))
+  (fset 'vip-selected-frame (symbol-function 'selected-frame))
+  (fset 'vip-frame-selected-window (symbol-function 'frame-selected-window))
+  (fset 'vip-frame-parameters (symbol-function 'frame-parameters))
+  (fset 'vip-modify-frame-parameters
+        (symbol-function 'modify-frame-parameters))
+  (cond (window-system
+         (fset 'vip-get-face (symbol-function 'internal-get-face))
+         (fset 'vip-color-defined-p (symbol-function 'x-color-defined-p))
+         (fset 'vip-display-color-p (symbol-function 'x-display-color-p)))))
+  
+;; OS/2
+(cond ((eq window-system 'pm)
+       (fset 'vip-color-defined-p
+             (function (lambda (color) (assoc color pm-color-alist))))))
+    
+;; needed to smooth out the difference between Emacs and XEmacs
+(defsubst vip-italicize-face (face)
+  (if vip-xemacs-p
+      (make-face-italic face)
+    (make-face-italic face nil 'noerror)))
+    
+;; test if display is color and the colors are defined
+(defsubst vip-can-use-colors (&rest colors)
+  (if (vip-display-color-p)
+      (not (memq nil (mapcar 'vip-color-defined-p colors)))
+    ))
+
+;; currently doesn't work for XEmacs
+(defun vip-change-cursor-color (new-color)
+  (if (and window-system  (vip-display-color-p)
+           (stringp new-color) (vip-color-defined-p new-color))
+      (vip-modify-frame-parameters
+       (vip-selected-frame) (list (cons 'cursor-color new-color)))))
+         
+(defsubst vip-save-cursor-color ()
+  (if (and window-system (vip-display-color-p))
+      (let ((color (cdr (assoc 'cursor-color (vip-frame-parameters)))))
+        (if (and (stringp color) (vip-color-defined-p color)
+                 (not (string= color vip-replace-overlay-cursor-color)))
+            (vip-overlay-put vip-replace-overlay 'vip-cursor-color color)))))
+        
+(defsubst vip-restore-cursor-color ()
+  (vip-change-cursor-color
+   (vip-overlay-get vip-replace-overlay 'vip-cursor-color)))
+         
+
+;; Check the current version against the major and minor version numbers
+;; using op: cur-vers op major.minor If emacs-major-version or
+;; emacs-minor-version are not defined, we assume that the current version
+;; is hopelessly outdated.  We assume that emacs-major-version and
+;; emacs-minor-version are defined.  Otherwise, for Emacs/XEmacs 19, if the
+;; current minor version is < 10 (xemacs) or < 23 (emacs) the return value
+;; will be nil (when op is =, >, or >=) and t (when op is <, <=), which may be
+;; incorrect. However, this gives correct result in our cases, since we are
+;; testing for sufficiently high Emacs versions.
+(defun vip-check-version (op major minor &optional type-of-emacs)
+  (if (and (boundp 'emacs-major-version) (boundp 'emacs-minor-version))
+      (and (cond ((eq type-of-emacs 'xemacs) vip-xemacs-p)
+                 ((eq type-of-emacs 'emacs) vip-emacs-p)
+                 (t t))
+           (cond ((eq op '=) (and (= emacs-minor-version minor)
+                                  (= emacs-major-version major)))
+                 ((memq op '(> >= < <=))
+                  (and (or (funcall op emacs-major-version major)
+                           (= emacs-major-version major))
+                       (if (= emacs-major-version major)
+                           (funcall op emacs-minor-version minor)
+                         t)))
+                 (t
+                  (error "%S: Invalid op in vip-check-version" op))))
+    (cond ((memq op '(= > >=)) nil)
+          ((memq op '(< <=)) t))))
+  
+    
+;; Early versions of XEmacs didn't have window-live-p (or it didn't work right)
+(if (vip-check-version '< 19 11 'xemacs)
+    (defun window-live-p (win)
+      (let ((visible nil))
+        (walk-windows
+         '(lambda (walk-win)
+            (if(equal walk-win win)
+                (setq visible t)))
+         nil 'all-screens)
+        visible))
+  )
+
+
+(defun vip-get-visible-buffer-window (wind)
+  (if vip-xemacs-p
+      (get-buffer-window wind t)
+    (get-buffer-window wind 'visible)))
+    
+    
+(defun vip-line-pos (pos)
+  "Return line position.
+If pos is 'start then returns position of line start.
+If pos is 'end, returns line end. If pos is 'mid, returns line center.
+Pos = 'indent returns beginning of indentation.
+Otherwise, returns point. Current point is not moved in any case."
+  (let ((cur-pos (point))
+        (result))
+    (cond
+     ((equal pos 'start)
+      (beginning-of-line))
+     ((equal pos 'end)
+      (end-of-line))
+     ((equal pos 'mid)
+      (goto-char (+ (vip-line-pos 'start) (vip-line-pos 'end) 2)))
+     ((equal pos 'indent)
+      (back-to-indentation))
+     (t   nil))
+    (setq result (point))
+    (goto-char cur-pos)
+    result))
+
+
+(defun vip-move-marker-locally (var pos &optional buffer)
+  "Like move-marker but creates a virgin marker if arg isn't already a marker.
+The first argument must eval to a variable name.
+Arguments: (var-name position &optional buffer).
+
+This is useful for moving markers that are supposed to be local.
+For this, VAR-NAME should be made buffer-local with nil as a default.
+Then, each time this var is used in `vip-move-marker-locally' in a new
+buffer, a new marker will be created."
+  (if (markerp (eval var))
+      ()
+    (set var (make-marker)))
+  (move-marker (eval var) pos buffer))
+
+
+(defun vip-message-conditions (conditions)
+  "Print CONDITIONS as a message."
+  (let ((case (car conditions)) (msg (cdr conditions)))
+    (if (null msg)
+        (message "%s" case)
+      (message "%s: %s" case (mapconcat 'prin1-to-string msg " ")))
+    (beep 1)))
+
+
+;;; List/alist utilities
+        
+(defun vip-list-to-alist (lst)
+  "Convert LIST to an alist."
+  (let ((alist))
+    (while lst
+      (setq alist (cons (list (car lst)) alist))
+      (setq lst (cdr lst)))
+    alist))     
+
+(defun vip-alist-to-list (alst)
+  "Convert ALIST to a list."
+  (let ((lst))
+    (while alst
+      (setq lst (cons (car (car alst)) lst))
+      (setq alst (cdr alst)))
+    lst))
+
+(defun vip-filter-alist (regexp alst)
+  "Filter ALIST using REGEXP. Return alist whose elements match the regexp."
+  (interactive "s x")
+  (let ((outalst) (inalst alst))
+    (while (car inalst)
+      (if (string-match regexp (car (car inalst)))
+          (setq outalst (cons (car inalst) outalst)))
+      (setq inalst (cdr inalst)))
+    outalst))    
+       
+(defun vip-filter-list (regexp lst)
+  "Filter LIST using REGEXP. Return list whose elements match the regexp."
+  (interactive "s x")
+  (let ((outlst) (inlst lst))
+    (while (car inlst)
+      (if (string-match regexp (car inlst))
+          (setq outlst (cons (car inlst) outlst)))
+      (setq inlst (cdr inlst)))
+    outlst))    
+
+   
+;; Append LIS2 to LIS1, both alists, by side-effect and returns LIS1
+;; LIS2 is modified by filtering it: deleting its members of the form
+;; \(car elt\) such that (car elt') is in LIS1.
+(defun vip-append-filter-alist (lis1 lis2)
+  (let ((temp lis1)
+        elt)
+  
+    ;;filter-append the second list
+    (while temp
+      ;; delete all occurrences
+      (while (setq elt (assoc (car (car temp)) lis2))
+        (setq lis2 (delq elt lis2)))
+      (setq temp (cdr temp)))
+    
+    (nconc lis1 lis2)))
+      
+
+
+
+;;; Insertion ring
+
+;; Rotate RING's index. DIRection can be positive or negative.
+(defun vip-ring-rotate1 (ring dir)
+  (if (and (ring-p ring) (> (ring-length ring) 0))
+      (progn
+        (setcar ring (cond ((> dir 0)
+                            (ring-plus1 (car ring) (ring-length ring)))
+                           ((< dir 0)
+                            (ring-minus1 (car ring) (ring-length ring)))
+                           ;; don't rotate if dir = 0
+                           (t (car ring))))
+        (vip-current-ring-item ring)
+        )))
+        
+(defun vip-special-ring-rotate1 (ring dir)
+  (if (memq vip-intermediate-command
+            '(repeating-display-destructive-command
+              repeating-insertion-from-ring))
+      (vip-ring-rotate1 ring dir)
+    ;; don't rotate otherwise
+    (vip-ring-rotate1 ring 0)))
+    
+;; current ring item; if N is given, then so many items back from the
+;; current
+(defun vip-current-ring-item (ring &optional n)
+  (setq n (or n 0))
+  (if (and (ring-p ring) (> (ring-length ring) 0))
+      (aref (cdr (cdr ring)) (mod (- (car ring) 1 n) (ring-length ring)))))
+    
+;; push item onto ring. the second argument is a ring-variable, not value.
+(defun vip-push-onto-ring (item ring-var)
+  (or (ring-p (eval ring-var))
+      (set ring-var (make-ring (eval (intern (format "%S-size" ring-var))))))
+  (or (null item) ; don't push nil
+      (and (stringp item) (string= item "")) ; or empty strings
+      (equal item (vip-current-ring-item (eval ring-var))) ; or old stuff
+      ;; Since vip-set-destructive-command checks if we are inside vip-repeat,
+      ;;    we don't check whether this-command-keys is a `.'.
+      ;;    The cmd vip-repeat makes a call to the current function only if
+      ;;    `.' is executing a command from the command history. It doesn't
+      ;;    call the push-onto-ring function if `.' is simply repeating the
+      ;;    last destructive command.
+      ;; We only check for ESC (which happens when we do insert with a
+      ;;    prefix argument, or if this-command-keys doesn't give anything
+      ;;    meaningful (in that case we don't know what to show to the user).
+      (and (eq ring-var 'vip-command-ring)
+           (string-match "\\([0-9]*\e\\|^[ \t]*$\\|escape\\)"
+                         (vip-array-to-string (this-command-keys))))
+      (vip-ring-insert (eval ring-var) item))
+  )
+  
+
+;; removing elts from ring seems to break it
+(defun vip-cleanup-ring (ring)
+  (or (< (ring-length ring) 2)
+      (null (vip-current-ring-item ring))
+      ;; last and previous equal
+      (if (equal (vip-current-ring-item ring) (vip-current-ring-item ring 1))
+          (vip-ring-pop ring))))
+          
+;; ring-remove seems to be buggy, so we concocted this for our purposes.
+(defun vip-ring-pop (ring)
+  (let* ((ln (ring-length ring))
+         (vec (cdr (cdr ring)))
+         (veclen (length vec))
+         (hd (car ring))
+         (idx (max 0 (ring-minus1 hd ln)))
+         (top-elt (aref vec idx)))
+        
+        ;; shift elements
+        (while (< (1+ idx) veclen)
+          (aset vec idx (aref vec (1+ idx)))
+          (setq idx (1+ idx)))
+        (aset vec idx nil)
+        
+        (setq hd (max 0 (ring-minus1 hd ln)))
+        (if (= hd (1- ln)) (setq hd 0))
+        (setcar ring hd) ; move head
+        (setcar (cdr ring) (max 0 (1- ln))) ; adjust length
+        top-elt
+        ))
+        
+(defun vip-ring-insert (ring item)
+  (let* ((ln (ring-length ring))
+         (vec (cdr (cdr ring)))
+         (veclen (length vec))
+         (hd (car ring))
+         (vecpos-after-hd (if (= hd 0) ln hd))
+         (idx ln))
+         
+    (if (= ln veclen)
+        (progn
+          (aset vec hd item) ; hd is always 1+ the actual head index in vec
+          (setcar ring (ring-plus1 hd ln)))
+      (setcar (cdr ring) (1+ ln))
+      (setcar ring (ring-plus1 vecpos-after-hd (1+ ln)))
+      (while (and (>= idx vecpos-after-hd) (> ln 0))
+        (aset vec idx (aref vec (1- idx)))
+        (setq idx (1- idx)))
+      (aset vec vecpos-after-hd item))
+    item))
+        
+
+;;; String utilities
+
+;; If STRING is longer than MAX-LEN, truncate it and print ...... instead
+;; PRE-STRING is a string to prepend to the abbrev string.
+;; POST-STRING is a string to append to the abbrev string.
+;; ABBREV_SIGN is a string to be inserted before POST-STRING
+;; if the orig string was truncated. 
+(defun vip-abbreviate-string (string max-len
+                                     pre-string post-string abbrev-sign)
+  (let (truncated-str)
+    (setq truncated-str
+          (if (stringp string) 
+              (substring string 0 (min max-len (length string)))))
+    (cond ((null truncated-str) "")
+          ((> (length string) max-len)
+           (format "%s%s%s%s"
+                   pre-string truncated-str abbrev-sign post-string))
+          (t (format "%s%s%s" pre-string truncated-str post-string)))))
+          
+
+;;; Saving settings in custom file
+
+(defun vip-save-setting (var message custom-file &optional erase-msg)
+  "Save the current setting of VAR in CUSTOM-FILE.
+If given, MESSAGE is a message to be displayed after that.
+This message is erased after 2 secs, if erase-msg is non-nil.
+Arguments: (vip-save-setting var message custom-file &optional erase-message)"
+  (let* ((var-name (symbol-name var))
+         (var-val (if (boundp var) (eval var)))
+         (regexp (format "^[^;]*%s[ \t\n]*[a-zA-Z---_']*[ \t\n)]" var-name))
+         (buf (find-file-noselect (substitute-in-file-name custom-file)))
+        )
+    (message message)
+    (save-excursion
+      (set-buffer buf)
+      (goto-char (point-min))
+      (if (re-search-forward regexp nil t)
+          (let ((reg-end (1- (match-end 0))))
+            (search-backward var-name)
+            (delete-region (match-beginning 0) reg-end)
+            (goto-char (match-beginning 0))
+            (insert (format "%s  '%S" var-name var-val)))
+        (goto-char (point-max))
+        (if (not (bolp)) (insert "\n"))
+        (insert (format "(setq %s '%S)\n" var-name var-val)))
+      (save-buffer))
+      (kill-buffer buf)
+      (if erase-msg
+          (progn
+            (sit-for 2)
+            (message "")))
+      ))
+      
+;; Save STRING in CUSTOM-FILE. If PATTERN is non-nil, remove strings that
+;; match this pattern.
+(defun vip-save-string-in-file (string custom-file &optional pattern)
+  (let ((buf (find-file-noselect (substitute-in-file-name custom-file))))
+    (save-excursion
+      (set-buffer buf)
+      (goto-char (point-min))
+      (if pattern (delete-matching-lines pattern))
+      (goto-char (point-max))
+      (if string (insert string))
+      (save-buffer))
+    (kill-buffer buf)
+    ))
+    
+
+;;; Overlays
+
+;; Search
+
+(defun vip-flash-search-pattern ()
+  (if (vip-overlay-p vip-search-overlay)
+      (vip-move-overlay vip-search-overlay (match-beginning 0) (match-end 0))
+    (setq vip-search-overlay
+          (vip-make-overlay
+           (match-beginning 0) (match-end 0) (current-buffer))))
+  
+  (vip-overlay-put vip-search-overlay 'priority vip-search-overlay-priority)
+  (if window-system
+      (progn
+        (vip-overlay-put vip-search-overlay 'face vip-search-face)
+        (sit-for 2)
+        (vip-overlay-put vip-search-overlay 'face nil))))
+
+;; Replace state
+
+(defun vip-set-replace-overlay (beg end)
+  (if (vip-overlay-p vip-replace-overlay)
+      (vip-move-replace-overlay beg end)
+    (setq vip-replace-overlay (vip-make-overlay beg end (current-buffer)))
+    (vip-overlay-put vip-replace-overlay
+                     'vip-start 
+                     (move-marker (make-marker)
+                                  (vip-overlay-start vip-replace-overlay)))
+    (vip-overlay-put vip-replace-overlay
+                     'vip-end 
+                     (move-marker (make-marker)
+                                  (vip-overlay-end vip-replace-overlay)))
+    (vip-overlay-put 
+     vip-replace-overlay 'priority vip-replace-overlay-priority)) 
+  (if window-system
+      (vip-overlay-put vip-replace-overlay 'face vip-replace-overlay-face))
+  (vip-save-cursor-color)
+  (vip-change-cursor-color vip-replace-overlay-cursor-color)
+  )
+  
+  
+(defsubst vip-hide-replace-overlay ()
+  (vip-restore-cursor-color)
+  (if window-system
+      (vip-overlay-put vip-replace-overlay 'face nil)))
+
+
+    
+(defsubst vip-replace-start ()
+  (vip-overlay-get vip-replace-overlay 'vip-start))
+(defsubst vip-replace-end ()
+  (vip-overlay-get vip-replace-overlay 'vip-end))
+  
+(defsubst vip-move-replace-overlay (beg end)
+  (vip-move-overlay vip-replace-overlay beg end)
+  (move-marker (vip-replace-start) (vip-overlay-start vip-replace-overlay))
+  (move-marker (vip-replace-end) (vip-overlay-end vip-replace-overlay)))
+ 
+
+;; Minibuffer
+
+(defun vip-set-minibuffer-overlay ()
+  (vip-check-minibuffer-overlay)
+  ;; We always move the minibuffer overlay, since in XEmacs
+  ;; this overlay may get detached. Moving will reattach it.
+  ;; This overlay is also moved via the post-command-hook,
+  ;; to insure taht it covers the whole minibuffer.
+  (vip-move-minibuffer-overlay)
+  (if window-system
+      (progn
+        (vip-overlay-put
+         vip-minibuffer-overlay 'face vip-minibuffer-current-face)
+        (vip-overlay-put 
+         vip-minibuffer-overlay 'priority vip-minibuffer-overlay-priority))
+         ))
+       
+(defun vip-check-minibuffer-overlay ()
+  (if (vip-overlay-p vip-minibuffer-overlay)
+      ()
+    (setq vip-minibuffer-overlay
+          (vip-make-overlay 1 (1+ (buffer-size)) (current-buffer)))))
+
+;; arguments to this function are dummies. they are needed just because
+;; it is used as a insert-in-front-hook to vip-minibuffer-overlay, and such
+;; hooks require 3 arguments.
+(defun vip-move-minibuffer-overlay (&optional overl beg end)
+  (if (vip-is-in-minibuffer)
+      (progn
+        (vip-check-minibuffer-overlay)
+        (vip-move-overlay vip-minibuffer-overlay 1 (1+ (buffer-size))))))
+
+(defsubst vip-is-in-minibuffer ()
+  (string-match "\*Minibuf-" (buffer-name)))
+  
+
+
+;;; XEmacs compatibility
+    
+;; Sit for VAL miliseconds. XEmacs doesn't support the milisecond arg to
+;; sit-for, so this is for compatibility.
+(defsubst vip-sit-for-short (val &optional nodisp)
+  (if vip-xemacs-p
+      (sit-for (/ val 1000.0) nodisp)
+    (sit-for 0 val nodisp)))
+
+;; EVENT may be a single event of a sequence of events
+(defsubst vip-ESC-event-p (event)
+  (let ((ESC-keys '(?\e (control \[) escape))
+        (key (vip-event-key event)))
+    (member key ESC-keys)))
+        
+;; like (set-mark-command nil) but doesn't push twice, if (car mark-ring)
+;; is the same as (mark t).
+(defsubst vip-set-mark-if-necessary ()
+  (setq mark-ring (delete (vip-mark-marker) mark-ring))
+  (set-mark-command nil))
+  
+(defsubst vip-mark-marker ()
+  (if vip-xemacs-p
+      (mark-marker t)
+    (mark-marker)))
+       
+;; In transient mark mode (zmacs mode), it is annoying when regions become
+;; highlighted due to Viper's pushing marks. So, we deactivate marks, unless
+;; the user explicitly wants highlighting, e.g., by hitting '' or ``
+(defun vip-deactivate-mark ()
+  (if vip-xemacs-p
+      (zmacs-deactivate-region)
+    (deactivate-mark)))
+
+    
+(defsubst vip-events-to-keys (events)
+  (cond (vip-xemacs-p (events-to-keys events))
+        (t events)))
+                  
+        
+(defun vip-eval-after-load (file form)
+  (if vip-emacs-p
+      (eval-after-load file form)
+    (or (assoc file after-load-alist)
+        (setq after-load-alist (cons (list file) after-load-alist)))
+    (let ((elt (assoc file after-load-alist)))
+      (or (member form (cdr elt))
+          (setq elt (nconc elt (list form)))))
+    form
+    ))
+    
+    
+;; like read-event, but in XEmacs also try to convert to char, if possible
+(defun vip-read-event-convert-to-char ()
+  (let (event)
+    (if vip-emacs-p
+        (read-event)
+      (setq event (next-command-event))
+      (or (event-to-character event)
+          event))
+    ))
+
+
+;; Enacs has a bug in eventp, which causes (eventp nil) to return (nil)
+;; instead of nil, if '(nil) was previously inadvertantly assigned to
+;; unread-command-events
+(defun vip-event-key (event)
+  (or (and event (eventp event))
+      (error "vip-event-key: Wrong type argument, eventp, %S" event))
+  (let ((mod (event-modifiers event))
+        basis)
+    (setq basis
+          (cond
+           (vip-xemacs-p
+            (cond ((key-press-event-p event)
+                   (event-key event))
+                  ((button-event-p event)
+                   (concat "mouse-" (event-button event)))
+                  (t 
+                   (error "vip-event-key: Unknown event, %S" event))))
+           (t 
+            ;; Emacs doesn't handle capital letters correctly, since
+            ;; \S-a isn't considered the same as A (it behaves as
+            ;; plain `a' instead). So we take care of this here
+            (if (and (numberp event) (<= ?A event) (<= event ?Z))
+                (setq mod nil
+                      event event)
+              (event-basic-type event)))))
+    
+    (if (numberp basis)
+        (setq basis
+              (if (= basis ?\C-?)
+                  (list 'control '\?) ; taking care of an emacs bug
+                (intern (char-to-string basis)))))
+    
+    (if mod
+        (append mod (list basis))
+      basis)
+    ))
+    
+(defun vip-key-to-emacs-key (key)
+  (let (key-name char-p modifiers mod-char-list base-key base-key-name)
+    (cond (vip-xemacs-p key)
+          ((symbolp key)
+           (setq key-name (symbol-name key))
+           (if (= (length key-name) 1) ; character event
+               (string-to-char key-name)
+             key))
+          ((listp key)
+           (setq modifiers (subseq key 0 (1- (length key)))
+                 base-key (vip-seq-last-elt key)
+                 base-key-name (symbol-name base-key)
+                 char-p (= (length base-key-name) 1))
+           (setq mod-char-list
+                 (mapcar
+                  '(lambda (elt) (upcase (substring (symbol-name elt) 0 1)))
+                  modifiers))
+           (if char-p
+               (setq key-name
+                     (car (read-from-string
+                           (concat
+                            "?\\"
+                            (mapconcat 'identity mod-char-list "-\\")
+                            "-"
+                            base-key-name))))
+             (setq key-name
+                   (intern
+                    (concat
+                     (mapconcat 'identity mod-char-list "-")
+                     "-"
+                     base-key-name))))))
+    ))
+
+
+;; Args can be a sequence of events, a string, or a Viper macro.  Will try to
+;; convert events to keys and, if all keys are regular printable
+;; characters, will return a string. Otherwise, will return a string
+;; representing a vector of converted events. If the input was a Viper macro,
+;; will return a string that represents this macro as a vector.
+(defun vip-array-to-string (event-seq &optional representation)
+  (let (temp)
+    (cond ((stringp event-seq) event-seq)
+          ((vip-event-vector-p event-seq)
+            (setq temp (mapcar 'vip-event-key event-seq))
+            (if (vip-char-symbol-sequence-p temp)
+                (mapconcat 'symbol-name temp "")
+              (prin1-to-string (vconcat temp))))
+          ((vip-char-symbol-sequence-p event-seq)
+           (mapconcat 'symbol-name event-seq ""))
+          (t (prin1-to-string event-seq)))))
+           
+    
+(defsubst vip-fast-keysequence-p ()
+  (not (vip-sit-for-short vip-fast-keyseq-timeout t)))
+    
+(defun vip-read-char-exclusive ()
+  (let (char
+        (echo-keystrokes 1))
+    (while (null char)
+      (condition-case nil
+          (setq char (read-char))
+        (error
+         ;; skip event if not char
+         (vip-read-event))))
+    char))
+
+    
+      
+(defun vip-setup-master-buffer (&rest other-files-or-buffers)
+  "Set up the current buffer as a master buffer.
+Arguments become related buffers. This function should normally be used in
+the `Local variables' section of a file."
+  (setq vip-related-files-and-buffers-ring 
+        (make-ring (1+ (length other-files-or-buffers))))
+  (mapcar '(lambda (elt)
+             (vip-ring-insert vip-related-files-and-buffers-ring elt))
+          other-files-or-buffers)
+  (vip-ring-insert vip-related-files-and-buffers-ring (buffer-name))
+  )
+  
+  
+(provide 'viper-util)
+
+;;;  viper-util.el ends here
diff --git a/lisp/emulation/viper.el b/lisp/emulation/viper.el
new file mode 100644
index 00000000000..b0533fbfd61
--- /dev/null
+++ b/lisp/emulation/viper.el
@@ -0,0 +1,5486 @@
+;;; viper.el --- A full-featured Vi emulator for GNU Emacs 19 and XEmacs 19,
+;;               a VI Plan for Emacs Rescue,
+;;               and a venomous VI PERil.
+;;               Viper Is also a Package for Emacs Rebels.
+
+;;  Version:  2.71
+;;  Keywords: emulations
+;;  Author: Michael Kifer <kifer@cs.sunysb.edu>
+
+;; LCD Archive Entry:
+;; viper|Michael Kifer|kifer@cs.sunysb.edu|
+;; A full-featured  Vi emulator for GNU Emacs 19 and XEmacs 19|
+;; 17-February-95|2.71|~/modes/viper.tar.Z|
+
+(defconst viper-version "2.71 of February 17, 1995"
+  "The current version of Viper")
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; 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
+;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, 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
+;; full access to all Emacs facilities.  Viper supports multiple undo,
+;; file name completion, command, file, and search history and it extends
+;; Vi in many other ways. Viper is highly customizable through the various
+;; hooks, user variables, and keymaps.  It is implemented as a collection
+;; of minor modes and it is designed to provide full access to all Emacs
+;; major and minor modes.
+;;
+;;; History
+;;
+;; Viper is a new name for a package formerly known as VIP-19,
+;; which was a successor of VIP version 3.5 by Masahiko Sato
+;; <ms@sail.stanford.edu> and VIP version 4.2 by Aamod Sane
+;; <sane@cs.uiuc.edu>. Some ideas from vip 4.4.2 by Aamod Sane
+;; were also shamelessly plagiarized.
+;;
+;; Viper maintains some degree of compatibility with these older
+;; packages. See the documentation for customization.
+;;
+;; The main difference between Viper and these older packages are:
+;;
+;; 1. Viper emulates Vi at several levels, from almost complete conformity
+;;    to a rather loose Vi-compliance.
+;;
+;; 2. Viper provides full access to all major and minor modes of Emacs
+;;    without the need to type extra keys.
+;;    The older versions of VIP (and other Vi emulators) do not work with
+;;    some major and minor modes.
+;;
+;; 3. Viper supports vi-style undo.
+;;
+;; 4. Viper fully emulates (and improves upon) vi's replacement mode.
+;;
+;; 5. Viper has a better interface to ex, including command, variable, and
+;;    file name completion.
+;;
+;; 6. Viper uses native Emacs history and completion features; it doesn't
+;;    rely on other packages (such as gmhist.el and completer.el) to provide
+;;    these features.
+;;
+;; 7. Viper supports Vi-style editing in the minibuffer, by allowing the
+;;    user to switch from Insert state to Vi state to Replace state, etc.
+;;
+;; 8. Viper keeps history of recently inserted pieces of text and recently
+;;    executed Vi-style destructive commands, such as `i', `d', etc.
+;;    These pieces of text can be inserted in later insertion commands;
+;;    the previous destructive commands can be re-executed.
+;;
+;; 9. Viper has Vi-style keyboard macros, which enhances the similar
+;;    facility in the original Vi.
+;;    First, one can execute any Emacs command while defining a
+;;    macro, not just the Vi commands. Second, macros are defined in a
+;;    WYSYWYG mode, using an interface to Emacs' WYSIWYG style of defining
+;;    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
+;;    definitions, which, in turn, override global definitions.
+;;
+;;
+;;; Installation:
+;;  -------------
+;;
+;;  (require 'viper)
+;;
+
+;;; Acknowledgements:
+;;  -----------------
+;;  Bug reports and ideas contributed by the following users
+;;  have helped improve Viper and the various versions of VIP: 
+;;
+;;  jjm@hplb.hpl.hp.com (Jean-Jacques Moreau), jl@cse.ogi.edu (John
+;;  Launchbury), rxga@ulysses.att.com, jamesm@bga.com (D.J. Miller II),
+;;  ascott@fws214.intel.com (Andy Scott), toma@convex.convex.com,
+;;  gvr@cs.brown.edu, dave@hellgate.utah.edu, cook@biostat.wisc.edu
+;;  (Tom Cook), lindstro@biostat.wisc.edu (Mary Lindstrom),
+;;  edmonds@edmonds.home.cs.ubc.ca (Brian Edmonds), mveiga@dit.upm.es
+;;  (Marcelino Veiga Tuimil), dwight@toolucky.llnl.gov (Dwight Shih),
+;;  phil_brooks@MENTORG.COM (Phil Brooks), kin@isi.com (Kin Cho),
+;;  ahg@panix.com (Al Gelders), dwallach@cs.princeton.edu (Dan Wallach),
+;;  hpz@ibmhpz.aug.ipp-garching.mpg.de (Hans-Peter Zehrfeld),
+;;  simonb@prl.philips.co.uk (Simon Blanchard), Mark.Bordas@East.Sun.COM
+;;  (Mark Bordas), gviswana@cs.wisc.edu (Guhan Viswanathan)
+;;
+;; Special thanks to Marcelino Veiga Tuimil <mveiga@dit.upm.es> for
+;; suggesting a way of intercepting ESC sequences on dumb terminals. Due to
+;; this, Viper can now handle arrow keys, F-keys, etc., in Xterm windows
+;; and on dumb terminals. This also made it possible to implement Vi-style
+;; timeout macros.
+;;
+;;
+;;; Notes:
+;;
+;; 1. Major modes.
+;; In most cases, Viper handles major modes correctly, i.e., they come up
+;; in the right state (either  vi-state or emacs-state). For instance, text
+;; files come up in vi-state, while, say, Dired appears in emacs-state by
+;; default. 
+;; However, some modes do not appear in the right mode in the beginning,
+;; usually because they neglect to follow Emacs conventions (e.g., they don't
+;; use (kill-all-local-variables) when they start. Some major modes
+;; may fail to come up in emacs-state if they call hooks, such as
+;; text-hook, for no good reason. 
+;; 
+;; As an immediate solution, you can hit C-z to bring about the right mode.
+;; An interim solution is to add an appropriate hook to the mode like this:
+;; 
+;;     (add-hook 'your-favorite-mode 'viper-mode)
+;; or    
+;;     (add-hook 'your-favorite-mode 'vip-change-state-to-emacs)
+;; 
+;; whichever applies. The right thing to do, however, is to complain to the
+;; author of the respective package. (Sometimes they also neglect to equip
+;; their  modes with hooks, which is one more reason for complaining.)
+;; 
+;; 2. Keymap handling
+;;    Because Emacs 19 has an elegant mechanism for turning minor mode keymaps
+;;    on and off, implementation of Viper has been greatly simplified. Viper
+;;    has several minor modes.
+;;
+;; Viper's  Vi state consists of seven minor modes:
+;;
+;;  vip-vi-intercept-minor-mode
+;;  vip-vi-local-user-minor-mode
+;;  vip-vi-global-user-minor-mode
+;;  vip-vi-kbd-minor-mode
+;;  vip-vi-state-modifier-minor-mode
+;;  vip-vi-diehard-minor-mode
+;;  vip-vi-basic-minor-mode
+;;
+;;  Bindings done to the keymap of the first mode overshadow those done to
+;;  the second, which, in turn, overshadows those done to the third, etc.
+;;
+;;  The last vip-vi-basic-minor-mode contains most of the usual Vi bindings
+;;  in its edit mode. This mode provides access to all Emacs facilities.
+;;  Novice users, however, may want to set their vip-expert-level to 1
+;;  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
+;;  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
+;;  essential for VI-style editing.
+;;  Pick-and-choose users may want to put
+;;      (setq vip-expert-level 5)
+;;  in ~/.vip. Viper will then leave it up to the user to set the variables
+;;  vip-want-*  See vip-set-expert-level for details.
+;;
+;;  The very first minor mode, vip-vi-intercept-minor-mode, is of no
+;;  concern for the user. It is needed to bind Viper's vital keys, such as
+;;  ESC and C-z.
+;;
+;;  The second mode,  vip-vi-local-user-minor-mode, usually has an
+;;  empty keymap. However, the user can set bindings in this keymap, which
+;;  will overshadow the corresponding bindings in the other two minor
+;;  modes. This is useful, for example, for setting up ZZ in gnus,
+;;  rmail, mh-e, etc., to send  message instead of saving it in a file.
+;;  Likewise, in Dired mode, you may want to bind ZN and ZP to commands
+;;  that would visit the next or the previous file in the Dired buffer.
+;;  Setting local keys is tricky, so don't do it directly. Instead, use
+;;  vip-add-local-keys function (see its doc).
+;;
+;;  The third minor mode, vip-vi-global-user-minor-mode, is also intended
+;;  for the users but, unlike vip-vi-local-user-minor-mode, its key
+;;  bindings are seen in all Viper buffers. This mode keys can be done
+;;  with define-key command.
+;;
+;;  The fourth minor mode, vip-vi-kbd-minor-mode, is used by keyboard
+;;  macros. Users are NOT supposed to modify this keymap directly.
+;;
+;;  The fifth mode, vip-vi-state-modifier-minor-mode, can be used to set
+;;  key bindings that are visible in some major modes but not in others.
+;;
+;;  Users are allowed to modify keymaps that belong to
+;;  vip-vi-local-user-minor-mode, vip-vi-global-user-minor-mode,
+;;  and vip-vi-state-modifier-minor-mode only.
+;;
+;;  Viper's Insert state also has seven minor modes:
+;;
+;;      vip-insert-intercept-minor-mode
+;;      vip-insert-local-user-minor-mode
+;;      vip-insert-global-user-minor-mode
+;;      vip-insert-kbd-minor-mode
+;;      vip-insert-state-modifier-minor-mode
+;;      vip-insert-diehard-minor-mode
+;;      vip-insert-basic-minor-mode
+;;
+;;  As with VI's editing modes, the first mode, vip-insert-intercept-minor-mode
+;;  is used to bind vital keys that are not to be changed by the user.
+;;
+;;  The next mode, vip-insert-local-user-minor-mode, is used to customize
+;;  bindings in the insert state of Viper. The third mode,
+;;  vip-insert-global-user-minor-mode is like
+;;  vip-insert-local-user-minor-mode, except that its bindings are seen in 
+;;  all Viper buffers. As with vip-vi-local-user-minor-mode, its bindings
+;;  should be done via the function vip-add-local-keys. Bindings for
+;;  vip-insert-global-user-minor-mode can be set with the define-key command.
+;;
+;;  The next minor mode, vip-insert-kbd-minor-mode,
+;;  is used for keyboard VI-style macros defined with :map!. 
+;;
+;;  The fifth minor mode, vip-insert-state-modifier-minor-mode, is like
+;;  vip-vi-state-modifier-minor-mode, except that it is used in the Insert
+;;  state; it can be used to modify keys in a mode-specific fashion. 
+;;
+;;  The minor mode vip-insert-diehard-minor-mode is in effect when
+;;  the user wants a high degree of Vi compatibility (a bad idea, really!).
+;;  The last minor mode, vip-insert-basic-minor-mode, is always in effect
+;;  when Viper is in insert state. It binds a small number of keys needed for
+;;  Viper's operation. 
+;;
+;;  Finally, Viper provides minor modes for overriding bindings set by Emacs
+;;  modes when Viper is in Emacs state:
+;;
+;;      vip-emacs-local-user-minor-mode
+;;      vip-emacs-global-user-minor-mode
+;;      vip-emacs-kbd-minor-mode
+;;      vip-emacs-state-modifier-minor-mode
+;;
+;;  These minor modes are in effect when Viper is in Emacs state. The keymap
+;;  associated with vip-emacs-global-user-minor-mode,
+;;  vip-emacs-global-user-map, overrides the global and local keymaps as
+;;  well as the minor mode keymaps set by other modes. The keymap of
+;;  vip-emacs-local-user-minor-mode, vip-emacs-local-user-map, overrides
+;;  everything, but it is used on a per buffer basis.
+;;  The keymap associated with vip-emacs-state-modifier-minor-mode
+;;  overrides keys on a per-major-mode basis. The mode
+;;  vip-emacs-kbd-minor-mode is used to define Vi-style macros in Emacs
+;;  state.
+;;
+;;  3. There is also one minor mode that is used when Viper is in its
+;;     replace-state (used for commands like cw, C, etc.). This mode is
+;;     called
+;;
+;;       vip-replace-minor-mode
+;;
+;;     and its keymap is vip-replace-map. Replace minor mode is always
+;;     used in conjunction with the minor modes for insert-state, and its
+;;     keymap overshadows the keymaps for insert minor modes.
+;;
+;;  4. Defining buffer-local bindings in Vi and Insert modes. 
+;;  As mentioned before, sometimes, it is convenient to have
+;;  buffer-specific of mode-specific key bindings in Vi and insert modes.
+;;  Viper provides a special function, vip-add-local-keys, to do precisely
+;;  this. For instance, is you need to add couple of mode-specific bindings
+;;  to Insert mode, you can put 
+;;
+;;       (vip-add-local-keys 'insert-state '((key1 . func1) (key2 .func2))) 
+;;
+;;  somewhere in a hook of this major mode. If you put something like this
+;;  in your own elisp function, this will define bindings specific to the
+;;  buffer that was current at the time of the call to vip-add-local-keys.
+;;  The only thing to make sure here is that the major mode of this buffer
+;;  is written according to Emacs conventions, which includes a call to
+;;  (kill-all-local-variables). See vip-add-local-keys for more details.
+;;
+;;
+;;  TO DO (volunteers?):
+;;
+;; 1. Some of the code that is inherited from VIP-3.5 is rather
+;;    convoluted. Instead of vip-command-argument, keymaps should bind the
+;;    actual commands. E.g., "dw" should be bound to a generic command
+;;    vip-delete that will delete things based on the value of
+;;    last-command-char. This would greatly simplify the logic and the code.
+;;
+;; 2. Somebody should venture to write a customization package a la
+;;    options.el that would allow the user to change values of variables
+;;    that meet certain specs (e.g., match a regexp) and whose doc string
+;;    starts with a '*'. Then, the user should be offered to save
+;;    variables that were changed. This will make user's customization job
+;;    much easier.
+;;
+
+
+(require 'advice)
+(require 'cl)
+(require 'ring)
+
+(require 'viper-util)
+
+
+;;; Variables
+              
+;; Is t until viper-mode executes for the very first time. 
+;; Prevents recursive descend into startup messages.
+(defvar vip-first-time t)
+
+(defvar vip-expert-level 0
+  "User's expert level.
+The minor mode vip-vi-diehard-minor-mode is in effect when
+vip-expert-level is 1 or 2 or when vip-want-emacs-keys-in-vi is t.
+The minor mode vip-insert-diehard-minor-mode is in effect when
+vip-expert-level is 1 or 2 or if vip-want-emacs-keys-in-insert is t.
+Use `M-x vip-set-expert-level' to change this.")
+
+;; Max expert level supported by Viper. This is NOT a user option.
+;; It is here to make it hard for the user from resetting it.
+(defconst vip-max-expert-level 5)
+
+;; Contains user settings for vars affected by vip-set-expert-level function.
+;; Not a user option.
+(defvar vip-saved-user-settings nil)
+               
+
+;;; Viper minor modes
+
+;; for some reason, this is not local in Emacs, so I made it so.
+(make-variable-buffer-local 'minor-mode-map-alist)
+
+;; Ideally, minor-mode-map-alist should be permanent-local. But Emacs has a
+;; bug that precludes that. So, there is a workaround in
+;; vip-harness-minor-mode. 
+;;(put 'minor-mode-map-alist 'permanent-local t)
+
+;; Mode for vital things like \e, C-z.
+(vip-deflocalvar vip-vi-intercept-minor-mode nil)
+
+(vip-deflocalvar vip-vi-basic-minor-mode nil
+  "Viper's minor mode for Vi bindings.")
+  
+(vip-deflocalvar vip-vi-local-user-minor-mode nil
+  "Auxiliary minor mode for user-defined local bindings in Vi state.")
+
+(vip-deflocalvar vip-vi-global-user-minor-mode nil
+  "Auxiliary minor mode for user-defined global bindings in Vi state.")
+
+(vip-deflocalvar vip-vi-state-modifier-minor-mode nil
+  "Minor mode used to make major-mode-specific modification to Vi state.")
+
+(vip-deflocalvar vip-vi-diehard-minor-mode nil
+  "This minor mode is in effect when the user wants Viper to be Vi.")
+
+(vip-deflocalvar vip-vi-kbd-minor-mode nil
+  "Minor mode for Ex command macros Vi state.
+The corresponding keymap stores key bindings of Vi macros defined with
+the Ex command :map.")
+
+;; Mode for vital things like \e, C-z.
+(vip-deflocalvar vip-insert-intercept-minor-mode nil)
+
+(vip-deflocalvar vip-insert-basic-minor-mode nil
+  "Viper's minor mode for bindings in Insert mode.")
+
+(vip-deflocalvar vip-insert-local-user-minor-mode nil
+  "Auxiliary minor mode for buffer-local user-defined bindings in Insert state.
+This is a way to overshadow normal Insert mode bindings locally to certain
+designated buffers.")
+
+(vip-deflocalvar vip-insert-global-user-minor-mode nil
+  "Auxiliary minor mode for global user-defined bindings in Insert state.")
+
+(vip-deflocalvar vip-insert-state-modifier-minor-mode nil
+  "Minor mode used to make major-mode-specific modification to Insert state.")
+
+(vip-deflocalvar vip-insert-diehard-minor-mode nil
+  "Minor mode that simulates Vi very closely.
+Not recommened, except for the novice user.")
+
+(vip-deflocalvar vip-insert-kbd-minor-mode nil
+"Minor mode for Ex command macros Insert state.
+The corresponding keymap stores key bindings of Vi macros defined with
+the Ex command :map!.")
+
+(vip-deflocalvar vip-replace-minor-mode nil
+  "Minor mode in effect in replace state (cw, C, and the like commands).")
+
+;; Mode for vital things like \C-z and \C-x)
+;; This is t, by default. So, any new buffer will have C-z defined as
+;; switch to Vi, unless we switched states in this buffer
+(vip-deflocalvar vip-emacs-intercept-minor-mode t)
+  
+(vip-deflocalvar vip-emacs-local-user-minor-mode t
+  "Minor mode for local user bindings effective in Emacs state.
+Users can use it to override Emacs bindings when Viper is in its Emacs
+state.")  
+  
+(vip-deflocalvar vip-emacs-global-user-minor-mode t
+  "Minor mode for global user bindings in effect in Emacs state.
+Users can use it to override Emacs bindings when Viper is in its Emacs
+state.")  
+
+(vip-deflocalvar vip-emacs-kbd-minor-mode t
+  "Minor mode for Vi style macros in Emacs state.
+The corresponding keymap stores key bindings of Vi macros defined with
+`vip-record-kbd-macro' command. There is no Ex-level command to do this
+interactively.")
+
+(vip-deflocalvar vip-emacs-state-modifier-minor-mode t
+  "Minor mode used to make major-mode-specific modification to Emacs state.
+For instance, a Vi purist may want to bind `dd' in Dired mode to a function
+that deletes a file.")
+
+
+
+;;; ISO characters
+  
+(defvar vip-automatic-iso-accents nil
+  "*If non-nil, ISO accents will be turned on in insert/replace emacs states and turned off in vi-state. 
+For some users, this behavior may be too primitive. In this case, use
+insert/emacs/vi state hooks.")
+  
+  
+;;; Emacs keys in other states.  
+
+(defvar vip-want-emacs-keys-in-insert t
+  "*Set to nil if you want complete Vi compatibility in insert mode.
+Complete compatibility with Vi is not recommended for power use of Viper.")
+
+(defvar vip-want-emacs-keys-in-vi t
+  "*Set to nil if you want complete Vi compatibility in Vi mode.
+Full Vi compatibility is not recommended for power use of Viper.")
+
+
+
+;; VI-style Undo
+
+;; Used to 'undo' complex commands, such as replace and insert commands.
+(vip-deflocalvar vip-undo-needs-adjustment nil)
+(put 'vip-undo-needs-adjustment 'permanent-local t)
+
+;; A mark that Viper puts on buffer-undo-list.  Marks the beginning of a
+;; complex command that must be undone atomically. If inserted, it is
+;; erased by vip-change-state-to-vi and vip-repeat.
+(defconst vip-buffer-undo-list-mark 'viper)
+
+(defvar vip-keep-point-on-undo nil
+  "*Non-nil means not to move point while undoing commands.
+This style is different from Emacs and Vi. Try it to see if
+it better fits your working style.")  
+
+;; Replace mode and changing text
+
+;; Viper's own after/before change functions, which get add-hook'ed to Emacs'
+(vip-deflocalvar vip-after-change-functions nil "")
+(vip-deflocalvar vip-before-change-functions nil "")
+(vip-deflocalvar vip-post-command-hooks nil "")
+(vip-deflocalvar vip-pre-command-hooks nil "")
+
+;; Can be used to pass global states around for short period of time
+(vip-deflocalvar vip-intermediate-command nil "")
+
+;; Indicates that the current destructive command has started in replace mode.
+(vip-deflocalvar vip-began-as-replace nil "")
+
+(defvar vip-replace-overlay-cursor-color "Red"
+  "*Color to use in Replace state")
+
+  
+(vip-deflocalvar vip-replace-overlay nil "")
+(put 'vip-replace-overlay 'permanent-local t)
+
+(if window-system
+    (progn
+      (make-face 'vip-replace-overlay-face)
+      (or (face-differs-from-default-p 'vip-replace-overlay-face)
+          (progn
+            (if (vip-can-use-colors "darkseagreen2" "Black")
+                (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))
+          )))
+            
+(defvar vip-replace-overlay-face 'vip-replace-overlay-face
+  "*Face for highlighting replace regions on a window display.")
+  
+(defvar vip-replace-region-end-symbol 
+  (if (and window-system (vip-display-color-p)) ""  "$")
+  "*Symbol to mark the end of a replacement region. A string.
+At present, only the first character of a non-empty string is used to
+actually mark the region.")
+(defvar vip-replace-region-start-symbol ""
+  "*Symbol to mark the beginning of a replacement region. A string.
+Not yet implemented.")
+  
+;; These are local marker that must be initialized to nil and moved with
+;; `vip-move-marker-locally'
+;;
+;; Remember the last position inside the replace region.
+(vip-deflocalvar vip-last-posn-in-replace-region nil)
+;; Remember the last position while inserting
+(vip-deflocalvar vip-last-posn-while-in-insert-state nil)
+(put 'vip-last-posn-in-replace-region 'permanent-local t)
+(put 'vip-last-posn-while-in-insert-state 'permanent-local t)
+
+(vip-deflocalvar vip-sitting-in-replace nil "")
+(put 'vip-sitting-in-replace 'permanent-local t)
+  
+;; Remember the number of characters that have to be deleted in replace
+;; mode to compensate for the inserted characters.
+(vip-deflocalvar vip-replace-chars-to-delete 0 "")
+(vip-deflocalvar vip-replace-chars-deleted 0 "")
+
+;; Insertion ring and command ring
+(defvar vip-insertion-ring-size 14
+  "The size of the insertion ring.")
+;; The insertion ring.
+(defvar vip-insertion-ring nil)
+;; This is temp insertion ring. Used to do rotation for display purposes.
+;; When rotation just started, it is initialized to vip-insertion-ring.
+(defvar vip-temp-insertion-ring nil)
+(defvar vip-last-inserted-string-from-insertion-ring "")
+
+(defvar vip-command-ring-size 14
+  "The size of the command ring.")
+;; The command ring.
+(defvar vip-command-ring nil)
+;; This is temp command ring. Used to do rotation for display purposes.
+;; When rotation just started, it is initialized to vip-command-ring.
+(defvar vip-temp-command-ring nil)
+
+;; 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,
+as is allowed by the major mode in effect.") 
+
+
+(defvar vip-want-ctl-h-help nil
+  "*If t then C-h is bound to help-command in insert mode, if nil then it is
+bound to delete-backward-char.")
+
+;; Autoindent in insert
+
+;; Variable that keeps track of whether C-t has been pressed.
+(vip-deflocalvar vip-cted nil "")
+
+;; Preserve the indent value, used by C-d in insert mode.
+(vip-deflocalvar vip-current-indent 0)
+
+;; Whether to preserve the indent, used by C-d in insert mode.
+(vip-deflocalvar vip-preserve-indent nil)
+
+(defconst vip-auto-indent nil
+  "*Autoindent if t.")
+
+(defconst vip-shift-width 8
+  "*The shiftwidth variable.")
+
+;; Variables for repeating destructive commands
+
+(defconst vip-keep-point-on-repeat t
+  "*If t, don't move point when repeating previous command.
+This is useful for doing repeated changes with the '.' key.
+The user can change this to nil, if she likes when the cursor moves
+to a new place after repeating previous Vi command.") 
+
+;; Remember insert point as a marker.  This is a local marker that must be
+;; initialized to nil and moved with `vip-move-marker-locally'.
+(vip-deflocalvar vip-insert-point nil)
+(put 'vip-insert-point 'permanent-local t)
+
+;; This remembers the point before dabbrev-expand was called.
+;; If vip-insert-point turns out to be bigger than that, it is reset
+;; back to vip-pre-command-point.
+;; The reason this is needed is because dabbrev-expand (and possibly
+;; others) may jump to before the insertion point, delete something and
+;; then reinsert a bigger piece. For instance:  bla^blo
+;; If dabbrev-expand is called after `blo' and ^ undicates vip-insert-point,
+;; then point jumps to the beginning of `blo'. If expansion is found, `blablo'
+;; is deleted, and we have |^, where | denotes point. Next, dabbrev-expand
+;; will insert the expansion, and we get: blablo^
+;; Whatever we insert next goes before the ^, i.e., before the
+;; vip-insert-point marker. So, Viper will think that nothing was
+;; inserted. Remembering the orig position of the marker circumvents the
+;; problem.
+;; We don't know of any command, except dabbrev-expand, that has the same
+;; problem. However, the same trick can be used if such a command is
+;; discovered later.
+;;
+(vip-deflocalvar vip-pre-command-point nil)
+(put 'vip-pre-command-point 'permanent-local t) ; this is probably an overkill
+
+;; This is used for saving inserted text.
+(defvar vip-last-insertion  nil)
+  
+;; Remembers the last replaced region.
+(defvar vip-last-replace-region "")
+  
+;; Remember com point as a marker.
+;; This is a local marker. Should be moved with `vip-move-marker-locally'
+(vip-deflocalvar vip-com-point nil)
+
+;; If non-nil, the value is a list (M-COM VAL COM REG inserted-text cmd-keys)
+;; It is used to re-execute last destructive command.
+;; M-COM is a Lisp symbol representing the function to be executed.
+;; VAL is the prefix argument that was used with that command.
+;; COM is an internal descriptor, such as ?r, ?c, ?C, which contains
+;; additional information on how the function in M-COM is to be handled.
+;; REG is the register used by command
+;; INSERTED-TEXT is text inserted by that command (in case of o, c, C, i, r
+;; commands).
+;; COMMAND-KEYS are the keys that were typed to invoke the command.
+(defvar vip-d-com nil)
+
+;; The character remembered by the Vi `r' command.
+(defvar vip-d-char nil)
+
+;; Name of register to store deleted or yanked strings
+(defvar vip-use-register nil)
+
+
+
+;; Variables for Moves and Searches
+
+;; For use by `;' command.
+(defvar vip-f-char nil)
+
+;; For use by `.' command.
+(defvar vip-F-char nil)
+
+;; For use by `;' command.
+(defvar vip-f-forward nil)
+
+;; For use by `;' command.
+(defvar vip-f-offset nil)
+
+;; Last search string
+(defvar vip-s-string "")
+
+(defvar vip-quote-string "> "
+  "String inserted at the beginning of quoted region.")
+
+;; If t, search is forward.
+(defvar vip-s-forward nil)
+
+(defconst vip-case-fold-search nil
+  "*If t, search ignores cases.")
+
+(defconst vip-re-search t
+  "*If t, search is reg-exp search, otherwise vanilla search.")
+
+(defconst vip-re-query-replace t
+  "*If t then do regexp replace, if nil then do string replace.")
+
+(defconst vip-re-replace t
+  "*If t, do regexp replace. nil means do string replace.")
+
+(vip-deflocalvar vip-ex-style-motion t
+  "*Ex-style: the commands l,h do not cross lines, etc.")
+
+(vip-deflocalvar vip-ex-style-editing-in-insert t
+  "*The keys ^H, ^? don't jump lines in insert, ESC moves cursor back, etc.
+Note: this doesn't preclude ^H and ^? from deleting characters by moving
+past the insertion point. This is a feature, not a bug. ")
+
+(vip-deflocalvar vip-delete-backwards-in-replace nil
+  "*If t, DEL key will delete characters while moving the cursor backwards.
+If nil, the cursor will move backwards without deleting anything.")
+
+(defconst vip-buffer-search-char nil
+  "*Key bound for buffer-searching.")
+
+(defconst vip-search-wrap-around-t t
+  "*If t, search wraps around.")
+  
+(vip-deflocalvar vip-related-files-and-buffers-ring nil
+  "*Ring of file and buffer names that are considered to be related to the
+current buffer.
+These buffers can be cycled through via :R and :P commands.")
+(put 'vip-related-files-and-buffers-ring 'permanent-local t)
+
+;; Used to find out if we are done with searching the current buffer.
+(vip-deflocalvar vip-local-search-start-marker nil)
+;; As above, but global
+(defvar vip-search-start-marker (make-marker))
+
+;; the search overlay
+(vip-deflocalvar vip-search-overlay nil)
+
+
+(defvar vip-heading-start 
+  (concat "^\\s-*(\\s-*defun\\s-\\|"                            ;; lisp
+          "^{\\s-*$\\|^[_a-zA-Z][^()]*[()].*{\\s-*$\\|"         ;; C/C++
+          "^\\s-*class.*{\\|^\\s-*struct.*{\\|^\\s-*enum.*{\\|"
+          "^\\\\[sb][a-z]*{.*}\\s-*$\\|"                        ;; latex
+          "^@node\\|@table\\|^@m?enu\\|^@itemize\\|^@if\\|"     ;; texinfo
+          "^.+:-")                                              ;; prolog
+  "*Regexps for Headings. Used by \[\[ and \]\].")
+
+(defvar vip-heading-end 
+  (concat "^}\\|"                                               ;; C/C++
+          "^\\\\end{\\|"                                        ;; latex
+          "^@end \\|"                                           ;; texinfo
+          ")\n\n[ \t\n]*\\|"                                    ;; lisp
+          "\\.\\s-*$")                                          ;; prolog
+      "*Regexps to end Headings/Sections. Used by \[\].")
+
+
+;; These two vars control the interaction of jumps performed by ' and `.
+;; In this new version, '' doesn't erase the marks set by ``, so one can
+;; use both kinds of jumps interchangeably and without loosing positions
+;; inside the lines.
+
+;; Remembers position of the last jump done using ``'.
+(vip-deflocalvar vip-last-jump  nil)
+;; Remembers position of the last jump done using `''.
+(vip-deflocalvar vip-last-jump-ignore 0)
+
+;; Some common error messages
+
+(defconst vip-SpuriousText "Spurious text after command"  "")
+(defconst vip-BadExCommand "Not an editor command"   "")
+(defconst vip-InvalidCommandArgument "Invalid command argument"   "")
+(defconst vip-NoPrevSearch "No previous search string"   "")
+(defconst vip-EmptyRegister "`%c': Nothing in this register"   "")
+(defconst vip-InvalidRegister "`%c': Invalid register"   "")
+(defconst vip-EmptyTextmarker "`%c': Text marker doesn't point anywhere"   "")
+(defconst vip-InvalidTextmarker "`%c': Invalid text marker"   "")
+(defconst vip-InvalidViCommand "Invalid command"   "")
+(defconst vip-BadAddress "Ill-formed address"   "")
+(defconst vip-FirstAddrExceedsSecond "First address exceeds second"   "")
+(defconst vip-NoFileSpecified "No file specified"   "")
+
+
+;; History variables
+
+(defvar vip-history nil)
+;; History of search strings.
+(defvar vip-search-history  (list ""))
+;; History of query-replace strings used as a source.
+(defvar vip-replace1-history nil)
+;; History of query-replace strings used as replacement.
+(defvar vip-replace2-history nil)
+;; History of region quoting strings.
+(defvar vip-quote-region-history (list vip-quote-string))
+;; History of Ex-style commands.
+(defvar vip-ex-history nil)
+;; History of shell commands.
+(defvar vip-shell-history nil)
+
+
+;; Last shell command. There are two of these, one for Ex (in viper-ex)
+;; and one for Vi.
+
+;; Last shell command executed with ! command.
+(defvar vip-last-shell-com nil)
+
+
+
+;;; Miscellaneous
+
+;; setup emacs-supported vi-style feel
+(setq mark-even-if-inactive t
+      next-line-add-newlines nil
+      require-final-newline t)
+
+(defvar vip-inhibit-startup-message nil
+  "Whether Viper startup message should be inhibited.")
+
+(defvar vip-always t
+  "t means, arrange that vi-state will be a default.")
+
+(defvar vip-custom-file-name "~/.vip"
+  "Viper customisation file.
+This variable must be set _before_ loading Viper.")
+
+(defvar vip-info-file-name "viper"
+  "The name prefix for Viper Info files.")
+
+(defvar vip-spell-function 'ispell-region
+  "Spell function used by #s<move> command to spell.")
+
+(defvar vip-tags-file-name "TAGS")
+
+;; Minibuffer
+
+(defvar vip-vi-style-in-minibuffer t
+  "If t, use vi-style editing in minibuffer.
+Should be set in `~/.vip' file.")
+  
+;; overlay used in the minibuffer to indicate which state it is in
+(vip-deflocalvar vip-minibuffer-overlay nil)
+
+;; Hook, specific to Viper, which is run just *before* exiting the minibuffer.
+;; Beginning with Emacs 19.26, the standard `minibuffer-exit-hook' is run
+;; *after* exiting the minibuffer
+(defvar vip-minibuffer-exit-hook nil)
+
+(vip-deflocalvar vip-vi-minibuffer-minor-mode nil
+   "Minor mode that forces Vi-style when the Minibuffer is in Vi state.")
+(vip-deflocalvar vip-insert-minibuffer-minor-mode nil
+   "Minor mode that forces Vi-style when the Minibuffer is in Insert state.")
+  
+(vip-deflocalvar vip-add-newline-at-eob t
+  "If t, always add a newline at the end of buffer.
+Usually, Viper adds a newline character at the end of the last
+line in a buffer, if it's missing. In some major modes, however, like
+shell-mode, this is undesirable and must be set to nil. See vip-set-hooks.")
+       
+
+;; Mode line
+(defconst vip-vi-state-id       "<V> "
+  "Mode line tag identifying the Vi mode of Viper.")
+(defconst vip-emacs-state-id    "<E> "
+  "Mode line tag identifying the Emacs mode of Viper.")
+(defconst vip-insert-state-id   "<I> "
+  "Mode line tag identifying the Insert mode of Viper.")
+(defconst vip-replace-state-id  "<R> "
+  "Mode line tag identifying the Replace mode of Viper.")
+
+;; Viper changes the default mode-line-buffer-identification
+(setq-default mode-line-buffer-identification '(" %b"))
+
+;; Variable displaying the current Viper state in the mode line.
+(vip-deflocalvar vip-mode-string vip-emacs-state-id)
+(or (memq 'vip-mode-string global-mode-string)
+    (setq global-mode-string
+          (append '("" vip-mode-string) (cdr global-mode-string))))
+
+
+(defvar vip-vi-state-hooks nil
+  "*Hooks run just before the switch to Vi mode is completed.")
+(defvar vip-insert-state-hooks nil
+  "*Hooks run just before the switch to Insert mode is completed.")
+(defvar vip-replace-state-hooks nil
+  "*Hooks run just before the switch to Replace mode is completed.")
+(defvar vip-emacs-state-hooks nil
+  "*Hooks run just before the switch to Emacs mode is completed.")
+  
+(defvar vip-load-hooks nil
+  "Hooks run just after loading Viper.")
+  
+
+;; Generic predicates
+
+;; These test functions are shamelessly lifted from vip 4.4.2 by Aamod Sane
+
+;; generate test functions
+;; given symbol foo, foo-p is the test function, foos is the set of
+;; Viper command keys
+;; (macroexpand '(vip-test-com-defun foo))
+;; (defun foo-p (com) (consp (memq (if (< com 0) (- com) com) foos)))
+
+(defmacro vip-test-com-defun (name)
+  (let* (;;(snm (make-symbol "s1"))
+         (snm (symbol-name name))
+         ;;(nm-p (make-symbol "s2"))
+         (nm-p (intern (concat snm "-p")))
+         ;;(nms (make-symbol "s3"))
+         (nms (intern (concat snm "s"))))
+    (` (defun (, nm-p) (com) 
+         (consp (memq (if (< com 0) (- com) com) (, nms)))))))
+  
+;; Variables for defining VI commands
+
+(defconst vip-prefix-commands '(?c ?d ?y ?! ?= ?# ?< ?> ?\")
+  "Modifying commands that can be prefixes to movement commands")
+(vip-test-com-defun vip-prefix-command)
+  
+(defconst vip-charpair-commands '(?c ?d ?y ?! ?= ?< ?> ?r ?R)
+  "Commands that are pairs eg. dd. r and R here are a hack")
+(vip-test-com-defun vip-charpair-command)
+
+(defconst vip-movement-commands '(?b ?B ?e ?E ?f ?F ?G ?h ?H ?j ?k ?l
+                                     ?H ?M ?n ?t ?T ?w ?W ?$ ?%
+                                     ?^ ?( ?) ?- ?+ ?| ?{ ?} ?[ ?] ?' ?`
+                                     ?; ?, ?0 ?? ?/
+                                     )
+                                     "Movement commands")
+(vip-test-com-defun vip-movement-command)
+
+(defconst vip-dotable-commands '(?c ?d ?C ?D ?> ?<)
+  "Commands that can be repeated by .(dotted)")
+(vip-test-com-defun vip-dotable-command)
+
+(defconst vip-hash-cmds '(?c ?C ?g ?q ?S)
+  "Commands that can follow a #")
+(vip-test-com-defun vip-hash-cmd)
+
+(defconst vip-regsuffix-commands '(?d ?y ?Y ?D ?p ?P ?x ?X)
+  "Commands that may have registers as prefix")
+(vip-test-com-defun vip-regsuffix-command)
+
+
+
+;;; Arrange the keymaps
+(require 'viper-keym)
+
+
+;;;; CODE
+
+;; changing mode
+
+;; Change state to NEW-STATE---either emacs-state, vi-state, or insert-state.
+(defun vip-change-state (new-state)
+  ;; keep them always fresh
+  (add-hook 'post-command-hook 'vip-post-command-sentinel t)
+  (add-hook 'pre-command-hook 'vip-pre-command-sentinel t)
+  ;; These hooks will be added back if switching to insert/replace mode
+  (remove-hook 'vip-post-command-hooks
+               'vip-insert-state-post-command-sentinel)
+  (remove-hook 'vip-pre-command-hooks
+               'vip-insert-state-pre-command-sentinel)
+  (cond ((eq new-state 'vi-state)
+         (cond ((member vip-current-state '(insert-state replace-state))
+                    
+                ;; move vip-last-posn-while-in-insert-state
+                ;; This is a normal hook that is executed in insert/replace
+                ;; states after each command. In Vi/Emacs state, it does
+                ;; nothing. We need to execute it here to make sure that
+                ;; the last posn was recorded when we hit ESC.
+                ;; It may be left unrecorded if the last thing done in
+                ;; insert/repl state was dabbrev-expansion or abbrev
+                ;; expansion caused by hitting ESC
+                (vip-insert-state-post-command-sentinel)
+                
+                (condition-case conds
+                    (progn
+                      (vip-save-last-insertion
+                       vip-insert-point 
+                       vip-last-posn-while-in-insert-state)
+                      (if vip-began-as-replace
+                          (setq vip-began-as-replace nil)
+                        ;; repeat insert commands if numerical arg > 1
+                        (save-excursion
+                          (vip-repeat-insert-command))))
+                  (error
+                   (vip-message-conditions conds)))
+                     
+                (if (> (length vip-last-insertion) 0)
+                    (vip-push-onto-ring vip-last-insertion
+                                        'vip-insertion-ring))
+                
+                (if vip-ex-style-editing-in-insert
+                    (or (bolp) (backward-char 1))))
+               ))
+         
+        ;; insert or replace
+        ((memq new-state '(insert-state replace-state))
+         (if (memq vip-current-state '(emacs-state vi-state))
+             (vip-move-marker-locally 'vip-insert-point (point)))
+         (vip-move-marker-locally 'vip-last-posn-while-in-insert-state (point))
+         (add-hook 'vip-post-command-hooks
+                   'vip-insert-state-post-command-sentinel t)
+         (add-hook 'vip-pre-command-hooks
+                   'vip-insert-state-pre-command-sentinel t)
+         )
+        ) ; outermost cond
+  
+  ;; Nothing needs to be done to switch to emacs mode! Just set some
+  ;; variables, which is done in vip-change-state-to-emacs!
+
+  (setq vip-current-state new-state)
+  (vip-normalize-minor-mode-map-alist)
+  (vip-adjust-keys-for new-state)
+  (vip-set-mode-vars-for new-state)
+  (vip-refresh-mode-line)
+  )
+
+
+    
+(defun vip-adjust-keys-for (state)
+  "Make necessary adjustments to keymaps before entering STATE."
+  (cond ((memq state '(insert-state replace-state))
+         (if vip-auto-indent
+             (progn
+               (define-key vip-insert-basic-map "\C-m" 'vip-autoindent)
+               (if vip-want-emacs-keys-in-insert
+                   ;; expert
+                   (define-key vip-insert-basic-map "\C-j" nil)
+                 ;; novice
+                 (define-key vip-insert-basic-map "\C-j" 'vip-autoindent))))
+                    
+         (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-replace-map "\C-h" 'help-command))
+           (define-key vip-insert-basic-map 
+             "\C-h" 'vip-del-backward-char-in-insert)
+           (define-key vip-replace-map
+             "\C-h" 'vip-del-backward-char-in-replace)))
+                     
+        (t
+         (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 "\C-h" 'vip-backward-char)))
+        ))
+             
+    
+(defun  vip-normalize-minor-mode-map-alist ()
+  "Normalizes minor-mode-map-alist by putting Viper keymaps first.
+This ensures that Viper bindings are in effect, regardless of which minor
+modes were turned on by the user or by other packages."
+  (setq minor-mode-map-alist 
+        (vip-append-filter-alist
+         (list
+               (cons 'vip-vi-intercept-minor-mode vip-vi-intercept-map)
+               (cons 'vip-vi-minibuffer-minor-mode vip-minibuffer-map) 
+               (cons 'vip-vi-local-user-minor-mode vip-vi-local-user-map)
+               (cons 'vip-vi-kbd-minor-mode vip-vi-kbd-map)
+               (cons 'vip-vi-global-user-minor-mode vip-vi-global-user-map)
+               (cons 'vip-vi-state-modifier-minor-mode
+                     (if (keymapp
+                          (cdr (assoc major-mode vip-vi-state-modifier-alist)))
+                         (cdr (assoc major-mode vip-vi-state-modifier-alist))
+                       vip-empty-keymap))
+               (cons 'vip-vi-diehard-minor-mode  vip-vi-diehard-map)
+               (cons 'vip-vi-basic-minor-mode     vip-vi-basic-map)
+               (cons 'vip-insert-intercept-minor-mode vip-insert-intercept-map)
+               (cons 'vip-replace-minor-mode  vip-replace-map)
+               ;; vip-insert-minibuffer-minor-mode must come after
+               ;; vip-replace-minor-mode 
+               (cons 'vip-insert-minibuffer-minor-mode
+                     vip-minibuffer-map) 
+               (cons 'vip-insert-local-user-minor-mode
+                     vip-insert-local-user-map)
+               (cons 'vip-insert-kbd-minor-mode vip-insert-kbd-map)
+               (cons 'vip-insert-global-user-minor-mode
+                     vip-insert-global-user-map)
+               (cons 'vip-insert-state-modifier-minor-mode
+                     (if (keymapp
+                          (cdr
+                           (assoc major-mode vip-insert-state-modifier-alist)))
+                         (cdr
+                          (assoc major-mode vip-insert-state-modifier-alist))
+                       vip-empty-keymap))
+               (cons 'vip-insert-diehard-minor-mode vip-insert-diehard-map)
+               (cons 'vip-insert-basic-minor-mode vip-insert-basic-map)
+               (cons 'vip-emacs-intercept-minor-mode
+                     vip-emacs-intercept-map)
+               (cons 'vip-emacs-local-user-minor-mode
+                     vip-emacs-local-user-map)
+               (cons 'vip-emacs-kbd-minor-mode vip-emacs-kbd-map)
+               (cons 'vip-emacs-global-user-minor-mode
+                     vip-emacs-global-user-map)
+               (cons 'vip-emacs-state-modifier-minor-mode
+                     (if (keymapp
+                          (cdr
+                           (assoc major-mode vip-emacs-state-modifier-alist)))
+                         (cdr
+                          (assoc major-mode vip-emacs-state-modifier-alist))
+                       vip-empty-keymap))
+               )
+         minor-mode-map-alist)))
+         
+ 
+
+
+
+;; Viper mode-changing commands and utilities
+
+(defun vip-refresh-mode-line ()
+  "Modifies mode-line-buffer-identification."
+  (setq vip-mode-string 
+        (cond ((eq vip-current-state 'emacs-state) vip-emacs-state-id)
+              ((eq vip-current-state 'vi-state) vip-vi-state-id)
+              ((eq vip-current-state 'replace-state) vip-replace-state-id)
+              ((eq vip-current-state 'insert-state) vip-insert-state-id)))
+    
+  ;; Sets Viper mode string in global-mode-string
+  (force-mode-line-update))
+  
+;;;###autoload
+(defun viper-mode ()
+  "Turn on Viper emulation of Vi."
+  (interactive)
+  (if (not noninteractive)
+      (progn
+        (if vip-first-time ; This check is important. Without it, startup and 
+            (progn         ; expert-level msgs mix up when viper-mode recurses
+              (setq vip-first-time nil)
+              (if (not vip-inhibit-startup-message)
+                  (save-window-excursion
+                    (setq vip-inhibit-startup-message t)
+                    (delete-other-windows)
+                    (switch-to-buffer "Viper Startup Message")
+                    (erase-buffer)
+                    (insert
+                     (substitute-command-keys
+                      "Viper Is a Package for Emacs Rebels.
+It is also a VI Plan for Emacs Rescue and a venomous VI PERil.
+
+Technically speaking, Viper is a Vi emulation package for GNU Emacs 19 and
+XEmacs 19.  It supports virtually all of Vi and Ex functionality, extending
+and improving upon much of it.
+
+   1. Viper supports Vi at several levels. Level 1 is the closest to
+      Vi, level 5 provides the most flexibility to depart from many Vi
+      conventions.
+      
+      You will be asked to specify your user level in a following screen.
+   
+      If you select user level 1 then the keys ^X, ^C, ^Z, and ^G will
+      behave as in VI, to smooth transition to Viper for the beginners. 
+      However, to use Emacs productively, you are advised to reach user
+      level 3 or higher. 
+      
+      If your user level is 2 or higher, ^X and ^C will invoke Emacs
+      functions,as usual in Emacs; ^Z will toggle vi/emacs modes, and
+      ^G will be the usual Emacs's keyboard-quit (something like ^C in VI).
+   
+   2. Vi exit functions (e.g., :wq, ZZ) work on INDIVIDUAL files -- they
+      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'.
+      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:
+
+   a. Typing `:help' in Vi state
+   b. Printing Viper manual, found in ./etc/viper.dvi
+   c. Printing ViperCard, the Quick Reference, found in ./etc/viperCard.dvi
+    
+This startup message appears whenever you load Viper, unless you type `y' now."
+                      ))
+                    (goto-char (point-min))
+                    (if (y-or-n-p "Inhibit Viper startup message? ")
+                        (vip-save-setting
+                         'vip-inhibit-startup-message
+                         "Viper startup message inhibited"
+                         vip-custom-file-name t))
+                    (kill-buffer (current-buffer))))
+              (message " ")
+              (vip-set-expert-level 'dont-change-unless)))
+        (vip-change-state-to-vi))))
+        
+;;;###autoload
+(defalias 'vip-mode 'viper-mode)
+
+
+(defun vip-exit-insert-state ()
+  "Switch from Insert state to Vi state."
+  (interactive)
+  (vip-change-state-to-vi))
+
+(defun vip-set-mode-vars-for (state)
+  "Sets Viper minor mode variables to put Viper's state STATE in effect."
+  
+  ;; Emacs state
+  (setq vip-vi-minibuffer-minor-mode       nil
+        vip-insert-minibuffer-minor-mode   nil
+        vip-vi-intercept-minor-mode        nil
+        vip-insert-intercept-minor-mode    nil
+        
+        vip-vi-local-user-minor-mode       nil
+        vip-vi-kbd-minor-mode              nil
+        vip-vi-global-user-minor-mode      nil
+        vip-vi-state-modifier-minor-mode   nil
+        vip-vi-diehard-minor-mode          nil
+        vip-vi-basic-minor-mode            nil
+        
+        vip-replace-minor-mode             nil
+        
+        vip-insert-local-user-minor-mode     nil
+        vip-insert-kbd-minor-mode            nil
+        vip-insert-global-user-minor-mode    nil
+        vip-insert-state-modifier-minor-mode nil
+        vip-insert-diehard-minor-mode        nil
+        vip-insert-basic-minor-mode          nil
+        vip-emacs-intercept-minor-mode       t
+        vip-emacs-local-user-minor-mode      t
+        vip-emacs-kbd-minor-mode             (not (vip-is-in-minibuffer))
+        vip-emacs-global-user-minor-mode     t
+        vip-emacs-state-modifier-minor-mode  t
+        )
+  
+  ;; Vi state
+  (if (eq state 'vi-state) ; adjust for vi-state
+      (setq 
+       vip-vi-intercept-minor-mode         t 
+       vip-vi-minibuffer-minor-mode        (vip-is-in-minibuffer)
+       vip-vi-local-user-minor-mode        t
+       vip-vi-kbd-minor-mode               (not (vip-is-in-minibuffer))
+       vip-vi-global-user-minor-mode       t
+       vip-vi-state-modifier-minor-mode    t
+       ;; don't let the diehard keymap block command completion 
+       ;; and other things in the minibuffer
+       vip-vi-diehard-minor-mode           (not
+                                            (or vip-want-emacs-keys-in-vi
+                                                (vip-is-in-minibuffer)))
+       vip-vi-basic-minor-mode              t 
+       vip-emacs-intercept-minor-mode       nil
+       vip-emacs-local-user-minor-mode      nil
+       vip-emacs-kbd-minor-mode             nil
+       vip-emacs-global-user-minor-mode     nil
+       vip-emacs-state-modifier-minor-mode  nil
+       ))
+  
+  ;; Insert and Replace states
+  (if (member state '(insert-state replace-state))
+      (setq 
+       vip-insert-intercept-minor-mode      t 
+       vip-replace-minor-mode               (eq state 'replace-state)
+       vip-insert-minibuffer-minor-mode     (vip-is-in-minibuffer)
+       vip-insert-local-user-minor-mode     t
+       vip-insert-kbd-minor-mode            (not (vip-is-in-minibuffer))
+       vip-insert-global-user-minor-mode    t
+       vip-insert-state-modifier-minor-mode  t
+       ;; don't let the diehard keymap block command completion 
+       ;; and other things in the minibuffer
+       vip-insert-diehard-minor-mode        (not
+                                             (or vip-want-emacs-keys-in-insert
+                                                 (vip-is-in-minibuffer)))
+       vip-insert-basic-minor-mode          t
+       vip-emacs-intercept-minor-mode       nil
+       vip-emacs-local-user-minor-mode      nil
+       vip-emacs-kbd-minor-mode             nil
+       vip-emacs-global-user-minor-mode     nil
+       vip-emacs-state-modifier-minor-mode  nil
+       ))
+       
+  ;; minibuffer faces
+  (if window-system
+      (setq vip-minibuffer-current-face
+            (cond ((eq state 'emacs-state) vip-minibuffer-emacs-face)
+                  ((eq state 'vi-state) vip-minibuffer-vi-face)
+                  ((memq state '(insert-state replace-state))
+                   vip-minibuffer-insert-face))))
+  
+  (if (vip-is-in-minibuffer)
+      (vip-set-minibuffer-overlay))
+  )
+
+;; This also takes care of the annoying incomplete lines in files.
+;; Also, this fixed 'undo' to work vi-style for complex commands.
+(defun vip-change-state-to-vi ()
+  "Change Viper state to Vi."
+  (interactive)
+  (if (and vip-first-time (not (vip-is-in-minibuffer)))
+      (viper-mode)
+    (if overwrite-mode (overwrite-mode nil))
+    (if abbrev-mode (expand-abbrev))
+    (if (and auto-fill-function (> (current-column) fill-column))
+        (funcall auto-fill-function))
+    (vip-add-newline-at-eob-if-necessary)
+    (if vip-undo-needs-adjustment  (vip-adjust-undo))
+    (vip-change-state 'vi-state)
+    (if (and vip-automatic-iso-accents (fboundp 'iso-accents-mode))
+        (iso-accents-mode -1)) ; turn off iso accents
+    
+    ;; Protection against user errors in hooks
+    (condition-case conds
+        (run-hooks 'vip-vi-state-hooks)
+      (error
+       (vip-message-conditions conds)))))
+
+(defun vip-change-state-to-insert ()
+  "Change Viper state to Insert."
+  (interactive)
+  (vip-change-state 'insert-state)
+  (if (and vip-automatic-iso-accents (fboundp 'iso-accents-mode))
+      (iso-accents-mode 1)) ; turn iso accents on
+  
+  ;; Protection against user errors in hooks
+  (condition-case conds
+      (run-hooks 'vip-insert-state-hooks)
+    (error
+     (vip-message-conditions conds))))
+     
+(defsubst vip-downgrade-to-insert ()
+ (setq vip-current-state 'insert-state
+       vip-replace-minor-mode nil)
+ )
+
+    
+  
+;; Change to replace state. When the end of replacement region is reached,
+;; replace state changes to insert state.
+(defun vip-change-state-to-replace (&optional non-R-cmd)
+  (vip-change-state 'replace-state)
+  (if (and vip-automatic-iso-accents (fboundp 'iso-accents-mode))
+      (iso-accents-mode 1)) ; turn iso accents on
+  ;; Run insert-state-hook
+  (condition-case conds
+      (run-hooks 'vip-insert-state-hooks 'vip-replace-state-hooks)
+    (error
+     (vip-message-conditions conds)))
+  
+  (if non-R-cmd
+      (vip-start-replace)
+    ;; 'R' is implemented using Emacs's overwrite-mode
+    (vip-start-R-mode))
+  )
+
+    
+(defun vip-change-state-to-emacs ()
+  "Change Viper state to Emacs."
+  (interactive)
+  (vip-change-state 'emacs-state)
+  (if (and vip-automatic-iso-accents (fboundp 'iso-accents-mode))
+      (iso-accents-mode 1)) ; turn iso accents on
+  
+  ;; Protection agains user errors in hooks
+  (condition-case conds
+      (run-hooks 'vip-emacs-state-hooks)
+    (error
+     (vip-message-conditions conds))))
+  
+;; escape to emacs mode termporarily
+(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")
+  (vip-escape-to-state arg events 'emacs-state))
+  
+;; escape to Vi mode termporarily
+(defun vip-escape-to-vi ()
+  "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
+cw, dw,  etc. But it does work with some 2-character commands,
+like dd or dr."
+  (interactive)
+  (vip-escape-to-state nil nil 'vi-state))  
+  
+;; Escape to STATE mode for one Emacs command.
+(defun vip-escape-to-state (arg events state)
+  (let (com key prefix-arg)
+    ;; 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
+          (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.
+                ;; 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
+          ;; otherwise, if we switch buffers in the escaped command,
+          ;; Viper's mode vars will remain those of `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 (event-to-character last-command-event))
+            ;; Emacs represents them as sequences (str or vec)
+            (setq last-command-event (vip-seq-last-elt key)
+                  last-command-char last-command-event))
+            
+          (if (commandp com)
+              (progn
+                (setq prefix-arg arg)
+                (command-execute com)))
+          )
+      (quit (ding))
+      (error (beep 1))))
+  (vip-set-mode-vars-for vip-current-state)) ; set state in new buffer
+      
+(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)
+    (vip-set-mode-vars-for 'emacs-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))
+
+
+  
+;; This is needed because minor modes sometimes override essential Viper
+;; bindings. By letting Viper know which files these modes are in, it will
+;; arrange to reorganize minor-mode-map-alist so that things will work right.
+(defun vip-harness-minor-mode (load-file)
+  "Familiarize Viper with a minor mode defined in LOAD_FILE.
+Minor modes that have their own keymaps may overshadow Viper keymaps.
+This function is designed to make Viper aware of the packages that define
+such minor modes.
+Usage:
+    (vip-harness-minor-mode load-file)
+
+LOAD-FILE is a name of the file where the specific minor mode is defined.
+Suffixes such as .el or .elc should be stripped."
+
+  (interactive "sEnter name of the load file: ")
+  
+  (vip-eval-after-load load-file '(vip-normalize-minor-mode-map-alist))
+  
+  ;; This is a work-around the emacs bug that doesn't let us make
+  ;; minor-mode-map-alist permanent-local.
+  ;; This workaround changes the default for minor-mode-map-alist
+  ;; each time a harnessed minor mode adds its own keymap to the a-list.
+  (vip-eval-after-load load-file '(setq-default minor-mode-map-alist
+                                            minor-mode-map-alist))
+  )
+  
+;; This doesn't work, i.e., doesn't replace vip-harness-minor-mode
+;; function, since autoloaded files don't seem to be loaded with lisp's
+;; `load' function.
+;;(defadvice load (after vip-load-advice activate)
+;;  "Rearrange `minor-mode-map-alist' after loading a file or a library."
+;;  (vip-normalize-minor-mode-map-alist)
+;;  (setq-default minor-mode-map-alist minor-mode-map-alist))
+
+
+
+(defun vip-ESC (arg)
+  "Emulate ESC key in Emacs.
+Prevents multiple escape keystrokes if vip-no-multiple-ESC is true. In that
+case \@ will be bound to ESC. If vip-no-multiple-ESC is 'twice double ESC
+would dings in vi-state. Other ESC sequences are emulated via the current
+Emacs's major mode keymap. This is more convenient on dumb terminals and in
+Emacs -nw, since this won't block functional keys such as up,down,
+etc. Meta key also will work. When vip-no-multiple-ESC is nil, ESC key
+behaves as in Emacs, 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) ))
+          ((and (eq vip-no-multiple-ESC 'twice) 
+                (eq vip-current-state 'vi-state))
+           (setq char (vip-read-char-exclusive))
+           (if (= char (string-to-char vip-ESC-key))
+               (ding)
+             (vip-escape-to-emacs arg (list ?\e char) )))
+          (t (ding)))
+    ))
+
+(defun vip-alternate-ESC (arg)
+  "ESC key without checking for multiple keystrokes."
+  (interactive "P")
+  (vip-escape-to-emacs arg '(?\e)))
+  
+
+;; 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.
+;; But only if there are characters to read during a very short time.
+;; Returns the last event, if any.
+(defun vip-envelop-ESC-key ()
+  (let ((event last-input-event)
+        (keyseq [nil])
+        inhibit-quit)
+    (if (vip-ESC-event-p event)
+        (progn 
+          (if (vip-fast-keysequence-p)
+              (progn
+                (let ((vip-vi-intercept-minor-mode nil)
+                      (vip-insert-intercept-minor-mode nil)
+                      (vip-emacs-intercept-minor-mode nil)
+                      (vip-vi-state-modifier-minor-mode  nil)
+                      (vip-vi-global-user-minor-mode  nil)
+                      (vip-vi-local-user-minor-mode  nil)
+                      (vip-replace-minor-mode nil) ; actually unnecessary
+                      (vip-insert-state-modifier-minor-mode  nil)
+                      (vip-insert-global-user-minor-mode  nil)
+                      (vip-insert-local-user-minor-mode  nil)
+                      (vip-emacs-state-modifier-minor-mode  nil)
+                      (vip-emacs-global-user-minor-mode  nil)
+                      (vip-emacs-local-user-minor-mode  nil)
+                      )
+                  ;; The treatment of XEmacs, below, is temporary, since we
+                  ;; don't know how XEmacs will implement dumb terminals.
+                  ;; Note: the treatment of fast keysequences here is
+                  ;; needed only on dumb terminals in order to be able to
+                  ;; handle function keys correctly.
+                  (if vip-xemacs-p
+                      (setq keyseq (vector event))
+                    (vip-set-unread-command-events event)
+                    (setq keyseq
+                          (funcall
+                           (ad-get-orig-definition 'read-key-sequence) nil))
+                    ))
+                ;; If keyseq translates into something that still has ESC
+                ;; in the beginning, separate ESC from the rest of the seq.
+                ;;
+                ;; This is needed for the following reason:
+                ;; If ESC is the first symbol, we interpret it as if the
+                ;; user typed ESC and then quickly some other symbols.
+                ;; If ESC is not the first one, then the key sequence
+                ;; entered was apparently translated into a function key or
+                ;; something (e.g., one may have
+                ;; (define-key function-key-map "\e[192z" [f11])
+                ;; which would translate the escape-sequence generated by
+                ;; f11 in an xterm window into the symbolic key f11.
+                (if (vip-ESC-event-p (elt keyseq 0))
+                    (progn
+                      ;; put keys following ESC on the unread list
+                      ;; and return ESC as the key-sequence
+                      (vip-set-unread-command-events (subseq keyseq 1))
+                      (setq last-input-event event
+                            keyseq "\e")))
+                ) ; end progn
+                
+            ;; this is escape event with nothing after it
+            ;; put in unread-command-event and then re-read
+            (vip-set-unread-command-events event)
+            (setq keyseq
+                  (funcall (ad-get-orig-definition 'read-key-sequence) nil))
+            ))
+      ;; not an escape event
+      (setq keyseq (vector event)))
+    keyseq))
+
+    
+    
+(defadvice read-key-sequence (around vip-read-key-sequence-ad activate)
+  (let (inhibit-quit event keyseq)
+    (setq keyseq ad-do-it)
+    (setq event (if vip-xemacs-p
+                    (elt keyseq 0) ; XEmacs returns vector of events
+                  (elt (listify-key-sequence keyseq) 0)))
+    (if (vip-ESC-event-p event)
+        (let (unread-command-events unread-command-event)
+          (vip-set-unread-command-events keyseq)
+          (if (vip-fast-keysequence-p)
+              (let ((vip-vi-global-user-minor-mode  nil)
+                    (vip-vi-local-user-minor-mode  nil)
+                    (vip-replace-minor-mode nil) ; actually unnecessary
+                    (vip-insert-global-user-minor-mode  nil)
+                    (vip-insert-local-user-minor-mode  nil))
+                (setq keyseq ad-do-it)) 
+            (setq keyseq ad-do-it))))
+    keyseq))
+    
+(defadvice describe-key (before vip-read-key-sequence-ad protect activate)
+  "Force `describe-key' to read key via `read-key-sequence'."
+  (interactive (list (vip-events-to-keys
+                      (read-key-sequence "Describe key: ")))))
+
+(defadvice describe-key-briefly 
+  (before vip-read-key-sequence-ad protect activate)
+  "Force `describe-key-briefly' to read key via `read-key-sequence'."
+  (interactive (list (vip-events-to-keys
+                      (read-key-sequence "Describe key briefly: ")))))
+
+(defun vip-intercept-ESC-key ()
+  "Listen to ESC key.
+If a sequence of keys starting with ESC is issued with very short delays,
+interpret these keys in Emacs mode, so ESC won't be interpreted as a Vi key."
+  (interactive)
+  (let ((cmd (or (key-binding (vip-envelop-ESC-key)) 
+                 '(lambda () (interactive) (error "")))))
+    
+    ;; call the actual function to execute ESC (if no other symbols followed)
+    ;; or the key bound to the ESC sequence (if the sequence was issued
+    ;; with very short delay between characters.
+    (if (eq cmd 'vip-intercept-ESC-key)
+        (setq cmd
+              (cond ((eq vip-current-state 'vi-state)
+                     'vip-ESC)
+                    ((eq vip-current-state 'insert-state)
+                     'vip-exit-insert-state) 
+                    ((eq vip-current-state 'replace-state)
+                     'vip-replace-state-exit-cmd)
+                    (t 'vip-change-state-to-vi)
+                    )))
+    (call-interactively cmd)))
+           
+
+
+;; prefix argument for Vi mode
+
+;; In Vi mode, prefix argument is a dotted pair (NUM . COM) where NUM
+;; represents the numeric value of the prefix argument and COM represents
+;; command prefix such as "c", "d", "m" and "y".
+
+(defun vip-prefix-arg-value (event com)
+  "Compute numeric prefix arg value. 
+Invoked by CHAR. COM is the command part obtained so far." 
+  (let (value)
+    ;; read while number
+    (while (and (numberp event) (>= event ?0) (<= event ?9))
+      (setq value (+ (* (if (numberp 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)))
+
+(defun vip-prefix-arg-com (char value com)
+  "Vi operator as prefix argument."
+  (let ((cont t))
+    (while (and cont
+                (memq char
+                      (list ?c ?d ?y ?! ?< ?> ?= ?# ?r ?R ?\"
+                            vip-buffer-search-char)))
+      (if com
+          ;; this means that we already have a command character, so we
+          ;; construct a com list and exit while.  however, if char is "
+          ;; it is an error.
+          (progn
+            ;; new com is (CHAR . OLDCOM)
+            (if (memq char '(?# ?\")) (error ""))
+            (setq com (cons char com))
+            (setq cont nil))
+        ;; If com is nil we set com as char, and read more.  Again, if char
+        ;; is ", we read the name of register and store it in vip-use-register.
+        ;; if char is !, =, or #, a complete com is formed so we exit the
+        ;; while loop.
+        (cond ((memq char '(?! ?=))
+               (setq com char)
+               (setq char (read-char))
+               (setq cont nil))
+              ((= char ?#)
+               ;; read a char and encode it as com
+               (setq com (+ 128 (read-char)))
+               (setq char (read-char)))
+              ((= char ?\")
+               (let ((reg (read-char)))
+                 (if (vip-valid-register reg)
+                     (setq vip-use-register reg)
+                   (error ""))
+                 (setq char (read-char))))
+              (t
+               (setq com char)
+               (setq char (vip-read-char-exclusive)))))))
+  (if (atom com)
+      ;; com is a single char, so we construct prefix-arg 
+      ;; and if char is ?, describe prefix arg, otherwise exit by
+      ;; pushing the char back
+      (progn
+        (setq prefix-arg (cons value com))
+        (while (= char ?U)
+          (vip-describe-arg prefix-arg)
+          (setq char (read-char)))
+        (vip-set-unread-command-events 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))
+          (if (= char ?r) (vip-region prefix-arg)
+            (vip-Region prefix-arg))
+          ;; reset prefix-arg
+          (setq prefix-arg nil))
+      ;; otherwise, reset prefix arg and call appropriate command
+      (setq value (if (null value) 1 value))
+      (setq prefix-arg nil)
+      (cond ((equal com '(?c . ?c)) (vip-line (cons value ?C)))
+            ((equal com '(?d . ?d)) (vip-line (cons value ?D)))
+            ((equal com '(?d . ?y)) (vip-yank-defun))
+            ((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 ""))))))
+
+(defun vip-describe-arg (arg)
+  (let (val com)
+    (setq val (vip-P-val arg)
+          com (vip-getcom arg))
+    (if (null val)
+        (if (null com)
+            (message "Value is nil, and command is nil")
+          (message "Value is nil, and command is `%c'" com))
+      (if (null com)
+          (message "Value is `%d', and command is nil" val)
+        (message "Value is `%d', and command is `%c'" val com)))))
+
+(defun vip-digit-argument (arg)
+  "Begin numeric argument for the next command."
+  (interactive "P")
+  (vip-prefix-arg-value 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
+      (vip-prefix-arg-com
+       last-command-char   
+       (cond ((null arg) nil)
+             ((consp arg) (car arg))
+             ((numberp arg) arg)
+             (t (error vip-InvalidCommandArgument)))
+       (cond ((null arg) nil)
+             ((consp arg) (cdr arg))
+             ((numberp arg) nil)
+             (t (error vip-InvalidCommandArgument))))
+    (quit (setq vip-use-register nil)
+          (signal 'quit nil)))
+  (vip-deactivate-mark))
+
+;; Get value part of prefix-argument ARG.
+(defsubst vip-p-val (arg)
+  (cond ((null arg) 1)
+        ((consp arg) (if (null (car arg)) 1 (car arg)))
+        (t arg)))
+
+;; Get raw value part of prefix-argument ARG.
+(defsubst vip-P-val (arg)
+  (cond ((consp arg) (car arg))
+        (t arg)))
+
+;; Get com part of prefix-argument ARG.
+(defsubst vip-getcom (arg)
+  (cond ((null arg) nil)
+        ((consp arg) (cdr arg))
+        (t nil)))
+
+;; Get com part of prefix-argument ARG and modify it.
+(defun vip-getCom (arg)
+  (let ((com (vip-getcom arg)))
+    (cond ((equal com ?c) ?C)
+          ((equal com ?d) ?D)
+          ((equal com ?y) ?Y)
+          (t com))))
+
+
+;; repeat last destructive command
+
+;; Append region to text in register REG.
+;; START and END are buffer positions indicating what to append.
+(defsubst vip-append-to-register (reg start end)
+  (set-register reg (concat (or (get-register reg) "")
+                            (buffer-substring start end))))
+                            
+;; define functions to be executed
+
+;; invoked by C command
+(defun vip-exec-change (m-com com) 
+  ;; handle C cmd at the eol and at eob.
+  (if (or (and (eolp) (= vip-com-point (point)))
+          (= vip-com-point (point-max)))
+      (progn
+        (insert " ")(backward-char 1)))
+  (if (= vip-com-point (point))
+      (vip-forward-char-carefully))
+  (if (= com ?c)
+      (vip-change vip-com-point (point))
+    (vip-change-subr vip-com-point (point))))
+
+;; this is invoked by vip-substitute-line
+(defun vip-exec-Change (m-com com)
+  (save-excursion
+    (set-mark vip-com-point)
+    (vip-enlarge-region (mark t) (point))
+    (if vip-use-register
+        (progn
+          (cond ((vip-valid-register vip-use-register '(letter digit))
+                 ;;(vip-valid-register vip-use-register '(letter)
+                 (copy-to-register
+                  vip-use-register (mark t) (point) nil))
+                ((vip-valid-register vip-use-register '(Letter))
+                 (vip-append-to-register
+                  (downcase vip-use-register) (mark t) (point)))
+                (t (setq vip-use-register nil)
+                   (error vip-InvalidRegister vip-use-register)))
+          (setq vip-use-register nil)))
+    (delete-region (mark t) (point)))
+  (open-line 1)
+  (if (= com ?C) (vip-change-mode-to-insert) (vip-yank-last-insertion)))
+
+(defun vip-exec-delete (m-com com)
+  (if vip-use-register
+      (progn
+        (cond ((vip-valid-register vip-use-register '(letter digit))
+               ;;(vip-valid-register vip-use-register '(letter))
+               (copy-to-register
+                vip-use-register vip-com-point (point) nil))
+              ((vip-valid-register vip-use-register '(Letter))
+               (vip-append-to-register
+                (downcase vip-use-register) vip-com-point (point)))
+              (t (setq vip-use-register nil)
+                 (error vip-InvalidRegister vip-use-register)))
+        (setq vip-use-register nil)))
+  (setq last-command
+        (if (eq last-command 'd-command) 'kill-region nil))
+  (kill-region vip-com-point (point))
+  (setq this-command 'd-command)
+  (if vip-ex-style-motion
+      (if (and (eolp) (not (bolp))) (backward-char 1))))
+
+(defun vip-exec-Delete (m-com com)
+  (save-excursion
+    (set-mark vip-com-point)
+    (vip-enlarge-region (mark t) (point))
+    (if vip-use-register
+        (progn
+          (cond ((vip-valid-register vip-use-register '(letter digit))
+                 ;;(vip-valid-register vip-use-register '(letter))
+                 (copy-to-register
+                  vip-use-register (mark t) (point) nil))
+                ((vip-valid-register vip-use-register '(Letter))
+                 (vip-append-to-register
+                  (downcase vip-use-register) (mark t) (point)))
+                (t (setq vip-use-register nil)
+                   (error vip-InvalidRegister vip-use-register)))
+          (setq vip-use-register nil)))
+    (setq last-command
+          (if (eq last-command 'D-command) 'kill-region nil))
+    (kill-region (mark t) (point))
+    (if (eq m-com 'vip-line) (setq this-command 'D-command)))
+  (back-to-indentation))
+
+(defun vip-exec-yank (m-com com)
+  (if vip-use-register
+      (progn
+        (cond ((vip-valid-register vip-use-register '(letter digit))
+               ;; (vip-valid-register vip-use-register '(letter))
+               (copy-to-register
+                vip-use-register vip-com-point (point) nil))
+              ((vip-valid-register vip-use-register '(Letter))
+               (vip-append-to-register
+                (downcase vip-use-register) vip-com-point (point)))
+              (t (setq vip-use-register nil)
+                 (error vip-InvalidRegister vip-use-register)))
+        (setq vip-use-register nil)))
+  (setq last-command nil)
+  (copy-region-as-kill vip-com-point (point))
+  (goto-char vip-com-point))
+
+(defun vip-exec-Yank (m-com com)
+  (save-excursion
+    (set-mark vip-com-point)
+    (vip-enlarge-region (mark t) (point))
+    (if vip-use-register
+        (progn
+          (cond ((vip-valid-register vip-use-register '(letter digit))
+                 ;;(vip-valid-register vip-use-register '(letter))
+                 (copy-to-register
+                  vip-use-register (mark t) (point) nil))
+                ((vip-valid-register vip-use-register '(Letter))
+                 (vip-append-to-register
+                  (downcase vip-use-register) (mark t) (point)))
+                (t (setq vip-use-register nil)
+                   (error vip-InvalidRegister  vip-use-register)))
+          (setq vip-use-register nil)))
+    (setq last-command nil)
+    (copy-region-as-kill (mark t) (point)))
+  (goto-char vip-com-point))
+
+(defun vip-exec-bang (m-com com)
+  (save-excursion
+    (set-mark vip-com-point)
+    (vip-enlarge-region (mark t) (point))
+    (shell-command-on-region
+     (mark t) (point)
+     (if (= com ?!)
+         (setq vip-last-shell-com
+               (vip-read-string-with-history 
+                "!"
+                nil
+                'vip-shell-history
+                (car vip-shell-history)
+                ))
+       vip-last-shell-com)
+     t)))
+
+(defun vip-exec-equals (m-com com)
+  (save-excursion
+    (set-mark vip-com-point)
+    (vip-enlarge-region (mark t) (point))
+    (if (> (mark t) (point)) (exchange-point-and-mark))
+    (indent-region (mark t) (point) nil)))
+
+(defun vip-exec-shift (m-com com)
+  (save-excursion
+    (set-mark vip-com-point)
+    (vip-enlarge-region (mark t) (point))
+    (if (> (mark t) (point)) (exchange-point-and-mark))
+    (indent-rigidly (mark t) (point) 
+                    (if (= com ?>)
+                        vip-shift-width
+                      (- vip-shift-width)))))
+
+;; this is needed because some commands fake com by setting it to ?r, which
+;; denotes repeated insert command.
+(defsubst vip-exec-dummy (m-com com)
+  nil)
+
+(defun vip-exec-buffer-search (m-com com)
+  (setq vip-s-string (buffer-substring (point) vip-com-point))
+  (setq vip-s-forward t)
+  (setq vip-search-history (cons vip-s-string vip-search-history))
+  (vip-search vip-s-string vip-s-forward 1))
+
+(defvar vip-exec-array (make-vector 128 nil))
+
+;; Using a dispatch array allows adding functions like buffer search
+;; without affecting other functions. Buffer search can now be bound
+;; to any character.
+
+(aset vip-exec-array ?c 'vip-exec-change)
+(aset vip-exec-array ?C 'vip-exec-Change)
+(aset vip-exec-array ?d 'vip-exec-delete)
+(aset vip-exec-array ?D 'vip-exec-Delete)
+(aset vip-exec-array ?y 'vip-exec-yank)
+(aset vip-exec-array ?Y 'vip-exec-Yank)
+(aset vip-exec-array ?r 'vip-exec-dummy)
+(aset vip-exec-array ?! 'vip-exec-bang)
+(aset vip-exec-array ?< 'vip-exec-shift)
+(aset vip-exec-array ?> 'vip-exec-shift)
+(aset vip-exec-array ?= 'vip-exec-equals)
+
+
+
+;; This function is called by various movement commands to execute a
+;; destructive command on the region specified by the movement command. For
+;; instance, if the user types cw, then the command vip-forward-word will
+;; call vip-execute-com to execute vip-exec-change, which eventually will
+;; call vip-change to invoke the replace mode on the region.
+;;
+;; The list (M-COM VAL COM REG INSETED-TEXT COMMAND-KEYS) is set to
+;; vip-d-com for later use by vip-repeat.
+(defun vip-execute-com (m-com val com)
+  (let ((reg vip-use-register))
+    ;; this is the special command `#'
+    (if (> com 128)
+        (vip-special-prefix-com (- com 128))
+      (let ((fn (aref vip-exec-array (if (< com 0) (- com) com))))
+        (if (null fn)
+            (error "%c: %s" com vip-InvalidViCommand)
+          (funcall fn m-com com))))
+    (if (vip-dotable-command-p com)
+        (vip-set-destructive-command
+         (list m-com val
+               (if (memq com (list ?c ?C ?!)) (- com) com)
+               reg nil nil)))
+    ))
+
+
+(defun vip-repeat (arg)
+  "Re-execute last destructive command.
+Use the info in vip-d-com, which has the form
+\(com val ch reg inserted-text command-keys\),
+where `com' is the command to be re-executed, `val' is the
+argument to `com', `ch' is a flag for repeat, and `reg' is optional;
+if it exists, it is the name of the register for `com'.
+If the prefix argument, ARG, is non-nil, it is used instead of `val'."
+  (interactive "P")
+  (let ((save-point (point)) ; save point before repeating prev cmd
+        ;; Pass along that we are repeating a destructive command
+        ;; This tells vip-set-destructive-command not to update
+        ;; vip-command-ring
+        (vip-intermediate-command 'vip-repeat))
+    (if (eq last-command 'vip-undo)
+        ;; if the last command was vip-undo, then undo-more
+        (vip-undo-more)
+      ;; otherwise execute the command stored in vip-d-com.  if arg is non-nil
+      ;; its prefix value is used as new prefix value for the command.
+      (let ((m-com (car vip-d-com))
+            (val (vip-P-val arg))
+            (com (nth 2 vip-d-com))
+            (reg (nth 3 vip-d-com)))
+        (if (null val) (setq val (nth 1 vip-d-com)))
+        (if (null m-com) (error "No previous command to repeat."))
+        (setq vip-use-register reg)
+        (if (nth 4 vip-d-com) ; text inserted by command
+            (setq vip-last-insertion (nth 4 vip-d-com)
+                  vip-d-char (nth 4 vip-d-com)))
+        (funcall m-com (cons val com))
+        (if (and vip-keep-point-on-repeat (< save-point (point)))
+            (goto-char save-point)) ; go back to before repeat.
+        (if (and (eolp) (not (bolp)))
+            (backward-char 1))
+     ))
+  (if vip-undo-needs-adjustment (vip-adjust-undo)) ; take care of undo
+  ;; If the prev cmd was rotating the command ring, this means that `.' has
+  ;; just executed a command from that ring. So, push it on the ring again.
+  ;; If we are just executing previous command , then don't push vip-d-com
+  ;; because vip-d-com is not fully constructed in this case (its keys and
+  ;; the inserted text may be nil). Besides, in this case, the command
+  ;; executed by `.' is already on the ring.
+  (if (eq last-command 'vip-display-current-destructive-command)
+      (vip-push-onto-ring vip-d-com 'vip-command-ring))
+  (vip-deactivate-mark)
+  ))
+  
+(defun vip-repeat-from-history ()
+  "Repeat a destructive command from history.
+Doesn't change vip-command-ring in any way, so `.' will work as before
+executing this command.
+This command is supposed to be bound to a two-character Vi macro where
+the second character is a digit 0 to 9. The digit indicates which
+history command to execute. `<char>0' is equivalent to `.', `<char>1'
+invokes the command before that, etc."
+  (interactive)
+  (let* ((vip-intermediate-command 'repeating-display-destructive-command)
+         (idx (cond (vip-this-kbd-macro
+                      (string-to-number
+                       (symbol-name (elt vip-this-kbd-macro 1))))
+                    (t 0)))
+         (num idx)
+         (vip-d-com vip-d-com))
+
+    (or (and (numberp num) (<= 0 num) (<= num 9))
+        (setq idx 0
+              num 0)
+        (message
+         "`vip-repeat-from-history' must be invoked as a Vi macro bound to `<key><digit>'"))
+    (while (< 0 num)
+      (setq vip-d-com (vip-special-ring-rotate1 vip-command-ring -1))
+      (setq num (1- num)))
+    (vip-repeat nil)
+    (while (> idx num)
+      (vip-special-ring-rotate1 vip-command-ring 1)
+      (setq num (1+ num)))
+    ))
+      
+
+(defun vip-special-prefix-com (char)
+  "This command is invoked interactively by the key sequence #<char>."
+  (cond ((= char ?c)
+         (downcase-region (min vip-com-point (point))
+                          (max vip-com-point (point))))
+        ((= char ?C)
+         (upcase-region (min vip-com-point (point))
+                        (max vip-com-point (point))))
+        ((= char ?g)
+         (push-mark vip-com-point t)
+         (vip-global-execute))
+        ((= char ?q)
+         (push-mark vip-com-point t)
+         (vip-quote-region))
+        ((= char ?s) (funcall vip-spell-function vip-com-point (point)))
+        (t (error "#%c: %s" char vip-InvalidViCommand))))
+
+
+;; undoing
+
+(defun vip-undo ()
+  "Undo previous change."
+  (interactive)
+  (message "undo!")
+  (let ((modified (buffer-modified-p))
+        (before-undo-pt (point-marker))
+        (after-change-functions after-change-functions)
+        undo-beg-posn undo-end-posn)
+        
+    ;; no need to remove this hook, since this var has scope inside a let.
+    (add-hook 'after-change-functions
+              '(lambda (beg end len)
+                 (setq undo-beg-posn beg
+                       undo-end-posn (or end beg))))
+  
+    (undo-start)
+    (undo-more 2)
+    (setq undo-beg-posn (or undo-beg-posn before-undo-pt)
+          undo-end-posn (or undo-end-posn undo-beg-posn))
+    
+    (goto-char undo-beg-posn)
+    (sit-for 0)
+    (if (and vip-keep-point-on-undo
+             (pos-visible-in-window-p before-undo-pt))
+        (progn
+          (push-mark (point-marker) t) 
+          (vip-sit-for-short 300)
+          (goto-char undo-end-posn)
+          (vip-sit-for-short 300)
+          (if (and (> (abs (- undo-beg-posn before-undo-pt)) 1)
+                  (> (abs (- undo-end-posn before-undo-pt)) 1))
+              (goto-char before-undo-pt)
+            (goto-char undo-beg-posn)))
+      (push-mark before-undo-pt t))
+    (if (and (eolp) (not (bolp))) (backward-char 1))
+    (if (not modified) (set-buffer-modified-p t)))
+  (setq this-command 'vip-undo))
+
+(defun vip-undo-more ()
+  "Continue undoing previous changes."
+  (message "undo more!")
+  (condition-case nil
+      (undo-more 1)
+    (error (beep)
+           (message "No further undo information in this buffer")))
+  (if (and (eolp) (not (bolp))) (backward-char 1))
+  (setq this-command 'vip-undo))
+
+;; The following two functions are used to set up undo properly.
+;; In VI, unlike Emacs, if you open a line, say, and add a bunch of lines,
+;; they are undone all at once.  
+(defun vip-adjust-undo ()
+  (let ((inhibit-quit t)
+        tmp tmp2)
+    (setq vip-undo-needs-adjustment nil)
+    (if (listp buffer-undo-list)
+        (if (setq tmp (memq vip-buffer-undo-list-mark buffer-undo-list))
+            (progn
+              (setq tmp2 (cdr tmp)) ; the part after mark
+              
+              ;; cut tail from buffer-undo-list temporarily by direct
+              ;; manipulation with pointers in buffer-undo-list
+              (setcdr tmp nil)
+              
+              (setq buffer-undo-list (delq nil buffer-undo-list))
+              (setq buffer-undo-list
+                    (delq vip-buffer-undo-list-mark buffer-undo-list))
+              ;; restore tail of buffer-undo-list
+              (setq buffer-undo-list (nconc buffer-undo-list tmp2)))
+          (setq buffer-undo-list (delq nil buffer-undo-list))))))
+  
+
+(defun vip-set-complex-command-for-undo ()  
+  (if (listp buffer-undo-list)
+      (if (not vip-undo-needs-adjustment)
+          (let ((inhibit-quit t))
+            (setq buffer-undo-list 
+                  (cons vip-buffer-undo-list-mark buffer-undo-list))
+            (setq vip-undo-needs-adjustment t)))))
+
+
+
+      
+(defun vip-display-current-destructive-command ()
+  (let ((text (nth 4 vip-d-com))
+        (keys (nth 5 vip-d-com))
+        (max-text-len 30))
+    
+    (setq this-command 'vip-display-current-destructive-command)
+        
+    (message " `.' runs  %s%s"
+             (concat "`" (vip-array-to-string keys) "'")
+             (vip-abbreviate-string text max-text-len
+                                    "  inserting  `" "'" "    ......."))
+    ))
+    
+    
+;; don't change vip-d-com if it was vip-repeat command invoked with `.'
+;; or in some other way (non-interactively).
+(defun vip-set-destructive-command (list)
+  (or (eq vip-intermediate-command 'vip-repeat)
+      (progn
+        (setq vip-d-com list)
+        (setcar (nthcdr 5 vip-d-com)
+                (vip-array-to-string (this-command-keys)))
+        (vip-push-onto-ring vip-d-com 'vip-command-ring))))
+    
+(defun vip-prev-destructive-command (next)
+  "Find previous destructive command in the history of destructive commands.
+With prefix argument, find next destructive command."
+  (interactive "P")
+  (let (cmd vip-intermediate-command)
+    (if (eq last-command 'vip-display-current-destructive-command)
+        ;; repeated search through command history
+        (setq vip-intermediate-command 'repeating-display-destructive-command)
+      ;; first search through command history--set temp ring
+      (setq vip-temp-command-ring (copy-list vip-command-ring))) 
+    (setq cmd (if next
+                  (vip-special-ring-rotate1 vip-temp-command-ring 1)
+                (vip-special-ring-rotate1 vip-temp-command-ring -1)))
+    (if (null cmd)
+        ()
+      (setq vip-d-com cmd))
+    (vip-display-current-destructive-command)))
+      
+(defun vip-next-destructive-command ()
+  "Find next destructive command in the history of destructive commands."
+  (interactive)
+  (vip-prev-destructive-command 'next))
+  
+(defun vip-insert-prev-from-insertion-ring (arg)
+  "Cycles through insertion ring in the direction of older insertions.
+Undoes previous insertion and inserts new.
+With prefix argument, cycles in the direction of newer elements.
+In minibuffer, this command executes whatever the invocation key is bound
+to in the global map, instead of cycling through the insertion ring."
+  (interactive "P")
+  (let (vip-intermediate-command)
+    (if (eq last-command 'vip-insert-from-insertion-ring)
+        (progn  ; repeated search through insertion history
+          (setq vip-intermediate-command 'repeating-insertion-from-ring)
+          (if (eq vip-current-state 'replace-state)
+              (undo 1)
+            (if vip-last-inserted-string-from-insertion-ring
+                (backward-delete-char
+                 (length vip-last-inserted-string-from-insertion-ring))))
+          )
+      ;;first search through insertion history
+      (setq vip-temp-insertion-ring (copy-list vip-insertion-ring)))
+    (setq this-command 'vip-insert-from-insertion-ring)
+    ;; so that things will be undone properly
+    (setq buffer-undo-list (cons nil buffer-undo-list))
+    (setq vip-last-inserted-string-from-insertion-ring
+          (vip-special-ring-rotate1 vip-temp-insertion-ring (if arg 1 -1)))
+    
+    ;; this change of vip-intermediate-command must come after
+    ;; vip-special-ring-rotate1, so that the ring will rotate, but before the
+    ;; insertion.
+    (setq vip-intermediate-command nil)
+    (if vip-last-inserted-string-from-insertion-ring
+        (insert vip-last-inserted-string-from-insertion-ring))
+    ))
+
+(defun vip-insert-next-from-insertion-ring ()
+  "Cycles through insertion ring in the direction of older insertions. Undoes previous insertion and inserts new."
+  (interactive)
+  (vip-insert-prev-from-insertion-ring 'next))
+    
+
+;; some region utilities
+
+(defun vip-add-newline-at-eob-if-necessary ()
+  "If at the last line of buffer, add \\n before eob, if newline is missing."
+  (save-excursion
+      (end-of-line)
+      ;; make sure all lines end with newline, unless in the minibuffer or
+      ;; when requested otherwise (vip-add-newline-at-eob is nil)
+      (if (and
+           (eobp)
+           (not (bolp))
+           vip-add-newline-at-eob
+           (not (vip-is-in-minibuffer)))
+          (insert "\n"))))
+
+(defun vip-yank-defun ()
+  (mark-defun)
+  (copy-region-as-kill (point) (mark t)))
+
+(defun vip-enlarge-region (beg end)
+  "Enlarge region between BEG and END."
+  (or beg (setq beg end)) ; if beg is nil, set to end
+  (or end (setq end beg)) ; if end is nil, set to beg
+  
+  (if (< beg end)
+      (progn (goto-char beg) (set-mark end))
+    (goto-char end)
+    (set-mark beg))
+  (beginning-of-line)
+  (exchange-point-and-mark)
+  (if (or (not (eobp)) (not (bolp))) (forward-line 1))
+  (if (not (eobp)) (beginning-of-line))
+  (if (> beg end) (exchange-point-and-mark)))
+
+
+(defun vip-quote-region ()
+  "Quote region by each line with a user supplied string."
+  (setq vip-quote-string
+        (vip-read-string-with-history
+         "Quote string: "
+         nil
+         'vip-quote-region-history
+         vip-quote-string))
+  (vip-enlarge-region (point) (mark t))
+  (if (> (point) (mark t)) (exchange-point-and-mark))
+  (insert vip-quote-string)
+  (beginning-of-line)
+  (forward-line 1)
+  (while (and (< (point) (mark t)) (bolp))
+    (insert vip-quote-string)
+    (beginning-of-line)
+    (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))
+     (cond ((and beg end)
+            ;; This 'if' is needed because Emacs treats the next empty line
+            ;; as part of the previous line.
+            (if (or (> beg (point-max)) (> end (point-max))) ; out of range
+                ()
+              (if (and (> end beg) (= (vip-line-pos 'start) end))
+                  (setq end (min (1+ end) (point-max))))
+              (if (and (> beg end) (= (vip-line-pos 'start) beg))
+                  (setq beg (min (1+ beg) (point-max))))
+              (<= (count-lines beg end) 1) ))
+           
+           (t nil))
+         ))
+         
+         
+;; 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)))
+
+(defun vip-tmp-insert-at-eob (msg)
+  (let ((savemax (point-max)))
+      (goto-char savemax)
+      (insert msg)
+      (sit-for 2)
+      (goto-char savemax) (delete-region (point) (point-max))
+      ))  
+      
+
+
+;;; Minibuffer business
+            
+(defsubst vip-set-minibuffer-style ()
+  (add-hook 'minibuffer-setup-hook 'vip-minibuffer-setup-sentinel))
+  
+  
+(defun vip-minibuffer-setup-sentinel ()
+  (let ((hook (if vip-vi-style-in-minibuffer
+                  'vip-change-state-to-insert
+                'vip-change-state-to-emacs)))
+    (funcall hook)
+
+    ;; Make sure the minibufer overlay is kept up-to-date. In XEmacs also
+    ;; guards against the possibility of detaching this overlay.
+    (add-hook 'vip-post-command-hooks 'vip-move-minibuffer-overlay)
+    ))
+  
+;; Interpret last event in the local map
+(defun vip-exit-minibuffer ()
+  (interactive)
+  (let (command)
+    (setq command (local-key-binding (char-to-string last-command-char)))
+    (if command
+        (command-execute command)
+      (exit-minibuffer))))
+  
+
+(defun vip-set-search-face ()
+  (if (not window-system)
+      ()
+    (defvar vip-search-face
+      (progn
+        (make-face 'vip-search-face)
+        (or (face-differs-from-default-p 'vip-search-face)
+            ;; 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)))
+        'vip-search-face)
+        "*Face used to flash out the search pattern.")
+    ))
+  
+  
+(defun vip-set-minibuffer-faces ()
+  (if (not window-system)
+      ()
+    (defvar vip-minibuffer-emacs-face
+      (progn
+        (make-face 'vip-minibuffer-emacs-face)
+        (or (face-differs-from-default-p 'vip-minibuffer-emacs-face)
+            ;; face wasn't set in .vip or .Xdefaults
+            (if vip-vi-style-in-minibuffer
+                ;; emacs state is an exception in the minibuffer
+                (if (vip-can-use-colors "darkseagreen2" "Black")
+                    (progn
+                      (set-face-background
+                       'vip-minibuffer-emacs-face "darkseagreen2")
+                      (set-face-foreground
+                       'vip-minibuffer-emacs-face "Black"))
+                  (copy-face 'highlight 'vip-minibuffer-emacs-face))
+              ;; emacs state is the main state in the minibuffer
+              (if (vip-can-use-colors "Black" "pink")
+                  (progn
+                    (set-face-background 'vip-minibuffer-emacs-face "pink") 
+                    (set-face-foreground
+                     'vip-minibuffer-emacs-face "Black"))
+                (copy-face 'italic 'vip-minibuffer-emacs-face))
+              ))
+        'vip-minibuffer-emacs-face)
+      "Face used in the Minibuffer when it is in Emacs state.")
+    
+    (defvar vip-minibuffer-insert-face
+      (progn
+        (make-face 'vip-minibuffer-insert-face)
+        (or (face-differs-from-default-p 'vip-minibuffer-insert-face)
+            (if vip-vi-style-in-minibuffer
+                (if (vip-can-use-colors "Black" "pink")
+                    (progn
+                      (set-face-background 'vip-minibuffer-insert-face "pink") 
+                      (set-face-foreground
+                       'vip-minibuffer-insert-face "Black"))
+                  (copy-face 'italic 'vip-minibuffer-insert-face))
+              ;; If Insert state is an exception
+              (if (vip-can-use-colors "darkseagreen2" "Black")
+                  (progn
+                    (set-face-background
+                     'vip-minibuffer-insert-face "darkseagreen2")
+                    (set-face-foreground
+                     'vip-minibuffer-insert-face "Black"))
+                (copy-face 'highlight 'vip-minibuffer-insert-face))
+              (vip-italicize-face 'vip-minibuffer-insert-face)))
+        'vip-minibuffer-insert-face)
+      "Face used in the Minibuffer when it is in Insert state.")
+    
+    (defvar vip-minibuffer-vi-face
+      (progn
+        (make-face 'vip-minibuffer-vi-face)
+        (or (face-differs-from-default-p 'vip-minibuffer-vi-face)
+            (if vip-vi-style-in-minibuffer
+                (if (vip-can-use-colors "Black" "grey")
+                    (progn
+                      (set-face-background 'vip-minibuffer-vi-face "grey")
+                      (set-face-foreground 'vip-minibuffer-vi-face "Black"))
+                  (copy-face 'bold 'vip-minibuffer-vi-face))
+              (copy-face 'bold 'vip-minibuffer-vi-face)
+              (invert-face 'vip-minibuffer-vi-face)))
+        'vip-minibuffer-vi-face)
+      "Face used in the Minibuffer when it is in Vi state.")
+    
+    ;; the current face used in the minibuffer
+    (vip-deflocalvar vip-minibuffer-current-face vip-minibuffer-emacs-face "")
+    ))
+    
+  
+
+;;; Reading string with history  
+    
+(defun vip-read-string-with-history (prompt &optional initial 
+                                            history-var default keymap)
+  ;; Reads string, prompting with PROMPT and inserting the INITIAL
+  ;; value. Uses HISTORY-VAR. DEFAULT is the default value to accept if the
+  ;; input is an empty string. Uses KEYMAP, if given, or the
+  ;; minibuffer-local-map.
+  ;; Default value is displayed until the user types something in the
+  ;; minibuffer. 
+  (let ((minibuffer-setup-hook 
+         '(lambda ()
+            (if (stringp initial)
+                (progn
+                  (sit-for 840)
+                  (erase-buffer)
+                  (insert initial)))
+            (vip-minibuffer-setup-sentinel)))
+        (val "")
+        (padding "")
+        temp-msg)
+    
+    (setq keymap (or keymap minibuffer-local-map)
+          initial (or initial "")
+          temp-msg (if default
+                       (format "(default: %s) " default)
+                     ""))
+                   
+    (setq vip-incomplete-ex-cmd nil)
+    (setq val (read-from-minibuffer prompt 
+                                    (concat temp-msg initial val padding)
+                                    keymap nil history-var))
+    (setq minibuffer-setup-hook nil
+          padding (vip-array-to-string (this-command-keys))
+          temp-msg "")
+    ;; the following overcomes a glaring bug in history handling
+    ;; in XEmacs 19.11
+    (if (not (string= val (car (eval history-var))))
+        (set history-var (cons val (eval history-var))))
+    (if (or (string= (nth 0 (eval history-var)) (nth 1 (eval history-var)))
+            (string= (nth 0 (eval history-var)) ""))
+        (set history-var (cdr (eval history-var))))
+    (if (string= val "")
+        (or default "")
+      val)))
+  
+
+
+;; insertion commands
+
+;; Called when state changes from Insert Vi command mode.
+;; Repeats the insertion command if Insert state was entered with prefix
+;; argument > 1.
+(defun vip-repeat-insert-command ()
+  (let ((i-com (car vip-d-com))
+        (val   (nth 1 vip-d-com))
+        (char  (nth 2 vip-d-com)))
+    (if (and val (> val 1)) ; first check that val is non-nil
+        (progn        
+          (setq vip-d-com (list i-com (1- val) ?r nil nil nil))
+          (vip-repeat nil)
+          (setq vip-d-com (list i-com val char nil nil nil))
+          ))))
+
+(defun vip-insert (arg)
+  "Insert before point."
+  (interactive "P")
+  (vip-set-complex-command-for-undo)
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (vip-set-destructive-command (list 'vip-insert val ?r nil nil nil))
+    (if com
+        (vip-loop val (vip-yank-last-insertion))
+      (vip-change-state-to-insert))))
+
+(defun vip-append (arg)
+  "Append after point."
+  (interactive "P")
+  (vip-set-complex-command-for-undo)
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (vip-set-destructive-command (list 'vip-append val ?r nil nil nil))
+    (if (not (eolp)) (forward-char))
+    (if (equal com ?r)
+        (vip-loop val (vip-yank-last-insertion))
+      (vip-change-state-to-insert))))
+
+(defun vip-Append (arg)
+  "Append at end of line."
+  (interactive "P")
+  (vip-set-complex-command-for-undo)
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (vip-set-destructive-command (list 'vip-Append val ?r nil nil nil))
+    (end-of-line)
+    (if (equal com ?r)
+        (vip-loop val (vip-yank-last-insertion))
+      (vip-change-state-to-insert))))
+
+(defun vip-Insert (arg)
+  "Insert before first non-white."
+  (interactive "P")
+  (vip-set-complex-command-for-undo)
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (vip-set-destructive-command (list 'vip-Insert val ?r nil nil nil))
+    (back-to-indentation)
+    (if (equal com ?r)
+        (vip-loop val (vip-yank-last-insertion))
+      (vip-change-state-to-insert))))
+
+(defun vip-open-line (arg)
+  "Open line below."
+  (interactive "P")
+  (vip-set-complex-command-for-undo)
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (vip-set-destructive-command (list 'vip-open-line val ?r nil nil nil))
+    (let ((col (current-indentation)))
+      (if (equal com ?r)
+          (vip-loop val
+                    (progn
+                      (end-of-line)
+                      (newline 1)
+                      (if vip-auto-indent 
+                          (progn (setq vip-cted t) (indent-to col)))
+                      (vip-yank-last-insertion)))
+        (end-of-line)
+        (newline 1)
+        (if vip-auto-indent (progn (setq vip-cted t) (indent-to col)))
+        (vip-change-state-to-insert)
+        ))))
+
+(defun vip-Open-line (arg)
+  "Open line above."
+  (interactive "P")
+  (vip-set-complex-command-for-undo)
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (vip-set-destructive-command (list 'vip-Open-line val ?r nil nil nil))
+    (let ((col (current-indentation)))
+      (if (equal com ?r)
+          (vip-loop val
+                    (progn
+                      (beginning-of-line)
+                      (open-line 1)
+                      (if vip-auto-indent 
+                          (progn (setq vip-cted t) (indent-to col)))
+                      (vip-yank-last-insertion)))
+        (beginning-of-line)
+        (open-line 1)
+        (if vip-auto-indent (progn (setq vip-cted t) (indent-to col)))
+        (vip-change-state-to-insert)))))
+
+(defun vip-open-line-at-point (arg)
+  "Open line at point."
+  (interactive "P")
+  (vip-set-complex-command-for-undo)
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (vip-set-destructive-command
+     (list 'vip-open-line-at-point val ?r nil nil nil))
+    (if (equal com ?r)
+        (vip-loop val
+                  (progn
+                    (open-line 1)
+                    (vip-yank-last-insertion)))
+      (open-line 1)
+      (vip-change-state-to-insert))))
+
+(defun vip-substitute (arg)
+  "Substitute characters."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (push-mark nil t)
+    (forward-char val)
+    (if (equal com ?r)
+        (vip-change-subr (mark t) (point))
+      (vip-change (mark t) (point)))
+    (vip-set-destructive-command (list 'vip-substitute val ?r nil nil nil))
+    ))
+
+(defun vip-substitute-line (arg)
+  "Substitute lines."
+  (interactive "p")
+  (vip-set-complex-command-for-undo)
+  (vip-line (cons arg ?C)))
+
+;; Prepare for replace
+(defun vip-start-replace ()
+  (setq vip-began-as-replace t
+        vip-sitting-in-replace t
+        vip-replace-chars-to-delete 0
+        vip-replace-chars-deleted 0)
+  (add-hook 'vip-after-change-functions 'vip-replace-mode-spy-after t)
+  (add-hook 'vip-before-change-functions 'vip-replace-mode-spy-before t)
+  ;; this will get added repeatedly, but no harm
+  (add-hook 'after-change-functions 'vip-after-change-sentinel t)
+  (add-hook 'before-change-functions 'vip-before-change-sentinel t)
+  (vip-move-marker-locally 'vip-last-posn-in-replace-region
+                           (vip-replace-start))
+  (add-hook 'vip-post-command-hooks 'vip-replace-state-post-command-sentinel t)
+  (add-hook 'vip-pre-command-hooks 'vip-replace-state-pre-command-sentinel t)
+  )
+  
+;; Runs vip-after-change-functions inside after-change-functions
+(defun vip-after-change-sentinel (beg end len)
+  (let ((list vip-after-change-functions))
+    (while list
+      (funcall (car list) beg end len)
+      (setq list (cdr list)))))
+      
+;; Runs vip-before-change-functions inside before-change-functions
+(defun vip-before-change-sentinel (beg end)
+  (let ((list vip-before-change-functions))
+    (while list
+      (funcall (car list) beg end)
+      (setq list (cdr list)))))
+
+(defun vip-post-command-sentinel ()
+  (run-hooks 'vip-post-command-hooks))
+  
+(defun vip-pre-command-sentinel ()
+  (run-hooks 'vip-pre-command-hooks))
+  
+;; Needed so that Viper will be able to figure the last inserted
+;; chunk of text with reasonable accuracy.
+(defun 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 (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))
+  )
+  
+(defun vip-insert-state-pre-command-sentinel ()
+  (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))))
+        
+(defun vip-R-state-post-command-sentinel ()
+  ;; This is needed despite vip-replace-state-pre-command-sentinel
+  ;; When you jump to another buffer in another frame, the pre-command
+  ;; hook won't change cursor color to default in that other frame.
+  ;; So, if the second frame cursor was red and we set the point
+  ;; outside the replacement region, then the cursor color woll remain
+  ;; red. Restoring the default, below, prevents this.
+  (vip-restore-cursor-color)
+  (if (and (<= (vip-replace-start) (point))
+               (<=  (point) (vip-replace-end)))
+      (vip-change-cursor-color vip-replace-overlay-cursor-color)))
+
+(defun vip-replace-state-pre-command-sentinel ()
+  (vip-restore-cursor-color))
+  
+(defun vip-replace-state-post-command-sentinel ()
+  ;; This is needed despite vip-replace-state-pre-command-sentinel
+  ;; When you jump to another buffer in another frame, the pre-command
+  ;; hook won't change cursor color to default in that other frame.
+  ;; So, if the second frame cursor was red and we set the point
+  ;; outside the replacement region, then the cursor color woll remain
+  ;; red. Restoring the default, below, prevents this.
+  (vip-restore-cursor-color)
+  (cond 
+   ((eq vip-current-state 'replace-state)
+    ;; delete characters to compensate for inserted chars.
+    (let ((replace-boundary 
+           ;; distinguish empty repl-reg-end-symbol from non-empty
+           (- (vip-replace-end)
+              (if (eq (length vip-replace-region-end-symbol) 0)
+                  0 1)))
+          )
+          
+      (save-excursion
+        (goto-char vip-last-posn-in-replace-region)
+        (delete-char vip-replace-chars-to-delete)
+        (setq vip-replace-chars-to-delete 0
+              vip-replace-chars-deleted 0)
+        ;; terminate replace mode if reached replace limit
+        (if (= vip-last-posn-in-replace-region 
+               (vip-replace-end))
+            (vip-finish-change vip-last-posn-in-replace-region)))
+      
+      (if (and (<= (vip-replace-start) (point))
+               (<=  (point) replace-boundary))
+          (progn
+            ;; the state may have changed in vip-finish-change above
+            (if (eq vip-current-state 'replace-state)
+                (vip-change-cursor-color vip-replace-overlay-cursor-color))
+            (setq vip-last-posn-in-replace-region (point-marker))))
+      ))
+   
+   (t ;; terminate replace mode if changed Viper states.
+    (vip-finish-change vip-last-posn-in-replace-region)))
+  )
+
+
+;; checks how many chars were deleted by the last change
+(defun vip-replace-mode-spy-before (beg end)
+  (setq vip-replace-chars-deleted (- end beg
+                                     (max 0 (- end (vip-replace-end)))
+                                     (max 0 (- (vip-replace-start) beg))
+                                     ))
+  )
+
+;; Invoked as an after-change-function to set up parameters of the last change
+(defun vip-replace-mode-spy-after (beg end length)
+  (if (memq vip-intermediate-command '(repeating-insertion-from-ring))
+      (progn
+        (setq vip-replace-chars-to-delete 0)
+        (vip-move-marker-locally 
+         'vip-last-posn-in-replace-region (point)))
+    
+    (let (beg-col end-col real-end chars-to-delete)
+      (setq real-end (min end (vip-replace-end)))
+      (save-excursion
+        (goto-char beg)
+        (setq beg-col (current-column))
+        (goto-char real-end)
+        (setq end-col (current-column)))
+      
+      ;; If beg of change is outside the replacement region, then don't
+      ;; delete anything in the repl region (set chars-to-delete to 0).
+      ;;
+      ;; This works fine except that we have to take special care of
+      ;; dabbrev-expand.  The problem stems from new-dabbrev.el, which
+      ;; sometimes simply shifts the repl region rightwards, without
+      ;; deleting an equal amount of characters.
+      ;;
+      ;; The reason why new-dabbrev.el causes this are this:
+      ;; if one dinamically completes a partial word that starts before the
+      ;; replacement region (but ends inside)then new-dabbrev.el first
+      ;; moves cursor backwards, to the beginning of the word to be
+      ;; completed (say, pt A). Then it inserts the 
+      ;; completed word and then deletes the old, incomplete part.
+      ;; Since the complete word is inserted at position before the repl
+      ;; region, the next If-statement would have set chars-to-delete to 0
+      ;; unless we check for the current command, which must be
+      ;; dabbrev-expand.
+      ;;
+      ;; We should be able deal with these problems in a better way
+      ;; when emacs will have overlays with sticky back ends.
+      ;; In fact, it would be also useful to add overlays for insert
+      ;; regions as well, since this will let us capture the situation when
+      ;; dabbrev-expand goes back past the insertion point to find the
+      ;; beginning of the word to be expanded.
+      (if (or (and (<= (vip-replace-start) beg)
+                   (<= beg (vip-replace-end)))
+              (and (= length 0) (eq this-command 'dabbrev-expand)))
+          (setq chars-to-delete
+                (max (- end-col beg-col) (- real-end beg) 0))
+        (setq chars-to-delete 0))
+      
+      ;; if beg = last change position, it means that we are within the
+      ;; same command that does multiple changes. Moreover, it means
+      ;; that we have two subsequent changes (insert/delete) that
+      ;; complement each other.
+      (if (= beg (marker-position vip-last-posn-in-replace-region))
+          (setq vip-replace-chars-to-delete 
+                (- (+ chars-to-delete vip-replace-chars-to-delete)
+                   vip-replace-chars-deleted)) 
+        (setq vip-replace-chars-to-delete chars-to-delete))
+      
+      (vip-move-marker-locally 
+       'vip-last-posn-in-replace-region
+       (max (if (> end (vip-replace-end)) (vip-replace-start) end)
+            (or (marker-position vip-last-posn-in-replace-region)
+                (vip-replace-start)) 
+            ))
+      
+      (setq vip-replace-chars-to-delete
+            (max 0 (min vip-replace-chars-to-delete
+                        (- (vip-replace-end)
+                           vip-last-posn-in-replace-region))))
+      )))
+
+
+;; Delete stuff between posn and the end of vip-replace-overlay-marker, if
+;; posn is within the overlay.
+(defun vip-finish-change (posn)
+  (remove-hook 'vip-after-change-functions 'vip-replace-mode-spy-after)
+  (remove-hook 'vip-before-change-functions 'vip-replace-mode-spy-before)
+  (remove-hook 'vip-post-command-hooks
+               'vip-replace-state-post-command-sentinel) 
+  (remove-hook 'vip-pre-command-hooks 'vip-replace-state-pre-command-sentinel) 
+  (vip-restore-cursor-color)
+  (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))
+         (<  posn (vip-replace-end)))
+           (delete-region posn (vip-replace-end)))
+    )
+  
+  (if (eq vip-current-state 'replace-state)
+      (vip-downgrade-to-insert))
+  ;; replace mode ended => nullify vip-last-posn-in-replace-region
+  (vip-move-marker-locally 'vip-last-posn-in-replace-region nil)
+  (vip-hide-replace-overlay)
+  (vip-refresh-mode-line)
+  (vip-put-string-on-kill-ring vip-last-replace-region)
+  )
+
+(defun vip-put-string-on-kill-ring (string)
+  "Make STRING be the first element of the kill ring."
+  (setq kill-ring (cons string kill-ring))
+  (if (> (length kill-ring) kill-ring-max)
+      (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil))
+  (setq kill-ring-yank-pointer kill-ring))
+
+(defun vip-finish-R-mode ()
+  (remove-hook 'vip-post-command-hooks 'vip-R-state-post-command-sentinel)
+  (remove-hook 'vip-pre-command-hooks 'vip-replace-state-pre-command-sentinel)
+  (vip-downgrade-to-insert))
+  
+(defun vip-start-R-mode ()
+  ;; Leave arg as 1, not t: XEmacs insists that it must be a pos number
+  (overwrite-mode 1)
+  (add-hook 'vip-post-command-hooks 'vip-R-state-post-command-sentinel t)
+  (add-hook 'vip-pre-command-hooks 'vip-replace-state-pre-command-sentinel t)
+  )
+
+
+  
+(defun vip-replace-state-exit-cmd ()
+  "Binding for keys that cause Replace state to switch to Vi or to Insert.
+These keys are ESC, RET, and LineFeed"
+  (interactive)
+  (if overwrite-mode  ;; If you are in replace mode invoked via 'R'
+      (vip-finish-R-mode)
+    (vip-finish-change vip-last-posn-in-replace-region))
+  (let (com)
+    (if (eq this-command 'vip-intercept-ESC-key)
+        (setq com 'vip-exit-insert-state)
+      (vip-set-unread-command-events last-input-char)
+      (setq com (key-binding (read-key-sequence nil))))
+      
+    (condition-case conds
+        (command-execute com)
+      (error
+       (vip-message-conditions conds)))
+    )
+  (vip-hide-replace-overlay))
+
+  
+(defun vip-overwrite (arg) 
+"This is the function bound to 'R'---unlimited replace.
+Similar to Emacs's own overwrite-mode."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)) (len))
+    (vip-set-destructive-command (list 'vip-overwrite val ?r nil nil nil))
+    (if com
+        (progn 
+          ;; Viper saves inserted text in vip-last-insertion
+          (setq len (length vip-last-insertion))
+          (delete-char len)     
+          (vip-loop val (vip-yank-last-insertion)))
+      (setq last-command 'vip-overwrite)
+      (vip-set-complex-command-for-undo)
+      (vip-set-replace-overlay (point) (vip-line-pos 'end))
+      (vip-change-state-to-replace)
+      )))
+
+
+;; line commands
+
+(defun vip-line (arg)
+  (let ((val (car arg))
+        (com (cdr arg)))
+    (vip-move-marker-locally 'vip-com-point (point))
+    (if (not (eobp))
+        (next-line (1- val)))
+    ;; this ensures that dd, cc, D, yy will do the right thing on the last
+    ;; line of buffer when this line has no \n.
+    (vip-add-newline-at-eob-if-necessary)
+    (vip-execute-com 'vip-line val com))
+  (if (and (eobp) (not (bobp))) (forward-line -1))
+  )
+
+(defun vip-yank-line (arg)
+  "Yank ARG lines (in Vi's sense)."
+  (interactive "P")
+  (let ((val (vip-p-val arg)))
+    (vip-line (cons val ?Y))))
+
+
+;; region commands
+
+(defun vip-region (arg)
+  (interactive "P")
+  (let ((val (vip-P-val arg))
+        (com (vip-getcom arg)))
+    (vip-move-marker-locally 'vip-com-point (point))
+    (exchange-point-and-mark)
+    (vip-execute-com 'vip-region val com)))
+
+(defun vip-Region (arg)
+  (interactive "P")
+  (let ((val (vip-P-val arg))
+        (com (vip-getCom arg)))
+    (vip-move-marker-locally 'vip-com-point (point))
+    (exchange-point-and-mark)
+    (vip-execute-com 'vip-Region val com)))
+
+(defun vip-replace-char (arg)
+  "Replace the following ARG chars by the character read."
+  (interactive "P")
+  (if (and (eolp) (bolp)) (error "I see no character to replace here"))
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (vip-replace-char-subr (if (equal com ?r) vip-d-char (read-char)) val)
+    (if (and (eolp) (not (bolp))) (forward-char 1))
+    (vip-set-destructive-command
+     (list 'vip-replace-char val ?r nil vip-d-char nil))
+  ))
+
+(defun vip-replace-char-subr (char arg)
+  (delete-char arg t)
+  (setq vip-d-char char)
+  (vip-loop (if (> arg 0) arg (- arg)) 
+            (if (eq char ?\C-m) (insert "\n") (insert char)))
+  (backward-char arg))
+
+(defun vip-replace-string ()
+  "The old replace string function. 
+If you supply null string as the string to be replaced,
+the query replace mode will toggle between string replace and regexp replace.
+This function comes from VIP 3.5 and is not used in Viper. A nostalgic user
+can bind it to a key, if necessary."
+  (interactive)
+  (let (str)
+    (setq str (vip-read-string-with-history
+               (if vip-re-replace "Replace regexp: " "Replace string: ")
+               nil  ; no initial
+               'vip-replace1-history
+               (car vip-replace1-history) ; default
+               ))
+    (if (string= str "")
+        (progn
+          (setq vip-re-replace (not vip-re-replace))
+          (message (format "Replace mode changed to %s"
+                           (if vip-re-replace "regexp replace"
+                             "string replace"))))
+      (if vip-re-replace
+          (replace-regexp
+           str
+           (vip-read-string-with-history
+            (format "Replace regexp `%s' with: " str)
+            nil  ; no initial
+            'vip-replace2-history
+            (car vip-replace2-history) ; default
+            ))
+        (replace-string
+         str
+         (vip-read-string-with-history
+          (format "Replace `%s' with: " str)
+          nil  ; no initial
+          'vip-replace2-history
+          (car vip-replace2-history) ; default
+          )))
+      )))
+
+
+;; basic cursor movement.  j, k, l, h commands.
+
+(defun vip-forward-char (arg)
+  "Move point right ARG characters (left if ARG negative).
+On reaching end of line, stop and signal error."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (if vip-ex-style-motion
+        (progn
+          ;; the boundary condition check gets weird here because
+          ;; forward-char may be the parameter of a delete, and 'dl' works
+          ;; just like 'x' for the last char on a line, so we have to allow
+          ;; the forward motion before the 'vip-execute-com', but, of
+          ;; course, 'dl' doesn't work on an empty line, so we have to
+          ;; catch that condition before 'vip-execute-com'
+          (if (and (eolp) (bolp)) (error "") (forward-char val))
+          (if com (vip-execute-com 'vip-forward-char val com))
+          (if (eolp) (progn (backward-char 1) (error ""))))
+      (forward-char val)
+      (if com (vip-execute-com 'vip-forward-char val com)))))
+
+(defun vip-backward-char (arg)
+  "Move point left ARG characters (right if ARG negative). 
+On reaching beginning of line, stop and signal error."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (if vip-ex-style-motion
+        (progn
+          (if (bolp) (error "") (backward-char val))
+          (if com (vip-execute-com 'vip-backward-char val com)))
+      (backward-char val)
+      (if com (vip-execute-com 'vip-backward-char val com)))))
+      
+(defun vip-forward-char-carefully (&optional arg)      
+  "Like forward-char, but doesn't move at end of buffer."
+  (setq arg (or arg 1))
+  (if (>= (point-max) (+ (point) arg))
+      (forward-char arg)
+    (goto-char (point-max))))
+      
+(defun vip-backward-char-carefully (&optional arg)      
+  "Like backward-char, but doesn't move at end of buffer."
+  (setq arg (or arg 1))
+  (if (<= (point-min) (- (point) arg))
+      (backward-char arg)
+    (goto-char (point-min))))
+
+
+
+;;; Word command
+
+;; Words are formed from alpha's and nonalphas - <sp>,\t\n are separators
+;; for word movement. When executed with a destructive command, \n is
+;; usually left untouched for the last word.
+
+;; skip only one \n
+(defun vip-skip-separators (forward)
+  (if forward
+      (progn
+        (skip-chars-forward " \t")
+        (if (looking-at "\n")
+            (progn
+              (forward-char)
+              (skip-chars-forward " \t"))))
+    (skip-chars-backward " \t")
+    (backward-char)
+    (if (looking-at "\n")
+        (skip-chars-backward " \t")
+      (forward-char))))
+      
+(defconst vip-ALPHA            "a-zA-Z0-9_")
+(defconst vip-ALPHA-B          (concat "[" vip-ALPHA "]"))
+(defconst vip-NONALPHA         (concat "^" vip-ALPHA))
+(defconst vip-NONALPHA-B       (concat "[" vip-NONALPHA "]"))
+(defconst vip-SEP               " \t\n")
+(defconst vip-SEP-B            (concat "[" vip-SEP "]"))
+(defconst vip-NONSEP           (concat "^" vip-SEP))
+(defconst vip-NONSEP-B         (concat "[" vip-NONSEP "]"))
+(defconst vip-ALPHASEP         (concat vip-ALPHA vip-SEP))
+(defconst vip-ALPHASEP-B       (concat "[" vip-ALPHASEP "]"))
+(defconst vip-NONALPHASEP      (concat "^" vip-ALPHASEP ))
+(defconst vip-NONALPHASEP-B    (concat "[" vip-NONALPHASEP "]"))
+
+
+(defun vip-forward-word-kernel (val)
+  (while (> val 0)
+    (cond ((looking-at vip-ALPHA-B)
+           (skip-chars-forward vip-ALPHA)
+           (vip-skip-separators t))
+          ((looking-at vip-SEP-B)
+           (vip-skip-separators t))
+          ((looking-at vip-NONALPHASEP-B)
+           (skip-chars-forward vip-NONALPHASEP)
+           (vip-skip-separators t)))
+    (setq val (1- val))))
+
+(defun vip-fwd-skip (pat aux-pat lim)
+  (if (and (save-excursion 
+             (re-search-backward pat lim t))
+           (= (point) (match-end 0)))
+      (goto-char (match-beginning 0)))
+  (skip-chars-backward aux-pat lim)
+  (if (= (point) lim)
+      (vip-forward-char-carefully))
+  )
+
+          
+(defun vip-forward-word (arg)
+  "Forward word."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (vip-forward-word-kernel val)
+    (if com (progn
+              (cond ((memq com (list ?c (- ?c) ?y (- ?y)))
+                     (vip-fwd-skip "\n[ \t]*" " \t" vip-com-point))
+                    ((vip-dotable-command-p com)
+                     (vip-fwd-skip "\n[ \t]*" "" vip-com-point)))
+              (vip-execute-com 'vip-forward-word val com)))))
+          
+
+(defun vip-forward-Word (arg)
+  "Forward word delimited by white character."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (vip-loop val
+              (progn
+                (skip-chars-forward vip-NONSEP)
+                (vip-skip-separators t)))
+    (if com (progn
+              (cond ((memq com (list ?c (- ?c) ?y (- ?y)))
+                     (vip-fwd-skip "\n[ \t]*" " \t" vip-com-point))
+                    ((vip-dotable-command-p com)
+                     (vip-fwd-skip "\n[ \t]*" "" vip-com-point)))
+              (vip-execute-com 'vip-forward-Word val com)))))
+
+
+;; this is a bit different from Vi, but Vi's end of word 
+;; makes no sense whatsoever
+(defun vip-end-of-word-kernel ()
+  (if (vip-end-of-word-p) (forward-char))
+  (if (looking-at "[ \t\n]")
+      (skip-chars-forward vip-SEP))
+  
+  (cond ((looking-at vip-ALPHA-B) (skip-chars-forward vip-ALPHA))
+        ((looking-at vip-NONALPHASEP-B)
+         (skip-chars-forward vip-NONALPHASEP)))
+  (vip-backward-char-carefully))
+
+(defun vip-end-of-word-p ()
+  (if (eobp) t
+    (save-excursion
+      (cond ((looking-at vip-ALPHA-B)
+             (forward-char)
+             (looking-at vip-NONALPHA-B))
+            ((looking-at vip-NONALPHASEP-B)
+             (forward-char)
+             (looking-at vip-ALPHASEP-B))))))
+
+(defun vip-one-char-word-p ()
+  (let ((step 2))
+    (save-excursion
+      (cond ((looking-at vip-ALPHA-B)
+             (if (bobp) (setq step 1) (backward-char))
+             (if (or (bobp) (looking-at vip-NONALPHA-B))
+                 (progn
+                   (forward-char step)
+                   (looking-at vip-NONALPHA-B))
+               nil))
+            ((looking-at vip-NONALPHASEP-B)
+             (if (bobp) (setq step 1) (backward-char))
+             (if (or (bobp) (looking-at vip-ALPHASEP-B))
+                 (progn
+                   (forward-char step)
+                   (looking-at vip-ALPHASEP-B))
+               nil))))))
+
+(defun vip-one-char-Word-p ()
+  (and (looking-at vip-NONSEP-B)
+       (save-excursion
+         (if (bobp)
+             t
+           (backward-char)
+           (looking-at vip-SEP-B)))
+       (save-excursion
+         (forward-char)
+         (or (eobp)
+             (looking-at vip-SEP-B)))))
+
+(defun vip-end-of-word (arg &optional careful)
+  "Move point to end of current word."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (vip-loop val (vip-end-of-word-kernel))
+    (if com 
+        (progn
+          (forward-char)
+          (vip-execute-com 'vip-end-of-word val com)))))
+
+(defun vip-end-of-Word (arg)
+  "Forward to end of word delimited by white character."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (vip-loop val
+        (progn
+          (vip-end-of-word-kernel)
+          (if (not (re-search-forward 
+                    vip-SEP-B nil t 1))
+              (goto-char (point-max)))
+          (skip-chars-backward vip-SEP)
+          (backward-char)))
+    (if com 
+        (progn
+          (forward-char)
+          (vip-execute-com 'vip-end-of-Word val com)))))
+
+(defun vip-backward-word-kernel (val)
+  (while (> val 0)
+    (backward-char)
+    (cond ((looking-at vip-ALPHA-B)
+           (skip-chars-backward vip-ALPHA))
+          ((looking-at vip-SEP-B)
+           (forward-char)
+           (vip-skip-separators nil)
+           (backward-char)
+           (cond ((looking-at vip-ALPHA-B)
+                  (skip-chars-backward vip-ALPHA))
+                 ((looking-at vip-NONALPHASEP-B)
+                  (skip-chars-backward vip-NONALPHASEP))
+                 (t (forward-char))))
+          ((looking-at vip-NONALPHASEP-B)
+           (skip-chars-backward vip-NONALPHASEP)))
+    (setq val (1- val))))
+
+(defun vip-backward-word (arg)
+  "Backward word."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (if com
+        (let (i)
+          (if (setq i (save-excursion (backward-char) (looking-at "\n")))
+              (backward-char))
+          (vip-move-marker-locally 'vip-com-point (point))
+          (if i (forward-char))))
+    (vip-backward-word-kernel val)
+    (if com (vip-execute-com 'vip-backward-word val com))))
+
+(defun vip-backward-Word (arg)
+  "Backward word delimited by white character."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (if com
+        (let (i)
+          (if (setq i (save-excursion (backward-char) (looking-at "\n")))
+              (backward-char))
+          (vip-move-marker-locally 'vip-com-point (point))
+          (if i (forward-char))))
+    (vip-loop val
+              (progn 
+                (vip-skip-separators nil)
+                (skip-chars-backward vip-NONSEP)))
+    (if com (vip-execute-com 'vip-backward-Word val com))))
+
+
+
+;; line commands
+
+(defun vip-beginning-of-line (arg)
+  "Go to beginning of line."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (beginning-of-line val)
+    (if com (vip-execute-com 'vip-beginning-of-line val com))))
+
+(defun vip-bol-and-skip-white (arg)
+  "Beginning of line at first non-white character."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (forward-to-indentation (1- val))
+    (if com (vip-execute-com 'vip-bol-and-skip-white val com))))
+
+(defun vip-goto-eol (arg)
+  "Go to end of line."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (end-of-line val)
+    (if com (vip-execute-com 'vip-goto-eol val com))
+    (if vip-ex-style-motion
+        (if (and (eolp) (not (bolp)) 
+                 ;; a fix for vip-change-to-eol
+                 (not (equal vip-current-state 'insert-state)))
+            (backward-char 1)
+    ))))
+
+
+(defun vip-goto-col (arg)
+  "Go to ARG's column."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (save-excursion
+      (end-of-line)
+      (if (> val (1+ (current-column))) (error "")))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (beginning-of-line)
+    (forward-char (1- val))
+    (if com (vip-execute-com 'vip-goto-col val com))))
+    
+
+(defun vip-next-line (arg)
+  "Go to next line."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getCom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (next-line val)
+    (if vip-ex-style-motion
+        (if (and (eolp) (not (bolp))) (backward-char 1)))
+    (setq this-command 'next-line)
+    (if com (vip-execute-com 'vip-next-line val com))))
+
+(defun vip-next-line-at-bol (arg)
+  "Next line at beginning of line."
+  (interactive "P")
+  (save-excursion
+    (end-of-line)
+    (if (eobp) (error "Last line in buffer")))
+  (let ((val (vip-p-val arg))
+        (com (vip-getCom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (forward-line val)
+    (back-to-indentation)
+    (if com (vip-execute-com 'vip-next-line-at-bol val com))))
+
+(defun vip-previous-line (arg)   
+  "Go to previous line."        
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getCom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (previous-line val)
+    (if vip-ex-style-motion
+        (if (and (eolp) (not (bolp))) (backward-char 1)))
+    (setq this-command 'previous-line)
+    (if com (vip-execute-com 'vip-previous-line val com))))
+
+
+(defun vip-previous-line-at-bol (arg)
+  "Previous line at beginning of line."
+  (interactive "P")
+  (save-excursion
+    (beginning-of-line)
+    (if (bobp) (error "First line in buffer")))
+  (let ((val (vip-p-val arg))
+        (com (vip-getCom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (forward-line (- val))
+    (back-to-indentation)
+    (if com (vip-execute-com 'vip-previous-line val com))))
+
+(defun vip-change-to-eol (arg)
+  "Change to end of line."
+  (interactive "P")
+  (vip-goto-eol (cons arg ?c)))
+
+(defun vip-kill-line (arg)
+  "Delete line."
+  (interactive "P")
+  (vip-goto-eol (cons arg ?d)))
+
+(defun vip-erase-line (arg)
+  "Erase line."
+  (interactive "P")
+  (vip-beginning-of-line (cons arg ?d)))
+
+
+;; moving around
+
+(defun vip-goto-line (arg)
+  "Go to ARG's line.  Without ARG go to end of buffer."
+  (interactive "P")
+  (let ((val (vip-P-val arg))
+        (com (vip-getCom arg)))
+    (vip-move-marker-locally 'vip-com-point (point))
+    (vip-deactivate-mark)
+    (push-mark nil t)
+    (if (null val)
+        (goto-char (point-max))
+      (goto-char (point-min))
+      (forward-line (1- val)))
+    (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
+    (back-to-indentation)
+    (if com (vip-execute-com 'vip-goto-line val com))))
+
+(defun vip-find-char (arg char forward offset)
+  "Find ARG's occurrence of CHAR on the current line. 
+If FORWARD then search is forward, otherwise backward.  OFFSET is used to
+adjust point after search."
+  (or (char-or-string-p char) (error ""))
+  (let ((arg (if forward arg (- arg)))
+        (cmd (if (eq vip-intermediate-command 'vip-repeat)
+                 (nth 5 vip-d-com)
+               (vip-array-to-string (this-command-keys))))
+        point)
+    (save-excursion
+      (save-restriction
+        (if (> arg 0)
+            (narrow-to-region
+             ;; forward search begins here
+             (if (eolp) (error "Command `%s':  At end of line" cmd) (point))
+             ;; forward search ends here
+             (progn (end-of-line) (point)))
+          (narrow-to-region
+           ;; backward search begins from here
+           (if (bolp)
+               (error "Command `%s':  At beginning of line" cmd) (point))
+           ;; backward search ends here
+           (progn (beginning-of-line) (point))))
+        ;; if arg > 0, point is forwarded before search.
+        (if (> arg 0) (goto-char (1+ (point-min)))
+          (goto-char (point-max)))
+        (if (let ((case-fold-search nil))
+              (search-forward (char-to-string char) nil 0 arg))
+            (setq point (point))
+          (error "Command `%s':  `%c' not found" cmd char))))
+    (goto-char (+ point (if (> arg 0) (if offset -2 -1) (if offset 1 0))))))
+
+(defun vip-find-char-forward (arg)
+  "Find char on the line. 
+If called interactively read the char to find from the terminal, and if
+called from vip-repeat, the char last used is used.  This behaviour is
+controlled by the sign of prefix numeric value."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (if (> val 0)
+        ;; this means that the function was called interactively
+        (setq vip-f-char (read-char)
+              vip-f-forward t
+              vip-f-offset nil)
+      ;; vip-repeat --- set vip-F-char from command-keys
+      (setq vip-F-char (if (stringp (nth 5 vip-d-com))
+                           (vip-seq-last-elt (nth 5 vip-d-com))
+                         vip-F-char)
+            vip-f-char vip-F-char)
+      (setq val (- val)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (vip-find-char val (if (> (vip-p-val arg) 0) vip-f-char vip-F-char) t nil)
+    (setq val (- val))
+    (if com
+        (progn
+          (setq vip-F-char vip-f-char) ; set new vip-F-char
+          (forward-char)
+          (vip-execute-com 'vip-find-char-forward val com)))))
+
+(defun vip-goto-char-forward (arg)
+  "Go up to char ARG forward on line."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (if (> val 0)
+        ;; this means that the function was called interactively
+        (setq vip-f-char (read-char)
+              vip-f-forward t
+              vip-f-offset t)
+      ;; vip-repeat --- set vip-F-char from command-keys
+      (setq vip-F-char (if (stringp (nth 5 vip-d-com))
+                           (vip-seq-last-elt (nth 5 vip-d-com))
+                         vip-F-char)
+            vip-f-char vip-F-char)
+      (setq val (- val)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (vip-find-char val (if (> (vip-p-val arg) 0) vip-f-char vip-F-char) t t)
+    (setq val (- val))
+    (if com
+        (progn
+          (setq vip-F-char vip-f-char) ; set new vip-F-char
+          (forward-char)
+          (vip-execute-com 'vip-goto-char-forward val com)))))
+
+(defun vip-find-char-backward (arg)
+  "Find char ARG on line backward."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (if (> val 0)
+        ;; this means that the function was called interactively
+        (setq vip-f-char (read-char)
+              vip-f-forward nil
+              vip-f-offset nil)
+      ;; vip-repeat --- set vip-F-char from command-keys
+      (setq vip-F-char (if (stringp (nth 5 vip-d-com))
+                           (vip-seq-last-elt (nth 5 vip-d-com))
+                         vip-F-char)
+            vip-f-char vip-F-char)
+      (setq val (- val)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (vip-find-char
+     val (if (> (vip-p-val arg) 0) vip-f-char vip-F-char) nil nil)
+    (setq val (- val))
+    (if com
+        (progn
+          (setq vip-F-char vip-f-char) ; set new vip-F-char
+          (vip-execute-com 'vip-find-char-backward val com)))))
+
+(defun vip-goto-char-backward (arg)
+  "Go up to char ARG backward on line."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (if (> val 0)
+        ;; this means that the function was called interactively
+        (setq vip-f-char (read-char)
+              vip-f-forward nil
+              vip-f-offset t)
+      ;; vip-repeat --- set vip-F-char from command-keys
+      (setq vip-F-char (if (stringp (nth 5 vip-d-com))
+                           (vip-seq-last-elt (nth 5 vip-d-com))
+                         vip-F-char)
+            vip-f-char vip-F-char)
+      (setq val (- val)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (vip-find-char val (if (> (vip-p-val arg) 0) vip-f-char vip-F-char) nil t)
+    (setq val (- val))
+    (if com
+        (progn
+          (setq vip-F-char vip-f-char) ; set new vip-F-char
+          (vip-execute-com 'vip-goto-char-backward val com)))))
+
+(defun vip-repeat-find (arg)
+  "Repeat previous find command."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (vip-deactivate-mark)
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (vip-find-char val vip-f-char vip-f-forward vip-f-offset)
+    (if com
+        (progn
+          (if vip-f-forward (forward-char))
+          (vip-execute-com 'vip-repeat-find val com)))))
+
+(defun vip-repeat-find-opposite (arg)
+  "Repeat previous find command in the opposite direction."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (vip-deactivate-mark)
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (vip-find-char val vip-f-char (not vip-f-forward) vip-f-offset)
+    (if com
+        (progn
+          (if vip-f-forward (forward-char))
+          (vip-execute-com 'vip-repeat-find-opposite val com)))))
+
+
+;; window scrolling etc.
+
+(defun vip-other-window (arg)
+  "Switch to other window."
+  (interactive "p")
+  (other-window arg)
+  (or (not (eq vip-current-state 'emacs-state))
+      (string= (buffer-name (current-buffer)) " *Minibuf-1*")
+      (vip-change-state-to-vi)))
+
+(defun vip-window-top (arg)
+  "Go to home window line."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getCom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (push-mark nil t) 
+    (move-to-window-line (1- val))
+    (if (not com) (back-to-indentation))
+    (if com (vip-execute-com 'vip-window-top val com))))
+
+(defun vip-window-middle (arg)
+  "Go to middle window line."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getCom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (push-mark nil t) 
+    (move-to-window-line (+ (/ (1- (window-height)) 2) (1- val)))
+    (if (not com) (back-to-indentation))
+    (if com (vip-execute-com 'vip-window-middle val com))))
+
+(defun vip-window-bottom (arg)
+  "Go to last window line."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getCom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (push-mark nil t) 
+    (move-to-window-line (- val))
+    (if (not com) (back-to-indentation))
+    (if com (vip-execute-com 'vip-window-bottom val com))))
+
+(defun vip-line-to-top (arg)
+  "Put current line on the home line."
+  (interactive "p")
+  (recenter (1- arg)))
+
+(defun vip-line-to-middle (arg)
+  "Put current line on the middle line."
+  (interactive "p")
+  (recenter (+ (1- arg) (/ (1- (window-height)) 2))))
+
+(defun vip-line-to-bottom (arg)
+  "Put current line on the last line."
+  (interactive "p")
+  (recenter (- (window-height) (1+ arg))))
+
+
+;; 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")
+  (let ((com (vip-getcom arg)))
+    (if (numberp arg)
+        (if (or (> arg 99) (< arg 1))
+            (error "Prefix must be between 1 and 99")
+          (goto-char
+           (if (> (point-max) 80000)
+               (* (/ (point-max) 100) arg)
+             (/ (* (point-max) arg) 100)))
+          (back-to-indentation))
+      (let (lim)
+        (if (and (eolp) (not (bolp))) (forward-char -1))
+        (save-excursion
+          (end-of-line)
+          (setq lim (point)))
+        (if (re-search-forward "[][(){}]" lim t) 
+            (backward-char) 
+          (error "No matching character on line")))
+      (cond ((looking-at "[\(\[{]")
+             (if com (vip-move-marker-locally 'vip-com-point (point)))
+             (forward-sexp 1)
+             (if com
+                 (vip-execute-com 'vip-paren-match nil com)
+               (backward-char)))
+            ((looking-at "[])}]")
+             (forward-char)
+             (if com (vip-move-marker-locally 'vip-com-point (point)))
+             (backward-sexp 1)
+             (if com (vip-execute-com 'vip-paren-match nil com)))
+            (t (error ""))))))
+
+
+;; sentence ,paragraph and heading
+
+(defun vip-forward-sentence (arg)
+  "Forward sentence."
+  (interactive "P")
+  (push-mark nil t) 
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (forward-sentence val)
+    (if com (vip-execute-com 'vip-forward-sentence nil com))))
+
+(defun vip-backward-sentence (arg)
+  "Backward sentence."
+  (interactive "P")
+  (push-mark nil t) 
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (backward-sentence val)
+    (if com (vip-execute-com 'vip-backward-sentence nil com))))
+
+(defun vip-forward-paragraph (arg)
+  "Forward paragraph."
+  (interactive "P")
+  (push-mark nil t) 
+  (let ((val (vip-p-val arg))
+        (com (vip-getCom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (forward-paragraph val)
+    (if com (vip-execute-com 'vip-forward-paragraph nil com))))
+
+(defun vip-backward-paragraph (arg)
+  "Backward paragraph."
+  (interactive "P")
+  (push-mark nil t) 
+  (let ((val (vip-p-val arg))
+        (com (vip-getCom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (backward-paragraph val)
+    (if com (vip-execute-com 'vip-backward-paragraph nil com))))
+
+;; should be mode-specific etc.
+
+(defun vip-prev-heading (arg)
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getCom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (re-search-backward vip-heading-start nil t val)
+    (goto-char (match-beginning 0))
+    (if com (vip-execute-com 'vip-prev-heading nil com))))
+
+(defun vip-heading-end (arg)
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getCom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (re-search-forward vip-heading-end nil t val)
+    (goto-char (match-beginning 0))
+    (if com (vip-execute-com 'vip-heading-end nil com))))
+
+(defun vip-next-heading (arg)
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getCom arg)))
+    (if com (vip-move-marker-locally 'vip-com-point (point)))
+    (end-of-line)
+    (re-search-forward vip-heading-start nil t val)
+    (goto-char (match-beginning 0))
+    (if com (vip-execute-com 'vip-next-heading nil com))))
+
+
+;; scrolling
+
+(setq scroll-step 1)
+
+(defun vip-scroll (arg)
+  "Scroll to next screen."
+  (interactive "p")
+  (if (> arg 0)
+      (while (> arg 0)
+        (scroll-up)
+        (setq arg (1- arg)))
+    (while (> 0 arg)
+      (scroll-down)
+      (setq arg (1+ arg)))))
+
+(defun vip-scroll-back (arg)
+  "Scroll to previous screen."
+  (interactive "p")
+  (vip-scroll (- arg)))
+
+(defun vip-scroll-down (arg)
+  "Pull down half screen."
+  (interactive "P")
+  (condition-case nil
+      (if (null arg)
+          (scroll-down (/ (window-height) 2))
+        (scroll-down arg))
+    (error (beep 1)
+           (message "Beginning of buffer")
+           (goto-char (point-min)))))
+
+(defun vip-scroll-down-one (arg)
+  "Scroll up one line."
+  (interactive "p")
+  (scroll-down arg))
+
+(defun vip-scroll-up (arg)
+  "Pull up half screen."
+  (interactive "P")
+  (condition-case nil
+      (if (null arg)
+          (scroll-up (/ (window-height) 2))
+        (scroll-up arg))
+    (error (beep 1)
+           (message "End of buffer")
+           (goto-char (point-max)))))
+
+(defun vip-scroll-up-one (arg)
+  "Scroll down one line."
+  (interactive "p")
+  (scroll-up arg))
+
+
+;; searching
+
+(defun vip-if-string (prompt)
+  (let ((s (vip-read-string-with-history
+            prompt
+            nil ; no initial
+            'vip-search-history
+            (car vip-search-history))))
+    (if (not (string= s ""))
+        (setq vip-s-string s))))  
+        
+    
+(defun vip-toggle-search-style (arg) 
+  "Toggle the value of vip-case-fold-search/vip-re-search.
+Without prefix argument, will ask which search style to toggle. With prefix
+arg 1,toggles vip-case-fold-search; with arg 2 toggles vip-re-search.
+
+Although this function is bound to \\[vip-toggle-search-style], the most
+convenient way to use it is to bind `//' to the macro
+`1 M-x vip-toggle-search-style' and `///' to
+`2 M-x vip-toggle-search-style'. In this way, hitting `//' quickly will
+toggle case-fold-search and hitting `/' three times witth toggle regexp
+search. Macros are more convenient in this case because they don't affect
+the Emacs binding of `/'."
+  (interactive "P")
+  (let (msg)
+    (cond ((or (eq arg 1)
+               (and (null arg)
+                    (y-or-n-p (format "Search style: '%s'. Want '%s'? "
+                                      (if vip-case-fold-search
+                                          "case-insensitive" "case-sensitive")
+                                      (if vip-case-fold-search
+                                          "case-sensitive"
+                                        "case-insensitive")))))
+           (setq vip-case-fold-search (null vip-case-fold-search))
+           (if vip-case-fold-search
+               (setq msg "Search becomes case-insensitive")
+             (setq msg "Search becomes case-sensitive")))
+          ((or (eq arg 2)
+               (and (null arg)
+                    (y-or-n-p (format "Search style: '%s'. Want '%s'? "
+                                      (if vip-re-search
+                                          "regexp-search" "vanilla-search")
+                                      (if vip-re-search
+                                          "vanilla-search"
+                                        "regexp-search")))))
+           (setq vip-re-search (null vip-re-search))
+           (if vip-re-search
+               (setq msg "Search becomes regexp-style")
+             (setq msg "Search becomes vanilla-style")))
+          (t
+           (setq msg "Search style remains unchanged")))
+    (prin1 msg t)))
+
+
+(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."
+  (interactive "P")
+  (let ((val (vip-P-val arg))
+        (com (vip-getcom arg))
+        (old-str vip-s-string))
+    (setq vip-s-forward t)
+    (vip-if-string "/")
+    ;; this is not used at present, but may be used later
+    (if (or (not (equal old-str vip-s-string))
+            (not (markerp vip-local-search-start-marker))
+            (not (marker-buffer vip-local-search-start-marker)))
+        (setq vip-local-search-start-marker (point-marker)))
+    (vip-search vip-s-string t val)
+    (if com
+        (progn
+          (vip-move-marker-locally 'vip-com-point (mark t))
+          (vip-execute-com 'vip-search-next val com)))))
+
+(defun vip-search-backward (arg)
+  "Search a string backward. 
+ARG is used to find the ARG's occurrence of the string.
+Null string will repeat previous search."
+  (interactive "P")
+  (let ((val (vip-P-val arg))
+        (com (vip-getcom arg))
+        (old-str vip-s-string))
+    (setq vip-s-forward nil)
+    (vip-if-string "?")
+    ;; this is not used at present, but may be used later
+    (if (or (not (equal old-str vip-s-string))
+            (not (markerp vip-local-search-start-marker))
+            (not (marker-buffer vip-local-search-start-marker)))
+        (setq vip-local-search-start-marker (point-marker)))
+    (vip-search vip-s-string nil val)
+    (if com
+        (progn
+          (vip-move-marker-locally 'vip-com-point (mark t))
+          (vip-execute-com 'vip-search-next val com)))))
+          
+
+(defun vip-search (string forward arg &optional no-offset init-point)
+  "Search for COUNT's occurrence of STRING.
+Search is forward if FORWARD is non-nil, otherwise backward.
+INIT-POINT is the position where search is to start.
+Arguments: (STRING FORWARD COUNT &optional NO-OFFSET INIT-POINT LIMIT)."
+  (if (not (equal string ""))
+    (let ((val (vip-p-val arg))
+          (com (vip-getcom arg))
+          (null-arg (null (vip-P-val arg))) (offset (not no-offset))
+          (case-fold-search vip-case-fold-search)
+          (start-point (or init-point (point))))
+      (vip-deactivate-mark)
+      (if forward
+          (condition-case nil
+              (progn
+                (if offset (vip-forward-char-carefully))
+                (if vip-re-search
+                    (progn
+                      (re-search-forward string nil nil val)
+                      (re-search-backward string))
+                  (search-forward string nil nil val)
+                  (search-backward string))
+                (vip-flash-search-pattern)
+                (if (not (equal start-point (point)))
+                    (push-mark start-point t))) 
+            (search-failed
+             (if (and null-arg vip-search-wrap-around-t)
+                 (progn
+                   (message "Search wrapped around end of buffer")
+                   (goto-char (point-min))
+                   (vip-search string forward (cons 1 com) t start-point)
+                   ;; delete the wrapped around message
+                   (sit-for 2)(message "")
+                   )
+               (goto-char start-point)
+               (error "`%s': %s not found"
+                      string
+                      (if vip-re-search "Pattern" "String"))
+               )))
+        ;; backward
+        (condition-case nil
+            (progn
+              (if vip-re-search
+                  (re-search-backward string nil nil val)
+                (search-backward string nil nil val))
+              (vip-flash-search-pattern)
+              (if (not (equal start-point (point)))
+                  (push-mark start-point t))) 
+          (search-failed
+           (if (and null-arg vip-search-wrap-around-t)
+               (progn
+                 (message "Search wrapped around beginning of buffer")
+                 (goto-char (point-max))
+                 (vip-search string forward (cons 1 com) t start-point)
+                 ;; delete the wrapped around message
+                 (sit-for 2)(message "")
+                 )
+             (goto-char start-point)
+             (error "`%s': %s not found"
+                    string
+                    (if vip-re-search "Pattern" "String"))
+             )))))))
+
+(defun vip-search-next (arg)
+  "Repeat previous search."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (if (null vip-s-string) (error vip-NoPrevSearch))
+    (vip-search vip-s-string vip-s-forward arg)
+    (if com
+        (progn
+          (vip-move-marker-locally 'vip-com-point (mark t))
+          (vip-execute-com 'vip-search-next val com)))))
+
+(defun vip-search-Next (arg)
+  "Repeat previous search in the reverse direction."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (com (vip-getcom arg)))
+    (if (null vip-s-string) (error vip-NoPrevSearch))
+    (vip-search vip-s-string (not vip-s-forward) arg)
+    (if com
+        (progn
+          (vip-move-marker-locally 'vip-com-point (mark t))
+          (vip-execute-com 'vip-search-Next val com)))))
+
+
+;; Search contents of buffer defined by one of Viper's motion commands.
+;; Repeatable via `n' and `N'.
+(defun vip-buffer-search-enable (&optional c)
+  (cond (c (setq vip-buffer-search-char c))
+        ((null vip-buffer-search-char)
+         (setq vip-buffer-search-char ?g)))
+  (define-key vip-vi-basic-map
+    (char-to-string vip-buffer-search-char) 'vip-command-argument)
+  (aset vip-exec-array vip-buffer-search-char 'vip-exec-buffer-search)
+  (setq vip-prefix-commands (cons vip-buffer-search-char vip-prefix-commands)))
+
+(defun vip-isearch-forward (arg)
+  "This is a Viper wrap-around for isearch-forward."
+  (interactive "P")
+  ;; emacs bug workaround
+  (if (listp arg) (setq arg (car arg)))
+  (vip-exec-form-in-emacs (list 'isearch-forward arg)))
+
+(defun vip-isearch-backward (arg)
+  "This is a Viper wrap-around for isearch-backward."
+  (interactive "P")
+  ;; emacs bug workaround
+  (if (listp arg) (setq arg (car arg)))
+  (vip-exec-form-in-emacs (list 'isearch-backward arg)))
+
+
+;; visiting and killing files, buffers
+
+(defun vip-switch-to-buffer ()
+  "Switch to buffer in the current window."
+  (interactive)
+  (let (buffer)
+    (setq buffer
+          (read-buffer
+           (format "Switch to buffer in this window \(%s\): "
+                   (buffer-name (other-buffer (current-buffer))))))
+    (switch-to-buffer buffer)
+    ))
+
+(defun vip-switch-to-buffer-other-window ()
+  "Switch to buffer in another window."
+  (interactive)
+  (let (buffer)
+    (setq buffer
+          (read-buffer
+           (format "Switch to buffer in another window \(%s\): "
+                   (buffer-name (other-buffer (current-buffer))))))
+    (switch-to-buffer-other-window buffer)
+    ))
+
+(defun vip-kill-buffer ()
+  "Kill a buffer."
+  (interactive)
+  (let (buffer buffer-name)
+    (setq buffer-name
+          (read-buffer
+           (format "Kill buffer \(%s\): "
+                   (buffer-name (current-buffer)))))
+    (setq buffer
+          (if (null buffer-name)
+              (current-buffer)
+            (get-buffer buffer-name)))
+    (if (null buffer) (error "`%s': No such buffer" buffer-name))
+    (if (or (not (buffer-modified-p buffer))
+            (y-or-n-p 
+             (format
+              "Buffer `%s' is modified, are you sure you want to kill it? "
+              buffer-name)))
+        (kill-buffer buffer)
+      (error "Buffer not killed"))))
+
+
+(defvar vip-smart-suffix-list '("" "tex" "c" "cc" "el" "p")
+  "*List of suffixes that Viper automatically tries to append to filenames ending with a `.'.
+This is useful when you the current directory contains files with the same
+prefix and many different suffixes. Usually, only one of the suffixes
+represents an editable file. However, file completion will stop at the `.'
+The smart suffix feature lets you hit RET in such a case, and Viper will
+select the appropriate suffix.
+
+Suffixes are tried in the order given and the first suffix for which a
+corresponding file exists is selected. If no file exists for any of the
+suffixes, the user is asked to confirm.
+
+To turn this feature off, set this variable to nil.")
+    
+;; Try to add suffix to files ending with a `.'
+;; Useful when the user hits RET on a non-completed file name.
+(defun vip-file-add-suffix ()
+  (let ((count 0)
+        (len (length vip-smart-suffix-list))
+        (file (buffer-string))
+        found key cmd suff)
+    (goto-char (point-max))
+    (if (and vip-smart-suffix-list (string-match "\\.$" file))
+        (progn
+          (while (and (not found) (< count len))
+            (setq suff (nth count vip-smart-suffix-list)
+                  count (1+ count))
+            (if (file-exists-p (format "%s%s" file suff))
+                (progn
+                  (setq found t)
+                  (insert suff))))
+      
+          (if found
+              ()
+            (vip-tmp-insert-at-eob " [Please complete file name]")
+            (unwind-protect 
+                (while (not (memq cmd '(exit-minibuffer vip-exit-minibuffer)))
+                  (setq cmd
+                        (key-binding (setq key (read-key-sequence nil))))
+                  (cond ((eq cmd 'self-insert-command)
+                         (if vip-xemacs-p
+                             (insert (events-to-keys key))
+                           (insert key)))
+                        ((memq cmd '(exit-minibuffer vip-exit-minibuffer))
+                         nil)
+                        (t (command-execute cmd)))
+                  )))
+              ))
+    ))
+
+
+;; Advice for use in find-file and read-file-name commands.
+(defadvice exit-minibuffer (before vip-exit-minibuffer-advice activate)
+  "Runs vip-minibuffer-exit-hook just before exiting the minibuffer.
+Beginning with Emacs 19.26, the standard `minibuffer-exit-hook' is run
+*after* exiting the minibuffer."
+  (run-hooks 'vip-minibuffer-exit-hook))
+
+(defadvice find-file (before vip-add-suffix-advice activate)
+  "Uses read-file-name to read arguments."
+  (interactive (list (read-file-name "Find file: "
+                                     nil default-directory))))
+    
+(defadvice find-file-other-window (before vip-add-suffix-advice activate)
+  "Uses read-file-name to read arguments."
+  (interactive (list (read-file-name "Find file in other window: "
+                                     nil default-directory))))
+    
+;; find-file-other-screen doesn't need advice because it apparently uses
+;; read-file-name to read its argument.
+(defadvice find-file-other-frame (before vip-add-suffix-advice activate)
+  "Uses read-file-name to read arguments."
+  (interactive (list (read-file-name "Find file in other frame: "
+                                     nil default-directory))))
+
+(defadvice read-file-name (around vip-suffix-advice activate)
+  "Makes exit-minibuffer run `vip-file-add-suffix' as a hook."
+  (let ((vip-minibuffer-exit-hook 'vip-file-add-suffix))
+    ad-do-it))
+
+;; must be after we did advice or else the advice won't take hold
+(if vip-xemacs-p
+    (fset 'vip-find-file-other-frame
+          (symbol-function 'find-file-other-screen))
+  (fset 'vip-find-file-other-frame
+        (symbol-function 'find-file-other-frame)))
+
+     
+
+;; yank and pop
+
+(defsubst vip-yank (text)
+  "Yank TEXT silently. This works correctly with Emacs's yank-pop command."
+    (insert text)
+    (setq this-command 'yank))
+
+(defun vip-put-back (arg)
+  "Put back after point/below line."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (text (if vip-use-register
+                  (cond ((vip-valid-register vip-use-register '(digit))
+                         (current-kill (- vip-use-register ?1) 'do-not-rotate))
+                        ((vip-valid-register vip-use-register)
+                         (get-register (downcase vip-use-register)))
+                        (t (error vip-InvalidRegister vip-use-register)))
+                (current-kill 0))))
+    (if (null text)
+        (if vip-use-register
+            (let ((reg vip-use-register))
+              (setq vip-use-register nil)
+              (error vip-EmptyRegister reg))
+          (error "")))
+    (setq vip-use-register nil)
+    (if (vip-end-with-a-newline-p text)
+        (progn
+          (if (eobp)
+              (insert "\n")
+            (forward-line 1))
+          (beginning-of-line))
+      (if (not (eolp)) (vip-forward-char-carefully)))
+    (set-marker (vip-mark-marker) (point) (current-buffer))
+    (vip-set-destructive-command
+     (list 'vip-put-back val nil vip-use-register nil nil))
+    (vip-loop val (vip-yank text)))
+  (exchange-point-and-mark)
+  (vip-deactivate-mark))
+
+(defun vip-Put-back (arg)
+  "Put back at point/above line."
+  (interactive "P")
+  (let ((val (vip-p-val arg))
+        (text (if vip-use-register
+                  (cond ((vip-valid-register vip-use-register '(digit))
+                         (current-kill (- vip-use-register ?1) 'do-not-rotate))
+                        ((vip-valid-register vip-use-register)
+                         (get-register (downcase vip-use-register)))
+                        (t (error vip-InvalidRegister vip-use-register)))
+                (current-kill 0))))
+    (if (null text)
+        (if vip-use-register
+            (let ((reg vip-use-register))
+              (setq vip-use-register nil)
+              (error vip-EmptyRegister reg))
+          (error "")))
+    (setq vip-use-register nil)
+    (if (vip-end-with-a-newline-p text) (beginning-of-line))
+    (vip-set-destructive-command
+     (list 'vip-Put-back val nil vip-use-register nil nil))
+    (set-marker (vip-mark-marker) (point) (current-buffer))
+    (vip-loop val (vip-yank text)))
+  (exchange-point-and-mark)
+  (vip-deactivate-mark))
+    
+
+(defun vip-copy-region-as-kill (beg end)
+  "Copy region to kill-ring.
+If BEG and END do not belong to the same buffer, copy empty region."
+  (condition-case nil
+      (copy-region-as-kill beg end)
+    (error (copy-region-as-kill beg beg))))
+    
+(defun vip-save-last-insertion (beg end)
+  "Saves last inserted text for possible use by vip-repeat command."
+  (setq vip-last-insertion (buffer-substring beg end))
+  (or (< (length vip-d-com) 5)
+      (setcar (nthcdr 4 vip-d-com) vip-last-insertion))
+  (or (null vip-command-ring)
+      (ring-empty-p vip-command-ring)
+      (progn
+        (setcar (nthcdr 4 (vip-current-ring-item vip-command-ring))
+                vip-last-insertion)
+        ;; del most recent elt, if identical to the second most-recent
+        (vip-cleanup-ring vip-command-ring)))
+  )
+    
+(defsubst vip-yank-last-insertion ()
+  "Inserts the text saved by the previous vip-save-last-insertion command."
+  (condition-case nil
+      (insert vip-last-insertion)
+    (error nil)))
+  
+
+(defun vip-delete-char (arg)
+  "Delete character."
+  (interactive "P")
+  (let ((val (vip-p-val arg)))
+    (vip-set-destructive-command (list 'vip-delete-char val nil nil nil nil))
+    (if (> val 1)
+        (save-excursion
+          (let ((here (point)))
+            (end-of-line)
+            (if (> val (- (point) here))
+                (setq val (- (point) here))))))
+    (if (and (eq val 0) (not vip-ex-style-motion)) (setq val 1))
+    (if (and vip-ex-style-motion (eolp))
+        (if (bolp) (error "") (setq val 0))) ; not bol---simply back 1 ch
+    (if vip-use-register
+        (progn
+          (cond ((vip-valid-register vip-use-register '((Letter)))
+                 (vip-append-to-register
+                  (downcase vip-use-register) (point) (- (point) val)))
+                ((vip-valid-register vip-use-register)
+                 (copy-to-register
+                  vip-use-register (point) (- (point) val) nil))
+                (t (error vip-InvalidRegister vip-use-register)))
+          (setq vip-use-register nil)))
+    (if vip-ex-style-motion
+        (progn
+          (delete-char val t)
+          (if (and (eolp) (not (bolp))) (backward-char 1)))
+      (if (eolp)
+          (delete-backward-char val t)
+        (delete-char val t)))))
+
+(defun vip-delete-backward-char (arg)
+  "Delete previous character. On reaching beginning of line, stop and beep."
+  (interactive "P")
+  (let ((val (vip-p-val arg)))
+    (vip-set-destructive-command
+     (list 'vip-delete-backward-char val nil nil nil nil))
+    (if (> val 1)
+        (save-excursion
+          (let ((here (point)))
+            (beginning-of-line)
+            (if (> val (- here (point)))
+                (setq val (- here (point)))))))
+    (if vip-use-register
+        (progn
+          (cond ((vip-valid-register vip-use-register '(Letter))
+                 (vip-append-to-register
+                  (downcase vip-use-register) (point) (+ (point) val)))
+                ((vip-valid-register vip-use-register)
+                 (copy-to-register
+                  vip-use-register (point) (+ (point) val) nil))
+                (t (error vip-InvalidRegister vip-use-register)))
+          (setq vip-use-register nil)))
+    (if (bolp) (ding)
+      (delete-backward-char val t))))
+      
+(defun vip-del-backward-char-in-insert ()
+  "Delete 1 char backwards while in insert mode."
+  (interactive)      
+  (if (and vip-ex-style-editing-in-insert (bolp))
+      (beep 1)
+    (delete-backward-char 1 t)))
+      
+(defun vip-del-backward-char-in-replace ()
+  "Delete one character in replace mode.
+If `vip-delete-backwards-in-replace' is t, then DEL key actually deletes
+charecters. If it is nil, then the cursor just moves backwards, similarly
+to Vi. The variable `vip-ex-style-editing-in-insert', if t, doesn't let the
+cursor move past the beginning of the replacement region."
+  (interactive)
+  (cond (vip-delete-backwards-in-replace
+         (cond ((not (bolp))
+                (delete-backward-char 1 t))
+               (vip-ex-style-editing-in-insert
+                (beep 1))
+               ((bobp)
+                (beep 1))
+               (t
+                (delete-backward-char 1 t))))
+        (vip-ex-style-editing-in-insert
+         (if (bolp)
+             (beep 1)
+           (backward-char 1)))
+        (t 
+         (backward-char 1))))
+
+
+
+;; join lines.
+
+(defun vip-join-lines (arg)
+  "Join this line to next, if ARG is nil.  Otherwise, join ARG lines."
+  (interactive "*P")
+  (let ((val (vip-P-val arg)))
+    (vip-set-destructive-command (list 'vip-join-lines val nil nil nil nil))
+    (vip-loop (if (null val) 1 (1- val))
+              (progn
+                (end-of-line)
+                (if (not (eobp))
+                    (progn
+                      (forward-line 1)
+                      (delete-region (point) (1- (point)))
+                      (fixup-whitespace)))))))
+
+
+;; Replace state
+
+(defun vip-change (beg end)
+  (if (markerp beg) (setq beg (marker-position beg)))
+  (if (markerp end) (setq end (marker-position end)))
+  ;; beg is sometimes (mark t), which may be nil
+  (or beg (setq beg end))
+  
+  (vip-set-complex-command-for-undo)
+  (if vip-use-register
+      (progn
+        (copy-to-register vip-use-register beg end nil)
+        (setq vip-use-register nil)))
+  (vip-set-replace-overlay beg end)
+  (setq last-command nil) ; separate repl text from prev kills
+  
+  (if (= (vip-replace-start) (point-max))
+      (error "End of buffer"))
+      
+  (setq vip-last-replace-region
+        (buffer-substring (vip-replace-start)
+                          (vip-replace-end)))
+  
+  ;; protect against error while inserting "@" and other disasters
+  ;; (e.g., read-only buff)
+  (condition-case conds
+      (if (vip-same-line (vip-replace-start)
+                         (vip-replace-end))
+          (let ((delim-end (if (= (length vip-replace-region-end-symbol) 0)
+                               ""
+                             (substring vip-replace-region-end-symbol 0 1))))
+            
+            ;; tabs cause problems in replace, so untabify
+            (goto-char (vip-replace-end))
+            (insert-before-markers "@") ; put placeholder after the TAB
+           
+            (untabify (vip-replace-start) (point))
+            ;; del @ and the char under the '$'; don't put on kill ring 
+            (delete-backward-char (1+ (length delim-end)))
+            (insert delim-end)
+            ;; this move takes care of the last posn in the overlay, which
+            ;; has to be shifted because of insert. We can't simply insert
+            ;; "$" before-markers because then overlay-start will shift the
+            ;; beginning of the overlay in case we are replacing a single
+            ;; character. This fixes the bug with `s' and `cl' commands.
+            (vip-move-replace-overlay (vip-replace-start) (point))
+            (goto-char (vip-replace-start))
+            (vip-change-state-to-replace t))
+        (kill-region (vip-replace-start)
+                     (vip-replace-end))
+        (vip-change-state-to-insert))
+    (error ;; make sure that the overlay doesn't stay.
+           ;; go back to the original point
+     (goto-char (vip-replace-start))
+     (vip-hide-replace-overlay)
+     (vip-message-conditions conds))))
+
+
+(defun vip-change-subr (beg end)
+  ;; beg is sometimes (mark t), which may be nil
+  (or beg (setq beg end))
+  
+  (if vip-use-register
+      (progn
+        (copy-to-register vip-use-register beg end nil)
+        (setq vip-use-register nil)))
+  (kill-region beg end)
+  (setq this-command 'vip-change)
+  (vip-yank-last-insertion))
+
+(defun vip-toggle-case (arg)
+  "Toggle character case."
+  (interactive "P")
+  (let ((val (vip-p-val arg)) (c))
+    (vip-set-destructive-command (list 'vip-toggle-case val nil nil nil nil))
+    (while (> val 0)
+      (setq c (following-char))
+      (delete-char 1 nil)
+      (if (eq c (upcase c))
+          (insert-char (downcase c) 1)
+        (insert-char (upcase c) 1))
+      (setq val (1- val)))))
+
+
+;; query replace
+
+(defun vip-query-replace ()
+  "Query replace. 
+If a null string is suplied as the string to be replaced,
+the query replace mode will toggle between string replace
+and regexp replace."
+  (interactive)
+  (let (str)
+    (setq str (vip-read-string-with-history
+               (if vip-re-query-replace "Query replace regexp: "
+                 "Query replace: ")
+               nil  ; no initial
+               'vip-replace1-history
+               (car vip-replace1-history) ; default
+               ))
+    (if (string= str "")
+        (progn
+          (setq vip-re-query-replace (not vip-re-query-replace))
+          (message "Query replace mode changed to %s"
+                   (if vip-re-query-replace "regexp replace"
+                     "string replace")))
+      (if vip-re-query-replace
+          (query-replace-regexp
+           str
+           (vip-read-string-with-history
+            (format "Query replace regexp `%s' with: " str)
+            nil  ; no initial
+            'vip-replace1-history
+            (car vip-replace1-history) ; default
+            ))
+        (query-replace
+         str
+         (vip-read-string-with-history
+          (format "Query replace `%s' with: " str)
+          nil  ; no initial
+          'vip-replace1-history
+          (car vip-replace1-history) ; default
+          ))))))
+
+
+;; marking
+
+(defun vip-mark-beginning-of-buffer ()
+  (interactive)
+  (push-mark (point))
+  (goto-char (point-min))
+  (exchange-point-and-mark)
+  (message "Mark set at the beginning of buffer"))
+
+(defun vip-mark-end-of-buffer ()
+  (interactive)
+  (push-mark (point))
+  (goto-char (point-max))
+  (exchange-point-and-mark)
+  (message "Mark set at the end of buffer"))
+
+(defun vip-mark-point ()
+  (interactive)
+  (let ((char (vip-read-char-exclusive)))
+  (cond ((and (<= ?a char) (<= char ?z))
+         (point-to-register (1+ (- char ?a))))
+        ((= char ?<) (vip-mark-beginning-of-buffer))
+        ((= char ?>) (vip-mark-end-of-buffer))
+        ((= char ?.) (vip-set-mark-if-necessary))
+        ((= char ?,) (vip-cycle-through-mark-ring))
+        ((= char ?D) (mark-defun))
+        (t (error ""))
+        )))
+        
+;; Algorithm: If first invocation of this command save mark on ring, goto
+;; mark, M0, and pop the most recent elt from the mark ring into mark,
+;; making it into the new mark, M1.
+;; Push this mark back and set mark to the original point position, p1.
+;; So, if you hit '' or `` then you can return to p1.
+;;
+;; If repeated command, pop top elt from the ring into mark and
+;; jump there. This forgets the position, p1, and puts M1 back into mark.
+;; Then we save the current pos, which is M0, jump to M1 and pop M2 from
+;; the ring into mark.  Push M2 back on the ring and set mark to M0.
+;; etc.
+(defun vip-cycle-through-mark-ring ()
+  "Visit previous locations on the mark ring.
+One can use `` and '' to temporarily jump 1 step back."
+  (let* ((sv-pt (point)))
+       ;; if repeated `m,' command, pop the previously saved mark.
+       ;; Prev saved mark is actually prev saved point. It is used if the
+       ;; user types `` or '' and is discarded 
+       ;; from the mark ring by the next `m,' command. 
+       ;; In any case, go to the previous or previously saved mark.
+       ;; Then push the current mark (popped off the ring) and set current
+       ;; point to be the mark. Current pt as mark is discarded by the next
+       ;; m, command.
+       (if (eq last-command 'vip-cycle-through-mark-ring)
+           ()
+         ;; save current mark if the first iteration
+         (setq mark-ring (delete (vip-mark-marker) mark-ring))
+         (if (mark t)
+             (push-mark (mark t) t)) )
+       (pop-mark)
+       (set-mark-command 1)
+       ;; don't duplicate mark on the ring
+       (setq mark-ring (delete (vip-mark-marker) mark-ring))
+       (push-mark sv-pt t)
+       (vip-deactivate-mark)
+       (setq this-command 'vip-cycle-through-mark-ring)
+       ))
+       
+
+(defun vip-goto-mark (arg)
+  "Go to mark."
+  (interactive "P")
+  (let ((char (read-char))
+        (com (vip-getcom arg)))
+    (vip-goto-mark-subr char com nil)))
+
+(defun vip-goto-mark-and-skip-white (arg)
+  "Go to mark and skip to first non-white character on line."
+  (interactive "P")
+  (let ((char (read-char))
+        (com (vip-getCom arg)))
+    (vip-goto-mark-subr char com t)))
+
+(defun vip-goto-mark-subr (char com skip-white)
+  (if (eobp) 
+      (if (bobp)
+          (error "Empty buffer")
+        (backward-char 1)))
+  (cond ((vip-valid-register char '(letter))
+         (let* ((buff (current-buffer))
+                (reg (1+ (- char ?a)))
+                (text-marker (get-register reg)))
+           (if com (vip-move-marker-locally 'vip-com-point (point)))
+           (if (not (vip-valid-marker text-marker))
+              (error (format vip-EmptyTextmarker char)))
+           (if (and (vip-same-line (point) vip-last-jump)
+                    (= (point) vip-last-jump-ignore))
+               (push-mark vip-last-jump t) 
+             (push-mark nil t)) ; no msg
+           (vip-register-to-point reg)
+           (setq vip-last-jump (point-marker))
+           (cond (skip-white 
+                  (back-to-indentation)
+                  (setq vip-last-jump-ignore (point))))
+           (if com
+               (if (equal buff (current-buffer))
+                   (vip-execute-com (if skip-white
+                                        'vip-goto-mark-and-skip-white
+                                      'vip-goto-mark)
+                                    nil com)
+                 (switch-to-buffer buff)
+                 (goto-char vip-com-point)
+                 (vip-change-state-to-vi)
+                 (error "")))))
+        ((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 (= (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)))
+        ((and 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 (= (point) (mark t)) (pop-mark))
+         (exchange-point-and-mark)
+         (setq vip-last-jump (point))
+         (back-to-indentation)
+         (setq vip-last-jump-ignore (point))
+         (if com (vip-execute-com 'vip-goto-mark-and-skip-white nil com)))
+        (t (error vip-InvalidTextmarker char))))
+        
+(defun vip-insert-tab ()
+  (interactive)
+  (insert-tab))
+
+(defun vip-exchange-point-and-mark ()
+  (interactive)
+  (exchange-point-and-mark)
+  (back-to-indentation))
+
+;; Input Mode Indentation
+
+(defun vip-forward-indent ()
+  "Indent forward -- `C-t' in Vi."
+  (interactive)
+  (setq vip-cted t)
+  (indent-to (+ (current-column) vip-shift-width)))
+
+(defun vip-backward-indent ()
+  "Backtab, C-d in VI"
+  (interactive)
+  (if vip-cted
+      (let ((p (point)) (c (current-column)) bol (indent t))
+        (if (vip-looking-back "[0^]")
+            (progn
+              (if (= ?^ (preceding-char)) (setq vip-preserve-indent t))
+              (delete-backward-char 1)
+              (setq p (point))
+              (setq indent nil)))
+        (save-excursion
+          (beginning-of-line)
+          (setq bol (point)))
+        (if (re-search-backward "[^ \t]" bol 1) (forward-char))
+        (delete-region (point) p)
+        (if indent
+            (indent-to (- c vip-shift-width)))
+        (if (or (bolp) (vip-looking-back "[^ \t]"))
+            (setq vip-cted nil)))))
+
+(defun vip-autoindent ()
+  "Auto Indentation, Vi-style."
+  (interactive)
+  (let ((col (current-indentation)))
+    (if (not vip-preserve-indent)
+        (setq vip-current-indent col)
+      (setq vip-preserve-indent nil))
+    (newline 1)
+    (if vip-auto-indent
+        (progn
+          (setq vip-cted t)
+          (indent-to vip-current-indent)))))
+
+           
+;; Viewing registers
+
+(defun vip-ket-function (arg)
+  "Function called by \], the ket. View registers and call \]\]."
+  (interactive "P")
+  (let ((reg (read-char)))
+    (cond ((vip-valid-register reg '(letter Letter))
+           (view-register (downcase reg)))
+          ((vip-valid-register reg '(digit))
+           (let ((text (current-kill (- reg ?1) 'do-not-rotate)))
+             (save-excursion 
+               (set-buffer (get-buffer-create "*Output*"))
+               (delete-region (point-min) (point-max))
+               (insert (format "Register %c contains the string:\n" reg))
+               (insert text)
+               (goto-char (point-min)))
+             (display-buffer "*Output*")))
+          ((= ?\] reg)
+           (vip-next-heading arg))
+          (t (error
+              vip-InvalidRegister reg)))))
+
+(defun vip-brac-function (arg)
+  "Function called by \[, the brac. View textmarkers and call \[\["
+  (interactive "P")
+  (let ((reg (read-char)))
+    (cond ((= ?\[ reg)
+           (vip-prev-heading arg))
+          ((= ?\] reg)
+           (vip-heading-end arg))
+          ((vip-valid-register reg '(letter))
+           (let* ((val (get-register (1+ (- reg ?a))))
+                  (buf (if (not val) 
+                           (error 
+                            (format vip-EmptyTextmarker reg))
+                         (marker-buffer val)))
+                  (pos (marker-position val))
+                  line-no text (s pos) (e pos))
+             (save-excursion 
+               (set-buffer (get-buffer-create "*Output*"))
+               (delete-region (point-min) (point-max))
+               (if (and buf pos)
+                   (progn
+                     (save-excursion 
+                       (set-buffer buf)
+                       (setq line-no (1+ (count-lines (point-min) val)))
+                       (goto-char pos)
+                       (beginning-of-line)
+                       (if (re-search-backward "[^ \t]" nil t)
+                           (progn
+                             (beginning-of-line)
+                             (setq s (point))))
+                       (goto-char pos)
+                       (forward-line 1)
+                       (if (re-search-forward "[^ \t]" nil t)
+                           (progn
+                             (end-of-line)
+                             (setq e (point))))
+                       (setq text (buffer-substring s e))
+                       (setq text (format "%s<%c>%s" 
+                                          (substring text 0 (- pos s)) 
+                                          reg (substring text (- pos s)))))
+                     (insert
+                      (format
+                       "Textmarker `%c' is in buffer `%s' at line %d.\n"
+                                     reg (buffer-name buf) line-no))
+                     (insert (format "Here is some text around %c:\n\n %s" 
+                                     reg text)))
+                 (insert (format vip-EmptyTextmarker reg)))
+               (goto-char (point-min)))
+             (display-buffer "*Output*")))
+          (t (error vip-InvalidTextmarker reg)))))
+  
+
+
+;; commands in insertion mode
+
+(defun vip-delete-backward-word (arg)
+  "Delete previous word."
+  (interactive "p")
+  (save-excursion
+    (push-mark nil t)
+    (backward-word arg)
+    (delete-region (point) (mark t))
+    (pop-mark)))
+
+
+(defun vip-set-expert-level (&optional dont-change-unless)
+  "Sets the expert level for a Viper user.
+Can be called interactively to change (temporarily or permanently) the
+current expert level.
+
+The optional argument DONT-CHANGE-UNLESS if not nil, says that
+the level should not be changed, unless its current value is
+meaningless (i.e., not one of 1,2,3,4,5).
+
+User level determines the setting of Viper variables that are most
+sensitive for VI-style look-and-feel."
+  
+  (interactive)
+  
+  (if (not (numberp vip-expert-level)) (setq vip-expert-level 0))
+  
+  (save-window-excursion
+    (delete-other-windows)
+    ;; if 0 < vip-expert-level < vip-max-expert-level
+    ;;    & dont-change-unless = t -- use it; else ask
+    (vip-ask-level dont-change-unless))
+  
+  (setq vip-always                      t
+        vip-ex-style-motion             t
+        vip-ex-style-editing-in-insert  t
+        vip-want-ctl-h-help nil)
+
+  (cond
+        ;; a novice or a beginner
+        ((eq vip-expert-level 1)
+         (global-set-key vip-toggle-key   ;; in emacs-state
+                         (if window-system
+                             '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))
+         (setq vip-no-multiple-ESC           (if window-system 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
+                                     ; and vip-no-multiple-ESC
+             (progn
+               (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
+                                         vip-saved-user-settings)))
+               (setq vip-ex-style-motion 
+                     (cdr (assoc 'vip-ex-style-motion vip-saved-user-settings))
+                     vip-ex-style-editing-in-insert
+                     (cdr (assoc 'vip-ex-style-editing-in-insert
+                                 vip-saved-user-settings))
+                     vip-re-search
+                     (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
+        ;; Ideally, if 5 is selected, a buffer should pop up to let the
+        ;; user toggle variable values.
+        (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
+                                     vip-saved-user-settings)))
+           (setq  vip-want-ctl-h-help 
+                  (cdr (assoc 'vip-want-ctl-h-help vip-saved-user-settings))
+                  vip-always
+                  (cdr (assoc 'vip-always vip-saved-user-settings))
+                  vip-no-multiple-ESC 
+                  (cdr (assoc 'vip-no-multiple-ESC vip-saved-user-settings))
+                  vip-ex-style-motion 
+                  (cdr (assoc 'vip-ex-style-motion vip-saved-user-settings))
+                  vip-ex-style-editing-in-insert
+                  (cdr (assoc 'vip-ex-style-editing-in-insert
+                              vip-saved-user-settings))
+                  vip-re-search
+                  (cdr (assoc 'vip-re-search vip-saved-user-settings))
+                  vip-want-emacs-keys-in-vi 
+                  (cdr (assoc 'vip-want-emacs-keys-in-vi
+                              vip-saved-user-settings))
+                  vip-want-emacs-keys-in-insert
+                  (cdr (assoc 'vip-want-emacs-keys-in-insert
+                              vip-saved-user-settings)))))
+  (vip-set-mode-vars-for vip-current-state)
+  (if (or vip-always
+          (and (> vip-expert-level 0) (> 5 vip-expert-level)))
+      (vip-set-hooks)))
+
+(defun vip-ask-level (dont-change-unless)
+  "Ask user expert level."
+  (let ((ask-buffer " *vip-ask-level*")
+        level-changed repeated)
+    (save-window-excursion
+      (switch-to-buffer ask-buffer)
+              
+      (or (eq this-command 'vip-set-expert-level)
+          (and
+           (<= vip-expert-level vip-max-expert-level)
+           (>= vip-expert-level 1))
+          (progn
+            (insert "
+              
+              *** Important Notice for VIP users***
+              
+                          This is VIPER
+              
+@joke
+Viper Is a Package for Emacs Rebels,
+a VI Plan for Emacs Rescue,
+and a venomous VI PERil.
+@end joke
+
+Technically speaking, Viper is a new Vi emulator that replaces
+the old VIP package.
+
+Viper emulates Vi much better than VIP.  It also significantly
+extends and improves upon Vi in many useful ways.
+
+Although many VIP settings in your ~/.vip are compatible with Viper,
+you may have to change some of them. Please refer to the documentation,
+which can be obtained by executing
+
+:help
+
+when Viper is in Vi state.
+
+If you will be so lucky as to find a bug, report it via the command
+
+:submitReport
+
+Type any key to continue... ")
+            
+            (read-char)
+            (erase-buffer)))
+              
+      (while (or (> vip-expert-level vip-max-expert-level)
+                 (< vip-expert-level 1)
+                 (null dont-change-unless))
+        (erase-buffer)
+        (if repeated
+            (progn
+              (message "Invalid user level")
+              (beep 1))
+          (setq repeated t))
+        (setq dont-change-unless t
+              level-changed t)
+        (insert "
+Please specify your level of familiarity with the venomous VI PERil
+(and the VI Plan for Emacs Rescue).
+You can change it at any time by typing `M-x vip-set-expert-level RET'
+        
+ 1 -- BEGINNER: Almost all Emacs features are suppressed.
+          Feels almost like straight Vi. File name completion and
+          command history in the minibuffer are thrown in as a bonus. 
+          To use Emacs productively, you must reach level 3 or higher.
+ 2 -- MASTER: C-c now has its standard Emacs meaning in Vi command state,
+          so most Emacs commands can be used when Viper is in Vi state.
+          Good progress---you are well on the way to level 3!
+ 3 -- GRAND MASTER: Like 3, but most Emacs commands are available also
+          in Viper's insert state.
+ 4 -- GURU: Like 3, but user settings are respected for vip-no-multiple-ESC,
+          vip-re-search, vip-ex-style-motion, & vip-ex-style-editing-in-insert
+          variables. Adjust these settings to your taste.
+ 5 -- WIZARD: Like 4, but user settings are also respected for vip-always,
+          vip-want-ctl-h-help, vip-want-emacs-keys-in-vi, and 
+          vip-want-emacs-keys-in-insert. Adjust these to your taste.
+      
+Please, specify your level now: ")
+          
+        (setq vip-expert-level (- (vip-read-char-exclusive) ?0))
+        ) ; end while
+      
+      ;; tell the user if level was changed
+      (and level-changed
+           (progn
+             (insert
+              (format "\n\n\n\n\n\t\tYou have selected user level %d"
+                      vip-expert-level))
+             (if (y-or-n-p "Do you wish to make this change permanent? ")
+                 ;; save the setting for vip-expert-level
+                 (vip-save-setting
+                  'vip-expert-level
+                  (format "Saving user level %d ..." vip-expert-level)
+                  vip-custom-file-name))
+             ))
+      (bury-buffer) ; remove ask-buffer from screen
+      (message "")
+      )))
+
+
+(defun viper-version ()
+  (interactive)
+  (message "Viper version is %s" viper-version)) 
+  
+(defalias 'vip-version 'viper-version)
+
+(defun vip-nil ()
+  (interactive)
+  (beep 1))
+  
+
+;; Returns t, if the string before point matches the regexp STR.
+(defsubst vip-looking-back (str)
+  (and (save-excursion (re-search-backward str nil t))
+       (= (point) (match-end 0))))
+
+    
+    
+;; if ENFORCE-BUFFER is not nil, error if CHAR is a marker in another buffer
+(defun vip-register-to-point (char &optional enforce-buffer)
+  "Like jump-to-register, but switches to another buffer in another window."
+  (interactive "cViper register to point: ")
+  (let ((val (get-register char)))
+    (cond
+     ((and (fboundp 'frame-configuration-p)
+           (frame-configuration-p val))
+      (set-frame-configuration val))
+     ((window-configuration-p val)
+      (set-window-configuration val))
+     ((vip-valid-marker val)
+      (if (and enforce-buffer
+               (not (equal (current-buffer) (marker-buffer val))))
+          (error (concat vip-EmptyTextmarker " in this buffer")
+                 (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 vip-EmptyTextmarker (1- (+ char ?a)))))))
+
+
+(defun vip-save-kill-buffer ()
+  "Save then kill current buffer. "
+  (interactive)
+  (if (< vip-expert-level 2)
+      (save-buffers-kill-emacs)
+    (save-buffer)
+    (kill-buffer (current-buffer))))
+
+
+
+;;; Bug Report
+
+(defun vip-submit-report ()
+  "Submit bug report on Viper."
+  (interactive)
+  (let ((reporter-prompt-for-summary-p t)
+        color-display-p frame-parameters
+        minibuffer-emacs-face minibuffer-vi-face minibuffer-insert-face
+        varlist salutation window-config)
+    
+    ;; If mode info is needed, add variable to `let' and then set it below,
+    ;; like we did with color-display-p.
+    (setq color-display-p (if window-system 
+                              (vip-display-color-p)
+                            'non-x)
+          minibuffer-vi-face (if window-system
+                                 (vip-get-face vip-minibuffer-vi-face)
+                               'non-x)
+          minibuffer-insert-face (if window-system
+                                     (vip-get-face vip-minibuffer-insert-face)
+                                   'non-x)
+          minibuffer-emacs-face (if window-system
+                                    (vip-get-face vip-minibuffer-emacs-face)
+                                  'non-x)
+          frame-parameters (if (fboundp 'vip-frame-parameters)
+                               (vip-frame-parameters (vip-selected-frame))))
+    
+    (setq varlist (list 'vip-vi-minibuffer-minor-mode
+                        'vip-insert-minibuffer-minor-mode
+                        'vip-vi-intercept-minor-mode
+                        'vip-vi-local-user-minor-mode     
+                        'vip-vi-kbd-minor-mode          
+                        'vip-vi-global-user-minor-mode
+                        'vip-vi-state-modifier-minor-mode
+                        'vip-vi-diehard-minor-mode   
+                        'vip-vi-basic-minor-mode    
+                        'vip-replace-minor-mode           
+                        'vip-insert-intercept-minor-mode
+                        'vip-insert-local-user-minor-mode 
+                        'vip-insert-kbd-minor-mode      
+                        'vip-insert-global-user-minor-mode
+                        'vip-insert-state-modifier-minor-mode
+                        'vip-insert-diehard-minor-mode  
+                        'vip-insert-basic-minor-mode   
+                        'vip-emacs-intercept-minor-mode 
+                        'vip-emacs-local-user-minor-mode 
+                        'vip-emacs-kbd-minor-mode 
+                        'vip-emacs-global-user-minor-mode
+                        'vip-emacs-state-modifier-minor-mode
+                        'vip-automatic-iso-accents
+                        'vip-want-emacs-keys-in-insert
+                        'vip-want-emacs-keys-in-vi
+                        'vip-keep-point-on-undo
+                        'vip-no-multiple-ESC
+                        'vip-ESC-key
+                        'vip-want-ctl-h-help
+                        'vip-ex-style-editing-in-insert
+                        'vip-delete-backwards-in-replace
+                        'vip-vi-style-in-minibuffer
+                        'vip-vi-state-hooks
+                        'vip-insert-state-hooks
+                        'vip-replace-state-hooks
+                        'vip-emacs-state-hooks
+                        'ex-cycle-other-window
+                        'ex-cycle-through-non-files
+                        'vip-expert-level
+                        'major-mode
+                        'window-system
+                        'color-display-p
+                        'frame-parameters
+                        'minibuffer-vi-face
+                        'minibuffer-insert-face
+                        'minibuffer-emacs-face
+                        ))
+          (setq salutation "
+Congratulations! You may have unearthed a bug in Viper!
+Please mail a concise, accurate summary of the problem to the address above.
+
+-------------------------------------------------------------------")
+          (setq window-config (current-window-configuration))
+          (with-output-to-temp-buffer " *vip-info*"
+            (switch-to-buffer " *vip-info*")
+            (delete-other-windows)
+            (princ "
+PLEASE FOLLOW THESE PROCEDURES
+------------------------------
+
+Before reporting a bug, please verify that it is related to Viper, and is
+not cause by other packages you are using.
+
+Don't report compilation warnings, unless you are certain that there is a
+problem. These warnings are normal and unavoidable.
+
+Please note that users should not modify variables and keymaps other than
+those advertised in the manual. Such `customization' is likely to crash
+Viper, as it would any other improperly customized Emacs package.
+
+If you are reporting an error message received while executing one of the
+Viper commands, type:
+
+    M-x set-variable <Return> debug-on-error <Return> t <Return>
+        
+Then reproduce the error. The above command will cause Emacs to produce a
+back trace of the execution that leads to the error. Please include this
+trace in your bug report.
+
+If you believe that one of Viper's commands goes into an infinite loop
+\(e.g., Emacs freezes\), type:
+
+    M-x set-variable <Return> debug-on-quit <Return> t <Return>
+        
+Then reproduce the problem. Wait for a few seconds, then type C-g to abort
+the current command. Include the resulting back trace in the bug report.
+
+Mail anyway (y or n)? ")
+            (if (y-or-n-p "Mail anyway? ")
+                ()
+              (set-window-configuration window-config)
+              (error "Bug report aborted")))
+
+          (require 'reporter)
+          (set-window-configuration window-config)
+    
+          (reporter-submit-bug-report "kifer@cs.sunysb.edu"
+                                      (vip-version)
+                                      varlist
+                                      nil 'delete-other-windows
+                                      salutation)
+          ))
+                    
+
+    
+                
+;; Needed to smooth out the difference between Emacs' unread-command-events
+;; and XEmacs unread-command-event. Arg is a character, an event, a list of
+;; events or a sequence of keys.
+;; The semantics of placing an event on unread-command-event in XEmacs is
+;; not the same as placing (setq unread-command-event event)
+;; on the event queue using enqueue-eval-event. For instance, an event
+;; sitting in unread-command-event will be available to (next-event).
+;; In contrast, evals placed on event queue are not evaluated until all
+;; previous commands have been executed. This makes a difference when one
+;; of the events placed on the event queue is bound to a function that
+;; pauses for input, because these evals won't make input immediately
+;; available
+;;
+;; Due to a bug in unread-command-events, a non-event symbol in
+;; unread-command-evets list may cause Emacs to label this symbol to be an
+;; event. Below, we delete nil from event lists, since nil is the most
+;; common problem here. Hopefully, unread-command-evets will be fixed in
+;; the next release.
+(defun vip-set-unread-command-events (arg)
+  (if vip-emacs-p
+      (setq unread-command-events
+            (let ((new-events
+                   (cond ((eventp arg) (list arg))
+                         ((listp arg) arg)
+                         ((sequencep arg)
+                          (listify-key-sequence arg))
+                         (t (error
+                             "vip-set-unread-command-events: Invalid arg, %S"
+                             arg)))))
+              (if (not (eventp nil))
+                  (setq new-events (delq nil new-events)))
+              (append new-events unread-command-events)))
+    ;; XEmacs
+    (cond ((numberp arg)
+           (setq unread-command-event (character-to-event arg)))
+          ((eventp arg)
+           (setq unread-command-event arg))
+          ((sequencep arg)
+           (let ((length (length arg))
+                 (count 0))
+             (while (< count length)
+               (enqueue-eval-event
+                'vip-fudge-event-list-in-xemacs
+                (if (stringp arg) 
+                    (character-to-event (elt arg count))
+                  (elt arg count)))
+               (setq count (1+ count))
+               ) ; while
+             (if (> length 0)
+                 (or arg unread-command-event))))
+          (t (error "vip-set-unread-command-events: Invalid argument")))))
+  
+(defun vip-fudge-event-list-in-xemacs (arg)
+  (setq unread-command-event arg))
+  
+
+;;; Bring in the rest of the files
+(require 'viper-mous)
+(require 'viper-macs)
+(require 'viper-ex)
+
+
+
+;; The following is provided for compatibility with older VIP's
+
+(defalias 'vip-change-mode-to-vi 'vip-change-state-to-vi)
+(defalias 'vip-change-mode-to-insert 'vip-change-state-to-insert)
+(defalias 'vip-change-mode-to-emacs 'vip-change-state-to-emacs)
+
+;; This was the main Vi mode in old versions of VIP which may have been
+;; extensively used by VIP users. We declare it as a global var
+;; and, after .vip is loaded, we add this keymap to vip-vi-basic-map.
+(defvar vip-mode-map (make-sparse-keymap)
+  "This was the main Vi-mode keymap in the old versions of VIP.
+Viper provides this variable for compatibility. Whatever the user defines
+for this map, is merged into Viper's vip-vi-basic-map after loading .vip")
+   
+
+
+;; Load .vip and setup hooks
+(defun vip-shell-mode-hook ()
+  "Hook specifically designed to enable Vi-style editing in shell mode."
+  (setq vip-add-newline-at-eob nil)
+  ;; this is nicer in shell mode
+  (setq vip-ex-style-editing-in-insert nil
+        vip-ex-style-motion nil)
+  (vip-add-local-keys 'vi-state
+                      '(("\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 vip-state.
+(defun vip-set-hooks ()
+  
+  ;; It is of course a misnomer to call viper-mode a `major mode'.
+  ;; 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.
+  (setq default-major-mode 'viper-mode)
+  
+  (defadvice fundamental-mode (after vip-fundamental-mode-ad activate)
+    (vip-change-state-to-vi))
+  
+  ;; The following major modes should come up in vi-state
+  (defvar emacs-lisp-mode-hook nil)
+  (add-hook 'emacs-lisp-mode-hook 'viper-mode)
+  
+  (defvar lisp-mode-hook nil)
+  (add-hook 'lisp-mode-hook 'viper-mode)
+  
+  (defvar bibtex-mode-hook nil)                         
+  (add-hook 'bibtex-mode-hook 'viper-mode)        
+      
+  (defvar cc-mode-hook nil)
+  (add-hook 'cc-mode-hook 'viper-mode)
+      
+  (defvar c-mode-hook nil)
+  (add-hook 'c-mode-hook 'viper-mode)
+      
+  (defvar c++-mode-hook nil)
+  (add-hook 'c++-mode-hook 'viper-mode)
+  
+  (defvar lisp-interaction-mode-hook nil)
+  (add-hook 'lisp-interaction-mode-hook 'viper-mode)
+      
+  (defvar text-mode-hook nil)
+  (add-hook 'text-mode-hook 'viper-mode)
+      
+  (add-hook 'completion-list-mode-hook 'viper-mode)  
+  (add-hook 'compilation-mode-hook     'viper-mode)  
+  
+  (defvar emerge-startup-hook nil)
+  (add-hook 'emerge-startup-hook 'vip-change-state-to-emacs)
+  ;; Run vip-change-state-to-vi after quitting emerge.
+  (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)))
+  ;; In case Emerge was loaded before Viper.
+  (defadvice emerge-quit (after vip-emerge-advice activate)
+                     "Run vip-change-state-to-vi after quitting emerge."
+                     (vip-change-state-to-vi))
+  
+  (vip-eval-after-load "asm-mode"
+                       '(defadvice asm-mode (after vip-asm-mode-ad activate)
+                       "Run vip-change-state-to-vi on entry."
+                       (vip-change-state-to-vi)))
+  
+  ;; passwd.el sets up its own buffer, which turns up in Vi mode,
+  ;; overriding the local map. Noone needs Vi mode here.
+  (vip-eval-after-load
+   "passwd"
+   '(defadvice read-passwd-1 (before vip-passwd-ad activate)
+      "Vi-ism is prohibited when reading passwords, so switch to Emacs."
+      (vip-change-state-to-emacs)))
+  
+  ;; Emacs shell
+  (defvar shell-mode-hook nil)
+  (add-hook 'shell-mode-hook 'vip-change-state-to-insert)
+  (add-hook 'shell-mode-hook 'vip-shell-mode-hook)
+  
+  ;; Shell scripts
+  (defvar sh-mode-hook nil)
+  (add-hook 'sh-mode-hook 'viper-mode)
+  
+  ;; Dired
+  ;; This is only necessary when the user uses vip-modify-major-mode
+  (add-hook 'dired-mode-hook 'vip-change-state-to-emacs)
+
+  (defvar view-hook nil
+    "View hook. Run after view mode.")
+  (add-hook 'view-hook 'vip-change-state-to-emacs)
+  
+  ;; For VM users.
+  ;; Put summary and other VM buffers in Emacs state.
+  (defvar vm-mode-hooks nil 
+    "This hook is run after vm is started.")
+  (defvar vm-summary-mode-hooks nil 
+    "This hook is run after vm switches to summary mode.")
+  (add-hook 'vm-mode-hooks   'vip-change-state-to-emacs)
+  (add-hook 'vm-summary-mode-hooks   'vip-change-state-to-emacs)
+  
+  ;; For RMAIL users.
+  ;; Put buf in Emacs state after edit.
+  (vip-eval-after-load
+   "rmailedit"
+   '(defadvice rmail-cease-edit (after vip-rmail-advice activate)
+      "Switch buffer to emacs-state  after finishing with editing a message."
+      (vip-change-state-to-emacs)))
+  ;; In case RMAIL was loaded before Viper.
+  (defadvice rmail-cease-edit (after vip-rmail-advice activate)
+      "Switch buffer to emacs-state after finishing with editing a message."
+      (vip-change-state-to-emacs))
+  ) ; vip-set-hooks
+      
+
+;; ~/.vip is loaded if it exists
+(if (and (file-exists-p vip-custom-file-name)
+         (not noninteractive))
+    (load vip-custom-file-name))
+
+;; VIP compatibility: merge whatever the user has in vip-mode-map into
+;; Viper's basic map.
+(vip-add-keymap vip-mode-map vip-vi-global-user-map)
+
+
+;; Applying Viper customization -- runs after (load .vip)
+
+;; Save user settings or Viper defaults for vars controled by vip-expert-level
+(setq vip-saved-user-settings 
+      (list (cons 'vip-want-ctl-h-help vip-want-ctl-h-help)
+            (cons 'vip-always vip-always)
+            (cons 'vip-no-multiple-ESC vip-no-multiple-ESC)
+            (cons 'vip-ex-style-motion vip-ex-style-motion)
+            (cons 'vip-ex-style-editing-in-insert
+                                            vip-ex-style-editing-in-insert) 
+            (cons 'vip-want-emacs-keys-in-vi vip-want-emacs-keys-in-vi)
+            (cons 'vip-want-emacs-keys-in-insert vip-want-emacs-keys-in-insert)
+            (cons 'vip-re-search vip-re-search)))
+              
+
+(vip-set-minibuffer-style)
+(vip-set-minibuffer-faces)
+(vip-set-search-face)
+   
+;;; Familiarize Viper with some minor modes that have their own keymaps
+(vip-harness-minor-mode "compile")
+(vip-harness-minor-mode "outline")
+(vip-harness-minor-mode "allout")
+(vip-harness-minor-mode "xref")
+(vip-harness-minor-mode "lmenu")
+(vip-harness-minor-mode "vc")
+(vip-harness-minor-mode "ltx-math") ; LaTeX-math-mode in AUC-TeX
+(vip-harness-minor-mode "latex")    ; latex they moved math mode here
+
+
+;; Intercept maps could go in viper-keym.el
+;; We keep them here in case someone redefines them in ~/.vip
+
+(define-key vip-vi-intercept-map vip-ESC-key 'vip-intercept-ESC-key)
+(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
+  '(lambda () (interactive)
+     (if (and (< vip-expert-level 2) (equal vip-toggle-key "\C-z"))
+         (if window-system (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)))
+    (vip-set-hooks))
+    
+;; Let all minor modes take effect after loading
+;; this may not be enough, so we also set default minor-mode-alist.
+;; Without setting the default, new buffers that come up in emacs mode have
+;; minor-mode-map-alist = nil, unless we call vip-change-state-*
+(if (eq vip-current-state 'emacs-state)
+    (progn
+      (vip-change-state-to-emacs)
+      (setq-default minor-mode-map-alist minor-mode-map-alist)
+      ))
+    
+;; set some useful macros
+
+;; repeat the 2nd previous command without rotating the command history
+(vip-record-kbd-macro
+ (vector vip-repeat-from-history-key '\1) '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)
+;; 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
+(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)
+ 
+
+(run-hooks 'vip-load-hooks) ; the last chance to change anything
+
+(provide 'viper)
+(provide 'vip19)
+(provide 'vip)
+
+;;;  viper.el ends here
+