1 ;;; viper-cmd.el --- Vi command support for Viper
2 ;; Copyright (C) 1997 Free Software Foundation, Inc.
4 ;; This file is part of GNU Emacs.
6 ;; GNU Emacs is free software; you can redistribute it and/or modify
7 ;; it under the terms of the GNU General Public License as published by
8 ;; the Free Software Foundation; either version 2, or (at your option)
11 ;; GNU Emacs is distributed in the hope that it will be useful,
12 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
13 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 ;; GNU General Public License for more details.
16 ;; You should have received a copy of the GNU General Public License
17 ;; along with GNU Emacs; see the file COPYING. If not, write to the
18 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 ;; Boston, MA 02111-1307, USA.
27 (defvar viper-minibuffer-current-face
)
28 (defvar viper-minibuffer-insert-face
)
29 (defvar viper-minibuffer-vi-face
)
30 (defvar viper-minibuffer-emacs-face
)
32 (defvar viper-mode-string
)
33 (defvar viper-custom-file-name
)
34 (defvar iso-accents-mode
)
36 (defvar quail-current-str
)
37 (defvar zmacs-region-stays
)
38 (defvar mark-even-if-inactive
)
40 ;; loading happens only in non-interactive compilation
41 ;; in order to spare non-viperized emacs from being viperized
44 (let ((load-path (cons (expand-file-name ".") load-path
)))
45 (or (featurep 'viper-util
)
46 (load "viper-util.el" nil nil
'nosuffix
))
47 (or (featurep 'viper-keym
)
48 (load "viper-keym.el" nil nil
'nosuffix
))
49 (or (featurep 'viper-mous
)
50 (load "viper-mous.el" nil nil
'nosuffix
))
51 (or (featurep 'viper-macs
)
52 (load "viper-macs.el" nil nil
'nosuffix
))
53 (or (featurep 'viper-ex
)
54 (load "viper-ex.el" nil nil
'nosuffix
))
69 ;; These test functions are shamelessly lifted from vip 4.4.2 by Aamod Sane
71 ;; generate test functions
72 ;; given symbol foo, foo-p is the test function, foos is the set of
74 ;; (macroexpand '(viper-test-com-defun foo))
75 ;; (defun foo-p (com) (consp (memq (if (< com 0) (- com) com) foos)))
77 (defmacro viper-test-com-defun
(name)
78 (let* ((snm (symbol-name name
))
79 (nm-p (intern (concat snm
"-p")))
80 (nms (intern (concat snm
"s"))))
82 (consp (memq (if (and (viper-characterp com
) (< com
0))
83 (- com
) com
) ,nms
)))))
85 ;; Variables for defining VI commands
87 ;; Modifying commands that can be prefixes to movement commands
88 (defconst viper-prefix-commands
'(?c ?d ?y ?
! ?
= ?
# ?
< ?
> ?
\"))
89 ;; define viper-prefix-command-p
90 (viper-test-com-defun viper-prefix-command)
92 ;; Commands that are pairs eg. dd. r and R here are a hack
93 (defconst viper-charpair-commands
'(?c ?d ?y ?
! ?
= ?
< ?
> ?r ?R
))
94 ;; define viper-charpair-command-p
95 (viper-test-com-defun viper-charpair-command)
97 (defconst viper-movement-commands
'(?b ?B ?e ?E ?f ?F ?G ?h ?H ?j ?k ?l
98 ?H ?M ?L ?n ?t ?T ?w ?W ?$ ?%
99 ?^ ?
( ?
) ?- ?
+ ?| ?
{ ?
} ?
[ ?
] ?
' ?
`
100 ?\
; ?, ?0 ?? ?/ ?\ ?\C-m
105 ;; define viper-movement-command-p
106 (viper-test-com-defun viper-movement-command)
109 (defconst viper-digit-commands
'(?
1 ?
2 ?
3 ?
4 ?
5 ?
6 ?
7 ?
8 ?
9))
111 ;; define viper-digit-command-p
112 (viper-test-com-defun viper-digit-command)
114 ;; Commands that can be repeated by . (dotted)
115 (defconst viper-dotable-commands
'(?c ?d ?C ?s ?S ?D ?
> ?
<))
116 ;; define viper-dotable-command-p
117 (viper-test-com-defun viper-dotable-command)
119 ;; Commands that can follow a #
120 (defconst viper-hash-commands
'(?c ?C ?g ?q ?s
))
121 ;; define viper-hash-command-p
122 (viper-test-com-defun viper-hash-command)
124 ;; Commands that may have registers as prefix
125 (defconst viper-regsuffix-commands
'(?d ?y ?Y ?D ?p ?P ?x ?X
))
126 ;; define viper-regsuffix-command-p
127 (viper-test-com-defun viper-regsuffix-command)
129 (defconst viper-vi-commands
(append viper-movement-commands
131 viper-dotable-commands
132 viper-charpair-commands
134 viper-prefix-commands
135 viper-regsuffix-commands
)
136 "The list of all commands in Vi-state.")
137 ;; define viper-vi-command-p
138 (viper-test-com-defun viper-vi-command)
140 ;; Where viper saves mark. This mark is resurrected by m^
141 (defvar viper-saved-mark nil
)
149 ;; Runs viper-after-change-functions inside after-change-functions
150 (defun viper-after-change-sentinel (beg end len
)
151 (run-hook-with-args 'viper-after-change-functions beg end len
))
153 ;; Runs viper-before-change-functions inside before-change-functions
154 (defun viper-before-change-sentinel (beg end
)
155 (run-hook-with-args 'viper-before-change-functions beg end
))
157 (defsubst viper-post-command-sentinel
()
158 (run-hooks 'viper-post-command-hooks
)
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 ((has-saved-cursor-color-in-insert-mode
178 (stringp (viper-get-saved-cursor-color-in-insert-mode))))
179 (or has-saved-cursor-color-in-insert-mode
180 (string= (viper-get-cursor-color) viper-insert-state-cursor-color
)
181 ;; save current color, if not already saved
182 (viper-save-cursor-color 'before-insert-mode
))
183 ;; set insert mode cursor color
184 (viper-change-cursor-color viper-insert-state-cursor-color
)))
186 (if (and (memq this-command
'(dabbrev-expand hippie-expand
))
187 (integerp viper-pre-command-point
)
188 (markerp viper-insert-point
)
189 (marker-position viper-insert-point
)
190 (> viper-insert-point viper-pre-command-point
))
191 (viper-move-marker-locally viper-insert-point viper-pre-command-point
))
194 (defsubst viper-insert-state-pre-command-sentinel
()
195 (or (memq this-command
'(self-insert-command))
196 (memq (viper-event-key last-command-event
)
197 '(up down left right
(meta f
) (meta b
)
198 (control n
) (control p
) (control f
) (control b
)))
199 (viper-restore-cursor-color 'after-insert-mode
))
200 (if (and (memq this-command
'(dabbrev-expand hippie-expand
))
201 (markerp viper-insert-point
)
202 (marker-position viper-insert-point
))
203 (setq viper-pre-command-point
(marker-position viper-insert-point
))))
205 (defsubst viper-R-state-post-command-sentinel
()
206 ;; Restoring cursor color is needed despite
207 ;; viper-replace-state-pre-command-sentinel: When you jump to another buffer
208 ;; in another frame, the pre-command hook won't change cursor color to
209 ;; default in that other frame. So, if the second frame cursor was red and
210 ;; we set the point outside the replacement region, then the cursor color
211 ;; will remain red. Restoring the default, below, prevents this.
212 (if (and (<= (viper-replace-start) (point))
213 (<= (point) (viper-replace-end)))
214 (viper-change-cursor-color viper-replace-overlay-cursor-color
)
215 (viper-restore-cursor-color 'after-replace-mode
)
218 ;; to speed up, don't change cursor color before self-insert
219 ;; and common move commands
220 (defsubst viper-replace-state-pre-command-sentinel
()
221 (or (memq this-command
'(self-insert-command))
222 (memq (viper-event-key last-command-event
)
223 '(up down left right
(meta f
) (meta b
)
224 (control n
) (control p
) (control f
) (control b
)))
225 (viper-restore-cursor-color 'after-replace-mode
)))
228 ;; Make sure we don't delete more than needed.
229 ;; This is executed at viper-last-posn-in-replace-region
230 (defsubst viper-trim-replace-chars-to-delete-if-necessary
()
231 (setq viper-replace-chars-to-delete
233 (min viper-replace-chars-to-delete
234 ;; Don't delete more than to the end of repl overlay
235 (viper-chars-in-region
236 (viper-replace-end) viper-last-posn-in-replace-region
)
237 ;; point is viper-last-posn-in-replace-region now
238 ;; So, this limits deletion to the end of line
239 (viper-chars-in-region (point) (viper-line-pos 'end
))
243 (defun viper-replace-state-post-command-sentinel ()
244 ;; Restoring cursor color is needed despite
245 ;; viper-replace-state-pre-command-sentinel: When one jumps to another buffer
246 ;; in another frame, the pre-command hook won't change cursor color to
247 ;; default in that other frame. So, if the second frame cursor was red and
248 ;; we set the point outside the replacement region, then the cursor color
249 ;; will remain red. Restoring the default, below, fixes this problem.
251 ;; We optimize for self-insert-command's here, since they either don't change
252 ;; cursor color or, if they terminate replace mode, the color will be changed
253 ;; in viper-finish-change
254 (or (memq this-command
'(self-insert-command))
255 (viper-restore-cursor-color 'after-replace-mode
))
257 ((eq viper-current-state
'replace-state
)
258 ;; delete characters to compensate for inserted chars.
259 (let ((replace-boundary (viper-replace-end)))
261 (goto-char viper-last-posn-in-replace-region
)
262 (viper-trim-replace-chars-to-delete-if-necessary)
263 (delete-char viper-replace-chars-to-delete
)
264 (setq viper-replace-chars-to-delete
0)
265 ;; terminate replace mode if reached replace limit
266 (if (= viper-last-posn-in-replace-region
(viper-replace-end))
267 (viper-finish-change)))
269 (if (viper-pos-within-region
270 (point) (viper-replace-start) replace-boundary
)
272 ;; the state may have changed in viper-finish-change above
273 (if (eq viper-current-state
'replace-state
)
274 (viper-change-cursor-color viper-replace-overlay-cursor-color
))
275 (setq viper-last-posn-in-replace-region
(point-marker))))
277 ;; terminate replace mode if changed Viper states.
278 (t (viper-finish-change))))
283 ;; Change state to NEW-STATE---either emacs-state, vi-state, or insert-state.
284 (defun viper-change-state (new-state)
285 ;; Keep viper-post/pre-command-hooks fresh.
286 ;; We remove then add viper-post/pre-command-sentinel since it is very
287 ;; desirable that viper-pre-command-sentinel is the last hook and
288 ;; viper-post-command-sentinel is the first hook.
290 (make-local-hook 'viper-after-change-functions
)
291 (make-local-hook 'viper-before-change-functions
)
292 (make-local-hook 'viper-post-command-hooks
)
293 (make-local-hook 'viper-pre-command-hooks
)
295 (remove-hook 'post-command-hook
'viper-post-command-sentinel
)
296 (add-hook 'post-command-hook
'viper-post-command-sentinel
)
297 (remove-hook 'pre-command-hook
'viper-pre-command-sentinel
)
298 (add-hook 'pre-command-hook
'viper-pre-command-sentinel t
)
299 ;; These hooks will be added back if switching to insert/replace mode
300 (remove-hook 'viper-post-command-hooks
301 'viper-insert-state-post-command-sentinel
'local
)
302 (remove-hook 'viper-pre-command-hooks
303 'viper-insert-state-pre-command-sentinel
'local
)
304 (setq viper-intermediate-command nil
)
305 (cond ((eq new-state
'vi-state
)
306 (cond ((member viper-current-state
'(insert-state replace-state
))
308 ;; move viper-last-posn-while-in-insert-state
309 ;; This is a normal hook that is executed in insert/replace
310 ;; states after each command. In Vi/Emacs state, it does
311 ;; nothing. We need to execute it here to make sure that
312 ;; the last posn was recorded when we hit ESC.
313 ;; It may be left unrecorded if the last thing done in
314 ;; insert/repl state was dabbrev-expansion or abbrev
315 ;; expansion caused by hitting ESC
316 (viper-insert-state-post-command-sentinel)
318 (condition-case conds
320 (viper-save-last-insertion
322 viper-last-posn-while-in-insert-state
)
323 (if viper-began-as-replace
324 (setq viper-began-as-replace nil
)
325 ;; repeat insert commands if numerical arg > 1
327 (viper-repeat-insert-command))))
329 (viper-message-conditions conds
)))
331 (if (> (length viper-last-insertion
) 0)
332 (viper-push-onto-ring viper-last-insertion
333 'viper-insertion-ring
))
335 (if viper-ESC-moves-cursor-back
336 (or (bolp) (backward-char 1))))
340 ((memq new-state
'(insert-state replace-state
))
341 (if (memq viper-current-state
'(emacs-state vi-state
))
342 (viper-move-marker-locally 'viper-insert-point
(point)))
343 (viper-move-marker-locally
344 'viper-last-posn-while-in-insert-state
(point))
345 (add-hook 'viper-post-command-hooks
346 'viper-insert-state-post-command-sentinel t
'local
)
347 (add-hook 'viper-pre-command-hooks
348 'viper-insert-state-pre-command-sentinel t
'local
))
351 ;; Nothing needs to be done to switch to emacs mode! Just set some
352 ;; variables, which is already done in viper-change-state-to-emacs!
355 ;; always turn off iso-accents-mode in vi-state, or else we won't be able to
356 ;; use the keys `,',^ , as they will do accents instead of Vi actions.
357 (cond ((eq new-state
'vi-state
) (viper-set-iso-accents-mode nil
));accents off
358 (viper-automatic-iso-accents (viper-set-iso-accents-mode t
));accents on
359 (t (viper-set-iso-accents-mode nil
)))
360 ;; Always turn off quail mode in vi state
361 (cond ((eq new-state
'vi-state
) (viper-set-input-method nil
)) ;intl input off
362 (viper-special-input-method (viper-set-input-method t
)) ;intl input on
363 (t (viper-set-input-method nil
)))
365 (setq viper-current-state new-state
)
367 (viper-update-syntax-classes)
368 (viper-normalize-minor-mode-map-alist)
369 (viper-adjust-keys-for new-state
)
370 (viper-set-mode-vars-for new-state
)
371 (viper-refresh-mode-line)
376 (defun viper-adjust-keys-for (state)
377 "Make necessary adjustments to keymaps before entering STATE."
378 (cond ((memq state
'(insert-state replace-state
))
379 (if viper-auto-indent
381 (define-key viper-insert-basic-map
"\C-m" 'viper-autoindent
)
382 (if viper-want-emacs-keys-in-insert
384 (define-key viper-insert-basic-map
"\C-j" nil
)
386 (define-key viper-insert-basic-map
"\C-j" 'viper-autoindent
)))
387 (define-key viper-insert-basic-map
"\C-m" nil
)
388 (define-key viper-insert-basic-map
"\C-j" nil
))
390 (setq viper-insert-diehard-minor-mode
391 (not viper-want-emacs-keys-in-insert
))
393 (if viper-want-ctl-h-help
395 (define-key viper-insert-basic-map
"\C-h" 'help-command
)
396 (define-key viper-replace-map
"\C-h" 'help-command
))
397 (define-key viper-insert-basic-map
398 "\C-h" 'viper-del-backward-char-in-insert
)
399 (define-key viper-replace-map
400 "\C-h" 'viper-del-backward-char-in-replace
))
401 ;; In XEmacs, C-h overrides backspace, so we make sure it doesn't.
402 (define-key viper-insert-basic-map
403 [backspace] 'viper-del-backward-char-in-insert)
404 (define-key viper-replace-map
405 [backspace] 'viper-del-backward-char-in-replace
)
406 ) ; end insert/replace case
408 (setq viper-vi-diehard-minor-mode
(not viper-want-emacs-keys-in-vi
))
409 (if viper-want-ctl-h-help
410 (define-key viper-vi-basic-map
"\C-h" 'help-command
)
411 (define-key viper-vi-basic-map
"\C-h" 'viper-backward-char
))
412 ;; In XEmacs, C-h overrides backspace, so we make sure it doesn't.
413 (define-key viper-vi-basic-map
[backspace] 'viper-backward-char))
417 ;; Normalizes minor-mode-map-alist by putting Viper keymaps first.
418 ;; This ensures that Viper bindings are in effect, regardless of which minor
419 ;; modes were turned on by the user or by other packages.
420 (defun viper-normalize-minor-mode-map-alist ()
421 (setq minor-mode-map-alist
422 (viper-append-filter-alist
423 (list (cons 'viper-vi-intercept-minor-mode viper-vi-intercept-map)
424 (cons 'viper-vi-minibuffer-minor-mode viper-minibuffer-map)
425 (cons 'viper-vi-local-user-minor-mode viper-vi-local-user-map)
426 (cons 'viper-vi-kbd-minor-mode viper-vi-kbd-map)
427 (cons 'viper-vi-global-user-minor-mode viper-vi-global-user-map)
428 (cons 'viper-vi-state-modifier-minor-mode
430 (cdr (assoc major-mode
431 viper-vi-state-modifier-alist)))
432 (cdr (assoc major-mode viper-vi-state-modifier-alist))
434 (cons 'viper-vi-diehard-minor-mode viper-vi-diehard-map)
435 (cons 'viper-vi-basic-minor-mode viper-vi-basic-map)
436 (cons 'viper-insert-intercept-minor-mode
437 viper-insert-intercept-map)
438 (cons 'viper-replace-minor-mode viper-replace-map)
439 ;; viper-insert-minibuffer-minor-mode must come after
440 ;; viper-replace-minor-mode
441 (cons 'viper-insert-minibuffer-minor-mode
442 viper-minibuffer-map)
443 (cons 'viper-insert-local-user-minor-mode
444 viper-insert-local-user-map)
445 (cons 'viper-insert-kbd-minor-mode viper-insert-kbd-map)
446 (cons 'viper-insert-global-user-minor-mode
447 viper-insert-global-user-map)
448 (cons 'viper-insert-state-modifier-minor-mode
450 (cdr (assoc major-mode
451 viper-insert-state-modifier-alist)))
452 (cdr (assoc major-mode
453 viper-insert-state-modifier-alist))
455 (cons 'viper-insert-diehard-minor-mode viper-insert-diehard-map)
456 (cons 'viper-insert-basic-minor-mode viper-insert-basic-map)
457 (cons 'viper-emacs-intercept-minor-mode
458 viper-emacs-intercept-map)
459 (cons 'viper-emacs-local-user-minor-mode
460 viper-emacs-local-user-map)
461 (cons 'viper-emacs-kbd-minor-mode viper-emacs-kbd-map)
462 (cons 'viper-emacs-global-user-minor-mode
463 viper-emacs-global-user-map)
464 (cons 'viper-emacs-state-modifier-minor-mode
467 (assoc major-mode viper-emacs-state-modifier-alist)))
469 (assoc major-mode viper-emacs-state-modifier-alist))
472 minor-mode-map-alist)))
476 ;; Viper mode-changing commands and utilities
478 ;; Modifies mode-line-buffer-identification.
479 (defun viper-refresh-mode-line ()
480 (setq viper-mode-string
481 (cond ((eq viper-current-state 'emacs-state) viper-emacs-state-id)
482 ((eq viper-current-state 'vi-state) viper-vi-state-id)
483 ((eq viper-current-state 'replace-state) viper-replace-state-id)
484 ((eq viper-current-state 'insert-state) viper-insert-state-id)))
486 ;; Sets Viper mode string in global-mode-string
487 (force-mode-line-update))
490 ;; Switch from Insert state to Vi state.
491 (defun viper-exit-insert-state ()
493 (viper-change-state-to-vi))
495 (defun viper-set-mode-vars-for (state)
496 "Sets Viper minor mode variables to put Viper's state STATE in effect."
499 (setq viper-vi-minibuffer-minor-mode nil
500 viper-insert-minibuffer-minor-mode nil
501 viper-vi-intercept-minor-mode nil
502 viper-insert-intercept-minor-mode nil
504 viper-vi-local-user-minor-mode nil
505 viper-vi-kbd-minor-mode nil
506 viper-vi-global-user-minor-mode nil
507 viper-vi-state-modifier-minor-mode nil
508 viper-vi-diehard-minor-mode nil
509 viper-vi-basic-minor-mode nil
511 viper-replace-minor-mode nil
513 viper-insert-local-user-minor-mode nil
514 viper-insert-kbd-minor-mode nil
515 viper-insert-global-user-minor-mode nil
516 viper-insert-state-modifier-minor-mode nil
517 viper-insert-diehard-minor-mode nil
518 viper-insert-basic-minor-mode nil
519 viper-emacs-intercept-minor-mode t
520 viper-emacs-local-user-minor-mode t
521 viper-emacs-kbd-minor-mode (not (viper-is-in-minibuffer))
522 viper-emacs-global-user-minor-mode t
523 viper-emacs-state-modifier-minor-mode t
527 (if (eq state 'vi-state) ; adjust for vi-state
529 viper-vi-intercept-minor-mode t
530 viper-vi-minibuffer-minor-mode (viper-is-in-minibuffer)
531 viper-vi-local-user-minor-mode t
532 viper-vi-kbd-minor-mode (not (viper-is-in-minibuffer))
533 viper-vi-global-user-minor-mode t
534 viper-vi-state-modifier-minor-mode t
535 ;; don't let the diehard keymap block command completion
536 ;; and other things in the minibuffer
537 viper-vi-diehard-minor-mode (not
538 (or viper-want-emacs-keys-in-vi
539 (viper-is-in-minibuffer)))
540 viper-vi-basic-minor-mode t
541 viper-emacs-intercept-minor-mode nil
542 viper-emacs-local-user-minor-mode nil
543 viper-emacs-kbd-minor-mode nil
544 viper-emacs-global-user-minor-mode nil
545 viper-emacs-state-modifier-minor-mode nil
548 ;; Insert and Replace states
549 (if (member state '(insert-state replace-state))
551 viper-insert-intercept-minor-mode t
552 viper-replace-minor-mode (eq state 'replace-state)
553 viper-insert-minibuffer-minor-mode (viper-is-in-minibuffer)
554 viper-insert-local-user-minor-mode t
555 viper-insert-kbd-minor-mode (not (viper-is-in-minibuffer))
556 viper-insert-global-user-minor-mode t
557 viper-insert-state-modifier-minor-mode t
558 ;; don't let the diehard keymap block command completion
559 ;; and other things in the minibuffer
560 viper-insert-diehard-minor-mode (not
562 viper-want-emacs-keys-in-insert
563 (viper-is-in-minibuffer)))
564 viper-insert-basic-minor-mode t
565 viper-emacs-intercept-minor-mode nil
566 viper-emacs-local-user-minor-mode nil
567 viper-emacs-kbd-minor-mode nil
568 viper-emacs-global-user-minor-mode nil
569 viper-emacs-state-modifier-minor-mode nil
573 (if (viper-has-face-support-p)
574 (setq viper-minibuffer-current-face
575 (cond ((eq state 'emacs-state) viper-minibuffer-emacs-face)
576 ((eq state 'vi-state) viper-minibuffer-vi-face)
577 ((memq state '(insert-state replace-state))
578 viper-minibuffer-insert-face))))
580 (if (viper-is-in-minibuffer)
581 (viper-set-minibuffer-overlay))
584 ;; This also takes care of the annoying incomplete lines in files.
585 ;; Also, this fixes `undo' to work vi-style for complex commands.
586 (defun viper-change-state-to-vi ()
587 "Change Viper state to Vi."
589 (if (and viper-first-time (not (viper-is-in-minibuffer)))
591 (if overwrite-mode (overwrite-mode nil))
592 (or (viper-overlay-p viper-replace-overlay)
593 (viper-set-replace-overlay (point-min) (point-min)))
594 (viper-hide-replace-overlay)
595 (if abbrev-mode (expand-abbrev))
596 (if (and auto-fill-function (> (current-column) fill-column))
597 (funcall auto-fill-function))
598 ;; don't leave whitespace lines around
599 (if (and (memq last-command
601 viper-open-line viper-Open-line
602 viper-replace-state-exit-cmd))
603 (viper-over-whitespace-line))
604 (indent-to-left-margin))
605 (viper-add-newline-at-eob-if-necessary)
607 (viper-change-state 'vi-state)
609 (viper-restore-cursor-color 'after-insert-mode)
611 ;; Protect against user errors in hooks
612 (condition-case conds
613 (run-hooks 'viper-vi-state-hook)
615 (viper-message-conditions conds)))))
617 (defun viper-change-state-to-insert ()
618 "Change Viper state to Insert."
620 (viper-change-state 'insert-state)
622 (or (viper-overlay-p viper-replace-overlay)
623 (viper-set-replace-overlay (point-min) (point-min)))
624 (viper-hide-replace-overlay)
626 (let ((has-saved-cursor-color-in-insert-mode
627 (stringp (viper-get-saved-cursor-color-in-insert-mode))))
628 (or has-saved-cursor-color-in-insert-mode
629 (string= (viper-get-cursor-color) viper-insert-state-cursor-color)
630 (viper-save-cursor-color 'before-insert-mode))
631 (viper-change-cursor-color viper-insert-state-cursor-color))
633 ;; Protect against user errors in hooks
634 (condition-case conds
635 (run-hooks 'viper-insert-state-hook)
637 (viper-message-conditions conds))))
639 (defsubst viper-downgrade-to-insert ()
640 (setq viper-current-state 'insert-state
641 viper-replace-minor-mode nil))
645 ;; Change to replace state. When the end of replacement region is reached,
646 ;; replace state changes to insert state.
647 (defun viper-change-state-to-replace (&optional non-R-cmd)
648 (viper-change-state 'replace-state)
649 ;; Run insert-state-hook
650 (condition-case conds
651 (run-hooks 'viper-insert-state-hook 'viper-replace-state-hook)
653 (viper-message-conditions conds)))
656 (viper-start-replace)
657 ;; 'R' is implemented using Emacs's overwrite-mode
658 (viper-start-R-mode))
662 (defun viper-change-state-to-emacs ()
663 "Change Viper state to Emacs."
665 (or (viper-overlay-p viper-replace-overlay)
666 (viper-set-replace-overlay (point-min) (point-min)))
667 (viper-hide-replace-overlay)
668 (viper-change-state 'emacs-state)
670 ;; Protect agains user errors in hooks
671 (condition-case conds
672 (run-hooks 'viper-emacs-state-hook)
674 (viper-message-conditions conds))))
676 ;; escape to emacs mode termporarily
677 (defun viper-escape-to-emacs (arg &optional events)
678 "Escape to Emacs state from Vi state for one Emacs command.
679 ARG is used as the prefix value for the executed command. If
680 EVENTS is a list of events, which become the beginning of the command."
682 (if (= last-command-char ?\\)
683 (message "Switched to EMACS state for the next command..."))
684 (viper-escape-to-state arg events 'emacs-state))
686 ;; escape to Vi mode termporarily
687 (defun viper-escape-to-vi (arg)
688 "Escape from Emacs state to Vi state for one Vi 1-character command.
689 If the Vi command that the user types has a prefix argument, e.g., `d2w', then
690 Vi's prefix argument will be used. Otherwise, the prefix argument passed to
691 `viper-escape-to-vi' is used."
693 (message "Switched to VI state for the next command...")
694 (viper-escape-to-state arg nil 'vi-state))
696 ;; Escape to STATE mode for one Emacs command.
697 (defun viper-escape-to-state (arg events state)
698 ;;(let (com key prefix-arg)
700 ;; this temporarily turns off Viper's minor mode keymaps
701 (viper-set-mode-vars-for state)
702 (viper-normalize-minor-mode-map-alist)
703 (if events (viper-set-unread-command-events events))
705 ;; protect against keyboard quit and other errors
707 (let (viper-vi-kbd-minor-mode
708 viper-insert-kbd-minor-mode
709 viper-emacs-kbd-minor-mode)
712 (setq com (key-binding (setq key
714 (read-key-sequence nil)
715 (read-key-sequence nil t)))))
716 ;; In case of binding indirection--chase definitions.
717 ;; Have to do it here because we execute this command under
718 ;; different keymaps, so command-execute may not do the
720 (while (vectorp com) (setq com (key-binding com))))
722 ;; Execute command com in the original Viper state, not in state
723 ;; `state'. Otherwise, if we switch buffers while executing the
724 ;; escaped to command, Viper's mode vars will remain those of
725 ;; `state'. When we return to the orig buffer, the bindings will be
727 (viper-set-mode-vars-for viper-current-state)
729 ;; this-command, last-command-char, last-command-event
730 (setq this-command com)
731 (if viper-xemacs-p ; XEmacs represents key sequences as vectors
732 (setq last-command-event
733 (viper-copy-event (viper-seq-last-elt key))
734 last-command-char (event-to-character last-command-event))
735 ;; Emacs represents them as sequences (str or vec)
736 (setq last-command-event
737 (viper-copy-event (viper-seq-last-elt key))
738 last-command-char last-command-event))
742 (setq prefix-arg (or prefix-arg arg))
743 (command-execute com)))
747 ;; set state in the new buffer
748 (viper-set-mode-vars-for viper-current-state))
750 (defun viper-exec-form-in-vi (form)
751 "Execute FORM in Vi state, regardless of the Ccurrent Vi state."
752 (let ((buff (current-buffer))
754 (viper-set-mode-vars-for 'vi-state)
757 (let (viper-vi-kbd-minor-mode) ; execute without kbd macros
758 (setq result (eval form))
763 (if (not (equal buff (current-buffer))) ; cmd switched buffer
766 (viper-set-mode-vars-for viper-current-state)))
767 (viper-set-mode-vars-for viper-current-state)
770 (defun viper-exec-form-in-emacs (form)
771 "Execute FORM in Emacs, temporarily disabling Viper's minor modes.
772 Similar to viper-escape-to-emacs, but accepts forms rather than keystrokes."
773 (let ((buff (current-buffer))
775 (viper-set-mode-vars-for 'emacs-state)
776 (setq result (eval form))
777 (if (not (equal buff (current-buffer))) ; cmd switched buffer
780 (viper-set-mode-vars-for viper-current-state)))
781 (viper-set-mode-vars-for viper-current-state)
785 ;; This is needed because minor modes sometimes override essential Viper
786 ;; bindings. By letting Viper know which files these modes are in, it will
787 ;; arrange to reorganize minor-mode-map-alist so that things will work right.
788 (defun viper-harness-minor-mode (load-file)
789 "Familiarize Viper with a minor mode defined in LOAD_FILE.
790 Minor modes that have their own keymaps may overshadow Viper keymaps.
791 This function is designed to make Viper aware of the packages that define
794 (viper-harness-minor-mode load-file)
796 LOAD-FILE is a name of the file where the specific minor mode is defined.
797 Suffixes such as .el or .elc should be stripped."
799 (interactive "sEnter name of the load file: ")
801 (eval-after-load load-file '(viper-normalize-minor-mode-map-alist))
803 ;; Change the default for minor-mode-map-alist each time a harnessed minor
804 ;; mode adds its own keymap to the a-list.
806 load-file '(setq-default minor-mode-map-alist minor-mode-map-alist))
810 (defun viper-ESC (arg)
811 "Emulate ESC key in Emacs.
812 Prevents multiple escape keystrokes if viper-no-multiple-ESC is true.
813 If viper-no-multiple-ESC is 'twice double ESC would ding in vi-state.
814 Other ESC sequences are emulated via the current Emacs's major mode
815 keymap. This is more convenient on TTYs, since this won't block
816 function keys such as up,down, etc. ESC will also will also work as
817 a Meta key in this case. When viper-no-multiple-ESC is nil, ESC functions
818 as a Meta key and any number of multiple escapes is allowed."
821 (cond ((and (not viper-no-multiple-ESC) (eq viper-current-state 'vi-state))
822 (setq char (viper-read-char-exclusive))
823 (viper-escape-to-emacs arg (list ?\e char) ))
824 ((and (eq viper-no-multiple-ESC 'twice)
825 (eq viper-current-state 'vi-state))
826 (setq char (viper-read-char-exclusive))
827 (if (= char (string-to-char viper-ESC-key))
829 (viper-escape-to-emacs arg (list ?\e char) )))
833 (defun viper-alternate-Meta-key (arg)
834 "Simulate Emacs Meta key."
836 (sit-for 1) (message "ESC-")
837 (viper-escape-to-emacs arg '(?\e)))
839 (defun viper-toggle-key-action ()
840 "Action bound to `viper-toggle-key'."
842 (if (and (< viper-expert-level 2) (equal viper-toggle-key "\C-z"))
843 (if (viper-window-display-p)
846 (viper-change-state-to-emacs)))
849 ;; Intercept ESC sequences on dumb terminals.
850 ;; Based on the idea contributed by Marcelino Veiga Tuimil <mveiga@dit.upm.es>
852 ;; Check if last key was ESC and if so try to reread it as a function key.
853 ;; But only if there are characters to read during a very short time.
854 ;; Returns the last event, if any.
855 (defun viper-envelop-ESC-key ()
856 (let ((event last-input-event)
859 (if (viper-ESC-event-p event)
861 (if (viper-fast-keysequence-p)
863 (let (minor-mode-map-alist)
864 (viper-set-unread-command-events event)
867 (ad-get-orig-definition 'read-key-sequence) nil))
869 ;; If keyseq translates into something that still has ESC
870 ;; at the beginning, separate ESC from the rest of the seq.
871 ;; In XEmacs we check for events that are keypress meta-key
872 ;; and convert them into [escape key]
874 ;; This is needed for the following reason:
875 ;; If ESC is the first symbol, we interpret it as if the
876 ;; user typed ESC and then quickly some other symbols.
877 ;; If ESC is not the first one, then the key sequence
878 ;; entered was apparently translated into a function key or
879 ;; something (e.g., one may have
880 ;; (define-key function-key-map "\e[192z" [f11])
881 ;; which would translate the escape-sequence generated by
882 ;; f11 in an xterm window into the symbolic key f11.
884 ;; If `first-key' is not an ESC event, we make it into the
885 ;; last-command-event in order to pretend that this key was
886 ;; pressed. This is needed to allow arrow keys to be bound to
887 ;; macros. Otherwise, viper-exec-mapped-kbd-macro will think
888 ;; that the last event was ESC and so it'll execute whatever is
889 ;; bound to ESC. (Viper macros can't be bound to
891 (let* ((first-key (elt keyseq 0))
892 (key-mod (event-modifiers first-key)))
893 (cond ((and (viper-ESC-event-p first-key)
894 (not viper-translate-all-ESC-keysequences))
895 ;; put keys following ESC on the unread list
896 ;; and return ESC as the key-sequence
897 (viper-set-unread-command-events (subseq keyseq 1))
898 (setq last-input-event event
899 keyseq (if viper-emacs-p
901 (vector (character-to-event ?\e)))))
903 (key-press-event-p first-key)
904 (equal '(meta) key-mod))
905 (viper-set-unread-command-events
907 (character-to-event (event-key first-key)))
909 (setq last-input-event event
910 keyseq (vector (character-to-event ?\e))))
912 (setq last-command-event
913 (viper-copy-event first-key)))
917 ;; this is escape event with nothing after it
918 ;; put in unread-command-event and then re-read
919 (viper-set-unread-command-events event)
921 (funcall (ad-get-orig-definition 'read-key-sequence) nil))
923 ;; not an escape event
924 (setq keyseq (vector event)))
929 ;; Listen to ESC key.
930 ;; If a sequence of keys starting with ESC is issued with very short delays,
931 ;; interpret these keys in Emacs mode, so ESC won't be interpreted as a Vi key.
932 (defun viper-intercept-ESC-key ()
933 "Function that implements ESC key in Viper emulation of Vi."
935 (let ((cmd (or (key-binding (viper-envelop-ESC-key))
936 '(lambda () (interactive) (error "")))))
938 ;; call the actual function to execute ESC (if no other symbols followed)
939 ;; or the key bound to the ESC sequence (if the sequence was issued
940 ;; with very short delay between characters.
941 (if (eq cmd 'viper-intercept-ESC-key)
943 (cond ((eq viper-current-state 'vi-state)
945 ((eq viper-current-state 'insert-state)
946 'viper-exit-insert-state)
947 ((eq viper-current-state 'replace-state)
948 'viper-replace-state-exit-cmd)
949 (t 'viper-change-state-to-vi)
951 (call-interactively cmd)))
956 ;; prefix argument for Vi mode
958 ;; In Vi mode, prefix argument is a dotted pair (NUM . COM) where NUM
959 ;; represents the numeric value of the prefix argument and COM represents
960 ;; command prefix such as "c", "d", "m" and "y".
962 ;; Get value part of prefix-argument ARG.
963 (defsubst viper-p-val (arg)
966 (if (or (null (car arg)) (equal (car arg) '(nil)))
970 ;; Get raw value part of prefix-argument ARG.
971 (defsubst viper-P-val (arg)
972 (cond ((consp arg) (car arg))
975 ;; Get com part of prefix-argument ARG.
976 (defsubst viper-getcom (arg)
977 (cond ((null arg) nil)
978 ((consp arg) (cdr arg))
981 ;; Get com part of prefix-argument ARG and modify it.
982 (defun viper-getCom (arg)
983 (let ((com (viper-getcom arg)))
984 (cond ((equal com ?c) ?c)
985 ;; Previously, ?c was being converted to ?C, but this prevented
986 ;; multiline replace regions.
987 ;;((equal com ?c) ?C)
993 ;; Compute numeric prefix arg value.
994 ;; Invoked by EVENT. COM is the command part obtained so far.
995 (defun viper-prefix-arg-value (event-char com)
996 (let ((viper-intermediate-command 'viper-digit-argument)
999 (while (and (viper-characterp event-char)
1000 (>= event-char ?0) (<= event-char ?9))
1001 (setq value (+ (* (if (integerp value) value 0) 10) (- event-char ?0)))
1002 (setq event-char (viper-read-event-convert-to-char)))
1004 (setq prefix-arg value)
1005 (if com (setq prefix-arg (cons prefix-arg com)))
1006 (while (eq event-char ?U)
1007 (viper-describe-arg prefix-arg)
1008 (setq event-char (viper-read-event-convert-to-char)))
1010 (if (or com (and (not (eq viper-current-state 'vi-state))
1011 ;; make sure it is a Vi command
1012 (viper-characterp event-char)
1013 (viper-vi-command-p event-char)
1015 ;; If appears to be one of the vi commands,
1016 ;; then execute it with funcall and clear prefix-arg in order to not
1017 ;; confuse subsequent commands
1019 ;; last-command-char is the char we want emacs to think was typed
1020 ;; last. If com is not nil, the viper-digit-argument command was
1021 ;; called from within viper-prefix-arg command, such as `d', `w',
1022 ;; etc., i.e., the user typed, say, d2. In this case, `com' would be
1023 ;; `d', `w', etc. If viper-digit-argument was invoked by
1024 ;; viper-escape-to-vi (which is indicated by the fact that the
1025 ;; current state is not vi-state), then `event-char' represents the
1026 ;; vi command to be executed (e.g., `d', `w', etc). Again,
1027 ;; last-command-char must make emacs believe that this is the command
1029 (cond ((eq event-char 'return) (setq event-char ?\C-m))
1030 ((eq event-char 'delete) (setq event-char ?\C-?))
1031 ((eq event-char 'backspace) (setq event-char ?\C-h))
1032 ((eq event-char 'space) (setq event-char ?\ )))
1033 (setq last-command-char (or com event-char))
1034 (setq func (viper-exec-form-in-vi
1035 `(key-binding (char-to-string ,event-char))))
1036 (funcall func prefix-arg)
1037 (setq prefix-arg nil))
1038 ;; some other command -- let emacs do it in its own way
1039 (viper-set-unread-command-events event-char))
1043 ;; Vi operator as prefix argument."
1044 (defun viper-prefix-arg-com (char value com)
1050 (list ?c ?d ?y ?! ?< ?> ?= ?# ?r ?R ?\"
1051 viper-buffer-search-char)))
1053 ;; this means that we already have a command character, so we
1054 ;; construct a com list and exit while. however, if char is "
1057 ;; new com is (CHAR . OLDCOM)
1058 (if (memq char '(?# ?\")) (error ""))
1059 (setq com (cons char com))
1061 ;; If com is nil we set com as char, and read more. Again, if char is
1062 ;; ", we read the name of register and store it in viper-use-register.
1063 ;; if char is !, =, or #, a complete com is formed so we exit the while
1065 (cond ((memq char '(?! ?=))
1067 (setq char (read-char))
1070 ;; read a char and encode it as com
1071 (setq com (+ 128 (read-char)))
1072 (setq char (read-char)))
1074 (let ((reg (read-char)))
1075 (if (viper-valid-register reg)
1076 (setq viper-use-register reg)
1078 (setq char (read-char))))
1081 (setq char (read-char))))))
1084 ;; `com' is a single char, so we construct the command argument
1085 ;; and if `char' is `?', we describe the arg; otherwise
1086 ;; we prepare the command that will be executed at the end.
1088 (setq cmd-info (cons value com))
1090 (viper-describe-arg cmd-info)
1091 (setq char (read-char)))
1092 ;; `char' is a movement cmd, a digit arg cmd, or a register cmd---so we
1093 ;; execute it at the very end
1094 (or (viper-movement-command-p char)
1095 (viper-digit-command-p char)
1096 (viper-regsuffix-command-p char)
1097 (= char ?!) ; bang command
1099 (setq cmd-to-exec-at-end
1100 (viper-exec-form-in-vi
1101 `(key-binding (char-to-string ,char)))))
1103 ;; as com is non-nil, this means that we have a command to execute
1104 (if (memq (car com) '(?r ?R))
1105 ;; execute apropriate region command.
1106 (let ((char (car com)) (com (cdr com)))
1107 (setq prefix-arg (cons value com))
1108 (if (= char ?r) (viper-region prefix-arg)
1109 (viper-Region prefix-arg))
1111 (setq prefix-arg nil))
1112 ;; otherwise, reset prefix arg and call appropriate command
1113 (setq value (if (null value) 1 value))
1114 (setq prefix-arg nil)
1116 ;; If we change ?C to ?c here, then cc will enter replacement mode
1117 ;; rather than deleting lines. However, it will affect 1 less line than
1118 ;; normal. We decided to not use replacement mode here and follow Vi,
1119 ;; since replacement mode on n full lines can be achieved with nC.
1120 ((equal com '(?c . ?c)) (viper-line (cons value ?C)))
1121 ((equal com '(?d . ?d)) (viper-line (cons value ?D)))
1122 ((equal com '(?d . ?y)) (viper-yank-defun))
1123 ((equal com '(?y . ?y)) (viper-line (cons value ?Y)))
1124 ((equal com '(?< . ?<)) (viper-line (cons value ?<)))
1125 ((equal com '(?> . ?>)) (viper-line (cons value ?>)))
1126 ((equal com '(?! . ?!)) (viper-line (cons value ?!)))
1127 ((equal com '(?= . ?=)) (viper-line (cons value ?=)))
1130 (if cmd-to-exec-at-end
1132 (setq last-command-char char)
1133 (setq last-command-event
1135 (if viper-xemacs-p (character-to-event char) char)))
1137 (funcall cmd-to-exec-at-end cmd-info)
1142 (defun viper-describe-arg (arg)
1144 (setq val (viper-P-val arg)
1145 com (viper-getcom arg))
1148 (message "Value is nil, and command is nil")
1149 (message "Value is nil, and command is `%c'" com))
1151 (message "Value is `%d', and command is nil" val)
1152 (message "Value is `%d', and command is `%c'" val com)))))
1154 (defun viper-digit-argument (arg)
1155 "Begin numeric argument for the next command."
1157 (viper-leave-region-active)
1158 (viper-prefix-arg-value
1159 last-command-char (if (consp arg) (cdr arg) nil)))
1161 (defun viper-command-argument (arg)
1162 "Accept a motion command as an argument."
1164 (let ((viper-intermediate-command 'viper-command-argument))
1166 (viper-prefix-arg-com
1168 (cond ((null arg) nil)
1169 ((consp arg) (car arg))
1170 ((integerp arg) arg)
1171 (t (error viper-InvalidCommandArgument)))
1172 (cond ((null arg) nil)
1173 ((consp arg) (cdr arg))
1174 ((integerp arg) nil)
1175 (t (error viper-InvalidCommandArgument))))
1176 (quit (setq viper-use-register nil)
1177 (signal 'quit nil)))
1178 (viper-deactivate-mark)))
1181 ;; repeat last destructive command
1183 ;; Append region to text in register REG.
1184 ;; START and END are buffer positions indicating what to append.
1185 (defsubst viper-append-to-register (reg start end)
1186 (set-register reg (concat (if (stringp (get-register reg))
1187 (get-register reg) "")
1188 (buffer-substring start end))))
1190 ;; Saves last inserted text for possible use by viper-repeat command.
1191 (defun viper-save-last-insertion (beg end)
1193 (setq viper-last-insertion (buffer-substring beg end))
1195 ;; beg or end marker are somehow screwed up
1196 (setq viper-last-insertion nil)))
1197 (setq viper-last-insertion (buffer-substring beg end))
1198 (or (< (length viper-d-com) 5)
1199 (setcar (nthcdr 4 viper-d-com) viper-last-insertion))
1200 (or (null viper-command-ring)
1201 (ring-empty-p viper-command-ring)
1203 (setcar (nthcdr 4 (viper-current-ring-item viper-command-ring))
1204 viper-last-insertion)
1205 ;; del most recent elt, if identical to the second most-recent
1206 (viper-cleanup-ring viper-command-ring)))
1209 (defsubst viper-yank-last-insertion ()
1210 "Inserts the text saved by the previous viper-save-last-insertion command."
1212 (insert viper-last-insertion)
1216 ;; define functions to be executed
1218 ;; invoked by the `C' command
1219 (defun viper-exec-change (m-com com)
1220 (or (and (markerp viper-com-point) (marker-position viper-com-point))
1221 (set-marker viper-com-point (point) (current-buffer)))
1222 ;; handle C cmd at the eol and at eob.
1223 (if (or (and (eolp) (= viper-com-point (point)))
1224 (= viper-com-point (point-max)))
1226 (insert " ")(backward-char 1)))
1227 (if (= viper-com-point (point))
1228 (viper-forward-char-carefully))
1229 (set-mark viper-com-point)
1230 (if (eq m-com 'viper-next-line-at-bol)
1231 (viper-enlarge-region (mark t) (point)))
1232 (if (< (point) (mark t))
1233 (exchange-point-and-mark))
1234 (if (eq (preceding-char) ?\n)
1235 (viper-backward-char-carefully)) ; give back the newline
1237 (viper-change (mark t) (point))
1238 (viper-change-subr (mark t) (point))))
1240 ;; this is invoked by viper-substitute-line
1241 (defun viper-exec-Change (m-com com)
1243 (set-mark viper-com-point)
1244 (viper-enlarge-region (mark t) (point))
1245 (if viper-use-register
1247 (cond ((viper-valid-register viper-use-register '(letter digit))
1249 viper-use-register (mark t) (point) nil))
1250 ((viper-valid-register viper-use-register '(Letter))
1251 (viper-append-to-register
1252 (downcase viper-use-register) (mark t) (point)))
1253 (t (setq viper-use-register nil)
1254 (error viper-InvalidRegister viper-use-register)))
1255 (setq viper-use-register nil)))
1256 (delete-region (mark t) (point)))
1259 (viper-change-state-to-insert)
1260 (viper-yank-last-insertion)))
1262 (defun viper-exec-delete (m-com com)
1263 (or (and (markerp viper-com-point) (marker-position viper-com-point))
1264 (set-marker viper-com-point (point) (current-buffer)))
1265 (let (chars-deleted)
1266 (if viper-use-register
1268 (cond ((viper-valid-register viper-use-register '(letter digit))
1270 viper-use-register viper-com-point (point) nil))
1271 ((viper-valid-register viper-use-register '(Letter))
1272 (viper-append-to-register
1273 (downcase viper-use-register) viper-com-point (point)))
1274 (t (setq viper-use-register nil)
1275 (error viper-InvalidRegister viper-use-register)))
1276 (setq viper-use-register nil)))
1278 (if (eq last-command 'd-command) 'kill-region nil))
1279 (setq chars-deleted (abs (- (point) viper-com-point)))
1280 (if (> chars-deleted viper-change-notification-threshold)
1281 (message "Deleted %d characters" chars-deleted))
1282 (kill-region viper-com-point (point))
1283 (setq this-command 'd-command)
1284 (if viper-ex-style-motion
1285 (if (and (eolp) (not (bolp))) (backward-char 1)))))
1287 (defun viper-exec-Delete (m-com com)
1289 (set-mark viper-com-point)
1290 (viper-enlarge-region (mark t) (point))
1291 (let (lines-deleted)
1292 (if viper-use-register
1294 (cond ((viper-valid-register viper-use-register '(letter digit))
1296 viper-use-register (mark t) (point) nil))
1297 ((viper-valid-register viper-use-register '(Letter))
1298 (viper-append-to-register
1299 (downcase viper-use-register) (mark t) (point)))
1300 (t (setq viper-use-register nil)
1301 (error viper-InvalidRegister viper-use-register)))
1302 (setq viper-use-register nil)))
1304 (if (eq last-command 'D-command) 'kill-region nil))
1305 (setq lines-deleted (count-lines (point) viper-com-point))
1306 (if (> lines-deleted viper-change-notification-threshold)
1307 (message "Deleted %d lines" lines-deleted))
1308 (kill-region (mark t) (point))
1309 (if (eq m-com 'viper-line) (setq this-command 'D-command)))
1310 (back-to-indentation)))
1313 (defun viper-exec-yank (m-com com)
1314 (or (and (markerp viper-com-point) (marker-position viper-com-point))
1315 (set-marker viper-com-point (point) (current-buffer)))
1317 (if viper-use-register
1319 (cond ((viper-valid-register viper-use-register '(letter digit))
1321 viper-use-register viper-com-point (point) nil))
1322 ((viper-valid-register viper-use-register '(Letter))
1323 (viper-append-to-register
1324 (downcase viper-use-register) viper-com-point (point)))
1325 (t (setq viper-use-register nil)
1326 (error viper-InvalidRegister viper-use-register)))
1327 (setq viper-use-register nil)))
1328 (setq last-command nil)
1329 (copy-region-as-kill viper-com-point (point))
1330 (setq chars-saved (abs (- (point) viper-com-point)))
1331 (if (> chars-saved viper-change-notification-threshold)
1332 (message "Saved %d characters" chars-saved))
1333 (goto-char viper-com-point)))
1336 (defun viper-exec-Yank (m-com com)
1338 (set-mark viper-com-point)
1339 (viper-enlarge-region (mark t) (point))
1341 (if viper-use-register
1343 (cond ((viper-valid-register viper-use-register '(letter digit))
1345 viper-use-register (mark t) (point) nil))
1346 ((viper-valid-register viper-use-register '(Letter))
1347 (viper-append-to-register
1348 (downcase viper-use-register) (mark t) (point)))
1349 (t (setq viper-use-register nil)
1350 (error viper-InvalidRegister viper-use-register)))
1351 (setq viper-use-register nil)))
1352 (setq last-command nil)
1353 (copy-region-as-kill (mark t) (point))
1354 (setq lines-saved (count-lines (mark t) (point)))
1355 (if (> lines-saved viper-change-notification-threshold)
1356 (message "Saved %d lines" lines-saved))))
1357 (viper-deactivate-mark)
1358 (goto-char viper-com-point))
1360 (defun viper-exec-bang (m-com com)
1362 (set-mark viper-com-point)
1363 (viper-enlarge-region (mark t) (point))
1364 (exchange-point-and-mark)
1365 (shell-command-on-region
1368 (setq viper-last-shell-com
1369 (viper-read-string-with-history
1372 'viper-shell-history
1373 (car viper-shell-history)
1375 viper-last-shell-com)
1378 (defun viper-exec-equals (m-com com)
1380 (set-mark viper-com-point)
1381 (viper-enlarge-region (mark t) (point))
1382 (if (> (mark t) (point)) (exchange-point-and-mark))
1383 (indent-region (mark t) (point) nil)))
1385 (defun viper-exec-shift (m-com com)
1387 (set-mark viper-com-point)
1388 (viper-enlarge-region (mark t) (point))
1389 (if (> (mark t) (point)) (exchange-point-and-mark))
1390 (indent-rigidly (mark t) (point)
1393 (- viper-shift-width))))
1394 ;; return point to where it was before shift
1395 (goto-char viper-com-point))
1397 ;; this is needed because some commands fake com by setting it to ?r, which
1398 ;; denotes repeated insert command.
1399 (defsubst viper-exec-dummy (m-com com)
1402 (defun viper-exec-buffer-search (m-com com)
1403 (setq viper-s-string (buffer-substring (point) viper-com-point))
1404 (setq viper-s-forward t)
1405 (setq viper-search-history (cons viper-s-string viper-search-history))
1406 (setq viper-intermediate-command 'viper-exec-buffer-search)
1407 (viper-search viper-s-string viper-s-forward 1))
1409 (defvar viper-exec-array (make-vector 128 nil))
1411 ;; Using a dispatch array allows adding functions like buffer search
1412 ;; without affecting other functions. Buffer search can now be bound
1413 ;; to any character.
1415 (aset viper-exec-array ?c 'viper-exec-change)
1416 (aset viper-exec-array ?C 'viper-exec-Change)
1417 (aset viper-exec-array ?d 'viper-exec-delete)
1418 (aset viper-exec-array ?D 'viper-exec-Delete)
1419 (aset viper-exec-array ?y 'viper-exec-yank)
1420 (aset viper-exec-array ?Y 'viper-exec-Yank)
1421 (aset viper-exec-array ?r 'viper-exec-dummy)
1422 (aset viper-exec-array ?! 'viper-exec-bang)
1423 (aset viper-exec-array ?< 'viper-exec-shift)
1424 (aset viper-exec-array ?> 'viper-exec-shift)
1425 (aset viper-exec-array ?= 'viper-exec-equals)
1429 ;; This function is called by various movement commands to execute a
1430 ;; destructive command on the region specified by the movement command. For
1431 ;; instance, if the user types cw, then the command viper-forward-word will
1432 ;; call viper-execute-com to execute viper-exec-change, which eventually will
1433 ;; call viper-change to invoke the replace mode on the region.
1435 ;; The var viper-d-com is set to (M-COM VAL COM REG INSETED-TEXT COMMAND-KEYS)
1436 ;; via a call to viper-set-destructive-command, for later use by viper-repeat.
1437 (defun viper-execute-com (m-com val com)
1438 (let ((reg viper-use-register))
1439 ;; this is the special command `#'
1441 (viper-special-prefix-com (- com 128))
1442 (let ((fn (aref viper-exec-array (if (< com 0) (- com) com))))
1444 (error "%c: %s" com viper-InvalidViCommand)
1445 (funcall fn m-com com))))
1446 (if (viper-dotable-command-p com)
1447 (viper-set-destructive-command
1449 (if (memq com (list ?c ?C ?!)) (- com) com)
1454 (defun viper-repeat (arg)
1455 "Re-execute last destructive command.
1456 Use the info in viper-d-com, which has the form
1457 \(com val ch reg inserted-text command-keys\),
1458 where `com' is the command to be re-executed, `val' is the
1459 argument to `com', `ch' is a flag for repeat, and `reg' is optional;
1460 if it exists, it is the name of the register for `com'.
1461 If the prefix argument, ARG, is non-nil, it is used instead of `val'."
1463 (let ((save-point (point)) ; save point before repeating prev cmd
1464 ;; Pass along that we are repeating a destructive command
1465 ;; This tells viper-set-destructive-command not to update
1466 ;; viper-command-ring
1467 (viper-intermediate-command 'viper-repeat))
1468 (if (eq last-command 'viper-undo)
1469 ;; if the last command was viper-undo, then undo-more
1471 ;; otherwise execute the command stored in viper-d-com. if arg is
1472 ;; non-nil its prefix value is used as new prefix value for the command.
1473 (let ((m-com (car viper-d-com))
1474 (val (viper-P-val arg))
1475 (com (nth 2 viper-d-com))
1476 (reg (nth 3 viper-d-com)))
1477 (if (null val) (setq val (nth 1 viper-d-com)))
1478 (if (null m-com) (error "No previous command to repeat."))
1479 (setq viper-use-register reg)
1480 (if (nth 4 viper-d-com) ; text inserted by command
1481 (setq viper-last-insertion (nth 4 viper-d-com)
1482 viper-d-char (nth 4 viper-d-com)))
1483 (funcall m-com (cons val com))
1484 (cond ((and (< save-point (point)) viper-keep-point-on-repeat)
1485 (goto-char save-point)) ; go back to before repeat.
1486 ((and (< save-point (point)) viper-ex-style-editing)
1487 (or (bolp) (backward-char 1))))
1488 (if (and (eolp) (not (bolp)))
1491 (viper-adjust-undo) ; take care of undo
1492 ;; If the prev cmd was rotating the command ring, this means that `.' has
1493 ;; just executed a command from that ring. So, push it on the ring again.
1494 ;; If we are just executing previous command , then don't push viper-d-com
1495 ;; because viper-d-com is not fully constructed in this case (its keys and
1496 ;; the inserted text may be nil). Besides, in this case, the command
1497 ;; executed by `.' is already on the ring.
1498 (if (eq last-command 'viper-display-current-destructive-command)
1499 (viper-push-onto-ring viper-d-com 'viper-command-ring))
1500 (viper-deactivate-mark)
1503 (defun viper-repeat-from-history ()
1504 "Repeat a destructive command from history.
1505 Doesn't change viper-command-ring in any way, so `.' will work as before
1506 executing this command.
1507 This command is supposed to be bound to a two-character Vi macro where
1508 the second character is a digit 0 to 9. The digit indicates which
1509 history command to execute. `<char>0' is equivalent to `.', `<char>1'
1510 invokes the command before that, etc."
1512 (let* ((viper-intermediate-command 'repeating-display-destructive-command)
1513 (idx (cond (viper-this-kbd-macro
1515 (symbol-name (elt viper-this-kbd-macro 1))))
1518 (viper-d-com viper-d-com))
1520 (or (and (numberp num) (<= 0 num) (<= num 9))
1525 "`viper-repeat-from-history' must be invoked as a Vi macro bound to `<key><digit>'")))
1527 (setq viper-d-com (viper-special-ring-rotate1 viper-command-ring -1))
1528 (setq num (1- num)))
1531 (viper-special-ring-rotate1 viper-command-ring 1)
1532 (setq num (1+ num)))
1536 ;; The hash-command. It is invoked interactively by the key sequence #<char>.
1537 ;; The chars that can follow `#' are determined by viper-hash-command-p
1538 (defun viper-special-prefix-com (char)
1540 (downcase-region (min viper-com-point (point))
1541 (max viper-com-point (point))))
1543 (upcase-region (min viper-com-point (point))
1544 (max viper-com-point (point))))
1546 (push-mark viper-com-point t)
1547 (viper-global-execute))
1549 (push-mark viper-com-point t)
1550 (viper-quote-region))
1551 ((= char ?s) (funcall viper-spell-function viper-com-point (point)))
1552 (t (error "#%c: %s" char viper-InvalidViCommand))))
1557 (defun viper-undo ()
1558 "Undo previous change."
1561 (let ((modified (buffer-modified-p))
1562 (before-undo-pt (point-marker))
1563 (after-change-functions after-change-functions)
1564 undo-beg-posn undo-end-posn)
1566 ;; no need to remove this hook, since this var has scope inside a let.
1567 (add-hook 'after-change-functions
1568 '(lambda (beg end len)
1569 (setq undo-beg-posn beg
1570 undo-end-posn (or end beg))))
1574 (setq undo-beg-posn (or undo-beg-posn before-undo-pt)
1575 undo-end-posn (or undo-end-posn undo-beg-posn))
1577 (goto-char undo-beg-posn)
1579 (if (and viper-keep-point-on-undo
1580 (pos-visible-in-window-p before-undo-pt))
1582 (push-mark (point-marker) t)
1583 (viper-sit-for-short 300)
1584 (goto-char undo-end-posn)
1585 (viper-sit-for-short 300)
1586 (if (and (> (viper-chars-in-region undo-beg-posn before-undo-pt) 1)
1587 (> (viper-chars-in-region undo-end-posn before-undo-pt) 1))
1588 (goto-char before-undo-pt)
1589 (goto-char undo-beg-posn)))
1590 (push-mark before-undo-pt t))
1591 (if (and (eolp) (not (bolp))) (backward-char 1))
1592 (if (not modified) (set-buffer-modified-p t)))
1593 (setq this-command 'viper-undo))
1595 ;; Continue undoing previous changes.
1596 (defun viper-undo-more ()
1597 (message "undo more!")
1601 (message "No further undo information in this buffer")))
1602 (if (and (eolp) (not (bolp))) (backward-char 1))
1603 (setq this-command 'viper-undo))
1605 ;; The following two functions are used to set up undo properly.
1606 ;; In VI, unlike Emacs, if you open a line, say, and add a bunch of lines,
1607 ;; they are undone all at once.
1608 (defun viper-adjust-undo ()
1609 (if viper-undo-needs-adjustment
1610 (let ((inhibit-quit t)
1612 (setq viper-undo-needs-adjustment nil)
1613 (if (listp buffer-undo-list)
1614 (if (setq tmp (memq viper-buffer-undo-list-mark buffer-undo-list))
1616 (setq tmp2 (cdr tmp)) ; the part after mark
1618 ;; cut tail from buffer-undo-list temporarily by direct
1619 ;; manipulation with pointers in buffer-undo-list
1622 (setq buffer-undo-list (delq nil buffer-undo-list))
1623 (setq buffer-undo-list
1624 (delq viper-buffer-undo-list-mark buffer-undo-list))
1625 ;; restore tail of buffer-undo-list
1626 (setq buffer-undo-list (nconc buffer-undo-list tmp2)))
1627 (setq buffer-undo-list (delq nil buffer-undo-list)))))
1631 (defun viper-set-complex-command-for-undo ()
1632 (if (listp buffer-undo-list)
1633 (if (not viper-undo-needs-adjustment)
1634 (let ((inhibit-quit t))
1635 (setq buffer-undo-list
1636 (cons viper-buffer-undo-list-mark buffer-undo-list))
1637 (setq viper-undo-needs-adjustment t)))))
1642 (defun viper-display-current-destructive-command ()
1643 (let ((text (nth 4 viper-d-com))
1644 (keys (nth 5 viper-d-com))
1647 (setq this-command 'viper-display-current-destructive-command)
1649 (message " `.' runs %s%s"
1650 (concat "`" (viper-array-to-string keys) "'")
1651 (viper-abbreviate-string
1654 (cond ((characterp text) (char-to-string text))
1655 ((stringp text) text)
1660 " inserting `" "'" " ......."))
1664 ;; don't change viper-d-com if it was viper-repeat command invoked with `.'
1665 ;; or in some other way (non-interactively).
1666 (defun viper-set-destructive-command (list)
1667 (or (eq viper-intermediate-command 'viper-repeat)
1669 (setq viper-d-com list)
1670 (setcar (nthcdr 5 viper-d-com)
1671 (viper-array-to-string (if (arrayp viper-this-command-keys)
1672 viper-this-command-keys
1673 (this-command-keys))))
1674 (viper-push-onto-ring viper-d-com 'viper-command-ring)))
1675 (setq viper-this-command-keys nil))
1678 (defun viper-prev-destructive-command (next)
1679 "Find previous destructive command in the history of destructive commands.
1680 With prefix argument, find next destructive command."
1682 (let (cmd viper-intermediate-command)
1683 (if (eq last-command 'viper-display-current-destructive-command)
1684 ;; repeated search through command history
1685 (setq viper-intermediate-command
1686 'repeating-display-destructive-command)
1687 ;; first search through command history--set temp ring
1688 (setq viper-temp-command-ring (copy-list viper-command-ring)))
1690 (viper-special-ring-rotate1 viper-temp-command-ring 1)
1691 (viper-special-ring-rotate1 viper-temp-command-ring -1)))
1694 (setq viper-d-com cmd))
1695 (viper-display-current-destructive-command)))
1698 (defun viper-next-destructive-command ()
1699 "Find next destructive command in the history of destructive commands."
1701 (viper-prev-destructive-command 'next))
1704 (defun viper-insert-prev-from-insertion-ring (arg)
1705 "Cycle through insertion ring in the direction of older insertions.
1706 Undoes previous insertion and inserts new.
1707 With prefix argument, cycles in the direction of newer elements.
1708 In minibuffer, this command executes whatever the invocation key is bound
1709 to in the global map, instead of cycling through the insertion ring."
1711 (let (viper-intermediate-command)
1712 (if (eq last-command 'viper-insert-from-insertion-ring)
1713 (progn ; repeated search through insertion history
1714 (setq viper-intermediate-command 'repeating-insertion-from-ring)
1715 (if (eq viper-current-state 'replace-state)
1717 (if viper-last-inserted-string-from-insertion-ring
1718 (backward-delete-char
1719 (length viper-last-inserted-string-from-insertion-ring))))
1721 ;;first search through insertion history
1722 (setq viper-temp-insertion-ring (copy-list viper-insertion-ring)))
1723 (setq this-command 'viper-insert-from-insertion-ring)
1724 ;; so that things will be undone properly
1725 (setq buffer-undo-list (cons nil buffer-undo-list))
1726 (setq viper-last-inserted-string-from-insertion-ring
1727 (viper-special-ring-rotate1 viper-temp-insertion-ring (if arg 1 -1)))
1729 ;; this change of viper-intermediate-command must come after
1730 ;; viper-special-ring-rotate1, so that the ring will rotate, but before the
1732 (setq viper-intermediate-command nil)
1733 (if viper-last-inserted-string-from-insertion-ring
1734 (insert viper-last-inserted-string-from-insertion-ring))
1737 (defun viper-insert-next-from-insertion-ring ()
1738 "Cycle through insertion ring in the direction of older insertions.
1739 Undo previous insertion and inserts new."
1741 (viper-insert-prev-from-insertion-ring 'next))
1745 ;; some region utilities
1747 ;; If at the last line of buffer, add \\n before eob, if newline is missing.
1748 (defun viper-add-newline-at-eob-if-necessary ()
1751 ;; make sure all lines end with newline, unless in the minibuffer or
1752 ;; when requested otherwise (require-final-newline is nil)
1755 require-final-newline
1756 (not (viper-is-in-minibuffer))
1757 (not buffer-read-only))
1760 (defun viper-yank-defun ()
1762 (copy-region-as-kill (point) (mark t)))
1764 ;; Enlarge region between BEG and END.
1765 (defun viper-enlarge-region (beg end)
1766 (or beg (setq beg end)) ; if beg is nil, set to end
1767 (or end (setq end beg)) ; if end is nil, set to beg
1770 (progn (goto-char beg) (set-mark end))
1774 (exchange-point-and-mark)
1775 (if (or (not (eobp)) (not (bolp))) (forward-line 1))
1776 (if (not (eobp)) (beginning-of-line))
1777 (if (> beg end) (exchange-point-and-mark)))
1780 ;; Quote region by each line with a user supplied string.
1781 (defun viper-quote-region ()
1782 (let ((quote-str viper-quote-string)
1783 (donot-change-dafault t))
1785 (viper-read-string-with-history
1788 'viper-quote-region-history
1789 (cond ((string-match "tex.*-mode" (symbol-name major-mode)) "%%")
1790 ((string-match "java.*-mode" (symbol-name major-mode)) "//")
1791 ((string-match "perl.*-mode" (symbol-name major-mode)) "#")
1792 ((string-match "lisp.*-mode" (symbol-name major-mode)) ";;")
1793 ((memq major-mode '(c-mode cc-mode c++-mode)) "//")
1794 ((memq major-mode '(sh-mode shell-mode)) "#")
1795 (t (setq donot-change-dafault nil)
1797 (or donot-change-dafault
1798 (setq viper-quote-string quote-str))
1799 (viper-enlarge-region (point) (mark t))
1800 (if (> (point) (mark t)) (exchange-point-and-mark))
1804 (while (and (< (point) (mark t)) (bolp))
1809 ;; Tells whether BEG is on the same line as END.
1810 ;; If one of the args is nil, it'll return nil.
1811 (defun viper-same-line (beg end)
1812 (let ((selective-display nil)
1815 (if (and beg end (> beg end))
1820 (cond ((or (> beg (point-max)) (> end (point-max))) ; out of range
1823 ;; This 'if' is needed because Emacs treats the next empty line
1824 ;; as part of the previous line.
1825 (if (= (viper-line-pos 'start) end)
1827 (<= (+ incr (count-lines beg end)) 1))))
1831 ;; Check if the string ends with a newline.
1832 (defun viper-end-with-a-newline-p (string)
1833 (or (string= string "")
1834 (= (viper-seq-last-elt string) ?\n)))
1836 (defun viper-tmp-insert-at-eob (msg)
1837 (let ((savemax (point-max)))
1841 (goto-char savemax) (delete-region (point) (point-max))
1846 ;;; Minibuffer business
1848 (defsubst viper-set-minibuffer-style ()
1849 (add-hook 'minibuffer-setup-hook 'viper-minibuffer-setup-sentinel))
1852 (defun viper-minibuffer-setup-sentinel ()
1853 (let ((hook (if viper-vi-style-in-minibuffer
1854 'viper-change-state-to-insert
1855 'viper-change-state-to-emacs)))
1859 ;; Thie is a temp hook that uses free variables init-message and initial.
1860 ;; A dirty feature, but it is the simplest way to have it do the right thing.
1861 ;; The init-message and initial vars come from the scope set by
1862 ;; viper-read-string-with-history
1863 (defun viper-minibuffer-standard-hook ()
1864 (if (stringp init-message)
1865 (viper-tmp-insert-at-eob init-message))
1866 (if (stringp initial)
1868 ;; don't wait if we have unread events or in kbd macro
1869 (or unread-command-events
1872 (if (fboundp 'minibuffer-prompt-end)
1873 (delete-region (minibuffer-prompt-end) (point-max))
1876 (viper-minibuffer-setup-sentinel))
1878 (defsubst viper-minibuffer-real-start ()
1879 (if (fboundp 'minibuffer-prompt-end)
1880 (minibuffer-prompt-end)
1884 ;; Interpret last event in the local map first; if fails, use exit-minibuffer.
1885 ;; Run viper-minibuffer-exit-hook before exiting.
1886 (defun viper-exit-minibuffer ()
1887 "Exit minibuffer Viper way."
1890 (setq command (local-key-binding (char-to-string last-command-char)))
1891 (run-hooks 'viper-minibuffer-exit-hook)
1893 (command-execute command)
1894 (exit-minibuffer))))
1897 (defcustom viper-smart-suffix-list
1898 '("" "tex" "c" "cc" "C" "java" "el" "html" "htm" "xml"
1899 "pl" "flr" "P" "p" "h" "H")
1900 "*List of suffixes that Viper tries to append to filenames ending with a `.'.
1901 This is useful when you the current directory contains files with the same
1902 prefix and many different suffixes. Usually, only one of the suffixes
1903 represents an editable file. However, file completion will stop at the `.'
1904 The smart suffix feature lets you hit RET in such a case, and Viper will
1905 select the appropriate suffix.
1907 Suffixes are tried in the order given and the first suffix for which a
1908 corresponding file exists is selected. If no file exists for any of the
1909 suffixes, the user is asked to confirm.
1911 To turn this feature off, set this variable to nil."
1912 :type '(repeat string)
1916 ;; Try to add a suitable suffix to files whose name ends with a `.'
1917 ;; Useful when the user hits RET on a non-completed file name.
1918 ;; Used as a minibuffer exit hook in read-file-name
1919 (defun viper-file-add-suffix ()
1921 (len (length viper-smart-suffix-list))
1922 (file (buffer-substring-no-properties
1923 (viper-minibuffer-real-start) (point-max)))
1925 (goto-char (point-max))
1926 (if (and viper-smart-suffix-list (string-match "\\.$" file))
1928 (while (and (not found) (< count len))
1929 (setq suff (nth count viper-smart-suffix-list)
1932 (format "%s%s" (substitute-in-file-name file) suff))
1939 (viper-tmp-insert-at-eob " [Please complete file name]")
1941 (while (not (memq cmd
1942 '(exit-minibuffer viper-exit-minibuffer)))
1944 (key-binding (setq key (read-key-sequence nil))))
1945 (cond ((eq cmd 'self-insert-command)
1947 (insert (events-to-keys key))
1949 ((memq cmd '(exit-minibuffer viper-exit-minibuffer))
1951 (t (command-execute cmd)))
1956 (defun viper-minibuffer-trim-tail ()
1957 "Delete junk at the end of the first line of the minibuffer input.
1958 Remove this function from `viper-minibuffer-exit-hook', if this causes
1960 (if (viper-is-in-minibuffer)
1962 (goto-char (viper-minibuffer-real-start))
1964 (delete-region (point) (point-max)))))
1967 ;;; Reading string with history
1969 (defun viper-read-string-with-history (prompt &optional initial
1970 history-var default keymap
1972 ;; Read string, prompting with PROMPT and inserting the INITIAL
1973 ;; value. Uses HISTORY-VAR. DEFAULT is the default value to accept if the
1974 ;; input is an empty string.
1975 ;; Default value is displayed until the user types something in the
1977 ;; KEYMAP is used, if given, instead of minibuffer-local-map.
1978 ;; INIT-MESSAGE is the message temporarily displayed after entering the
1980 (let ((minibuffer-setup-hook 'viper-minibuffer-standard-hook)
1985 (setq keymap (or keymap minibuffer-local-map)
1986 initial (or initial "")
1987 temp-msg (if default
1988 (format "(default: %s) " default)
1991 (setq viper-incomplete-ex-cmd nil)
1992 (setq val (read-from-minibuffer prompt
1993 (concat temp-msg initial val padding)
1994 keymap nil history-var))
1995 (setq minibuffer-setup-hook nil
1996 padding (viper-array-to-string (this-command-keys))
1998 ;; the following tries to be smart about what to put in history
1999 (if (not (string= val (car (eval history-var))))
2000 (set history-var (cons val (eval history-var))))
2001 (if (or (string= (nth 0 (eval history-var)) (nth 1 (eval history-var)))
2002 (string= (nth 0 (eval history-var)) ""))
2003 (set history-var (cdr (eval history-var))))
2004 ;; If the user enters nothing but the prev cmd wasn't viper-ex,
2005 ;; viper-command-argument, or `! shell-command', this probably means
2006 ;; that the user typed something then erased. Return "" in this case, not
2007 ;; the default---the default is too confusing in this case.
2008 (cond ((and (string= val "")
2009 (not (string= prompt "!")) ; was a `! shell-command'
2010 (not (memq last-command
2012 viper-command-argument
2016 ((string= val "") (or default ""))
2022 ;; insertion commands
2024 ;; Called when state changes from Insert Vi command mode.
2025 ;; Repeats the insertion command if Insert state was entered with prefix
2027 (defun viper-repeat-insert-command ()
2028 (let ((i-com (car viper-d-com))
2029 (val (nth 1 viper-d-com))
2030 (char (nth 2 viper-d-com)))
2031 (if (and val (> val 1)) ; first check that val is non-nil
2033 (setq viper-d-com (list i-com (1- val) ?r nil nil nil))
2035 (setq viper-d-com (list i-com val char nil nil nil))
2038 (defun viper-insert (arg)
2039 "Insert before point."
2041 (viper-set-complex-command-for-undo)
2042 (let ((val (viper-p-val arg))
2043 (com (viper-getcom arg)))
2044 (viper-set-destructive-command (list 'viper-insert val ?r nil nil nil))
2046 (viper-loop val (viper-yank-last-insertion))
2047 (viper-change-state-to-insert))))
2049 (defun viper-append (arg)
2050 "Append after point."
2052 (viper-set-complex-command-for-undo)
2053 (let ((val (viper-p-val arg))
2054 (com (viper-getcom arg)))
2055 (viper-set-destructive-command (list 'viper-append val ?r nil nil nil))
2056 (if (not (eolp)) (forward-char))
2058 (viper-loop val (viper-yank-last-insertion))
2059 (viper-change-state-to-insert))))
2061 (defun viper-Append (arg)
2062 "Append at end of line."
2064 (viper-set-complex-command-for-undo)
2065 (let ((val (viper-p-val arg))
2066 (com (viper-getcom arg)))
2067 (viper-set-destructive-command (list 'viper-Append val ?r nil nil nil))
2070 (viper-loop val (viper-yank-last-insertion))
2071 (viper-change-state-to-insert))))
2073 (defun viper-Insert (arg)
2074 "Insert before first non-white."
2076 (viper-set-complex-command-for-undo)
2077 (let ((val (viper-p-val arg))
2078 (com (viper-getcom arg)))
2079 (viper-set-destructive-command (list 'viper-Insert val ?r nil nil nil))
2080 (back-to-indentation)
2082 (viper-loop val (viper-yank-last-insertion))
2083 (viper-change-state-to-insert))))
2085 (defun viper-open-line (arg)
2088 (viper-set-complex-command-for-undo)
2089 (let ((val (viper-p-val arg))
2090 (com (viper-getcom arg)))
2091 (viper-set-destructive-command (list 'viper-open-line val ?r nil nil nil))
2092 (let ((col (current-indentation)))
2097 (if viper-auto-indent
2100 (if viper-electric-mode
2101 (indent-according-to-mode)
2104 (viper-yank-last-insertion))
2107 (if viper-auto-indent
2110 (if viper-electric-mode
2111 (indent-according-to-mode)
2113 (viper-change-state-to-insert)))))
2115 (defun viper-Open-line (arg)
2118 (viper-set-complex-command-for-undo)
2119 (let ((val (viper-p-val arg))
2120 (com (viper-getcom arg)))
2121 (viper-set-destructive-command (list 'viper-Open-line val ?r nil nil nil))
2122 (let ((col (current-indentation)))
2127 (if viper-auto-indent
2130 (if viper-electric-mode
2131 (indent-according-to-mode)
2134 (viper-yank-last-insertion))
2137 (if viper-auto-indent
2140 (if viper-electric-mode
2141 (indent-according-to-mode)
2144 (viper-change-state-to-insert)))))
2146 (defun viper-open-line-at-point (arg)
2147 "Open line at point."
2149 (viper-set-complex-command-for-undo)
2150 (let ((val (viper-p-val arg))
2151 (com (viper-getcom arg)))
2152 (viper-set-destructive-command
2153 (list 'viper-open-line-at-point val ?r nil nil nil))
2157 (viper-yank-last-insertion))
2159 (viper-change-state-to-insert))))
2161 (defun viper-substitute (arg)
2162 "Substitute characters."
2164 (let ((val (viper-p-val arg))
2165 (com (viper-getcom arg)))
2169 (viper-change-subr (mark t) (point))
2170 (viper-change (mark t) (point)))
2171 (viper-set-destructive-command (list 'viper-substitute val ?r nil nil nil))
2174 ;; Command bound to S
2175 (defun viper-substitute-line (arg)
2178 (viper-set-complex-command-for-undo)
2179 (viper-line (cons arg ?C)))
2181 ;; Prepare for replace
2182 (defun viper-start-replace ()
2183 (setq viper-began-as-replace t
2184 viper-sitting-in-replace t
2185 viper-replace-chars-to-delete 0)
2187 'viper-after-change-functions 'viper-replace-mode-spy-after t 'local)
2189 'viper-before-change-functions 'viper-replace-mode-spy-before t 'local)
2190 ;; this will get added repeatedly, but no harm
2191 (add-hook 'after-change-functions 'viper-after-change-sentinel t)
2192 (add-hook 'before-change-functions 'viper-before-change-sentinel t)
2193 (viper-move-marker-locally
2194 'viper-last-posn-in-replace-region (viper-replace-start))
2196 'viper-post-command-hooks 'viper-replace-state-post-command-sentinel
2199 'viper-pre-command-hooks 'viper-replace-state-pre-command-sentinel t 'local)
2200 ;; guard against a smartie who switched from R-replace to normal replace
2202 'viper-post-command-hooks 'viper-R-state-post-command-sentinel 'local)
2203 (if overwrite-mode (overwrite-mode nil))
2207 (defun viper-replace-mode-spy-before (beg end)
2208 (setq viper-replace-region-chars-deleted (viper-chars-in-region beg end))
2211 ;; Invoked as an after-change-function to calculate how many chars have to be
2212 ;; deleted. This function may be called several times within a single command,
2213 ;; if this command performs several separate buffer changes. Therefore, if
2214 ;; adds up the number of chars inserted and subtracts the number of chars
2216 (defun viper-replace-mode-spy-after (beg end length)
2217 (if (memq viper-intermediate-command
2218 '(dabbrev-expand hippie-expand repeating-insertion-from-ring))
2219 ;; Take special care of text insertion from insertion ring inside
2220 ;; replacement overlays.
2222 (setq viper-replace-chars-to-delete 0)
2223 (viper-move-marker-locally
2224 'viper-last-posn-in-replace-region (point)))
2226 (let* ((real-end (min end (viper-replace-end)))
2227 (column-shift (- (save-excursion (goto-char real-end)
2229 (save-excursion (goto-char beg)
2234 (setq chars-deleted viper-replace-region-chars-deleted))
2235 (setq viper-replace-region-chars-deleted 0)
2236 (setq viper-replace-chars-to-delete
2237 (+ viper-replace-chars-to-delete
2239 ;; if column shift is bigger, due to a TAB insertion, take
2240 ;; column-shift instead of the number of inserted chars
2241 (max (viper-chars-in-region beg real-end)
2242 ;; This test accounts for Chinese/Japanese/... chars,
2243 ;; which occupy 2 columns instead of one. If we use
2244 ;; column-shift here, we may delete two chars instead of
2245 ;; one when the user types one Chinese character.
2246 ;; Deleting two would be OK, if they were European chars,
2247 ;; but it is not OK if they are Chinese chars.
2248 ;; Since it is hard to
2249 ;; figure out which characters are being deleted in any
2250 ;; given region, we decided to treat Eastern and European
2251 ;; characters equally, even though Eastern chars may
2252 ;; occupy more columns.
2253 (if (memq this-command '(self-insert-command
2254 quoted-insert viper-insert-tab))
2257 ;; the number of deleted chars
2260 (viper-move-marker-locally
2261 'viper-last-posn-in-replace-region
2262 (max (if (> end (viper-replace-end)) (viper-replace-end) end)
2263 (or (marker-position viper-last-posn-in-replace-region)
2264 (viper-replace-start))
2270 ;; Delete stuff between viper-last-posn-in-replace-region and the end of
2271 ;; viper-replace-overlay-marker, if viper-last-posn-in-replace-region is within
2272 ;; the overlay and current point is before the end of the overlay.
2273 ;; Don't delete anything if current point is past the end of the overlay.
2274 (defun viper-finish-change ()
2276 'viper-after-change-functions 'viper-replace-mode-spy-after 'local)
2278 'viper-before-change-functions 'viper-replace-mode-spy-before 'local)
2280 'viper-post-command-hooks 'viper-replace-state-post-command-sentinel 'local)
2282 'viper-pre-command-hooks 'viper-replace-state-pre-command-sentinel 'local)
2283 (viper-restore-cursor-color 'after-replace-mode)
2284 (setq viper-sitting-in-replace nil) ; just in case we'll need to know it
2286 (if (and viper-replace-overlay
2287 (viper-pos-within-region viper-last-posn-in-replace-region
2288 (viper-replace-start)
2289 (viper-replace-end))
2290 (< (point) (viper-replace-end)))
2292 viper-last-posn-in-replace-region (viper-replace-end))))
2294 (if (eq viper-current-state 'replace-state)
2295 (viper-downgrade-to-insert))
2296 ;; replace mode ended => nullify viper-last-posn-in-replace-region
2297 (viper-move-marker-locally 'viper-last-posn-in-replace-region nil)
2298 (viper-hide-replace-overlay)
2299 (viper-refresh-mode-line)
2300 (viper-put-string-on-kill-ring viper-last-replace-region)
2303 ;; Make STRING be the first element of the kill ring.
2304 (defun viper-put-string-on-kill-ring (string)
2305 (setq kill-ring (cons string kill-ring))
2306 (if (> (length kill-ring) kill-ring-max)
2307 (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil))
2308 (setq kill-ring-yank-pointer kill-ring))
2310 (defun viper-finish-R-mode ()
2312 'viper-post-command-hooks 'viper-R-state-post-command-sentinel 'local)
2314 'viper-pre-command-hooks 'viper-replace-state-pre-command-sentinel 'local)
2315 (viper-downgrade-to-insert))
2317 (defun viper-start-R-mode ()
2318 ;; Leave arg as 1, not t: XEmacs insists that it must be a pos number
2321 'viper-post-command-hooks 'viper-R-state-post-command-sentinel t 'local)
2323 'viper-pre-command-hooks 'viper-replace-state-pre-command-sentinel t 'local)
2324 ;; guard against a smartie who switched from R-replace to normal replace
2326 'viper-post-command-hooks 'viper-replace-state-post-command-sentinel 'local)
2331 (defun viper-replace-state-exit-cmd ()
2332 "Binding for keys that cause Replace state to switch to Vi or to Insert.
2333 These keys are ESC, RET, and LineFeed"
2335 (if overwrite-mode ; if in replace mode invoked via 'R'
2336 (viper-finish-R-mode)
2337 (viper-finish-change))
2339 (if (eq this-command 'viper-intercept-ESC-key)
2340 (setq com 'viper-exit-insert-state)
2341 (viper-set-unread-command-events last-input-char)
2342 (setq com (key-binding (read-key-sequence nil))))
2344 (condition-case conds
2345 (command-execute com)
2347 (viper-message-conditions conds)))
2349 (viper-hide-replace-overlay))
2352 (defun viper-replace-state-carriage-return ()
2353 "Carriage return in Viper replace state."
2355 ;; If Emacs start supporting overlay maps, as it currently supports
2356 ;; text-property maps, we could do away with viper-replace-minor-mode and
2357 ;; just have keymap attached to replace overlay. Then the "if part" of this
2358 ;; statement can be deleted.
2359 (if (or (< (point) (viper-replace-start))
2360 (> (point) (viper-replace-end)))
2361 (let (viper-replace-minor-mode com)
2362 (viper-set-unread-command-events last-input-char)
2363 (setq com (key-binding (read-key-sequence nil)))
2364 (condition-case conds
2365 (command-execute com)
2367 (viper-message-conditions conds))))
2368 (if (not viper-allow-multiline-replace-regions)
2369 (viper-replace-state-exit-cmd)
2370 (if (viper-same-line (point) (viper-replace-end))
2371 (viper-replace-state-exit-cmd)
2372 ;; delete the rest of line
2373 (delete-region (point) (viper-line-pos 'end))
2376 (if (eobp) (error "Last line in buffer")))
2377 ;; skip to the next line
2379 (back-to-indentation)
2383 ;; This is the function bound to 'R'---unlimited replace.
2384 ;; Similar to Emacs's own overwrite-mode.
2385 (defun viper-overwrite (arg)
2386 "Begin overwrite mode."
2388 (let ((val (viper-p-val arg))
2389 (com (viper-getcom arg)) (len))
2390 (viper-set-destructive-command (list 'viper-overwrite val ?r nil nil nil))
2393 ;; Viper saves inserted text in viper-last-insertion
2394 (setq len (length viper-last-insertion))
2396 (viper-loop val (viper-yank-last-insertion)))
2397 (setq last-command 'viper-overwrite)
2398 (viper-set-complex-command-for-undo)
2399 (viper-set-replace-overlay (point) (viper-line-pos 'end))
2400 (viper-change-state-to-replace)
2406 (defun viper-line (arg)
2407 (let ((val (car arg))
2409 (viper-move-marker-locally 'viper-com-point (point))
2411 (viper-next-line-carefully (1- val)))
2412 ;; the following ensures that dd, cc, D, yy will do the right thing on the
2413 ;; last line of buffer when this line has no \n.
2414 (viper-add-newline-at-eob-if-necessary)
2415 (viper-execute-com 'viper-line val com))
2416 (if (and (eobp) (not (bobp))) (forward-line -1))
2419 (defun viper-yank-line (arg)
2420 "Yank ARG lines (in Vi's sense)."
2422 (let ((val (viper-p-val arg)))
2423 (viper-line (cons val ?Y))))
2428 (defun viper-region (arg)
2429 "Execute command on a region."
2431 (let ((val (viper-P-val arg))
2432 (com (viper-getcom arg)))
2433 (viper-move-marker-locally 'viper-com-point (point))
2434 (exchange-point-and-mark)
2435 (viper-execute-com 'viper-region val com)))
2437 (defun viper-Region (arg)
2438 "Execute command on a Region."
2440 (let ((val (viper-P-val arg))
2441 (com (viper-getCom arg)))
2442 (viper-move-marker-locally 'viper-com-point (point))
2443 (exchange-point-and-mark)
2444 (viper-execute-com 'viper-Region val com)))
2446 (defun viper-replace-char (arg)
2447 "Replace the following ARG chars by the character read."
2449 (if (and (eolp) (bolp)) (error "No character to replace here"))
2450 (let ((val (viper-p-val arg))
2451 (com (viper-getcom arg)))
2452 (viper-replace-char-subr com val)
2453 (if (and (eolp) (not (bolp))) (forward-char 1))
2454 (setq viper-this-command-keys
2455 (format "%sr" (if (integerp arg) arg "")))
2456 (viper-set-destructive-command
2457 (list 'viper-replace-char val ?r nil viper-d-char nil))
2460 (defun viper-replace-char-subr (com arg)
2462 (setq char (if (equal com ?r)
2465 (let (inhibit-quit) ; preserve consistency of undo-list and iso-accents
2466 (if (and viper-automatic-iso-accents (memq char '(?' ?\" ?^ ?~)))
2467 ;; get European characters
2469 (viper-set-iso-accents-mode t)
2470 (viper-set-unread-command-events char)
2471 (setq char (aref (read-key-sequence nil) 0))
2472 (viper-set-iso-accents-mode nil)))
2473 (viper-set-complex-command-for-undo)
2474 (if (eq char ?\C-m) (setq char ?\n))
2475 (if (and viper-special-input-method (fboundp 'quail-start-translation))
2476 ;; get Intl. characters
2478 (viper-set-input-method t)
2479 (setq last-command-event
2481 (if viper-xemacs-p (character-to-event char) char)))
2487 (quail-start-translation 1)
2488 (quail-start-translation)))
2490 ;; quail translation failed
2491 (if (and (not (stringp quail-current-str))
2492 (not (viper-characterp quail-current-str)))
2497 (viper-set-input-method nil)
2498 (error "Composing character failed, changes undone")))
2499 ;; quail translation seems ok
2501 ;;(setq char quail-current-str))
2502 (setq char (viper-char-at-pos 'backward)))
2503 (setq viper-d-char char)
2504 (viper-loop (1- (if (> arg 0) arg (- arg)))
2507 (viper-set-input-method nil))
2509 (setq viper-d-char char)
2510 (viper-loop (if (> arg 0) arg (- arg))
2513 (backward-char arg))))
2516 ;; basic cursor movement. j, k, l, h commands.
2518 (defun viper-forward-char (arg)
2519 "Move point right ARG characters (left if ARG negative).
2520 On reaching end of line, stop and signal error."
2522 (viper-leave-region-active)
2523 (let ((val (viper-p-val arg))
2524 (com (viper-getcom arg)))
2525 (if com (viper-move-marker-locally 'viper-com-point (point)))
2526 (if viper-ex-style-motion
2528 ;; the boundary condition check gets weird here because
2529 ;; forward-char may be the parameter of a delete, and 'dl' works
2530 ;; just like 'x' for the last char on a line, so we have to allow
2531 ;; the forward motion before the 'viper-execute-com', but, of
2532 ;; course, 'dl' doesn't work on an empty line, so we have to
2533 ;; catch that condition before 'viper-execute-com'
2534 (if (and (eolp) (bolp)) (error "") (forward-char val))
2535 (if com (viper-execute-com 'viper-forward-char val com))
2536 (if (eolp) (progn (backward-char 1) (error ""))))
2538 (if com (viper-execute-com 'viper-forward-char val com)))))
2541 (defun viper-backward-char (arg)
2542 "Move point left ARG characters (right if ARG negative).
2543 On reaching beginning of line, stop and signal error."
2545 (viper-leave-region-active)
2546 (let ((val (viper-p-val arg))
2547 (com (viper-getcom arg)))
2548 (if com (viper-move-marker-locally 'viper-com-point (point)))
2549 (if viper-ex-style-motion
2551 (if (bolp) (error "") (backward-char val))
2552 (if com (viper-execute-com 'viper-backward-char val com)))
2554 (if com (viper-execute-com 'viper-backward-char val com)))))
2557 ;; Like forward-char, but doesn't move at end of buffer.
2558 ;; Returns distance traveled
2559 ;; (positive or 0, if arg positive; negative if arg negative).
2560 (defun viper-forward-char-carefully (&optional arg)
2561 (setq arg (or arg 1))
2566 (if (< (point) pt) ; arg was negative
2567 (- (viper-chars-in-region pt (point)))
2568 (viper-chars-in-region pt (point)))))
2571 ;; Like backward-char, but doesn't move at beg of buffer.
2572 ;; Returns distance traveled
2573 ;; (negative or 0, if arg positive; positive if arg negative).
2574 (defun viper-backward-char-carefully (&optional arg)
2575 (setq arg (or arg 1))
2580 (if (> (point) pt) ; arg was negative
2581 (viper-chars-in-region pt (point))
2582 (- (viper-chars-in-region pt (point))))))
2584 (defun viper-next-line-carefully (arg)
2593 ;; Words are formed from alpha's and nonalphas - <sp>,\t\n are separators for
2594 ;; word movement. When executed with a destructive command, \n is usually left
2595 ;; untouched for the last word. Viper uses syntax table to determine what is a
2596 ;; word and what is a separator. However, \n is always a separator. Also, if
2597 ;; viper-syntax-preference is 'vi, then `_' is part of the word.
2600 (defun viper-skip-separators (forward)
2603 (viper-skip-all-separators-forward 'within-line)
2604 (if (looking-at "\n")
2607 (viper-skip-all-separators-forward 'within-line))))
2608 ;; check for eob and white space before it. move off of eob
2609 (if (and (eobp) (save-excursion
2610 (viper-backward-char-carefully)
2611 (viper-looking-at-separator)))
2612 (viper-backward-char-carefully))
2613 (viper-skip-all-separators-backward 'within-line)
2614 (viper-backward-char-carefully)
2615 (if (looking-at "\n")
2616 (viper-skip-all-separators-backward 'within-line)
2617 (or (bobp) (forward-char)))))
2620 (defun viper-forward-word-kernel (val)
2622 (cond ((viper-looking-at-alpha)
2623 (viper-skip-alpha-forward "_")
2624 (viper-skip-separators t))
2625 ((viper-looking-at-separator)
2626 (viper-skip-separators t))
2627 ((not (viper-looking-at-alphasep))
2628 (viper-skip-nonalphasep-forward)
2629 (viper-skip-separators t)))
2630 (setq val (1- val))))
2632 ;; first skip non-newline separators backward, then skip \n. Then, if TWICE is
2633 ;; non-nil, skip non-\n back again, but don't overshoot the limit LIM.
2634 (defun viper-separator-skipback-special (twice lim)
2635 (let ((prev-char (viper-char-at-pos 'backward))
2636 (saved-point (point)))
2637 ;; skip non-newline separators backward
2638 (while (and (not (memq prev-char '(nil \n)))
2640 ;; must be non-newline separator
2641 (if (eq viper-syntax-preference 'strict-vi)
2642 (memq prev-char '(?\ ?\t))
2643 (memq (char-syntax prev-char) '(?\ ?-))))
2644 (viper-backward-char-carefully)
2645 (setq prev-char (viper-char-at-pos 'backward)))
2647 (if (and (< lim (point)) (eq prev-char ?\n))
2649 ;; If we skipped to the next word and the prefix of this line doesn't
2650 ;; consist of separators preceded by a newline, then don't skip backwards
2652 (goto-char saved-point))
2653 (setq prev-char (viper-char-at-pos 'backward))
2655 ;; skip again, but make sure we don't overshoot the limit
2657 (while (and (not (memq prev-char '(nil \n)))
2659 ;; must be non-newline separator
2660 (if (eq viper-syntax-preference 'strict-vi)
2661 (memq prev-char '(?\ ?\t))
2662 (memq (char-syntax prev-char) '(?\ ?-))))
2663 (viper-backward-char-carefully)
2664 (setq prev-char (viper-char-at-pos 'backward))))
2667 (viper-forward-char-carefully))
2671 (defun viper-forward-word (arg)
2674 (viper-leave-region-active)
2675 (let ((val (viper-p-val arg))
2676 (com (viper-getcom arg)))
2677 (if com (viper-move-marker-locally 'viper-com-point (point)))
2678 (viper-forward-word-kernel val)
2680 (cond ((memq com (list ?c (- ?c)))
2681 (viper-separator-skipback-special 'twice viper-com-point))
2682 ;; Yank words including the whitespace, but not newline
2683 ((memq com (list ?y (- ?y)))
2684 (viper-separator-skipback-special nil viper-com-point))
2685 ((viper-dotable-command-p com)
2686 (viper-separator-skipback-special nil viper-com-point)))
2687 (viper-execute-com 'viper-forward-word val com)))))
2690 (defun viper-forward-Word (arg)
2691 "Forward word delimited by white characters."
2693 (viper-leave-region-active)
2694 (let ((val (viper-p-val arg))
2695 (com (viper-getcom arg)))
2696 (if com (viper-move-marker-locally 'viper-com-point (point)))
2698 (viper-skip-nonseparators 'forward)
2699 (viper-skip-separators t))
2701 (cond ((memq com (list ?c (- ?c)))
2702 (viper-separator-skipback-special 'twice viper-com-point))
2703 ;; Yank words including the whitespace, but not newline
2704 ((memq com (list ?y (- ?y)))
2705 (viper-separator-skipback-special nil viper-com-point))
2706 ((viper-dotable-command-p com)
2707 (viper-separator-skipback-special nil viper-com-point)))
2708 (viper-execute-com 'viper-forward-Word val com)))))
2711 ;; this is a bit different from Vi, but Vi's end of word
2712 ;; makes no sense whatsoever
2713 (defun viper-end-of-word-kernel ()
2714 (if (viper-end-of-word-p) (forward-char))
2715 (if (viper-looking-at-separator)
2716 (viper-skip-all-separators-forward))
2718 (cond ((viper-looking-at-alpha) (viper-skip-alpha-forward "_"))
2719 ((not (viper-looking-at-alphasep)) (viper-skip-nonalphasep-forward)))
2720 (viper-backward-char-carefully))
2722 (defun viper-end-of-word-p ()
2725 (cond ((viper-looking-at-alpha)
2727 (not (viper-looking-at-alpha)))
2728 ((not (viper-looking-at-alphasep))
2730 (viper-looking-at-alphasep))))))
2733 (defun viper-end-of-word (arg &optional careful)
2734 "Move point to end of current word."
2736 (viper-leave-region-active)
2737 (let ((val (viper-p-val arg))
2738 (com (viper-getcom arg)))
2739 (if com (viper-move-marker-locally 'viper-com-point (point)))
2740 (viper-loop val (viper-end-of-word-kernel))
2744 (viper-execute-com 'viper-end-of-word val com)))))
2746 (defun viper-end-of-Word (arg)
2747 "Forward to end of word delimited by white character."
2749 (viper-leave-region-active)
2750 (let ((val (viper-p-val arg))
2751 (com (viper-getcom arg)))
2752 (if com (viper-move-marker-locally 'viper-com-point (point)))
2754 (viper-end-of-word-kernel)
2755 (viper-skip-nonseparators 'forward)
2760 (viper-execute-com 'viper-end-of-Word val com)))))
2762 (defun viper-backward-word-kernel (val)
2764 (viper-backward-char-carefully)
2765 (cond ((viper-looking-at-alpha)
2766 (viper-skip-alpha-backward "_"))
2767 ((viper-looking-at-separator)
2769 (viper-skip-separators nil)
2770 (viper-backward-char-carefully)
2771 (cond ((viper-looking-at-alpha)
2772 (viper-skip-alpha-backward "_"))
2773 ((not (viper-looking-at-alphasep))
2774 (viper-skip-nonalphasep-backward))
2775 ((bobp)) ; could still be at separator, but at beg of buffer
2776 (t (forward-char))))
2777 ((not (viper-looking-at-alphasep))
2778 (viper-skip-nonalphasep-backward)))
2779 (setq val (1- val))))
2781 (defun viper-backward-word (arg)
2784 (viper-leave-region-active)
2785 (let ((val (viper-p-val arg))
2786 (com (viper-getcom arg)))
2789 (if (setq i (save-excursion (backward-char) (looking-at "\n")))
2791 (viper-move-marker-locally 'viper-com-point (point))
2792 (if i (forward-char))))
2793 (viper-backward-word-kernel val)
2794 (if com (viper-execute-com 'viper-backward-word val com))))
2796 (defun viper-backward-Word (arg)
2797 "Backward word delimited by white character."
2799 (viper-leave-region-active)
2800 (let ((val (viper-p-val arg))
2801 (com (viper-getcom arg)))
2804 (if (setq i (save-excursion (backward-char) (looking-at "\n")))
2806 (viper-move-marker-locally 'viper-com-point (point))
2807 (if i (forward-char))))
2809 (viper-skip-separators nil) ; nil means backward here
2810 (viper-skip-nonseparators 'backward))
2811 (if com (viper-execute-com 'viper-backward-Word val com))))
2817 (defun viper-beginning-of-line (arg)
2818 "Go to beginning of line."
2820 (viper-leave-region-active)
2821 (let ((val (viper-p-val arg))
2822 (com (viper-getcom arg)))
2823 (if com (viper-move-marker-locally 'viper-com-point (point)))
2824 (beginning-of-line val)
2825 (if com (viper-execute-com 'viper-beginning-of-line val com))))
2827 (defun viper-bol-and-skip-white (arg)
2828 "Beginning of line at first non-white character."
2830 (viper-leave-region-active)
2831 (let ((val (viper-p-val arg))
2832 (com (viper-getcom arg)))
2833 (if com (viper-move-marker-locally 'viper-com-point (point)))
2834 (forward-to-indentation (1- val))
2835 (if com (viper-execute-com 'viper-bol-and-skip-white val com))))
2837 (defun viper-goto-eol (arg)
2838 "Go to end of line."
2840 (viper-leave-region-active)
2841 (let ((val (viper-p-val arg))
2842 (com (viper-getcom arg)))
2843 (if com (viper-move-marker-locally 'viper-com-point (point)))
2845 (if com (viper-execute-com 'viper-goto-eol val com))
2846 (if viper-ex-style-motion
2847 (if (and (eolp) (not (bolp))
2848 ;; a fix for viper-change-to-eol
2849 (not (equal viper-current-state 'insert-state)))
2854 (defun viper-goto-col (arg)
2855 "Go to ARG's column."
2857 (viper-leave-region-active)
2858 (let ((val (viper-p-val arg))
2859 (com (viper-getcom arg))
2862 (viper-chars-in-region
2863 (viper-line-pos 'start) (viper-line-pos 'end)))
2864 (if com (viper-move-marker-locally 'viper-com-point (point)))
2866 (forward-char (1- (min line-len val)))
2867 (while (> (current-column) (1- val))
2869 (if com (viper-execute-com 'viper-goto-col val com))
2872 (if (> val (current-column)) (error "")))
2876 (defun viper-next-line (arg)
2879 (viper-leave-region-active)
2880 (let ((val (viper-p-val arg))
2881 (com (viper-getCom arg)))
2882 (if com (viper-move-marker-locally 'viper-com-point (point)))
2884 (if viper-ex-style-motion
2885 (if (and (eolp) (not (bolp))) (backward-char 1)))
2886 (setq this-command 'next-line)
2887 (if com (viper-execute-com 'viper-next-line val com))))
2889 (defun viper-next-line-at-bol (arg)
2890 "Next line at beginning of line."
2892 (viper-leave-region-active)
2895 (if (eobp) (error "Last line in buffer")))
2896 (let ((val (viper-p-val arg))
2897 (com (viper-getCom arg)))
2898 (if com (viper-move-marker-locally 'viper-com-point (point)))
2900 (back-to-indentation)
2901 (if com (viper-execute-com 'viper-next-line-at-bol val com))))
2904 (defun viper-previous-line (arg)
2905 "Go to previous line."
2907 (viper-leave-region-active)
2908 (let ((val (viper-p-val arg))
2909 (com (viper-getCom arg)))
2910 (if com (viper-move-marker-locally 'viper-com-point (point)))
2912 (if viper-ex-style-motion
2913 (if (and (eolp) (not (bolp))) (backward-char 1)))
2914 (setq this-command 'previous-line)
2915 (if com (viper-execute-com 'viper-previous-line val com))))
2918 (defun viper-previous-line-at-bol (arg)
2919 "Previous line at beginning of line."
2921 (viper-leave-region-active)
2924 (if (bobp) (error "First line in buffer")))
2925 (let ((val (viper-p-val arg))
2926 (com (viper-getCom arg)))
2927 (if com (viper-move-marker-locally 'viper-com-point (point)))
2928 (forward-line (- val))
2929 (back-to-indentation)
2930 (if com (viper-execute-com 'viper-previous-line val com))))
2932 (defun viper-change-to-eol (arg)
2933 "Change to end of line."
2935 (viper-goto-eol (cons arg ?c)))
2937 (defun viper-kill-line (arg)
2940 (viper-goto-eol (cons arg ?d)))
2942 (defun viper-erase-line (arg)
2945 (viper-beginning-of-line (cons arg ?d)))
2950 (defun viper-goto-line (arg)
2951 "Go to ARG's line. Without ARG go to end of buffer."
2953 (let ((val (viper-P-val arg))
2954 (com (viper-getCom arg)))
2955 (viper-move-marker-locally 'viper-com-point (point))
2956 (viper-deactivate-mark)
2959 (goto-char (point-max))
2960 (goto-char (point-min))
2961 (forward-line (1- val)))
2963 ;; positioning is done twice: before and after command execution
2964 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
2965 (back-to-indentation)
2967 (if com (viper-execute-com 'viper-goto-line val com))
2969 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
2970 (back-to-indentation)
2973 ;; Find ARG's occurrence of CHAR on the current line.
2974 ;; If FORWARD then search is forward, otherwise backward. OFFSET is used to
2975 ;; adjust point after search.
2976 (defun viper-find-char (arg char forward offset)
2977 (or (char-or-string-p char) (error ""))
2978 (let ((arg (if forward arg (- arg)))
2979 (cmd (if (eq viper-intermediate-command 'viper-repeat)
2981 (viper-array-to-string (this-command-keys))))
2982 point region-beg region-end)
2985 (if (> arg 0) ; forward
2987 (setq region-beg (point))
2988 (if viper-allow-multiline-replace-regions
2989 (viper-forward-paragraph 1)
2991 (setq region-end (point)))
2992 (setq region-end (point))
2993 (if viper-allow-multiline-replace-regions
2994 (viper-backward-paragraph 1)
2995 (beginning-of-line))
2996 (setq region-beg (point)))
2997 (if (or (and (< arg 0)
2998 (< (- region-end region-beg)
2999 (if viper-allow-multiline-replace-regions
3003 (< (- region-end region-beg)
3004 (if viper-allow-multiline-replace-regions
3007 (error "Command `%s': At %s of %s"
3009 (if (> arg 0) "end" "beginning")
3010 (if viper-allow-multiline-replace-regions
3011 "paragraph" "line")))
3012 (narrow-to-region region-beg region-end)
3013 ;; if arg > 0, point is forwarded before search.
3014 (if (> arg 0) (goto-char (1+ (point-min)))
3015 (goto-char (point-max)))
3016 (if (let ((case-fold-search nil))
3017 (search-forward (char-to-string char) nil 0 arg))
3018 (setq point (point))
3019 (error "Command `%s': `%c' not found" cmd char))))
3022 (backward-char (if offset 2 1))
3023 (forward-char (if offset 1 0)))))
3025 (defun viper-find-char-forward (arg)
3026 "Find char on the line.
3027 If called interactively read the char to find from the terminal, and if
3028 called from viper-repeat, the char last used is used. This behaviour is
3029 controlled by the sign of prefix numeric value."
3031 (let ((val (viper-p-val arg))
3032 (com (viper-getcom arg))
3033 (cmd-representation (nth 5 viper-d-com)))
3035 ;; this means that the function was called interactively
3036 (setq viper-f-char (read-char)
3039 ;; viper-repeat --- set viper-F-char from command-keys
3040 (setq viper-F-char (if (stringp cmd-representation)
3041 (viper-seq-last-elt cmd-representation)
3043 viper-f-char viper-F-char)
3045 (if com (viper-move-marker-locally 'viper-com-point (point)))
3047 val (if (> (viper-p-val arg) 0) viper-f-char viper-F-char) t nil)
3051 (setq viper-F-char viper-f-char) ; set new viper-F-char
3053 (viper-execute-com 'viper-find-char-forward val com)))))
3055 (defun viper-goto-char-forward (arg)
3056 "Go up to char ARG forward on line."
3058 (let ((val (viper-p-val arg))
3059 (com (viper-getcom arg))
3060 (cmd-representation (nth 5 viper-d-com)))
3062 ;; this means that the function was called interactively
3063 (setq viper-f-char (read-char)
3066 ;; viper-repeat --- set viper-F-char from command-keys
3067 (setq viper-F-char (if (stringp cmd-representation)
3068 (viper-seq-last-elt cmd-representation)
3070 viper-f-char viper-F-char)
3072 (if com (viper-move-marker-locally 'viper-com-point (point)))
3074 val (if (> (viper-p-val arg) 0) viper-f-char viper-F-char) t t)
3078 (setq viper-F-char viper-f-char) ; set new viper-F-char
3080 (viper-execute-com 'viper-goto-char-forward val com)))))
3082 (defun viper-find-char-backward (arg)
3083 "Find char ARG on line backward."
3085 (let ((val (viper-p-val arg))
3086 (com (viper-getcom arg))
3087 (cmd-representation (nth 5 viper-d-com)))
3089 ;; this means that the function was called interactively
3090 (setq viper-f-char (read-char)
3093 ;; viper-repeat --- set viper-F-char from command-keys
3094 (setq viper-F-char (if (stringp cmd-representation)
3095 (viper-seq-last-elt cmd-representation)
3097 viper-f-char viper-F-char)
3099 (if com (viper-move-marker-locally 'viper-com-point (point)))
3101 val (if (> (viper-p-val arg) 0) viper-f-char viper-F-char) nil nil)
3105 (setq viper-F-char viper-f-char) ; set new viper-F-char
3106 (viper-execute-com 'viper-find-char-backward val com)))))
3108 (defun viper-goto-char-backward (arg)
3109 "Go up to char ARG backward on line."
3111 (let ((val (viper-p-val arg))
3112 (com (viper-getcom arg))
3113 (cmd-representation (nth 5 viper-d-com)))
3115 ;; this means that the function was called interactively
3116 (setq viper-f-char (read-char)
3119 ;; viper-repeat --- set viper-F-char from command-keys
3120 (setq viper-F-char (if (stringp cmd-representation)
3121 (viper-seq-last-elt cmd-representation)
3123 viper-f-char viper-F-char)
3125 (if com (viper-move-marker-locally 'viper-com-point (point)))
3127 val (if (> (viper-p-val arg) 0) viper-f-char viper-F-char) nil t)
3131 (setq viper-F-char viper-f-char) ; set new viper-F-char
3132 (viper-execute-com 'viper-goto-char-backward val com)))))
3134 (defun viper-repeat-find (arg)
3135 "Repeat previous find command."
3137 (let ((val (viper-p-val arg))
3138 (com (viper-getcom arg)))
3139 (viper-deactivate-mark)
3140 (if com (viper-move-marker-locally 'viper-com-point (point)))
3141 (viper-find-char val viper-f-char viper-f-forward viper-f-offset)
3144 (if viper-f-forward (forward-char))
3145 (viper-execute-com 'viper-repeat-find val com)))))
3147 (defun viper-repeat-find-opposite (arg)
3148 "Repeat previous find command in the opposite direction."
3150 (let ((val (viper-p-val arg))
3151 (com (viper-getcom arg)))
3152 (viper-deactivate-mark)
3153 (if com (viper-move-marker-locally 'viper-com-point (point)))
3154 (viper-find-char val viper-f-char (not viper-f-forward) viper-f-offset)
3157 (if viper-f-forward (forward-char))
3158 (viper-execute-com 'viper-repeat-find-opposite val com)))))
3161 ;; window scrolling etc.
3163 (defun viper-window-top (arg)
3164 "Go to home window line."
3166 (let ((val (viper-p-val arg))
3167 (com (viper-getCom arg)))
3168 (viper-leave-region-active)
3169 (if com (viper-move-marker-locally 'viper-com-point (point)))
3171 (move-to-window-line (1- val))
3173 ;; positioning is done twice: before and after command execution
3174 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3175 (back-to-indentation)
3177 (if com (viper-execute-com 'viper-window-top val com))
3179 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3180 (back-to-indentation)
3183 (defun viper-window-middle (arg)
3184 "Go to middle window line."
3186 (let ((val (viper-p-val arg))
3187 (com (viper-getCom arg)))
3188 (viper-leave-region-active)
3189 (if com (viper-move-marker-locally 'viper-com-point (point)))
3191 (move-to-window-line (+ (/ (1- (window-height)) 2) (1- val)))
3193 ;; positioning is done twice: before and after command execution
3194 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3195 (back-to-indentation)
3197 (if com (viper-execute-com 'viper-window-middle val com))
3199 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3200 (back-to-indentation)
3203 (defun viper-window-bottom (arg)
3204 "Go to last window line."
3206 (let ((val (viper-p-val arg))
3207 (com (viper-getCom arg)))
3208 (viper-leave-region-active)
3209 (if com (viper-move-marker-locally 'viper-com-point (point)))
3211 (move-to-window-line (- val))
3213 ;; positioning is done twice: before and after command execution
3214 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3215 (back-to-indentation)
3217 (if com (viper-execute-com 'viper-window-bottom val com))
3219 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3220 (back-to-indentation)
3223 (defun viper-line-to-top (arg)
3224 "Put current line on the home line."
3226 (recenter (1- arg)))
3228 (defun viper-line-to-middle (arg)
3229 "Put current line on the middle line."
3231 (recenter (+ (1- arg) (/ (1- (window-height)) 2))))
3233 (defun viper-line-to-bottom (arg)
3234 "Put current line on the last line."
3236 (recenter (- (window-height) (1+ arg))))
3238 ;; If point is within viper-search-scroll-threshold of window top or bottom,
3239 ;; scroll up or down 1/7 of window height, depending on whether we are at the
3240 ;; bottom or at the top of the window. This function is called by viper-search
3241 ;; (which is called from viper-search-forward/backward/next). If the value of
3242 ;; viper-search-scroll-threshold is negative - don't scroll.
3243 (defun viper-adjust-window ()
3244 (let ((win-height (if viper-emacs-p
3245 (1- (window-height)) ; adjust for modeline
3246 (window-displayed-height)))
3248 at-top-p at-bottom-p
3249 min-scroll direction)
3251 (move-to-window-line 0) ; top
3253 (<= (count-lines pt (point))
3254 viper-search-scroll-threshold))
3255 (move-to-window-line -1) ; bottom
3257 (<= (count-lines pt (point)) viper-search-scroll-threshold))
3259 (cond (at-top-p (setq min-scroll (1- viper-search-scroll-threshold)
3261 (at-bottom-p (setq min-scroll (1+ viper-search-scroll-threshold)
3265 (* (max min-scroll (/ win-height 7)) direction)))
3270 ;; must correct this to only match ( to ) etc. On the other hand
3271 ;; it is good that paren match gets confused, because that way you
3272 ;; catch _all_ imbalances.
3274 (defun viper-paren-match (arg)
3275 "Go to the matching parenthesis."
3277 (viper-leave-region-active)
3278 (let ((com (viper-getcom arg))
3279 (parse-sexp-ignore-comments viper-parse-sexp-ignore-comments)
3282 (if (or (> arg 99) (< arg 1))
3283 (error "Prefix must be between 1 and 99")
3285 (if (> (point-max) 80000)
3286 (* (/ (point-max) 100) arg)
3287 (/ (* (point-max) arg) 100)))
3288 (back-to-indentation))
3289 (let (beg-lim end-lim)
3290 (if (and (eolp) (not (bolp))) (forward-char -1))
3291 (if (not (looking-at "[][(){}]"))
3292 (setq anchor-point (point)))
3295 (setq beg-lim (point))
3297 (setq end-lim (point)))
3298 (cond ((re-search-forward "[][(){}]" end-lim t)
3300 ((re-search-backward "[][(){}]" beg-lim t))
3302 (error "No matching character on line"))))
3303 (cond ((looking-at "[\(\[{]")
3304 (if com (viper-move-marker-locally 'viper-com-point (point)))
3307 (viper-execute-com 'viper-paren-match nil com)
3312 (viper-move-marker-locally 'viper-com-point anchor-point)
3314 (viper-execute-com 'viper-paren-match nil com)
3316 ((looking-at "[])}]")
3318 (if com (viper-move-marker-locally 'viper-com-point (point)))
3320 (if com (viper-execute-com 'viper-paren-match nil com)))
3323 (defun viper-toggle-parse-sexp-ignore-comments ()
3325 (setq viper-parse-sexp-ignore-comments
3326 (not viper-parse-sexp-ignore-comments))
3328 "From now on, `%%' will %signore parentheses inside comment fields"
3329 (if viper-parse-sexp-ignore-comments "" "NOT "))))
3332 ;; sentence, paragraph and heading
3334 (defun viper-forward-sentence (arg)
3337 (or (eq last-command this-command)
3339 (let ((val (viper-p-val arg))
3340 (com (viper-getcom arg)))
3341 (if com (viper-move-marker-locally 'viper-com-point (point)))
3342 (forward-sentence val)
3343 (if com (viper-execute-com 'viper-forward-sentence nil com))))
3345 (defun viper-backward-sentence (arg)
3346 "Backward sentence."
3348 (or (eq last-command this-command)
3350 (let ((val (viper-p-val arg))
3351 (com (viper-getcom arg)))
3352 (if com (viper-move-marker-locally 'viper-com-point (point)))
3353 (backward-sentence val)
3354 (if com (viper-execute-com 'viper-backward-sentence nil com))))
3356 (defun viper-forward-paragraph (arg)
3357 "Forward paragraph."
3359 (or (eq last-command this-command)
3361 (let ((val (viper-p-val arg))
3362 ;; if you want d} operate on whole lines, change viper-getcom to
3363 ;; viper-getCom below
3364 (com (viper-getcom arg)))
3365 (if com (viper-move-marker-locally 'viper-com-point (point)))
3366 (forward-paragraph val)
3370 (viper-execute-com 'viper-forward-paragraph nil com)))))
3372 (defun viper-backward-paragraph (arg)
3373 "Backward paragraph."
3375 (or (eq last-command this-command)
3377 (let ((val (viper-p-val arg))
3378 ;; if you want d{ operate on whole lines, change viper-getcom to
3379 ;; viper-getCom below
3380 (com (viper-getcom arg)))
3381 (if com (viper-move-marker-locally 'viper-com-point (point)))
3382 (backward-paragraph val)
3386 (viper-execute-com 'viper-backward-paragraph nil com)
3387 (backward-char 1)))))
3389 ;; should be mode-specific
3390 (defun viper-prev-heading (arg)
3392 (let ((val (viper-p-val arg))
3393 (com (viper-getCom arg)))
3394 (if com (viper-move-marker-locally 'viper-com-point (point)))
3395 (re-search-backward viper-heading-start nil t val)
3396 (goto-char (match-beginning 0))
3397 (if com (viper-execute-com 'viper-prev-heading nil com))))
3399 (defun viper-heading-end (arg)
3401 (let ((val (viper-p-val arg))
3402 (com (viper-getCom arg)))
3403 (if com (viper-move-marker-locally 'viper-com-point (point)))
3404 (re-search-forward viper-heading-end nil t val)
3405 (goto-char (match-beginning 0))
3406 (if com (viper-execute-com 'viper-heading-end nil com))))
3408 (defun viper-next-heading (arg)
3410 (let ((val (viper-p-val arg))
3411 (com (viper-getCom arg)))
3412 (if com (viper-move-marker-locally 'viper-com-point (point)))
3414 (re-search-forward viper-heading-start nil t val)
3415 (goto-char (match-beginning 0))
3416 (if com (viper-execute-com 'viper-next-heading nil com))))
3421 (defun viper-scroll-screen (arg)
3422 "Scroll to next screen."
3428 (setq arg (1- arg)))
3431 (setq arg (1+ arg))))
3435 (message "End of buffer")
3436 (goto-char (point-max)))
3437 (message "Beginning of buffer")
3438 (goto-char (point-min))))
3441 (defun viper-scroll-screen-back (arg)
3442 "Scroll to previous screen."
3444 (viper-scroll-screen (- arg)))
3446 (defun viper-scroll-down (arg)
3447 "Pull down half screen."
3451 (scroll-down (/ (window-height) 2))
3454 (message "Beginning of buffer")
3455 (goto-char (point-min)))))
3457 (defun viper-scroll-down-one (arg)
3458 "Scroll up one line."
3462 (defun viper-scroll-up (arg)
3463 "Pull up half screen."
3467 (scroll-up (/ (window-height) 2))
3470 (message "End of buffer")
3471 (goto-char (point-max)))))
3473 (defun viper-scroll-up-one (arg)
3474 "Scroll down one line."
3481 (defun viper-if-string (prompt)
3482 (if (memq viper-intermediate-command
3483 '(viper-command-argument viper-digit-argument viper-repeat))
3484 (setq viper-this-command-keys (this-command-keys)))
3485 (let ((s (viper-read-string-with-history
3488 'viper-search-history
3489 (car viper-search-history))))
3490 (if (not (string= s ""))
3491 (setq viper-s-string s))))
3494 (defun viper-toggle-search-style (arg)
3495 "Toggle the value of viper-case-fold-search/viper-re-search.
3496 Without prefix argument, will ask which search style to toggle. With prefix
3497 arg 1,toggles viper-case-fold-search; with arg 2 toggles viper-re-search.
3499 Although this function is bound to \\[viper-toggle-search-style], the most
3500 convenient way to use it is to bind `//' to the macro
3501 `1 M-x viper-toggle-search-style' and `///' to
3502 `2 M-x viper-toggle-search-style'. In this way, hitting `//' quickly will
3503 toggle case-fold-search and hitting `/' three times witth toggle regexp
3504 search. Macros are more convenient in this case because they don't affect
3505 the Emacs binding of `/'."
3508 (cond ((or (eq arg 1)
3510 (y-or-n-p (format "Search style: '%s'. Want '%s'? "
3511 (if viper-case-fold-search
3512 "case-insensitive" "case-sensitive")
3513 (if viper-case-fold-search
3515 "case-insensitive")))))
3516 (setq viper-case-fold-search (null viper-case-fold-search))
3517 (if viper-case-fold-search
3518 (setq msg "Search becomes case-insensitive")
3519 (setq msg "Search becomes case-sensitive")))
3522 (y-or-n-p (format "Search style: '%s'. Want '%s'? "
3524 "regexp-search" "vanilla-search")
3527 "regexp-search")))))
3528 (setq viper-re-search (null viper-re-search))
3530 (setq msg "Search becomes regexp-style")
3531 (setq msg "Search becomes vanilla-style")))
3533 (setq msg "Search style remains unchanged")))
3536 (defun viper-set-searchstyle-toggling-macros (unset)
3537 "Set the macros for toggling the search style in Viper's vi-state.
3538 The macro that toggles case sensitivity is bound to `//', and the one that
3539 toggles regexp search is bound to `///'.
3540 With a prefix argument, this function unsets the macros. "
3545 ;; toggle case sensitivity in search
3546 (viper-record-kbd-macro
3548 [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]
3550 ;; toggle regexp/vanila search
3551 (viper-record-kbd-macro
3553 [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]
3557 "// and /// now toggle case-sensitivity and regexp search")))
3558 (viper-unrecord-kbd-macro "//" 'vi-state)
3560 (viper-unrecord-kbd-macro "///" 'vi-state))))
3563 (defun viper-set-parsing-style-toggling-macro (unset)
3564 "Set `%%%' to be a macro that toggles whether comment fields should be parsed for matching parentheses.
3565 This is used in conjunction with the `%' command.
3567 With a prefix argument, unsets the macro."
3572 ;; Make %%% toggle parsing comments for matching parentheses
3573 (viper-record-kbd-macro
3575 [(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]
3579 "%%%%%% now toggles whether comments should be parsed for matching parentheses")))
3580 (viper-unrecord-kbd-macro "%%%" 'vi-state))))
3583 (defun viper-set-emacs-state-searchstyle-macros (unset &optional arg-majormode)
3584 "Set the macros for toggling the search style in Viper's emacs-state.
3585 The macro that toggles case sensitivity is bound to `//', and the one that
3586 toggles regexp search is bound to `///'.
3587 With a prefix argument, this function unsets the macros.
3588 If the optional prefix argument is non-nil and specifies a valid major mode,
3589 this sets the macros only in the macros in that major mode. Otherwise,
3590 the macros are set in the current major mode.
3591 \(When unsetting the macros, the second argument has no effect.\)"
3596 ;; toggle case sensitivity in search
3597 (viper-record-kbd-macro
3599 [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]
3600 (or arg-majormode major-mode))
3601 ;; toggle regexp/vanila search
3602 (viper-record-kbd-macro
3604 [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]
3605 (or arg-majormode major-mode))
3608 "// and /// now toggle case-sensitivity and regexp search.")))
3609 (viper-unrecord-kbd-macro "//" 'emacs-state)
3611 (viper-unrecord-kbd-macro "///" 'emacs-state))))
3614 (defun viper-search-forward (arg)
3615 "Search a string forward.
3616 ARG is used to find the ARG's occurrence of the string.
3617 Null string will repeat previous search."
3619 (let ((val (viper-P-val arg))
3620 (com (viper-getcom arg))
3621 (old-str viper-s-string))
3622 (setq viper-s-forward t)
3623 (viper-if-string "/")
3624 ;; this is not used at present, but may be used later
3625 (if (or (not (equal old-str viper-s-string))
3626 (not (markerp viper-local-search-start-marker))
3627 (not (marker-buffer viper-local-search-start-marker)))
3628 (setq viper-local-search-start-marker (point-marker)))
3629 (viper-search viper-s-string t val)
3632 (viper-move-marker-locally 'viper-com-point (mark t))
3633 (viper-execute-com 'viper-search-next val com)))))
3635 (defun viper-search-backward (arg)
3636 "Search a string backward.
3637 ARG is used to find the ARG's occurrence of the string.
3638 Null string will repeat previous search."
3640 (let ((val (viper-P-val arg))
3641 (com (viper-getcom arg))
3642 (old-str viper-s-string))
3643 (setq viper-s-forward nil)
3644 (viper-if-string "?")
3645 ;; this is not used at present, but may be used later
3646 (if (or (not (equal old-str viper-s-string))
3647 (not (markerp viper-local-search-start-marker))
3648 (not (marker-buffer viper-local-search-start-marker)))
3649 (setq viper-local-search-start-marker (point-marker)))
3650 (viper-search viper-s-string nil val)
3653 (viper-move-marker-locally 'viper-com-point (mark t))
3654 (viper-execute-com 'viper-search-next val com)))))
3657 ;; Search for COUNT's occurrence of STRING.
3658 ;; Search is forward if FORWARD is non-nil, otherwise backward.
3659 ;; INIT-POINT is the position where search is to start.
3661 ;; (STRING FORW COUNT &optional NO-OFFSET INIT-POINT LIMIT FAIL-IF-NOT-FOUND)
3662 (defun viper-search (string forward arg
3663 &optional no-offset init-point fail-if-not-found)
3664 (if (not (equal string ""))
3665 (let ((val (viper-p-val arg))
3666 (com (viper-getcom arg))
3667 (offset (not no-offset))
3668 (case-fold-search viper-case-fold-search)
3669 (start-point (or init-point (point))))
3670 (viper-deactivate-mark)
3674 (if offset (viper-forward-char-carefully))
3677 (re-search-forward string nil nil val)
3678 (re-search-backward string))
3679 (search-forward string nil nil val)
3680 (search-backward string))
3681 (if (not (equal start-point (point)))
3682 (push-mark start-point t)))
3684 (if (and (not fail-if-not-found) viper-search-wrap-around-t)
3686 (message "Search wrapped around BOTTOM of buffer")
3687 (goto-char (point-min))
3688 (viper-search string forward (cons 1 com) t start-point 'fail)
3689 ;; don't wait in macros
3690 (or executing-kbd-macro
3691 (memq viper-intermediate-command
3693 viper-digit-argument
3694 viper-command-argument))
3696 ;; delete the wrap-around message
3699 (goto-char start-point)
3700 (error "`%s': %s not found"
3702 (if viper-re-search "Pattern" "String"))
3708 (re-search-backward string nil nil val)
3709 (search-backward string nil nil val))
3710 (if (not (equal start-point (point)))
3711 (push-mark start-point t)))
3713 (if (and (not fail-if-not-found) viper-search-wrap-around-t)
3715 (message "Search wrapped around TOP of buffer")
3716 (goto-char (point-max))
3717 (viper-search string forward (cons 1 com) t start-point 'fail)
3718 ;; don't wait in macros
3719 (or executing-kbd-macro
3720 (memq viper-intermediate-command
3722 viper-digit-argument
3723 viper-command-argument))
3725 ;; delete the wrap-around message
3728 (goto-char start-point)
3729 (error "`%s': %s not found"
3731 (if viper-re-search "Pattern" "String"))
3733 ;; pull up or down if at top/bottom of window
3734 (viper-adjust-window)
3735 ;; highlight the result of search
3736 ;; don't wait and don't highlight in macros
3737 (or executing-kbd-macro
3738 (memq viper-intermediate-command
3739 '(viper-repeat viper-digit-argument viper-command-argument))
3740 (viper-flash-search-pattern))
3743 (defun viper-search-next (arg)
3744 "Repeat previous search."
3746 (let ((val (viper-p-val arg))
3747 (com (viper-getcom arg)))
3748 (if (null viper-s-string) (error viper-NoPrevSearch))
3749 (viper-search viper-s-string viper-s-forward arg)
3752 (viper-move-marker-locally 'viper-com-point (mark t))
3753 (viper-execute-com 'viper-search-next val com)))))
3755 (defun viper-search-Next (arg)
3756 "Repeat previous search in the reverse direction."
3758 (let ((val (viper-p-val arg))
3759 (com (viper-getcom arg)))
3760 (if (null viper-s-string) (error viper-NoPrevSearch))
3761 (viper-search viper-s-string (not viper-s-forward) arg)
3764 (viper-move-marker-locally 'viper-com-point (mark t))
3765 (viper-execute-com 'viper-search-Next val com)))))
3768 ;; Search contents of buffer defined by one of Viper's motion commands.
3769 ;; Repeatable via `n' and `N'.
3770 (defun viper-buffer-search-enable (&optional c)
3771 (cond (c (setq viper-buffer-search-char c))
3772 ((null viper-buffer-search-char)
3773 (setq viper-buffer-search-char ?g)))
3774 (define-key viper-vi-basic-map
3775 (cond ((viper-characterp viper-buffer-search-char)
3776 (char-to-string viper-buffer-search-char))
3777 (t (error "viper-buffer-search-char: wrong value type, %s"
3778 viper-buffer-search-char)))
3779 'viper-command-argument)
3780 (aset viper-exec-array viper-buffer-search-char 'viper-exec-buffer-search)
3781 (setq viper-prefix-commands
3782 (cons viper-buffer-search-char viper-prefix-commands)))
3784 ;; This is a Viper wraper for isearch-forward.
3785 (defun viper-isearch-forward (arg)
3786 "Do incremental search forward."
3788 ;; emacs bug workaround
3789 (if (listp arg) (setq arg (car arg)))
3790 (viper-exec-form-in-emacs (list 'isearch-forward arg)))
3792 ;; This is a Viper wraper for isearch-backward."
3793 (defun viper-isearch-backward (arg)
3794 "Do incremental search backward."
3796 ;; emacs bug workaround
3797 (if (listp arg) (setq arg (car arg)))
3798 (viper-exec-form-in-emacs (list 'isearch-backward arg)))
3801 ;; visiting and killing files, buffers
3803 (defun viper-switch-to-buffer ()
3804 "Switch to buffer in the current window."
3806 (let ((other-buffer (other-buffer (current-buffer)))
3809 (funcall viper-read-buffer-function
3810 "Switch to buffer in this window: " other-buffer))
3811 (switch-to-buffer buffer)))
3813 (defun viper-switch-to-buffer-other-window ()
3814 "Switch to buffer in another window."
3816 (let ((other-buffer (other-buffer (current-buffer)))
3819 (funcall viper-read-buffer-function
3820 "Switch to buffer in another window: " other-buffer))
3821 (switch-to-buffer-other-window buffer)))
3823 (defun viper-kill-buffer ()
3826 (let (buffer buffer-name)
3828 (funcall viper-read-buffer-function
3829 (format "Kill buffer \(%s\): "
3830 (buffer-name (current-buffer)))))
3832 (if (null buffer-name)
3834 (get-buffer buffer-name)))
3835 (if (null buffer) (error "`%s': No such buffer" buffer-name))
3836 (if (or (not (buffer-modified-p buffer))
3839 "Buffer `%s' is modified, are you sure you want to kill it? "
3841 (kill-buffer buffer)
3842 (error "Buffer not killed"))))
3848 (defsubst viper-yank (text)
3849 "Yank TEXT silently. This works correctly with Emacs's yank-pop command."
3851 (setq this-command 'yank))
3853 (defun viper-put-back (arg)
3854 "Put back after point/below line."
3856 (let ((val (viper-p-val arg))
3857 (text (if viper-use-register
3858 (cond ((viper-valid-register viper-use-register '(digit))
3860 (- viper-use-register ?1) 'do-not-rotate))
3861 ((viper-valid-register viper-use-register)
3862 (get-register (downcase viper-use-register)))
3863 (t (error viper-InvalidRegister viper-use-register)))
3865 sv-point chars-inserted lines-inserted)
3867 (if viper-use-register
3868 (let ((reg viper-use-register))
3869 (setq viper-use-register nil)
3870 (error viper-EmptyRegister reg))
3872 (setq viper-use-register nil)
3873 (if (viper-end-with-a-newline-p text)
3879 (beginning-of-line))
3880 (if (not (eolp)) (viper-forward-char-carefully)))
3881 (set-marker (viper-mark-marker) (point) (current-buffer))
3882 (viper-set-destructive-command
3883 (list 'viper-put-back val nil viper-use-register nil nil))
3884 (setq sv-point (point))
3885 (viper-loop val (viper-yank text))
3886 (setq chars-inserted (abs (- (point) sv-point))
3887 lines-inserted (abs (count-lines (point) sv-point)))
3888 (if (or (> chars-inserted viper-change-notification-threshold)
3889 (> lines-inserted viper-change-notification-threshold))
3890 (message "Inserted %d character(s), %d line(s)"
3891 chars-inserted lines-inserted)))
3892 ;; Vi puts cursor on the last char when the yanked text doesn't contain a
3893 ;; newline; it leaves the cursor at the beginning when the text contains
3895 (if (viper-same-line (point) (mark))
3896 (or (= (point) (mark)) (viper-backward-char-carefully))
3897 (exchange-point-and-mark)
3899 (back-to-indentation)))
3900 (viper-deactivate-mark))
3902 (defun viper-Put-back (arg)
3903 "Put back at point/above line."
3905 (let ((val (viper-p-val arg))
3906 (text (if viper-use-register
3907 (cond ((viper-valid-register viper-use-register '(digit))
3909 (- viper-use-register ?1) 'do-not-rotate))
3910 ((viper-valid-register viper-use-register)
3911 (get-register (downcase viper-use-register)))
3912 (t (error viper-InvalidRegister viper-use-register)))
3914 sv-point chars-inserted lines-inserted)
3916 (if viper-use-register
3917 (let ((reg viper-use-register))
3918 (setq viper-use-register nil)
3919 (error viper-EmptyRegister reg))
3921 (setq viper-use-register nil)
3922 (if (viper-end-with-a-newline-p text) (beginning-of-line))
3923 (viper-set-destructive-command
3924 (list 'viper-Put-back val nil viper-use-register nil nil))
3925 (set-marker (viper-mark-marker) (point) (current-buffer))
3926 (setq sv-point (point))
3927 (viper-loop val (viper-yank text))
3928 (setq chars-inserted (abs (- (point) sv-point))
3929 lines-inserted (abs (count-lines (point) sv-point)))
3930 (if (or (> chars-inserted viper-change-notification-threshold)
3931 (> lines-inserted viper-change-notification-threshold))
3932 (message "Inserted %d character(s), %d line(s)"
3933 chars-inserted lines-inserted)))
3934 ;; Vi puts cursor on the last char when the yanked text doesn't contain a
3935 ;; newline; it leaves the cursor at the beginning when the text contains
3937 (if (viper-same-line (point) (mark))
3938 (or (= (point) (mark)) (viper-backward-char-carefully))
3939 (exchange-point-and-mark)
3941 (back-to-indentation)))
3942 (viper-deactivate-mark))
3945 ;; Copy region to kill-ring.
3946 ;; If BEG and END do not belong to the same buffer, copy empty region.
3947 (defun viper-copy-region-as-kill (beg end)
3949 (copy-region-as-kill beg end)
3950 (error (copy-region-as-kill beg beg))))
3953 (defun viper-delete-char (arg)
3954 "Delete next character."
3956 (let ((val (viper-p-val arg))
3958 (viper-set-destructive-command
3959 (list 'viper-delete-char val nil nil nil nil))
3960 (if (and viper-ex-style-editing
3961 (> val (viper-chars-in-region (point) (viper-line-pos 'end))))
3962 (setq val (viper-chars-in-region (point) (viper-line-pos 'end))))
3963 (if (and viper-ex-style-motion (eolp))
3964 (if (bolp) (error "") (setq val 0))) ; not bol---simply back 1 ch
3966 (viper-forward-char-carefully val)
3967 (setq end-del-pos (point)))
3968 (if viper-use-register
3970 (cond ((viper-valid-register viper-use-register '((Letter)))
3971 (viper-append-to-register
3972 (downcase viper-use-register) (point) end-del-pos))
3973 ((viper-valid-register viper-use-register)
3975 viper-use-register (point) end-del-pos nil))
3976 (t (error viper-InvalidRegister viper-use-register)))
3977 (setq viper-use-register nil)))
3980 (if viper-ex-style-motion
3981 (if (and (eolp) (not (bolp))) (backward-char 1)))
3984 (defun viper-delete-backward-char (arg)
3985 "Delete previous character. On reaching beginning of line, stop and beep."
3987 (let ((val (viper-p-val arg))
3989 (viper-set-destructive-command
3990 (list 'viper-delete-backward-char val nil nil nil nil))
3992 viper-ex-style-editing
3993 (> val (viper-chars-in-region (viper-line-pos 'start) (point))))
3994 (setq val (viper-chars-in-region (viper-line-pos 'start) (point))))
3996 (viper-backward-char-carefully val)
3997 (setq end-del-pos (point)))
3998 (if viper-use-register
4000 (cond ((viper-valid-register viper-use-register '(Letter))
4001 (viper-append-to-register
4002 (downcase viper-use-register) end-del-pos (point)))
4003 ((viper-valid-register viper-use-register)
4005 viper-use-register end-del-pos (point) nil))
4006 (t (error viper-InvalidRegister viper-use-register)))
4007 (setq viper-use-register nil)))
4008 (if (and (bolp) viper-ex-style-editing)
4010 (delete-backward-char val t)))
4013 (defun viper-del-backward-char-in-insert ()
4014 "Delete 1 char backwards while in insert mode."
4016 (if (and viper-ex-style-editing (bolp))
4018 (delete-backward-char 1 t)))
4021 (defun viper-del-backward-char-in-replace ()
4022 "Delete one character in replace mode.
4023 If `viper-delete-backwards-in-replace' is t, then DEL key actually deletes
4024 charecters. If it is nil, then the cursor just moves backwards, similarly
4025 to Vi. The variable `viper-ex-style-editing', if t, doesn't let the
4026 cursor move past the beginning of line."
4028 (cond (viper-delete-backwards-in-replace
4030 (delete-backward-char 1 t))
4031 (viper-ex-style-editing
4036 (delete-backward-char 1 t))))
4037 (viper-ex-style-editing
4042 (backward-char 1))))
4048 (defun viper-join-lines (arg)
4049 "Join this line to next, if ARG is nil. Otherwise, join ARG lines."
4051 (let ((val (viper-P-val arg)))
4052 (viper-set-destructive-command
4053 (list 'viper-join-lines val nil nil nil nil))
4054 (viper-loop (if (null val) 1 (1- val))
4059 (delete-region (point) (1- (point)))
4061 ;; fixup-whitespace sometimes does not leave space
4062 ;; between objects, so we insert it as in Vi
4063 (or (looking-at " ")
4071 (defun viper-change (beg end)
4072 (if (markerp beg) (setq beg (marker-position beg)))
4073 (if (markerp end) (setq end (marker-position end)))
4074 ;; beg is sometimes (mark t), which may be nil
4075 (or beg (setq beg end))
4077 (viper-set-complex-command-for-undo)
4078 (if viper-use-register
4080 (copy-to-register viper-use-register beg end nil)
4081 (setq viper-use-register nil)))
4082 (viper-set-replace-overlay beg end)
4083 (setq last-command nil) ; separate repl text from prev kills
4085 (if (= (viper-replace-start) (point-max))
4086 (error "End of buffer"))
4088 (setq viper-last-replace-region
4089 (buffer-substring (viper-replace-start)
4090 (viper-replace-end)))
4092 ;; protect against error while inserting "@" and other disasters
4093 ;; (e.g., read-only buff)
4094 (condition-case conds
4095 (if (or viper-allow-multiline-replace-regions
4096 (viper-same-line (viper-replace-start)
4097 (viper-replace-end)))
4099 ;; tabs cause problems in replace, so untabify
4100 (goto-char (viper-replace-end))
4101 (insert-before-markers "@") ; put placeholder after the TAB
4102 (untabify (viper-replace-start) (point))
4103 ;; del @, don't put on kill ring
4104 (delete-backward-char 1)
4106 (viper-set-replace-overlay-glyphs
4107 viper-replace-region-start-delimiter
4108 viper-replace-region-end-delimiter)
4109 ;; this move takes care of the last posn in the overlay, which
4110 ;; has to be shifted because of insert. We can't simply insert
4111 ;; "$" before-markers because then overlay-start will shift the
4112 ;; beginning of the overlay in case we are replacing a single
4113 ;; character. This fixes the bug with `s' and `cl' commands.
4114 (viper-move-replace-overlay (viper-replace-start) (point))
4115 (goto-char (viper-replace-start))
4116 (viper-change-state-to-replace t))
4117 (kill-region (viper-replace-start)
4118 (viper-replace-end))
4119 (viper-hide-replace-overlay)
4120 (viper-change-state-to-insert))
4121 (error ;; make sure that the overlay doesn't stay.
4122 ;; go back to the original point
4123 (goto-char (viper-replace-start))
4124 (viper-hide-replace-overlay)
4125 (viper-message-conditions conds))))
4128 (defun viper-change-subr (beg end)
4129 ;; beg is sometimes (mark t), which may be nil
4130 (or beg (setq beg end))
4131 (if viper-use-register
4133 (copy-to-register viper-use-register beg end nil)
4134 (setq viper-use-register nil)))
4135 (kill-region beg end)
4136 (setq this-command 'viper-change)
4137 (viper-yank-last-insertion))
4139 (defun viper-toggle-case (arg)
4140 "Toggle character case."
4142 (let ((val (viper-p-val arg)) (c))
4143 (viper-set-destructive-command
4144 (list 'viper-toggle-case val nil nil nil nil))
4146 (setq c (following-char))
4148 (if (eq c (upcase c))
4149 (insert-char (downcase c) 1)
4150 (insert-char (upcase c) 1))
4151 (if (eolp) (backward-char 1))
4152 (setq val (1- val)))))
4157 (defun viper-query-replace ()
4159 If a null string is suplied as the string to be replaced,
4160 the query replace mode will toggle between string replace
4161 and regexp replace."
4164 (setq str (viper-read-string-with-history
4165 (if viper-re-query-replace "Query replace regexp: "
4168 'viper-replace1-history
4169 (car viper-replace1-history) ; default
4171 (if (string= str "")
4173 (setq viper-re-query-replace (not viper-re-query-replace))
4174 (message "Query replace mode changed to %s"
4175 (if viper-re-query-replace "regexp replace"
4177 (if viper-re-query-replace
4178 (query-replace-regexp
4180 (viper-read-string-with-history
4181 (format "Query replace regexp `%s' with: " str)
4183 'viper-replace1-history
4184 (car viper-replace1-history) ; default
4188 (viper-read-string-with-history
4189 (format "Query replace `%s' with: " str)
4191 'viper-replace1-history
4192 (car viper-replace1-history) ; default
4198 (defun viper-mark-beginning-of-buffer ()
4199 "Mark beginning of buffer."
4202 (goto-char (point-min))
4203 (exchange-point-and-mark)
4204 (message "Mark set at the beginning of buffer"))
4206 (defun viper-mark-end-of-buffer ()
4207 "Mark end of buffer."
4210 (goto-char (point-max))
4211 (exchange-point-and-mark)
4212 (message "Mark set at the end of buffer"))
4214 (defun viper-mark-point ()
4215 "Set mark at point of buffer."
4217 (let ((char (read-char)))
4218 (cond ((and (<= ?a char) (<= char ?z))
4219 (point-to-register (1+ (- char ?a))))
4220 ((= char ?<) (viper-mark-beginning-of-buffer))
4221 ((= char ?>) (viper-mark-end-of-buffer))
4222 ((= char ?.) (viper-set-mark-if-necessary))
4223 ((= char ?,) (viper-cycle-through-mark-ring))
4224 ((= char ?^) (push-mark viper-saved-mark t t))
4225 ((= char ?D) (mark-defun))
4229 ;; Algorithm: If first invocation of this command save mark on ring, goto
4230 ;; mark, M0, and pop the most recent elt from the mark ring into mark,
4231 ;; making it into the new mark, M1.
4232 ;; Push this mark back and set mark to the original point position, p1.
4233 ;; So, if you hit '' or `` then you can return to p1.
4235 ;; If repeated command, pop top elt from the ring into mark and
4236 ;; jump there. This forgets the position, p1, and puts M1 back into mark.
4237 ;; Then we save the current pos, which is M0, jump to M1 and pop M2 from
4238 ;; the ring into mark. Push M2 back on the ring and set mark to M0.
4240 (defun viper-cycle-through-mark-ring ()
4241 "Visit previous locations on the mark ring.
4242 One can use `` and '' to temporarily jump 1 step back."
4243 (let* ((sv-pt (point)))
4244 ;; if repeated `m,' command, pop the previously saved mark.
4245 ;; Prev saved mark is actually prev saved point. It is used if the
4246 ;; user types `` or '' and is discarded
4247 ;; from the mark ring by the next `m,' command.
4248 ;; In any case, go to the previous or previously saved mark.
4249 ;; Then push the current mark (popped off the ring) and set current
4250 ;; point to be the mark. Current pt as mark is discarded by the next
4252 (if (eq last-command 'viper-cycle-through-mark-ring)
4254 ;; save current mark if the first iteration
4255 (setq mark-ring (delete (viper-mark-marker) mark-ring))
4257 (push-mark (mark t) t)) )
4259 (set-mark-command 1)
4260 ;; don't duplicate mark on the ring
4261 (setq mark-ring (delete (viper-mark-marker) mark-ring))
4263 (viper-deactivate-mark)
4264 (setq this-command 'viper-cycle-through-mark-ring)
4268 (defun viper-goto-mark (arg)
4271 (let ((char (read-char))
4272 (com (viper-getcom arg)))
4273 (viper-goto-mark-subr char com nil)))
4275 (defun viper-goto-mark-and-skip-white (arg)
4276 "Go to mark and skip to first non-white character on line."
4278 (let ((char (read-char))
4279 (com (viper-getCom arg)))
4280 (viper-goto-mark-subr char com t)))
4282 (defun viper-goto-mark-subr (char com skip-white)
4285 (error "Empty buffer")
4287 (cond ((viper-valid-register char '(letter))
4288 (let* ((buff (current-buffer))
4289 (reg (1+ (- char ?a)))
4290 (text-marker (get-register reg)))
4291 ;; If marker points to file that had markers set (and those markers
4292 ;; were saved (as e.g., in session.el), then restore those markers
4293 (if (and (consp text-marker)
4294 (eq (car text-marker) 'file-query)
4295 (or (find-buffer-visiting (nth 1 text-marker))
4296 (y-or-n-p (format "Visit file %s again? "
4297 (nth 1 text-marker)))))
4299 (find-file (nth 1 text-marker))
4300 (when (and (<= (nth 2 text-marker) (point-max))
4301 (<= (point-min) (nth 2 text-marker)))
4302 (setq text-marker (copy-marker (nth 2 text-marker)))
4303 (set-register reg text-marker))))
4304 (if com (viper-move-marker-locally 'viper-com-point (point)))
4305 (if (not (viper-valid-marker text-marker))
4306 (error viper-EmptyTextmarker char))
4307 (if (and (viper-same-line (point) viper-last-jump)
4308 (= (point) viper-last-jump-ignore))
4309 (push-mark viper-last-jump t)
4310 (push-mark nil t)) ; no msg
4311 (viper-register-to-point reg)
4312 (setq viper-last-jump (point-marker))
4314 (back-to-indentation)
4315 (setq viper-last-jump-ignore (point))))
4317 (if (equal buff (current-buffer))
4318 (viper-execute-com (if skip-white
4319 'viper-goto-mark-and-skip-white
4322 (switch-to-buffer buff)
4323 (goto-char viper-com-point)
4324 (viper-change-state-to-vi)
4326 ((and (not skip-white) (= char ?`))
4327 (if com (viper-move-marker-locally 'viper-com-point (point)))
4328 (if (and (viper-same-line (point) viper-last-jump)
4329 (= (point) viper-last-jump-ignore))
4330 (goto-char viper-last-jump))
4331 (if (null (mark t)) (error "Mark is not set in this buffer"))
4332 (if (= (point) (mark t)) (pop-mark))
4333 (exchange-point-and-mark)
4334 (setq viper-last-jump (point-marker)
4335 viper-last-jump-ignore 0)
4336 (if com (viper-execute-com 'viper-goto-mark nil com)))
4337 ((and skip-white (= char ?'))
4338 (if com (viper-move-marker-locally 'viper-com-point (point)))
4339 (if (and (viper-same-line (point) viper-last-jump)
4340 (= (point) viper-last-jump-ignore))
4341 (goto-char viper-last-jump))
4342 (if (= (point) (mark t)) (pop-mark))
4343 (exchange-point-and-mark)
4344 (setq viper-last-jump (point))
4345 (back-to-indentation)
4346 (setq viper-last-jump-ignore (point))
4347 (if com (viper-execute-com 'viper-goto-mark-and-skip-white nil com)))
4348 (t (error viper-InvalidTextmarker char))))
4350 (defun viper-insert-tab ()
4354 (defun viper-exchange-point-and-mark ()
4356 (exchange-point-and-mark)
4357 (back-to-indentation))
4359 ;; Input Mode Indentation
4361 ;; Returns t, if the string before point matches the regexp STR.
4362 (defsubst viper-looking-back (str)
4363 (and (save-excursion (re-search-backward str nil t))
4364 (= (point) (match-end 0))))
4367 (defun viper-forward-indent ()
4368 "Indent forward -- `C-t' in Vi."
4371 (indent-to (+ (current-column) viper-shift-width)))
4373 (defun viper-backward-indent ()
4374 "Backtab, C-d in VI"
4377 (let ((p (point)) (c (current-column)) bol (indent t))
4378 (if (viper-looking-back "[0^]")
4380 (if (eq ?^ (preceding-char))
4381 (setq viper-preserve-indent t))
4382 (delete-backward-char 1)
4388 (if (re-search-backward "[^ \t]" bol 1) (forward-char))
4389 (delete-region (point) p)
4391 (indent-to (- c viper-shift-width)))
4392 (if (or (bolp) (viper-looking-back "[^ \t]"))
4393 (setq viper-cted nil)))))
4395 (defun viper-autoindent ()
4396 "Auto Indentation, Vi-style."
4398 (let ((col (current-indentation)))
4399 (if abbrev-mode (expand-abbrev))
4400 (if viper-preserve-indent
4401 (setq viper-preserve-indent nil)
4402 (setq viper-current-indent col))
4403 ;; don't leave whitespace lines around
4404 (if (memq last-command
4406 viper-open-line viper-Open-line
4407 viper-replace-state-exit-cmd))
4408 (indent-to-left-margin))
4409 ;; use \n instead of newline, or else <Return> will move the insert point
4412 (if viper-auto-indent
4415 (if (and viper-electric-mode
4417 (memq major-mode '(fundamental-mode
4419 paragraph-indent-text-mode ))))
4420 (indent-according-to-mode)
4421 (indent-to viper-current-indent))
4426 ;; Viewing registers
4428 (defun viper-ket-function (arg)
4429 "Function called by \], the ket. View registers and call \]\]."
4431 (let ((reg (read-char)))
4432 (cond ((viper-valid-register reg '(letter Letter))
4433 (view-register (downcase reg)))
4434 ((viper-valid-register reg '(digit))
4435 (let ((text (current-kill (- reg ?1) 'do-not-rotate)))
4436 (with-output-to-temp-buffer " *viper-info*"
4437 (princ (format "Register %c contains the string:\n" reg))
4441 (viper-next-heading arg))
4443 viper-InvalidRegister reg)))))
4445 (defun viper-brac-function (arg)
4446 "Function called by \[, the brac. View textmarkers and call \[\["
4448 (let ((reg (read-char)))
4450 (viper-prev-heading arg))
4452 (viper-heading-end arg))
4453 ((viper-valid-register reg '(letter))
4454 (let* ((val (get-register (1+ (- reg ?a))))
4455 (buf (if (not (markerp val))
4456 (error viper-EmptyTextmarker reg)
4457 (marker-buffer val)))
4458 (pos (marker-position val))
4459 line-no text (s pos) (e pos))
4460 (with-output-to-temp-buffer " *viper-info*"
4465 (setq line-no (1+ (count-lines (point-min) val)))
4468 (if (re-search-backward "[^ \t]" nil t)
4474 (if (re-search-forward "[^ \t]" nil t)
4478 (setq text (buffer-substring s e))
4479 (setq text (format "%s<%c>%s"
4480 (substring text 0 (- pos s))
4481 reg (substring text (- pos s)))))
4484 "Textmarker `%c' is in buffer `%s' at line %d.\n"
4485 reg (buffer-name buf) line-no))
4486 (princ (format "Here is some text around %c:\n\n %s"
4488 (princ (format viper-EmptyTextmarker reg))))
4490 (t (error viper-InvalidTextmarker reg)))))
4494 ;; commands in insertion mode
4496 (defun viper-delete-backward-word (arg)
4497 "Delete previous word."
4502 (delete-region (point) (mark t))
4506 (defun viper-set-expert-level (&optional dont-change-unless)
4507 "Sets the expert level for a Viper user.
4508 Can be called interactively to change (temporarily or permanently) the
4509 current expert level.
4511 The optional argument DONT-CHANGE-UNLESS, if not nil, says that
4512 the level should not be changed, unless its current value is
4513 meaningless (i.e., not one of 1,2,3,4,5).
4515 User level determines the setting of Viper variables that are most
4516 sensitive for VI-style look-and-feel."
4520 (if (not (natnump viper-expert-level)) (setq viper-expert-level 0))
4522 (save-window-excursion
4523 (delete-other-windows)
4524 ;; if 0 < viper-expert-level < viper-max-expert-level
4525 ;; & dont-change-unless = t -- use it; else ask
4526 (viper-ask-level dont-change-unless))
4528 (setq viper-always t
4529 viper-ex-style-motion t
4530 viper-ex-style-editing t
4531 viper-want-ctl-h-help nil)
4533 (cond ((eq viper-expert-level 1) ; novice or beginner
4534 (global-set-key ; in emacs-state
4536 (if (viper-window-display-p) 'viper-iconify 'suspend-emacs))
4537 (setq viper-no-multiple-ESC t
4539 viper-vi-style-in-minibuffer t
4540 viper-search-wrap-around-t t
4541 viper-electric-mode nil
4542 viper-want-emacs-keys-in-vi nil
4543 viper-want-emacs-keys-in-insert nil))
4545 ((and (> viper-expert-level 1) (< viper-expert-level 5))
4546 ;; intermediate to guru
4547 (setq viper-no-multiple-ESC (if (viper-window-display-p)
4549 viper-electric-mode t
4550 viper-want-emacs-keys-in-vi t
4551 viper-want-emacs-keys-in-insert (> viper-expert-level 2))
4553 (if (eq viper-expert-level 4) ; respect user's ex-style motion
4554 ; and viper-no-multiple-ESC
4557 viper-ex-style-editing
4558 (viper-standard-value 'viper-ex-style-editing)
4559 viper-ex-style-motion
4560 (viper-standard-value 'viper-ex-style-motion))
4561 (setq viper-ex-style-motion
4562 (viper-standard-value 'viper-ex-style-motion)
4563 viper-ex-style-editing
4564 (viper-standard-value 'viper-ex-style-editing)
4566 (viper-standard-value 'viper-re-search)
4567 viper-no-multiple-ESC
4568 (viper-standard-value 'viper-no-multiple-ESC)))))
4571 ;; Ideally, if 5 is selected, a buffer should pop up to let the
4572 ;; user toggle the values of variables.
4573 (t (setq-default viper-ex-style-editing
4574 (viper-standard-value 'viper-ex-style-editing)
4575 viper-ex-style-motion
4576 (viper-standard-value 'viper-ex-style-motion))
4577 (setq viper-want-ctl-h-help
4578 (viper-standard-value 'viper-want-ctl-h-help)
4580 (viper-standard-value 'viper-always)
4581 viper-no-multiple-ESC
4582 (viper-standard-value 'viper-no-multiple-ESC)
4583 viper-ex-style-motion
4584 (viper-standard-value 'viper-ex-style-motion)
4585 viper-ex-style-editing
4586 (viper-standard-value 'viper-ex-style-editing)
4588 (viper-standard-value 'viper-re-search)
4590 (viper-standard-value 'viper-electric-mode)
4591 viper-want-emacs-keys-in-vi
4592 (viper-standard-value 'viper-want-emacs-keys-in-vi)
4593 viper-want-emacs-keys-in-insert
4594 (viper-standard-value 'viper-want-emacs-keys-in-insert))))
4596 (viper-set-mode-vars-for viper-current-state)
4597 (if (or viper-always
4598 (and (> viper-expert-level 0) (> 5 viper-expert-level)))
4602 ;; Ask user expert level.
4603 (defun viper-ask-level (dont-change-unless)
4604 (let ((ask-buffer " *viper-ask-level*")
4605 level-changed repeated)
4606 (save-window-excursion
4607 (switch-to-buffer ask-buffer)
4609 (while (or (> viper-expert-level viper-max-expert-level)
4610 (< viper-expert-level 1)
4611 (null dont-change-unless))
4615 (message "Invalid user level")
4618 (setq dont-change-unless t
4621 Please specify your level of familiarity with the venomous VI PERil
4622 (and the VI Plan for Emacs Rescue).
4623 You can change it at any time by typing `M-x viper-set-expert-level RET'
4625 1 -- BEGINNER: Almost all Emacs features are suppressed.
4626 Feels almost like straight Vi. File name completion and
4627 command history in the minibuffer are thrown in as a bonus.
4628 To use Emacs productively, you must reach level 3 or higher.
4629 2 -- MASTER: C-c now has its standard Emacs meaning in Vi command state,
4630 so most Emacs commands can be used when Viper is in Vi state.
4631 Good progress---you are well on the way to level 3!
4632 3 -- GRAND MASTER: Like 3, but most Emacs commands are available also
4633 in Viper's insert state.
4634 4 -- GURU: Like 3, but user settings are respected for viper-no-multiple-ESC,
4635 viper-ex-style-motion, viper-ex-style-editing, and
4636 viper-re-search variables. Adjust these settings to your taste.
4637 5 -- WIZARD: Like 4, but user settings are also respected for viper-always,
4638 viper-electric-mode, viper-want-ctl-h-help, viper-want-emacs-keys-in-vi,
4639 and viper-want-emacs-keys-in-insert. Adjust these to your taste.
4641 Please, specify your level now: ")
4643 (setq viper-expert-level (- (viper-read-char-exclusive) ?0))
4646 ;; tell the user if level was changed
4650 (format "\n\n\n\n\n\t\tYou have selected user level %d"
4651 viper-expert-level))
4652 (if (y-or-n-p "Do you wish to make this change permanent? ")
4653 ;; save the setting for viper-expert-level
4656 (format "Saving user level %d ..." viper-expert-level)
4657 viper-custom-file-name))
4659 (bury-buffer) ; remove ask-buffer from screen
4669 ;; if ENFORCE-BUFFER is not nil, error if CHAR is a marker in another buffer
4670 (defun viper-register-to-point (char &optional enforce-buffer)
4671 "Like jump-to-register, but switches to another buffer in another window."
4672 (interactive "cViper register to point: ")
4673 (let ((val (get-register char)))
4675 ((and (fboundp 'frame-configuration-p)
4676 (frame-configuration-p val))
4677 (set-frame-configuration val))
4678 ((window-configuration-p val)
4679 (set-window-configuration val))
4680 ((viper-valid-marker val)
4681 (if (and enforce-buffer
4682 (not (equal (current-buffer) (marker-buffer val))))
4683 (error (concat viper-EmptyTextmarker " in this buffer")
4685 (pop-to-buffer (marker-buffer val))
4687 ((and (consp val) (eq (car val) 'file))
4688 (find-file (cdr val)))
4690 (error viper-EmptyTextmarker (1- (+ char ?a)))))))
4693 (defun viper-save-kill-buffer ()
4694 "Save then kill current buffer. "
4696 (if (< viper-expert-level 2)
4697 (save-buffers-kill-emacs)
4699 (kill-buffer (current-buffer))))
4705 (defun viper-submit-report ()
4706 "Submit bug report on Viper."
4708 (let ((reporter-prompt-for-summary-p t)
4709 (viper-device-type (viper-device-type))
4710 color-display-p frame-parameters
4711 minibuffer-emacs-face minibuffer-vi-face minibuffer-insert-face
4712 varlist salutation window-config)
4714 ;; If mode info is needed, add variable to `let' and then set it below,
4715 ;; like we did with color-display-p.
4716 (setq color-display-p (if (viper-window-display-p)
4717 (viper-color-display-p)
4719 minibuffer-vi-face (if (viper-has-face-support-p)
4720 (viper-get-face viper-minibuffer-vi-face)
4722 minibuffer-insert-face (if (viper-has-face-support-p)
4724 viper-minibuffer-insert-face)
4726 minibuffer-emacs-face (if (viper-has-face-support-p)
4728 viper-minibuffer-emacs-face)
4730 frame-parameters (if (fboundp 'frame-parameters)
4731 (frame-parameters (selected-frame))))
4733 (setq varlist (list 'viper-vi-minibuffer-minor-mode
4734 'viper-insert-minibuffer-minor-mode
4735 'viper-vi-intercept-minor-mode
4736 'viper-vi-local-user-minor-mode
4737 'viper-vi-kbd-minor-mode
4738 'viper-vi-global-user-minor-mode
4739 'viper-vi-state-modifier-minor-mode
4740 'viper-vi-diehard-minor-mode
4741 'viper-vi-basic-minor-mode
4742 'viper-replace-minor-mode
4743 'viper-insert-intercept-minor-mode
4744 'viper-insert-local-user-minor-mode
4745 'viper-insert-kbd-minor-mode
4746 'viper-insert-global-user-minor-mode
4747 'viper-insert-state-modifier-minor-mode
4748 'viper-insert-diehard-minor-mode
4749 'viper-insert-basic-minor-mode
4750 'viper-emacs-intercept-minor-mode
4751 'viper-emacs-local-user-minor-mode
4752 'viper-emacs-kbd-minor-mode
4753 'viper-emacs-global-user-minor-mode
4754 'viper-emacs-state-modifier-minor-mode
4755 'viper-automatic-iso-accents
4756 'viper-special-input-method
4757 'viper-want-emacs-keys-in-insert
4758 'viper-want-emacs-keys-in-vi
4759 'viper-keep-point-on-undo
4760 'viper-no-multiple-ESC
4761 'viper-electric-mode
4763 'viper-want-ctl-h-help
4764 'viper-ex-style-editing
4765 'viper-delete-backwards-in-replace
4766 'viper-vi-style-in-minibuffer
4767 'viper-vi-state-hook
4768 'viper-insert-state-hook
4769 'viper-replace-state-hook
4770 'viper-emacs-state-hook
4771 'ex-cycle-other-window
4772 'ex-cycle-through-non-files
4779 'minibuffer-insert-face
4780 'minibuffer-emacs-face
4783 Congratulations! You may have unearthed a bug in Viper!
4784 Please mail a concise, accurate summary of the problem to the address above.
4786 -------------------------------------------------------------------")
4787 (setq window-config (current-window-configuration))
4788 (with-output-to-temp-buffer " *viper-info*"
4789 (switch-to-buffer " *viper-info*")
4790 (delete-other-windows)
4792 PLEASE FOLLOW THESE PROCEDURES
4793 ------------------------------
4795 Before reporting a bug, please verify that it is related to Viper, and is
4796 not cause by other packages you are using.
4798 Don't report compilation warnings, unless you are certain that there is a
4799 problem. These warnings are normal and unavoidable.
4801 Please note that users should not modify variables and keymaps other than
4802 those advertised in the manual. Such `customization' is likely to crash
4803 Viper, as it would any other improperly customized Emacs package.
4805 If you are reporting an error message received while executing one of the
4806 Viper commands, type:
4808 M-x set-variable <Return> debug-on-error <Return> t <Return>
4810 Then reproduce the error. The above command will cause Emacs to produce a
4811 back trace of the execution that leads to the error. Please include this
4812 trace in your bug report.
4814 If you believe that one of Viper's commands goes into an infinite loop
4815 \(e.g., Emacs freezes\), type:
4817 M-x set-variable <Return> debug-on-quit <Return> t <Return>
4819 Then reproduce the problem. Wait for a few seconds, then type C-g to abort
4820 the current command. Include the resulting back trace in the bug report.
4822 Mail anyway (y or n)? ")
4823 (if (y-or-n-p "Mail anyway? ")
4825 (set-window-configuration window-config)
4826 (error "Bug report aborted")))
4829 (set-window-configuration window-config)
4831 (reporter-submit-bug-report "kifer@cs.sunysb.edu"
4834 nil 'delete-other-windows
4840 ;; Smoothes out the difference between Emacs' unread-command-events
4841 ;; and XEmacs unread-command-event. Arg is a character, an event, a list of
4842 ;; events or a sequence of keys.
4844 ;; Due to the way unread-command-events in Emacs (not XEmacs), a non-event
4845 ;; symbol in unread-command-events list may cause Emacs to turn this symbol
4846 ;; into an event. Below, we delete nil from event lists, since nil is the most
4847 ;; common symbol that might appear in this wrong context.
4848 (defun viper-set-unread-command-events (arg)
4851 unread-command-events
4853 (cond ((eventp arg) (list arg))
4856 (listify-key-sequence arg))
4858 "viper-set-unread-command-events: Invalid argument, %S"
4860 (if (not (eventp nil))
4861 (setq new-events (delq nil new-events)))
4862 (append new-events unread-command-events)))
4865 unread-command-events
4867 (cond ((viper-characterp arg) (list (character-to-event arg)))
4868 ((eventp arg) (list arg))
4869 ((stringp arg) (mapcar 'character-to-event arg))
4870 ((vectorp arg) (append arg nil)) ; turn into list
4871 ((listp arg) (viper-eventify-list-xemacs arg))
4873 "viper-set-unread-command-events: Invalid argument, %S" arg)))
4874 unread-command-events))))
4876 ;; list is assumed to be a list of events of characters
4877 (defun viper-eventify-list-xemacs (lis)
4880 (cond ((viper-characterp elt) (character-to-event elt))
4883 "viper-eventify-list-xemacs: can't convert to event, %S"
4889 ;;; viper-cmd.el ends here