![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vi.el CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / lisp|
Return to vi.el CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / lisp |
1.1 root 1: ; Evi: Major mode for emulating "vi" editor under GNU Emacs.
2: ; Originally written by : [email protected] (Neal Ziring)
3: ; Extensively redesigned and rewritten by [email protected] (Felix S.T. Wu)
4: ; Last revision: 01/07/87 Wed (for GNU Emacs 18.33)
5: ;
6: ; INSTALLATION PROCEDURE:
7: ; 1) Add a global key binding for command "vi-mode" (I use ESC ESC instead of
8: ; the single ESC used in real "vi", so I can access other ESC prefixed emacs
9: ; commands while I'm in "vi"), say, by putting the following line in your
10: ; ".emacs" file:
11: ; (define-key global-map "\e\e" 'vi-mode) ;quick switch into vi-mode
12: ; 2) If you wish you can define "find-file-hooks" to enter "vi" automatically
13: ; after a file is loaded into the buffer. For example, I defined it as:
14: ; (setq find-file-hooks (list
15: ; (function (lambda ()
16: ; (if (not (or (eq major-mode 'Info-mode)
17: ; (eq major-mode 'vi-mode)))
18: ; (vi-mode))))))
19: ; 3) In your .emacs file you can define the command "vi-mode" to be "autoload"
20: ; or you can execute the "load" command to load "vi" directly.
21: ; 4) Read the comments for command "vi-mode" before you start using it.
22: ;
23: ; COULD DO
24: ; 1). A general 'define-operator' function to replace current hack
25: ; 2). In operator handling, should allow other point moving Emacs commands
26: ; (such as ESC <, ESC >) to be used as arguments.
27: ;
28:
29: (defun vi-switch-mode (arg mode-char)
30: "Switch the major mode of current buffer as specified by the following char \\{vi-tilde-map}"
31: (interactive "P\nc")
32: (let ((mode-cmd (lookup-key vi-tilde-map (char-to-string mode-char))))
33: (if (null mode-cmd)
34: (with-output-to-temp-buffer "*Help*"
35: (princ (substitute-command-keys "Possible major modes to switch to: \\{vi-tilde-map}")))
36: (setq prefix-arg arg) ; prefix arg will be passed down
37: (command-execute mode-cmd nil) ; may need to save mode-line-format etc
38: (set-buffer-modified-p (buffer-modified-p))))) ; just in case
39:
40:
41: (if (null (where-is-internal 'vi-switch-mode (current-local-map)))
42: (define-key ctl-x-map "~" 'vi-switch-mode))
43:
44: (defvar vi-tilde-map nil
45: "Keymap used for \\[vi-switch-mode] prefix key. Link to various major modes.")
46:
47: (if vi-tilde-map
48: nil
49: (setq vi-tilde-map (make-keymap))
50: (define-key vi-tilde-map "a" 'abbrev-mode)
51: (define-key vi-tilde-map "c" 'c-mode)
52: (define-key vi-tilde-map "d" 'vi-debugging)
53: (define-key vi-tilde-map "e" 'emacs-lisp-mode)
54: (define-key vi-tilde-map "f" 'auto-fill-mode)
55: (define-key vi-tilde-map "g" 'prolog-mode)
56: (define-key vi-tilde-map "h" 'hanoi)
57: (define-key vi-tilde-map "i" 'info-mode)
58: (define-key vi-tilde-map "l" 'lisp-mode)
59: (define-key vi-tilde-map "n" 'nroff-mode)
60: (define-key vi-tilde-map "o" 'overwrite-mode)
61: (define-key vi-tilde-map "O" 'outline-mode)
62: (define-key vi-tilde-map "P" 'picture-mode)
63: (define-key vi-tilde-map "r" 'vi-readonly-mode)
64: (define-key vi-tilde-map "t" 'text-mode)
65: (define-key vi-tilde-map "v" 'vi-mode)
66: (define-key vi-tilde-map "x" 'tex-mode)
67: (define-key vi-tilde-map "~" 'vi-back-to-old-mode))
68:
69: (defun vi-debugging (arg)
70: "Toggle debug-on-error flag. If prefix arg is given, set t."
71: (interactive "P")
72: (if arg
73: (setq debug-on-error t)
74: (setq debug-on-error (not debug-on-error)))
75: (if debug-on-error
76: (message "Debug-on-error ...")
77: (message "NO more debug-on-error")))
78:
79: (defun vi-back-to-old-mode ()
80: "Go back to the previous mode without setting up for insertion."
81: (interactive)
82: (if vi-mode-old-major-mode
83: (progn
84: (setq mode-name vi-mode-old-mode-name)
85: (use-local-map vi-mode-old-local-map)
86: (setq major-mode vi-mode-old-major-mode)
87: (setq case-fold-search vi-mode-old-case-fold)
88: (set-buffer-modified-p (buffer-modified-p)))))
89:
90: (defun vi-readonly-mode ()
91: "Toggle current buffer's readonly flag."
92: (interactive)
93: (setq buffer-read-only (not buffer-read-only)))
94:
95: (defvar vi-com-map nil
96: "Keymap used in Evi's command state
97: Command state includes most of the vi editing commands, with some Emacs
98: command extensions.")
99:
100: (put 'vi-undefined 'suppress-keymap t)
101: (if vi-com-map nil
102: (setq vi-com-map (make-keymap))
103: ;;(fillarray vi-com-map 'vi-undefined)
104: (define-key vi-com-map "\C-@" 'vi-mark-region) ; extension
105: (define-key vi-com-map "\C-a" 'vi-ask-for-info) ; extension
106: (define-key vi-com-map "\C-b" 'vi-backward-windowfull)
107: (define-key vi-com-map "\C-c" 'vi-do-old-mode-C-c-command) ; extension
108: (define-key vi-com-map "\C-d" 'vi-scroll-down-window)
109: (define-key vi-com-map "\C-e" 'vi-expose-line-below)
110: (define-key vi-com-map "\C-f" 'vi-forward-windowfull)
111: (define-key vi-com-map "\C-g" 'keyboard-quit)
112: (define-key vi-com-map "\C-i" 'indent-relative-maybe) ; TAB
113: (define-key vi-com-map "\C-j" 'vi-next-line) ; LFD
114: (define-key vi-com-map "\C-k" 'vi-kill-line) ; extension
115: (define-key vi-com-map "\C-l" 'recenter)
116: (define-key vi-com-map "\C-m" 'vi-next-line-first-nonwhite) ; RET
117: (define-key vi-com-map "\C-n" 'vi-next-line)
118: (define-key vi-com-map "\C-o" 'vi-split-open-line)
119: (define-key vi-com-map "\C-p" 'previous-line)
120: (define-key vi-com-map "\C-q" 'vi-query-replace) ; extension
121: (define-key vi-com-map "\C-r" 'vi-isearch-backward) ; modification
122: (define-key vi-com-map "\C-s" 'vi-isearch-forward) ; extension
123: (define-key vi-com-map "\C-t" 'vi-transpose-objects) ; extension
124: (define-key vi-com-map "\C-u" 'vi-scroll-up-window)
125: (define-key vi-com-map "\C-v" 'scroll-up) ; extension
126: (define-key vi-com-map "\C-w" 'vi-kill-region) ; extension
127: (define-key vi-com-map "\C-x" 'Control-X-prefix) ; extension
128: (define-key vi-com-map "\C-y" 'vi-expose-line-above)
129: (define-key vi-com-map "\C-z" 'suspend-emacs)
130:
131: (define-key vi-com-map "\e" 'ESC-prefix); C-[ (ESC)
132: (define-key vi-com-map "\C-\\" 'vi-unimplemented)
133: (define-key vi-com-map "\C-]" 'find-tag)
134: (define-key vi-com-map "\C-^" 'vi-locate-def) ; extension
135: (define-key vi-com-map "\C-_" 'vi-undefined)
136:
137: (define-key vi-com-map " " 'forward-char)
138: (define-key vi-com-map "!" 'vi-operator)
139: (define-key vi-com-map "\"" 'vi-char-argument)
140: (define-key vi-com-map "#" 'universal-argument) ; extension
141: (define-key vi-com-map "$" 'end-of-line)
142: (define-key vi-com-map "%" 'vi-find-matching-paren)
143: (define-key vi-com-map "&" 'vi-unimplemented)
144: (define-key vi-com-map "'" 'vi-goto-line-mark)
145: (define-key vi-com-map "(" 'backward-sexp)
146: (define-key vi-com-map ")" 'forward-sexp)
147: (define-key vi-com-map "*" 'vi-name-last-change-or-macro) ; extension
148: (define-key vi-com-map "+" 'vi-next-line-first-nonwhite)
149: (define-key vi-com-map "," 'vi-reverse-last-find-char)
150: (define-key vi-com-map "-" 'vi-previous-line-first-nonwhite)
151: (define-key vi-com-map "." 'vi-redo-last-change-command)
152: (define-key vi-com-map "/" 'vi-search-forward)
153: (define-key vi-com-map "0" 'beginning-of-line)
154:
155: (define-key vi-com-map "1" 'vi-digit-argument)
156: (define-key vi-com-map "2" 'vi-digit-argument)
157: (define-key vi-com-map "3" 'vi-digit-argument)
158: (define-key vi-com-map "4" 'vi-digit-argument)
159: (define-key vi-com-map "5" 'vi-digit-argument)
160: (define-key vi-com-map "6" 'vi-digit-argument)
161: (define-key vi-com-map "7" 'vi-digit-argument)
162: (define-key vi-com-map "8" 'vi-digit-argument)
163: (define-key vi-com-map "9" 'vi-digit-argument)
164:
165: (define-key vi-com-map ":" 'vi-ex-cmd)
166: (define-key vi-com-map ";" 'vi-repeat-last-find-char)
167: (define-key vi-com-map "<" 'vi-operator)
168: (define-key vi-com-map "=" 'vi-operator)
169: (define-key vi-com-map ">" 'vi-operator)
170: (define-key vi-com-map "?" 'vi-search-backward)
171: (define-key vi-com-map "@" 'vi-call-named-change-or-macro) ; extension
172:
173: (define-key vi-com-map "A" 'vi-append-at-end-of-line)
174: (define-key vi-com-map "B" 'vi-backward-blank-delimited-word)
175: (define-key vi-com-map "C" 'vi-change-rest-of-line)
176: (define-key vi-com-map "D" 'vi-kill-line)
177: (define-key vi-com-map "E" 'vi-end-of-blank-delimited-word)
178: (define-key vi-com-map "F" 'vi-backward-find-char)
179: (define-key vi-com-map "G" 'vi-goto-line)
180: (define-key vi-com-map "H" 'vi-home-window-line)
181: (define-key vi-com-map "I" 'vi-insert-before-first-nonwhite)
182: (define-key vi-com-map "J" 'vi-join-lines)
183: (define-key vi-com-map "K" 'vi-undefined)
184: (define-key vi-com-map "L" 'vi-last-window-line)
185: (define-key vi-com-map "M" 'vi-middle-window-line)
186: (define-key vi-com-map "N" 'vi-reverse-last-search)
187: (define-key vi-com-map "O" 'vi-open-above)
188: (define-key vi-com-map "P" 'vi-put-before)
189: (define-key vi-com-map "Q" 'vi-quote-words) ; extension
190: (define-key vi-com-map "R" 'vi-replace-chars)
191: (define-key vi-com-map "S" 'vi-substitute-lines)
192: (define-key vi-com-map "T" 'vi-backward-upto-char)
193: (define-key vi-com-map "U" 'vi-unimplemented)
194: (define-key vi-com-map "V" 'vi-undefined)
195: (define-key vi-com-map "W" 'vi-forward-blank-delimited-word)
196: (define-key vi-com-map "X" 'call-last-kbd-macro) ; modification/extension
197: (define-key vi-com-map "Y" 'vi-yank-line)
198: (define-key vi-com-map "Z" (make-sparse-keymap)) ;allow below prefix command
199: (define-key vi-com-map "ZZ" 'vi-save-all-and-exit)
200:
201: (define-key vi-com-map "[" 'vi-unimplemented)
202: (define-key vi-com-map "\\" 'vi-operator) ; extension for vi-narrow-op
203: (define-key vi-com-map "]" 'vi-unimplemented)
204: (define-key vi-com-map "^" 'back-to-indentation)
205: (define-key vi-com-map "_" 'vi-undefined)
206: (define-key vi-com-map "`" 'vi-goto-char-mark)
207:
208: (define-key vi-com-map "a" 'vi-insert-after)
209: (define-key vi-com-map "b" 'backward-word)
210: (define-key vi-com-map "c" 'vi-operator)
211: (define-key vi-com-map "d" 'vi-operator)
212: (define-key vi-com-map "e" 'vi-end-of-word)
213: (define-key vi-com-map "f" 'vi-forward-find-char)
214: (define-key vi-com-map "g" 'vi-beginning-of-buffer) ; extension
215: (define-key vi-com-map "h" 'backward-char)
216: (define-key vi-com-map "i" 'vi-insert-before)
217: (define-key vi-com-map "j" 'vi-next-line)
218: (define-key vi-com-map "k" 'previous-line)
219: (define-key vi-com-map "l" 'forward-char)
220: (define-key vi-com-map "m" 'vi-set-mark)
221: (define-key vi-com-map "n" 'vi-repeat-last-search)
222: (define-key vi-com-map "o" 'vi-open-below)
223: (define-key vi-com-map "p" 'vi-put-after)
224: (define-key vi-com-map "q" 'vi-replace)
225: (define-key vi-com-map "r" 'vi-replace-1-char)
226: (define-key vi-com-map "s" 'vi-substitute-chars)
227: (define-key vi-com-map "t" 'vi-forward-upto-char)
228: (define-key vi-com-map "u" 'undo)
229: (define-key vi-com-map "v" 'vi-verify-spelling)
230: (define-key vi-com-map "w" 'vi-forward-word)
231: (define-key vi-com-map "x" 'vi-kill-char)
232: (define-key vi-com-map "y" 'vi-operator)
233: (define-key vi-com-map "z" 'vi-adjust-window)
234:
235: (define-key vi-com-map "{" 'backward-paragraph)
236: (define-key vi-com-map "|" 'vi-goto-column)
237: (define-key vi-com-map "}" 'forward-paragraph)
238: (define-key vi-com-map "~" 'vi-change-case)
239: (define-key vi-com-map "\177" 'delete-backward-char))
240:
241: (put 'backward-char 'point-moving-unit 'char)
242: (put 'vi-next-line 'point-moving-unit 'line)
243: (put 'next-line 'point-moving-unit 'line)
244: (put 'forward-line 'point-moving-unit 'line)
245: (put 'previous-line 'point-moving-unit 'line)
246: (put 'vi-isearch-backward 'point-moving-unit 'search)
247: (put 'vi-search-backward 'point-moving-unit 'search)
248: (put 'vi-isearch-forward 'point-moving-unit 'search)
249: (put 'vi-search-forward 'point-moving-unit 'search)
250: (put 'forward-char 'point-moving-unit 'char)
251: (put 'end-of-line 'point-moving-unit 'char)
252: (put 'vi-find-matching-paren 'point-moving-unit 'match)
253: (put 'vi-goto-line-mark 'point-moving-unit 'line)
254: (put 'backward-sexp 'point-moving-unit 'sexp)
255: (put 'forward-sexp 'point-moving-unit 'sexp)
256: (put 'vi-next-line-first-nonwhite 'point-moving-unit 'line)
257: (put 'vi-previous-line-first-nonwhite 'point-moving-unit 'line)
258: (put 'vi-reverse-last-find-char 'point-moving-unit 'rev-find)
259: (put 'vi-re-search-forward 'point-moving-unit 'search)
260: (put 'beginning-of-line 'point-moving-unit 'char)
261: (put 'vi-beginning-of-buffer 'point-moving-unit 'char)
262: (put 'vi-repeat-last-find-char 'point-moving-unit 'find)
263: (put 'vi-re-search-backward 'point-moving-unit 'search)
264: (put 'vi-backward-blank-delimited-word 'point-moving-unit 'WORD)
265: (put 'vi-end-of-blank-delimited-word 'point-moving-unit 'match)
266: (put 'vi-backward-find-char 'point-moving-unit 'find)
267: (put 'vi-goto-line 'point-moving-unit 'line)
268: (put 'vi-home-window-line 'point-moving-unit 'line)
269: (put 'vi-last-window-line 'point-moving-unit 'line)
270: (put 'vi-middle-window-line 'point-moving-unit 'line)
271: (put 'vi-reverse-last-search 'point-moving-unit 'rev-search)
272: (put 'vi-backward-upto-char 'point-moving-unit 'find)
273: (put 'vi-forward-blank-delimited-word 'point-moving-unit 'WORD)
274: (put 'back-to-indentation 'point-moving-unit 'char)
275: (put 'vi-goto-char-mark 'point-moving-unit 'char)
276: (put 'backward-word 'point-moving-unit 'word)
277: (put 'vi-end-of-word 'point-moving-unit 'match)
278: (put 'vi-forward-find-char 'point-moving-unit 'find)
279: (put 'backward-char 'point-moving-unit 'char)
280: (put 'vi-forward-char 'point-moving-unit 'char)
281: (put 'vi-repeat-last-search 'point-moving-unit 'search)
282: (put 'vi-forward-upto-char 'point-moving-unit 'find)
283: (put 'vi-forward-word 'point-moving-unit 'word)
284: (put 'vi-goto-column 'point-moving-unit 'match)
285: (put 'forward-paragraph 'point-moving-unit 'paragraph)
286: (put 'backward-paragraph 'point-moving-unit 'paragraph)
287:
288: ;;; region mark commands
289: (put 'mark-page 'point-moving-unit 'region)
290: (put 'mark-paragraph 'point-moving-unit 'region)
291: (put 'mark-word 'point-moving-unit 'region)
292: (put 'mark-sexp 'point-moving-unit 'region)
293: (put 'mark-defun 'point-moving-unit 'region)
294: (put 'mark-whole-buffer 'point-moving-unit 'region)
295: (put 'mark-end-of-sentence 'point-moving-unit 'region)
296: (put 'mark-c-function 'point-moving-unit 'region)
297: ;;;
298:
299: (defvar vi-mark-alist nil
300: "Alist of (NAME . MARK), marks are local to each buffer.")
301:
302: (defvar vi-scroll-amount (/ (window-height) 2)
303: "Default amount of lines for scrolling (used by "^D"/"^U").")
304:
305: (defvar vi-shift-width 4
306: "Shift amount for "<"/">" operators.")
307:
308: (defvar vi-ins-point nil ; integer
309: "Last insertion point. Should use 'mark' instead.")
310:
311: (defvar vi-ins-length nil ; integer
312: "Length of last insertion.")
313:
314: (defvar vi-ins-repetition nil ; integer
315: "The repetition required for last insertion.")
316:
317: (defvar vi-ins-overwrt-p nil ; boolean
318: "T if last insertion was a replace actually.")
319:
320: (defvar vi-ins-prefix-code nil ; ready-to-eval sexp
321: "Code to be eval'ed before (redo-)insertion begins.")
322:
323: (defvar vi-last-find-char nil ; cons cell
324: "Save last direction, char and upto-flag used for char finding.")
325:
326: (defvar vi-last-change-command nil ; cons cell
327: "Save commmands for redoing last changes. Each command is in (FUNC . ARGS)
328: form that is ready to be 'apply'ed.")
329:
330: (defvar vi-last-shell-command nil ; last shell op command line
331: "Save last shell command given for \"!\" operator.")
332:
333: (defvar vi-insert-state nil ; boolean
334: "T if it is in insert state.")
335:
336: ; in "loaddefs.el"
337: ;(defvar search-last-string ""
338: ; "Last string search for by a search command.")
339:
340: (defvar vi-search-last-command nil ; (re-)search-forward(backward)
341: "Save last search command for possible redo.")
342:
343: (defvar vi-mode-old-local-map nil
344: "Save the local-map used before entering vi-mode.")
345:
346: (defvar vi-mode-old-mode-name nil
347: "Save the mode-name before entering vi-mode.")
348:
349: (defvar vi-mode-old-major-mode nil
350: "Save the major-mode before entering vi-mode.")
351:
352: (defvar vi-mode-old-case-fold nil)
353:
354: ;(defconst vi-add-to-mode-line-1
355: ; '(overwrite-mode nil " Insert"))
356:
357: ;; Value is same as vi-add-to-mode-line-1 when in vi mode,
358: ;; but nil in other buffers.
359: ;(defvar vi-add-to-mode-line nil)
360:
361: (defun vi-mode-setup ()
362: "Setup a buffer for vi-mode by creating necessary buffer-local variables."
363: ; (make-local-variable 'vi-add-to-mode-line)
364: ; (setq vi-add-to-mode-line vi-add-to-mode-line-1)
365: ; (or (memq vi-add-to-mode-line minor-mode-alist)
366: ; (setq minor-mode-alist (cons vi-add-to-mode-line minor-mode-alist)))
367: (make-local-variable 'vi-scroll-amount)
368: (setq vi-scroll-amount (/ (window-height) 2))
369: (make-local-variable 'vi-shift-width)
370: (setq vi-shift-width 4)
371: (make-local-variable 'vi-ins-point)
372: (make-local-variable 'vi-ins-length)
373: (make-local-variable 'vi-ins-repetition)
374: (make-local-variable 'vi-ins-overwrt-p)
375: (make-local-variable 'vi-ins-prefix-code)
376: (make-local-variable 'vi-last-change-command)
377: (make-local-variable 'vi-last-shell-command)
378: (make-local-variable 'vi-last-find-char)
379: (make-local-variable 'vi-mark-alist)
380: (make-local-variable 'vi-insert-state)
381: (make-local-variable 'vi-mode-old-local-map)
382: (make-local-variable 'vi-mode-old-mode-name)
383: (make-local-variable 'vi-mode-old-major-mode)
384: (make-local-variable 'vi-mode-old-case-fold)
385: (run-hooks 'vi-mode-hook))
386:
387: (defun vi-mode ()
388: "Major mode that acts like the `vi' editor.
389: The purpose of this mode is to provide you the combined power of vi (namely,
390: the \"cross product\" effect of commands and repeat last changes) and Emacs.
391:
392: This command redefines nearly all keys to look like vi commands.
393: It records the previous major mode, and any vi command for input
394: \(`i', `a', `s', etc.) switches back to that mode.
395: Thus, ordinary Emacs (in whatever major mode you had been using)
396: is \"input\" mode as far as vi is concerned.
397:
398: To get back into vi from \"input\" mode, you must issue this command again.
399: Therefore, it is recommended that you assign it to a key.
400:
401: Major differences between this mode and real vi :
402:
403: * Limitations and unsupported features
404: - Search patterns with line offset (e.g. /pat/+3 or /pat/z.) are
405: not supported.
406: - Ex commands are not implemented; try ':' to get some hints.
407: - No line undo (i.e. the 'U' command), but multi-undo is a standard feature.
408:
409: * Modifications
410: - The stopping positions for some point motion commands (word boundary,
411: pattern search) are slightly different from standard 'vi'.
412: Also, no automatic wrap around at end of buffer for pattern searching.
413: - Since changes are done in two steps (deletion then insertion), you need
414: to undo twice to completely undo a change command. But this is not needed
415: for undoing a repeated change command.
416: - No need to set/unset 'magic', to search for a string with regular expr
417: in it just put a prefix arg for the search commands. Replace cmds too.
418: - ^R is bound to incremental backward search, so use ^L to redraw screen.
419:
420: * Extensions
421: - Some standard (or modified) Emacs commands were integrated, such as
422: incremental search, query replace, transpose objects, and keyboard macros.
423: - In command state, ^X links to the 'ctl-x-map', and ESC can be linked to
424: esc-map or set undefined. These can give you the full power of Emacs.
425: - See vi-com-map for those keys that are extensions to standard vi, e.g.
426: `vi-name-last-change-or-macro', `vi-verify-spelling', `vi-locate-def',
427: `vi-mark-region', and 'vi-quote-words'. Some of them are quite handy.
428: - Use \\[vi-switch-mode] to switch among different modes quickly.
429:
430: Syntax table and abbrevs while in vi mode remain as they were in Emacs."
431: (interactive)
432: (if (null vi-mode-old-major-mode) ; very first call for current buffer
433: (vi-mode-setup))
434:
435: (if (eq major-mode 'vi-mode)
436: (message "Already in vi-mode." (ding))
437: (setq vi-mode-old-local-map (current-local-map))
438: (setq vi-mode-old-mode-name mode-name)
439: (setq vi-mode-old-major-mode major-mode)
440: (setq vi-mode-old-case-fold case-fold-search) ; this is needed !!
441: (setq case-fold-search nil) ; exact case match in searching
442: (use-local-map vi-com-map)
443: (setq major-mode 'vi-mode)
444: (setq mode-name "VI")
445: (set-buffer-modified-p (buffer-modified-p)) ; force mode line update
446: (if vi-insert-state ; this is a return from insertion
447: (vi-end-of-insert-state))))
448:
449: (defun vi-ding()
450: "Ding !"
451: (interactive)
452: (ding))
453:
454: (defun vi-save-all-and-exit ()
455: "Save all modified buffers without asking, then exits emacs."
456: (interactive)
457: (save-some-buffers t)
458: (kill-emacs))
459:
460: ;; to be used by "ex" commands
461: (defvar vi-replaced-string nil)
462: (defvar vi-replacing-string nil)
463:
464: (defun vi-ex-cmd ()
465: "Ex commands are not implemented in Evi mode. For some commonly used ex
466: commands, you can use the following alternatives for similar effect :
467: w C-x C-s (save-buffer)
468: wq C-x C-c (save-buffers-kill-emacs)
469: w fname C-x C-w (write-file)
470: e fname C-x C-f (find-file)
471: r fname C-x i (insert-file)
472: s/old/new use q (vi-replace) to do unconditional replace
473: use C-q (vi-query-replace) to do query replace
474: set sw=n M-x set-variable vi-shift-width n "
475: (interactive)
476: ;; (let ((cmd (read-string ":")) (lines 1))
477: ;; (cond ((string-match "s"))))
478: (with-output-to-temp-buffer "*Help*"
479: (princ (documentation 'vi-ex-cmd))))
480:
481: (defun vi-undefined ()
482: (interactive)
483: (message "Command key \"%s\" is undefined in Evi."
484: (single-key-description last-command-char))
485: (ding))
486:
487: (defun vi-unimplemented ()
488: (interactive)
489: (message "Command key \"%s\" is not implemented in Evi."
490: (single-key-description last-command-char))
491: (ding))
492:
493: ;;;;;
494: (defun vi-goto-insert-state (repetition &optional prefix-code do-it-now-p)
495: "Go into insert state, the text entered will be repeated if REPETITION > 1.
496: If PREFIX-CODE is given, do it before insertion begins if DO-IT-NOW-P is T.
497: In any case, the prefix-code will be done before each 'redo-insert'.
498: This function expects 'overwrite-mode' being set properly beforehand."
499: (if do-it-now-p (apply (car prefix-code) (cdr prefix-code)))
500: (setq vi-ins-point (point))
501: (setq vi-ins-repetition repetition)
502: (setq vi-ins-prefix-code prefix-code)
503: (setq mode-name vi-mode-old-mode-name)
504: (setq case-fold-search vi-mode-old-case-fold)
505: (use-local-map vi-mode-old-local-map)
506: (setq major-mode vi-mode-old-major-mode)
507: (set-buffer-modified-p (buffer-modified-p)) ; force mode line update
508: (setq vi-insert-state t))
509:
510: (defun vi-end-of-insert-state ()
511: "Terminate insertion and set up last change command."
512: (if (or (< (point) vi-ins-point) ;Check if there is any effective change
513: (and (= (point) vi-ins-point) (null vi-ins-prefix-code))
514: (<= vi-ins-repetition 0))
515: (vi-goto-command-state t)
516: (if (> vi-ins-repetition 1)
517: (progn
518: (let ((str (buffer-substring vi-ins-point (point))))
519: (while (> vi-ins-repetition 1)
520: (insert str)
521: (setq vi-ins-repetition (1- vi-ins-repetition))))))
522: (vi-set-last-change-command 'vi-first-redo-insertion vi-ins-point (point)
523: overwrite-mode vi-ins-prefix-code)
524: (vi-goto-command-state t)))
525:
526: (defun vi-first-redo-insertion (begin end &optional overwrite-p prefix-code)
527: "Redo last insertion the first time. Extract the string and save it for
528: future redoes. Do prefix-code if it's given, use overwrite mode if asked."
529: (let ((str (buffer-substring begin end)))
530: (if prefix-code (apply (car prefix-code) (cdr prefix-code)))
531: (if overwrite-p (delete-region (point) (+ (point) (length str))))
532: (insert str)
533: (vi-set-last-change-command 'vi-more-redo-insertion str overwrite-p prefix-code)))
534:
535: (defun vi-more-redo-insertion (str &optional overwrite-p prefix-code)
536: "Redo more insertion : copy string from STR to point, use overwrite mode
537: if overwrite-p is T; apply prefix-code first if it's non-nil."
538: (if prefix-code (apply (car prefix-code) (cdr prefix-code)))
539: (if overwrite-p (delete-region (point) (+ (point) (length str))))
540: (insert str))
541:
542: (defun vi-goto-command-state (&optional from-insert-state-p)
543: "Go to vi-mode command state. If optional arg exists, means return from
544: insert state."
545: (use-local-map vi-com-map)
546: (setq vi-insert-state nil)
547: (if from-insert-state-p
548: (if overwrite-mode
549: (overwrite-mode 0)
550: ; (set-minor-mode 'ins "Insert" nil)
551: )))
552:
553: (defun vi-kill-line (arg)
554: "kill specified number of lines (=d$), text saved in the kill ring."
555: (interactive "*P")
556: (kill-line arg)
557: (vi-set-last-change-command 'kill-line arg))
558:
559: (defun vi-kill-region ()
560: (interactive)
561: (kill-region)
562: (vi-set-last-change-command 'kill-region))
563:
564: (defun vi-append-at-end-of-line (arg)
565: "go to end of line and then go into vi insert state."
566: (interactive "*p")
567: (vi-goto-insert-state arg '(end-of-line) t))
568:
569: (defun vi-change-rest-of-line (arg)
570: "Change the rest of (ARG) lines (= c$ in vi)."
571: (interactive "*P")
572: (vi-goto-insert-state 1 (list 'kill-line arg) t))
573:
574: (defun vi-insert-before-first-nonwhite (arg)
575: "(= ^i in vi)"
576: (interactive "*p")
577: (vi-goto-insert-state arg '(back-to-indentation) t))
578:
579: (defun vi-open-above (arg)
580: "open new line(s) above current line and enter insert state."
581: (interactive "*p")
582: (vi-goto-insert-state 1
583: (list (function (lambda (x)
584: (or (beginning-of-line)
585: (open-line x)))) arg)
586: t))
587:
588: (defun vi-open-below (arg)
589: "open new line(s) and go into insert mode on the last line."
590: (interactive "*p")
591: (vi-goto-insert-state 1
592: (list (function (lambda (x)
593: (or (end-of-line)
594: (open-line x)
595: (forward-line x)))) arg)
596: t))
597:
598: (defun vi-insert-after (arg)
599: "start vi insert state after cursor."
600: (interactive "*p")
601: (vi-goto-insert-state arg
602: (list (function (lambda ()
603: (if (not (eolp)) (forward-char)))))
604: t))
605:
606: (defun vi-insert-before (arg)
607: "enter insert state before the cursor."
608: (interactive "*p")
609: (vi-goto-insert-state arg))
610:
611: (defun vi-goto-line (arg)
612: "Go to ARGth line."
613: (interactive "P")
614: (if (null (vi-raw-numeric-prefix arg))
615: (end-of-buffer)
616: (goto-line (vi-prefix-numeric-value arg))))
617:
618: (defun vi-beginning-of-buffer ()
619: "Move point to the beginning of current buffer."
620: (interactive)
621: (goto-char (point-min)))
622:
623: ;;;;; not used now
624: ;;(defvar regexp-search t ; string
625: ;; "*T if search string can contain regular expressions. (= set magic in vi)")
626: ;;;;;
627:
628: (defun vi-isearch-forward (arg)
629: "Incremental search forward. Use regexp version if ARG is non-nil."
630: (interactive "P")
631: (let ((scmd (if arg 'isearch-forward-regexp 'isearch-forward))
632: (opoint (point)))
633: (call-interactively scmd)
634: (if (= opoint (point))
635: nil
636: (setq vi-search-last-command (if arg 're-search-forward 'search-forward)))))
637:
638: (defun vi-isearch-backward (arg)
639: "Incremental search backward. Use regexp version if ARG is non-nil."
640: (interactive "P")
641: (let ((scmd (if arg 'isearch-backward-regexp 'isearch-backward))
642: (opoint (point)))
643: (call-interactively scmd)
644: (if (= opoint (point))
645: nil
646: (setq vi-search-last-command (if arg 're-search-backward 'search-backward)))))
647:
648: (defun vi-search-forward (arg string)
649: "Nonincremental search forward. Use regexp version if ARG is non-nil."
650: (interactive (if current-prefix-arg
651: (list t (read-string "regexp/" nil))
652: (list nil (read-string "/" nil))))
653: (setq vi-search-last-command (if arg 're-search-forward 'search-forward))
654: (if (> (length string) 0) (setq search-last-string string))
655: (funcall vi-search-last-command search-last-string nil nil 1))
656:
657: (defun vi-search-backward (arg string)
658: "Nonincremental search backward. Use regexp version if ARG is non-nil."
659: (interactive (if current-prefix-arg
660: (list t (read-string "regexp?" nil))
661: (list nil (read-string "?" nil))))
662: (setq vi-search-last-command (if arg 're-search-backward 'search-backward))
663: (if (> (length string) 0) (setq search-last-string string))
664: (funcall vi-search-last-command search-last-string nil nil 1))
665:
666: (defun vi-repeat-last-search (arg &optional search-command search-string)
667: "Repeat last search command. If optional search-command/string are given,
668: use those instead of the ones saved."
669: (interactive "p")
670: (if (null search-command) (setq search-command vi-search-last-command))
671: (if (null search-string) (setq search-string search-last-string))
672: (if (null search-command)
673: (message "No last search command to repeat." (ding))
674: (funcall search-command search-string nil nil arg)))
675:
676: (defun vi-reverse-last-search (arg &optional search-command search-string)
677: "Redo last search command in reverse direction. If the optional search args
678: are given, use those instead of the ones saved."
679: (interactive "p")
680: (if (null search-command) (setq search-command vi-search-last-command))
681: (if (null search-string) (setq search-string search-last-string))
682: (if (null search-command)
683: (message "No last search command to repeat." (ding))
684: (funcall (cond ((eq search-command 're-search-forward) 're-search-backward)
685: ((eq search-command 're-search-backward) 're-search-forward)
686: ((eq search-command 'search-forward) 'search-backward)
687: ((eq search-command 'search-backward) 'search-forward))
688: search-string nil nil arg)))
689:
690: (defun vi-join-lines (arg)
691: "join ARG lines from current line (default 2), cleaning up white space."
692: (interactive "P")
693: (if (null (vi-raw-numeric-prefix arg))
694: (delete-indentation t)
695: (setq count (vi-prefix-numeric-value arg))
696: (while (>= count 2)
697: (delete-indentation t)
698: (setq count (1- count))))
699: (vi-set-last-change-command 'vi-join-lines arg))
700:
701: (defun vi-backward-kill-line ()
702: "kill the current line. Only works in insert state."
703: (interactive)
704: (if (not vi-insert-state)
705: nil
706: (beginning-of-line 1)
707: (kill-line nil)))
708:
709: (defun vi-abort-ins ()
710: "abort insert state, kill inserted text and go back to command state."
711: (interactive)
712: (if (not vi-insert-state)
713: nil
714: (if (> (point) vi-ins-point)
715: (kill-region vi-ins-point (point)))
716: (vi-goto-command-state t)))
717:
718: (defun vi-backward-windowfull (count)
719: "Backward COUNT windowfulls. Default is one."
720: (interactive "p")
721: ; (set-mark-command nil)
722: (while (> count 0)
723: (scroll-down nil)
724: (setq count (1- count))))
725:
726: (defun vi-scroll-down-window (count)
727: "Scrolls down window COUNT lines. If COUNT is nil (actually, non-integer),
728: scrolls default amount. The given COUNT is remembered for future scrollings."
729: (interactive "P")
730: (if (integerp count)
731: (setq vi-scroll-amount count))
732: (scroll-up vi-scroll-amount))
733:
734: (defun vi-expose-line-below (count)
735: "Expose COUNT more lines below the current window. Default COUNT is 1."
736: (interactive "p")
737: (scroll-up count))
738:
739: (defun vi-forward-windowfull (count)
740: "Forward COUNT windowfulls. Default is one."
741: (interactive "p")
742: ; (set-mark-command nil)
743: (while (> count 0)
744: (scroll-up nil)
745: (setq count (1- count))))
746:
747: (defun vi-next-line (count)
748: "Go down count lines, try to keep at the same column."
749: (interactive "p")
750: (setq this-command 'next-line) ; this is a needed trick
751: (if (= (point) (or (line-move count) (point)))
752: (ding) ; no moving, already at end of buffer
753: (setq last-command 'next-line)))
754:
755: (defun vi-next-line-first-nonwhite (count)
756: "Go down COUNT lines. Stop at first non-white."
757: (interactive "p")
758: (if (= (point) (progn (forward-line count) (back-to-indentation) (point)))
759: (ding))) ; no moving, already at end of buffer
760:
761: (defun vi-previous-line-first-nonwhite (count)
762: "Go up COUNT lines. Stop at first non-white."
763: (interactive "p")
764: (previous-line count)
765: (back-to-indentation))
766:
767: (defun vi-scroll-up-window (count)
768: "Scrolls up window COUNT lines. If COUNT is nil (actually, non-integer),
769: scrolls default amount. The given COUNT is remembered for future scrollings."
770: (interactive "P")
771: (if (integerp count)
772: (setq vi-scroll-amount count))
773: (scroll-down vi-scroll-amount))
774:
775: (defun vi-expose-line-above (count)
776: "Expose COUNT more lines above the current window. Default COUNT is 1."
777: (interactive "p")
778: (scroll-down count))
779:
780: (defun vi-char-argument (arg)
781: "Get following character (could be any CHAR) as part of the prefix argument.
782: Possible perfix-arg cases are NIL, INTEGER, (NIL . CHAR) or (INTEGER . CHAR)."
783: (interactive "P")
784: (let ((char (read-char)))
785: (cond ((null arg) (setq prefix-arg (cons nil char)))
786: ((integerp arg) (setq prefix-arg (cons arg char)))
787: ; This can happen only if the user changed his/her mind for CHAR,
788: ; Or there are some leading "universal-argument"s
789: (t (setq prefix-arg (cons (car arg) char))))))
790:
791: (defun vi-goto-mark (mark-char &optional line-flag)
792: "Go to marked position or line (if line-flag is given). Goto mark '@' means
793: jump into and pop the top mark on the mark ring."
794: (cond ((char-equal mark-char last-command-char) ; `` or ''
795: (exchange-point-and-mark) (if line-flag (back-to-indentation)))
796: ((char-equal mark-char ?@) ; jump and pop mark
797: (set-mark-command t) (if line-flag (back-to-indentation)))
798: (t
799: (let ((mark (vi-get-mark mark-char)))
800: (if (null mark)
801: (message "Mark register undefined." (vi-ding))
802: (set-mark-command nil)
803: (goto-char mark)
804: (if line-flag (back-to-indentation)))))))
805:
806: (defun vi-goto-line-mark (char)
807: "Go to the line (at first non-white) marked by next char."
808: (interactive "c")
809: (vi-goto-mark char t))
810:
811: (defun vi-goto-char-mark (char)
812: "Go to the char position marked by next mark-char."
813: (interactive "c")
814: (vi-goto-mark char))
815:
816: (defun vi-digit-argument (arg)
817: "Set numeric prefix argument."
818: (interactive "P")
819: (cond ((null arg) (digit-argument arg))
820: ((integerp arg) (digit-argument nil)
821: (setq prefix-arg (* prefix-arg arg)))
822: (t (digit-argument nil) ; in (NIL . CHAR) or (NUM . CHAR) form
823: (setq prefix-arg (cons (* prefix-arg
824: (if (null (car arg)) 1 (car arg)))
825: (cdr arg))))))
826:
827: (defun vi-raw-numeric-prefix (arg)
828: "Return the raw value of numeric part prefix argument."
829: (if (consp arg) (car arg) arg))
830:
831: (defun vi-prefix-numeric-value (arg)
832: "Return numeric meaning of the raw prefix argument. This is a modification
833: to the standard one provided in `callint.c' to handle (_ . CHAR) cases."
834: (cond ((null arg) 1)
835: ((integerp arg) arg)
836: ((consp arg) (if (car arg) (car arg) 1))))
837:
838: (defun vi-reverse-last-find-char (count &optional find-arg)
839: "Reverse last f F t T operation COUNT times. If the optional FIND-ARG
840: is given, it is used instead of the saved one."
841: (interactive "p")
842: (if (null find-arg) (setq find-arg vi-last-find-char))
843: (if (null find-arg)
844: (message "No last find char to repeat." (ding))
845: (vi-find-char (cons (* (car find-arg) -1) (cdr find-arg)) count))) ;6/13/86
846:
847: (defun vi-find-char (arg count)
848: "Find in DIRECTION (1/-1) for CHAR of COUNT'th times on current line.
849: If UPTO-FLAG is T, stop before the char. ARG = (DIRECTION.CHAR.UPTO-FLAG."
850: (let* ((direction (car arg)) (char (car (cdr arg)))
851: (upto-flag (cdr (cdr arg))) (pos (+ (point) direction)))
852: (if (catch 'exit-find-char
853: (while t
854: (cond ((null (char-after pos)) (throw 'exit-find-char nil))
855: ((char-equal (char-after pos) ?\n) (throw 'exit-find-char nil))
856: ((char-equal char (char-after pos)) (setq count (1- count))
857: (if (= count 0)
858: (throw 'exit-find-char
859: (if upto-flag
860: (setq pos (- pos direction))
861: pos)))))
862: (setq pos (+ pos direction))))
863: (goto-char pos)
864: (ding))))
865:
866: (defun vi-repeat-last-find-char (count &optional find-arg)
867: "Repeat last f F t T operation COUNT times. If optional FIND-ARG is given,
868: it is used instead of the saved one."
869: (interactive "p")
870: (if (null find-arg) (setq find-arg vi-last-find-char))
871: (if (null find-arg)
872: (message "No last find char to repeat." (ding))
873: (vi-find-char find-arg count)))
874:
875: (defun vi-backward-find-char (count char)
876: "Find the COUNT'th CHAR backward on current line."
877: (interactive "p\nc")
878: (setq vi-last-find-char (cons -1 (cons char nil)))
879: (vi-repeat-last-find-char count))
880:
881: (defun vi-forward-find-char (count char)
882: "Find the COUNT'th CHAR forward on current line."
883: (interactive "p\nc")
884: (setq vi-last-find-char (cons 1 (cons char nil)))
885: (vi-repeat-last-find-char count))
886:
887: (defun vi-backward-upto-char (count char)
888: "Find upto the COUNT'th CHAR backward on current line."
889: (interactive "p\nc")
890: (setq vi-last-find-char (cons -1 (cons char t)))
891: (vi-repeat-last-find-char count))
892:
893: (defun vi-forward-upto-char (count char)
894: "Find upto the COUNT'th CHAR forward on current line."
895: (interactive "p\nc")
896: (setq vi-last-find-char (cons 1 (cons char t)))
897: (vi-repeat-last-find-char count))
898:
899: (defun vi-end-of-word (count)
900: "Move forward until encountering the end of a word.
901: With argument, do this that many times."
902: (interactive "p")
903: (if (not (eobp)) (forward-char))
904: (if (re-search-forward "\\W*\\w+\\>" nil t count)
905: (backward-char)))
906:
907: (defun vi-replace-1-char (count char)
908: "Replace char after point by CHAR. Repeat COUNT times."
909: (interactive "p\nc")
910: (delete-char count nil) ; don't save in kill ring
911: (setq last-command-char char)
912: (self-insert-command count)
913: (vi-set-last-change-command 'vi-replace-1-char count char))
914:
915: (defun vi-replace-chars (arg)
916: "Replace chars over old ones."
917: (interactive "*p")
918: (overwrite-mode 1)
919: (vi-goto-insert-state arg))
920:
921: (defun vi-substitute-chars (count)
922: "Substitute COUNT chars by the input chars, enter insert state."
923: (interactive "*p")
924: (vi-goto-insert-state 1 (list (function (lambda (c) ; this is a bit tricky
925: (delete-region (point)
926: (+ (point) c))))
927: count) t))
928:
929: (defun vi-substitute-lines (count)
930: "Substitute COUNT lines by the input chars. (=cc in vi)"
931: (interactive "*p")
932: (vi-goto-insert-state 1 (list 'vi-delete-op 'next-line (1- count)) t))
933:
934: (defun vi-prefix-char-value (arg)
935: "Get the char part of the current prefix argument."
936: (cond ((null arg) nil)
937: ((integerp arg) nil)
938: ((consp arg) (cdr arg))
939: (t nil)))
940:
941: (defun vi-operator (arg)
942: "Handling vi operators (d/c/</>/!/=/y). Current implementation requires
943: the key bindings of the operators being fixed."
944: (interactive "P")
945: (catch 'vi-exit-op
946: (let ((this-op-char last-command-char))
947: (setq last-command-char (read-char))
948: (setq this-command (lookup-key vi-com-map (char-to-string last-command-char)))
949: (if (not (eq this-command 'vi-digit-argument))
950: (setq prefix-arg arg)
951: (vi-digit-argument arg)
952: (setq last-command-char (read-char))
953: (setq this-command (lookup-key vi-com-map (char-to-string last-command-char))))
954: (cond ((char-equal this-op-char last-command-char) ; line op
955: (vi-execute-op this-op-char 'next-line
956: (cons (1- (vi-prefix-numeric-value prefix-arg))
957: (vi-prefix-char-value prefix-arg))))
958: ;; We assume any command that has no property 'point-moving-unit'
959: ;; as having that property with the value 'CHAR'. 3/12/86
960: (t ;; (get this-command 'point-moving-unit)
961: (vi-execute-op this-op-char this-command prefix-arg))))))
962: ;; (t (throw 'vi-exit-op (ding)))))))
963:
964: (defun vi-execute-op (op-char motion-command arg)
965: "Execute vi edit operator as specified by OP-CHAR, the operand is the region
966: determined by the MOTION-COMMAND with ARG."
967: (cond ((= op-char ?d)
968: (if (vi-delete-op motion-command arg)
969: (vi-set-last-change-command 'vi-delete-op (vi-repeat-command-of motion-command) arg)))
970: ((= op-char ?c)
971: (if (vi-delete-op motion-command arg)
972: (vi-goto-insert-state 1 (list 'vi-delete-op
973: (vi-repeat-command-of motion-command) arg) nil)))
974: ((= op-char ?y)
975: (if (vi-yank-op motion-command arg)
976: (vi-set-last-change-command 'vi-yank-op (vi-repeat-command-of motion-command) arg)))
977: ((= op-char ?!)
978: (if (vi-shell-op motion-command arg)
979: (vi-set-last-change-command 'vi-shell-op (vi-repeat-command-of motion-command) arg vi-last-shell-command)))
980: ((= op-char ?<)
981: (if (vi-shift-op motion-command arg (- vi-shift-width))
982: (vi-set-last-change-command 'vi-shift-op (vi-repeat-command-of motion-command) arg (- vi-shift-width))))
983: ((= op-char ?>)
984: (if (vi-shift-op motion-command arg vi-shift-width)
985: (vi-set-last-change-command 'vi-shift-op (vi-repeat-command-of motion-command) arg vi-shift-width)))
986: ((= op-char ?=)
987: (if (vi-indent-op motion-command arg)
988: (vi-set-last-change-command 'vi-indent-op (vi-repeat-command-of motion-command) arg)))
989: ((= op-char ?\\)
990: (vi-narrow-op motion-command arg))))
991:
992: (defun vi-repeat-command-of (command)
993: "Return the command for redo the given command."
994: (let ((cmd-type (get command 'point-moving-unit)))
995: (cond ((eq cmd-type 'search) 'vi-repeat-last-search)
996: ((eq cmd-type 'find) 'vi-repeat-last-find-char)
997: (t command))))
998:
999: (defun vi-effective-range (motion-command arg)
1000: "Return (begin . end) of the range spanned by executing the given
1001: MOTION-COMMAND with ARG.
1002: MOTION-COMMAND in ready-to-eval list form is not yet supported."
1003: (save-excursion
1004: (let ((begin (point)) end opoint
1005: (moving-unit (get motion-command 'point-moving-unit)))
1006: (setq prefix-arg arg)
1007: (setq opoint (point))
1008: (command-execute motion-command nil)
1009: ;; Check if there is any effective motion. Note that for single line operation
1010: ;; the motion-command causes no effective point movement (since it moves up or
1011: ;; down zero lines), but it should be counted as effectively moved.
1012: (if (and (= (point) opoint) (not (eq moving-unit 'line)))
1013: (cons opoint opoint) ; no effective motion
1014: (if (eq moving-unit 'region)
1015: (setq begin (or (mark) (point))))
1016: (if (<= begin (point))
1017: (setq end (point))
1018: (setq end begin)
1019: (setq begin (point)))
1020: (cond ((or (eq moving-unit 'match) (eq moving-unit 'find))
1021: (setq end (1+ end)))
1022: ((eq moving-unit 'line)
1023: (goto-char begin) (beginning-of-line) (setq begin (point))
1024: (goto-char end) (next-line 1) (beginning-of-line) (setq end (point))))
1025: (if (> end (point-max)) (setq end (point-max))) ; force in buffer region
1026: (cons begin end)))))
1027:
1028: (defun vi-delete-op (motion-command arg)
1029: "Delete range specified by MOTION-COMMAND with ARG."
1030: (let* ((range (vi-effective-range motion-command arg))
1031: (begin (car range)) (end (cdr range)) reg)
1032: (if (= begin end)
1033: nil ; point not moved, abort op
1034: (setq reg (vi-prefix-char-value arg))
1035: (if (null reg)
1036: (kill-region begin end) ; kill ring as unnamed registers
1037: (if (and (>= reg ?A) (<= reg ?Z))
1038: (append-to-register (downcase reg) begin end t)
1039: (copy-to-register reg begin end t)))
1040: t)))
1041:
1042: (defun vi-yank-op (motion-command arg)
1043: "Yank (in vi sense) range specified by MOTION-COMMAND with ARG."
1044: (let* ((range (vi-effective-range motion-command arg))
1045: (begin (car range)) (end (cdr range)) reg)
1046: (if (= begin end)
1047: nil ; point not moved, abort op
1048: (setq reg (vi-prefix-char-value arg))
1049: (if (null reg)
1050: (copy-region-as-kill begin end); kill ring as unnamed registers
1051: (if (and (>= reg ?A) (<= reg ?Z))
1052: (append-to-register (downcase reg) begin end nil)
1053: (copy-to-register reg begin end nil)))
1054: t)))
1055:
1056: (defun vi-yank-line (arg)
1057: "Yank (in vi sense) lines (= `yy' command)."
1058: (interactive "*P")
1059: (setq arg (cons (1- (vi-prefix-numeric-value arg)) (vi-prefix-char-value arg)))
1060: (if (vi-yank-op 'next-line arg)
1061: (vi-set-last-change-command 'vi-yank-op 'next-line arg)))
1062:
1063: (defun vi-string-end-with-nl-p (string)
1064: "See if STRING ends with a newline char. Used in checking whether the yanked
1065: text should be put back as lines or not."
1066: (= (aref string (1- (length string))) ?\n))
1067:
1068: (defun vi-put-before (arg &optional after-p)
1069: "Put yanked (in vi sense) text back before/above cursor. If a numeric prefix
1070: value (currently it should be >1) is given, put back text as lines.
1071: If the optional after-p is given, put after/below the cursor."
1072: (interactive "P")
1073: (let ((reg (vi-prefix-char-value arg)) put-text)
1074: (if (and reg (or (< reg ?1) (> reg ?9)) (null (get-register reg)))
1075: (error "Nothing in register %c" reg)
1076: (if (null reg) (setq reg ?1)) ; the default is the last text killed
1077: (setq put-text
1078: (if (and (>= reg ?1) (<= reg ?9))
1079: (let ((ring-length (length kill-ring)))
1080: (setq this-command 'yank) ; So we may yank-pop !!
1081: (nth (% (+ (- reg ?0 1) (- ring-length
1082: (length kill-ring-yank-pointer)))
1083: ring-length) kill-ring))
1084: (if (stringp (get-register reg))
1085: (get-register reg)
1086: (error "Register %c is not containing text string" reg))))
1087: (if (vi-string-end-with-nl-p put-text) ; put back text as lines
1088: (if after-p
1089: (progn (next-line 1) (beginning-of-line))
1090: (beginning-of-line))
1091: (if after-p (forward-char 1)))
1092: (push-mark (point))
1093: (insert put-text)
1094: (exchange-point-and-mark)
1095: ;; (back-to-indentation) ; this is not allowed if we allow yank-pop
1096: (vi-set-last-change-command 'vi-put-before arg after-p))))
1097:
1098: (defun vi-put-after (arg)
1099: "Put yanked (in vi sense) text back after/below cursor."
1100: (interactive "P")
1101: (vi-put-before arg t))
1102:
1103: (defun vi-shell-op (motion-command arg &optional shell-command)
1104: "Perform shell command (as filter) on range specified by MOTION-COMMAND
1105: with ARG. If SHELL-COMMAND is not given, ask for one from minibuffer.
1106: If char argument is given, it directs the output to a *temp* buffer."
1107: (let* ((range (vi-effective-range motion-command arg))
1108: (begin (car range)) (end (cdr range)))
1109: (if (= begin end)
1110: nil ; point not moved, abort op
1111: (cond ((null shell-command)
1112: (setq shell-command (read-string "!" nil))
1113: (setq vi-last-shell-command shell-command)))
1114: (shell-command-on-region begin end shell-command (not (vi-prefix-char-value arg)))
1115: t)))
1116:
1117: (defun vi-shift-op (motion-command arg amount)
1118: "Perform shift command on range specified by MOTION-COMMAND with ARG for
1119: AMOUNT on each line. Negative amount means shift left.
1120: SPECIAL FEATURE: char argument can be used to specify shift amount(1-9)."
1121: (let* ((range (vi-effective-range motion-command arg))
1122: (begin (car range)) (end (cdr range)))
1123: (if (= begin end)
1124: nil ; point not moved, abort op
1125: (if (vi-prefix-char-value arg)
1126: (setq amount (if (> amount 0)
1127: (- (vi-prefix-char-value arg) ?0)
1128: (- ?0 (vi-prefix-char-value arg)))))
1129: (indent-rigidly begin end amount)
1130: t)))
1131:
1132: (defun vi-indent-op (motion-command arg)
1133: "Perform indent command on range specified by MOTION-COMMAND with ARG."
1134: (let* ((range (vi-effective-range motion-command arg))
1135: (begin (car range)) (end (cdr range)))
1136: (if (= begin end)
1137: nil ; point not moved, abort op
1138: (indent-region begin end nil) ; insert TAB as indent command
1139: t)))
1140:
1141: (defun vi-narrow-op (motion-command arg)
1142: "Narrow to region specified by MOTION-COMMAND with ARG."
1143: (let* ((range (vi-effective-range motion-command arg))
1144: (begin (car range)) (end (cdr range)) reg)
1145: (if (= begin end)
1146: nil ; point not moved, abort op
1147: (narrow-to-region begin end))))
1148:
1149: (defun vi-get-mark (char)
1150: "Return contents of vi mark register named CHAR, or nil if undefined."
1151: (cdr (assq char vi-mark-alist)))
1152:
1153: (defun vi-set-mark (char)
1154: "Set contents of vi mark register named CHAR to current point. '@' is the
1155: special anonymous mark register."
1156: (interactive "c")
1157: (if (char-equal char ?@)
1158: (set-mark-command nil)
1159: (let ((aelt (assq char vi-mark-alist)))
1160: (if aelt
1161: (move-marker (cdr aelt) (point)) ; fixed 6/12/86
1162: (setq aelt (cons char (copy-marker (point))))
1163: (setq vi-mark-alist (cons aelt vi-mark-alist))))))
1164:
1165: (defun vi-find-matching-paren ()
1166: "Locate the matching paren. It's a hack right now."
1167: (interactive)
1168: (cond ((looking-at "[[({]") (forward-sexp 1) (backward-char 1))
1169: ((looking-at "[])}]") (forward-char 1) (backward-sexp 1))
1170: (t (ding))))
1171:
1172: (defun vi-backward-blank-delimited-word (count)
1173: "Backward COUNT blank-delimited words."
1174: (interactive "p")
1175: (if (re-search-backward "[ \t\n\`][^ \t\n\`]+" nil t count)
1176: (if (not (bobp)) (forward-char 1))))
1177:
1178: (defun vi-forward-blank-delimited-word (count)
1179: "Forward COUNT blank-delimited words."
1180: (interactive "p")
1181: (if (re-search-forward "[^ \t\n]*[ \t\n]+[^ \t\n]" nil t count)
1182: (if (not (eobp)) (backward-char 1))))
1183:
1184: (defun vi-end-of-blank-delimited-word (count)
1185: "Forward to the end of the COUNT'th blank-delimited word."
1186: (interactive "p")
1187: (if (re-search-forward "[^ \t\n\']+[ \t\n\']" nil t count)
1188: (if (not (eobp)) (backward-char 2))))
1189:
1190: (defun vi-home-window-line (arg)
1191: "To window home or arg'th line from the top of the window."
1192: (interactive "p")
1193: (move-to-window-line (1- arg))
1194: (back-to-indentation))
1195:
1196: (defun vi-last-window-line (arg)
1197: "To window last line or arg'th line from the bottom of the window."
1198: (interactive "p")
1199: (move-to-window-line (- arg))
1200: (back-to-indentation))
1201:
1202: (defun vi-middle-window-line ()
1203: "To the middle line of the window."
1204: (interactive)
1205: (move-to-window-line nil)
1206: (back-to-indentation))
1207:
1208: (defun vi-forward-word (count)
1209: "Stop at the beginning of the COUNT'th words from point."
1210: (interactive "p")
1211: (if (re-search-forward "\\w*\\W+\\<" nil t count)
1212: t
1213: (vi-ding)))
1214:
1215: (defun vi-set-last-change-command (fun &rest args)
1216: "Set (FUN . ARGS) as the last-change-command."
1217: (setq vi-last-change-command (cons fun args)))
1218:
1219: (defun vi-redo-last-change-command (count &optional command)
1220: "Redo last change command COUNT times. If the optional COMMAND is given,
1221: it is used instead of the current last-change-command."
1222: (interactive "p")
1223: (if (null command)
1224: (setq command vi-last-change-command))
1225: (if (null command)
1226: (message "No last change command available.")
1227: (while (> count 0)
1228: (apply (car command) (cdr command))
1229: (setq count (1- count)))))
1230:
1231: (defun vi-kill-char (count)
1232: "Kill COUNT chars from current point."
1233: (interactive "*p")
1234: (delete-char count t) ; save in kill ring
1235: (vi-set-last-change-command 'delete-char count t))
1236:
1237: (defun vi-transpose-objects (arg unit)
1238: "Transpose objects, the following char specifies unit of objects to be
1239: transposed -- \"c\" for chars, \"l\" for lines, \"w\" for words, \"s\" for
1240: sexp, \"p\" for paragraph.
1241: For the use of the prefix-arg, refer to individual functions called."
1242: (interactive "*P\nc")
1243: (if (char-equal unit ??)
1244: (progn
1245: (message "Transpose: c(har), l(ine), p(aragraph), s(-exp), w(ord),")
1246: (setq unit (read-char))))
1247: (vi-set-last-change-command 'vi-transpose-objects arg unit)
1248: (cond ((char-equal unit ?c) (transpose-chars arg))
1249: ((char-equal unit ?l) (transpose-lines (vi-prefix-numeric-value arg)))
1250: ((char-equal unit ?p) (transpose-paragraphs (vi-prefix-numeric-value arg)))
1251: ((char-equal unit ?s) (transpose-sexps (vi-prefix-numeric-value arg)))
1252: ((char-equal unit ?w) (transpose-words (vi-prefix-numeric-value arg)))
1253: (t (vi-transpose-objects arg ??))))
1254:
1255: (defun vi-query-replace (arg)
1256: "Query replace, use regexp version if ARG is non-nil."
1257: (interactive "*P")
1258: (let ((rcmd (if arg 'query-replace-regexp 'query-replace)))
1259: (call-interactively rcmd nil)))
1260:
1261: (defun vi-replace (arg)
1262: "Replace strings, use regexp version if ARG is non-nil."
1263: (interactive "*P")
1264: (let ((rcmd (if arg 'replace-regexp 'replace-string)))
1265: (call-interactively rcmd nil)))
1266:
1267: (defun vi-adjust-window (arg position)
1268: "Move current line to the top/center/bottom of the window."
1269: (interactive "p\nc")
1270: (cond ((char-equal position ?\r) (recenter 0))
1271: ((char-equal position ?-) (recenter -1))
1272: ((char-equal position ?.) (recenter (/ (window-height) 2)))
1273: (t (message "Move current line to: \\r(top) -(bottom) .(middle)")
1274: (setq position (read-char))
1275: (vi-adjust-window arg position))))
1276:
1277: (defun vi-goto-column (col)
1278: "Go to given column of the current line."
1279: (interactive "p")
1280: (let ((opoint (point)))
1281: (beginning-of-line)
1282: (while (> col 1)
1283: (if (eolp)
1284: (setq col 0)
1285: (forward-char 1)
1286: (setq col (1- col))))
1287: (if (= col 1)
1288: t
1289: (goto-char opoint)
1290: (ding))))
1291:
1292: (defun vi-name-last-change-or-macro (arg char)
1293: "Give name to the last change command or just defined kbd macro. If prefix
1294: ARG is given, name last macro, otherwise name last change command. The
1295: following CHAR will be the name for the command or macro."
1296: (interactive "P\nc")
1297: (if arg
1298: (name-last-kbd-macro (intern (char-to-string char)))
1299: (if (eq (car vi-last-change-command) 'vi-first-redo-insertion)
1300: (let* ((args (cdr vi-last-change-command)) ; save the insertion text
1301: (str (buffer-substring (nth 0 args) (nth 1 args)))
1302: (overwrite-p (nth 2 args))
1303: (prefix-code (nth 3 args)))
1304: (vi-set-last-change-command 'vi-more-redo-insertion str
1305: overwrite-p prefix-code)))
1306: (fset (intern (char-to-string char)) vi-last-change-command)))
1307:
1308: (defun vi-call-named-change-or-macro (count char)
1309: "Execute COUNT times the keyboard macro definition named by the following CHAR."
1310: (interactive "p\nc")
1311: (if (stringp (symbol-function (intern (char-to-string char))))
1312: (execute-kbd-macro (intern (char-to-string char)) count)
1313: (vi-redo-last-change-command count (symbol-function (intern (char-to-string char))))))
1314:
1315: (defun vi-change-case (arg) ; could be made as an operator ?
1316: "Change the case of the char after point."
1317: (interactive "*p")
1318: (catch 'exit
1319: (if (looking-at "[a-z]")
1320: (upcase-region (point) (+ (point) arg))
1321: (if (looking-at "[A-Z]")
1322: (downcase-region (point) (+ (point) arg))
1323: (ding)
1324: (throw 'exit nil)))
1325: (vi-set-last-change-command 'vi-change-case arg) ;should avoid redundant save
1326: (forward-char arg)))
1327:
1328: (defun vi-ask-for-info (char)
1329: "Inquire status info. The next CHAR will specify the particular info requested."
1330: (interactive "c")
1331: (cond ((char-equal char ?l) (what-line))
1332: ((char-equal char ?c) (what-cursor-position))
1333: ((char-equal char ?p) (what-page))
1334: (t (message "Ask for: l(ine number), c(ursor position), p(age number)")
1335: (setq char (read-char))
1336: (vi-ask-for-info char))))
1337:
1338: (defun vi-mark-region (arg region)
1339: "Mark region approriately. The next char REGION is d(efun),s(-exp),b(uffer),
1340: p(aragraph), P(age), f(unction in C/Pascal etc.), w(ord), e(nd of sentence),
1341: l(ines)."
1342: (interactive "p\nc")
1343: (cond ((char-equal region ?d) (mark-defun arg))
1344: ((char-equal region ?s) (mark-sexp arg))
1345: ((char-equal region ?b) (mark-whole-buffer))
1346: ((char-equal region ?p) (mark-paragraph arg))
1347: ((char-equal region ?P) (mark-page arg))
1348: ((char-equal region ?f) (mark-c-function arg))
1349: ((char-equal region ?w) (mark-word arg))
1350: ((char-equal region ?e) (mark-end-of-sentence arg))
1351: ((char-equal region ?l) (vi-mark-lines arg))
1352: (t (message "Mark: d(efun),s(-exp),b(uf),p(arag),P(age),f(unct),w(ord),e(os),l(ines)")
1353: (setq region (read-char))
1354: (vi-mark-region arg region))))
1355:
1356: (defun vi-mark-lines (num)
1357: "Mark NUM of lines from current line as current region."
1358: (beginning-of-line 1)
1359: (push-mark)
1360: (end-of-line num))
1361:
1362: (defun vi-verify-spelling (arg unit)
1363: "Verify spelling for the objects specified by char UNIT : [b(uffer),
1364: r(egion), s(tring), w(ord) ]."
1365: (interactive "P\nc")
1366: (setq prefix-arg arg) ; seems not needed
1367: (cond ((char-equal unit ?b) (call-interactively 'spell-buffer))
1368: ((char-equal unit ?r) (call-interactively 'spell-region))
1369: ((char-equal unit ?s) (call-interactively 'spell-string))
1370: ((char-equal unit ?w) (call-interactively 'spell-word))
1371: (t (message "Spell check: b(uffer), r(egion), s(tring), w(ord)")
1372: (setq unit (read-char))
1373: (vi-verify-spelling arg unit))))
1374:
1375: (defun vi-do-old-mode-C-c-command (arg)
1376: "This is a hack for accessing mode specific C-c commands in vi-mode."
1377: (interactive "P")
1378: (let ((cmd (lookup-key vi-mode-old-local-map
1379: (concat "\C-c" (char-to-string (read-char))))))
1380: (if (catch 'exit-vi-mode ; kludge hack due to dynamic binding
1381: ; of case-fold-search
1382: (if (null cmd)
1383: (progn (ding) nil)
1384: (let ((case-fold-search vi-mode-old-case-fold)) ; a hack
1385: (setq prefix-arg arg)
1386: (command-execute cmd nil)
1387: nil)))
1388: (progn
1389: (vi-back-to-old-mode)
1390: (setq prefix-arg arg)
1391: (command-execute cmd nil)))))
1392:
1393: (defun vi-quote-words (arg char)
1394: "Quote ARG words from the word point is on with the pattern specified by the
1395: CHAR. Currently, CHAR could be [,{,(,\",',`,<,*, etc."
1396: (interactive "*p\nc")
1397: (while (not (string-match "[[({<\"'`*]" (char-to-string char)))
1398: (message "Enter any of [,{,(,<,\",',`,* as quoting character.")
1399: (setq char (read-char)))
1400: (vi-set-last-change-command 'vi-quote-words arg char)
1401: (if (not (looking-at "\\<")) (forward-word -1))
1402: (insert char)
1403: (cond ((char-equal char ?[) (setq char ?]))
1404: ((char-equal char ?{) (setq char ?}))
1405: ((char-equal char ?<) (setq char ?>))
1406: ((char-equal char ?() (setq char ?)))
1407: ((char-equal char ?`) (setq char ?')))
1408: (vi-end-of-word arg)
1409: (forward-char 1)
1410: (insert char))
1411:
1412: (defun vi-locate-def ()
1413: "Locate definition in current file for the name before the point. It assumes
1414: a `(def..' always starts at the beginning of a line."
1415: (interactive)
1416: (let (name)
1417: (save-excursion
1418: (setq name (buffer-substring (progn (vi-backward-blank-delimited-word 1)
1419: (skip-chars-forward "^a-zA-Z")
1420: (point))
1421: (progn (vi-end-of-blank-delimited-word 1)
1422: (forward-char)
1423: (skip-chars-backward "^a-zA-Z")
1424: (point)))))
1425: (set-mark-command nil)
1426: (goto-char (point-min))
1427: (if (re-search-forward (concat "^(def[unvarconst ]*" name) nil t)
1428: nil
1429: (message "No definition for \"%s\" in current file." name (ding))
1430: (set-mark-command t))))
1431:
1432: (defun vi-split-open-line (arg)
1433: "Insert a newline and leave point before it.
1434: With arg, inserts that many newlines."
1435: (interactive "*p")
1436: (vi-goto-insert-state 1
1437: (list (function (lambda (arg)
1438: (let ((flag (and (bolp) (not (bobp)))))
1439: (if flag (forward-char -1))
1440: (while (> arg 0)
1441: (save-excursion
1442: (insert ?\n)
1443: (if fill-prefix (insert fill-prefix)))
1444: (setq arg (1- arg)))
1445: (if flag (forward-char 1))))) arg)
1446: t))
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.