Mercurial > emacs
comparison lisp/calc/macedit.el @ 40785:2fb9d407ae73
Initial import of Calc 2.02f.
author | Eli Zaretskii <eliz@gnu.org> |
---|---|
date | Tue, 06 Nov 2001 18:59:06 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
40784:d57f74c55909 | 40785:2fb9d407ae73 |
---|---|
1 ;; Keyboard macro editor for GNU Emacs. Version 1.05. | |
2 ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. | |
3 ;; Written by Dave Gillespie, daveg@synaptics.com. | |
4 | |
5 ;; This file is part of GNU Emacs. | |
6 | |
7 ;; GNU Emacs is distributed in the hope that it will be useful, | |
8 ;; but WITHOUT ANY WARRANTY. No author or distributor | |
9 ;; accepts responsibility to anyone for the consequences of using it | |
10 ;; or for whether it serves any particular purpose or works at all, | |
11 ;; unless he says so in writing. Refer to the GNU Emacs General Public | |
12 ;; License for full details. | |
13 | |
14 ;; Everyone is granted permission to copy, modify and redistribute | |
15 ;; GNU Emacs, but only under the conditions described in the | |
16 ;; GNU Emacs General Public License. A copy of this license is | |
17 ;; supposed to have been given to you along with GNU Emacs so you | |
18 ;; can know your rights and responsibilities. It should be in a | |
19 ;; file named COPYING. Among other things, the copyright notice | |
20 ;; and this notice must be preserved on all copies. | |
21 | |
22 ;; Installation: | |
23 ;; (autoload 'edit-kbd-macro "macedit" "Edit a named keyboard macro" t) | |
24 ;; (autoload 'edit-last-kbd-macro "macedit" "Edit a keyboard macro" t) | |
25 ;; (autoload 'read-kbd-macro "macedit" "Parse region as keyboard macro" t) | |
26 | |
27 | |
28 | |
29 ;; To use, type `M-x edit-last-kbd-macro' to edit the most recently | |
30 ;; defined keyboard macro. If you have used `M-x name-last-kbd-macro' | |
31 ;; to give a keyboard macro a name, type `M-x edit-kbd-macro' to edit | |
32 ;; the macro by name. When you are done editing, type `C-c C-c' to | |
33 ;; record your changes back into the original keyboard macro. | |
34 | |
35 | |
36 | |
37 | |
38 ;;; The user-level commands for editing macros. | |
39 | |
40 ;;;###autoload | |
41 (defun edit-last-kbd-macro (&optional prefix buffer hook) | |
42 "Edit the most recently defined keyboard macro." | |
43 (interactive "P") | |
44 (MacEdit-edit-macro last-kbd-macro | |
45 (function (lambda (x arg) (setq last-kbd-macro x))) | |
46 prefix buffer hook) | |
47 ) | |
48 | |
49 ;;;###autoload | |
50 (defun edit-kbd-macro (cmd &optional prefix buffer hook in-hook out-hook) | |
51 "Edit a keyboard macro which has been assigned a name by name-last-kbd-macro. | |
52 \(See also edit-last-kbd-macro.)" | |
53 (interactive "CCommand name: \nP") | |
54 (and cmd | |
55 (MacEdit-edit-macro (if in-hook | |
56 (funcall in-hook cmd) | |
57 (symbol-function cmd)) | |
58 (or out-hook | |
59 (list 'lambda '(x arg) | |
60 (list 'fset | |
61 (list 'quote cmd) | |
62 'x))) | |
63 prefix buffer hook cmd)) | |
64 ) | |
65 | |
66 ;;;###autoload | |
67 (defun read-kbd-macro (start &optional end) | |
68 "Read the region as a keyboard macro definition. | |
69 The region is interpreted as spelled-out keystrokes, e.g., `M-x abc RET'. | |
70 The resulting macro is installed as the \"current\" keyboard macro. | |
71 | |
72 Symbols: RET, SPC, TAB, DEL, LFD, NUL; C-key; M-key. (Must be uppercase.) | |
73 REM marks the rest of a line as a comment. | |
74 Whitespace is ignored; other characters are copied into the macro." | |
75 (interactive "r") | |
76 (if (stringp start) | |
77 (setq last-kbd-macro (MacEdit-parse-keys start)) | |
78 (setq last-kbd-macro (MacEdit-parse-keys (buffer-substring start end))) | |
79 (if (and (string-match "\\`\C-x(" last-kbd-macro) | |
80 (string-match "\C-x)\\'" last-kbd-macro)) | |
81 (setq last-kbd-macro (substring last-kbd-macro 2 -2)))) | |
82 ) | |
83 | |
84 | |
85 | |
86 | |
87 ;;; Formatting a keyboard macro as human-readable text. | |
88 | |
89 (defun MacEdit-print-macro (macro-str local-map) | |
90 (let ((save-map (current-local-map)) | |
91 (print-escape-newlines t) | |
92 key-symbol key-str key-last prefix-arg this-prefix) | |
93 (unwind-protect | |
94 (progn | |
95 (use-local-map local-map) | |
96 (while (MacEdit-peek-char) | |
97 (MacEdit-read-key) | |
98 (setq this-prefix prefix-arg) | |
99 (or (memq key-symbol '(digit-argument | |
100 negative-argument | |
101 universal-argument)) | |
102 (null prefix-arg) | |
103 (progn | |
104 (cond ((consp prefix-arg) | |
105 (insert (format "prefix-arg (%d)\n" | |
106 (car prefix-arg)))) | |
107 ((eq prefix-arg '-) | |
108 (insert "prefix-arg -\n")) | |
109 ((numberp prefix-arg) | |
110 (insert (format "prefix-arg %d\n" prefix-arg)))) | |
111 (setq prefix-arg nil))) | |
112 (cond ((null key-symbol) | |
113 (insert "type \"") | |
114 (MacEdit-insert-string macro-str) | |
115 (insert "\"\n") | |
116 (setq macro-str "")) | |
117 ((stringp key-symbol) ; key defined by another kbd macro | |
118 (insert "type \"") | |
119 (MacEdit-insert-string key-symbol) | |
120 (insert "\"\n")) | |
121 ((eq key-symbol 'digit-argument) | |
122 (MacEdit-prefix-arg key-last nil prefix-arg)) | |
123 ((eq key-symbol 'negative-argument) | |
124 (MacEdit-prefix-arg ?- nil prefix-arg)) | |
125 ((eq key-symbol 'universal-argument) | |
126 (let* ((c-u 4) (argstartchar key-last) | |
127 (char (MacEdit-read-char))) | |
128 (while (= char argstartchar) | |
129 (setq c-u (* 4 c-u) | |
130 char (MacEdit-read-char))) | |
131 (MacEdit-prefix-arg char c-u nil))) | |
132 ((eq key-symbol 'self-insert-command) | |
133 (insert "insert ") | |
134 (if (and (>= key-last 32) (<= key-last 126)) | |
135 (let ((str "")) | |
136 (while (or (and (eq key-symbol | |
137 'self-insert-command) | |
138 (< (length str) 60) | |
139 (>= key-last 32) | |
140 (<= key-last 126)) | |
141 (and (memq key-symbol | |
142 '(backward-delete-char | |
143 delete-backward-char | |
144 backward-delete-char-untabify)) | |
145 (> (length str) 0))) | |
146 (if (eq key-symbol 'self-insert-command) | |
147 (setq str (concat str | |
148 (char-to-string key-last))) | |
149 (setq str (substring str 0 -1))) | |
150 (MacEdit-read-key)) | |
151 (insert "\"" str "\"\n") | |
152 (MacEdit-unread-chars key-str)) | |
153 (insert "\"") | |
154 (MacEdit-insert-string (char-to-string key-last)) | |
155 (insert "\"\n"))) | |
156 ((and (eq key-symbol 'quoted-insert) | |
157 (MacEdit-peek-char)) | |
158 (insert "quoted-insert\n") | |
159 (let ((ch (MacEdit-read-char)) | |
160 ch2) | |
161 (if (and (>= ch ?0) (<= ch ?7)) | |
162 (progn | |
163 (setq ch (- ch ?0) | |
164 ch2 (MacEdit-read-char)) | |
165 (if ch2 | |
166 (if (and (>= ch2 ?0) (<= ch2 ?7)) | |
167 (progn | |
168 (setq ch (+ (* ch 8) (- ch2 ?0)) | |
169 ch2 (MacEdit-read-char)) | |
170 (if ch2 | |
171 (if (and (>= ch2 ?0) (<= ch2 ?7)) | |
172 (setq ch (+ (* ch 8) (- ch2 ?0))) | |
173 (MacEdit-unread-chars ch2)))) | |
174 (MacEdit-unread-chars ch2))))) | |
175 (if (or (and (>= ch ?0) (<= ch ?7)) | |
176 (< ch 32) (> ch 126)) | |
177 (insert (format "type \"\\%03o\"\n" ch)) | |
178 (insert "type \"" (char-to-string ch) "\"\n")))) | |
179 ((memq key-symbol '(isearch-forward | |
180 isearch-backward | |
181 isearch-forward-regexp | |
182 isearch-backward-regexp)) | |
183 (insert (symbol-name key-symbol) "\n") | |
184 (MacEdit-isearch-argument)) | |
185 ((eq key-symbol 'execute-extended-command) | |
186 (MacEdit-read-argument obarray 'commandp)) | |
187 (t | |
188 (let ((cust (get key-symbol 'MacEdit-print))) | |
189 (if cust | |
190 (funcall cust) | |
191 (insert (symbol-name key-symbol)) | |
192 (indent-to 30) | |
193 (insert " # ") | |
194 (MacEdit-insert-string key-str) | |
195 (insert "\n") | |
196 (let ((int (MacEdit-get-interactive key-symbol))) | |
197 (if (string-match "\\`\\*" int) | |
198 (setq int (substring int 1))) | |
199 (while (> (length int) 0) | |
200 (cond ((= (aref int 0) ?a) | |
201 (MacEdit-read-argument | |
202 obarray nil)) | |
203 ((memq (aref int 0) '(?b ?B ?D ?f ?F ?n | |
204 ?s ?S ?x ?X)) | |
205 (MacEdit-read-argument)) | |
206 ((and (= (aref int 0) ?c) | |
207 (MacEdit-peek-char)) | |
208 (insert "type \"") | |
209 (MacEdit-insert-string | |
210 (char-to-string | |
211 (MacEdit-read-char))) | |
212 (insert "\"\n")) | |
213 ((= (aref int 0) ?C) | |
214 (MacEdit-read-argument | |
215 obarray 'commandp)) | |
216 ((= (aref int 0) ?k) | |
217 (MacEdit-read-key) | |
218 (if key-symbol | |
219 (progn | |
220 (insert "type \"") | |
221 (MacEdit-insert-string key-str) | |
222 (insert "\"\n")) | |
223 (MacEdit-unread-chars key-str))) | |
224 ((= (aref int 0) ?N) | |
225 (or this-prefix | |
226 (MacEdit-read-argument))) | |
227 ((= (aref int 0) ?v) | |
228 (MacEdit-read-argument | |
229 obarray 'user-variable-p))) | |
230 (let ((nl (string-match "\n" int))) | |
231 (setq int (if nl | |
232 (substring int (1+ nl)) | |
233 ""))))))))))) | |
234 (use-local-map save-map))) | |
235 ) | |
236 | |
237 (defun MacEdit-prefix-arg (char c-u value) | |
238 (let ((sign 1)) | |
239 (if (and (numberp value) (< value 0)) | |
240 (setq sign -1 value (- value))) | |
241 (if (eq value '-) | |
242 (setq sign -1 value nil)) | |
243 (while (and char (= ?- char)) | |
244 (setq sign (- sign) c-u nil) | |
245 (setq char (MacEdit-read-char))) | |
246 (while (and char (>= char ?0) (<= char ?9)) | |
247 (setq value (+ (* (if (numberp value) value 0) 10) (- char ?0)) c-u nil) | |
248 (setq char (MacEdit-read-char))) | |
249 (setq prefix-arg | |
250 (cond (c-u (list c-u)) | |
251 ((numberp value) (* value sign)) | |
252 ((= sign -1) '-))) | |
253 (MacEdit-unread-chars char)) | |
254 ) | |
255 | |
256 (defun MacEdit-insert-string (str) | |
257 (let ((i 0) j ch) | |
258 (while (< i (length str)) | |
259 (if (and (> (setq ch (aref str i)) 127) | |
260 (< ch 160)) | |
261 (progn | |
262 (setq ch (- ch 128)) | |
263 (insert "\\M-"))) | |
264 (if (< ch 32) | |
265 (cond ((= ch 8) (insert "\\b")) | |
266 ((= ch 9) (insert "\\t")) | |
267 ((= ch 10) (insert "\\n")) | |
268 ((= ch 13) (insert "\\r")) | |
269 ((= ch 27) (insert "\\e")) | |
270 (t (insert "\\C-" (char-to-string (downcase (+ ch 64)))))) | |
271 (if (< ch 127) | |
272 (if (or (= ch 34) (= ch 92)) | |
273 (insert "\\" (char-to-string ch)) | |
274 (setq j i) | |
275 (while (and (< (setq i (1+ i)) (length str)) | |
276 (>= (setq ch (aref str i)) 32) | |
277 (/= ch 34) (/= ch 92) | |
278 (< ch 127))) | |
279 (insert (substring str j i)) | |
280 (setq i (1- i))) | |
281 (if (memq ch '(127 255)) | |
282 (insert (format "\\%03o" ch)) | |
283 (insert "\\M-" (char-to-string (- ch 128)))))) | |
284 (setq i (1+ i)))) | |
285 ) | |
286 | |
287 (defun MacEdit-lookup-key (map) | |
288 (let ((loc (and map (lookup-key map macro-str))) | |
289 (glob (lookup-key (current-global-map) macro-str)) | |
290 (loc-str macro-str) | |
291 (glob-str macro-str)) | |
292 (and (integerp loc) | |
293 (setq loc-str (substring macro-str 0 loc) | |
294 loc (lookup-key map loc-str))) | |
295 (and (consp loc) | |
296 (setq loc nil)) | |
297 (or loc | |
298 (setq loc-str "")) | |
299 (and (integerp glob) | |
300 (setq glob-str (substring macro-str 0 glob) | |
301 glob (lookup-key (current-global-map) glob-str))) | |
302 (and (consp glob) | |
303 (setq glob nil)) | |
304 (or glob | |
305 (setq glob-str "")) | |
306 (if (> (length glob-str) (length loc-str)) | |
307 (setq key-symbol glob | |
308 key-str glob-str) | |
309 (setq key-symbol loc | |
310 key-str loc-str)) | |
311 (setq key-last (and (> (length key-str) 0) | |
312 (logand (aref key-str (1- (length key-str))) 127))) | |
313 key-symbol) | |
314 ) | |
315 | |
316 (defun MacEdit-read-argument (&optional obarray pred) ;; currently ignored | |
317 (let ((str "") | |
318 (min-bsp 0) | |
319 (exec (eq key-symbol 'execute-extended-command)) | |
320 str-base) | |
321 (while (progn | |
322 (MacEdit-lookup-key (current-global-map)) | |
323 (or (and (eq key-symbol 'self-insert-command) | |
324 (< (length str) 60)) | |
325 (memq key-symbol | |
326 '(backward-delete-char | |
327 delete-backward-char | |
328 backward-delete-char-untabify)) | |
329 (eq key-last 9))) | |
330 (setq macro-str (substring macro-str (length key-str))) | |
331 (or (and (eq key-last 9) | |
332 obarray | |
333 (let ((comp (try-completion str obarray pred))) | |
334 (and (stringp comp) | |
335 (> (length comp) (length str)) | |
336 (setq str comp)))) | |
337 (if (or (eq key-symbol 'self-insert-command) | |
338 (and (or (eq key-last 9) | |
339 (<= (length str) min-bsp)) | |
340 (setq min-bsp (+ (length str) (length key-str))))) | |
341 (setq str (concat str key-str)) | |
342 (setq str (substring str 0 -1))))) | |
343 (setq str-base str | |
344 str (concat str key-str) | |
345 macro-str (substring macro-str (length key-str))) | |
346 (if exec | |
347 (let ((comp (try-completion str-base obarray pred))) | |
348 (if (if (stringp comp) | |
349 (and (commandp (intern comp)) | |
350 (setq str-base comp)) | |
351 (commandp (intern str-base))) | |
352 (insert str-base "\n") | |
353 (insert "execute-extended-command\n") | |
354 (insert "type \"") | |
355 (MacEdit-insert-string str) | |
356 (insert "\"\n"))) | |
357 (if (> (length str) 0) | |
358 (progn | |
359 (insert "type \"") | |
360 (MacEdit-insert-string str) | |
361 (insert "\"\n"))))) | |
362 ) | |
363 | |
364 (defun MacEdit-isearch-argument () | |
365 (let ((str "") | |
366 (min-bsp 0) | |
367 ch) | |
368 (while (and (setq ch (MacEdit-read-char)) | |
369 (or (<= ch 127) (not search-exit-option)) | |
370 (not (eq ch search-exit-char)) | |
371 (or (eq ch search-repeat-char) | |
372 (eq ch search-reverse-char) | |
373 (eq ch search-delete-char) | |
374 (eq ch search-yank-word-char) | |
375 (eq ch search-yank-line-char) | |
376 (eq ch search-quote-char) | |
377 (eq ch ?\r) | |
378 (eq ch ?\t) | |
379 (not search-exit-option) | |
380 (and (/= ch 127) (>= ch 32)))) | |
381 (if (and (eq ch search-quote-char) | |
382 (MacEdit-peek-char)) | |
383 (setq str (concat str (char-to-string ch) | |
384 (char-to-string (MacEdit-read-char))) | |
385 min-bsp (length str)) | |
386 (if (or (and (< ch 127) (>= ch 32)) | |
387 (eq ch search-yank-word-char) | |
388 (eq ch search-yank-line-char) | |
389 (and (or (not (eq ch search-delete-char)) | |
390 (<= (length str) min-bsp)) | |
391 (setq min-bsp (1+ (length str))))) | |
392 (setq str (concat str (char-to-string ch))) | |
393 (setq str (substring str 0 -1))))) | |
394 (if (eq ch search-exit-char) | |
395 (if (= (length str) 0) ;; non-incremental search | |
396 (progn | |
397 (setq str (concat str (char-to-string ch))) | |
398 (and (eq (MacEdit-peek-char) ?\C-w) | |
399 (progn | |
400 (setq str (concat str "\C-w")) | |
401 (MacEdit-read-char))) | |
402 (if (> (length str) 0) | |
403 (progn | |
404 (insert "type \"") | |
405 (MacEdit-insert-string str) | |
406 (insert "\"\n"))) | |
407 (MacEdit-read-argument) | |
408 (setq str ""))) | |
409 (MacEdit-unread-chars ch)) | |
410 (if (> (length str) 0) | |
411 (progn | |
412 (insert "type \"") | |
413 (MacEdit-insert-string str) | |
414 (insert "\\e\"\n")))) | |
415 ) | |
416 | |
417 ;;; Get the next keystroke-sequence from the input stream. | |
418 ;;; Sets key-symbol, key-str, and key-last as a side effect. | |
419 (defun MacEdit-read-key () | |
420 (MacEdit-lookup-key (current-local-map)) | |
421 (and key-symbol | |
422 (setq macro-str (substring macro-str (length key-str)))) | |
423 ) | |
424 | |
425 (defun MacEdit-peek-char () | |
426 (and (> (length macro-str) 0) | |
427 (aref macro-str 0)) | |
428 ) | |
429 | |
430 (defun MacEdit-read-char () | |
431 (and (> (length macro-str) 0) | |
432 (prog1 | |
433 (aref macro-str 0) | |
434 (setq macro-str (substring macro-str 1)))) | |
435 ) | |
436 | |
437 (defun MacEdit-unread-chars (chars) | |
438 (and (integerp chars) | |
439 (setq chars (char-to-string chars))) | |
440 (and chars | |
441 (setq macro-str (concat chars macro-str))) | |
442 ) | |
443 | |
444 (defun MacEdit-dump (mac) | |
445 (set-mark-command nil) | |
446 (insert "\n\n") | |
447 (MacEdit-print-macro mac (current-local-map)) | |
448 ) | |
449 | |
450 | |
451 | |
452 ;;; Parse a string of spelled-out keystrokes, as produced by key-description. | |
453 | |
454 (defun MacEdit-parse-keys (str) | |
455 (let ((pos 0) | |
456 (mac "") | |
457 part) | |
458 (while (and (< pos (length str)) | |
459 (string-match "[^ \t\n]+" str pos)) | |
460 (setq pos (match-end 0) | |
461 part (substring str (match-beginning 0) (match-end 0)) | |
462 mac (concat mac | |
463 (if (and (> (length part) 2) | |
464 (= (aref part 1) ?-) | |
465 (= (aref part 0) ?M)) | |
466 (progn | |
467 (setq part (substring part 2)) | |
468 "\e") | |
469 (if (and (> (length part) 4) | |
470 (= (aref part 0) ?C) | |
471 (= (aref part 1) ?-) | |
472 (= (aref part 2) ?M) | |
473 (= (aref part 3) ?-)) | |
474 (progn | |
475 (setq part (concat "C-" (substring part 4))) | |
476 "\e") | |
477 "")) | |
478 (or (cdr (assoc part '( ( "NUL" . "\0" ) | |
479 ( "RET" . "\r" ) | |
480 ( "LFD" . "\n" ) | |
481 ( "TAB" . "\t" ) | |
482 ( "ESC" . "\e" ) | |
483 ( "SPC" . " " ) | |
484 ( "DEL" . "\177" ) | |
485 ( "C-?" . "\177" ) | |
486 ( "C-2" . "\0" ) | |
487 ( "C-SPC" . "\0") ))) | |
488 (and (equal part "REM") | |
489 (setq pos (or (string-match "\n" str pos) | |
490 (length str))) | |
491 "") | |
492 (and (= (length part) 3) | |
493 (= (aref part 0) ?C) | |
494 (= (aref part 1) ?-) | |
495 (char-to-string (logand (aref part 2) 31))) | |
496 part)))) | |
497 mac) | |
498 ) | |
499 | |
500 | |
501 | |
502 | |
503 ;;; Parse a keyboard macro description in MacEdit-print-macro's format. | |
504 | |
505 (defun MacEdit-read-macro (&optional map) | |
506 (or map (setq map (current-local-map))) | |
507 (let ((macro-str "")) | |
508 (while (not (progn | |
509 (skip-chars-forward " \t\n") | |
510 (eobp))) | |
511 (cond ((looking-at "#")) ;; comment | |
512 ((looking-at "prefix-arg[ \t]*-[ \t]*\n") | |
513 (MacEdit-append-chars "\C-u-")) | |
514 ((looking-at "prefix-arg[ \t]*\\(-?[0-9]+\\)[ \t]*\n") | |
515 (MacEdit-append-chars (concat "\C-u" (MacEdit-match-string 1)))) | |
516 ((looking-at "prefix-arg[ \t]*(\\([0-9]+\\))[ \t]*\n") | |
517 (let ((val (string-to-int (MacEdit-match-string 1)))) | |
518 (while (> val 1) | |
519 (or (= (% val 4) 0) | |
520 (error "Bad prefix argument value")) | |
521 (MacEdit-append-chars "\C-u") | |
522 (setq val (/ val 4))))) | |
523 ((looking-at "prefix-arg") | |
524 (error "Bad prefix argument syntax")) | |
525 ((looking-at "insert ") | |
526 (forward-char 7) | |
527 (MacEdit-append-chars (read (current-buffer))) | |
528 (if (< (current-column) 7) | |
529 (forward-line -1))) | |
530 ((looking-at "type ") | |
531 (forward-char 5) | |
532 (MacEdit-append-chars (read (current-buffer))) | |
533 (if (< (current-column) 5) | |
534 (forward-line -1))) | |
535 ((looking-at "keys \\(.*\\)\n") | |
536 (goto-char (1- (match-end 0))) | |
537 (MacEdit-append-chars (MacEdit-parse-keys | |
538 (buffer-substring (match-beginning 1) | |
539 (match-end 1))))) | |
540 ((looking-at "\\([-a-zA-z0-9_]+\\)[ \t]*\\(.*\\)\n") | |
541 (let* ((func (intern (MacEdit-match-string 1))) | |
542 (arg (MacEdit-match-string 2)) | |
543 (cust (get func 'MacEdit-read))) | |
544 (if cust | |
545 (funcall cust arg) | |
546 (or (commandp func) | |
547 (error "Not an Emacs command")) | |
548 (or (equal arg "") | |
549 (string-match "\\`#" arg) | |
550 (error "Unexpected argument to command")) | |
551 (let ((keys | |
552 (or (where-is-internal func map t) | |
553 (where-is-internal func (current-global-map) t)))) | |
554 (if keys | |
555 (MacEdit-append-chars keys) | |
556 (MacEdit-append-chars (concat "\ex" | |
557 (symbol-name func) | |
558 "\n"))))))) | |
559 (t (error "Syntax error"))) | |
560 (forward-line 1)) | |
561 macro-str) | |
562 ) | |
563 | |
564 (defun MacEdit-append-chars (chars) | |
565 (setq macro-str (concat macro-str chars)) | |
566 ) | |
567 | |
568 (defun MacEdit-match-string (n) | |
569 (if (match-beginning n) | |
570 (buffer-substring (match-beginning n) (match-end n)) | |
571 "") | |
572 ) | |
573 | |
574 | |
575 | |
576 (defun MacEdit-get-interactive (func) | |
577 (if (symbolp func) | |
578 (let ((cust (get func 'MacEdit-interactive))) | |
579 (if cust | |
580 cust | |
581 (MacEdit-get-interactive (symbol-function func)))) | |
582 (or (and (eq (car-safe func) 'lambda) | |
583 (let ((int (if (consp (nth 2 func)) | |
584 (nth 2 func) | |
585 (nth 3 func)))) | |
586 (and (eq (car-safe int) 'interactive) | |
587 (stringp (nth 1 int)) | |
588 (nth 1 int)))) | |
589 "")) | |
590 ) | |
591 | |
592 (put 'search-forward 'MacEdit-interactive "s") | |
593 (put 'search-backward 'MacEdit-interactive "s") | |
594 (put 'word-search-forward 'MacEdit-interactive "s") | |
595 (put 'word-search-backward 'MacEdit-interactive "s") | |
596 (put 're-search-forward 'MacEdit-interactive "s") | |
597 (put 're-search-backward 'MacEdit-interactive "s") | |
598 (put 'switch-to-buffer 'MacEdit-interactive "B") | |
599 (put 'kill-buffer 'MacEdit-interactive "B") | |
600 (put 'rename-buffer 'MacEdit-interactive "B\nB") | |
601 (put 'goto-char 'MacEdit-interactive "N") | |
602 (put 'global-set-key 'MacEdit-interactive "k\nC") | |
603 (put 'global-unset-key 'MacEdit-interactive "k") | |
604 (put 'local-set-key 'MacEdit-interactive "k\nC") | |
605 (put 'local-unset-key 'MacEdit-interactive "k") | |
606 | |
607 ;;; Think about kbd-macro-query | |
608 | |
609 | |
610 | |
611 ;;; Edit a keyboard macro in another buffer. | |
612 ;;; (Prefix argument is currently ignored.) | |
613 | |
614 (defun MacEdit-edit-macro (mac repl &optional prefix buffer hook arg) | |
615 (or (stringp mac) | |
616 (error "Not a keyboard macro")) | |
617 (let ((oldbuf (current-buffer)) | |
618 (from-calc (and (get-buffer-window "*Calculator*") | |
619 (eq (lookup-key (current-global-map) "\e#") | |
620 'calc-dispatch))) | |
621 (local (current-local-map)) | |
622 (buf (get-buffer-create (or buffer "*Edit Macro*")))) | |
623 (set-buffer buf) | |
624 (kill-all-local-variables) | |
625 (use-local-map MacEdit-mode-map) | |
626 (setq buffer-read-only nil) | |
627 (setq major-mode 'MacEdit-mode) | |
628 (setq mode-name "Edit Macro") | |
629 (make-local-variable 'MacEdit-original-buffer) | |
630 (setq MacEdit-original-buffer oldbuf) | |
631 (make-local-variable 'MacEdit-replace-function) | |
632 (setq MacEdit-replace-function repl) | |
633 (make-local-variable 'MacEdit-replace-argument) | |
634 (setq MacEdit-replace-argument arg) | |
635 (make-local-variable 'MacEdit-finish-hook) | |
636 (setq MacEdit-finish-hook hook) | |
637 (erase-buffer) | |
638 (insert "# Keyboard Macro Editor. Press " | |
639 (if from-calc "M-# M-#" "C-c C-c") | |
640 " to finish; press " | |
641 (if from-calc "M-# x" "C-x k RET") | |
642 " to cancel.\n") | |
643 (insert "# Original keys: " (key-description mac) "\n\n") | |
644 (message "Formatting keyboard macro...") | |
645 (MacEdit-print-macro mac local) | |
646 (switch-to-buffer buf) | |
647 (goto-char (point-min)) | |
648 (forward-line 3) | |
649 (recenter '(4)) | |
650 (set-buffer-modified-p nil) | |
651 (message "Formatting keyboard macro...done") | |
652 (run-hooks 'MacEdit-format-hook)) | |
653 ) | |
654 | |
655 (defun MacEdit-finish-edit () | |
656 (interactive) | |
657 (or (and (boundp 'MacEdit-original-buffer) | |
658 (boundp 'MacEdit-replace-function) | |
659 (boundp 'MacEdit-replace-argument) | |
660 (boundp 'MacEdit-finish-hook) | |
661 (eq major-mode 'MacEdit-mode)) | |
662 (error "This command is valid only in buffers created by edit-kbd-macro.")) | |
663 (let ((buf (current-buffer)) | |
664 (str (buffer-string)) | |
665 (func MacEdit-replace-function) | |
666 (arg MacEdit-replace-argument) | |
667 (hook MacEdit-finish-hook)) | |
668 (goto-char (point-min)) | |
669 (and (buffer-modified-p) | |
670 func | |
671 (progn | |
672 (message "Compiling keyboard macro...") | |
673 (run-hooks 'MacEdit-compile-hook) | |
674 (let ((mac (MacEdit-read-macro | |
675 (and (buffer-name MacEdit-original-buffer) | |
676 (save-excursion | |
677 (set-buffer MacEdit-original-buffer) | |
678 (current-local-map)))))) | |
679 (and (buffer-name MacEdit-original-buffer) | |
680 (switch-to-buffer MacEdit-original-buffer)) | |
681 (funcall func mac arg)) | |
682 (message "Compiling keyboard macro...done"))) | |
683 (kill-buffer buf) | |
684 (if hook | |
685 (funcall hook arg))) | |
686 ) | |
687 | |
688 (defun MacEdit-cancel-edit () | |
689 (interactive) | |
690 (if (eq major-mode 'MacEdit-mode) | |
691 (set-buffer-modified-p nil)) | |
692 (MacEdit-finish-edit) | |
693 (message "(Cancelled)") | |
694 ) | |
695 | |
696 (defun MacEdit-mode () | |
697 "Keyboard Macro Editing mode. Press C-c C-c to save and exit. | |
698 To abort the edit, just kill this buffer with C-x k RET. | |
699 | |
700 The keyboard macro is represented as a series of M-x style command names. | |
701 Keystrokes which do not correspond to simple M-x commands are written as | |
702 \"type\" commands. When you press C-c C-c, MacEdit converts each command | |
703 back into a suitable keystroke sequence; \"type\" commands are converted | |
704 directly back into keystrokes." | |
705 (interactive) | |
706 (error "This mode can be enabled only by edit-kbd-macro or edit-last-kbd-macro.") | |
707 ) | |
708 (put 'MacEdit-mode 'mode-class 'special) | |
709 | |
710 (defvar MacEdit-mode-map nil) | |
711 (if MacEdit-mode-map | |
712 () | |
713 (setq MacEdit-mode-map (make-sparse-keymap)) | |
714 (define-key MacEdit-mode-map "\C-c\C-c" 'MacEdit-finish-edit) | |
715 ) | |
716 |