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