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