lisp/macros.el

   1 ;;; macros.el --- non-primitive commands for keyboard macros.
   2
   3 ;; Copyright (C) 1985, 1986, 1987 Free Software Foundation, Inc.
   4
   5 ;; Maintainer: FSF
   6
   7 ;; This file is part of GNU Emacs.
   8
   9 ;; GNU Emacs is free software; you can redistribute it and/or modify
  10 ;; it under the terms of the GNU General Public License as published by
  11 ;; the Free Software Foundation; either version 2, or (at your option)
  12 ;; any later version.
  13
  14 ;; GNU Emacs is distributed in the hope that it will be useful,
  15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 ;; GNU General Public License for more details.
  18
  19 ;; You should have received a copy of the GNU General Public License
  20 ;; along with GNU Emacs; see the file COPYING.  If not, write to
  21 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  22
  23 ;;; Code:
  24
  25 ;;;###autoload
  26 (defun name-last-kbd-macro (symbol)
  27   "Assign a name to the last keyboard macro defined.
  28 Argument SYMBOL is the name to define.
  29 The symbol's function definition becomes the keyboard macro string.
  30 Such a \"function\" cannot be called from Lisp, but it is a valid editor command."
  31   (interactive "SName for last kbd macro: ")
  32   (or last-kbd-macro
  33       (error "No keyboard macro defined"))
  34   (and (fboundp symbol)
  35        (not (stringp (symbol-function symbol)))
  36        (error "Function %s is already defined and not a keyboard macro."
  37               symbol))
  38   (fset symbol last-kbd-macro))
  39
  40 ;;;###autoload
  41 (defun insert-kbd-macro (macroname &optional keys)
  42   "Insert in buffer the definition of kbd macro NAME, as Lisp code.
  43 Optional second arg KEYS means also record the keys it is on
  44 (this is the prefix argument, when calling interactively).
  45
  46 This Lisp code will, when executed, define the kbd macro with the same
  47 definition it has now.  If you say to record the keys, the Lisp code
  48 will also rebind those keys to the macro.  Only global key bindings
  49 are recorded since executing this Lisp code always makes global
  50 bindings.
  51
  52 To save a kbd macro, visit a file of Lisp code such as your ~/.emacs,
  53 use this command, and then save the file."
  54   (interactive "CInsert kbd macro (name): \nP")
  55   (insert "(fset '")
  56   (prin1 macroname (current-buffer))
  57   (insert "\n   ")
  58   (prin1 (symbol-function macroname) (current-buffer))
  59   (insert ")\n")
  60   (if keys
  61       (let ((keys (where-is-internal macroname nil)))
  62         (while keys
  63           (insert "(global-set-key ")
  64           (prin1 (car keys) (current-buffer))
  65           (insert " '")
  66           (prin1 macroname (current-buffer))
  67           (insert ")\n")
  68           (setq keys (cdr keys))))))
  69
  70 ;;;###autoload
  71 (defun kbd-macro-query (flag)
  72   "Query user during kbd macro execution.
  73   With prefix argument, enters recursive edit, reading keyboard
  74 commands even within a kbd macro.  You can give different commands
  75 each time the macro executes.
  76   Without prefix argument, reads a character.  Your options are:
  77 Space -- execute the rest of the macro.
  78 DEL -- skip the rest of the macro; start next repetition.
  79 C-d -- skip rest of the macro and don't repeat it any more.
  80 C-r -- enter a recursive edit, then on exit ask again for a character
  81 C-l -- redisplay screen and ask again."
  82   (interactive "P")
  83   (or executing-macro
  84       defining-kbd-macro
  85       (error "Not defining or executing kbd macro"))
  86   (if flag
  87       (let (executing-macro defining-kbd-macro)
  88         (recursive-edit))
  89     (if (not executing-macro)
  90         nil
  91       (let ((loop t))
  92         (while loop
  93           (let ((char (let ((executing-macro nil)
  94                             (defining-kbd-macro nil))
  95                         (message "Proceed with macro? (Space, DEL, C-d, C-r or C-l) ")
  96                         (read-char))))
  97             (cond ((= char ? )
  98                    (setq loop nil))
  99                   ((= char ?\177)
 100                    (setq loop nil)
 101                    (setq executing-macro ""))
 102                   ((= char ?\C-d)
 103                    (setq loop nil)
 104                    (setq executing-macro t))
 105                   ((= char ?\C-l)
 106                    (recenter nil))
 107                   ((= char ?\C-r)
 108                    (let (executing-macro defining-kbd-macro)
 109                      (recursive-edit))))))))))
 110
 111 ;;;###autoload
 112 (defun apply-macro-to-region-lines (top bottom &optional macro)
 113   "For each complete line between point and mark, move to the beginning
 114 of the line, and run the last keyboard macro.
 115
 116 When called from lisp, this function takes two arguments TOP and
 117 BOTTOM, describing the current region.  TOP must be before BOTTOM.
 118 The optional third argument MACRO specifies a keyboard macro to
 119 execute.
 120
 121 This is useful for quoting or unquoting included text, adding and
 122 removing comments, or producing tables where the entries are regular.
 123
 124 For example, in Usenet articles, sections of text quoted from another
 125 author are indented, or have each line start with `>'.  To quote a
 126 section of text, define a keyboard macro which inserts `>', put point
 127 and mark at opposite ends of the quoted section, and use
 128 `\\[apply-macro-to-region-lines]' to mark the entire section.
 129
 130 Suppose you wanted to build a keyword table in C where each entry
 131 looked like this:
 132
 133     { \"foo\", foo_data, foo_function },
 134     { \"bar\", bar_data, bar_function },
 135     { \"baz\", baz_data, baz_function },
 136
 137 You could enter the names in this format:
 138
 139     foo
 140     bar
 141     baz
 142
 143 and write a macro to massage a word into a table entry:
 144
 145     \\C-x (
 146        \\M-d { \"\\C-y\", \\C-y_data, \\C-y_function },
 147     \\C-x )
 148
 149 and then select the region of un-tablified names and use
 150 `\\[apply-macro-to-region-lines]' to build the table from the names.
 151 "
 152   (interactive "r")
 153   (or macro
 154       (progn
 155         (if (null last-kbd-macro)
 156             (error "No keyboard macro has been defined."))
 157         (setq macro last-kbd-macro)))
 158   (save-excursion
 159     (let ((end-marker (progn
 160                         (goto-char bottom)
 161                         (beginning-of-line)
 162                         (point-marker)))
 163           next-line-marker)
 164       (goto-char top)
 165       (if (not (bolp))
 166           (forward-line 1))
 167       (setq next-line-marker (point-marker))
 168       (while (< next-line-marker end-marker)
 169         (goto-char next-line-marker)
 170         (save-excursion
 171           (forward-line 1)
 172           (set-marker next-line-marker (point)))
 173         (save-excursion
 174           (execute-kbd-macro (or macro last-kbd-macro))))
 175       (set-marker end-marker nil)
 176       (set-marker next-line-marker nil))))
 177
 178 ;;;###autoload
 179 (define-key ctl-x-map "q" 'kbd-macro-query)
 180
 181 ;;; macros.el ends here