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
== linebuffer
|| *(p
- 1) == '\\')
639 /* We come here also if the line entered is empty (just a 'return') */
640 p
--; /* Put on top of '\'. */
644 readline_input_state
.linebuffer
= savestring (linebuffer
,
645 strlen (linebuffer
));
646 readline_input_state
.linebuffer_ptr
= p
;
648 /* We will not invoke a execute_command if there is more
649 input expected to complete the command. So, we need to
650 print an empty prompt here. */
652 push_prompt ("", "", "");
653 display_gdb_prompt (0);
660 signal (STOP_SIGNAL
, SIG_DFL
);
663 #define SERVER_COMMAND_LENGTH 7
665 (p
- linebuffer
> SERVER_COMMAND_LENGTH
)
666 && STREQN (linebuffer
, "server ", SERVER_COMMAND_LENGTH
);
669 /* Note that we don't set `line'. Between this and the check in
670 dont_repeat, this insures that repeating will still do the
673 command_handler (linebuffer
+ SERVER_COMMAND_LENGTH
);
674 display_gdb_prompt (0);
678 /* Do history expansion if that is wished. */
679 if (history_expansion_p
&& instream
== stdin
680 && ISATTY (instream
))
685 *p
= '\0'; /* Insert null now. */
686 expanded
= history_expand (linebuffer
, &history_value
);
689 /* Print the changes. */
690 printf_unfiltered ("%s\n", history_value
);
692 /* If there was an error, call this function again. */
695 free (history_value
);
698 if (strlen (history_value
) > linelength
)
700 linelength
= strlen (history_value
) + 1;
701 linebuffer
= (char *) xrealloc (linebuffer
, linelength
);
703 strcpy (linebuffer
, history_value
);
704 p
= linebuffer
+ strlen (linebuffer
);
705 free (history_value
);
709 /* If we just got an empty line, and that is supposed
710 to repeat the previous command, return the value in the
712 if (repeat
&& p
== linebuffer
&& *p
!= '\\')
714 command_handler (line
);
715 display_gdb_prompt (0);
719 for (p1
= linebuffer
; *p1
== ' ' || *p1
== '\t'; p1
++);
722 command_handler (line
);
723 display_gdb_prompt (0);
729 /* Add line to history if appropriate. */
730 if (instream
== stdin
731 && ISATTY (stdin
) && *linebuffer
)
732 add_history (linebuffer
);
734 /* Note: lines consisting solely of comments are added to the command
735 history. This is useful when you type a command, and then
736 realize you don't want to execute it quite yet. You can comment
737 out the command and then later fetch it from the value history
738 and remove the '#'. The kill ring is probably better, but some
739 people are in the habit of commenting things out. */
741 *p1
= '\0'; /* Found a comment. */
743 /* Save into global buffer if appropriate. */
746 if (linelength
> linesize
)
748 line
= xrealloc (line
, linelength
);
749 linesize
= linelength
;
751 strcpy (line
, linebuffer
);
754 command_handler (line
);
755 display_gdb_prompt (0);
760 command_handler (linebuffer
);
761 display_gdb_prompt (0);
765 /* Does reading of input from terminal w/o the editing features
766 provided by the readline library. */
768 /* NOTE: 1999-04-30 Asynchronous version of gdb_readline. gdb_readline
769 will become obsolete when the event loop is made the default
770 execution for gdb. */
777 int result_size
= 80;
779 result
= (char *) xmalloc (result_size
);
781 /* We still need the while loop here, even though it would seem
782 obvious to invoke gdb_readline2 at every character entered. If
783 not using the readline library, the terminal is in cooked mode,
784 which sends the characters all at once. Poll will notice that the
785 input fd has changed state only after enter is pressed. At this
786 point we still need to fetch all the chars entered. */
790 /* Read from stdin if we are executing a user defined command.
791 This is the right thing for prompt_for_continue, at least. */
792 c
= fgetc (instream
? instream
: stdin
);
797 /* The last line does not end with a newline. Return it, and
798 if we are called again fgetc will still return EOF and
799 we'll return NULL then. */
802 (*input_handler
) (0);
806 #ifndef CRLF_SOURCE_FILES
810 if (input_index
> 0 && result
[input_index
- 1] == '\r')
816 result
[input_index
++] = c
;
817 while (input_index
>= result_size
)
820 result
= (char *) xrealloc (result
, result_size
);
824 result
[input_index
++] = '\0';
825 (*input_handler
) (result
);
829 /* Initialization of signal handlers and tokens. There is a function
830 handle_sig* for each of the signals GDB cares about. Specifically:
831 SIGINT, SIGFPE, SIGQUIT, SIGTSTP, SIGHUP, SIGWINCH. These
832 functions are the actual signal handlers associated to the signals
833 via calls to signal(). The only job for these functions is to
834 enqueue the appropriate event/procedure with the event loop. Such
835 procedures are the old signal handlers. The event loop will take
836 care of invoking the queued procedures to perform the usual tasks
837 associated with the reception of the signal. */
838 /* NOTE: 1999-04-30 This is the asynchronous version of init_signals.
839 init_signals will become obsolete as we move to have to event loop
840 as the default for gdb. */
842 async_init_signals ()
844 signal (SIGINT
, handle_sigint
);
846 create_async_signal_handler (async_request_quit
, NULL
);
848 /* If SIGTRAP was set to SIG_IGN, then the SIG_IGN will get passed
849 to the inferior and breakpoints will be ignored. */
851 signal (SIGTRAP
, SIG_DFL
);
854 /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get
855 passed to the inferior, which we don't want. It would be
856 possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but
857 on BSD4.3 systems using vfork, that can affect the
858 GDB process as well as the inferior (the signal handling tables
859 might be in memory, shared between the two). Since we establish
860 a handler for SIGQUIT, when we call exec it will set the signal
861 to SIG_DFL for us. */
862 signal (SIGQUIT
, handle_sigquit
);
864 create_async_signal_handler (async_do_nothing
, NULL
);
866 if (signal (SIGHUP
, handle_sighup
) != SIG_IGN
)
868 create_async_signal_handler (async_disconnect
, NULL
);
871 create_async_signal_handler (async_do_nothing
, NULL
);
873 signal (SIGFPE
, handle_sigfpe
);
875 create_async_signal_handler (async_float_handler
, NULL
);
877 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
878 signal (SIGWINCH
, handle_sigwinch
);
880 create_async_signal_handler (SIGWINCH_HANDLER
, NULL
);
884 create_async_signal_handler (async_stop_sig
, NULL
);
890 mark_async_signal_handler_wrapper (token
)
893 mark_async_signal_handler ((async_signal_handler
*) token
);
896 /* Tell the event loop what to do if SIGINT is received.
897 See event-signal.c. */
902 signal (sig
, handle_sigint
);
904 /* If immediate_quit is set, we go ahead and process the SIGINT right
905 away, even if we usually would defer this to the event loop. The
906 assumption here is that it is safe to process ^C immediately if
907 immediate_quit is set. If we didn't, SIGINT would be really
908 processed only the next time through the event loop. To get to
909 that point, though, the command that we want to interrupt needs to
910 finish first, which is unacceptable. */
912 async_request_quit (0);
914 /* If immediate quit is not set, we process SIGINT the next time
915 through the loop, which is fine. */
916 mark_async_signal_handler_wrapper (sigint_token
);
919 /* Do the quit. All the checks have been done by the caller. */
921 async_request_quit (arg
)
932 /* Tell the event loop what to do if SIGQUIT is received.
933 See event-signal.c. */
938 mark_async_signal_handler_wrapper (sigquit_token
);
939 signal (sig
, handle_sigquit
);
942 /* Called by the event loop in response to a SIGQUIT. */
944 async_do_nothing (arg
)
947 /* Empty function body. */
951 /* Tell the event loop what to do if SIGHUP is received.
952 See event-signal.c. */
957 mark_async_signal_handler_wrapper (sighup_token
);
958 signal (sig
, handle_sighup
);
961 /* Called by the event loop to process a SIGHUP */
963 async_disconnect (arg
)
966 catch_errors (quit_cover
, NULL
,
967 "Could not kill the program being debugged",
969 signal (SIGHUP
, SIG_DFL
); /*FIXME: ??????????? */
970 kill (getpid (), SIGHUP
);
976 handle_stop_sig (sig
)
979 mark_async_signal_handler_wrapper (sigtstp_token
);
980 signal (sig
, handle_stop_sig
);
987 char *prompt
= get_prompt ();
988 #if STOP_SIGNAL == SIGTSTP
989 signal (SIGTSTP
, SIG_DFL
);
991 kill (getpid (), SIGTSTP
);
992 signal (SIGTSTP
, handle_stop_sig
);
994 signal (STOP_SIGNAL
, handle_stop_sig
);
996 printf_unfiltered ("%s", prompt
);
997 gdb_flush (gdb_stdout
);
999 /* Forget about any previous command -- null line now will do nothing. */
1002 #endif /* STOP_SIGNAL */
1004 /* Tell the event loop what to do if SIGFPE is received.
1005 See event-signal.c. */
1010 mark_async_signal_handler_wrapper (sigfpe_token
);
1011 signal (sig
, handle_sigfpe
);
1014 /* Event loop will call this functin to process a SIGFPE. */
1016 async_float_handler (arg
)
1017 gdb_client_data arg
;
1019 /* This message is based on ANSI C, section 4.7. Note that integer
1020 divide by zero causes this, so "float" is a misnomer. */
1021 error ("Erroneous arithmetic operation.");
1024 /* Tell the event loop what to do if SIGWINCH is received.
1025 See event-signal.c. */
1026 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1028 handle_sigwinch (sig
)
1031 mark_async_signal_handler_wrapper (sigwinch_token
);
1032 signal (sig
, handle_sigwinch
);
1037 /* Called by do_setshow_command. */
1040 set_async_editing_command (args
, from_tty
, c
)
1043 struct cmd_list_element
*c
;
1045 change_line_handler ();
1048 /* Called by do_setshow_command. */
1051 set_async_annotation_level (args
, from_tty
, c
)
1054 struct cmd_list_element
*c
;
1056 change_annotation_level ();
1059 /* Called by do_setshow_command. */
1062 set_async_prompt (args
, from_tty
, c
)
1065 struct cmd_list_element
*c
;
1067 PROMPT (0) = savestring (new_async_prompt
, strlen (new_async_prompt
));
1070 /* Set things up for readline to be invoked via the alternate
1071 interface, i.e. via a callback function (rl_callback_read_char),
1072 and hook up instream to the event loop. */
1074 _initialize_event_loop ()
1078 /* When a character is detected on instream by select or poll,
1079 readline will be invoked via this callback function. */
1080 call_readline
= rl_callback_read_char
;
1082 /* When readline has read an end-of-line character, it passes
1083 the complete line to gdb for processing. command_line_handler
1084 is the function that does this. */
1085 input_handler
= command_line_handler
;
1087 /* Tell readline to use the same input stream that gdb uses. */
1088 rl_instream
= instream
;
1090 /* Get a file descriptor for the input stream, so that we can
1091 register it with the event loop. */
1092 input_fd
= fileno (instream
);
1094 /* Tell gdb to use the cli_command_loop as the main loop. */
1095 command_loop_hook
= cli_command_loop
;
1097 /* Now we need to create the event sources for the input file
1099 /* At this point in time, this is the only event source that we
1100 register with the even loop. Another source is going to be
1101 the target program (inferior), but that must be registered
1102 only when it actually exists (I.e. after we say 'run' or
1103 after we connect to a remote target. */
1104 add_file_handler (input_fd
, (file_handler_func
*) call_readline
, 0);
1106 /* Tell gdb that we will be using the readline library. This
1107 could be overwritten by a command in .gdbinit like 'set
1108 editing on' or 'off'. */
1109 async_command_editing_p
= 1;