code.delx.au - gnu-emacs/blob - src/macros.c

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