(custom-set-variables): Set options with :require

[gnu-emacs] / lisp / macros.el

diff --git a/lisp/macros.el b/lisp/macros.el
index 0fe325aadd3bf8ad1c48032da791fd7b4e028804..0857dd3c2db751be723c1fd63bf0a7824c7045c4 100644 (file)
--- a/lisp/macros.el
+++ b/lisp/macros.el
@@ -1,6 +1,6 @@
-;;; macros.el --- non-primitive commands for keyboard macros.
+;;; macros.el --- non-primitive commands for keyboard macros
 
-;; Copyright (C) 1985, 1986, 1987, 1992, 1994 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:
 
@@ -42,8 +43,10 @@ Such a \"function\" cannot be called from Lisp, but it is a valid editor command
   (and (fboundp symbol)
        (not (stringp (symbol-function symbol)))
        (not (vectorp (symbol-function symbol)))
-       (error "Function %s is already defined and not a keyboard macro."
+       (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
@@ -116,39 +119,44 @@ use this command, and then save the file."
                     (delete-region (point) (1+ (point)))
                     (insert "\\M-\\C-?"))))))
       (if (vectorp definition)
-         (let ((len (length definition)) (i 0) char)
+         (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 (and (wholenump char) (< char 256)))
+             (cond ((not (numberp char))
                     (prin1 char (current-buffer)))
-                   ((= char 0)
-                    (insert "?\\C-@"))
-                   ((< char 27)
-                    (insert "?\\C-" (+ 96 char)))
-                   ((= char ?\C-\\)
-                    (insert "?\\C-\\\\"))
-                   ((< char 32)
-                    (insert "?\\C-" (+ 64 char)))
-                   ((< char 127)
-                    (insert ?? char))
-                   ((= char 127)
-                    (insert "?\\C-?"))
-                   ((= char 128)
-                    (insert "?\\M-\\C-@"))
-                   ((= char (aref "\M-\C-\\" 0))
-                    (insert "?\\M-\\C-\\\\"))
-                   ((< char 155)
-                    (insert "?\\M-\\C-" (- char 32)))
-                   ((< char 160)
-                    (insert "?\\M-\\C-" (- char 64)))
-                   ((= char (aref "\M-\\" 0))
-                    (insert "?\\M-\\\\"))
-                   ((< char 255)
-                    (insert "?\\M-" (- char 128)))
-                   ((= char 255)
-                    (insert "?\\M-\\C-?"))))
+                   (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 ?\;)
+                           (insert "\\;"))
+                          ((= char 127)
+                           (insert "\\C-?"))
+                          ((< char 127)
+                           (insert char))
+                          (t (insert "\\" (format "%o" char)))))))
            (insert ?\]))
        (prin1 definition (current-buffer))))
     (insert ")\n")
@@ -176,22 +184,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))
@@ -200,14 +208,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))
@@ -273,7 +281,7 @@ and then select the region of un-tablified names and use
   (or macro
       (progn
        (if (null last-kbd-macro)
-           (error "No keyboard macro has been defined."))
+           (error "No keyboard macro has been defined"))
        (setq macro last-kbd-macro)))
   (save-excursion
     (let ((end-marker (progn
@@ -297,4 +305,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