1 /* callback.c -- functions to use readline as an X `callback' mechanism. */
2
3 /* Copyright (C) 1987-2017 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 /* Applications can set this to non-zero to have readline's signal handlers
54 installed during the entire duration of reading a complete line, as in
55 readline-6.2. This should be used with care, because it can result in
56 readline receiving signals and not handling them until it's called again
57 via rl_callback_read_char, thereby stealing them from the application.
58 By default, signal handlers are only active while readline is active. */
59 int rl_persistent_signal_handlers = 0;
60
61 /* **************************************************************** */
62 /* */
63 /* Callback Readline Functions */
64 /* */
65 /* **************************************************************** */
66
67 /* Allow using readline in situations where a program may have multiple
68 things to handle at once, and dispatches them via select(). Call
69 rl_callback_handler_install() with the prompt and a function to call
70 whenever a complete line of input is ready. The user must then
71 call rl_callback_read_char() every time some input is available, and
72 rl_callback_read_char() will call the user's function with the complete
73 text read in at each end of line. The terminal is kept prepped
74 all the time, except during calls to the user's function. Signal
75 handlers are only installed when the application calls back into
76 readline, so readline doesn't `steal' signals from the application. */
77
78 rl_vcpfunc_t *rl_linefunc; /* user callback function */
79 static int in_handler; /* terminal_prepped and signals set? */
80
81 /* Make sure the terminal is set up, initialize readline, and prompt. */
82 static void
_rl_callback_newline(void)83 _rl_callback_newline (void)
84 {
85 rl_initialize ();
86
87 if (in_handler == 0)
88 {
89 in_handler = 1;
90
91 if (rl_prep_term_function)
92 (*rl_prep_term_function) (_rl_meta_flag);
93
94 #if defined (HANDLE_SIGNALS)
95 if (rl_persistent_signal_handlers)
96 rl_set_signals ();
97 #endif
98 }
99
100 readline_internal_setup ();
101 RL_CHECK_SIGNALS ();
102 }
103
104 /* Install a readline handler, set up the terminal, and issue the prompt. */
105 void
rl_callback_handler_install(const char * prompt,rl_vcpfunc_t * linefunc)106 rl_callback_handler_install (const char *prompt, rl_vcpfunc_t *linefunc)
107 {
108 rl_set_prompt (prompt);
109 RL_SETSTATE (RL_STATE_CALLBACK);
110 rl_linefunc = linefunc;
111 _rl_callback_newline ();
112 }
113
114 #if defined (HANDLE_SIGNALS)
115 #define CALLBACK_READ_RETURN() \
116 do { \
117 if (rl_persistent_signal_handlers == 0) \
118 rl_clear_signals (); \
119 return; \
120 } while (0)
121 #else
122 #define CALLBACK_READ_RETURN() return
123 #endif
124
125 /* Read one character, and dispatch to the handler if it ends the line. */
126 void
rl_callback_read_char(void)127 rl_callback_read_char (void)
128 {
129 char *line;
130 int eof, jcode;
131 static procenv_t olevel;
132
133 if (rl_linefunc == NULL)
134 {
135 _rl_errmsg ("readline_callback_read_char() called with no handler!");
136 abort ();
137 }
138
139 memcpy ((void *)olevel, (void *)_rl_top_level, sizeof (procenv_t));
140 #if defined (HAVE_POSIX_SIGSETJMP)
141 jcode = sigsetjmp (_rl_top_level, 0);
142 #else
143 jcode = setjmp (_rl_top_level);
144 #endif
145 if (jcode)
146 {
147 (*rl_redisplay_function) ();
148 _rl_want_redisplay = 0;
149 memcpy ((void *)_rl_top_level, (void *)olevel, sizeof (procenv_t));
150 CALLBACK_READ_RETURN ();
151 }
152
153 #if defined (HANDLE_SIGNALS)
154 /* Install signal handlers only when readline has control. */
155 if (rl_persistent_signal_handlers == 0)
156 rl_set_signals ();
157 #endif
158
159 do
160 {
161 RL_CHECK_SIGNALS ();
162 if (RL_ISSTATE (RL_STATE_ISEARCH))
163 {
164 eof = _rl_isearch_callback (_rl_iscxt);
165 if (eof == 0 && (RL_ISSTATE (RL_STATE_ISEARCH) == 0) && RL_ISSTATE (RL_STATE_INPUTPENDING))
166 rl_callback_read_char ();
167
168 CALLBACK_READ_RETURN ();
169 }
170 else if (RL_ISSTATE (RL_STATE_NSEARCH))
171 {
172 eof = _rl_nsearch_callback (_rl_nscxt);
173
174 CALLBACK_READ_RETURN ();
175 }
176 #if defined (VI_MODE)
177 /* States that can occur while in state VIMOTION have to be checked
178 before RL_STATE_VIMOTION */
179 else if (RL_ISSTATE (RL_STATE_CHARSEARCH))
180 {
181 int k;
182
183 k = _rl_callback_data->i2;
184
185 eof = (*_rl_callback_func) (_rl_callback_data);
186 /* If the function `deregisters' itself, make sure the data is
187 cleaned up. */
188 if (_rl_callback_func == 0) /* XXX - just sanity check */
189 {
190 if (_rl_callback_data)
191 {
192 _rl_callback_data_dispose (_rl_callback_data);
193 _rl_callback_data = 0;
194 }
195 }
196
197 /* Messy case where vi motion command can be char search */
198 if (RL_ISSTATE (RL_STATE_VIMOTION))
199 {
200 _rl_vi_domove_motion_cleanup (k, _rl_vimvcxt);
201 _rl_internal_char_cleanup ();
202 CALLBACK_READ_RETURN ();
203 }
204
205 _rl_internal_char_cleanup ();
206 }
207 else if (RL_ISSTATE (RL_STATE_VIMOTION))
208 {
209 eof = _rl_vi_domove_callback (_rl_vimvcxt);
210 /* Should handle everything, including cleanup, numeric arguments,
211 and turning off RL_STATE_VIMOTION */
212 if (RL_ISSTATE (RL_STATE_NUMERICARG) == 0)
213 _rl_internal_char_cleanup ();
214
215 CALLBACK_READ_RETURN ();
216 }
217 #endif
218 else if (RL_ISSTATE (RL_STATE_NUMERICARG))
219 {
220 eof = _rl_arg_callback (_rl_argcxt);
221 if (eof == 0 && (RL_ISSTATE (RL_STATE_NUMERICARG) == 0) && RL_ISSTATE (RL_STATE_INPUTPENDING))
222 rl_callback_read_char ();
223 /* XXX - this should handle _rl_last_command_was_kill better */
224 else if (RL_ISSTATE (RL_STATE_NUMERICARG) == 0)
225 _rl_internal_char_cleanup ();
226
227 CALLBACK_READ_RETURN ();
228 }
229 else if (RL_ISSTATE (RL_STATE_MULTIKEY))
230 {
231 eof = _rl_dispatch_callback (_rl_kscxt); /* For now */
232 while ((eof == -1 || eof == -2) && RL_ISSTATE (RL_STATE_MULTIKEY) && _rl_kscxt && (_rl_kscxt->flags & KSEQ_DISPATCHED))
233 eof = _rl_dispatch_callback (_rl_kscxt);
234 if (RL_ISSTATE (RL_STATE_MULTIKEY) == 0)
235 {
236 _rl_internal_char_cleanup ();
237 _rl_want_redisplay = 1;
238 }
239 }
240 else if (_rl_callback_func)
241 {
242 /* This allows functions that simply need to read an additional
243 character (like quoted-insert) to register a function to be
244 called when input is available. _rl_callback_data is a
245 pointer to a struct that has the argument count originally
246 passed to the registering function and space for any additional
247 parameters. */
248 eof = (*_rl_callback_func) (_rl_callback_data);
249 /* If the function `deregisters' itself, make sure the data is
250 cleaned up. */
251 if (_rl_callback_func == 0)
252 {
253 if (_rl_callback_data)
254 {
255 _rl_callback_data_dispose (_rl_callback_data);
256 _rl_callback_data = 0;
257 }
258 _rl_internal_char_cleanup ();
259 }
260 }
261 else
262 eof = readline_internal_char ();
263
264 RL_CHECK_SIGNALS ();
265 if (rl_done == 0 && _rl_want_redisplay)
266 {
267 (*rl_redisplay_function) ();
268 _rl_want_redisplay = 0;
269 }
270
271 if (rl_done)
272 {
273 line = readline_internal_teardown (eof);
274
275 if (rl_deprep_term_function)
276 (*rl_deprep_term_function) ();
277 #if defined (HANDLE_SIGNALS)
278 rl_clear_signals ();
279 #endif
280 in_handler = 0;
281 (*rl_linefunc) (line);
282
283 /* If the user did not clear out the line, do it for him. */
284 if (rl_line_buffer[0])
285 _rl_init_line_state ();
286
287 /* Redisplay the prompt if readline_handler_{install,remove}
288 not called. */
289 if (in_handler == 0 && rl_linefunc)
290 _rl_callback_newline ();
291 }
292 }
293 while (rl_pending_input || _rl_pushed_input_available () || RL_ISSTATE (RL_STATE_MACROINPUT));
294
295 CALLBACK_READ_RETURN ();
296 }
297
298 /* Remove the handler, and make sure the terminal is in its normal state. */
299 void
rl_callback_handler_remove(void)300 rl_callback_handler_remove (void)
301 {
302 rl_linefunc = NULL;
303 RL_UNSETSTATE (RL_STATE_CALLBACK);
304 RL_CHECK_SIGNALS ();
305 if (in_handler)
306 {
307 in_handler = 0;
308 if (rl_deprep_term_function)
309 (*rl_deprep_term_function) ();
310 #if defined (HANDLE_SIGNALS)
311 rl_clear_signals ();
312 #endif
313 }
314 }
315
316 _rl_callback_generic_arg *
_rl_callback_data_alloc(int count)317 _rl_callback_data_alloc (int count)
318 {
319 _rl_callback_generic_arg *arg;
320
321 arg = (_rl_callback_generic_arg *)xmalloc (sizeof (_rl_callback_generic_arg));
322 arg->count = count;
323
324 arg->i1 = arg->i2 = 0;
325
326 return arg;
327 }
328
329 void
_rl_callback_data_dispose(_rl_callback_generic_arg * arg)330 _rl_callback_data_dispose (_rl_callback_generic_arg *arg)
331 {
332 xfree (arg);
333 }
334
335 /* Make sure that this agrees with cases in rl_callback_read_char */
336 void
rl_callback_sigcleanup(void)337 rl_callback_sigcleanup (void)
338 {
339 if (RL_ISSTATE (RL_STATE_CALLBACK) == 0)
340 return;
341
342 if (RL_ISSTATE (RL_STATE_ISEARCH))
343 _rl_isearch_cleanup (_rl_iscxt, 0);
344 else if (RL_ISSTATE (RL_STATE_NSEARCH))
345 _rl_nsearch_cleanup (_rl_nscxt, 0);
346 else if (RL_ISSTATE (RL_STATE_VIMOTION))
347 RL_UNSETSTATE (RL_STATE_VIMOTION);
348 else if (RL_ISSTATE (RL_STATE_NUMERICARG))
349 {
350 _rl_argcxt = 0;
351 RL_UNSETSTATE (RL_STATE_NUMERICARG);
352 }
353 else if (RL_ISSTATE (RL_STATE_MULTIKEY))
354 RL_UNSETSTATE (RL_STATE_MULTIKEY);
355 if (RL_ISSTATE (RL_STATE_CHARSEARCH))
356 RL_UNSETSTATE (RL_STATE_CHARSEARCH);
357
358 _rl_callback_func = 0;
359 }
360 #endif
361