2 Copyright (C) 1985, 1986, 1992, 1993, 1994 Free Software Foundation, Inc.
4 This file is part of XEmacs.
6 XEmacs is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
11 XEmacs is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with XEmacs; 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. */
21 /* Synched up with: FSF 19.30. */
23 /* A keyboard macro is a string of ASCII characters, or a vector of event
24 objects. Only key-press, mouse-press, mouse-release, and menu-selection
25 events ever get into a keyboard macro.
27 When interactively defining a keyboard macro, it will always be a vector
28 of events; strings may be executed for backwards compatibility.
42 Lisp_Object Qexecute_kbd_macro;
44 /* The current macro and our position in it. When executing nested kbd
45 macros, previous values for these are wound through the execution stack
48 Lisp_Object Vexecuting_macro;
49 int executing_macro_index;
52 DEFUN ("start-kbd-macro", Fstart_kbd_macro, 1, 1, "P", /*
53 Record subsequent keyboard and menu input, defining a keyboard macro.
54 The commands are recorded even as they are executed.
55 Use \\[end-kbd-macro] to finish recording and make the macro available.
56 Use \\[name-last-kbd-macro] to give it a permanent name.
57 Non-nil arg (prefix arg) means append to last macro defined;
58 This begins by re-executing that macro as if you typed it again.
62 /* This function can GC */
63 struct console *con = XCONSOLE (Vselected_console);
64 if (!NILP (con->defining_kbd_macro))
65 error ("Already defining kbd macro");
67 if (NILP (con->kbd_macro_builder))
68 con->kbd_macro_builder = make_vector (30, Qnil);
70 zmacs_region_stays = 1; /* set this before calling Fexecute_kbd_macro()
71 so that functions there can override */
72 MARK_MODELINE_CHANGED;
75 con->kbd_macro_ptr = 0;
76 con->kbd_macro_end = 0;
77 message ("Defining kbd macro...");
81 message ("Appending to kbd macro...");
82 con->kbd_macro_ptr = con->kbd_macro_end;
83 Fexecute_kbd_macro (con->last_kbd_macro, make_int (1));
85 con->defining_kbd_macro = Qt;
90 DEFUN ("end-kbd-macro", Fend_kbd_macro, 0, 1, "P", /*
91 Finish defining a keyboard macro.
92 The definition was started by \\[start-kbd-macro].
93 The macro is now available for use via \\[call-last-kbd-macro],
94 or it can be given a name with \\[name-last-kbd-macro] and then invoked
97 With numeric arg, repeat macro now that many times,
98 counting the definition just completed as the first repetition.
99 An argument of zero means repeat until error.
103 /* This function can GC */
104 struct console *con = XCONSOLE (Vselected_console);
107 if (NILP (con->defining_kbd_macro))
108 error ("Not defining kbd macro");
113 repeat = XINT (Fprefix_numeric_value (arg));
115 if (!NILP (con->defining_kbd_macro))
118 int size = con->kbd_macro_end;
122 con->last_kbd_macro = make_vector (size, Qnil);
123 for (i = 0; i < size; i++)
124 XVECTOR_DATA (con->last_kbd_macro) [i] =
125 XVECTOR_DATA (con->kbd_macro_builder) [i];
126 con->defining_kbd_macro = Qnil;
127 MARK_MODELINE_CHANGED;
128 message ("Keyboard macro defined");
131 zmacs_region_stays = 1; /* set this before calling Fexecute_kbd_macro()
132 so that functions there can override */
135 else if (repeat == 0)
136 return Fexecute_kbd_macro (con->last_kbd_macro, Qzero);
138 return Fexecute_kbd_macro (con->last_kbd_macro,
139 make_int (repeat - 1));
142 /* #### Read the comment in modeline.el to see why this ugliness is
143 needed. #### Try to avoid it, somehow! */
144 DEFUN ("zap-last-kbd-macro-event", Fzap_last_kbd_macro_event, 0, 0, 0, /*
145 Don't look at this lest you vomit or spontaneously combust.
149 struct console *con = XCONSOLE (Vselected_console);
150 if (con->kbd_macro_end)
151 --con->kbd_macro_end;
155 /* Store event into kbd macro being defined
158 store_kbd_macro_event (Lisp_Object event)
160 struct console *con = event_console_or_selected (event);
162 if (con->kbd_macro_ptr == XVECTOR_LENGTH (con->kbd_macro_builder))
165 int old_size = XVECTOR_LENGTH (con->kbd_macro_builder);
166 int new_size = old_size * 2;
167 Lisp_Object new = make_vector (new_size, Qnil);
168 for (i = 0; i < old_size; i++)
169 XVECTOR_DATA (new) [i] = XVECTOR_DATA (con->kbd_macro_builder) [i];
170 con->kbd_macro_builder = new;
172 XVECTOR_DATA (con->kbd_macro_builder) [con->kbd_macro_ptr++] =
173 Fcopy_event (event, Qnil);
176 /* Extract the next kbd-macro element into the given event.
177 If we're done, throws to the catch in Fexecute_kbd_macro().
180 pop_kbd_macro_event (Lisp_Object event)
182 if (NILP (Vexecuting_macro)) ABORT ();
184 if (STRINGP (Vexecuting_macro) || VECTORP (Vexecuting_macro))
186 if (executing_macro_index < XINT (Flength (Vexecuting_macro)))
188 nth_of_key_sequence_as_event (Vexecuting_macro,
189 executing_macro_index++,
194 else if (!EQ (Vexecuting_macro, Qt)) /* Some things replace the macro
195 with Qt to force an early exit. */
196 error ("junk in executing-macro");
198 Fthrow (Qexecute_kbd_macro, Qt);
202 /* Declare that all chars stored so far in the kbd macro being defined
203 really belong to it. This is done in between editor commands. */
206 finalize_kbd_macro_chars (struct console *con)
208 con->kbd_macro_end = con->kbd_macro_ptr;
211 DEFUN ("cancel-kbd-macro-events", Fcancel_kbd_macro_events, 0, 0, 0, /*
212 Cancel the events added to a keyboard macro for this command.
216 struct console *con = XCONSOLE (Vselected_console);
218 con->kbd_macro_ptr = con->kbd_macro_end;
223 DEFUN ("call-last-kbd-macro", Fcall_last_kbd_macro, 0, 1, "p", /*
224 Call the last keyboard macro that you defined with \\[start-kbd-macro].
226 A prefix argument serves as a repeat count. Zero means repeat until error.
228 To make a macro permanent so you can call it even after
229 defining others, use \\[name-last-kbd-macro].
233 /* This function can GC */
234 struct console *con = XCONSOLE (Vselected_console);
236 if (!NILP (con->defining_kbd_macro))
237 error ("Can't execute anonymous macro while defining one");
238 else if (NILP (con->last_kbd_macro))
239 error ("No kbd macro has been defined");
241 Fexecute_kbd_macro (con->last_kbd_macro, prefix);
245 /* Restore Vexecuting_macro and executing_macro_index - called when
246 the unwind-protect in Fexecute_kbd_macro gets invoked. */
248 pop_kbd_macro (Lisp_Object info)
250 Vexecuting_macro = Fcar (info);
251 executing_macro_index = XINT (Fcdr (info));
255 DEFUN ("execute-kbd-macro", Fexecute_kbd_macro, 1, 2, 0, /*
256 Execute MACRO as string of editor command characters.
257 If MACRO is a symbol, its function definition is used.
258 COUNT is a repeat count, or nil for once, or 0 for infinite loop.
262 /* This function can GC */
265 int speccount = specpdl_depth ();
268 struct console *con = XCONSOLE (Vselected_console);
272 count = Fprefix_numeric_value (count);
273 repeat = XINT (count);
276 final = indirect_function (macro, 1);
277 if (!STRINGP (final) && !VECTORP (final))
278 error ("Keyboard macros must be strings or vectors");
280 tem = Fcons (Vexecuting_macro, make_int (executing_macro_index));
281 record_unwind_protect (pop_kbd_macro, tem);
286 Vexecuting_macro = final;
287 executing_macro_index = 0;
288 con->prefix_arg = Qnil;
289 internal_catch (Qexecute_kbd_macro, call_command_loop,
293 && (STRINGP (Vexecuting_macro) ||
294 VECTORP (Vexecuting_macro)));
297 return unbind_to (speccount, Qnil);
302 syms_of_macros (void)
304 DEFSUBR (Fstart_kbd_macro);
305 DEFSUBR (Fend_kbd_macro);
306 DEFSUBR (Fzap_last_kbd_macro_event);
307 DEFSUBR (Fcall_last_kbd_macro);
308 DEFSUBR (Fexecute_kbd_macro);
309 DEFSUBR (Fcancel_kbd_macro_events);
310 defsymbol (&Qexecute_kbd_macro, "execute-kbd-macro");
314 vars_of_macros (void)
316 DEFVAR_LISP ("executing-macro", &Vexecuting_macro /*
317 Currently executing keyboard macro (a vector of events or string);
318 nil if none executing.
321 DEFVAR_LISP ("executing-kbd-macro", &Vexecuting_macro /*
322 Currently executing keyboard macro (a vector of events or string);
323 nil if none executing.
330 Vexecuting_macro = Qnil;