gdb/
[deliverable/binutils-gdb.git] / gdb / event-top.c
1 /* Top level stuff for GDB, the GNU debugger.
2
3 Copyright (C) 1999-2002, 2004-2005, 2007-2012 Free Software
4 Foundation, Inc.
5
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
12 the Free Software Foundation; either version 3 of the License, or
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
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22
23 #include "defs.h"
24 #include "top.h"
25 #include "inferior.h"
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>
32 #include "exceptions.h"
33 #include "cli/cli-script.h" /* for reset_command_nest_depth */
34 #include "main.h"
35 #include "gdbthread.h"
36 #include "observer.h"
37 #include "continuations.h"
38 #include "gdbcmd.h" /* for dont_repeat() */
39
40 /* readline include files. */
41 #include "readline/readline.h"
42 #include "readline/history.h"
43
44 /* readline defines this. */
45 #undef savestring
46
47 static void rl_callback_read_char_wrapper (gdb_client_data client_data);
48 static void command_line_handler (char *rl);
49 static void change_line_handler (void);
50 static void command_handler (char *command);
51 static char *top_level_prompt (void);
52
53 /* Signal handlers. */
54 #ifdef SIGQUIT
55 static void handle_sigquit (int sig);
56 #endif
57 #ifdef SIGHUP
58 static void handle_sighup (int sig);
59 #endif
60 static void handle_sigfpe (int sig);
61
62 /* Functions to be invoked by the event loop in response to
63 signals. */
64 #if defined (SIGQUIT) || defined (SIGHUP)
65 static void async_do_nothing (gdb_client_data);
66 #endif
67 #ifdef SIGHUP
68 static void async_disconnect (gdb_client_data);
69 #endif
70 static void async_float_handler (gdb_client_data);
71 #ifdef STOP_SIGNAL
72 static void async_stop_sig (gdb_client_data);
73 #endif
74
75 /* Readline offers an alternate interface, via callback
76 functions. These are all included in the file callback.c in the
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
81 there is a new character ready on the input stream. This function
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
87 of the old command_line_input in gdb. Instead of invoking (and waiting
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
93 that readline offers as callback to the event_loop. */
94
95 void (*input_handler) (char *);
96 void (*call_readline) (gdb_client_data);
97
98 /* Important variables for the event loop. */
99
100 /* This is used to determine if GDB is using the readline library or
101 its own simplified form of readline. It is used by the asynchronous
102 form of the set editing command.
103 ezannoni: as of 1999-04-29 I expect that this
104 variable will not be used after gdb is changed to use the event
105 loop as default engine, and event-top.c is merged into top.c. */
106 int async_command_editing_p;
107
108 /* This is the annotation suffix that will be used when the
109 annotation_level is 2. */
110 char *async_annotation_suffix;
111
112 /* This is used to display the notification of the completion of an
113 asynchronous execution command. */
114 int exec_done_display_p = 0;
115
116 /* This is the file descriptor for the input stream that GDB uses to
117 read commands from. */
118 int input_fd;
119
120 /* Signal handling variables. */
121 /* Each of these is a pointer to a function that the event loop will
122 invoke if the corresponding signal has received. The real signal
123 handlers mark these functions as ready to be executed and the event
124 loop, in a later iteration, calls them. See the function
125 invoke_async_signal_handler. */
126 static struct async_signal_handler *sigint_token;
127 #ifdef SIGHUP
128 static struct async_signal_handler *sighup_token;
129 #endif
130 #ifdef SIGQUIT
131 static struct async_signal_handler *sigquit_token;
132 #endif
133 static struct async_signal_handler *sigfpe_token;
134 #ifdef STOP_SIGNAL
135 static struct async_signal_handler *sigtstp_token;
136 #endif
137
138 /* Structure to save a partially entered command. This is used when
139 the user types '\' at the end of a command line. This is necessary
140 because each line of input is handled by a different call to
141 command_line_handler, and normally there is no state retained
142 between different calls. */
143 static int more_to_come = 0;
144
145 struct readline_input_state
146 {
147 char *linebuffer;
148 char *linebuffer_ptr;
149 }
150 readline_input_state;
151
152 /* This hook is called by rl_callback_read_char_wrapper after each
153 character is processed. */
154 void (*after_char_processing_hook) (void);
155 \f
156
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. */
160 static void
161 rl_callback_read_char_wrapper (gdb_client_data client_data)
162 {
163 rl_callback_read_char ();
164 if (after_char_processing_hook)
165 (*after_char_processing_hook) ();
166 }
167
168 /* Initialize all the necessary variables, start the event loop,
169 register readline, and stdin, start the loop. */
170 void
171 cli_command_loop (void)
172 {
173 display_gdb_prompt (0);
174
175 /* Now it's time to start the event loop. */
176 start_event_loop ();
177 }
178
179 /* Change the function to be invoked every time there is a character
180 ready on stdin. This is used when the user sets the editing off,
181 therefore bypassing readline, and letting gdb handle the input
182 itself, via gdb_readline2. Also it is used in the opposite case in
183 which the user sets editing on again, by restoring readline
184 handling of the input. */
185 static void
186 change_line_handler (void)
187 {
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
190 async mode, we always read commands from a file with editing
191 off. This means that the 'set editing on/off' will have effect
192 only on the interactive session. */
193
194 if (async_command_editing_p)
195 {
196 /* Turn on editing by using readline. */
197 call_readline = rl_callback_read_char_wrapper;
198 input_handler = command_line_handler;
199 }
200 else
201 {
202 /* Turn off editing by using gdb_readline2. */
203 rl_callback_handler_remove ();
204 call_readline = gdb_readline2;
205
206 /* Set up the command handler as well, in case we are called as
207 first thing from .gdbinit. */
208 input_handler = command_line_handler;
209 }
210 }
211
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
220 1. When the user enters a command line which is ended by '\'
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
224 2. When the user is entering 'commands' for a breakpoint, or
225 actions for a tracepoint. In this case the prompt will be '>'
226
227 3. On prompting for pagination. */
228
229 void
230 display_gdb_prompt (char *new_prompt)
231 {
232 char *actual_gdb_prompt = NULL;
233 struct cleanup *old_chain;
234
235 /* Reset the nesting depth used when trace-commands is set. */
236 reset_command_nest_depth ();
237
238 /* Each interpreter has its own rules on displaying the command
239 prompt. */
240 if (!current_interp_display_prompt_p ())
241 return;
242
243 old_chain = make_cleanup (free_current_contents, &actual_gdb_prompt);
244
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)
249 {
250 if (sync_execution)
251 {
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;
270 }
271 else
272 {
273 /* Display the top level prompt. */
274 actual_gdb_prompt = top_level_prompt ();
275 }
276 }
277 else
278 actual_gdb_prompt = xstrdup (new_prompt);
279
280 if (async_command_editing_p)
281 {
282 rl_callback_handler_remove ();
283 rl_callback_handler_install (actual_gdb_prompt, input_handler);
284 }
285 /* new_prompt at this point can be the top of the stack or the one
286 passed in. It can't be NULL. */
287 else
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. */
292 fputs_unfiltered (actual_gdb_prompt, gdb_stdout);
293 gdb_flush (gdb_stdout);
294 }
295
296 do_cleanups (old_chain);
297 }
298
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)
306 {
307 char *prefix;
308 char *prompt = NULL;
309 char *suffix;
310 char *composed_prompt;
311 size_t prompt_length;
312
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 ());
318
319 if (annotation_level >= 2)
320 {
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");
333 }
334 else
335 {
336 prefix = "";
337 suffix = "";
338 }
339
340 prompt_length = strlen (prefix) + strlen (prompt) + strlen (suffix);
341 composed_prompt = xmalloc (prompt_length + 1);
342
343 strcpy (composed_prompt, prefix);
344 strcat (composed_prompt, prompt);
345 strcat (composed_prompt, suffix);
346
347 xfree (prompt);
348
349 return composed_prompt;
350 }
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
355 errors and do something. */
356 void
357 stdin_event_handler (int error, gdb_client_data client_data)
358 {
359 if (error)
360 {
361 printf_unfiltered (_("error detected on stdin\n"));
362 delete_file_handler (input_fd);
363 discard_all_continuations ();
364 discard_all_intermediate_continuations ();
365 /* If stdin died, we may as well kill gdb. */
366 quit_command ((char *) 0, stdin == instream);
367 }
368 else
369 (*call_readline) (client_data);
370 }
371
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
374 the exec operation. */
375
376 void
377 async_enable_stdin (void)
378 {
379 if (sync_execution)
380 {
381 /* See NOTE in async_disable_stdin(). */
382 /* FIXME: cagney/1999-09-27: Call this before clearing
383 sync_execution. Current target_terminal_ours() implementations
384 check for sync_execution before switching the terminal. */
385 target_terminal_ours ();
386 sync_execution = 0;
387 }
388 }
389
390 /* Disable reads from stdin (the console) marking the command as
391 synchronous. */
392
393 void
394 async_disable_stdin (void)
395 {
396 sync_execution = 1;
397 }
398 \f
399
400 /* Handles a gdb command. This function is called by
401 command_line_handler, which has processed one or more input lines
402 into COMMAND. */
403 /* NOTE: 1999-04-30 This is the asynchronous version of the command_loop
404 function. The command_loop function will be obsolete when we
405 switch to use the event loop at every execution of gdb. */
406 static void
407 command_handler (char *command)
408 {
409 int stdin_is_tty = ISATTY (stdin);
410 struct cleanup *stat_chain;
411
412 clear_quit_flag ();
413 if (instream == stdin && stdin_is_tty)
414 reinitialize_more_filter ();
415
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. */
421 if (command == 0)
422 {
423 printf_unfiltered ("quit\n");
424 execute_command ("quit", stdin == instream);
425 }
426
427 stat_chain = make_command_stats_cleanup (1);
428
429 execute_command (command, instream == stdin);
430
431 /* Do any commands attached to breakpoint we stopped at. */
432 bpstat_do_actions ();
433
434 do_cleanups (stat_chain);
435 }
436
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. */
441
442 /* NOTE: 1999-04-30 This is the asynchronous version of the
443 command_line_input function; command_line_input will become
444 obsolete once we use the event loop as the default mechanism in
445 GDB. */
446 static void
447 command_line_handler (char *rl)
448 {
449 static char *linebuffer = 0;
450 static unsigned linelength = 0;
451 char *p;
452 char *p1;
453 char *nline;
454 char got_eof = 0;
455
456 int repeat = (instream == stdin);
457
458 if (annotation_level > 1 && instream == stdin)
459 {
460 printf_unfiltered (("\n\032\032post-"));
461 puts_unfiltered (async_annotation_suffix);
462 printf_unfiltered (("\n"));
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;
477 xfree (readline_input_state.linebuffer);
478 more_to_come = 0;
479 }
480
481 #ifdef STOP_SIGNAL
482 if (job_control)
483 signal (STOP_SIGNAL, handle_stop_sig);
484 #endif
485
486 /* Make sure that all output has been output. Some machines may let
487 you get away with leaving out some of the gdb_flush, but not
488 all. */
489 wrap_here ("");
490 gdb_flush (gdb_stdout);
491 gdb_flush (gdb_stderr);
492
493 if (source_file_name != NULL)
494 ++source_line_number;
495
496 /* If we are in this case, then command_handler will call quit
497 and exit from gdb. */
498 if (!rl || rl == (char *) EOF)
499 {
500 got_eof = 1;
501 command_handler (0);
502 return; /* Lint. */
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
513 if this was just a newline). */
514 while (*p1)
515 *p++ = *p1++;
516
517 xfree (rl); /* Allocated in readline. */
518
519 if (p > linebuffer && *(p - 1) == '\\')
520 {
521 *p = '\0';
522 p--; /* Put on top of '\'. */
523
524 readline_input_state.linebuffer = xstrdup (linebuffer);
525 readline_input_state.linebuffer_ptr = p;
526
527 /* We will not invoke a execute_command if there is more
528 input expected to complete the command. So, we need to
529 print an empty prompt here. */
530 more_to_come = 1;
531 display_gdb_prompt ("");
532 return;
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)
543 && strncmp (linebuffer, "server ", SERVER_COMMAND_LENGTH) == 0;
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 {
572 xfree (history_value);
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);
582 }
583 xfree (history_value);
584 }
585
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. */
588 if (repeat && p == linebuffer && *p != '\\')
589 {
590 command_handler (saved_command_line);
591 display_gdb_prompt (0);
592 return;
593 }
594
595 for (p1 = linebuffer; *p1 == ' ' || *p1 == '\t'; p1++);
596 if (repeat && !*p1)
597 {
598 command_handler (saved_command_line);
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 == '#')
617 *p1 = '\0'; /* Found a comment. */
618
619 /* Save into global buffer if appropriate. */
620 if (repeat)
621 {
622 if (linelength > saved_command_line_size)
623 {
624 saved_command_line = xrealloc (saved_command_line, linelength);
625 saved_command_line_size = linelength;
626 }
627 strcpy (saved_command_line, linebuffer);
628 if (!more_to_come)
629 {
630 command_handler (saved_command_line);
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
642 provided by the readline library. */
643
644 /* NOTE: 1999-04-30 Asynchronous version of gdb_readline; gdb_readline
645 will become obsolete when the event loop is made the default
646 execution for gdb. */
647 void
648 gdb_readline2 (gdb_client_data client_data)
649 {
650 int c;
651 char *result;
652 int input_index = 0;
653 int result_size = 80;
654 static int done_once = 0;
655
656 /* Unbuffer the input stream, so that, later on, the calls to fgetc
657 fetch only one char at the time from the stream. The fgetc's will
658 get up to the first newline, but there may be more chars in the
659 stream after '\n'. If we buffer the input and fgetc drains the
660 stream, getting stuff beyond the newline as well, a select, done
661 afterwards will not trigger. */
662 if (!done_once && !ISATTY (instream))
663 {
664 setbuf (instream, NULL);
665 done_once = 1;
666 }
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,
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. */
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)
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. */
689 break;
690 xfree (result);
691 (*input_handler) (0);
692 return;
693 }
694
695 if (c == '\n')
696 {
697 if (input_index > 0 && result[input_index - 1] == '\r')
698 input_index--;
699 break;
700 }
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';
711 (*input_handler) (result);
712 }
713 \f
714
715 /* Initialization of signal handlers and tokens. There is a function
716 handle_sig* for each of the signals GDB cares about. Specifically:
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
721 procedures are the old signal handlers. The event loop will take
722 care of invoking the queued procedures to perform the usual tasks
723 associated with the reception of the signal. */
724 /* NOTE: 1999-04-30 This is the asynchronous version of init_signals.
725 init_signals will become obsolete as we move to have to event loop
726 as the default for gdb. */
727 void
728 async_init_signals (void)
729 {
730 signal (SIGINT, handle_sigint);
731 sigint_token =
732 create_async_signal_handler (async_request_quit, NULL);
733 signal (SIGTERM, handle_sigterm);
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
741 #ifdef SIGQUIT
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 =
752 create_async_signal_handler (async_do_nothing, NULL);
753 #endif
754 #ifdef SIGHUP
755 if (signal (SIGHUP, handle_sighup) != SIG_IGN)
756 sighup_token =
757 create_async_signal_handler (async_disconnect, NULL);
758 else
759 sighup_token =
760 create_async_signal_handler (async_do_nothing, NULL);
761 #endif
762 signal (SIGFPE, handle_sigfpe);
763 sigfpe_token =
764 create_async_signal_handler (async_float_handler, NULL);
765
766 #ifdef STOP_SIGNAL
767 sigtstp_token =
768 create_async_signal_handler (async_stop_sig, NULL);
769 #endif
770
771 }
772
773 /* Tell the event loop what to do if SIGINT is received.
774 See event-signal.c. */
775 void
776 handle_sigint (int sig)
777 {
778 signal (sig, handle_sigint);
779
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
782 set quit_flag to 1 here. Then if QUIT is called before we get to
783 the event loop, we will unwind as expected. */
784
785 set_quit_flag ();
786
787 /* If immediate_quit is set, we go ahead and process the SIGINT right
788 away, even if we usually would defer this to the event loop. The
789 assumption here is that it is safe to process ^C immediately if
790 immediate_quit is set. If we didn't, SIGINT would be really
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
793 finish first, which is unacceptable. If immediate quit is not set,
794 we process SIGINT the next time through the loop, which is fine. */
795 gdb_call_async_signal_handler (sigint_token, immediate_quit);
796 }
797
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
807 /* Do the quit. All the checks have been done by the caller. */
808 void
809 async_request_quit (gdb_client_data arg)
810 {
811 /* If the quit_flag has gotten reset back to 0 by the time we get
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
814 is no reason to call quit again here. */
815
816 if (check_quit_flag ())
817 quit ();
818 }
819
820 #ifdef SIGQUIT
821 /* Tell the event loop what to do if SIGQUIT is received.
822 See event-signal.c. */
823 static void
824 handle_sigquit (int sig)
825 {
826 mark_async_signal_handler (sigquit_token);
827 signal (sig, handle_sigquit);
828 }
829 #endif
830
831 #if defined (SIGQUIT) || defined (SIGHUP)
832 /* Called by the event loop in response to a SIGQUIT or an
833 ignored SIGHUP. */
834 static void
835 async_do_nothing (gdb_client_data arg)
836 {
837 /* Empty function body. */
838 }
839 #endif
840
841 #ifdef SIGHUP
842 /* Tell the event loop what to do if SIGHUP is received.
843 See event-signal.c. */
844 static void
845 handle_sighup (int sig)
846 {
847 mark_async_signal_handler (sighup_token);
848 signal (sig, handle_sighup);
849 }
850
851 /* Called by the event loop to process a SIGHUP. */
852 static void
853 async_disconnect (gdb_client_data arg)
854 {
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
874 signal (SIGHUP, SIG_DFL); /*FIXME: ??????????? */
875 raise (SIGHUP);
876 }
877 #endif
878
879 #ifdef STOP_SIGNAL
880 void
881 handle_stop_sig (int sig)
882 {
883 mark_async_signal_handler (sigtstp_token);
884 signal (sig, handle_stop_sig);
885 }
886
887 static void
888 async_stop_sig (gdb_client_data arg)
889 {
890 char *prompt = get_prompt ();
891
892 #if STOP_SIGNAL == SIGTSTP
893 signal (SIGTSTP, SIG_DFL);
894 #if HAVE_SIGPROCMASK
895 {
896 sigset_t zero;
897
898 sigemptyset (&zero);
899 sigprocmask (SIG_SETMASK, &zero, 0);
900 }
901 #elif HAVE_SIGSETMASK
902 sigsetmask (0);
903 #endif
904 raise (SIGTSTP);
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
912 /* Forget about any previous command -- null line now will do
913 nothing. */
914 dont_repeat ();
915 }
916 #endif /* STOP_SIGNAL */
917
918 /* Tell the event loop what to do if SIGFPE is received.
919 See event-signal.c. */
920 static void
921 handle_sigfpe (int sig)
922 {
923 mark_async_signal_handler (sigfpe_token);
924 signal (sig, handle_sigfpe);
925 }
926
927 /* Event loop will call this functin to process a SIGFPE. */
928 static void
929 async_float_handler (gdb_client_data arg)
930 {
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. */
933 error (_("Erroneous arithmetic operation."));
934 }
935 \f
936
937 /* Called by do_setshow_command. */
938 void
939 set_async_editing_command (char *args, int from_tty,
940 struct cmd_list_element *c)
941 {
942 change_line_handler ();
943 }
944
945 /* Set things up for readline to be invoked via the alternate
946 interface, i.e. via a callback function (rl_callback_read_char),
947 and hook up instream to the event loop. */
948 void
949 gdb_setup_readline (void)
950 {
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. */
955 if (!batch_silent)
956 gdb_stdout = stdio_fileopen (stdout);
957 gdb_stderr = stdio_fileopen (stderr);
958 gdb_stdlog = gdb_stderr; /* for moment */
959 gdb_stdtarg = gdb_stderr; /* for moment */
960 gdb_stdtargerr = gdb_stderr; /* for moment */
961
962 /* If the input stream is connected to a terminal, turn on
963 editing. */
964 if (ISATTY (instream))
965 {
966 /* Tell gdb that we will be using the readline library. This
967 could be overwritten by a command in .gdbinit like 'set
968 editing on' or 'off'. */
969 async_command_editing_p = 1;
970
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;
974 }
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
982 complete line to gdb for processing; command_line_handler is the
983 function that does this. */
984 input_handler = command_line_handler;
985
986 /* Tell readline to use the same input stream that gdb uses. */
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
996 register with the even loop. Another source is going to be the
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);
1001 }
1002
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 {
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. */
1013
1014 #if 0
1015 ui_file_delete (gdb_stdout);
1016 ui_file_delete (gdb_stderr);
1017 gdb_stdlog = NULL;
1018 gdb_stdtarg = NULL;
1019 gdb_stdtargerr = NULL;
1020 #endif
1021
1022 rl_callback_handler_remove ();
1023 delete_file_handler (input_fd);
1024 }
This page took 0.066972 seconds and 4 git commands to generate.