gdb/event-top.c

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