Commit | Line | Data |
---|---|---|
6c2e12f4 | 1 | ;;; viper-util.el --- Utilities used by viper.el |
b578f267 | 2 | |
9b70a748 | 3 | ;; Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc. |
d6fd318f | 4 | |
6c2e12f4 KH |
5 | ;; This file is part of GNU Emacs. |
6 | ||
7 | ;; GNU Emacs is free software; you can redistribute it and/or modify | |
8 | ;; it under the terms of the GNU General Public License as published by | |
9 | ;; the Free Software Foundation; either version 2, or (at your option) | |
10 | ;; any later version. | |
11 | ||
12 | ;; GNU Emacs is distributed in the hope that it will be useful, | |
13 | ;; but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | ;; GNU General Public License for more details. | |
16 | ||
17 | ;; You should have received a copy of the GNU General Public License | |
b578f267 EN |
18 | ;; along with GNU Emacs; see the file COPYING. If not, write to the |
19 | ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
20 | ;; Boston, MA 02111-1307, USA. | |
6c2e12f4 | 21 | |
03fc1246 MK |
22 | |
23 | ;; Code | |
24 | ||
03fc1246 | 25 | ;; Compiler pacifier |
8626cfa2 | 26 | (defvar viper-overriding-map) |
03fc1246 MK |
27 | (defvar pm-color-alist) |
28 | (defvar zmacs-region-stays) | |
8626cfa2 MK |
29 | (defvar viper-minibuffer-current-face) |
30 | (defvar viper-minibuffer-insert-face) | |
31 | (defvar viper-minibuffer-vi-face) | |
32 | (defvar viper-minibuffer-emacs-face) | |
33 | (defvar viper-replace-overlay-face) | |
34 | (defvar viper-fast-keyseq-timeout) | |
9b70a748 MK |
35 | (defvar ex-unix-type-shell) |
36 | (defvar ex-unix-type-shell-options) | |
8626cfa2 | 37 | (defvar viper-ex-tmp-buf-name) |
34317da2 | 38 | (defvar viper-syntax-preference) |
9b70a748 MK |
39 | |
40 | (require 'cl) | |
41 | (require 'ring) | |
42 | ||
726e270f MK |
43 | (if noninteractive |
44 | (eval-when-compile | |
45 | (let ((load-path (cons (expand-file-name ".") load-path))) | |
46 | (or (featurep 'viper-init) | |
47 | (load "viper-init.el" nil nil 'nosuffix)) | |
48 | ))) | |
9b70a748 MK |
49 | ;; end pacifier |
50 | ||
51 | (require 'viper-init) | |
ae37fce9 | 52 | |
6c2e12f4 | 53 | |
41497c90 MK |
54 | ;; A fix for NeXT Step |
55 | ;; Should go away, when NS people fix the design flaw, which leaves the | |
56 | ;; two x-* functions undefined. | |
57 | (if (and (not (fboundp 'x-display-color-p)) (fboundp 'ns-display-color-p)) | |
58 | (fset 'x-display-color-p (symbol-function 'ns-display-color-p))) | |
59 | (if (and (not (fboundp 'x-color-defined-p)) (fboundp 'ns-color-defined-p)) | |
60 | (fset 'x-color-defined-p (symbol-function 'ns-color-defined-p))) | |
61 | ||
6c2e12f4 KH |
62 | \f |
63 | ;;; XEmacs support | |
64 | ||
9b70a748 | 65 | |
8626cfa2 | 66 | (if viper-xemacs-p |
6c2e12f4 | 67 | (progn |
8626cfa2 MK |
68 | (fset 'viper-read-event (symbol-function 'next-command-event)) |
69 | (fset 'viper-make-overlay (symbol-function 'make-extent)) | |
70 | (fset 'viper-overlay-start (symbol-function 'extent-start-position)) | |
71 | (fset 'viper-overlay-end (symbol-function 'extent-end-position)) | |
72 | (fset 'viper-overlay-put (symbol-function 'set-extent-property)) | |
73 | (fset 'viper-overlay-p (symbol-function 'extentp)) | |
74 | (fset 'viper-overlay-get (symbol-function 'extent-property)) | |
75 | (fset 'viper-move-overlay (symbol-function 'set-extent-endpoints)) | |
76 | (if (viper-window-display-p) | |
77 | (fset 'viper-iconify (symbol-function 'iconify-frame))) | |
78 | (cond ((viper-has-face-support-p) | |
79 | (fset 'viper-get-face (symbol-function 'get-face)) | |
80 | (fset 'viper-color-defined-p | |
75551c46 KH |
81 | (symbol-function 'valid-color-name-p)) |
82 | ))) | |
8626cfa2 MK |
83 | (fset 'viper-read-event (symbol-function 'read-event)) |
84 | (fset 'viper-make-overlay (symbol-function 'make-overlay)) | |
85 | (fset 'viper-overlay-start (symbol-function 'overlay-start)) | |
86 | (fset 'viper-overlay-end (symbol-function 'overlay-end)) | |
87 | (fset 'viper-overlay-put (symbol-function 'overlay-put)) | |
88 | (fset 'viper-overlay-p (symbol-function 'overlayp)) | |
89 | (fset 'viper-overlay-get (symbol-function 'overlay-get)) | |
90 | (fset 'viper-move-overlay (symbol-function 'move-overlay)) | |
91 | (if (viper-window-display-p) | |
92 | (fset 'viper-iconify (symbol-function 'iconify-or-deiconify-frame))) | |
93 | (cond ((viper-has-face-support-p) | |
94 | (fset 'viper-get-face (symbol-function 'internal-get-face)) | |
95 | (fset 'viper-color-defined-p (symbol-function 'x-color-defined-p)) | |
75551c46 KH |
96 | ))) |
97 | ||
9b70a748 | 98 | |
8626cfa2 | 99 | (fset 'viper-characterp |
bbe6126c | 100 | (symbol-function |
8626cfa2 | 101 | (if viper-xemacs-p 'characterp 'integerp))) |
bbe6126c | 102 | |
8626cfa2 MK |
103 | (defsubst viper-color-display-p () |
104 | (if viper-emacs-p | |
75551c46 KH |
105 | (x-display-color-p) |
106 | (eq (device-class (selected-device)) 'color))) | |
03fc1246 | 107 | |
8626cfa2 MK |
108 | (defsubst viper-get-cursor-color () |
109 | (if viper-emacs-p | |
20626291 MK |
110 | (cdr (assoc 'cursor-color (frame-parameters))) |
111 | (color-instance-name (frame-property (selected-frame) 'cursor-color)))) | |
112 | ||
ab124470 | 113 | |
6c2e12f4 | 114 | ;; OS/2 |
8626cfa2 MK |
115 | (cond ((eq (viper-device-type) 'pm) |
116 | (fset 'viper-color-defined-p | |
6c2e12f4 KH |
117 | (function (lambda (color) (assoc color pm-color-alist)))))) |
118 | ||
d3e1167f MK |
119 | |
120 | ;; cursor colors | |
8626cfa2 MK |
121 | (defun viper-change-cursor-color (new-color) |
122 | (if (and (viper-window-display-p) (viper-color-display-p) | |
123 | (stringp new-color) (viper-color-defined-p new-color) | |
124 | (not (string= new-color (viper-get-cursor-color)))) | |
75551c46 KH |
125 | (modify-frame-parameters |
126 | (selected-frame) (list (cons 'cursor-color new-color))))) | |
6c2e12f4 | 127 | |
8626cfa2 MK |
128 | (defun viper-save-cursor-color () |
129 | (if (and (viper-window-display-p) (viper-color-display-p)) | |
130 | (let ((color (viper-get-cursor-color))) | |
131 | (if (and (stringp color) (viper-color-defined-p color) | |
132 | (not (string= color viper-replace-overlay-cursor-color))) | |
133 | (viper-overlay-put viper-replace-overlay 'viper-cursor-color color))))) | |
6c2e12f4 | 134 | |
bf5d92c5 | 135 | ;; restore cursor color from replace overlay |
8626cfa2 MK |
136 | (defsubst viper-restore-cursor-color-after-replace () |
137 | (viper-change-cursor-color | |
138 | (viper-overlay-get viper-replace-overlay 'viper-cursor-color))) | |
139 | (defsubst viper-restore-cursor-color-after-insert () | |
140 | (viper-change-cursor-color viper-saved-cursor-color)) | |
6c2e12f4 | 141 | |
9b70a748 MK |
142 | |
143 | \f | |
6c2e12f4 KH |
144 | ;; Check the current version against the major and minor version numbers |
145 | ;; using op: cur-vers op major.minor If emacs-major-version or | |
146 | ;; emacs-minor-version are not defined, we assume that the current version | |
147 | ;; is hopelessly outdated. We assume that emacs-major-version and | |
148 | ;; emacs-minor-version are defined. Otherwise, for Emacs/XEmacs 19, if the | |
149 | ;; current minor version is < 10 (xemacs) or < 23 (emacs) the return value | |
150 | ;; will be nil (when op is =, >, or >=) and t (when op is <, <=), which may be | |
151 | ;; incorrect. However, this gives correct result in our cases, since we are | |
152 | ;; testing for sufficiently high Emacs versions. | |
8626cfa2 | 153 | (defun viper-check-version (op major minor &optional type-of-emacs) |
6c2e12f4 | 154 | (if (and (boundp 'emacs-major-version) (boundp 'emacs-minor-version)) |
8626cfa2 MK |
155 | (and (cond ((eq type-of-emacs 'xemacs) viper-xemacs-p) |
156 | ((eq type-of-emacs 'emacs) viper-emacs-p) | |
6c2e12f4 KH |
157 | (t t)) |
158 | (cond ((eq op '=) (and (= emacs-minor-version minor) | |
159 | (= emacs-major-version major))) | |
160 | ((memq op '(> >= < <=)) | |
161 | (and (or (funcall op emacs-major-version major) | |
162 | (= emacs-major-version major)) | |
163 | (if (= emacs-major-version major) | |
164 | (funcall op emacs-minor-version minor) | |
165 | t))) | |
166 | (t | |
8626cfa2 | 167 | (error "%S: Invalid op in viper-check-version" op)))) |
6c2e12f4 KH |
168 | (cond ((memq op '(= > >=)) nil) |
169 | ((memq op '(< <=)) t)))) | |
4702a420 | 170 | |
6c2e12f4 | 171 | |
8626cfa2 MK |
172 | (defun viper-get-visible-buffer-window (wind) |
173 | (if viper-xemacs-p | |
6c2e12f4 KH |
174 | (get-buffer-window wind t) |
175 | (get-buffer-window wind 'visible))) | |
176 | ||
177 | ||
75551c46 KH |
178 | ;; Return line position. |
179 | ;; If pos is 'start then returns position of line start. | |
180 | ;; If pos is 'end, returns line end. If pos is 'mid, returns line center. | |
181 | ;; Pos = 'indent returns beginning of indentation. | |
182 | ;; Otherwise, returns point. Current point is not moved in any case." | |
8626cfa2 | 183 | (defun viper-line-pos (pos) |
6c2e12f4 KH |
184 | (let ((cur-pos (point)) |
185 | (result)) | |
186 | (cond | |
187 | ((equal pos 'start) | |
188 | (beginning-of-line)) | |
189 | ((equal pos 'end) | |
190 | (end-of-line)) | |
191 | ((equal pos 'mid) | |
8626cfa2 | 192 | (goto-char (+ (viper-line-pos 'start) (viper-line-pos 'end) 2))) |
6c2e12f4 KH |
193 | ((equal pos 'indent) |
194 | (back-to-indentation)) | |
195 | (t nil)) | |
196 | (setq result (point)) | |
197 | (goto-char cur-pos) | |
198 | result)) | |
199 | ||
34317da2 MK |
200 | ;; Emacs counts each multibyte character as several positions in the buffer, so |
201 | ;; we use Emacs' chars-in-region. XEmacs is counting each char as just one pos, | |
202 | ;; so we can simply subtract. | |
203 | (defun viper-chars-in-region (beg end &optional preserve-sign) | |
204 | (let ((count (abs (if (fboundp 'chars-in-region) | |
205 | (chars-in-region beg end) | |
206 | (- end beg))))) | |
207 | (if (and (< end beg) preserve-sign) | |
208 | (- count) | |
209 | count))) | |
210 | ||
211 | ;; Test if POS is between BEG and END | |
212 | (defsubst viper-pos-within-region (pos beg end) | |
213 | (and (>= pos (min beg end)) (>= (max beg end) pos))) | |
214 | ||
6c2e12f4 | 215 | |
75551c46 KH |
216 | ;; Like move-marker but creates a virgin marker if arg isn't already a marker. |
217 | ;; The first argument must eval to a variable name. | |
218 | ;; Arguments: (var-name position &optional buffer). | |
219 | ;; | |
220 | ;; This is useful for moving markers that are supposed to be local. | |
221 | ;; For this, VAR-NAME should be made buffer-local with nil as a default. | |
8626cfa2 | 222 | ;; Then, each time this var is used in `viper-move-marker-locally' in a new |
75551c46 | 223 | ;; buffer, a new marker will be created. |
8626cfa2 | 224 | (defun viper-move-marker-locally (var pos &optional buffer) |
6c2e12f4 KH |
225 | (if (markerp (eval var)) |
226 | () | |
227 | (set var (make-marker))) | |
228 | (move-marker (eval var) pos buffer)) | |
229 | ||
230 | ||
75551c46 | 231 | ;; Print CONDITIONS as a message. |
8626cfa2 | 232 | (defun viper-message-conditions (conditions) |
6c2e12f4 KH |
233 | (let ((case (car conditions)) (msg (cdr conditions))) |
234 | (if (null msg) | |
235 | (message "%s" case) | |
236 | (message "%s: %s" case (mapconcat 'prin1-to-string msg " "))) | |
237 | (beep 1))) | |
238 | ||
75551c46 | 239 | |
6c2e12f4 KH |
240 | \f |
241 | ;;; List/alist utilities | |
242 | ||
75551c46 | 243 | ;; Convert LIST to an alist |
8626cfa2 | 244 | (defun viper-list-to-alist (lst) |
6c2e12f4 KH |
245 | (let ((alist)) |
246 | (while lst | |
247 | (setq alist (cons (list (car lst)) alist)) | |
248 | (setq lst (cdr lst))) | |
249 | alist)) | |
250 | ||
75551c46 | 251 | ;; Convert ALIST to a list. |
8626cfa2 | 252 | (defun viper-alist-to-list (alst) |
6c2e12f4 KH |
253 | (let ((lst)) |
254 | (while alst | |
255 | (setq lst (cons (car (car alst)) lst)) | |
256 | (setq alst (cdr alst))) | |
257 | lst)) | |
258 | ||
75551c46 | 259 | ;; Filter ALIST using REGEXP. Return alist whose elements match the regexp. |
8626cfa2 | 260 | (defun viper-filter-alist (regexp alst) |
6c2e12f4 KH |
261 | (interactive "s x") |
262 | (let ((outalst) (inalst alst)) | |
263 | (while (car inalst) | |
264 | (if (string-match regexp (car (car inalst))) | |
265 | (setq outalst (cons (car inalst) outalst))) | |
266 | (setq inalst (cdr inalst))) | |
267 | outalst)) | |
268 | ||
75551c46 | 269 | ;; Filter LIST using REGEXP. Return list whose elements match the regexp. |
8626cfa2 | 270 | (defun viper-filter-list (regexp lst) |
6c2e12f4 KH |
271 | (interactive "s x") |
272 | (let ((outlst) (inlst lst)) | |
273 | (while (car inlst) | |
274 | (if (string-match regexp (car inlst)) | |
275 | (setq outlst (cons (car inlst) outlst))) | |
276 | (setq inlst (cdr inlst))) | |
277 | outlst)) | |
278 | ||
279 | ||
280 | ;; Append LIS2 to LIS1, both alists, by side-effect and returns LIS1 | |
281 | ;; LIS2 is modified by filtering it: deleting its members of the form | |
282 | ;; \(car elt\) such that (car elt') is in LIS1. | |
8626cfa2 | 283 | (defun viper-append-filter-alist (lis1 lis2) |
6c2e12f4 KH |
284 | (let ((temp lis1) |
285 | elt) | |
286 | ||
287 | ;;filter-append the second list | |
288 | (while temp | |
289 | ;; delete all occurrences | |
290 | (while (setq elt (assoc (car (car temp)) lis2)) | |
291 | (setq lis2 (delq elt lis2))) | |
292 | (setq temp (cdr temp))) | |
293 | ||
294 | (nconc lis1 lis2))) | |
bbe6126c MK |
295 | |
296 | \f | |
297 | ;;; Support for :e and file globbing | |
298 | ||
8626cfa2 | 299 | (defun viper-ex-nontrivial-find-file-unix (filespec) |
bbe6126c MK |
300 | "Glob the file spec and visit all files matching the spec. |
301 | This function is designed to work under Unix. It may also work under VMS. | |
302 | ||
303 | Users who prefer other types of shells should write their own version of this | |
304 | function and set the variable `ex-nontrivial-find-file-function' | |
305 | appropriately." | |
306 | (let ((gshell | |
307 | (cond (ex-unix-type-shell shell-file-name) | |
308 | ((memq system-type '(vax-vms axp-vms)) "*dcl*") ; VAX VMS | |
309 | (t "sh"))) ; probably Unix anyway | |
310 | (gshell-options | |
311 | ;; using cond in anticipation of further additions | |
312 | (cond (ex-unix-type-shell-options) | |
313 | )) | |
8626cfa2 | 314 | (command (cond (viper-ms-style-os-p (format "\"ls -1 -d %s\"" filespec)) |
ab124470 MK |
315 | (t (format "ls -1 -d %s" filespec)))) |
316 | file-list status) | |
bbe6126c | 317 | (save-excursion |
8626cfa2 | 318 | (set-buffer (get-buffer-create viper-ex-tmp-buf-name)) |
bbe6126c MK |
319 | (erase-buffer) |
320 | (setq status | |
321 | (if gshell-options | |
322 | (call-process gshell nil t nil | |
323 | gshell-options | |
324 | "-c" | |
325 | command) | |
326 | (call-process gshell nil t nil | |
327 | "-c" | |
328 | command))) | |
329 | (goto-char (point-min)) | |
330 | ;; Issue an error, if no match. | |
331 | (if (> status 0) | |
332 | (save-excursion | |
333 | (skip-chars-forward " \t\n\j") | |
334 | (if (looking-at "ls:") | |
8626cfa2 | 335 | (viper-forward-Word 1)) |
bbe6126c MK |
336 | (error "%s: %s" |
337 | (if (stringp gshell) | |
338 | gshell | |
339 | "shell") | |
8626cfa2 | 340 | (buffer-substring (point) (viper-line-pos 'end))) |
bbe6126c MK |
341 | )) |
342 | (goto-char (point-min)) | |
8626cfa2 | 343 | (setq file-list (viper-get-filenames-from-buffer 'one-per-line))) |
bbe6126c MK |
344 | |
345 | (mapcar 'find-file file-list) | |
346 | )) | |
347 | ||
8626cfa2 | 348 | (defun viper-ex-nontrivial-find-file-ms (filespec) |
bbe6126c MK |
349 | "Glob the file spec and visit all files matching the spec. |
350 | This function is designed to work under MS type systems, such as NT, W95, and | |
351 | DOS. It may also work under OS/2. | |
352 | ||
353 | The users of Unix-type shells should be able to use | |
8626cfa2 | 354 | `viper-ex-nontrivial-find-file-unix', making it into the value of the variable |
bbe6126c | 355 | `ex-nontrivial-find-file-function'. If this doesn't work, the user may have |
8626cfa2 | 356 | to write a custom function, similar to `viper-ex-nontrivial-find-file-unix'." |
bbe6126c | 357 | (save-excursion |
8626cfa2 | 358 | (set-buffer (get-buffer-create viper-ex-tmp-buf-name)) |
bbe6126c MK |
359 | (erase-buffer) |
360 | (insert filespec) | |
361 | (goto-char (point-min)) | |
362 | (mapcar 'find-file | |
8626cfa2 | 363 | (viper-glob-ms-windows-files (viper-get-filenames-from-buffer))) |
bbe6126c MK |
364 | )) |
365 | ||
366 | ||
367 | ;; Interpret the stuff in the buffer as a list of file names | |
368 | ;; return a list of file names listed in the buffer beginning at point | |
369 | ;; If optional arg is supplied, assume each filename is listed on a separate | |
370 | ;; line | |
8626cfa2 | 371 | (defun viper-get-filenames-from-buffer (&optional one-per-line) |
bbe6126c MK |
372 | (let ((skip-chars (if one-per-line "\t\n" " \t\n")) |
373 | result fname delim) | |
374 | (skip-chars-forward skip-chars) | |
375 | (while (not (eobp)) | |
376 | (if (cond ((looking-at "\"") | |
377 | (setq delim ?\") | |
378 | (re-search-forward "[^\"]+" nil t)) ; noerror | |
379 | ((looking-at "'") | |
380 | (setq delim ?') | |
381 | (re-search-forward "[^']+" nil t)) ; noerror | |
382 | (t | |
383 | (re-search-forward | |
384 | (concat "[^" skip-chars "]+") nil t))) ;noerror | |
385 | (setq fname | |
386 | (buffer-substring (match-beginning 0) (match-end 0)))) | |
387 | (if delim | |
388 | (forward-char 1)) | |
389 | (skip-chars-forward " \t\n") | |
390 | (setq result (cons fname result))) | |
391 | result)) | |
392 | ||
393 | ;; convert MS-DOS wildcards to regexp | |
8626cfa2 | 394 | (defun viper-wildcard-to-regexp (wcard) |
bbe6126c | 395 | (save-excursion |
8626cfa2 | 396 | (set-buffer (get-buffer-create viper-ex-tmp-buf-name)) |
bbe6126c MK |
397 | (erase-buffer) |
398 | (insert wcard) | |
399 | (goto-char (point-min)) | |
400 | (while (not (eobp)) | |
401 | (skip-chars-forward "^*?.\\\\") | |
402 | (cond ((eq (char-after (point)) ?*) (insert ".")(forward-char 1)) | |
403 | ((eq (char-after (point)) ?.) (insert "\\")(forward-char 1)) | |
404 | ((eq (char-after (point)) ?\\) (insert "\\")(forward-char 1)) | |
405 | ((eq (char-after (point)) ??) (delete-char 1)(insert "."))) | |
406 | ) | |
407 | (buffer-string) | |
408 | )) | |
409 | ||
410 | ||
411 | ;; glob windows files | |
412 | ;; LIST is expected to be in reverse order | |
8626cfa2 | 413 | (defun viper-glob-ms-windows-files (list) |
bbe6126c MK |
414 | (let ((tmp list) |
415 | (case-fold-search t) | |
416 | tmp2) | |
417 | (while tmp | |
418 | (setq tmp2 (cons (directory-files | |
419 | ;; the directory part | |
420 | (or (file-name-directory (car tmp)) | |
421 | "") | |
422 | t ; return full names | |
423 | ;; the regexp part: globs the file names | |
424 | (concat "^" | |
8626cfa2 | 425 | (viper-wildcard-to-regexp |
bbe6126c MK |
426 | (file-name-nondirectory (car tmp))) |
427 | "$")) | |
428 | tmp2)) | |
429 | (setq tmp (cdr tmp))) | |
430 | (reverse (apply 'append tmp2)))) | |
431 | ||
6c2e12f4 KH |
432 | \f |
433 | ;;; Insertion ring | |
434 | ||
435 | ;; Rotate RING's index. DIRection can be positive or negative. | |
8626cfa2 | 436 | (defun viper-ring-rotate1 (ring dir) |
6c2e12f4 KH |
437 | (if (and (ring-p ring) (> (ring-length ring) 0)) |
438 | (progn | |
439 | (setcar ring (cond ((> dir 0) | |
440 | (ring-plus1 (car ring) (ring-length ring))) | |
441 | ((< dir 0) | |
442 | (ring-minus1 (car ring) (ring-length ring))) | |
443 | ;; don't rotate if dir = 0 | |
444 | (t (car ring)))) | |
8626cfa2 | 445 | (viper-current-ring-item ring) |
6c2e12f4 KH |
446 | ))) |
447 | ||
8626cfa2 MK |
448 | (defun viper-special-ring-rotate1 (ring dir) |
449 | (if (memq viper-intermediate-command | |
6c2e12f4 KH |
450 | '(repeating-display-destructive-command |
451 | repeating-insertion-from-ring)) | |
8626cfa2 | 452 | (viper-ring-rotate1 ring dir) |
6c2e12f4 | 453 | ;; don't rotate otherwise |
8626cfa2 | 454 | (viper-ring-rotate1 ring 0))) |
6c2e12f4 KH |
455 | |
456 | ;; current ring item; if N is given, then so many items back from the | |
457 | ;; current | |
8626cfa2 | 458 | (defun viper-current-ring-item (ring &optional n) |
6c2e12f4 KH |
459 | (setq n (or n 0)) |
460 | (if (and (ring-p ring) (> (ring-length ring) 0)) | |
461 | (aref (cdr (cdr ring)) (mod (- (car ring) 1 n) (ring-length ring))))) | |
462 | ||
463 | ;; push item onto ring. the second argument is a ring-variable, not value. | |
8626cfa2 | 464 | (defun viper-push-onto-ring (item ring-var) |
6c2e12f4 KH |
465 | (or (ring-p (eval ring-var)) |
466 | (set ring-var (make-ring (eval (intern (format "%S-size" ring-var)))))) | |
467 | (or (null item) ; don't push nil | |
468 | (and (stringp item) (string= item "")) ; or empty strings | |
8626cfa2 MK |
469 | (equal item (viper-current-ring-item (eval ring-var))) ; or old stuff |
470 | ;; Since viper-set-destructive-command checks if we are inside | |
471 | ;; viper-repeat, we don't check whether this-command-keys is a `.'. The | |
472 | ;; cmd viper-repeat makes a call to the current function only if `.' is | |
473 | ;; executing a command from the command history. It doesn't call the | |
474 | ;; push-onto-ring function if `.' is simply repeating the last | |
475 | ;; destructive command. We only check for ESC (which happens when we do | |
476 | ;; insert with a prefix argument, or if this-command-keys doesn't give | |
477 | ;; anything meaningful (in that case we don't know what to show to the | |
478 | ;; user). | |
479 | (and (eq ring-var 'viper-command-ring) | |
6c2e12f4 | 480 | (string-match "\\([0-9]*\e\\|^[ \t]*$\\|escape\\)" |
8626cfa2 MK |
481 | (viper-array-to-string (this-command-keys)))) |
482 | (viper-ring-insert (eval ring-var) item)) | |
6c2e12f4 KH |
483 | ) |
484 | ||
485 | ||
486 | ;; removing elts from ring seems to break it | |
8626cfa2 | 487 | (defun viper-cleanup-ring (ring) |
6c2e12f4 | 488 | (or (< (ring-length ring) 2) |
8626cfa2 | 489 | (null (viper-current-ring-item ring)) |
6c2e12f4 | 490 | ;; last and previous equal |
8626cfa2 MK |
491 | (if (equal (viper-current-ring-item ring) |
492 | (viper-current-ring-item ring 1)) | |
493 | (viper-ring-pop ring)))) | |
6c2e12f4 KH |
494 | |
495 | ;; ring-remove seems to be buggy, so we concocted this for our purposes. | |
8626cfa2 | 496 | (defun viper-ring-pop (ring) |
6c2e12f4 KH |
497 | (let* ((ln (ring-length ring)) |
498 | (vec (cdr (cdr ring))) | |
499 | (veclen (length vec)) | |
500 | (hd (car ring)) | |
501 | (idx (max 0 (ring-minus1 hd ln))) | |
502 | (top-elt (aref vec idx))) | |
503 | ||
504 | ;; shift elements | |
505 | (while (< (1+ idx) veclen) | |
506 | (aset vec idx (aref vec (1+ idx))) | |
507 | (setq idx (1+ idx))) | |
508 | (aset vec idx nil) | |
509 | ||
510 | (setq hd (max 0 (ring-minus1 hd ln))) | |
511 | (if (= hd (1- ln)) (setq hd 0)) | |
512 | (setcar ring hd) ; move head | |
513 | (setcar (cdr ring) (max 0 (1- ln))) ; adjust length | |
514 | top-elt | |
515 | )) | |
516 | ||
8626cfa2 | 517 | (defun viper-ring-insert (ring item) |
6c2e12f4 KH |
518 | (let* ((ln (ring-length ring)) |
519 | (vec (cdr (cdr ring))) | |
520 | (veclen (length vec)) | |
521 | (hd (car ring)) | |
522 | (vecpos-after-hd (if (= hd 0) ln hd)) | |
523 | (idx ln)) | |
524 | ||
525 | (if (= ln veclen) | |
526 | (progn | |
527 | (aset vec hd item) ; hd is always 1+ the actual head index in vec | |
528 | (setcar ring (ring-plus1 hd ln))) | |
529 | (setcar (cdr ring) (1+ ln)) | |
530 | (setcar ring (ring-plus1 vecpos-after-hd (1+ ln))) | |
531 | (while (and (>= idx vecpos-after-hd) (> ln 0)) | |
532 | (aset vec idx (aref vec (1- idx))) | |
533 | (setq idx (1- idx))) | |
534 | (aset vec vecpos-after-hd item)) | |
535 | item)) | |
536 | ||
537 | \f | |
538 | ;;; String utilities | |
539 | ||
540 | ;; If STRING is longer than MAX-LEN, truncate it and print ...... instead | |
541 | ;; PRE-STRING is a string to prepend to the abbrev string. | |
542 | ;; POST-STRING is a string to append to the abbrev string. | |
543 | ;; ABBREV_SIGN is a string to be inserted before POST-STRING | |
544 | ;; if the orig string was truncated. | |
8626cfa2 | 545 | (defun viper-abbreviate-string (string max-len |
6c2e12f4 KH |
546 | pre-string post-string abbrev-sign) |
547 | (let (truncated-str) | |
548 | (setq truncated-str | |
549 | (if (stringp string) | |
550 | (substring string 0 (min max-len (length string))))) | |
551 | (cond ((null truncated-str) "") | |
552 | ((> (length string) max-len) | |
553 | (format "%s%s%s%s" | |
554 | pre-string truncated-str abbrev-sign post-string)) | |
555 | (t (format "%s%s%s" pre-string truncated-str post-string))))) | |
c8085774 KH |
556 | |
557 | ;; tells if we are over a whitespace-only line | |
8626cfa2 | 558 | (defsubst viper-over-whitespace-line () |
c8085774 KH |
559 | (save-excursion |
560 | (beginning-of-line) | |
561 | (looking-at "^[ \t]*$"))) | |
6c2e12f4 KH |
562 | |
563 | \f | |
564 | ;;; Saving settings in custom file | |
565 | ||
75551c46 KH |
566 | ;; Save the current setting of VAR in CUSTOM-FILE. |
567 | ;; If given, MESSAGE is a message to be displayed after that. | |
568 | ;; This message is erased after 2 secs, if erase-msg is non-nil. | |
569 | ;; Arguments: var message custom-file &optional erase-message | |
8626cfa2 | 570 | (defun viper-save-setting (var message custom-file &optional erase-msg) |
6c2e12f4 KH |
571 | (let* ((var-name (symbol-name var)) |
572 | (var-val (if (boundp var) (eval var))) | |
573 | (regexp (format "^[^;]*%s[ \t\n]*[a-zA-Z---_']*[ \t\n)]" var-name)) | |
574 | (buf (find-file-noselect (substitute-in-file-name custom-file))) | |
575 | ) | |
95d70c42 | 576 | (message message) |
6c2e12f4 KH |
577 | (save-excursion |
578 | (set-buffer buf) | |
579 | (goto-char (point-min)) | |
580 | (if (re-search-forward regexp nil t) | |
581 | (let ((reg-end (1- (match-end 0)))) | |
582 | (search-backward var-name) | |
583 | (delete-region (match-beginning 0) reg-end) | |
584 | (goto-char (match-beginning 0)) | |
585 | (insert (format "%s '%S" var-name var-val))) | |
586 | (goto-char (point-max)) | |
587 | (if (not (bolp)) (insert "\n")) | |
588 | (insert (format "(setq %s '%S)\n" var-name var-val))) | |
589 | (save-buffer)) | |
590 | (kill-buffer buf) | |
591 | (if erase-msg | |
592 | (progn | |
593 | (sit-for 2) | |
594 | (message ""))) | |
595 | )) | |
596 | ||
597 | ;; Save STRING in CUSTOM-FILE. If PATTERN is non-nil, remove strings that | |
598 | ;; match this pattern. | |
8626cfa2 | 599 | (defun viper-save-string-in-file (string custom-file &optional pattern) |
6c2e12f4 KH |
600 | (let ((buf (find-file-noselect (substitute-in-file-name custom-file)))) |
601 | (save-excursion | |
602 | (set-buffer buf) | |
2eb4bdca MK |
603 | (let (buffer-read-only) |
604 | (goto-char (point-min)) | |
605 | (if pattern (delete-matching-lines pattern)) | |
606 | (goto-char (point-max)) | |
607 | (if string (insert string)) | |
608 | (save-buffer))) | |
6c2e12f4 KH |
609 | (kill-buffer buf) |
610 | )) | |
2eb4bdca MK |
611 | |
612 | ||
613 | ;; define remote file test | |
614 | (or (fboundp 'viper-file-remote-p) ; user supplied his own function: use it | |
615 | (defun viper-file-remote-p (file-name) | |
616 | (car (cond ((featurep 'efs-auto) (efs-ftp-path file-name)) | |
617 | ((fboundp 'file-remote-p) (file-remote-p file-name)) | |
618 | (t (require 'ange-ftp) | |
619 | ;; Can happen only in Emacs, since XEmacs has file-remote-p | |
620 | (ange-ftp-ftp-name file-name)))))) | |
621 | ||
622 | ||
623 | ||
624 | ;; This is a simple-minded check for whether a file is under version control. | |
625 | ;; If file,v exists but file doesn't, this file is considered to be not checked | |
626 | ;; in and not checked out for the purpose of patching (since patch won't be | |
627 | ;; able to read such a file anyway). | |
628 | ;; FILE is a string representing file name | |
629 | ;;(defun viper-file-under-version-control (file) | |
630 | ;; (let* ((filedir (file-name-directory file)) | |
631 | ;; (file-nondir (file-name-nondirectory file)) | |
632 | ;; (trial (concat file-nondir ",v")) | |
633 | ;; (full-trial (concat filedir trial)) | |
634 | ;; (full-rcs-trial (concat filedir "RCS/" trial))) | |
635 | ;; (and (stringp file) | |
636 | ;; (file-exists-p file) | |
637 | ;; (or | |
638 | ;; (and | |
639 | ;; (file-exists-p full-trial) | |
640 | ;; ;; in FAT FS, `file,v' and `file' may turn out to be the same! | |
641 | ;; ;; don't be fooled by this! | |
642 | ;; (not (equal (file-attributes file) | |
643 | ;; (file-attributes full-trial)))) | |
644 | ;; ;; check if a version is in RCS/ directory | |
645 | ;; (file-exists-p full-rcs-trial))) | |
646 | ;; )) | |
647 | ||
648 | ||
649 | (defsubst viper-file-checked-in-p (file) | |
650 | (and (vc-backend file) | |
651 | (not (vc-locking-user file)))) | |
652 | ;; checkout if visited file is checked in | |
653 | (defun viper-maybe-checkout (buf) | |
654 | (let ((file (expand-file-name (buffer-file-name buf))) | |
655 | (checkout-function (key-binding "\C-x\C-q"))) | |
656 | (if (and (viper-file-checked-in-p file) | |
657 | (or (beep 1) t) | |
658 | (y-or-n-p | |
659 | (format | |
660 | "File %s is checked in. Check it out? " | |
661 | (viper-abbreviate-file-name file)))) | |
662 | (with-current-buffer buf | |
663 | (command-execute checkout-function))))) | |
664 | ||
665 | ||
6c2e12f4 KH |
666 | |
667 | \f | |
668 | ;;; Overlays | |
669 | ||
670 | ;; Search | |
671 | ||
8626cfa2 MK |
672 | (defun viper-flash-search-pattern () |
673 | (if (viper-overlay-p viper-search-overlay) | |
674 | (viper-move-overlay | |
675 | viper-search-overlay (match-beginning 0) (match-end 0)) | |
676 | (setq viper-search-overlay | |
677 | (viper-make-overlay | |
6c2e12f4 KH |
678 | (match-beginning 0) (match-end 0) (current-buffer)))) |
679 | ||
8626cfa2 MK |
680 | (viper-overlay-put |
681 | viper-search-overlay 'priority viper-search-overlay-priority) | |
682 | (if (viper-has-face-support-p) | |
6c2e12f4 | 683 | (progn |
8626cfa2 | 684 | (viper-overlay-put viper-search-overlay 'face viper-search-face) |
6c2e12f4 | 685 | (sit-for 2) |
8626cfa2 | 686 | (viper-overlay-put viper-search-overlay 'face nil)))) |
6c2e12f4 | 687 | |
ab124470 | 688 | |
6c2e12f4 KH |
689 | ;; Replace state |
690 | ||
8626cfa2 MK |
691 | (defsubst viper-move-replace-overlay (beg end) |
692 | (viper-move-overlay viper-replace-overlay beg end)) | |
03fc1246 | 693 | |
8626cfa2 MK |
694 | (defun viper-set-replace-overlay (beg end) |
695 | (if (viper-overlay-p viper-replace-overlay) | |
696 | (viper-move-replace-overlay beg end) | |
697 | (setq viper-replace-overlay (viper-make-overlay beg end (current-buffer))) | |
03fc1246 | 698 | ;; never detach |
8626cfa2 MK |
699 | (viper-overlay-put |
700 | viper-replace-overlay (if viper-emacs-p 'evaporate 'detachable) nil) | |
701 | (viper-overlay-put | |
702 | viper-replace-overlay 'priority viper-replace-overlay-priority) | |
9b70a748 | 703 | ;; If Emacs will start supporting overlay maps, as it currently supports |
8626cfa2 | 704 | ;; text-property maps, we could do away with viper-replace-minor-mode and |
9b70a748 | 705 | ;; just have keymap attached to replace overlay. |
8626cfa2 MK |
706 | ;;(viper-overlay-put |
707 | ;; viper-replace-overlay | |
708 | ;; (if viper-xemacs-p 'keymap 'local-map) | |
709 | ;; viper-replace-map) | |
9b70a748 | 710 | ) |
8626cfa2 MK |
711 | (if (viper-has-face-support-p) |
712 | (viper-overlay-put | |
713 | viper-replace-overlay 'face viper-replace-overlay-face)) | |
714 | (viper-save-cursor-color) | |
715 | (viper-change-cursor-color viper-replace-overlay-cursor-color) | |
6c2e12f4 KH |
716 | ) |
717 | ||
75551c46 | 718 | |
8626cfa2 MK |
719 | (defun viper-set-replace-overlay-glyphs (before-glyph after-glyph) |
720 | (if (or (not (viper-has-face-support-p)) | |
721 | viper-use-replace-region-delimiters) | |
722 | (let ((before-name (if viper-xemacs-p 'begin-glyph 'before-string)) | |
723 | (after-name (if viper-xemacs-p 'end-glyph 'after-string))) | |
724 | (viper-overlay-put viper-replace-overlay before-name before-glyph) | |
725 | (viper-overlay-put viper-replace-overlay after-name after-glyph)))) | |
03fc1246 | 726 | |
8626cfa2 MK |
727 | (defun viper-hide-replace-overlay () |
728 | (viper-set-replace-overlay-glyphs nil nil) | |
729 | (viper-restore-cursor-color-after-replace) | |
730 | (viper-restore-cursor-color-after-insert) | |
731 | (if (viper-has-face-support-p) | |
732 | (viper-overlay-put viper-replace-overlay 'face nil))) | |
6c2e12f4 KH |
733 | |
734 | ||
8626cfa2 MK |
735 | (defsubst viper-replace-start () |
736 | (viper-overlay-start viper-replace-overlay)) | |
737 | (defsubst viper-replace-end () | |
738 | (viper-overlay-end viper-replace-overlay)) | |
6c2e12f4 KH |
739 | |
740 | ||
741 | ;; Minibuffer | |
742 | ||
8626cfa2 MK |
743 | (defun viper-set-minibuffer-overlay () |
744 | (viper-check-minibuffer-overlay) | |
745 | (if (viper-has-face-support-p) | |
6c2e12f4 | 746 | (progn |
8626cfa2 MK |
747 | (viper-overlay-put |
748 | viper-minibuffer-overlay 'face viper-minibuffer-current-face) | |
749 | (viper-overlay-put | |
750 | viper-minibuffer-overlay 'priority viper-minibuffer-overlay-priority) | |
03fc1246 | 751 | ;; never detach |
8626cfa2 MK |
752 | (viper-overlay-put |
753 | viper-minibuffer-overlay | |
754 | (if viper-emacs-p 'evaporate 'detachable) | |
755 | nil) | |
756 | ;; make viper-minibuffer-overlay open-ended | |
d3e1167f | 757 | ;; In emacs, it is made open ended at creation time |
8626cfa2 | 758 | (if viper-xemacs-p |
03fc1246 | 759 | (progn |
8626cfa2 MK |
760 | (viper-overlay-put viper-minibuffer-overlay 'start-open nil) |
761 | (viper-overlay-put viper-minibuffer-overlay 'end-open nil))) | |
d3e1167f | 762 | ))) |
6c2e12f4 | 763 | |
8626cfa2 MK |
764 | (defun viper-check-minibuffer-overlay () |
765 | (or (viper-overlay-p viper-minibuffer-overlay) | |
766 | (setq viper-minibuffer-overlay | |
767 | (if viper-xemacs-p | |
768 | (viper-make-overlay 1 (1+ (buffer-size)) (current-buffer)) | |
03fc1246 | 769 | ;; make overlay open-ended |
8626cfa2 | 770 | (viper-make-overlay |
03fc1246 | 771 | 1 (1+ (buffer-size)) (current-buffer) nil 'rear-advance))) |
d3e1167f MK |
772 | )) |
773 | ||
6c2e12f4 | 774 | |
8626cfa2 | 775 | (defsubst viper-is-in-minibuffer () |
2eb4bdca MK |
776 | (save-match-data |
777 | (string-match "\*Minibuf-" (buffer-name)))) | |
6c2e12f4 KH |
778 | |
779 | ||
780 | \f | |
781 | ;;; XEmacs compatibility | |
ae37fce9 | 782 | |
8626cfa2 MK |
783 | (defun viper-abbreviate-file-name (file) |
784 | (if viper-emacs-p | |
ae37fce9 MK |
785 | (abbreviate-file-name file) |
786 | ;; XEmacs requires addl argument | |
787 | (abbreviate-file-name file t))) | |
6c2e12f4 | 788 | |
dd7c19d4 | 789 | ;; Sit for VAL milliseconds. XEmacs doesn't support the millisecond arg |
75551c46 | 790 | ;; in sit-for, so this function smoothes out the differences. |
8626cfa2 MK |
791 | (defsubst viper-sit-for-short (val &optional nodisp) |
792 | (if viper-xemacs-p | |
6c2e12f4 KH |
793 | (sit-for (/ val 1000.0) nodisp) |
794 | (sit-for 0 val nodisp))) | |
795 | ||
796 | ;; EVENT may be a single event of a sequence of events | |
8626cfa2 | 797 | (defsubst viper-ESC-event-p (event) |
6c2e12f4 | 798 | (let ((ESC-keys '(?\e (control \[) escape)) |
8626cfa2 | 799 | (key (viper-event-key event))) |
6c2e12f4 | 800 | (member key ESC-keys))) |
9b70a748 MK |
801 | |
802 | ;; checks if object is a marker, has a buffer, and points to within that buffer | |
8626cfa2 | 803 | (defun viper-valid-marker (marker) |
9b70a748 MK |
804 | (if (and (markerp marker) (marker-buffer marker)) |
805 | (let ((buf (marker-buffer marker)) | |
806 | (pos (marker-position marker))) | |
807 | (save-excursion | |
808 | (set-buffer buf) | |
809 | (and (<= pos (point-max)) (<= (point-min) pos)))))) | |
6c2e12f4 | 810 | |
8626cfa2 MK |
811 | (defsubst viper-mark-marker () |
812 | (if viper-xemacs-p | |
6c2e12f4 KH |
813 | (mark-marker t) |
814 | (mark-marker))) | |
03fc1246 MK |
815 | |
816 | ;; like (set-mark-command nil) but doesn't push twice, if (car mark-ring) | |
817 | ;; is the same as (mark t). | |
8626cfa2 MK |
818 | (defsubst viper-set-mark-if-necessary () |
819 | (setq mark-ring (delete (viper-mark-marker) mark-ring)) | |
03fc1246 | 820 | (set-mark-command nil)) |
6c2e12f4 KH |
821 | |
822 | ;; In transient mark mode (zmacs mode), it is annoying when regions become | |
823 | ;; highlighted due to Viper's pushing marks. So, we deactivate marks, unless | |
824 | ;; the user explicitly wants highlighting, e.g., by hitting '' or `` | |
8626cfa2 MK |
825 | (defun viper-deactivate-mark () |
826 | (if viper-xemacs-p | |
6c2e12f4 KH |
827 | (zmacs-deactivate-region) |
828 | (deactivate-mark))) | |
829 | ||
8626cfa2 MK |
830 | (defsubst viper-leave-region-active () |
831 | (if viper-xemacs-p | |
dd7c19d4 MK |
832 | (setq zmacs-region-stays t))) |
833 | ||
9b70a748 MK |
834 | ;; Check if arg is a valid character for register |
835 | ;; TYPE is a list that can contain `letter', `Letter', and `digit'. | |
836 | ;; Letter means lowercase letters, Letter means uppercase letters, and | |
837 | ;; digit means digits from 1 to 9. | |
838 | ;; If TYPE is nil, then down/uppercase letters and digits are allowed. | |
8626cfa2 | 839 | (defun viper-valid-register (reg &optional type) |
9b70a748 MK |
840 | (or type (setq type '(letter Letter digit))) |
841 | (or (if (memq 'letter type) | |
842 | (and (<= ?a reg) (<= reg ?z))) | |
843 | (if (memq 'digit type) | |
844 | (and (<= ?1 reg) (<= reg ?9))) | |
845 | (if (memq 'Letter type) | |
846 | (and (<= ?A reg) (<= reg ?Z))) | |
847 | )) | |
848 | ||
6c2e12f4 | 849 | |
8626cfa2 MK |
850 | (defsubst viper-events-to-keys (events) |
851 | (cond (viper-xemacs-p (events-to-keys events)) | |
6c2e12f4 KH |
852 | (t events))) |
853 | ||
6c2e12f4 | 854 | |
9b70a748 MK |
855 | ;; it is suggested that an event must be copied before it is assigned to |
856 | ;; last-command-event in XEmacs | |
8626cfa2 MK |
857 | (defun viper-copy-event (event) |
858 | (if viper-xemacs-p | |
9b70a748 MK |
859 | (copy-event event) |
860 | event)) | |
6c2e12f4 KH |
861 | |
862 | ;; like read-event, but in XEmacs also try to convert to char, if possible | |
8626cfa2 | 863 | (defun viper-read-event-convert-to-char () |
6c2e12f4 | 864 | (let (event) |
8626cfa2 | 865 | (if viper-emacs-p |
6c2e12f4 KH |
866 | (read-event) |
867 | (setq event (next-command-event)) | |
868 | (or (event-to-character event) | |
869 | event)) | |
870 | )) | |
871 | ||
4702a420 | 872 | ;; This function lets function-key-map convert key sequences into logical |
8626cfa2 | 873 | ;; keys. This does a better job than viper-read-event when it comes to kbd |
20626291 MK |
874 | ;; macros, since it enables certain macros to be shared between X and TTY modes |
875 | ;; by correctly mapping key sequences for Left/Right/... (one an ascii | |
876 | ;; terminal) into logical keys left, right, etc. | |
8626cfa2 MK |
877 | (defun viper-read-key () |
878 | (let ((overriding-local-map viper-overriding-map) | |
20626291 | 879 | (inhibit-quit t) |
41497c90 | 880 | help-char key) |
8626cfa2 | 881 | (use-global-map viper-overriding-map) |
41497c90 MK |
882 | (unwind-protect |
883 | (setq key (elt (read-key-sequence nil) 0)) | |
884 | (use-global-map global-map)) | |
20626291 | 885 | key)) |
4702a420 | 886 | |
6c2e12f4 | 887 | |
75551c46 | 888 | ;; Emacs has a bug in eventp, which causes (eventp nil) to return (nil) |
f8169b5e | 889 | ;; instead of nil, if '(nil) was previously inadvertently assigned to |
6c2e12f4 | 890 | ;; unread-command-events |
8626cfa2 | 891 | (defun viper-event-key (event) |
6c2e12f4 | 892 | (or (and event (eventp event)) |
8626cfa2 MK |
893 | (error "viper-event-key: Wrong type argument, eventp, %S" event)) |
894 | (when (cond (viper-xemacs-p (or (key-press-event-p event) | |
895 | (mouse-event-p event))) | |
9b70a748 MK |
896 | (t t)) |
897 | (let ((mod (event-modifiers event)) | |
898 | basis) | |
899 | (setq basis | |
900 | (cond | |
8626cfa2 | 901 | (viper-xemacs-p |
9b70a748 MK |
902 | (cond ((key-press-event-p event) |
903 | (event-key event)) | |
904 | ((button-event-p event) | |
905 | (concat "mouse-" (prin1-to-string (event-button event)))) | |
906 | (t | |
8626cfa2 | 907 | (error "viper-event-key: Unknown event, %S" event)))) |
9b70a748 MK |
908 | (t |
909 | ;; Emacs doesn't handle capital letters correctly, since | |
910 | ;; \S-a isn't considered the same as A (it behaves as | |
911 | ;; plain `a' instead). So we take care of this here | |
8626cfa2 | 912 | (cond ((and (viper-characterp event) (<= ?A event) (<= event ?Z)) |
9b70a748 MK |
913 | (setq mod nil |
914 | event event)) | |
915 | ;; Emacs has the oddity whereby characters 128+char | |
916 | ;; represent M-char *if* this appears inside a string. | |
917 | ;; So, we convert them manually to (meta char). | |
8626cfa2 | 918 | ((and (viper-characterp event) |
9b70a748 MK |
919 | (< ?\C-? event) (<= event 255)) |
920 | (setq mod '(meta) | |
921 | event (- event ?\C-? 1))) | |
8626cfa2 MK |
922 | ((and (null mod) (eq event 'return)) |
923 | (setq event ?\C-m)) | |
924 | ((and (null mod) (eq event 'space)) | |
925 | (setq event ?\ )) | |
926 | ((and (null mod) (eq event 'delete)) | |
927 | (setq event ?\C-?)) | |
928 | ((and (null mod) (eq event 'backspace)) | |
929 | (setq event ?\C-h)) | |
9b70a748 MK |
930 | (t (event-basic-type event))) |
931 | ))) | |
8626cfa2 | 932 | (if (viper-characterp basis) |
9b70a748 MK |
933 | (setq basis |
934 | (if (= basis ?\C-?) | |
935 | (list 'control '\?) ; taking care of an emacs bug | |
936 | (intern (char-to-string basis))))) | |
937 | (if mod | |
938 | (append mod (list basis)) | |
939 | basis)))) | |
6c2e12f4 | 940 | |
8626cfa2 | 941 | (defun viper-key-to-emacs-key (key) |
6c2e12f4 | 942 | (let (key-name char-p modifiers mod-char-list base-key base-key-name) |
8626cfa2 | 943 | (cond (viper-xemacs-p key) |
1e70790f | 944 | |
6c2e12f4 KH |
945 | ((symbolp key) |
946 | (setq key-name (symbol-name key)) | |
1e70790f MK |
947 | (cond ((= (length key-name) 1) ; character event |
948 | (string-to-char key-name)) | |
949 | ;; Emacs doesn't recognize `return' and `escape' as events on | |
950 | ;; dumb terminals, so we translate them into characters | |
8626cfa2 | 951 | ((and viper-emacs-p (not (viper-window-display-p)) |
1e70790f MK |
952 | (string= key-name "return")) |
953 | ?\C-m) | |
8626cfa2 | 954 | ((and viper-emacs-p (not (viper-window-display-p)) |
1e70790f MK |
955 | (string= key-name "escape")) |
956 | ?\e) | |
957 | ;; pass symbol-event as is | |
958 | (t key))) | |
959 | ||
6c2e12f4 KH |
960 | ((listp key) |
961 | (setq modifiers (subseq key 0 (1- (length key))) | |
8626cfa2 | 962 | base-key (viper-seq-last-elt key) |
6c2e12f4 KH |
963 | base-key-name (symbol-name base-key) |
964 | char-p (= (length base-key-name) 1)) | |
965 | (setq mod-char-list | |
966 | (mapcar | |
967 | '(lambda (elt) (upcase (substring (symbol-name elt) 0 1))) | |
968 | modifiers)) | |
969 | (if char-p | |
970 | (setq key-name | |
971 | (car (read-from-string | |
972 | (concat | |
973 | "?\\" | |
974 | (mapconcat 'identity mod-char-list "-\\") | |
975 | "-" | |
976 | base-key-name)))) | |
977 | (setq key-name | |
978 | (intern | |
979 | (concat | |
980 | (mapconcat 'identity mod-char-list "-") | |
981 | "-" | |
982 | base-key-name)))))) | |
983 | )) | |
984 | ||
985 | ||
986 | ;; Args can be a sequence of events, a string, or a Viper macro. Will try to | |
987 | ;; convert events to keys and, if all keys are regular printable | |
988 | ;; characters, will return a string. Otherwise, will return a string | |
989 | ;; representing a vector of converted events. If the input was a Viper macro, | |
990 | ;; will return a string that represents this macro as a vector. | |
8626cfa2 | 991 | (defun viper-array-to-string (event-seq) |
bbe6126c | 992 | (let (temp temp2) |
6c2e12f4 | 993 | (cond ((stringp event-seq) event-seq) |
8626cfa2 MK |
994 | ((viper-event-vector-p event-seq) |
995 | (setq temp (mapcar 'viper-event-key event-seq)) | |
996 | (cond ((viper-char-symbol-sequence-p temp) | |
bbe6126c | 997 | (mapconcat 'symbol-name temp "")) |
8626cfa2 MK |
998 | ((and (viper-char-array-p |
999 | (setq temp2 (mapcar 'viper-key-to-character temp)))) | |
bbe6126c MK |
1000 | (mapconcat 'char-to-string temp2 "")) |
1001 | (t (prin1-to-string (vconcat temp))))) | |
8626cfa2 | 1002 | ((viper-char-symbol-sequence-p event-seq) |
6c2e12f4 | 1003 | (mapconcat 'symbol-name event-seq "")) |
bbe6126c | 1004 | ((and (vectorp event-seq) |
8626cfa2 MK |
1005 | (viper-char-array-p |
1006 | (setq temp (mapcar 'viper-key-to-character event-seq)))) | |
bbe6126c | 1007 | (mapconcat 'char-to-string temp "")) |
6c2e12f4 | 1008 | (t (prin1-to-string event-seq))))) |
e0c82342 | 1009 | |
8626cfa2 MK |
1010 | (defun viper-key-press-events-to-chars (events) |
1011 | (mapconcat (if viper-emacs-p | |
e0c82342 MK |
1012 | 'char-to-string |
1013 | (function | |
1014 | (lambda (elt) (char-to-string (event-to-character elt))))) | |
1015 | events | |
1016 | "")) | |
6c2e12f4 KH |
1017 | |
1018 | ||
1e70790f | 1019 | ;; Uses different timeouts for ESC-sequences and others |
8626cfa2 MK |
1020 | (defsubst viper-fast-keysequence-p () |
1021 | (not (viper-sit-for-short | |
1022 | (if (viper-ESC-event-p last-input-event) | |
1023 | viper-ESC-keyseq-timeout | |
1024 | viper-fast-keyseq-timeout) | |
1e70790f | 1025 | t))) |
6c2e12f4 | 1026 | |
8626cfa2 | 1027 | (defun viper-read-char-exclusive () |
6c2e12f4 KH |
1028 | (let (char |
1029 | (echo-keystrokes 1)) | |
1030 | (while (null char) | |
1031 | (condition-case nil | |
1032 | (setq char (read-char)) | |
1033 | (error | |
1034 | ;; skip event if not char | |
8626cfa2 | 1035 | (viper-read-event)))) |
6c2e12f4 KH |
1036 | char)) |
1037 | ||
bbe6126c MK |
1038 | ;; key is supposed to be in viper's representation, e.g., (control l), a |
1039 | ;; character, etc. | |
8626cfa2 | 1040 | (defun viper-key-to-character (key) |
bbe6126c MK |
1041 | (cond ((eq key 'space) ?\ ) |
1042 | ((eq key 'delete) ?\C-?) | |
8626cfa2 | 1043 | ((eq key 'return) ?\C-m) |
bbe6126c MK |
1044 | ((eq key 'backspace) ?\C-h) |
1045 | ((and (symbolp key) | |
1046 | (= 1 (length (symbol-name key)))) | |
1047 | (string-to-char (symbol-name key))) | |
1048 | ((and (listp key) | |
1049 | (eq (car key) 'control) | |
1050 | (symbol-name (nth 1 key)) | |
1051 | (= 1 (length (symbol-name (nth 1 key))))) | |
1052 | (read (format "?\\C-%s" (symbol-name (nth 1 key))))) | |
1053 | (t key))) | |
6c2e12f4 KH |
1054 | |
1055 | ||
8626cfa2 | 1056 | (defun viper-setup-master-buffer (&rest other-files-or-buffers) |
6c2e12f4 KH |
1057 | "Set up the current buffer as a master buffer. |
1058 | Arguments become related buffers. This function should normally be used in | |
1059 | the `Local variables' section of a file." | |
8626cfa2 | 1060 | (setq viper-related-files-and-buffers-ring |
6c2e12f4 KH |
1061 | (make-ring (1+ (length other-files-or-buffers)))) |
1062 | (mapcar '(lambda (elt) | |
8626cfa2 | 1063 | (viper-ring-insert viper-related-files-and-buffers-ring elt)) |
6c2e12f4 | 1064 | other-files-or-buffers) |
8626cfa2 | 1065 | (viper-ring-insert viper-related-files-and-buffers-ring (buffer-name)) |
6c2e12f4 | 1066 | ) |
e0c82342 MK |
1067 | |
1068 | ;;; Movement utilities | |
1069 | ||
34317da2 MK |
1070 | ;; Characters that should not be considered as part of the word, in reformed-vi |
1071 | ;; syntax mode. | |
1072 | (defconst viper-non-word-characters-reformed-vi | |
1073 | "!@#$%^&*()-+=|\\~`{}[];:'\",<.>/?") | |
1074 | ;; These are characters that are not to be considered as parts of a word in | |
1075 | ;; Viper. | |
1076 | ;; Set each time state changes and at loading time | |
1077 | (viper-deflocalvar viper-non-word-characters nil) | |
e0c82342 | 1078 | |
34317da2 | 1079 | ;; must be buffer-local |
8626cfa2 | 1080 | (viper-deflocalvar viper-ALPHA-char-class "w" |
e0c82342 MK |
1081 | "String of syntax classes characterizing Viper's alphanumeric symbols. |
1082 | In addition, the symbol `_' may be considered alphanumeric if | |
34317da2 | 1083 | `viper-syntax-preference' is `strict-vi' or `reformed-vi'.") |
e0c82342 | 1084 | |
34317da2 MK |
1085 | (defconst viper-strict-ALPHA-chars "a-zA-Z0-9_" |
1086 | "Regexp matching the set of alphanumeric characters acceptable to strict | |
1087 | Vi.") | |
1088 | (defconst viper-strict-SEP-chars " \t\n" | |
e0c82342 MK |
1089 | "Regexp matching the set of alphanumeric characters acceptable to strict |
1090 | Vi.") | |
34317da2 | 1091 | (defconst viper-strict-SEP-chars-sans-newline " \t" |
e0c82342 MK |
1092 | "Regexp matching the set of alphanumeric characters acceptable to strict |
1093 | Vi.") | |
1094 | ||
34317da2 | 1095 | (defconst viper-SEP-char-class " -" |
e0c82342 MK |
1096 | "String of syntax classes for Vi separators. |
1097 | Usually contains ` ', linefeed, TAB or formfeed.") | |
1098 | ||
34317da2 MK |
1099 | |
1100 | ;; Set Viper syntax classes and related variables according to | |
1101 | ;; `viper-syntax-preference'. | |
1102 | (defun viper-update-syntax-classes (&optional set-default) | |
1103 | (let ((preference (cond ((eq viper-syntax-preference 'emacs) | |
1104 | "w") ; Viper words have only Emacs word chars | |
1105 | ((eq viper-syntax-preference 'extended) | |
1106 | "w_") ; Viper words have Emacs word & symbol chars | |
1107 | (t "w"))) ; Viper words are Emacs words plus `_' | |
1108 | (non-word-chars (cond ((eq viper-syntax-preference 'reformed-vi) | |
1109 | (viper-string-to-list | |
1110 | viper-non-word-characters-reformed-vi)) | |
1111 | (t nil)))) | |
1112 | (if set-default | |
1113 | (setq-default viper-ALPHA-char-class preference | |
1114 | viper-non-word-characters non-word-chars) | |
1115 | (setq viper-ALPHA-char-class preference | |
1116 | viper-non-word-characters non-word-chars)) | |
1117 | )) | |
1118 | ||
1119 | ;; SYMBOL is used because customize requires it, but it is ignored, unless it | |
1120 | ;; is `nil'. If nil, use setq. | |
1121 | (defun viper-set-syntax-preference (&optional symbol value) | |
1122 | "Set Viper syntax preference. | |
1123 | If called interactively or if SYMBOL is nil, sets syntax preference in current | |
1124 | buffer. If called non-interactively, preferably via the customization widget, | |
1125 | sets the default value." | |
e0c82342 | 1126 | (interactive) |
34317da2 MK |
1127 | (or value |
1128 | (setq value | |
1129 | (completing-read | |
1130 | "Viper syntax preference: " | |
1131 | '(("strict-vi") ("reformed-vi") ("extended") ("emacs")) | |
1132 | nil 'require-match))) | |
1133 | (if (stringp value) (setq value (intern value))) | |
1134 | (or (memq value '(strict-vi reformed-vi extended emacs)) | |
1135 | (error "Invalid Viper syntax preference, %S" value)) | |
1136 | (if symbol | |
1137 | (setq-default viper-syntax-preference value) | |
1138 | (setq viper-syntax-preference value)) | |
1139 | (viper-update-syntax-classes)) | |
1140 | ||
1141 | (defcustom viper-syntax-preference 'reformed-vi | |
1142 | "*Syntax type characterizing Viper's alphanumeric symbols. | |
1143 | Affects movement and change commands that deal with Vi-style words. | |
1144 | Works best when set in the hooks to various major modes. | |
1145 | ||
1146 | `strict-vi' means Viper words are (hopefully) exactly as in Vi. | |
1147 | ||
1148 | `reformed-vi' means Viper words are like Emacs words \(as determined using | |
1149 | Emacs syntax tables, which are different for different major modes\) with two | |
1150 | exceptions: the symbol `_' is always part of a word and typical Vi non-word | |
1151 | symbols, such as `,',:,\",),{, etc., are excluded. | |
1152 | This behaves very close to `strict-vi', but also works well with non-ASCII | |
1153 | characters from various alphabets. | |
1154 | ||
1155 | `extended' means Viper word constituents are symbols that are marked as being | |
1156 | parts of words OR symbols in Emacs syntax tables. | |
1157 | This is most appropriate for major modes intended for editing programs. | |
1158 | ||
1159 | `emacs' means Viper words are the same as Emacs words as specified by Emacs | |
1160 | syntax tables. | |
1161 | This option is appropriate if you like Emacs-style words." | |
1162 | :type '(radio (const strict-vi) (const reformed-vi) | |
1163 | (const extended) (const emacs)) | |
1164 | :set 'viper-set-syntax-preference | |
1165 | :group 'viper) | |
1166 | (make-variable-buffer-local 'viper-syntax-preference) | |
1167 | ||
e0c82342 MK |
1168 | |
1169 | ;; addl-chars are characters to be temporarily considered as alphanumerical | |
8626cfa2 | 1170 | (defun viper-looking-at-alpha (&optional addl-chars) |
e0c82342 | 1171 | (or (stringp addl-chars) (setq addl-chars "")) |
8626cfa2 | 1172 | (if (eq viper-syntax-preference 'reformed-vi) |
e0c82342 MK |
1173 | (setq addl-chars (concat addl-chars "_"))) |
1174 | (let ((char (char-after (point)))) | |
1175 | (if char | |
8626cfa2 MK |
1176 | (if (eq viper-syntax-preference 'strict-vi) |
1177 | (looking-at (concat "[" viper-strict-ALPHA-chars addl-chars "]")) | |
34317da2 MK |
1178 | (or |
1179 | ;; or one of the additional chars being asked to include | |
1180 | (memq char (viper-string-to-list addl-chars)) | |
1181 | (and | |
1182 | ;; not one of the excluded word chars | |
1183 | (not (memq char viper-non-word-characters)) | |
1184 | ;; char of the Viper-word syntax class | |
1185 | (memq (char-syntax char) | |
1186 | (viper-string-to-list viper-ALPHA-char-class)))))) | |
e0c82342 MK |
1187 | )) |
1188 | ||
8626cfa2 | 1189 | (defun viper-looking-at-separator () |
e0c82342 MK |
1190 | (let ((char (char-after (point)))) |
1191 | (if char | |
34317da2 MK |
1192 | (if (eq viper-syntax-preference 'strict-vi) |
1193 | (memq char (viper-string-to-list viper-strict-SEP-chars)) | |
1194 | (or (eq char ?\n) ; RET is always a separator in Vi | |
1195 | (memq (char-syntax char) | |
1196 | (viper-string-to-list viper-SEP-char-class))))) | |
1197 | )) | |
e0c82342 | 1198 | |
8626cfa2 MK |
1199 | (defsubst viper-looking-at-alphasep (&optional addl-chars) |
1200 | (or (viper-looking-at-separator) (viper-looking-at-alpha addl-chars))) | |
e0c82342 | 1201 | |
8626cfa2 | 1202 | (defun viper-skip-alpha-forward (&optional addl-chars) |
e0c82342 | 1203 | (or (stringp addl-chars) (setq addl-chars "")) |
8626cfa2 | 1204 | (viper-skip-syntax |
e0c82342 | 1205 | 'forward |
8626cfa2 | 1206 | (cond ((eq viper-syntax-preference 'strict-vi) |
e0c82342 | 1207 | "") |
985d0dad | 1208 | (t viper-ALPHA-char-class)) |
8626cfa2 MK |
1209 | (cond ((eq viper-syntax-preference 'strict-vi) |
1210 | (concat viper-strict-ALPHA-chars addl-chars)) | |
e0c82342 MK |
1211 | (t addl-chars)))) |
1212 | ||
8626cfa2 | 1213 | (defun viper-skip-alpha-backward (&optional addl-chars) |
e0c82342 | 1214 | (or (stringp addl-chars) (setq addl-chars "")) |
8626cfa2 | 1215 | (viper-skip-syntax |
e0c82342 | 1216 | 'backward |
8626cfa2 | 1217 | (cond ((eq viper-syntax-preference 'strict-vi) |
e0c82342 | 1218 | "") |
985d0dad | 1219 | (t viper-ALPHA-char-class)) |
8626cfa2 MK |
1220 | (cond ((eq viper-syntax-preference 'strict-vi) |
1221 | (concat viper-strict-ALPHA-chars addl-chars)) | |
e0c82342 MK |
1222 | (t addl-chars)))) |
1223 | ||
1224 | ;; weird syntax tables may confuse strict-vi style | |
8626cfa2 | 1225 | (defsubst viper-skip-all-separators-forward (&optional within-line) |
34317da2 MK |
1226 | (if (eq viper-syntax-preference 'strict-vi) |
1227 | (if within-line | |
1228 | (skip-chars-forward viper-strict-SEP-chars-sans-newline) | |
1229 | (skip-chars-forward viper-strict-SEP-chars)) | |
1230 | (viper-skip-syntax 'forward | |
1231 | viper-SEP-char-class | |
1232 | (or within-line "\n") | |
1233 | (if within-line (viper-line-pos 'end))))) | |
8626cfa2 | 1234 | (defsubst viper-skip-all-separators-backward (&optional within-line) |
34317da2 MK |
1235 | (if (eq viper-syntax-preference 'strict-vi) |
1236 | (if within-line | |
1237 | (skip-chars-backward viper-strict-SEP-chars-sans-newline) | |
1238 | (skip-chars-backward viper-strict-SEP-chars)) | |
1239 | (viper-skip-syntax 'backward | |
1240 | viper-SEP-char-class | |
1241 | (or within-line "\n") | |
1242 | (if within-line (viper-line-pos 'start))))) | |
8626cfa2 | 1243 | (defun viper-skip-nonseparators (direction) |
34317da2 MK |
1244 | (viper-skip-syntax |
1245 | direction | |
1246 | (concat "^" viper-SEP-char-class) | |
1247 | nil | |
1248 | (viper-line-pos (if (eq direction 'forward) 'end 'start)))) | |
1249 | ||
e0c82342 | 1250 | |
34317da2 | 1251 | ;; skip over non-word constituents and non-separators |
8626cfa2 MK |
1252 | (defun viper-skip-nonalphasep-forward () |
1253 | (if (eq viper-syntax-preference 'strict-vi) | |
e0c82342 | 1254 | (skip-chars-forward |
8626cfa2 | 1255 | (concat "^" viper-strict-SEP-chars viper-strict-ALPHA-chars)) |
34317da2 MK |
1256 | (viper-skip-syntax |
1257 | 'forward | |
1258 | (concat "^" viper-ALPHA-char-class viper-SEP-char-class) | |
1259 | ;; Emacs may consider some of these as words, but we don't want them | |
1260 | viper-non-word-characters | |
1261 | (viper-line-pos 'end)))) | |
8626cfa2 MK |
1262 | (defun viper-skip-nonalphasep-backward () |
1263 | (if (eq viper-syntax-preference 'strict-vi) | |
e0c82342 | 1264 | (skip-chars-backward |
8626cfa2 | 1265 | (concat "^" viper-strict-SEP-chars viper-strict-ALPHA-chars)) |
34317da2 MK |
1266 | (viper-skip-syntax |
1267 | 'backward | |
1268 | (concat "^" viper-ALPHA-char-class viper-SEP-char-class) | |
1269 | ;; Emacs may consider some of these as words, but we don't want them | |
1270 | viper-non-word-characters | |
8626cfa2 | 1271 | (viper-line-pos 'start)))) |
e0c82342 MK |
1272 | |
1273 | ;; Skip SYNTAX like skip-syntax-* and ADDL-CHARS like skip-chars-* | |
1274 | ;; Return the number of chars traveled. | |
34317da2 MK |
1275 | ;; Both SYNTAX or ADDL-CHARS can be strings or lists of characters. |
1276 | ;; When SYNTAX is "w", then viper-non-word-characters are not considered to be | |
1277 | ;; words, even if Emacs syntax table says they are. | |
8626cfa2 | 1278 | (defun viper-skip-syntax (direction syntax addl-chars &optional limit) |
e0c82342 MK |
1279 | (let ((total 0) |
1280 | (local 1) | |
34317da2 MK |
1281 | (skip-chars-func |
1282 | (if (eq direction 'forward) | |
1283 | 'skip-chars-forward 'skip-chars-backward)) | |
1284 | (skip-syntax-func | |
1285 | (if (eq direction 'forward) | |
1286 | 'viper-forward-char-carefully 'viper-backward-char-carefully)) | |
1287 | char-looked-at syntax-of-char-looked-at negated-syntax) | |
1288 | (setq addl-chars | |
1289 | (cond ((listp addl-chars) (viper-charlist-to-string addl-chars)) | |
1290 | ((stringp addl-chars) addl-chars) | |
1291 | (t ""))) | |
1292 | (setq syntax | |
1293 | (cond ((listp syntax) syntax) | |
1294 | ((stringp syntax) (viper-string-to-list syntax)) | |
1295 | (t nil))) | |
1296 | (if (memq ?^ syntax) (setq negated-syntax t)) | |
1297 | ||
63b98362 KH |
1298 | (while (and (not (= local 0)) |
1299 | (cond ((eq direction 'forward) | |
1300 | (not (eobp))) | |
1301 | (t (not (bobp))))) | |
34317da2 MK |
1302 | (setq char-looked-at (viper-char-at-pos direction) |
1303 | ;; if outside the range, set to nil | |
1304 | syntax-of-char-looked-at (if char-looked-at | |
1305 | (char-syntax char-looked-at))) | |
e0c82342 | 1306 | (setq local |
34317da2 MK |
1307 | (+ (if (and |
1308 | (cond ((and limit (eq direction 'forward)) | |
1309 | (< (point) limit)) | |
1310 | (limit ; backward & limit | |
1311 | (> (point) limit)) | |
1312 | (t t)) ; no limit | |
1313 | ;; char under/before cursor has appropriate syntax | |
1314 | (if negated-syntax | |
1315 | (not (memq syntax-of-char-looked-at syntax)) | |
1316 | (memq syntax-of-char-looked-at syntax)) | |
1317 | ;; if char-syntax class is "word", make sure it is not one | |
1318 | ;; of the excluded characters | |
1319 | (if (and (eq syntax-of-char-looked-at ?w) | |
1320 | (not negated-syntax)) | |
1321 | (not (memq char-looked-at viper-non-word-characters)) | |
1322 | t)) | |
1323 | (funcall skip-syntax-func 1) | |
1324 | 0) | |
e0c82342 MK |
1325 | (funcall skip-chars-func addl-chars limit))) |
1326 | (setq total (+ total local))) | |
1327 | total | |
1328 | )) | |
1329 | ||
1330 | ||
6c2e12f4 | 1331 | |
6c2e12f4 | 1332 | (provide 'viper-util) |
1e70790f MK |
1333 | |
1334 | ||
1335 | ;;; Local Variables: | |
8626cfa2 | 1336 | ;;; eval: (put 'viper-deflocalvar 'lisp-indent-hook 'defun) |
1e70790f | 1337 | ;;; End: |
6c2e12f4 KH |
1338 | |
1339 | ;;; viper-util.el ends here |