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