macro.c revision 75406 
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#define SWAP(s, e)  do { int t; t = s; s = e; e = t; } while (0)
53
54/* **************************************************************** */
55/*								    */
56/*			Hacking Keyboard Macros 		    */
57/*								    */
58/* **************************************************************** */
59
60/* The currently executing macro string.  If this is non-zero,
61   then it is a malloc ()'ed string where input is coming from. */
62char *rl_executing_macro = (char *)NULL;
63
64/* Non-zero means to save keys that we dispatch on in a kbd macro. */
65int _rl_defining_kbd_macro = 0;
66
67/* The offset in the above string to the next character to be read. */
68static int executing_macro_index;
69
70/* The current macro string being built.  Characters get stuffed
71   in here by add_macro_char (). */
72static char *current_macro = (char *)NULL;
73
74/* The size of the buffer allocated to current_macro. */
75static int current_macro_size;
76
77/* The index at which characters are being added to current_macro. */
78static int current_macro_index;
79
80/* A structure used to save nested macro strings.
81   It is a linked list of string/index for each saved macro. */
82struct saved_macro {
83  struct saved_macro *next;
84  char *string;
85  int sindex;
86};
87
88/* The list of saved macros. */
89static struct saved_macro *macro_list = (struct saved_macro *)NULL;
90
91/* Set up to read subsequent input from STRING.
92   STRING is free ()'ed when we are done with it. */
93void
94_rl_with_macro_input (string)
95     char *string;
96{
97  _rl_push_executing_macro ();
98  rl_executing_macro = string;
99  executing_macro_index = 0;
100  RL_SETSTATE(RL_STATE_MACROINPUT);
101}
102
103/* Return the next character available from a macro, or 0 if
104   there are no macro characters. */
105int
106_rl_next_macro_key ()
107{
108  if (rl_executing_macro == 0)
109    return (0);
110
111  if (rl_executing_macro[executing_macro_index] == 0)
112    {
113      _rl_pop_executing_macro ();
114      return (_rl_next_macro_key ());
115    }
116
117  return (rl_executing_macro[executing_macro_index++]);
118}
119
120/* Save the currently executing macro on a stack of saved macros. */
121void
122_rl_push_executing_macro ()
123{
124  struct saved_macro *saver;
125
126  saver = (struct saved_macro *)xmalloc (sizeof (struct saved_macro));
127  saver->next = macro_list;
128  saver->sindex = executing_macro_index;
129  saver->string = rl_executing_macro;
130
131  macro_list = saver;
132}
133
134/* Discard the current macro, replacing it with the one
135   on the top of the stack of saved macros. */
136void
137_rl_pop_executing_macro ()
138{
139  struct saved_macro *macro;
140
141  FREE (rl_executing_macro);
142  rl_executing_macro = (char *)NULL;
143  executing_macro_index = 0;
144
145  if (macro_list)
146    {
147      macro = macro_list;
148      rl_executing_macro = macro_list->string;
149      executing_macro_index = macro_list->sindex;
150      macro_list = macro_list->next;
151      free (macro);
152    }
153
154  if (rl_executing_macro == 0)
155    RL_UNSETSTATE(RL_STATE_MACROINPUT);
156}
157
158/* Add a character to the macro being built. */
159void
160_rl_add_macro_char (c)
161     int c;
162{
163  if (current_macro_index + 1 >= current_macro_size)
164    {
165      if (current_macro == 0)
166	current_macro = xmalloc (current_macro_size = 25);
167      else
168	current_macro = xrealloc (current_macro, current_macro_size += 25);
169    }
170
171  current_macro[current_macro_index++] = c;
172  current_macro[current_macro_index] = '\0';
173}
174
175void
176_rl_kill_kbd_macro ()
177{
178  if (current_macro)
179    {
180      free (current_macro);
181      current_macro = (char *) NULL;
182    }
183  current_macro_size = current_macro_index = 0;
184
185  FREE (rl_executing_macro);
186  rl_executing_macro = (char *) NULL;
187  executing_macro_index = 0;
188
189  _rl_defining_kbd_macro = 0;
190  RL_UNSETSTATE(RL_STATE_MACRODEF);
191}
192
193/* Begin defining a keyboard macro.
194   Keystrokes are recorded as they are executed.
195   End the definition with rl_end_kbd_macro ().
196   If a numeric argument was explicitly typed, then append this
197   definition to the end of the existing macro, and start by
198   re-executing the existing macro. */
199int
200rl_start_kbd_macro (ignore1, ignore2)
201     int ignore1, ignore2;
202{
203  if (_rl_defining_kbd_macro)
204    {
205      _rl_abort_internal ();
206      return -1;
207    }
208
209  if (rl_explicit_arg)
210    {
211      if (current_macro)
212	_rl_with_macro_input (savestring (current_macro));
213    }
214  else
215    current_macro_index = 0;
216
217  _rl_defining_kbd_macro = 1;
218  RL_SETSTATE(RL_STATE_MACRODEF);
219  return 0;
220}
221
222/* Stop defining a keyboard macro.
223   A numeric argument says to execute the macro right now,
224   that many times, counting the definition as the first time. */
225int
226rl_end_kbd_macro (count, ignore)
227     int count, ignore;
228{
229  if (_rl_defining_kbd_macro == 0)
230    {
231      _rl_abort_internal ();
232      return -1;
233    }
234
235  current_macro_index -= rl_key_sequence_length - 1;
236  current_macro[current_macro_index] = '\0';
237
238  _rl_defining_kbd_macro = 0;
239  RL_UNSETSTATE(RL_STATE_MACRODEF);
240
241  return (rl_call_last_kbd_macro (--count, 0));
242}
243
244/* Execute the most recently defined keyboard macro.
245   COUNT says how many times to execute it. */
246int
247rl_call_last_kbd_macro (count, ignore)
248     int count, ignore;
249{
250  if (current_macro == 0)
251    _rl_abort_internal ();
252
253  if (_rl_defining_kbd_macro)
254    {
255      rl_ding ();		/* no recursive macros */
256      current_macro[--current_macro_index] = '\0';	/* erase this char */
257      return 0;
258    }
259
260  while (count--)
261    _rl_with_macro_input (savestring (current_macro));
262  return 0;
263}
264
265void
266rl_push_macro_input (macro)
267     char *macro;
268{
269  _rl_with_macro_input (macro);
270}
271