Commit | Line | Data |
---|---|---|
d60d9f65 SS |
1 | /* callback.c -- functions to use readline as an X `callback' mechanism. */ |
2 | ||
775e241e | 3 | /* Copyright (C) 1987-2015 Free Software Foundation, Inc. |
d60d9f65 | 4 | |
cc88a640 JK |
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. | |
d60d9f65 | 7 | |
cc88a640 JK |
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 | |
d60d9f65 SS |
11 | (at your option) any later version. |
12 | ||
cc88a640 JK |
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 | |
d60d9f65 SS |
16 | GNU General Public License for more details. |
17 | ||
cc88a640 JK |
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 | ||
d60d9f65 SS |
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> | |
9255ee31 EZ |
33 | |
34 | #ifdef HAVE_STDLIB_H | |
35 | # include <stdlib.h> | |
36 | #else | |
37 | # include "ansi_stdlib.h" | |
38 | #endif | |
39 | ||
d60d9f65 SS |
40 | #include <stdio.h> |
41 | ||
42 | /* System-specific feature definitions and include files. */ | |
43 | #include "rldefs.h" | |
44 | #include "readline.h" | |
1b17e766 | 45 | #include "rlprivate.h" |
0b7b5a97 | 46 | #include "xmalloc.h" |
d60d9f65 | 47 | |
5bdf8622 DJ |
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 | ||
775e241e TT |
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 | ||
d60d9f65 SS |
61 | /* **************************************************************** */ |
62 | /* */ | |
5bdf8622 | 63 | /* Callback Readline Functions */ |
d60d9f65 SS |
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 | |
775e241e TT |
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. */ | |
d60d9f65 | 77 | |
9255ee31 | 78 | rl_vcpfunc_t *rl_linefunc; /* user callback function */ |
d60d9f65 SS |
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 | |
83 | _rl_callback_newline () | |
84 | { | |
85 | rl_initialize (); | |
86 | ||
87 | if (in_handler == 0) | |
88 | { | |
89 | in_handler = 1; | |
90 | ||
5bdf8622 DJ |
91 | if (rl_prep_term_function) |
92 | (*rl_prep_term_function) (_rl_meta_flag); | |
5836a818 PP |
93 | |
94 | #if defined (HANDLE_SIGNALS) | |
775e241e TT |
95 | if (rl_persistent_signal_handlers) |
96 | rl_set_signals (); | |
5836a818 | 97 | #endif |
d60d9f65 SS |
98 | } |
99 | ||
100 | readline_internal_setup (); | |
cc88a640 | 101 | RL_CHECK_SIGNALS (); |
d60d9f65 SS |
102 | } |
103 | ||
104 | /* Install a readline handler, set up the terminal, and issue the prompt. */ | |
105 | void | |
106 | rl_callback_handler_install (prompt, linefunc) | |
9255ee31 EZ |
107 | const char *prompt; |
108 | rl_vcpfunc_t *linefunc; | |
d60d9f65 | 109 | { |
9255ee31 | 110 | rl_set_prompt (prompt); |
5bdf8622 | 111 | RL_SETSTATE (RL_STATE_CALLBACK); |
d60d9f65 SS |
112 | rl_linefunc = linefunc; |
113 | _rl_callback_newline (); | |
114 | } | |
115 | ||
775e241e TT |
116 | #if defined (HANDLE_SIGNALS) |
117 | #define CALLBACK_READ_RETURN() \ | |
118 | do { \ | |
119 | if (rl_persistent_signal_handlers == 0) \ | |
120 | rl_clear_signals (); \ | |
121 | return; \ | |
122 | } while (0) | |
123 | #else | |
124 | #define CALLBACK_READ_RETURN() return | |
125 | #endif | |
126 | ||
d60d9f65 SS |
127 | /* Read one character, and dispatch to the handler if it ends the line. */ |
128 | void | |
129 | rl_callback_read_char () | |
130 | { | |
131 | char *line; | |
5bdf8622 DJ |
132 | int eof, jcode; |
133 | static procenv_t olevel; | |
d60d9f65 SS |
134 | |
135 | if (rl_linefunc == NULL) | |
136 | { | |
cc88a640 | 137 | _rl_errmsg ("readline_callback_read_char() called with no handler!"); |
d60d9f65 SS |
138 | abort (); |
139 | } | |
140 | ||
cc88a640 | 141 | memcpy ((void *)olevel, (void *)_rl_top_level, sizeof (procenv_t)); |
775e241e TT |
142 | #if defined (HAVE_POSIX_SIGSETJMP) |
143 | jcode = sigsetjmp (_rl_top_level, 0); | |
144 | #else | |
cc88a640 | 145 | jcode = setjmp (_rl_top_level); |
775e241e | 146 | #endif |
5bdf8622 DJ |
147 | if (jcode) |
148 | { | |
149 | (*rl_redisplay_function) (); | |
150 | _rl_want_redisplay = 0; | |
cc88a640 | 151 | memcpy ((void *)_rl_top_level, (void *)olevel, sizeof (procenv_t)); |
775e241e | 152 | CALLBACK_READ_RETURN (); |
5bdf8622 DJ |
153 | } |
154 | ||
775e241e TT |
155 | #if defined (HANDLE_SIGNALS) |
156 | /* Install signal handlers only when readline has control. */ | |
157 | if (rl_persistent_signal_handlers == 0) | |
158 | rl_set_signals (); | |
159 | #endif | |
160 | ||
cc88a640 | 161 | do |
5bdf8622 | 162 | { |
cc88a640 JK |
163 | RL_CHECK_SIGNALS (); |
164 | if (RL_ISSTATE (RL_STATE_ISEARCH)) | |
165 | { | |
166 | eof = _rl_isearch_callback (_rl_iscxt); | |
167 | if (eof == 0 && (RL_ISSTATE (RL_STATE_ISEARCH) == 0) && RL_ISSTATE (RL_STATE_INPUTPENDING)) | |
168 | rl_callback_read_char (); | |
5bdf8622 | 169 | |
775e241e | 170 | CALLBACK_READ_RETURN (); |
cc88a640 JK |
171 | } |
172 | else if (RL_ISSTATE (RL_STATE_NSEARCH)) | |
173 | { | |
174 | eof = _rl_nsearch_callback (_rl_nscxt); | |
775e241e TT |
175 | |
176 | CALLBACK_READ_RETURN (); | |
cc88a640 JK |
177 | } |
178 | #if defined (VI_MODE) | |
775e241e TT |
179 | /* States that can occur while in state VIMOTION have to be checked |
180 | before RL_STATE_VIMOTION */ | |
181 | else if (RL_ISSTATE (RL_STATE_CHARSEARCH)) | |
182 | { | |
183 | int k; | |
184 | ||
185 | k = _rl_callback_data->i2; | |
186 | ||
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) /* XXX - just sanity check */ | |
191 | { | |
192 | if (_rl_callback_data) | |
193 | { | |
194 | _rl_callback_data_dispose (_rl_callback_data); | |
195 | _rl_callback_data = 0; | |
196 | } | |
197 | } | |
198 | ||
199 | /* Messy case where vi motion command can be char search */ | |
200 | if (RL_ISSTATE (RL_STATE_VIMOTION)) | |
201 | { | |
202 | _rl_vi_domove_motion_cleanup (k, _rl_vimvcxt); | |
203 | _rl_internal_char_cleanup (); | |
204 | CALLBACK_READ_RETURN (); | |
205 | } | |
206 | ||
207 | _rl_internal_char_cleanup (); | |
208 | } | |
cc88a640 JK |
209 | else if (RL_ISSTATE (RL_STATE_VIMOTION)) |
210 | { | |
211 | eof = _rl_vi_domove_callback (_rl_vimvcxt); | |
212 | /* Should handle everything, including cleanup, numeric arguments, | |
213 | and turning off RL_STATE_VIMOTION */ | |
214 | if (RL_ISSTATE (RL_STATE_NUMERICARG) == 0) | |
215 | _rl_internal_char_cleanup (); | |
5bdf8622 | 216 | |
775e241e | 217 | CALLBACK_READ_RETURN (); |
cc88a640 JK |
218 | } |
219 | #endif | |
220 | else if (RL_ISSTATE (RL_STATE_NUMERICARG)) | |
5bdf8622 | 221 | { |
cc88a640 JK |
222 | eof = _rl_arg_callback (_rl_argcxt); |
223 | if (eof == 0 && (RL_ISSTATE (RL_STATE_NUMERICARG) == 0) && RL_ISSTATE (RL_STATE_INPUTPENDING)) | |
224 | rl_callback_read_char (); | |
225 | /* XXX - this should handle _rl_last_command_was_kill better */ | |
226 | else if (RL_ISSTATE (RL_STATE_NUMERICARG) == 0) | |
227 | _rl_internal_char_cleanup (); | |
228 | ||
775e241e | 229 | CALLBACK_READ_RETURN (); |
5bdf8622 | 230 | } |
cc88a640 | 231 | else if (RL_ISSTATE (RL_STATE_MULTIKEY)) |
5bdf8622 | 232 | { |
cc88a640 JK |
233 | eof = _rl_dispatch_callback (_rl_kscxt); /* For now */ |
234 | while ((eof == -1 || eof == -2) && RL_ISSTATE (RL_STATE_MULTIKEY) && _rl_kscxt && (_rl_kscxt->flags & KSEQ_DISPATCHED)) | |
235 | eof = _rl_dispatch_callback (_rl_kscxt); | |
236 | if (RL_ISSTATE (RL_STATE_MULTIKEY) == 0) | |
5bdf8622 | 237 | { |
cc88a640 JK |
238 | _rl_internal_char_cleanup (); |
239 | _rl_want_redisplay = 1; | |
5bdf8622 | 240 | } |
5bdf8622 | 241 | } |
cc88a640 JK |
242 | else if (_rl_callback_func) |
243 | { | |
244 | /* This allows functions that simply need to read an additional | |
245 | character (like quoted-insert) to register a function to be | |
775e241e | 246 | called when input is available. _rl_callback_data is a |
cc88a640 JK |
247 | pointer to a struct that has the argument count originally |
248 | passed to the registering function and space for any additional | |
249 | parameters. */ | |
250 | eof = (*_rl_callback_func) (_rl_callback_data); | |
251 | /* If the function `deregisters' itself, make sure the data is | |
252 | cleaned up. */ | |
253 | if (_rl_callback_func == 0) | |
254 | { | |
255 | if (_rl_callback_data) | |
256 | { | |
257 | _rl_callback_data_dispose (_rl_callback_data); | |
258 | _rl_callback_data = 0; | |
259 | } | |
260 | _rl_internal_char_cleanup (); | |
261 | } | |
262 | } | |
263 | else | |
264 | eof = readline_internal_char (); | |
5bdf8622 | 265 | |
cc88a640 JK |
266 | RL_CHECK_SIGNALS (); |
267 | if (rl_done == 0 && _rl_want_redisplay) | |
268 | { | |
269 | (*rl_redisplay_function) (); | |
270 | _rl_want_redisplay = 0; | |
271 | } | |
d60d9f65 | 272 | |
9255ee31 EZ |
273 | if (rl_done) |
274 | { | |
275 | line = readline_internal_teardown (eof); | |
d60d9f65 | 276 | |
5bdf8622 DJ |
277 | if (rl_deprep_term_function) |
278 | (*rl_deprep_term_function) (); | |
d60d9f65 | 279 | #if defined (HANDLE_SIGNALS) |
9255ee31 | 280 | rl_clear_signals (); |
d60d9f65 | 281 | #endif |
9255ee31 EZ |
282 | in_handler = 0; |
283 | (*rl_linefunc) (line); | |
284 | ||
285 | /* If the user did not clear out the line, do it for him. */ | |
286 | if (rl_line_buffer[0]) | |
287 | _rl_init_line_state (); | |
288 | ||
289 | /* Redisplay the prompt if readline_handler_{install,remove} | |
290 | not called. */ | |
291 | if (in_handler == 0 && rl_linefunc) | |
292 | _rl_callback_newline (); | |
293 | } | |
d60d9f65 | 294 | } |
cc88a640 | 295 | while (rl_pending_input || _rl_pushed_input_available () || RL_ISSTATE (RL_STATE_MACROINPUT)); |
775e241e TT |
296 | |
297 | CALLBACK_READ_RETURN (); | |
d60d9f65 SS |
298 | } |
299 | ||
300 | /* Remove the handler, and make sure the terminal is in its normal state. */ | |
301 | void | |
302 | rl_callback_handler_remove () | |
303 | { | |
304 | rl_linefunc = NULL; | |
5bdf8622 | 305 | RL_UNSETSTATE (RL_STATE_CALLBACK); |
cc88a640 | 306 | RL_CHECK_SIGNALS (); |
d60d9f65 SS |
307 | if (in_handler) |
308 | { | |
309 | in_handler = 0; | |
5bdf8622 DJ |
310 | if (rl_deprep_term_function) |
311 | (*rl_deprep_term_function) (); | |
d60d9f65 SS |
312 | #if defined (HANDLE_SIGNALS) |
313 | rl_clear_signals (); | |
314 | #endif | |
315 | } | |
316 | } | |
317 | ||
5bdf8622 DJ |
318 | _rl_callback_generic_arg * |
319 | _rl_callback_data_alloc (count) | |
320 | int count; | |
321 | { | |
322 | _rl_callback_generic_arg *arg; | |
323 | ||
324 | arg = (_rl_callback_generic_arg *)xmalloc (sizeof (_rl_callback_generic_arg)); | |
325 | arg->count = count; | |
326 | ||
327 | arg->i1 = arg->i2 = 0; | |
328 | ||
329 | return arg; | |
330 | } | |
331 | ||
775e241e TT |
332 | void |
333 | _rl_callback_data_dispose (arg) | |
5bdf8622 DJ |
334 | _rl_callback_generic_arg *arg; |
335 | { | |
cc88a640 | 336 | xfree (arg); |
5bdf8622 DJ |
337 | } |
338 | ||
775e241e TT |
339 | /* Make sure that this agrees with cases in rl_callback_read_char */ |
340 | void | |
341 | rl_callback_sigcleanup () | |
342 | { | |
343 | if (RL_ISSTATE (RL_STATE_CALLBACK) == 0) | |
344 | return; | |
345 | ||
346 | if (RL_ISSTATE (RL_STATE_ISEARCH)) | |
347 | _rl_isearch_cleanup (_rl_iscxt, 0); | |
348 | else if (RL_ISSTATE (RL_STATE_NSEARCH)) | |
349 | _rl_nsearch_cleanup (_rl_nscxt, 0); | |
350 | else if (RL_ISSTATE (RL_STATE_VIMOTION)) | |
351 | RL_UNSETSTATE (RL_STATE_VIMOTION); | |
352 | else if (RL_ISSTATE (RL_STATE_NUMERICARG)) | |
353 | { | |
354 | _rl_argcxt = 0; | |
355 | RL_UNSETSTATE (RL_STATE_NUMERICARG); | |
356 | } | |
357 | else if (RL_ISSTATE (RL_STATE_MULTIKEY)) | |
358 | RL_UNSETSTATE (RL_STATE_MULTIKEY); | |
359 | if (RL_ISSTATE (RL_STATE_CHARSEARCH)) | |
360 | RL_UNSETSTATE (RL_STATE_CHARSEARCH); | |
361 | ||
362 | _rl_callback_func = 0; | |
363 | } | |
d60d9f65 | 364 | #endif |