(pages-copy-header-and-position): Call end-of-line, not forward-line.

[bpt/emacs.git] / lisp / macros.el

diff --git a/lisp/macros.el b/lisp/macros.el
index 41c0218..1e093a7 100644 (file)
--- a/lisp/macros.el
+++ b/lisp/macros.el
@@ -41,6 +41,7 @@ Such a \"function\" cannot be called from Lisp, but it is a valid editor command
       (error "No keyboard macro defined"))
   (and (fboundp symbol)
        (not (stringp (symbol-function symbol)))
+       (not (vectorp (symbol-function symbol)))
        (error "Function %s is already defined and not a keyboard macro."
              symbol))
   (fset symbol last-kbd-macro))
@@ -109,12 +110,13 @@ use this command, and then save the file."
   With prefix argument, enters recursive edit, reading keyboard
 commands even within a kbd macro.  You can give different commands
 each time the macro executes.
-  Without prefix argument, reads a character.  Your options are:
-Space -- execute the rest of the macro.
-DEL -- skip the rest of the macro; start next repetition.
-C-d -- skip rest of the macro and don't repeat it any more.
-C-r -- enter a recursive edit, then on exit ask again for a character
-C-l -- redisplay screen and ask again."
+  Without prefix argument, asks whether to continue running the macro.
+Your options are: \\<query-replace-map>
+\\[act]        Finish this iteration normally and continue with the next.
+\\[skip]       Skip the rest of this iteration, and start the next.
+\\[exit]       Stop the macro entirely right now.
+\\[recenter]   Redisplay the screen, then ask again.
+\\[edit]       Enter recursive edit; ask again when you exit from that."
   (interactive "P")
   (or executing-macro
       defining-kbd-macro
@@ -124,25 +126,47 @@ C-l -- redisplay screen and ask again."
        (recursive-edit))
     (if (not executing-macro)
        nil
-      (let ((loop t))
+      (let ((loop t)
+           (msg (substitute-command-keys
+                 "Proceed with macro?\\<query-replace-map>\
+ (\\[act], \\[skip], \\[exit], \\[recenter], \\[edit]) ")))
        (while loop
-         (let ((char (let ((executing-macro nil)
-                           (defining-kbd-macro nil))
-                       (message "Proceed with macro? (Space, DEL, C-d, C-r or C-l) ")
-                       (read-char))))
-           (cond ((= char ? )
+         (let ((key (let ((executing-macro nil)
+                          (defining-kbd-macro nil))
+                      (message msg)
+                      (read-event)))
+               def)
+           (setq key (vector key))
+           (setq def (lookup-key query-replace-map key))
+           (cond ((eq def 'act)
                   (setq loop nil))
-                 ((= char ?\177)
+                 ((eq def 'skip)
                   (setq loop nil)
                   (setq executing-macro ""))
-                 ((= char ?\C-d)
+                 ((eq def 'exit)
                   (setq loop nil)
                   (setq executing-macro t))
-                 ((= char ?\C-l)
+                 ((eq def 'recenter)
                   (recenter nil))
-                 ((= char ?\C-r)
+                 ((eq def 'edit)
                   (let (executing-macro defining-kbd-macro)
-                    (recursive-edit))))))))))
+                    (recursive-edit)))
+                 ((eq def 'quit)
+                  (setq quit-flag t))
+                 (t
+                  (or (eq def 'help)
+                      (ding))
+                  (with-output-to-temp-buffer "*Help*"
+                    (princ
+                     (substitute-command-keys
+                      "Specify how to proceed with keyboard macro execution.
+Possibilities: \\<query-replace-map>
+\\[act]        Finish this iteration normally and continue with the next.
+\\[skip]       Skip the rest of this iteration, and start the next.
+\\[exit]       Stop the macro entirely right now.
+\\[recenter]   Redisplay the screen, then ask again.
+\\[edit]       Enter recursive edit; ask again when you exit from that."))))
+                 )))))))
 
 ;;;###autoload
 (defun apply-macro-to-region-lines (top bottom &optional macro)
@@ -211,7 +235,6 @@ and then select the region of un-tablified names and use
       (set-marker end-marker nil)
       (set-marker next-line-marker nil))))
 
-;;;###autoload
-(define-key ctl-x-map "q" 'kbd-macro-query)
+;;;###autoload (define-key ctl-x-map "q" 'kbd-macro-query)
 
 ;;; macros.el ends here