readline/macro.c

   1 /* macro.c -- keyboard macros for readline. */
   2
   3 /* Copyright (C) 1994 Free Software Foundation, Inc.
   4
   5    This file is part of the GNU Readline Library, a library for
   6    reading lines of text with interactive input and history editing.
   7
   8    The GNU Readline Library is free software; you can redistribute it
   9    and/or modify it under the terms of the GNU General Public License
  10    as published by the Free Software Foundation; either version 2, or
  11    (at your option) any later version.
  12
  13    The GNU Readline Library is distributed in the hope that it will be
  14    useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  15    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    The GNU General Public License is often shipped with GNU software, and
  19    is generally kept in a file called COPYING or LICENSE.  If you do not
  20    have a copy of the license, write to the Free Software Foundation,
  21    59 Temple Place, Suite 330, Boston, MA 02111 USA. */
  22 #define READLINE_LIBRARY
  23
  24 #if defined (HAVE_CONFIG_H)
  25 #  include <config.h>
  26 #endif
  27
  28 #include <sys/types.h>
  29
  30 #if defined (HAVE_UNISTD_H)
  31 #  include <unistd.h>           /* for _POSIX_VERSION */
  32 #endif /* HAVE_UNISTD_H */
  33
  34 #if defined (HAVE_STDLIB_H)
  35 #  include <stdlib.h>
  36 #else
  37 #  include "ansi_stdlib.h"
  38 #endif /* HAVE_STDLIB_H */
  39
  40 #include <stdio.h>
  41
  42 /* System-specific feature definitions and include files. */
  43 #include "rldefs.h"
  44
  45 /* Some standard library routines. */
  46 #include "readline.h"
  47 #include "history.h"
  48
  49 #include "rlprivate.h"
  50 #include "xmalloc.h"
  51
  52 /* **************************************************************** */
  53 /*                                                                  */
  54 /*                      Hacking Keyboard Macros                     */
  55 /*                                                                  */
  56 /* **************************************************************** */
  57
  58 /* The currently executing macro string.  If this is non-zero,
  59    then it is a malloc ()'ed string where input is coming from. */
  60 char *rl_executing_macro = (char *)NULL;
  61
  62 /* The offset in the above string to the next character to be read. */
  63 static int executing_macro_index;
  64
  65 /* The current macro string being built.  Characters get stuffed
  66    in here by add_macro_char (). */
  67 static char *current_macro = (char *)NULL;
  68
  69 /* The size of the buffer allocated to current_macro. */
  70 static int current_macro_size;
  71
  72 /* The index at which characters are being added to current_macro. */
  73 static int current_macro_index;
  74
  75 /* A structure used to save nested macro strings.
  76    It is a linked list of string/index for each saved macro. */
  77 struct saved_macro {
  78   struct saved_macro *next;
  79   char *string;
  80   int sindex;
  81 };
  82
  83 /* The list of saved macros. */
  84 static struct saved_macro *macro_list = (struct saved_macro *)NULL;
  85
  86 /* Set up to read subsequent input from STRING.
  87    STRING is free ()'ed when we are done with it. */
  88 void
  89 _rl_with_macro_input (string)
  90      char *string;
  91 {
  92   _rl_push_executing_macro ();
  93   rl_executing_macro = string;
  94   executing_macro_index = 0;
  95   RL_SETSTATE(RL_STATE_MACROINPUT);
  96 }
  97
  98 /* Return the next character available from a macro, or 0 if
  99    there are no macro characters. */
 100 int
 101 _rl_next_macro_key ()
 102 {
 103   int c;
 104
 105   if (rl_executing_macro == 0)
 106     return (0);
 107
 108   if (rl_executing_macro[executing_macro_index] == 0)
 109     {
 110       _rl_pop_executing_macro ();
 111       return (_rl_next_macro_key ());
 112     }
 113
 114 #if defined (READLINE_CALLBACKS)
 115   c = rl_executing_macro[executing_macro_index++];
 116   if (RL_ISSTATE (RL_STATE_CALLBACK) && RL_ISSTATE (RL_STATE_READCMD) && rl_executing_macro[executing_macro_index] == 0)
 117       _rl_pop_executing_macro ();
 118   return c;
 119 #else
 120   return (rl_executing_macro[executing_macro_index++]);
 121 #endif
 122 }
 123
 124 /* Save the currently executing macro on a stack of saved macros. */
 125 void
 126 _rl_push_executing_macro ()
 127 {
 128   struct saved_macro *saver;
 129
 130   saver = (struct saved_macro *)xmalloc (sizeof (struct saved_macro));
 131   saver->next = macro_list;
 132   saver->sindex = executing_macro_index;
 133   saver->string = rl_executing_macro;
 134
 135   macro_list = saver;
 136 }
 137
 138 /* Discard the current macro, replacing it with the one
 139    on the top of the stack of saved macros. */
 140 void
 141 _rl_pop_executing_macro ()
 142 {
 143   struct saved_macro *macro;
 144
 145   FREE (rl_executing_macro);
 146   rl_executing_macro = (char *)NULL;
 147   executing_macro_index = 0;
 148
 149   if (macro_list)
 150     {
 151       macro = macro_list;
 152       rl_executing_macro = macro_list->string;
 153       executing_macro_index = macro_list->sindex;
 154       macro_list = macro_list->next;
 155       free (macro);
 156     }
 157
 158   if (rl_executing_macro == 0)
 159     RL_UNSETSTATE(RL_STATE_MACROINPUT);
 160 }
 161
 162 /* Add a character to the macro being built. */
 163 void
 164 _rl_add_macro_char (c)
 165      int c;
 166 {
 167   if (current_macro_index + 1 >= current_macro_size)
 168     {
 169       if (current_macro == 0)
 170         current_macro = (char *)xmalloc (current_macro_size = 25);
 171       else
 172         current_macro = (char *)xrealloc (current_macro, current_macro_size += 25);
 173     }
 174
 175   current_macro[current_macro_index++] = c;
 176   current_macro[current_macro_index] = '\0';
 177 }
 178
 179 void
 180 _rl_kill_kbd_macro ()
 181 {
 182   if (current_macro)
 183     {
 184       free (current_macro);
 185       current_macro = (char *) NULL;
 186     }
 187   current_macro_size = current_macro_index = 0;
 188
 189   FREE (rl_executing_macro);
 190   rl_executing_macro = (char *) NULL;
 191   executing_macro_index = 0;
 192
 193   RL_UNSETSTATE(RL_STATE_MACRODEF);
 194 }
 195
 196 /* Begin defining a keyboard macro.
 197    Keystrokes are recorded as they are executed.
 198    End the definition with rl_end_kbd_macro ().
 199    If a numeric argument was explicitly typed, then append this
 200    definition to the end of the existing macro, and start by
 201    re-executing the existing macro. */
 202 int
 203 rl_start_kbd_macro (ignore1, ignore2)
 204      int ignore1, ignore2;
 205 {
 206   if (RL_ISSTATE (RL_STATE_MACRODEF))
 207     {
 208       _rl_abort_internal ();
 209       return -1;
 210     }
 211
 212   if (rl_explicit_arg)
 213     {
 214       if (current_macro)
 215         _rl_with_macro_input (savestring (current_macro));
 216     }
 217   else
 218     current_macro_index = 0;
 219
 220   RL_SETSTATE(RL_STATE_MACRODEF);
 221   return 0;
 222 }
 223
 224 /* Stop defining a keyboard macro.
 225    A numeric argument says to execute the macro right now,
 226    that many times, counting the definition as the first time. */
 227 int
 228 rl_end_kbd_macro (count, ignore)
 229      int count, ignore;
 230 {
 231   if (RL_ISSTATE (RL_STATE_MACRODEF) == 0)
 232     {
 233       _rl_abort_internal ();
 234       return -1;
 235     }
 236
 237   current_macro_index -= rl_key_sequence_length - 1;
 238   current_macro[current_macro_index] = '\0';
 239
 240   RL_UNSETSTATE(RL_STATE_MACRODEF);
 241
 242   return (rl_call_last_kbd_macro (--count, 0));
 243 }
 244
 245 /* Execute the most recently defined keyboard macro.
 246    COUNT says how many times to execute it. */
 247 int
 248 rl_call_last_kbd_macro (count, ignore)
 249      int count, ignore;
 250 {
 251   if (current_macro == 0)
 252     _rl_abort_internal ();
 253
 254   if (RL_ISSTATE (RL_STATE_MACRODEF))
 255     {
 256       rl_ding ();               /* no recursive macros */
 257       current_macro[--current_macro_index] = '\0';      /* erase this char */
 258       return 0;
 259     }
 260
 261   while (count--)
 262     _rl_with_macro_input (savestring (current_macro));
 263   return 0;
 264 }
 265
 266 void
 267 rl_push_macro_input (macro)
 268      char *macro;
 269 {
 270   _rl_with_macro_input (macro);
 271 }