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