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. */
60char *rl_executing_macro = (char *)NULL;
61
62/* The offset in the above string to the next character to be read. */
63static int executing_macro_index;
64
65/* The current macro string being built.  Characters get stuffed
66   in here by add_macro_char (). */
67static char *current_macro = (char *)NULL;
68
69/* The size of the buffer allocated to current_macro. */
70static int current_macro_size;
71
72/* The index at which characters are being added to current_macro. */
73static 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. */
77struct saved_macro {
78  struct saved_macro *next;
79  char *string;
80  int sindex;
81};
82
83/* The list of saved macros. */
84static 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. */
88void
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. */
100int
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. */
125void
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. */
140void
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. */
163void
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
179void
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. */
202int
203rl_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. */
227int
228rl_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. */
247int
248rl_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
266void
267rl_push_macro_input (macro)
268     char *macro;
269{
270  _rl_with_macro_input (macro);
271}
272