1 ;;; viper-cmd.el --- Vi command support for Viper -*- lexical-binding:t -*-
3 ;; Copyright (C) 1997-2016 Free Software Foundation, Inc.
5 ;; Author: Michael Kifer <kifer@cs.stonybrook.edu>
8 ;; This file is part of GNU Emacs.
10 ;; GNU Emacs is free software: you can redistribute it and/or modify
11 ;; it under the terms of the GNU General Public License as published by
12 ;; the Free Software Foundation, either version 3 of the License, or
13 ;; (at your option) any later version.
15 ;; GNU Emacs is distributed in the hope that it will be useful,
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 ;; GNU General Public License for more details.
20 ;; You should have received a copy of the GNU General Public License
21 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
30 (defvar viper-minibuffer-current-face)
31 (defvar viper-minibuffer-insert-face)
32 (defvar viper-minibuffer-vi-face)
33 (defvar viper-minibuffer-emacs-face)
35 (defvar viper-mode-string)
36 (defvar viper-custom-file-name)
37 (defvar viper--key-maps)
38 (defvar viper--intercept-key-maps)
39 (defvar iso-accents-mode)
41 (defvar quail-current-str)
42 (defvar mark-even-if-inactive)
43 (defvar viper--init-message)
44 (defvar viper-initial)
45 (defvar undo-beg-posn)
46 (defvar undo-end-posn)
49 (unless (fboundp 'declare-function) (defmacro declare-function (&rest _))))
63 ;; These test functions are shamelessly lifted from vip 4.4.2 by Aamod Sane
65 ;; generate test functions
66 ;; given symbol foo, foo-p is the test function, foos is the set of
68 ;; (macroexpand '(viper-test-com-defun foo))
69 ;; (defun foo-p (com) (consp (memq com foos)))
71 (defmacro viper-test-com-defun (name)
72 (let* ((snm (symbol-name name))
73 (nm-p (intern (concat snm "-p")))
74 (nms (intern (concat snm "s"))))
76 (consp (viper-memq-char com ,nms)
79 ;; Variables for defining VI commands
81 ;; Modifying commands that can be prefixes to movement commands
82 (defvar viper-prefix-commands '(?c ?d ?y ?! ?= ?# ?< ?> ?\"))
83 ;; define viper-prefix-command-p
84 (viper-test-com-defun viper-prefix-command)
86 ;; Commands that are pairs eg. dd. r and R here are a hack
87 (defconst viper-charpair-commands '(?c ?d ?y ?! ?= ?< ?> ?r ?R))
88 ;; define viper-charpair-command-p
89 (viper-test-com-defun viper-charpair-command)
91 (defconst viper-movement-commands '(?b ?B ?e ?E ?f ?F ?G ?h ?j ?k ?l
92 ?H ?M ?L ?n ?t ?T ?w ?W ?$ ?%
93 ?^ ?( ?) ?- ?+ ?| ?{ ?} ?[ ?] ?' ?`
94 ?\; ?, ?0 ?? ?/ ?\ ?\C-m
99 ;; define viper-movement-command-p
100 (viper-test-com-defun viper-movement-command)
103 (defconst viper-digit-commands '(?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9))
105 ;; define viper-digit-command-p
106 (viper-test-com-defun viper-digit-command)
108 ;; Commands that can be repeated by . (dotted)
109 (defconst viper-dotable-commands '(?c ?d ?C ?s ?S ?D ?> ?<))
110 ;; define viper-dotable-command-p
111 (viper-test-com-defun viper-dotable-command)
113 ;; Commands that can follow a #
114 (defconst viper-hash-commands '(?c ?C ?g ?q ?s))
115 ;; define viper-hash-command-p
116 (viper-test-com-defun viper-hash-command)
118 ;; Commands that may have registers as prefix
119 (defconst viper-regsuffix-commands '(?d ?y ?Y ?D ?p ?P ?x ?X))
120 ;; define viper-regsuffix-command-p
121 (viper-test-com-defun viper-regsuffix-command)
123 (defconst viper-vi-commands (append viper-movement-commands
125 viper-dotable-commands
126 viper-charpair-commands
128 viper-prefix-commands
129 viper-regsuffix-commands)
130 "The list of all commands in Vi-state.")
131 ;; define viper-vi-command-p
132 (viper-test-com-defun viper-vi-command)
134 ;; Where viper saves mark. This mark is resurrected by m^
135 (defvar viper-saved-mark nil)
137 ;; Contains user settings for vars affected by viper-set-expert-level function.
138 ;; Not a user option.
139 (defvar viper-saved-user-settings nil)
147 ;; Runs viper-after-change-functions inside after-change-functions
148 (defun viper-after-change-sentinel (beg end len)
149 (run-hook-with-args 'viper-after-change-functions beg end len))
151 ;; Runs viper-before-change-functions inside before-change-functions
152 (defun viper-before-change-sentinel (beg end)
153 (run-hook-with-args 'viper-before-change-functions beg end))
155 (defsubst viper-post-command-sentinel ()
156 (condition-case conds
157 (run-hooks 'viper-post-command-hooks)
158 (error (viper-message-conditions conds)))
159 (if (eq viper-current-state 'vi-state)
160 (viper-restore-cursor-color 'after-insert-mode)))
162 (defsubst viper-pre-command-sentinel ()
163 (run-hooks 'viper-pre-command-hooks))
165 ;; Needed so that Viper will be able to figure the last inserted
166 ;; chunk of text with reasonable accuracy.
167 (defsubst viper-insert-state-post-command-sentinel ()
168 (if (and (memq viper-current-state '(insert-state replace-state))
170 (>= (point) viper-insert-point))
171 (setq viper-last-posn-while-in-insert-state (point-marker)))
172 (or (viper-overlay-p viper-replace-overlay)
174 (viper-set-replace-overlay (point-min) (point-min))
175 (viper-hide-replace-overlay)))
176 (if (eq viper-current-state 'insert-state)
177 (let ((icolor (viper-frame-value viper-insert-state-cursor-color)))
178 (or (stringp (viper-get-saved-cursor-color-in-insert-mode))
179 (string= (viper-get-cursor-color) icolor)
180 ;; save current color, if not already saved
181 (viper-save-cursor-color 'before-insert-mode))
182 ;; set insert mode cursor color
183 (viper-change-cursor-color icolor)))
184 (let ((ecolor (viper-frame-value viper-emacs-state-cursor-color)))
185 (when (and ecolor (eq viper-current-state 'emacs-state))
186 (or (stringp (viper-get-saved-cursor-color-in-emacs-mode))
187 (string= (viper-get-cursor-color) ecolor)
188 ;; save current color, if not already saved
189 (viper-save-cursor-color 'before-emacs-mode))
190 ;; set emacs mode cursor color
191 (viper-change-cursor-color ecolor)))
193 (if (and (memq this-command '(dabbrev-expand hippie-expand))
194 (integerp viper-pre-command-point)
195 (markerp viper-insert-point)
196 (marker-position viper-insert-point)
197 (> viper-insert-point viper-pre-command-point))
198 (viper-move-marker-locally viper-insert-point viper-pre-command-point)))
200 (defsubst viper-preserve-cursor-color ()
201 (or (memq this-command '(self-insert-command
202 viper-del-backward-char-in-insert
203 viper-del-backward-char-in-replace
204 viper-delete-backward-char
207 (memq (viper-event-key last-command-event)
208 '(up down left right (meta f) (meta b)
209 (control n) (control p) (control f) (control b)))))
211 (defsubst viper-insert-state-pre-command-sentinel ()
212 (or (viper-preserve-cursor-color)
213 (viper-restore-cursor-color 'after-insert-mode))
214 (if (and (memq this-command '(dabbrev-expand hippie-expand))
215 (markerp viper-insert-point)
216 (marker-position viper-insert-point))
217 (setq viper-pre-command-point (marker-position viper-insert-point))))
219 (defun viper-R-state-post-command-sentinel ()
220 ;; Restoring cursor color is needed despite
221 ;; viper-replace-state-pre-command-sentinel: When you jump to another buffer
222 ;; in another frame, the pre-command hook won't change cursor color to
223 ;; default in that other frame. So, if the second frame cursor was red and
224 ;; we set the point outside the replacement region, then the cursor color
225 ;; will remain red. Restoring the default, below, prevents this.
226 (if (and (<= (viper-replace-start) (point))
227 (<= (point) (viper-replace-end)))
228 (viper-change-cursor-color
229 (viper-frame-value viper-replace-overlay-cursor-color))
230 (viper-restore-cursor-color 'after-replace-mode)))
232 ;; to speed up, don't change cursor color before self-insert
233 ;; and common move commands
234 (defsubst viper-replace-state-pre-command-sentinel ()
235 (or (viper-preserve-cursor-color)
236 (viper-restore-cursor-color 'after-replace-mode)))
239 ;; Make sure we don't delete more than needed.
240 ;; This is executed at viper-last-posn-in-replace-region
241 (defsubst viper-trim-replace-chars-to-delete-if-necessary ()
242 (setq viper-replace-chars-to-delete
244 (min viper-replace-chars-to-delete
245 ;; Don't delete more than to the end of repl overlay
246 (viper-chars-in-region
247 (viper-replace-end) viper-last-posn-in-replace-region)
248 ;; point is viper-last-posn-in-replace-region now
249 ;; So, this limits deletion to the end of line
250 (viper-chars-in-region (point) (viper-line-pos 'end))
254 (defun viper-replace-state-post-command-sentinel ()
255 ;; Restoring cursor color is needed despite
256 ;; viper-replace-state-pre-command-sentinel: When one jumps to another buffer
257 ;; in another frame, the pre-command hook won't change cursor color to
258 ;; default in that other frame. So, if the second frame cursor was red and
259 ;; we set the point outside the replacement region, then the cursor color
260 ;; will remain red. Restoring the default, below, fixes this problem.
262 ;; We optimize for some commands, like self-insert-command,
263 ;; viper-delete-backward-char, etc., since they either don't change
264 ;; cursor color or, if they terminate replace mode, the color will be changed
265 ;; in viper-finish-change
266 (or (viper-preserve-cursor-color)
267 (viper-restore-cursor-color 'after-replace-mode))
269 ((eq viper-current-state 'replace-state)
270 ;; delete characters to compensate for inserted chars.
271 (let ((replace-boundary (viper-replace-end)))
273 (goto-char viper-last-posn-in-replace-region)
274 (viper-trim-replace-chars-to-delete-if-necessary)
275 (delete-char viper-replace-chars-to-delete)
276 (setq viper-replace-chars-to-delete 0)
277 ;; terminate replace mode if reached replace limit
278 (if (= viper-last-posn-in-replace-region (viper-replace-end))
279 (viper-finish-change)))
281 (when (viper-pos-within-region
282 (point) (viper-replace-start) replace-boundary)
283 ;; the state may have changed in viper-finish-change above
284 (if (eq viper-current-state 'replace-state)
285 (viper-change-cursor-color
286 (viper-frame-value viper-replace-overlay-cursor-color)))
287 (setq viper-last-posn-in-replace-region (point-marker)))))
288 ;; terminate replace mode if changed Viper states.
289 (t (viper-finish-change))))
294 ;; Change state to NEW-STATE---either emacs-state, vi-state, or insert-state.
295 (defun viper-change-state (new-state)
296 ;; Keep viper-post/pre-command-hooks fresh.
297 ;; We remove then add viper-post/pre-command-sentinel since it is very
298 ;; desirable that viper-pre-command-sentinel is the last hook and
299 ;; viper-post-command-sentinel is the first hook.
301 (when (featurep 'xemacs)
302 (make-local-hook 'viper-after-change-functions)
303 (make-local-hook 'viper-before-change-functions)
304 (make-local-hook 'viper-post-command-hooks)
305 (make-local-hook 'viper-pre-command-hooks))
307 (remove-hook 'post-command-hook 'viper-post-command-sentinel)
308 (add-hook 'post-command-hook 'viper-post-command-sentinel)
309 (remove-hook 'pre-command-hook 'viper-pre-command-sentinel)
310 (add-hook 'pre-command-hook 'viper-pre-command-sentinel t)
311 ;; These hooks will be added back if switching to insert/replace mode
312 (remove-hook 'viper-post-command-hooks
313 'viper-insert-state-post-command-sentinel 'local)
314 (remove-hook 'viper-pre-command-hooks
315 'viper-insert-state-pre-command-sentinel 'local)
316 (setq viper-intermediate-command nil)
317 (cond ((eq new-state 'vi-state)
318 (cond ((member viper-current-state '(insert-state replace-state))
320 ;; move viper-last-posn-while-in-insert-state
321 ;; This is a normal hook that is executed in insert/replace
322 ;; states after each command. In Vi/Emacs state, it does
323 ;; nothing. We need to execute it here to make sure that
324 ;; the last posn was recorded when we hit ESC.
325 ;; It may be left unrecorded if the last thing done in
326 ;; insert/repl state was dabbrev-expansion or abbrev
327 ;; expansion caused by hitting ESC
328 (viper-insert-state-post-command-sentinel)
330 (condition-case conds
332 (viper-save-last-insertion
334 viper-last-posn-while-in-insert-state)
335 (if viper-began-as-replace
336 (setq viper-began-as-replace nil)
337 ;; repeat insert commands if numerical arg > 1
339 (viper-repeat-insert-command))))
341 (viper-message-conditions conds)))
343 (if (> (length viper-last-insertion) 0)
344 (viper-push-onto-ring viper-last-insertion
345 'viper-insertion-ring))
347 (if viper-ESC-moves-cursor-back
348 (or (bolp) (viper-beginning-of-field) (backward-char 1))))
352 ((memq new-state '(insert-state replace-state))
353 (if (memq viper-current-state '(emacs-state vi-state))
354 (viper-move-marker-locally 'viper-insert-point (point)))
355 (viper-move-marker-locally
356 'viper-last-posn-while-in-insert-state (point))
357 (add-hook 'viper-post-command-hooks
358 'viper-insert-state-post-command-sentinel t 'local)
359 (add-hook 'viper-pre-command-hooks
360 'viper-insert-state-pre-command-sentinel t 'local))
363 ;; Nothing needs to be done to switch to emacs mode! Just set some
364 ;; variables, which is already done in viper-change-state-to-emacs!
367 ;; always turn off iso-accents-mode in vi-state, or else we won't be able to
368 ;; use the keys `,',^ , as they will do accents instead of Vi actions.
369 (cond ((eq new-state 'vi-state) (viper-set-iso-accents-mode nil));accents off
370 (viper-automatic-iso-accents (viper-set-iso-accents-mode t));accents on
371 (t (viper-set-iso-accents-mode nil)))
372 ;; Always turn off quail mode in vi state
373 (cond ((eq new-state 'vi-state) (viper-set-input-method nil)) ;intl input off
374 (viper-special-input-method (viper-set-input-method t)) ;intl input on
375 (t (viper-set-input-method nil)))
377 (setq viper-current-state new-state)
379 (viper-update-syntax-classes)
380 (viper-normalize-minor-mode-map-alist)
381 (viper-adjust-keys-for new-state)
382 (viper-set-mode-vars-for new-state)
383 (viper-refresh-mode-line)
387 (defun viper-adjust-keys-for (state)
388 "Make necessary adjustments to keymaps before entering STATE."
389 (cond ((memq state '(insert-state replace-state))
390 (if viper-auto-indent
392 (define-key viper-insert-basic-map "\C-m" 'viper-autoindent)
393 (if viper-want-emacs-keys-in-insert
395 (define-key viper-insert-basic-map "\C-j" nil)
397 (define-key viper-insert-basic-map "\C-j" 'viper-autoindent)))
398 (define-key viper-insert-basic-map "\C-m" nil)
399 (define-key viper-insert-basic-map "\C-j" nil))
401 (setq viper-insert-diehard-minor-mode
402 (not viper-want-emacs-keys-in-insert))
404 (if viper-want-ctl-h-help
406 (define-key viper-insert-basic-map "\C-h" 'help-command)
407 (define-key viper-replace-map "\C-h" 'help-command))
408 (define-key viper-insert-basic-map
409 "\C-h" 'viper-del-backward-char-in-insert)
410 (define-key viper-replace-map
411 "\C-h" 'viper-del-backward-char-in-replace))
412 ;; In XEmacs, C-h overrides backspace, so we make sure it doesn't.
413 (define-key viper-insert-basic-map
414 [backspace] 'viper-del-backward-char-in-insert)
415 (define-key viper-replace-map
416 [backspace] 'viper-del-backward-char-in-replace)
417 ) ; end insert/replace case
419 (setq viper-vi-diehard-minor-mode (not viper-want-emacs-keys-in-vi))
420 (if viper-want-ctl-h-help
421 (define-key viper-vi-basic-map "\C-h" 'help-command)
422 (define-key viper-vi-basic-map "\C-h" 'viper-backward-char))
423 ;; In XEmacs, C-h overrides backspace, so we make sure it doesn't.
424 (define-key viper-vi-basic-map [backspace] 'viper-backward-char))
428 ;; Normalizes minor-mode-map-alist by putting Viper keymaps first.
429 ;; This ensures that Viper bindings are in effect, regardless of which minor
430 ;; modes were turned on by the user or by other packages.
431 (defun viper-normalize-minor-mode-map-alist ()
432 (setq viper--intercept-key-maps
434 (cons 'viper-vi-intercept-minor-mode viper-vi-intercept-map)
435 (cons 'viper-insert-intercept-minor-mode viper-insert-intercept-map)
436 (cons 'viper-emacs-intercept-minor-mode viper-emacs-intercept-map)
438 (setq viper--key-maps
439 (list (cons 'viper-vi-minibuffer-minor-mode viper-minibuffer-map)
440 (cons 'viper-vi-local-user-minor-mode viper-vi-local-user-map)
441 (cons 'viper-vi-kbd-minor-mode viper-vi-kbd-map)
442 (cons 'viper-vi-global-user-minor-mode viper-vi-global-user-map)
443 (cons 'viper-vi-state-modifier-minor-mode
445 (cdr (assoc major-mode viper-vi-state-modifier-alist)))
446 (cdr (assoc major-mode viper-vi-state-modifier-alist))
448 (cons 'viper-vi-diehard-minor-mode viper-vi-diehard-map)
449 (cons 'viper-vi-basic-minor-mode viper-vi-basic-map)
450 (cons 'viper-replace-minor-mode viper-replace-map)
451 ;; viper-insert-minibuffer-minor-mode must come after
452 ;; viper-replace-minor-mode
453 (cons 'viper-insert-minibuffer-minor-mode
454 viper-minibuffer-map)
455 (cons 'viper-insert-local-user-minor-mode
456 viper-insert-local-user-map)
457 (cons 'viper-insert-kbd-minor-mode viper-insert-kbd-map)
458 (cons 'viper-insert-global-user-minor-mode
459 viper-insert-global-user-map)
460 (cons 'viper-insert-state-modifier-minor-mode
462 (cdr (assoc major-mode
463 viper-insert-state-modifier-alist)))
464 (cdr (assoc major-mode
465 viper-insert-state-modifier-alist))
467 (cons 'viper-insert-diehard-minor-mode viper-insert-diehard-map)
468 (cons 'viper-insert-basic-minor-mode viper-insert-basic-map)
469 (cons 'viper-emacs-local-user-minor-mode
470 viper-emacs-local-user-map)
471 (cons 'viper-emacs-kbd-minor-mode viper-emacs-kbd-map)
472 (cons 'viper-emacs-global-user-minor-mode
473 viper-emacs-global-user-map)
474 (cons 'viper-emacs-state-modifier-minor-mode
477 (assoc major-mode viper-emacs-state-modifier-alist)))
479 (assoc major-mode viper-emacs-state-modifier-alist))
483 ;; This var is not local in Emacs, so we make it local. It must be local
484 ;; because although the stack of minor modes can be the same for all buffers,
485 ;; the associated *keymaps* can be different. In Viper,
486 ;; viper-vi-local-user-map, viper-insert-local-user-map, and others can have
487 ;; different keymaps for different buffers. Also, the keymaps associated
488 ;; with viper-vi/insert-state-modifier-minor-mode can be different.
489 ;; ***This is needed only in case emulation-mode-map-alists is not defined.
490 ;; In emacs with emulation-mode-map-alists, nothing needs to be done
492 (and (fboundp 'add-to-ordered-list) (boundp 'emulation-mode-map-alists))
493 (set (make-local-variable 'minor-mode-map-alist)
494 (viper-append-filter-alist
495 (append viper--intercept-key-maps viper--key-maps)
496 minor-mode-map-alist)))
501 ;; Viper mode-changing commands and utilities
503 ;; Modifies mode-line-buffer-identification.
504 (defun viper-refresh-mode-line ()
505 (set (make-local-variable 'viper-mode-string)
506 (cond ((eq viper-current-state 'emacs-state) viper-emacs-state-id)
507 ((eq viper-current-state 'vi-state) viper-vi-state-id)
508 ((eq viper-current-state 'replace-state) viper-replace-state-id)
509 ((eq viper-current-state 'insert-state) viper-insert-state-id)))
511 ;; Sets Viper mode string in global-mode-string
512 (force-mode-line-update))
515 ;; Switch from Insert state to Vi state.
516 (defun viper-exit-insert-state ()
518 (viper-change-state-to-vi))
520 (defun viper-set-mode-vars-for (state)
521 "Sets Viper minor mode variables to put Viper's state STATE in effect."
524 (setq viper-vi-minibuffer-minor-mode nil
525 viper-insert-minibuffer-minor-mode nil
526 viper-vi-intercept-minor-mode nil
527 viper-insert-intercept-minor-mode nil
529 viper-vi-local-user-minor-mode nil
530 viper-vi-kbd-minor-mode nil
531 viper-vi-global-user-minor-mode nil
532 viper-vi-state-modifier-minor-mode nil
533 viper-vi-diehard-minor-mode nil
534 viper-vi-basic-minor-mode nil
536 viper-replace-minor-mode nil
538 viper-insert-local-user-minor-mode nil
539 viper-insert-kbd-minor-mode nil
540 viper-insert-global-user-minor-mode nil
541 viper-insert-state-modifier-minor-mode nil
542 viper-insert-diehard-minor-mode nil
543 viper-insert-basic-minor-mode nil
544 viper-emacs-intercept-minor-mode t
545 viper-emacs-local-user-minor-mode t
546 viper-emacs-kbd-minor-mode (not (viper-is-in-minibuffer))
547 viper-emacs-global-user-minor-mode t
548 viper-emacs-state-modifier-minor-mode t
552 (if (eq state 'vi-state) ; adjust for vi-state
554 viper-vi-intercept-minor-mode t
555 viper-vi-minibuffer-minor-mode (viper-is-in-minibuffer)
556 viper-vi-local-user-minor-mode t
557 viper-vi-kbd-minor-mode (not (viper-is-in-minibuffer))
558 viper-vi-global-user-minor-mode t
559 viper-vi-state-modifier-minor-mode t
560 ;; don't let the diehard keymap block command completion
561 ;; and other things in the minibuffer
562 viper-vi-diehard-minor-mode (not
563 (or viper-want-emacs-keys-in-vi
564 (viper-is-in-minibuffer)))
565 viper-vi-basic-minor-mode t
566 viper-emacs-intercept-minor-mode nil
567 viper-emacs-local-user-minor-mode nil
568 viper-emacs-kbd-minor-mode nil
569 viper-emacs-global-user-minor-mode nil
570 viper-emacs-state-modifier-minor-mode nil
573 ;; Insert and Replace states
574 (if (member state '(insert-state replace-state))
576 viper-insert-intercept-minor-mode t
577 viper-replace-minor-mode (eq state 'replace-state)
578 viper-insert-minibuffer-minor-mode (viper-is-in-minibuffer)
579 viper-insert-local-user-minor-mode t
580 viper-insert-kbd-minor-mode (not (viper-is-in-minibuffer))
581 viper-insert-global-user-minor-mode t
582 viper-insert-state-modifier-minor-mode t
583 ;; don't let the diehard keymap block command completion
584 ;; and other things in the minibuffer
585 viper-insert-diehard-minor-mode (not
587 viper-want-emacs-keys-in-insert
588 (viper-is-in-minibuffer)))
589 viper-insert-basic-minor-mode t
590 viper-emacs-intercept-minor-mode nil
591 viper-emacs-local-user-minor-mode nil
592 viper-emacs-kbd-minor-mode nil
593 viper-emacs-global-user-minor-mode nil
594 viper-emacs-state-modifier-minor-mode nil
598 (if (viper-has-face-support-p)
599 (setq viper-minibuffer-current-face
600 (cond ((eq state 'emacs-state) viper-minibuffer-emacs-face)
601 ((eq state 'vi-state) viper-minibuffer-vi-face)
602 ((memq state '(insert-state replace-state))
603 viper-minibuffer-insert-face))))
605 (if (viper-is-in-minibuffer)
606 (viper-set-minibuffer-overlay))
609 ;; This also takes care of the annoying incomplete lines in files.
610 ;; Also, this fixes `undo' to work vi-style for complex commands.
611 (defun viper-change-state-to-vi (&rest _)
612 "Change Viper state to Vi."
614 (if (and viper-first-time (not (viper-is-in-minibuffer)))
616 (if overwrite-mode (overwrite-mode -1))
617 (or (viper-overlay-p viper-replace-overlay)
618 (viper-set-replace-overlay (point-min) (point-min)))
619 (viper-hide-replace-overlay)
620 ;; Expand abbrevs iff the previous character has word syntax.
622 (eq (char-syntax (preceding-char)) ?w)
624 (if (and auto-fill-function (> (current-column) fill-column))
625 (funcall auto-fill-function))
626 ;; don't leave whitespace lines around
627 (if (and (memq last-command
629 viper-open-line viper-Open-line
630 viper-replace-state-exit-cmd))
631 (viper-over-whitespace-line))
632 (indent-to-left-margin))
633 (viper-add-newline-at-eob-if-necessary)
636 (if (eq viper-current-state 'emacs-state)
637 (viper-restore-cursor-color 'after-emacs-mode)
638 (viper-restore-cursor-color 'after-insert-mode))
640 (viper-change-state 'vi-state)
642 ;; Protect against user errors in hooks
643 (condition-case conds
644 (run-hooks 'viper-vi-state-hook)
646 (viper-message-conditions conds)))))
648 (defun viper-change-state-to-insert ()
649 "Change Viper state to Insert."
651 (viper-change-state 'insert-state)
653 (or (viper-overlay-p viper-replace-overlay)
654 (viper-set-replace-overlay (point-min) (point-min)))
655 (viper-hide-replace-overlay)
657 (let ((icolor (viper-frame-value viper-insert-state-cursor-color)))
658 (or (stringp (viper-get-saved-cursor-color-in-insert-mode))
659 (string= (viper-get-cursor-color) icolor)
660 (viper-save-cursor-color 'before-insert-mode))
661 (viper-change-cursor-color icolor))
663 ;; Protect against user errors in hooks
664 (condition-case conds
665 (run-hooks 'viper-insert-state-hook)
667 (viper-message-conditions conds))))
669 (defsubst viper-downgrade-to-insert ()
670 ;; Protect against user errors in hooks
671 (condition-case conds
672 (run-hooks 'viper-insert-state-hook)
674 (viper-message-conditions conds)))
675 (setq viper-current-state 'insert-state
676 viper-replace-minor-mode nil))
680 ;; Change to replace state. When the end of replacement region is reached,
681 ;; replace state changes to insert state.
682 (defun viper-change-state-to-replace (&optional non-R-cmd)
683 (viper-change-state 'replace-state)
684 ;; Run insert-state-hook
685 (condition-case conds
686 (run-hooks 'viper-insert-state-hook 'viper-replace-state-hook)
688 (viper-message-conditions conds)))
691 (viper-start-replace)
692 ;; 'R' is implemented using Emacs's overwrite-mode
693 (viper-start-R-mode))
697 (defun viper-change-state-to-emacs (&rest _)
698 "Change Viper state to Emacs."
700 (or (viper-overlay-p viper-replace-overlay)
701 (viper-set-replace-overlay (point-min) (point-min)))
702 (viper-hide-replace-overlay)
704 (let ((ecolor (viper-frame-value viper-emacs-state-cursor-color)))
706 (or (stringp (viper-get-saved-cursor-color-in-emacs-mode))
707 (string= (viper-get-cursor-color) ecolor)
708 (viper-save-cursor-color 'before-emacs-mode))
709 (viper-change-cursor-color ecolor)))
711 (viper-change-state 'emacs-state)
713 ;; Protect against user errors in hooks
714 (condition-case conds
715 (run-hooks 'viper-emacs-state-hook)
717 (viper-message-conditions conds))))
719 ;; escape to emacs mode temporarily
720 (defun viper-escape-to-emacs (arg &optional events)
721 "Escape to Emacs state from Vi state for one Emacs command.
722 ARG is used as the prefix value for the executed command. If
723 EVENTS is a list of events, which become the beginning of the command."
725 (if (viper= (viper-last-command-char) ?\\)
726 (message "Switched to EMACS state for the next command..."))
727 (viper-escape-to-state arg events 'emacs-state))
729 ;; escape to Vi mode temporarily
730 (defun viper-escape-to-vi (arg)
731 "Escape from Emacs state to Vi state for one Vi 1-character command.
732 If the Vi command that the user types has a prefix argument, e.g., `d2w', then
733 Vi's prefix argument will be used. Otherwise, the prefix argument passed to
734 `viper-escape-to-vi' is used."
736 (message "Switched to VI state for the next command...")
737 (viper-escape-to-state arg nil 'vi-state))
739 ;; Escape to STATE mode for one Emacs command.
740 (defun viper-escape-to-state (arg events state)
741 ;;(let (com key prefix-arg)
743 ;; this temporarily turns off Viper's minor mode keymaps
744 (viper-set-mode-vars-for state)
745 (viper-normalize-minor-mode-map-alist)
746 (if events (viper-set-unread-command-events events))
748 ;; protect against keyboard quit and other errors
750 (let (viper-vi-kbd-minor-mode
751 viper-insert-kbd-minor-mode
752 viper-emacs-kbd-minor-mode)
756 (key-binding (setq key (viper-read-key-sequence nil))))
757 ;; In case of binding indirection--chase definitions.
758 ;; Have to do it here because we execute this command under
759 ;; different keymaps, so command-execute may not do the
761 (while (vectorp com) (setq com (key-binding com))))
763 ;; Execute command com in the original Viper state, not in state
764 ;; `state'. Otherwise, if we switch buffers while executing the
765 ;; escaped to command, Viper's mode vars will remain those of
766 ;; `state'. When we return to the orig buffer, the bindings will be
768 (viper-set-mode-vars-for viper-current-state)
770 ;; this-command, last-command-char, last-command-event
771 (setq this-command com)
772 (if (featurep 'xemacs)
773 ;; XEmacs represents key sequences as vectors
774 (setq last-command-event
775 (viper-copy-event (viper-seq-last-elt key))
776 last-command-char (event-to-character last-command-event))
777 ;; Emacs represents them as sequences (str or vec)
778 (setq last-command-event
779 (viper-copy-event (viper-seq-last-elt key))))
782 ;; pretend that current state is the state we escaped to
783 (let ((viper-current-state state))
784 (setq prefix-arg (or prefix-arg arg))
785 (command-execute com)))
789 ;; set state in the new buffer
790 (viper-set-mode-vars-for viper-current-state))
792 ;; This is used in order to allow reading characters according to the input
793 ;; method. The character is read in emacs and inserted into the buffer.
794 ;; If an input method is in effect, this might
795 ;; cause several characters to be combined into one.
796 ;; Also takes care of the iso-accents mode
797 (defun viper-special-read-and-insert-char ()
798 (viper-set-mode-vars-for 'emacs-state)
799 (viper-normalize-minor-mode-map-alist)
800 (if viper-special-input-method
801 (viper-set-input-method t))
802 (if viper-automatic-iso-accents
803 (viper-set-iso-accents-mode t))
805 (let (viper-vi-kbd-minor-mode
806 viper-insert-kbd-minor-mode
807 viper-emacs-kbd-minor-mode
809 (cond ((and viper-special-input-method
811 (fboundp 'quail-input-method))
812 ;; (let ...) is used to restore unread-command-events to the
813 ;; original state. We don't want anything left in there after
814 ;; key translation. (Such left-overs are possible if the user
815 ;; types a regular key.)
816 (let (unread-command-events)
817 ;; The next cmd and viper-set-unread-command-events
818 ;; are intended to prevent the input method
819 ;; from swallowing ^M, ^Q and other special characters
820 (setq ch (read-char-exclusive))
821 ;; replace ^M with the newline
822 (if (eq ch ?\C-m) (setq ch ?\n))
823 ;; Make sure ^V and ^Q work as quotation chars
824 (if (memq ch '(?\C-v ?\C-q))
825 (setq ch (read-char-exclusive)))
826 (viper-set-unread-command-events ch)
827 (quail-input-method nil)
829 (if (and ch (string= quail-current-str ""))
831 (insert quail-current-str))
833 (aref quail-current-str
834 (1- (length quail-current-str)))))
836 ((and viper-special-input-method
838 (fboundp 'quail-start-translation))
839 ;; same as above but for XEmacs, which doesn't have
840 ;; quail-input-method
841 (let (unread-command-events)
842 (setq ch (read-char-exclusive))
843 ;; replace ^M with the newline
844 (if (eq ch ?\C-m) (setq ch ?\n))
845 ;; Make sure ^V and ^Q work as quotation chars
846 (if (memq ch '(?\C-v ?\C-q))
847 (setq ch (read-char-exclusive)))
848 (viper-set-unread-command-events ch)
849 (quail-start-translation nil)
851 (if (and ch (string= quail-current-str ""))
853 (insert quail-current-str))
855 (aref quail-current-str
856 (1- (length quail-current-str)))))
858 ((and (boundp 'iso-accents-mode) iso-accents-mode)
859 (setq ch (aref (read-key-sequence nil) 0))
860 ;; replace ^M with the newline
861 (if (eq ch ?\C-m) (setq ch ?\n))
862 ;; Make sure ^V and ^Q work as quotation chars
863 (if (memq ch '(?\C-v ?\C-q))
864 (setq ch (aref (read-key-sequence nil) 0)))
867 ;;(setq ch (read-char-exclusive))
868 (setq ch (aref (read-key-sequence nil) 0))
869 (if (featurep 'xemacs)
870 (setq ch (event-to-character ch)))
871 ;; replace ^M with the newline
872 (if (eq ch ?\C-m) (setq ch ?\n))
873 ;; Make sure ^V and ^Q work as quotation chars
874 (if (memq ch '(?\C-v ?\C-q))
876 ;;(setq ch (read-char-exclusive))
877 (setq ch (aref (read-key-sequence nil) 0))
878 (if (featurep 'xemacs)
879 (setq ch (event-to-character ch))))
883 (setq last-command-event
884 (viper-copy-event (if (featurep 'xemacs)
885 (character-to-event ch) ch)))
890 (viper-set-input-method nil)
891 (viper-set-iso-accents-mode nil)
892 (viper-set-mode-vars-for viper-current-state)
896 (defun viper-exec-form-in-vi (form)
897 "Execute FORM in Vi state, regardless of the current Vi state."
898 (let ((buff (current-buffer))
900 (viper-set-mode-vars-for 'vi-state)
903 (let (viper-vi-kbd-minor-mode) ; execute without kbd macros
904 (setq result (eval form)))
908 (if (not (equal buff (current-buffer))) ; cmd switched buffer
909 (with-current-buffer buff
910 (viper-set-mode-vars-for viper-current-state)))
911 (viper-set-mode-vars-for viper-current-state)
914 (defun viper-exec-form-in-emacs (form)
915 "Execute FORM in Emacs, temporarily disabling Viper's minor modes.
916 Similar to `viper-escape-to-emacs', but accepts forms rather than keystrokes."
917 (let ((buff (current-buffer))
919 (viper-set-mode-vars-for 'emacs-state)
920 (setq result (eval form))
921 (if (not (equal buff (current-buffer))) ; cmd switched buffer
922 (with-current-buffer buff
923 (viper-set-mode-vars-for viper-current-state)))
924 (viper-set-mode-vars-for viper-current-state)
927 ;; This executes the last kbd event in emacs mode. Is used when we want to
928 ;; interpret certain keys directly in emacs (as, for example, in comint mode).
929 (defun viper-exec-key-in-emacs (arg)
931 (viper-escape-to-emacs arg last-command-event))
934 ;; This is needed because minor modes sometimes override essential Viper
935 ;; bindings. By letting Viper know which files these modes are in, it will
936 ;; arrange to reorganize minor-mode-map-alist so that things will work right.
937 (defun viper-harness-minor-mode (load-file)
938 "Familiarize Viper with a minor mode defined in LOAD-FILE.
939 Minor modes that have their own keymaps may overshadow Viper keymaps.
940 This function is designed to make Viper aware of the packages that define
943 (viper-harness-minor-mode load-file)
945 LOAD-FILE is the name of the file where the specific minor mode is defined.
946 Suffixes such as .el or .elc should be stripped."
948 (interactive "sEnter name of the load file: ")
950 (eval-after-load load-file '(viper-normalize-minor-mode-map-alist))
952 ;; Change the default for minor-mode-map-alist each time a harnessed minor
953 ;; mode adds its own keymap to the a-list.
955 (and (fboundp 'add-to-ordered-list) (boundp 'emulation-mode-map-alists))
957 load-file '(setq-default minor-mode-map-alist minor-mode-map-alist)))
961 (defun viper-ESC (arg)
962 "Emulate ESC key in Emacs.
963 Prevents multiple escape keystrokes if viper-no-multiple-ESC is true.
964 If `viper-no-multiple-ESC' is `twice' double ESC would ding in vi-state.
965 Other ESC sequences are emulated via the current Emacs's major mode
966 keymap. This is more convenient on TTYs, since this won't block
967 function keys such as up, down, etc. ESC will also will also work as
968 a Meta key in this case. When `viper-no-multiple-ESC' is nil, ESC works
969 as a Meta key and any number of multiple escapes are allowed."
972 (cond ((and (not viper-no-multiple-ESC) (eq viper-current-state 'vi-state))
973 (setq char (viper-read-char-exclusive))
974 (viper-escape-to-emacs arg (list ?\e char) ))
975 ((and (eq viper-no-multiple-ESC 'twice)
976 (eq viper-current-state 'vi-state))
977 (setq char (viper-read-char-exclusive))
978 (if (= char (string-to-char viper-ESC-key))
980 (viper-escape-to-emacs arg (list ?\e char) )))
984 (defun viper-alternate-Meta-key (arg)
985 "Simulate Emacs Meta key."
987 (sit-for 1) (message "ESC-")
988 (viper-escape-to-emacs arg '(?\e)))
990 (defun viper-toggle-key-action ()
991 "Action bound to `viper-toggle-key'."
993 (if (and (< viper-expert-level 2) (equal viper-toggle-key "\C-z"))
994 (if (viper-window-display-p)
997 (viper-change-state-to-emacs)))
999 ;; Listen to ESC key.
1000 (defun viper-intercept-ESC-key ()
1001 "Function that implements ESC key in Viper emulation of Vi."
1003 ;; `key-binding' needs to be called in a context where Viper's
1004 ;; minor-mode map(s) have been temporarily disabled so the ESC
1005 ;; binding to viper-intercept-ESC-key doesn't hide the binding we're
1006 ;; looking for (Bug#9146):
1007 (let* ((cmd 'viper-intercept-ESC-key))
1009 ;; call the actual function to execute ESC (if no other symbols followed)
1010 ;; or the key bound to the ESC sequence (if the sequence was issued
1011 ;; with very short delay between characters).
1012 (if (eq cmd 'viper-intercept-ESC-key)
1014 (cond ((eq viper-current-state 'vi-state)
1016 ((eq viper-current-state 'insert-state)
1017 'viper-exit-insert-state)
1018 ((eq viper-current-state 'replace-state)
1019 'viper-replace-state-exit-cmd)
1020 (t 'viper-change-state-to-vi)
1022 (call-interactively cmd)))
1027 ;; prefix argument for Vi mode
1029 ;; In Vi mode, prefix argument is a dotted pair (NUM . COM) where NUM
1030 ;; represents the numeric value of the prefix argument and COM represents
1031 ;; command prefix such as "c", "d", "m" and "y".
1033 ;; Get value part of prefix-argument ARG.
1034 (defsubst viper-p-val (arg)
1035 (cond ((null arg) 1)
1037 (if (or (null (car arg)) (equal (car arg) '(nil)))
1041 ;; Get raw value part of prefix-argument ARG.
1042 (defsubst viper-P-val (arg)
1043 (cond ((consp arg) (car arg))
1046 ;; Get com part of prefix-argument ARG.
1047 (defsubst viper-getcom (arg)
1048 (cond ((null arg) nil)
1049 ((consp arg) (cdr arg))
1052 ;; Get com part of prefix-argument ARG and modify it.
1053 (defun viper-getCom (arg)
1054 (let ((com (viper-getcom arg)))
1055 (cond ((viper= com ?c) ?c)
1056 ;; Previously, ?c was being converted to ?C, but this prevented
1057 ;; multiline replace regions.
1058 ;;((viper= com ?c) ?C)
1059 ((viper= com ?d) ?D)
1060 ((viper= com ?y) ?Y)
1064 ;; Compute numeric prefix arg value.
1065 ;; Invoked by EVENT-CHAR. COM is the command part obtained so far.
1066 (defun viper-prefix-arg-value (event-char com)
1067 (let ((viper-intermediate-command 'viper-digit-argument)
1069 ;; read while number
1070 (while (and (viper-characterp event-char)
1071 (>= event-char ?0) (<= event-char ?9))
1072 (setq value (+ (* (if (integerp value) value 0) 10) (- event-char ?0)))
1073 (setq event-char (viper-read-event-convert-to-char)))
1075 (setq prefix-arg value)
1076 (if com (setq prefix-arg (cons prefix-arg com)))
1077 (while (eq event-char ?U)
1078 (viper-describe-arg prefix-arg)
1079 (setq event-char (viper-read-event-convert-to-char)))
1081 (if (or com (and (not (eq viper-current-state 'vi-state))
1082 ;; make sure it is a Vi command
1083 (viper-characterp event-char)
1084 (viper-vi-command-p event-char)
1086 ;; If appears to be one of the vi commands,
1087 ;; then execute it with funcall and clear prefix-arg in order to not
1088 ;; confuse subsequent commands
1090 ;; last-command-event is the char we want emacs to think was typed
1091 ;; last. If com is not nil, the viper-digit-argument command was
1092 ;; called from within viper-prefix-arg command, such as `d', `w',
1093 ;; etc., i.e., the user typed, say, d2. In this case, `com' would be
1094 ;; `d', `w', etc. If viper-digit-argument was invoked by
1095 ;; viper-escape-to-vi (which is indicated by the fact that the
1096 ;; current state is not vi-state), then `event-char' represents the
1097 ;; vi command to be executed (e.g., `d', `w', etc). Again,
1098 ;; last-command-event must make emacs believe that this is the command
1100 (cond ((eq event-char 'return) (setq event-char ?\C-m))
1101 ((eq event-char 'delete) (setq event-char ?\C-?))
1102 ((eq event-char 'backspace) (setq event-char ?\C-h))
1103 ((eq event-char 'space) (setq event-char ?\ )))
1104 (setq last-command-event
1105 (if (featurep 'xemacs)
1106 (character-to-event (or com event-char))
1107 (or com event-char)))
1108 (setq func (viper-exec-form-in-vi
1109 `(key-binding (char-to-string ,event-char))))
1110 (funcall func prefix-arg)
1111 (setq prefix-arg nil))
1112 ;; some other command -- let emacs do it in its own way
1113 (viper-set-unread-command-events event-char))
1117 ;; Vi operator as prefix argument."
1118 (defun viper-prefix-arg-com (char value com)
1123 (viper-memq-char char
1124 (list ?c ?d ?y ?! ?< ?> ?= ?# ?r ?R ?\"
1125 viper-buffer-search-char)))
1127 ;; this means that we already have a command character, so we
1128 ;; construct a com list and exit while. however, if char is "
1131 ;; new com is (CHAR . OLDCOM)
1132 (if (viper-memq-char char '(?# ?\")) (error "Viper bell"))
1133 (setq com (cons char com))
1135 ;; If com is nil we set com as char, and read more. Again, if char is
1136 ;; ", we read the name of register and store it in viper-use-register.
1137 ;; if char is !, =, or #, a complete com is formed so we exit the while
1139 (cond ((viper-memq-char char '(?! ?=))
1141 (setq char (read-char))
1144 ;; read a char and encode it as com
1145 (setq com (+ 128 (read-char)))
1146 (setq char (read-char)))
1148 (let ((reg (read-char)))
1149 (if (viper-valid-register reg)
1150 (setq viper-use-register reg)
1151 (error "Viper bell"))
1152 (setq char (read-char))))
1155 (setq char (read-char))))))
1158 ;; `com' is a single char, so we construct the command argument
1159 ;; and if `char' is `?', we describe the arg; otherwise
1160 ;; we prepare the command that will be executed at the end.
1162 (setq cmd-info (cons value com))
1163 (while (viper= char ?U)
1164 (viper-describe-arg cmd-info)
1165 (setq char (read-char)))
1166 ;; `char' is a movement cmd, a digit arg cmd, or a register cmd---so
1167 ;; we execute it at the very end
1168 (or (viper-movement-command-p char)
1169 (viper-digit-command-p char)
1170 (viper-regsuffix-command-p char)
1171 (viper= char ?!) ; bang command
1172 (viper= char ?g) ; the gg command (like G0)
1173 (error "Viper bell"))
1174 (setq cmd-to-exec-at-end
1175 (viper-exec-form-in-vi
1176 `(key-binding (char-to-string ,char)))))
1178 ;; as com is non-nil, this means that we have a command to execute
1179 (if (viper-memq-char (car com) '(?r ?R))
1180 ;; execute appropriate region command.
1181 (let ((char (car com)) (com (cdr com)))
1182 (setq prefix-arg (cons value com))
1183 (if (viper= char ?r)
1184 (viper-region prefix-arg)
1185 (viper-Region prefix-arg))
1187 (setq prefix-arg nil))
1188 ;; otherwise, reset prefix arg and call appropriate command
1189 (setq value (if (null value) 1 value))
1190 (setq prefix-arg nil)
1192 ;; If we change ?C to ?c here, then cc will enter replacement mode
1193 ;; rather than deleting lines. However, it will affect 1 less line
1194 ;; than normal. We decided to not use replacement mode here and
1195 ;; follow Vi, since replacement mode on n full lines can be achieved
1197 ((equal com '(?c . ?c)) (viper-line (cons value ?C)))
1198 ((equal com '(?d . ?d)) (viper-line (cons value ?D)))
1199 ((equal com '(?d . ?y)) (viper-yank-defun))
1200 ((equal com '(?y . ?y)) (viper-line (cons value ?Y)))
1201 ((equal com '(?< . ?<)) (viper-line (cons value ?<)))
1202 ((equal com '(?> . ?>)) (viper-line (cons value ?>)))
1203 ((equal com '(?! . ?!)) (viper-line (cons value ?!)))
1204 ((equal com '(?= . ?=)) (viper-line (cons value ?=)))
1206 ((equal (car com) ?g) (viper-goto-line 0))
1207 (t (error "Viper bell")))))
1209 (if cmd-to-exec-at-end
1211 (setq last-command-event
1213 (if (featurep 'xemacs) (character-to-event char) char)))
1215 (funcall cmd-to-exec-at-end cmd-info)
1217 (error "%s" (error-message-string err))))))
1220 (defun viper-describe-arg (arg)
1222 (setq val (viper-P-val arg)
1223 com (viper-getcom arg))
1226 (message "Value is nil, and command is nil")
1227 (message "Value is nil, and command is `%c'" com))
1229 (message "Value is `%d', and command is nil" val)
1230 (message "Value is `%d', and command is `%c'" val com)))))
1232 (defun viper-digit-argument (arg)
1233 "Begin numeric argument for the next command."
1235 (viper-leave-region-active)
1236 (viper-prefix-arg-value
1237 (viper-last-command-char) (if (consp arg) (cdr arg) nil)))
1239 (defun viper-command-argument (arg)
1240 "Accept a motion command as an argument."
1242 (let ((viper-intermediate-command 'viper-command-argument))
1244 (viper-prefix-arg-com
1245 (viper-last-command-char)
1246 (cond ((null arg) nil)
1247 ((consp arg) (car arg))
1248 ((integerp arg) arg)
1249 (t (error viper-InvalidCommandArgument)))
1250 (cond ((null arg) nil)
1251 ((consp arg) (cdr arg))
1252 ((integerp arg) nil)
1253 (t (error viper-InvalidCommandArgument))))
1254 (quit (setq viper-use-register nil)
1255 (signal 'quit nil)))
1256 (viper-deactivate-mark)))
1259 ;; repeat last destructive command
1261 ;; Append region to text in register REG.
1262 ;; START and END are buffer positions indicating what to append.
1263 (defsubst viper-append-to-register (reg start end)
1264 (set-register reg (concat (if (stringp (get-register reg))
1265 (get-register reg) "")
1266 (buffer-substring start end))))
1268 ;; Saves last inserted text for possible use by viper-repeat command.
1269 (defun viper-save-last-insertion (beg end)
1271 (setq viper-last-insertion (buffer-substring beg end))
1273 ;; beg or end marker are somehow screwed up
1274 (setq viper-last-insertion nil)))
1275 (setq viper-last-insertion (buffer-substring beg end))
1276 (or (< (length viper-d-com) 5)
1277 (setcar (nthcdr 4 viper-d-com) viper-last-insertion))
1278 (or (null viper-command-ring)
1279 (ring-empty-p viper-command-ring)
1281 (setcar (nthcdr 4 (viper-current-ring-item viper-command-ring))
1282 viper-last-insertion)
1283 ;; del most recent elt, if identical to the second most-recent
1284 (viper-cleanup-ring viper-command-ring)))
1287 (defsubst viper-yank-last-insertion ()
1288 "Inserts the text saved by the previous viper-save-last-insertion command."
1290 (insert viper-last-insertion)
1294 ;; define functions to be executed
1296 ;; invoked by the `C' command
1297 (defun viper-exec-change (m-com _com)
1298 (or (and (markerp viper-com-point) (marker-position viper-com-point))
1299 (set-marker viper-com-point (point) (current-buffer)))
1300 ;; handle C cmd at the eol and at eob.
1301 (if (or (and (eolp) (= viper-com-point (point)))
1302 (= viper-com-point (point-max)))
1304 (insert " ")(backward-char 1)))
1305 (if (= viper-com-point (point))
1306 (viper-forward-char-carefully))
1307 (push-mark viper-com-point)
1308 (if (eq m-com 'viper-next-line-at-bol)
1309 (viper-enlarge-region (mark t) (point)))
1310 (if (< (point) (mark t))
1311 (exchange-point-and-mark))
1312 (if (eq (preceding-char) ?\n)
1313 (viper-backward-char-carefully)) ; give back the newline
1314 (if (eq viper-intermediate-command 'viper-repeat)
1315 (viper-change-subr (mark t) (point))
1316 (viper-change (mark t) (point))))
1318 ;; this is invoked by viper-substitute-line
1319 (defun viper-exec-Change (_m-com _com)
1321 (set-mark viper-com-point)
1322 (viper-enlarge-region (mark t) (point))
1323 (if viper-use-register
1325 (cond ((viper-valid-register viper-use-register '(letter digit))
1327 viper-use-register (mark t) (point) nil))
1328 ((viper-valid-register viper-use-register '(Letter))
1329 (viper-append-to-register
1330 (downcase viper-use-register) (mark t) (point)))
1331 (t (setq viper-use-register nil)
1332 (error viper-InvalidRegister viper-use-register)))
1333 (setq viper-use-register nil)))
1334 (delete-region (mark t) (point)))
1336 (if (eq viper-intermediate-command 'viper-repeat)
1337 (viper-yank-last-insertion)
1338 (viper-change-state-to-insert)
1341 (defun viper-exec-delete (_m-com _com)
1342 (or (and (markerp viper-com-point) (marker-position viper-com-point))
1343 (set-marker viper-com-point (point) (current-buffer)))
1344 (let (chars-deleted)
1345 (if viper-use-register
1347 (cond ((viper-valid-register viper-use-register '(letter digit))
1349 viper-use-register viper-com-point (point) nil))
1350 ((viper-valid-register viper-use-register '(Letter))
1351 (viper-append-to-register
1352 (downcase viper-use-register) viper-com-point (point)))
1353 (t (setq viper-use-register nil)
1354 (error viper-InvalidRegister viper-use-register)))
1355 (setq viper-use-register nil)))
1357 (if (eq last-command 'd-command) 'kill-region nil))
1358 (setq chars-deleted (abs (- (point) viper-com-point)))
1359 (if (> chars-deleted viper-change-notification-threshold)
1360 (unless (viper-is-in-minibuffer)
1361 (message "Deleted %d characters" chars-deleted)))
1362 (kill-region viper-com-point (point))
1363 (setq this-command 'd-command)
1364 (if viper-ex-style-motion
1365 (if (and (eolp) (not (bolp))) (backward-char 1)))))
1367 (defun viper-exec-Delete (m-com _com)
1369 (set-mark viper-com-point)
1370 (viper-enlarge-region (mark t) (point))
1371 (let (lines-deleted)
1372 (if viper-use-register
1374 (cond ((viper-valid-register viper-use-register '(letter digit))
1376 viper-use-register (mark t) (point) nil))
1377 ((viper-valid-register viper-use-register '(Letter))
1378 (viper-append-to-register
1379 (downcase viper-use-register) (mark t) (point)))
1380 (t (setq viper-use-register nil)
1381 (error viper-InvalidRegister viper-use-register)))
1382 (setq viper-use-register nil)))
1384 (if (eq last-command 'D-command) 'kill-region nil))
1385 (setq lines-deleted (count-lines (point) viper-com-point))
1386 (if (> lines-deleted viper-change-notification-threshold)
1387 (unless (viper-is-in-minibuffer)
1388 (message "Deleted %d lines" lines-deleted)))
1389 (kill-region (mark t) (point))
1390 (if (eq m-com 'viper-line) (setq this-command 'D-command)))
1391 (back-to-indentation)))
1394 (defun viper-exec-yank (_m-com _com)
1395 (or (and (markerp viper-com-point) (marker-position viper-com-point))
1396 (set-marker viper-com-point (point) (current-buffer)))
1398 (if viper-use-register
1400 (cond ((viper-valid-register viper-use-register '(letter digit))
1402 viper-use-register viper-com-point (point) nil))
1403 ((viper-valid-register viper-use-register '(Letter))
1404 (viper-append-to-register
1405 (downcase viper-use-register) viper-com-point (point)))
1406 (t (setq viper-use-register nil)
1407 (error viper-InvalidRegister viper-use-register)))
1408 (setq viper-use-register nil)))
1409 (setq last-command nil)
1410 (copy-region-as-kill viper-com-point (point))
1411 (setq chars-saved (abs (- (point) viper-com-point)))
1412 (if (> chars-saved viper-change-notification-threshold)
1413 (unless (viper-is-in-minibuffer)
1414 (message "Saved %d characters" chars-saved)))
1415 (goto-char viper-com-point)))
1418 (defun viper-exec-Yank (_m-com _com)
1420 (set-mark viper-com-point)
1421 (viper-enlarge-region (mark t) (point))
1423 (if viper-use-register
1425 (cond ((viper-valid-register viper-use-register '(letter digit))
1427 viper-use-register (mark t) (point) nil))
1428 ((viper-valid-register viper-use-register '(Letter))
1429 (viper-append-to-register
1430 (downcase viper-use-register) (mark t) (point)))
1431 (t (setq viper-use-register nil)
1432 (error viper-InvalidRegister viper-use-register)))
1433 (setq viper-use-register nil)))
1434 (setq last-command nil)
1435 (copy-region-as-kill (mark t) (point))
1436 (setq lines-saved (count-lines (mark t) (point)))
1437 (if (> lines-saved viper-change-notification-threshold)
1438 (unless (viper-is-in-minibuffer)
1439 (message "Saved %d lines" lines-saved)))))
1440 (viper-deactivate-mark)
1441 (goto-char viper-com-point))
1443 (defun viper-exec-bang (_m-com com)
1445 (set-mark viper-com-point)
1446 (viper-enlarge-region (mark t) (point))
1447 (exchange-point-and-mark)
1448 (shell-command-on-region
1451 (setq viper-last-shell-com
1452 (viper-read-string-with-history
1455 'viper-shell-history
1456 (car viper-shell-history)
1458 viper-last-shell-com)
1461 (defun viper-exec-equals (_m-com _com)
1463 (set-mark viper-com-point)
1464 (viper-enlarge-region (mark t) (point))
1465 (if (> (mark t) (point)) (exchange-point-and-mark))
1466 (indent-region (mark t) (point) nil)))
1468 (defun viper-exec-shift (_m-com com)
1470 (set-mark viper-com-point)
1471 (viper-enlarge-region (mark t) (point))
1472 (if (> (mark t) (point)) (exchange-point-and-mark))
1473 (indent-rigidly (mark t) (point)
1476 (- viper-shift-width))))
1477 ;; return point to where it was before shift
1478 (goto-char viper-com-point))
1480 ;; this is needed because some commands fake com by setting it to ?r, which
1481 ;; denotes repeated insert command.
1482 (defsubst viper-exec-dummy (_m-com _com)
1485 (defun viper-exec-buffer-search (_m-com _com)
1486 (setq viper-s-string
1487 (regexp-quote (buffer-substring (point) viper-com-point)))
1488 (setq viper-s-forward t)
1489 (setq viper-search-history (cons viper-s-string viper-search-history))
1490 (setq viper-intermediate-command 'viper-exec-buffer-search)
1491 (viper-search viper-s-string viper-s-forward 1))
1493 (defvar viper-exec-array (make-vector 128 nil))
1495 ;; Using a dispatch array allows adding functions like buffer search
1496 ;; without affecting other functions. Buffer search can now be bound
1497 ;; to any character.
1499 (aset viper-exec-array ?c 'viper-exec-change)
1500 (aset viper-exec-array ?C 'viper-exec-Change)
1501 (aset viper-exec-array ?d 'viper-exec-delete)
1502 (aset viper-exec-array ?D 'viper-exec-Delete)
1503 (aset viper-exec-array ?y 'viper-exec-yank)
1504 (aset viper-exec-array ?Y 'viper-exec-Yank)
1505 (aset viper-exec-array ?r 'viper-exec-dummy)
1506 (aset viper-exec-array ?! 'viper-exec-bang)
1507 (aset viper-exec-array ?< 'viper-exec-shift)
1508 (aset viper-exec-array ?> 'viper-exec-shift)
1509 (aset viper-exec-array ?= 'viper-exec-equals)
1513 ;; This function is called by various movement commands to execute a
1514 ;; destructive command on the region specified by the movement command. For
1515 ;; instance, if the user types cw, then the command viper-forward-word will
1516 ;; call viper-execute-com to execute viper-exec-change, which eventually will
1517 ;; call viper-change to invoke the replace mode on the region.
1519 ;; The var viper-d-com is set to (M-COM VAL COM REG INSERTED-TEXT COMMAND-KEYS)
1520 ;; via a call to viper-set-destructive-command, for later use by viper-repeat.
1521 (defun viper-execute-com (m-com val com)
1522 (let ((reg viper-use-register))
1523 ;; this is the special command `#'
1525 (viper-special-prefix-com (- com 128))
1526 (let ((fn (aref viper-exec-array com)))
1528 (error "%c: %s" com viper-InvalidViCommand)
1529 (funcall fn m-com com))))
1530 (if (viper-dotable-command-p com)
1531 (viper-set-destructive-command
1532 (list m-com val com reg nil nil)))
1536 (defun viper-repeat (arg)
1537 "Re-execute last destructive command.
1538 Use the info in viper-d-com, which has the form
1539 \(com val ch reg inserted-text command-keys),
1540 where `com' is the command to be re-executed, `val' is the
1541 argument to `com', `ch' is a flag for repeat, and `reg' is optional;
1542 if it exists, it is the name of the register for `com'.
1543 If the prefix argument ARG is non-nil, it is used instead of `val'."
1545 (let ((save-point (point)) ; save point before repeating prev cmd
1546 ;; Pass along that we are repeating a destructive command
1547 ;; This tells viper-set-destructive-command not to update
1548 ;; viper-command-ring
1549 (viper-intermediate-command 'viper-repeat))
1550 (if (eq last-command 'viper-undo)
1551 ;; if the last command was viper-undo, then undo-more
1553 ;; otherwise execute the command stored in viper-d-com. if arg is
1554 ;; non-nil its prefix value is used as new prefix value for the command.
1555 (let ((m-com (car viper-d-com))
1556 (val (viper-P-val arg))
1557 (com (nth 2 viper-d-com))
1558 (reg (nth 3 viper-d-com)))
1559 (if (null val) (setq val (nth 1 viper-d-com)))
1560 (if (null m-com) (error "No previous command to repeat"))
1561 (setq viper-use-register reg)
1562 (if (nth 4 viper-d-com) ; text inserted by command
1563 (setq viper-last-insertion (nth 4 viper-d-com)
1564 viper-d-char (nth 4 viper-d-com)))
1565 (funcall m-com (cons val com))
1566 (cond ((and (< save-point (point)) viper-keep-point-on-repeat)
1567 (goto-char save-point)) ; go back to before repeat.
1568 ((and (< save-point (point)) viper-ex-style-editing)
1569 (or (bolp) (backward-char 1))))
1570 (if (and (eolp) (not (bolp)))
1573 (viper-adjust-undo) ; take care of undo
1574 ;; If the prev cmd was rotating the command ring, this means that `.' has
1575 ;; just executed a command from that ring. So, push it on the ring again.
1576 ;; If we are just executing previous command , then don't push viper-d-com
1577 ;; because viper-d-com is not fully constructed in this case (its keys and
1578 ;; the inserted text may be nil). Besides, in this case, the command
1579 ;; executed by `.' is already on the ring.
1580 (if (eq last-command 'viper-display-current-destructive-command)
1581 (viper-push-onto-ring viper-d-com 'viper-command-ring))
1582 (viper-deactivate-mark)
1585 (defun viper-repeat-from-history ()
1586 "Repeat a destructive command from history.
1587 Doesn't change viper-command-ring in any way, so `.' will work as before
1588 executing this command.
1589 This command is supposed to be bound to a two-character Vi macro where
1590 the second character is a digit 0 to 9. The digit indicates which
1591 history command to execute. `<char>0' is equivalent to `.', `<char>1'
1592 invokes the command before that, etc."
1594 (let* ((viper-intermediate-command 'repeating-display-destructive-command)
1595 (idx (cond (viper-this-kbd-macro
1597 (symbol-name (elt viper-this-kbd-macro 1))))
1600 (viper-d-com viper-d-com))
1602 (or (and (numberp num) (<= 0 num) (<= num 9))
1607 "`viper-repeat-from-history' must be invoked as a Vi macro bound to `<key><digit>'")))
1609 (setq viper-d-com (viper-special-ring-rotate1 viper-command-ring -1))
1610 (setq num (1- num)))
1613 (viper-special-ring-rotate1 viper-command-ring 1)
1614 (setq num (1+ num)))
1618 ;; The hash-command. It is invoked interactively by the key sequence #<char>.
1619 ;; The chars that can follow `#' are determined by viper-hash-command-p
1620 (defun viper-special-prefix-com (char)
1621 (cond ((viper= char ?c)
1622 (downcase-region (min viper-com-point (point))
1623 (max viper-com-point (point))))
1625 (upcase-region (min viper-com-point (point))
1626 (max viper-com-point (point))))
1628 (push-mark viper-com-point t)
1629 ;; execute the last emacs kbd macro on each line of the region
1630 (viper-global-execute))
1632 (push-mark viper-com-point t)
1633 (viper-quote-region))
1635 (funcall viper-spell-function viper-com-point (point)))
1636 (t (error "#%c: %s" char viper-InvalidViCommand))))
1641 ;; hook used inside undo
1642 (defvar viper-undo-functions nil)
1644 ;; Runs viper-before-change-functions inside before-change-functions
1645 (defun viper-undo-sentinel (beg end length)
1646 (run-hook-with-args 'viper-undo-functions beg end length))
1648 (add-hook 'after-change-functions 'viper-undo-sentinel)
1650 ;; Hook used in viper-undo
1651 (defun viper-after-change-undo-hook (beg end _len)
1652 (if (and (boundp 'undo-in-progress) undo-in-progress)
1653 (setq undo-beg-posn beg
1654 undo-end-posn (or end beg))
1655 ;; some other hooks may be changing various text properties in
1656 ;; the buffer in response to 'undo'; so remove this hook to avoid
1657 ;; its repeated invocation
1658 (remove-hook 'viper-undo-functions 'viper-after-change-undo-hook 'local)
1661 (defun viper-undo ()
1662 "Undo previous change."
1665 (let ((before-undo-pt (point-marker))
1666 undo-beg-posn undo-end-posn)
1668 ;; the viper-after-change-undo-hook removes itself after the 1st invocation
1669 (add-hook 'viper-undo-functions 'viper-after-change-undo-hook nil 'local)
1673 ;;(setq undo-beg-posn (or undo-beg-posn (point))
1674 ;; undo-end-posn (or undo-end-posn (point)))
1675 ;;(setq undo-beg-posn (or undo-beg-posn before-undo-pt)
1676 ;; undo-end-posn (or undo-end-posn undo-beg-posn))
1678 (if (and undo-beg-posn undo-end-posn)
1680 (goto-char undo-beg-posn)
1682 (if (and viper-keep-point-on-undo
1683 (pos-visible-in-window-p before-undo-pt))
1685 (push-mark (point-marker) t)
1686 (viper-sit-for-short 300)
1687 (goto-char undo-end-posn)
1688 (viper-sit-for-short 300)
1689 (if (pos-visible-in-window-p undo-beg-posn)
1690 (goto-char before-undo-pt)
1691 (goto-char undo-beg-posn)))
1692 (push-mark before-undo-pt t))
1695 (if (and (eolp) (not (bolp))) (backward-char 1))
1697 (setq this-command 'viper-undo))
1699 ;; Continue undoing previous changes.
1700 (defun viper-undo-more ()
1701 (message "undo more!")
1705 (message "No further undo information in this buffer")))
1706 (if (and (eolp) (not (bolp))) (backward-char 1))
1707 (setq this-command 'viper-undo))
1709 ;; The following two functions are used to set up undo properly.
1710 ;; In VI, unlike Emacs, if you open a line, say, and add a bunch of lines,
1711 ;; they are undone all at once.
1712 (defun viper-adjust-undo ()
1713 (if viper-undo-needs-adjustment
1714 (let ((inhibit-quit t)
1716 (setq viper-undo-needs-adjustment nil)
1717 (when (listp buffer-undo-list)
1718 (let ((had-boundary (null (car buffer-undo-list))))
1719 (if (setq tmp (memq viper-buffer-undo-list-mark buffer-undo-list))
1721 (setq tmp2 (cdr tmp)) ; the part after mark
1723 ;; cut tail from buffer-undo-list temporarily by direct
1724 ;; manipulation with pointers in buffer-undo-list
1727 (setq buffer-undo-list (delq nil buffer-undo-list))
1728 (setq buffer-undo-list
1729 (delq viper-buffer-undo-list-mark buffer-undo-list))
1730 ;; restore tail of buffer-undo-list
1731 (setq buffer-undo-list (nconc buffer-undo-list tmp2)))
1732 (setq buffer-undo-list (delq nil buffer-undo-list)))
1733 ;; The top-level loop only adds boundaries if there has been
1734 ;; modifications in the buffer, so make sure we don't accidentally
1735 ;; drop the "final" boundary (bug#22295).
1736 (if had-boundary (undo-boundary)))))))
1739 (defun viper-set-complex-command-for-undo ()
1740 (if (listp buffer-undo-list)
1741 (if (not viper-undo-needs-adjustment)
1742 (let ((inhibit-quit t))
1743 (setq buffer-undo-list
1744 (cons viper-buffer-undo-list-mark buffer-undo-list))
1745 (setq viper-undo-needs-adjustment t)))))
1748 ;;; Viper's destructive Command ring utilities
1750 (defun viper-display-current-destructive-command ()
1751 (let ((text (nth 4 viper-d-com))
1752 (keys (nth 5 viper-d-com))
1755 (setq this-command 'viper-display-current-destructive-command)
1757 (message " `.' runs `%s'%s"
1758 (viper-array-to-string keys)
1759 (viper-abbreviate-string
1760 (if (featurep 'xemacs)
1761 (replace-in-string ; xemacs
1762 (cond ((characterp text) (char-to-string text))
1763 ((stringp text) text)
1769 (format-message " inserting `") (format-message "'")
1774 ;; don't change viper-d-com if it was viper-repeat command invoked with `.'
1775 ;; or in some other way (non-interactively).
1776 (defun viper-set-destructive-command (list)
1777 (or (eq viper-intermediate-command 'viper-repeat)
1779 (setq viper-d-com list)
1780 (setcar (nthcdr 5 viper-d-com)
1781 (viper-array-to-string (if (arrayp viper-this-command-keys)
1782 viper-this-command-keys
1783 (this-command-keys))))
1784 (viper-push-onto-ring viper-d-com 'viper-command-ring)))
1785 (setq viper-this-command-keys nil))
1788 (defun viper-prev-destructive-command (next)
1789 "Find previous destructive command in the history of destructive commands.
1790 With prefix argument, find next destructive command."
1792 (let (cmd viper-intermediate-command)
1793 (if (eq last-command 'viper-display-current-destructive-command)
1794 ;; repeated search through command history
1795 (setq viper-intermediate-command
1796 'repeating-display-destructive-command)
1797 ;; first search through command history--set temp ring
1798 (setq viper-temp-command-ring (ring-copy viper-command-ring)))
1800 (viper-special-ring-rotate1 viper-temp-command-ring 1)
1801 (viper-special-ring-rotate1 viper-temp-command-ring -1)))
1804 (setq viper-d-com cmd))
1805 (viper-display-current-destructive-command)))
1808 (defun viper-next-destructive-command ()
1809 "Find next destructive command in the history of destructive commands."
1811 (viper-prev-destructive-command 'next))
1814 (defun viper-insert-prev-from-insertion-ring (arg)
1815 "Cycle through insertion ring in the direction of older insertions.
1816 Undoes previous insertion and inserts new.
1817 With prefix argument, cycles in the direction of newer elements.
1818 In minibuffer, this command executes whatever the invocation key is bound
1819 to in the global map, instead of cycling through the insertion ring."
1821 (let (viper-intermediate-command)
1822 (if (eq last-command 'viper-insert-from-insertion-ring)
1823 (progn ; repeated search through insertion history
1824 (setq viper-intermediate-command 'repeating-insertion-from-ring)
1825 (if (eq viper-current-state 'replace-state)
1827 (if viper-last-inserted-string-from-insertion-ring
1828 (backward-delete-char
1829 (length viper-last-inserted-string-from-insertion-ring))))
1831 ;;first search through insertion history
1832 (setq viper-temp-insertion-ring (ring-copy viper-insertion-ring)))
1833 (setq this-command 'viper-insert-from-insertion-ring)
1834 ;; so that things will be undone properly
1835 (setq buffer-undo-list (cons nil buffer-undo-list))
1836 (setq viper-last-inserted-string-from-insertion-ring
1837 (viper-special-ring-rotate1 viper-temp-insertion-ring (if arg 1 -1)))
1839 ;; this change of viper-intermediate-command must come after
1840 ;; viper-special-ring-rotate1, so that the ring will rotate, but before the
1842 (setq viper-intermediate-command nil)
1843 (if viper-last-inserted-string-from-insertion-ring
1844 (insert viper-last-inserted-string-from-insertion-ring))
1847 (defun viper-insert-next-from-insertion-ring ()
1848 "Cycle through insertion ring in the direction of older insertions.
1849 Undo previous insertion and inserts new."
1851 (viper-insert-prev-from-insertion-ring 'next))
1855 ;; some region utilities
1857 ;; If at the last line of buffer, add \\n before eob, if newline is missing.
1858 (defun viper-add-newline-at-eob-if-necessary ()
1861 ;; make sure all lines end with newline, unless in the minibuffer or
1862 ;; when requested otherwise (require-final-newline is nil)
1867 require-final-newline
1868 ;; add newline only if we actually edited buffer. otherwise it
1869 ;; might unintentionally modify binary buffers
1871 (not (viper-is-in-minibuffer))
1872 (not buffer-read-only))
1873 ;; text property may be read-only
1880 (defun viper-yank-defun ()
1882 (copy-region-as-kill (point) (mark t)))
1884 ;; Enlarge region between BEG and END.
1885 (defun viper-enlarge-region (beg end)
1886 (or beg (setq beg end)) ; if beg is nil, set to end
1887 (or end (setq end beg)) ; if end is nil, set to beg
1890 (progn (goto-char beg) (set-mark end))
1894 (exchange-point-and-mark)
1895 (if (or (not (eobp)) (not (bolp))) (forward-line 1))
1896 (if (not (eobp)) (beginning-of-line))
1897 (if (> beg end) (exchange-point-and-mark)))
1900 ;; Quote region by each line with a user supplied string.
1901 (defun viper-quote-region ()
1902 (let ((quote-str viper-quote-string)
1903 (do-not-change-default t))
1905 (viper-read-string-with-history
1908 'viper-quote-region-history
1909 ;; FIXME: Use comment-region.
1910 (cond ((string-match "tex.*-mode" (symbol-name major-mode)) "%%")
1911 ((string-match "java.*-mode" (symbol-name major-mode)) "//")
1912 ((string-match "perl.*-mode" (symbol-name major-mode)) "#")
1913 ((string-match "lisp.*-mode" (symbol-name major-mode)) ";;")
1914 ((memq major-mode '(c-mode cc-mode c++-mode)) "//")
1915 ((memq major-mode '(sh-mode shell-mode)) "#")
1916 (t (setq do-not-change-default nil)
1918 (or do-not-change-default
1919 (setq viper-quote-string quote-str))
1920 (viper-enlarge-region (point) (mark t))
1921 (if (> (point) (mark t)) (exchange-point-and-mark))
1925 (while (and (< (point) (mark t)) (bolp))
1930 ;; Tells whether BEG is on the same line as END.
1931 ;; If one of the args is nil, it'll return nil.
1932 (defun viper-same-line (beg end)
1933 (let ((selective-display nil)
1936 (if (and beg end (> beg end))
1941 (cond ((or (> beg (point-max)) (> end (point-max))) ; out of range
1944 ;; This 'if' is needed because Emacs treats the next empty line
1945 ;; as part of the previous line.
1946 (if (= (viper-line-pos 'start) end)
1948 (<= (+ incr (count-lines beg end)) 1))))
1952 ;; Check if the string ends with a newline.
1953 (defun viper-end-with-a-newline-p (string)
1954 (or (string= string "")
1955 (= (viper-seq-last-elt string) ?\n)))
1957 (defun viper-tmp-insert-at-eob (msg)
1958 (let ((savemax (point-max)))
1962 (goto-char savemax) (delete-region (point) (point-max))
1967 ;;; Minibuffer business
1969 (defsubst viper-set-minibuffer-style ()
1970 (add-hook 'minibuffer-setup-hook 'viper-minibuffer-setup-sentinel)
1971 (add-hook 'post-command-hook 'viper-minibuffer-post-command-hook))
1974 (defun viper-minibuffer-setup-sentinel ()
1975 (let ((hook (if viper-vi-style-in-minibuffer
1976 'viper-change-state-to-insert
1977 'viper-change-state-to-emacs)))
1978 ;; making buffer-local variables so that normal buffers won't affect the
1979 ;; minibuffer and vice versa. Otherwise, command arguments will affect
1980 ;; minibuffer ops and insertions from the minibuffer will change those in
1981 ;; the normal buffers
1982 (make-local-variable 'viper-d-com)
1983 (make-local-variable 'viper-last-insertion)
1984 (make-local-variable 'viper-command-ring)
1985 (setq viper-d-com nil
1986 viper-last-insertion nil
1987 viper-command-ring nil)
1991 ;; This is a temp hook that uses free variables viper--init-message and viper-initial.
1992 ;; A dirty feature, but it is the simplest way to have it do the right thing.
1993 ;; The VIPER--INIT-MESSAGE and VIPER-INITIAL vars come from the scope set by
1994 ;; viper-read-string-with-history
1995 (defun viper-minibuffer-standard-hook ()
1996 (if (stringp viper--init-message)
1997 (viper-tmp-insert-at-eob viper--init-message))
1998 (when (stringp viper-initial)
1999 ;; don't wait if we have unread events or in kbd macro
2000 (or unread-command-events
2003 (if (fboundp 'minibuffer-prompt-end)
2004 (delete-region (minibuffer-prompt-end) (point-max))
2006 (insert viper-initial)))
2008 (defsubst viper-minibuffer-real-start ()
2009 (if (fboundp 'minibuffer-prompt-end)
2010 (minibuffer-prompt-end)
2013 (defun viper-minibuffer-post-command-hook()
2014 (when (active-minibuffer-window)
2015 (when (< (point) (viper-minibuffer-real-start))
2016 (goto-char (viper-minibuffer-real-start)))))
2019 ;; Interpret last event in the local map first; if fails, use exit-minibuffer.
2020 ;; Run viper-minibuffer-exit-hook before exiting.
2021 (defun viper-exit-minibuffer ()
2022 "Exit minibuffer Viper way."
2025 (setq command (local-key-binding (char-to-string (viper-last-command-char))))
2026 (run-hooks 'viper-minibuffer-exit-hook)
2028 (command-execute command)
2029 (exit-minibuffer))))
2032 (defcustom viper-smart-suffix-list
2033 '("" "tex" "c" "cc" "C" "java" "el" "html" "htm" "xml"
2034 "pl" "flr" "P" "p" "h" "H")
2035 "List of suffixes that Viper tries to append to filenames ending with a `.'.
2036 This is useful when the current directory contains files with the same
2037 prefix and many different suffixes. Usually, only one of the suffixes
2038 represents an editable file. However, file completion will stop at the `.'
2039 The smart suffix feature lets you hit RET in such a case, and Viper will
2040 select the appropriate suffix.
2042 Suffixes are tried in the order given and the first suffix for which a
2043 corresponding file exists is selected. If no file exists for any of the
2044 suffixes, the user is asked to confirm.
2046 To turn this feature off, set this variable to nil."
2047 :type '(repeat string)
2051 ;; Try to add a suitable suffix to files whose name ends with a `.'
2052 ;; Useful when the user hits RET on a non-completed file name.
2053 ;; Used as a minibuffer exit hook in read-file-name
2054 (defun viper-file-add-suffix ()
2056 (len (length viper-smart-suffix-list))
2057 (file (buffer-substring-no-properties
2058 (viper-minibuffer-real-start) (point-max)))
2060 (goto-char (point-max))
2061 (if (and viper-smart-suffix-list (string-match "\\.\\'" file))
2063 (while (and (not found) (< count len))
2064 (setq suff (nth count viper-smart-suffix-list)
2067 (format "%s%s" (substitute-in-file-name file) suff))
2074 (viper-tmp-insert-at-eob " [Please complete file name]")
2076 (while (not (memq cmd
2077 '(exit-minibuffer viper-exit-minibuffer)))
2079 (key-binding (setq key (read-key-sequence nil))))
2080 (cond ((eq cmd 'self-insert-command)
2081 (if (featurep 'xemacs)
2082 (insert (events-to-keys key)) ; xemacs
2083 (insert key) ; emacs
2085 ((memq cmd '(exit-minibuffer viper-exit-minibuffer))
2087 (t (command-execute cmd)))
2092 (defun viper-minibuffer-trim-tail ()
2093 "Delete junk at the end of the first line of the minibuffer input.
2094 Remove this function from `viper-minibuffer-exit-hook', if this causes
2096 (if (viper-is-in-minibuffer)
2097 (let ((inhibit-field-text-motion t))
2098 (goto-char (viper-minibuffer-real-start))
2100 (delete-region (point) (point-max)))))
2103 ;;; Reading string with history
2105 (defun viper-read-string-with-history (prompt &optional initial
2106 history-var default keymap
2108 ;; Read string, prompting with PROMPT and inserting the INITIAL
2109 ;; value. Uses HISTORY-VAR. DEFAULT is the default value to accept if the
2110 ;; input is an empty string.
2111 ;; Default value is displayed until the user types something in the
2113 ;; KEYMAP is used, if given, instead of minibuffer-local-map.
2114 ;; INIT-MESSAGE is the message temporarily displayed after entering the
2116 (let ((viper-initial initial)
2117 (viper--init-message init-message)
2118 (minibuffer-setup-hook
2119 ;; stolen from add-hook
2121 (if (boundp 'minibuffer-setup-hook)
2122 minibuffer-setup-hook
2125 #'viper-minibuffer-standard-hook
2126 (if (or (not (listp old)) (eq (car old) 'lambda))
2132 (setq keymap (or keymap minibuffer-local-map)
2133 initial (or initial "")
2134 viper-initial initial
2135 temp-msg (if default
2136 (format "(default %s) " default)
2139 (setq viper-incomplete-ex-cmd nil)
2140 (setq val (read-from-minibuffer prompt
2141 (concat temp-msg initial val padding)
2142 keymap nil history-var))
2143 (setq minibuffer-setup-hook nil
2144 padding (viper-array-to-string (this-command-keys))
2146 ;; the following tries to be smart about what to put in history
2147 (if (not (string= val (car (eval history-var))))
2148 (set history-var (cons val (eval history-var))))
2149 (if (or (string= (nth 0 (eval history-var)) (nth 1 (eval history-var)))
2150 (string= (nth 0 (eval history-var)) ""))
2151 (set history-var (cdr (eval history-var))))
2152 ;; If the user enters nothing but the prev cmd wasn't viper-ex,
2153 ;; viper-command-argument, or `! shell-command', this probably means
2154 ;; that the user typed something then erased. Return "" in this case, not
2155 ;; the default---the default is too confusing in this case.
2156 (cond ((and (string= val "")
2157 (not (string= prompt "!")) ; was a `! shell-command'
2158 (not (memq last-command
2160 viper-command-argument
2164 ((string= val "") (or default ""))
2170 ;; insertion commands
2172 ;; Called when state changes from Insert Vi command mode.
2173 ;; Repeats the insertion command if Insert state was entered with prefix
2175 (defun viper-repeat-insert-command ()
2176 (let ((i-com (car viper-d-com))
2177 (val (nth 1 viper-d-com))
2178 (char (nth 2 viper-d-com)))
2179 (if (and val (> val 1)) ; first check that val is non-nil
2181 (setq viper-d-com (list i-com (1- val) ?r nil nil nil))
2183 (setq viper-d-com (list i-com val char nil nil nil))
2186 (defun viper-insert (arg)
2187 "Insert before point."
2189 (viper-set-complex-command-for-undo)
2190 (let ((val (viper-p-val arg))
2191 ;;(com (viper-getcom arg))
2193 (viper-set-destructive-command (list 'viper-insert val ?r nil nil nil))
2194 (if (eq viper-intermediate-command 'viper-repeat)
2195 (viper-loop val (viper-yank-last-insertion))
2196 (viper-change-state-to-insert))))
2198 (defun viper-append (arg)
2199 "Append after point."
2201 (viper-set-complex-command-for-undo)
2202 (let ((val (viper-p-val arg))
2203 ;;(com (viper-getcom arg))
2205 (viper-set-destructive-command (list 'viper-append val ?r nil nil nil))
2206 (if (not (eolp)) (forward-char))
2207 (if (eq viper-intermediate-command 'viper-repeat)
2208 (viper-loop val (viper-yank-last-insertion))
2209 (viper-change-state-to-insert))))
2211 (defun viper-Append (arg)
2212 "Append at end of line."
2214 (viper-set-complex-command-for-undo)
2215 (let ((val (viper-p-val arg))
2216 ;;(com (viper-getcom arg))
2218 (viper-set-destructive-command (list 'viper-Append val ?r nil nil nil))
2220 (if (eq viper-intermediate-command 'viper-repeat)
2221 (viper-loop val (viper-yank-last-insertion))
2222 (viper-change-state-to-insert))))
2224 (defun viper-Insert (arg)
2225 "Insert before first non-white."
2227 (viper-set-complex-command-for-undo)
2228 (let ((val (viper-p-val arg))
2229 ;;(com (viper-getcom arg))
2231 (viper-set-destructive-command (list 'viper-Insert val ?r nil nil nil))
2232 (back-to-indentation)
2233 (if (eq viper-intermediate-command 'viper-repeat)
2234 (viper-loop val (viper-yank-last-insertion))
2235 (viper-change-state-to-insert))))
2237 (defun viper-open-line (arg)
2240 (viper-set-complex-command-for-undo)
2241 (let ((val (viper-p-val arg))
2242 ;;(com (viper-getcom arg))
2244 (viper-set-destructive-command (list 'viper-open-line val ?r nil nil nil))
2245 (let ((col (current-indentation)))
2246 (if (eq viper-intermediate-command 'viper-repeat)
2250 (viper-indent-line col)
2251 (viper-yank-last-insertion))
2254 (viper-indent-line col)
2255 (viper-change-state-to-insert)))))
2257 (defun viper-Open-line (arg)
2260 (viper-set-complex-command-for-undo)
2261 (let ((val (viper-p-val arg))
2262 ;;(com (viper-getcom arg))
2264 (viper-set-destructive-command (list 'viper-Open-line val ?r nil nil nil))
2265 (let ((col (current-indentation)))
2266 (if (eq viper-intermediate-command 'viper-repeat)
2270 (viper-indent-line col)
2271 (viper-yank-last-insertion))
2274 (viper-indent-line col)
2275 (viper-change-state-to-insert)))))
2277 (defun viper-open-line-at-point (arg)
2278 "Open line at point."
2280 (viper-set-complex-command-for-undo)
2281 (let ((val (viper-p-val arg))
2282 ;;(com (viper-getcom arg))
2284 (viper-set-destructive-command
2285 (list 'viper-open-line-at-point val ?r nil nil nil))
2286 (if (eq viper-intermediate-command 'viper-repeat)
2289 (viper-yank-last-insertion))
2291 (viper-change-state-to-insert))))
2294 (defun viper-substitute (arg)
2295 "Substitute characters."
2297 (let ((val (viper-p-val arg))
2298 ;;(com (viper-getcom arg))
2302 (if (eq viper-intermediate-command 'viper-repeat)
2303 (viper-change-subr (mark t) (point))
2304 (viper-change (mark t) (point)))
2305 ;; com is set to ?r when we repeat this command with dot
2306 (viper-set-destructive-command (list 'viper-substitute val ?r nil nil nil))
2309 ;; Command bound to S
2310 (defun viper-substitute-line (arg)
2313 (viper-set-complex-command-for-undo)
2314 (viper-line (cons arg ?C)))
2316 ;; Prepare for replace
2317 (defun viper-start-replace ()
2318 (setq viper-began-as-replace t
2319 viper-sitting-in-replace t
2320 viper-replace-chars-to-delete 0)
2322 'viper-after-change-functions 'viper-replace-mode-spy-after t 'local)
2324 'viper-before-change-functions 'viper-replace-mode-spy-before t 'local)
2325 ;; this will get added repeatedly, but no harm
2326 (add-hook 'after-change-functions 'viper-after-change-sentinel t)
2327 (add-hook 'before-change-functions 'viper-before-change-sentinel t)
2328 (viper-move-marker-locally
2329 'viper-last-posn-in-replace-region (viper-replace-start))
2331 'viper-post-command-hooks 'viper-replace-state-post-command-sentinel
2334 'viper-pre-command-hooks 'viper-replace-state-pre-command-sentinel t 'local)
2335 ;; guard against a smarty who switched from R-replace to normal replace
2337 'viper-post-command-hooks 'viper-R-state-post-command-sentinel 'local)
2338 (if overwrite-mode (overwrite-mode -1))
2342 (defun viper-replace-mode-spy-before (beg end)
2343 (setq viper-replace-region-chars-deleted (viper-chars-in-region beg end))
2346 ;; Invoked as an after-change-function to calculate how many chars have to be
2347 ;; deleted. This function may be called several times within a single command,
2348 ;; if this command performs several separate buffer changes. Therefore, if
2349 ;; adds up the number of chars inserted and subtracts the number of chars
2351 (defun viper-replace-mode-spy-after (beg end length)
2352 (if (memq viper-intermediate-command
2353 '(dabbrev-expand hippie-expand repeating-insertion-from-ring))
2354 ;; Take special care of text insertion from insertion ring inside
2355 ;; replacement overlays.
2357 (setq viper-replace-chars-to-delete 0)
2358 (viper-move-marker-locally
2359 'viper-last-posn-in-replace-region (point)))
2361 (let* ((real-end (min end (viper-replace-end)))
2362 (column-shift (- (save-excursion (goto-char real-end)
2364 (save-excursion (goto-char beg)
2369 (setq chars-deleted viper-replace-region-chars-deleted))
2370 (setq viper-replace-region-chars-deleted 0)
2371 (setq viper-replace-chars-to-delete
2372 (+ viper-replace-chars-to-delete
2374 ;; if column shift is bigger, due to a TAB insertion, take
2375 ;; column-shift instead of the number of inserted chars
2376 (max (viper-chars-in-region beg real-end)
2377 ;; This test accounts for Chinese/Japanese/... chars,
2378 ;; which occupy 2 columns instead of one. If we use
2379 ;; column-shift here, we may delete two chars instead of
2380 ;; one when the user types one Chinese character.
2381 ;; Deleting two would be OK, if they were European chars,
2382 ;; but it is not OK if they are Chinese chars.
2383 ;; Since it is hard to
2384 ;; figure out which characters are being deleted in any
2385 ;; given region, we decided to treat Eastern and European
2386 ;; characters equally, even though Eastern chars may
2387 ;; occupy more columns.
2388 (if (memq this-command '(self-insert-command
2389 quoted-insert viper-insert-tab))
2392 ;; the number of deleted chars
2395 (viper-move-marker-locally
2396 'viper-last-posn-in-replace-region
2397 (max (if (> end (viper-replace-end)) (viper-replace-end) end)
2398 (or (marker-position viper-last-posn-in-replace-region)
2399 (viper-replace-start))
2405 ;; Delete stuff between viper-last-posn-in-replace-region and the end of
2406 ;; viper-replace-overlay-marker, if viper-last-posn-in-replace-region is within
2407 ;; the overlay and current point is before the end of the overlay.
2408 ;; Don't delete anything if current point is past the end of the overlay.
2409 (defun viper-finish-change ()
2411 'viper-after-change-functions 'viper-replace-mode-spy-after 'local)
2413 'viper-before-change-functions 'viper-replace-mode-spy-before 'local)
2415 'viper-post-command-hooks 'viper-replace-state-post-command-sentinel 'local)
2417 'viper-pre-command-hooks 'viper-replace-state-pre-command-sentinel 'local)
2418 (viper-restore-cursor-color 'after-replace-mode)
2419 (setq viper-sitting-in-replace nil) ; just in case we'll need to know it
2421 (if (and viper-replace-overlay
2422 (viper-pos-within-region viper-last-posn-in-replace-region
2423 (viper-replace-start)
2424 (viper-replace-end))
2425 (< (point) (viper-replace-end)))
2427 viper-last-posn-in-replace-region (viper-replace-end))))
2429 (if (eq viper-current-state 'replace-state)
2430 (viper-downgrade-to-insert))
2431 ;; replace mode ended => nullify viper-last-posn-in-replace-region
2432 (viper-move-marker-locally 'viper-last-posn-in-replace-region nil)
2433 (viper-hide-replace-overlay)
2434 (viper-refresh-mode-line)
2435 (viper-put-string-on-kill-ring viper-last-replace-region)
2438 ;; Make STRING be the first element of the kill ring.
2439 (defun viper-put-string-on-kill-ring (string)
2440 (setq kill-ring (cons string kill-ring))
2441 (if (> (length kill-ring) kill-ring-max)
2442 (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil))
2443 (setq kill-ring-yank-pointer kill-ring))
2445 (defun viper-finish-R-mode ()
2447 'viper-post-command-hooks 'viper-R-state-post-command-sentinel 'local)
2449 'viper-pre-command-hooks 'viper-replace-state-pre-command-sentinel 'local)
2450 (viper-downgrade-to-insert))
2452 (defun viper-start-R-mode ()
2453 ;; Leave arg as 1, not t: XEmacs insists that it must be a pos number
2456 'viper-post-command-hooks 'viper-R-state-post-command-sentinel t 'local)
2458 'viper-pre-command-hooks 'viper-replace-state-pre-command-sentinel t 'local)
2459 ;; guard against a smarty who switched from R-replace to normal replace
2461 'viper-post-command-hooks 'viper-replace-state-post-command-sentinel 'local)
2466 (defun viper-replace-state-exit-cmd ()
2467 "Binding for keys that cause Replace state to switch to Vi or to Insert.
2468 These keys are ESC, RET, and LineFeed."
2470 (if overwrite-mode ; if in replace mode invoked via 'R'
2471 (viper-finish-R-mode)
2472 (viper-finish-change))
2474 (if (eq this-command 'viper-intercept-ESC-key)
2475 (setq com 'viper-exit-insert-state)
2476 (viper-set-unread-command-events last-input-event)
2477 (setq com (key-binding (viper-read-key-sequence nil))))
2479 (condition-case conds
2480 (command-execute com)
2482 (viper-message-conditions conds)))
2484 (viper-hide-replace-overlay))
2487 (defun viper-replace-state-carriage-return ()
2488 "Carriage return in Viper replace state."
2490 ;; If Emacs start supporting overlay maps, as it currently supports
2491 ;; text-property maps, we could do away with viper-replace-minor-mode and
2492 ;; just have keymap attached to replace overlay. Then the "if part" of this
2493 ;; statement can be deleted.
2494 (if (or (< (point) (viper-replace-start))
2495 (> (point) (viper-replace-end)))
2496 (let (viper-replace-minor-mode com)
2497 (viper-set-unread-command-events last-input-event)
2498 (setq com (key-binding (read-key-sequence nil)))
2499 (condition-case conds
2500 (command-execute com)
2502 (viper-message-conditions conds))))
2503 (if (not viper-allow-multiline-replace-regions)
2504 (viper-replace-state-exit-cmd)
2505 (if (viper-same-line (point) (viper-replace-end))
2506 (viper-replace-state-exit-cmd)
2507 ;; delete the rest of line
2508 (delete-region (point) (viper-line-pos 'end))
2511 (if (eobp) (error "Last line in buffer")))
2512 ;; skip to the next line
2514 (back-to-indentation)
2518 ;; This is the function bound to 'R'---unlimited replace.
2519 ;; Similar to Emacs's own overwrite-mode.
2520 (defun viper-overwrite (arg)
2521 "Begin overwrite mode."
2523 (let ((val (viper-p-val arg))
2524 ;;(com (viper-getcom arg))
2526 (viper-set-destructive-command (list 'viper-overwrite val ?r nil nil nil))
2527 (if (eq viper-intermediate-command 'viper-repeat)
2529 ;; Viper saves inserted text in viper-last-insertion
2530 (setq len (length viper-last-insertion))
2531 (delete-char (min len (- (point-max) (point) 1)))
2532 (viper-loop val (viper-yank-last-insertion)))
2533 (setq last-command 'viper-overwrite)
2534 (viper-set-complex-command-for-undo)
2535 (viper-set-replace-overlay (point) (viper-line-pos 'end))
2536 (viper-change-state-to-replace)
2542 (defun viper-line (arg)
2543 (let ((val (car arg))
2545 (viper-move-marker-locally 'viper-com-point (point))
2547 (viper-next-line-carefully (1- val)))
2548 ;; the following ensures that dd, cc, D, yy will do the right thing on the
2549 ;; last line of buffer when this line has no \n.
2550 (viper-add-newline-at-eob-if-necessary)
2551 (viper-execute-com 'viper-line val com))
2552 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
2555 (defun viper-yank-line (arg)
2556 "Yank ARG lines (in Vi's sense)."
2558 (let ((val (viper-p-val arg)))
2559 (viper-line (cons val ?Y))))
2564 (defun viper-region (arg)
2565 "Execute command on a region."
2567 (let ((val (viper-P-val arg))
2568 (com (viper-getcom arg)))
2569 (viper-move-marker-locally 'viper-com-point (point))
2570 (exchange-point-and-mark)
2571 (viper-execute-com 'viper-region val com)))
2573 (defun viper-Region (arg)
2574 "Execute command on a Region."
2576 (let ((val (viper-P-val arg))
2577 (com (viper-getCom arg)))
2578 (viper-move-marker-locally 'viper-com-point (point))
2579 (exchange-point-and-mark)
2580 (viper-execute-com 'viper-Region val com)))
2582 (defun viper-replace-char (arg)
2583 "Replace the following ARG chars by the character read."
2585 (if (and (eolp) (bolp)) (error "No character to replace here"))
2586 (let ((val (viper-p-val arg))
2587 (com (viper-getcom arg)))
2588 (viper-replace-char-subr com val)
2589 (if (and (eolp) (not (bolp))) (forward-char 1))
2590 (setq viper-this-command-keys
2591 (format "%sr" (if (integerp arg) arg "")))
2592 (viper-set-destructive-command
2593 (list 'viper-replace-char val ?r nil viper-d-char nil))
2596 (defun viper-replace-char-subr (com arg)
2597 (let ((inhibit-quit t)
2599 (viper-set-complex-command-for-undo)
2600 (or (eq viper-intermediate-command 'viper-repeat)
2601 (viper-special-read-and-insert-char))
2604 (setq char (if com viper-d-char (viper-char-at-pos 'backward)))
2606 (if com (insert char))
2608 (setq viper-d-char char)
2610 (viper-loop (1- (if (> arg 0) arg (- arg)))
2619 ;; basic cursor movement. j, k, l, h commands.
2621 (defun viper-forward-char (arg)
2622 "Move point right ARG characters (left if ARG negative).
2623 On reaching end of line, stop and signal error."
2625 (viper-leave-region-active)
2626 (let ((val (viper-p-val arg))
2627 (com (viper-getcom arg)))
2628 (if com (viper-move-marker-locally 'viper-com-point (point)))
2629 (if viper-ex-style-motion
2631 ;; the boundary condition check gets weird here because
2632 ;; forward-char may be the parameter of a delete, and 'dl' works
2633 ;; just like 'x' for the last char on a line, so we have to allow
2634 ;; the forward motion before the 'viper-execute-com', but, of
2635 ;; course, 'dl' doesn't work on an empty line, so we have to
2636 ;; catch that condition before 'viper-execute-com'
2637 (if (and (eolp) (bolp)) (error "Viper bell") (forward-char val))
2638 (if com (viper-execute-com 'viper-forward-char val com))
2639 (if (eolp) (progn (backward-char 1) (error "Viper bell"))))
2641 (if com (viper-execute-com 'viper-forward-char val com)))))
2644 (defun viper-backward-char (arg)
2645 "Move point left ARG characters (right if ARG negative).
2646 On reaching beginning of line, stop and signal error."
2648 (viper-leave-region-active)
2649 (let ((val (viper-p-val arg))
2650 (com (viper-getcom arg)))
2651 (if com (viper-move-marker-locally 'viper-com-point (point)))
2652 (if viper-ex-style-motion
2654 (if (bolp) (error "Viper bell") (backward-char val))
2655 (if com (viper-execute-com 'viper-backward-char val com)))
2657 (if com (viper-execute-com 'viper-backward-char val com)))))
2660 ;; Like forward-char, but doesn't move at end of buffer.
2661 ;; Returns distance traveled
2662 ;; (positive or 0, if arg positive; negative if arg negative).
2663 (defun viper-forward-char-carefully (&optional arg)
2664 (setq arg (or arg 1))
2669 (if (< (point) pt) ; arg was negative
2670 (- (viper-chars-in-region pt (point)))
2671 (viper-chars-in-region pt (point)))))
2674 ;; Like backward-char, but doesn't move at beg of buffer.
2675 ;; Returns distance traveled
2676 ;; (negative or 0, if arg positive; positive if arg negative).
2677 (defun viper-backward-char-carefully (&optional arg)
2678 (setq arg (or arg 1))
2683 (if (> (point) pt) ; arg was negative
2684 (viper-chars-in-region pt (point))
2685 (- (viper-chars-in-region pt (point))))))
2687 (defun viper-next-line-carefully (arg)
2689 ;; do not use forward-line! need to keep column
2690 (let ((line-move-visual nil))
2691 (if (featurep 'emacs)
2692 (with-no-warnings (next-line arg))
2700 ;; Words are formed from alpha's and nonalphas - <sp>,\t\n are separators for
2701 ;; word movement. When executed with a destructive command, \n is usually left
2702 ;; untouched for the last word. Viper uses syntax table to determine what is a
2703 ;; word and what is a separator. However, \n is always a separator. Also, if
2704 ;; viper-syntax-preference is 'vi, then `_' is part of the word.
2707 (defun viper-skip-separators (forward)
2710 (viper-skip-all-separators-forward 'within-line)
2711 (if (looking-at "\n")
2714 (viper-skip-all-separators-forward 'within-line))))
2715 ;; check for eob and white space before it. move off of eob
2716 (if (and (eobp) (save-excursion
2717 (viper-backward-char-carefully)
2718 (viper-looking-at-separator)))
2719 (viper-backward-char-carefully))
2720 (viper-skip-all-separators-backward 'within-line)
2721 (viper-backward-char-carefully)
2722 (if (looking-at "\n")
2723 (viper-skip-all-separators-backward 'within-line)
2724 (or (viper-looking-at-separator) (forward-char)))))
2727 (defun viper-forward-word-kernel (val)
2729 (cond ((viper-looking-at-alpha)
2730 (viper-skip-alpha-forward "_")
2731 (viper-skip-separators t))
2732 ((viper-looking-at-separator)
2733 (viper-skip-separators t))
2734 ((not (viper-looking-at-alphasep))
2735 (viper-skip-nonalphasep-forward)
2736 (viper-skip-separators t)))
2737 (setq val (1- val))))
2739 ;; first skip non-newline separators backward, then skip \n. Then, if TWICE is
2740 ;; non-nil, skip non-\n back again, but don't overshoot the limit LIM.
2741 (defun viper-separator-skipback-special (twice lim)
2742 (let ((prev-char (viper-char-at-pos 'backward))
2743 (saved-point (point)))
2744 ;; skip non-newline separators backward
2745 (while (and (not (viper-memq-char prev-char '(nil \n)))
2747 ;; must be non-newline separator
2748 (if (eq viper-syntax-preference 'strict-vi)
2749 (viper-memq-char prev-char '(?\ ?\t))
2750 (viper-memq-char (char-syntax prev-char) '(?\ ?-))))
2751 (viper-backward-char-carefully)
2752 (setq prev-char (viper-char-at-pos 'backward)))
2754 (if (and (< lim (point)) (eq prev-char ?\n))
2756 ;; If we skipped to the next word and the prefix of this line doesn't
2757 ;; consist of separators preceded by a newline, then don't skip backwards
2759 (goto-char saved-point))
2760 (setq prev-char (viper-char-at-pos 'backward))
2762 ;; skip again, but make sure we don't overshoot the limit
2764 (while (and (not (viper-memq-char prev-char '(nil \n)))
2766 ;; must be non-newline separator
2767 (if (eq viper-syntax-preference 'strict-vi)
2768 (viper-memq-char prev-char '(?\ ?\t))
2769 (viper-memq-char (char-syntax prev-char) '(?\ ?-))))
2770 (viper-backward-char-carefully)
2771 (setq prev-char (viper-char-at-pos 'backward))))
2774 (viper-forward-char-carefully))
2778 (defun viper-forward-word (arg)
2781 (viper-leave-region-active)
2782 (let ((val (viper-p-val arg))
2783 (com (viper-getcom arg)))
2784 (if com (viper-move-marker-locally 'viper-com-point (point)))
2785 (viper-forward-word-kernel val)
2788 (cond ((viper-char-equal com ?c)
2789 (viper-separator-skipback-special 'twice viper-com-point))
2790 ;; Yank words including the whitespace, but not newline
2791 ((viper-char-equal com ?y)
2792 (viper-separator-skipback-special nil viper-com-point))
2793 ((viper-dotable-command-p com)
2794 (viper-separator-skipback-special nil viper-com-point)))
2795 (viper-execute-com 'viper-forward-word val com)))
2799 (defun viper-forward-Word (arg)
2800 "Forward word delimited by white characters."
2802 (viper-leave-region-active)
2803 (let ((val (viper-p-val arg))
2804 (com (viper-getcom arg)))
2805 (if com (viper-move-marker-locally 'viper-com-point (point)))
2807 (viper-skip-nonseparators 'forward)
2808 (viper-skip-separators t))
2810 (cond ((viper-char-equal com ?c)
2811 (viper-separator-skipback-special 'twice viper-com-point))
2812 ;; Yank words including the whitespace, but not newline
2813 ((viper-char-equal com ?y)
2814 (viper-separator-skipback-special nil viper-com-point))
2815 ((viper-dotable-command-p com)
2816 (viper-separator-skipback-special nil viper-com-point)))
2817 (viper-execute-com 'viper-forward-Word val com)))))
2820 ;; this is a bit different from Vi, but Vi's end of word
2821 ;; makes no sense whatsoever
2822 (defun viper-end-of-word-kernel ()
2823 (if (viper-end-of-word-p) (forward-char))
2824 (if (viper-looking-at-separator)
2825 (viper-skip-all-separators-forward))
2827 (cond ((viper-looking-at-alpha) (viper-skip-alpha-forward "_"))
2828 ((not (viper-looking-at-alphasep)) (viper-skip-nonalphasep-forward)))
2829 (viper-backward-char-carefully))
2831 (defun viper-end-of-word-p ()
2834 (cond ((viper-looking-at-alpha)
2836 (not (viper-looking-at-alpha)))
2837 ((not (viper-looking-at-alphasep))
2839 (viper-looking-at-alphasep))))))
2842 (defun viper-end-of-word (arg &optional _careful)
2843 "Move point to end of current word."
2845 (viper-leave-region-active)
2846 (let ((val (viper-p-val arg))
2847 (com (viper-getcom arg)))
2848 (if com (viper-move-marker-locally 'viper-com-point (point)))
2849 (viper-loop val (viper-end-of-word-kernel))
2853 (viper-execute-com 'viper-end-of-word val com)))))
2855 (defun viper-end-of-Word (arg)
2856 "Forward to end of word delimited by white character."
2858 (viper-leave-region-active)
2859 (let ((val (viper-p-val arg))
2860 (com (viper-getcom arg)))
2861 (if com (viper-move-marker-locally 'viper-com-point (point)))
2863 (viper-end-of-word-kernel)
2864 (viper-skip-nonseparators 'forward)
2869 (viper-execute-com 'viper-end-of-Word val com)))))
2871 (defun viper-backward-word-kernel (val)
2873 (viper-backward-char-carefully)
2874 (cond ((viper-looking-at-alpha)
2875 (viper-skip-alpha-backward "_"))
2876 ((viper-looking-at-separator)
2878 (viper-skip-separators nil)
2879 (viper-backward-char-carefully)
2880 (cond ((viper-looking-at-alpha)
2881 (viper-skip-alpha-backward "_"))
2882 ((not (viper-looking-at-alphasep))
2883 (viper-skip-nonalphasep-backward))
2884 ((bobp)) ; could still be at separator, but at beg of buffer
2885 (t (forward-char))))
2886 ((not (viper-looking-at-alphasep))
2887 (viper-skip-nonalphasep-backward)))
2888 (setq val (1- val))))
2890 (defun viper-backward-word (arg)
2893 (viper-leave-region-active)
2894 (let ((val (viper-p-val arg))
2895 (com (viper-getcom arg)))
2898 (if (setq i (save-excursion (backward-char) (looking-at "\n")))
2900 (viper-move-marker-locally 'viper-com-point (point))
2901 (if i (forward-char))))
2902 (viper-backward-word-kernel val)
2903 (if com (viper-execute-com 'viper-backward-word val com))))
2905 (defun viper-backward-Word (arg)
2906 "Backward word delimited by white character."
2908 (viper-leave-region-active)
2909 (let ((val (viper-p-val arg))
2910 (com (viper-getcom arg)))
2913 (if (setq i (save-excursion (backward-char) (looking-at "\n")))
2915 (viper-move-marker-locally 'viper-com-point (point))
2916 (if i (forward-char))))
2918 (viper-skip-separators nil) ; nil means backward here
2919 (viper-skip-nonseparators 'backward))
2920 (if com (viper-execute-com 'viper-backward-Word val com))))
2926 (defun viper-beginning-of-line (arg)
2927 "Go to beginning of line."
2929 (viper-leave-region-active)
2930 (let ((val (viper-p-val arg))
2931 (com (viper-getcom arg)))
2932 (if com (viper-move-marker-locally 'viper-com-point (point)))
2933 (beginning-of-line val)
2934 (if com (viper-execute-com 'viper-beginning-of-line val com))))
2936 (defun viper-bol-and-skip-white (arg)
2937 "Beginning of line at first non-white character."
2939 (viper-leave-region-active)
2940 (let ((val (viper-p-val arg))
2941 (com (viper-getcom arg)))
2942 (if com (viper-move-marker-locally 'viper-com-point (point)))
2943 (forward-to-indentation (1- val))
2944 (if com (viper-execute-com 'viper-bol-and-skip-white val com))))
2946 (defun viper-goto-eol (arg)
2947 "Go to end of line."
2949 (viper-leave-region-active)
2950 (let ((val (viper-p-val arg))
2951 (com (viper-getcom arg)))
2952 (if com (viper-move-marker-locally 'viper-com-point (point)))
2954 (if com (viper-execute-com 'viper-goto-eol val com))
2955 (if viper-ex-style-motion
2956 (if (and (eolp) (not (bolp))
2957 ;; a fix for viper-change-to-eol
2958 (not (equal viper-current-state 'insert-state)))
2963 (defun viper-goto-col (arg)
2964 "Go to ARG's column."
2966 (viper-leave-region-active)
2967 (let ((val (viper-p-val arg))
2968 (com (viper-getcom arg))
2971 (viper-chars-in-region
2972 (viper-line-pos 'start) (viper-line-pos 'end)))
2973 (if com (viper-move-marker-locally 'viper-com-point (point)))
2975 (forward-char (1- (min line-len val)))
2976 (while (> (current-column) (1- val))
2978 (if com (viper-execute-com 'viper-goto-col val com))
2981 (if (> val (current-column)) (error "Viper bell")))
2985 (defun viper-next-line (arg)
2988 (viper-leave-region-active)
2989 (let ((val (viper-p-val arg))
2990 (com (viper-getCom arg)))
2991 (if com (viper-move-marker-locally 'viper-com-point (point)))
2992 ;; do not use forward-line! need to keep column
2993 (let ((line-move-visual nil))
2994 (if (featurep 'emacs)
2995 (with-no-warnings (next-line val))
2997 (if viper-ex-style-motion
2998 (if (and (eolp) (not (bolp))) (backward-char 1)))
2999 (setq this-command 'next-line)
3000 (if com (viper-execute-com 'viper-next-line val com))))
3002 (declare-function widget-type "wid-edit" (widget))
3003 (declare-function widget-button-press "wid-edit" (pos &optional event))
3004 (declare-function viper-set-hooks "viper" ())
3006 (defun viper-next-line-at-bol (arg)
3007 "Next line at beginning of line.
3008 If point is on a widget or a button, simulate clicking on that widget/button."
3010 (let* ((field (get-char-property (point) 'field))
3011 (button (get-char-property (point) 'button))
3012 (doc (get-char-property (point) 'widget-doc))
3013 (widget (or field button doc)))
3015 (if (symbolp widget)
3016 (get widget 'widget-type)
3018 (get (widget-type widget) 'widget-type))))
3019 (widget-button-press (point))
3020 (if (and (fboundp 'button-at) (fboundp 'push-button) (button-at (point)))
3022 ;; not a widget or a button
3023 (viper-leave-region-active)
3026 (if (eobp) (error "Last line in buffer")))
3027 (let ((val (viper-p-val arg))
3028 (com (viper-getCom arg)))
3029 (if com (viper-move-marker-locally 'viper-com-point (point)))
3031 (back-to-indentation)
3032 (if com (viper-execute-com 'viper-next-line-at-bol val com)))))))
3035 (defun viper-previous-line (arg)
3036 "Go to previous line."
3038 (viper-leave-region-active)
3039 (let ((val (viper-p-val arg))
3040 (com (viper-getCom arg)))
3041 (if com (viper-move-marker-locally 'viper-com-point (point)))
3042 ;; do not use forward-line! need to keep column
3043 (let ((line-move-visual nil))
3044 (if (featurep 'emacs)
3045 (with-no-warnings (previous-line val))
3046 (previous-line val)))
3047 (if viper-ex-style-motion
3048 (if (and (eolp) (not (bolp))) (backward-char 1)))
3049 (setq this-command 'previous-line)
3050 (if com (viper-execute-com 'viper-previous-line val com))))
3053 (defun viper-previous-line-at-bol (arg)
3054 "Previous line at beginning of line."
3056 (viper-leave-region-active)
3059 (if (bobp) (error "First line in buffer")))
3060 (let ((val (viper-p-val arg))
3061 (com (viper-getCom arg)))
3062 (if com (viper-move-marker-locally 'viper-com-point (point)))
3063 (forward-line (- val))
3064 (back-to-indentation)
3065 (if com (viper-execute-com 'viper-previous-line val com))))
3067 (defun viper-change-to-eol (arg)
3068 "Change to end of line."
3070 (viper-goto-eol (cons arg ?c)))
3072 (defun viper-kill-line (arg)
3075 (viper-goto-eol (cons arg ?d)))
3077 (defun viper-erase-line (arg)
3080 (viper-beginning-of-line (cons arg ?d)))
3085 (defun viper-goto-line (arg)
3086 "Go to ARG's line. Without ARG go to end of buffer."
3088 (let ((val (viper-P-val arg))
3089 (com (viper-getCom arg)))
3090 (viper-move-marker-locally 'viper-com-point (point))
3091 (viper-deactivate-mark)
3094 (goto-char (point-max))
3095 (goto-char (point-min))
3096 (forward-line (1- val)))
3098 ;; positioning is done twice: before and after command execution
3099 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3100 (back-to-indentation)
3102 (if com (viper-execute-com 'viper-goto-line val com))
3104 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3105 (back-to-indentation)
3108 ;; Find ARG's occurrence of CHAR on the current line.
3109 ;; If FORWARD then search is forward, otherwise backward. OFFSET is used to
3110 ;; adjust point after search.
3111 (defun viper-find-char (arg char forward offset)
3112 (or (char-or-string-p char) (error "Viper bell"))
3113 (let ((arg (if forward arg (- arg)))
3114 (cmd (if (eq viper-intermediate-command 'viper-repeat)
3116 (viper-array-to-string (this-command-keys))))
3117 point region-beg region-end)
3120 (if (> arg 0) ; forward
3122 (setq region-beg (point))
3123 (if viper-allow-multiline-replace-regions
3124 (viper-forward-paragraph 1)
3126 (setq region-end (point)))
3127 (setq region-end (point))
3128 (if viper-allow-multiline-replace-regions
3129 (viper-backward-paragraph 1)
3130 (beginning-of-line))
3131 (setq region-beg (point)))
3132 (if (or (and (< arg 0)
3133 (< (- region-end region-beg)
3134 (if viper-allow-multiline-replace-regions
3138 (< (- region-end region-beg)
3139 (if viper-allow-multiline-replace-regions
3142 (error "Command `%s': At %s of %s"
3144 (if (> arg 0) "end" "beginning")
3145 (if viper-allow-multiline-replace-regions
3146 "paragraph" "line")))
3147 (narrow-to-region region-beg region-end)
3148 ;; if arg > 0, point is forwarded before search.
3149 (if (> arg 0) (goto-char (1+ (point-min)))
3150 (goto-char (point-max)))
3151 (if (let ((case-fold-search nil))
3152 (search-forward (char-to-string char) nil 0 arg))
3153 (setq point (point))
3154 (error "Command `%s': `%c' not found" cmd char))))
3157 (backward-char (if offset 2 1))
3158 (forward-char (if offset 1 0)))))
3160 (defun viper-find-char-forward (arg)
3161 "Find char on the line.
3162 If called interactively read the char to find from the terminal, and if
3163 called from viper-repeat, the char last used is used. This behavior is
3164 controlled by the sign of prefix numeric value."
3166 (let ((val (viper-p-val arg))
3167 (com (viper-getcom arg))
3168 (cmd-representation (nth 5 viper-d-com)))
3170 ;; this means that the function was called interactively
3171 (setq viper-f-char (read-char)
3174 ;; viper-repeat --- set viper-F-char from command-keys
3175 (setq viper-F-char (if (stringp cmd-representation)
3176 (viper-seq-last-elt cmd-representation)
3178 viper-f-char viper-F-char)
3180 (if com (viper-move-marker-locally 'viper-com-point (point)))
3182 val (if (> (viper-p-val arg) 0) viper-f-char viper-F-char) t nil)
3186 (setq viper-F-char viper-f-char) ; set new viper-F-char
3188 (viper-execute-com 'viper-find-char-forward val com)))))
3190 (defun viper-goto-char-forward (arg)
3191 "Go up to char ARG forward on line."
3193 (let ((val (viper-p-val arg))
3194 (com (viper-getcom arg))
3195 (cmd-representation (nth 5 viper-d-com)))
3197 ;; this means that the function was called interactively
3198 (setq viper-f-char (read-char)
3201 ;; viper-repeat --- set viper-F-char from command-keys
3202 (setq viper-F-char (if (stringp cmd-representation)
3203 (viper-seq-last-elt cmd-representation)
3205 viper-f-char viper-F-char)
3207 (if com (viper-move-marker-locally 'viper-com-point (point)))
3209 val (if (> (viper-p-val arg) 0) viper-f-char viper-F-char) t t)
3213 (setq viper-F-char viper-f-char) ; set new viper-F-char
3215 (viper-execute-com 'viper-goto-char-forward val com)))))
3217 (defun viper-find-char-backward (arg)
3218 "Find char ARG on line backward."
3220 (let ((val (viper-p-val arg))
3221 (com (viper-getcom arg))
3222 (cmd-representation (nth 5 viper-d-com)))
3224 ;; this means that the function was called interactively
3225 (setq viper-f-char (read-char)
3228 ;; viper-repeat --- set viper-F-char from command-keys
3229 (setq viper-F-char (if (stringp cmd-representation)
3230 (viper-seq-last-elt cmd-representation)
3232 viper-f-char viper-F-char)
3234 (if com (viper-move-marker-locally 'viper-com-point (point)))
3236 val (if (> (viper-p-val arg) 0) viper-f-char viper-F-char) nil nil)
3240 (setq viper-F-char viper-f-char) ; set new viper-F-char
3241 (viper-execute-com 'viper-find-char-backward val com)))))
3243 (defun viper-goto-char-backward (arg)
3244 "Go up to char ARG backward on line."
3246 (let ((val (viper-p-val arg))
3247 (com (viper-getcom arg))
3248 (cmd-representation (nth 5 viper-d-com)))
3250 ;; this means that the function was called interactively
3251 (setq viper-f-char (read-char)
3254 ;; viper-repeat --- set viper-F-char from command-keys
3255 (setq viper-F-char (if (stringp cmd-representation)
3256 (viper-seq-last-elt cmd-representation)
3258 viper-f-char viper-F-char)
3260 (if com (viper-move-marker-locally 'viper-com-point (point)))
3262 val (if (> (viper-p-val arg) 0) viper-f-char viper-F-char) nil t)
3266 (setq viper-F-char viper-f-char) ; set new viper-F-char
3267 (viper-execute-com 'viper-goto-char-backward val com)))))
3269 (defun viper-repeat-find (arg)
3270 "Repeat previous find command."
3272 (let ((val (viper-p-val arg))
3273 (com (viper-getcom arg)))
3274 (viper-deactivate-mark)
3275 (if com (viper-move-marker-locally 'viper-com-point (point)))
3276 (viper-find-char val viper-f-char viper-f-forward viper-f-offset)
3279 (if viper-f-forward (forward-char))
3280 (viper-execute-com 'viper-repeat-find val com)))))
3282 (defun viper-repeat-find-opposite (arg)
3283 "Repeat previous find command in the opposite direction."
3285 (let ((val (viper-p-val arg))
3286 (com (viper-getcom arg)))
3287 (viper-deactivate-mark)
3288 (if com (viper-move-marker-locally 'viper-com-point (point)))
3289 (viper-find-char val viper-f-char (not viper-f-forward) viper-f-offset)
3292 (if viper-f-forward (forward-char))
3293 (viper-execute-com 'viper-repeat-find-opposite val com)))))
3296 ;; window scrolling etc.
3298 (defun viper-window-top (arg)
3299 "Go to home window line."
3301 (let ((val (viper-p-val arg))
3302 (com (viper-getCom arg)))
3303 (viper-leave-region-active)
3304 (if com (viper-move-marker-locally 'viper-com-point (point)))
3306 (move-to-window-line (1- val))
3308 ;; positioning is done twice: before and after command execution
3309 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3310 (back-to-indentation)
3312 (if com (viper-execute-com 'viper-window-top val com))
3314 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3315 (back-to-indentation)
3318 (defun viper-window-middle (arg)
3319 "Go to middle window line."
3321 (let ((val (viper-p-val arg))
3322 (com (viper-getCom arg)))
3323 (viper-leave-region-active)
3324 (if com (viper-move-marker-locally 'viper-com-point (point)))
3326 (move-to-window-line (+ (/ (1- (window-height)) 2) (1- val)))
3328 ;; positioning is done twice: before and after command execution
3329 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3330 (back-to-indentation)
3332 (if com (viper-execute-com 'viper-window-middle val com))
3334 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3335 (back-to-indentation)
3338 (defun viper-window-bottom (arg)
3339 "Go to last window line."
3341 (let ((val (viper-p-val arg))
3342 (com (viper-getCom arg)))
3343 (viper-leave-region-active)
3344 (if com (viper-move-marker-locally 'viper-com-point (point)))
3346 (move-to-window-line (- val))
3348 ;; positioning is done twice: before and after command execution
3349 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3350 (back-to-indentation)
3352 (if com (viper-execute-com 'viper-window-bottom val com))
3354 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3355 (back-to-indentation)
3358 (defun viper-line-to-top (arg)
3359 "Put current line on the home line."
3361 (recenter (1- arg)))
3363 (defun viper-line-to-middle (arg)
3364 "Put current line on the middle line."
3366 (recenter (+ (1- arg) (/ (1- (window-height)) 2))))
3368 (defun viper-line-to-bottom (arg)
3369 "Put current line on the last line."
3371 (recenter (- (window-height) (1+ arg))))
3373 ;; If point is within viper-search-scroll-threshold of window top or bottom,
3374 ;; scroll up or down 1/7 of window height, depending on whether we are at the
3375 ;; bottom or at the top of the window. This function is called by viper-search
3376 ;; (which is called from viper-search-forward/backward/next). If the value of
3377 ;; viper-search-scroll-threshold is negative - don't scroll.
3378 (defun viper-adjust-window ()
3379 (let ((win-height (if (featurep 'xemacs)
3380 (window-displayed-height)
3381 (1- (window-height)))) ; adjust for mode line
3383 at-top-p at-bottom-p
3384 min-scroll direction)
3386 (move-to-window-line 0) ; top
3388 (<= (count-lines pt (point))
3389 viper-search-scroll-threshold))
3390 (move-to-window-line -1) ; bottom
3392 (<= (count-lines pt (point)) viper-search-scroll-threshold)))
3393 (cond (at-top-p (setq min-scroll (1- viper-search-scroll-threshold)
3395 (at-bottom-p (setq min-scroll (1+ viper-search-scroll-threshold)
3399 (* (max min-scroll (/ win-height 7)) direction)))
3404 ;; must correct this to only match ( to ) etc. On the other hand
3405 ;; it is good that paren match gets confused, because that way you
3406 ;; catch _all_ imbalances.
3408 (defun viper-paren-match (arg)
3409 "Go to the matching parenthesis."
3411 (viper-leave-region-active)
3412 (let ((com (viper-getcom arg))
3413 (parse-sexp-ignore-comments viper-parse-sexp-ignore-comments)
3416 (if (or (> arg 99) (< arg 1))
3417 (error "Prefix must be between 1 and 99")
3419 (if (> (point-max) 80000)
3420 (* (/ (point-max) 100) arg)
3421 (/ (* (point-max) arg) 100)))
3422 (back-to-indentation))
3423 (let (beg-lim end-lim)
3424 (if (and (eolp) (not (bolp))) (forward-char -1))
3425 (if (not (looking-at "[][(){}]"))
3426 (setq anchor-point (point)))
3427 (setq beg-lim (point-at-bol)
3428 end-lim (point-at-eol))
3429 (cond ((re-search-forward "[][(){}]" end-lim t)
3431 ((re-search-backward "[][(){}]" beg-lim t))
3433 (error "No matching character on line"))))
3434 (cond ((looking-at "[([{]")
3435 (if com (viper-move-marker-locally 'viper-com-point (point)))
3438 (viper-execute-com 'viper-paren-match nil com)
3443 (viper-move-marker-locally 'viper-com-point anchor-point)
3445 (viper-execute-com 'viper-paren-match nil com)
3447 ((looking-at "[])}]")
3449 (if com (viper-move-marker-locally 'viper-com-point (point)))
3451 (if com (viper-execute-com 'viper-paren-match nil com)))
3452 (t (error "Viper bell"))))))
3454 (defun viper-toggle-parse-sexp-ignore-comments ()
3456 (setq viper-parse-sexp-ignore-comments
3457 (not viper-parse-sexp-ignore-comments))
3458 (princ (format-message
3459 "From now on, `%%' will %signore parentheses inside comment fields"
3460 (if viper-parse-sexp-ignore-comments "" "NOT "))))
3463 ;; sentence, paragraph and heading
3465 (defun viper-forward-sentence (arg)
3468 (or (eq last-command this-command)
3470 (let ((val (viper-p-val arg))
3471 (com (viper-getcom arg)))
3472 (if com (viper-move-marker-locally 'viper-com-point (point)))
3473 (forward-sentence val)
3474 (if com (viper-execute-com 'viper-forward-sentence nil com))))
3476 (defun viper-backward-sentence (arg)
3477 "Backward sentence."
3479 (or (eq last-command this-command)
3481 (let ((val (viper-p-val arg))
3482 (com (viper-getcom arg)))
3483 (if com (viper-move-marker-locally 'viper-com-point (point)))
3484 (backward-sentence val)
3485 (if com (viper-execute-com 'viper-backward-sentence nil com))))
3487 (defun viper-forward-paragraph (arg)
3488 "Forward paragraph."
3490 (or (eq last-command this-command)
3492 (let ((val (viper-p-val arg))
3493 ;; if you want d} operate on whole lines, change viper-getcom to
3494 ;; viper-getCom below
3495 (com (viper-getcom arg)))
3496 (if com (viper-move-marker-locally 'viper-com-point (point)))
3497 (forward-paragraph val)
3501 (viper-execute-com 'viper-forward-paragraph nil com)))))
3503 (defun viper-backward-paragraph (arg)
3504 "Backward paragraph."
3506 (or (eq last-command this-command)
3508 (let ((val (viper-p-val arg))
3509 ;; if you want d{ operate on whole lines, change viper-getcom to
3510 ;; viper-getCom below
3511 (com (viper-getcom arg)))
3512 (if com (viper-move-marker-locally 'viper-com-point (point)))
3513 (backward-paragraph val)
3517 (viper-execute-com 'viper-backward-paragraph nil com)
3518 (backward-char 1)))))
3520 ;; should be mode-specific
3521 (defun viper-prev-heading (arg)
3523 (let ((val (viper-p-val arg))
3524 (com (viper-getCom arg)))
3525 (if com (viper-move-marker-locally 'viper-com-point (point)))
3526 (re-search-backward viper-heading-start nil t val)
3527 (goto-char (match-beginning 0))
3528 (if com (viper-execute-com 'viper-prev-heading nil com))))
3530 (defun viper-heading-end (arg)
3532 (let ((val (viper-p-val arg))
3533 (com (viper-getCom arg)))
3534 (if com (viper-move-marker-locally 'viper-com-point (point)))
3535 (re-search-forward viper-heading-end nil t val)
3536 (goto-char (match-beginning 0))
3537 (if com (viper-execute-com 'viper-heading-end nil com))))
3539 (defun viper-next-heading (arg)
3541 (let ((val (viper-p-val arg))
3542 (com (viper-getCom arg)))
3543 (if com (viper-move-marker-locally 'viper-com-point (point)))
3545 (re-search-forward viper-heading-start nil t val)
3546 (goto-char (match-beginning 0))
3547 (if com (viper-execute-com 'viper-next-heading nil com))))
3552 (defun viper-scroll-screen (arg)
3553 "Scroll to next screen."
3559 (setq arg (1- arg)))
3562 (setq arg (1+ arg))))
3566 (message "End of buffer")
3567 (goto-char (point-max)))
3568 (message "Beginning of buffer")
3569 (goto-char (point-min))))
3572 (defun viper-scroll-screen-back (arg)
3573 "Scroll to previous screen."
3575 (viper-scroll-screen (- arg)))
3577 (defun viper-scroll-down (arg)
3578 "Pull down half screen."
3582 (scroll-down (/ (window-height) 2))
3585 (message "Beginning of buffer")
3586 (goto-char (point-min)))))
3588 (defun viper-scroll-down-one (arg)
3589 "Scroll up one line."
3593 (defun viper-scroll-up (arg)
3594 "Pull up half screen."
3598 (scroll-up (/ (window-height) 2))
3601 (message "End of buffer")
3602 (goto-char (point-max)))))
3604 (defun viper-scroll-up-one (arg)
3605 "Scroll down one line."
3612 (defun viper-insert-isearch-string ()
3613 "Insert `isearch' last search string."
3615 (when isearch-string (insert isearch-string)))
3617 (defun viper-if-string (prompt)
3618 (if (memq viper-intermediate-command
3619 '(viper-command-argument viper-digit-argument viper-repeat))
3620 (setq viper-this-command-keys (this-command-keys)))
3621 (let* ((keymap (let ((keymap (copy-keymap minibuffer-local-map)))
3622 (define-key keymap [(control ?s)] 'viper-insert-isearch-string)
3624 (s (viper-read-string-with-history
3627 'viper-search-history
3628 (car viper-search-history)
3630 (if (not (string= s ""))
3631 (setq viper-s-string s))))
3634 (defun viper-toggle-search-style (arg)
3635 "Toggle the value of viper-case-fold-search/viper-re-search.
3636 Without prefix argument, will ask which search style to toggle. With prefix
3637 arg 1, toggles viper-case-fold-search; with arg 2 toggles viper-re-search.
3639 Although this function is bound to \\[viper-toggle-search-style], the most
3640 convenient way to use it is to bind `//' to the macro
3641 `1 M-x viper-toggle-search-style' and `///' to
3642 `2 M-x viper-toggle-search-style'. In this way, hitting `//' quickly will
3643 toggle case-fold-search and hitting `/' three times with toggle regexp
3644 search. Macros are more convenient in this case because they don't affect
3645 the Emacs binding of `/'."
3648 (cond ((or (eq arg 1)
3650 (y-or-n-p (format-message
3651 "Search style: `%s'. Want `%s'? "
3652 (if viper-case-fold-search
3653 "case-insensitive" "case-sensitive")
3654 (if viper-case-fold-search
3656 "case-insensitive")))))
3657 (setq viper-case-fold-search (null viper-case-fold-search))
3658 (if viper-case-fold-search
3659 (setq msg "Search becomes case-insensitive")
3660 (setq msg "Search becomes case-sensitive")))
3663 (y-or-n-p (format-message
3664 "Search style: `%s'. Want `%s'? "
3666 "regexp-search" "vanilla-search")
3669 "regexp-search")))))
3670 (setq viper-re-search (null viper-re-search))
3672 (setq msg "Search becomes regexp-style")
3673 (setq msg "Search becomes vanilla-style")))
3675 (setq msg "Search style remains unchanged")))
3678 (defun viper-set-searchstyle-toggling-macros (unset &optional mode)
3679 "Set the macros for toggling the search style in Viper's vi-state.
3680 The macro that toggles case sensitivity is bound to `//', and the one that
3681 toggles regexp search is bound to `///'.
3682 With a prefix argument, this function unsets the macros.
3683 If MODE is set, set the macros only in that major mode."
3685 (let ((scope (if (and mode (symbolp mode)) mode t)))
3689 ;; toggle case sensitivity in search
3690 (viper-record-kbd-macro
3692 [1 (meta x) v i p e r - t o g g l e - s e a r c h - s t y l e return]
3694 ;; toggle regexp/vanilla search
3695 (viper-record-kbd-macro
3697 [2 (meta x) v i p e r - t o g g l e - s e a r c h - s t y l e return]
3699 (if (if (featurep 'xemacs)
3701 (called-interactively-p 'interactive))
3703 "// and /// now toggle case-sensitivity and regexp search")))
3704 (viper-unrecord-kbd-macro "//" 'vi-state)
3706 (viper-unrecord-kbd-macro "///" 'vi-state)))
3710 (defun viper-set-parsing-style-toggling-macro (unset)
3711 "Set `%%%' to be a macro that toggles whether comment fields should be parsed for matching parentheses.
3712 This is used in conjunction with the `%' command.
3714 With a prefix argument, unsets the macro."
3719 ;; Make %%% toggle parsing comments for matching parentheses
3720 (viper-record-kbd-macro
3722 [(meta x) v i p e r - t o g g l e - p a r s e - s e x p - i g n o r e - c o m m e n t s return]
3724 (if (if (featurep 'xemacs)
3726 (called-interactively-p 'interactive))
3728 "%%%%%% now toggles whether comments should be parsed for matching parentheses")))
3729 (viper-unrecord-kbd-macro "%%%" 'vi-state))))
3732 (defun viper-set-emacs-state-searchstyle-macros (unset &optional arg-majormode)
3733 "Set the macros for toggling the search style in Viper's emacs-state.
3734 The macro that toggles case sensitivity is bound to `//', and the one that
3735 toggles regexp search is bound to `///'.
3736 With a prefix argument, this function unsets the macros.
3737 If the optional prefix argument is non-nil and specifies a valid major mode,
3738 this sets the macros only in the macros in that major mode. Otherwise,
3739 the macros are set in the current major mode.
3740 \(When unsetting the macros, the second argument has no effect.)"
3745 ;; toggle case sensitivity in search
3746 (viper-record-kbd-macro
3748 [1 (meta x) v i p e r - t o g g l e - s e a r c h - s t y l e return]
3749 (or arg-majormode major-mode))
3750 ;; toggle regexp/vanilla search
3751 (viper-record-kbd-macro
3753 [2 (meta x) v i p e r - t o g g l e - s e a r c h - s t y l e return]
3754 (or arg-majormode major-mode))
3755 (if (if (featurep 'xemacs)
3757 (called-interactively-p 'interactive))
3759 "// and /// now toggle case-sensitivity and regexp search.")))
3760 (viper-unrecord-kbd-macro "//" 'emacs-state)
3762 (viper-unrecord-kbd-macro "///" 'emacs-state))))
3765 (defun viper-search-forward (arg)
3766 "Search a string forward.
3767 ARG is used to find the ARG's occurrence of the string.
3768 Null string will repeat previous search."
3770 (let ((val (viper-P-val arg))
3771 (com (viper-getcom arg))
3772 (old-str viper-s-string)
3774 (setq viper-s-forward t)
3775 (viper-if-string "/")
3776 ;; this is not used at present, but may be used later
3777 (if (or (not (equal old-str viper-s-string))
3778 (not (markerp viper-local-search-start-marker))
3779 (not (marker-buffer viper-local-search-start-marker)))
3780 (setq viper-local-search-start-marker (point-marker)))
3781 (viper-search viper-s-string t val)
3784 (viper-move-marker-locally 'viper-com-point (mark t))
3785 (viper-execute-com 'viper-search-next val com)))
3788 (defun viper-search-backward (arg)
3789 "Search a string backward.
3790 ARG is used to find the ARG's occurrence of the string.
3791 Null string will repeat previous search."
3793 (let ((val (viper-P-val arg))
3794 (com (viper-getcom arg))
3795 (old-str viper-s-string)
3797 (setq viper-s-forward nil)
3798 (viper-if-string "?")
3799 ;; this is not used at present, but may be used later
3800 (if (or (not (equal old-str viper-s-string))
3801 (not (markerp viper-local-search-start-marker))
3802 (not (marker-buffer viper-local-search-start-marker)))
3803 (setq viper-local-search-start-marker (point-marker)))
3804 (viper-search viper-s-string nil val)
3807 (viper-move-marker-locally 'viper-com-point (mark t))
3808 (viper-execute-com 'viper-search-next val com)))))
3811 ;; Search for COUNT's occurrence of STRING.
3812 ;; Search is forward if FORWARD is non-nil, otherwise backward.
3813 ;; INIT-POINT is the position where search is to start.
3815 ;; (STRING FORW COUNT &optional NO-OFFSET INIT-POINT LIMIT FAIL-IF-NOT-FOUND)
3816 (defun viper-search (string forward arg
3817 &optional no-offset init-point fail-if-not-found)
3818 (if (not (equal string ""))
3819 (let ((val (viper-p-val arg))
3820 (com (viper-getcom arg))
3821 (offset (not no-offset))
3822 (case-fold-search viper-case-fold-search)
3823 (start-point (or init-point (point))))
3824 (viper-deactivate-mark)
3828 (if offset (viper-forward-char-carefully))
3831 (re-search-forward string nil nil val)
3832 (re-search-backward string))
3833 (search-forward string nil nil val)
3834 (search-backward string))
3835 (if (not (equal start-point (point)))
3836 (push-mark start-point t)))
3838 (if (and (not fail-if-not-found) viper-search-wrap-around)
3840 (message "Search wrapped around BOTTOM of buffer")
3841 (goto-char (point-min))
3842 (viper-search string forward (cons 1 com) t start-point 'fail)
3843 ;; don't wait in macros
3844 (or executing-kbd-macro
3845 (memq viper-intermediate-command
3847 viper-digit-argument
3848 viper-command-argument))
3850 ;; delete the wrap-around message
3853 (goto-char start-point)
3854 (error "`%s': %s not found"
3856 (if viper-re-search "Pattern" "String"))
3862 (re-search-backward string nil nil val)
3863 (search-backward string nil nil val))
3864 (if (not (equal start-point (point)))
3865 (push-mark start-point t)))
3867 (if (and (not fail-if-not-found) viper-search-wrap-around)
3869 (message "Search wrapped around TOP of buffer")
3870 (goto-char (point-max))
3871 (viper-search string forward (cons 1 com) t start-point 'fail)
3872 ;; don't wait in macros
3873 (or executing-kbd-macro
3874 (memq viper-intermediate-command
3876 viper-digit-argument
3877 viper-command-argument))
3879 ;; delete the wrap-around message
3882 (goto-char start-point)
3883 (error "`%s': %s not found"
3885 (if viper-re-search "Pattern" "String"))
3887 ;; pull up or down if at top/bottom of window
3888 (viper-adjust-window)
3889 ;; highlight the result of search
3890 ;; don't wait and don't highlight in macros
3891 (or executing-kbd-macro
3892 (memq viper-intermediate-command
3893 '(viper-repeat viper-digit-argument viper-command-argument))
3894 (viper-flash-search-pattern))
3897 (defun viper-search-next (arg)
3898 "Repeat previous search."
3900 (let ((val (viper-p-val arg))
3901 (com (viper-getcom arg))
3903 (if (or (null viper-s-string) (string= viper-s-string ""))
3904 (error viper-NoPrevSearch))
3905 (viper-search viper-s-string viper-s-forward arg)
3908 (viper-move-marker-locally 'viper-com-point (mark t))
3909 (viper-execute-com 'viper-search-next val com)))))
3911 (defun viper-search-Next (arg)
3912 "Repeat previous search in the reverse direction."
3914 (let ((val (viper-p-val arg))
3915 (com (viper-getcom arg))
3917 (if (null viper-s-string) (error viper-NoPrevSearch))
3918 (viper-search viper-s-string (not viper-s-forward) arg)
3921 (viper-move-marker-locally 'viper-com-point (mark t))
3922 (viper-execute-com 'viper-search-Next val com)))))
3925 ;; Search contents of buffer defined by one of Viper's motion commands.
3926 ;; Repeatable via `n' and `N'.
3927 (defun viper-buffer-search-enable (&optional c)
3928 (cond (c (setq viper-buffer-search-char c))
3929 ((null viper-buffer-search-char)
3930 ;; ?g acts as a default value for viper-buffer-search-char
3931 (setq viper-buffer-search-char ?g)))
3932 (define-key viper-vi-basic-map
3933 (cond ((viper-characterp viper-buffer-search-char)
3934 (char-to-string viper-buffer-search-char))
3935 (t (error "viper-buffer-search-char: wrong value type, %S"
3936 viper-buffer-search-char)))
3937 'viper-command-argument)
3938 (aset viper-exec-array viper-buffer-search-char 'viper-exec-buffer-search)
3939 (setq viper-prefix-commands
3940 (cons viper-buffer-search-char viper-prefix-commands)))
3942 ;; This is a Viper wrapper for isearch-forward.
3943 (defun viper-isearch-forward (arg)
3944 "Do incremental search forward."
3946 ;; emacs bug workaround
3947 (if (listp arg) (setq arg (car arg)))
3948 (viper-exec-form-in-emacs (list 'isearch-forward arg)))
3950 ;; This is a Viper wrapper for isearch-backward."
3951 (defun viper-isearch-backward (arg)
3952 "Do incremental search backward."
3954 ;; emacs bug workaround
3955 (if (listp arg) (setq arg (car arg)))
3956 (viper-exec-form-in-emacs (list 'isearch-backward arg)))
3959 ;; visiting and killing files, buffers
3961 (defun viper-switch-to-buffer ()
3962 "Switch to buffer in the current window."
3964 (let ((other-buffer (other-buffer (current-buffer)))
3967 (funcall viper-read-buffer-function
3968 "Switch to buffer in this window: " other-buffer))
3969 (switch-to-buffer buffer)))
3971 (defun viper-switch-to-buffer-other-window ()
3972 "Switch to buffer in another window."
3974 (let ((other-buffer (other-buffer (current-buffer)))
3977 (funcall viper-read-buffer-function
3978 "Switch to buffer in another window: " other-buffer))
3979 (switch-to-buffer-other-window buffer)))
3981 (defun viper-kill-buffer ()
3984 (let (buffer buffer-name)
3986 (funcall viper-read-buffer-function
3987 (format "Kill buffer (%s): "
3988 (buffer-name (current-buffer)))))
3990 (if (null buffer-name)
3992 (get-buffer buffer-name)))
3993 (if (null buffer) (error "`%s': No such buffer" buffer-name))
3994 (if (or (not (buffer-modified-p buffer))
3997 "Buffer `%s' is modified, are you sure you want to kill it? "
3999 (kill-buffer buffer)
4000 (error "Buffer not killed"))))
4006 (defsubst viper-yank (text)
4007 "Yank TEXT silently. This works correctly with Emacs's yank-pop command."
4009 (setq this-command 'yank))
4011 (defun viper-put-back (arg)
4012 "Put back after point/below line."
4014 (let ((val (viper-p-val arg))
4015 (text (if viper-use-register
4016 (cond ((viper-valid-register viper-use-register '(digit))
4018 (- viper-use-register ?1) 'do-not-rotate))
4019 ((viper-valid-register viper-use-register)
4020 (get-register (downcase viper-use-register)))
4021 (t (error viper-InvalidRegister viper-use-register)))
4023 sv-point chars-inserted lines-inserted)
4025 (if viper-use-register
4026 (let ((reg viper-use-register))
4027 (setq viper-use-register nil)
4028 (error viper-EmptyRegister reg))
4029 (error "Viper bell")))
4030 (setq viper-use-register nil)
4031 (if (viper-end-with-a-newline-p text)
4037 (beginning-of-line))
4038 (if (not (eolp)) (viper-forward-char-carefully)))
4039 (set-marker (viper-mark-marker) (point) (current-buffer))
4040 (viper-set-destructive-command
4041 (list 'viper-put-back val nil viper-use-register nil nil))
4042 (setq sv-point (point))
4043 (viper-loop val (viper-yank text))
4044 (setq chars-inserted (abs (- (point) sv-point))
4045 lines-inserted (abs (count-lines (point) sv-point)))
4046 (if (or (> chars-inserted viper-change-notification-threshold)
4047 (> lines-inserted viper-change-notification-threshold))
4048 (unless (viper-is-in-minibuffer)
4049 (message "Inserted %d character(s), %d line(s)"
4050 chars-inserted lines-inserted))))
4051 ;; Vi puts cursor on the last char when the yanked text doesn't contain a
4052 ;; newline; it leaves the cursor at the beginning when the text contains
4054 (if (viper-same-line (point) (mark))
4055 (or (= (point) (mark)) (viper-backward-char-carefully))
4056 (exchange-point-and-mark)
4058 (back-to-indentation)))
4059 (viper-deactivate-mark))
4061 (defun viper-Put-back (arg)
4062 "Put back at point/above line."
4064 (let ((val (viper-p-val arg))
4065 (text (if viper-use-register
4066 (cond ((viper-valid-register viper-use-register '(digit))
4068 (- viper-use-register ?1) 'do-not-rotate))
4069 ((viper-valid-register viper-use-register)
4070 (get-register (downcase viper-use-register)))
4071 (t (error viper-InvalidRegister viper-use-register)))
4073 sv-point chars-inserted lines-inserted)
4075 (if viper-use-register
4076 (let ((reg viper-use-register))
4077 (setq viper-use-register nil)
4078 (error viper-EmptyRegister reg))
4079 (error "Viper bell")))
4080 (setq viper-use-register nil)
4081 (if (viper-end-with-a-newline-p text) (beginning-of-line))
4082 (viper-set-destructive-command
4083 (list 'viper-Put-back val nil viper-use-register nil nil))
4084 (set-marker (viper-mark-marker) (point) (current-buffer))
4085 (setq sv-point (point))
4086 (viper-loop val (viper-yank text))
4087 (setq chars-inserted (abs (- (point) sv-point))
4088 lines-inserted (abs (count-lines (point) sv-point)))
4089 (if (or (> chars-inserted viper-change-notification-threshold)
4090 (> lines-inserted viper-change-notification-threshold))
4091 (unless (viper-is-in-minibuffer)
4092 (message "Inserted %d character(s), %d line(s)"
4093 chars-inserted lines-inserted))))
4094 ;; Vi puts cursor on the last char when the yanked text doesn't contain a
4095 ;; newline; it leaves the cursor at the beginning when the text contains
4097 (if (viper-same-line (point) (mark))
4098 (or (= (point) (mark)) (viper-backward-char-carefully))
4099 (exchange-point-and-mark)
4101 (back-to-indentation)))
4102 (viper-deactivate-mark))
4105 ;; Copy region to kill-ring.
4106 ;; If BEG and END do not belong to the same buffer, copy empty region.
4107 (defun viper-copy-region-as-kill (beg end)
4109 (copy-region-as-kill beg end)
4110 (error (copy-region-as-kill beg beg))))
4113 (defun viper-delete-char (arg)
4114 "Delete next character."
4116 (let ((val (viper-p-val arg))
4118 (viper-set-destructive-command
4119 (list 'viper-delete-char val nil nil nil nil))
4120 (if (and viper-ex-style-editing
4121 (> val (viper-chars-in-region (point) (viper-line-pos 'end))))
4122 (setq val (viper-chars-in-region (point) (viper-line-pos 'end))))
4123 (if (and viper-ex-style-motion (eolp))
4124 (if (bolp) (error "Viper bell") (setq val 0))) ; not bol---simply back 1 ch
4126 (viper-forward-char-carefully val)
4127 (setq end-del-pos (point)))
4128 (if viper-use-register
4130 (cond ((viper-valid-register viper-use-register '((Letter)))
4131 (viper-append-to-register
4132 (downcase viper-use-register) (point) end-del-pos))
4133 ((viper-valid-register viper-use-register)
4135 viper-use-register (point) end-del-pos nil))
4136 (t (error viper-InvalidRegister viper-use-register)))
4137 (setq viper-use-register nil)))
4140 (if viper-ex-style-motion
4141 (if (and (eolp) (not (bolp))) (backward-char 1)))
4144 (defun viper-delete-backward-char (arg)
4145 "Delete previous character. On reaching beginning of line, stop and beep."
4147 (let ((val (viper-p-val arg))
4149 (viper-set-destructive-command
4150 (list 'viper-delete-backward-char val nil nil nil nil))
4152 viper-ex-style-editing
4153 (> val (viper-chars-in-region (viper-line-pos 'start) (point))))
4154 (setq val (viper-chars-in-region (viper-line-pos 'start) (point))))
4156 (viper-backward-char-carefully val)
4157 (setq end-del-pos (point)))
4158 (if viper-use-register
4160 (cond ((viper-valid-register viper-use-register '(Letter))
4161 (viper-append-to-register
4162 (downcase viper-use-register) end-del-pos (point)))
4163 ((viper-valid-register viper-use-register)
4165 viper-use-register end-del-pos (point) nil))
4166 (t (error viper-InvalidRegister viper-use-register)))
4167 (setq viper-use-register nil)))
4168 (if (and (bolp) viper-ex-style-editing)
4170 (delete-char (- val) t)))
4173 (defun viper-del-backward-char-in-insert ()
4174 "Delete 1 char backwards while in insert mode."
4176 (if (and viper-ex-style-editing (bolp))
4178 ;; don't put on kill ring
4179 (delete-char -1 nil)))
4182 (defun viper-del-backward-char-in-replace ()
4183 "Delete one character in replace mode.
4184 If `viper-delete-backwards-in-replace' is t, then DEL key actually deletes
4185 characters. If it is nil, then the cursor just moves backwards, similarly
4186 to Vi. The variable `viper-ex-style-editing', if t, doesn't let the
4187 cursor move past the beginning of line."
4189 (cond (viper-delete-backwards-in-replace
4191 ;; don't put on kill ring
4192 (delete-char -1 nil))
4193 (viper-ex-style-editing
4198 ;; don't put on kill ring
4199 (delete-char -1 nil))))
4200 (viper-ex-style-editing
4205 (backward-char 1))))
4207 (defun viper-del-forward-char-in-insert ()
4208 "Delete 1 char forward if in insert or replace state."
4210 ;; don't put on kill ring
4211 (delete-char 1 nil))
4216 (defun viper-join-lines (arg)
4217 "Join this line to next, if ARG is nil. Otherwise, join ARG lines."
4219 (let ((val (viper-P-val arg)))
4220 (viper-set-destructive-command
4221 (list 'viper-join-lines val nil nil nil nil))
4222 (viper-loop (if (null val) 1 (1- val))
4227 (delete-region (point) (1- (point)))
4229 ;; fixup-whitespace sometimes does not leave space
4230 ;; between objects, so we insert it as in Vi
4231 (or (looking-at " ")
4239 (defun viper-change (beg end)
4240 (if (markerp beg) (setq beg (marker-position beg)))
4241 (if (markerp end) (setq end (marker-position end)))
4242 ;; beg is sometimes (mark t), which may be nil
4243 (or beg (setq beg end))
4245 (viper-set-complex-command-for-undo)
4246 (if viper-use-register
4248 (copy-to-register viper-use-register beg end nil)
4249 (setq viper-use-register nil)))
4250 (viper-set-replace-overlay beg end)
4251 (setq last-command nil) ; separate repl text from prev kills
4253 (if (= (viper-replace-start) (point-max))
4254 (error "End of buffer"))
4256 (setq viper-last-replace-region
4257 (buffer-substring (viper-replace-start)
4258 (viper-replace-end)))
4260 ;; protect against error while inserting "@" and other disasters
4261 ;; (e.g., read-only buff)
4262 (condition-case conds
4263 (if (or viper-allow-multiline-replace-regions
4264 (viper-same-line (viper-replace-start)
4265 (viper-replace-end)))
4267 ;; tabs cause problems in replace, so untabify
4268 (goto-char (viper-replace-end))
4269 (insert-before-markers "@") ; put placeholder after the TAB
4270 (untabify (viper-replace-start) (point))
4271 ;; del @, don't put on kill ring
4274 (viper-set-replace-overlay-glyphs
4275 viper-replace-region-start-delimiter
4276 viper-replace-region-end-delimiter)
4277 ;; this move takes care of the last posn in the overlay, which
4278 ;; has to be shifted because of insert. We can't simply insert
4279 ;; "$" before-markers because then overlay-start will shift the
4280 ;; beginning of the overlay in case we are replacing a single
4281 ;; character. This fixes the bug with `s' and `cl' commands.
4282 (viper-move-replace-overlay (viper-replace-start) (point))
4283 (goto-char (viper-replace-start))
4284 (viper-change-state-to-replace t))
4285 (kill-region (viper-replace-start)
4286 (viper-replace-end))
4287 (viper-hide-replace-overlay)
4288 (viper-change-state-to-insert))
4289 (error ;; make sure that the overlay doesn't stay.
4290 ;; go back to the original point
4291 (goto-char (viper-replace-start))
4292 (viper-hide-replace-overlay)
4293 (viper-message-conditions conds))))
4296 (defun viper-change-subr (beg end)
4297 ;; beg is sometimes (mark t), which may be nil
4298 (or beg (setq beg end))
4299 (if viper-use-register
4301 (copy-to-register viper-use-register beg end nil)
4302 (setq viper-use-register nil)))
4303 (kill-region beg end)
4304 (setq this-command 'viper-change)
4305 (viper-yank-last-insertion))
4307 (defun viper-toggle-case (arg)
4308 "Toggle character case."
4310 (let ((val (viper-p-val arg)) (c))
4311 (viper-set-destructive-command
4312 (list 'viper-toggle-case val nil nil nil nil))
4314 (setq c (following-char))
4316 (if (eq c (upcase c))
4317 (insert-char (downcase c) 1)
4318 (insert-char (upcase c) 1))
4319 (if (eolp) (backward-char 1))
4320 (setq val (1- val)))))
4325 (defun viper-query-replace ()
4327 If a null string is supplied as the string to be replaced,
4328 the query replace mode will toggle between string replace
4329 and regexp replace."
4332 (setq str (viper-read-string-with-history
4333 (if viper-re-query-replace "Query replace regexp: "
4336 'viper-replace1-history
4337 (car viper-replace1-history) ; default
4339 (if (string= str "")
4341 (setq viper-re-query-replace (not viper-re-query-replace))
4342 (message "Query replace mode changed to %s"
4343 (if viper-re-query-replace "regexp replace"
4345 (if viper-re-query-replace
4346 (query-replace-regexp
4348 (viper-read-string-with-history
4349 (format-message "Query replace regexp `%s' with: " str)
4351 'viper-replace1-history
4352 (car viper-replace1-history) ; default
4356 (viper-read-string-with-history
4357 (format-message "Query replace `%s' with: " str)
4359 'viper-replace1-history
4360 (car viper-replace1-history) ; default
4366 (defun viper-mark-beginning-of-buffer ()
4367 "Mark beginning of buffer."
4370 (goto-char (point-min))
4371 (exchange-point-and-mark)
4372 (message "Mark set at the beginning of buffer"))
4374 (defun viper-mark-end-of-buffer ()
4375 "Mark end of buffer."
4378 (goto-char (point-max))
4379 (exchange-point-and-mark)
4380 (message "Mark set at the end of buffer"))
4382 (defun viper-mark-point ()
4383 "Set mark at point of buffer."
4385 (let ((char (read-char)))
4386 (cond ((and (<= ?a char) (<= char ?z))
4387 (point-to-register (viper-int-to-char (1+ (- char ?a)))))
4388 ((viper= char ?<) (viper-mark-beginning-of-buffer))
4389 ((viper= char ?>) (viper-mark-end-of-buffer))
4390 ((viper= char ?.) (viper-set-mark-if-necessary))
4391 ((viper= char ?,) (viper-cycle-through-mark-ring))
4392 ((viper= char ?^) (push-mark viper-saved-mark t t))
4393 ((viper= char ?D) (mark-defun))
4394 (t (error "Viper bell"))
4397 ;; Algorithm: If first invocation of this command save mark on ring, goto
4398 ;; mark, M0, and pop the most recent elt from the mark ring into mark,
4399 ;; making it into the new mark, M1.
4400 ;; Push this mark back and set mark to the original point position, p1.
4401 ;; So, if you hit '' or `` then you can return to p1.
4403 ;; If repeated command, pop top elt from the ring into mark and
4404 ;; jump there. This forgets the position, p1, and puts M1 back into mark.
4405 ;; Then we save the current pos, which is M0, jump to M1 and pop M2 from
4406 ;; the ring into mark. Push M2 back on the ring and set mark to M0.
4408 (defun viper-cycle-through-mark-ring ()
4409 "Visit previous locations on the mark ring.
4410 One can use \\=`\\=` and \\='\\=' to temporarily jump 1 step back."
4411 (let* ((sv-pt (point)))
4412 ;; if repeated `m,' command, pop the previously saved mark.
4413 ;; Prev saved mark is actually prev saved point. It is used if the
4414 ;; user types `` or '' and is discarded
4415 ;; from the mark ring by the next `m,' command.
4416 ;; In any case, go to the previous or previously saved mark.
4417 ;; Then push the current mark (popped off the ring) and set current
4418 ;; point to be the mark. Current pt as mark is discarded by the next
4420 (if (eq last-command 'viper-cycle-through-mark-ring)
4422 ;; save current mark if the first iteration
4423 (setq mark-ring (delete (viper-mark-marker) mark-ring))
4425 (push-mark (mark t) t)) )
4427 (set-mark-command 1)
4428 ;; don't duplicate mark on the ring
4429 (setq mark-ring (delete (viper-mark-marker) mark-ring))
4431 (viper-deactivate-mark)
4432 (setq this-command 'viper-cycle-through-mark-ring)
4436 (defun viper-goto-mark (arg)
4439 (let ((char (read-char))
4440 (com (viper-getcom arg)))
4441 (viper-goto-mark-subr char com nil)))
4443 (defun viper-goto-mark-and-skip-white (arg)
4444 "Go to mark and skip to first non-white character on line."
4446 (let ((char (read-char))
4447 (com (viper-getCom arg)))
4448 (viper-goto-mark-subr char com t)))
4450 (defun viper-goto-mark-subr (char com skip-white)
4453 (error "Empty buffer")
4455 (cond ((viper-valid-register char '(letter))
4456 (let* ((buff (current-buffer))
4457 (reg (viper-int-to-char (1+ (- char ?a))))
4458 (text-marker (get-register reg)))
4459 ;; If marker points to file that had markers set (and those markers
4460 ;; were saved (as e.g., in session.el), then restore those markers
4461 (if (and (consp text-marker)
4462 (eq (car text-marker) 'file-query)
4463 (or (find-buffer-visiting (nth 1 text-marker))
4464 (y-or-n-p (format "Visit file %s again? "
4465 (nth 1 text-marker)))))
4467 (find-file (nth 1 text-marker))
4468 (when (and (<= (nth 2 text-marker) (point-max))
4469 (<= (point-min) (nth 2 text-marker)))
4470 (setq text-marker (copy-marker (nth 2 text-marker)))
4471 (set-register reg text-marker))))
4472 (if com (viper-move-marker-locally 'viper-com-point (point)))
4473 (if (not (viper-valid-marker text-marker))
4474 (error viper-EmptyTextmarker char))
4475 (if (and (viper-same-line (point) viper-last-jump)
4476 (= (point) viper-last-jump-ignore))
4477 (push-mark viper-last-jump t)
4478 (push-mark nil t)) ; no msg
4479 (viper-register-to-point reg)
4480 (setq viper-last-jump (point-marker))
4482 (back-to-indentation)
4483 (setq viper-last-jump-ignore (point))))
4485 (if (equal buff (current-buffer))
4486 (viper-execute-com (if skip-white
4487 'viper-goto-mark-and-skip-white
4490 (switch-to-buffer buff)
4491 (goto-char viper-com-point)
4492 (viper-change-state-to-vi)
4493 (error "Viper bell")))))
4494 ((and (not skip-white) (viper= char ?`))
4495 (if com (viper-move-marker-locally 'viper-com-point (point)))
4496 (if (and (viper-same-line (point) viper-last-jump)
4497 (= (point) viper-last-jump-ignore))
4498 (goto-char viper-last-jump))
4499 (if (null (mark t)) (error "Mark is not set in this buffer"))
4500 (if (= (point) (mark t)) (pop-mark))
4501 (exchange-point-and-mark)
4502 (setq viper-last-jump (point-marker)
4503 viper-last-jump-ignore 0)
4504 (if com (viper-execute-com 'viper-goto-mark nil com)))
4505 ((and skip-white (viper= char ?'))
4506 (if com (viper-move-marker-locally 'viper-com-point (point)))
4507 (if (and (viper-same-line (point) viper-last-jump)
4508 (= (point) viper-last-jump-ignore))
4509 (goto-char viper-last-jump))
4510 (if (= (point) (mark t)) (pop-mark))
4511 (exchange-point-and-mark)
4512 (setq viper-last-jump (point))
4513 (back-to-indentation)
4514 (setq viper-last-jump-ignore (point))
4515 (if com (viper-execute-com 'viper-goto-mark-and-skip-white nil com)))
4516 (t (error viper-InvalidTextmarker char))))
4518 (defun viper-insert-tab ()
4522 (defun viper-exchange-point-and-mark ()
4524 (exchange-point-and-mark)
4525 (back-to-indentation))
4527 ;; Input Mode Indentation
4529 (define-obsolete-function-alias 'viper-looking-back 'looking-back "24.4")
4532 (defun viper-forward-indent ()
4533 "Indent forward -- `C-t' in Vi."
4536 (indent-to (+ (current-column) viper-shift-width)))
4538 (defun viper-backward-indent ()
4539 "Backtab, `C-d' in Vi."
4542 (let ((p (point)) (c (current-column)) bol (indent t))
4543 (if (looking-back "[0^]" (1- (point)))
4545 (if (eq ?^ (preceding-char))
4546 (setq viper-preserve-indent t))
4550 (setq bol (point-at-bol))
4551 (if (re-search-backward "[^ \t]" bol 1) (forward-char))
4552 (delete-region (point) p)
4554 (indent-to (- c viper-shift-width)))
4555 (if (or (bolp) (looking-back "[^ \t]" (1- (point))))
4556 (setq viper-cted nil)))))
4559 (defun viper-indent-line (col)
4560 (if viper-auto-indent
4563 (if (and viper-electric-mode
4564 (not (memq major-mode '(fundamental-mode
4566 paragraph-indent-text-mode))))
4567 (indent-according-to-mode)
4571 (defun viper-autoindent ()
4572 "Auto Indentation, Vi-style."
4574 (let ((col (current-indentation)))
4575 (if abbrev-mode (expand-abbrev))
4576 (if viper-preserve-indent
4577 (setq viper-preserve-indent nil)
4578 (setq viper-current-indent col))
4579 ;; don't leave whitespace lines around
4580 (if (memq last-command
4582 viper-open-line viper-Open-line
4583 viper-replace-state-exit-cmd))
4584 (indent-to-left-margin))
4585 ;; use \n instead of newline, or else <Return> will move the insert point
4588 (viper-indent-line viper-current-indent)
4592 ;; Viewing registers
4594 (defun viper-ket-function (arg)
4595 "Function called by ], the ket. View registers and call ]]."
4597 (let ((reg (read-char)))
4598 (cond ((viper-valid-register reg '(letter Letter))
4599 (view-register (downcase reg)))
4600 ((viper-valid-register reg '(digit))
4601 (let ((text (current-kill (- reg ?1) 'do-not-rotate)))
4602 (with-output-to-temp-buffer " *viper-info*"
4603 (princ (format "Register %c contains the string:\n" reg))
4607 (viper-next-heading arg))
4609 viper-InvalidRegister reg)))))
4611 (defun viper-brac-function (arg)
4612 "Function called by [, the brac. View textmarkers and call [[."
4614 (let ((reg (read-char)))
4615 (cond ((viper= ?\[ reg)
4616 (viper-prev-heading arg))
4618 (viper-heading-end arg))
4619 ((viper-valid-register reg '(letter))
4620 (let* ((val (get-register (viper-int-to-char (1+ (- reg ?a)))))
4621 (buf (if (not (markerp val))
4622 (error viper-EmptyTextmarker reg)
4623 (marker-buffer val)))
4624 (pos (marker-position val))
4625 line-no text (s pos) (e pos))
4626 (with-output-to-temp-buffer " *viper-info*"
4629 (with-current-buffer buf
4630 (setq line-no (1+ (count-lines (point-min) val)))
4633 (if (re-search-backward "[^ \t]" nil t)
4634 (setq s (point-at-bol)))
4637 (if (re-search-forward "[^ \t]" nil t)
4641 (setq text (buffer-substring s e))
4642 (setq text (format "%s<%c>%s"
4643 (substring text 0 (- pos s))
4644 reg (substring text (- pos s)))))
4647 "Textmarker `%c' is in buffer `%s' at line %d.\n"
4648 reg (buffer-name buf) line-no))
4649 (princ (format "Here is some text around %c:\n\n %s"
4651 (princ (format-message viper-EmptyTextmarker reg))))
4653 (t (error viper-InvalidTextmarker reg)))))
4657 (defun viper-delete-backward-word (arg)
4658 "Delete previous word."
4663 (delete-region (point) (mark t))
4668 ;; Get viper standard value of SYMBOL. If symbol is customized, get its
4669 ;; standard value. Otherwise, get the value saved in the alist STORAGE. If
4670 ;; STORAGE is nil, use viper-saved-user-settings.
4671 (defun viper-standard-value (symbol &optional storage)
4672 (or (eval (car (get symbol 'customized-value)))
4673 (eval (car (get symbol 'saved-value)))
4674 (nth 1 (assoc symbol (or storage viper-saved-user-settings)))))
4678 (defun viper-set-expert-level (&optional dont-change-unless)
4679 "Sets the expert level for a Viper user.
4680 Can be called interactively to change (temporarily or permanently) the
4681 current expert level.
4683 The optional argument DONT-CHANGE-UNLESS, if not nil, says that
4684 the level should not be changed, unless its current value is
4685 meaningless (i.e., not one of 1,2,3,4,5).
4687 User level determines the setting of Viper variables that are most
4688 sensitive for VI-style look-and-feel."
4692 (if (not (natnump viper-expert-level)) (setq viper-expert-level 0))
4694 (save-window-excursion
4695 (delete-other-windows)
4696 ;; if 0 < viper-expert-level < viper-max-expert-level
4697 ;; & dont-change-unless = t -- use it; else ask
4698 (viper-ask-level dont-change-unless))
4700 (setq viper-always t
4701 viper-ex-style-motion t
4702 viper-ex-style-editing t
4703 viper-want-ctl-h-help nil)
4705 (cond ((eq viper-expert-level 1) ; novice or beginner
4706 (global-set-key ; in emacs-state
4708 (if (viper-window-display-p) 'viper-iconify 'suspend-emacs))
4709 (setq viper-no-multiple-ESC t
4711 viper-vi-style-in-minibuffer t
4712 viper-search-wrap-around t
4713 viper-electric-mode nil
4714 viper-want-emacs-keys-in-vi nil
4715 viper-want-emacs-keys-in-insert nil))
4717 ((and (> viper-expert-level 1) (< viper-expert-level 5))
4718 ;; intermediate to guru
4719 (setq viper-no-multiple-ESC (if (viper-window-display-p)
4721 viper-electric-mode t
4722 viper-want-emacs-keys-in-vi t
4723 viper-want-emacs-keys-in-insert (> viper-expert-level 2))
4725 (if (eq viper-expert-level 4) ; respect user's ex-style motion
4726 ; and viper-no-multiple-ESC
4729 viper-ex-style-editing
4730 (viper-standard-value 'viper-ex-style-editing)
4731 viper-ex-style-motion
4732 (viper-standard-value 'viper-ex-style-motion))
4733 (setq viper-ex-style-motion
4734 (viper-standard-value 'viper-ex-style-motion)
4735 viper-ex-style-editing
4736 (viper-standard-value 'viper-ex-style-editing)
4738 (viper-standard-value 'viper-re-search)
4739 viper-no-multiple-ESC
4740 (viper-standard-value 'viper-no-multiple-ESC)))))
4743 ;; Ideally, if 5 is selected, a buffer should pop up to let the
4744 ;; user toggle the values of variables.
4745 (t (setq-default viper-ex-style-editing
4746 (viper-standard-value 'viper-ex-style-editing)
4747 viper-ex-style-motion
4748 (viper-standard-value 'viper-ex-style-motion))
4749 (setq viper-want-ctl-h-help
4750 (viper-standard-value 'viper-want-ctl-h-help)
4752 (viper-standard-value 'viper-always)
4753 viper-no-multiple-ESC
4754 (viper-standard-value 'viper-no-multiple-ESC)
4755 viper-ex-style-motion
4756 (viper-standard-value 'viper-ex-style-motion)
4757 viper-ex-style-editing
4758 (viper-standard-value 'viper-ex-style-editing)
4760 (viper-standard-value 'viper-re-search)
4762 (viper-standard-value 'viper-electric-mode)
4763 viper-want-emacs-keys-in-vi
4764 (viper-standard-value 'viper-want-emacs-keys-in-vi)
4765 viper-want-emacs-keys-in-insert
4766 (viper-standard-value 'viper-want-emacs-keys-in-insert))))
4768 (viper-set-mode-vars-for viper-current-state)
4769 (if (or viper-always
4770 (and (> viper-expert-level 0) (> 5 viper-expert-level)))
4774 ;; Ask user expert level.
4775 (defun viper-ask-level (dont-change-unless)
4776 (let ((ask-buffer " *viper-ask-level*")
4777 level-changed repeated)
4778 (save-window-excursion
4779 (switch-to-buffer ask-buffer)
4781 (while (or (> viper-expert-level viper-max-expert-level)
4782 (< viper-expert-level 1)
4783 (null dont-change-unless))
4787 (message "Invalid user level")
4790 (setq dont-change-unless t
4792 (insert (substitute-command-keys "
4793 Please specify your level of familiarity with the venomous VI PERil
4794 \(and the VI Plan for Emacs Rescue).
4795 You can change it at any time by typing `\\[viper-set-expert-level]'
4797 1 -- BEGINNER: Almost all Emacs features are suppressed.
4798 Feels almost like straight Vi. File name completion and
4799 command history in the minibuffer are thrown in as a bonus.
4800 To use Emacs productively, you must reach level 3 or higher.
4801 2 -- MASTER: C-c now has its standard Emacs meaning in Vi command state,
4802 so most Emacs commands can be used when Viper is in Vi state.
4803 Good progress---you are well on the way to level 3!
4804 3 -- GRAND MASTER: Like 2, but most Emacs commands are available also
4805 in Viper's insert state.
4806 4 -- GURU: Like 3, but user settings are respected for viper-no-multiple-ESC,
4807 viper-ex-style-motion, viper-ex-style-editing, and
4808 viper-re-search variables. Adjust these settings to your taste.
4809 5 -- WIZARD: Like 4, but user settings are also respected for viper-always,
4810 viper-electric-mode, viper-want-ctl-h-help, viper-want-emacs-keys-in-vi,
4811 and viper-want-emacs-keys-in-insert. Adjust these to your taste.
4813 Please, specify your level now: "))
4815 (setq viper-expert-level (- (viper-read-char-exclusive) ?0))
4818 ;; tell the user if level was changed
4822 (format "\n\n\n\n\n\t\tYou have selected user level %d"
4823 viper-expert-level))
4824 (if (y-or-n-p "Do you wish to make this change permanent? ")
4825 ;; save the setting for viper-expert-level
4828 (format "Saving user level %d ..." viper-expert-level)
4829 viper-custom-file-name))
4831 (bury-buffer) ; remove ask-buffer from screen
4841 ;; FIXME Use register-read-with-preview?
4842 ;; if ENFORCE-BUFFER is not nil, error if CHAR is a marker in another buffer
4843 (defun viper-register-to-point (char &optional enforce-buffer)
4844 "Like `jump-to-register', but switches to another buffer in another window."
4845 (interactive "cViper register to point: ")
4846 (let ((val (get-register char)))
4848 ((and (fboundp 'frame-configuration-p)
4849 (frame-configuration-p val))
4850 (set-frame-configuration val))
4851 ((window-configuration-p val)
4852 (set-window-configuration val))
4853 ((viper-valid-marker val)
4854 (if (and enforce-buffer
4855 (not (equal (current-buffer) (marker-buffer val))))
4856 (error (concat viper-EmptyTextmarker " in this buffer")
4857 (viper-int-to-char (1- (+ char ?a)))))
4858 (pop-to-buffer (marker-buffer val))
4860 ((and (consp val) (eq (car val) 'file))
4861 (find-file (cdr val)))
4863 (error viper-EmptyTextmarker (viper-int-to-char (1- (+ char ?a))))))))
4866 (defun viper-save-kill-buffer ()
4867 "Save then kill current buffer."
4869 (if (< viper-expert-level 2)
4870 (save-buffers-kill-emacs)
4871 (if (buffer-modified-p) (save-buffer))
4872 (kill-buffer (current-buffer))))
4878 (defvar reporter-prompt-for-summary-p)
4880 (defun viper-submit-report ()
4881 "Submit bug report on Viper."
4883 (defvar viper-device-type)
4884 (defvar viper-color-display-p)
4885 (defvar viper-frame-parameters)
4886 (defvar viper-minibuffer-emacs-face)
4887 (defvar viper-minibuffer-vi-face)
4888 (defvar viper-minibuffer-insert-face)
4889 (let ((reporter-prompt-for-summary-p t)
4890 (viper-device-type (viper-device-type))
4891 (viper-color-display-p (if (viper-window-display-p)
4892 (viper-color-display-p)
4894 (viper-frame-parameters (if (fboundp 'frame-parameters)
4895 (frame-parameters (selected-frame))))
4896 (viper-minibuffer-emacs-face (if (viper-has-face-support-p)
4898 viper-minibuffer-emacs-face)
4900 (viper-minibuffer-vi-face (if (viper-has-face-support-p)
4901 (viper-get-face viper-minibuffer-vi-face)
4903 (viper-minibuffer-insert-face (if (viper-has-face-support-p)
4905 viper-minibuffer-insert-face)
4907 varlist salutation window-config)
4909 (setq varlist (list 'viper-vi-minibuffer-minor-mode
4910 'viper-insert-minibuffer-minor-mode
4911 'viper-vi-intercept-minor-mode
4912 'viper-vi-local-user-minor-mode
4913 'viper-vi-kbd-minor-mode
4914 'viper-vi-global-user-minor-mode
4915 'viper-vi-state-modifier-minor-mode
4916 'viper-vi-diehard-minor-mode
4917 'viper-vi-basic-minor-mode
4918 'viper-replace-minor-mode
4919 'viper-insert-intercept-minor-mode
4920 'viper-insert-local-user-minor-mode
4921 'viper-insert-kbd-minor-mode
4922 'viper-insert-global-user-minor-mode
4923 'viper-insert-state-modifier-minor-mode
4924 'viper-insert-diehard-minor-mode
4925 'viper-insert-basic-minor-mode
4926 'viper-emacs-intercept-minor-mode
4927 'viper-emacs-local-user-minor-mode
4928 'viper-emacs-kbd-minor-mode
4929 'viper-emacs-global-user-minor-mode
4930 'viper-emacs-state-modifier-minor-mode
4931 'viper-automatic-iso-accents
4932 'viper-special-input-method
4933 'viper-want-emacs-keys-in-insert
4934 'viper-want-emacs-keys-in-vi
4935 'viper-keep-point-on-undo
4936 'viper-no-multiple-ESC
4937 'viper-electric-mode
4939 'viper-want-ctl-h-help
4940 'viper-ex-style-editing
4941 'viper-delete-backwards-in-replace
4942 'viper-vi-style-in-minibuffer
4943 'viper-vi-state-hook
4944 'viper-insert-state-hook
4945 'viper-replace-state-hook
4946 'viper-emacs-state-hook
4947 'ex-cycle-other-window
4948 'ex-cycle-through-non-files
4952 'viper-color-display-p
4953 'viper-frame-parameters
4954 'viper-minibuffer-vi-face
4955 'viper-minibuffer-insert-face
4956 'viper-minibuffer-emacs-face
4959 Congratulations! You may have unearthed a bug in Viper!
4960 Please mail a concise, accurate summary of the problem to the address above.
4962 -------------------------------------------------------------------")
4963 (setq window-config (current-window-configuration))
4964 (with-output-to-temp-buffer " *viper-info*"
4965 (switch-to-buffer " *viper-info*")
4966 (delete-other-windows)
4968 PLEASE FOLLOW THESE PROCEDURES
4969 ------------------------------
4971 Before reporting a bug, please verify that it is related to Viper, and is
4972 not caused by other packages you are using.
4974 Don't report compilation warnings, unless you are certain that there is a
4975 problem. These warnings are normal and unavoidable.
4977 Please note that users should not modify variables and keymaps other than
4978 those advertised in the manual. Such `customization' is likely to crash
4979 Viper, as it would any other improperly customized Emacs package.
4981 If you are reporting an error message received while executing one of the
4982 Viper commands, type:
4984 M-x set-variable <Return> debug-on-error <Return> t <Return>
4986 Then reproduce the error. The above command will cause Emacs to produce a
4987 back trace of the execution that leads to the error. Please include this
4988 trace in your bug report.
4990 If you believe that one of Viper's commands goes into an infinite loop
4991 \(e.g., Emacs freezes), type:
4993 M-x set-variable <Return> debug-on-quit <Return> t <Return>
4995 Then reproduce the problem. Wait for a few seconds, then type C-g to abort
4996 the current command. Include the resulting back trace in the bug report.
4998 Mail anyway (y or n)? ")
4999 (if (y-or-n-p "Mail anyway? ")
5001 (set-window-configuration window-config)
5002 (error "Bug report aborted")))
5005 (set-window-configuration window-config)
5007 (reporter-submit-bug-report
5008 "kifer@cs.stonybrook.edu, bug-gnu-emacs@gnu.org"
5011 nil 'delete-other-windows
5017 ;;; viper-cmd.el ends here