(texinfo-block-default): New var.
[emacs.git] / src / macros.c
blob3c6e0b33edbda170feee5e0b18bd0e331502252c
1 /* Keyboard macros.
2 Copyright (C) 1985, 1986, 1993 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
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.
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.
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. */
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"
30 Lisp_Object Qexecute_kbd_macro;
32 /* Kbd macro currently being executed (a string or vector). */
34 Lisp_Object Vexecuting_macro;
36 /* Index of next character to fetch from that macro. */
38 int executing_macro_index;
40 /* Number of successful iterations so far
41 for innermost keyboard macro.
42 This is not bound at each level,
43 so after an error, it describes the innermost interrupted macro. */
45 int executing_macro_iterations;
47 /* This is the macro that was executing.
48 This is not bound at each level,
49 so after an error, it describes the innermost interrupted macro.
50 We use it only as a kind of flag, so no need to protect it. */
52 Lisp_Object executing_macro;
54 extern Lisp_Object real_this_command;
56 Lisp_Object Fexecute_kbd_macro ();
58 DEFUN ("start-kbd-macro", Fstart_kbd_macro, Sstart_kbd_macro, 1, 1, "P",
59 "Record subsequent keyboard input, defining a keyboard macro.\n\
60 The commands are recorded even as they are executed.\n\
61 Use \\[end-kbd-macro] to finish recording and make the macro available.\n\
62 Use \\[name-last-kbd-macro] to give it a permanent name.\n\
63 Non-nil arg (prefix arg) means append to last macro defined;\n\
64 This begins by re-executing that macro as if you typed it again.")
65 (append)
66 Lisp_Object append;
68 if (!NILP (current_kboard->defining_kbd_macro))
69 error ("Already defining kbd macro");
71 if (!current_kboard->kbd_macro_buffer)
73 current_kboard->kbd_macro_bufsize = 30;
74 current_kboard->kbd_macro_buffer
75 = (Lisp_Object *)xmalloc (30 * sizeof (Lisp_Object));
77 update_mode_lines++;
78 if (NILP (append))
80 if (current_kboard->kbd_macro_bufsize > 200)
82 current_kboard->kbd_macro_bufsize = 30;
83 current_kboard->kbd_macro_buffer
84 = (Lisp_Object *)xrealloc (current_kboard->kbd_macro_buffer,
85 30 * sizeof (Lisp_Object));
87 current_kboard->kbd_macro_ptr = current_kboard->kbd_macro_buffer;
88 current_kboard->kbd_macro_end = current_kboard->kbd_macro_buffer;
89 message ("Defining kbd macro...");
91 else
93 int i, len;
95 /* Check the type of last-kbd-macro in case Lisp code changed it. */
96 if (!STRINGP (current_kboard->Vlast_kbd_macro)
97 && !VECTORP (current_kboard->Vlast_kbd_macro))
98 current_kboard->Vlast_kbd_macro
99 = wrong_type_argument (Qarrayp, current_kboard->Vlast_kbd_macro);
101 len = XINT (Flength (current_kboard->Vlast_kbd_macro));
103 /* Copy last-kbd-macro into the buffer, in case the Lisp code
104 has put another macro there. */
105 if (current_kboard->kbd_macro_bufsize < len + 30)
107 current_kboard->kbd_macro_bufsize = len + 30;
108 current_kboard->kbd_macro_buffer
109 = (Lisp_Object *)xrealloc (current_kboard->kbd_macro_buffer,
110 (len + 30) * sizeof (Lisp_Object));
112 for (i = 0; i < len; i++)
113 current_kboard->kbd_macro_buffer[i]
114 = Faref (current_kboard->Vlast_kbd_macro, make_number (i));
116 current_kboard->kbd_macro_ptr = current_kboard->kbd_macro_buffer + len;
117 current_kboard->kbd_macro_end = current_kboard->kbd_macro_ptr;
119 /* Re-execute the macro we are appending to,
120 for consistency of behavior. */
121 Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro,
122 make_number (1));
124 message ("Appending to kbd macro...");
126 current_kboard->defining_kbd_macro = Qt;
128 return Qnil;
131 DEFUN ("end-kbd-macro", Fend_kbd_macro, Send_kbd_macro, 0, 1, "p",
132 "Finish defining a keyboard macro.\n\
133 The definition was started by \\[start-kbd-macro].\n\
134 The macro is now available for use via \\[call-last-kbd-macro],\n\
135 or it can be given a name with \\[name-last-kbd-macro] and then invoked\n\
136 under that name.\n\
138 With numeric arg, repeat macro now that many times,\n\
139 counting the definition just completed as the first repetition.\n\
140 An argument of zero means repeat until error.")
141 (repeat)
142 Lisp_Object repeat;
144 if (NILP (current_kboard->defining_kbd_macro))
145 error ("Not defining kbd macro");
147 if (NILP (repeat))
148 XSETFASTINT (repeat, 1);
149 else
150 CHECK_NUMBER (repeat, 0);
152 if (!NILP (current_kboard->defining_kbd_macro))
154 current_kboard->defining_kbd_macro = Qnil;
155 update_mode_lines++;
156 current_kboard->Vlast_kbd_macro
157 = make_event_array ((current_kboard->kbd_macro_end
158 - current_kboard->kbd_macro_buffer),
159 current_kboard->kbd_macro_buffer);
160 message ("Keyboard macro defined");
163 if (XFASTINT (repeat) == 0)
164 Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, repeat);
165 else
167 XSETINT (repeat, XINT (repeat)-1);
168 if (XINT (repeat) > 0)
169 Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, repeat);
171 return Qnil;
174 /* Store character c into kbd macro being defined */
176 void
177 store_kbd_macro_char (c)
178 Lisp_Object c;
180 if (!NILP (current_kboard->defining_kbd_macro))
182 if ((current_kboard->kbd_macro_ptr
183 - current_kboard->kbd_macro_buffer)
184 == current_kboard->kbd_macro_bufsize)
186 register Lisp_Object *new;
187 current_kboard->kbd_macro_bufsize *= 2;
188 new = (Lisp_Object *)xrealloc (current_kboard->kbd_macro_buffer,
189 (current_kboard->kbd_macro_bufsize
190 * sizeof (Lisp_Object)));
191 current_kboard->kbd_macro_ptr
192 += new - current_kboard->kbd_macro_buffer;
193 current_kboard->kbd_macro_end
194 += new - current_kboard->kbd_macro_buffer;
195 current_kboard->kbd_macro_buffer = new;
197 *current_kboard->kbd_macro_ptr++ = c;
201 /* Declare that all chars stored so far in the kbd macro being defined
202 really belong to it. This is done in between editor commands. */
204 void
205 finalize_kbd_macro_chars ()
207 current_kboard->kbd_macro_end = current_kboard->kbd_macro_ptr;
210 DEFUN ("cancel-kbd-macro-events", Fcancel_kbd_macro_events,
211 Scancel_kbd_macro_events, 0, 0, 0,
212 "Cancel the events added to a keyboard macro for this command.")
215 current_kboard->kbd_macro_ptr = current_kboard->kbd_macro_end;
216 return Qnil;
219 DEFUN ("store-kbd-macro-event", Fstore_kbd_macro_event,
220 Sstore_kbd_macro_event, 1, 1, 0,
221 "Store EVENT into the keyboard macro being defined.")
222 (event)
223 Lisp_Object event;
225 store_kbd_macro_char (event);
226 return Qnil;
229 DEFUN ("call-last-kbd-macro", Fcall_last_kbd_macro, Scall_last_kbd_macro,
230 0, 1, "p",
231 "Call the last keyboard macro that you defined with \\[start-kbd-macro].\n\
233 A prefix argument serves as a repeat count. Zero means repeat until error.\n\
235 To make a macro permanent so you can call it even after\n\
236 defining others, use \\[name-last-kbd-macro].")
237 (prefix)
238 Lisp_Object prefix;
240 /* Don't interfere with recognition of the previous command
241 from before this macro started. */
242 Vthis_command = current_kboard->Vlast_command;
243 /* C-x z after the macro should repeat the macro. */
244 real_this_command = current_kboard->Vlast_kbd_macro;
246 if (! NILP (current_kboard->defining_kbd_macro))
247 error ("Can't execute anonymous macro while defining one");
248 else if (NILP (current_kboard->Vlast_kbd_macro))
249 error ("No kbd macro has been defined");
250 else
251 Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, prefix);
253 /* command_loop_1 sets this to nil before it returns;
254 get back the last command within the macro
255 so that it can be last, again, after we return. */
256 Vthis_command = current_kboard->Vlast_command;
258 return Qnil;
261 /* Restore Vexecuting_macro and executing_macro_index - called when
262 the unwind-protect in Fexecute_kbd_macro gets invoked. */
264 static Lisp_Object
265 pop_kbd_macro (info)
266 Lisp_Object info;
268 Lisp_Object tem;
269 Vexecuting_macro = XCAR (info);
270 tem = XCDR (info);
271 executing_macro_index = XINT (XCAR (tem));
272 real_this_command = XCDR (tem);
273 return Qnil;
276 DEFUN ("execute-kbd-macro", Fexecute_kbd_macro, Sexecute_kbd_macro, 1, 2, 0,
277 "Execute MACRO as string of editor command characters.\n\
278 If MACRO is a symbol, its function definition is used.\n\
279 COUNT is a repeat count, or nil for once, or 0 for infinite loop.")
280 (macro, count)
281 Lisp_Object macro, count;
283 Lisp_Object final;
284 Lisp_Object tem;
285 int pdlcount = specpdl_ptr - specpdl;
286 int repeat = 1;
287 struct gcpro gcpro1;
288 int success_count = 0;
290 executing_macro_iterations = 0;
292 if (!NILP (count))
294 count = Fprefix_numeric_value (count);
295 repeat = XINT (count);
298 final = indirect_function (macro);
299 if (!STRINGP (final) && !VECTORP (final))
300 error ("Keyboard macros must be strings or vectors");
302 tem = Fcons (Vexecuting_macro,
303 Fcons (make_number (executing_macro_index),
304 real_this_command));
305 record_unwind_protect (pop_kbd_macro, tem);
307 GCPRO1 (final);
310 Vexecuting_macro = final;
311 executing_macro = final;
312 executing_macro_index = 0;
314 current_kboard->Vprefix_arg = Qnil;
315 command_loop_1 ();
317 executing_macro_iterations = ++success_count;
319 QUIT;
321 while (--repeat
322 && (STRINGP (Vexecuting_macro) || VECTORP (Vexecuting_macro)));
324 executing_macro = Qnil;
326 real_this_command = Vexecuting_macro;
328 UNGCPRO;
329 return unbind_to (pdlcount, Qnil);
332 void
333 init_macros ()
335 Vexecuting_macro = Qnil;
336 executing_macro = Qnil;
339 void
340 syms_of_macros ()
342 Qexecute_kbd_macro = intern ("execute-kbd-macro");
343 staticpro (&Qexecute_kbd_macro);
345 defsubr (&Sstart_kbd_macro);
346 defsubr (&Send_kbd_macro);
347 defsubr (&Scall_last_kbd_macro);
348 defsubr (&Sexecute_kbd_macro);
349 defsubr (&Scancel_kbd_macro_events);
350 defsubr (&Sstore_kbd_macro_event);
352 DEFVAR_KBOARD ("defining-kbd-macro", defining_kbd_macro,
353 "Non-nil while a keyboard macro is being defined. Don't set this!");
355 DEFVAR_LISP ("executing-macro", &Vexecuting_macro,
356 "Currently executing keyboard macro (string or vector); nil if none executing.");
358 DEFVAR_LISP_NOPRO ("executing-kbd-macro", &Vexecuting_macro,
359 "Currently executing keyboard macro (string or vector); nil if none executing.");
361 DEFVAR_KBOARD ("last-kbd-macro", Vlast_kbd_macro,
362 "Last kbd macro defined, as a string or vector; nil if none defined.");
365 void
366 keys_of_macros ()
368 initial_define_key (control_x_map, ('e'), "call-last-kbd-macro");
369 initial_define_key (control_x_map, ('('), "start-kbd-macro");
370 initial_define_key (control_x_map, (')'), "end-kbd-macro");