src/macros.c

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