/* Keyboard macros. Copyright (C) 1985, 1986, 1993 Free Software Foundation, Inc.This file is part of GNU Emacs.GNU Emacs is free software; you can redistribute it and/or modifyit under the terms of the GNU General Public License as published bythe Free Software Foundation; either version 2, or (at your option)any later version.GNU Emacs is distributed in the hope that it will be useful,but WITHOUT ANY WARRANTY; without even the implied warranty ofMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See theGNU General Public License for more details.You should have received a copy of the GNU General Public Licensealong with GNU Emacs; see the file COPYING. If not, write tothe Free Software Foundation, Inc., 59 Temple Place - Suite 330,Boston, MA 02111-1307, USA. */#include <config.h>#include "lisp.h"#include "macros.h"#include "commands.h"#include "buffer.h"#include "window.h"#include "keyboard.h"Lisp_Object Qexecute_kbd_macro;/* Kbd macro currently being executed (a string or vector). */Lisp_Object Vexecuting_macro;/* Index of next character to fetch from that macro. */int executing_macro_index;/* Number of successful iterations so far for innermost keyboard macro. This is not bound at each level, so after an error, it describes the innermost interrupted macro. */int executing_macro_iterations;/* This is the macro that was executing. This is not bound at each level, so after an error, it describes the innermost interrupted macro. We use it only as a kind of flag, so no need to protect it. */Lisp_Object executing_macro;Lisp_Object Fexecute_kbd_macro ();DEFUN ("start-kbd-macro", Fstart_kbd_macro, Sstart_kbd_macro, 1, 1, "P", "Record subsequent keyboard input, defining a keyboard macro.\n\The commands are recorded even as they are executed.\n\Use \\[end-kbd-macro] to finish recording and make the macro available.\n\Use \\[name-last-kbd-macro] to give it a permanent name.\n\Non-nil arg (prefix arg) means append to last macro defined;\n\ This begins by re-executing that macro as if you typed it again.") (append) Lisp_Object append;{ if (!NILP (current_kboard->defining_kbd_macro)) error ("Already defining kbd macro"); if (!current_kboard->kbd_macro_buffer) { current_kboard->kbd_macro_bufsize = 30; current_kboard->kbd_macro_buffer = (Lisp_Object *)xmalloc (30 * sizeof (Lisp_Object)); } update_mode_lines++; if (NILP (append)) { if (current_kboard->kbd_macro_bufsize > 200) { current_kboard->kbd_macro_bufsize = 30; current_kboard->kbd_macro_buffer = (Lisp_Object *)xrealloc (current_kboard->kbd_macro_buffer, 30 * sizeof (Lisp_Object)); } current_kboard->kbd_macro_ptr = current_kboard->kbd_macro_buffer; current_kboard->kbd_macro_end = current_kboard->kbd_macro_buffer; message ("Defining kbd macro..."); } else { message ("Appending to kbd macro..."); current_kboard->kbd_macro_ptr = current_kboard->kbd_macro_end; Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, make_number (1)); } current_kboard->defining_kbd_macro = Qt; return Qnil;}DEFUN ("end-kbd-macro", Fend_kbd_macro, Send_kbd_macro, 0, 1, "p", "Finish defining a keyboard macro.\n\The definition was started by \\[start-kbd-macro].\n\The macro is now available for use via \\[call-last-kbd-macro],\n\or it can be given a name with \\[name-last-kbd-macro] and then invoked\n\under that name.\n\\n\With numeric arg, repeat macro now that many times,\n\counting the definition just completed as the first repetition.\n\An argument of zero means repeat until error.") (repeat) Lisp_Object repeat;{ if (NILP (current_kboard->defining_kbd_macro)) error ("Not defining kbd macro."); if (NILP (repeat)) XSETFASTINT (repeat, 1); else CHECK_NUMBER (repeat, 0); if (!NILP (current_kboard->defining_kbd_macro)) { current_kboard->defining_kbd_macro = Qnil; update_mode_lines++; current_kboard->Vlast_kbd_macro = make_event_array ((current_kboard->kbd_macro_end - current_kboard->kbd_macro_buffer), current_kboard->kbd_macro_buffer); message ("Keyboard macro defined"); } if (XFASTINT (repeat) == 0) Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, repeat); else { XSETINT (repeat, XINT (repeat)-1); if (XINT (repeat) > 0) Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, repeat); } return Qnil;}/* Store character c into kbd macro being defined */store_kbd_macro_char (c) Lisp_Object c;{ if (!NILP (current_kboard->defining_kbd_macro)) { if ((current_kboard->kbd_macro_ptr - current_kboard->kbd_macro_buffer) == current_kboard->kbd_macro_bufsize) { register Lisp_Object *new; current_kboard->kbd_macro_bufsize *= 2; new = (Lisp_Object *)xrealloc (current_kboard->kbd_macro_buffer, (current_kboard->kbd_macro_bufsize * sizeof (Lisp_Object))); current_kboard->kbd_macro_ptr += new - current_kboard->kbd_macro_buffer; current_kboard->kbd_macro_end += new - current_kboard->kbd_macro_buffer; current_kboard->kbd_macro_buffer = new; } *current_kboard->kbd_macro_ptr++ = c; }}/* Declare that all chars stored so far in the kbd macro being defined really belong to it. This is done in between editor commands. */finalize_kbd_macro_chars (){ current_kboard->kbd_macro_end = current_kboard->kbd_macro_ptr;}DEFUN ("cancel-kbd-macro-events", Fcancel_kbd_macro_events, Scancel_kbd_macro_events, 0, 0, 0, "Cancel the events added to a keyboard macro for this command.") (){ current_kboard->kbd_macro_ptr = current_kboard->kbd_macro_end;}DEFUN ("store-kbd-macro-event", Fstore_kbd_macro_event, Sstore_kbd_macro_event, 1, 1, 0, "Store EVENT into the keyboard macro being defined.") (event) Lisp_Object event;{ store_kbd_macro_char (event); return Qnil;}DEFUN ("call-last-kbd-macro", Fcall_last_kbd_macro, Scall_last_kbd_macro, 0, 1, "p", "Call the last keyboard macro that you defined with \\[start-kbd-macro].\n\\n\A prefix argument serves as a repeat count. Zero means repeat until error.\n\\n\To make a macro permanent so you can call it even after\n\defining others, use \\[name-last-kbd-macro].") (prefix) Lisp_Object prefix;{ /* Don't interfere with recognition of the previous command from before this macro started. */ this_command = current_kboard->Vlast_command; if (! NILP (current_kboard->defining_kbd_macro)) error ("Can't execute anonymous macro while defining one"); else if (NILP (current_kboard->Vlast_kbd_macro)) error ("No kbd macro has been defined"); else Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, prefix); /* command_loop_1 sets this to nil before it returns; get back the last command within the macro so that it can be last, again, after we return. */ this_command = current_kboard->Vlast_command; return Qnil;}/* Restore Vexecuting_macro and executing_macro_index - called when the unwind-protect in Fexecute_kbd_macro gets invoked. */static Lisp_Objectpop_kbd_macro (info) Lisp_Object info;{ Lisp_Object tem; Vexecuting_macro = Fcar (info); tem = Fcdr (info); executing_macro_index = XINT (tem); return Qnil;}DEFUN ("execute-kbd-macro", Fexecute_kbd_macro, Sexecute_kbd_macro, 1, 2, 0, "Execute MACRO as string of editor command characters.\n\If MACRO is a symbol, its function definition is used.\n\COUNT is a repeat count, or nil for once, or 0 for infinite loop.") (macro, count) Lisp_Object macro, count;{ Lisp_Object final; Lisp_Object tem; int pdlcount = specpdl_ptr - specpdl; int repeat = 1; struct gcpro gcpro1; int success_count = 0; if (!NILP (count)) { count = Fprefix_numeric_value (count); repeat = XINT (count); } final = indirect_function (macro); if (!STRINGP (final) && !VECTORP (final)) error ("Keyboard macros must be strings or vectors."); XSETFASTINT (tem, executing_macro_index); tem = Fcons (Vexecuting_macro, tem); record_unwind_protect (pop_kbd_macro, tem); GCPRO1 (final); do { Vexecuting_macro = final; executing_macro = final; executing_macro_index = 0; current_kboard->Vprefix_arg = Qnil; command_loop_1 (); executing_macro_iterations = ++success_count; QUIT; } while (--repeat && (STRINGP (Vexecuting_macro) || VECTORP (Vexecuting_macro))); executing_macro = Qnil; UNGCPRO; return unbind_to (pdlcount, Qnil);}init_macros (){ Vexecuting_macro = Qnil; executing_macro = Qnil;}syms_of_macros (){ Qexecute_kbd_macro = intern ("execute-kbd-macro"); staticpro (&Qexecute_kbd_macro); defsubr (&Sstart_kbd_macro); defsubr (&Send_kbd_macro); defsubr (&Scall_last_kbd_macro); defsubr (&Sexecute_kbd_macro); defsubr (&Scancel_kbd_macro_events); defsubr (&Sstore_kbd_macro_event); DEFVAR_KBOARD ("defining-kbd-macro", defining_kbd_macro, "Non-nil while a keyboard macro is being defined. Don't set this!"); DEFVAR_LISP ("executing-macro", &Vexecuting_macro, "Currently executing keyboard macro (string or vector); nil if none executing."); DEFVAR_LISP_NOPRO ("executing-kbd-macro", &Vexecuting_macro, "Currently executing keyboard macro (string or vector); nil if none executing."); DEFVAR_KBOARD ("last-kbd-macro", Vlast_kbd_macro, "Last kbd macro defined, as a string or vector; nil if none defined.");}keys_of_macros (){ initial_define_key (control_x_map, ('e'), "call-last-kbd-macro"); initial_define_key (control_x_map, ('('), "start-kbd-macro"); initial_define_key (control_x_map, (')'), "end-kbd-macro");}