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