X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/16f635545126842f3c732cc7300c92b866d7c826..2d4e1e6e5a3877adc1b13d47881e6e74b6665c61:/lisp/macros.el

diff --git a/lisp/macros.el b/lisp/macros.el
index cbb612494b..e333bc106b 100644
--- a/lisp/macros.el
+++ b/lisp/macros.el
@@ -1,6 +1,6 @@
 ;;; macros.el --- non-primitive commands for keyboard macros.
 
-;; Copyright (C) 1985, 1986, 1987, 1992 Free Software Foundation, Inc.
+;; Copyright (C) 1985, 86, 87, 92, 94, 95 Free Software Foundation, Inc.
 
 ;; Maintainer: FSF
 ;; Keywords: abbrev
@@ -18,8 +18,9 @@
 ;; GNU General Public License for more details.
 
 ;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING.  If not, write to
-;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+;; along with GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
 
 ;;; Commentary:
 
@@ -44,6 +45,8 @@ Such a \"function\" cannot be called from Lisp, but it is a valid editor command
        (not (vectorp (symbol-function symbol)))
        (error "Function %s is already defined and not a keyboard macro."
 	      symbol))
+  (if (string-equal symbol "")
+      (error "No command name given"))
   (fset symbol last-kbd-macro))
 
 ;;;###autoload
@@ -70,29 +73,90 @@ use this command, and then save the file."
       (insert "(fset '"))
     (prin1 macroname (current-buffer))
     (insert "\n   ")
-    (let ((beg (point)) end)
-      (prin1 definition (current-buffer))
-      (setq end (point-marker))
-      (goto-char beg)
-      (while (< (point) end)
-	(let ((char (following-char)))
-	  (cond ((< char 32)
-		 (delete-region (point) (1+ (point)))
-		 (insert "\\C-" (+ 96 char)))
-		((< char 127)
-		 (forward-char 1))
-		((= char 127)
-		 (delete-region (point) (1+ (point)))
-		 (insert "\\C-?"))
-		((< char 160)
-		 (delete-region (point) (1+ (point)))
-		 (insert "\\M-C-" (- char 32)))
-		((< char 255)
-		 (delete-region (point) (1+ (point)))
-		 (insert "\\M-" (- char 128)))
-		((= char 255)
-		 (delete-region (point) (1+ (point)))
-		 (insert "\\M-C-?"))))))
+    (if (stringp definition)
+	(let ((beg (point)) end)
+	  (prin1 definition (current-buffer))
+	  (setq end (point-marker))
+	  (goto-char beg)
+	  (while (< (point) end)
+	    (let ((char (following-char)))
+	      (cond ((= char 0)
+		     (delete-region (point) (1+ (point)))
+		     (insert "\\C-@"))
+		    ((< char 27)
+		     (delete-region (point) (1+ (point)))
+		     (insert "\\C-" (+ 96 char)))
+		    ((= char ?\C-\\)
+		     (delete-region (point) (1+ (point)))
+		     (insert "\\C-\\\\"))
+		    ((< char 32)
+		     (delete-region (point) (1+ (point)))
+		     (insert "\\C-" (+ 64 char)))
+		    ((< char 127)
+		     (forward-char 1))
+		    ((= char 127)
+		     (delete-region (point) (1+ (point)))
+		     (insert "\\C-?"))
+		    ((= char 128)
+		     (delete-region (point) (1+ (point)))
+		     (insert "\\M-\\C-@"))
+		    ((= char (aref "\M-\C-\\" 0))
+		     (delete-region (point) (1+ (point)))
+		     (insert "\\M-\\C-\\\\"))
+		    ((< char 155)
+		     (delete-region (point) (1+ (point)))
+		     (insert "\\M-\\C-" (- char 32)))
+		    ((< char 160)
+		     (delete-region (point) (1+ (point)))
+		     (insert "\\M-\\C-" (- char 64)))
+		    ((= char (aref "\M-\\" 0))
+		     (delete-region (point) (1+ (point)))
+		     (insert "\\M-\\\\"))
+		    ((< char 255)
+		     (delete-region (point) (1+ (point)))
+		     (insert "\\M-" (- char 128)))
+		    ((= char 255)
+		     (delete-region (point) (1+ (point)))
+		     (insert "\\M-\\C-?"))))))
+      (if (vectorp definition)
+	  (let ((len (length definition)) (i 0) char mods)
+	    (while (< i len)
+	      (insert (if (zerop i) ?\[ ?\ ))
+	      (setq char (aref definition i)
+		    i (1+ i))
+	      (cond ((not (numberp char))
+		     (prin1 char (current-buffer)))
+		    (t
+		     (insert "?")
+		     (setq mods (event-modifiers char)
+			   char (event-basic-type char))
+		     (while mods
+		       (cond ((eq (car mods) 'control)
+			      (insert "\\C-"))
+			     ((eq (car mods) 'meta)
+			      (insert "\\M-"))
+			     ((eq (car mods) 'hyper)
+			      (insert "\\H-"))
+			     ((eq (car mods) 'super)
+			      (insert "\\s-"))
+			     ((eq (car mods) 'alt)
+			      (insert "\\A-"))
+			     ((and (eq (car mods) 'shift)
+				   (>= char ?a)
+				   (<= char ?z))
+			      (setq char (upcase char)))
+			     ((eq (car mods) 'shift)
+			      (insert "\\S-")))
+		       (setq mods (cdr mods)))
+		     (cond ((= char ?\\)
+			    (insert "\\\\"))
+			   ((= char 127)
+			    (insert "\\C-?"))
+			   ((< char 127)
+			    (insert char))
+			   (t (insert "\\" (format "%o" char)))))))
+	    (insert ?\]))
+	(prin1 definition (current-buffer))))
     (insert ")\n")
     (if keys
 	(let ((keys (where-is-internal macroname '(keymap))))
@@ -118,22 +182,22 @@ Your options are: \\<query-replace-map>
 \\[recenter]	Redisplay the screen, then ask again.
 \\[edit]	Enter recursive edit; ask again when you exit from that."
   (interactive "P")
-  (or executing-macro
+  (or executing-kbd-macro
       defining-kbd-macro
       (error "Not defining or executing kbd macro"))
   (if flag
-      (let (executing-macro defining-kbd-macro)
+      (let (executing-kbd-macro defining-kbd-macro)
 	(recursive-edit))
-    (if (not executing-macro)
+    (if (not executing-kbd-macro)
 	nil
       (let ((loop t)
 	    (msg (substitute-command-keys
 		  "Proceed with macro?\\<query-replace-map>\
  (\\[act], \\[skip], \\[exit], \\[recenter], \\[edit]) ")))
 	(while loop
-	  (let ((key (let ((executing-macro nil)
+	  (let ((key (let ((executing-kbd-macro nil)
 			   (defining-kbd-macro nil))
-		       (message msg)
+		       (message "%s" msg)
 		       (read-event)))
 		def)
 	    (setq key (vector key))
@@ -142,14 +206,14 @@ Your options are: \\<query-replace-map>
 		   (setq loop nil))
 		  ((eq def 'skip)
 		   (setq loop nil)
-		   (setq executing-macro ""))
+		   (setq executing-kbd-macro ""))
 		  ((eq def 'exit)
 		   (setq loop nil)
-		   (setq executing-macro t))
+		   (setq executing-kbd-macro t))
 		  ((eq def 'recenter)
 		   (recenter nil))
 		  ((eq def 'edit)
-		   (let (executing-macro defining-kbd-macro)
+		   (let (executing-kbd-macro defining-kbd-macro)
 		     (recursive-edit)))
 		  ((eq def 'quit)
 		   (setq quit-flag t))
@@ -165,8 +229,10 @@ Possibilities: \\<query-replace-map>
 \\[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."))))
-		  )))))))
+\\[edit]	Enter recursive edit; ask again when you exit from that."))
+		     (save-excursion
+		       (set-buffer standard-output)
+		       (help-mode)))))))))))
 
 ;;;###autoload
 (defun apply-macro-to-region-lines (top bottom &optional macro)
@@ -237,4 +303,6 @@ and then select the region of un-tablified names and use
 
 ;;;###autoload (define-key ctl-x-map "q" 'kbd-macro-query)
 
+(provide 'macros)
+
 ;;; macros.el ends here