1 /* Top level stuff for GDB, the GNU debugger.
2 Copyright 1999 Free Software Foundation, Inc.
3 Written by Elena Zannoni <ezannoni@cygnus.com> of Cygnus Solutions.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
25 #include "terminal.h" /* for job_control */
27 #include "event-loop.h"
29 /* readline include files */
30 #include <readline/readline.h>
31 #include <readline/history.h>
33 /* readline defines this. */
36 extern void _initialize_event_loop
PARAMS ((void));
38 static void command_line_handler
PARAMS ((char *));
39 static void command_line_handler_continuation
PARAMS ((struct continuation_arg
*));
40 void gdb_readline2
PARAMS ((void));
41 void pop_prompt
PARAMS ((void));
42 void push_prompt
PARAMS ((char *, char *, char *));
43 static void change_line_handler
PARAMS ((void));
44 static void change_annotation_level
PARAMS ((void));
45 static void command_handler
PARAMS ((char *));
47 /* Signal handlers. */
48 void handle_sigint
PARAMS ((int));
49 static void handle_sigquit
PARAMS ((int));
50 static void handle_sighup
PARAMS ((int));
51 static void handle_sigfpe
PARAMS ((int));
52 static void handle_sigwinch
PARAMS ((int));
53 /* Signal to catch ^Z typed while reading a command: SIGTSTP or SIGCONT. */
56 #define STOP_SIGNAL SIGTSTP
57 void handle_stop_sig
PARAMS ((int));
61 /* Functions to be invoked by the event loop in response to
63 void async_request_quit
PARAMS ((gdb_client_data
));
64 static void async_do_nothing
PARAMS ((gdb_client_data
));
65 static void async_disconnect
PARAMS ((gdb_client_data
));
66 static void async_float_handler
PARAMS ((gdb_client_data
));
67 static void async_stop_sig
PARAMS ((gdb_client_data
));
69 /* If this definition isn't overridden by the header files, assume
70 that isatty and fileno exist on this system. */
72 #define ISATTY(FP) (isatty (fileno (FP)))
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. */
95 void (*input_handler
) PARAMS ((char *));
96 void (*call_readline
) PARAMS ((void));
98 /* Important variables for the event loop. */
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
;
108 /* This variable contains the new prompt that the user sets with the
109 set prompt command. */
110 char *new_async_prompt
;
112 /* This is the annotation suffix that will be used when the
113 annotation_level is 2. */
114 char *async_annotation_suffix
;
116 /* This is the file descriptor for the input stream that GDB uses to
117 read commands from. */
120 /* This is the prompt stack. Prompts will be pushed on the stack as
121 needed by the different 'kinds' of user inputs GDB is asking
122 for. See event-loop.h. */
123 struct prompts the_prompts
;
125 /* signal handling variables */
126 /* Each of these is a pointer to a function that the event loop will
127 invoke if the corresponding signal has received. The real signal
128 handlers mark these functions as ready to be executed and the event
129 loop, in a later iteration, calls them. See the function
130 invoke_async_signal_handler. */
137 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
144 void mark_async_signal_handler_wrapper
PARAMS ((void *));
146 /* Structure to save a partially entered command. This is used when
147 the user types '\' at the end of a command line. This is necessary
148 because each line of input is handled by a different call to
149 command_line_handler, and normally there is no state retained
150 between different calls. */
151 int more_to_come
= 0;
153 struct readline_input_state
156 char *linebuffer_ptr
;
158 readline_input_state
;
161 /* Initialize all the necessary variables, start the event loop,
162 register readline, and stdin, start the loop. */
168 char *gdb_prompt
= get_prompt ();
170 /* If we are using readline, set things up and display the first
171 prompt, otherwise just print the prompt. */
172 if (async_command_editing_p
)
174 /* Tell readline what the prompt to display is and what function it
175 will need to call after a whole line is read. This also displays
177 length
= strlen (PREFIX (0)) + strlen (gdb_prompt
) + strlen (SUFFIX (0)) + 1;
178 a_prompt
= (char *) xmalloc (length
);
179 strcpy (a_prompt
, PREFIX (0));
180 strcat (a_prompt
, gdb_prompt
);
181 strcat (a_prompt
, SUFFIX (0));
182 rl_callback_handler_install (a_prompt
, input_handler
);
185 display_gdb_prompt (0);
187 /* Now it's time to start the event loop. */
191 /* Change the function to be invoked every time there is a character
192 ready on stdin. This is used when the user sets the editing off,
193 therefore bypassing readline, and letting gdb handle the input
194 itself, via gdb_readline2. Also it is used in the opposite case in
195 which the user sets editing on again, by restoring readline
196 handling of the input. */
198 change_line_handler ()
200 if (async_command_editing_p
)
202 /* Turn on editing by using readline. */
203 call_readline
= rl_callback_read_char
;
204 input_handler
= command_line_handler
;
208 /* Turn off editing by using gdb_readline2. */
209 rl_callback_handler_remove ();
210 call_readline
= gdb_readline2
;
212 /* Set up the command handler as well, in case we are called as
213 first thing from .gdbinit. */
214 input_handler
= command_line_handler
;
217 /* To tell the event loop to change the handler associated with the
218 input file descriptor, we need to create a new event source,
219 corresponding to the same fd, but with a new event handler
221 /* NOTE: this operates on input_fd, not instream. If we are reading
222 commands from a file, instream will point to the file. However in
223 async mode, we always read commands from a file with editing
224 off. This means that the 'set editing on/off' will have effect
225 only on the interactive session. */
226 delete_file_handler (input_fd
);
227 add_file_handler (input_fd
, (file_handler_func
*) call_readline
, 0);
230 /* Displays the prompt. The prompt that is displayed is the current
231 top of the prompt stack, if the argument NEW_PROMPT is
232 0. Otherwise, it displays whatever NEW_PROMPT is. This is used
233 after each gdb command has completed, and in the following cases:
234 1. when the user enters a command line which is ended by '\'
235 indicating that the command will continue on the next line.
236 In that case the prompt that is displayed is the empty string.
237 2. When the user is entering 'commands' for a breakpoint, or
238 actions for a tracepoint. In this case the prompt will be '>'
240 FIXME: 2. & 3. not implemented yet for async. */
242 display_gdb_prompt (new_prompt
)
245 int prompt_length
= 0;
246 char *gdb_prompt
= get_prompt ();
250 /* Just use the top of the prompt stack. */
251 prompt_length
= strlen (PREFIX (0)) +
252 strlen (SUFFIX (0)) +
253 strlen (gdb_prompt
) + 1;
255 new_prompt
= (char *) alloca (prompt_length
);
257 /* Prefix needs to have new line at end. */
258 strcpy (new_prompt
, PREFIX (0));
259 strcat (new_prompt
, gdb_prompt
);
260 /* Suffix needs to have a new line at end and \032 \032 at
262 strcat (new_prompt
, SUFFIX (0));
265 if (async_command_editing_p
)
267 rl_callback_handler_remove ();
268 rl_callback_handler_install (new_prompt
, input_handler
);
272 /* Don't use a _filtered function here. It causes the assumed
273 character position to be off, since the newline we read from
274 the user is not accounted for. */
275 fputs_unfiltered (new_prompt
, gdb_stdout
);
278 /* Move to a new line so the entered line doesn't have a prompt
279 on the front of it. */
280 fputs_unfiltered ("\n", gdb_stdout
);
282 gdb_flush (gdb_stdout
);
286 /* Used when the user requests a different annotation level, with
287 'set annotate'. It pushes a new prompt (with prefix and suffix) on top
288 of the prompt stack, if the annotation level desired is 2, otherwise
289 it pops the top of the prompt stack when we want the annotation level
290 to be the normal ones (1 or 2). */
292 change_annotation_level ()
294 char *prefix
, *suffix
;
296 if (!PREFIX (0) || !PROMPT (0) || !SUFFIX (0))
298 /* The prompt stack has not been initialized to "", we are
299 using gdb w/o the --async switch */
300 warning ("Command has same effect as set annotate");
304 if (annotation_level
> 1)
306 if (!strcmp (PREFIX (0), "") && !strcmp (SUFFIX (0), ""))
308 /* Push a new prompt if the previous annotation_level was not >1. */
309 prefix
= (char *) alloca (strlen (async_annotation_suffix
) + 10);
310 strcpy (prefix
, "\n\032\032pre-");
311 strcat (prefix
, async_annotation_suffix
);
312 strcat (prefix
, "\n");
314 suffix
= (char *) alloca (strlen (async_annotation_suffix
) + 6);
315 strcpy (suffix
, "\n\032\032");
316 strcat (suffix
, async_annotation_suffix
);
317 strcat (suffix
, "\n");
319 push_prompt (prefix
, (char *) 0, suffix
);
324 if (strcmp (PREFIX (0), "") && strcmp (SUFFIX (0), ""))
326 /* Pop the top of the stack, we are going back to annotation < 1. */
332 /* Pushes a new prompt on the prompt stack. Each prompt has three
333 parts: prefix, prompt, suffix. Usually prefix and suffix are empty
334 strings, except when the annotation level is 2. Memory is allocated
335 within savestring for the new prompt. */
337 push_prompt (prefix
, prompt
, suffix
)
343 PREFIX (0) = savestring (prefix
, strlen (prefix
));
345 /* Note that this function is used by the set annotate 2
346 command. This is why we take care of saving the old prompt
347 in case a new one is not specified. */
349 PROMPT (0) = savestring (prompt
, strlen (prompt
));
351 PROMPT (0) = savestring (PROMPT (-1), strlen (PROMPT (-1)));
353 SUFFIX (0) = savestring (suffix
, strlen (suffix
));
356 /* Pops the top of the prompt stack, and frees the memory allocated for it. */
360 /* If we are not during a 'synchronous' execution command, in which
361 case, the top prompt would be empty. */
362 if (strcmp (PROMPT (0), ""))
363 /* This is for the case in which the prompt is set while the
364 annotation level is 2. The top prompt will be changed, but when
365 we return to annotation level < 2, we want that new prompt to be
366 in effect, until the user does another 'set prompt'. */
367 if (strcmp (PROMPT (0), PROMPT (-1)))
370 PROMPT (-1) = savestring (PROMPT (0), strlen (PROMPT (0)));
379 /* Handles a gdb command. This function is called by
380 command_line_handler, which has processed one or more input lines
382 /* NOTE: 1999-04-30 This is the asynchronous version of the command_loop
383 function. The command_loop function will be obsolete when we
384 switch to use the event loop at every execution of gdb. */
386 command_handler (command
)
389 struct cleanup
*old_chain
;
390 int stdin_is_tty
= ISATTY (stdin
);
391 struct continuation_arg
*arg1
;
392 struct continuation_arg
*arg2
;
393 long time_at_cmd_start
;
395 long space_at_cmd_start
= 0;
397 extern int display_time
;
398 extern int display_space
;
401 extern int insert_mode
;
405 if (instream
== stdin
&& stdin_is_tty
)
406 reinitialize_more_filter ();
407 old_chain
= make_cleanup ((make_cleanup_func
) command_loop_marker
, 0);
412 /* If readline returned a NULL command, it means that the
413 connection with the terminal is gone. This happens at the
414 end of a testsuite run, after Expect has hung up
415 but GDB is still alive. In such a case, we just quit gdb
416 killing the inferior program too. */
418 quit_command ((char *) 0, stdin
== instream
);
420 time_at_cmd_start
= get_run_time ();
425 extern char **environ
;
426 char *lim
= (char *) sbrk (0);
428 space_at_cmd_start
= (long) (lim
- (char *) &environ
);
432 execute_command (command
, instream
== stdin
);
434 /* Set things up for this function to be compete later, once the
435 executin has completed, if we are doing an execution command,
436 otherwise, just go ahead and finish. */
437 if (target_has_async
&& target_executing
)
440 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
442 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
445 arg1
->data
= (PTR
) time_at_cmd_start
;
446 arg2
->data
= (PTR
) space_at_cmd_start
;
447 add_continuation (command_line_handler_continuation
, arg1
);
450 /* Do any commands attached to breakpoint we stopped at. Only if we
451 are always running synchronously. Or if we have just executed a
452 command that doesn't start the target. */
453 if (!target_has_async
|| !target_executing
)
455 bpstat_do_actions (&stop_bpstat
);
456 do_cleanups (old_chain
);
460 long cmd_time
= get_run_time () - time_at_cmd_start
;
462 printf_unfiltered ("Command execution time: %ld.%06ld\n",
463 cmd_time
/ 1000000, cmd_time
% 1000000);
469 extern char **environ
;
470 char *lim
= (char *) sbrk (0);
471 long space_now
= lim
- (char *) &environ
;
472 long space_diff
= space_now
- space_at_cmd_start
;
474 printf_unfiltered ("Space used: %ld (%c%ld for this command)\n",
476 (space_diff
>= 0 ? '+' : '-'),
483 /* Do any commands attached to breakpoint we stopped at. Only if we
484 are always running synchronously. Or if we have just executed a
485 command that doesn't start the target. */
487 command_line_handler_continuation (arg
)
488 struct continuation_arg
*arg
;
490 extern int display_time
;
491 extern int display_space
;
493 long time_at_cmd_start
= (long) arg
->data
;
494 long space_at_cmd_start
= (long) arg
->next
->data
;
496 bpstat_do_actions (&stop_bpstat
);
497 /*do_cleanups (old_chain); *//*?????FIXME????? */
501 long cmd_time
= get_run_time () - time_at_cmd_start
;
503 printf_unfiltered ("Command execution time: %ld.%06ld\n",
504 cmd_time
/ 1000000, cmd_time
% 1000000);
509 extern char **environ
;
510 char *lim
= (char *) sbrk (0);
511 long space_now
= lim
- (char *) &environ
;
512 long space_diff
= space_now
- space_at_cmd_start
;
514 printf_unfiltered ("Space used: %ld (%c%ld for this command)\n",
516 (space_diff
>= 0 ? '+' : '-'),
522 /* Handle a complete line of input. This is called by the callback
523 mechanism within the readline library. Deal with incomplete commands
524 as well, by saving the partial input in a global buffer. */
526 /* NOTE: 1999-04-30 This is the asynchronous version of the
527 command_line_input function. command_line_input will become
528 obsolete once we use the event loop as the default mechanism in
531 command_line_handler (rl
)
534 static char *linebuffer
= 0;
535 static unsigned linelength
= 0;
538 int change_prompt
= 0;
545 int repeat
= (instream
== stdin
);
547 if (annotation_level
> 1 && instream
== stdin
)
549 printf_unfiltered ("\n\032\032post-");
550 printf_unfiltered (async_annotation_suffix
);
551 printf_unfiltered ("\n");
557 linebuffer
= (char *) xmalloc (linelength
);
564 strcpy (linebuffer
, readline_input_state
.linebuffer
);
565 p
= readline_input_state
.linebuffer_ptr
;
566 free (readline_input_state
.linebuffer
);
573 signal (STOP_SIGNAL
, handle_stop_sig
);
576 /* Make sure that all output has been output. Some machines may let
577 you get away with leaving out some of the gdb_flush, but not all. */
579 gdb_flush (gdb_stdout
);
580 gdb_flush (gdb_stderr
);
582 if (source_file_name
!= NULL
)
584 ++source_line_number
;
585 sprintf (source_error
,
586 "%s%s:%d: Error in sourced command file:\n",
590 error_pre_print
= source_error
;
593 /* If we are in this case, then command_handler will call quit
594 and exit from gdb. */
595 if (!rl
|| rl
== (char *) EOF
)
600 if (strlen (rl
) + 1 + (p
- linebuffer
) > linelength
)
602 linelength
= strlen (rl
) + 1 + (p
- linebuffer
);
603 nline
= (char *) xrealloc (linebuffer
, linelength
);
604 p
+= nline
- linebuffer
;
608 /* Copy line. Don't copy null at end. (Leaves line alone
609 if this was just a newline) */
613 free (rl
); /* Allocated in readline. */
615 if (p
== linebuffer
|| *(p
- 1) == '\\')
617 /* We come here also if the line entered is empty (just a 'return') */
618 p
--; /* Put on top of '\'. */
622 readline_input_state
.linebuffer
= savestring (linebuffer
,
623 strlen (linebuffer
));
624 readline_input_state
.linebuffer_ptr
= p
;
626 /* We will not invoke a execute_command if there is more
627 input expected to complete the command. So, we need to
628 print an empty prompt here. */
629 display_gdb_prompt ("");
636 signal (STOP_SIGNAL
, SIG_DFL
);
639 #define SERVER_COMMAND_LENGTH 7
641 (p
- linebuffer
> SERVER_COMMAND_LENGTH
)
642 && STREQN (linebuffer
, "server ", SERVER_COMMAND_LENGTH
);
645 /* Note that we don't set `line'. Between this and the check in
646 dont_repeat, this insures that repeating will still do the
649 command_handler (linebuffer
+ SERVER_COMMAND_LENGTH
);
650 display_gdb_prompt (0);
654 /* Do history expansion if that is wished. */
655 if (history_expansion_p
&& instream
== stdin
656 && ISATTY (instream
))
661 *p
= '\0'; /* Insert null now. */
662 expanded
= history_expand (linebuffer
, &history_value
);
665 /* Print the changes. */
666 printf_unfiltered ("%s\n", history_value
);
668 /* If there was an error, call this function again. */
671 free (history_value
);
674 if (strlen (history_value
) > linelength
)
676 linelength
= strlen (history_value
) + 1;
677 linebuffer
= (char *) xrealloc (linebuffer
, linelength
);
679 strcpy (linebuffer
, history_value
);
680 p
= linebuffer
+ strlen (linebuffer
);
681 free (history_value
);
685 /* If we just got an empty line, and that is supposed
686 to repeat the previous command, return the value in the
688 if (repeat
&& p
== linebuffer
&& *p
!= '\\')
690 command_handler (line
);
691 display_gdb_prompt (0);
695 for (p1
= linebuffer
; *p1
== ' ' || *p1
== '\t'; p1
++);
698 command_handler (line
);
699 display_gdb_prompt (0);
705 /* Add line to history if appropriate. */
706 if (instream
== stdin
707 && ISATTY (stdin
) && *linebuffer
)
708 add_history (linebuffer
);
710 /* Note: lines consisting solely of comments are added to the command
711 history. This is useful when you type a command, and then
712 realize you don't want to execute it quite yet. You can comment
713 out the command and then later fetch it from the value history
714 and remove the '#'. The kill ring is probably better, but some
715 people are in the habit of commenting things out. */
717 *p1
= '\0'; /* Found a comment. */
719 /* Save into global buffer if appropriate. */
722 if (linelength
> linesize
)
724 line
= xrealloc (line
, linelength
);
725 linesize
= linelength
;
727 strcpy (line
, linebuffer
);
730 command_handler (line
);
731 display_gdb_prompt (0);
736 command_handler (linebuffer
);
737 display_gdb_prompt (0);
741 /* Does reading of input from terminal w/o the editing features
742 provided by the readline library. */
744 /* NOTE: 1999-04-30 Asynchronous version of gdb_readline. gdb_readline
745 will become obsolete when the event loop is made the default
746 execution for gdb. */
753 int result_size
= 80;
755 result
= (char *) xmalloc (result_size
);
757 /* We still need the while loop here, even though it would seem
758 obvious to invoke gdb_readline2 at every character entered. If
759 not using the readline library, the terminal is in cooked mode,
760 which sends the characters all at once. Poll will notice that the
761 input fd has changed state only after enter is pressed. At this
762 point we still need to fetch all the chars entered. */
766 /* Read from stdin if we are executing a user defined command.
767 This is the right thing for prompt_for_continue, at least. */
768 c
= fgetc (instream
? instream
: stdin
);
773 /* The last line does not end with a newline. Return it, and
774 if we are called again fgetc will still return EOF and
775 we'll return NULL then. */
778 (*input_handler
) (0);
782 #ifndef CRLF_SOURCE_FILES
786 if (input_index
> 0 && result
[input_index
- 1] == '\r')
792 result
[input_index
++] = c
;
793 while (input_index
>= result_size
)
796 result
= (char *) xrealloc (result
, result_size
);
800 result
[input_index
++] = '\0';
801 (*input_handler
) (result
);
805 /* Initialization of signal handlers and tokens. There is a function
806 handle_sig* for each of the signals GDB cares about. Specifically:
807 SIGINT, SIGFPE, SIGQUIT, SIGTSTP, SIGHUP, SIGWINCH. These
808 functions are the actual signal handlers associated to the signals
809 via calls to signal(). The only job for these functions is to
810 enqueue the appropriate event/procedure with the event loop. Such
811 procedures are the old signal handlers. The event loop will take
812 care of invoking the queued procedures to perform the usual tasks
813 associated with the reception of the signal. */
814 /* NOTE: 1999-04-30 This is the asynchronous version of init_signals.
815 init_signals will become obsolete as we move to have to event loop
816 as the default for gdb. */
818 async_init_signals ()
820 signal (SIGINT
, handle_sigint
);
822 create_async_signal_handler (async_request_quit
, NULL
);
824 /* If SIGTRAP was set to SIG_IGN, then the SIG_IGN will get passed
825 to the inferior and breakpoints will be ignored. */
827 signal (SIGTRAP
, SIG_DFL
);
830 /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get
831 passed to the inferior, which we don't want. It would be
832 possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but
833 on BSD4.3 systems using vfork, that can affect the
834 GDB process as well as the inferior (the signal handling tables
835 might be in memory, shared between the two). Since we establish
836 a handler for SIGQUIT, when we call exec it will set the signal
837 to SIG_DFL for us. */
838 signal (SIGQUIT
, handle_sigquit
);
840 create_async_signal_handler (async_do_nothing
, NULL
);
842 if (signal (SIGHUP
, handle_sighup
) != SIG_IGN
)
844 create_async_signal_handler (async_disconnect
, NULL
);
847 create_async_signal_handler (async_do_nothing
, NULL
);
849 signal (SIGFPE
, handle_sigfpe
);
851 create_async_signal_handler (async_float_handler
, NULL
);
853 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
854 signal (SIGWINCH
, handle_sigwinch
);
856 create_async_signal_handler (SIGWINCH_HANDLER
, NULL
);
860 create_async_signal_handler (async_stop_sig
, NULL
);
866 mark_async_signal_handler_wrapper (token
)
869 mark_async_signal_handler ((async_signal_handler
*) token
);
872 /* Tell the event loop what to do if SIGINT is received.
873 See event-signal.c. */
878 signal (sig
, handle_sigint
);
880 /* If immediate_quit is set, we go ahead and process the SIGINT right
881 away, even if we usually would defer this to the event loop. The
882 assumption here is that it is safe to process ^C immediately if
883 immediate_quit is set. If we didn't, SIGINT would be really
884 processed only the next time through the event loop. To get to
885 that point, though, the command that we want to interrupt needs to
886 finish first, which is unacceptable. */
888 async_request_quit (0);
890 /* If immediate quit is not set, we process SIGINT the next time
891 through the loop, which is fine. */
892 mark_async_signal_handler_wrapper (sigint_token
);
895 /* Do the quit. All the checks have been done by the caller. */
897 async_request_quit (arg
)
908 /* Tell the event loop what to do if SIGQUIT is received.
909 See event-signal.c. */
914 mark_async_signal_handler_wrapper (sigquit_token
);
915 signal (sig
, handle_sigquit
);
918 /* Called by the event loop in response to a SIGQUIT. */
920 async_do_nothing (arg
)
923 /* Empty function body. */
927 /* Tell the event loop what to do if SIGHUP is received.
928 See event-signal.c. */
933 mark_async_signal_handler_wrapper (sighup_token
);
934 signal (sig
, handle_sighup
);
937 /* Called by the event loop to process a SIGHUP */
939 async_disconnect (arg
)
942 catch_errors (quit_cover
, NULL
,
943 "Could not kill the program being debugged",
945 signal (SIGHUP
, SIG_DFL
); /*FIXME: ??????????? */
946 kill (getpid (), SIGHUP
);
952 handle_stop_sig (sig
)
955 mark_async_signal_handler_wrapper (sigtstp_token
);
956 signal (sig
, handle_stop_sig
);
963 char *prompt
= get_prompt ();
964 #if STOP_SIGNAL == SIGTSTP
965 signal (SIGTSTP
, SIG_DFL
);
967 kill (getpid (), SIGTSTP
);
968 signal (SIGTSTP
, handle_stop_sig
);
970 signal (STOP_SIGNAL
, handle_stop_sig
);
972 printf_unfiltered ("%s", prompt
);
973 gdb_flush (gdb_stdout
);
975 /* Forget about any previous command -- null line now will do nothing. */
978 #endif /* STOP_SIGNAL */
980 /* Tell the event loop what to do if SIGFPE is received.
981 See event-signal.c. */
986 mark_async_signal_handler_wrapper (sigfpe_token
);
987 signal (sig
, handle_sigfpe
);
990 /* Event loop will call this functin to process a SIGFPE. */
992 async_float_handler (arg
)
995 /* This message is based on ANSI C, section 4.7. Note that integer
996 divide by zero causes this, so "float" is a misnomer. */
997 error ("Erroneous arithmetic operation.");
1000 /* Tell the event loop what to do if SIGWINCH is received.
1001 See event-signal.c. */
1002 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1004 handle_sigwinch (sig
)
1007 mark_async_signal_handler_wrapper (sigwinch_token
);
1008 signal (sig
, handle_sigwinch
);
1013 /* Called by do_setshow_command. */
1016 set_async_editing_command (args
, from_tty
, c
)
1019 struct cmd_list_element
*c
;
1021 change_line_handler ();
1024 /* Called by do_setshow_command. */
1027 set_async_annotation_level (args
, from_tty
, c
)
1030 struct cmd_list_element
*c
;
1032 change_annotation_level ();
1035 /* Called by do_setshow_command. */
1038 set_async_prompt (args
, from_tty
, c
)
1041 struct cmd_list_element
*c
;
1043 PROMPT (0) = savestring (new_async_prompt
, strlen (new_async_prompt
));
1046 /* Set things up for readline to be invoked via the alternate
1047 interface, i.e. via a callback function (rl_callback_read_char),
1048 and hook up instream to the event loop. */
1050 _initialize_event_loop ()
1054 /* When a character is detected on instream by select or poll,
1055 readline will be invoked via this callback function. */
1056 call_readline
= rl_callback_read_char
;
1058 /* When readline has read an end-of-line character, it passes
1059 the complete line to gdb for processing. command_line_handler
1060 is the function that does this. */
1061 input_handler
= command_line_handler
;
1063 /* Tell readline to use the same input stream that gdb uses. */
1064 rl_instream
= instream
;
1066 /* Get a file descriptor for the input stream, so that we can
1067 register it with the event loop. */
1068 input_fd
= fileno (instream
);
1070 /* Tell gdb to use the cli_command_loop as the main loop. */
1071 command_loop_hook
= cli_command_loop
;
1073 /* Now we need to create the event sources for the input file
1075 /* At this point in time, this is the only event source that we
1076 register with the even loop. Another source is going to be
1077 the target program (inferior), but that must be registered
1078 only when it actually exists (I.e. after we say 'run' or
1079 after we connect to a remote target. */
1080 add_file_handler (input_fd
, (file_handler_func
*) call_readline
, 0);
1082 /* Tell gdb that we will be using the readline library. This
1083 could be overwritten by a command in .gdbinit like 'set
1084 editing on' or 'off'. */
1085 async_command_editing_p
= 1;