readline/macro.c

   1 /* macro.c -- keyboard macros for readline. */
   2
   3 /* Copyright (C) 1994-2009 Free Software Foundation, Inc.
   4
   5    This file is part of the GNU Readline Library (Readline), a library
   6    for reading lines of text with interactive input and history editing.
   7
   8    Readline is free software: you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation, either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    Readline is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with Readline.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  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_STATE_MOREINPUT) && 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       xfree (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       xfree (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 }