gas/
[external/binutils.git] / readline / callback.c
1 /* callback.c -- functions to use readline as an X `callback' mechanism. */
2
3 /* Copyright (C) 1987-2009 Free Software Foundation, Inc.
4
5    This file is part of the GNU Readline Library (Readline), a library
6    for reading lines of text with interactive input and history editing.
7
8    Readline is free software: you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation, either version 3 of the License, or
11    (at your option) any later version.
12
13    Readline is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with Readline.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
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   RL_CHECK_SIGNALS ();
91 }
92
93 /* Install a readline handler, set up the terminal, and issue the prompt. */
94 void
95 rl_callback_handler_install (prompt, linefunc)
96      const char *prompt;
97      rl_vcpfunc_t *linefunc;
98 {
99   rl_set_prompt (prompt);
100   RL_SETSTATE (RL_STATE_CALLBACK);
101   rl_linefunc = linefunc;
102   _rl_callback_newline ();
103 }
104
105 /* Read one character, and dispatch to the handler if it ends the line. */
106 void
107 rl_callback_read_char ()
108 {
109   char *line;
110   int eof, jcode;
111   static procenv_t olevel;
112
113   if (rl_linefunc == NULL)
114     {
115       _rl_errmsg ("readline_callback_read_char() called with no handler!");
116       abort ();
117     }
118
119   memcpy ((void *)olevel, (void *)_rl_top_level, sizeof (procenv_t));
120   jcode = setjmp (_rl_top_level);
121   if (jcode)
122     {
123       (*rl_redisplay_function) ();
124       _rl_want_redisplay = 0;
125       memcpy ((void *)_rl_top_level, (void *)olevel, sizeof (procenv_t));
126       return;
127     }
128
129   do
130     {
131       RL_CHECK_SIGNALS ();
132       if  (RL_ISSTATE (RL_STATE_ISEARCH))
133         {
134           eof = _rl_isearch_callback (_rl_iscxt);
135           if (eof == 0 && (RL_ISSTATE (RL_STATE_ISEARCH) == 0) && RL_ISSTATE (RL_STATE_INPUTPENDING))
136             rl_callback_read_char ();
137
138           return;
139         }
140       else if  (RL_ISSTATE (RL_STATE_NSEARCH))
141         {
142           eof = _rl_nsearch_callback (_rl_nscxt);
143           return;
144         }
145 #if defined (VI_MODE)
146       else if (RL_ISSTATE (RL_STATE_VIMOTION))
147         {
148           eof = _rl_vi_domove_callback (_rl_vimvcxt);
149           /* Should handle everything, including cleanup, numeric arguments,
150              and turning off RL_STATE_VIMOTION */
151           if (RL_ISSTATE (RL_STATE_NUMERICARG) == 0)
152             _rl_internal_char_cleanup ();
153
154           return;
155         }
156 #endif
157       else if (RL_ISSTATE (RL_STATE_NUMERICARG))
158         {
159           eof = _rl_arg_callback (_rl_argcxt);
160           if (eof == 0 && (RL_ISSTATE (RL_STATE_NUMERICARG) == 0) && RL_ISSTATE (RL_STATE_INPUTPENDING))
161             rl_callback_read_char ();
162           /* XXX - this should handle _rl_last_command_was_kill better */
163           else if (RL_ISSTATE (RL_STATE_NUMERICARG) == 0)
164             _rl_internal_char_cleanup ();
165
166           return;
167         }
168       else if (RL_ISSTATE (RL_STATE_MULTIKEY))
169         {
170           eof = _rl_dispatch_callback (_rl_kscxt);      /* For now */
171           while ((eof == -1 || eof == -2) && RL_ISSTATE (RL_STATE_MULTIKEY) && _rl_kscxt && (_rl_kscxt->flags & KSEQ_DISPATCHED))
172             eof = _rl_dispatch_callback (_rl_kscxt);
173           if (RL_ISSTATE (RL_STATE_MULTIKEY) == 0)
174             {
175               _rl_internal_char_cleanup ();
176               _rl_want_redisplay = 1;
177             }
178         }
179       else if (_rl_callback_func)
180         {
181           /* This allows functions that simply need to read an additional
182              character (like quoted-insert) to register a function to be
183              called when input is available.  _rl_callback_data is simply a
184              pointer to a struct that has the argument count originally
185              passed to the registering function and space for any additional
186              parameters.  */
187           eof = (*_rl_callback_func) (_rl_callback_data);
188           /* If the function `deregisters' itself, make sure the data is
189              cleaned up. */
190           if (_rl_callback_func == 0)
191             {
192               if (_rl_callback_data)    
193                 {
194                   _rl_callback_data_dispose (_rl_callback_data);
195                   _rl_callback_data = 0;
196                 }
197               _rl_internal_char_cleanup ();
198             }
199         }
200       else
201         eof = readline_internal_char ();
202
203       RL_CHECK_SIGNALS ();
204       if (rl_done == 0 && _rl_want_redisplay)
205         {
206           (*rl_redisplay_function) ();
207           _rl_want_redisplay = 0;
208         }
209
210       if (rl_done)
211         {
212           line = readline_internal_teardown (eof);
213
214           if (rl_deprep_term_function)
215             (*rl_deprep_term_function) ();
216 #if defined (HANDLE_SIGNALS)
217           rl_clear_signals ();
218 #endif
219           in_handler = 0;
220           (*rl_linefunc) (line);
221
222           /* If the user did not clear out the line, do it for him. */
223           if (rl_line_buffer[0])
224             _rl_init_line_state ();
225
226           /* Redisplay the prompt if readline_handler_{install,remove}
227              not called. */
228           if (in_handler == 0 && rl_linefunc)
229             _rl_callback_newline ();
230         }
231     }
232   while (rl_pending_input || _rl_pushed_input_available () || RL_ISSTATE (RL_STATE_MACROINPUT));
233 }
234
235 /* Remove the handler, and make sure the terminal is in its normal state. */
236 void
237 rl_callback_handler_remove ()
238 {
239   rl_linefunc = NULL;
240   RL_UNSETSTATE (RL_STATE_CALLBACK);
241   RL_CHECK_SIGNALS ();
242   if (in_handler)
243     {
244       in_handler = 0;
245       if (rl_deprep_term_function)
246         (*rl_deprep_term_function) ();
247 #if defined (HANDLE_SIGNALS)
248       rl_clear_signals ();
249 #endif
250     }
251 }
252
253 _rl_callback_generic_arg *
254 _rl_callback_data_alloc (count)
255      int count;
256 {
257   _rl_callback_generic_arg *arg;
258
259   arg = (_rl_callback_generic_arg *)xmalloc (sizeof (_rl_callback_generic_arg));
260   arg->count = count;
261
262   arg->i1 = arg->i2 = 0;
263
264   return arg;
265 }
266
267 void _rl_callback_data_dispose (arg)
268      _rl_callback_generic_arg *arg;
269 {
270   xfree (arg);
271 }
272
273 #endif