src/macros.c

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