gdb/event-top.c

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