code.delx.au - gnu-emacs/blob - src/macros.c

   1 /* Keyboard macros.
   2    Copyright (C) 1985, 1986, 1993 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   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.
  10
  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.
  15
  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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20
  21 #include <config.h>
  22 #include "lisp.h"
  23 #include "macros.h"
  24 #include "commands.h"
  25 #include "buffer.h"
  26 #include "window.h"
  27 #include "keyboard.h"
  28
  29 Lisp_Object Qexecute_kbd_macro;
  30
  31 Lisp_Object Vexecuting_macro;
  32 int executing_macro_index;
  33
  34 Lisp_Object Fexecute_kbd_macro ();
  35 \f
  36 DEFUN ("start-kbd-macro", Fstart_kbd_macro, Sstart_kbd_macro, 1, 1, "P",
  37   "Record subsequent keyboard input, defining a keyboard macro.\n\
  38 The commands are recorded even as they are executed.\n\
  39 Use \\[end-kbd-macro] to finish recording and make the macro available.\n\
  40 Use \\[name-last-kbd-macro] to give it a permanent name.\n\
  41 Non-nil arg (prefix arg) means append to last macro defined;\n\
  42  This begins by re-executing that macro as if you typed it again.")
  43   (append)
  44      Lisp_Object append;
  45 {
  46   if (!NILP (current_kboard->defining_kbd_macro))
  47     error ("Already defining kbd macro");
  48
  49   if (!current_kboard->kbd_macro_buffer)
  50     {
  51       current_kboard->kbd_macro_bufsize = 30;
  52       current_kboard->kbd_macro_buffer
  53         = (Lisp_Object *)malloc (30 * sizeof (Lisp_Object));
  54     }
  55   update_mode_lines++;
  56   if (NILP (append))
  57     {
  58       current_kboard->kbd_macro_ptr = current_kboard->kbd_macro_buffer;
  59       current_kboard->kbd_macro_end = current_kboard->kbd_macro_buffer;
  60       message("Defining kbd macro...");
  61     }
  62   else
  63     {
  64       message("Appending to kbd macro...");
  65       current_kboard->kbd_macro_ptr = current_kboard->kbd_macro_end;
  66       Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro,
  67                           make_number (1));
  68     }
  69   current_kboard->defining_kbd_macro = Qt;
  70
  71   return Qnil;
  72 }
  73
  74 DEFUN ("end-kbd-macro", Fend_kbd_macro, Send_kbd_macro, 0, 1, "p",
  75   "Finish defining a keyboard macro.\n\
  76 The definition was started by \\[start-kbd-macro].\n\
  77 The macro is now available for use via \\[call-last-kbd-macro],\n\
  78 or it can be given a name with \\[name-last-kbd-macro] and then invoked\n\
  79 under that name.\n\
  80 \n\
  81 With numeric arg, repeat macro now that many times,\n\
  82 counting the definition just completed as the first repetition.\n\
  83 An argument of zero means repeat until error.")
  84   (arg)
  85      Lisp_Object arg;
  86 {
  87   if (NILP (current_kboard->defining_kbd_macro))
  88     error ("Not defining kbd macro.");
  89
  90   if (NILP (arg))
  91     XSETFASTINT (arg, 1);
  92   else
  93     CHECK_NUMBER (arg, 0);
  94
  95   if (!NILP (current_kboard->defining_kbd_macro))
  96     {
  97       current_kboard->defining_kbd_macro = Qnil;
  98       update_mode_lines++;
  99       current_kboard->Vlast_kbd_macro
 100         = make_event_array ((current_kboard->kbd_macro_end
 101                              - current_kboard->kbd_macro_buffer),
 102                             current_kboard->kbd_macro_buffer);
 103       message("Keyboard macro defined");
 104     }
 105
 106   if (XFASTINT (arg) == 0)
 107     Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, arg);
 108   else
 109     {
 110       XSETINT (arg, XINT (arg)-1);
 111       if (XINT (arg) > 0)
 112         Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, arg);
 113     }
 114   return Qnil;
 115 }
 116
 117 /* Store character c into kbd macro being defined */
 118
 119 store_kbd_macro_char (c)
 120      Lisp_Object c;
 121 {
 122   if (!NILP (current_kboard->defining_kbd_macro))
 123     {
 124       if ((current_kboard->kbd_macro_ptr
 125            - current_kboard->kbd_macro_buffer)
 126           == current_kboard->kbd_macro_bufsize)
 127         {
 128           register Lisp_Object *new;
 129           current_kboard->kbd_macro_bufsize *= 2;
 130           new = (Lisp_Object *)xrealloc (current_kboard->kbd_macro_buffer,
 131                                          (current_kboard->kbd_macro_bufsize
 132                                           * sizeof (Lisp_Object)));
 133           current_kboard->kbd_macro_ptr
 134             += new - current_kboard->kbd_macro_buffer;
 135           current_kboard->kbd_macro_end
 136             += new - current_kboard->kbd_macro_buffer;
 137           current_kboard->kbd_macro_buffer = new;
 138         }
 139       *current_kboard->kbd_macro_ptr++ = c;
 140     }
 141 }
 142
 143 /* Declare that all chars stored so far in the kbd macro being defined
 144  really belong to it.  This is done in between editor commands.  */
 145
 146 finalize_kbd_macro_chars ()
 147 {
 148   current_kboard->kbd_macro_end = current_kboard->kbd_macro_ptr;
 149 }
 150
 151 DEFUN ("cancel-kbd-macro-events", Fcancel_kbd_macro_events,
 152        Scancel_kbd_macro_events, 0, 0, 0,
 153   "Cancel the events added to a keyboard macro for this command.")
 154   ()
 155 {
 156   current_kboard->kbd_macro_ptr = current_kboard->kbd_macro_end;
 157 }
 158 \f
 159 DEFUN ("call-last-kbd-macro", Fcall_last_kbd_macro, Scall_last_kbd_macro,
 160   0, 1, "p",
 161   "Call the last keyboard macro that you defined with \\[start-kbd-macro].\n\
 162 \n\
 163 A prefix argument serves as a repeat count.  Zero means repeat until error.\n\
 164 \n\
 165 To make a macro permanent so you can call it even after\n\
 166 defining others, use \\[name-last-kbd-macro].")
 167   (prefix)
 168      Lisp_Object prefix;
 169 {
 170   if (! NILP (current_kboard->defining_kbd_macro))
 171     error ("Can't execute anonymous macro while defining one");
 172   else if (NILP (current_kboard->Vlast_kbd_macro))
 173     error ("No kbd macro has been defined");
 174   else
 175     Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, prefix);
 176   return Qnil;
 177 }
 178
 179 /* Restore Vexecuting_macro and executing_macro_index - called when
 180    the unwind-protect in Fexecute_kbd_macro gets invoked.  */
 181 static Lisp_Object
 182 pop_kbd_macro (info)
 183      Lisp_Object info;
 184 {
 185   Lisp_Object tem;
 186   Vexecuting_macro = Fcar (info);
 187   tem = Fcdr (info);
 188   executing_macro_index = XINT (tem);
 189   return Qnil;
 190 }
 191
 192 DEFUN ("execute-kbd-macro", Fexecute_kbd_macro, Sexecute_kbd_macro, 1, 2, 0,
 193   "Execute MACRO as string of editor command characters.\n\
 194 If MACRO is a symbol, its function definition is used.\n\
 195 COUNT is a repeat count, or nil for once, or 0 for infinite loop.")
 196   (macro, prefixarg)
 197      Lisp_Object macro, prefixarg;
 198 {
 199   Lisp_Object final;
 200   Lisp_Object tem;
 201   int count = specpdl_ptr - specpdl;
 202   int repeat = 1;
 203   struct gcpro gcpro1;
 204
 205   if (!NILP (prefixarg))
 206     prefixarg = Fprefix_numeric_value (prefixarg),
 207     repeat = XINT (prefixarg);
 208
 209   final = indirect_function (macro);
 210   if (!STRINGP (final) && !VECTORP (final))
 211     error ("Keyboard macros must be strings or vectors.");
 212
 213   XSETFASTINT (tem, executing_macro_index);
 214   tem = Fcons (Vexecuting_macro, tem);
 215   record_unwind_protect (pop_kbd_macro, tem);
 216
 217   GCPRO1 (final);
 218   do
 219     {
 220       Vexecuting_macro = final;
 221       executing_macro_index = 0;
 222
 223       current_kboard->Vprefix_arg = Qnil;
 224       command_loop_1 ();
 225
 226       QUIT;
 227     }
 228   while (--repeat
 229          && (STRINGP (Vexecuting_macro) || VECTORP (Vexecuting_macro)));
 230
 231   UNGCPRO;
 232   return unbind_to (count, Qnil);
 233 }
 234 \f
 235 init_macros ()
 236 {
 237   Vexecuting_macro = Qnil;
 238 }
 239
 240 syms_of_macros ()
 241 {
 242   Qexecute_kbd_macro = intern ("execute-kbd-macro");
 243   staticpro (&Qexecute_kbd_macro);
 244
 245   defsubr (&Sstart_kbd_macro);
 246   defsubr (&Send_kbd_macro);
 247   defsubr (&Scall_last_kbd_macro);
 248   defsubr (&Sexecute_kbd_macro);
 249   defsubr (&Scancel_kbd_macro_events);
 250
 251   DEFVAR_KBOARD ("defining-kbd-macro", defining_kbd_macro,
 252     "Non-nil while a keyboard macro is being defined.  Don't set this!");
 253
 254   DEFVAR_LISP ("executing-macro", &Vexecuting_macro,
 255     "Currently executing keyboard macro (string or vector); nil if none executing.");
 256
 257   DEFVAR_LISP_NOPRO ("executing-kbd-macro", &Vexecuting_macro,
 258     "Currently executing keyboard macro (string or vector); nil if none executing.");
 259
 260   DEFVAR_KBOARD ("last-kbd-macro", Vlast_kbd_macro,
 261     "Last kbd macro defined, as a string or vector; nil if none defined.");
 262 }
 263
 264 keys_of_macros ()
 265 {
 266   initial_define_key (control_x_map, ('e'), "call-last-kbd-macro");
 267   initial_define_key (control_x_map, ('('), "start-kbd-macro");
 268   initial_define_key (control_x_map, (')'), "end-kbd-macro");
 269 }