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

comparison lisp/viper/viper.el @ 14:9ee227acff29 r19-15b90

Import from CVS: tag r19-15b90

author	cvs
date	Mon, 13 Aug 2007 08:48:42 +0200
parents	bcdc7deadc19
children	0293115a14e9

comparison

equal deleted inserted replaced

-:13c6d0aaafe5
+:9ee227acff29
 ;;  Keywords: emulations
 ;;  Author: Michael Kifer <kifer@cs.sunysb.edu>
 ;; Copyright (C) 1994, 1995, 1996 Free Software Foundation, Inc.
-(defconst viper-version "2.91 of August 5, 1996"
+(defconst viper-version "2.92 of January 3, 1997"
 "The current version of Viper")
 ;; This file is part of GNU Emacs.
 ;; GNU Emacs is free software; you can redistribute it and/or modify
 (require 'advice)
 (require 'cl)
 (require 'ring)
-(require 'viper-util)
+(provide 'viper)
 ;; Compiler pacifier
 (defvar vip-minibuffer-current-face)
 (defvar vip-minibuffer-insert-face)
 (defvar vip-minibuffer-vi-face)
 (defvar vip-minibuffer-emacs-face)
 (defvar iso-accents-mode)
 (defvar zmacs-region-stays)
+(defvar mark-even-if-inactive)
+(eval-when-compile
+(let ((load-path (cons "." load-path)))
+(or (featurep 'viper-util)
+	(load "viper-util.el" nil nil 'nosuffix))
+(or (featurep 'viper-keym)
+	(load "viper-keym.el" nil nil 'nosuffix))
+(or (featurep 'viper-mous)
+	(load "viper-mous.el" nil nil 'nosuffix))
+(or (featurep 'viper-macs)
+	(load "viper-macs.el" nil nil 'nosuffix))
+(or (featurep 'viper-ex)
+	(load "viper-ex.el" nil nil 'nosuffix))
+))
 ;; end pacifier
+(require 'viper-util)
+(require 'viper-keym)
+(require 'viper-mous)
+(require 'viper-macs)
+(require 'viper-ex)
 ;;; Variables
 ;; Is t until viper-mode executes for the very first time.
 ;; 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
-;; This must be local because although the stack of minor modes can be the same
-;; for all buffers, the associated *keymaps* can be different. In Viper,
-;; vip-vi-local-user-map, vip-insert-local-user-map, and others can have
-;; different keymaps for different buffers.
-;; Also, the keymaps associated with vip-vi/insert-state-modifier-minor-mode
-;; can be different.
-(make-variable-buffer-local 'minor-mode-map-alist)
-;; Mode for vital things like \e, C-z.
-(vip-deflocalvar vip-vi-intercept-minor-mode nil)
-(vip-deflocalvar vip-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 in 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
 (vip-deflocalvar 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)
 ;; 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"
 "*Cursor color to use in Replace state")
 (defvar vip-insert-state-cursor-color nil
 "Cursor color for Viper insert state.")
 (put 'vip-insert-state-cursor-color 'permanent-local t)
 ;; place to save cursor colow when switching to insert mode
 (vip-deflocalvar vip-saved-cursor-color nil "")
 (vip-deflocalvar vip-replace-overlay nil "")
 (put 'vip-replace-overlay 'permanent-local t)
 (defvar vip-replace-overlay-pixmap "gray3"
 "Pixmap to use for search face on non-color displays.")
 ;; Modes and related variables
 ;; Current mode.  One of: `emacs-state', `vi-state', `insert-state'
 (vip-deflocalvar vip-current-state 'emacs-state)
-(defvar vip-no-multiple-ESC  t
-"*If true, multiple ESC in Vi mode will cause bell to ring.
-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 "")
 ;; If t, search is forward.
 (defvar vip-s-forward nil)
 (defconst vip-case-fold-search nil
-"*If not nil, search ignores case.")
+"*If not nil, search ignores cases.")
 (defconst vip-re-search t
 "*If not nil, search is reg-exp search, otherwise vanilla search.")
-(defvar vip-adjust-window-after-search t
+(defvar vip-search-scroll-threshold 2
-"*If not nil, pull the window up or down, depending on the direction of the
+"*If search lands within this threshnold from the window top/bottom,
-search, if search ends up near the bottom or near the top of the window.")
+the window will be scrolled up or down appropriately, to reveal context.
+If you want Viper search to behave as usual in Vi, set this variable to a
+negative number.")
 (defconst vip-re-query-replace t
 "*If t then do regexp replace, if nil then do string replace.")
 (defconst vip-re-replace t
 ;; 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
 ;; History of search strings.
 (defvar vip-search-history  (list ""))
 "Spell function used by #s<move> command to spell.")
 (defvar vip-tags-file-name "TAGS"
 "The tags file used by Viper.")
+;; Indicates if we are in the middle of executing a command that takes another
+;; command as an argument, e.g., cw, dw, etc.
+(defvar vip-inside-command-argument-action nil)
 ;; Minibuffer
 (defvar vip-vi-style-in-minibuffer t
 "If t, use vi-style editing in minibuffer.
 Should be set in `~/.vip' file.")
 ;; 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.")
 ;; setup emacs-supported vi-style feel
 (setq next-line-add-newlines nil
 require-final-newline t)
 (make-variable-buffer-local 'require-final-newline)
 ;; Variables for defining VI commands
 ;; Modifying commands that can be prefixes to movement commands
 (defconst vip-prefix-commands '(?c ?d ?y ?! ?= ?# ?< ?> ?\"))
+;; define vip-prefix-command-p
 (vip-test-com-defun vip-prefix-command)
 ;; Commands that are pairs eg. dd. r and R here are a hack
 (defconst vip-charpair-commands '(?c ?d ?y ?! ?= ?< ?> ?r ?R))
+;; define vip-charpair-command-p
 (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")
+;; define vip-movement-command-p
 (vip-test-com-defun vip-movement-command)
 ;; Commands that can be repeated by . (dotted)
-(defconst vip-dotable-commands '(?c ?d ?C ?D ?> ?<))
+(defconst vip-dotable-commands '(?c ?d ?C ?s ?S ?D ?> ?<))
+;; define vip-dotable-command-p
 (vip-test-com-defun vip-dotable-command)
 ;; Commands that can follow a #
-(defconst vip-hash-cmds '(?c ?C ?g ?q ?S))
+(defconst vip-hash-commands '(?c ?C ?g ?q ?s))
-(vip-test-com-defun vip-hash-cmd)
+;; define vip-hash-command-p
+(vip-test-com-defun vip-hash-command)
 ;; Commands that may have registers as prefix
 (defconst vip-regsuffix-commands '(?d ?y ?Y ?D ?p ?P ?x ?X))
+;; define vip-regsuffix-command-p
 (vip-test-com-defun vip-regsuffix-command)
 (defconst vip-vi-commands (append vip-movement-commands
 				  vip-dotable-commands
 				  vip-charpair-commands
-				  vip-hash-cmds
+				  vip-hash-commands
 				  vip-prefix-commands
 				  vip-regsuffix-commands)
 "The list of all commands in Vi-state.")
+;; define vip-vi-command-p
 (vip-test-com-defun vip-vi-command)
-;;; Arrange the keymaps
-(require 'viper-keym)
 ;;; CODE
 ;; sentinels
 (defsubst vip-replace-state-pre-command-sentinel ()
 (or (memq this-command '(self-insert-command))
 (memq (vip-event-key last-command-event)
 	    '(up down left right (meta f) (meta b)
 		 (control n) (control p) (control f) (control b)))
-(vip-restore-cursor-color)))
+(vip-restore-cursor-color-after-replace)))
 (defun vip-replace-state-post-command-sentinel ()
 ;; Restoring cursor color is needed despite
 ;; vip-replace-state-pre-command-sentinel: When one jumps to another buffer
 ;; in another frame, the pre-command hook won't change cursor color to
 	       (define-key vip-replace-map [(control h)] 'help-command))
 	   (define-key vip-insert-basic-map
 	     [(control h)] 'vip-del-backward-char-in-insert)
 	   (define-key vip-replace-map
 	     [(control h)] 'vip-del-backward-char-in-replace)))
 	(t ; Vi state
 	 (setq vip-vi-diehard-minor-mode (not vip-want-emacs-keys-in-vi))
 	 (if vip-want-ctl-h-help
 	     (define-key vip-vi-basic-map [(control h)] 'help-command)
 	   (define-key vip-vi-basic-map [(control h)] 'vip-backward-char)))
 ;; keys `,',^ in Vi state, as they will do accents instead of Vi actions.
 (if (and (boundp 'iso-accents-mode) iso-accents-mode)
 	(iso-accents-mode -1))
 (vip-restore-cursor-color-after-insert)
 ;; Protection against user errors in hooks
 (condition-case conds
 	(run-hooks 'vip-vi-state-hook)
 (error
 (vip-message-conditions conds)))))
 Vi's prefix argument will be used. Otherwise, the prefix argument passed to
 `vip-escape-to-vi' is used."
 (interactive "P")
 (message "Switched to VI state for the next command...")
 (vip-escape-to-state arg nil 'vi-state))
 ;; Escape to STATE mode for one Emacs command.
 (defun vip-escape-to-state (arg events state)
 ;;(let (com key prefix-arg)
 (let (com key)
 ;; this temporarily turns off Viper's minor mode keymaps
 	  (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)
+	      (setq last-command-event (vip-copy-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)
+	    (setq last-command-event (vip-copy-event (vip-seq-last-elt key))
 		  last-command-char last-command-event))
 	  (if (commandp com)
 	      (progn
 		(setq prefix-arg (or prefix-arg arg))
 ))
 (defun vip-alternate-Meta-key (arg)
 "Simulate Emacs Meta key."
 (interactive "P")
+(sit-for 1) (message "ESC-")
 (vip-escape-to-emacs arg '(?\e)))
 (defun vip-toggle-key-action ()
 "Action bound to `vip-toggle-key'."
 (interactive)
 (if (and (< vip-expert-level 2) (equal vip-toggle-key "\C-z"))
 (if (vip-window-display-p)
 	  (vip-iconify)
 	(suspend-emacs))
 (vip-change-state-to-emacs)))
 ;; Intercept ESC sequences on dumb terminals.
 ;; Based on the idea contributed by Marcelino Veiga Tuimil <mveiga@dit.upm.es>
 ;; Check if last key was ESC and if so try to reread it as a function key.
 				    (character-to-event (event-key first-key)))
 				   (subseq keyseq 1)))
 			 (setq last-input-event event
 			       keyseq (vector (character-to-event ?\e))))
 			((eventp first-key)
-			 (setq last-command-event first-key))
+			 (setq last-command-event (vip-copy-event first-key)))
 			))
 		) ; end progn
 	    ;; this is escape event with nothing after it
 	    ;; put in unread-command-event and then re-read
 (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)))
 (if (or com (and (not (eq vip-current-state 'vi-state))
 		     ;; make sure it is a Vi command
 		     (vip-characterp event) (vip-vi-command-p event)
 		     ))
 	;; If appears to be one of the vi commands,
 	  ;; the user typed, say, d2. In this case, `com' would be `d', `w',
 	  ;; etc.
 	  ;; If vip-digit-argument was invoked by vip-escape-to-vi (which is
 	  ;; indicated by the fact that the current state is not vi-state,
 	  ;; then `event' represents the vi command to be executed (e.g., `d',
-	  ;; `w', etc. Again, last-command-char must make emacs believe that
+	  ;; `w', etc). Again, last-command-char must make emacs believe that
 	  ;; this is the command we typed.
 	  (setq last-command-char (or com event))
 	  (setq func (vip-exec-form-in-vi
 		      (` (key-binding (char-to-string (, event))))))
 	  (funcall func prefix-arg)
 	  (setq prefix-arg nil))
 ;; some other command -- let emacs do it in its own way
 (vip-set-unread-command-events event))
 ))
 ;; Vi operator as prefix argument."
 (defun vip-prefix-arg-com (char value com)
 (let ((cont t)
 	cmd-info mv-or-digit-cmd)
 		     (setq vip-use-register reg)
 		   (error ""))
 		 (setq char (read-char))))
 	      (t
 	       (setq com char)
-	       (setq char (vip-read-char-exclusive))))))
+	       (setq char (read-char))))))
 (if (atom com)
 ;; `com' is a single char, so we construct the command argument
 ;; and if `char' is `?', we describe the arg; otherwise
 ;; we prepare the command that will be executed at the end.
 (progn
 	;; `char' is a movement command or a digit arg command---so we execute
 	;; it at the very end
 	(setq mv-or-digit-cmd
 	      (vip-exec-form-in-vi
 	       (` (key-binding (char-to-string (, char)))))))
 ;; as com is non-nil, this means that we have a command to execute
 (if (memq (car com) '(?r ?R))
 	;; execute apropriate region command.
 	(let ((char (car com)) (com (cdr com)))
 	  (setq prefix-arg (cons value com))
 	    ((equal com '(?< . ?<)) (vip-line (cons value ?<)))
 	    ((equal com '(?> . ?>)) (vip-line (cons value ?>)))
 	    ((equal com '(?! . ?!)) (vip-line (cons value ?!)))
 	    ((equal com '(?= . ?=)) (vip-line (cons value ?=)))
 	    (t (error "")))))
 (if mv-or-digit-cmd
 (progn
 	(setq last-command-char char)
+	(setq last-command-event
+	      (vip-copy-event
+	       (if vip-xemacs-p (character-to-event char) char)))
 	(funcall mv-or-digit-cmd cmd-info)))
 ))
 (defun vip-describe-arg (arg)
 (let (val com)
 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
+(let ((vip-inside-command-argument-action t))
-(vip-prefix-arg-com
+(condition-case nil
-last-command-char
+	(vip-prefix-arg-com
-(cond ((null arg) nil)
+	 last-command-char
-	     ((consp arg) (car arg))
+	 (cond ((null arg) nil)
-	     ((integerp arg) arg)
+	       ((consp arg) (car arg))
-	     (t (error vip-InvalidCommandArgument)))
+	       ((integerp arg) arg)
-(cond ((null arg) nil)
+	       (t (error vip-InvalidCommandArgument)))
-	     ((consp arg) (cdr arg))
+	 (cond ((null arg) nil)
-	     ((integerp arg) nil)
+	       ((consp arg) (cdr arg))
-	     (t (error vip-InvalidCommandArgument))))
+	       ((integerp arg) nil)
-(quit (setq vip-use-register nil)
+	       (t (error vip-InvalidCommandArgument))))
-	  (signal 'quit nil)))
+(quit (setq vip-use-register nil)
-(vip-deactivate-mark))
+	    (signal 'quit nil)))
+(vip-deactivate-mark)))
 ;; repeat last destructive command
 ;; Append region to text in register REG.
 ;; define functions to be executed
 ;; invoked by the `C' command
 (defun vip-exec-change (m-com com)
+(or (and (markerp vip-com-point) (marker-position vip-com-point))
+(set-marker vip-com-point (point) (current-buffer)))
 ;; 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)))
 (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)
+(or (and (markerp vip-com-point) (marker-position vip-com-point))
+(set-marker vip-com-point (point) (current-buffer)))
 (if vip-use-register
 (progn
 	(cond ((vip-valid-register vip-use-register '(letter digit))
 	       ;;(vip-valid-register vip-use-register '(letter))
 	       (copy-to-register
 (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)
+(or (and (markerp vip-com-point) (marker-position vip-com-point))
+(set-marker vip-com-point (point) (current-buffer)))
 (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-special-ring-rotate1 vip-command-ring 1)
 (setq num (1+ num)))
 ))
-;; This command is invoked interactively by the key sequence #<char>
+;; The hash-command. It is invoked interactively by the key sequence #<char>.
+;; The chars that can follow `#' are determined by vip-hash-command-p
 (defun vip-special-prefix-com (char)
 (cond ((= char ?c)
 	 (downcase-region (min vip-com-point (point))
 			  (max vip-com-point (point))))
 	((= char ?C)
 		;; as part of the previous line.
 		(if (= (vip-line-pos 'start) end)
 		    (setq incr 1))
 		(<= (+ incr (count-lines beg end)) 1))))
 ))
 ;; Check if the string ends with a newline.
 (defun vip-end-with-a-newline-p (string)
 (or (string= string "")
 (= (vip-seq-last-elt string) ?\n)))
 (defun vip-line-to-bottom (arg)
 "Put current line on the last line."
 (interactive "p")
 (recenter (- (window-height) (1+ arg))))
-;; If vip-adjust-window-after-search is t, scroll up or down 1/4 of window
+;; If point is within vip-search-scroll-threshold of window top or bottom,
-;; height, depending on whether we are at the bottom or at the top of the
+;; scroll up or down 1/7 of window height, depending on whether we are at the
-;; window. This function is called by vip-search (which is called from
+;; bottom or at the top of the  window. This function is called by vip-search
-;; vip-search-forward/backward/next)
+;; (which is called from vip-search-forward/backward/next). If the value of
+;; vip-search-scroll-threshold is negative - don't scroll.
 (defun vip-adjust-window ()
 (let ((win-height (if vip-emacs-p
 			(1- (window-height)) ; adjust for modeline
 		      (window-displayed-height)))
 	(pt (point))
 	at-top-p at-bottom-p
 	min-scroll direction)
 (save-excursion
 (move-to-window-line 0) ; top
-(setq at-top-p (<= (count-lines pt (point)) 2))
+(setq at-top-p
+	    (<= (count-lines pt (point))
+		vip-search-scroll-threshold))
 (move-to-window-line -1) ; bottom
-(setq at-bottom-p (<= (count-lines pt (point)) 2))
+(setq at-bottom-p
+	    (<= (count-lines pt (point)) vip-search-scroll-threshold))
 )
-(cond (at-top-p (setq min-scroll 1
+(cond (at-top-p (setq min-scroll (1- vip-search-scroll-threshold)
 			  direction  1))
-	  (at-bottom-p (setq min-scroll 2
+	  (at-bottom-p (setq min-scroll (1+ vip-search-scroll-threshold)
 			     direction -1)))
-(if (and vip-adjust-window-after-search min-scroll)
+(if min-scroll
 	(recenter
 	 (* (max min-scroll (/ win-height 7)) direction)))
 ))
 With a prefix argument, this function unsets the macros.
 If the optional prefix argument is non-nil and specifies a valid major mode,
 this sets the macros only in the macros in that major mode. Otherwise,
 the macros are set in the current major mode.
 \(When unsetting the macros, the second argument has no effect.\)"
 (interactive "P")
 (or noninteractive
 (if (not unset)
 	  (progn
 	    ;; toggle case sensitivity in search
 	    (vip-record-kbd-macro
 ;; pull up or down if at top/bottom of window
 (vip-adjust-window)
 ;; highlight the result of search
 ;; don't wait and don't highlight in macros
 (or executing-kbd-macro
+	  vip-inside-command-argument-action
 	  (vip-flash-search-pattern))
 )))
 (defun vip-search-next (arg)
 "Repeat previous search."
 (message "Mark set at the end of buffer"))
 (defun vip-mark-point ()
 "Set mark at point of buffer."
 (interactive)
-(let ((char (vip-read-char-exclusive)))
+(let ((char (read-char)))
 (cond ((and (<= ?a char) (<= char ?z))
-	 (point-to-register (1+ (- char ?a))))
+	   (point-to-register (1+ (- char ?a))))
-	((= char ?<) (vip-mark-beginning-of-buffer))
+	  ((= char ?<) (vip-mark-beginning-of-buffer))
-	((= char ?>) (vip-mark-end-of-buffer))
+	  ((= char ?>) (vip-mark-end-of-buffer))
-	((= char ?.) (vip-set-mark-if-necessary))
+	  ((= char ?.) (vip-set-mark-if-necessary))
-	((= char ?,) (vip-cycle-through-mark-ring))
+	  ((= char ?,) (vip-cycle-through-mark-ring))
-	((= char ?D) (mark-defun))
+	  ((= char ?D) (mark-defun))
-	(t (error ""))
+	  (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.
 	       vip-search-wrap-around-t	     t
 	       vip-want-emacs-keys-in-vi     nil
 	       vip-want-emacs-keys-in-insert nil))
 	((and (> vip-expert-level 1) (< vip-expert-level 5))
-	 ;; an intermediate to guru
+	 ;; intermediate to guru
 	 (setq vip-no-multiple-ESC     (if (vip-window-display-p) t 'twice)
 	       vip-want-emacs-keys-in-vi     t
 	       vip-want-emacs-keys-in-insert (> vip-expert-level 2))
 	 (if (eq vip-expert-level 4) ; respect user's ex-style motions
 			 elt)))))
 lis))
-;;; 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)
 (defvar lisp-interaction-mode-hook)
 (add-hook 'lisp-interaction-mode-hook 'viper-mode)
 (defvar fortran-mode-hook)
 (add-hook 'fortran-mode-hook 'vip-mode)
 (defvar basic-mode-hook)
 (add-hook 'basic-mode-hook 'vip-mode)
 (defvar bat-mode-hook)
 (add-hook 'bat-mode-hook 'vip-mode)
 (defvar text-mode-hook)
 (add-hook 'text-mode-hook 'viper-mode)
 (add-hook 'completion-list-mode-hook 'viper-mode)
 (add-hook 'compilation-mode-hook     'viper-mode)
 (vip-eval-after-load
 "vc"
 '(defadvice vc-diff (after vip-vc-ad activate)
 	"Force Vi state in VC diff buffer."
 	(vip-change-state-to-vi))))
 (vip-eval-after-load
 "emerge"
 '(defadvice emerge-quit (after vip-emerge-advice activate)
 "Run `vip-change-state-to-vi' after quitting emerge."
 (vip-change-state-to-vi)))
 'internal-ange-ftp-mode 'insert-state vip-comint-mode-modifier-map)
 (vip-modify-major-mode
 'internal-ange-ftp-mode 'vi-state vip-comint-mode-modifier-map)
 ;; set hook
 (add-hook 'comint-mode-hook 'vip-comint-mode-hook)
 ;; Shell scripts
 (defvar sh-mode-hook)
 (add-hook 'sh-mode-hook 'viper-mode)
 (defvar ksh-mode-hook)
 (add-hook 'ksh-mode-hook 'viper-mode)
 (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)
 ;; set the toggle case sensitivity and regexp search macros
 (vip-set-vi-search-style-macros nil)
 ;; ~/.vip is loaded if it exists
 (if (and (file-exists-p vip-custom-file-name)
 	 (not noninteractive))
 (load vip-custom-file-name))
 ))
 (run-hooks 'vip-load-hook) ; the last chance to change something
-(provide 'viper)
 (provide 'vip19)
 (provide 'vip)
 ;;;  viper.el ends here

Mercurial > hg > xemacs-beta

comparison lisp/viper/viper.el @ 14:9ee227acff29 r19-15b90