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 ();
249 if (target_executing
&& sync_execution
)
251 /* This is to trick readline into not trying to display the
252 prompt. Even though we display the prompt using this
253 function, readline still tries to do its own display if we
254 don't call rl_callback_handler_install and
255 rl_callback_handler_remove (which readline detects because a
256 global variable is not set). If readline did that, it could
257 mess up gdb signal handlers for SIGINT. Readline assumes
258 that between calls to rl_set_signals and rl_clear_signals gdb
259 doesn't do anything with the signal handlers. Well, that's
260 not the case, because when the target executes we change the
261 SIGINT signal handler. If we allowed readline to display the
262 prompt, the signal handler change would happen exactly
263 between the calls to the above two functions.
264 Calling rl_callback_handler_remove(), does the job. */
266 rl_callback_handler_remove ();
272 /* Just use the top of the prompt stack. */
273 prompt_length
= strlen (PREFIX (0)) +
274 strlen (SUFFIX (0)) +
275 strlen (gdb_prompt
) + 1;
277 new_prompt
= (char *) alloca (prompt_length
);
279 /* Prefix needs to have new line at end. */
280 strcpy (new_prompt
, PREFIX (0));
281 strcat (new_prompt
, gdb_prompt
);
282 /* Suffix needs to have a new line at end and \032 \032 at
284 strcat (new_prompt
, SUFFIX (0));
287 if (async_command_editing_p
)
289 rl_callback_handler_remove ();
290 rl_callback_handler_install (new_prompt
, input_handler
);
292 /* new_prompt at this point can be the top of the stack or the one passed in */
295 /* Don't use a _filtered function here. It causes the assumed
296 character position to be off, since the newline we read from
297 the user is not accounted for. */
298 fputs_unfiltered (new_prompt
, gdb_stdout
);
301 /* Move to a new line so the entered line doesn't have a prompt
302 on the front of it. */
303 fputs_unfiltered ("\n", gdb_stdout
);
305 gdb_flush (gdb_stdout
);
309 /* Used when the user requests a different annotation level, with
310 'set annotate'. It pushes a new prompt (with prefix and suffix) on top
311 of the prompt stack, if the annotation level desired is 2, otherwise
312 it pops the top of the prompt stack when we want the annotation level
313 to be the normal ones (1 or 0). */
315 change_annotation_level ()
317 char *prefix
, *suffix
;
319 if (!PREFIX (0) || !PROMPT (0) || !SUFFIX (0))
321 /* The prompt stack has not been initialized to "", we are
322 using gdb w/o the --async switch */
323 warning ("Command has same effect as set annotate");
327 if (annotation_level
> 1)
329 if (!strcmp (PREFIX (0), "") && !strcmp (SUFFIX (0), ""))
331 /* Push a new prompt if the previous annotation_level was not >1. */
332 prefix
= (char *) alloca (strlen (async_annotation_suffix
) + 10);
333 strcpy (prefix
, "\n\032\032pre-");
334 strcat (prefix
, async_annotation_suffix
);
335 strcat (prefix
, "\n");
337 suffix
= (char *) alloca (strlen (async_annotation_suffix
) + 6);
338 strcpy (suffix
, "\n\032\032");
339 strcat (suffix
, async_annotation_suffix
);
340 strcat (suffix
, "\n");
342 push_prompt (prefix
, (char *) 0, suffix
);
347 if (strcmp (PREFIX (0), "") && strcmp (SUFFIX (0), ""))
349 /* Pop the top of the stack, we are going back to annotation < 1. */
355 /* Pushes a new prompt on the prompt stack. Each prompt has three
356 parts: prefix, prompt, suffix. Usually prefix and suffix are empty
357 strings, except when the annotation level is 2. Memory is allocated
358 within savestring for the new prompt. */
360 push_prompt (prefix
, prompt
, suffix
)
366 PREFIX (0) = savestring (prefix
, strlen (prefix
));
368 /* Note that this function is used by the set annotate 2
369 command. This is why we take care of saving the old prompt
370 in case a new one is not specified. */
372 PROMPT (0) = savestring (prompt
, strlen (prompt
));
374 PROMPT (0) = savestring (PROMPT (-1), strlen (PROMPT (-1)));
376 SUFFIX (0) = savestring (suffix
, strlen (suffix
));
379 /* Pops the top of the prompt stack, and frees the memory allocated for it. */
383 /* If we are not during a 'synchronous' execution command, in which
384 case, the top prompt would be empty. */
385 if (strcmp (PROMPT (0), ""))
386 /* This is for the case in which the prompt is set while the
387 annotation level is 2. The top prompt will be changed, but when
388 we return to annotation level < 2, we want that new prompt to be
389 in effect, until the user does another 'set prompt'. */
390 if (strcmp (PROMPT (0), PROMPT (-1)))
393 PROMPT (-1) = savestring (PROMPT (0), strlen (PROMPT (0)));
402 /* Handles a gdb command. This function is called by
403 command_line_handler, which has processed one or more input lines
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
407 switch to use the event loop at every execution of gdb. */
409 command_handler (command
)
412 struct cleanup
*old_chain
;
413 int stdin_is_tty
= ISATTY (stdin
);
414 struct continuation_arg
*arg1
;
415 struct continuation_arg
*arg2
;
416 long time_at_cmd_start
;
418 long space_at_cmd_start
= 0;
420 extern int display_time
;
421 extern int display_space
;
424 extern int insert_mode
;
428 if (instream
== stdin
&& stdin_is_tty
)
429 reinitialize_more_filter ();
430 old_chain
= make_cleanup ((make_cleanup_func
) command_loop_marker
, 0);
435 /* If readline returned a NULL command, it means that the
436 connection with the terminal is gone. This happens at the
437 end of a testsuite run, after Expect has hung up
438 but GDB is still alive. In such a case, we just quit gdb
439 killing the inferior program too. */
441 quit_command ((char *) 0, stdin
== instream
);
443 time_at_cmd_start
= get_run_time ();
448 extern char **environ
;
449 char *lim
= (char *) sbrk (0);
451 space_at_cmd_start
= (long) (lim
- (char *) &environ
);
455 execute_command (command
, instream
== stdin
);
457 /* Set things up for this function to be compete later, once the
458 executin has completed, if we are doing an execution command,
459 otherwise, just go ahead and finish. */
460 if (target_has_async
&& target_executing
)
463 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
465 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
468 arg1
->data
= (PTR
) time_at_cmd_start
;
469 arg2
->data
= (PTR
) space_at_cmd_start
;
470 add_continuation (command_line_handler_continuation
, arg1
);
473 /* Do any commands attached to breakpoint we stopped at. Only if we
474 are always running synchronously. Or if we have just executed a
475 command that doesn't start the target. */
476 if (!target_has_async
|| !target_executing
)
478 bpstat_do_actions (&stop_bpstat
);
479 do_cleanups (old_chain
);
483 long cmd_time
= get_run_time () - time_at_cmd_start
;
485 printf_unfiltered ("Command execution time: %ld.%06ld\n",
486 cmd_time
/ 1000000, cmd_time
% 1000000);
492 extern char **environ
;
493 char *lim
= (char *) sbrk (0);
494 long space_now
= lim
- (char *) &environ
;
495 long space_diff
= space_now
- space_at_cmd_start
;
497 printf_unfiltered ("Space used: %ld (%c%ld for this command)\n",
499 (space_diff
>= 0 ? '+' : '-'),
506 /* Do any commands attached to breakpoint we stopped at. Only if we
507 are always running synchronously. Or if we have just executed a
508 command that doesn't start the target. */
510 command_line_handler_continuation (arg
)
511 struct continuation_arg
*arg
;
513 extern int display_time
;
514 extern int display_space
;
516 long time_at_cmd_start
= (long) arg
->data
;
517 long space_at_cmd_start
= (long) arg
->next
->data
;
519 bpstat_do_actions (&stop_bpstat
);
520 /*do_cleanups (old_chain); *//*?????FIXME????? */
524 long cmd_time
= get_run_time () - time_at_cmd_start
;
526 printf_unfiltered ("Command execution time: %ld.%06ld\n",
527 cmd_time
/ 1000000, cmd_time
% 1000000);
532 extern char **environ
;
533 char *lim
= (char *) sbrk (0);
534 long space_now
= lim
- (char *) &environ
;
535 long space_diff
= space_now
- space_at_cmd_start
;
537 printf_unfiltered ("Space used: %ld (%c%ld for this command)\n",
539 (space_diff
>= 0 ? '+' : '-'),
545 /* Handle a complete line of input. This is called by the callback
546 mechanism within the readline library. Deal with incomplete commands
547 as well, by saving the partial input in a global buffer. */
549 /* NOTE: 1999-04-30 This is the asynchronous version of the
550 command_line_input function. command_line_input will become
551 obsolete once we use the event loop as the default mechanism in
554 command_line_handler (rl
)
557 static char *linebuffer
= 0;
558 static unsigned linelength
= 0;
567 int repeat
= (instream
== stdin
);
569 if (annotation_level
> 1 && instream
== stdin
)
571 printf_unfiltered ("\n\032\032post-");
572 printf_unfiltered (async_annotation_suffix
);
573 printf_unfiltered ("\n");
579 linebuffer
= (char *) xmalloc (linelength
);
586 strcpy (linebuffer
, readline_input_state
.linebuffer
);
587 p
= readline_input_state
.linebuffer_ptr
;
588 free (readline_input_state
.linebuffer
);
595 signal (STOP_SIGNAL
, handle_stop_sig
);
598 /* Make sure that all output has been output. Some machines may let
599 you get away with leaving out some of the gdb_flush, but not all. */
601 gdb_flush (gdb_stdout
);
602 gdb_flush (gdb_stderr
);
604 if (source_file_name
!= NULL
)
606 ++source_line_number
;
607 sprintf (source_error
,
608 "%s%s:%d: Error in sourced command file:\n",
612 error_pre_print
= source_error
;
615 /* If we are in this case, then command_handler will call quit
616 and exit from gdb. */
617 if (!rl
|| rl
== (char *) EOF
)
622 if (strlen (rl
) + 1 + (p
- linebuffer
) > linelength
)
624 linelength
= strlen (rl
) + 1 + (p
- linebuffer
);
625 nline
= (char *) xrealloc (linebuffer
, linelength
);
626 p
+= nline
- linebuffer
;
630 /* Copy line. Don't copy null at end. (Leaves line alone
631 if this was just a newline) */
635 free (rl
); /* Allocated in readline. */
637 if (*(p
- 1) == '\\')
639 p
--; /* Put on top of '\'. */
643 readline_input_state
.linebuffer
= savestring (linebuffer
,
644 strlen (linebuffer
));
645 readline_input_state
.linebuffer_ptr
= p
;
647 /* We will not invoke a execute_command if there is more
648 input expected to complete the command. So, we need to
649 print an empty prompt here. */
651 push_prompt ("", "", "");
652 display_gdb_prompt (0);
659 signal (STOP_SIGNAL
, SIG_DFL
);
662 #define SERVER_COMMAND_LENGTH 7
664 (p
- linebuffer
> SERVER_COMMAND_LENGTH
)
665 && STREQN (linebuffer
, "server ", SERVER_COMMAND_LENGTH
);
668 /* Note that we don't set `line'. Between this and the check in
669 dont_repeat, this insures that repeating will still do the
672 command_handler (linebuffer
+ SERVER_COMMAND_LENGTH
);
673 display_gdb_prompt (0);
677 /* Do history expansion if that is wished. */
678 if (history_expansion_p
&& instream
== stdin
679 && ISATTY (instream
))
684 *p
= '\0'; /* Insert null now. */
685 expanded
= history_expand (linebuffer
, &history_value
);
688 /* Print the changes. */
689 printf_unfiltered ("%s\n", history_value
);
691 /* If there was an error, call this function again. */
694 free (history_value
);
697 if (strlen (history_value
) > linelength
)
699 linelength
= strlen (history_value
) + 1;
700 linebuffer
= (char *) xrealloc (linebuffer
, linelength
);
702 strcpy (linebuffer
, history_value
);
703 p
= linebuffer
+ strlen (linebuffer
);
704 free (history_value
);
708 /* If we just got an empty line, and that is supposed
709 to repeat the previous command, return the value in the
711 if (repeat
&& p
== linebuffer
&& *p
!= '\\')
713 command_handler (line
);
714 display_gdb_prompt (0);
718 for (p1
= linebuffer
; *p1
== ' ' || *p1
== '\t'; p1
++);
721 command_handler (line
);
722 display_gdb_prompt (0);
728 /* Add line to history if appropriate. */
729 if (instream
== stdin
730 && ISATTY (stdin
) && *linebuffer
)
731 add_history (linebuffer
);
733 /* Note: lines consisting solely of comments are added to the command
734 history. This is useful when you type a command, and then
735 realize you don't want to execute it quite yet. You can comment
736 out the command and then later fetch it from the value history
737 and remove the '#'. The kill ring is probably better, but some
738 people are in the habit of commenting things out. */
740 *p1
= '\0'; /* Found a comment. */
742 /* Save into global buffer if appropriate. */
745 if (linelength
> linesize
)
747 line
= xrealloc (line
, linelength
);
748 linesize
= linelength
;
750 strcpy (line
, linebuffer
);
753 command_handler (line
);
754 display_gdb_prompt (0);
759 command_handler (linebuffer
);
760 display_gdb_prompt (0);
764 /* Does reading of input from terminal w/o the editing features
765 provided by the readline library. */
767 /* NOTE: 1999-04-30 Asynchronous version of gdb_readline. gdb_readline
768 will become obsolete when the event loop is made the default
769 execution for gdb. */
776 int result_size
= 80;
778 result
= (char *) xmalloc (result_size
);
780 /* We still need the while loop here, even though it would seem
781 obvious to invoke gdb_readline2 at every character entered. If
782 not using the readline library, the terminal is in cooked mode,
783 which sends the characters all at once. Poll will notice that the
784 input fd has changed state only after enter is pressed. At this
785 point we still need to fetch all the chars entered. */
789 /* Read from stdin if we are executing a user defined command.
790 This is the right thing for prompt_for_continue, at least. */
791 c
= fgetc (instream
? instream
: stdin
);
796 /* The last line does not end with a newline. Return it, and
797 if we are called again fgetc will still return EOF and
798 we'll return NULL then. */
801 (*input_handler
) (0);
805 #ifndef CRLF_SOURCE_FILES
809 if (input_index
> 0 && result
[input_index
- 1] == '\r')
815 result
[input_index
++] = c
;
816 while (input_index
>= result_size
)
819 result
= (char *) xrealloc (result
, result_size
);
823 result
[input_index
++] = '\0';
824 (*input_handler
) (result
);
828 /* Initialization of signal handlers and tokens. There is a function
829 handle_sig* for each of the signals GDB cares about. Specifically:
830 SIGINT, SIGFPE, SIGQUIT, SIGTSTP, SIGHUP, SIGWINCH. These
831 functions are the actual signal handlers associated to the signals
832 via calls to signal(). The only job for these functions is to
833 enqueue the appropriate event/procedure with the event loop. Such
834 procedures are the old signal handlers. The event loop will take
835 care of invoking the queued procedures to perform the usual tasks
836 associated with the reception of the signal. */
837 /* NOTE: 1999-04-30 This is the asynchronous version of init_signals.
838 init_signals will become obsolete as we move to have to event loop
839 as the default for gdb. */
841 async_init_signals ()
843 signal (SIGINT
, handle_sigint
);
845 create_async_signal_handler (async_request_quit
, NULL
);
847 /* If SIGTRAP was set to SIG_IGN, then the SIG_IGN will get passed
848 to the inferior and breakpoints will be ignored. */
850 signal (SIGTRAP
, SIG_DFL
);
853 /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get
854 passed to the inferior, which we don't want. It would be
855 possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but
856 on BSD4.3 systems using vfork, that can affect the
857 GDB process as well as the inferior (the signal handling tables
858 might be in memory, shared between the two). Since we establish
859 a handler for SIGQUIT, when we call exec it will set the signal
860 to SIG_DFL for us. */
861 signal (SIGQUIT
, handle_sigquit
);
863 create_async_signal_handler (async_do_nothing
, NULL
);
865 if (signal (SIGHUP
, handle_sighup
) != SIG_IGN
)
867 create_async_signal_handler (async_disconnect
, NULL
);
870 create_async_signal_handler (async_do_nothing
, NULL
);
872 signal (SIGFPE
, handle_sigfpe
);
874 create_async_signal_handler (async_float_handler
, NULL
);
876 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
877 signal (SIGWINCH
, handle_sigwinch
);
879 create_async_signal_handler (SIGWINCH_HANDLER
, NULL
);
883 create_async_signal_handler (async_stop_sig
, NULL
);
889 mark_async_signal_handler_wrapper (token
)
892 mark_async_signal_handler ((async_signal_handler
*) token
);
895 /* Tell the event loop what to do if SIGINT is received.
896 See event-signal.c. */
901 signal (sig
, handle_sigint
);
903 /* If immediate_quit is set, we go ahead and process the SIGINT right
904 away, even if we usually would defer this to the event loop. The
905 assumption here is that it is safe to process ^C immediately if
906 immediate_quit is set. If we didn't, SIGINT would be really
907 processed only the next time through the event loop. To get to
908 that point, though, the command that we want to interrupt needs to
909 finish first, which is unacceptable. */
911 async_request_quit (0);
913 /* If immediate quit is not set, we process SIGINT the next time
914 through the loop, which is fine. */
915 mark_async_signal_handler_wrapper (sigint_token
);
918 /* Do the quit. All the checks have been done by the caller. */
920 async_request_quit (arg
)
931 /* Tell the event loop what to do if SIGQUIT is received.
932 See event-signal.c. */
937 mark_async_signal_handler_wrapper (sigquit_token
);
938 signal (sig
, handle_sigquit
);
941 /* Called by the event loop in response to a SIGQUIT. */
943 async_do_nothing (arg
)
946 /* Empty function body. */
950 /* Tell the event loop what to do if SIGHUP is received.
951 See event-signal.c. */
956 mark_async_signal_handler_wrapper (sighup_token
);
957 signal (sig
, handle_sighup
);
960 /* Called by the event loop to process a SIGHUP */
962 async_disconnect (arg
)
965 catch_errors (quit_cover
, NULL
,
966 "Could not kill the program being debugged",
968 signal (SIGHUP
, SIG_DFL
); /*FIXME: ??????????? */
969 kill (getpid (), SIGHUP
);
975 handle_stop_sig (sig
)
978 mark_async_signal_handler_wrapper (sigtstp_token
);
979 signal (sig
, handle_stop_sig
);
986 char *prompt
= get_prompt ();
987 #if STOP_SIGNAL == SIGTSTP
988 signal (SIGTSTP
, SIG_DFL
);
990 kill (getpid (), SIGTSTP
);
991 signal (SIGTSTP
, handle_stop_sig
);
993 signal (STOP_SIGNAL
, handle_stop_sig
);
995 printf_unfiltered ("%s", prompt
);
996 gdb_flush (gdb_stdout
);
998 /* Forget about any previous command -- null line now will do nothing. */
1001 #endif /* STOP_SIGNAL */
1003 /* Tell the event loop what to do if SIGFPE is received.
1004 See event-signal.c. */
1009 mark_async_signal_handler_wrapper (sigfpe_token
);
1010 signal (sig
, handle_sigfpe
);
1013 /* Event loop will call this functin to process a SIGFPE. */
1015 async_float_handler (arg
)
1016 gdb_client_data arg
;
1018 /* This message is based on ANSI C, section 4.7. Note that integer
1019 divide by zero causes this, so "float" is a misnomer. */
1020 error ("Erroneous arithmetic operation.");
1023 /* Tell the event loop what to do if SIGWINCH is received.
1024 See event-signal.c. */
1025 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1027 handle_sigwinch (sig
)
1030 mark_async_signal_handler_wrapper (sigwinch_token
);
1031 signal (sig
, handle_sigwinch
);
1036 /* Called by do_setshow_command. */
1039 set_async_editing_command (args
, from_tty
, c
)
1042 struct cmd_list_element
*c
;
1044 change_line_handler ();
1047 /* Called by do_setshow_command. */
1050 set_async_annotation_level (args
, from_tty
, c
)
1053 struct cmd_list_element
*c
;
1055 change_annotation_level ();
1058 /* Called by do_setshow_command. */
1061 set_async_prompt (args
, from_tty
, c
)
1064 struct cmd_list_element
*c
;
1066 PROMPT (0) = savestring (new_async_prompt
, strlen (new_async_prompt
));
1069 /* Set things up for readline to be invoked via the alternate
1070 interface, i.e. via a callback function (rl_callback_read_char),
1071 and hook up instream to the event loop. */
1073 _initialize_event_loop ()
1077 /* When a character is detected on instream by select or poll,
1078 readline will be invoked via this callback function. */
1079 call_readline
= rl_callback_read_char
;
1081 /* When readline has read an end-of-line character, it passes
1082 the complete line to gdb for processing. command_line_handler
1083 is the function that does this. */
1084 input_handler
= command_line_handler
;
1086 /* Tell readline to use the same input stream that gdb uses. */
1087 rl_instream
= instream
;
1089 /* Get a file descriptor for the input stream, so that we can
1090 register it with the event loop. */
1091 input_fd
= fileno (instream
);
1093 /* Tell gdb to use the cli_command_loop as the main loop. */
1094 command_loop_hook
= cli_command_loop
;
1096 /* Now we need to create the event sources for the input file
1098 /* At this point in time, this is the only event source that we
1099 register with the even loop. Another source is going to be
1100 the target program (inferior), but that must be registered
1101 only when it actually exists (I.e. after we say 'run' or
1102 after we connect to a remote target. */
1103 add_file_handler (input_fd
, (file_handler_func
*) call_readline
, 0);
1105 /* Tell gdb that we will be using the readline library. This
1106 could be overwritten by a command in .gdbinit like 'set
1107 editing on' or 'off'. */
1108 async_command_editing_p
= 1;