* gnutls.c (emacs_gnutls_handshake): Revert last change. Add QUIT
[emacs.git] / src / macros.c
blobd43e37513f50377027622174e1cbdd27061f1c30
1 /* Keyboard macros.
3 Copyright (C) 1985-1986, 1993, 2000-2012 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
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.
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.
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/>. */
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"
30 Lisp_Object Qexecute_kbd_macro;
31 static Lisp_Object Qkbd_macro_termination_hook;
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. */
38 EMACS_INT executing_kbd_macro_iterations;
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. */
45 Lisp_Object executing_kbd_macro;
47 Lisp_Object Fexecute_kbd_macro (Lisp_Object macro, Lisp_Object count, Lisp_Object loopfunc);
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)
60 if (!NILP (KVAR (current_kboard, defining_kbd_macro)))
61 error ("Already defining kbd macro");
63 if (!current_kboard->kbd_macro_buffer)
65 current_kboard->kbd_macro_buffer
66 = (Lisp_Object *)xmalloc (30 * sizeof (Lisp_Object));
67 current_kboard->kbd_macro_bufsize = 30;
69 update_mode_lines++;
70 if (NILP (append))
72 if (current_kboard->kbd_macro_bufsize > 200)
74 current_kboard->kbd_macro_buffer
75 = (Lisp_Object *)xrealloc (current_kboard->kbd_macro_buffer,
76 30 * sizeof (Lisp_Object));
77 current_kboard->kbd_macro_bufsize = 30;
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...");
83 else
85 ptrdiff_t i;
86 EMACS_INT len;
87 int cvt;
89 /* Check the type of last-kbd-macro in case Lisp code changed it. */
90 CHECK_VECTOR_OR_STRING (KVAR (current_kboard, Vlast_kbd_macro));
92 len = XINT (Flength (KVAR (current_kboard, Vlast_kbd_macro)));
94 /* Copy last-kbd-macro into the buffer, in case the Lisp code
95 has put another macro there. */
96 if (current_kboard->kbd_macro_bufsize < len + 30)
98 if (min (PTRDIFF_MAX, SIZE_MAX) / sizeof (Lisp_Object) - 30
99 < current_kboard->kbd_macro_bufsize)
100 memory_full (SIZE_MAX);
101 current_kboard->kbd_macro_buffer
102 = (Lisp_Object *)xrealloc (current_kboard->kbd_macro_buffer,
103 (len + 30) * sizeof (Lisp_Object));
104 current_kboard->kbd_macro_bufsize = len + 30;
107 /* Must convert meta modifier when copying string to vector. */
108 cvt = STRINGP (KVAR (current_kboard, Vlast_kbd_macro));
109 for (i = 0; i < len; i++)
111 Lisp_Object c;
112 c = Faref (KVAR (current_kboard, Vlast_kbd_macro), make_number (i));
113 if (cvt && NATNUMP (c) && (XFASTINT (c) & 0x80))
114 XSETFASTINT (c, CHAR_META | (XFASTINT (c) & ~0x80));
115 current_kboard->kbd_macro_buffer[i] = c;
118 current_kboard->kbd_macro_ptr = current_kboard->kbd_macro_buffer + len;
119 current_kboard->kbd_macro_end = current_kboard->kbd_macro_ptr;
121 /* Re-execute the macro we are appending to,
122 for consistency of behavior. */
123 if (NILP (no_exec))
124 Fexecute_kbd_macro (KVAR (current_kboard, Vlast_kbd_macro),
125 make_number (1), Qnil);
127 message ("Appending to kbd macro...");
129 KVAR (current_kboard, defining_kbd_macro) = Qt;
131 return Qnil;
134 /* Finish defining the current keyboard macro. */
136 void
137 end_kbd_macro (void)
139 KVAR (current_kboard, defining_kbd_macro) = Qnil;
140 update_mode_lines++;
141 KVAR (current_kboard, Vlast_kbd_macro)
142 = make_event_array ((current_kboard->kbd_macro_end
143 - current_kboard->kbd_macro_buffer),
144 current_kboard->kbd_macro_buffer);
147 DEFUN ("end-kbd-macro", Fend_kbd_macro, Send_kbd_macro, 0, 2, "p",
148 doc: /* Finish defining a keyboard macro.
149 The definition was started by \\[start-kbd-macro].
150 The macro is now available for use via \\[call-last-kbd-macro],
151 or it can be given a name with \\[name-last-kbd-macro] and then invoked
152 under that name.
154 With numeric arg, repeat macro now that many times,
155 counting the definition just completed as the first repetition.
156 An argument of zero means repeat until error.
158 In Lisp, optional second arg LOOPFUNC may be a function that is called prior to
159 each iteration of the macro. Iteration stops if LOOPFUNC returns nil. */)
160 (Lisp_Object repeat, Lisp_Object loopfunc)
162 if (NILP (KVAR (current_kboard, defining_kbd_macro)))
163 error ("Not defining kbd macro");
165 if (NILP (repeat))
166 XSETFASTINT (repeat, 1);
167 else
168 CHECK_NUMBER (repeat);
170 if (!NILP (KVAR (current_kboard, defining_kbd_macro)))
172 end_kbd_macro ();
173 message ("Keyboard macro defined");
176 if (XFASTINT (repeat) == 0)
177 Fexecute_kbd_macro (KVAR (current_kboard, Vlast_kbd_macro), repeat, loopfunc);
178 else if (XINT (repeat) > 1)
180 XSETINT (repeat, XINT (repeat)-1);
181 Fexecute_kbd_macro (KVAR (current_kboard, Vlast_kbd_macro),
182 repeat, loopfunc);
184 return Qnil;
187 /* Store character c into kbd macro being defined */
189 void
190 store_kbd_macro_char (Lisp_Object c)
192 struct kboard *kb = current_kboard;
194 if (!NILP (KVAR (kb, defining_kbd_macro)))
196 if (kb->kbd_macro_ptr - kb->kbd_macro_buffer == kb->kbd_macro_bufsize)
198 ptrdiff_t ptr_offset, end_offset, nbytes;
200 ptr_offset = kb->kbd_macro_ptr - kb->kbd_macro_buffer;
201 end_offset = kb->kbd_macro_end - kb->kbd_macro_buffer;
202 if (min (PTRDIFF_MAX, SIZE_MAX) / sizeof *kb->kbd_macro_buffer / 2
203 < kb->kbd_macro_bufsize)
204 memory_full (SIZE_MAX);
205 nbytes = kb->kbd_macro_bufsize * (2 * sizeof *kb->kbd_macro_buffer);
206 kb->kbd_macro_buffer
207 = (Lisp_Object *) xrealloc (kb->kbd_macro_buffer, nbytes);
208 kb->kbd_macro_bufsize *= 2;
209 kb->kbd_macro_ptr = kb->kbd_macro_buffer + ptr_offset;
210 kb->kbd_macro_end = kb->kbd_macro_buffer + end_offset;
213 *kb->kbd_macro_ptr++ = c;
217 /* Declare that all chars stored so far in the kbd macro being defined
218 really belong to it. This is done in between editor commands. */
220 void
221 finalize_kbd_macro_chars (void)
223 current_kboard->kbd_macro_end = current_kboard->kbd_macro_ptr;
226 DEFUN ("cancel-kbd-macro-events", Fcancel_kbd_macro_events,
227 Scancel_kbd_macro_events, 0, 0, 0,
228 doc: /* Cancel the events added to a keyboard macro for this command. */)
229 (void)
231 current_kboard->kbd_macro_ptr = current_kboard->kbd_macro_end;
232 return Qnil;
235 DEFUN ("store-kbd-macro-event", Fstore_kbd_macro_event,
236 Sstore_kbd_macro_event, 1, 1, 0,
237 doc: /* Store EVENT into the keyboard macro being defined. */)
238 (Lisp_Object event)
240 store_kbd_macro_char (event);
241 return Qnil;
244 DEFUN ("call-last-kbd-macro", Fcall_last_kbd_macro, Scall_last_kbd_macro,
245 0, 2, "p",
246 doc: /* Call the last keyboard macro that you defined with \\[start-kbd-macro].
248 A prefix argument serves as a repeat count. Zero means repeat until error.
250 To make a macro permanent so you can call it even after
251 defining others, use \\[name-last-kbd-macro].
253 In Lisp, optional second arg LOOPFUNC may be a function that is called prior to
254 each iteration of the macro. Iteration stops if LOOPFUNC returns nil. */)
255 (Lisp_Object prefix, Lisp_Object loopfunc)
257 /* Don't interfere with recognition of the previous command
258 from before this macro started. */
259 Vthis_command = KVAR (current_kboard, Vlast_command);
260 /* C-x z after the macro should repeat the macro. */
261 real_this_command = KVAR (current_kboard, Vlast_kbd_macro);
263 if (! NILP (KVAR (current_kboard, defining_kbd_macro)))
264 error ("Can't execute anonymous macro while defining one");
265 else if (NILP (KVAR (current_kboard, Vlast_kbd_macro)))
266 error ("No kbd macro has been defined");
267 else
268 Fexecute_kbd_macro (KVAR (current_kboard, Vlast_kbd_macro), prefix, loopfunc);
270 /* command_loop_1 sets this to nil before it returns;
271 get back the last command within the macro
272 so that it can be last, again, after we return. */
273 Vthis_command = KVAR (current_kboard, Vlast_command);
275 return Qnil;
278 /* Restore Vexecuting_kbd_macro and executing_kbd_macro_index.
279 Called when the unwind-protect in Fexecute_kbd_macro gets invoked. */
281 static Lisp_Object
282 pop_kbd_macro (Lisp_Object info)
284 Lisp_Object tem;
285 Vexecuting_kbd_macro = XCAR (info);
286 tem = XCDR (info);
287 executing_kbd_macro_index = XINT (XCAR (tem));
288 real_this_command = XCDR (tem);
289 Frun_hooks (1, &Qkbd_macro_termination_hook);
290 return Qnil;
293 DEFUN ("execute-kbd-macro", Fexecute_kbd_macro, Sexecute_kbd_macro, 1, 3, 0,
294 doc: /* Execute MACRO as string of editor command characters.
295 If MACRO is a symbol, its function definition is used.
296 COUNT is a repeat count, or nil for once, or 0 for infinite loop.
298 Optional third arg LOOPFUNC may be a function that is called prior to
299 each iteration of the macro. Iteration stops if LOOPFUNC returns nil. */)
300 (Lisp_Object macro, Lisp_Object count, Lisp_Object loopfunc)
302 Lisp_Object final;
303 Lisp_Object tem;
304 int pdlcount = SPECPDL_INDEX ();
305 EMACS_INT repeat = 1;
306 struct gcpro gcpro1, gcpro2;
307 EMACS_INT success_count = 0;
309 executing_kbd_macro_iterations = 0;
311 if (!NILP (count))
313 count = Fprefix_numeric_value (count);
314 repeat = XINT (count);
317 final = indirect_function (macro);
318 if (!STRINGP (final) && !VECTORP (final))
319 error ("Keyboard macros must be strings or vectors");
321 tem = Fcons (Vexecuting_kbd_macro,
322 Fcons (make_number (executing_kbd_macro_index),
323 real_this_command));
324 record_unwind_protect (pop_kbd_macro, tem);
326 GCPRO2 (final, loopfunc);
329 Vexecuting_kbd_macro = final;
330 executing_kbd_macro = final;
331 executing_kbd_macro_index = 0;
333 KVAR (current_kboard, Vprefix_arg) = Qnil;
335 if (!NILP (loopfunc))
337 Lisp_Object cont;
338 cont = call0 (loopfunc);
339 if (NILP (cont))
340 break;
343 command_loop_1 ();
345 executing_kbd_macro_iterations = ++success_count;
347 QUIT;
349 while (--repeat
350 && (STRINGP (Vexecuting_kbd_macro) || VECTORP (Vexecuting_kbd_macro)));
352 executing_kbd_macro = Qnil;
354 real_this_command = Vexecuting_kbd_macro;
356 UNGCPRO;
357 return unbind_to (pdlcount, Qnil);
360 void
361 init_macros (void)
363 Vexecuting_kbd_macro = Qnil;
364 executing_kbd_macro = Qnil;
367 void
368 syms_of_macros (void)
370 DEFSYM (Qexecute_kbd_macro, "execute-kbd-macro");
372 DEFVAR_LISP ("kbd-macro-termination-hook", Vkbd_macro_termination_hook,
373 doc: /* Normal hook run whenever a keyboard macro terminates.
374 This is run whether the macro ends normally or prematurely due to an error. */);
375 Vkbd_macro_termination_hook = Qnil;
376 DEFSYM (Qkbd_macro_termination_hook, "kbd-macro-termination-hook");
378 defsubr (&Sstart_kbd_macro);
379 defsubr (&Send_kbd_macro);
380 defsubr (&Scall_last_kbd_macro);
381 defsubr (&Sexecute_kbd_macro);
382 defsubr (&Scancel_kbd_macro_events);
383 defsubr (&Sstore_kbd_macro_event);
385 DEFVAR_KBOARD ("defining-kbd-macro", defining_kbd_macro,
386 doc: /* Non-nil while a keyboard macro is being defined. Don't set this!
387 The value is the symbol `append' while appending to the definition of
388 an existing macro. */);
390 DEFVAR_LISP ("executing-kbd-macro", Vexecuting_kbd_macro,
391 doc: /* Currently executing keyboard macro (string or vector).
392 This is nil when not executing a keyboard macro. */);
394 DEFVAR_INT ("executing-kbd-macro-index", executing_kbd_macro_index,
395 doc: /* Index in currently executing keyboard macro; undefined if none executing. */);
397 DEFVAR_KBOARD ("last-kbd-macro", Vlast_kbd_macro,
398 doc: /* Last kbd macro defined, as a string or vector; nil if none defined. */);