Commit | Line | Data |
---|---|---|
b5a0ac70 | 1 | /* Top level stuff for GDB, the GNU debugger. |
637537d0 | 2 | |
28e7fd62 | 3 | Copyright (C) 1999-2013 Free Software Foundation, Inc. |
637537d0 | 4 | |
b5a0ac70 SS |
5 | Written by Elena Zannoni <ezannoni@cygnus.com> of Cygnus Solutions. |
6 | ||
7 | This file is part of GDB. | |
8 | ||
9 | This program is free software; you can redistribute it and/or modify | |
10 | it under the terms of the GNU General Public License as published by | |
a9762ec7 | 11 | the Free Software Foundation; either version 3 of the License, or |
b5a0ac70 SS |
12 | (at your option) any later version. |
13 | ||
14 | This program is distributed in the hope that it will be useful, | |
15 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 | GNU General Public License for more details. | |
18 | ||
19 | You should have received a copy of the GNU General Public License | |
371d5dec | 20 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
b5a0ac70 SS |
21 | |
22 | #include "defs.h" | |
0f71a2f6 | 23 | #include "top.h" |
b5a0ac70 | 24 | #include "inferior.h" |
e514a9d6 | 25 | #include "target.h" |
c5aa993b | 26 | #include "terminal.h" /* for job_control */ |
9e0b60a8 | 27 | #include "event-loop.h" |
c2c6d25f | 28 | #include "event-top.h" |
4389a95a | 29 | #include "interps.h" |
042be3a9 | 30 | #include <signal.h> |
60250e8b | 31 | #include "exceptions.h" |
16026cd7 | 32 | #include "cli/cli-script.h" /* for reset_command_nest_depth */ |
d01a8610 | 33 | #include "main.h" |
8ea051c5 | 34 | #include "gdbthread.h" |
d17b6f81 | 35 | #include "observer.h" |
be34f849 | 36 | #include "continuations.h" |
371d5dec | 37 | #include "gdbcmd.h" /* for dont_repeat() */ |
bd00c694 | 38 | #include "annotate.h" |
bd712aed | 39 | #include "maint.h" |
104c1213 | 40 | |
371d5dec | 41 | /* readline include files. */ |
dbda9972 AC |
42 | #include "readline/readline.h" |
43 | #include "readline/history.h" | |
b5a0ac70 SS |
44 | |
45 | /* readline defines this. */ | |
46 | #undef savestring | |
47 | ||
c2c6d25f JM |
48 | static void rl_callback_read_char_wrapper (gdb_client_data client_data); |
49 | static void command_line_handler (char *rl); | |
c2c6d25f | 50 | static void change_line_handler (void); |
c2c6d25f | 51 | static void command_handler (char *command); |
ab821bc6 | 52 | static char *top_level_prompt (void); |
b5a0ac70 | 53 | |
371d5dec | 54 | /* Signal handlers. */ |
6d318c73 | 55 | #ifdef SIGQUIT |
c2c6d25f | 56 | static void handle_sigquit (int sig); |
6d318c73 | 57 | #endif |
0f0b8dcd | 58 | #ifdef SIGHUP |
c2c6d25f | 59 | static void handle_sighup (int sig); |
0f0b8dcd | 60 | #endif |
c2c6d25f | 61 | static void handle_sigfpe (int sig); |
b5a0ac70 SS |
62 | |
63 | /* Functions to be invoked by the event loop in response to | |
371d5dec | 64 | signals. */ |
0f0b8dcd | 65 | #if defined (SIGQUIT) || defined (SIGHUP) |
c2c6d25f | 66 | static void async_do_nothing (gdb_client_data); |
0f0b8dcd DJ |
67 | #endif |
68 | #ifdef SIGHUP | |
c2c6d25f | 69 | static void async_disconnect (gdb_client_data); |
0f0b8dcd | 70 | #endif |
c2c6d25f | 71 | static void async_float_handler (gdb_client_data); |
0f0b8dcd | 72 | #ifdef STOP_SIGNAL |
c2c6d25f | 73 | static void async_stop_sig (gdb_client_data); |
0f0b8dcd | 74 | #endif |
b5a0ac70 | 75 | |
b5a0ac70 | 76 | /* Readline offers an alternate interface, via callback |
371d5dec | 77 | functions. These are all included in the file callback.c in the |
b5a0ac70 SS |
78 | readline distribution. This file provides (mainly) a function, which |
79 | the event loop uses as callback (i.e. event handler) whenever an event | |
80 | is detected on the standard input file descriptor. | |
81 | readline_callback_read_char is called (by the GDB event loop) whenever | |
371d5dec | 82 | there is a new character ready on the input stream. This function |
b5a0ac70 SS |
83 | incrementally builds a buffer internal to readline where it |
84 | accumulates the line read up to the point of invocation. In the | |
85 | special case in which the character read is newline, the function | |
86 | invokes a GDB supplied callback routine, which does the processing of | |
87 | a full command line. This latter routine is the asynchronous analog | |
371d5dec | 88 | of the old command_line_input in gdb. Instead of invoking (and waiting |
b5a0ac70 SS |
89 | for) readline to read the command line and pass it back to |
90 | command_loop for processing, the new command_line_handler function has | |
91 | the command line already available as its parameter. INPUT_HANDLER is | |
92 | to be set to the function that readline will invoke when a complete | |
93 | line of input is ready. CALL_READLINE is to be set to the function | |
371d5dec | 94 | that readline offers as callback to the event_loop. */ |
b5a0ac70 | 95 | |
c2c6d25f JM |
96 | void (*input_handler) (char *); |
97 | void (*call_readline) (gdb_client_data); | |
b5a0ac70 | 98 | |
371d5dec | 99 | /* Important variables for the event loop. */ |
b5a0ac70 SS |
100 | |
101 | /* This is used to determine if GDB is using the readline library or | |
371d5dec | 102 | its own simplified form of readline. It is used by the asynchronous |
0f71a2f6 | 103 | form of the set editing command. |
392a587b | 104 | ezannoni: as of 1999-04-29 I expect that this |
b5a0ac70 | 105 | variable will not be used after gdb is changed to use the event |
371d5dec | 106 | loop as default engine, and event-top.c is merged into top.c. */ |
b5a0ac70 SS |
107 | int async_command_editing_p; |
108 | ||
b5a0ac70 | 109 | /* This is the annotation suffix that will be used when the |
371d5dec | 110 | annotation_level is 2. */ |
b5a0ac70 SS |
111 | char *async_annotation_suffix; |
112 | ||
104c1213 | 113 | /* This is used to display the notification of the completion of an |
371d5dec | 114 | asynchronous execution command. */ |
104c1213 JM |
115 | int exec_done_display_p = 0; |
116 | ||
b5a0ac70 | 117 | /* This is the file descriptor for the input stream that GDB uses to |
371d5dec | 118 | read commands from. */ |
b5a0ac70 SS |
119 | int input_fd; |
120 | ||
371d5dec | 121 | /* Signal handling variables. */ |
b5a0ac70 | 122 | /* Each of these is a pointer to a function that the event loop will |
371d5dec | 123 | invoke if the corresponding signal has received. The real signal |
b5a0ac70 | 124 | handlers mark these functions as ready to be executed and the event |
371d5dec MS |
125 | loop, in a later iteration, calls them. See the function |
126 | invoke_async_signal_handler. */ | |
05fa9251 | 127 | static struct async_signal_handler *sigint_token; |
b5a0ac70 | 128 | #ifdef SIGHUP |
05fa9251 | 129 | static struct async_signal_handler *sighup_token; |
b5a0ac70 | 130 | #endif |
6d318c73 | 131 | #ifdef SIGQUIT |
05fa9251 | 132 | static struct async_signal_handler *sigquit_token; |
6d318c73 | 133 | #endif |
05fa9251 | 134 | static struct async_signal_handler *sigfpe_token; |
0f71a2f6 | 135 | #ifdef STOP_SIGNAL |
05fa9251 | 136 | static struct async_signal_handler *sigtstp_token; |
0f71a2f6 JM |
137 | #endif |
138 | ||
b5a0ac70 | 139 | /* Structure to save a partially entered command. This is used when |
371d5dec | 140 | the user types '\' at the end of a command line. This is necessary |
b5a0ac70 SS |
141 | because each line of input is handled by a different call to |
142 | command_line_handler, and normally there is no state retained | |
371d5dec | 143 | between different calls. */ |
ab821bc6 | 144 | static int more_to_come = 0; |
b5a0ac70 SS |
145 | |
146 | struct readline_input_state | |
147 | { | |
148 | char *linebuffer; | |
149 | char *linebuffer_ptr; | |
150 | } | |
151 | readline_input_state; | |
467d8519 TT |
152 | |
153 | /* This hook is called by rl_callback_read_char_wrapper after each | |
154 | character is processed. */ | |
b08ee6a2 | 155 | void (*after_char_processing_hook) (void); |
b5a0ac70 SS |
156 | \f |
157 | ||
371d5dec MS |
158 | /* Wrapper function for calling into the readline library. The event |
159 | loop expects the callback function to have a paramter, while | |
160 | readline expects none. */ | |
c2c6d25f JM |
161 | static void |
162 | rl_callback_read_char_wrapper (gdb_client_data client_data) | |
163 | { | |
164 | rl_callback_read_char (); | |
467d8519 TT |
165 | if (after_char_processing_hook) |
166 | (*after_char_processing_hook) (); | |
c2c6d25f JM |
167 | } |
168 | ||
b5a0ac70 | 169 | /* Initialize all the necessary variables, start the event loop, |
371d5dec | 170 | register readline, and stdin, start the loop. */ |
b5a0ac70 | 171 | void |
c2c6d25f | 172 | cli_command_loop (void) |
b5a0ac70 | 173 | { |
7d8e6458 | 174 | display_gdb_prompt (0); |
b5a0ac70 | 175 | |
371d5dec | 176 | /* Now it's time to start the event loop. */ |
085dd6e6 | 177 | start_event_loop (); |
b5a0ac70 SS |
178 | } |
179 | ||
180 | /* Change the function to be invoked every time there is a character | |
371d5dec | 181 | ready on stdin. This is used when the user sets the editing off, |
b5a0ac70 | 182 | therefore bypassing readline, and letting gdb handle the input |
371d5dec | 183 | itself, via gdb_readline2. Also it is used in the opposite case in |
b5a0ac70 | 184 | which the user sets editing on again, by restoring readline |
371d5dec | 185 | handling of the input. */ |
392a587b | 186 | static void |
c2c6d25f | 187 | change_line_handler (void) |
b5a0ac70 | 188 | { |
371d5dec MS |
189 | /* NOTE: this operates on input_fd, not instream. If we are reading |
190 | commands from a file, instream will point to the file. However in | |
c2c6d25f | 191 | async mode, we always read commands from a file with editing |
371d5dec MS |
192 | off. This means that the 'set editing on/off' will have effect |
193 | only on the interactive session. */ | |
c2c6d25f | 194 | |
b5a0ac70 SS |
195 | if (async_command_editing_p) |
196 | { | |
371d5dec | 197 | /* Turn on editing by using readline. */ |
c2c6d25f | 198 | call_readline = rl_callback_read_char_wrapper; |
0f71a2f6 | 199 | input_handler = command_line_handler; |
b5a0ac70 SS |
200 | } |
201 | else | |
202 | { | |
371d5dec | 203 | /* Turn off editing by using gdb_readline2. */ |
b5a0ac70 SS |
204 | rl_callback_handler_remove (); |
205 | call_readline = gdb_readline2; | |
0f71a2f6 JM |
206 | |
207 | /* Set up the command handler as well, in case we are called as | |
371d5dec | 208 | first thing from .gdbinit. */ |
0f71a2f6 | 209 | input_handler = command_line_handler; |
b5a0ac70 | 210 | } |
b5a0ac70 SS |
211 | } |
212 | ||
ab821bc6 PA |
213 | /* Displays the prompt. If the argument NEW_PROMPT is NULL, the |
214 | prompt that is displayed is the current top level prompt. | |
215 | Otherwise, it displays whatever NEW_PROMPT is as a local/secondary | |
216 | prompt. | |
217 | ||
218 | This is used after each gdb command has completed, and in the | |
219 | following cases: | |
220 | ||
371d5dec | 221 | 1. When the user enters a command line which is ended by '\' |
ab821bc6 PA |
222 | indicating that the command will continue on the next line. In |
223 | that case the prompt that is displayed is the empty string. | |
224 | ||
0f71a2f6 | 225 | 2. When the user is entering 'commands' for a breakpoint, or |
371d5dec | 226 | actions for a tracepoint. In this case the prompt will be '>' |
ab821bc6 PA |
227 | |
228 | 3. On prompting for pagination. */ | |
229 | ||
b5a0ac70 | 230 | void |
c2c6d25f | 231 | display_gdb_prompt (char *new_prompt) |
b5a0ac70 | 232 | { |
d17b6f81 | 233 | char *actual_gdb_prompt = NULL; |
ab821bc6 | 234 | struct cleanup *old_chain; |
b5a0ac70 | 235 | |
bd00c694 PA |
236 | annotate_display_prompt (); |
237 | ||
16026cd7 AS |
238 | /* Reset the nesting depth used when trace-commands is set. */ |
239 | reset_command_nest_depth (); | |
240 | ||
4389a95a AC |
241 | /* Each interpreter has its own rules on displaying the command |
242 | prompt. */ | |
243 | if (!current_interp_display_prompt_p ()) | |
fb40c209 | 244 | return; |
fb40c209 | 245 | |
ab821bc6 | 246 | old_chain = make_cleanup (free_current_contents, &actual_gdb_prompt); |
d17b6f81 | 247 | |
ab821bc6 PA |
248 | /* Do not call the python hook on an explicit prompt change as |
249 | passed to this function, as this forms a secondary/local prompt, | |
250 | IE, displayed but not set. */ | |
251 | if (! new_prompt) | |
adf40b2e | 252 | { |
ab821bc6 | 253 | if (sync_execution) |
d17b6f81 | 254 | { |
ab821bc6 PA |
255 | /* This is to trick readline into not trying to display the |
256 | prompt. Even though we display the prompt using this | |
257 | function, readline still tries to do its own display if | |
258 | we don't call rl_callback_handler_install and | |
259 | rl_callback_handler_remove (which readline detects | |
260 | because a global variable is not set). If readline did | |
261 | that, it could mess up gdb signal handlers for SIGINT. | |
262 | Readline assumes that between calls to rl_set_signals and | |
263 | rl_clear_signals gdb doesn't do anything with the signal | |
264 | handlers. Well, that's not the case, because when the | |
265 | target executes we change the SIGINT signal handler. If | |
266 | we allowed readline to display the prompt, the signal | |
267 | handler change would happen exactly between the calls to | |
268 | the above two functions. Calling | |
269 | rl_callback_handler_remove(), does the job. */ | |
270 | ||
271 | rl_callback_handler_remove (); | |
272 | return; | |
d17b6f81 PM |
273 | } |
274 | else | |
ab821bc6 PA |
275 | { |
276 | /* Display the top level prompt. */ | |
277 | actual_gdb_prompt = top_level_prompt (); | |
278 | } | |
b5a0ac70 | 279 | } |
ab821bc6 PA |
280 | else |
281 | actual_gdb_prompt = xstrdup (new_prompt); | |
b5a0ac70 SS |
282 | |
283 | if (async_command_editing_p) | |
284 | { | |
285 | rl_callback_handler_remove (); | |
d17b6f81 | 286 | rl_callback_handler_install (actual_gdb_prompt, input_handler); |
b5a0ac70 | 287 | } |
371d5dec | 288 | /* new_prompt at this point can be the top of the stack or the one |
d014929c MS |
289 | passed in. It can't be NULL. */ |
290 | else | |
b5a0ac70 SS |
291 | { |
292 | /* Don't use a _filtered function here. It causes the assumed | |
293 | character position to be off, since the newline we read from | |
294 | the user is not accounted for. */ | |
d17b6f81 | 295 | fputs_unfiltered (actual_gdb_prompt, gdb_stdout); |
b5a0ac70 SS |
296 | gdb_flush (gdb_stdout); |
297 | } | |
ab821bc6 PA |
298 | |
299 | do_cleanups (old_chain); | |
b5a0ac70 SS |
300 | } |
301 | ||
ab821bc6 PA |
302 | /* Return the top level prompt, as specified by "set prompt", possibly |
303 | overriden by the python gdb.prompt_hook hook, and then composed | |
304 | with the prompt prefix and suffix (annotations). The caller is | |
305 | responsible for freeing the returned string. */ | |
306 | ||
307 | static char * | |
308 | top_level_prompt (void) | |
b5a0ac70 | 309 | { |
ab821bc6 PA |
310 | char *prefix; |
311 | char *prompt = NULL; | |
312 | char *suffix; | |
313 | char *composed_prompt; | |
314 | size_t prompt_length; | |
b5a0ac70 | 315 | |
ab821bc6 PA |
316 | /* Give observers a chance of changing the prompt. E.g., the python |
317 | `gdb.prompt_hook' is installed as an observer. */ | |
318 | observer_notify_before_prompt (get_prompt ()); | |
319 | ||
320 | prompt = xstrdup (get_prompt ()); | |
b5a0ac70 | 321 | |
ab821bc6 | 322 | if (annotation_level >= 2) |
b5a0ac70 | 323 | { |
ab821bc6 PA |
324 | /* Prefix needs to have new line at end. */ |
325 | prefix = (char *) alloca (strlen (async_annotation_suffix) + 10); | |
326 | strcpy (prefix, "\n\032\032pre-"); | |
327 | strcat (prefix, async_annotation_suffix); | |
328 | strcat (prefix, "\n"); | |
329 | ||
330 | /* Suffix needs to have a new line at end and \032 \032 at | |
331 | beginning. */ | |
332 | suffix = (char *) alloca (strlen (async_annotation_suffix) + 6); | |
333 | strcpy (suffix, "\n\032\032"); | |
334 | strcat (suffix, async_annotation_suffix); | |
335 | strcat (suffix, "\n"); | |
b5a0ac70 SS |
336 | } |
337 | else | |
338 | { | |
ab821bc6 PA |
339 | prefix = ""; |
340 | suffix = ""; | |
b5a0ac70 | 341 | } |
b5a0ac70 | 342 | |
ab821bc6 PA |
343 | prompt_length = strlen (prefix) + strlen (prompt) + strlen (suffix); |
344 | composed_prompt = xmalloc (prompt_length + 1); | |
b5a0ac70 | 345 | |
ab821bc6 PA |
346 | strcpy (composed_prompt, prefix); |
347 | strcat (composed_prompt, prompt); | |
348 | strcat (composed_prompt, suffix); | |
b5a0ac70 | 349 | |
ab821bc6 PA |
350 | xfree (prompt); |
351 | ||
352 | return composed_prompt; | |
b5a0ac70 | 353 | } |
c2c6d25f JM |
354 | |
355 | /* When there is an event ready on the stdin file desriptor, instead | |
356 | of calling readline directly throught the callback function, or | |
357 | instead of calling gdb_readline2, give gdb a chance to detect | |
371d5dec | 358 | errors and do something. */ |
c2c6d25f | 359 | void |
2acceee2 | 360 | stdin_event_handler (int error, gdb_client_data client_data) |
c2c6d25f JM |
361 | { |
362 | if (error) | |
363 | { | |
a3f17187 | 364 | printf_unfiltered (_("error detected on stdin\n")); |
2acceee2 | 365 | delete_file_handler (input_fd); |
c2c6d25f | 366 | discard_all_continuations (); |
604ead4a | 367 | discard_all_intermediate_continuations (); |
371d5dec | 368 | /* If stdin died, we may as well kill gdb. */ |
c5394b80 | 369 | quit_command ((char *) 0, stdin == instream); |
c2c6d25f JM |
370 | } |
371 | else | |
6426a772 | 372 | (*call_readline) (client_data); |
c2c6d25f JM |
373 | } |
374 | ||
6426a772 JM |
375 | /* Re-enable stdin after the end of an execution command in |
376 | synchronous mode, or after an error from the target, and we aborted | |
371d5dec | 377 | the exec operation. */ |
6426a772 JM |
378 | |
379 | void | |
712af3be | 380 | async_enable_stdin (void) |
6426a772 | 381 | { |
32c1e744 VP |
382 | if (sync_execution) |
383 | { | |
371d5dec | 384 | /* See NOTE in async_disable_stdin(). */ |
32c1e744 VP |
385 | /* FIXME: cagney/1999-09-27: Call this before clearing |
386 | sync_execution. Current target_terminal_ours() implementations | |
371d5dec | 387 | check for sync_execution before switching the terminal. */ |
32c1e744 | 388 | target_terminal_ours (); |
32c1e744 VP |
389 | sync_execution = 0; |
390 | } | |
6426a772 JM |
391 | } |
392 | ||
393 | /* Disable reads from stdin (the console) marking the command as | |
371d5dec | 394 | synchronous. */ |
6426a772 JM |
395 | |
396 | void | |
397 | async_disable_stdin (void) | |
398 | { | |
ab821bc6 | 399 | sync_execution = 1; |
6426a772 | 400 | } |
b5a0ac70 | 401 | \f |
6426a772 | 402 | |
371d5dec | 403 | /* Handles a gdb command. This function is called by |
b5a0ac70 | 404 | command_line_handler, which has processed one or more input lines |
371d5dec | 405 | into COMMAND. */ |
392a587b | 406 | /* NOTE: 1999-04-30 This is the asynchronous version of the command_loop |
b5a0ac70 | 407 | function. The command_loop function will be obsolete when we |
371d5dec | 408 | switch to use the event loop at every execution of gdb. */ |
392a587b | 409 | static void |
c2c6d25f | 410 | command_handler (char *command) |
b5a0ac70 | 411 | { |
b5a0ac70 | 412 | int stdin_is_tty = ISATTY (stdin); |
0f3bb72e | 413 | struct cleanup *stat_chain; |
b5a0ac70 | 414 | |
522002f9 | 415 | clear_quit_flag (); |
b5a0ac70 SS |
416 | if (instream == stdin && stdin_is_tty) |
417 | reinitialize_more_filter (); | |
b5a0ac70 | 418 | |
371d5dec MS |
419 | /* If readline returned a NULL command, it means that the connection |
420 | with the terminal is gone. This happens at the end of a | |
421 | testsuite run, after Expect has hung up but GDB is still alive. | |
422 | In such a case, we just quit gdb killing the inferior program | |
423 | too. */ | |
b5a0ac70 | 424 | if (command == 0) |
fa3fd85b AS |
425 | { |
426 | printf_unfiltered ("quit\n"); | |
427 | execute_command ("quit", stdin == instream); | |
428 | } | |
b5a0ac70 | 429 | |
0f3bb72e | 430 | stat_chain = make_command_stats_cleanup (1); |
b5a0ac70 SS |
431 | |
432 | execute_command (command, instream == stdin); | |
c5aa993b | 433 | |
347bddb7 PA |
434 | /* Do any commands attached to breakpoint we stopped at. */ |
435 | bpstat_do_actions (); | |
c5aa993b | 436 | |
0f3bb72e | 437 | do_cleanups (stat_chain); |
43ff13b4 JM |
438 | } |
439 | ||
371d5dec MS |
440 | /* Handle a complete line of input. This is called by the callback |
441 | mechanism within the readline library. Deal with incomplete | |
442 | commands as well, by saving the partial input in a global | |
443 | buffer. */ | |
b5a0ac70 | 444 | |
392a587b | 445 | /* NOTE: 1999-04-30 This is the asynchronous version of the |
371d5dec | 446 | command_line_input function; command_line_input will become |
b5a0ac70 | 447 | obsolete once we use the event loop as the default mechanism in |
371d5dec | 448 | GDB. */ |
b5a0ac70 | 449 | static void |
c2c6d25f | 450 | command_line_handler (char *rl) |
b5a0ac70 SS |
451 | { |
452 | static char *linebuffer = 0; | |
453 | static unsigned linelength = 0; | |
52f0bd74 | 454 | char *p; |
b5a0ac70 | 455 | char *p1; |
b5a0ac70 | 456 | char *nline; |
b5a0ac70 SS |
457 | int repeat = (instream == stdin); |
458 | ||
459 | if (annotation_level > 1 && instream == stdin) | |
460 | { | |
a3f17187 | 461 | printf_unfiltered (("\n\032\032post-")); |
306d9ac5 | 462 | puts_unfiltered (async_annotation_suffix); |
a3f17187 | 463 | printf_unfiltered (("\n")); |
b5a0ac70 SS |
464 | } |
465 | ||
466 | if (linebuffer == 0) | |
467 | { | |
468 | linelength = 80; | |
469 | linebuffer = (char *) xmalloc (linelength); | |
470 | } | |
471 | ||
472 | p = linebuffer; | |
473 | ||
474 | if (more_to_come) | |
475 | { | |
476 | strcpy (linebuffer, readline_input_state.linebuffer); | |
477 | p = readline_input_state.linebuffer_ptr; | |
b8c9b27d | 478 | xfree (readline_input_state.linebuffer); |
b5a0ac70 | 479 | more_to_come = 0; |
b5a0ac70 SS |
480 | } |
481 | ||
482 | #ifdef STOP_SIGNAL | |
483 | if (job_control) | |
0f71a2f6 | 484 | signal (STOP_SIGNAL, handle_stop_sig); |
b5a0ac70 SS |
485 | #endif |
486 | ||
487 | /* Make sure that all output has been output. Some machines may let | |
371d5dec MS |
488 | you get away with leaving out some of the gdb_flush, but not |
489 | all. */ | |
b5a0ac70 SS |
490 | wrap_here (""); |
491 | gdb_flush (gdb_stdout); | |
492 | gdb_flush (gdb_stderr); | |
493 | ||
494 | if (source_file_name != NULL) | |
637537d0 | 495 | ++source_line_number; |
b5a0ac70 SS |
496 | |
497 | /* If we are in this case, then command_handler will call quit | |
371d5dec | 498 | and exit from gdb. */ |
b5a0ac70 SS |
499 | if (!rl || rl == (char *) EOF) |
500 | { | |
b5a0ac70 | 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 | { | |
460014f5 | 871 | pop_all_targets (); |
b2cd6b29 JM |
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 | } |