Merge from emacs-24; up to 2012-12-06T01:39:03Z!monnier@iro.umontreal.ca

[gnu-emacs] / lisp / macros.el

diff --git a/lisp/macros.el b/lisp/macros.el
index 43b5b2ae9450c53abb7400ce9915eb57fcfa8066..b6db9bdcdef94f7c0a831ce33a287e18e709229a 100644 (file)
--- a/lisp/macros.el
+++ b/lisp/macros.el
@@ -1,16 +1,18 @@
-;;; macros.el --- non-primitive commands for keyboard macros.
+;;; macros.el --- non-primitive commands for keyboard macros

 
 

-;; Copyright (C) 1985, 1986, 1987, 1992 Free Software Foundation, Inc.
+;; Copyright (C) 1985-1987, 1992, 1994-1995, 2001-2013 Free Software
+;; Foundation, Inc.

 
 ;; Maintainer: FSF
 ;; Keywords: abbrev
 
 ;; Maintainer: FSF
 ;; Keywords: abbrev

+;; Package: emacs

 
 ;; This file is part of GNU Emacs.
 
 
 ;; This file is part of GNU Emacs.
 

-;; GNU Emacs is free software; you can redistribute it and/or modify
+;; GNU Emacs is free software: you can redistribute it and/or modify

 ;; it under the terms of the GNU General Public License as published by
 ;; it under the terms of the GNU General Public License as published by

-;; the Free Software Foundation; either version 2, or (at your option)
-;; any later version.
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.

 
 ;; GNU Emacs is distributed in the hope that it will be useful,
 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
 
 ;; GNU Emacs is distributed in the hope that it will be useful,
 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of


@@ -18,8 +20,7 @@
 ;; GNU General Public License for more details.
 
 ;; You should have received a copy of the GNU General Public License
 ;; 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.  If not, see <http://www.gnu.org/licenses/>.

 
 ;;; Commentary:
 
 
 ;;; Commentary:
 


@@ -41,8 +42,11 @@ 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)))
       (error "No keyboard macro defined"))
   (and (fboundp symbol)
        (not (stringp (symbol-function symbol)))

-       (error "Function %s is already defined and not a keyboard macro."
+       (not (vectorp (symbol-function symbol)))
+       (error "Function %s is already defined and not a keyboard macro"

              symbol))
              symbol))

+  (if (string-equal symbol "")
+      (error "No command name given"))

   (fset symbol last-kbd-macro))
 
 ;;;###autoload
   (fset symbol last-kbd-macro))
 
 ;;;###autoload


@@ -59,7 +63,15 @@ bindings.
 
 To save a kbd macro, visit a file of Lisp code such as your `~/.emacs',
 use this command, and then save the file."
 
 To save a kbd macro, visit a file of Lisp code such as your `~/.emacs',
 use this command, and then save the file."

-  (interactive "CInsert kbd macro (name): \nP")
+  (interactive (list (intern (completing-read "Insert kbd macro (name): "
+                                             obarray
+                                             (lambda (elt)
+                                               (and (fboundp elt)
+                                                    (or (stringp (symbol-function elt))
+                                                        (vectorp (symbol-function elt))
+                                                        (get elt 'kmacro))))
+                                             t))
+                    current-prefix-arg))

   (let (definition)
     (if (string= (symbol-name macroname) "")
        (progn
   (let (definition)
     (if (string= (symbol-name macroname) "")
        (progn


@@ -69,32 +81,66 @@ use this command, and then save the file."
       (insert "(fset '"))
     (prin1 macroname (current-buffer))
     (insert "\n   ")
       (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)
+           (while (< i len)
+             (insert (if (zerop i) ?\[ ?\s))
+             (setq char (aref definition i)
+                   i (1+ i))
+             (if (not (numberp char))
+                  (prin1 char (current-buffer))
+                (princ (prin1-char char) (current-buffer))))
+           (insert ?\]))
+       (prin1 definition (current-buffer))))

     (insert ")\n")
     (if keys
     (insert ")\n")
     (if keys

-       (let ((keys (where-is-internal macroname nil)))
+       (let ((keys (where-is-internal (symbol-function macroname)
+                                      '(keymap))))

          (while keys
            (insert "(global-set-key ")
            (prin1 (car keys) (current-buffer))
          (while keys
            (insert "(global-set-key ")
            (prin1 (car keys) (current-buffer))


@@ -117,22 +163,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")
 \\[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
       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))
        (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
        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))
                           (defining-kbd-macro nil))

-                      (message msg)
+                      (message "%s" msg)

                       (read-event)))
                def)
            (setq key (vector key))
                       (read-event)))
                def)
            (setq key (vector key))


@@ -141,14 +187,14 @@ Your options are: \\<query-replace-map>
                   (setq loop nil))
                  ((eq def 'skip)
                   (setq loop nil)
                   (setq loop nil))
                  ((eq def 'skip)
                   (setq loop nil)

-                  (setq executing-macro ""))
+                  (setq executing-kbd-macro ""))

                  ((eq def 'exit)
                   (setq loop nil)
                  ((eq def 'exit)
                   (setq loop nil)

-                  (setq executing-macro t))
+                  (setq executing-kbd-macro t))

                  ((eq def 'recenter)
                   (recenter nil))
                  ((eq def 'edit)
                  ((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))
                     (recursive-edit)))
                  ((eq def 'quit)
                   (setq quit-flag t))


@@ -158,19 +204,21 @@ Your options are: \\<query-replace-map>
                   (with-output-to-temp-buffer "*Help*"
                     (princ
                      (substitute-command-keys
                   (with-output-to-temp-buffer "*Help*"
                     (princ
                      (substitute-command-keys

-                      "Specify how to procede with keyboard macro execution.
+                      "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.
 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."))))
-                 )))))))
+\\[edit]       Enter recursive edit; ask again when you exit from that."))
+                    (with-current-buffer standard-output
+                      (help-mode)))))))))))

 
 ;;;###autoload
 (defun apply-macro-to-region-lines (top bottom &optional macro)
 
 ;;;###autoload
 (defun apply-macro-to-region-lines (top bottom &optional macro)

-  "For each complete line between point and mark, move to the beginning
-of the line, and run the last keyboard macro.
+  "Apply last keyboard macro to all lines in the region.
+For each line that begins in the region, move to the beginning of
+the line, and run the last keyboard macro.

 
 When called from lisp, this function takes two arguments TOP and
 BOTTOM, describing the current region.  TOP must be before BOTTOM.
 
 When called from lisp, this function takes two arguments TOP and
 BOTTOM, describing the current region.  TOP must be before BOTTOM.


@@ -189,7 +237,7 @@ and mark at opposite ends of the quoted section, and use
 Suppose you wanted to build a keyword table in C where each entry
 looked like this:
 
 Suppose you wanted to build a keyword table in C where each entry
 looked like this:
 

-    { \"foo\", foo_data, foo_function }, 
+    { \"foo\", foo_data, foo_function },

     { \"bar\", bar_data, bar_function },
     { \"baz\", baz_data, baz_function },
 
     { \"bar\", bar_data, bar_function },
     { \"baz\", baz_data, baz_function },
 


@@ -206,19 +254,15 @@ and write a macro to massage a word into a table entry:
     \\C-x )
 
 and then select the region of un-tablified names and use
     \\C-x )
 
 and then select the region of un-tablified names and use

-`\\[apply-macro-to-region-lines]' to build the table from the names.
-"
+`\\[apply-macro-to-region-lines]' to build the table from the names."

   (interactive "r")
   (or macro
       (progn
        (if (null last-kbd-macro)
   (interactive "r")
   (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
        (setq macro last-kbd-macro)))
   (save-excursion

-    (let ((end-marker (progn
-                       (goto-char bottom)
-                       (beginning-of-line)
-                       (point-marker)))
+    (let ((end-marker (copy-marker bottom))

          next-line-marker)
       (goto-char top)
       (if (not (bolp))
          next-line-marker)
       (goto-char top)
       (if (not (bolp))


@@ -230,11 +274,13 @@ and then select the region of un-tablified names and use
          (forward-line 1)
          (set-marker next-line-marker (point)))
        (save-excursion
          (forward-line 1)
          (set-marker next-line-marker (point)))
        (save-excursion

-         (execute-kbd-macro (or macro last-kbd-macro))))
+         (let ((mark-active nil))
+           (execute-kbd-macro macro))))

       (set-marker end-marker nil)
       (set-marker next-line-marker nil))))
 
       (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)
+
+(provide 'macros)

 
 ;;; macros.el ends here
 
 ;;; macros.el ends here