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, Inc., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21
  22 #include <config.h>
  23 #include "lisp.h"
  24 #include "macros.h"
  25 #include "commands.h"
  26 #include "buffer.h"
  27 #include "window.h"
  28 #include "keyboard.h"
  29
  30 Lisp_Object Qexecute_kbd_macro;
  31
  32 /* Kbd macro currently being executed (a string or vector).  */
  33
  34 Lisp_Object Vexecuting_macro;
  35
  36 /* Index of next character to fetch from that macro.  */
  37
  38 int executing_macro_index;
  39
  40 /* Number of successful iterations so far
  41    for innermost keyboard macro.
  42    This is not bound at each level,
  43    so after an error, it describes the innermost interrupted macro.  */
  44
  45 int executing_macro_iterations;
  46
  47 /* This is the macro that was executing.
  48    This is not bound at each level,
  49    so after an error, it describes the innermost interrupted macro.
  50    We use it only as a kind of flag, so no need to protect it.  */
  51
  52 Lisp_Object executing_macro;
  53
  54 Lisp_Object Fexecute_kbd_macro ();
  55 \f
  56 DEFUN ("start-kbd-macro", Fstart_kbd_macro, Sstart_kbd_macro, 1, 1, "P",
  57   "Record subsequent keyboard input, defining a keyboard macro.\n\
  58 The commands are recorded even as they are executed.\n\
  59 Use \\[end-kbd-macro] to finish recording and make the macro available.\n\
  60 Use \\[name-last-kbd-macro] to give it a permanent name.\n\
  61 Non-nil arg (prefix arg) means append to last macro defined;\n\
  62  This begins by re-executing that macro as if you typed it again.")
  63   (append)
  64      Lisp_Object append;
  65 {
  66   if (!NILP (current_kboard->defining_kbd_macro))
  67     error ("Already defining kbd macro");
  68
  69   if (!current_kboard->kbd_macro_buffer)
  70     {
  71       current_kboard->kbd_macro_bufsize = 30;
  72       current_kboard->kbd_macro_buffer
  73         = (Lisp_Object *)xmalloc (30 * sizeof (Lisp_Object));
  74     }
  75   update_mode_lines++;
  76   if (NILP (append))
  77     {
  78       if (current_kboard->kbd_macro_bufsize > 200)
  79         {
  80           current_kboard->kbd_macro_bufsize = 30;
  81           current_kboard->kbd_macro_buffer
  82             = (Lisp_Object *)xrealloc (current_kboard->kbd_macro_buffer,
  83                                        30 * sizeof (Lisp_Object));
  84         }
  85       current_kboard->kbd_macro_ptr = current_kboard->kbd_macro_buffer;
  86       current_kboard->kbd_macro_end = current_kboard->kbd_macro_buffer;
  87       message ("Defining kbd macro...");
  88     }
  89   else
  90     {
  91       message ("Appending to kbd macro...");
  92       current_kboard->kbd_macro_ptr = current_kboard->kbd_macro_end;
  93       Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro,
  94                           make_number (1));
  95     }
  96   current_kboard->defining_kbd_macro = Qt;
  97
  98   return Qnil;
  99 }
 100
 101 DEFUN ("end-kbd-macro", Fend_kbd_macro, Send_kbd_macro, 0, 1, "p",
 102   "Finish defining a keyboard macro.\n\
 103 The definition was started by \\[start-kbd-macro].\n\
 104 The macro is now available for use via \\[call-last-kbd-macro],\n\
 105 or it can be given a name with \\[name-last-kbd-macro] and then invoked\n\
 106 under that name.\n\
 107 \n\
 108 With numeric arg, repeat macro now that many times,\n\
 109 counting the definition just completed as the first repetition.\n\
 110 An argument of zero means repeat until error.")
 111   (repeat)
 112      Lisp_Object repeat;
 113 {
 114   if (NILP (current_kboard->defining_kbd_macro))
 115     error ("Not defining kbd macro.");
 116
 117   if (NILP (repeat))
 118     XSETFASTINT (repeat, 1);
 119   else
 120     CHECK_NUMBER (repeat, 0);
 121
 122   if (!NILP (current_kboard->defining_kbd_macro))
 123     {
 124       current_kboard->defining_kbd_macro = Qnil;
 125       update_mode_lines++;
 126       current_kboard->Vlast_kbd_macro
 127         = make_event_array ((current_kboard->kbd_macro_end
 128                              - current_kboard->kbd_macro_buffer),
 129                             current_kboard->kbd_macro_buffer);
 130       message ("Keyboard macro defined");
 131     }
 132
 133   if (XFASTINT (repeat) == 0)
 134     Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, repeat);
 135   else
 136     {
 137       XSETINT (repeat, XINT (repeat)-1);
 138       if (XINT (repeat) > 0)
 139         Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, repeat);
 140     }
 141   return Qnil;
 142 }
 143
 144 /* Store character c into kbd macro being defined */
 145
 146 store_kbd_macro_char (c)
 147      Lisp_Object c;
 148 {
 149   if (!NILP (current_kboard->defining_kbd_macro))
 150     {
 151       if ((current_kboard->kbd_macro_ptr
 152            - current_kboard->kbd_macro_buffer)
 153           == current_kboard->kbd_macro_bufsize)
 154         {
 155           register Lisp_Object *new;
 156           current_kboard->kbd_macro_bufsize *= 2;
 157           new = (Lisp_Object *)xrealloc (current_kboard->kbd_macro_buffer,
 158                                          (current_kboard->kbd_macro_bufsize
 159                                           * sizeof (Lisp_Object)));
 160           current_kboard->kbd_macro_ptr
 161             += new - current_kboard->kbd_macro_buffer;
 162           current_kboard->kbd_macro_end
 163             += new - current_kboard->kbd_macro_buffer;
 164           current_kboard->kbd_macro_buffer = new;
 165         }
 166       *current_kboard->kbd_macro_ptr++ = c;
 167     }
 168 }
 169
 170 /* Declare that all chars stored so far in the kbd macro being defined
 171  really belong to it.  This is done in between editor commands.  */
 172
 173 finalize_kbd_macro_chars ()
 174 {
 175   current_kboard->kbd_macro_end = current_kboard->kbd_macro_ptr;
 176 }
 177
 178 DEFUN ("cancel-kbd-macro-events", Fcancel_kbd_macro_events,
 179        Scancel_kbd_macro_events, 0, 0, 0,
 180   "Cancel the events added to a keyboard macro for this command.")
 181   ()
 182 {
 183   current_kboard->kbd_macro_ptr = current_kboard->kbd_macro_end;
 184 }
 185
 186 DEFUN ("store-kbd-macro-event", Fstore_kbd_macro_event,
 187        Sstore_kbd_macro_event, 1, 1, 0,
 188   "Store EVENT into the keyboard macro being defined.")
 189   (event)
 190      Lisp_Object event;
 191 {
 192   store_kbd_macro_char (event);
 193   return Qnil;
 194 }
 195 \f
 196 DEFUN ("call-last-kbd-macro", Fcall_last_kbd_macro, Scall_last_kbd_macro,
 197   0, 1, "p",
 198   "Call the last keyboard macro that you defined with \\[start-kbd-macro].\n\
 199 \n\
 200 A prefix argument serves as a repeat count.  Zero means repeat until error.\n\
 201 \n\
 202 To make a macro permanent so you can call it even after\n\
 203 defining others, use \\[name-last-kbd-macro].")
 204   (prefix)
 205      Lisp_Object prefix;
 206 {
 207   /* Don't interfere with recognition of the previous command
 208      from before this macro started.  */
 209   this_command = current_kboard->Vlast_command;
 210
 211   if (! NILP (current_kboard->defining_kbd_macro))
 212     error ("Can't execute anonymous macro while defining one");
 213   else if (NILP (current_kboard->Vlast_kbd_macro))
 214     error ("No kbd macro has been defined");
 215   else
 216     Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, prefix);
 217
 218   /* command_loop_1 sets this to nil before it returns;
 219      get back the last command within the macro
 220      so that it can be last, again, after we return.  */
 221   this_command = current_kboard->Vlast_command;
 222
 223   return Qnil;
 224 }
 225
 226 /* Restore Vexecuting_macro and executing_macro_index - called when
 227    the unwind-protect in Fexecute_kbd_macro gets invoked.  */
 228
 229 static Lisp_Object
 230 pop_kbd_macro (info)
 231      Lisp_Object info;
 232 {
 233   Lisp_Object tem;
 234   Vexecuting_macro = Fcar (info);
 235   tem = Fcdr (info);
 236   executing_macro_index = XINT (tem);
 237   return Qnil;
 238 }
 239
 240 DEFUN ("execute-kbd-macro", Fexecute_kbd_macro, Sexecute_kbd_macro, 1, 2, 0,
 241   "Execute MACRO as string of editor command characters.\n\
 242 If MACRO is a symbol, its function definition is used.\n\
 243 COUNT is a repeat count, or nil for once, or 0 for infinite loop.")
 244   (macro, count)
 245      Lisp_Object macro, count;
 246 {
 247   Lisp_Object final;
 248   Lisp_Object tem;
 249   int pdlcount = specpdl_ptr - specpdl;
 250   int repeat = 1;
 251   struct gcpro gcpro1;
 252   int success_count = 0;
 253
 254   if (!NILP (count))
 255     {
 256       count = Fprefix_numeric_value (count);
 257       repeat = XINT (count);
 258     }
 259
 260   final = indirect_function (macro);
 261   if (!STRINGP (final) && !VECTORP (final))
 262     error ("Keyboard macros must be strings or vectors.");
 263
 264   XSETFASTINT (tem, executing_macro_index);
 265   tem = Fcons (Vexecuting_macro, tem);
 266   record_unwind_protect (pop_kbd_macro, tem);
 267
 268   GCPRO1 (final);
 269   do
 270     {
 271       Vexecuting_macro = final;
 272       executing_macro = final;
 273       executing_macro_index = 0;
 274
 275       current_kboard->Vprefix_arg = Qnil;
 276       command_loop_1 ();
 277
 278       executing_macro_iterations = ++success_count;
 279
 280       QUIT;
 281     }
 282   while (--repeat
 283          && (STRINGP (Vexecuting_macro) || VECTORP (Vexecuting_macro)));
 284
 285   executing_macro = Qnil;
 286
 287   UNGCPRO;
 288   return unbind_to (pdlcount, Qnil);
 289 }
 290 \f
 291 init_macros ()
 292 {
 293   Vexecuting_macro = Qnil;
 294   executing_macro = Qnil;
 295 }
 296
 297 syms_of_macros ()
 298 {
 299   Qexecute_kbd_macro = intern ("execute-kbd-macro");
 300   staticpro (&Qexecute_kbd_macro);
 301
 302   defsubr (&Sstart_kbd_macro);
 303   defsubr (&Send_kbd_macro);
 304   defsubr (&Scall_last_kbd_macro);
 305   defsubr (&Sexecute_kbd_macro);
 306   defsubr (&Scancel_kbd_macro_events);
 307   defsubr (&Sstore_kbd_macro_event);
 308
 309   DEFVAR_KBOARD ("defining-kbd-macro", defining_kbd_macro,
 310     "Non-nil while a keyboard macro is being defined.  Don't set this!");
 311
 312   DEFVAR_LISP ("executing-macro", &Vexecuting_macro,
 313     "Currently executing keyboard macro (string or vector); nil if none executing.");
 314
 315   DEFVAR_LISP_NOPRO ("executing-kbd-macro", &Vexecuting_macro,
 316     "Currently executing keyboard macro (string or vector); nil if none executing.");
 317
 318   DEFVAR_KBOARD ("last-kbd-macro", Vlast_kbd_macro,
 319     "Last kbd macro defined, as a string or vector; nil if none defined.");
 320 }
 321
 322 keys_of_macros ()
 323 {
 324   initial_define_key (control_x_map, ('e'), "call-last-kbd-macro");
 325   initial_define_key (control_x_map, ('('), "start-kbd-macro");
 326   initial_define_key (control_x_map, (')'), "end-kbd-macro");
 327 }