Fix longjmp across readline w/ --enable-sjlj-exceptions toolchains
[external/binutils.git] / gdb / event-top.c
1 /* Top level stuff for GDB, the GNU debugger.
2
3    Copyright (C) 1999-2016 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 #include "buffer.h"
41 #include "ser-event.h"
42 #include "gdb_select.h"
43
44 /* readline include files.  */
45 #include "readline/readline.h"
46 #include "readline/history.h"
47
48 /* readline defines this.  */
49 #undef savestring
50
51 static char *top_level_prompt (void);
52
53 /* Signal handlers.  */
54 #ifdef SIGQUIT
55 static void handle_sigquit (int sig);
56 #endif
57 #ifdef SIGHUP
58 static void handle_sighup (int sig);
59 #endif
60 static void handle_sigfpe (int sig);
61
62 /* Functions to be invoked by the event loop in response to
63    signals.  */
64 #if defined (SIGQUIT) || defined (SIGHUP)
65 static void async_do_nothing (gdb_client_data);
66 #endif
67 #ifdef SIGHUP
68 static void async_disconnect (gdb_client_data);
69 #endif
70 static void async_float_handler (gdb_client_data);
71 #ifdef STOP_SIGNAL
72 static void async_stop_sig (gdb_client_data);
73 #endif
74 static void async_sigterm_handler (gdb_client_data arg);
75
76 /* Instead of invoking (and waiting for) readline to read the command
77    line and pass it back for processing, we use readline's alternate
78    interface, via callback functions, so that the event loop can react
79    to other event sources while we wait for input.  */
80
81 /* Important variables for the event loop.  */
82
83 /* This is used to determine if GDB is using the readline library or
84    its own simplified form of readline.  It is used by the asynchronous
85    form of the set editing command.
86    ezannoni: as of 1999-04-29 I expect that this
87    variable will not be used after gdb is changed to use the event
88    loop as default engine, and event-top.c is merged into top.c.  */
89 int set_editing_cmd_var;
90
91 /* This is used to display the notification of the completion of an
92    asynchronous execution command.  */
93 int exec_done_display_p = 0;
94
95 /* Used by the stdin event handler to compensate for missed stdin events.
96    Setting this to a non-zero value inside an stdin callback makes the callback
97    run again.  */
98 int call_stdin_event_handler_again_p;
99
100 /* Signal handling variables.  */
101 /* Each of these is a pointer to a function that the event loop will
102    invoke if the corresponding signal has received.  The real signal
103    handlers mark these functions as ready to be executed and the event
104    loop, in a later iteration, calls them.  See the function
105    invoke_async_signal_handler.  */
106 static struct async_signal_handler *sigint_token;
107 #ifdef SIGHUP
108 static struct async_signal_handler *sighup_token;
109 #endif
110 #ifdef SIGQUIT
111 static struct async_signal_handler *sigquit_token;
112 #endif
113 static struct async_signal_handler *sigfpe_token;
114 #ifdef STOP_SIGNAL
115 static struct async_signal_handler *sigtstp_token;
116 #endif
117 static struct async_signal_handler *async_sigterm_token;
118
119 /* This hook is called by gdb_rl_callback_read_char_wrapper after each
120    character is processed.  */
121 void (*after_char_processing_hook) (void);
122 \f
123
124 /* Wrapper function for calling into the readline library.  This takes
125    care of a couple things:
126
127    - The event loop expects the callback function to have a parameter,
128      while readline expects none.
129
130    - Propagation of GDB exceptions/errors thrown from INPUT_HANDLER
131      across readline requires special handling.
132
133    On the exceptions issue:
134
135    DWARF-based unwinding cannot cross code built without -fexceptions.
136    Any exception that tries to propagate through such code will fail
137    and the result is a call to std::terminate.  While some ABIs, such
138    as x86-64, require all code to be built with exception tables,
139    others don't.
140
141    This is a problem when GDB calls some non-EH-aware C library code,
142    that calls into GDB again through a callback, and that GDB callback
143    code throws a C++ exception.  Turns out this is exactly what
144    happens with GDB's readline callback.
145
146    In such cases, we must catch and save any C++ exception that might
147    be thrown from the GDB callback before returning to the
148    non-EH-aware code.  When the non-EH-aware function itself returns
149    back to GDB, we then rethrow the original C++ exception.
150
151    In the readline case however, the right thing to do is to longjmp
152    out of the callback, rather than do a normal return -- there's no
153    way for the callback to return to readline an indication that an
154    error happened, so a normal return would have rl_callback_read_char
155    potentially continue processing further input, redisplay the
156    prompt, etc.  Instead of raw setjmp/longjmp however, we use our
157    sjlj-based TRY/CATCH mechanism, which knows to handle multiple
158    levels of active setjmp/longjmp frames, needed in order to handle
159    the readline callback recursing, as happens with e.g., secondary
160    prompts / queries, through gdb_readline_wrapper.  This must be
161    noexcept in order to avoid problems with mixing sjlj and
162    (sjlj-based) C++ exceptions.  */
163
164 static struct gdb_exception
165 gdb_rl_callback_read_char_wrapper_noexcept () noexcept
166 {
167   struct gdb_exception gdb_expt = exception_none;
168
169   /* C++ exceptions can't normally be thrown across readline (unless
170      it is built with -fexceptions, but it won't by default on many
171      ABIs).  So we instead wrap the readline call with a sjlj-based
172      TRY/CATCH, and rethrow the GDB exception once back in GDB.  */
173   TRY_SJLJ
174     {
175       rl_callback_read_char ();
176       if (after_char_processing_hook)
177         (*after_char_processing_hook) ();
178     }
179   CATCH_SJLJ (ex, RETURN_MASK_ALL)
180     {
181       gdb_expt = ex;
182     }
183   END_CATCH_SJLJ
184
185   return gdb_expt;
186 }
187
188 static void
189 gdb_rl_callback_read_char_wrapper (gdb_client_data client_data)
190 {
191   struct gdb_exception gdb_expt
192     = gdb_rl_callback_read_char_wrapper_noexcept ();
193
194   /* Rethrow using the normal EH mechanism.  */
195   if (gdb_expt.reason < 0)
196     throw_exception (gdb_expt);
197 }
198
199 /* GDB's readline callback handler.  Calls the current INPUT_HANDLER,
200    and propagates GDB exceptions/errors thrown from INPUT_HANDLER back
201    across readline.  See gdb_rl_callback_read_char_wrapper.  This must
202    be noexcept in order to avoid problems with mixing sjlj and
203    (sjlj-based) C++ exceptions.  */
204
205 static void
206 gdb_rl_callback_handler (char *rl) noexcept
207 {
208   struct gdb_exception gdb_rl_expt = exception_none;
209   struct ui *ui = current_ui;
210
211   TRY
212     {
213       ui->input_handler (rl);
214     }
215   CATCH (ex, RETURN_MASK_ALL)
216     {
217       gdb_rl_expt = ex;
218     }
219   END_CATCH
220
221   /* If we caught a GDB exception, longjmp out of the readline
222      callback.  There's no other way for the callback to signal to
223      readline that an error happened.  A normal return would have
224      readline potentially continue processing further input, redisplay
225      the prompt, etc.  (This is what GDB historically did when it was
226      a C program.)  Note that since we're long jumping, local variable
227      dtors are NOT run automatically.  */
228   if (gdb_rl_expt.reason < 0)
229     throw_exception_sjlj (gdb_rl_expt);
230 }
231
232 /* Change the function to be invoked every time there is a character
233    ready on stdin.  This is used when the user sets the editing off,
234    therefore bypassing readline, and letting gdb handle the input
235    itself, via gdb_readline_no_editing_callback.  Also it is used in
236    the opposite case in which the user sets editing on again, by
237    restoring readline handling of the input.
238
239    NOTE: this operates on input_fd, not instream.  If we are reading
240    commands from a file, instream will point to the file.  However, we
241    always read commands from a file with editing off.  This means that
242    the 'set editing on/off' will have effect only on the interactive
243    session.  */
244
245 void
246 change_line_handler (int editing)
247 {
248   struct ui *ui = current_ui;
249
250   /* We can only have one instance of readline, so we only allow
251      editing on the main UI.  */
252   if (ui != main_ui)
253     return;
254
255   /* Don't try enabling editing if the interpreter doesn't support it
256      (e.g., MI).  */
257   if (!interp_supports_command_editing (top_level_interpreter ())
258       || !interp_supports_command_editing (command_interp ()))
259     return;
260
261   if (editing)
262     {
263       gdb_assert (ui == main_ui);
264
265       /* Turn on editing by using readline.  */
266       ui->call_readline = gdb_rl_callback_read_char_wrapper;
267     }
268   else
269     {
270       /* Turn off editing by using gdb_readline_no_editing_callback.  */
271       if (ui->command_editing)
272         gdb_rl_callback_handler_remove ();
273       ui->call_readline = gdb_readline_no_editing_callback;
274     }
275   ui->command_editing = editing;
276 }
277
278 /* The functions below are wrappers for rl_callback_handler_remove and
279    rl_callback_handler_install that keep track of whether the callback
280    handler is installed in readline.  This is necessary because after
281    handling a target event of a background execution command, we may
282    need to reinstall the callback handler if it was removed due to a
283    secondary prompt.  See gdb_readline_wrapper_line.  We don't
284    unconditionally install the handler for every target event because
285    that also clears the line buffer, thus installing it while the user
286    is typing would lose input.  */
287
288 /* Whether we've registered a callback handler with readline.  */
289 static int callback_handler_installed;
290
291 /* See event-top.h, and above.  */
292
293 void
294 gdb_rl_callback_handler_remove (void)
295 {
296   gdb_assert (current_ui == main_ui);
297
298   rl_callback_handler_remove ();
299   callback_handler_installed = 0;
300 }
301
302 /* See event-top.h, and above.  Note this wrapper doesn't have an
303    actual callback parameter because we always install
304    INPUT_HANDLER.  */
305
306 void
307 gdb_rl_callback_handler_install (const char *prompt)
308 {
309   gdb_assert (current_ui == main_ui);
310
311   /* Calling rl_callback_handler_install resets readline's input
312      buffer.  Calling this when we were already processing input
313      therefore loses input.  */
314   gdb_assert (!callback_handler_installed);
315
316   rl_callback_handler_install (prompt, gdb_rl_callback_handler);
317   callback_handler_installed = 1;
318 }
319
320 /* See event-top.h, and above.  */
321
322 void
323 gdb_rl_callback_handler_reinstall (void)
324 {
325   gdb_assert (current_ui == main_ui);
326
327   if (!callback_handler_installed)
328     {
329       /* Passing NULL as prompt argument tells readline to not display
330          a prompt.  */
331       gdb_rl_callback_handler_install (NULL);
332     }
333 }
334
335 /* Displays the prompt.  If the argument NEW_PROMPT is NULL, the
336    prompt that is displayed is the current top level prompt.
337    Otherwise, it displays whatever NEW_PROMPT is as a local/secondary
338    prompt.
339
340    This is used after each gdb command has completed, and in the
341    following cases:
342
343    1. When the user enters a command line which is ended by '\'
344    indicating that the command will continue on the next line.  In
345    that case the prompt that is displayed is the empty string.
346
347    2. When the user is entering 'commands' for a breakpoint, or
348    actions for a tracepoint.  In this case the prompt will be '>'
349
350    3. On prompting for pagination.  */
351
352 void
353 display_gdb_prompt (const char *new_prompt)
354 {
355   char *actual_gdb_prompt = NULL;
356   struct cleanup *old_chain;
357
358   annotate_display_prompt ();
359
360   /* Reset the nesting depth used when trace-commands is set.  */
361   reset_command_nest_depth ();
362
363   old_chain = make_cleanup (free_current_contents, &actual_gdb_prompt);
364
365   /* Do not call the python hook on an explicit prompt change as
366      passed to this function, as this forms a secondary/local prompt,
367      IE, displayed but not set.  */
368   if (! new_prompt)
369     {
370       struct ui *ui = current_ui;
371
372       if (ui->prompt_state == PROMPTED)
373         internal_error (__FILE__, __LINE__, _("double prompt"));
374       else if (ui->prompt_state == PROMPT_BLOCKED)
375         {
376           /* This is to trick readline into not trying to display the
377              prompt.  Even though we display the prompt using this
378              function, readline still tries to do its own display if
379              we don't call rl_callback_handler_install and
380              rl_callback_handler_remove (which readline detects
381              because a global variable is not set).  If readline did
382              that, it could mess up gdb signal handlers for SIGINT.
383              Readline assumes that between calls to rl_set_signals and
384              rl_clear_signals gdb doesn't do anything with the signal
385              handlers.  Well, that's not the case, because when the
386              target executes we change the SIGINT signal handler.  If
387              we allowed readline to display the prompt, the signal
388              handler change would happen exactly between the calls to
389              the above two functions.  Calling
390              rl_callback_handler_remove(), does the job.  */
391
392           if (current_ui->command_editing)
393             gdb_rl_callback_handler_remove ();
394           do_cleanups (old_chain);
395           return;
396         }
397       else if (ui->prompt_state == PROMPT_NEEDED)
398         {
399           /* Display the top level prompt.  */
400           actual_gdb_prompt = top_level_prompt ();
401           ui->prompt_state = PROMPTED;
402         }
403     }
404   else
405     actual_gdb_prompt = xstrdup (new_prompt);
406
407   if (current_ui->command_editing)
408     {
409       gdb_rl_callback_handler_remove ();
410       gdb_rl_callback_handler_install (actual_gdb_prompt);
411     }
412   /* new_prompt at this point can be the top of the stack or the one
413      passed in.  It can't be NULL.  */
414   else
415     {
416       /* Don't use a _filtered function here.  It causes the assumed
417          character position to be off, since the newline we read from
418          the user is not accounted for.  */
419       fputs_unfiltered (actual_gdb_prompt, gdb_stdout);
420       gdb_flush (gdb_stdout);
421     }
422
423   do_cleanups (old_chain);
424 }
425
426 /* Return the top level prompt, as specified by "set prompt", possibly
427    overriden by the python gdb.prompt_hook hook, and then composed
428    with the prompt prefix and suffix (annotations).  The caller is
429    responsible for freeing the returned string.  */
430
431 static char *
432 top_level_prompt (void)
433 {
434   char *prompt;
435
436   /* Give observers a chance of changing the prompt.  E.g., the python
437      `gdb.prompt_hook' is installed as an observer.  */
438   observer_notify_before_prompt (get_prompt ());
439
440   prompt = get_prompt ();
441
442   if (annotation_level >= 2)
443     {
444       /* Prefix needs to have new line at end.  */
445       const char prefix[] = "\n\032\032pre-prompt\n";
446
447       /* Suffix needs to have a new line at end and \032 \032 at
448          beginning.  */
449       const char suffix[] = "\n\032\032prompt\n";
450
451       return concat (prefix, prompt, suffix, (char *) NULL);
452     }
453
454   return xstrdup (prompt);
455 }
456
457 /* See top.h.  */
458
459 struct ui *main_ui;
460 struct ui *current_ui;
461 struct ui *ui_list;
462
463 /* Get a pointer to the current UI's line buffer.  This is used to
464    construct a whole line of input from partial input.  */
465
466 static struct buffer *
467 get_command_line_buffer (void)
468 {
469   return &current_ui->line_buffer;
470 }
471
472 /* When there is an event ready on the stdin file descriptor, instead
473    of calling readline directly throught the callback function, or
474    instead of calling gdb_readline_no_editing_callback, give gdb a
475    chance to detect errors and do something.  */
476
477 void
478 stdin_event_handler (int error, gdb_client_data client_data)
479 {
480   struct ui *ui = (struct ui *) client_data;
481
482   if (error)
483     {
484       /* Switch to the main UI, so diagnostics always go there.  */
485       current_ui = main_ui;
486
487       delete_file_handler (ui->input_fd);
488       if (main_ui == ui)
489         {
490           /* If stdin died, we may as well kill gdb.  */
491           printf_unfiltered (_("error detected on stdin\n"));
492           quit_command ((char *) 0, 0);
493         }
494       else
495         {
496           /* Simply delete the UI.  */
497           delete_ui (ui);
498         }
499     }
500   else
501     {
502       /* Switch to the UI whose input descriptor woke up the event
503          loop.  */
504       current_ui = ui;
505
506       /* This makes sure a ^C immediately followed by further input is
507          always processed in that order.  E.g,. with input like
508          "^Cprint 1\n", the SIGINT handler runs, marks the async
509          signal handler, and then select/poll may return with stdin
510          ready, instead of -1/EINTR.  The
511          gdb.base/double-prompt-target-event-error.exp test exercises
512          this.  */
513       QUIT;
514
515       do
516         {
517           call_stdin_event_handler_again_p = 0;
518           ui->call_readline (client_data);
519         }
520       while (call_stdin_event_handler_again_p != 0);
521     }
522 }
523
524 /* See top.h.  */
525
526 void
527 ui_register_input_event_handler (struct ui *ui)
528 {
529   add_file_handler (ui->input_fd, stdin_event_handler, ui);
530 }
531
532 /* See top.h.  */
533
534 void
535 ui_unregister_input_event_handler (struct ui *ui)
536 {
537   delete_file_handler (ui->input_fd);
538 }
539
540 /* Re-enable stdin after the end of an execution command in
541    synchronous mode, or after an error from the target, and we aborted
542    the exec operation.  */
543
544 void
545 async_enable_stdin (void)
546 {
547   struct ui *ui = current_ui;
548
549   if (ui->prompt_state == PROMPT_BLOCKED)
550     {
551       target_terminal_ours ();
552       ui_register_input_event_handler (ui);
553       ui->prompt_state = PROMPT_NEEDED;
554     }
555 }
556
557 /* Disable reads from stdin (the console) marking the command as
558    synchronous.  */
559
560 void
561 async_disable_stdin (void)
562 {
563   struct ui *ui = current_ui;
564
565   ui->prompt_state = PROMPT_BLOCKED;
566   delete_file_handler (ui->input_fd);
567 }
568 \f
569
570 /* Handle a gdb command line.  This function is called when
571    handle_line_of_input has concatenated one or more input lines into
572    a whole command.  */
573
574 void
575 command_handler (char *command)
576 {
577   struct ui *ui = current_ui;
578   char *c;
579
580   if (ui->instream == ui->stdin_stream)
581     reinitialize_more_filter ();
582
583   scoped_command_stats stat_reporter (true);
584
585   /* Do not execute commented lines.  */
586   for (c = command; *c == ' ' || *c == '\t'; c++)
587     ;
588   if (c[0] != '#')
589     {
590       execute_command (command, ui->instream == ui->stdin_stream);
591
592       /* Do any commands attached to breakpoint we stopped at.  */
593       bpstat_do_actions ();
594     }
595 }
596
597 /* Append RL, an input line returned by readline or one of its
598    emulations, to CMD_LINE_BUFFER.  Returns the command line if we
599    have a whole command line ready to be processed by the command
600    interpreter or NULL if the command line isn't complete yet (input
601    line ends in a backslash).  Takes ownership of RL.  */
602
603 static char *
604 command_line_append_input_line (struct buffer *cmd_line_buffer, char *rl)
605 {
606   char *cmd;
607   size_t len;
608
609   len = strlen (rl);
610
611   if (len > 0 && rl[len - 1] == '\\')
612     {
613       /* Don't copy the backslash and wait for more.  */
614       buffer_grow (cmd_line_buffer, rl, len - 1);
615       cmd = NULL;
616     }
617   else
618     {
619       /* Copy whole line including terminating null, and we're
620          done.  */
621       buffer_grow (cmd_line_buffer, rl, len + 1);
622       cmd = cmd_line_buffer->buffer;
623     }
624
625   /* Allocated in readline.  */
626   xfree (rl);
627
628   return cmd;
629 }
630
631 /* Handle a line of input coming from readline.
632
633    If the read line ends with a continuation character (backslash),
634    save the partial input in CMD_LINE_BUFFER (except the backslash),
635    and return NULL.  Otherwise, save the partial input and return a
636    pointer to CMD_LINE_BUFFER's buffer (null terminated), indicating a
637    whole command line is ready to be executed.
638
639    Returns EOF on end of file.
640
641    If REPEAT, handle command repetitions:
642
643      - If the input command line is NOT empty, the command returned is
644        copied into the global 'saved_command_line' var so that it can
645        be repeated later.
646
647      - OTOH, if the input command line IS empty, return the previously
648        saved command instead of the empty input line.
649 */
650
651 char *
652 handle_line_of_input (struct buffer *cmd_line_buffer,
653                       char *rl, int repeat, char *annotation_suffix)
654 {
655   struct ui *ui = current_ui;
656   int from_tty = ui->instream == ui->stdin_stream;
657   char *p1;
658   char *cmd;
659
660   if (rl == NULL)
661     return (char *) EOF;
662
663   cmd = command_line_append_input_line (cmd_line_buffer, rl);
664   if (cmd == NULL)
665     return NULL;
666
667   /* We have a complete command line now.  Prepare for the next
668      command, but leave ownership of memory to the buffer .  */
669   cmd_line_buffer->used_size = 0;
670
671   if (from_tty && annotation_level > 1)
672     {
673       printf_unfiltered (("\n\032\032post-"));
674       puts_unfiltered (annotation_suffix);
675       printf_unfiltered (("\n"));
676     }
677
678 #define SERVER_COMMAND_PREFIX "server "
679   if (startswith (cmd, SERVER_COMMAND_PREFIX))
680     {
681       /* Note that we don't set `saved_command_line'.  Between this
682          and the check in dont_repeat, this insures that repeating
683          will still do the right thing.  */
684       return cmd + strlen (SERVER_COMMAND_PREFIX);
685     }
686
687   /* Do history expansion if that is wished.  */
688   if (history_expansion_p && from_tty && input_interactive_p (current_ui))
689     {
690       char *history_value;
691       int expanded;
692
693       expanded = history_expand (cmd, &history_value);
694       if (expanded)
695         {
696           size_t len;
697
698           /* Print the changes.  */
699           printf_unfiltered ("%s\n", history_value);
700
701           /* If there was an error, call this function again.  */
702           if (expanded < 0)
703             {
704               xfree (history_value);
705               return cmd;
706             }
707
708           /* history_expand returns an allocated string.  Just replace
709              our buffer with it.  */
710           len = strlen (history_value);
711           xfree (buffer_finish (cmd_line_buffer));
712           cmd_line_buffer->buffer = history_value;
713           cmd_line_buffer->buffer_size = len + 1;
714           cmd = history_value;
715         }
716     }
717
718   /* If we just got an empty line, and that is supposed to repeat the
719      previous command, return the previously saved command.  */
720   for (p1 = cmd; *p1 == ' ' || *p1 == '\t'; p1++)
721     ;
722   if (repeat && *p1 == '\0')
723     return saved_command_line;
724
725   /* Add command to history if appropriate.  Note: lines consisting
726      solely of comments are also added to the command history.  This
727      is useful when you type a command, and then realize you don't
728      want to execute it quite yet.  You can comment out the command
729      and then later fetch it from the value history and remove the
730      '#'.  The kill ring is probably better, but some people are in
731      the habit of commenting things out.  */
732   if (*cmd != '\0' && from_tty && input_interactive_p (current_ui))
733     gdb_add_history (cmd);
734
735   /* Save into global buffer if appropriate.  */
736   if (repeat)
737     {
738       xfree (saved_command_line);
739       saved_command_line = xstrdup (cmd);
740       return saved_command_line;
741     }
742   else
743     return cmd;
744 }
745
746 /* Handle a complete line of input.  This is called by the callback
747    mechanism within the readline library.  Deal with incomplete
748    commands as well, by saving the partial input in a global
749    buffer.
750
751    NOTE: This is the asynchronous version of the command_line_input
752    function.  */
753
754 void
755 command_line_handler (char *rl)
756 {
757   struct buffer *line_buffer = get_command_line_buffer ();
758   struct ui *ui = current_ui;
759   char *cmd;
760
761   cmd = handle_line_of_input (line_buffer, rl, 1, "prompt");
762   if (cmd == (char *) EOF)
763     {
764       /* stdin closed.  The connection with the terminal is gone.
765          This happens at the end of a testsuite run, after Expect has
766          hung up but GDB is still alive.  In such a case, we just quit
767          gdb killing the inferior program too.  */
768       printf_unfiltered ("quit\n");
769       execute_command ("quit", 1);
770     }
771   else if (cmd == NULL)
772     {
773       /* We don't have a full line yet.  Print an empty prompt.  */
774       display_gdb_prompt ("");
775     }
776   else
777     {
778       ui->prompt_state = PROMPT_NEEDED;
779
780       command_handler (cmd);
781
782       if (ui->prompt_state != PROMPTED)
783         display_gdb_prompt (0);
784     }
785 }
786
787 /* Does reading of input from terminal w/o the editing features
788    provided by the readline library.  Calls the line input handler
789    once we have a whole input line.  */
790
791 void
792 gdb_readline_no_editing_callback (gdb_client_data client_data)
793 {
794   int c;
795   char *result;
796   struct buffer line_buffer;
797   static int done_once = 0;
798   struct ui *ui = current_ui;
799
800   buffer_init (&line_buffer);
801
802   /* Unbuffer the input stream, so that, later on, the calls to fgetc
803      fetch only one char at the time from the stream.  The fgetc's will
804      get up to the first newline, but there may be more chars in the
805      stream after '\n'.  If we buffer the input and fgetc drains the
806      stream, getting stuff beyond the newline as well, a select, done
807      afterwards will not trigger.  */
808   if (!done_once && !ISATTY (ui->instream))
809     {
810       setbuf (ui->instream, NULL);
811       done_once = 1;
812     }
813
814   /* We still need the while loop here, even though it would seem
815      obvious to invoke gdb_readline_no_editing_callback at every
816      character entered.  If not using the readline library, the
817      terminal is in cooked mode, which sends the characters all at
818      once.  Poll will notice that the input fd has changed state only
819      after enter is pressed.  At this point we still need to fetch all
820      the chars entered.  */
821
822   while (1)
823     {
824       /* Read from stdin if we are executing a user defined command.
825          This is the right thing for prompt_for_continue, at least.  */
826       c = fgetc (ui->instream != NULL ? ui->instream : ui->stdin_stream);
827
828       if (c == EOF)
829         {
830           if (line_buffer.used_size > 0)
831             {
832               /* The last line does not end with a newline.  Return it, and
833                  if we are called again fgetc will still return EOF and
834                  we'll return NULL then.  */
835               break;
836             }
837           xfree (buffer_finish (&line_buffer));
838           ui->input_handler (NULL);
839           return;
840         }
841
842       if (c == '\n')
843         {
844           if (line_buffer.used_size > 0
845               && line_buffer.buffer[line_buffer.used_size - 1] == '\r')
846             line_buffer.used_size--;
847           break;
848         }
849
850       buffer_grow_char (&line_buffer, c);
851     }
852
853   buffer_grow_char (&line_buffer, '\0');
854   result = buffer_finish (&line_buffer);
855   ui->input_handler (result);
856 }
857 \f
858
859 /* The serial event associated with the QUIT flag.  set_quit_flag sets
860    this, and check_quit_flag clears it.  Used by interruptible_select
861    to be able to do interruptible I/O with no race with the SIGINT
862    handler.  */
863 static struct serial_event *quit_serial_event;
864
865 /* Initialization of signal handlers and tokens.  There is a function
866    handle_sig* for each of the signals GDB cares about.  Specifically:
867    SIGINT, SIGFPE, SIGQUIT, SIGTSTP, SIGHUP, SIGWINCH.  These
868    functions are the actual signal handlers associated to the signals
869    via calls to signal().  The only job for these functions is to
870    enqueue the appropriate event/procedure with the event loop.  Such
871    procedures are the old signal handlers.  The event loop will take
872    care of invoking the queued procedures to perform the usual tasks
873    associated with the reception of the signal.  */
874 /* NOTE: 1999-04-30 This is the asynchronous version of init_signals.
875    init_signals will become obsolete as we move to have to event loop
876    as the default for gdb.  */
877 void
878 async_init_signals (void)
879 {
880   initialize_async_signal_handlers ();
881
882   quit_serial_event = make_serial_event ();
883
884   signal (SIGINT, handle_sigint);
885   sigint_token =
886     create_async_signal_handler (async_request_quit, NULL);
887   signal (SIGTERM, handle_sigterm);
888   async_sigterm_token
889     = create_async_signal_handler (async_sigterm_handler, NULL);
890
891   /* If SIGTRAP was set to SIG_IGN, then the SIG_IGN will get passed
892      to the inferior and breakpoints will be ignored.  */
893 #ifdef SIGTRAP
894   signal (SIGTRAP, SIG_DFL);
895 #endif
896
897 #ifdef SIGQUIT
898   /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get
899      passed to the inferior, which we don't want.  It would be
900      possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but
901      on BSD4.3 systems using vfork, that can affect the
902      GDB process as well as the inferior (the signal handling tables
903      might be in memory, shared between the two).  Since we establish
904      a handler for SIGQUIT, when we call exec it will set the signal
905      to SIG_DFL for us.  */
906   signal (SIGQUIT, handle_sigquit);
907   sigquit_token =
908     create_async_signal_handler (async_do_nothing, NULL);
909 #endif
910 #ifdef SIGHUP
911   if (signal (SIGHUP, handle_sighup) != SIG_IGN)
912     sighup_token =
913       create_async_signal_handler (async_disconnect, NULL);
914   else
915     sighup_token =
916       create_async_signal_handler (async_do_nothing, NULL);
917 #endif
918   signal (SIGFPE, handle_sigfpe);
919   sigfpe_token =
920     create_async_signal_handler (async_float_handler, NULL);
921
922 #ifdef STOP_SIGNAL
923   sigtstp_token =
924     create_async_signal_handler (async_stop_sig, NULL);
925 #endif
926 }
927
928 /* See defs.h.  */
929
930 void
931 quit_serial_event_set (void)
932 {
933   serial_event_set (quit_serial_event);
934 }
935
936 /* See defs.h.  */
937
938 void
939 quit_serial_event_clear (void)
940 {
941   serial_event_clear (quit_serial_event);
942 }
943
944 /* Return the selectable file descriptor of the serial event
945    associated with the quit flag.  */
946
947 static int
948 quit_serial_event_fd (void)
949 {
950   return serial_event_fd (quit_serial_event);
951 }
952
953 /* See defs.h.  */
954
955 void
956 default_quit_handler (void)
957 {
958   if (check_quit_flag ())
959     {
960       if (target_terminal_is_ours ())
961         quit ();
962       else
963         target_pass_ctrlc ();
964     }
965 }
966
967 /* See defs.h.  */
968 quit_handler_ftype *quit_handler = default_quit_handler;
969
970 /* Data for make_cleanup_override_quit_handler.  Wrap the previous
971    handler pointer in a data struct because it's not portable to cast
972    a function pointer to a data pointer, which is what make_cleanup
973    expects.  */
974 struct quit_handler_cleanup_data
975 {
976   /* The previous quit handler.  */
977   quit_handler_ftype *prev_handler;
978 };
979
980 /* Cleanup call that restores the previous quit handler.  */
981
982 static void
983 restore_quit_handler (void *arg)
984 {
985   struct quit_handler_cleanup_data *data
986     = (struct quit_handler_cleanup_data *) arg;
987
988   quit_handler = data->prev_handler;
989 }
990
991 /* Destructor for the quit handler cleanup.  */
992
993 static void
994 restore_quit_handler_dtor (void *arg)
995 {
996   xfree (arg);
997 }
998
999 /* See defs.h.  */
1000
1001 struct cleanup *
1002 make_cleanup_override_quit_handler (quit_handler_ftype *new_quit_handler)
1003 {
1004   struct cleanup *old_chain;
1005   struct quit_handler_cleanup_data *data;
1006
1007   data = XNEW (struct quit_handler_cleanup_data);
1008   data->prev_handler = quit_handler;
1009   old_chain = make_cleanup_dtor (restore_quit_handler, data,
1010                                  restore_quit_handler_dtor);
1011   quit_handler = new_quit_handler;
1012   return old_chain;
1013 }
1014
1015 /* Handle a SIGINT.  */
1016
1017 void
1018 handle_sigint (int sig)
1019 {
1020   signal (sig, handle_sigint);
1021
1022   /* We could be running in a loop reading in symfiles or something so
1023      it may be quite a while before we get back to the event loop.  So
1024      set quit_flag to 1 here.  Then if QUIT is called before we get to
1025      the event loop, we will unwind as expected.  */
1026   set_quit_flag ();
1027
1028   /* In case nothing calls QUIT before the event loop is reached, the
1029      event loop handles it.  */
1030   mark_async_signal_handler (sigint_token);
1031 }
1032
1033 /* See gdb_select.h.  */
1034
1035 int
1036 interruptible_select (int n,
1037                       fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
1038                       struct timeval *timeout)
1039 {
1040   fd_set my_readfds;
1041   int fd;
1042   int res;
1043
1044   if (readfds == NULL)
1045     {
1046       readfds = &my_readfds;
1047       FD_ZERO (&my_readfds);
1048     }
1049
1050   fd = quit_serial_event_fd ();
1051   FD_SET (fd, readfds);
1052   if (n <= fd)
1053     n = fd + 1;
1054
1055   do
1056     {
1057       res = gdb_select (n, readfds, writefds, exceptfds, timeout);
1058     }
1059   while (res == -1 && errno == EINTR);
1060
1061   if (res == 1 && FD_ISSET (fd, readfds))
1062     {
1063       errno = EINTR;
1064       return -1;
1065     }
1066   return res;
1067 }
1068
1069 /* Handle GDB exit upon receiving SIGTERM if target_can_async_p ().  */
1070
1071 static void
1072 async_sigterm_handler (gdb_client_data arg)
1073 {
1074   quit_force (NULL, 0);
1075 }
1076
1077 /* See defs.h.  */
1078 volatile int sync_quit_force_run;
1079
1080 /* Quit GDB if SIGTERM is received.
1081    GDB would quit anyway, but this way it will clean up properly.  */
1082 void
1083 handle_sigterm (int sig)
1084 {
1085   signal (sig, handle_sigterm);
1086
1087   sync_quit_force_run = 1;
1088   set_quit_flag ();
1089
1090   mark_async_signal_handler (async_sigterm_token);
1091 }
1092
1093 /* Do the quit.  All the checks have been done by the caller.  */
1094 void
1095 async_request_quit (gdb_client_data arg)
1096 {
1097   /* If the quit_flag has gotten reset back to 0 by the time we get
1098      back here, that means that an exception was thrown to unwind the
1099      current command before we got back to the event loop.  So there
1100      is no reason to call quit again here.  */
1101   QUIT;
1102 }
1103
1104 #ifdef SIGQUIT
1105 /* Tell the event loop what to do if SIGQUIT is received.
1106    See event-signal.c.  */
1107 static void
1108 handle_sigquit (int sig)
1109 {
1110   mark_async_signal_handler (sigquit_token);
1111   signal (sig, handle_sigquit);
1112 }
1113 #endif
1114
1115 #if defined (SIGQUIT) || defined (SIGHUP)
1116 /* Called by the event loop in response to a SIGQUIT or an
1117    ignored SIGHUP.  */
1118 static void
1119 async_do_nothing (gdb_client_data arg)
1120 {
1121   /* Empty function body.  */
1122 }
1123 #endif
1124
1125 #ifdef SIGHUP
1126 /* Tell the event loop what to do if SIGHUP is received.
1127    See event-signal.c.  */
1128 static void
1129 handle_sighup (int sig)
1130 {
1131   mark_async_signal_handler (sighup_token);
1132   signal (sig, handle_sighup);
1133 }
1134
1135 /* Called by the event loop to process a SIGHUP.  */
1136 static void
1137 async_disconnect (gdb_client_data arg)
1138 {
1139
1140   TRY
1141     {
1142       quit_cover ();
1143     }
1144
1145   CATCH (exception, RETURN_MASK_ALL)
1146     {
1147       fputs_filtered ("Could not kill the program being debugged",
1148                       gdb_stderr);
1149       exception_print (gdb_stderr, exception);
1150     }
1151   END_CATCH
1152
1153   TRY
1154     {
1155       pop_all_targets ();
1156     }
1157   CATCH (exception, RETURN_MASK_ALL)
1158     {
1159     }
1160   END_CATCH
1161
1162   signal (SIGHUP, SIG_DFL);     /*FIXME: ???????????  */
1163   raise (SIGHUP);
1164 }
1165 #endif
1166
1167 #ifdef STOP_SIGNAL
1168 void
1169 handle_stop_sig (int sig)
1170 {
1171   mark_async_signal_handler (sigtstp_token);
1172   signal (sig, handle_stop_sig);
1173 }
1174
1175 static void
1176 async_stop_sig (gdb_client_data arg)
1177 {
1178   char *prompt = get_prompt ();
1179
1180 #if STOP_SIGNAL == SIGTSTP
1181   signal (SIGTSTP, SIG_DFL);
1182 #if HAVE_SIGPROCMASK
1183   {
1184     sigset_t zero;
1185
1186     sigemptyset (&zero);
1187     sigprocmask (SIG_SETMASK, &zero, 0);
1188   }
1189 #elif HAVE_SIGSETMASK
1190   sigsetmask (0);
1191 #endif
1192   raise (SIGTSTP);
1193   signal (SIGTSTP, handle_stop_sig);
1194 #else
1195   signal (STOP_SIGNAL, handle_stop_sig);
1196 #endif
1197   printf_unfiltered ("%s", prompt);
1198   gdb_flush (gdb_stdout);
1199
1200   /* Forget about any previous command -- null line now will do
1201      nothing.  */
1202   dont_repeat ();
1203 }
1204 #endif /* STOP_SIGNAL */
1205
1206 /* Tell the event loop what to do if SIGFPE is received.
1207    See event-signal.c.  */
1208 static void
1209 handle_sigfpe (int sig)
1210 {
1211   mark_async_signal_handler (sigfpe_token);
1212   signal (sig, handle_sigfpe);
1213 }
1214
1215 /* Event loop will call this functin to process a SIGFPE.  */
1216 static void
1217 async_float_handler (gdb_client_data arg)
1218 {
1219   /* This message is based on ANSI C, section 4.7.  Note that integer
1220      divide by zero causes this, so "float" is a misnomer.  */
1221   error (_("Erroneous arithmetic operation."));
1222 }
1223 \f
1224
1225 /* Set things up for readline to be invoked via the alternate
1226    interface, i.e. via a callback function
1227    (gdb_rl_callback_read_char), and hook up instream to the event
1228    loop.  */
1229
1230 void
1231 gdb_setup_readline (int editing)
1232 {
1233   struct ui *ui = current_ui;
1234
1235   /* This function is a noop for the sync case.  The assumption is
1236      that the sync setup is ALL done in gdb_init, and we would only
1237      mess it up here.  The sync stuff should really go away over
1238      time.  */
1239   if (!batch_silent)
1240     gdb_stdout = stdio_fileopen (ui->outstream);
1241   gdb_stderr = stderr_fileopen (ui->errstream);
1242   gdb_stdlog = gdb_stderr;  /* for moment */
1243   gdb_stdtarg = gdb_stderr; /* for moment */
1244   gdb_stdtargerr = gdb_stderr; /* for moment */
1245
1246   /* If the input stream is connected to a terminal, turn on editing.
1247      However, that is only allowed on the main UI, as we can only have
1248      one instance of readline.  */
1249   if (ISATTY (ui->instream) && editing && ui == main_ui)
1250     {
1251       /* Tell gdb that we will be using the readline library.  This
1252          could be overwritten by a command in .gdbinit like 'set
1253          editing on' or 'off'.  */
1254       ui->command_editing = 1;
1255
1256       /* When a character is detected on instream by select or poll,
1257          readline will be invoked via this callback function.  */
1258       ui->call_readline = gdb_rl_callback_read_char_wrapper;
1259
1260       /* Tell readline to use the same input stream that gdb uses.  */
1261       rl_instream = ui->instream;
1262     }
1263   else
1264     {
1265       ui->command_editing = 0;
1266       ui->call_readline = gdb_readline_no_editing_callback;
1267     }
1268
1269   /* Now create the event source for this UI's input file descriptor.
1270      Another source is going to be the target program (inferior), but
1271      that must be registered only when it actually exists (I.e. after
1272      we say 'run' or after we connect to a remote target.  */
1273   ui_register_input_event_handler (ui);
1274 }
1275
1276 /* Disable command input through the standard CLI channels.  Used in
1277    the suspend proc for interpreters that use the standard gdb readline
1278    interface, like the cli & the mi.  */
1279
1280 void
1281 gdb_disable_readline (void)
1282 {
1283   struct ui *ui = current_ui;
1284
1285   /* FIXME - It is too heavyweight to delete and remake these every
1286      time you run an interpreter that needs readline.  It is probably
1287      better to have the interpreters cache these, which in turn means
1288      that this needs to be moved into interpreter specific code.  */
1289
1290 #if 0
1291   ui_file_delete (gdb_stdout);
1292   ui_file_delete (gdb_stderr);
1293   gdb_stdlog = NULL;
1294   gdb_stdtarg = NULL;
1295   gdb_stdtargerr = NULL;
1296 #endif
1297
1298   if (ui->command_editing)
1299     gdb_rl_callback_handler_remove ();
1300   delete_file_handler (ui->input_fd);
1301 }