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 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA. */
22 #define READLINE_LIBRARY
23
24 #if defined (HAVE_CONFIG_H)
25 # include "config_readline.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
_rl_with_macro_input(string)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
_rl_next_macro_key()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
_rl_push_executing_macro()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
_rl_pop_executing_macro()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
_rl_add_macro_char(c)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
_rl_kill_kbd_macro()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
rl_start_kbd_macro(ignore1,ignore2)203 rl_start_kbd_macro (ignore1, ignore2)
204 int ignore1 __attribute__((unused)), ignore2 __attribute__((unused));
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
rl_end_kbd_macro(count,ignore)228 rl_end_kbd_macro (count, ignore)
229 int count, ignore __attribute__((unused));
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
rl_call_last_kbd_macro(count,ignore)248 rl_call_last_kbd_macro (count, ignore)
249 int count, ignore __attribute__((unused));
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
rl_push_macro_input(macro)267 rl_push_macro_input (macro)
268 char *macro;
269 {
270 _rl_with_macro_input (macro);
271 }
272