src/macros.c

   1 /* Keyboard macros.
   2    Copyright (C) 1985, 1986, 1993 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20
  21 #include <config.h>
  22 #include "lisp.h"
  23 #include "macros.h"
  24 #include "commands.h"
  25 #include "buffer.h"
  26 #include "window.h"
  27
  28 Lisp_Object Qexecute_kbd_macro;
  29
  30 Lisp_Object Vlast_kbd_macro;
  31
  32 Lisp_Object Vexecuting_macro;
  33 int executing_macro_index;
  34
  35 Lisp_Object Fexecute_kbd_macro ();
  36 \f
  37 DEFUN ("start-kbd-macro", Fstart_kbd_macro, Sstart_kbd_macro, 1, 1, "P",
  38   "Record subsequent keyboard input, defining a keyboard macro.\n\
  39 The commands are recorded even as they are executed.\n\
  40 Use \\[end-kbd-macro] to finish recording and make the macro available.\n\
  41 Use \\[name-last-kbd-macro] to give it a permanent name.\n\
  42 Non-nil arg (prefix arg) means append to last macro defined;\n\
  43  This begins by re-executing that macro as if you typed it again.")
  44   (append)
  45      Lisp_Object append;
  46 {
  47   if (!NILP (current_perdisplay->defining_kbd_macro))
  48     error ("Already defining kbd macro");
  49
  50   if (!current_perdisplay->kbd_macro_buffer)
  51     {
  52       current_perdisplay->kbd_macro_bufsize = 30;
  53       current_perdisplay->kbd_macro_buffer
  54         = (Lisp_Object *)malloc (30 * sizeof (Lisp_Object));
  55     }
  56   update_mode_lines++;
  57   if (NILP (append))
  58     {
  59       current_perdisplay->kbd_macro_ptr = current_perdisplay->kbd_macro_buffer;
  60       current_perdisplay->kbd_macro_end = current_perdisplay->kbd_macro_buffer;
  61       message("Defining kbd macro...");
  62     }
  63   else
  64     {
  65       message("Appending to kbd macro...");
  66       current_perdisplay->kbd_macro_ptr = current_perdisplay->kbd_macro_end;
  67       Fexecute_kbd_macro (Vlast_kbd_macro, make_number (1));
  68     }
  69   current_perdisplay->defining_kbd_macro = Qt;
  70
  71   return Qnil;
  72 }
  73
  74 DEFUN ("end-kbd-macro", Fend_kbd_macro, Send_kbd_macro, 0, 1, "p",
  75   "Finish defining a keyboard macro.\n\
  76 The definition was started by \\[start-kbd-macro].\n\
  77 The macro is now available for use via \\[call-last-kbd-macro],\n\
  78 or it can be given a name with \\[name-last-kbd-macro] and then invoked\n\
  79 under that name.\n\
  80 \n\
  81 With numeric arg, repeat macro now that many times,\n\
  82 counting the definition just completed as the first repetition.\n\
  83 An argument of zero means repeat until error.")
  84   (arg)
  85      Lisp_Object arg;
  86 {
  87   if (NILP (current_perdisplay->defining_kbd_macro))
  88       error ("Not defining kbd macro.");
  89
  90   if (NILP (arg))
  91     XSETFASTINT (arg, 1);
  92   else
  93     CHECK_NUMBER (arg, 0);
  94
  95   if (!NILP (current_perdisplay->defining_kbd_macro))
  96     {
  97       current_perdisplay->defining_kbd_macro = Qnil;
  98       update_mode_lines++;
  99       Vlast_kbd_macro
 100         = make_event_array ((current_perdisplay->kbd_macro_end
 101                              - current_perdisplay->kbd_macro_buffer),
 102                             current_perdisplay->kbd_macro_buffer);
 103       message("Keyboard macro defined");
 104     }
 105
 106   if (XFASTINT (arg) == 0)
 107     Fexecute_kbd_macro (Vlast_kbd_macro, arg);
 108   else
 109     {
 110       XSETINT (arg, XINT (arg)-1);
 111       if (XINT (arg) > 0)
 112         Fexecute_kbd_macro (Vlast_kbd_macro, arg);
 113     }
 114   return Qnil;
 115 }
 116
 117 /* Store character c into kbd macro being defined */
 118
 119 store_kbd_macro_char (c)
 120      Lisp_Object c;
 121 {
 122   if (!NILP (current_perdisplay->defining_kbd_macro))
 123     {
 124       if ((current_perdisplay->kbd_macro_ptr
 125            - current_perdisplay->kbd_macro_buffer)
 126           == current_perdisplay->kbd_macro_bufsize)
 127         {
 128           register Lisp_Object *new;
 129           current_perdisplay->kbd_macro_bufsize *= 2;
 130           new = (Lisp_Object *)xrealloc (current_perdisplay->kbd_macro_buffer,
 131                                          (current_perdisplay->kbd_macro_bufsize
 132                                           * sizeof (Lisp_Object)));
 133           current_perdisplay->kbd_macro_ptr
 134             += new - current_perdisplay->kbd_macro_buffer;
 135           current_perdisplay->kbd_macro_end
 136             += new - current_perdisplay->kbd_macro_buffer;
 137           current_perdisplay->kbd_macro_buffer = new;
 138         }
 139       *current_perdisplay->kbd_macro_ptr++ = c;
 140     }
 141 }
 142
 143 /* Declare that all chars stored so far in the kbd macro being defined
 144  really belong to it.  This is done in between editor commands.  */
 145
 146 finalize_kbd_macro_chars ()
 147 {
 148   current_perdisplay->kbd_macro_end = current_perdisplay->kbd_macro_ptr;
 149 }
 150 \f
 151 DEFUN ("call-last-kbd-macro", Fcall_last_kbd_macro, Scall_last_kbd_macro,
 152   0, 1, "p",
 153   "Call the last keyboard macro that you defined with \\[start-kbd-macro].\n\
 154 \n\
 155 A prefix argument serves as a repeat count.  Zero means repeat until error.\n\
 156 \n\
 157 To make a macro permanent so you can call it even after\n\
 158 defining others, use \\[name-last-kbd-macro].")
 159   (prefix)
 160      Lisp_Object prefix;
 161 {
 162   if (! NILP (current_perdisplay->defining_kbd_macro))
 163     error ("Can't execute anonymous macro while defining one");
 164   else if (NILP (Vlast_kbd_macro))
 165     error ("No kbd macro has been defined");
 166   else
 167     Fexecute_kbd_macro (Vlast_kbd_macro, prefix);
 168   return Qnil;
 169 }
 170
 171 /* Restore Vexecuting_macro and executing_macro_index - called when
 172    the unwind-protect in Fexecute_kbd_macro gets invoked.  */
 173 static Lisp_Object
 174 pop_kbd_macro (info)
 175      Lisp_Object info;
 176 {
 177   Lisp_Object tem;
 178   Vexecuting_macro = Fcar (info);
 179   tem = Fcdr (info);
 180   executing_macro_index = XINT (tem);
 181   return Qnil;
 182 }
 183
 184 DEFUN ("execute-kbd-macro", Fexecute_kbd_macro, Sexecute_kbd_macro, 1, 2, 0,
 185   "Execute MACRO as string of editor command characters.\n\
 186 If MACRO is a symbol, its function definition is used.\n\
 187 COUNT is a repeat count, or nil for once, or 0 for infinite loop.")
 188   (macro, prefixarg)
 189      Lisp_Object macro, prefixarg;
 190 {
 191   Lisp_Object final;
 192   Lisp_Object tem;
 193   int count = specpdl_ptr - specpdl;
 194   int repeat = 1;
 195   struct gcpro gcpro1;
 196
 197   if (!NILP (prefixarg))
 198     prefixarg = Fprefix_numeric_value (prefixarg),
 199     repeat = XINT (prefixarg);
 200
 201   final = indirect_function (macro);
 202   if (!STRINGP (final) && !VECTORP (final))
 203     error ("Keyboard macros must be strings or vectors.");
 204
 205   XSETFASTINT (tem, executing_macro_index);
 206   tem = Fcons (Vexecuting_macro, tem);
 207   record_unwind_protect (pop_kbd_macro, tem);
 208
 209   GCPRO1 (final);
 210   do
 211     {
 212       Vexecuting_macro = final;
 213       executing_macro_index = 0;
 214
 215       if (!current_perdisplay)
 216         abort ();
 217       clear_prefix_arg ();
 218       command_loop_1 ();
 219
 220       QUIT;
 221     }
 222   while (--repeat
 223          && (STRINGP (Vexecuting_macro) || VECTORP (Vexecuting_macro)));
 224
 225   UNGCPRO;
 226   return unbind_to (count, Qnil);
 227 }
 228 \f
 229 init_macros ()
 230 {
 231   Vlast_kbd_macro = Qnil;
 232   Vexecuting_macro = Qnil;
 233 }
 234
 235 syms_of_macros ()
 236 {
 237   Qexecute_kbd_macro = intern ("execute-kbd-macro");
 238   staticpro (&Qexecute_kbd_macro);
 239
 240   defsubr (&Sstart_kbd_macro);
 241   defsubr (&Send_kbd_macro);
 242   defsubr (&Scall_last_kbd_macro);
 243   defsubr (&Sexecute_kbd_macro);
 244
 245   DEFVAR_DISPLAY ("defining-kbd-macro", defining_kbd_macro,
 246     "Non-nil while a keyboard macro is being defined.  Don't set this!");
 247
 248   DEFVAR_LISP ("executing-macro", &Vexecuting_macro,
 249     "Currently executing keyboard macro (a string); nil if none executing.");
 250
 251   DEFVAR_LISP_NOPRO ("executing-kbd-macro", &Vexecuting_macro,
 252     "Currently executing keyboard macro (a string); nil if none executing.");
 253
 254   DEFVAR_LISP ("last-kbd-macro", &Vlast_kbd_macro,
 255     "Last kbd macro defined, as a string; nil if none defined.");
 256 }
 257
 258 keys_of_macros ()
 259 {
 260   initial_define_key (control_x_map, ('e'), "call-last-kbd-macro");
 261   initial_define_key (control_x_map, ('('), "start-kbd-macro");
 262   initial_define_key (control_x_map, (')'), "end-kbd-macro");
 263 }