Commit | Line | Data |
---|---|---|
b5a0ac70 | 1 | /* Top level stuff for GDB, the GNU debugger. |
637537d0 | 2 | |
0b302171 JB |
3 | Copyright (C) 1999-2002, 2004-2005, 2007-2012 Free Software |
4 | Foundation, Inc. | |
637537d0 | 5 | |
b5a0ac70 SS |
6 | Written by Elena Zannoni <ezannoni@cygnus.com> of Cygnus Solutions. |
7 | ||
8 | This file is part of GDB. | |
9 | ||
10 | This program is free software; you can redistribute it and/or modify | |
11 | it under the terms of the GNU General Public License as published by | |
a9762ec7 | 12 | the Free Software Foundation; either version 3 of the License, or |
b5a0ac70 SS |
13 | (at your option) any later version. |
14 | ||
15 | This program is distributed in the hope that it will be useful, | |
16 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 | GNU General Public License for more details. | |
19 | ||
20 | You should have received a copy of the GNU General Public License | |
371d5dec | 21 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
b5a0ac70 SS |
22 | |
23 | #include "defs.h" | |
0f71a2f6 | 24 | #include "top.h" |
b5a0ac70 | 25 | #include "inferior.h" |
e514a9d6 | 26 | #include "target.h" |
c5aa993b | 27 | #include "terminal.h" /* for job_control */ |
9e0b60a8 | 28 | #include "event-loop.h" |
c2c6d25f | 29 | #include "event-top.h" |
4389a95a | 30 | #include "interps.h" |
042be3a9 | 31 | #include <signal.h> |
60250e8b | 32 | #include "exceptions.h" |
16026cd7 | 33 | #include "cli/cli-script.h" /* for reset_command_nest_depth */ |
d01a8610 | 34 | #include "main.h" |
8ea051c5 | 35 | #include "gdbthread.h" |
d17b6f81 | 36 | #include "observer.h" |
be34f849 | 37 | #include "continuations.h" |
371d5dec | 38 | #include "gdbcmd.h" /* for dont_repeat() */ |
104c1213 | 39 | |
371d5dec | 40 | /* readline include files. */ |
dbda9972 AC |
41 | #include "readline/readline.h" |
42 | #include "readline/history.h" | |
b5a0ac70 SS |
43 | |
44 | /* readline defines this. */ | |
45 | #undef savestring | |
46 | ||
c2c6d25f JM |
47 | static void rl_callback_read_char_wrapper (gdb_client_data client_data); |
48 | static void command_line_handler (char *rl); | |
c2c6d25f | 49 | static void change_line_handler (void); |
c2c6d25f | 50 | static void command_handler (char *command); |
ab821bc6 | 51 | static char *top_level_prompt (void); |
b5a0ac70 | 52 | |
371d5dec | 53 | /* Signal handlers. */ |
6d318c73 | 54 | #ifdef SIGQUIT |
c2c6d25f | 55 | static void handle_sigquit (int sig); |
6d318c73 | 56 | #endif |
0f0b8dcd | 57 | #ifdef SIGHUP |
c2c6d25f | 58 | static void handle_sighup (int sig); |
0f0b8dcd | 59 | #endif |
c2c6d25f | 60 | static void handle_sigfpe (int sig); |
b5a0ac70 SS |
61 | |
62 | /* Functions to be invoked by the event loop in response to | |
371d5dec | 63 | signals. */ |
0f0b8dcd | 64 | #if defined (SIGQUIT) || defined (SIGHUP) |
c2c6d25f | 65 | static void async_do_nothing (gdb_client_data); |
0f0b8dcd DJ |
66 | #endif |
67 | #ifdef SIGHUP | |
c2c6d25f | 68 | static void async_disconnect (gdb_client_data); |
0f0b8dcd | 69 | #endif |
c2c6d25f | 70 | static void async_float_handler (gdb_client_data); |
0f0b8dcd | 71 | #ifdef STOP_SIGNAL |
c2c6d25f | 72 | static void async_stop_sig (gdb_client_data); |
0f0b8dcd | 73 | #endif |
b5a0ac70 | 74 | |
b5a0ac70 | 75 | /* Readline offers an alternate interface, via callback |
371d5dec | 76 | functions. These are all included in the file callback.c in the |
b5a0ac70 SS |
77 | readline distribution. This file provides (mainly) a function, which |
78 | the event loop uses as callback (i.e. event handler) whenever an event | |
79 | is detected on the standard input file descriptor. | |
80 | readline_callback_read_char is called (by the GDB event loop) whenever | |
371d5dec | 81 | there is a new character ready on the input stream. This function |
b5a0ac70 SS |
82 | incrementally builds a buffer internal to readline where it |
83 | accumulates the line read up to the point of invocation. In the | |
84 | special case in which the character read is newline, the function | |
85 | invokes a GDB supplied callback routine, which does the processing of | |
86 | a full command line. This latter routine is the asynchronous analog | |
371d5dec | 87 | of the old command_line_input in gdb. Instead of invoking (and waiting |
b5a0ac70 SS |
88 | for) readline to read the command line and pass it back to |
89 | command_loop for processing, the new command_line_handler function has | |
90 | the command line already available as its parameter. INPUT_HANDLER is | |
91 | to be set to the function that readline will invoke when a complete | |
92 | line of input is ready. CALL_READLINE is to be set to the function | |
371d5dec | 93 | that readline offers as callback to the event_loop. */ |
b5a0ac70 | 94 | |
c2c6d25f JM |
95 | void (*input_handler) (char *); |
96 | void (*call_readline) (gdb_client_data); | |
b5a0ac70 | 97 | |
371d5dec | 98 | /* Important variables for the event loop. */ |
b5a0ac70 SS |
99 | |
100 | /* This is used to determine if GDB is using the readline library or | |
371d5dec | 101 | its own simplified form of readline. It is used by the asynchronous |
0f71a2f6 | 102 | form of the set editing command. |
392a587b | 103 | ezannoni: as of 1999-04-29 I expect that this |
b5a0ac70 | 104 | variable will not be used after gdb is changed to use the event |
371d5dec | 105 | loop as default engine, and event-top.c is merged into top.c. */ |
b5a0ac70 SS |
106 | int async_command_editing_p; |
107 | ||
b5a0ac70 | 108 | /* This is the annotation suffix that will be used when the |
371d5dec | 109 | annotation_level is 2. */ |
b5a0ac70 SS |
110 | char *async_annotation_suffix; |
111 | ||
104c1213 | 112 | /* This is used to display the notification of the completion of an |
371d5dec | 113 | asynchronous execution command. */ |
104c1213 JM |
114 | int exec_done_display_p = 0; |
115 | ||
b5a0ac70 | 116 | /* This is the file descriptor for the input stream that GDB uses to |
371d5dec | 117 | read commands from. */ |
b5a0ac70 SS |
118 | int input_fd; |
119 | ||
371d5dec | 120 | /* Signal handling variables. */ |
b5a0ac70 | 121 | /* Each of these is a pointer to a function that the event loop will |
371d5dec | 122 | invoke if the corresponding signal has received. The real signal |
b5a0ac70 | 123 | handlers mark these functions as ready to be executed and the event |
371d5dec MS |
124 | loop, in a later iteration, calls them. See the function |
125 | invoke_async_signal_handler. */ | |
05fa9251 | 126 | static struct async_signal_handler *sigint_token; |
b5a0ac70 | 127 | #ifdef SIGHUP |
05fa9251 | 128 | static struct async_signal_handler *sighup_token; |
b5a0ac70 | 129 | #endif |
6d318c73 | 130 | #ifdef SIGQUIT |
05fa9251 | 131 | static struct async_signal_handler *sigquit_token; |
6d318c73 | 132 | #endif |
05fa9251 | 133 | static struct async_signal_handler *sigfpe_token; |
0f71a2f6 | 134 | #ifdef STOP_SIGNAL |
05fa9251 | 135 | static struct async_signal_handler *sigtstp_token; |
0f71a2f6 JM |
136 | #endif |
137 | ||
b5a0ac70 | 138 | /* Structure to save a partially entered command. This is used when |
371d5dec | 139 | the user types '\' at the end of a command line. This is necessary |
b5a0ac70 SS |
140 | because each line of input is handled by a different call to |
141 | command_line_handler, and normally there is no state retained | |
371d5dec | 142 | between different calls. */ |
ab821bc6 | 143 | static int more_to_come = 0; |
b5a0ac70 SS |
144 | |
145 | struct readline_input_state | |
146 | { | |
147 | char *linebuffer; | |
148 | char *linebuffer_ptr; | |
149 | } | |
150 | readline_input_state; | |
467d8519 TT |
151 | |
152 | /* This hook is called by rl_callback_read_char_wrapper after each | |
153 | character is processed. */ | |
b08ee6a2 | 154 | void (*after_char_processing_hook) (void); |
b5a0ac70 SS |
155 | \f |
156 | ||
371d5dec MS |
157 | /* Wrapper function for calling into the readline library. The event |
158 | loop expects the callback function to have a paramter, while | |
159 | readline expects none. */ | |
c2c6d25f JM |
160 | static void |
161 | rl_callback_read_char_wrapper (gdb_client_data client_data) | |
162 | { | |
163 | rl_callback_read_char (); | |
467d8519 TT |
164 | if (after_char_processing_hook) |
165 | (*after_char_processing_hook) (); | |
c2c6d25f JM |
166 | } |
167 | ||
b5a0ac70 | 168 | /* Initialize all the necessary variables, start the event loop, |
371d5dec | 169 | register readline, and stdin, start the loop. */ |
b5a0ac70 | 170 | void |
c2c6d25f | 171 | cli_command_loop (void) |
b5a0ac70 | 172 | { |
7d8e6458 | 173 | display_gdb_prompt (0); |
b5a0ac70 | 174 | |
371d5dec | 175 | /* Now it's time to start the event loop. */ |
085dd6e6 | 176 | start_event_loop (); |
b5a0ac70 SS |
177 | } |
178 | ||
179 | /* Change the function to be invoked every time there is a character | |
371d5dec | 180 | ready on stdin. This is used when the user sets the editing off, |
b5a0ac70 | 181 | therefore bypassing readline, and letting gdb handle the input |
371d5dec | 182 | itself, via gdb_readline2. Also it is used in the opposite case in |
b5a0ac70 | 183 | which the user sets editing on again, by restoring readline |
371d5dec | 184 | handling of the input. */ |
392a587b | 185 | static void |
c2c6d25f | 186 | change_line_handler (void) |
b5a0ac70 | 187 | { |
371d5dec MS |
188 | /* NOTE: this operates on input_fd, not instream. If we are reading |
189 | commands from a file, instream will point to the file. However in | |
c2c6d25f | 190 | async mode, we always read commands from a file with editing |
371d5dec MS |
191 | off. This means that the 'set editing on/off' will have effect |
192 | only on the interactive session. */ | |
c2c6d25f | 193 | |
b5a0ac70 SS |
194 | if (async_command_editing_p) |
195 | { | |
371d5dec | 196 | /* Turn on editing by using readline. */ |
c2c6d25f | 197 | call_readline = rl_callback_read_char_wrapper; |
0f71a2f6 | 198 | input_handler = command_line_handler; |
b5a0ac70 SS |
199 | } |
200 | else | |
201 | { | |
371d5dec | 202 | /* Turn off editing by using gdb_readline2. */ |
b5a0ac70 SS |
203 | rl_callback_handler_remove (); |
204 | call_readline = gdb_readline2; | |
0f71a2f6 JM |
205 | |
206 | /* Set up the command handler as well, in case we are called as | |
371d5dec | 207 | first thing from .gdbinit. */ |
0f71a2f6 | 208 | input_handler = command_line_handler; |
b5a0ac70 | 209 | } |
b5a0ac70 SS |
210 | } |
211 | ||
ab821bc6 PA |
212 | /* Displays the prompt. If the argument NEW_PROMPT is NULL, the |
213 | prompt that is displayed is the current top level prompt. | |
214 | Otherwise, it displays whatever NEW_PROMPT is as a local/secondary | |
215 | prompt. | |
216 | ||
217 | This is used after each gdb command has completed, and in the | |
218 | following cases: | |
219 | ||
371d5dec | 220 | 1. When the user enters a command line which is ended by '\' |
ab821bc6 PA |
221 | indicating that the command will continue on the next line. In |
222 | that case the prompt that is displayed is the empty string. | |
223 | ||
0f71a2f6 | 224 | 2. When the user is entering 'commands' for a breakpoint, or |
371d5dec | 225 | actions for a tracepoint. In this case the prompt will be '>' |
ab821bc6 PA |
226 | |
227 | 3. On prompting for pagination. */ | |
228 | ||
b5a0ac70 | 229 | void |
c2c6d25f | 230 | display_gdb_prompt (char *new_prompt) |
b5a0ac70 | 231 | { |
d17b6f81 | 232 | char *actual_gdb_prompt = NULL; |
ab821bc6 | 233 | struct cleanup *old_chain; |
b5a0ac70 | 234 | |
16026cd7 AS |
235 | /* Reset the nesting depth used when trace-commands is set. */ |
236 | reset_command_nest_depth (); | |
237 | ||
4389a95a AC |
238 | /* Each interpreter has its own rules on displaying the command |
239 | prompt. */ | |
240 | if (!current_interp_display_prompt_p ()) | |
fb40c209 | 241 | return; |
fb40c209 | 242 | |
ab821bc6 | 243 | old_chain = make_cleanup (free_current_contents, &actual_gdb_prompt); |
d17b6f81 | 244 | |
ab821bc6 PA |
245 | /* Do not call the python hook on an explicit prompt change as |
246 | passed to this function, as this forms a secondary/local prompt, | |
247 | IE, displayed but not set. */ | |
248 | if (! new_prompt) | |
adf40b2e | 249 | { |
ab821bc6 | 250 | if (sync_execution) |
d17b6f81 | 251 | { |
ab821bc6 PA |
252 | /* This is to trick readline into not trying to display the |
253 | prompt. Even though we display the prompt using this | |
254 | function, readline still tries to do its own display if | |
255 | we don't call rl_callback_handler_install and | |
256 | rl_callback_handler_remove (which readline detects | |
257 | because a global variable is not set). If readline did | |
258 | that, it could mess up gdb signal handlers for SIGINT. | |
259 | Readline assumes that between calls to rl_set_signals and | |
260 | rl_clear_signals gdb doesn't do anything with the signal | |
261 | handlers. Well, that's not the case, because when the | |
262 | target executes we change the SIGINT signal handler. If | |
263 | we allowed readline to display the prompt, the signal | |
264 | handler change would happen exactly between the calls to | |
265 | the above two functions. Calling | |
266 | rl_callback_handler_remove(), does the job. */ | |
267 | ||
268 | rl_callback_handler_remove (); | |
269 | return; | |
d17b6f81 PM |
270 | } |
271 | else | |
ab821bc6 PA |
272 | { |
273 | /* Display the top level prompt. */ | |
274 | actual_gdb_prompt = top_level_prompt (); | |
275 | } | |
b5a0ac70 | 276 | } |
ab821bc6 PA |
277 | else |
278 | actual_gdb_prompt = xstrdup (new_prompt); | |
b5a0ac70 SS |
279 | |
280 | if (async_command_editing_p) | |
281 | { | |
282 | rl_callback_handler_remove (); | |
d17b6f81 | 283 | rl_callback_handler_install (actual_gdb_prompt, input_handler); |
b5a0ac70 | 284 | } |
371d5dec | 285 | /* new_prompt at this point can be the top of the stack or the one |
d014929c MS |
286 | passed in. It can't be NULL. */ |
287 | else | |
b5a0ac70 SS |
288 | { |
289 | /* Don't use a _filtered function here. It causes the assumed | |
290 | character position to be off, since the newline we read from | |
291 | the user is not accounted for. */ | |
d17b6f81 | 292 | fputs_unfiltered (actual_gdb_prompt, gdb_stdout); |
b5a0ac70 SS |
293 | gdb_flush (gdb_stdout); |
294 | } | |
ab821bc6 PA |
295 | |
296 | do_cleanups (old_chain); | |
b5a0ac70 SS |
297 | } |
298 | ||
ab821bc6 PA |
299 | /* Return the top level prompt, as specified by "set prompt", possibly |
300 | overriden by the python gdb.prompt_hook hook, and then composed | |
301 | with the prompt prefix and suffix (annotations). The caller is | |
302 | responsible for freeing the returned string. */ | |
303 | ||
304 | static char * | |
305 | top_level_prompt (void) | |
b5a0ac70 | 306 | { |
ab821bc6 PA |
307 | char *prefix; |
308 | char *prompt = NULL; | |
309 | char *suffix; | |
310 | char *composed_prompt; | |
311 | size_t prompt_length; | |
b5a0ac70 | 312 | |
ab821bc6 PA |
313 | /* Give observers a chance of changing the prompt. E.g., the python |
314 | `gdb.prompt_hook' is installed as an observer. */ | |
315 | observer_notify_before_prompt (get_prompt ()); | |
316 | ||
317 | prompt = xstrdup (get_prompt ()); | |
b5a0ac70 | 318 | |
ab821bc6 | 319 | if (annotation_level >= 2) |
b5a0ac70 | 320 | { |
ab821bc6 PA |
321 | /* Prefix needs to have new line at end. */ |
322 | prefix = (char *) alloca (strlen (async_annotation_suffix) + 10); | |
323 | strcpy (prefix, "\n\032\032pre-"); | |
324 | strcat (prefix, async_annotation_suffix); | |
325 | strcat (prefix, "\n"); | |
326 | ||
327 | /* Suffix needs to have a new line at end and \032 \032 at | |
328 | beginning. */ | |
329 | suffix = (char *) alloca (strlen (async_annotation_suffix) + 6); | |
330 | strcpy (suffix, "\n\032\032"); | |
331 | strcat (suffix, async_annotation_suffix); | |
332 | strcat (suffix, "\n"); | |
b5a0ac70 SS |
333 | } |
334 | else | |
335 | { | |
ab821bc6 PA |
336 | prefix = ""; |
337 | suffix = ""; | |
b5a0ac70 | 338 | } |
b5a0ac70 | 339 | |
ab821bc6 PA |
340 | prompt_length = strlen (prefix) + strlen (prompt) + strlen (suffix); |
341 | composed_prompt = xmalloc (prompt_length + 1); | |
b5a0ac70 | 342 | |
ab821bc6 PA |
343 | strcpy (composed_prompt, prefix); |
344 | strcat (composed_prompt, prompt); | |
345 | strcat (composed_prompt, suffix); | |
b5a0ac70 | 346 | |
ab821bc6 PA |
347 | xfree (prompt); |
348 | ||
349 | return composed_prompt; | |
b5a0ac70 | 350 | } |
c2c6d25f JM |
351 | |
352 | /* When there is an event ready on the stdin file desriptor, instead | |
353 | of calling readline directly throught the callback function, or | |
354 | instead of calling gdb_readline2, give gdb a chance to detect | |
371d5dec | 355 | errors and do something. */ |
c2c6d25f | 356 | void |
2acceee2 | 357 | stdin_event_handler (int error, gdb_client_data client_data) |
c2c6d25f JM |
358 | { |
359 | if (error) | |
360 | { | |
a3f17187 | 361 | printf_unfiltered (_("error detected on stdin\n")); |
2acceee2 | 362 | delete_file_handler (input_fd); |
c2c6d25f | 363 | discard_all_continuations (); |
604ead4a | 364 | discard_all_intermediate_continuations (); |
371d5dec | 365 | /* If stdin died, we may as well kill gdb. */ |
c5394b80 | 366 | quit_command ((char *) 0, stdin == instream); |
c2c6d25f JM |
367 | } |
368 | else | |
6426a772 | 369 | (*call_readline) (client_data); |
c2c6d25f JM |
370 | } |
371 | ||
6426a772 JM |
372 | /* Re-enable stdin after the end of an execution command in |
373 | synchronous mode, or after an error from the target, and we aborted | |
371d5dec | 374 | the exec operation. */ |
6426a772 JM |
375 | |
376 | void | |
712af3be | 377 | async_enable_stdin (void) |
6426a772 | 378 | { |
32c1e744 VP |
379 | if (sync_execution) |
380 | { | |
371d5dec | 381 | /* See NOTE in async_disable_stdin(). */ |
32c1e744 VP |
382 | /* FIXME: cagney/1999-09-27: Call this before clearing |
383 | sync_execution. Current target_terminal_ours() implementations | |
371d5dec | 384 | check for sync_execution before switching the terminal. */ |
32c1e744 | 385 | target_terminal_ours (); |
32c1e744 VP |
386 | sync_execution = 0; |
387 | } | |
6426a772 JM |
388 | } |
389 | ||
390 | /* Disable reads from stdin (the console) marking the command as | |
371d5dec | 391 | synchronous. */ |
6426a772 JM |
392 | |
393 | void | |
394 | async_disable_stdin (void) | |
395 | { | |
ab821bc6 | 396 | sync_execution = 1; |
6426a772 | 397 | } |
b5a0ac70 | 398 | \f |
6426a772 | 399 | |
371d5dec | 400 | /* Handles a gdb command. This function is called by |
b5a0ac70 | 401 | command_line_handler, which has processed one or more input lines |
371d5dec | 402 | into COMMAND. */ |
392a587b | 403 | /* NOTE: 1999-04-30 This is the asynchronous version of the command_loop |
b5a0ac70 | 404 | function. The command_loop function will be obsolete when we |
371d5dec | 405 | switch to use the event loop at every execution of gdb. */ |
392a587b | 406 | static void |
c2c6d25f | 407 | command_handler (char *command) |
b5a0ac70 | 408 | { |
b5a0ac70 | 409 | int stdin_is_tty = ISATTY (stdin); |
0f3bb72e | 410 | struct cleanup *stat_chain; |
b5a0ac70 | 411 | |
522002f9 | 412 | clear_quit_flag (); |
b5a0ac70 SS |
413 | if (instream == stdin && stdin_is_tty) |
414 | reinitialize_more_filter (); | |
b5a0ac70 | 415 | |
371d5dec MS |
416 | /* If readline returned a NULL command, it means that the connection |
417 | with the terminal is gone. This happens at the end of a | |
418 | testsuite run, after Expect has hung up but GDB is still alive. | |
419 | In such a case, we just quit gdb killing the inferior program | |
420 | too. */ | |
b5a0ac70 | 421 | if (command == 0) |
fa3fd85b AS |
422 | { |
423 | printf_unfiltered ("quit\n"); | |
424 | execute_command ("quit", stdin == instream); | |
425 | } | |
b5a0ac70 | 426 | |
0f3bb72e | 427 | stat_chain = make_command_stats_cleanup (1); |
b5a0ac70 SS |
428 | |
429 | execute_command (command, instream == stdin); | |
c5aa993b | 430 | |
347bddb7 PA |
431 | /* Do any commands attached to breakpoint we stopped at. */ |
432 | bpstat_do_actions (); | |
c5aa993b | 433 | |
0f3bb72e | 434 | do_cleanups (stat_chain); |
43ff13b4 JM |
435 | } |
436 | ||
371d5dec MS |
437 | /* Handle a complete line of input. This is called by the callback |
438 | mechanism within the readline library. Deal with incomplete | |
439 | commands as well, by saving the partial input in a global | |
440 | buffer. */ | |
b5a0ac70 | 441 | |
392a587b | 442 | /* NOTE: 1999-04-30 This is the asynchronous version of the |
371d5dec | 443 | command_line_input function; command_line_input will become |
b5a0ac70 | 444 | obsolete once we use the event loop as the default mechanism in |
371d5dec | 445 | GDB. */ |
b5a0ac70 | 446 | static void |
c2c6d25f | 447 | command_line_handler (char *rl) |
b5a0ac70 SS |
448 | { |
449 | static char *linebuffer = 0; | |
450 | static unsigned linelength = 0; | |
52f0bd74 | 451 | char *p; |
b5a0ac70 | 452 | char *p1; |
b5a0ac70 SS |
453 | char *nline; |
454 | char got_eof = 0; | |
455 | ||
b5a0ac70 SS |
456 | int repeat = (instream == stdin); |
457 | ||
458 | if (annotation_level > 1 && instream == stdin) | |
459 | { | |
a3f17187 | 460 | printf_unfiltered (("\n\032\032post-")); |
306d9ac5 | 461 | puts_unfiltered (async_annotation_suffix); |
a3f17187 | 462 | printf_unfiltered (("\n")); |
b5a0ac70 SS |
463 | } |
464 | ||
465 | if (linebuffer == 0) | |
466 | { | |
467 | linelength = 80; | |
468 | linebuffer = (char *) xmalloc (linelength); | |
469 | } | |
470 | ||
471 | p = linebuffer; | |
472 | ||
473 | if (more_to_come) | |
474 | { | |
475 | strcpy (linebuffer, readline_input_state.linebuffer); | |
476 | p = readline_input_state.linebuffer_ptr; | |
b8c9b27d | 477 | xfree (readline_input_state.linebuffer); |
b5a0ac70 | 478 | more_to_come = 0; |
b5a0ac70 SS |
479 | } |
480 | ||
481 | #ifdef STOP_SIGNAL | |
482 | if (job_control) | |
0f71a2f6 | 483 | signal (STOP_SIGNAL, handle_stop_sig); |
b5a0ac70 SS |
484 | #endif |
485 | ||
486 | /* Make sure that all output has been output. Some machines may let | |
371d5dec MS |
487 | you get away with leaving out some of the gdb_flush, but not |
488 | all. */ | |
b5a0ac70 SS |
489 | wrap_here (""); |
490 | gdb_flush (gdb_stdout); | |
491 | gdb_flush (gdb_stderr); | |
492 | ||
493 | if (source_file_name != NULL) | |
637537d0 | 494 | ++source_line_number; |
b5a0ac70 SS |
495 | |
496 | /* If we are in this case, then command_handler will call quit | |
371d5dec | 497 | and exit from gdb. */ |
b5a0ac70 SS |
498 | if (!rl || rl == (char *) EOF) |
499 | { | |
500 | got_eof = 1; | |
501 | command_handler (0); | |
371d5dec | 502 | return; /* Lint. */ |
b5a0ac70 SS |
503 | } |
504 | if (strlen (rl) + 1 + (p - linebuffer) > linelength) | |
505 | { | |
506 | linelength = strlen (rl) + 1 + (p - linebuffer); | |
507 | nline = (char *) xrealloc (linebuffer, linelength); | |
508 | p += nline - linebuffer; | |
509 | linebuffer = nline; | |
510 | } | |
511 | p1 = rl; | |
512 | /* Copy line. Don't copy null at end. (Leaves line alone | |
371d5dec | 513 | if this was just a newline). */ |
b5a0ac70 SS |
514 | while (*p1) |
515 | *p++ = *p1++; | |
516 | ||
b8c9b27d | 517 | xfree (rl); /* Allocated in readline. */ |
b5a0ac70 | 518 | |
4dd79c29 | 519 | if (p > linebuffer && *(p - 1) == '\\') |
b5a0ac70 | 520 | { |
20bb6bc8 | 521 | *p = '\0'; |
b5a0ac70 SS |
522 | p--; /* Put on top of '\'. */ |
523 | ||
1b36a34b | 524 | readline_input_state.linebuffer = xstrdup (linebuffer); |
d96429cd AS |
525 | readline_input_state.linebuffer_ptr = p; |
526 | ||
527 | /* We will not invoke a execute_command if there is more | |
371d5dec MS |
528 | input expected to complete the command. So, we need to |
529 | print an empty prompt here. */ | |
d96429cd | 530 | more_to_come = 1; |
ab821bc6 | 531 | display_gdb_prompt (""); |
d96429cd | 532 | return; |
b5a0ac70 SS |
533 | } |
534 | ||
535 | #ifdef STOP_SIGNAL | |
536 | if (job_control) | |
537 | signal (STOP_SIGNAL, SIG_DFL); | |
538 | #endif | |
539 | ||
540 | #define SERVER_COMMAND_LENGTH 7 | |
541 | server_command = | |
542 | (p - linebuffer > SERVER_COMMAND_LENGTH) | |
bf896cb0 | 543 | && strncmp (linebuffer, "server ", SERVER_COMMAND_LENGTH) == 0; |
b5a0ac70 SS |
544 | if (server_command) |
545 | { | |
546 | /* Note that we don't set `line'. Between this and the check in | |
547 | dont_repeat, this insures that repeating will still do the | |
548 | right thing. */ | |
549 | *p = '\0'; | |
550 | command_handler (linebuffer + SERVER_COMMAND_LENGTH); | |
551 | display_gdb_prompt (0); | |
552 | return; | |
553 | } | |
554 | ||
555 | /* Do history expansion if that is wished. */ | |
556 | if (history_expansion_p && instream == stdin | |
557 | && ISATTY (instream)) | |
558 | { | |
559 | char *history_value; | |
560 | int expanded; | |
561 | ||
562 | *p = '\0'; /* Insert null now. */ | |
563 | expanded = history_expand (linebuffer, &history_value); | |
564 | if (expanded) | |
565 | { | |
566 | /* Print the changes. */ | |
567 | printf_unfiltered ("%s\n", history_value); | |
568 | ||
569 | /* If there was an error, call this function again. */ | |
570 | if (expanded < 0) | |
571 | { | |
b8c9b27d | 572 | xfree (history_value); |
b5a0ac70 SS |
573 | return; |
574 | } | |
575 | if (strlen (history_value) > linelength) | |
576 | { | |
577 | linelength = strlen (history_value) + 1; | |
578 | linebuffer = (char *) xrealloc (linebuffer, linelength); | |
579 | } | |
580 | strcpy (linebuffer, history_value); | |
581 | p = linebuffer + strlen (linebuffer); | |
b5a0ac70 | 582 | } |
f5b73fbb | 583 | xfree (history_value); |
b5a0ac70 SS |
584 | } |
585 | ||
371d5dec MS |
586 | /* If we just got an empty line, and that is supposed to repeat the |
587 | previous command, return the value in the global buffer. */ | |
b5a0ac70 SS |
588 | if (repeat && p == linebuffer && *p != '\\') |
589 | { | |
dc7eb48e | 590 | command_handler (saved_command_line); |
b5a0ac70 SS |
591 | display_gdb_prompt (0); |
592 | return; | |
593 | } | |
594 | ||
595 | for (p1 = linebuffer; *p1 == ' ' || *p1 == '\t'; p1++); | |
596 | if (repeat && !*p1) | |
597 | { | |
dc7eb48e | 598 | command_handler (saved_command_line); |
b5a0ac70 SS |
599 | display_gdb_prompt (0); |
600 | return; | |
601 | } | |
602 | ||
603 | *p = 0; | |
604 | ||
605 | /* Add line to history if appropriate. */ | |
606 | if (instream == stdin | |
607 | && ISATTY (stdin) && *linebuffer) | |
608 | add_history (linebuffer); | |
609 | ||
610 | /* Note: lines consisting solely of comments are added to the command | |
611 | history. This is useful when you type a command, and then | |
612 | realize you don't want to execute it quite yet. You can comment | |
613 | out the command and then later fetch it from the value history | |
614 | and remove the '#'. The kill ring is probably better, but some | |
615 | people are in the habit of commenting things out. */ | |
616 | if (*p1 == '#') | |
371d5dec | 617 | *p1 = '\0'; /* Found a comment. */ |
b5a0ac70 SS |
618 | |
619 | /* Save into global buffer if appropriate. */ | |
620 | if (repeat) | |
621 | { | |
dc7eb48e | 622 | if (linelength > saved_command_line_size) |
b5a0ac70 | 623 | { |
dc7eb48e PA |
624 | saved_command_line = xrealloc (saved_command_line, linelength); |
625 | saved_command_line_size = linelength; | |
b5a0ac70 | 626 | } |
dc7eb48e | 627 | strcpy (saved_command_line, linebuffer); |
b5a0ac70 SS |
628 | if (!more_to_come) |
629 | { | |
dc7eb48e | 630 | command_handler (saved_command_line); |
b5a0ac70 SS |
631 | display_gdb_prompt (0); |
632 | } | |
633 | return; | |
634 | } | |
635 | ||
636 | command_handler (linebuffer); | |
637 | display_gdb_prompt (0); | |
638 | return; | |
639 | } | |
640 | ||
641 | /* Does reading of input from terminal w/o the editing features | |
371d5dec | 642 | provided by the readline library. */ |
b5a0ac70 | 643 | |
371d5dec | 644 | /* NOTE: 1999-04-30 Asynchronous version of gdb_readline; gdb_readline |
b5a0ac70 | 645 | will become obsolete when the event loop is made the default |
371d5dec | 646 | execution for gdb. */ |
085dd6e6 | 647 | void |
c2c6d25f | 648 | gdb_readline2 (gdb_client_data client_data) |
b5a0ac70 SS |
649 | { |
650 | int c; | |
651 | char *result; | |
652 | int input_index = 0; | |
653 | int result_size = 80; | |
7be570e7 JM |
654 | static int done_once = 0; |
655 | ||
656 | /* Unbuffer the input stream, so that, later on, the calls to fgetc | |
371d5dec | 657 | fetch only one char at the time from the stream. The fgetc's will |
7be570e7 | 658 | get up to the first newline, but there may be more chars in the |
371d5dec | 659 | stream after '\n'. If we buffer the input and fgetc drains the |
7be570e7 | 660 | stream, getting stuff beyond the newline as well, a select, done |
371d5dec | 661 | afterwards will not trigger. */ |
7be570e7 JM |
662 | if (!done_once && !ISATTY (instream)) |
663 | { | |
664 | setbuf (instream, NULL); | |
665 | done_once = 1; | |
666 | } | |
b5a0ac70 SS |
667 | |
668 | result = (char *) xmalloc (result_size); | |
669 | ||
670 | /* We still need the while loop here, even though it would seem | |
671 | obvious to invoke gdb_readline2 at every character entered. If | |
672 | not using the readline library, the terminal is in cooked mode, | |
371d5dec MS |
673 | which sends the characters all at once. Poll will notice that the |
674 | input fd has changed state only after enter is pressed. At this | |
675 | point we still need to fetch all the chars entered. */ | |
b5a0ac70 SS |
676 | |
677 | while (1) | |
678 | { | |
679 | /* Read from stdin if we are executing a user defined command. | |
680 | This is the right thing for prompt_for_continue, at least. */ | |
681 | c = fgetc (instream ? instream : stdin); | |
682 | ||
683 | if (c == EOF) | |
684 | { | |
685 | if (input_index > 0) | |
371d5dec MS |
686 | /* The last line does not end with a newline. Return it, |
687 | and if we are called again fgetc will still return EOF | |
688 | and we'll return NULL then. */ | |
b5a0ac70 | 689 | break; |
b8c9b27d | 690 | xfree (result); |
0f71a2f6 | 691 | (*input_handler) (0); |
13ce7133 | 692 | return; |
b5a0ac70 SS |
693 | } |
694 | ||
695 | if (c == '\n') | |
b5a0ac70 SS |
696 | { |
697 | if (input_index > 0 && result[input_index - 1] == '\r') | |
698 | input_index--; | |
699 | break; | |
700 | } | |
b5a0ac70 SS |
701 | |
702 | result[input_index++] = c; | |
703 | while (input_index >= result_size) | |
704 | { | |
705 | result_size *= 2; | |
706 | result = (char *) xrealloc (result, result_size); | |
707 | } | |
708 | } | |
709 | ||
710 | result[input_index++] = '\0'; | |
0f71a2f6 | 711 | (*input_handler) (result); |
b5a0ac70 SS |
712 | } |
713 | \f | |
714 | ||
715 | /* Initialization of signal handlers and tokens. There is a function | |
371d5dec | 716 | handle_sig* for each of the signals GDB cares about. Specifically: |
b5a0ac70 SS |
717 | SIGINT, SIGFPE, SIGQUIT, SIGTSTP, SIGHUP, SIGWINCH. These |
718 | functions are the actual signal handlers associated to the signals | |
719 | via calls to signal(). The only job for these functions is to | |
720 | enqueue the appropriate event/procedure with the event loop. Such | |
371d5dec | 721 | procedures are the old signal handlers. The event loop will take |
b5a0ac70 | 722 | care of invoking the queued procedures to perform the usual tasks |
371d5dec | 723 | associated with the reception of the signal. */ |
392a587b | 724 | /* NOTE: 1999-04-30 This is the asynchronous version of init_signals. |
b5a0ac70 | 725 | init_signals will become obsolete as we move to have to event loop |
371d5dec | 726 | as the default for gdb. */ |
b5a0ac70 | 727 | void |
c2c6d25f | 728 | async_init_signals (void) |
c5aa993b | 729 | { |
b5a0ac70 SS |
730 | signal (SIGINT, handle_sigint); |
731 | sigint_token = | |
0f71a2f6 | 732 | create_async_signal_handler (async_request_quit, NULL); |
a7266fef | 733 | signal (SIGTERM, handle_sigterm); |
b5a0ac70 SS |
734 | |
735 | /* If SIGTRAP was set to SIG_IGN, then the SIG_IGN will get passed | |
736 | to the inferior and breakpoints will be ignored. */ | |
737 | #ifdef SIGTRAP | |
738 | signal (SIGTRAP, SIG_DFL); | |
739 | #endif | |
740 | ||
6d318c73 | 741 | #ifdef SIGQUIT |
b5a0ac70 SS |
742 | /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get |
743 | passed to the inferior, which we don't want. It would be | |
744 | possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but | |
745 | on BSD4.3 systems using vfork, that can affect the | |
746 | GDB process as well as the inferior (the signal handling tables | |
747 | might be in memory, shared between the two). Since we establish | |
748 | a handler for SIGQUIT, when we call exec it will set the signal | |
749 | to SIG_DFL for us. */ | |
750 | signal (SIGQUIT, handle_sigquit); | |
751 | sigquit_token = | |
0f71a2f6 | 752 | create_async_signal_handler (async_do_nothing, NULL); |
6d318c73 | 753 | #endif |
b5a0ac70 SS |
754 | #ifdef SIGHUP |
755 | if (signal (SIGHUP, handle_sighup) != SIG_IGN) | |
756 | sighup_token = | |
0f71a2f6 | 757 | create_async_signal_handler (async_disconnect, NULL); |
b5a0ac70 SS |
758 | else |
759 | sighup_token = | |
0f71a2f6 | 760 | create_async_signal_handler (async_do_nothing, NULL); |
b5a0ac70 SS |
761 | #endif |
762 | signal (SIGFPE, handle_sigfpe); | |
763 | sigfpe_token = | |
0f71a2f6 | 764 | create_async_signal_handler (async_float_handler, NULL); |
b5a0ac70 | 765 | |
0f71a2f6 JM |
766 | #ifdef STOP_SIGNAL |
767 | sigtstp_token = | |
768 | create_async_signal_handler (async_stop_sig, NULL); | |
769 | #endif | |
770 | ||
771 | } | |
772 | ||
371d5dec MS |
773 | /* Tell the event loop what to do if SIGINT is received. |
774 | See event-signal.c. */ | |
c5aa993b | 775 | void |
c2c6d25f | 776 | handle_sigint (int sig) |
b5a0ac70 SS |
777 | { |
778 | signal (sig, handle_sigint); | |
779 | ||
5f960e00 FF |
780 | /* We could be running in a loop reading in symfiles or something so |
781 | it may be quite a while before we get back to the event loop. So | |
371d5dec | 782 | set quit_flag to 1 here. Then if QUIT is called before we get to |
5f960e00 FF |
783 | the event loop, we will unwind as expected. */ |
784 | ||
522002f9 | 785 | set_quit_flag (); |
5f960e00 | 786 | |
b5a0ac70 | 787 | /* If immediate_quit is set, we go ahead and process the SIGINT right |
371d5dec | 788 | away, even if we usually would defer this to the event loop. The |
b5a0ac70 | 789 | assumption here is that it is safe to process ^C immediately if |
371d5dec | 790 | immediate_quit is set. If we didn't, SIGINT would be really |
b5a0ac70 SS |
791 | processed only the next time through the event loop. To get to |
792 | that point, though, the command that we want to interrupt needs to | |
b803fb0f | 793 | finish first, which is unacceptable. If immediate quit is not set, |
371d5dec | 794 | we process SIGINT the next time through the loop, which is fine. */ |
b803fb0f | 795 | gdb_call_async_signal_handler (sigint_token, immediate_quit); |
b5a0ac70 SS |
796 | } |
797 | ||
a7266fef AS |
798 | /* Quit GDB if SIGTERM is received. |
799 | GDB would quit anyway, but this way it will clean up properly. */ | |
800 | void | |
801 | handle_sigterm (int sig) | |
802 | { | |
803 | signal (sig, handle_sigterm); | |
804 | quit_force ((char *) 0, stdin == instream); | |
805 | } | |
806 | ||
371d5dec | 807 | /* Do the quit. All the checks have been done by the caller. */ |
c5aa993b | 808 | void |
c2c6d25f | 809 | async_request_quit (gdb_client_data arg) |
b5a0ac70 | 810 | { |
5f960e00 | 811 | /* If the quit_flag has gotten reset back to 0 by the time we get |
4ac94eda FF |
812 | back here, that means that an exception was thrown to unwind the |
813 | current command before we got back to the event loop. So there | |
522002f9 | 814 | is no reason to call quit again here. */ |
5f960e00 | 815 | |
522002f9 | 816 | if (check_quit_flag ()) |
4ac94eda | 817 | quit (); |
b5a0ac70 SS |
818 | } |
819 | ||
6d318c73 | 820 | #ifdef SIGQUIT |
371d5dec MS |
821 | /* Tell the event loop what to do if SIGQUIT is received. |
822 | See event-signal.c. */ | |
c5aa993b | 823 | static void |
c2c6d25f | 824 | handle_sigquit (int sig) |
b5a0ac70 | 825 | { |
f6fbab7d | 826 | mark_async_signal_handler (sigquit_token); |
b5a0ac70 SS |
827 | signal (sig, handle_sigquit); |
828 | } | |
6d318c73 | 829 | #endif |
b5a0ac70 | 830 | |
0f0b8dcd DJ |
831 | #if defined (SIGQUIT) || defined (SIGHUP) |
832 | /* Called by the event loop in response to a SIGQUIT or an | |
833 | ignored SIGHUP. */ | |
c5aa993b | 834 | static void |
c2c6d25f | 835 | async_do_nothing (gdb_client_data arg) |
b5a0ac70 | 836 | { |
371d5dec | 837 | /* Empty function body. */ |
b5a0ac70 | 838 | } |
0f0b8dcd | 839 | #endif |
b5a0ac70 SS |
840 | |
841 | #ifdef SIGHUP | |
371d5dec MS |
842 | /* Tell the event loop what to do if SIGHUP is received. |
843 | See event-signal.c. */ | |
c5aa993b | 844 | static void |
fba45db2 | 845 | handle_sighup (int sig) |
b5a0ac70 | 846 | { |
f6fbab7d | 847 | mark_async_signal_handler (sighup_token); |
b5a0ac70 SS |
848 | signal (sig, handle_sighup); |
849 | } | |
850 | ||
371d5dec | 851 | /* Called by the event loop to process a SIGHUP. */ |
c5aa993b | 852 | static void |
c2c6d25f | 853 | async_disconnect (gdb_client_data arg) |
b5a0ac70 | 854 | { |
b2cd6b29 JM |
855 | volatile struct gdb_exception exception; |
856 | ||
857 | TRY_CATCH (exception, RETURN_MASK_ALL) | |
858 | { | |
859 | quit_cover (); | |
860 | } | |
861 | ||
862 | if (exception.reason < 0) | |
863 | { | |
864 | fputs_filtered ("Could not kill the program being debugged", | |
865 | gdb_stderr); | |
866 | exception_print (gdb_stderr, exception); | |
867 | } | |
868 | ||
869 | TRY_CATCH (exception, RETURN_MASK_ALL) | |
870 | { | |
871 | pop_all_targets (1); | |
872 | } | |
873 | ||
371d5dec | 874 | signal (SIGHUP, SIG_DFL); /*FIXME: ??????????? */ |
ec4dfccf | 875 | raise (SIGHUP); |
b5a0ac70 SS |
876 | } |
877 | #endif | |
878 | ||
0f71a2f6 | 879 | #ifdef STOP_SIGNAL |
c5aa993b | 880 | void |
c2c6d25f | 881 | handle_stop_sig (int sig) |
0f71a2f6 | 882 | { |
f6fbab7d | 883 | mark_async_signal_handler (sigtstp_token); |
c5aa993b | 884 | signal (sig, handle_stop_sig); |
0f71a2f6 JM |
885 | } |
886 | ||
887 | static void | |
c2c6d25f | 888 | async_stop_sig (gdb_client_data arg) |
0f71a2f6 | 889 | { |
ab821bc6 | 890 | char *prompt = get_prompt (); |
d7f9d729 | 891 | |
0f71a2f6 JM |
892 | #if STOP_SIGNAL == SIGTSTP |
893 | signal (SIGTSTP, SIG_DFL); | |
2acceee2 JM |
894 | #if HAVE_SIGPROCMASK |
895 | { | |
896 | sigset_t zero; | |
46711df8 | 897 | |
2acceee2 JM |
898 | sigemptyset (&zero); |
899 | sigprocmask (SIG_SETMASK, &zero, 0); | |
900 | } | |
46711df8 | 901 | #elif HAVE_SIGSETMASK |
0f71a2f6 | 902 | sigsetmask (0); |
2acceee2 | 903 | #endif |
ec4dfccf | 904 | raise (SIGTSTP); |
0f71a2f6 JM |
905 | signal (SIGTSTP, handle_stop_sig); |
906 | #else | |
907 | signal (STOP_SIGNAL, handle_stop_sig); | |
908 | #endif | |
909 | printf_unfiltered ("%s", prompt); | |
910 | gdb_flush (gdb_stdout); | |
911 | ||
371d5dec MS |
912 | /* Forget about any previous command -- null line now will do |
913 | nothing. */ | |
0f71a2f6 JM |
914 | dont_repeat (); |
915 | } | |
916 | #endif /* STOP_SIGNAL */ | |
917 | ||
371d5dec MS |
918 | /* Tell the event loop what to do if SIGFPE is received. |
919 | See event-signal.c. */ | |
c5aa993b | 920 | static void |
c2c6d25f | 921 | handle_sigfpe (int sig) |
b5a0ac70 | 922 | { |
f6fbab7d | 923 | mark_async_signal_handler (sigfpe_token); |
b5a0ac70 SS |
924 | signal (sig, handle_sigfpe); |
925 | } | |
926 | ||
371d5dec | 927 | /* Event loop will call this functin to process a SIGFPE. */ |
c5aa993b | 928 | static void |
c2c6d25f | 929 | async_float_handler (gdb_client_data arg) |
b5a0ac70 | 930 | { |
371d5dec MS |
931 | /* This message is based on ANSI C, section 4.7. Note that integer |
932 | divide by zero causes this, so "float" is a misnomer. */ | |
8a3fe4f8 | 933 | error (_("Erroneous arithmetic operation.")); |
b5a0ac70 | 934 | } |
b5a0ac70 SS |
935 | \f |
936 | ||
937 | /* Called by do_setshow_command. */ | |
b5a0ac70 | 938 | void |
371d5dec MS |
939 | set_async_editing_command (char *args, int from_tty, |
940 | struct cmd_list_element *c) | |
b5a0ac70 SS |
941 | { |
942 | change_line_handler (); | |
943 | } | |
944 | ||
0f71a2f6 JM |
945 | /* Set things up for readline to be invoked via the alternate |
946 | interface, i.e. via a callback function (rl_callback_read_char), | |
371d5dec | 947 | and hook up instream to the event loop. */ |
0f71a2f6 | 948 | void |
cee6ddeb | 949 | gdb_setup_readline (void) |
0f71a2f6 | 950 | { |
362646f5 AC |
951 | /* This function is a noop for the sync case. The assumption is |
952 | that the sync setup is ALL done in gdb_init, and we would only | |
953 | mess it up here. The sync stuff should really go away over | |
954 | time. */ | |
1a088d06 AS |
955 | if (!batch_silent) |
956 | gdb_stdout = stdio_fileopen (stdout); | |
362646f5 AC |
957 | gdb_stderr = stdio_fileopen (stderr); |
958 | gdb_stdlog = gdb_stderr; /* for moment */ | |
959 | gdb_stdtarg = gdb_stderr; /* for moment */ | |
8d4d924b | 960 | gdb_stdtargerr = gdb_stderr; /* for moment */ |
362646f5 AC |
961 | |
962 | /* If the input stream is connected to a terminal, turn on | |
963 | editing. */ | |
964 | if (ISATTY (instream)) | |
9e0b60a8 | 965 | { |
371d5dec | 966 | /* Tell gdb that we will be using the readline library. This |
362646f5 AC |
967 | could be overwritten by a command in .gdbinit like 'set |
968 | editing on' or 'off'. */ | |
969 | async_command_editing_p = 1; | |
c5201926 | 970 | |
362646f5 AC |
971 | /* When a character is detected on instream by select or poll, |
972 | readline will be invoked via this callback function. */ | |
973 | call_readline = rl_callback_read_char_wrapper; | |
9e0b60a8 | 974 | } |
362646f5 AC |
975 | else |
976 | { | |
977 | async_command_editing_p = 0; | |
978 | call_readline = gdb_readline2; | |
979 | } | |
980 | ||
981 | /* When readline has read an end-of-line character, it passes the | |
371d5dec | 982 | complete line to gdb for processing; command_line_handler is the |
362646f5 AC |
983 | function that does this. */ |
984 | input_handler = command_line_handler; | |
985 | ||
371d5dec | 986 | /* Tell readline to use the same input stream that gdb uses. */ |
362646f5 AC |
987 | rl_instream = instream; |
988 | ||
989 | /* Get a file descriptor for the input stream, so that we can | |
990 | register it with the event loop. */ | |
991 | input_fd = fileno (instream); | |
992 | ||
993 | /* Now we need to create the event sources for the input file | |
994 | descriptor. */ | |
995 | /* At this point in time, this is the only event source that we | |
371d5dec | 996 | register with the even loop. Another source is going to be the |
362646f5 AC |
997 | target program (inferior), but that must be registered only when |
998 | it actually exists (I.e. after we say 'run' or after we connect | |
999 | to a remote target. */ | |
1000 | add_file_handler (input_fd, stdin_event_handler, 0); | |
0f71a2f6 | 1001 | } |
cee6ddeb | 1002 | |
7d5b6fdd EZ |
1003 | /* Disable command input through the standard CLI channels. Used in |
1004 | the suspend proc for interpreters that use the standard gdb readline | |
1005 | interface, like the cli & the mi. */ | |
1006 | void | |
1007 | gdb_disable_readline (void) | |
1008 | { | |
362646f5 AC |
1009 | /* FIXME - It is too heavyweight to delete and remake these every |
1010 | time you run an interpreter that needs readline. It is probably | |
1011 | better to have the interpreters cache these, which in turn means | |
1012 | that this needs to be moved into interpreter specific code. */ | |
7d5b6fdd EZ |
1013 | |
1014 | #if 0 | |
362646f5 AC |
1015 | ui_file_delete (gdb_stdout); |
1016 | ui_file_delete (gdb_stderr); | |
1017 | gdb_stdlog = NULL; | |
1018 | gdb_stdtarg = NULL; | |
8d4d924b | 1019 | gdb_stdtargerr = NULL; |
7d5b6fdd EZ |
1020 | #endif |
1021 | ||
362646f5 AC |
1022 | rl_callback_handler_remove (); |
1023 | delete_file_handler (input_fd); | |
7d5b6fdd | 1024 | } |