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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [readline/] [callback.c] - Blame information for rev 856

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* callback.c -- functions to use readline as an X `callback' mechanism. */
2
 
3
/* Copyright (C) 1987-2005 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 "rlconf.h"
29
 
30
#if defined (READLINE_CALLBACKS)
31
 
32
#include <sys/types.h>
33
 
34
#ifdef HAVE_STDLIB_H
35
#  include <stdlib.h>
36
#else
37
#  include "ansi_stdlib.h"
38
#endif
39
 
40
#include <stdio.h>
41
 
42
/* System-specific feature definitions and include files. */
43
#include "rldefs.h"
44
#include "readline.h"
45
#include "rlprivate.h"
46
#include "xmalloc.h"
47
 
48
/* Private data for callback registration functions.  See comments in
49
   rl_callback_read_char for more details. */
50
_rl_callback_func_t *_rl_callback_func = 0;
51
_rl_callback_generic_arg *_rl_callback_data = 0;
52
 
53
/* **************************************************************** */
54
/*                                                                  */
55
/*                      Callback Readline Functions              */
56
/*                                                                  */
57
/* **************************************************************** */
58
 
59
/* Allow using readline in situations where a program may have multiple
60
   things to handle at once, and dispatches them via select().  Call
61
   rl_callback_handler_install() with the prompt and a function to call
62
   whenever a complete line of input is ready.  The user must then
63
   call rl_callback_read_char() every time some input is available, and
64
   rl_callback_read_char() will call the user's function with the complete
65
   text read in at each end of line.  The terminal is kept prepped and
66
   signals handled all the time, except during calls to the user's function. */
67
 
68
rl_vcpfunc_t *rl_linefunc;              /* user callback function */
69
static int in_handler;          /* terminal_prepped and signals set? */
70
 
71
/* Make sure the terminal is set up, initialize readline, and prompt. */
72
static void
73
_rl_callback_newline ()
74
{
75
  rl_initialize ();
76
 
77
  if (in_handler == 0)
78
    {
79
      in_handler = 1;
80
 
81
      if (rl_prep_term_function)
82
        (*rl_prep_term_function) (_rl_meta_flag);
83
 
84
#if defined (HANDLE_SIGNALS)
85
      rl_set_signals ();
86
#endif
87
    }
88
 
89
  readline_internal_setup ();
90
}
91
 
92
/* Install a readline handler, set up the terminal, and issue the prompt. */
93
void
94
rl_callback_handler_install (prompt, linefunc)
95
     const char *prompt;
96
     rl_vcpfunc_t *linefunc;
97
{
98
  rl_set_prompt (prompt);
99
  RL_SETSTATE (RL_STATE_CALLBACK);
100
  rl_linefunc = linefunc;
101
  _rl_callback_newline ();
102
}
103
 
104
/* Read one character, and dispatch to the handler if it ends the line. */
105
void
106
rl_callback_read_char ()
107
{
108
  char *line;
109
  int eof, jcode;
110
  static procenv_t olevel;
111
 
112
  if (rl_linefunc == NULL)
113
    {
114
      fprintf (stderr, "readline: readline_callback_read_char() called with no handler!\r\n");
115
      abort ();
116
    }
117
 
118
  memcpy ((void *)olevel, (void *)readline_top_level, sizeof (procenv_t));
119
  jcode = setjmp (readline_top_level);
120
  if (jcode)
121
    {
122
      (*rl_redisplay_function) ();
123
      _rl_want_redisplay = 0;
124
      memcpy ((void *)readline_top_level, (void *)olevel, sizeof (procenv_t));
125
      return;
126
    }
127
 
128
  if  (RL_ISSTATE (RL_STATE_ISEARCH))
129
    {
130
      eof = _rl_isearch_callback (_rl_iscxt);
131
      if (eof == 0 && (RL_ISSTATE (RL_STATE_ISEARCH) == 0) && RL_ISSTATE (RL_STATE_INPUTPENDING))
132
        rl_callback_read_char ();
133
 
134
      return;
135
    }
136
  else if  (RL_ISSTATE (RL_STATE_NSEARCH))
137
    {
138
      eof = _rl_nsearch_callback (_rl_nscxt);
139
      return;
140
    }
141
  else if (RL_ISSTATE (RL_STATE_NUMERICARG))
142
    {
143
      eof = _rl_arg_callback (_rl_argcxt);
144
      if (eof == 0 && (RL_ISSTATE (RL_STATE_NUMERICARG) == 0) && RL_ISSTATE (RL_STATE_INPUTPENDING))
145
        rl_callback_read_char ();
146
      /* XXX - this should handle _rl_last_command_was_kill better */
147
      else if (RL_ISSTATE (RL_STATE_NUMERICARG) == 0)
148
        _rl_internal_char_cleanup ();
149
 
150
      return;
151
    }
152
  else if (RL_ISSTATE (RL_STATE_MULTIKEY))
153
    {
154
      eof = _rl_dispatch_callback (_rl_kscxt);  /* For now */
155
      while ((eof == -1 || eof == -2) && RL_ISSTATE (RL_STATE_MULTIKEY) && _rl_kscxt && (_rl_kscxt->flags & KSEQ_DISPATCHED))
156
        eof = _rl_dispatch_callback (_rl_kscxt);
157
      if (RL_ISSTATE (RL_STATE_MULTIKEY) == 0)
158
        {
159
          _rl_internal_char_cleanup ();
160
          _rl_want_redisplay = 1;
161
        }
162
    }
163
  else if (_rl_callback_func)
164
    {
165
      /* This allows functions that simply need to read an additional character
166
         (like quoted-insert) to register a function to be called when input is
167
         available.  _rl_callback_data is simply a pointer to a struct that has
168
         the argument count originally passed to the registering function and
169
         space for any additional parameters.  */
170
      eof = (*_rl_callback_func) (_rl_callback_data);
171
      /* If the function `deregisters' itself, make sure the data is cleaned
172
         up. */
173
      if (_rl_callback_func == 0)
174
        {
175
          if (_rl_callback_data)
176
            {
177
              _rl_callback_data_dispose (_rl_callback_data);
178
              _rl_callback_data = 0;
179
            }
180
          _rl_internal_char_cleanup ();
181
        }
182
    }
183
  else
184
    eof = readline_internal_char ();
185
 
186
  if (rl_done == 0 && _rl_want_redisplay)
187
    {
188
      (*rl_redisplay_function) ();
189
      _rl_want_redisplay = 0;
190
    }
191
 
192
  /* We loop in case some function has pushed input back with rl_execute_next. */
193
  for (;;)
194
    {
195
      if (rl_done)
196
        {
197
          line = readline_internal_teardown (eof);
198
 
199
          if (rl_deprep_term_function)
200
            (*rl_deprep_term_function) ();
201
#if defined (HANDLE_SIGNALS)
202
          rl_clear_signals ();
203
#endif
204
          in_handler = 0;
205
          (*rl_linefunc) (line);
206
 
207
          /* If the user did not clear out the line, do it for him. */
208
          if (rl_line_buffer[0])
209
            _rl_init_line_state ();
210
 
211
          /* Redisplay the prompt if readline_handler_{install,remove}
212
             not called. */
213
          if (in_handler == 0 && rl_linefunc)
214
            _rl_callback_newline ();
215
        }
216
      if (rl_pending_input || _rl_pushed_input_available () || RL_ISSTATE (RL_STATE_MACROINPUT))
217
        eof = readline_internal_char ();
218
      else
219
        break;
220
    }
221
}
222
 
223
/* Remove the handler, and make sure the terminal is in its normal state. */
224
void
225
rl_callback_handler_remove ()
226
{
227
  rl_linefunc = NULL;
228
  RL_UNSETSTATE (RL_STATE_CALLBACK);
229
  if (in_handler)
230
    {
231
      in_handler = 0;
232
      if (rl_deprep_term_function)
233
        (*rl_deprep_term_function) ();
234
#if defined (HANDLE_SIGNALS)
235
      rl_clear_signals ();
236
#endif
237
    }
238
}
239
 
240
_rl_callback_generic_arg *
241
_rl_callback_data_alloc (count)
242
     int count;
243
{
244
  _rl_callback_generic_arg *arg;
245
 
246
  arg = (_rl_callback_generic_arg *)xmalloc (sizeof (_rl_callback_generic_arg));
247
  arg->count = count;
248
 
249
  arg->i1 = arg->i2 = 0;
250
 
251
  return arg;
252
}
253
 
254
void _rl_callback_data_dispose (arg)
255
     _rl_callback_generic_arg *arg;
256
{
257
  if (arg)
258
    free (arg);
259
}
260
 
261
#endif

powered by: WebSVN 2.1.0

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