home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume15 / calc-1.05 / part20 < prev    next >
Lisp/Scheme  |  1990-10-14  |  19KB  |  579 lines
  1. Newsgroups: comp.sources.misc
  2. X-UNIX-From: daveg@csvax.cs.caltech.edu
  3. subject: v15i047: Patch for GNU Emacs Calc, version 1.04 -> 1.05, part 20/20
  4. from: daveg@csvax.cs.caltech.edu (David Gillespie)
  5. Sender: allbery@uunet.UU.NET (Brandon S. Allbery - comp.sources.misc)
  6.  
  7. Posting-number: Volume 15, Issue 47
  8. Submitted-by: daveg@csvax.cs.caltech.edu (David Gillespie)
  9. Archive-name: calc-1.05/part20
  10.  
  11. #!/bin/sh
  12. # this is part 20 of a multipart archive
  13. # do not concatenate these parts, unpack them in order with /bin/sh
  14. # file calc.patch continued
  15. #
  16. CurArch=20
  17. if test ! -r s2_seq_.tmp
  18. then echo "Please unpack part 1 first!"
  19.      exit 1; fi
  20. ( read Scheck
  21.   if test "$Scheck" != $CurArch
  22.   then echo "Please unpack part $Scheck next!"
  23.        exit 1;
  24.   else exit 0; fi
  25. ) < s2_seq_.tmp || exit 1
  26. sed 's/^X//' << 'SHAR_EOF' >> calc.patch
  27. X+           ((and (eq key-symbol 'quoted-insert)
  28. X+             (MacEdit-peek-char))
  29. X+            (insert "quoted-insert\n")
  30. X+            (let ((ch (MacEdit-read-char))
  31. X+              ch2)
  32. X+              (if (and (>= ch ?0) (<= ch ?7))
  33. X+              (progn
  34. X+                (setq ch (- ch ?0)
  35. X+                  ch2 (MacEdit-read-char))
  36. X+                (if ch2
  37. X+                    (if (and (>= ch2 ?0) (<= ch2 ?7))
  38. X+                    (progn
  39. X+                      (setq ch (+ (* ch 8) (- ch2 ?0))
  40. X+                        ch2 (MacEdit-read-char))
  41. X+                      (if ch2
  42. X+                      (if (and (>= ch2 ?0) (<= ch2 ?7))
  43. X+                          (setq ch (+ (* ch 8) (- ch2 ?0)))
  44. X+                        (MacEdit-unread-chars ch2))))
  45. X+                  (MacEdit-unread-chars ch2)))))
  46. X+              (if (or (and (>= ch ?0) (<= ch ?7))
  47. X+                  (< ch 32) (> ch 126))
  48. X+              (insert (format "type \"\\%03o\"\n" ch))
  49. X+                (insert "type \"" (char-to-string ch) "\"\n"))))
  50. X+           ((memq key-symbol '(isearch-forward
  51. X+                       isearch-backward
  52. X+                       isearch-forward-regexp
  53. X+                       isearch-backward-regexp))
  54. X+            (insert (symbol-name key-symbol) "\n")
  55. X+            (MacEdit-isearch-argument))
  56. X+           ((eq key-symbol 'execute-extended-command)
  57. X+            (MacEdit-read-argument obarray 'commandp))
  58. X+           (t
  59. X+            (let ((cust (get key-symbol 'MacEdit-print)))
  60. X+              (if cust
  61. X+              (funcall cust)
  62. X+                (insert (symbol-name key-symbol))
  63. X+                (indent-to 30)
  64. X+                (insert " # ")
  65. X+                (MacEdit-insert-string key-str)
  66. X+                (insert "\n")
  67. X+                (let ((int (MacEdit-get-interactive key-symbol)))
  68. X+              (if (string-match "\\`\\*" int)
  69. X+                  (setq int (substring int 1)))
  70. X+              (while (> (length int) 0)
  71. X+                (cond ((= (aref int 0) ?a)
  72. X+                   (MacEdit-read-argument
  73. X+                    obarray nil))
  74. X+                  ((memq (aref int 0) '(?b ?B ?D ?f ?F ?n
  75. X+                               ?s ?S ?x ?X))
  76. X+                   (MacEdit-read-argument))
  77. X+                  ((and (= (aref int 0) ?c)
  78. X+                        (MacEdit-peek-char))
  79. X+                   (insert "type \"")
  80. X+                   (MacEdit-insert-string
  81. X+                    (char-to-string
  82. X+                     (MacEdit-read-char)))
  83. X+                   (insert "\"\n"))
  84. X+                  ((= (aref int 0) ?C)
  85. X+                   (MacEdit-read-argument
  86. X+                    obarray 'commandp))
  87. X+                  ((= (aref int 0) ?k)
  88. X+                   (MacEdit-read-key)
  89. X+                   (if key-symbol
  90. X+                       (progn
  91. X+                     (insert "type \"")
  92. X+                     (MacEdit-insert-string key-str)
  93. X+                     (insert "\"\n"))
  94. X+                     (MacEdit-unread-chars key-str)))
  95. X+                  ((= (aref int 0) ?N)
  96. X+                   (or this-prefix
  97. X+                       (MacEdit-read-argument)))
  98. X+                  ((= (aref int 0) ?v)
  99. X+                   (MacEdit-read-argument
  100. X+                    obarray 'user-variable-p)))
  101. X+                (let ((nl (string-match "\n" int)))
  102. X+                  (setq int (if nl
  103. X+                        (substring int (1+ nl))
  104. X+                      "")))))))))))
  105. X+       (use-local-map save-map)))
  106. X+ )
  107. X+ 
  108. X+ (defun MacEdit-prefix-arg (char c-u value)
  109. X+   (let ((sign 1))
  110. X+     (if (and (numberp value) (< value 0))
  111. X+     (setq sign -1 value (- value)))
  112. X+     (if (eq value '-)
  113. X+     (setq sign -1 value nil))
  114. X+     (while (and char (= ?- char))
  115. X+       (setq sign (- sign) c-u nil)
  116. X+       (setq char (MacEdit-read-char)))
  117. X+     (while (and char (>= char ?0) (<= char ?9))
  118. X+       (setq value (+ (* (if (numberp value) value 0) 10) (- char ?0)) c-u nil)
  119. X+       (setq char (MacEdit-read-char)))
  120. X+     (setq prefix-arg
  121. X+       (cond (c-u (list c-u))
  122. X+         ((numberp value) (* value sign))
  123. X+         ((= sign -1) '-)))
  124. X+     (MacEdit-unread-chars char))
  125. X+ )
  126. X+ 
  127. X+ (defun MacEdit-insert-string (str)
  128. X+   (let ((i 0) j ch)
  129. X+     (while (< i (length str))
  130. X+       (if (and (> (setq ch (aref str i)) 127)
  131. X+            (< ch 160))
  132. X+       (progn
  133. X+         (setq ch (- ch 128))
  134. X+         (insert "\\M-")))
  135. X+       (if (< ch 32)
  136. X+       (cond ((= ch 8)  (insret "\\b"))
  137. X+         ((= ch 9)  (insert "\\t"))
  138. X+         ((= ch 10) (insert "\\n"))
  139. X+         ((= ch 13) (insert "\\r"))
  140. X+         ((= ch 27) (insert "\\e"))
  141. X+         (t (insert "\\C-" (char-to-string (downcase (+ ch 64))))))
  142. X+     (if (< ch 127)
  143. X+         (if (or (= ch 34) (= ch 92))
  144. X+         (insert "\\" (char-to-string ch))
  145. X+           (setq j i)
  146. X+           (while (and (< (setq i (1+ i)) (length str))
  147. X+               (>= (setq ch (aref str i)) 32)
  148. X+               (/= ch 34) (/= ch 92)
  149. X+               (< ch 127)))
  150. X+           (insert (substring str j i))
  151. X+           (setq i (1- i)))
  152. X+       (if (memq ch '(127 255))
  153. X+           (insert (format "\\%03o" ch))
  154. X+         (insert "\\M-" (char-to-string (- ch 128))))))
  155. X+       (setq i (1+ i))))
  156. X+ )
  157. X+ 
  158. X+ (defun MacEdit-lookup-key (map)
  159. X+   (let ((loc (and map (lookup-key map macro-str)))
  160. X+     (glob (lookup-key (current-global-map) macro-str))
  161. X+     (loc-str macro-str)
  162. X+     (glob-str macro-str))
  163. X+     (and (integerp loc)
  164. X+      (setq loc-str (substring macro-str 0 loc)
  165. X+            loc (lookup-key map loc-str)))
  166. X+     (and (consp loc)
  167. X+      (setq loc nil))
  168. X+     (or loc
  169. X+     (setq loc-str ""))
  170. X+     (and (integerp glob)
  171. X+      (setq glob-str (substring macro-str 0 glob)
  172. X+            glob (lookup-key (current-global-map) glob-str)))
  173. X+     (and (consp glob)
  174. X+      (setq glob nil))
  175. X+     (or glob
  176. X+     (setq glob-str ""))
  177. X+     (if (> (length glob-str) (length loc-str))
  178. X+     (setq key-symbol glob
  179. X+           key-str glob-str)
  180. X+       (setq key-symbol loc
  181. X+         key-str loc-str))
  182. X+     (setq key-last (and (> (length key-str) 0)
  183. X+             (logand (aref key-str (1- (length key-str))) 127)))
  184. X+     key-symbol)
  185. X+ )
  186. X+ 
  187. X+ (defun MacEdit-read-argument (&optional obarray pred)   ;; currently ignored
  188. X+   (let ((str "")
  189. X+     (min-bsp 0)
  190. X+     (exec (eq key-symbol 'execute-extended-command))
  191. X+     str-base)
  192. X+     (while (progn
  193. X+          (MacEdit-lookup-key (current-global-map))
  194. X+          (or (and (eq key-symbol 'self-insert-command)
  195. X+               (< (length str) 60))
  196. X+          (memq key-symbol
  197. X+                 '(backward-delete-char
  198. X+                   delete-backward-char
  199. X+                   backward-delete-char-untabify))
  200. X+          (eq key-last 9)))
  201. X+       (setq macro-str (substring macro-str (length key-str)))
  202. X+       (or (and (eq key-last 9)
  203. X+            obarray
  204. X+            (let ((comp (try-completion str obarray pred)))
  205. X+          (and (stringp comp)
  206. X+               (> (length comp) (length str))
  207. X+               (setq str comp))))
  208. X+       (if (or (eq key-symbol 'self-insert-command)
  209. X+           (and (or (eq key-last 9)
  210. X+                (<= (length str) min-bsp))
  211. X+                (setq min-bsp (+ (length str) (length key-str)))))
  212. X+           (setq str (concat str key-str))
  213. X+         (setq str (substring str 0 -1)))))
  214. X+     (setq str-base str
  215. X+       str (concat str key-str)
  216. X+       macro-str (substring macro-str (length key-str)))
  217. X+     (if exec
  218. X+     (let ((comp (try-completion str-base obarray pred)))
  219. X+       (if (if (stringp comp)
  220. X+           (and (commandp (intern comp))
  221. X+                (setq str-base comp))
  222. X+         (commandp (intern str-base)))
  223. X+           (insert str-base "\n")
  224. X+         (insert "execute-extended-command\n")
  225. X+         (insert "type \"")
  226. X+         (MacEdit-insert-string str)
  227. X+         (insert "\"\n")))
  228. X+       (if (> (length str) 0)
  229. X+       (progn
  230. X+         (insert "type \"")
  231. X+         (MacEdit-insert-string str)
  232. X+         (insert "\"\n")))))
  233. X+ )
  234. X+ 
  235. X+ (defun MacEdit-isearch-argument ()
  236. X+   (let ((str "")
  237. X+     (min-bsp 0)
  238. X+     ch)
  239. X+     (while (and (setq ch (MacEdit-read-char))
  240. X+         (or (<= ch 127) (not search-exit-option))
  241. X+         (not (eq ch search-exit-char))
  242. X+         (or (eq ch search-repeat-char)
  243. X+             (eq ch search-reverse-char)
  244. X+             (eq ch search-delete-char)
  245. X+             (eq ch search-yank-word-char)
  246. X+             (eq ch search-yank-line-char)
  247. X+             (eq ch search-quote-char)
  248. X+             (eq ch ?\r)
  249. X+             (eq ch ?\t)
  250. X+             (not search-exit-option)
  251. X+             (and (/= ch 127) (>= ch 32))))
  252. X+       (if (and (eq ch search-quote-char)
  253. X+            (MacEdit-peek-char))
  254. X+       (setq str (concat str (char-to-string ch)
  255. X+                 (char-to-string (MacEdit-read-char)))
  256. X+         min-bsp (length str))
  257. X+     (if (or (and (< ch 127) (>= ch 32))
  258. X+         (eq ch search-yank-word-char)
  259. X+         (eq ch search-yank-line-char)
  260. X+         (and (or (not (eq ch search-delete-char))
  261. X+              (<= (length str) min-bsp))
  262. X+              (setq min-bsp (1+ (length str)))))
  263. X+         (setq str (concat str (char-to-string ch)))
  264. X+       (setq str (substring str 0 -1)))))
  265. X+     (if (eq ch search-exit-char)
  266. X+     (if (= (length str) 0)  ;; non-incremental search
  267. X+         (progn
  268. X+           (setq str (concat str (char-to-string ch)))
  269. X+           (and (eq (MacEdit-peek-char) ?\C-w)
  270. X+            (progn
  271. X+              (setq str (concat str "\C-w"))
  272. X+              (MacEdit-read-char)))
  273. X+           (if (> (length str) 0)
  274. X+           (progn
  275. X+             (insert "type \"")
  276. X+             (MacEdit-insert-string str)
  277. X+             (insert "\"\n")))
  278. X+           (MacEdit-read-argument)
  279. X+           (setq str "")))
  280. X+       (MacEdit-unread-chars ch))
  281. X+     (if (> (length str) 0)
  282. X+     (progn
  283. X+       (insert "type \"")
  284. X+       (MacEdit-insert-string str)
  285. X+       (insert "\\e\"\n"))))
  286. X+ )
  287. X+ 
  288. X+ ;;; Get the next keystroke-sequence from the input stream.
  289. X+ ;;; Sets key-symbol, key-str, and key-last as a side effect.
  290. X+ (defun MacEdit-read-key ()
  291. X+   (MacEdit-lookup-key (current-local-map))
  292. X+   (and key-symbol
  293. X+        (setq macro-str (substring macro-str (length key-str))))
  294. X+ )
  295. X+ 
  296. X+ (defun MacEdit-peek-char ()
  297. X+   (and (> (length macro-str) 0)
  298. X+        (aref macro-str 0))
  299. X+ )
  300. X+ 
  301. X+ (defun MacEdit-read-char ()
  302. X+   (and (> (length macro-str) 0)
  303. X+        (prog1
  304. X+        (aref macro-str 0)
  305. X+      (setq macro-str (substring macro-str 1))))
  306. X+ )
  307. X+ 
  308. X+ (defun MacEdit-unread-chars (chars)
  309. X+   (and (integerp chars)
  310. X+        (setq chars (char-to-string chars)))
  311. X+   (and chars
  312. X+        (setq macro-str (concat chars macro-str)))
  313. X+ )
  314. X+ 
  315. X+ (defun MacEdit-dump (mac)
  316. X+   (set-mark-command nil)
  317. X+   (insert "\n\n")
  318. X+   (MacEdit-print-macro mac (current-local-map))
  319. X+ )
  320. X+ 
  321. X+ 
  322. X+ 
  323. X+ ;;; Parse a string of spelled-out keystrokes, as produced by key-description.
  324. X+ 
  325. X+ (defun MacEdit-parse-keys (str)
  326. X+   (let ((pos 0)
  327. X+     (mac "")
  328. X+     part)
  329. X+     (while (and (< pos (length str))
  330. X+         (string-match "[^ \t\n]+" str pos))
  331. X+       (setq pos (match-end 0)
  332. X+         part (substring str (match-beginning 0) (match-end 0))
  333. X+         mac (concat mac
  334. X+             (if (and (> (length part) 2)
  335. X+                  (= (aref part 1) ?-)
  336. X+                  (= (aref part 0) ?M))
  337. X+                 (progn
  338. X+                   (setq part (substring part 2))
  339. X+                   "\e")
  340. X+               (if (and (> (length part) 4)
  341. X+                    (= (aref part 0) ?C)
  342. X+                    (= (aref part 1) ?-)
  343. X+                    (= (aref part 2) ?M)
  344. X+                    (= (aref part 3) ?-))
  345. X+                   (progn
  346. X+                 (setq part (concat "C-" (substring part 4)))
  347. X+                 "\e")
  348. X+                 ""))
  349. X+             (or (cdr (assoc part '( ( "NUL" . "\0" )
  350. X+                         ( "RET" . "\r" )
  351. X+                         ( "LFD" . "\n" )
  352. X+                         ( "TAB" . "\t" )
  353. X+                         ( "ESC" . "\e" )
  354. X+                         ( "SPC" . " " )
  355. X+                         ( "DEL" . "\177" )
  356. X+                         ( "C-?" . "\177" )
  357. X+                         ( "C-2" . "\0" )
  358. X+                         ( "C-SPC" . "\0") )))
  359. X+                 (and (equal part "REM")
  360. X+                  (setq pos (or (string-match "\n" str pos)
  361. X+                            (length str)))
  362. X+                  "")
  363. X+                 (and (= (length part) 3)
  364. X+                  (= (aref part 0) ?C)
  365. X+                  (= (aref part 1) ?-)
  366. X+                  (char-to-string (logand (aref part 2) 31)))
  367. X+                 part))))
  368. X+     mac)
  369. X+ )
  370. X+ 
  371. X+ 
  372. X+ 
  373. X+ 
  374. X+ ;;; Parse a keyboard macro description in MacEdit-print-macro's format.
  375. X+ 
  376. X+ (defun MacEdit-read-macro (&optional map)
  377. X+   (or map (setq map (current-local-map)))
  378. X+   (let ((macro-str ""))
  379. X+     (while (not (progn
  380. X+           (skip-chars-forward " \t\n")
  381. X+           (eobp)))
  382. X+       (cond ((looking-at "#"))   ;; comment
  383. X+         ((looking-at "prefix-arg[ \t]*-[ \t]*\n")
  384. X+          (MacEdit-append-chars "\C-u-"))
  385. X+         ((looking-at "prefix-arg[ \t]*\\(-?[0-9]+\\)[ \t]*\n")
  386. X+          (MacEdit-append-chars (concat "\C-u" (MacEdit-match-string 1))))
  387. X+         ((looking-at "prefix-arg[ \t]*(\\([0-9]+\\))[ \t]*\n")
  388. X+          (let ((val (string-to-int (MacEdit-match-string 1))))
  389. X+            (while (> val 1)
  390. X+          (or (= (% val 4) 0)
  391. X+              (error "Bad prefix argument value"))
  392. X+          (MacEdit-append-chars "\C-u")
  393. X+          (setq val (/ val 4)))))
  394. X+         ((looking-at "prefix-arg")
  395. X+          (error "Bad prefix argument syntax"))
  396. X+         ((looking-at "insert ")
  397. X+          (forward-char 7)
  398. X+          (MacEdit-append-chars (read (current-buffer)))
  399. X+          (if (< (current-column) 7)
  400. X+          (forward-line -1)))
  401. X+         ((looking-at "type ")
  402. X+          (forward-char 5)
  403. X+          (MacEdit-append-chars (read (current-buffer)))
  404. X+          (if (< (current-column) 5)
  405. X+          (forward-line -1)))
  406. X+         ((looking-at "keys \\(.*\\)\n")
  407. X+          (goto-char (1- (match-end 0)))
  408. X+          (MacEdit-append-chars (MacEdit-parse-keys
  409. X+                     (buffer-substring (match-beginning 1)
  410. X+                               (match-end 1)))))
  411. X+         ((looking-at "\\([-a-zA-z0-9_]+\\)[ \t]*\\(.*\\)\n")
  412. X+          (let* ((func (intern (MacEdit-match-string 1)))
  413. X+             (arg (MacEdit-match-string 2))
  414. X+             (cust (get func 'MacEdit-read)))
  415. X+            (if cust
  416. X+            (funcall cust arg)
  417. X+          (or (commandp func)
  418. X+              (error "Not an Emacs command"))
  419. X+          (or (equal arg "")
  420. X+              (string-match "\\`#" arg)
  421. X+              (error "Unexpected argument to command"))
  422. X+          (let ((keys
  423. X+             (or (where-is-internal func map t)
  424. X+                 (where-is-internal func (current-global-map) t))))
  425. X+            (if keys
  426. X+                (MacEdit-append-chars keys)
  427. X+              (MacEdit-append-chars (concat "\ex"
  428. X+                            (symbol-name func)
  429. X+                            "\n")))))))
  430. X+         (t (error "Syntax error")))
  431. X+       (forward-line 1))
  432. X+     macro-str)
  433. X+ )
  434. X+ 
  435. X+ (defun MacEdit-append-chars (chars)
  436. X+   (setq macro-str (concat macro-str chars))
  437. X+ )
  438. X+ 
  439. X+ (defun MacEdit-match-string (n)
  440. X+   (if (match-beginning n)
  441. X+       (buffer-substring (match-beginning n) (match-end n))
  442. X+     "")
  443. X+ )
  444. X+ 
  445. X+ 
  446. X+ 
  447. X+ (defun MacEdit-get-interactive (func)
  448. X+   (if (symbolp func)
  449. X+       (let ((cust (get func 'MacEdit-interactive)))
  450. X+     (if cust
  451. X+         cust
  452. X+       (MacEdit-get-interactive (symbol-function func))))
  453. X+     (or (and (eq (car-safe func) 'lambda)
  454. X+          (let ((int (if (consp (nth 2 func))
  455. X+                 (nth 2 func)
  456. X+               (nth 3 func))))
  457. X+            (and (eq (car-safe int) 'interactive)
  458. X+             (stringp (nth 1 int))
  459. X+             (nth 1 int))))
  460. X+     ""))
  461. X+ )
  462. X+ 
  463. X+ (put 'search-forward           'MacEdit-interactive "s")
  464. X+ (put 'search-backward          'MacEdit-interactive "s")
  465. X+ (put 'word-search-forward      'MacEdit-interactive "s")
  466. X+ (put 'word-search-backward     'MacEdit-interactive "s")
  467. X+ (put 're-search-forward        'MacEdit-interactive "s")
  468. X+ (put 're-search-backward       'MacEdit-interactive "s")
  469. X+ (put 'switch-to-buffer         'MacEdit-interactive "B")
  470. X+ (put 'kill-buffer              'MacEdit-interactive "B")
  471. X+ (put 'rename-buffer            'MacEdit-interactive "B\nB")
  472. X+ (put 'goto-char                'MacEdit-interactive "N")
  473. X+ (put 'global-set-key           'MacEdit-interactive "k\nC")
  474. X+ (put 'global-unset-key         'MacEdit-interactive "k")
  475. X+ (put 'local-set-key            'MacEdit-interactive "k\nC")
  476. X+ (put 'local-unset-key          'MacEdit-interactive "k")
  477. X+ 
  478. X+ ;;; Think about kbd-macro-query
  479. X+ 
  480. X+ 
  481. X+ 
  482. X+ ;;; Edit a keyboard macro in another buffer.
  483. X+ ;;; (Prefix argument is currently ignored.)
  484. X+ 
  485. X+ (defun MacEdit-edit-macro (mac repl &optional prefix buffer hook arg)
  486. X+   (or (stringp mac)
  487. X+       (error "Not a keyboard macro"))
  488. X+   (let ((oldbuf (current-buffer))
  489. X+     (local (current-local-map))
  490. X+     (buf (get-buffer-create (or buffer "*Edit Macro*"))))
  491. X+     (set-buffer buf)
  492. X+     (kill-all-local-variables)
  493. X+     (use-local-map MacEdit-mode-map)
  494. X+     (setq buffer-read-only nil)
  495. X+     (setq major-mode 'MacEdit-mode)
  496. X+     (setq mode-name "Edit Macro")
  497. X+     (make-local-variable 'MacEdit-original-buffer)
  498. X+     (setq MacEdit-original-buffer oldbuf)
  499. X+     (make-local-variable 'MacEdit-replace-function)
  500. X+     (setq MacEdit-replace-function repl)
  501. X+     (make-local-variable 'MacEdit-replace-argument)
  502. X+     (setq MacEdit-replace-argument arg)
  503. X+     (make-local-variable 'MacEdit-finish-hook)
  504. X+     (setq MacEdit-finish-hook hook)
  505. X+     (erase-buffer)
  506. X+     (insert "# Keyboard Macro Editor.  Press C-c C-c to finish; press C-x k RET to cancel.\n")
  507. X+     (insert "# Original keys: " (key-description mac) "\n\n")
  508. X+     (message "Formatting keyboard macro...")
  509. X+     (MacEdit-print-macro mac local)
  510. X+     (switch-to-buffer buf)
  511. X+     (goto-char (point-min))
  512. X+     (forward-line 3)
  513. X+     (recenter '(4))
  514. X+     (set-buffer-modified-p nil)
  515. X+     (message "Formatting keyboard macro...done")
  516. X+     (run-hooks 'MacEdit-format-hook))
  517. X+ )
  518. X+ 
  519. X+ (defun MacEdit-finish-edit ()
  520. X+   (interactive)
  521. X+   (or (and (boundp 'MacEdit-original-buffer)
  522. X+        (boundp 'MacEdit-replace-function)
  523. X+        (boundp 'MacEdit-replace-argument)
  524. X+        (boundp 'MacEdit-finish-hook)
  525. X+        (eq major-mode 'MacEdit-mode))
  526. X+       (error "This command is valid only in buffers created by edit-kbd-macro."))
  527. X+   (let ((buf (current-buffer))
  528. X+     (str (buffer-string))
  529. X+     (func MacEdit-replace-function)
  530. X+     (arg MacEdit-replace-argument)
  531. X+     (hook MacEdit-finish-hook))
  532. X+     (goto-char (point-min))
  533. X+     (run-hooks 'MacEdit-compile-hook)
  534. X+     (and (buffer-modified-p)
  535. X+      func
  536. X+      (progn
  537. X+        (message "Compiling keyboard macro...")
  538. X+        (let ((mac (MacEdit-read-macro
  539. X+                (and (buffer-name MacEdit-original-buffer)
  540. X+                 (save-excursion
  541. X+                   (set-buffer MacEdit-original-buffer)
  542. X+                   (current-local-map))))))
  543. X+          (and (buffer-name MacEdit-original-buffer)
  544. X+           (switch-to-buffer MacEdit-original-buffer))
  545. X+          (funcall func mac arg))
  546. X+        (message "Compiling keyboard macro...done")))
  547. X+     (kill-buffer buf)
  548. X+     (if hook
  549. X+     (funcall hook arg)))
  550. X+ )
  551. X+ 
  552. X+ (defun MacEdit-mode ()
  553. X+   "Keyboard Macro Editing mode.  Press C-c C-c to save and exit.
  554. X+ To abort the edit, just kill this buffer with C-x k RET.
  555. X+ 
  556. X+ The keyboard macro is represented as a series of M-x style command names.
  557. X+ Keystrokes which do not correspond to simple M-x commands are written as
  558. X+ \"type\" commands.  When you press C-c C-c, MacEdit converts each command
  559. X+ back into a suitable keystroke sequence; \"type\" commands are converted
  560. X+ directly back into keystrokes."
  561. X+   (interactive)
  562. X+   (error "This mode can be enabled only by edit-kbd-macro or edit-last-kbd-macro.")
  563. X+ )
  564. X+ (put 'MacEdit-mode 'mode-class 'special)
  565. X+ 
  566. X+ (defvar MacEdit-mode-map nil)
  567. X+ (if MacEdit-mode-map
  568. X+     ()
  569. X+   (setq MacEdit-mode-map (make-sparse-keymap))
  570. X+   (define-key MacEdit-mode-map "\C-c\C-c" 'MacEdit-finish-edit)
  571. X+ )
  572. X+ 
  573. SHAR_EOF
  574. chmod 0666 calc.patch || echo "restore of calc.patch fails"
  575. rm -f s2_seq_.tmp
  576. echo "You have unpacked the last part"
  577. exit 0
  578.  
  579.