OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [branches/] [oc/] [gdb-5.0/] [readline/] [macro.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.