(Fstart_kbd_macro): Added NO-EXEC argument to inhibit

executing macro before appending to it (when used from Lisp).
(Fexecute_kbd_macro): Added LOOPFUNC argument to supply function
which is called prior to each iteration of macro (for kmacro.el).
(Fend_kbd_macro, Fcall_last_kbd_macro): Likewise.

1 files changed, 44 insertions, 23 deletions

diff --git a/src/macros.c b/src/macros.c
index 5f6d83b52d6..e9601b1aa7f 100644
--- a/src/macros.c
+++ b/src/macros.c
@@ -55,15 +55,17 @@ extern Lisp_Object real_this_command;
 
 Lisp_Object Fexecute_kbd_macro ();
 
-DEFUN ("start-kbd-macro", Fstart_kbd_macro, Sstart_kbd_macro, 1, 1, "P",
+DEFUN ("start-kbd-macro", Fstart_kbd_macro, Sstart_kbd_macro, 1, 2, "P",
        doc: /* Record subsequent keyboard input, defining a keyboard macro.
 The commands are recorded even as they are executed.
 Use \\[end-kbd-macro] to finish recording and make the macro available.
 Use \\[name-last-kbd-macro] to give it a permanent name.
 Non-nil arg (prefix arg) means append to last macro defined;
-this begins by re-executing that macro as if you typed it again.  */)
-     (append)
-     Lisp_Object append;
+this begins by re-executing that macro as if you typed it again.
+If optional second arg, NO-EXEC, is non-nil, do not re-execute last 
+macro before appending to it. */)
+     (append, no_exec)
+     Lisp_Object append, no_exec;
 {
   if (!NILP (current_kboard->defining_kbd_macro))
     error ("Already defining kbd macro");
@@ -118,8 +120,9 @@ this begins by re-executing that macro as if you typed it again.  */)
 
       /* Re-execute the macro we are appending to,
          for consistency of behavior.  */
-      Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro,
-                          make_number (1));
+      if (NILP (no_exec))
+        Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro,
+                            make_number (1), Qnil);
 
       message ("Appending to kbd macro...");
     }
@@ -128,7 +131,7 @@ this begins by re-executing that macro as if you typed it again.  */)
   return Qnil;
 }
 
-DEFUN ("end-kbd-macro", Fend_kbd_macro, Send_kbd_macro, 0, 1, "p",
+DEFUN ("end-kbd-macro", Fend_kbd_macro, Send_kbd_macro, 0, 2, "p",
        doc: /* Finish defining a keyboard macro.
 The definition was started by \\[start-kbd-macro].
 The macro is now available for use via \\[call-last-kbd-macro],
@@ -137,9 +140,12 @@ under that name.
 
 With numeric arg, repeat macro now that many times,
 counting the definition just completed as the first repetition.
-An argument of zero means repeat until error.  */)
-     (repeat)
-     Lisp_Object repeat;
+An argument of zero means repeat until error.
+
+In Lisp, optional second arg LOOPFUNC may be a function that is called prior to 
+each iteration of the macro.  Iteration stops if LOOPFUNC returns nil.  */)
+     (repeat, loopfunc)
+     Lisp_Object repeat, loopfunc;
 {
   if (NILP (current_kboard->defining_kbd_macro))
     error ("Not defining kbd macro");
@@ -161,12 +167,12 @@ An argument of zero means repeat until error.  */)
     }
 
   if (XFASTINT (repeat) == 0)
-    Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, repeat);
+    Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, repeat, loopfunc);
   else
     {
       XSETINT (repeat, XINT (repeat)-1);
       if (XINT (repeat) > 0)
-        Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, repeat);
+        Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, repeat, loopfunc);
     }
   return Qnil;
 }
@@ -228,15 +234,18 @@ DEFUN ("store-kbd-macro-event", Fstore_kbd_macro_event,
 }
 
 DEFUN ("call-last-kbd-macro", Fcall_last_kbd_macro, Scall_last_kbd_macro,
-       0, 1, "p",
+       0, 2, "p",
        doc: /* Call the last keyboard macro that you defined with \\[start-kbd-macro].
 
 A prefix argument serves as a repeat count.  Zero means repeat until error.
 
 To make a macro permanent so you can call it even after
-defining others, use \\[name-last-kbd-macro].  */)
-     (prefix)
-     Lisp_Object prefix;
+defining others, use \\[name-last-kbd-macro].  
+
+In Lisp, optional second arg LOOPFUNC may be a function that is called prior to 
+each iteration of the macro.  Iteration stops if LOOPFUNC returns nil.  */)
+     (prefix, loopfunc)
+     Lisp_Object prefix, loopfunc;
 {
   /* Don't interfere with recognition of the previous command
      from before this macro started.  */
@@ -249,7 +258,7 @@ defining others, use \\[name-last-kbd-macro].  */)
   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);
+    Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, prefix, loopfunc);
 
   /* command_loop_1 sets this to nil before it returns;
      get back the last command within the macro
@@ -275,18 +284,21 @@ pop_kbd_macro (info)
   return Qnil;
 }
 
-DEFUN ("execute-kbd-macro", Fexecute_kbd_macro, Sexecute_kbd_macro, 1, 2, 0,
+DEFUN ("execute-kbd-macro", Fexecute_kbd_macro, Sexecute_kbd_macro, 1, 3, 0,
        doc: /* Execute MACRO as string of editor command characters.
 If MACRO is a symbol, its function definition is used.
-COUNT is a repeat count, or nil for once, or 0 for infinite loop.  */)
-     (macro, count)
-     Lisp_Object macro, count;
+COUNT is a repeat count, or nil for once, or 0 for infinite loop. 
+
+Optional third arg LOOPFUNC may be a function that is called prior to 
+each iteration of the macro.  Iteration stops if LOOPFUNC returns nil.  */)
+     (macro, count, loopfunc)
+     Lisp_Object macro, count, loopfunc;
 {
   Lisp_Object final;
   Lisp_Object tem;
   int pdlcount = SPECPDL_INDEX ();
   int repeat = 1;
-  struct gcpro gcpro1;
+  struct gcpro gcpro1, gcpro2;
   int success_count = 0;
 
   executing_macro_iterations = 0;
@@ -306,7 +318,7 @@ COUNT is a repeat count, or nil for once, or 0 for infinite loop.  */)
                       real_this_command));
   record_unwind_protect (pop_kbd_macro, tem);
 
-  GCPRO1 (final);
+  GCPRO2 (final, loopfunc);
   do
     {
       Vexecuting_macro = final;
@@ -314,6 +326,15 @@ COUNT is a repeat count, or nil for once, or 0 for infinite loop.  */)
       executing_macro_index = 0;
 
       current_kboard->Vprefix_arg = Qnil;
+
+      if (!NILP (loopfunc))
+        {
+          Lisp_Object cont;
+          cont = call0 (loopfunc);
+          if (NILP (cont))
+            break;
+        }
+
       command_loop_1 ();
 
       executing_macro_iterations = ++success_count;