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 if (rl_executing_macro == 0) 104 return (0); 105 106 if (rl_executing_macro[executing_macro_index] == 0) 107 { 108 _rl_pop_executing_macro (); 109 return (_rl_next_macro_key ()); 110 } 111 112 return (rl_executing_macro[executing_macro_index++]); 113 } 114 115 /* Save the currently executing macro on a stack of saved macros. */ 116 void 117 _rl_push_executing_macro () 118 { 119 struct saved_macro *saver; 120 121 saver = (struct saved_macro *)xmalloc (sizeof (struct saved_macro)); 122 saver->next = macro_list; 123 saver->sindex = executing_macro_index; 124 saver->string = rl_executing_macro; 125 126 macro_list = saver; 127 } 128 129 /* Discard the current macro, replacing it with the one 130 on the top of the stack of saved macros. */ 131 void 132 _rl_pop_executing_macro () 133 { 134 struct saved_macro *macro; 135 136 FREE (rl_executing_macro); 137 rl_executing_macro = (char *)NULL; 138 executing_macro_index = 0; 139 140 if (macro_list) 141 { 142 macro = macro_list; 143 rl_executing_macro = macro_list->string; 144 executing_macro_index = macro_list->sindex; 145 macro_list = macro_list->next; 146 free (macro); 147 } 148 149 if (rl_executing_macro == 0) 150 RL_UNSETSTATE(RL_STATE_MACROINPUT); 151 } 152 153 /* Add a character to the macro being built. */ 154 void 155 _rl_add_macro_char (c) 156 int c; 157 { 158 if (current_macro_index + 1 >= current_macro_size) 159 { 160 if (current_macro == 0) 161 current_macro = (char *)xmalloc (current_macro_size = 25); 162 else 163 current_macro = (char *)xrealloc (current_macro, current_macro_size += 25); 164 } 165 166 current_macro[current_macro_index++] = c; 167 current_macro[current_macro_index] = '\0'; 168 } 169 170 void 171 _rl_kill_kbd_macro () 172 { 173 if (current_macro) 174 { 175 free (current_macro); 176 current_macro = (char *) NULL; 177 } 178 current_macro_size = current_macro_index = 0; 179 180 FREE (rl_executing_macro); 181 rl_executing_macro = (char *) NULL; 182 executing_macro_index = 0; 183 184 RL_UNSETSTATE(RL_STATE_MACRODEF); 185 } 186 187 /* Begin defining a keyboard macro. 188 Keystrokes are recorded as they are executed. 189 End the definition with rl_end_kbd_macro (). 190 If a numeric argument was explicitly typed, then append this 191 definition to the end of the existing macro, and start by 192 re-executing the existing macro. */ 193 int 194 rl_start_kbd_macro (ignore1, ignore2) 195 int ignore1, ignore2; 196 { 197 if (RL_ISSTATE (RL_STATE_MACRODEF)) 198 { 199 _rl_abort_internal (); 200 return -1; 201 } 202 203 if (rl_explicit_arg) 204 { 205 if (current_macro) 206 _rl_with_macro_input (savestring (current_macro)); 207 } 208 else 209 current_macro_index = 0; 210 211 RL_SETSTATE(RL_STATE_MACRODEF); 212 return 0; 213 } 214 215 /* Stop defining a keyboard macro. 216 A numeric argument says to execute the macro right now, 217 that many times, counting the definition as the first time. */ 218 int 219 rl_end_kbd_macro (count, ignore) 220 int count, ignore; 221 { 222 if (RL_ISSTATE (RL_STATE_MACRODEF) == 0) 223 { 224 _rl_abort_internal (); 225 return -1; 226 } 227 228 current_macro_index -= rl_key_sequence_length - 1; 229 current_macro[current_macro_index] = '\0'; 230 231 RL_UNSETSTATE(RL_STATE_MACRODEF); 232 233 return (rl_call_last_kbd_macro (--count, 0)); 234 } 235 236 /* Execute the most recently defined keyboard macro. 237 COUNT says how many times to execute it. */ 238 int 239 rl_call_last_kbd_macro (count, ignore) 240 int count, ignore; 241 { 242 if (current_macro == 0) 243 _rl_abort_internal (); 244 245 if (RL_ISSTATE (RL_STATE_MACRODEF)) 246 { 247 rl_ding (); /* no recursive macros */ 248 current_macro[--current_macro_index] = '\0'; /* erase this char */ 249 return 0; 250 } 251 252 while (count--) 253 _rl_with_macro_input (savestring (current_macro)); 254 return 0; 255 } 256 257 void 258 rl_push_macro_input (macro) 259 char *macro; 260 { 261 _rl_with_macro_input (macro); 262 } 263