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