1 ;;; viper.el --- A full-featured Vi emulator for GNU Emacs 19 and XEmacs 19,
2 ;; a VI Plan for Emacs Rescue,
3 ;; and a venomous VI PERil.
4 ;; Viper Is also a Package for Emacs Rebels.
6 ;; Keywords: emulations
7 ;; Author: Michael Kifer <kifer@cs.sunysb.edu>
9 ;; Copyright (C) 1994, 1995, 1996 Free Software Foundation, Inc.
11 (defconst viper-version
"2.90 of June 19, 1996"
12 "The current version of Viper")
14 ;; This file is part of GNU Emacs.
16 ;; GNU Emacs is free software; you can redistribute it and/or modify
17 ;; it under the terms of the GNU General Public License as published by
18 ;; the Free Software Foundation; either version 2, or (at your option)
21 ;; GNU Emacs is distributed in the hope that it will be useful,
22 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
23 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 ;; GNU General Public License for more details.
26 ;; You should have received a copy of the GNU General Public License
27 ;; along with GNU Emacs; see the file COPYING. If not, write to
28 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
32 ;; Viper is a full-featured Vi emulator for Emacs 19. It emulates and
33 ;; improves upon the standard features of Vi and, at the same time, allows
34 ;; full access to all Emacs facilities. Viper supports multiple undo,
35 ;; file name completion, command, file, and search history and it extends
36 ;; Vi in many other ways. Viper is highly customizable through the various
37 ;; hooks, user variables, and keymaps. It is implemented as a collection
38 ;; of minor modes and it is designed to provide full access to all Emacs
39 ;; major and minor modes.
43 ;; Viper is a new name for a package formerly known as VIP-19,
44 ;; which was a successor of VIP version 3.5 by Masahiko Sato
45 ;; <ms@sail.stanford.edu> and VIP version 4.2 by Aamod Sane
46 ;; <sane@cs.uiuc.edu>. Some ideas from vip 4.4.2 by Aamod Sane
47 ;; were also shamelessly plagiarized.
49 ;; Viper maintains some degree of compatibility with these older
50 ;; packages. See the documentation for customization.
52 ;; The main difference between Viper and these older packages are:
54 ;; 1. Viper emulates Vi at several levels, from almost complete conformity
55 ;; to a rather loose Vi-compliance.
57 ;; 2. Viper provides full access to all major and minor modes of Emacs
58 ;; without the need to type extra keys.
59 ;; The older versions of VIP (and other Vi emulators) do not work with
60 ;; some major and minor modes.
62 ;; 3. Viper supports vi-style undo.
64 ;; 4. Viper fully emulates (and improves upon) vi's replacement mode.
66 ;; 5. Viper has a better interface to ex, including command, variable, and
67 ;; file name completion.
69 ;; 6. Viper uses native Emacs history and completion features; it doesn't
70 ;; rely on other packages (such as gmhist.el and completer.el) to provide
73 ;; 7. Viper supports Vi-style editing in the minibuffer, by allowing the
74 ;; user to switch from Insert state to Vi state to Replace state, etc.
76 ;; 8. Viper keeps history of recently inserted pieces of text and recently
77 ;; executed Vi-style destructive commands, such as `i', `d', etc.
78 ;; These pieces of text can be inserted in later insertion commands;
79 ;; the previous destructive commands can be re-executed.
81 ;; 9. Viper has Vi-style keyboard macros, which enhances the similar
82 ;; facility in the original Vi.
83 ;; First, one can execute any Emacs command while defining a
84 ;; macro, not just the Vi commands. Second, macros are defined in a
85 ;; WYSYWYG mode, using an interface to Emacs' WYSIWYG style of defining
86 ;; macros. Third, in Viper, one can define macros that are specific to
87 ;; a given buffer, a given major mode, or macros defined for all buffers.
88 ;; The same macro name can have several different definitions:
89 ;; one global, several definitions for various major modes, and
90 ;; definitions for specific buffers.
91 ;; Bffer-specific definitions override mode-specific
92 ;; definitions, which, in turn, override global definitions.
101 ;;; Acknowledgements:
103 ;; Bug reports and ideas contributed by the following users
104 ;; have helped improve Viper and the various versions of VIP.
105 ;; See the on-line manual for a complete list of contributors.
111 ;; In most cases, Viper handles major modes correctly, i.e., they come up
112 ;; in the right state (either vi-state or emacs-state). For instance, text
113 ;; files come up in vi-state, while, say, Dired appears in emacs-state by
115 ;; However, some modes do not appear in the right mode in the beginning,
116 ;; usually because they neglect to follow Emacs conventions (e.g., they don't
117 ;; use kill-all-local-variables when they start). Some major modes
118 ;; may fail to come up in emacs-state if they call hooks, such as
119 ;; text-hook, for no good reason.
121 ;; As an immediate solution, you can hit C-z to bring about the right mode.
122 ;; An interim solution is to add an appropriate hook to the mode like this:
124 ;; (add-hook 'your-favorite-mode 'viper-mode)
126 ;; (add-hook 'your-favorite-mode 'vip-change-state-to-emacs)
128 ;; whichever applies. The right thing to do, however, is to complain to the
129 ;; author of the respective package. (Sometimes they also neglect to equip
130 ;; their modes with hooks, which is one more reason for complaining.)
132 ;; 2. Keymap handling
133 ;; Because Emacs 19 has an elegant mechanism for turning minor mode keymaps
134 ;; on and off, implementation of Viper has been greatly simplified. Viper
135 ;; has several minor modes.
137 ;; Viper's Vi state consists of seven minor modes:
139 ;; vip-vi-intercept-minor-mode
140 ;; vip-vi-local-user-minor-mode
141 ;; vip-vi-global-user-minor-mode
142 ;; vip-vi-kbd-minor-mode
143 ;; vip-vi-state-modifier-minor-mode
144 ;; vip-vi-diehard-minor-mode
145 ;; vip-vi-basic-minor-mode
147 ;; Bindings done to the keymap of the first mode overshadow those done to
148 ;; the second, which, in turn, overshadows those done to the third, etc.
150 ;; The last vip-vi-basic-minor-mode contains most of the usual Vi bindings
151 ;; in its edit mode. This mode provides access to all Emacs facilities.
152 ;; Novice users, however, may want to set their vip-expert-level to 1
153 ;; in their .vip file. This will enable vip-vi-diehard-minor-mode. This
154 ;; minor mode's bindings make Viper simulate the usual Vi very closely.
155 ;; For instance, C-c will not have its standard Emacs binding
156 ;; and so many of the goodies of Emacs are not available.
158 ;; An skilled user, should set vip-expert-level to at least 3. This will
159 ;; enable ;; C-c and many Emacs facilities will become available.
160 ;; In this case, vip-vi-diehard-minor-mode is inactive.
162 ;; Viper gurus should have at least
163 ;; (setq vip-expert-level 4)
164 ;; in their ~/.vip files. This will unsuppress all Emacs keys that are not
165 ;; essential for VI-style editing.
166 ;; Pick-and-choose users may want to put
167 ;; (setq vip-expert-level 5)
168 ;; in ~/.vip. Viper will then leave it up to the user to set the variables
169 ;; vip-want-* See vip-set-expert-level for details.
171 ;; The very first minor mode, vip-vi-intercept-minor-mode, is of no
172 ;; concern for the user. It is needed to bind Viper's vital keys, such as
175 ;; The second mode, vip-vi-local-user-minor-mode, usually has an
176 ;; empty keymap. However, the user can set bindings in this keymap, which
177 ;; will overshadow the corresponding bindings in the other two minor
178 ;; modes. This is useful, for example, for setting up ZZ in gnus,
179 ;; rmail, mh-e, etc., to send message instead of saving it in a file.
180 ;; Likewise, in Dired mode, you may want to bind ZN and ZP to commands
181 ;; that would visit the next or the previous file in the Dired buffer.
182 ;; Setting local keys is tricky, so don't do it directly. Instead, use
183 ;; vip-add-local-keys function (see its doc).
185 ;; The third minor mode, vip-vi-global-user-minor-mode, is also intended
186 ;; for the users but, unlike vip-vi-local-user-minor-mode, its key
187 ;; bindings are seen in all Viper buffers. This mode keys can be done
188 ;; with define-key command.
190 ;; The fourth minor mode, vip-vi-kbd-minor-mode, is used by keyboard
191 ;; macros. Users are NOT supposed to modify this keymap directly.
193 ;; The fifth mode, vip-vi-state-modifier-minor-mode, can be used to set
194 ;; key bindings that are visible in some major modes but not in others.
196 ;; Users are allowed to modify keymaps that belong to
197 ;; vip-vi-local-user-minor-mode, vip-vi-global-user-minor-mode,
198 ;; and vip-vi-state-modifier-minor-mode only.
200 ;; Viper's Insert state also has seven minor modes:
202 ;; vip-insert-intercept-minor-mode
203 ;; vip-insert-local-user-minor-mode
204 ;; vip-insert-global-user-minor-mode
205 ;; vip-insert-kbd-minor-mode
206 ;; vip-insert-state-modifier-minor-mode
207 ;; vip-insert-diehard-minor-mode
208 ;; vip-insert-basic-minor-mode
210 ;; As with VI's editing modes, the first mode, vip-insert-intercept-minor-mode
211 ;; is used to bind vital keys that are not to be changed by the user.
213 ;; The next mode, vip-insert-local-user-minor-mode, is used to customize
214 ;; bindings in the insert state of Viper. The third mode,
215 ;; vip-insert-global-user-minor-mode is like
216 ;; vip-insert-local-user-minor-mode, except that its bindings are seen in
217 ;; all Viper buffers. As with vip-vi-local-user-minor-mode, its bindings
218 ;; should be done via the function vip-add-local-keys. Bindings for
219 ;; vip-insert-global-user-minor-mode can be set with the define-key command.
221 ;; The next minor mode, vip-insert-kbd-minor-mode,
222 ;; is used for keyboard VI-style macros defined with :map!.
224 ;; The fifth minor mode, vip-insert-state-modifier-minor-mode, is like
225 ;; vip-vi-state-modifier-minor-mode, except that it is used in the Insert
226 ;; state; it can be used to modify keys in a mode-specific fashion.
228 ;; The minor mode vip-insert-diehard-minor-mode is in effect when
229 ;; the user wants a high degree of Vi compatibility (a bad idea, really!).
230 ;; The last minor mode, vip-insert-basic-minor-mode, is always in effect
231 ;; when Viper is in insert state. It binds a small number of keys needed for
232 ;; Viper's operation.
234 ;; Finally, Viper provides minor modes for overriding bindings set by Emacs
235 ;; modes when Viper is in Emacs state:
237 ;; vip-emacs-local-user-minor-mode
238 ;; vip-emacs-global-user-minor-mode
239 ;; vip-emacs-kbd-minor-mode
240 ;; vip-emacs-state-modifier-minor-mode
242 ;; These minor modes are in effect when Viper is in Emacs state. The keymap
243 ;; associated with vip-emacs-global-user-minor-mode,
244 ;; vip-emacs-global-user-map, overrides the global and local keymaps as
245 ;; well as the minor mode keymaps set by other modes. The keymap of
246 ;; vip-emacs-local-user-minor-mode, vip-emacs-local-user-map, overrides
247 ;; everything, but it is used on a per buffer basis.
248 ;; The keymap associated with vip-emacs-state-modifier-minor-mode
249 ;; overrides keys on a per-major-mode basis. The mode
250 ;; vip-emacs-kbd-minor-mode is used to define Vi-style macros in Emacs
253 ;; 3. There is also one minor mode that is used when Viper is in its
254 ;; replace-state (used for commands like cw, C, etc.). This mode is
257 ;; vip-replace-minor-mode
259 ;; and its keymap is vip-replace-map. Replace minor mode is always
260 ;; used in conjunction with the minor modes for insert-state, and its
261 ;; keymap overshadows the keymaps for insert minor modes.
263 ;; 4. Defining buffer-local bindings in Vi and Insert modes.
264 ;; As mentioned before, sometimes, it is convenient to have
265 ;; buffer-specific of mode-specific key bindings in Vi and insert modes.
266 ;; Viper provides a special function, vip-add-local-keys, to do precisely
267 ;; this. For instance, is you need to add couple of mode-specific bindings
268 ;; to Insert mode, you can put
270 ;; (vip-add-local-keys 'insert-state '((key1 . func1) (key2 .func2)))
272 ;; somewhere in a hook of this major mode. If you put something like this
273 ;; in your own elisp function, this will define bindings specific to the
274 ;; buffer that was current at the time of the call to vip-add-local-keys.
275 ;; The only thing to make sure here is that the major mode of this buffer
276 ;; is written according to Emacs conventions, which includes a call to
277 ;; (kill-all-local-variables). See vip-add-local-keys for more details.
280 ;; TO DO (volunteers?):
282 ;; 1. Some of the code that is inherited from VIP-3.5 is rather
283 ;; convoluted. Instead of vip-command-argument, keymaps should bind the
284 ;; actual commands. E.g., "dw" should be bound to a generic command
285 ;; vip-delete that will delete things based on the value of
286 ;; last-command-char. This would greatly simplify the logic and the code.
288 ;; 2. Somebody should venture to write a customization package a la
289 ;; options.el that would allow the user to change values of variables
290 ;; that meet certain specs (e.g., match a regexp) and whose doc string
291 ;; starts with a '*'. Then, the user should be offered to save
292 ;; variables that were changed. This will make user's customization job
302 (require 'viper-util
)
305 (defvar vip-minibuffer-current-face
)
306 (defvar vip-minibuffer-insert-face
)
307 (defvar vip-minibuffer-vi-face
)
308 (defvar vip-minibuffer-emacs-face
)
309 (defvar iso-accents-mode
)
310 (defvar zmacs-region-stays
)
316 ;; Is t until viper-mode executes for the very first time.
317 ;; Prevents recursive descend into startup messages.
318 (defvar vip-first-time t
)
320 (defvar vip-expert-level
0
321 "User's expert level.
322 The minor mode vip-vi-diehard-minor-mode is in effect when
323 vip-expert-level is 1 or 2 or when vip-want-emacs-keys-in-vi is t.
324 The minor mode vip-insert-diehard-minor-mode is in effect when
325 vip-expert-level is 1 or 2 or if vip-want-emacs-keys-in-insert is t.
326 Use `M-x vip-set-expert-level' to change this.")
328 ;; Max expert level supported by Viper. This is NOT a user option.
329 ;; It is here to make it hard for the user from resetting it.
330 (defconst vip-max-expert-level
5)
332 ;; Contains user settings for vars affected by vip-set-expert-level function.
333 ;; Not a user option.
334 (defvar vip-saved-user-settings nil
)
337 ;;; Viper minor modes
339 ;; This is not local in Emacs, so we make it local.
340 (make-variable-buffer-local 'minor-mode-map-alist
)
342 ;; Mode for vital things like \e, C-z.
343 (vip-deflocalvar vip-vi-intercept-minor-mode nil
)
345 (vip-deflocalvar vip-vi-basic-minor-mode nil
346 "Viper's minor mode for Vi bindings.")
348 (vip-deflocalvar vip-vi-local-user-minor-mode nil
349 "Auxiliary minor mode for user-defined local bindings in Vi state.")
351 (vip-deflocalvar vip-vi-global-user-minor-mode nil
352 "Auxiliary minor mode for user-defined global bindings in Vi state.")
354 (vip-deflocalvar vip-vi-state-modifier-minor-mode nil
355 "Minor mode used to make major-mode-specific modification to Vi state.")
357 (vip-deflocalvar vip-vi-diehard-minor-mode nil
358 "This minor mode is in effect when the user wants Viper to be Vi.")
360 (vip-deflocalvar vip-vi-kbd-minor-mode nil
361 "Minor mode for Ex command macros in Vi state.
362 The corresponding keymap stores key bindings of Vi macros defined with
363 the Ex command :map.")
365 ;; Mode for vital things like \e, C-z.
366 (vip-deflocalvar vip-insert-intercept-minor-mode nil
)
368 (vip-deflocalvar vip-insert-basic-minor-mode nil
369 "Viper's minor mode for bindings in Insert mode.")
371 (vip-deflocalvar vip-insert-local-user-minor-mode nil
372 "Auxiliary minor mode for buffer-local user-defined bindings in Insert state.
373 This is a way to overshadow normal Insert mode bindings locally to certain
374 designated buffers.")
376 (vip-deflocalvar vip-insert-global-user-minor-mode nil
377 "Auxiliary minor mode for global user-defined bindings in Insert state.")
379 (vip-deflocalvar vip-insert-state-modifier-minor-mode nil
380 "Minor mode used to make major-mode-specific modification to Insert state.")
382 (vip-deflocalvar vip-insert-diehard-minor-mode nil
383 "Minor mode that simulates Vi very closely.
384 Not recommened, except for the novice user.")
386 (vip-deflocalvar vip-insert-kbd-minor-mode nil
387 "Minor mode for Ex command macros Insert state.
388 The corresponding keymap stores key bindings of Vi macros defined with
389 the Ex command :map!.")
391 (vip-deflocalvar vip-replace-minor-mode nil
392 "Minor mode in effect in replace state (cw, C, and the like commands).")
394 ;; Mode for vital things like \C-z and \C-x)
395 ;; This is t, by default. So, any new buffer will have C-z defined as
396 ;; switch to Vi, unless we switched states in this buffer
397 (vip-deflocalvar vip-emacs-intercept-minor-mode t
)
399 (vip-deflocalvar vip-emacs-local-user-minor-mode t
400 "Minor mode for local user bindings effective in Emacs state.
401 Users can use it to override Emacs bindings when Viper is in its Emacs
404 (vip-deflocalvar vip-emacs-global-user-minor-mode t
405 "Minor mode for global user bindings in effect in Emacs state.
406 Users can use it to override Emacs bindings when Viper is in its Emacs
409 (vip-deflocalvar vip-emacs-kbd-minor-mode t
410 "Minor mode for Vi style macros in Emacs state.
411 The corresponding keymap stores key bindings of Vi macros defined with
412 `vip-record-kbd-macro' command. There is no Ex-level command to do this
415 (vip-deflocalvar vip-emacs-state-modifier-minor-mode t
416 "Minor mode used to make major-mode-specific modification to Emacs state.
417 For instance, a Vi purist may want to bind `dd' in Dired mode to a function
418 that deletes a file.")
424 (vip-deflocalvar vip-automatic-iso-accents nil
425 "*If non-nil, ISO accents will be turned on in insert/replace emacs states and turned off in vi-state.
426 For some users, this behavior may be too primitive. In this case, use
427 insert/emacs/vi state hooks.")
430 ;;; Emacs keys in other states.
432 (defvar vip-want-emacs-keys-in-insert t
433 "*Set to nil if you want complete Vi compatibility in insert mode.
434 Complete compatibility with Vi is not recommended for power use of Viper.")
436 (defvar vip-want-emacs-keys-in-vi t
437 "*Set to nil if you want complete Vi compatibility in Vi mode.
438 Full Vi compatibility is not recommended for power use of Viper.")
444 ;; Used to 'undo' complex commands, such as replace and insert commands.
445 (vip-deflocalvar vip-undo-needs-adjustment nil
)
446 (put 'vip-undo-needs-adjustment
'permanent-local t
)
448 ;; A mark that Viper puts on buffer-undo-list. Marks the beginning of a
449 ;; complex command that must be undone atomically. If inserted, it is
450 ;; erased by vip-change-state-to-vi and vip-repeat.
451 (defconst vip-buffer-undo-list-mark
'viper
)
453 (defvar vip-keep-point-on-undo nil
454 "*Non-nil means not to move point while undoing commands.
455 This style is different from Emacs and Vi. Try it to see if
456 it better fits your working style.")
458 ;; Replace mode and changing text
460 ;; Viper's own after/before change functions, which get vip-add-hook'ed to
462 (vip-deflocalvar vip-after-change-functions nil
"")
463 (vip-deflocalvar vip-before-change-functions nil
"")
464 (vip-deflocalvar vip-post-command-hooks nil
"")
465 (vip-deflocalvar vip-pre-command-hooks nil
"")
467 ;; Can be used to pass global states around for short period of time
468 (vip-deflocalvar vip-intermediate-command nil
"")
470 ;; Indicates that the current destructive command has started in replace mode.
471 (vip-deflocalvar vip-began-as-replace nil
"")
473 (defvar vip-replace-overlay-cursor-color
"Red"
474 "*Cursor color to use in Replace state")
477 (vip-deflocalvar vip-replace-overlay nil
"")
478 (put 'vip-replace-overlay
'permanent-local t
)
480 (if (vip-has-face-support-p)
482 (make-face 'vip-replace-overlay-face
)
483 (vip-hide-face 'vip-replace-overlay-face
)
484 (or (face-differs-from-default-p 'vip-replace-overlay-face
)
486 (if (vip-can-use-colors "darkseagreen2" "Black")
489 'vip-replace-overlay-face
"darkseagreen2")
490 (set-face-foreground 'vip-replace-overlay-face
"Black")))
491 (set-face-underline-p 'vip-replace-overlay-face t
))
494 (defvar vip-replace-overlay-face
'vip-replace-overlay-face
495 "*Face for highlighting replace regions on a window display.")
497 (defvar vip-replace-region-end-delimiter
"$"
498 "A string marking the end of replacement regions.
499 It is used only with TTYs or if `vip-use-replace-region-delimiters'
501 (defvar vip-replace-region-start-delimiter
""
502 "A string marking the beginning of replacement regions.
503 It is used only with TTYs or if `vip-use-replace-region-delimiters'
505 (defvar vip-use-replace-region-delimiters
506 (or (not (vip-has-face-support-p)) (not (vip-color-display-p)))
507 "*If non-nil, Viper will always use `vip-replace-region-end-delimiter' and
508 `vip-replace-region-start-delimiter' to delimit replacement regions, even on
509 color displays. By default, the delimiters are used only on TTYs or
510 monochrome displays.")
512 ;; XEmacs requires glyphs
515 (or (glyphp vip-replace-region-end-delimiter
)
516 (setq vip-replace-region-end-delimiter
517 (make-glyph vip-replace-region-end-delimiter
)))
518 (or (glyphp vip-replace-region-start-delimiter
)
519 (setq vip-replace-region-start-delimiter
520 (make-glyph vip-replace-region-start-delimiter
)))
524 ;; These are local marker that must be initialized to nil and moved with
525 ;; `vip-move-marker-locally'
527 ;; Remember the last position inside the replace region.
528 (vip-deflocalvar vip-last-posn-in-replace-region nil
)
529 ;; Remember the last position while inserting
530 (vip-deflocalvar vip-last-posn-while-in-insert-state nil
)
531 (put 'vip-last-posn-in-replace-region
'permanent-local t
)
532 (put 'vip-last-posn-while-in-insert-state
'permanent-local t
)
534 (vip-deflocalvar vip-sitting-in-replace nil
"")
535 (put 'vip-sitting-in-replace
'permanent-local t
)
537 ;; Remember the number of characters that have to be deleted in replace
538 ;; mode to compensate for the inserted characters.
539 (vip-deflocalvar vip-replace-chars-to-delete
0 "")
540 (vip-deflocalvar vip-replace-chars-deleted
0 "")
542 ;; Insertion ring and command ring
543 (defvar vip-insertion-ring-size
14
544 "The size of the insertion ring.")
545 ;; The insertion ring.
546 (defvar vip-insertion-ring nil
)
547 ;; This is temp insertion ring. Used to do rotation for display purposes.
548 ;; When rotation just started, it is initialized to vip-insertion-ring.
549 (defvar vip-temp-insertion-ring nil
)
550 (defvar vip-last-inserted-string-from-insertion-ring
"")
552 (defvar vip-command-ring-size
14
553 "The size of the command ring.")
555 (defvar vip-command-ring nil
)
556 ;; This is temp command ring. Used to do rotation for display purposes.
557 ;; When rotation just started, it is initialized to vip-command-ring.
558 (defvar vip-temp-command-ring nil
)
560 ;; Modes and related variables
562 ;; Current mode. One of: `emacs-state', `vi-state', `insert-state'
563 (vip-deflocalvar vip-current-state
'emacs-state
)
566 (defvar vip-toggle-key
"\C-z"
567 "The key used to change states from emacs to Vi and back.
568 In insert mode, this key also functions as Meta.
569 Must be set in .vip file or prior to loading Viper.
570 This setting cannot be changed interactively.")
572 (defvar vip-ESC-key
"\e"
574 Must be set in .vip file or prior to loading Viper.
575 This setting cannot be changed interactively.")
577 (defvar vip-no-multiple-ESC t
578 "*If true, multiple ESC in Vi mode will cause bell to ring.
579 \_ is then mapped to Meta.
580 This is set to t on a windowing terminal and to 'twice on a dumb
581 terminal (unless the user level is 1, 2, or 5). On a dumb terminal, this
582 enables cursor keys and is generally more convenient, as terminals usually
583 don't have a convenient Meta key.
584 Setting vip-no-multiple-ESC to nil will allow as many multiple ESC,
585 as is allowed by the major mode in effect.")
588 (defvar vip-want-ctl-h-help nil
589 "*If t then C-h is bound to help-command in insert mode, if nil then it is
590 bound to delete-backward-char.")
592 ;; Autoindent in insert
594 ;; Variable that keeps track of whether C-t has been pressed.
595 (vip-deflocalvar vip-cted nil
"")
597 ;; Preserve the indent value, used by C-d in insert mode.
598 (vip-deflocalvar vip-current-indent
0)
600 ;; Whether to preserve the indent, used by C-d in insert mode.
601 (vip-deflocalvar vip-preserve-indent nil
)
603 (vip-deflocalvar vip-auto-indent nil
605 (vip-deflocalvar vip-electric-mode t
606 "*If t, enable electric behavior.
607 Currently only enables auto-indentation `according to mode'.")
609 (defconst vip-shift-width
8
610 "*The shiftwidth variable.")
612 ;; Variables for repeating destructive commands
614 (defconst vip-keep-point-on-repeat t
615 "*If t, don't move point when repeating previous command.
616 This is useful for doing repeated changes with the '.' key.
617 The user can change this to nil, if she likes when the cursor moves
618 to a new place after repeating previous Vi command.")
620 ;; Remember insert point as a marker. This is a local marker that must be
621 ;; initialized to nil and moved with `vip-move-marker-locally'.
622 (vip-deflocalvar vip-insert-point nil
)
623 (put 'vip-insert-point
'permanent-local t
)
625 ;; This remembers the point before dabbrev-expand was called.
626 ;; If vip-insert-point turns out to be bigger than that, it is reset
627 ;; back to vip-pre-command-point.
628 ;; The reason this is needed is because dabbrev-expand (and possibly
629 ;; others) may jump to before the insertion point, delete something and
630 ;; then reinsert a bigger piece. For instance: bla^blo
631 ;; If dabbrev-expand is called after `blo' and ^ undicates vip-insert-point,
632 ;; then point jumps to the beginning of `blo'. If expansion is found, `blablo'
633 ;; is deleted, and we have |^, where | denotes point. Next, dabbrev-expand
634 ;; will insert the expansion, and we get: blablo^
635 ;; Whatever we insert next goes before the ^, i.e., before the
636 ;; vip-insert-point marker. So, Viper will think that nothing was
637 ;; inserted. Remembering the orig position of the marker circumvents the
639 ;; We don't know of any command, except dabbrev-expand, that has the same
640 ;; problem. However, the same trick can be used if such a command is
643 (vip-deflocalvar vip-pre-command-point nil
)
644 (put 'vip-pre-command-point
'permanent-local t
) ; this is probably an overkill
646 ;; This is used for saving inserted text.
647 (defvar vip-last-insertion nil
)
649 ;; Remembers the last replaced region.
650 (defvar vip-last-replace-region
"")
652 ;; Remember com point as a marker.
653 ;; This is a local marker. Should be moved with `vip-move-marker-locally'
654 (vip-deflocalvar vip-com-point nil
)
656 ;; If non-nil, the value is a list (M-COM VAL COM REG inserted-text cmd-keys)
657 ;; It is used to re-execute last destructive command.
658 ;; M-COM is a Lisp symbol representing the function to be executed.
659 ;; VAL is the prefix argument that was used with that command.
660 ;; COM is an internal descriptor, such as ?r, ?c, ?C, which contains
661 ;; additional information on how the function in M-COM is to be handled.
662 ;; REG is the register used by command
663 ;; INSERTED-TEXT is text inserted by that command (in case of o, c, C, i, r
665 ;; COMMAND-KEYS are the keys that were typed to invoke the command.
666 (defvar vip-d-com nil
)
668 ;; The character remembered by the Vi `r' command.
669 (defvar vip-d-char nil
)
671 ;; Name of register to store deleted or yanked strings
672 (defvar vip-use-register nil
)
676 ;; Variables for Moves and Searches
678 ;; For use by `;' command.
679 (defvar vip-f-char nil
)
681 ;; For use by `.' command.
682 (defvar vip-F-char nil
)
684 ;; For use by `;' command.
685 (defvar vip-f-forward nil
)
687 ;; For use by `;' command.
688 (defvar vip-f-offset nil
)
690 ;; Last search string
691 (defvar vip-s-string
"")
693 (defvar vip-quote-string
"> "
694 "String inserted at the beginning of quoted region.")
696 ;; If t, search is forward.
697 (defvar vip-s-forward nil
)
699 (defconst vip-case-fold-search nil
700 "*If t, search ignores cases.")
702 (defconst vip-re-search t
703 "*If t, search is reg-exp search, otherwise vanilla search.")
705 (defconst vip-re-query-replace t
706 "*If t then do regexp replace, if nil then do string replace.")
708 (defconst vip-re-replace t
709 "*If t, do regexp replace. nil means do string replace.")
711 (vip-deflocalvar vip-ex-style-motion t
712 "*Ex-style: the commands l,h do not cross lines, etc.")
714 (vip-deflocalvar vip-ex-style-editing-in-insert t
715 "*The keys ^H, ^? don't jump lines in insert, ESC moves cursor back, etc.
716 Note: this doesn't preclude ^H and ^? from deleting characters by moving
717 past the insertion point. This is a feature, not a bug. ")
719 (vip-deflocalvar vip-delete-backwards-in-replace nil
720 "*If t, DEL key will delete characters while moving the cursor backwards.
721 If nil, the cursor will move backwards without deleting anything.")
723 (defconst vip-buffer-search-char nil
724 "*Key bound for buffer-searching.")
726 (defconst vip-search-wrap-around-t t
727 "*If t, search wraps around.")
729 (vip-deflocalvar vip-related-files-and-buffers-ring nil
730 "*Ring of file and buffer names that are considered to be related to the
732 These buffers can be cycled through via :R and :P commands.")
733 (put 'vip-related-files-and-buffers-ring
'permanent-local t
)
735 ;; Used to find out if we are done with searching the current buffer.
736 (vip-deflocalvar vip-local-search-start-marker nil
)
737 ;; As above, but global
738 (defvar vip-search-start-marker
(make-marker))
740 ;; the search overlay
741 (vip-deflocalvar vip-search-overlay nil
)
744 (defvar vip-heading-start
745 (concat "^\\s-*(\\s-*defun\\s-\\|" ; lisp
746 "^{\\s-*$\\|^[_a-zA-Z][^()]*[()].*{\\s-*$\\|" ; C/C++
747 "^\\s-*class.*{\\|^\\s-*struct.*{\\|^\\s-*enum.*{\\|"
748 "^\\\\[sb][a-z]*{.*}\\s-*$\\|" ; latex
749 "^@node\\|@table\\|^@m?enu\\|^@itemize\\|^@if\\|" ; texinfo
751 "*Regexps for Headings. Used by \[\[ and \]\].")
753 (defvar vip-heading-end
754 (concat "^}\\|" ; C/C++
755 "^\\\\end{\\|" ; latex
756 "^@end \\|" ; texinfo
757 ")\n\n[ \t\n]*\\|" ; lisp
758 "\\.\\s-*$") ; prolog
759 "*Regexps to end Headings/Sections. Used by \[\].")
762 ;; These two vars control the interaction of jumps performed by ' and `.
763 ;; In this new version, '' doesn't erase the marks set by ``, so one can
764 ;; use both kinds of jumps interchangeably and without loosing positions
767 ;; Remembers position of the last jump done using ``'.
768 (vip-deflocalvar vip-last-jump nil
)
769 ;; Remembers position of the last jump done using `''.
770 (vip-deflocalvar vip-last-jump-ignore
0)
772 ;; Some common error messages
774 (defconst vip-SpuriousText
"Spurious text after command" "")
775 (defconst vip-BadExCommand
"Not an editor command" "")
776 (defconst vip-InvalidCommandArgument
"Invalid command argument" "")
777 (defconst vip-NoPrevSearch
"No previous search string" "")
778 (defconst vip-EmptyRegister
"`%c': Nothing in this register" "")
779 (defconst vip-InvalidRegister
"`%c': Invalid register" "")
780 (defconst vip-EmptyTextmarker
"`%c': Text marker doesn't point anywhere" "")
781 (defconst vip-InvalidTextmarker
"`%c': Invalid text marker" "")
782 (defconst vip-InvalidViCommand
"Invalid command" "")
783 (defconst vip-BadAddress
"Ill-formed address" "")
784 (defconst vip-FirstAddrExceedsSecond
"First address exceeds second" "")
785 (defconst vip-NoFileSpecified
"No file specified" "")
790 ;; History of search strings.
791 (defvar vip-search-history
(list ""))
792 ;; History of query-replace strings used as a source.
793 (defvar vip-replace1-history nil
)
794 ;; History of query-replace strings used as replacement.
795 (defvar vip-replace2-history nil
)
796 ;; History of region quoting strings.
797 (defvar vip-quote-region-history
(list vip-quote-string
))
798 ;; History of Ex-style commands.
799 (defvar vip-ex-history nil
)
800 ;; History of shell commands.
801 (defvar vip-shell-history nil
)
804 ;; Last shell command. There are two of these, one for Ex (in viper-ex)
807 ;; Last shell command executed with ! command.
808 (defvar vip-last-shell-com nil
)
814 ;; don't bark when mark is inactive
815 (setq mark-even-if-inactive t
)
817 (defvar vip-inhibit-startup-message nil
818 "Whether Viper startup message should be inhibited.")
821 "t means, arrange that vi-state will be a default.")
823 (defvar vip-ms-style-os-p
(memq system-type
'(ms-dos windows-nt windows-95
))
824 "Tells is Emacs is running under an MS-style OS: ms-dos, window-nt, W95.")
825 (defvar vip-vms-os-p
(memq system-type
'(vax-vms axp-vms
))
826 "Tells if Emacs is running under VMS.")
828 (defvar vip-custom-file-name
(cond (vip-vms-os-p "sys$login:.vip")
829 ((memq system-type
'(emx ms-dos
))
831 ((memq system-type
'(windows-nt windows-95
))
835 "Viper customisation file.
836 This variable must be set _before_ loading Viper.")
839 (defvar vip-spell-function
'ispell-region
840 "Spell function used by #s<move> command to spell.")
842 (defvar vip-tags-file-name
"TAGS"
843 "The tags file used by Viper.")
847 (defvar vip-vi-style-in-minibuffer t
848 "If t, use vi-style editing in minibuffer.
849 Should be set in `~/.vip' file.")
851 ;; overlay used in the minibuffer to indicate which state it is in
852 (vip-deflocalvar vip-minibuffer-overlay nil
)
854 ;; Hook, specific to Viper, which is run just *before* exiting the minibuffer.
855 ;; Beginning with Emacs 19.26, the standard `minibuffer-exit-hook' is run
856 ;; *after* exiting the minibuffer
857 (defvar vip-minibuffer-exit-hook nil
)
859 (vip-deflocalvar vip-vi-minibuffer-minor-mode nil
860 "Minor mode that forces Vi-style when the Minibuffer is in Vi state.")
861 (vip-deflocalvar vip-insert-minibuffer-minor-mode nil
862 "Minor mode that forces Vi-style when the Minibuffer is in Insert state.")
864 ;; setup emacs-supported vi-style feel
865 (setq next-line-add-newlines nil
866 require-final-newline t
)
868 (make-variable-buffer-local 'require-final-newline
)
872 (defconst vip-vi-state-id
"<V> "
873 "Mode line tag identifying the Vi mode of Viper.")
874 (defconst vip-emacs-state-id
"<E> "
875 "Mode line tag identifying the Emacs mode of Viper.")
876 (defconst vip-insert-state-id
"<I> "
877 "Mode line tag identifying the Insert mode of Viper.")
878 (defconst vip-replace-state-id
"<R> "
879 "Mode line tag identifying the Replace mode of Viper.")
881 ;; Viper changes the default mode-line-buffer-identification
882 (setq-default mode-line-buffer-identification
'(" %b"))
884 ;; Variable displaying the current Viper state in the mode line.
885 (vip-deflocalvar vip-mode-string vip-emacs-state-id
)
886 (or (memq 'vip-mode-string global-mode-string
)
887 (setq global-mode-string
888 (append '("" vip-mode-string
) (cdr global-mode-string
))))
891 (defvar vip-vi-state-hook nil
892 "*Hooks run just before the switch to Vi mode is completed.")
893 (defvar vip-insert-state-hook nil
894 "*Hooks run just before the switch to Insert mode is completed.")
895 (defvar vip-replace-state-hook nil
896 "*Hooks run just before the switch to Replace mode is completed.")
897 (defvar vip-emacs-state-hook nil
898 "*Hooks run just before the switch to Emacs mode is completed.")
900 (defvar vip-load-hook nil
901 "Hooks run just after loading Viper.")
904 ;; Generic predicates
906 ;; These test functions are shamelessly lifted from vip 4.4.2 by Aamod Sane
908 ;; generate test functions
909 ;; given symbol foo, foo-p is the test function, foos is the set of
910 ;; Viper command keys
911 ;; (macroexpand '(vip-test-com-defun foo))
912 ;; (defun foo-p (com) (consp (memq (if (< com 0) (- com) com) foos)))
914 (defmacro vip-test-com-defun
(name)
915 (let* ((snm (symbol-name name
))
916 (nm-p (intern (concat snm
"-p")))
917 (nms (intern (concat snm
"s"))))
918 (` (defun (, nm-p
) (com)
919 (consp (memq (if (< com
0) (- com
) com
) (, nms
)))))))
921 ;; Variables for defining VI commands
923 ;; Modifying commands that can be prefixes to movement commands
924 (defconst vip-prefix-commands
'(?c ?d ?y ?
! ?
= ?
# ?
< ?
> ?
\"))
925 (vip-test-com-defun vip-prefix-command)
927 ;; Commands that are pairs eg. dd. r and R here are a hack
928 (defconst vip-charpair-commands
'(?c ?d ?y ?
! ?
= ?
< ?
> ?r ?R
))
929 (vip-test-com-defun vip-charpair-command)
931 (defconst vip-movement-commands
'(?b ?B ?e ?E ?f ?F ?G ?h ?H ?j ?k ?l
932 ?H ?M ?n ?t ?T ?w ?W ?$ ?%
933 ?^ ?
( ?
) ?- ?
+ ?| ?
{ ?
} ?
[ ?
] ?
' ?
`
937 (vip-test-com-defun vip-movement-command)
939 ;; Commands that can be repeated by .(dotted)
940 (defconst vip-dotable-commands
'(?c ?d ?C ?D ?
> ?
<))
941 (vip-test-com-defun vip-dotable-command)
943 ;; Commands that can follow a #
944 (defconst vip-hash-cmds
'(?c ?C ?g ?q ?S
))
945 (vip-test-com-defun vip-hash-cmd)
947 ;; Commands that may have registers as prefix
948 (defconst vip-regsuffix-commands
'(?d ?y ?Y ?D ?p ?P ?x ?X
))
949 (vip-test-com-defun vip-regsuffix-command)
953 ;;; Arrange the keymaps
954 (require 'viper-keym
)
961 ;; Runs vip-after-change-functions inside after-change-functions
962 (defun vip-after-change-sentinel (beg end len
)
963 (let ((list vip-after-change-functions
))
965 (funcall (car list
) beg end len
)
966 (setq list
(cdr list
)))))
968 ;; Runs vip-before-change-functions inside before-change-functions
969 (defun vip-before-change-sentinel (beg end
)
970 (let ((list vip-before-change-functions
))
972 (funcall (car list
) beg end
)
973 (setq list
(cdr list
)))))
975 (defsubst vip-post-command-sentinel
()
976 (run-hooks 'vip-post-command-hooks
))
978 (defsubst vip-pre-command-sentinel
()
979 (run-hooks 'vip-pre-command-hooks
))
981 ;; Needed so that Viper will be able to figure the last inserted
982 ;; chunk of text with reasonable accuracy.
983 (defsubst vip-insert-state-post-command-sentinel
()
984 (if (and (memq vip-current-state
'(insert-state replace-state
))
986 (>= (point) vip-insert-point
))
987 (setq vip-last-posn-while-in-insert-state
(point-marker)))
988 (if (and (eq this-command
'dabbrev-expand
)
989 (integerp vip-pre-command-point
)
990 (> vip-insert-point vip-pre-command-point
))
991 (move-marker vip-insert-point vip-pre-command-point
))
994 (defsubst vip-insert-state-pre-command-sentinel
()
995 (if (and (eq this-command
'dabbrev-expand
)
996 (markerp vip-insert-point
)
997 (marker-position vip-insert-point
))
998 (setq vip-pre-command-point
(marker-position vip-insert-point
))))
1000 (defsubst vip-R-state-post-command-sentinel
()
1001 ;; Restoring cursor color is needed despite
1002 ;; vip-replace-state-pre-command-sentinel: When you jump to another buffer in
1003 ;; another frame, the pre-command hook won't change cursor color to default
1004 ;; in that other frame. So, if the second frame cursor was red and we set
1005 ;; the point outside the replacement region, then the cursor color will
1006 ;; remain red. Restoring the default, below, prevents this.
1007 (if (and (<= (vip-replace-start) (point))
1008 (<= (point) (vip-replace-end)))
1009 (vip-change-cursor-color vip-replace-overlay-cursor-color
)
1010 (vip-restore-cursor-color)
1013 ;; to speed up, don't change cursor color before self-insert
1014 ;; and common move commands
1015 (defsubst vip-replace-state-pre-command-sentinel
()
1016 (or (memq this-command
'(self-insert-command))
1017 (memq (vip-event-key last-command-event
)
1018 '(up down left right
(meta f
) (meta b
)
1019 (control n
) (control p
) (control f
) (control b
)))
1020 (vip-restore-cursor-color)))
1022 (defun vip-replace-state-post-command-sentinel ()
1023 ;; Restoring cursor color is needed despite
1024 ;; vip-replace-state-pre-command-sentinel: When one jumps to another buffer
1025 ;; in another frame, the pre-command hook won't change cursor color to
1026 ;; default in that other frame. So, if the second frame cursor was red and
1027 ;; we set the point outside the replacement region, then the cursor color
1028 ;; will remain red. Restoring the default, below, fixes this problem.
1030 ;; We optimize for self-insert-command's here, since they either don't change
1031 ;; cursor color or, if they terminate replace mode, the color will be changed
1032 ;; in vip-finish-change
1033 (or (memq this-command
'(self-insert-command))
1034 (vip-restore-cursor-color))
1036 ((eq vip-current-state
'replace-state
)
1037 ;; delete characters to compensate for inserted chars.
1038 (let ((replace-boundary (vip-replace-end)))
1040 (goto-char vip-last-posn-in-replace-region
)
1041 (delete-char vip-replace-chars-to-delete
)
1042 (setq vip-replace-chars-to-delete
0
1043 vip-replace-chars-deleted
0)
1044 ;; terminate replace mode if reached replace limit
1045 (if (= vip-last-posn-in-replace-region
1047 (vip-finish-change vip-last-posn-in-replace-region
)))
1049 (if (and (<= (vip-replace-start) (point))
1050 (<= (point) replace-boundary
))
1052 ;; the state may have changed in vip-finish-change above
1053 (if (eq vip-current-state
'replace-state
)
1054 (vip-change-cursor-color vip-replace-overlay-cursor-color
))
1055 (setq vip-last-posn-in-replace-region
(point-marker))))
1058 (t ;; terminate replace mode if changed Viper states.
1059 (vip-finish-change vip-last-posn-in-replace-region
))))
1064 ;; Change state to NEW-STATE---either emacs-state, vi-state, or insert-state.
1065 (defun vip-change-state (new-state)
1066 ;; Keep vip-post/pre-command-hooks fresh.
1067 ;; We remove then add vip-post/pre-command-sentinel since it is very
1068 ;; desirable that vip-pre-command-sentinel is the last hook and
1069 ;; vip-post-command-sentinel is the first hook.
1070 (remove-hook 'post-command-hook
'vip-post-command-sentinel
)
1071 (add-hook 'post-command-hook
'vip-post-command-sentinel
)
1072 (remove-hook 'pre-command-hook
'vip-pre-command-sentinel
)
1073 (add-hook 'pre-command-hook
'vip-pre-command-sentinel t
)
1074 ;; These hooks will be added back if switching to insert/replace mode
1075 (vip-remove-hook 'vip-post-command-hooks
1076 'vip-insert-state-post-command-sentinel
)
1077 (vip-remove-hook 'vip-pre-command-hooks
1078 'vip-insert-state-pre-command-sentinel
)
1079 (cond ((eq new-state
'vi-state
)
1080 (cond ((member vip-current-state
'(insert-state replace-state
))
1082 ;; move vip-last-posn-while-in-insert-state
1083 ;; This is a normal hook that is executed in insert/replace
1084 ;; states after each command. In Vi/Emacs state, it does
1085 ;; nothing. We need to execute it here to make sure that
1086 ;; the last posn was recorded when we hit ESC.
1087 ;; It may be left unrecorded if the last thing done in
1088 ;; insert/repl state was dabbrev-expansion or abbrev
1089 ;; expansion caused by hitting ESC
1090 (vip-insert-state-post-command-sentinel)
1092 (condition-case conds
1094 (vip-save-last-insertion
1096 vip-last-posn-while-in-insert-state
)
1097 (if vip-began-as-replace
1098 (setq vip-began-as-replace nil
)
1099 ;; repeat insert commands if numerical arg > 1
1101 (vip-repeat-insert-command))))
1103 (vip-message-conditions conds
)))
1105 (if (> (length vip-last-insertion
) 0)
1106 (vip-push-onto-ring vip-last-insertion
1107 'vip-insertion-ring
))
1109 (if vip-ex-style-editing-in-insert
1110 (or (bolp) (backward-char 1))))
1113 ;; insert or replace
1114 ((memq new-state
'(insert-state replace-state
))
1115 (if (memq vip-current-state
'(emacs-state vi-state
))
1116 (vip-move-marker-locally 'vip-insert-point
(point)))
1117 (vip-move-marker-locally 'vip-last-posn-while-in-insert-state
(point))
1118 (vip-add-hook 'vip-post-command-hooks
1119 'vip-insert-state-post-command-sentinel t
)
1120 (vip-add-hook 'vip-pre-command-hooks
1121 'vip-insert-state-pre-command-sentinel t
))
1124 ;; Nothing needs to be done to switch to emacs mode! Just set some
1125 ;; variables, which is already done in vip-change-state-to-emacs!
1127 (setq vip-current-state new-state
)
1128 (vip-normalize-minor-mode-map-alist)
1129 (vip-adjust-keys-for new-state
)
1130 (vip-set-mode-vars-for new-state
)
1131 (vip-refresh-mode-line)
1136 (defun vip-adjust-keys-for (state)
1137 "Make necessary adjustments to keymaps before entering STATE."
1138 (cond ((memq state
'(insert-state replace-state
))
1141 (define-key vip-insert-basic-map
"\C-m" 'vip-autoindent
)
1142 (if vip-want-emacs-keys-in-insert
1144 (define-key vip-insert-basic-map
"\C-j" nil
)
1146 (define-key vip-insert-basic-map
"\C-j" 'vip-autoindent
))))
1148 (setq vip-insert-diehard-minor-mode
1149 (not vip-want-emacs-keys-in-insert
))
1151 (if vip-want-ctl-h-help
1153 (define-key vip-insert-basic-map
"\C-h" 'help-command
)
1154 (define-key vip-replace-map
"\C-h" 'help-command
))
1155 (define-key vip-insert-basic-map
1156 "\C-h" 'vip-del-backward-char-in-insert
)
1157 (define-key vip-replace-map
1158 "\C-h" 'vip-del-backward-char-in-replace
)))
1161 (setq vip-vi-diehard-minor-mode
(not vip-want-emacs-keys-in-vi
))
1162 (if vip-want-ctl-h-help
1163 (define-key vip-vi-basic-map
"\C-h" 'help-command
)
1164 (define-key vip-vi-basic-map
"\C-h" 'vip-backward-char
)))
1168 ;; Normalizes minor-mode-map-alist by putting Viper keymaps first.
1169 ;; This ensures that Viper bindings are in effect, regardless of which minor
1170 ;; modes were turned on by the user or by other packages.
1171 (defun vip-normalize-minor-mode-map-alist ()
1172 (setq minor-mode-map-alist
1173 (vip-append-filter-alist
1175 (cons 'vip-vi-intercept-minor-mode vip-vi-intercept-map
)
1176 (cons 'vip-vi-minibuffer-minor-mode vip-minibuffer-map
)
1177 (cons 'vip-vi-local-user-minor-mode vip-vi-local-user-map
)
1178 (cons 'vip-vi-kbd-minor-mode vip-vi-kbd-map
)
1179 (cons 'vip-vi-global-user-minor-mode vip-vi-global-user-map
)
1180 (cons 'vip-vi-state-modifier-minor-mode
1182 (cdr (assoc major-mode vip-vi-state-modifier-alist
)))
1183 (cdr (assoc major-mode vip-vi-state-modifier-alist
))
1185 (cons 'vip-vi-diehard-minor-mode vip-vi-diehard-map
)
1186 (cons 'vip-vi-basic-minor-mode vip-vi-basic-map
)
1187 (cons 'vip-insert-intercept-minor-mode vip-insert-intercept-map
)
1188 (cons 'vip-replace-minor-mode vip-replace-map
)
1189 ;; vip-insert-minibuffer-minor-mode must come after
1190 ;; vip-replace-minor-mode
1191 (cons 'vip-insert-minibuffer-minor-mode
1193 (cons 'vip-insert-local-user-minor-mode
1194 vip-insert-local-user-map
)
1195 (cons 'vip-insert-kbd-minor-mode vip-insert-kbd-map
)
1196 (cons 'vip-insert-global-user-minor-mode
1197 vip-insert-global-user-map
)
1198 (cons 'vip-insert-state-modifier-minor-mode
1201 (assoc major-mode vip-insert-state-modifier-alist
)))
1203 (assoc major-mode vip-insert-state-modifier-alist
))
1205 (cons 'vip-insert-diehard-minor-mode vip-insert-diehard-map
)
1206 (cons 'vip-insert-basic-minor-mode vip-insert-basic-map
)
1207 (cons 'vip-emacs-intercept-minor-mode
1208 vip-emacs-intercept-map
)
1209 (cons 'vip-emacs-local-user-minor-mode
1210 vip-emacs-local-user-map
)
1211 (cons 'vip-emacs-kbd-minor-mode vip-emacs-kbd-map
)
1212 (cons 'vip-emacs-global-user-minor-mode
1213 vip-emacs-global-user-map
)
1214 (cons 'vip-emacs-state-modifier-minor-mode
1217 (assoc major-mode vip-emacs-state-modifier-alist
)))
1219 (assoc major-mode vip-emacs-state-modifier-alist
))
1222 minor-mode-map-alist
)))
1228 ;; Viper mode-changing commands and utilities
1230 ;; Modifies mode-line-buffer-identification.
1231 (defun vip-refresh-mode-line ()
1232 (setq vip-mode-string
1233 (cond ((eq vip-current-state
'emacs-state
) vip-emacs-state-id
)
1234 ((eq vip-current-state
'vi-state
) vip-vi-state-id
)
1235 ((eq vip-current-state
'replace-state
) vip-replace-state-id
)
1236 ((eq vip-current-state
'insert-state
) vip-insert-state-id
)))
1238 ;; Sets Viper mode string in global-mode-string
1239 (force-mode-line-update))
1242 (defun viper-mode ()
1243 "Turn on Viper emulation of Vi."
1245 (if (not noninteractive
)
1247 (if vip-first-time
; This check is important. Without it, startup and
1248 (progn ; expert-level msgs mix up when viper-mode recurses
1249 (setq vip-first-time nil
)
1250 (if (not vip-inhibit-startup-message
)
1251 (save-window-excursion
1252 (setq vip-inhibit-startup-message t
)
1253 (delete-other-windows)
1254 (switch-to-buffer "Viper Startup Message")
1257 (substitute-command-keys
1258 "Viper Is a Package for Emacs Rebels.
1259 It is also a VI Plan for Emacs Rescue and a venomous VI PERil.
1261 Technically speaking, Viper is a Vi emulation package for GNU Emacs 19 and
1262 XEmacs 19. It supports virtually all of Vi and Ex functionality, extending
1263 and improving upon much of it.
1265 1. Viper supports Vi at several levels. Level 1 is the closest to Vi,
1266 level 5 provides the most flexibility to depart from many Vi conventions.
1268 You will be asked to specify your user level in a following screen.
1270 If you select user level 1 then the keys ^X, ^C, ^Z, and ^G will behave
1271 as in VI, to smooth transition to Viper for the beginners. However, to
1272 use Emacs productively, you are advised to reach user level 3 or higher.
1274 If your user level is 2 or higher, ^X and ^C will invoke Emacs
1275 functions,as usual in Emacs; ^Z will toggle vi/emacs modes, and
1276 ^G will be the usual Emacs's keyboard-quit (something like ^C in VI).
1278 2. Vi exit functions (e.g., :wq, ZZ) work on INDIVIDUAL files -- they
1279 do not cause Emacs to quit, except at user level 1 (a novice).
1280 3. ^X^C EXITS EMACS.
1281 4. Viper supports multiple undo: `u' will undo. Typing `.' will repeat
1282 undo. Another `u' changes direction.
1284 6. Emacs Meta functions are invoked by typing `_' or `\\ ESC'.
1285 On a window system, the best way is to use the Meta-key.
1286 7. Try \\[keyboard-quit] and \\[abort-recursive-edit] repeatedly,if
1287 something funny happens. This would abort the current editing command.
1289 You can get more information on Viper by:
1291 a. Typing `:help' in Vi state
1292 b. Printing Viper manual, found in ./etc/viper.dvi
1293 c. Printing ViperCard, the Quick Reference, found in ./etc/viperCard.dvi
1295 This startup message appears whenever you load Viper, unless you type `y' now."
1297 (goto-char (point-min))
1298 (if (y-or-n-p "Inhibit Viper startup message? ")
1300 'vip-inhibit-startup-message
1301 "Viper startup message inhibited"
1302 vip-custom-file-name t
))
1303 ;;(kill-buffer (current-buffer))
1305 "The last message is in buffer `Viper Startup Message'")
1308 (vip-set-expert-level 'dont-change-unless
)))
1309 (vip-change-state-to-vi))))
1312 (defalias 'vip-mode
'viper-mode
)
1315 ;; Switch from Insert state to Vi state.
1316 (defun vip-exit-insert-state ()
1318 (vip-change-state-to-vi))
1320 (defun vip-set-mode-vars-for (state)
1321 "Sets Viper minor mode variables to put Viper's state STATE in effect."
1324 (setq vip-vi-minibuffer-minor-mode nil
1325 vip-insert-minibuffer-minor-mode nil
1326 vip-vi-intercept-minor-mode nil
1327 vip-insert-intercept-minor-mode nil
1329 vip-vi-local-user-minor-mode nil
1330 vip-vi-kbd-minor-mode nil
1331 vip-vi-global-user-minor-mode nil
1332 vip-vi-state-modifier-minor-mode nil
1333 vip-vi-diehard-minor-mode nil
1334 vip-vi-basic-minor-mode nil
1336 vip-replace-minor-mode nil
1338 vip-insert-local-user-minor-mode nil
1339 vip-insert-kbd-minor-mode nil
1340 vip-insert-global-user-minor-mode nil
1341 vip-insert-state-modifier-minor-mode nil
1342 vip-insert-diehard-minor-mode nil
1343 vip-insert-basic-minor-mode nil
1344 vip-emacs-intercept-minor-mode t
1345 vip-emacs-local-user-minor-mode t
1346 vip-emacs-kbd-minor-mode
(not (vip-is-in-minibuffer))
1347 vip-emacs-global-user-minor-mode t
1348 vip-emacs-state-modifier-minor-mode t
1352 (if (eq state
'vi-state
) ; adjust for vi-state
1354 vip-vi-intercept-minor-mode t
1355 vip-vi-minibuffer-minor-mode
(vip-is-in-minibuffer)
1356 vip-vi-local-user-minor-mode t
1357 vip-vi-kbd-minor-mode
(not (vip-is-in-minibuffer))
1358 vip-vi-global-user-minor-mode t
1359 vip-vi-state-modifier-minor-mode t
1360 ;; don't let the diehard keymap block command completion
1361 ;; and other things in the minibuffer
1362 vip-vi-diehard-minor-mode
(not
1363 (or vip-want-emacs-keys-in-vi
1364 (vip-is-in-minibuffer)))
1365 vip-vi-basic-minor-mode t
1366 vip-emacs-intercept-minor-mode nil
1367 vip-emacs-local-user-minor-mode nil
1368 vip-emacs-kbd-minor-mode nil
1369 vip-emacs-global-user-minor-mode nil
1370 vip-emacs-state-modifier-minor-mode nil
1373 ;; Insert and Replace states
1374 (if (member state
'(insert-state replace-state
))
1376 vip-insert-intercept-minor-mode t
1377 vip-replace-minor-mode
(eq state
'replace-state
)
1378 vip-insert-minibuffer-minor-mode
(vip-is-in-minibuffer)
1379 vip-insert-local-user-minor-mode t
1380 vip-insert-kbd-minor-mode
(not (vip-is-in-minibuffer))
1381 vip-insert-global-user-minor-mode t
1382 vip-insert-state-modifier-minor-mode t
1383 ;; don't let the diehard keymap block command completion
1384 ;; and other things in the minibuffer
1385 vip-insert-diehard-minor-mode
(not
1386 (or vip-want-emacs-keys-in-insert
1387 (vip-is-in-minibuffer)))
1388 vip-insert-basic-minor-mode t
1389 vip-emacs-intercept-minor-mode nil
1390 vip-emacs-local-user-minor-mode nil
1391 vip-emacs-kbd-minor-mode nil
1392 vip-emacs-global-user-minor-mode nil
1393 vip-emacs-state-modifier-minor-mode nil
1397 (if (vip-has-face-support-p)
1398 (setq vip-minibuffer-current-face
1399 (cond ((eq state
'emacs-state
) vip-minibuffer-emacs-face
)
1400 ((eq state
'vi-state
) vip-minibuffer-vi-face
)
1401 ((memq state
'(insert-state replace-state
))
1402 vip-minibuffer-insert-face
))))
1404 (if (vip-is-in-minibuffer)
1405 (vip-set-minibuffer-overlay))
1408 ;; This also takes care of the annoying incomplete lines in files.
1409 ;; Also, this fixes `undo' to work vi-style for complex commands.
1410 (defun vip-change-state-to-vi ()
1411 "Change Viper state to Vi."
1413 (if (and vip-first-time
(not (vip-is-in-minibuffer)))
1415 (if overwrite-mode
(overwrite-mode nil
))
1416 (if abbrev-mode
(expand-abbrev))
1417 (if (and auto-fill-function
(> (current-column) fill-column
))
1418 (funcall auto-fill-function
))
1419 ;; don't leave whitespace lines around
1420 (if (and (memq last-command
1422 vip-open-line vip-Open-line
1423 vip-replace-state-exit-cmd
))
1424 (vip-over-whitespace-line))
1425 (indent-to-left-margin))
1426 (vip-add-newline-at-eob-if-necessary)
1427 (if vip-undo-needs-adjustment
(vip-adjust-undo))
1428 (vip-change-state 'vi-state
)
1430 ;; always turn off iso-accents-mode, or else we won't be able to use the
1431 ;; keys `,',^ in Vi state, as they will do accents instead of Vi actions.
1432 (if (and (boundp 'iso-accents-mode
) iso-accents-mode
)
1433 (iso-accents-mode -
1))
1435 ;; Protection against user errors in hooks
1436 (condition-case conds
1437 (run-hooks 'vip-vi-state-hook
)
1439 (vip-message-conditions conds
)))))
1441 (defun vip-change-state-to-insert ()
1442 "Change Viper state to Insert."
1444 (vip-change-state 'insert-state
)
1445 (if (and vip-automatic-iso-accents
(fboundp 'iso-accents-mode
))
1446 (iso-accents-mode 1)) ; turn iso accents on
1448 ;; Protection against user errors in hooks
1449 (condition-case conds
1450 (run-hooks 'vip-insert-state-hook
)
1452 (vip-message-conditions conds
))))
1454 (defsubst vip-downgrade-to-insert
()
1455 (setq vip-current-state
'insert-state
1456 vip-replace-minor-mode nil
)
1461 ;; Change to replace state. When the end of replacement region is reached,
1462 ;; replace state changes to insert state.
1463 (defun vip-change-state-to-replace (&optional non-R-cmd
)
1464 (vip-change-state 'replace-state
)
1465 (if (and vip-automatic-iso-accents
(fboundp 'iso-accents-mode
))
1466 (iso-accents-mode 1)) ; turn iso accents on
1467 ;; Run insert-state-hook
1468 (condition-case conds
1469 (run-hooks 'vip-insert-state-hook
'vip-replace-state-hook
)
1471 (vip-message-conditions conds
)))
1475 ;; 'R' is implemented using Emacs's overwrite-mode
1480 (defun vip-change-state-to-emacs ()
1481 "Change Viper state to Emacs."
1483 (vip-change-state 'emacs-state
)
1484 (if (and vip-automatic-iso-accents
(fboundp 'iso-accents-mode
))
1485 (iso-accents-mode 1)) ; turn iso accents on
1487 ;; Protection agains user errors in hooks
1488 (condition-case conds
1489 (run-hooks 'vip-emacs-state-hook
)
1491 (vip-message-conditions conds
))))
1493 ;; escape to emacs mode termporarily
1494 (defun vip-escape-to-emacs (arg &optional events
)
1495 "Escape to Emacs state from Vi state for one Emacs command.
1496 ARG is used as the prefix value for the executed command. If
1497 EVENTS is a list of events, which become the beginning of the command."
1499 (vip-escape-to-state arg events
'emacs-state
))
1501 ;; escape to Vi mode termporarily
1502 (defun vip-escape-to-vi ()
1503 "Escape from Emacs state to Vi state for one Vi 1-character command.
1504 This doesn't work with prefix arguments or most complex commands like
1505 cw, dw, etc. But it does work with some 2-character commands,
1508 (vip-escape-to-state nil nil
'vi-state
))
1510 ;; Escape to STATE mode for one Emacs command.
1511 (defun vip-escape-to-state (arg events state
)
1512 (let (com key prefix-arg
)
1513 ;; this temporarily turns off Viper's minor mode keymaps
1514 (vip-set-mode-vars-for state
)
1515 (vip-normalize-minor-mode-map-alist)
1516 (if events
(vip-set-unread-command-events events
))
1518 ;; protect against keyboard quit and other errors
1523 (setq com
(key-binding (setq key
1525 (read-key-sequence nil
)
1526 (read-key-sequence nil t
)))))
1527 ;; In case of indirection--chase definitions.
1528 ;; Have to do it here because we execute this command under
1529 ;; different keymaps, so command-execute may not do the
1530 ;; right thing there
1531 (while (vectorp com
) (setq com
(key-binding com
))))
1533 ;; exec command in the right Viper state
1534 ;; otherwise, if we switch buffers in the escaped command,
1535 ;; Viper's mode vars will remain those of `state'. When we return
1536 ;; to the orig buffer, the bindings will be screwed up.
1537 (vip-set-mode-vars-for vip-current-state
)
1539 ;; this-command, last-command-char, last-command-event
1540 (setq this-command com
)
1541 (if vip-xemacs-p
; XEmacs represents key sequences as vectors
1542 (setq last-command-event
(vip-seq-last-elt key
)
1543 last-command-char
(event-to-character last-command-event
))
1544 ;; Emacs represents them as sequences (str or vec)
1545 (setq last-command-event
(vip-seq-last-elt key
)
1546 last-command-char last-command-event
))
1550 (setq prefix-arg arg
)
1551 (command-execute com
)))
1555 (vip-set-mode-vars-for vip-current-state
)) ; set state in new buffer
1557 (defun vip-exec-form-in-emacs (form)
1558 "Execute FORM in Emacs, temporarily disabling Viper's minor modes.
1559 Similar to vip-escape-to-emacs, but accepts forms rather than keystrokes."
1560 (let ((buff (current-buffer))
1562 (vip-set-mode-vars-for 'emacs-state
)
1563 (setq result
(eval form
))
1564 (if (not (equal buff
(current-buffer))) ; cmd switched buffer
1567 (vip-set-mode-vars-for vip-current-state
)))
1568 (vip-set-mode-vars-for vip-current-state
)
1572 ;; This is needed because minor modes sometimes override essential Viper
1573 ;; bindings. By letting Viper know which files these modes are in, it will
1574 ;; arrange to reorganize minor-mode-map-alist so that things will work right.
1575 (defun vip-harness-minor-mode (load-file)
1576 "Familiarize Viper with a minor mode defined in LOAD_FILE.
1577 Minor modes that have their own keymaps may overshadow Viper keymaps.
1578 This function is designed to make Viper aware of the packages that define
1581 (vip-harness-minor-mode load-file)
1583 LOAD-FILE is a name of the file where the specific minor mode is defined.
1584 Suffixes such as .el or .elc should be stripped."
1586 (interactive "sEnter name of the load file: ")
1588 (vip-eval-after-load load-file
'(vip-normalize-minor-mode-map-alist))
1590 ;; Change the default for minor-mode-map-alist each time a harnessed minor
1591 ;; mode adds its own keymap to the a-list.
1592 (vip-eval-after-load
1593 load-file
'(setq-default minor-mode-map-alist minor-mode-map-alist
))
1597 (defun vip-ESC (arg)
1598 "Emulate ESC key in Emacs.
1599 Prevents multiple escape keystrokes if vip-no-multiple-ESC is true. In that
1600 case \@ will be bound to ESC. If vip-no-multiple-ESC is 'twice double ESC
1601 would dings in vi-state. Other ESC sequences are emulated via the current
1602 Emacs's major mode keymap. This is more convenient on dumb terminals and in
1603 Emacs -nw, since this won't block functional keys such as up,down,
1604 etc. Meta key also will work. When vip-no-multiple-ESC is nil, ESC key
1605 behaves as in Emacs, any number of multiple escapes is allowed."
1608 (cond ((and (not vip-no-multiple-ESC
) (eq vip-current-state
'vi-state
))
1609 (setq char
(vip-read-char-exclusive))
1610 (vip-escape-to-emacs arg
(list ?\e char
) ))
1611 ((and (eq vip-no-multiple-ESC
'twice
)
1612 (eq vip-current-state
'vi-state
))
1613 (setq char
(vip-read-char-exclusive))
1614 (if (= char
(string-to-char vip-ESC-key
))
1616 (vip-escape-to-emacs arg
(list ?\e char
) )))
1620 (defun vip-alternate-ESC (arg)
1621 "ESC key without checking for multiple keystrokes."
1623 (vip-escape-to-emacs arg
'(?\e
)))
1626 ;; Intercept ESC sequences on dumb terminals.
1627 ;; Based on the idea contributed by Marcelino Veiga Tuimil <mveiga@dit.upm.es>
1629 ;; Check if last key was ESC and if so try to reread it as a function key.
1630 ;; But only if there are characters to read during a very short time.
1631 ;; Returns the last event, if any.
1632 (defun vip-envelop-ESC-key ()
1633 (let ((event last-input-event
)
1636 (if (vip-ESC-event-p event)
1638 (if (vip-fast-keysequence-p)
1640 (let (minor-mode-map-alist)
1641 (vip-set-unread-command-events event)
1644 (ad-get-orig-definition 'read-key-sequence) nil))
1646 ;; If keyseq translates into something that still has ESC
1647 ;; at the beginning, separate ESC from the rest of the seq.
1648 ;; In XEmacs we check for events that are keypress meta-key
1649 ;; and convert them into [escape key]
1651 ;; This is needed for the following reason:
1652 ;; If ESC is the first symbol, we interpret it as if the
1653 ;; user typed ESC and then quickly some other symbols.
1654 ;; If ESC is not the first one, then the key sequence
1655 ;; entered was apparently translated into a function key or
1656 ;; something (e.g., one may have
1657 ;; (define-key function-key-map "\e[192z" [f11])
1658 ;; which would translate the escape-sequence generated by
1659 ;; f11 in an xterm window into the symbolic key f11.
1661 ;; If `first-key' is not an ESC event, we make it into the
1662 ;; last-command-event in order to pretend that this key was
1663 ;; pressed. This is needed to allow arrow keys to be bound to
1664 ;; macros. Otherwise, vip-exec-mapped-kbd-macro will think that
1665 ;; the last event was ESC and so it'll execute whatever is
1666 ;; bound to ESC. (Viper macros can't be bound to
1668 (let* ((first-key (elt keyseq 0))
1669 (key-mod (event-modifiers first-key)))
1670 (cond ((vip-ESC-event-p first-key)
1671 ;; put keys following ESC on the unread list
1672 ;; and return ESC as the key-sequence
1673 (vip-set-unread-command-events (subseq keyseq 1))
1674 (setq last-input-event event
1675 keyseq (if vip-emacs-p
1677 (vector (character-to-event ?\e)))))
1679 (key-press-event-p first-key)
1680 (equal '(meta) key-mod))
1681 (vip-set-unread-command-events
1683 (character-to-event (event-key first-key)))
1685 (setq last-input-event event
1686 keyseq (vector (character-to-event ?\e))))
1688 (setq last-command-event first-key))
1692 ;; this is escape event with nothing after it
1693 ;; put in unread-command-event and then re-read
1694 (vip-set-unread-command-events event)
1696 (funcall (ad-get-orig-definition 'read-key-sequence) nil))
1698 ;; not an escape event
1699 (setq keyseq (vector event)))
1704 (defadvice read-key-sequence (around vip-read-keyseq-ad activate)
1705 "Harness to work for Viper. This advice is harmless---don't worry!"
1706 (let (inhibit-quit event keyseq)
1707 (setq keyseq ad-do-it)
1708 (setq event (if vip-xemacs-p
1709 (elt keyseq 0) ; XEmacs returns vector of events
1710 (elt (listify-key-sequence keyseq) 0)))
1711 (if (vip-ESC-event-p event)
1712 (let (unread-command-events)
1713 (vip-set-unread-command-events keyseq)
1714 (if (vip-fast-keysequence-p)
1715 (let ((vip-vi-global-user-minor-mode nil)
1716 (vip-vi-local-user-minor-mode nil)
1717 (vip-replace-minor-mode nil) ; actually unnecessary
1718 (vip-insert-global-user-minor-mode nil)
1719 (vip-insert-local-user-minor-mode nil))
1720 (setq keyseq ad-do-it))
1721 (setq keyseq ad-do-it))))
1724 (defadvice describe-key (before vip-read-keyseq-ad protect activate)
1725 "Force to read key via `read-key-sequence'."
1726 (interactive (list (vip-events-to-keys
1727 (read-key-sequence "Describe key: ")))))
1729 (defadvice describe-key-briefly (before vip-read-keyseq-ad protect activate)
1730 "Force to read key via `read-key-sequence'."
1731 (interactive (list (vip-events-to-keys
1732 (read-key-sequence "Describe key briefly: ")))))
1734 ;; Listen to ESC key.
1735 ;; If a sequence of keys starting with ESC is issued with very short delays,
1736 ;; interpret these keys in Emacs mode, so ESC won't be interpreted as a Vi key.
1737 (defun vip-intercept-ESC-key ()
1738 "Function that implements ESC key in Viper emulation of Vi."
1740 (let ((cmd (or (key-binding (vip-envelop-ESC-key))
1741 '(lambda () (interactive) (error "")))))
1743 ;; call the actual function to execute ESC (if no other symbols followed)
1744 ;; or the key bound to the ESC sequence (if the sequence was issued
1745 ;; with very short delay between characters.
1746 (if (eq cmd 'vip-intercept-ESC-key)
1748 (cond ((eq vip-current-state 'vi-state)
1750 ((eq vip-current-state 'insert-state)
1751 'vip-exit-insert-state)
1752 ((eq vip-current-state 'replace-state)
1753 'vip-replace-state-exit-cmd)
1754 (t 'vip-change-state-to-vi)
1756 (call-interactively cmd)))
1760 ;; prefix argument for Vi mode
1762 ;; In Vi mode, prefix argument is a dotted pair (NUM . COM) where NUM
1763 ;; represents the numeric value of the prefix argument and COM represents
1764 ;; command prefix such as "c", "d", "m" and "y".
1766 ;; Get value part of prefix-argument ARG.
1767 (defsubst vip-p-val (arg)
1768 (cond ((null arg) 1)
1770 (if (or (null (car arg)) (equal (car arg) '(nil)))
1774 ;; Get raw value part of prefix-argument ARG.
1775 (defsubst vip-P-val (arg)
1776 (cond ((consp arg) (car arg))
1779 ;; Get com part of prefix-argument ARG.
1780 (defsubst vip-getcom (arg)
1781 (cond ((null arg) nil)
1782 ((consp arg) (cdr arg))
1785 ;; Get com part of prefix-argument ARG and modify it.
1786 (defun vip-getCom (arg)
1787 (let ((com (vip-getcom arg)))
1788 (cond ((equal com ?c) ?C)
1794 ;; Compute numeric prefix arg value.
1795 ;; Invoked by CHAR. COM is the command part obtained so far.
1796 (defun vip-prefix-arg-value (event com)
1798 ;; read while number
1799 (while (and (vip-characterp event) (>= event ?0) (<= event ?9))
1800 (setq value (+ (* (if (vip-characterp value) value 0) 10) (- event ?0)))
1801 (setq event (vip-read-event-convert-to-char)))
1803 (setq prefix-arg value)
1804 (if com (setq prefix-arg (cons prefix-arg com)))
1805 (while (eq event ?U)
1806 (vip-describe-arg prefix-arg)
1807 (setq event (vip-read-event-convert-to-char)))
1808 (vip-set-unread-command-events event)))
1810 ;; Vi operator as prefix argument."
1811 (defun vip-prefix-arg-com (char value com)
1815 (list ?c ?d ?y ?! ?< ?> ?= ?# ?r ?R ?\"
1816 vip-buffer-search-char)))
1818 ;; this means that we already have a command character, so we
1819 ;; construct a com list and exit while. however, if char is "
1822 ;; new com is (CHAR . OLDCOM)
1823 (if (memq char '(?# ?\")) (error ""))
1824 (setq com (cons char com))
1826 ;; If com is nil we set com as char, and read more. Again, if char
1827 ;; is ", we read the name of register and store it in vip-use-register.
1828 ;; if char is !, =, or #, a complete com is formed so we exit the
1830 (cond ((memq char '(?! ?=))
1832 (setq char (read-char))
1835 ;; read a char and encode it as com
1836 (setq com (+ 128 (read-char)))
1837 (setq char (read-char)))
1839 (let ((reg (read-char)))
1840 (if (vip-valid-register reg)
1841 (setq vip-use-register reg)
1843 (setq char (read-char))))
1846 (setq char (vip-read-char-exclusive)))))))
1848 ;; com is a single char, so we construct prefix-arg
1849 ;; and if char is ?, describe prefix arg, otherwise exit by
1850 ;; pushing the char back into vip-set-unread-command-events
1851 ;; Since char is a command, the command will execute with the prefix
1852 ;; argument that we just constructed.
1854 (setq prefix-arg (cons value com))
1856 (vip-describe-arg prefix-arg)
1857 (setq char (read-char)))
1858 (vip-set-unread-command-events char)
1860 ;; as com is non-nil, this means that we have a command to execute
1861 (if (memq (car com) '(?r ?R))
1862 ;; execute apropriate region command.
1863 (let ((char (car com)) (com (cdr com)))
1864 (setq prefix-arg (cons value com))
1865 (if (= char ?r) (vip-region prefix-arg)
1866 (vip-Region prefix-arg))
1868 (setq prefix-arg nil))
1869 ;; otherwise, reset prefix arg and call appropriate command
1870 (setq value (if (null value) 1 value))
1871 (setq prefix-arg nil)
1872 (cond ((equal com '(?c . ?c)) (vip-line (cons value ?C)))
1873 ((equal com '(?d . ?d)) (vip-line (cons value ?D)))
1874 ((equal com '(?d . ?y)) (vip-yank-defun))
1875 ((equal com '(?y . ?y)) (vip-line (cons value ?Y)))
1876 ((equal com '(?< . ?<)) (vip-line (cons value ?<)))
1877 ((equal com '(?> . ?>)) (vip-line (cons value ?>)))
1878 ((equal com '(?! . ?!)) (vip-line (cons value ?!)))
1879 ((equal com '(?= . ?=)) (vip-line (cons value ?=)))
1882 (defun vip-describe-arg (arg)
1884 (setq val (vip-P-val arg)
1885 com (vip-getcom arg))
1888 (message "Value is nil, and command is nil")
1889 (message "Value is nil, and command is `%c'" com))
1891 (message "Value is `%d', and command is nil" val)
1892 (message "Value is `%d', and command is `%c'" val com)))))
1894 (defun vip-digit-argument (arg)
1895 "Begin numeric argument for the next command."
1897 (vip-leave-region-active)
1898 (vip-prefix-arg-value last-command-char
1899 (if (consp arg) (cdr arg) nil)))
1901 (defun vip-command-argument (arg)
1902 "Accept a motion command as an argument."
1907 (cond ((null arg) nil)
1908 ((consp arg) (car arg))
1909 ((integerp arg) arg)
1910 (t (error vip-InvalidCommandArgument)))
1911 (cond ((null arg) nil)
1912 ((consp arg) (cdr arg))
1913 ((integerp arg) nil)
1914 (t (error vip-InvalidCommandArgument))))
1915 (quit (setq vip-use-register nil)
1916 (signal 'quit nil)))
1917 (vip-deactivate-mark))
1920 ;; repeat last destructive command
1922 ;; Append region to text in register REG.
1923 ;; START and END are buffer positions indicating what to append.
1924 (defsubst vip-append-to-register (reg start end)
1925 (set-register reg (concat (if (stringp (get-register reg))
1926 (get-register reg) "")
1927 (buffer-substring start end))))
1929 ;; Saves last inserted text for possible use by vip-repeat command.
1930 (defun vip-save-last-insertion (beg end)
1931 (setq vip-last-insertion (buffer-substring beg end))
1932 (or (< (length vip-d-com) 5)
1933 (setcar (nthcdr 4 vip-d-com) vip-last-insertion))
1934 (or (null vip-command-ring)
1935 (ring-empty-p vip-command-ring)
1937 (setcar (nthcdr 4 (vip-current-ring-item vip-command-ring))
1939 ;; del most recent elt, if identical to the second most-recent
1940 (vip-cleanup-ring vip-command-ring)))
1943 (defsubst vip-yank-last-insertion ()
1944 "Inserts the text saved by the previous vip-save-last-insertion command."
1946 (insert vip-last-insertion)
1950 ;; define functions to be executed
1952 ;; invoked by the `C' command
1953 (defun vip-exec-change (m-com com)
1954 ;; handle C cmd at the eol and at eob.
1955 (if (or (and (eolp) (= vip-com-point (point)))
1956 (= vip-com-point (point-max)))
1958 (insert " ")(backward-char 1)))
1959 (if (= vip-com-point (point))
1960 (vip-forward-char-carefully))
1962 (vip-change vip-com-point (point))
1963 (vip-change-subr vip-com-point (point))))
1965 ;; this is invoked by vip-substitute-line
1966 (defun vip-exec-Change (m-com com)
1968 (set-mark vip-com-point)
1969 (vip-enlarge-region (mark t) (point))
1970 (if vip-use-register
1972 (cond ((vip-valid-register vip-use-register '(letter digit))
1973 ;;(vip-valid-register vip-use-register '(letter)
1975 vip-use-register (mark t) (point) nil))
1976 ((vip-valid-register vip-use-register '(Letter))
1977 (vip-append-to-register
1978 (downcase vip-use-register) (mark t) (point)))
1979 (t (setq vip-use-register nil)
1980 (error vip-InvalidRegister vip-use-register)))
1981 (setq vip-use-register nil)))
1982 (delete-region (mark t) (point)))
1984 (if (= com ?C) (vip-change-mode-to-insert) (vip-yank-last-insertion)))
1986 (defun vip-exec-delete (m-com com)
1987 (if vip-use-register
1989 (cond ((vip-valid-register vip-use-register '(letter digit))
1990 ;;(vip-valid-register vip-use-register '(letter))
1992 vip-use-register vip-com-point (point) nil))
1993 ((vip-valid-register vip-use-register '(Letter))
1994 (vip-append-to-register
1995 (downcase vip-use-register) vip-com-point (point)))
1996 (t (setq vip-use-register nil)
1997 (error vip-InvalidRegister vip-use-register)))
1998 (setq vip-use-register nil)))
2000 (if (eq last-command 'd-command) 'kill-region nil))
2001 (kill-region vip-com-point (point))
2002 (setq this-command 'd-command)
2003 (if vip-ex-style-motion
2004 (if (and (eolp) (not (bolp))) (backward-char 1))))
2006 (defun vip-exec-Delete (m-com com)
2008 (set-mark vip-com-point)
2009 (vip-enlarge-region (mark t) (point))
2010 (if vip-use-register
2012 (cond ((vip-valid-register vip-use-register '(letter digit))
2013 ;;(vip-valid-register vip-use-register '(letter))
2015 vip-use-register (mark t) (point) nil))
2016 ((vip-valid-register vip-use-register '(Letter))
2017 (vip-append-to-register
2018 (downcase vip-use-register) (mark t) (point)))
2019 (t (setq vip-use-register nil)
2020 (error vip-InvalidRegister vip-use-register)))
2021 (setq vip-use-register nil)))
2023 (if (eq last-command 'D-command) 'kill-region nil))
2024 (kill-region (mark t) (point))
2025 (if (eq m-com 'vip-line) (setq this-command 'D-command)))
2026 (back-to-indentation))
2028 (defun vip-exec-yank (m-com com)
2029 (if vip-use-register
2031 (cond ((vip-valid-register vip-use-register '(letter digit))
2032 ;; (vip-valid-register vip-use-register '(letter))
2034 vip-use-register vip-com-point (point) nil))
2035 ((vip-valid-register vip-use-register '(Letter))
2036 (vip-append-to-register
2037 (downcase vip-use-register) vip-com-point (point)))
2038 (t (setq vip-use-register nil)
2039 (error vip-InvalidRegister vip-use-register)))
2040 (setq vip-use-register nil)))
2041 (setq last-command nil)
2042 (copy-region-as-kill vip-com-point (point))
2043 (goto-char vip-com-point))
2045 (defun vip-exec-Yank (m-com com)
2047 (set-mark vip-com-point)
2048 (vip-enlarge-region (mark t) (point))
2049 (if vip-use-register
2051 (cond ((vip-valid-register vip-use-register '(letter digit))
2053 vip-use-register (mark t) (point) nil))
2054 ((vip-valid-register vip-use-register '(Letter))
2055 (vip-append-to-register
2056 (downcase vip-use-register) (mark t) (point)))
2057 (t (setq vip-use-register nil)
2058 (error vip-InvalidRegister vip-use-register)))
2059 (setq vip-use-register nil)))
2060 (setq last-command nil)
2061 (copy-region-as-kill (mark t) (point)))
2062 (vip-deactivate-mark)
2063 (goto-char vip-com-point))
2065 (defun vip-exec-bang (m-com com)
2067 (set-mark vip-com-point)
2068 (vip-enlarge-region (mark t) (point))
2069 (shell-command-on-region
2072 (setq vip-last-shell-com
2073 (vip-read-string-with-history
2077 (car vip-shell-history)
2082 (defun vip-exec-equals (m-com com)
2084 (set-mark vip-com-point)
2085 (vip-enlarge-region (mark t) (point))
2086 (if (> (mark t) (point)) (exchange-point-and-mark))
2087 (indent-region (mark t) (point) nil)))
2089 (defun vip-exec-shift (m-com com)
2091 (set-mark vip-com-point)
2092 (vip-enlarge-region (mark t) (point))
2093 (if (> (mark t) (point)) (exchange-point-and-mark))
2094 (indent-rigidly (mark t) (point)
2097 (- vip-shift-width))))
2098 ;; return point to where it was before shift
2099 (goto-char vip-com-point))
2101 ;; this is needed because some commands fake com by setting it to ?r, which
2102 ;; denotes repeated insert command.
2103 (defsubst vip-exec-dummy (m-com com)
2106 (defun vip-exec-buffer-search (m-com com)
2107 (setq vip-s-string (buffer-substring (point) vip-com-point))
2108 (setq vip-s-forward t)
2109 (setq vip-search-history (cons vip-s-string vip-search-history))
2110 (vip-search vip-s-string vip-s-forward 1))
2112 (defvar vip-exec-array (make-vector 128 nil))
2114 ;; Using a dispatch array allows adding functions like buffer search
2115 ;; without affecting other functions. Buffer search can now be bound
2116 ;; to any character.
2118 (aset vip-exec-array ?c 'vip-exec-change)
2119 (aset vip-exec-array ?C 'vip-exec-Change)
2120 (aset vip-exec-array ?d 'vip-exec-delete)
2121 (aset vip-exec-array ?D 'vip-exec-Delete)
2122 (aset vip-exec-array ?y 'vip-exec-yank)
2123 (aset vip-exec-array ?Y 'vip-exec-Yank)
2124 (aset vip-exec-array ?r 'vip-exec-dummy)
2125 (aset vip-exec-array ?! 'vip-exec-bang)
2126 (aset vip-exec-array ?< 'vip-exec-shift)
2127 (aset vip-exec-array ?> 'vip-exec-shift)
2128 (aset vip-exec-array ?= 'vip-exec-equals)
2132 ;; This function is called by various movement commands to execute a
2133 ;; destructive command on the region specified by the movement command. For
2134 ;; instance, if the user types cw, then the command vip-forward-word will
2135 ;; call vip-execute-com to execute vip-exec-change, which eventually will
2136 ;; call vip-change to invoke the replace mode on the region.
2138 ;; The list (M-COM VAL COM REG INSETED-TEXT COMMAND-KEYS) is set to
2139 ;; vip-d-com for later use by vip-repeat.
2140 (defun vip-execute-com (m-com val com)
2141 (let ((reg vip-use-register))
2142 ;; this is the special command `#'
2144 (vip-special-prefix-com (- com 128))
2145 (let ((fn (aref vip-exec-array (if (< com 0) (- com) com))))
2147 (error "%c: %s" com vip-InvalidViCommand)
2148 (funcall fn m-com com))))
2149 (if (vip-dotable-command-p com)
2150 (vip-set-destructive-command
2152 (if (memq com (list ?c ?C ?!)) (- com) com)
2157 (defun vip-repeat (arg)
2158 "Re-execute last destructive command.
2159 Use the info in vip-d-com, which has the form
2160 \(com val ch reg inserted-text command-keys\),
2161 where `com' is the command to be re-executed, `val' is the
2162 argument to `com', `ch' is a flag for repeat, and `reg' is optional;
2163 if it exists, it is the name of the register for `com'.
2164 If the prefix argument, ARG, is non-nil, it is used instead of `val'."
2166 (let ((save-point (point)) ; save point before repeating prev cmd
2167 ;; Pass along that we are repeating a destructive command
2168 ;; This tells vip-set-destructive-command not to update
2170 (vip-intermediate-command 'vip-repeat))
2171 (if (eq last-command 'vip-undo)
2172 ;; if the last command was vip-undo, then undo-more
2174 ;; otherwise execute the command stored in vip-d-com. if arg is non-nil
2175 ;; its prefix value is used as new prefix value for the command.
2176 (let ((m-com (car vip-d-com))
2177 (val (vip-P-val arg))
2178 (com (nth 2 vip-d-com))
2179 (reg (nth 3 vip-d-com)))
2180 (if (null val) (setq val (nth 1 vip-d-com)))
2181 (if (null m-com) (error "No previous command to repeat."))
2182 (setq vip-use-register reg)
2183 (if (nth 4 vip-d-com) ; text inserted by command
2184 (setq vip-last-insertion (nth 4 vip-d-com)
2185 vip-d-char (nth 4 vip-d-com)))
2186 (funcall m-com (cons val com))
2187 (if (and vip-keep-point-on-repeat (< save-point (point)))
2188 (goto-char save-point)) ; go back to before repeat.
2189 (if (and (eolp) (not (bolp)))
2192 (if vip-undo-needs-adjustment (vip-adjust-undo)) ; take care of undo
2193 ;; If the prev cmd was rotating the command ring, this means that `.' has
2194 ;; just executed a command from that ring. So, push it on the ring again.
2195 ;; If we are just executing previous command , then don't push vip-d-com
2196 ;; because vip-d-com is not fully constructed in this case (its keys and
2197 ;; the inserted text may be nil). Besides, in this case, the command
2198 ;; executed by `.' is already on the ring.
2199 (if (eq last-command 'vip-display-current-destructive-command)
2200 (vip-push-onto-ring vip-d-com 'vip-command-ring))
2201 (vip-deactivate-mark)
2204 (defun vip-repeat-from-history ()
2205 "Repeat a destructive command from history.
2206 Doesn't change vip-command-ring in any way, so `.' will work as before
2207 executing this command.
2208 This command is supposed to be bound to a two-character Vi macro where
2209 the second character is a digit 0 to 9. The digit indicates which
2210 history command to execute. `<char>0' is equivalent to `.', `<char>1'
2211 invokes the command before that, etc."
2213 (let* ((vip-intermediate-command 'repeating-display-destructive-command)
2214 (idx (cond (vip-this-kbd-macro
2216 (symbol-name (elt vip-this-kbd-macro 1))))
2219 (vip-d-com vip-d-com))
2221 (or (and (numberp num) (<= 0 num) (<= num 9))
2226 "`vip-repeat-from-history' must be invoked as a Vi macro bound to `<key><digit>'")))
2228 (setq vip-d-com (vip-special-ring-rotate1 vip-command-ring -1))
2229 (setq num (1- num)))
2232 (vip-special-ring-rotate1 vip-command-ring 1)
2233 (setq num (1+ num)))
2237 ;; This command is invoked interactively by the key sequence #<char>
2238 (defun vip-special-prefix-com (char)
2240 (downcase-region (min vip-com-point (point))
2241 (max vip-com-point (point))))
2243 (upcase-region (min vip-com-point (point))
2244 (max vip-com-point (point))))
2246 (push-mark vip-com-point t)
2247 (vip-global-execute))
2249 (push-mark vip-com-point t)
2251 ((= char ?s) (funcall vip-spell-function vip-com-point (point)))
2252 (t (error "#%c: %s" char vip-InvalidViCommand))))
2258 "Undo previous change."
2261 (let ((modified (buffer-modified-p))
2262 (before-undo-pt (point-marker))
2263 (after-change-functions after-change-functions)
2264 undo-beg-posn undo-end-posn)
2266 ;; no need to remove this hook, since this var has scope inside a let.
2267 (add-hook 'after-change-functions
2268 '(lambda (beg end len)
2269 (setq undo-beg-posn beg
2270 undo-end-posn (or end beg))))
2274 (setq undo-beg-posn (or undo-beg-posn before-undo-pt)
2275 undo-end-posn (or undo-end-posn undo-beg-posn))
2277 (goto-char undo-beg-posn)
2279 (if (and vip-keep-point-on-undo
2280 (pos-visible-in-window-p before-undo-pt))
2282 (push-mark (point-marker) t)
2283 (vip-sit-for-short 300)
2284 (goto-char undo-end-posn)
2285 (vip-sit-for-short 300)
2286 (if (and (> (abs (- undo-beg-posn before-undo-pt)) 1)
2287 (> (abs (- undo-end-posn before-undo-pt)) 1))
2288 (goto-char before-undo-pt)
2289 (goto-char undo-beg-posn)))
2290 (push-mark before-undo-pt t))
2291 (if (and (eolp) (not (bolp))) (backward-char 1))
2292 (if (not modified) (set-buffer-modified-p t)))
2293 (setq this-command 'vip-undo))
2295 ;; Continue undoing previous changes.
2296 (defun vip-undo-more ()
2297 (message "undo more!")
2301 (message "No further undo information in this buffer")))
2302 (if (and (eolp) (not (bolp))) (backward-char 1))
2303 (setq this-command 'vip-undo))
2305 ;; The following two functions are used to set up undo properly.
2306 ;; In VI, unlike Emacs, if you open a line, say, and add a bunch of lines,
2307 ;; they are undone all at once.
2308 (defun vip-adjust-undo ()
2309 (let ((inhibit-quit t)
2311 (setq vip-undo-needs-adjustment nil)
2312 (if (listp buffer-undo-list)
2313 (if (setq tmp (memq vip-buffer-undo-list-mark buffer-undo-list))
2315 (setq tmp2 (cdr tmp)) ; the part after mark
2317 ;; cut tail from buffer-undo-list temporarily by direct
2318 ;; manipulation with pointers in buffer-undo-list
2321 (setq buffer-undo-list (delq nil buffer-undo-list))
2322 (setq buffer-undo-list
2323 (delq vip-buffer-undo-list-mark buffer-undo-list))
2324 ;; restore tail of buffer-undo-list
2325 (setq buffer-undo-list (nconc buffer-undo-list tmp2)))
2326 (setq buffer-undo-list (delq nil buffer-undo-list))))))
2329 (defun vip-set-complex-command-for-undo ()
2330 (if (listp buffer-undo-list)
2331 (if (not vip-undo-needs-adjustment)
2332 (let ((inhibit-quit t))
2333 (setq buffer-undo-list
2334 (cons vip-buffer-undo-list-mark buffer-undo-list))
2335 (setq vip-undo-needs-adjustment t)))))
2340 (defun vip-display-current-destructive-command ()
2341 (let ((text (nth 4 vip-d-com))
2342 (keys (nth 5 vip-d-com))
2345 (setq this-command 'vip-display-current-destructive-command)
2347 (message " `.' runs %s%s"
2348 (concat "`" (vip-array-to-string keys) "'")
2349 (vip-abbreviate-string text max-text-len
2350 " inserting `" "'" " ......."))
2354 ;; don't change vip-d-com if it was vip-repeat command invoked with `.'
2355 ;; or in some other way (non-interactively).
2356 (defun vip-set-destructive-command (list)
2357 (or (eq vip-intermediate-command 'vip-repeat)
2359 (setq vip-d-com list)
2360 (setcar (nthcdr 5 vip-d-com)
2361 (vip-array-to-string (this-command-keys)))
2362 (vip-push-onto-ring vip-d-com 'vip-command-ring))))
2364 (defun vip-prev-destructive-command (next)
2365 "Find previous destructive command in the history of destructive commands.
2366 With prefix argument, find next destructive command."
2368 (let (cmd vip-intermediate-command)
2369 (if (eq last-command 'vip-display-current-destructive-command)
2370 ;; repeated search through command history
2371 (setq vip-intermediate-command 'repeating-display-destructive-command)
2372 ;; first search through command history--set temp ring
2373 (setq vip-temp-command-ring (copy-list vip-command-ring)))
2375 (vip-special-ring-rotate1 vip-temp-command-ring 1)
2376 (vip-special-ring-rotate1 vip-temp-command-ring -1)))
2379 (setq vip-d-com cmd))
2380 (vip-display-current-destructive-command)))
2382 (defun vip-next-destructive-command ()
2383 "Find next destructive command in the history of destructive commands."
2385 (vip-prev-destructive-command 'next))
2387 (defun vip-insert-prev-from-insertion-ring (arg)
2388 "Cycle through insertion ring in the direction of older insertions.
2389 Undoes previous insertion and inserts new.
2390 With prefix argument, cycles in the direction of newer elements.
2391 In minibuffer, this command executes whatever the invocation key is bound
2392 to in the global map, instead of cycling through the insertion ring."
2394 (let (vip-intermediate-command)
2395 (if (eq last-command 'vip-insert-from-insertion-ring)
2396 (progn ; repeated search through insertion history
2397 (setq vip-intermediate-command 'repeating-insertion-from-ring)
2398 (if (eq vip-current-state 'replace-state)
2400 (if vip-last-inserted-string-from-insertion-ring
2401 (backward-delete-char
2402 (length vip-last-inserted-string-from-insertion-ring))))
2404 ;;first search through insertion history
2405 (setq vip-temp-insertion-ring (copy-list vip-insertion-ring)))
2406 (setq this-command 'vip-insert-from-insertion-ring)
2407 ;; so that things will be undone properly
2408 (setq buffer-undo-list (cons nil buffer-undo-list))
2409 (setq vip-last-inserted-string-from-insertion-ring
2410 (vip-special-ring-rotate1 vip-temp-insertion-ring (if arg 1 -1)))
2412 ;; this change of vip-intermediate-command must come after
2413 ;; vip-special-ring-rotate1, so that the ring will rotate, but before the
2415 (setq vip-intermediate-command nil)
2416 (if vip-last-inserted-string-from-insertion-ring
2417 (insert vip-last-inserted-string-from-insertion-ring))
2420 (defun vip-insert-next-from-insertion-ring ()
2421 "Cycle through insertion ring in the direction of older insertions.
2422 Undo previous insertion and inserts new."
2424 (vip-insert-prev-from-insertion-ring 'next))
2427 ;; some region utilities
2429 ;; If at the last line of buffer, add \\n before eob, if newline is missing.
2430 (defun vip-add-newline-at-eob-if-necessary ()
2433 ;; make sure all lines end with newline, unless in the minibuffer or
2434 ;; when requested otherwise (require-final-newline is nil)
2437 require-final-newline
2438 (not (vip-is-in-minibuffer))
2439 (not buffer-read-only))
2442 (defun vip-yank-defun ()
2444 (copy-region-as-kill (point) (mark t)))
2446 ;; Enlarge region between BEG and END.
2447 (defun vip-enlarge-region (beg end)
2448 (or beg (setq beg end)) ; if beg is nil, set to end
2449 (or end (setq end beg)) ; if end is nil, set to beg
2452 (progn (goto-char beg) (set-mark end))
2456 (exchange-point-and-mark)
2457 (if (or (not (eobp)) (not (bolp))) (forward-line 1))
2458 (if (not (eobp)) (beginning-of-line))
2459 (if (> beg end) (exchange-point-and-mark)))
2462 ;; Quote region by each line with a user supplied string.
2463 (defun vip-quote-region ()
2464 (setq vip-quote-string
2465 (vip-read-string-with-history
2468 'vip-quote-region-history
2470 (vip-enlarge-region (point) (mark t))
2471 (if (> (point) (mark t)) (exchange-point-and-mark))
2472 (insert vip-quote-string)
2475 (while (and (< (point) (mark t)) (bolp))
2476 (insert vip-quote-string)
2480 ;; Tells whether BEG is on the same line as END.
2481 ;; If one of the args is nil, it'll return nil.
2482 (defun vip-same-line (beg end)
2483 (let ((selective-display nil))
2484 (cond ((and beg end)
2485 ;; This 'if' is needed because Emacs treats the next empty line
2486 ;; as part of the previous line.
2487 (if (or (> beg (point-max)) (> end (point-max))) ; out of range
2489 (if (and (> end beg) (= (vip-line-pos 'start) end))
2490 (setq end (min (1+ end) (point-max))))
2491 (if (and (> beg end) (= (vip-line-pos 'start) beg))
2492 (setq beg (min (1+ beg) (point-max))))
2493 (<= (count-lines beg end) 1) ))
2499 ;; Check if the string ends with a newline.
2500 (defun vip-end-with-a-newline-p (string)
2501 (or (string= string "")
2502 (= (vip-seq-last-elt string) ?\n)))
2504 (defun vip-tmp-insert-at-eob (msg)
2505 (let ((savemax (point-max)))
2509 (goto-char savemax) (delete-region (point) (point-max))
2514 ;;; Minibuffer business
2516 (defsubst vip-set-minibuffer-style ()
2517 (add-hook 'minibuffer-setup-hook 'vip-minibuffer-setup-sentinel))
2520 (defun vip-minibuffer-setup-sentinel ()
2521 (let ((hook (if vip-vi-style-in-minibuffer
2522 'vip-change-state-to-insert
2523 'vip-change-state-to-emacs)))
2527 ;; Interpret last event in the local map
2528 (defun vip-exit-minibuffer ()
2531 (setq command (local-key-binding (char-to-string last-command-char)))
2533 (command-execute command)
2534 (exit-minibuffer))))
2537 (defun vip-set-search-face ()
2538 (if (vip-has-face-support-p)
2539 (defvar vip-search-face
2541 (make-face 'vip-search-face)
2542 (vip-hide-face 'vip-search-face)
2543 (or (face-differs-from-default-p 'vip-search-face)
2544 ;; face wasn't set in .vip or .Xdefaults
2545 (if (vip-can-use-colors "Black" "khaki")
2547 (set-face-background 'vip-search-face "khaki")
2548 (set-face-foreground 'vip-search-face "Black"))
2549 (copy-face 'italic 'vip-search-face)
2550 (set-face-underline-p 'vip-search-face t)))
2552 "*Face used to flash out the search pattern.")
2556 (defun vip-set-minibuffer-faces ()
2557 (if (not (vip-has-face-support-p))
2559 (defvar vip-minibuffer-emacs-face
2561 (make-face 'vip-minibuffer-emacs-face)
2562 (vip-hide-face 'vip-minibuffer-emacs-face)
2563 (or (face-differs-from-default-p 'vip-minibuffer-emacs-face)
2564 ;; face wasn't set in .vip or .Xdefaults
2565 (if vip-vi-style-in-minibuffer
2566 ;; emacs state is an exception in the minibuffer
2567 (if (vip-can-use-colors "darkseagreen2" "Black")
2569 (set-face-background
2570 'vip-minibuffer-emacs-face "darkseagreen2")
2571 (set-face-foreground
2572 'vip-minibuffer-emacs-face "Black"))
2573 (copy-face 'modeline 'vip-minibuffer-emacs-face))
2574 ;; emacs state is the main state in the minibuffer
2575 (if (vip-can-use-colors "Black" "pink")
2577 (set-face-background 'vip-minibuffer-emacs-face "pink")
2578 (set-face-foreground
2579 'vip-minibuffer-emacs-face "Black"))
2580 (copy-face 'italic 'vip-minibuffer-emacs-face))
2582 'vip-minibuffer-emacs-face)
2583 "Face used in the Minibuffer when it is in Emacs state.")
2585 (defvar vip-minibuffer-insert-face
2587 (make-face 'vip-minibuffer-insert-face)
2588 (vip-hide-face 'vip-minibuffer-insert-face)
2589 (or (face-differs-from-default-p 'vip-minibuffer-insert-face)
2590 (if vip-vi-style-in-minibuffer
2591 (if (vip-can-use-colors "Black" "pink")
2593 (set-face-background 'vip-minibuffer-insert-face "pink")
2594 (set-face-foreground
2595 'vip-minibuffer-insert-face "Black"))
2596 (copy-face 'italic 'vip-minibuffer-insert-face))
2597 ;; If Insert state is an exception
2598 (if (vip-can-use-colors "darkseagreen2" "Black")
2600 (set-face-background
2601 'vip-minibuffer-insert-face "darkseagreen2")
2602 (set-face-foreground
2603 'vip-minibuffer-insert-face "Black"))
2604 (copy-face 'modeline 'vip-minibuffer-insert-face))
2605 (vip-italicize-face 'vip-minibuffer-insert-face)))
2606 'vip-minibuffer-insert-face)
2607 "Face used in the Minibuffer when it is in Insert state.")
2609 (defvar vip-minibuffer-vi-face
2611 (make-face 'vip-minibuffer-vi-face)
2612 (vip-hide-face 'vip-minibuffer-vi-face)
2613 (or (face-differs-from-default-p 'vip-minibuffer-vi-face)
2614 (if vip-vi-style-in-minibuffer
2615 (if (vip-can-use-colors "Black" "grey")
2617 (set-face-background 'vip-minibuffer-vi-face "grey")
2618 (set-face-foreground 'vip-minibuffer-vi-face "Black"))
2619 (copy-face 'bold 'vip-minibuffer-vi-face))
2620 (copy-face 'bold 'vip-minibuffer-vi-face)
2621 (invert-face 'vip-minibuffer-vi-face)))
2622 'vip-minibuffer-vi-face)
2623 "Face used in the Minibuffer when it is in Vi state.")
2625 ;; the current face used in the minibuffer
2626 (vip-deflocalvar vip-minibuffer-current-face vip-minibuffer-emacs-face "")
2631 ;;; Reading string with history
2633 (defun vip-read-string-with-history (prompt &optional initial
2634 history-var default keymap)
2635 ;; Read string, prompting with PROMPT and inserting the INITIAL
2636 ;; value. Uses HISTORY-VAR. DEFAULT is the default value to accept if the
2637 ;; input is an empty string. Use KEYMAP, if given, or the
2638 ;; minibuffer-local-map.
2639 ;; Default value is displayed until the user types something in the
2641 (let ((minibuffer-setup-hook
2643 (if (stringp initial)
2645 ;; don't wait if we have unread events or in kbd macro
2646 (or unread-command-events
2651 (vip-minibuffer-setup-sentinel)))
2656 (setq keymap (or keymap minibuffer-local-map)
2657 initial (or initial "")
2658 temp-msg (if default
2659 (format "(default: %s) " default)
2662 (setq vip-incomplete-ex-cmd nil)
2663 (setq val (read-from-minibuffer prompt
2664 (concat temp-msg initial val padding)
2665 keymap nil history-var))
2666 (setq minibuffer-setup-hook nil
2667 padding (vip-array-to-string (this-command-keys))
2669 ;; the following tries to be smart about what to put in history
2670 (if (not (string= val (car (eval history-var))))
2671 (set history-var (cons val (eval history-var))))
2672 (if (or (string= (nth 0 (eval history-var)) (nth 1 (eval history-var)))
2673 (string= (nth 0 (eval history-var)) ""))
2674 (set history-var (cdr (eval history-var))))
2675 ;; If the user enters nothing but the prev cmd wasn't vip-ex,
2676 ;; vip-command-argument, or `! shell-command', this probably means
2677 ;; that the user typed something then erased. Return "" in this case, not
2678 ;; the default---the default is too confusing in this case.
2679 (cond ((and (string= val "")
2680 (not (string= prompt "!")) ; was a `! shell-command'
2681 (not (memq last-command
2683 vip-command-argument
2687 ((string= val "") (or default ""))
2693 ;; insertion commands
2695 ;; Called when state changes from Insert Vi command mode.
2696 ;; Repeats the insertion command if Insert state was entered with prefix
2698 (defun vip-repeat-insert-command ()
2699 (let ((i-com (car vip-d-com))
2700 (val (nth 1 vip-d-com))
2701 (char (nth 2 vip-d-com)))
2702 (if (and val (> val 1)) ; first check that val is non-nil
2704 (setq vip-d-com (list i-com (1- val) ?r nil nil nil))
2706 (setq vip-d-com (list i-com val char nil nil nil))
2709 (defun vip-insert (arg)
2710 "Insert before point."
2712 (vip-set-complex-command-for-undo)
2713 (let ((val (vip-p-val arg))
2714 (com (vip-getcom arg)))
2715 (vip-set-destructive-command (list 'vip-insert val ?r nil nil nil))
2717 (vip-loop val (vip-yank-last-insertion))
2718 (vip-change-state-to-insert))))
2720 (defun vip-append (arg)
2721 "Append after point."
2723 (vip-set-complex-command-for-undo)
2724 (let ((val (vip-p-val arg))
2725 (com (vip-getcom arg)))
2726 (vip-set-destructive-command (list 'vip-append val ?r nil nil nil))
2727 (if (not (eolp)) (forward-char))
2729 (vip-loop val (vip-yank-last-insertion))
2730 (vip-change-state-to-insert))))
2732 (defun vip-Append (arg)
2733 "Append at end of line."
2735 (vip-set-complex-command-for-undo)
2736 (let ((val (vip-p-val arg))
2737 (com (vip-getcom arg)))
2738 (vip-set-destructive-command (list 'vip-Append val ?r nil nil nil))
2741 (vip-loop val (vip-yank-last-insertion))
2742 (vip-change-state-to-insert))))
2744 (defun vip-Insert (arg)
2745 "Insert before first non-white."
2747 (vip-set-complex-command-for-undo)
2748 (let ((val (vip-p-val arg))
2749 (com (vip-getcom arg)))
2750 (vip-set-destructive-command (list 'vip-Insert val ?r nil nil nil))
2751 (back-to-indentation)
2753 (vip-loop val (vip-yank-last-insertion))
2754 (vip-change-state-to-insert))))
2756 (defun vip-open-line (arg)
2759 (vip-set-complex-command-for-undo)
2760 (let ((val (vip-p-val arg))
2761 (com (vip-getcom arg)))
2762 (vip-set-destructive-command (list 'vip-open-line val ?r nil nil nil))
2763 (let ((col (current-indentation)))
2772 (if vip-electric-mode
2773 (indent-according-to-mode)
2776 (vip-yank-last-insertion)))
2782 (if vip-electric-mode
2783 (indent-according-to-mode)
2786 (vip-change-state-to-insert)
2789 (defun vip-Open-line (arg)
2792 (vip-set-complex-command-for-undo)
2793 (let ((val (vip-p-val arg))
2794 (com (vip-getcom arg)))
2795 (vip-set-destructive-command (list 'vip-Open-line val ?r nil nil nil))
2796 (let ((col (current-indentation)))
2805 (if vip-electric-mode
2806 (indent-according-to-mode)
2809 (vip-yank-last-insertion)))
2815 (if vip-electric-mode
2816 (indent-according-to-mode)
2819 (vip-change-state-to-insert)))))
2821 (defun vip-open-line-at-point (arg)
2822 "Open line at point."
2824 (vip-set-complex-command-for-undo)
2825 (let ((val (vip-p-val arg))
2826 (com (vip-getcom arg)))
2827 (vip-set-destructive-command
2828 (list 'vip-open-line-at-point val ?r nil nil nil))
2833 (vip-yank-last-insertion)))
2835 (vip-change-state-to-insert))))
2837 (defun vip-substitute (arg)
2838 "Substitute characters."
2840 (let ((val (vip-p-val arg))
2841 (com (vip-getcom arg)))
2845 (vip-change-subr (mark t) (point))
2846 (vip-change (mark t) (point)))
2847 (vip-set-destructive-command (list 'vip-substitute val ?r nil nil nil))
2850 (defun vip-substitute-line (arg)
2853 (vip-set-complex-command-for-undo)
2854 (vip-line (cons arg ?C)))
2856 ;; Prepare for replace
2857 (defun vip-start-replace ()
2858 (setq vip-began-as-replace t
2859 vip-sitting-in-replace t
2860 vip-replace-chars-to-delete 0
2861 vip-replace-chars-deleted 0)
2862 (vip-add-hook 'vip-after-change-functions 'vip-replace-mode-spy-after t)
2863 (vip-add-hook 'vip-before-change-functions 'vip-replace-mode-spy-before t)
2864 ;; this will get added repeatedly, but no harm
2865 (add-hook 'after-change-functions 'vip-after-change-sentinel t)
2866 (add-hook 'before-change-functions 'vip-before-change-sentinel t)
2867 (vip-move-marker-locally 'vip-last-posn-in-replace-region
2868 (vip-replace-start))
2870 'vip-post-command-hooks 'vip-replace-state-post-command-sentinel t)
2872 'vip-pre-command-hooks 'vip-replace-state-pre-command-sentinel t)
2876 ;; checks how many chars were deleted by the last change
2877 (defun vip-replace-mode-spy-before (beg end)
2878 (setq vip-replace-chars-deleted
2880 (max 0 (- end (vip-replace-end)))
2881 (max 0 (- (vip-replace-start) beg))
2884 ;; Invoked as an after-change-function to set up parameters of the last change
2885 (defun vip-replace-mode-spy-after (beg end length)
2886 (if (memq vip-intermediate-command '(repeating-insertion-from-ring))
2888 (setq vip-replace-chars-to-delete 0)
2889 (vip-move-marker-locally
2890 'vip-last-posn-in-replace-region (point)))
2892 (let (beg-col end-col real-end chars-to-delete)
2893 (setq real-end (min end (vip-replace-end)))
2896 (setq beg-col (current-column))
2897 (goto-char real-end)
2898 (setq end-col (current-column)))
2900 ;; If beg of change is outside the replacement region, then don't
2901 ;; delete anything in the repl region (set chars-to-delete to 0).
2903 ;; This works fine except that we have to take special care of
2904 ;; dabbrev-expand. The problem stems from new-dabbrev.el, which
2905 ;; sometimes simply shifts the repl region rightwards, without
2906 ;; deleting an equal amount of characters.
2908 ;; The reason why new-dabbrev.el causes this are this:
2909 ;; if one dinamically completes a partial word that starts before the
2910 ;; replacement region (but ends inside) then new-dabbrev.el first
2911 ;; moves cursor backwards, to the beginning of the word to be
2912 ;; completed (say, pt A). Then it inserts the
2913 ;; completed word and then deletes the old, incomplete part.
2914 ;; Since the complete word is inserted at position before the repl
2915 ;; region, the next If-statement would have set chars-to-delete to 0
2916 ;; unless we check for the current command, which must be
2919 ;; In fact, it might be also useful to have overlays for insert
2920 ;; regions as well, since this will let us capture the situation when
2921 ;; dabbrev-expand goes back past the insertion point to find the
2922 ;; beginning of the word to be expanded.
2923 (if (or (and (<= (vip-replace-start) beg)
2924 (<= beg (vip-replace-end)))
2925 (and (= length 0) (eq this-command 'dabbrev-expand)))
2926 (setq chars-to-delete
2927 (max (- end-col beg-col) (- real-end beg) 0))
2928 (setq chars-to-delete 0))
2930 ;; if beg = last change position, it means that we are within the
2931 ;; same command that does multiple changes. Moreover, it means
2932 ;; that we have two subsequent changes (insert/delete) that
2933 ;; complement each other.
2934 (if (= beg (marker-position vip-last-posn-in-replace-region))
2935 (setq vip-replace-chars-to-delete
2936 (- (+ chars-to-delete vip-replace-chars-to-delete)
2937 vip-replace-chars-deleted))
2938 (setq vip-replace-chars-to-delete chars-to-delete))
2940 (vip-move-marker-locally
2941 'vip-last-posn-in-replace-region
2942 (max (if (> end (vip-replace-end)) (vip-replace-start) end)
2943 (or (marker-position vip-last-posn-in-replace-region)
2944 (vip-replace-start))
2947 (setq vip-replace-chars-to-delete
2948 (max 0 (min vip-replace-chars-to-delete
2949 (- (vip-replace-end)
2950 vip-last-posn-in-replace-region))))
2954 ;; Delete stuff between posn and the end of vip-replace-overlay-marker, if
2955 ;; posn is within the overlay.
2956 (defun vip-finish-change (posn)
2957 (vip-remove-hook 'vip-after-change-functions 'vip-replace-mode-spy-after)
2958 (vip-remove-hook 'vip-before-change-functions 'vip-replace-mode-spy-before)
2959 (vip-remove-hook 'vip-post-command-hooks
2960 'vip-replace-state-post-command-sentinel)
2962 'vip-pre-command-hooks 'vip-replace-state-pre-command-sentinel)
2963 (vip-restore-cursor-color)
2964 (setq vip-sitting-in-replace nil) ; just in case we'll need to know it
2968 (>= posn (vip-replace-start))
2969 (< posn (vip-replace-end)))
2970 (delete-region posn (vip-replace-end)))
2973 (if (eq vip-current-state 'replace-state)
2974 (vip-downgrade-to-insert))
2975 ;; replace mode ended => nullify vip-last-posn-in-replace-region
2976 (vip-move-marker-locally 'vip-last-posn-in-replace-region nil)
2977 (vip-hide-replace-overlay)
2978 (vip-refresh-mode-line)
2979 (vip-put-string-on-kill-ring vip-last-replace-region)
2982 ;; Make STRING be the first element of the kill ring.
2983 (defun vip-put-string-on-kill-ring (string)
2984 (setq kill-ring (cons string kill-ring))
2985 (if (> (length kill-ring) kill-ring-max)
2986 (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil))
2987 (setq kill-ring-yank-pointer kill-ring))
2989 (defun vip-finish-R-mode ()
2990 (vip-remove-hook 'vip-post-command-hooks 'vip-R-state-post-command-sentinel)
2992 'vip-pre-command-hooks 'vip-replace-state-pre-command-sentinel)
2993 (vip-downgrade-to-insert))
2995 (defun vip-start-R-mode ()
2996 ;; Leave arg as 1, not t: XEmacs insists that it must be a pos number
2999 'vip-post-command-hooks 'vip-R-state-post-command-sentinel t)
3001 'vip-pre-command-hooks 'vip-replace-state-pre-command-sentinel t)
3006 (defun vip-replace-state-exit-cmd ()
3007 "Binding for keys that cause Replace state to switch to Vi or to Insert.
3008 These keys are ESC, RET, and LineFeed"
3010 (if overwrite-mode ;; If you are in replace mode invoked via 'R'
3012 (vip-finish-change vip-last-posn-in-replace-region))
3014 (if (eq this-command 'vip-intercept-ESC-key)
3015 (setq com 'vip-exit-insert-state)
3016 (vip-set-unread-command-events last-input-char)
3017 (setq com (key-binding (read-key-sequence nil))))
3019 (condition-case conds
3020 (command-execute com)
3022 (vip-message-conditions conds)))
3024 (vip-hide-replace-overlay))
3027 ;; This is the function bound to 'R'---unlimited replace.
3028 ;; Similar to Emacs's own overwrite-mode.
3029 (defun vip-overwrite (arg)
3030 "Begin overwrite mode."
3032 (let ((val (vip-p-val arg))
3033 (com (vip-getcom arg)) (len))
3034 (vip-set-destructive-command (list 'vip-overwrite val ?r nil nil nil))
3037 ;; Viper saves inserted text in vip-last-insertion
3038 (setq len (length vip-last-insertion))
3040 (vip-loop val (vip-yank-last-insertion)))
3041 (setq last-command 'vip-overwrite)
3042 (vip-set-complex-command-for-undo)
3043 (vip-set-replace-overlay (point) (vip-line-pos 'end))
3044 (vip-change-state-to-replace)
3050 (defun vip-line (arg)
3051 (let ((val (car arg))
3053 (vip-move-marker-locally 'vip-com-point (point))
3055 (vip-next-line-carefully (1- val)))
3056 ;; this ensures that dd, cc, D, yy will do the right thing on the last
3057 ;; line of buffer when this line has no \n.
3058 (vip-add-newline-at-eob-if-necessary)
3059 (vip-execute-com 'vip-line val com))
3060 (if (and (eobp) (not (bobp))) (forward-line -1))
3063 (defun vip-yank-line (arg)
3064 "Yank ARG lines (in Vi's sense)."
3066 (let ((val (vip-p-val arg)))
3067 (vip-line (cons val ?Y))))
3072 (defun vip-region (arg)
3073 "Execute command on a region."
3075 (let ((val (vip-P-val arg))
3076 (com (vip-getcom arg)))
3077 (vip-move-marker-locally 'vip-com-point (point))
3078 (exchange-point-and-mark)
3079 (vip-execute-com 'vip-region val com)))
3081 (defun vip-Region (arg)
3082 "Execute command on a Region."
3084 (let ((val (vip-P-val arg))
3085 (com (vip-getCom arg)))
3086 (vip-move-marker-locally 'vip-com-point (point))
3087 (exchange-point-and-mark)
3088 (vip-execute-com 'vip-Region val com)))
3090 (defun vip-replace-char (arg)
3091 "Replace the following ARG chars by the character read."
3093 (if (and (eolp) (bolp)) (error "No character to replace here"))
3094 (let ((val (vip-p-val arg))
3095 (com (vip-getcom arg)))
3096 (vip-replace-char-subr com val)
3097 (if (and (eolp) (not (bolp))) (forward-char 1))
3098 (vip-set-destructive-command
3099 (list 'vip-replace-char val ?r nil vip-d-char nil))
3102 (defun vip-replace-char-subr (com arg)
3103 (let ((take-care-of-iso-accents
3104 (and (boundp 'iso-accents-mode) vip-automatic-iso-accents))
3106 (setq char (if (equal com ?r)
3109 (if (and take-care-of-iso-accents (memq char '(?' ?\" ?^ ?~)))
3110 ;; get European characters
3112 (iso-accents-mode 1)
3113 (vip-set-unread-command-events char)
3114 (setq char (aref (read-key-sequence nil) 0))
3115 (iso-accents-mode -1)))
3117 (setq vip-d-char char)
3118 (vip-loop (if (> arg 0) arg (- arg))
3119 (if (eq char ?\C-m) (insert "\n") (insert char)))
3120 (backward-char arg)))
3123 ;; basic cursor movement. j, k, l, h commands.
3125 (defun vip-forward-char (arg)
3126 "Move point right ARG characters (left if ARG negative).
3127 On reaching end of line, stop and signal error."
3129 (vip-leave-region-active)
3130 (let ((val (vip-p-val arg))
3131 (com (vip-getcom arg)))
3132 (if com (vip-move-marker-locally 'vip-com-point (point)))
3133 (if vip-ex-style-motion
3135 ;; the boundary condition check gets weird here because
3136 ;; forward-char may be the parameter of a delete, and 'dl' works
3137 ;; just like 'x' for the last char on a line, so we have to allow
3138 ;; the forward motion before the 'vip-execute-com', but, of
3139 ;; course, 'dl' doesn't work on an empty line, so we have to
3140 ;; catch that condition before 'vip-execute-com'
3141 (if (and (eolp) (bolp)) (error "") (forward-char val))
3142 (if com (vip-execute-com 'vip-forward-char val com))
3143 (if (eolp) (progn (backward-char 1) (error ""))))
3145 (if com (vip-execute-com 'vip-forward-char val com)))))
3147 (defun vip-backward-char (arg)
3148 "Move point left ARG characters (right if ARG negative).
3149 On reaching beginning of line, stop and signal error."
3151 (vip-leave-region-active)
3152 (let ((val (vip-p-val arg))
3153 (com (vip-getcom arg)))
3154 (if com (vip-move-marker-locally 'vip-com-point (point)))
3155 (if vip-ex-style-motion
3157 (if (bolp) (error "") (backward-char val))
3158 (if com (vip-execute-com 'vip-backward-char val com)))
3160 (if com (vip-execute-com 'vip-backward-char val com)))))
3162 ;; Like forward-char, but doesn't move at end of buffer.
3163 (defun vip-forward-char-carefully (&optional arg)
3164 (setq arg (or arg 1))
3165 (if (>= (point-max) (+ (point) arg))
3167 (goto-char (point-max))))
3169 ;; Like backward-char, but doesn't move at end of buffer.
3170 (defun vip-backward-char-carefully (&optional arg)
3171 (setq arg (or arg 1))
3172 (if (<= (point-min) (- (point) arg))
3174 (goto-char (point-min))))
3176 (defun vip-next-line-carefully (arg)
3185 ;; Words are formed from alpha's and nonalphas - <sp>,\t\n are separators
3186 ;; for word movement. When executed with a destructive command, \n is
3187 ;; usually left untouched for the last word.
3188 ;; Viper uses syntax table to determine what is a word and what is a
3189 ;; separator. However, \n is always a separator. Also, if vip-syntax-preference
3190 ;; is 'vi, then `_' is part of the word.
3193 (defun vip-skip-separators (forward)
3196 (vip-skip-all-separators-forward 'within-line)
3197 (if (looking-at "\n")
3200 (vip-skip-all-separators-forward 'within-line))))
3201 (vip-skip-all-separators-backward 'within-line)
3203 (if (looking-at "\n")
3204 (vip-skip-all-separators-backward 'within-line)
3207 (defun vip-forward-word-kernel (val)
3209 (cond ((vip-looking-at-alpha)
3210 (vip-skip-alpha-forward "_")
3211 (vip-skip-separators t))
3212 ((vip-looking-at-separator)
3213 (vip-skip-separators t))
3214 ((not (vip-looking-at-alphasep))
3215 (vip-skip-nonalphasep-forward)
3216 (vip-skip-separators t)))
3217 (setq val (1- val))))
3219 ;; first search backward for pat. Then skip chars backwards using aux-pat
3220 (defun vip-fwd-skip (pat aux-pat lim)
3221 (if (and (save-excursion
3222 (re-search-backward pat lim t))
3223 (= (point) (match-end 0)))
3224 (goto-char (match-beginning 0)))
3225 (skip-chars-backward aux-pat lim)
3227 (vip-forward-char-carefully))
3231 (defun vip-forward-word (arg)
3234 (vip-leave-region-active)
3235 (let ((val (vip-p-val arg))
3236 (com (vip-getcom arg)))
3237 (if com (vip-move-marker-locally 'vip-com-point (point)))
3238 (vip-forward-word-kernel val)
3240 (cond ((memq com (list ?c (- ?c)))
3241 (vip-fwd-skip "\n[ \t]*" " \t" vip-com-point))
3242 ;; Yank words including the whitespace, but not newline
3243 ((memq com (list ?y (- ?y)))
3244 (vip-fwd-skip "\n[ \t]*" "" vip-com-point))
3245 ((vip-dotable-command-p com)
3246 (vip-fwd-skip "\n[ \t]*" "" vip-com-point)))
3247 (vip-execute-com 'vip-forward-word val com)))))
3250 (defun vip-forward-Word (arg)
3251 "Forward word delimited by white characters."
3253 (vip-leave-region-active)
3254 (let ((val (vip-p-val arg))
3255 (com (vip-getcom arg)))
3256 (if com (vip-move-marker-locally 'vip-com-point (point)))
3259 (vip-skip-nonseparators 'forward)
3260 (vip-skip-separators t)))
3262 (cond ((memq com (list ?c (- ?c)))
3263 (vip-fwd-skip "\n[ \t]*" " \t" vip-com-point))
3264 ;; Yank words including the whitespace, but not newline
3265 ((memq com (list ?y (- ?y)))
3266 (vip-fwd-skip "\n[ \t]*" "" vip-com-point))
3267 ((vip-dotable-command-p com)
3268 (vip-fwd-skip "\n[ \t]*" "" vip-com-point)))
3269 (vip-execute-com 'vip-forward-Word val com)))))
3272 ;; this is a bit different from Vi, but Vi's end of word
3273 ;; makes no sense whatsoever
3274 (defun vip-end-of-word-kernel ()
3275 (if (vip-end-of-word-p) (forward-char))
3276 (if (vip-looking-at-separator)
3277 (vip-skip-all-separators-forward))
3279 (cond ((vip-looking-at-alpha) (vip-skip-alpha-forward "_"))
3280 ((not (vip-looking-at-alphasep)) (vip-skip-nonalphasep-forward)))
3281 (vip-backward-char-carefully))
3283 (defun vip-end-of-word-p ()
3286 (cond ((vip-looking-at-alpha)
3288 (not (vip-looking-at-alpha)))
3289 ((not (vip-looking-at-alphasep))
3291 (vip-looking-at-alphasep))))))
3294 (defun vip-end-of-word (arg &optional careful)
3295 "Move point to end of current word."
3297 (vip-leave-region-active)
3298 (let ((val (vip-p-val arg))
3299 (com (vip-getcom arg)))
3300 (if com (vip-move-marker-locally 'vip-com-point (point)))
3301 (vip-loop val (vip-end-of-word-kernel))
3305 (vip-execute-com 'vip-end-of-word val com)))))
3307 (defun vip-end-of-Word (arg)
3308 "Forward to end of word delimited by white character."
3310 (vip-leave-region-active)
3311 (let ((val (vip-p-val arg))
3312 (com (vip-getcom arg)))
3313 (if com (vip-move-marker-locally 'vip-com-point (point)))
3316 (vip-end-of-word-kernel)
3317 (vip-skip-nonseparators 'forward)
3322 (vip-execute-com 'vip-end-of-Word val com)))))
3324 (defun vip-backward-word-kernel (val)
3327 (cond ((vip-looking-at-alpha)
3328 (vip-skip-alpha-backward "_"))
3329 ((vip-looking-at-separator)
3331 (vip-skip-separators nil)
3333 (cond ((vip-looking-at-alpha)
3334 (vip-skip-alpha-backward "_"))
3335 ((not (vip-looking-at-alphasep))
3336 (vip-skip-nonalphasep-backward))
3337 (t (forward-char))))
3338 ((not (vip-looking-at-alphasep))
3339 (vip-skip-nonalphasep-backward)))
3340 (setq val (1- val))))
3342 (defun vip-backward-word (arg)
3345 (vip-leave-region-active)
3346 (let ((val (vip-p-val arg))
3347 (com (vip-getcom arg)))
3350 (if (setq i (save-excursion (backward-char) (looking-at "\n")))
3352 (vip-move-marker-locally 'vip-com-point (point))
3353 (if i (forward-char))))
3354 (vip-backward-word-kernel val)
3355 (if com (vip-execute-com 'vip-backward-word val com))))
3357 (defun vip-backward-Word (arg)
3358 "Backward word delimited by white character."
3360 (vip-leave-region-active)
3361 (let ((val (vip-p-val arg))
3362 (com (vip-getcom arg)))
3365 (if (setq i (save-excursion (backward-char) (looking-at "\n")))
3367 (vip-move-marker-locally 'vip-com-point (point))
3368 (if i (forward-char))))
3371 (vip-skip-separators nil)
3372 (vip-skip-nonseparators 'backward)))
3373 (if com (vip-execute-com 'vip-backward-Word val com))))
3379 (defun vip-beginning-of-line (arg)
3380 "Go to beginning of line."
3382 (vip-leave-region-active)
3383 (let ((val (vip-p-val arg))
3384 (com (vip-getcom arg)))
3385 (if com (vip-move-marker-locally 'vip-com-point (point)))
3386 (beginning-of-line val)
3387 (if com (vip-execute-com 'vip-beginning-of-line val com))))
3389 (defun vip-bol-and-skip-white (arg)
3390 "Beginning of line at first non-white character."
3392 (vip-leave-region-active)
3393 (let ((val (vip-p-val arg))
3394 (com (vip-getcom arg)))
3395 (if com (vip-move-marker-locally 'vip-com-point (point)))
3396 (forward-to-indentation (1- val))
3397 (if com (vip-execute-com 'vip-bol-and-skip-white val com))))
3399 (defun vip-goto-eol (arg)
3400 "Go to end of line."
3402 (vip-leave-region-active)
3403 (let ((val (vip-p-val arg))
3404 (com (vip-getcom arg)))
3405 (if com (vip-move-marker-locally 'vip-com-point (point)))
3407 (if com (vip-execute-com 'vip-goto-eol val com))
3408 (if vip-ex-style-motion
3409 (if (and (eolp) (not (bolp))
3410 ;; a fix for vip-change-to-eol
3411 (not (equal vip-current-state 'insert-state)))
3416 (defun vip-goto-col (arg)
3417 "Go to ARG's column."
3419 (vip-leave-region-active)
3420 (let ((val (vip-p-val arg))
3421 (com (vip-getcom arg)))
3424 (if (> val (1+ (current-column))) (error "")))
3425 (if com (vip-move-marker-locally 'vip-com-point (point)))
3427 (forward-char (1- val))
3428 (if com (vip-execute-com 'vip-goto-col val com))))
3431 (defun vip-next-line (arg)
3434 (vip-leave-region-active)
3435 (let ((val (vip-p-val arg))
3436 (com (vip-getCom arg)))
3437 (if com (vip-move-marker-locally 'vip-com-point (point)))
3439 (if vip-ex-style-motion
3440 (if (and (eolp) (not (bolp))) (backward-char 1)))
3441 (setq this-command 'next-line)
3442 (if com (vip-execute-com 'vip-next-line val com))))
3444 (defun vip-next-line-at-bol (arg)
3445 "Next line at beginning of line."
3447 (vip-leave-region-active)
3450 (if (eobp) (error "Last line in buffer")))
3451 (let ((val (vip-p-val arg))
3452 (com (vip-getCom arg)))
3453 (if com (vip-move-marker-locally 'vip-com-point (point)))
3455 (back-to-indentation)
3456 (if com (vip-execute-com 'vip-next-line-at-bol val com))))
3458 (defun vip-previous-line (arg)
3459 "Go to previous line."
3461 (vip-leave-region-active)
3462 (let ((val (vip-p-val arg))
3463 (com (vip-getCom arg)))
3464 (if com (vip-move-marker-locally 'vip-com-point (point)))
3466 (if vip-ex-style-motion
3467 (if (and (eolp) (not (bolp))) (backward-char 1)))
3468 (setq this-command 'previous-line)
3469 (if com (vip-execute-com 'vip-previous-line val com))))
3472 (defun vip-previous-line-at-bol (arg)
3473 "Previous line at beginning of line."
3475 (vip-leave-region-active)
3478 (if (bobp) (error "First line in buffer")))
3479 (let ((val (vip-p-val arg))
3480 (com (vip-getCom arg)))
3481 (if com (vip-move-marker-locally 'vip-com-point (point)))
3482 (forward-line (- val))
3483 (back-to-indentation)
3484 (if com (vip-execute-com 'vip-previous-line val com))))
3486 (defun vip-change-to-eol (arg)
3487 "Change to end of line."
3489 (vip-goto-eol (cons arg ?c)))
3491 (defun vip-kill-line (arg)
3494 (vip-goto-eol (cons arg ?d)))
3496 (defun vip-erase-line (arg)
3499 (vip-beginning-of-line (cons arg ?d)))
3504 (defun vip-goto-line (arg)
3505 "Go to ARG's line. Without ARG go to end of buffer."
3507 (let ((val (vip-P-val arg))
3508 (com (vip-getCom arg)))
3509 (vip-move-marker-locally 'vip-com-point (point))
3510 (vip-deactivate-mark)
3513 (goto-char (point-max))
3514 (goto-char (point-min))
3515 (forward-line (1- val)))
3517 ;; positioning is done twice: before and after command execution
3518 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3519 (back-to-indentation)
3521 (if com (vip-execute-com 'vip-goto-line val com))
3523 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3524 (back-to-indentation)
3527 ;; Find ARG's occurrence of CHAR on the current line.
3528 ;; If FORWARD then search is forward, otherwise backward. OFFSET is used to
3529 ;; adjust point after search.
3530 (defun vip-find-char (arg char forward offset)
3531 (or (char-or-string-p char) (error ""))
3532 (let ((arg (if forward arg (- arg)))
3533 (cmd (if (eq vip-intermediate-command 'vip-repeat)
3535 (vip-array-to-string (this-command-keys))))
3541 ;; forward search begins here
3542 (if (eolp) (error "Command `%s': At end of line" cmd) (point))
3543 ;; forward search ends here
3544 (progn (end-of-line) (point)))
3546 ;; backward search begins from here
3548 (error "Command `%s': At beginning of line" cmd) (point))
3549 ;; backward search ends here
3550 (progn (beginning-of-line) (point))))
3551 ;; if arg > 0, point is forwarded before search.
3552 (if (> arg 0) (goto-char (1+ (point-min)))
3553 (goto-char (point-max)))
3554 (if (let ((case-fold-search nil))
3555 (search-forward (char-to-string char) nil 0 arg))
3556 (setq point (point))
3557 (error "Command `%s': `%c' not found" cmd char))))
3558 (goto-char (+ point (if (> arg 0) (if offset -2 -1) (if offset 1 0))))))
3560 (defun vip-find-char-forward (arg)
3561 "Find char on the line.
3562 If called interactively read the char to find from the terminal, and if
3563 called from vip-repeat, the char last used is used. This behaviour is
3564 controlled by the sign of prefix numeric value."
3566 (let ((val (vip-p-val arg))
3567 (com (vip-getcom arg))
3568 (cmd-representation (nth 5 vip-d-com)))
3570 ;; this means that the function was called interactively
3571 (setq vip-f-char (read-char)
3574 ;; vip-repeat --- set vip-F-char from command-keys
3575 (setq vip-F-char (if (stringp cmd-representation)
3576 (vip-seq-last-elt cmd-representation)
3578 vip-f-char vip-F-char)
3580 (if com (vip-move-marker-locally 'vip-com-point (point)))
3581 (vip-find-char val (if (> (vip-p-val arg) 0) vip-f-char vip-F-char) t nil)
3585 (setq vip-F-char vip-f-char) ; set new vip-F-char
3587 (vip-execute-com 'vip-find-char-forward val com)))))
3589 (defun vip-goto-char-forward (arg)
3590 "Go up to char ARG forward on line."
3592 (let ((val (vip-p-val arg))
3593 (com (vip-getcom arg))
3594 (cmd-representation (nth 5 vip-d-com)))
3596 ;; this means that the function was called interactively
3597 (setq vip-f-char (read-char)
3600 ;; vip-repeat --- set vip-F-char from command-keys
3601 (setq vip-F-char (if (stringp cmd-representation)
3602 (vip-seq-last-elt cmd-representation)
3604 vip-f-char vip-F-char)
3606 (if com (vip-move-marker-locally 'vip-com-point (point)))
3607 (vip-find-char val (if (> (vip-p-val arg) 0) vip-f-char vip-F-char) t t)
3611 (setq vip-F-char vip-f-char) ; set new vip-F-char
3613 (vip-execute-com 'vip-goto-char-forward val com)))))
3615 (defun vip-find-char-backward (arg)
3616 "Find char ARG on line backward."
3618 (let ((val (vip-p-val arg))
3619 (com (vip-getcom arg))
3620 (cmd-representation (nth 5 vip-d-com)))
3622 ;; this means that the function was called interactively
3623 (setq vip-f-char (read-char)
3626 ;; vip-repeat --- set vip-F-char from command-keys
3627 (setq vip-F-char (if (stringp cmd-representation)
3628 (vip-seq-last-elt cmd-representation)
3630 vip-f-char vip-F-char)
3632 (if com (vip-move-marker-locally 'vip-com-point (point)))
3634 val (if (> (vip-p-val arg) 0) vip-f-char vip-F-char) nil nil)
3638 (setq vip-F-char vip-f-char) ; set new vip-F-char
3639 (vip-execute-com 'vip-find-char-backward val com)))))
3641 (defun vip-goto-char-backward (arg)
3642 "Go up to char ARG backward on line."
3644 (let ((val (vip-p-val arg))
3645 (com (vip-getcom arg))
3646 (cmd-representation (nth 5 vip-d-com)))
3648 ;; this means that the function was called interactively
3649 (setq vip-f-char (read-char)
3652 ;; vip-repeat --- set vip-F-char from command-keys
3653 (setq vip-F-char (if (stringp cmd-representation)
3654 (vip-seq-last-elt cmd-representation)
3656 vip-f-char vip-F-char)
3658 (if com (vip-move-marker-locally 'vip-com-point (point)))
3659 (vip-find-char val (if (> (vip-p-val arg) 0) vip-f-char vip-F-char) nil t)
3663 (setq vip-F-char vip-f-char) ; set new vip-F-char
3664 (vip-execute-com 'vip-goto-char-backward val com)))))
3666 (defun vip-repeat-find (arg)
3667 "Repeat previous find command."
3669 (let ((val (vip-p-val arg))
3670 (com (vip-getcom arg)))
3671 (vip-deactivate-mark)
3672 (if com (vip-move-marker-locally 'vip-com-point (point)))
3673 (vip-find-char val vip-f-char vip-f-forward vip-f-offset)
3676 (if vip-f-forward (forward-char))
3677 (vip-execute-com 'vip-repeat-find val com)))))
3679 (defun vip-repeat-find-opposite (arg)
3680 "Repeat previous find command in the opposite direction."
3682 (let ((val (vip-p-val arg))
3683 (com (vip-getcom arg)))
3684 (vip-deactivate-mark)
3685 (if com (vip-move-marker-locally 'vip-com-point (point)))
3686 (vip-find-char val vip-f-char (not vip-f-forward) vip-f-offset)
3689 (if vip-f-forward (forward-char))
3690 (vip-execute-com 'vip-repeat-find-opposite val com)))))
3693 ;; window scrolling etc.
3695 (defun vip-other-window (arg)
3696 "Switch to other window."
3699 (or (not (eq vip-current-state 'emacs-state))
3700 (string= (buffer-name (current-buffer)) " *Minibuf-1*")
3701 (vip-change-state-to-vi)))
3703 (defun vip-window-top (arg)
3704 "Go to home window line."
3706 (let ((val (vip-p-val arg))
3707 (com (vip-getCom arg)))
3708 (if com (vip-move-marker-locally 'vip-com-point (point)))
3710 (move-to-window-line (1- val))
3712 ;; positioning is done twice: before and after command execution
3713 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3714 (back-to-indentation)
3716 (if com (vip-execute-com 'vip-window-top val com))
3718 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3719 (back-to-indentation)
3722 (defun vip-window-middle (arg)
3723 "Go to middle window line."
3725 (let ((val (vip-p-val arg))
3726 (com (vip-getCom arg))
3728 (if com (vip-move-marker-locally 'vip-com-point (point)))
3730 (if (not (pos-visible-in-window-p (point-max)))
3731 (move-to-window-line (+ (/ (1- (window-height)) 2) (1- val)))
3732 (setq lines (count-lines (window-start) (point-max)))
3733 (move-to-window-line (+ (/ lines 2) (1- val))))
3735 ;; positioning is done twice: before and after command execution
3736 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3737 (back-to-indentation)
3739 (if com (vip-execute-com 'vip-window-middle val com))
3741 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3742 (back-to-indentation)
3745 (defun vip-window-bottom (arg)
3746 "Go to last window line."
3748 (let ((val (vip-p-val arg))
3749 (com (vip-getCom arg)))
3750 (if com (vip-move-marker-locally 'vip-com-point (point)))
3752 (move-to-window-line (- val))
3754 ;; positioning is done twice: before and after command execution
3755 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3756 (back-to-indentation)
3758 (if com (vip-execute-com 'vip-window-bottom val com))
3760 (if (and (eobp) (bolp) (not (bobp))) (forward-line -1))
3761 (back-to-indentation)
3764 (defun vip-line-to-top (arg)
3765 "Put current line on the home line."
3767 (recenter (1- arg)))
3769 (defun vip-line-to-middle (arg)
3770 "Put current line on the middle line."
3772 (recenter (+ (1- arg) (/ (1- (window-height)) 2))))
3774 (defun vip-line-to-bottom (arg)
3775 "Put current line on the last line."
3777 (recenter (- (window-height) (1+ arg))))
3781 ;; must correct this to only match ( to ) etc. On the other hand
3782 ;; it is good that paren match gets confused, because that way you
3783 ;; catch _all_ imbalances.
3785 (defun vip-paren-match (arg)
3786 "Go to the matching parenthesis."
3788 (let ((com (vip-getcom arg))
3791 (if (or (> arg 99) (< arg 1))
3792 (error "Prefix must be between 1 and 99")
3794 (if (> (point-max) 80000)
3795 (* (/ (point-max) 100) arg)
3796 (/ (* (point-max) arg) 100)))
3797 (back-to-indentation))
3798 (let (beg-lim end-lim)
3799 (if (and (eolp) (not (bolp))) (forward-char -1))
3800 (if (not (looking-at "[][(){}]"))
3801 (setq anchor-point (point)))
3804 (setq beg-lim (point))
3806 (setq end-lim (point)))
3807 (cond ((re-search-forward "[][(){}]" end-lim t)
3809 ((re-search-backward "[][(){}]" beg-lim t))
3811 (error "No matching character on line"))))
3812 (cond ((looking-at "[\(\[{]")
3813 (if com (vip-move-marker-locally 'vip-com-point (point)))
3816 (vip-execute-com 'vip-paren-match nil com)
3821 (vip-move-marker-locally 'vip-com-point anchor-point)
3823 (vip-execute-com 'vip-paren-match nil com)
3825 ((looking-at "[])}]")
3827 (if com (vip-move-marker-locally 'vip-com-point (point)))
3829 (if com (vip-execute-com 'vip-paren-match nil com)))
3833 ;; sentence ,paragraph and heading
3835 (defun vip-forward-sentence (arg)
3839 (let ((val (vip-p-val arg))
3840 (com (vip-getcom arg)))
3841 (if com (vip-move-marker-locally 'vip-com-point (point)))
3842 (forward-sentence val)
3843 (if com (vip-execute-com 'vip-forward-sentence nil com))))
3845 (defun vip-backward-sentence (arg)
3846 "Backward sentence."
3849 (let ((val (vip-p-val arg))
3850 (com (vip-getcom arg)))
3851 (if com (vip-move-marker-locally 'vip-com-point (point)))
3852 (backward-sentence val)
3853 (if com (vip-execute-com 'vip-backward-sentence nil com))))
3855 (defun vip-forward-paragraph (arg)
3856 "Forward paragraph."
3859 (let ((val (vip-p-val arg))
3860 (com (vip-getCom arg)))
3861 (if com (vip-move-marker-locally 'vip-com-point (point)))
3862 (forward-paragraph val)
3866 (vip-execute-com 'vip-forward-paragraph nil com)))))
3868 (defun vip-backward-paragraph (arg)
3869 "Backward paragraph."
3872 (let ((val (vip-p-val arg))
3873 (com (vip-getCom arg)))
3874 (if com (vip-move-marker-locally 'vip-com-point (point)))
3875 (backward-paragraph val)
3879 (vip-execute-com 'vip-backward-paragraph nil com)
3880 (backward-char 1)))))
3882 ;; should be mode-specific etc.
3884 (defun vip-prev-heading (arg)
3886 (let ((val (vip-p-val arg))
3887 (com (vip-getCom arg)))
3888 (if com (vip-move-marker-locally 'vip-com-point (point)))
3889 (re-search-backward vip-heading-start nil t val)
3890 (goto-char (match-beginning 0))
3891 (if com (vip-execute-com 'vip-prev-heading nil com))))
3893 (defun vip-heading-end (arg)
3895 (let ((val (vip-p-val arg))
3896 (com (vip-getCom arg)))
3897 (if com (vip-move-marker-locally 'vip-com-point (point)))
3898 (re-search-forward vip-heading-end nil t val)
3899 (goto-char (match-beginning 0))
3900 (if com (vip-execute-com 'vip-heading-end nil com))))
3902 (defun vip-next-heading (arg)
3904 (let ((val (vip-p-val arg))
3905 (com (vip-getCom arg)))
3906 (if com (vip-move-marker-locally 'vip-com-point (point)))
3908 (re-search-forward vip-heading-start nil t val)
3909 (goto-char (match-beginning 0))
3910 (if com (vip-execute-com 'vip-next-heading nil com))))
3915 (setq scroll-step 1)
3917 (defun vip-scroll (arg)
3918 "Scroll to next screen."
3923 (setq arg (1- arg)))
3926 (setq arg (1+ arg)))))
3928 (defun vip-scroll-back (arg)
3929 "Scroll to previous screen."
3931 (vip-scroll (- arg)))
3933 (defun vip-scroll-down (arg)
3934 "Pull down half screen."
3938 (scroll-down (/ (window-height) 2))
3941 (message "Beginning of buffer")
3942 (goto-char (point-min)))))
3944 (defun vip-scroll-down-one (arg)
3945 "Scroll up one line."
3949 (defun vip-scroll-up (arg)
3950 "Pull up half screen."
3954 (scroll-up (/ (window-height) 2))
3957 (message "End of buffer")
3958 (goto-char (point-max)))))
3960 (defun vip-scroll-up-one (arg)
3961 "Scroll down one line."
3968 (defun vip-if-string (prompt)
3969 (let ((s (vip-read-string-with-history
3973 (car vip-search-history))))
3974 (if (not (string= s ""))
3975 (setq vip-s-string s))))
3978 (defun vip-toggle-search-style (arg)
3979 "Toggle the value of vip-case-fold-search/vip-re-search.
3980 Without prefix argument, will ask which search style to toggle. With prefix
3981 arg 1,toggles vip-case-fold-search; with arg 2 toggles vip-re-search.
3983 Although this function is bound to \\[vip-toggle-search-style], the most
3984 convenient way to use it is to bind `//' to the macro
3985 `1 M-x vip-toggle-search-style' and `///' to
3986 `2 M-x vip-toggle-search-style'. In this way, hitting `//' quickly will
3987 toggle case-fold-search and hitting `/' three times witth toggle regexp
3988 search. Macros are more convenient in this case because they don't affect
3989 the Emacs binding of `/'."
3992 (cond ((or (eq arg 1)
3994 (y-or-n-p (format "Search style: '%s'. Want '%s'? "
3995 (if vip-case-fold-search
3996 "case-insensitive" "case-sensitive")
3997 (if vip-case-fold-search
3999 "case-insensitive")))))
4000 (setq vip-case-fold-search (null vip-case-fold-search))
4001 (if vip-case-fold-search
4002 (setq msg "Search becomes case-insensitive")
4003 (setq msg "Search becomes case-sensitive")))
4006 (y-or-n-p (format "Search style: '%s'. Want '%s'? "
4008 "regexp-search" "vanilla-search")
4011 "regexp-search")))))
4012 (setq vip-re-search (null vip-re-search))
4014 (setq msg "Search becomes regexp-style")
4015 (setq msg "Search becomes vanilla-style")))
4017 (setq msg "Search style remains unchanged")))
4021 (defun vip-search-forward (arg)
4022 "Search a string forward.
4023 ARG is used to find the ARG's occurrence of the string.
4024 Null string will repeat previous search."
4026 (let ((val (vip-P-val arg))
4027 (com (vip-getcom arg))
4028 (old-str vip-s-string))
4029 (setq vip-s-forward t)
4031 ;; this is not used at present, but may be used later
4032 (if (or (not (equal old-str vip-s-string))
4033 (not (markerp vip-local-search-start-marker))
4034 (not (marker-buffer vip-local-search-start-marker)))
4035 (setq vip-local-search-start-marker (point-marker)))
4036 (vip-search vip-s-string t val)
4039 (vip-move-marker-locally 'vip-com-point (mark t))
4040 (vip-execute-com 'vip-search-next val com)))))
4042 (defun vip-search-backward (arg)
4043 "Search a string backward.
4044 ARG is used to find the ARG's occurrence of the string.
4045 Null string will repeat previous search."
4047 (let ((val (vip-P-val arg))
4048 (com (vip-getcom arg))
4049 (old-str vip-s-string))
4050 (setq vip-s-forward nil)
4052 ;; this is not used at present, but may be used later
4053 (if (or (not (equal old-str vip-s-string))
4054 (not (markerp vip-local-search-start-marker))
4055 (not (marker-buffer vip-local-search-start-marker)))
4056 (setq vip-local-search-start-marker (point-marker)))
4057 (vip-search vip-s-string nil val)
4060 (vip-move-marker-locally 'vip-com-point (mark t))
4061 (vip-execute-com 'vip-search-next val com)))))
4064 ;; Search for COUNT's occurrence of STRING.
4065 ;; Search is forward if FORWARD is non-nil, otherwise backward.
4066 ;; INIT-POINT is the position where search is to start.
4068 ;; (STRING FORW COUNT &optional NO-OFFSET INIT-POINT LIMIT FAIL-IF-NOT-FOUND)
4069 (defun vip-search (string forward arg
4070 &optional no-offset init-point fail-if-not-found)
4071 (if (not (equal string ""))
4072 (let ((val (vip-p-val arg))
4073 (com (vip-getcom arg))
4074 (offset (not no-offset))
4075 (case-fold-search vip-case-fold-search)
4076 (start-point (or init-point (point))))
4077 (vip-deactivate-mark)
4081 (if offset (vip-forward-char-carefully))
4084 (re-search-forward string nil nil val)
4085 (re-search-backward string))
4086 (search-forward string nil nil val)
4087 (search-backward string))
4088 ;; don't wait and don't flash in macros
4089 (or executing-kbd-macro
4090 (vip-flash-search-pattern))
4091 (if (not (equal start-point (point)))
4092 (push-mark start-point t)))
4094 (if (and (not fail-if-not-found) vip-search-wrap-around-t)
4096 (message "Search wrapped around end of buffer")
4097 (goto-char (point-min))
4098 (vip-search string forward (cons 1 com) t start-point 'fail)
4099 ;; don't wait in macros
4100 (or executing-kbd-macro (sit-for 2))
4101 ;; delete the wrap-around message
4104 (goto-char start-point)
4105 (error "`%s': %s not found"
4107 (if vip-re-search "Pattern" "String"))
4113 (re-search-backward string nil nil val)
4114 (search-backward string nil nil val))
4115 ;; don't wait and don't flash in macros
4116 (or executing-kbd-macro
4117 (vip-flash-search-pattern))
4118 (if (not (equal start-point (point)))
4119 (push-mark start-point t)))
4121 (if (and (not fail-if-not-found) vip-search-wrap-around-t)
4123 (message "Search wrapped around beginning of buffer")
4124 (goto-char (point-max))
4125 (vip-search string forward (cons 1 com) t start-point 'fail)
4126 ;; don't wait in macros
4127 (or executing-kbd-macro (sit-for 2))
4128 ;; delete the wrap-around message
4131 (goto-char start-point)
4132 (error "`%s': %s not found"
4134 (if vip-re-search "Pattern" "String"))
4137 (defun vip-search-next (arg)
4138 "Repeat previous search."
4140 (let ((val (vip-p-val arg))
4141 (com (vip-getcom arg)))
4142 (if (null vip-s-string) (error vip-NoPrevSearch))
4143 (vip-search vip-s-string vip-s-forward arg)
4146 (vip-move-marker-locally 'vip-com-point (mark t))
4147 (vip-execute-com 'vip-search-next val com)))))
4149 (defun vip-search-Next (arg)
4150 "Repeat previous search in the reverse direction."
4152 (let ((val (vip-p-val arg))
4153 (com (vip-getcom arg)))
4154 (if (null vip-s-string) (error vip-NoPrevSearch))
4155 (vip-search vip-s-string (not vip-s-forward) arg)
4158 (vip-move-marker-locally 'vip-com-point (mark t))
4159 (vip-execute-com 'vip-search-Next val com)))))
4162 ;; Search contents of buffer defined by one of Viper's motion commands.
4163 ;; Repeatable via `n' and `N'.
4164 (defun vip-buffer-search-enable (&optional c)
4165 (cond (c (setq vip-buffer-search-char c))
4166 ((null vip-buffer-search-char)
4167 (setq vip-buffer-search-char ?g)))
4168 (define-key vip-vi-basic-map
4169 (char-to-string vip-buffer-search-char) 'vip-command-argument)
4170 (aset vip-exec-array vip-buffer-search-char 'vip-exec-buffer-search)
4171 (setq vip-prefix-commands (cons vip-buffer-search-char vip-prefix-commands)))
4173 ;; This is a Viper wraper for isearch-forward.
4174 (defun vip-isearch-forward (arg)
4175 "Do incremental search forward."
4177 ;; emacs bug workaround
4178 (if (listp arg) (setq arg (car arg)))
4179 (vip-exec-form-in-emacs (list 'isearch-forward arg)))
4181 ;; This is a Viper wraper for isearch-backward."
4182 (defun vip-isearch-backward (arg)
4183 "Do incremental search backward."
4185 ;; emacs bug workaround
4186 (if (listp arg) (setq arg (car arg)))
4187 (vip-exec-form-in-emacs (list 'isearch-backward arg)))
4190 ;; visiting and killing files, buffers
4192 (defun vip-switch-to-buffer ()
4193 "Switch to buffer in the current window."
4198 (format "Switch to buffer in this window \(%s\): "
4199 (buffer-name (other-buffer (current-buffer))))))
4200 (switch-to-buffer buffer)
4203 (defun vip-switch-to-buffer-other-window ()
4204 "Switch to buffer in another window."
4209 (format "Switch to buffer in another window \(%s\): "
4210 (buffer-name (other-buffer (current-buffer))))))
4211 (switch-to-buffer-other-window buffer)
4214 (defun vip-kill-buffer ()
4217 (let (buffer buffer-name)
4220 (format "Kill buffer \(%s\): "
4221 (buffer-name (current-buffer)))))
4223 (if (null buffer-name)
4225 (get-buffer buffer-name)))
4226 (if (null buffer) (error "`%s': No such buffer" buffer-name))
4227 (if (or (not (buffer-modified-p buffer))
4230 "Buffer `%s' is modified, are you sure you want to kill it? "
4232 (kill-buffer buffer)
4233 (error "Buffer not killed"))))
4236 (defvar vip-smart-suffix-list '("" "tex" "c" "cc" "el" "p")
4237 "*List of suffixes that Viper automatically tries to append to filenames ending with a `.'.
4238 This is useful when you the current directory contains files with the same
4239 prefix and many different suffixes. Usually, only one of the suffixes
4240 represents an editable file. However, file completion will stop at the `.'
4241 The smart suffix feature lets you hit RET in such a case, and Viper will
4242 select the appropriate suffix.
4244 Suffixes are tried in the order given and the first suffix for which a
4245 corresponding file exists is selected. If no file exists for any of the
4246 suffixes, the user is asked to confirm.
4248 To turn this feature off, set this variable to nil.")
4250 ;; Try to add suffix to files ending with a `.'
4251 ;; Useful when the user hits RET on a non-completed file name.
4252 (defun vip-file-add-suffix ()
4254 (len (length vip-smart-suffix-list))
4255 (file (buffer-string))
4257 (goto-char (point-max))
4258 (if (and vip-smart-suffix-list (string-match "\\.$" file))
4260 (while (and (not found) (< count len))
4261 (setq suff (nth count vip-smart-suffix-list)
4263 (if (file-exists-p (format "%s%s" file suff))
4270 (vip-tmp-insert-at-eob " [Please complete file name]")
4272 (while (not (memq cmd '(exit-minibuffer vip-exit-minibuffer)))
4274 (key-binding (setq key (read-key-sequence nil))))
4275 (cond ((eq cmd 'self-insert-command)
4277 (insert (events-to-keys key))
4279 ((memq cmd '(exit-minibuffer vip-exit-minibuffer))
4281 (t (command-execute cmd)))
4287 ;; Advice for use in find-file and read-file-name commands.
4288 (defadvice exit-minibuffer (before vip-exit-minibuffer-advice activate)
4289 "Run `vip-minibuffer-exit-hook' just before exiting the minibuffer."
4290 (run-hooks 'vip-minibuffer-exit-hook))
4292 (defadvice find-file (before vip-add-suffix-advice activate)
4293 "Use `read-file-name' for reading arguments."
4294 (interactive (list (read-file-name "Find file: "
4295 nil default-directory))))
4297 (defadvice find-file-other-window (before vip-add-suffix-advice activate)
4298 "Use `read-file-name' for reading arguments."
4299 (interactive (list (read-file-name "Find file in other window: "
4300 nil default-directory))))
4302 (defadvice find-file-other-frame (before vip-add-suffix-advice activate)
4303 "Use `read-file-name' for reading arguments."
4304 (interactive (list (read-file-name "Find file in other frame: "
4305 nil default-directory))))
4307 (defadvice read-file-name (around vip-suffix-advice activate)
4308 "Tell `exit-minibuffer' to run `vip-file-add-suffix' as a hook."
4309 (let ((vip-minibuffer-exit-hook 'vip-file-add-suffix))
4316 (defsubst vip-yank (text)
4317 "Yank TEXT silently. This works correctly with Emacs's yank-pop command."
4319 (setq this-command 'yank))
4321 (defun vip-put-back (arg)
4322 "Put back after point/below line."
4324 (let ((val (vip-p-val arg))
4325 (text (if vip-use-register
4326 (cond ((vip-valid-register vip-use-register '(digit))
4327 (current-kill (- vip-use-register ?1) 'do-not-rotate))
4328 ((vip-valid-register vip-use-register)
4329 (get-register (downcase vip-use-register)))
4330 (t (error vip-InvalidRegister vip-use-register)))
4333 (if vip-use-register
4334 (let ((reg vip-use-register))
4335 (setq vip-use-register nil)
4336 (error vip-EmptyRegister reg))
4338 (setq vip-use-register nil)
4339 (if (vip-end-with-a-newline-p text)
4344 (beginning-of-line))
4345 (if (not (eolp)) (vip-forward-char-carefully)))
4346 (set-marker (vip-mark-marker) (point) (current-buffer))
4347 (vip-set-destructive-command
4348 (list 'vip-put-back val nil vip-use-register nil nil))
4349 (vip-loop val (vip-yank text)))
4350 ;; Vi puts cursor on the last char when the yanked text doesn't contain a
4351 ;; newline; it leaves the cursor at the beginning when the text contains
4353 (if (vip-same-line (point) (mark))
4354 (or (= (point) (mark)) (vip-backward-char-carefully))
4355 (exchange-point-and-mark)
4357 (back-to-indentation)))
4358 (vip-deactivate-mark))
4360 (defun vip-Put-back (arg)
4361 "Put back at point/above line."
4363 (let ((val (vip-p-val arg))
4364 (text (if vip-use-register
4365 (cond ((vip-valid-register vip-use-register '(digit))
4366 (current-kill (- vip-use-register ?1) 'do-not-rotate))
4367 ((vip-valid-register vip-use-register)
4368 (get-register (downcase vip-use-register)))
4369 (t (error vip-InvalidRegister vip-use-register)))
4372 (if vip-use-register
4373 (let ((reg vip-use-register))
4374 (setq vip-use-register nil)
4375 (error vip-EmptyRegister reg))
4377 (setq vip-use-register nil)
4378 (if (vip-end-with-a-newline-p text) (beginning-of-line))
4379 (vip-set-destructive-command
4380 (list 'vip-Put-back val nil vip-use-register nil nil))
4381 (set-marker (vip-mark-marker) (point) (current-buffer))
4382 (vip-loop val (vip-yank text)))
4383 ;; Vi puts cursor on the last char when the yanked text doesn't contain a
4384 ;; newline; it leaves the cursor at the beginning when the text contains
4386 (if (vip-same-line (point) (mark))
4387 (or (= (point) (mark)) (vip-backward-char-carefully))
4388 (exchange-point-and-mark)
4390 (back-to-indentation)))
4391 (vip-deactivate-mark))
4394 ;; Copy region to kill-ring.
4395 ;; If BEG and END do not belong to the same buffer, copy empty region.
4396 (defun vip-copy-region-as-kill (beg end)
4398 (copy-region-as-kill beg end)
4399 (error (copy-region-as-kill beg beg))))
4402 (defun vip-delete-char (arg)
4405 (let ((val (vip-p-val arg)))
4406 (vip-set-destructive-command (list 'vip-delete-char val nil nil nil nil))
4409 (let ((here (point)))
4411 (if (> val (- (point) here))
4412 (setq val (- (point) here))))))
4413 (if (and (eq val 0) (not vip-ex-style-motion)) (setq val 1))
4414 (if (and vip-ex-style-motion (eolp))
4415 (if (bolp) (error "") (setq val 0))) ; not bol---simply back 1 ch
4416 (if vip-use-register
4418 (cond ((vip-valid-register vip-use-register '((Letter)))
4419 (vip-append-to-register
4420 (downcase vip-use-register) (point) (- (point) val)))
4421 ((vip-valid-register vip-use-register)
4423 vip-use-register (point) (- (point) val) nil))
4424 (t (error vip-InvalidRegister vip-use-register)))
4425 (setq vip-use-register nil)))
4426 (if vip-ex-style-motion
4429 (if (and (eolp) (not (bolp))) (backward-char 1)))
4431 (delete-backward-char val t)
4432 (delete-char val t)))))
4434 (defun vip-delete-backward-char (arg)
4435 "Delete previous character. On reaching beginning of line, stop and beep."
4437 (let ((val (vip-p-val arg)))
4438 (vip-set-destructive-command
4439 (list 'vip-delete-backward-char val nil nil nil nil))
4442 (let ((here (point)))
4444 (if (> val (- here (point)))
4445 (setq val (- here (point)))))))
4446 (if vip-use-register
4448 (cond ((vip-valid-register vip-use-register '(Letter))
4449 (vip-append-to-register
4450 (downcase vip-use-register) (point) (+ (point) val)))
4451 ((vip-valid-register vip-use-register)
4453 vip-use-register (point) (+ (point) val) nil))
4454 (t (error vip-InvalidRegister vip-use-register)))
4455 (setq vip-use-register nil)))
4457 (delete-backward-char val t))))
4459 (defun vip-del-backward-char-in-insert ()
4460 "Delete 1 char backwards while in insert mode."
4462 (if (and vip-ex-style-editing-in-insert (bolp))
4464 (delete-backward-char 1 t)))
4466 (defun vip-del-backward-char-in-replace ()
4467 "Delete one character in replace mode.
4468 If `vip-delete-backwards-in-replace' is t, then DEL key actually deletes
4469 charecters. If it is nil, then the cursor just moves backwards, similarly
4470 to Vi. The variable `vip-ex-style-editing-in-insert', if t, doesn't let the
4471 cursor move past the beginning of line."
4473 (cond (vip-delete-backwards-in-replace
4475 (delete-backward-char 1 t))
4476 (vip-ex-style-editing-in-insert
4481 (delete-backward-char 1 t))))
4482 (vip-ex-style-editing-in-insert
4487 (backward-char 1))))
4493 (defun vip-join-lines (arg)
4494 "Join this line to next, if ARG is nil. Otherwise, join ARG lines."
4496 (let ((val (vip-P-val arg)))
4497 (vip-set-destructive-command (list 'vip-join-lines val nil nil nil nil))
4498 (vip-loop (if (null val) 1 (1- val))
4504 (delete-region (point) (1- (point)))
4505 (fixup-whitespace)))))))
4510 (defun vip-change (beg end)
4511 (if (markerp beg) (setq beg (marker-position beg)))
4512 (if (markerp end) (setq end (marker-position end)))
4513 ;; beg is sometimes (mark t), which may be nil
4514 (or beg (setq beg end))
4516 (vip-set-complex-command-for-undo)
4517 (if vip-use-register
4519 (copy-to-register vip-use-register beg end nil)
4520 (setq vip-use-register nil)))
4521 (vip-set-replace-overlay beg end)
4522 (setq last-command nil) ; separate repl text from prev kills
4524 (if (= (vip-replace-start) (point-max))
4525 (error "End of buffer"))
4527 (setq vip-last-replace-region
4528 (buffer-substring (vip-replace-start)
4531 ;; protect against error while inserting "@" and other disasters
4532 ;; (e.g., read-only buff)
4533 (condition-case conds
4534 (if (vip-same-line (vip-replace-start)
4537 ;; tabs cause problems in replace, so untabify
4538 (goto-char (vip-replace-end))
4539 (insert-before-markers "@") ; put placeholder after the TAB
4540 (untabify (vip-replace-start) (point))
4541 ;; del @, don't put on kill ring
4542 (delete-backward-char 1)
4544 (vip-set-replace-overlay-glyphs
4545 vip-replace-region-start-delimiter
4546 vip-replace-region-end-delimiter)
4547 ;; this move takes care of the last posn in the overlay, which
4548 ;; has to be shifted because of insert. We can't simply insert
4549 ;; "$" before-markers because then overlay-start will shift the
4550 ;; beginning of the overlay in case we are replacing a single
4551 ;; character. This fixes the bug with `s' and `cl' commands.
4552 (vip-move-replace-overlay (vip-replace-start) (point))
4553 (goto-char (vip-replace-start))
4554 (vip-change-state-to-replace t))
4555 (kill-region (vip-replace-start)
4557 (vip-hide-replace-overlay)
4558 (vip-change-state-to-insert))
4559 (error ;; make sure that the overlay doesn't stay.
4560 ;; go back to the original point
4561 (goto-char (vip-replace-start))
4562 (vip-hide-replace-overlay)
4563 (vip-message-conditions conds))))
4566 (defun vip-change-subr (beg end)
4567 ;; beg is sometimes (mark t), which may be nil
4568 (or beg (setq beg end))
4570 (if vip-use-register
4572 (copy-to-register vip-use-register beg end nil)
4573 (setq vip-use-register nil)))
4574 (kill-region beg end)
4575 (setq this-command 'vip-change)
4576 (vip-yank-last-insertion))
4578 (defun vip-toggle-case (arg)
4579 "Toggle character case."
4581 (let ((val (vip-p-val arg)) (c))
4582 (vip-set-destructive-command (list 'vip-toggle-case val nil nil nil nil))
4584 (setq c (following-char))
4586 (if (eq c (upcase c))
4587 (insert-char (downcase c) 1)
4588 (insert-char (upcase c) 1))
4589 (if (eolp) (backward-char 1))
4590 (setq val (1- val)))))
4595 (defun vip-query-replace ()
4597 If a null string is suplied as the string to be replaced,
4598 the query replace mode will toggle between string replace
4599 and regexp replace."
4602 (setq str (vip-read-string-with-history
4603 (if vip-re-query-replace "Query replace regexp: "
4606 'vip-replace1-history
4607 (car vip-replace1-history) ; default
4609 (if (string= str "")
4611 (setq vip-re-query-replace (not vip-re-query-replace))
4612 (message "Query replace mode changed to %s"
4613 (if vip-re-query-replace "regexp replace"
4615 (if vip-re-query-replace
4616 (query-replace-regexp
4618 (vip-read-string-with-history
4619 (format "Query replace regexp `%s' with: " str)
4621 'vip-replace1-history
4622 (car vip-replace1-history) ; default
4626 (vip-read-string-with-history
4627 (format "Query replace `%s' with: " str)
4629 'vip-replace1-history
4630 (car vip-replace1-history) ; default
4636 (defun vip-mark-beginning-of-buffer ()
4637 "Mark beginning of buffer."
4640 (goto-char (point-min))
4641 (exchange-point-and-mark)
4642 (message "Mark set at the beginning of buffer"))
4644 (defun vip-mark-end-of-buffer ()
4645 "Mark end of buffer."
4648 (goto-char (point-max))
4649 (exchange-point-and-mark)
4650 (message "Mark set at the end of buffer"))
4652 (defun vip-mark-point ()
4653 "Set mark at point of buffer."
4655 (let ((char (vip-read-char-exclusive)))
4656 (cond ((and (<= ?a char) (<= char ?z))
4657 (point-to-register (1+ (- char ?a))))
4658 ((= char ?<) (vip-mark-beginning-of-buffer))
4659 ((= char ?>) (vip-mark-end-of-buffer))
4660 ((= char ?.) (vip-set-mark-if-necessary))
4661 ((= char ?,) (vip-cycle-through-mark-ring))
4662 ((= char ?D) (mark-defun))
4666 ;; Algorithm: If first invocation of this command save mark on ring, goto
4667 ;; mark, M0, and pop the most recent elt from the mark ring into mark,
4668 ;; making it into the new mark, M1.
4669 ;; Push this mark back and set mark to the original point position, p1.
4670 ;; So, if you hit '' or `` then you can return to p1.
4672 ;; If repeated command, pop top elt from the ring into mark and
4673 ;; jump there. This forgets the position, p1, and puts M1 back into mark.
4674 ;; Then we save the current pos, which is M0, jump to M1 and pop M2 from
4675 ;; the ring into mark. Push M2 back on the ring and set mark to M0.
4677 (defun vip-cycle-through-mark-ring ()
4678 "Visit previous locations on the mark ring.
4679 One can use `` and '' to temporarily jump 1 step back."
4680 (let* ((sv-pt (point)))
4681 ;; if repeated `m,' command, pop the previously saved mark.
4682 ;; Prev saved mark is actually prev saved point. It is used if the
4683 ;; user types `` or '' and is discarded
4684 ;; from the mark ring by the next `m,' command.
4685 ;; In any case, go to the previous or previously saved mark.
4686 ;; Then push the current mark (popped off the ring) and set current
4687 ;; point to be the mark. Current pt as mark is discarded by the next
4689 (if (eq last-command 'vip-cycle-through-mark-ring)
4691 ;; save current mark if the first iteration
4692 (setq mark-ring (delete (vip-mark-marker) mark-ring))
4694 (push-mark (mark t) t)) )
4696 (set-mark-command 1)
4697 ;; don't duplicate mark on the ring
4698 (setq mark-ring (delete (vip-mark-marker) mark-ring))
4700 (vip-deactivate-mark)
4701 (setq this-command 'vip-cycle-through-mark-ring)
4705 (defun vip-goto-mark (arg)
4708 (let ((char (read-char))
4709 (com (vip-getcom arg)))
4710 (vip-goto-mark-subr char com nil)))
4712 (defun vip-goto-mark-and-skip-white (arg)
4713 "Go to mark and skip to first non-white character on line."
4715 (let ((char (read-char))
4716 (com (vip-getCom arg)))
4717 (vip-goto-mark-subr char com t)))
4719 (defun vip-goto-mark-subr (char com skip-white)
4722 (error "Empty buffer")
4724 (cond ((vip-valid-register char '(letter))
4725 (let* ((buff (current-buffer))
4726 (reg (1+ (- char ?a)))
4727 (text-marker (get-register reg)))
4728 (if com (vip-move-marker-locally 'vip-com-point (point)))
4729 (if (not (vip-valid-marker text-marker))
4730 (error vip-EmptyTextmarker char))
4731 (if (and (vip-same-line (point) vip-last-jump)
4732 (= (point) vip-last-jump-ignore))
4733 (push-mark vip-last-jump t)
4734 (push-mark nil t)) ; no msg
4735 (vip-register-to-point reg)
4736 (setq vip-last-jump (point-marker))
4738 (back-to-indentation)
4739 (setq vip-last-jump-ignore (point))))
4741 (if (equal buff (current-buffer))
4742 (vip-execute-com (if skip-white
4743 'vip-goto-mark-and-skip-white
4746 (switch-to-buffer buff)
4747 (goto-char vip-com-point)
4748 (vip-change-state-to-vi)
4750 ((and (not skip-white) (= char ?`))
4751 (if com (vip-move-marker-locally 'vip-com-point (point)))
4752 (if (and (vip-same-line (point) vip-last-jump)
4753 (= (point) vip-last-jump-ignore))
4754 (goto-char vip-last-jump))
4755 (if (= (point) (mark t)) (pop-mark))
4756 (exchange-point-and-mark)
4757 (setq vip-last-jump (point-marker)
4758 vip-last-jump-ignore 0)
4759 (if com (vip-execute-com 'vip-goto-mark nil com)))
4760 ((and skip-white (= char ?'))
4761 (if com (vip-move-marker-locally 'vip-com-point (point)))
4762 (if (and (vip-same-line (point) vip-last-jump)
4763 (= (point) vip-last-jump-ignore))
4764 (goto-char vip-last-jump))
4765 (if (= (point) (mark t)) (pop-mark))
4766 (exchange-point-and-mark)
4767 (setq vip-last-jump (point))
4768 (back-to-indentation)
4769 (setq vip-last-jump-ignore (point))
4770 (if com (vip-execute-com 'vip-goto-mark-and-skip-white nil com)))
4771 (t (error vip-InvalidTextmarker char))))
4773 (defun vip-insert-tab ()
4777 (defun vip-exchange-point-and-mark ()
4779 (exchange-point-and-mark)
4780 (back-to-indentation))
4782 ;; Input Mode Indentation
4784 ;; Returns t, if the string before point matches the regexp STR.
4785 (defsubst vip-looking-back (str)
4786 (and (save-excursion (re-search-backward str nil t))
4787 (= (point) (match-end 0))))
4790 (defun vip-forward-indent ()
4791 "Indent forward -- `C-t' in Vi."
4794 (indent-to (+ (current-column) vip-shift-width)))
4796 (defun vip-backward-indent ()
4797 "Backtab, C-d in VI"
4800 (let ((p (point)) (c (current-column)) bol (indent t))
4801 (if (vip-looking-back "[0^]")
4803 (if (eq ?^ (preceding-char))
4804 (setq vip-preserve-indent t))
4805 (delete-backward-char 1)
4811 (if (re-search-backward "[^ \t]" bol 1) (forward-char))
4812 (delete-region (point) p)
4814 (indent-to (- c vip-shift-width)))
4815 (if (or (bolp) (vip-looking-back "[^ \t]"))
4816 (setq vip-cted nil)))))
4818 (defun vip-autoindent ()
4819 "Auto Indentation, Vi-style."
4821 (let ((col (current-indentation)))
4822 (if vip-preserve-indent
4823 (setq vip-preserve-indent nil)
4824 (setq vip-current-indent col))
4825 ;; don't leave whitespace lines around
4826 (if (memq last-command
4828 vip-open-line vip-Open-line
4829 vip-replace-state-exit-cmd))
4830 (indent-to-left-margin))
4835 (if vip-electric-mode
4836 (indent-according-to-mode)
4837 (indent-to vip-current-indent))
4842 ;; Viewing registers
4844 (defun vip-ket-function (arg)
4845 "Function called by \], the ket. View registers and call \]\]."
4847 (let ((reg (read-char)))
4848 (cond ((vip-valid-register reg '(letter Letter))
4849 (view-register (downcase reg)))
4850 ((vip-valid-register reg '(digit))
4851 (let ((text (current-kill (- reg ?1) 'do-not-rotate)))
4853 (set-buffer (get-buffer-create "*Output*"))
4854 (delete-region (point-min) (point-max))
4855 (insert (format "Register %c contains the string:\n" reg))
4857 (goto-char (point-min)))
4858 (display-buffer "*Output*")))
4860 (vip-next-heading arg))
4862 vip-InvalidRegister reg)))))
4864 (defun vip-brac-function (arg)
4865 "Function called by \[, the brac. View textmarkers and call \[\["
4867 (let ((reg (read-char)))
4869 (vip-prev-heading arg))
4871 (vip-heading-end arg))
4872 ((vip-valid-register reg '(letter))
4873 (let* ((val (get-register (1+ (- reg ?a))))
4875 (error vip-EmptyTextmarker reg)
4876 (marker-buffer val)))
4877 (pos (marker-position val))
4878 line-no text (s pos) (e pos))
4880 (set-buffer (get-buffer-create "*Output*"))
4881 (delete-region (point-min) (point-max))
4886 (setq line-no (1+ (count-lines (point-min) val)))
4889 (if (re-search-backward "[^ \t]" nil t)
4895 (if (re-search-forward "[^ \t]" nil t)
4899 (setq text (buffer-substring s e))
4900 (setq text (format "%s<%c>%s"
4901 (substring text 0 (- pos s))
4902 reg (substring text (- pos s)))))
4905 "Textmarker `%c' is in buffer `%s' at line %d.\n"
4906 reg (buffer-name buf) line-no))
4907 (insert (format "Here is some text around %c:\n\n %s"
4909 (insert (format vip-EmptyTextmarker reg)))
4910 (goto-char (point-min)))
4911 (display-buffer "*Output*")))
4912 (t (error vip-InvalidTextmarker reg)))))
4916 ;; commands in insertion mode
4918 (defun vip-delete-backward-word (arg)
4919 "Delete previous word."
4924 (delete-region (point) (mark t))
4928 (defun vip-set-expert-level (&optional dont-change-unless)
4929 "Sets the expert level for a Viper user.
4930 Can be called interactively to change (temporarily or permanently) the
4931 current expert level.
4933 The optional argument DONT-CHANGE-UNLESS if not nil, says that
4934 the level should not be changed, unless its current value is
4935 meaningless (i.e., not one of 1,2,3,4,5).
4937 User level determines the setting of Viper variables that are most
4938 sensitive for VI-style look-and-feel."
4942 (if (not (natnump vip-expert-level)) (setq vip-expert-level 0))
4944 (save-window-excursion
4945 (delete-other-windows)
4946 ;; if 0 < vip-expert-level < vip-max-expert-level
4947 ;; & dont-change-unless = t -- use it; else ask
4948 (vip-ask-level dont-change-unless))
4951 vip-ex-style-motion t
4952 vip-ex-style-editing-in-insert t
4953 vip-want-ctl-h-help nil)
4956 ;; a novice or a beginner
4957 ((eq vip-expert-level 1)
4958 (global-set-key vip-toggle-key ;; in emacs-state
4959 (if (vip-window-display-p)
4962 (setq vip-no-multiple-ESC t
4964 vip-vi-style-in-minibuffer t
4965 vip-search-wrap-around-t t
4966 vip-want-emacs-keys-in-vi nil
4967 vip-want-emacs-keys-in-insert nil))
4969 ;; an intermediate to guru
4970 ((and (> vip-expert-level 1) (< vip-expert-level 5))
4971 (setq vip-no-multiple-ESC (if (vip-window-display-p) t 'twice)
4972 vip-want-emacs-keys-in-vi t
4973 vip-want-emacs-keys-in-insert (> vip-expert-level 2))
4975 (if (eq vip-expert-level 4) ; respect user's ex-style motions
4976 ; and vip-no-multiple-ESC
4978 (setq-default vip-ex-style-editing-in-insert
4979 (cdr (assoc 'vip-ex-style-editing-in-insert
4980 vip-saved-user-settings))
4982 (cdr (assoc 'vip-ex-style-motion
4983 vip-saved-user-settings)))
4984 (setq vip-ex-style-motion
4985 (cdr (assoc 'vip-ex-style-motion vip-saved-user-settings))
4986 vip-ex-style-editing-in-insert
4987 (cdr (assoc 'vip-ex-style-editing-in-insert
4988 vip-saved-user-settings))
4990 (cdr (assoc 'vip-re-search vip-saved-user-settings))
4992 (cdr (assoc 'vip-no-multiple-ESC
4993 vip-saved-user-settings))))))
4996 ;; Ideally, if 5 is selected, a buffer should pop up to let the
4997 ;; user toggle variable values.
4998 (t (setq-default vip-ex-style-editing-in-insert
4999 (cdr (assoc 'vip-ex-style-editing-in-insert
5000 vip-saved-user-settings))
5002 (cdr (assoc 'vip-ex-style-motion
5003 vip-saved-user-settings)))
5004 (setq vip-want-ctl-h-help
5005 (cdr (assoc 'vip-want-ctl-h-help vip-saved-user-settings))
5007 (cdr (assoc 'vip-always vip-saved-user-settings))
5009 (cdr (assoc 'vip-no-multiple-ESC vip-saved-user-settings))
5011 (cdr (assoc 'vip-ex-style-motion vip-saved-user-settings))
5012 vip-ex-style-editing-in-insert
5013 (cdr (assoc 'vip-ex-style-editing-in-insert
5014 vip-saved-user-settings))
5016 (cdr (assoc 'vip-re-search vip-saved-user-settings))
5017 vip-want-emacs-keys-in-vi
5018 (cdr (assoc 'vip-want-emacs-keys-in-vi
5019 vip-saved-user-settings))
5020 vip-want-emacs-keys-in-insert
5021 (cdr (assoc 'vip-want-emacs-keys-in-insert
5022 vip-saved-user-settings)))))
5023 (vip-set-mode-vars-for vip-current-state)
5025 (and (> vip-expert-level 0) (> 5 vip-expert-level)))
5028 ;; Ask user expert level.
5029 (defun vip-ask-level (dont-change-unless)
5030 (let ((ask-buffer " *vip-ask-level*")
5031 level-changed repeated)
5032 (save-window-excursion
5033 (switch-to-buffer ask-buffer)
5035 (or (eq this-command 'vip-set-expert-level)
5037 (<= vip-expert-level vip-max-expert-level)
5038 (>= vip-expert-level 1))
5042 *** Important Notice for VIP users***
5047 Viper Is a Package for Emacs Rebels,
5048 a VI Plan for Emacs Rescue,
5049 and a venomous VI PERil.
5052 Technically speaking, Viper is a new Vi emulator that replaces
5053 the old VIP package.
5055 Viper emulates Vi much better than VIP. It also significantly
5056 extends and improves upon Vi in many useful ways.
5058 Although many VIP settings in your ~/.vip are compatible with Viper,
5059 you may have to change some of them. Please refer to the documentation,
5060 which can be obtained by executing
5064 when Viper is in Vi state.
5066 If you will be so lucky as to find a bug, report it via the command
5070 Type any key to continue... ")
5075 (while (or (> vip-expert-level vip-max-expert-level)
5076 (< vip-expert-level 1)
5077 (null dont-change-unless))
5081 (message "Invalid user level")
5084 (setq dont-change-unless t
5087 Please specify your level of familiarity with the venomous VI PERil
5088 (and the VI Plan for Emacs Rescue).
5089 You can change it at any time by typing `M-x vip-set-expert-level RET'
5091 1 -- BEGINNER: Almost all Emacs features are suppressed.
5092 Feels almost like straight Vi. File name completion and
5093 command history in the minibuffer are thrown in as a bonus.
5094 To use Emacs productively, you must reach level 3 or higher.
5095 2 -- MASTER: C-c now has its standard Emacs meaning in Vi command state,
5096 so most Emacs commands can be used when Viper is in Vi state.
5097 Good progress---you are well on the way to level 3!
5098 3 -- GRAND MASTER: Like 3, but most Emacs commands are available also
5099 in Viper's insert state.
5100 4 -- GURU: Like 3, but user settings are respected for vip-no-multiple-ESC,
5101 vip-re-search, vip-ex-style-motion, & vip-ex-style-editing-in-insert
5102 variables. Adjust these settings to your taste.
5103 5 -- WIZARD: Like 4, but user settings are also respected for vip-always,
5104 vip-want-ctl-h-help, vip-want-emacs-keys-in-vi, and
5105 vip-want-emacs-keys-in-insert. Adjust these to your taste.
5107 Please, specify your level now: ")
5109 (setq vip-expert-level (- (vip-read-char-exclusive) ?0))
5112 ;; tell the user if level was changed
5116 (format "\n\n\n\n\n\t\tYou have selected user level %d"
5118 (if (y-or-n-p "Do you wish to make this change permanent? ")
5119 ;; save the setting for vip-expert-level
5122 (format "Saving user level %d ..." vip-expert-level)
5123 vip-custom-file-name))
5125 (bury-buffer) ; remove ask-buffer from screen
5130 (defun viper-version ()
5132 (message "Viper version is %s" viper-version))
5134 (defalias 'vip-version 'viper-version)
5141 ;; if ENFORCE-BUFFER is not nil, error if CHAR is a marker in another buffer
5142 (defun vip-register-to-point (char &optional enforce-buffer)
5143 "Like jump-to-register, but switches to another buffer in another window."
5144 (interactive "cViper register to point: ")
5145 (let ((val (get-register char)))
5147 ((and (fboundp 'frame-configuration-p)
5148 (frame-configuration-p val))
5149 (set-frame-configuration val))
5150 ((window-configuration-p val)
5151 (set-window-configuration val))
5152 ((vip-valid-marker val)
5153 (if (and enforce-buffer
5154 (not (equal (current-buffer) (marker-buffer val))))
5155 (error (concat vip-EmptyTextmarker " in this buffer")
5157 (pop-to-buffer (marker-buffer val))
5159 ((and (consp val) (eq (car val) 'file))
5160 (find-file (cdr val)))
5162 (error vip-EmptyTextmarker (1- (+ char ?a)))))))
5165 (defun vip-save-kill-buffer ()
5166 "Save then kill current buffer. "
5168 (if (< vip-expert-level 2)
5169 (save-buffers-kill-emacs)
5171 (kill-buffer (current-buffer))))
5177 (defun vip-submit-report ()
5178 "Submit bug report on Viper."
5180 (let ((reporter-prompt-for-summary-p t)
5181 (vip-device-type (vip-device-type))
5182 color-display-p frame-parameters
5183 minibuffer-emacs-face minibuffer-vi-face minibuffer-insert-face
5184 varlist salutation window-config)
5186 ;; If mode info is needed, add variable to `let' and then set it below,
5187 ;; like we did with color-display-p.
5188 (setq color-display-p (if (vip-window-display-p)
5189 (vip-color-display-p)
5191 minibuffer-vi-face (if (vip-has-face-support-p)
5192 (vip-get-face vip-minibuffer-vi-face)
5194 minibuffer-insert-face (if (vip-has-face-support-p)
5195 (vip-get-face vip-minibuffer-insert-face)
5197 minibuffer-emacs-face (if (vip-has-face-support-p)
5198 (vip-get-face vip-minibuffer-emacs-face)
5200 frame-parameters (if (fboundp 'frame-parameters)
5201 (frame-parameters (selected-frame))))
5203 (setq varlist (list 'vip-vi-minibuffer-minor-mode
5204 'vip-insert-minibuffer-minor-mode
5205 'vip-vi-intercept-minor-mode
5206 'vip-vi-local-user-minor-mode
5207 'vip-vi-kbd-minor-mode
5208 'vip-vi-global-user-minor-mode
5209 'vip-vi-state-modifier-minor-mode
5210 'vip-vi-diehard-minor-mode
5211 'vip-vi-basic-minor-mode
5212 'vip-replace-minor-mode
5213 'vip-insert-intercept-minor-mode
5214 'vip-insert-local-user-minor-mode
5215 'vip-insert-kbd-minor-mode
5216 'vip-insert-global-user-minor-mode
5217 'vip-insert-state-modifier-minor-mode
5218 'vip-insert-diehard-minor-mode
5219 'vip-insert-basic-minor-mode
5220 'vip-emacs-intercept-minor-mode
5221 'vip-emacs-local-user-minor-mode
5222 'vip-emacs-kbd-minor-mode
5223 'vip-emacs-global-user-minor-mode
5224 'vip-emacs-state-modifier-minor-mode
5225 'vip-automatic-iso-accents
5226 'vip-want-emacs-keys-in-insert
5227 'vip-want-emacs-keys-in-vi
5228 'vip-keep-point-on-undo
5229 'vip-no-multiple-ESC
5231 'vip-want-ctl-h-help
5232 'vip-ex-style-editing-in-insert
5233 'vip-delete-backwards-in-replace
5234 'vip-vi-style-in-minibuffer
5236 'vip-insert-state-hook
5237 'vip-replace-state-hook
5238 'vip-emacs-state-hook
5239 'ex-cycle-other-window
5240 'ex-cycle-through-non-files
5247 'minibuffer-insert-face
5248 'minibuffer-emacs-face
5251 Congratulations! You may have unearthed a bug in Viper!
5252 Please mail a concise, accurate summary of the problem to the address above.
5254 -------------------------------------------------------------------")
5255 (setq window-config (current-window-configuration))
5256 (with-output-to-temp-buffer " *vip-info*"
5257 (switch-to-buffer " *vip-info*")
5258 (delete-other-windows)
5260 PLEASE FOLLOW THESE PROCEDURES
5261 ------------------------------
5263 Before reporting a bug, please verify that it is related to Viper, and is
5264 not cause by other packages you are using.
5266 Don't report compilation warnings, unless you are certain that there is a
5267 problem. These warnings are normal and unavoidable.
5269 Please note that users should not modify variables and keymaps other than
5270 those advertised in the manual. Such `customization' is likely to crash
5271 Viper, as it would any other improperly customized Emacs package.
5273 If you are reporting an error message received while executing one of the
5274 Viper commands, type:
5276 M-x set-variable <Return> debug-on-error <Return> t <Return>
5278 Then reproduce the error. The above command will cause Emacs to produce a
5279 back trace of the execution that leads to the error. Please include this
5280 trace in your bug report.
5282 If you believe that one of Viper's commands goes into an infinite loop
5283 \(e.g., Emacs freezes\), type:
5285 M-x set-variable <Return> debug-on-quit <Return> t <Return>
5287 Then reproduce the problem. Wait for a few seconds, then type C-g to abort
5288 the current command. Include the resulting back trace in the bug report.
5290 Mail anyway (y or n)? ")
5291 (if (y-or-n-p "Mail anyway? ")
5293 (set-window-configuration window-config)
5294 (error "Bug report aborted")))
5297 (set-window-configuration window-config)
5299 (reporter-submit-bug-report "kifer@cs.sunysb.edu"
5302 nil 'delete-other-windows
5309 ;; Smoothes out the difference between Emacs' unread-command-events
5310 ;; and XEmacs unread-command-event. Arg is a character, an event, a list of
5311 ;; events or a sequence of keys.
5313 ;; Due to the way unread-command-events in Emacs (not XEmacs), a non-event
5314 ;; symbol in unread-command-events list may cause Emacs to turn this symbol
5315 ;; into an event. Below, we delete nil from event lists, since nil is the most
5316 ;; common symbol that might appear in this wrong context.
5317 (defun vip-set-unread-command-events (arg)
5320 unread-command-events
5322 (cond ((eventp arg) (list arg))
5325 (listify-key-sequence arg))
5327 "vip-set-unread-command-events: Invalid argument, %S"
5329 (if (not (eventp nil))
5330 (setq new-events (delq nil new-events)))
5331 (append new-events unread-command-events)))
5334 unread-command-events
5336 (cond ((vip-characterp arg) (list (character-to-event arg)))
5337 ((eventp arg) (list arg))
5338 ((stringp arg) (mapcar 'character-to-event arg))
5339 ((vectorp arg) (append arg nil)) ; turn into list
5340 ((listp arg) (vip-eventify-list-xemacs arg))
5342 "vip-set-unread-command-events: Invalid argument, %S" arg)))
5343 unread-command-events))))
5345 ;; list is assumed to be a list of events of characters
5346 (defun vip-eventify-list-xemacs (lis)
5348 (function (lambda (elt)
5349 (cond ((vip-characterp elt) (character-to-event elt))
5352 "vip-eventify-list-xemacs: can't convert to event, %S"
5358 ;;; Bring in the rest of the files
5359 (require 'viper-mous)
5360 (require 'viper-macs)
5365 ;; The following is provided for compatibility with older VIP's
5367 (defalias 'vip-change-mode-to-vi 'vip-change-state-to-vi)
5368 (defalias 'vip-change-mode-to-insert 'vip-change-state-to-insert)
5369 (defalias 'vip-change-mode-to-emacs 'vip-change-state-to-emacs)
5373 ;;; Load .vip and set up hooks
5375 ;; This hook designed to enable Vi-style editing in comint-based modes."
5376 (defun vip-comint-mode-hook ()
5377 (setq require-final-newline nil)
5378 (setq vip-ex-style-editing-in-insert nil
5379 vip-ex-style-motion nil)
5380 (vip-add-local-keys 'vi-state
5381 '(("\C-m" . comint-send-input) ; return
5382 ("\C-d" . comint-delchar-or-maybe-eof))) ; \C-d
5383 (vip-add-local-keys 'insert-state
5384 '(("\C-m" . comint-send-input) ; return
5385 ("\C-d" . comint-delchar-or-maybe-eof))) ; \C-d
5389 ;; This sets major mode hooks to make them come up in vi-state.
5390 (defun vip-set-hooks ()
5392 ;; It is of course a misnomer to call viper-mode a `major mode'.
5393 ;; However, this has the effect that if the user didn't specify the
5394 ;; default mode, new buffers that fall back on the default will come up
5395 ;; in Fundamental Mode and Vi state.
5396 (setq default-major-mode 'viper-mode)
5398 ;; The following major modes should come up in vi-state
5399 (defadvice fundamental-mode (after vip-fundamental-mode-ad activate)
5400 "Run `vip-change-state-to-vi' on entry."
5401 (vip-change-state-to-vi))
5403 (defvar makefile-mode-hook)
5404 (add-hook 'makefile-mode-hook 'viper-mode)
5406 (defvar help-mode-hook)
5407 (add-hook 'help-mode-hook 'viper-mode)
5409 (defvar awk-mode-hook)
5410 (add-hook 'awk-mode-hook 'viper-mode)
5412 (defvar html-mode-hook)
5413 (add-hook 'html-mode-hook 'viper-mode)
5414 (defvar html-helper-mode-hook)
5415 (add-hook 'html-helper-mode-hook 'viper-mode)
5417 (defvar emacs-lisp-mode-hook)
5418 (add-hook 'emacs-lisp-mode-hook 'viper-mode)
5420 (defvar lisp-mode-hook)
5421 (add-hook 'lisp-mode-hook 'viper-mode)
5423 (defvar bibtex-mode-hook)
5424 (add-hook 'bibtex-mode-hook 'viper-mode)
5426 (defvar cc-mode-hook)
5427 (add-hook 'cc-mode-hook 'viper-mode)
5429 (defvar c-mode-hook)
5430 (add-hook 'c-mode-hook 'viper-mode)
5432 (defvar c++-mode-hook)
5433 (add-hook 'c++-mode-hook 'viper-mode)
5435 (defvar lisp-interaction-mode-hook)
5436 (add-hook 'lisp-interaction-mode-hook 'viper-mode)
5438 (defvar fortran-mode-hook)
5439 (add-hook 'fortran-mode-hook 'vip-mode)
5441 (defvar text-mode-hook)
5442 (add-hook 'text-mode-hook 'viper-mode)
5444 (add-hook 'completion-list-mode-hook 'viper-mode)
5445 (add-hook 'compilation-mode-hook 'viper-mode)
5447 (add-hook 'perl-mode-hook 'viper-mode)
5448 (add-hook 'tcl-mode-hook 'viper-mode)
5450 (defvar emerge-startup-hook)
5451 (add-hook 'emerge-startup-hook 'vip-change-state-to-emacs)
5452 ;; Run vip-change-state-to-vi after quitting emerge.
5453 (vip-eval-after-load
5455 '(defadvice emerge-quit (after vip-emerge-advice activate)
5456 "Run `vip-change-state-to-vi' after quitting emerge."
5457 (vip-change-state-to-vi)))
5458 ;; In case Emerge was loaded before Viper.
5459 (defadvice emerge-quit (after vip-emerge-advice activate)
5460 "Run `vip-change-state-to-vi' after quitting emerge."
5461 (vip-change-state-to-vi))
5463 (vip-eval-after-load
5465 '(defadvice asm-mode (after vip-asm-mode-ad activate)
5466 "Run `vip-change-state-to-vi' on entry."
5467 (vip-change-state-to-vi)))
5469 ;; passwd.el sets up its own buffer, which turns up in Vi mode,
5470 ;; thus overriding the local map. We don't need Vi mode here.
5471 (vip-eval-after-load
5473 '(defadvice read-passwd-1 (before vip-passwd-ad activate)
5474 "Switch to emacs state while reading password."
5475 (vip-change-state-to-emacs)))
5477 (vip-eval-after-load
5479 '(defadvice prolog-mode (after vip-prolog-ad activate)
5480 "Switch to Vi state in Prolog mode."
5481 (vip-change-state-to-vi)))
5483 ;; Emacs shell, ange-ftp, and comint-based modes
5484 (defvar comint-mode-hook)
5485 (add-hook 'comint-mode-hook 'vip-change-state-to-insert)
5486 (add-hook 'comint-mode-hook 'vip-comint-mode-hook)
5489 (defvar sh-mode-hook)
5490 (add-hook 'sh-mode-hook 'viper-mode)
5491 (defvar ksh-mode-hook)
5492 (add-hook 'ksh-mode-hook 'viper-mode)
5495 ;; This is only necessary when the user uses vip-modify-major-mode
5496 (add-hook 'dired-mode-hook 'vip-change-state-to-emacs)
5500 (defvar view-mode-hook)
5501 (add-hook 'view-mode-hook 'vip-change-state-to-emacs))
5502 (defadvice view-minor-mode (after vip-view-ad activate)
5503 "Switch to Emacs state in View mode."
5504 (vip-change-state-to-emacs))
5506 (add-hook 'view-hook 'vip-change-state-to-emacs))
5509 ;; Put summary and other VM buffers in Emacs state.
5510 (defvar vm-mode-hooks)
5511 (defvar vm-summary-mode-hooks)
5512 (add-hook 'vm-mode-hooks 'vip-change-state-to-emacs)
5513 (add-hook 'vm-summary-mode-hooks 'vip-change-state-to-emacs)
5516 ;; Put buf in Emacs state after edit.
5517 (vip-eval-after-load
5519 '(defadvice rmail-cease-edit (after vip-rmail-advice activate)
5520 "Switch to emacs state when done editing message."
5521 (vip-change-state-to-emacs)))
5522 ;; In case RMAIL was loaded before Viper.
5523 (defadvice rmail-cease-edit (after vip-rmail-advice activate)
5524 "Switch to emacs state when done editing message."
5525 (vip-change-state-to-emacs))
5528 ;; Set some useful macros
5529 ;; These must be before we load .vip, so the user can unrecord them.
5531 ;; repeat the 2nd previous command without rotating the command history
5532 (vip-record-kbd-macro
5533 (vector vip-repeat-from-history-key '\1) 'vi-state
5534 [(meta x) v i p - r e p e a t - f r o m - h i s t o r y return] 't)
5535 ;; repeat the 3d previous command without rotating the command history
5536 (vip-record-kbd-macro
5537 (vector vip-repeat-from-history-key '\2) 'vi-state
5538 [(meta x) v i p - r e p e a t - f r o m - h i s t o r y return] 't)
5540 ;; toggle case sensitivity in search
5541 (vip-record-kbd-macro
5543 [1 (meta x) v i p - t o g g l e - s e a r c h - s t y l e return] 't)
5544 ;; toggle regexp/vanila search
5545 (vip-record-kbd-macro
5547 [2 (meta x) v i p - t o g g l e - s e a r c h - s t y l e return] 't)
5550 ;; ~/.vip is loaded if it exists
5551 (if (and (file-exists-p vip-custom-file-name)
5552 (not noninteractive))
5553 (load vip-custom-file-name))
5555 ;; VIP compatibility: merge whatever the user has in vip-mode-map into
5556 ;; Viper's basic map.
5557 (vip-add-keymap vip-mode-map vip-vi-global-user-map)
5560 ;; Applying Viper customization -- runs after (load .vip)
5562 ;; Save user settings or Viper defaults for vars controled by vip-expert-level
5563 (setq vip-saved-user-settings
5564 (list (cons 'vip-want-ctl-h-help vip-want-ctl-h-help)
5565 (cons 'vip-always vip-always)
5566 (cons 'vip-no-multiple-ESC vip-no-multiple-ESC)
5567 (cons 'vip-ex-style-motion vip-ex-style-motion)
5568 (cons 'vip-ex-style-editing-in-insert
5569 vip-ex-style-editing-in-insert)
5570 (cons 'vip-want-emacs-keys-in-vi vip-want-emacs-keys-in-vi)
5571 (cons 'vip-want-emacs-keys-in-insert vip-want-emacs-keys-in-insert)
5572 (cons 'vip-re-search vip-re-search)))
5575 (vip-set-minibuffer-style)
5576 (vip-set-minibuffer-faces)
5577 (vip-set-search-face)
5578 (if vip-buffer-search-char
5579 (vip-buffer-search-enable))
5580 (vip-update-alphanumeric-class)
5582 ;;; Familiarize Viper with some minor modes that have their own keymaps
5583 (vip-harness-minor-mode "compile")
5584 (vip-harness-minor-mode "outline")
5585 (vip-harness-minor-mode "allout")
5586 (vip-harness-minor-mode "xref")
5587 (vip-harness-minor-mode "lmenu")
5588 (vip-harness-minor-mode "vc")
5589 (vip-harness-minor-mode "ltx-math") ; LaTeX-math-mode in AUC-TeX
5590 (vip-harness-minor-mode "latex") ; which is in one of these two files
5591 (vip-harness-minor-mode "cyrillic")
5592 (vip-harness-minor-mode "russian")
5593 (vip-harness-minor-mode "view-less")
5594 (vip-harness-minor-mode "view")
5597 ;; Intercept maps could go in viper-keym.el
5598 ;; We keep them here in case someone redefines them in ~/.vip
5600 (define-key vip-vi-intercept-map vip-ESC-key 'vip-intercept-ESC-key)
5601 (define-key vip-insert-intercept-map vip-ESC-key 'vip-intercept-ESC-key)
5603 ;; This is taken care of by vip-insert-global-user-map.
5604 ;;(define-key vip-replace-map vip-ESC-key 'vip-intercept-ESC-key)
5606 (define-key vip-insert-intercept-map vip-toggle-key 'vip-alternate-ESC)
5607 ;; The default vip-toggle-key is \C-z; for the novice, it suspends or
5609 (define-key vip-vi-intercept-map vip-toggle-key
5610 '(lambda () (interactive)
5611 (if (and (< vip-expert-level 2) (equal vip-toggle-key "\C-z"))
5612 (if (vip-window-display-p) (vip-iconify) (suspend-emacs))
5613 (vip-change-state-to-emacs))))
5615 (define-key vip-emacs-intercept-map vip-toggle-key 'vip-change-state-to-vi)
5619 (and (< vip-expert-level 5) (> vip-expert-level 0)))
5622 ;; Let all minor modes take effect after loading
5623 ;; this may not be enough, so we also set default minor-mode-alist.
5624 ;; Without setting the default, new buffers that come up in emacs mode have
5625 ;; minor-mode-map-alist = nil, unless we call vip-change-state-*
5626 (if (eq vip-current-state 'emacs-state)
5628 (vip-change-state-to-emacs)
5629 (setq-default minor-mode-map-alist minor-mode-map-alist)
5633 (run-hooks 'vip-load-hook) ; the last chance to change something
5639 ;;; viper.el ends here