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, Boston, MA 02111-1307, USA. */
24 #include "terminal.h" /* for job_control*/
26 #include "event-loop.h"
28 /* readline include files */
29 #include <readline/readline.h>
30 #include <readline/history.h>
32 /* readline defines this. */
35 extern void _initialize_event_loop
PARAMS ((void));
37 static void command_line_handler
PARAMS ((char *));
38 void gdb_readline2
PARAMS ((void));
39 static void pop_prompt
PARAMS ((void));
40 static void push_prompt
PARAMS ((char *, char *, char *));
41 static void change_line_handler
PARAMS ((void));
42 static void change_annotation_level
PARAMS ((void));
43 static void command_handler
PARAMS ((char *));
45 /* Signal handlers. */
46 static void handle_sigint
PARAMS ((int));
47 static void handle_sigquit
PARAMS ((int));
48 static void handle_sighup
PARAMS ((int));
49 static void handle_sigfpe
PARAMS ((int));
50 static void handle_sigwinch
PARAMS ((int));
51 /* Signal to catch ^Z typed while reading a command: SIGTSTP or SIGCONT. */
54 #define STOP_SIGNAL SIGTSTP
55 void handle_stop_sig
PARAMS ((int));
59 /* Functions to be invoked by the event loop in response to
61 void async_request_quit
PARAMS ((gdb_client_data
));
62 static void async_do_nothing
PARAMS ((gdb_client_data
));
63 static void async_disconnect
PARAMS ((gdb_client_data
));
64 static void async_float_handler
PARAMS ((gdb_client_data
));
65 static void async_stop_sig
PARAMS ((gdb_client_data
));
67 /* If this definition isn't overridden by the header files, assume
68 that isatty and fileno exist on this system. */
70 #define ISATTY(FP) (isatty (fileno (FP)))
73 /* Readline offers an alternate interface, via callback
74 functions. These are all included in the file callback.c in the
75 readline distribution. This file provides (mainly) a function, which
76 the event loop uses as callback (i.e. event handler) whenever an event
77 is detected on the standard input file descriptor.
78 readline_callback_read_char is called (by the GDB event loop) whenever
79 there is a new character ready on the input stream. This function
80 incrementally builds a buffer internal to readline where it
81 accumulates the line read up to the point of invocation. In the
82 special case in which the character read is newline, the function
83 invokes a GDB supplied callback routine, which does the processing of
84 a full command line. This latter routine is the asynchronous analog
85 of the old command_line_input in gdb. Instead of invoking (and waiting
86 for) readline to read the command line and pass it back to
87 command_loop for processing, the new command_line_handler function has
88 the command line already available as its parameter. INPUT_HANDLER is
89 to be set to the function that readline will invoke when a complete
90 line of input is ready. CALL_READLINE is to be set to the function
91 that readline offers as callback to the event_loop. */
93 void (*input_handler
) PARAMS ((char *));
94 void (*call_readline
) PARAMS ((void));
96 /* Important variables for the event loop. */
98 /* This is used to determine if GDB is using the readline library or
99 its own simplified form of readline. It is used by the asynchronous
100 form of the set editing command.
101 ezannoni: as of 1999-04-29 I expect that this
102 variable will not be used after gdb is changed to use the event
103 loop as default engine, and event-top.c is merged into top.c. */
104 int async_command_editing_p
;
106 /* This variable contains the new prompt that the user sets with the
107 set prompt command. */
108 char *new_async_prompt
;
110 /* This is the annotation suffix that will be used when the
111 annotation_level is 2. */
112 char *async_annotation_suffix
;
114 /* This is the file descriptor for the input stream that GDB uses to
115 read commands from. */
118 /* This is the prompt stack. Prompts will be pushed on the stack as
119 needed by the different 'kinds' of user inputs GDB is asking
120 for. See event-loop.h. */
121 struct prompts the_prompts
;
123 /* signal handling variables */
124 /* Each of these is a pointer to a function that the event loop will
125 invoke if the corresponding signal has received. The real signal
126 handlers mark these functions as ready to be executed and the event
127 loop, in a later iteration, calls them. See the function
128 invoke_async_signal_handler. */
135 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
142 void mark_async_signal_handler_wrapper
PARAMS ((void *));
144 /* Structure to save a partially entered command. This is used when
145 the user types '\' at the end of a command line. This is necessary
146 because each line of input is handled by a different call to
147 command_line_handler, and normally there is no state retained
148 between different calls. */
149 int more_to_come
= 0;
151 struct readline_input_state
154 char *linebuffer_ptr
;
156 readline_input_state
;
159 /* Initialize all the necessary variables, start the event loop,
160 register readline, and stdin, start the loop. */
166 char *gdb_prompt
= get_prompt ();
168 /* If we are using readline, set things up and display the first
169 prompt, otherwise just print the prompt. */
170 if (async_command_editing_p
)
172 /* Tell readline what the prompt to display is and what function it
173 will need to call after a whole line is read. This also displays
175 length
= strlen (PREFIX (0)) + strlen (gdb_prompt
) + strlen (SUFFIX (0)) + 1;
176 a_prompt
= (char *) xmalloc (length
);
177 strcpy (a_prompt
, PREFIX (0));
178 strcat (a_prompt
, gdb_prompt
);
179 strcat (a_prompt
, SUFFIX (0));
180 rl_callback_handler_install (a_prompt
, input_handler
);
183 display_gdb_prompt (0);
185 /* Now it's time to start the event loop. */
189 /* Change the function to be invoked every time there is a character
190 ready on stdin. This is used when the user sets the editing off,
191 therefore bypassing readline, and letting gdb handle the input
192 itself, via gdb_readline2. Also it is used in the opposite case in
193 which the user sets editing on again, by restoring readline
194 handling of the input. */
196 change_line_handler ()
198 if (async_command_editing_p
)
200 /* Turn on editing by using readline. */
201 call_readline
= rl_callback_read_char
;
202 input_handler
= command_line_handler
;
206 /* Turn off editing by using gdb_readline2. */
207 rl_callback_handler_remove ();
208 call_readline
= gdb_readline2
;
210 /* Set up the command handler as well, in case we are called as
211 first thing from .gdbinit. */
212 input_handler
= command_line_handler
;
215 /* To tell the event loop to change the handler associated with the
216 input file descriptor, we need to create a new event source,
217 corresponding to the same fd, but with a new event handler
219 /* NOTE: this operates on input_fd, not instream. If we are reading
220 commands from a file, instream will point to the file. However in
221 async mode, we always read commands from a file with editing
222 off. This means that the 'set editing on/off' will have effect
223 only on the interactive session. */
224 delete_file_handler (input_fd
);
225 add_file_handler (input_fd
, (file_handler_func
*) call_readline
, 0);
228 /* Displays the prompt. The prompt that is displayed is the current
229 top of the prompt stack, if the argument NEW_PROMPT is
230 0. Otherwise, it displays whatever NEW_PROMPT is. This is used
231 after each gdb command has completed, and in the following cases:
232 1. when the user enters a command line which is ended by '\'
233 indicating that the command will continue on the next line.
234 In that case the prompt that is displayed is the empty string.
235 2. When the user is entering 'commands' for a breakpoint, or
236 actions for a tracepoint. In this case the prompt will be '>'
238 FIXME: 2. & 3. not implemented yet for async. */
240 display_gdb_prompt (new_prompt
)
243 int prompt_length
= 0;
244 char *gdb_prompt
= get_prompt ();
248 /* Just use the top of the prompt stack. */
249 prompt_length
= strlen (PREFIX (0)) +
250 strlen (SUFFIX (0)) +
251 strlen (gdb_prompt
) + 1;
253 new_prompt
= (char *) alloca (prompt_length
);
255 /* Prefix needs to have new line at end. */
256 strcpy (new_prompt
, PREFIX (0));
257 strcat (new_prompt
, gdb_prompt
);
258 /* Suffix needs to have a new line at end and \032 \032 at
260 strcat (new_prompt
, SUFFIX (0));
263 if (async_command_editing_p
)
265 rl_callback_handler_remove ();
266 rl_callback_handler_install (new_prompt
, input_handler
);
270 /* Don't use a _filtered function here. It causes the assumed
271 character position to be off, since the newline we read from
272 the user is not accounted for. */
273 fputs_unfiltered (new_prompt
, gdb_stdout
);
276 /* Move to a new line so the entered line doesn't have a prompt
277 on the front of it. */
278 fputs_unfiltered ("\n", gdb_stdout
);
280 gdb_flush (gdb_stdout
);
284 /* Used when the user requests a different annotation level, with
285 'set annotate'. It pushes a new prompt (with prefix and suffix) on top
286 of the prompt stack, if the annotation level desired is 2, otherwise
287 it pops the top of the prompt stack when we want the annotation level
288 to be the normal ones (1 or 2). */
290 change_annotation_level ()
292 char *prefix
, *suffix
;
294 if (!PREFIX (0) || !PROMPT (0) || !SUFFIX (0))
296 /* The prompt stack has not been initialized to "", we are
297 using gdb w/o the --async switch */
298 warning ("Command has same effect as set annotate");
302 if (annotation_level
> 1)
304 if (!strcmp (PREFIX (0), "") && !strcmp (SUFFIX (0), ""))
306 /* Push a new prompt if the previous annotation_level was not >1. */
307 prefix
= (char *) alloca (strlen (async_annotation_suffix
) + 10);
308 strcpy (prefix
, "\n\032\032pre-");
309 strcat (prefix
, async_annotation_suffix
);
310 strcat (prefix
, "\n");
312 suffix
= (char *) alloca (strlen (async_annotation_suffix
) + 6);
313 strcpy (suffix
, "\n\032\032");
314 strcat (suffix
, async_annotation_suffix
);
315 strcat (suffix
, "\n");
317 push_prompt (prefix
, (char *) 0, suffix
);
322 if (strcmp (PREFIX (0), "") && strcmp (SUFFIX (0), ""))
324 /* Pop the top of the stack, we are going back to annotation < 1. */
330 /* Pushes a new prompt on the prompt stack. Each prompt has three
331 parts: prefix, prompt, suffix. Usually prefix and suffix are empty
332 strings, except when the annotation level is 2. Memory is allocated
333 within savestring for the new prompt. */
335 push_prompt (prefix
, prompt
, suffix
)
341 PREFIX (0) = savestring (prefix
, strlen (prefix
));
344 PROMPT (0) = savestring (prompt
, strlen (prompt
));
346 PROMPT (0) = savestring (PROMPT (-1), strlen (PROMPT (-1)));
348 SUFFIX (0) = savestring (suffix
, strlen (suffix
));
351 /* Pops the top of the prompt stack, and frees the memory allocated for it. */
355 if (strcmp (PROMPT (0), PROMPT (-1)))
358 PROMPT (-1) = savestring (PROMPT (0), strlen (PROMPT (0)));
367 /* Handles a gdb command. This function is called by
368 command_line_handler, which has processed one or more input lines
370 /* NOTE: 1999-04-30 This is the asynchronous version of the command_loop
371 function. The command_loop function will be obsolete when we
372 switch to use the event loop at every execution of gdb. */
374 command_handler (command
)
377 struct cleanup
*old_chain
;
378 int stdin_is_tty
= ISATTY (stdin
);
379 long time_at_cmd_start
;
381 long space_at_cmd_start
= 0;
383 extern int display_time
;
384 extern int display_space
;
387 extern int insert_mode
;
391 if (instream
== stdin
&& stdin_is_tty
)
392 reinitialize_more_filter ();
393 old_chain
= make_cleanup ((make_cleanup_func
) command_loop_marker
, 0);
398 /* If readline returned a NULL command, it means that the
399 connection with the terminal is gone. This happens at the
400 end of a testsuite run, after Expect has hung up
401 but GDB is still alive. In such a case, we just quit gdb
402 killing the inferior program too. */
404 quit_command ((char *) 0, stdin
== instream
);
406 time_at_cmd_start
= get_run_time ();
411 extern char **environ
;
412 char *lim
= (char *) sbrk (0);
414 space_at_cmd_start
= (long) (lim
- (char *) &environ
);
418 execute_command (command
, instream
== stdin
);
420 /* Do any commands attached to breakpoint we stopped at. */
421 bpstat_do_actions (&stop_bpstat
);
422 do_cleanups (old_chain
);
426 long cmd_time
= get_run_time () - time_at_cmd_start
;
428 printf_unfiltered ("Command execution time: %ld.%06ld\n",
429 cmd_time
/ 1000000, cmd_time
% 1000000);
435 extern char **environ
;
436 char *lim
= (char *) sbrk (0);
437 long space_now
= lim
- (char *) &environ
;
438 long space_diff
= space_now
- space_at_cmd_start
;
440 printf_unfiltered ("Space used: %ld (%c%ld for this command)\n",
442 (space_diff
>= 0 ? '+' : '-'),
448 /* Handle a complete line of input. This is called by the callback
449 mechanism within the readline library. Deal with incomplete commands
450 as well, by saving the partial input in a global buffer. */
452 /* NOTE: 1999-04-30 This is the asynchronous version of the
453 command_line_input function. command_line_input will become
454 obsolete once we use the event loop as the default mechanism in
457 command_line_handler (rl
)
460 static char *linebuffer
= 0;
461 static unsigned linelength
= 0;
464 int change_prompt
= 0;
471 int repeat
= (instream
== stdin
);
473 if (annotation_level
> 1 && instream
== stdin
)
475 printf_unfiltered ("\n\032\032post-");
476 printf_unfiltered (async_annotation_suffix
);
477 printf_unfiltered ("\n");
483 linebuffer
= (char *) xmalloc (linelength
);
490 strcpy (linebuffer
, readline_input_state
.linebuffer
);
491 p
= readline_input_state
.linebuffer_ptr
;
492 free (readline_input_state
.linebuffer
);
499 signal (STOP_SIGNAL
, handle_stop_sig
);
502 /* Make sure that all output has been output. Some machines may let
503 you get away with leaving out some of the gdb_flush, but not all. */
505 gdb_flush (gdb_stdout
);
506 gdb_flush (gdb_stderr
);
508 if (source_file_name
!= NULL
)
510 ++source_line_number
;
511 sprintf (source_error
,
512 "%s%s:%d: Error in sourced command file:\n",
516 error_pre_print
= source_error
;
519 /* If we are in this case, then command_handler will call quit
520 and exit from gdb. */
521 if (!rl
|| rl
== (char *) EOF
)
526 if (strlen (rl
) + 1 + (p
- linebuffer
) > linelength
)
528 linelength
= strlen (rl
) + 1 + (p
- linebuffer
);
529 nline
= (char *) xrealloc (linebuffer
, linelength
);
530 p
+= nline
- linebuffer
;
534 /* Copy line. Don't copy null at end. (Leaves line alone
535 if this was just a newline) */
539 free (rl
); /* Allocated in readline. */
541 if (p
== linebuffer
|| *(p
- 1) == '\\')
543 /* We come here also if the line entered is empty (just a 'return') */
544 p
--; /* Put on top of '\'. */
548 readline_input_state
.linebuffer
= savestring (linebuffer
,
549 strlen (linebuffer
));
550 readline_input_state
.linebuffer_ptr
= p
;
552 /* We will not invoke a execute_command if there is more
553 input expected to complete the command. So, we need to
554 print an empty prompt here. */
555 display_gdb_prompt ("");
562 signal (STOP_SIGNAL
, SIG_DFL
);
565 #define SERVER_COMMAND_LENGTH 7
567 (p
- linebuffer
> SERVER_COMMAND_LENGTH
)
568 && STREQN (linebuffer
, "server ", SERVER_COMMAND_LENGTH
);
571 /* Note that we don't set `line'. Between this and the check in
572 dont_repeat, this insures that repeating will still do the
575 command_handler (linebuffer
+ SERVER_COMMAND_LENGTH
);
576 display_gdb_prompt (0);
580 /* Do history expansion if that is wished. */
581 if (history_expansion_p
&& instream
== stdin
582 && ISATTY (instream
))
587 *p
= '\0'; /* Insert null now. */
588 expanded
= history_expand (linebuffer
, &history_value
);
591 /* Print the changes. */
592 printf_unfiltered ("%s\n", history_value
);
594 /* If there was an error, call this function again. */
597 free (history_value
);
600 if (strlen (history_value
) > linelength
)
602 linelength
= strlen (history_value
) + 1;
603 linebuffer
= (char *) xrealloc (linebuffer
, linelength
);
605 strcpy (linebuffer
, history_value
);
606 p
= linebuffer
+ strlen (linebuffer
);
607 free (history_value
);
611 /* If we just got an empty line, and that is supposed
612 to repeat the previous command, return the value in the
614 if (repeat
&& p
== linebuffer
&& *p
!= '\\')
616 command_handler (line
);
617 display_gdb_prompt (0);
621 for (p1
= linebuffer
; *p1
== ' ' || *p1
== '\t'; p1
++);
624 command_handler (line
);
625 display_gdb_prompt (0);
631 /* Add line to history if appropriate. */
632 if (instream
== stdin
633 && ISATTY (stdin
) && *linebuffer
)
634 add_history (linebuffer
);
636 /* Note: lines consisting solely of comments are added to the command
637 history. This is useful when you type a command, and then
638 realize you don't want to execute it quite yet. You can comment
639 out the command and then later fetch it from the value history
640 and remove the '#'. The kill ring is probably better, but some
641 people are in the habit of commenting things out. */
643 *p1
= '\0'; /* Found a comment. */
645 /* Save into global buffer if appropriate. */
648 if (linelength
> linesize
)
650 line
= xrealloc (line
, linelength
);
651 linesize
= linelength
;
653 strcpy (line
, linebuffer
);
656 command_handler (line
);
657 display_gdb_prompt (0);
662 command_handler (linebuffer
);
663 display_gdb_prompt (0);
667 /* Does reading of input from terminal w/o the editing features
668 provided by the readline library. */
670 /* NOTE: 1999-04-30 Asynchronous version of gdb_readline. gdb_readline
671 will become obsolete when the event loop is made the default
672 execution for gdb. */
679 int result_size
= 80;
681 result
= (char *) xmalloc (result_size
);
683 /* We still need the while loop here, even though it would seem
684 obvious to invoke gdb_readline2 at every character entered. If
685 not using the readline library, the terminal is in cooked mode,
686 which sends the characters all at once. Poll will notice that the
687 input fd has changed state only after enter is pressed. At this
688 point we still need to fetch all the chars entered. */
692 /* Read from stdin if we are executing a user defined command.
693 This is the right thing for prompt_for_continue, at least. */
694 c
= fgetc (instream
? instream
: stdin
);
699 /* The last line does not end with a newline. Return it, and
700 if we are called again fgetc will still return EOF and
701 we'll return NULL then. */
704 (*input_handler
) (0);
708 #ifndef CRLF_SOURCE_FILES
712 if (input_index
> 0 && result
[input_index
- 1] == '\r')
718 result
[input_index
++] = c
;
719 while (input_index
>= result_size
)
722 result
= (char *) xrealloc (result
, result_size
);
726 result
[input_index
++] = '\0';
727 (*input_handler
) (result
);
731 /* Initialization of signal handlers and tokens. There is a function
732 handle_sig* for each of the signals GDB cares about. Specifically:
733 SIGINT, SIGFPE, SIGQUIT, SIGTSTP, SIGHUP, SIGWINCH. These
734 functions are the actual signal handlers associated to the signals
735 via calls to signal(). The only job for these functions is to
736 enqueue the appropriate event/procedure with the event loop. Such
737 procedures are the old signal handlers. The event loop will take
738 care of invoking the queued procedures to perform the usual tasks
739 associated with the reception of the signal. */
740 /* NOTE: 1999-04-30 This is the asynchronous version of init_signals.
741 init_signals will become obsolete as we move to have to event loop
742 as the default for gdb. */
744 async_init_signals ()
746 signal (SIGINT
, handle_sigint
);
748 create_async_signal_handler (async_request_quit
, NULL
);
750 /* If SIGTRAP was set to SIG_IGN, then the SIG_IGN will get passed
751 to the inferior and breakpoints will be ignored. */
753 signal (SIGTRAP
, SIG_DFL
);
756 /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get
757 passed to the inferior, which we don't want. It would be
758 possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but
759 on BSD4.3 systems using vfork, that can affect the
760 GDB process as well as the inferior (the signal handling tables
761 might be in memory, shared between the two). Since we establish
762 a handler for SIGQUIT, when we call exec it will set the signal
763 to SIG_DFL for us. */
764 signal (SIGQUIT
, handle_sigquit
);
766 create_async_signal_handler (async_do_nothing
, NULL
);
768 if (signal (SIGHUP
, handle_sighup
) != SIG_IGN
)
770 create_async_signal_handler (async_disconnect
, NULL
);
773 create_async_signal_handler (async_do_nothing
, NULL
);
775 signal (SIGFPE
, handle_sigfpe
);
777 create_async_signal_handler (async_float_handler
, NULL
);
779 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
780 signal (SIGWINCH
, handle_sigwinch
);
782 create_async_signal_handler (SIGWINCH_HANDLER
, NULL
);
786 create_async_signal_handler (async_stop_sig
, NULL
);
792 mark_async_signal_handler_wrapper (token
)
795 mark_async_signal_handler ((async_signal_handler
*) token
);
798 /* Tell the event loop what to do if SIGINT is received.
799 See event-signal.c. */
804 signal (sig
, handle_sigint
);
806 /* If immediate_quit is set, we go ahead and process the SIGINT right
807 away, even if we usually would defer this to the event loop. The
808 assumption here is that it is safe to process ^C immediately if
809 immediate_quit is set. If we didn't, SIGINT would be really
810 processed only the next time through the event loop. To get to
811 that point, though, the command that we want to interrupt needs to
812 finish first, which is unacceptable. */
814 async_request_quit (0);
816 /* If immediate quit is not set, we process SIGINT the next time
817 through the loop, which is fine. */
818 mark_async_signal_handler_wrapper (sigint_token
);
821 /* Do the quit. All the checks have been done by the caller. */
823 async_request_quit (arg
)
834 /* Tell the event loop what to do if SIGQUIT is received.
835 See event-signal.c. */
840 mark_async_signal_handler_wrapper (sigquit_token
);
841 signal (sig
, handle_sigquit
);
844 /* Called by the event loop in response to a SIGQUIT. */
846 async_do_nothing (arg
)
849 /* Empty function body. */
853 /* Tell the event loop what to do if SIGHUP is received.
854 See event-signal.c. */
859 mark_async_signal_handler_wrapper (sighup_token
);
860 signal (sig
, handle_sighup
);
863 /* Called by the event loop to process a SIGHUP */
865 async_disconnect (arg
)
868 catch_errors (quit_cover
, NULL
,
869 "Could not kill the program being debugged",
871 signal (SIGHUP
, SIG_DFL
); /*FIXME: ??????????? */
872 kill (getpid (), SIGHUP
);
877 void handle_stop_sig (sig
)
880 mark_async_signal_handler_wrapper (sigtstp_token
);
881 signal (sig
, handle_stop_sig
);
888 char *prompt
= get_prompt ();
889 #if STOP_SIGNAL == SIGTSTP
890 signal (SIGTSTP
, SIG_DFL
);
892 kill (getpid (), SIGTSTP
);
893 signal (SIGTSTP
, handle_stop_sig
);
895 signal (STOP_SIGNAL
, handle_stop_sig
);
897 printf_unfiltered ("%s", prompt
);
898 gdb_flush (gdb_stdout
);
900 /* Forget about any previous command -- null line now will do nothing. */
903 #endif /* STOP_SIGNAL */
905 /* Tell the event loop what to do if SIGFPE is received.
906 See event-signal.c. */
911 mark_async_signal_handler_wrapper (sigfpe_token
);
912 signal (sig
, handle_sigfpe
);
915 /* Event loop will call this functin to process a SIGFPE. */
917 async_float_handler (arg
)
920 /* This message is based on ANSI C, section 4.7. Note that integer
921 divide by zero causes this, so "float" is a misnomer. */
922 error ("Erroneous arithmetic operation.");
925 /* Tell the event loop what to do if SIGWINCH is received.
926 See event-signal.c. */
927 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
929 handle_sigwinch (sig
)
932 mark_async_signal_handler_wrapper (sigwinch_token
);
933 signal (sig
, handle_sigwinch
);
938 /* Called by do_setshow_command. */
941 set_async_editing_command (args
, from_tty
, c
)
944 struct cmd_list_element
*c
;
946 change_line_handler ();
949 /* Called by do_setshow_command. */
952 set_async_annotation_level (args
, from_tty
, c
)
955 struct cmd_list_element
*c
;
957 change_annotation_level ();
960 /* Called by do_setshow_command. */
963 set_async_prompt (args
, from_tty
, c
)
966 struct cmd_list_element
*c
;
968 PROMPT (0) = savestring (new_async_prompt
, strlen (new_async_prompt
));
971 /* Set things up for readline to be invoked via the alternate
972 interface, i.e. via a callback function (rl_callback_read_char),
973 and hook up instream to the event loop.*/
975 _initialize_event_loop ()
979 /* When a character is detected on instream by select or poll,
980 readline will be invoked via this callback function. */
981 call_readline
= rl_callback_read_char
;
983 /* When readline has read an end-of-line character, it passes
984 the complete line to gdb for processing. command_line_handler
985 is the function that does this. */
986 input_handler
= command_line_handler
;
988 /* Tell readline to use the same input stream that gdb uses. */
989 rl_instream
= instream
;
991 /* Get a file descriptor for the input stream, so that we can
992 register it with the event loop. */
993 input_fd
= fileno (instream
);
995 /* Tell gdb to use the cli_command_loop as the main loop. */
996 command_loop_hook
= cli_command_loop
;
998 /* Now we need to create the event sources for the input file
1000 /* At this point in time, this is the only event source that we
1001 register with the even loop. Another source is going to be
1002 the target program (inferior), but that must be registered
1003 only when it actually exists (I.e. after we say 'run' or
1004 after we connect to a remote target. */
1005 add_file_handler (input_fd
, (file_handler_func
*) call_readline
, 0);
1007 /* Tell gdb that we will be using the readline library. This
1008 could be overwritten by a command in .gdbinit like 'set
1009 editing on' or 'off'. */
1010 async_command_editing_p
= 1;