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