gdb/tui/tui-io.c

   1 /* TUI support I/O functions.
   2
   3    Copyright (C) 1998-2015 Free Software Foundation, Inc.
   4
   5    Contributed by Hewlett-Packard Company.
   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 "target.h"
  24 #include "event-loop.h"
  25 #include "event-top.h"
  26 #include "command.h"
  27 #include "top.h"
  28 #include "tui/tui.h"
  29 #include "tui/tui-data.h"
  30 #include "tui/tui-io.h"
  31 #include "tui/tui-command.h"
  32 #include "tui/tui-win.h"
  33 #include "tui/tui-wingeneral.h"
  34 #include "tui/tui-file.h"
  35 #include "ui-out.h"
  36 #include "cli-out.h"
  37 #include <fcntl.h>
  38 #include <signal.h>
  39 #include "filestuff.h"
  40 #include "completer.h"
  41 #include "gdb_curses.h"
  42
  43 /* This redefines CTRL if it is not already defined, so it must come
  44    after terminal state releated include files like <term.h> and
  45    "gdb_curses.h".  */
  46 #include "readline/readline.h"
  47
  48 int
  49 key_is_start_sequence (int ch)
  50 {
  51   return (ch == 27);
  52 }
  53
  54 int
  55 key_is_end_sequence (int ch)
  56 {
  57   return (ch == 126);
  58 }
  59
  60 int
  61 key_is_backspace (int ch)
  62 {
  63   return (ch == 8);
  64 }
  65
  66 /* Use definition from readline 4.3.  */
  67 #undef CTRL_CHAR
  68 #define CTRL_CHAR(c) \
  69      ((c) < control_character_threshold && (((c) & 0x80) == 0))
  70
  71 /* This file controls the IO interactions between gdb and curses.
  72    When the TUI is enabled, gdb has two modes a curses and a standard
  73    mode.
  74
  75    In curses mode, the gdb outputs are made in a curses command
  76    window.  For this, the gdb_stdout and gdb_stderr are redirected to
  77    the specific ui_file implemented by TUI.  The output is handled by
  78    tui_puts().  The input is also controlled by curses with
  79    tui_getc().  The readline library uses this function to get its
  80    input.  Several readline hooks are installed to redirect readline
  81    output to the TUI (see also the note below).
  82
  83    In normal mode, the gdb outputs are restored to their origin, that
  84    is as if TUI is not used.  Readline also uses its original getc()
  85    function with stdin.
  86
  87    Note SCz/2001-07-21: the current readline is not clean in its
  88    management of the output.  Even if we install a redisplay handler,
  89    it sometimes writes on a stdout file.  It is important to redirect
  90    every output produced by readline, otherwise the curses window will
  91    be garbled.  This is implemented with a pipe that TUI reads and
  92    readline writes to.  A gdb input handler is created so that reading
  93    the pipe is handled automatically.  This will probably not work on
  94    non-Unix platforms.  The best fix is to make readline clean enougth
  95    so that is never write on stdout.
  96
  97    Note SCz/2002-09-01: we now use more readline hooks and it seems
  98    that with them we don't need the pipe anymore (verified by creating
  99    the pipe and closing its end so that write causes a SIGPIPE).  The
 100    old pipe code is still there and can be conditionally removed by
 101    #undef TUI_USE_PIPE_FOR_READLINE.  */
 102
 103 /* For gdb 5.3, prefer to continue the pipe hack as a backup wheel.  */
 104 #ifdef HAVE_PIPE
 105 #define TUI_USE_PIPE_FOR_READLINE
 106 #endif
 107 /* #undef TUI_USE_PIPE_FOR_READLINE */
 108
 109 /* TUI output files.  */
 110 static struct ui_file *tui_stdout;
 111 static struct ui_file *tui_stderr;
 112 struct ui_out *tui_out;
 113
 114 /* GDB output files in non-curses mode.  */
 115 static struct ui_file *tui_old_stdout;
 116 static struct ui_file *tui_old_stderr;
 117 struct ui_out *tui_old_uiout;
 118
 119 /* Readline previous hooks.  */
 120 static rl_getc_func_t *tui_old_rl_getc_function;
 121 static rl_voidfunc_t *tui_old_rl_redisplay_function;
 122 static rl_vintfunc_t *tui_old_rl_prep_terminal;
 123 static rl_voidfunc_t *tui_old_rl_deprep_terminal;
 124 static rl_compdisp_func_t *tui_old_rl_display_matches_hook;
 125 static int tui_old_rl_echoing_p;
 126
 127 /* Readline output stream.
 128    Should be removed when readline is clean.  */
 129 static FILE *tui_rl_outstream;
 130 static FILE *tui_old_rl_outstream;
 131 #ifdef TUI_USE_PIPE_FOR_READLINE
 132 static int tui_readline_pipe[2];
 133 #endif
 134
 135 /* The last gdb prompt that was registered in readline.
 136    This may be the main gdb prompt or a secondary prompt.  */
 137 static char *tui_rl_saved_prompt;
 138
 139 static void
 140 tui_putc (char c)
 141 {
 142   char buf[2];
 143
 144   buf[0] = c;
 145   buf[1] = 0;
 146   tui_puts (buf);
 147 }
 148
 149 /* Print the string in the curses command window.
 150    The output is buffered.  It is up to the caller to refresh the screen
 151    if necessary.  */
 152
 153 void
 154 tui_puts (const char *string)
 155 {
 156   static int tui_skip_line = -1;
 157   char c;
 158   WINDOW *w;
 159
 160   w = TUI_CMD_WIN->generic.handle;
 161   while ((c = *string++) != 0)
 162     {
 163       /* Catch annotation and discard them.  We need two \032 and
 164          discard until a \n is seen.  */
 165       if (c == '\032')
 166         {
 167           tui_skip_line++;
 168         }
 169       else if (tui_skip_line != 1)
 170         {
 171           tui_skip_line = -1;
 172           /* Expand TABs, since ncurses on MS-Windows doesn't.  */
 173           if (c == '\t')
 174             {
 175               int line, col;
 176
 177               getyx (w, line, col);
 178               do
 179                 {
 180                   waddch (w, ' ');
 181                   col++;
 182                 } while ((col % 8) != 0);
 183             }
 184           else
 185             waddch (w, c);
 186         }
 187       else if (c == '\n')
 188         tui_skip_line = -1;
 189     }
 190   TUI_CMD_WIN->detail.command_info.start_line = getcury (w);
 191 }
 192
 193 /* Readline callback.
 194    Redisplay the command line with its prompt after readline has
 195    changed the edited text.  */
 196 void
 197 tui_redisplay_readline (void)
 198 {
 199   int prev_col;
 200   int height;
 201   int col, line;
 202   int c_pos;
 203   int c_line;
 204   int in;
 205   WINDOW *w;
 206   char *prompt;
 207   int start_line;
 208
 209   /* Detect when we temporarily left SingleKey and now the readline
 210      edit buffer is empty, automatically restore the SingleKey
 211      mode.  The restore must only be done if the command has finished.
 212      The command could call prompt_for_continue and we must not
 213      restore SingleKey so that the prompt and normal keymap are used.  */
 214   if (tui_current_key_mode == TUI_ONE_COMMAND_MODE && rl_end == 0
 215       && immediate_quit == 0)
 216     tui_set_key_mode (TUI_SINGLE_KEY_MODE);
 217
 218   if (tui_current_key_mode == TUI_SINGLE_KEY_MODE)
 219     prompt = "";
 220   else
 221     prompt = tui_rl_saved_prompt;
 222
 223   c_pos = -1;
 224   c_line = -1;
 225   w = TUI_CMD_WIN->generic.handle;
 226   start_line = TUI_CMD_WIN->detail.command_info.start_line;
 227   wmove (w, start_line, 0);
 228   prev_col = 0;
 229   height = 1;
 230   for (in = 0; prompt && prompt[in]; in++)
 231     {
 232       waddch (w, prompt[in]);
 233       getyx (w, line, col);
 234       if (col <= prev_col)
 235         height++;
 236       prev_col = col;
 237     }
 238   for (in = 0; in <= rl_end; in++)
 239     {
 240       unsigned char c;
 241
 242       if (in == rl_point)
 243         {
 244           getyx (w, c_line, c_pos);
 245         }
 246
 247       if (in == rl_end)
 248         break;
 249
 250       c = (unsigned char) rl_line_buffer[in];
 251       if (CTRL_CHAR (c) || c == RUBOUT)
 252         {
 253           waddch (w, '^');
 254           waddch (w, CTRL_CHAR (c) ? UNCTRL (c) : '?');
 255         }
 256       else if (c == '\t')
 257         {
 258           /* Expand TABs, since ncurses on MS-Windows doesn't.  */
 259           getyx (w, line, col);
 260           do
 261             {
 262               waddch (w, ' ');
 263               col++;
 264             } while ((col % 8) != 0);
 265         }
 266       else
 267         {
 268           waddch (w, c);
 269         }
 270       if (c == '\n')
 271         TUI_CMD_WIN->detail.command_info.start_line = getcury (w);
 272       getyx (w, line, col);
 273       if (col < prev_col)
 274         height++;
 275       prev_col = col;
 276     }
 277   wclrtobot (w);
 278   TUI_CMD_WIN->detail.command_info.start_line = getcury (w);
 279   if (c_line >= 0)
 280     wmove (w, c_line, c_pos);
 281   TUI_CMD_WIN->detail.command_info.start_line -= height - 1;
 282
 283   wrefresh (w);
 284   fflush(stdout);
 285 }
 286
 287 /* Readline callback to prepare the terminal.  It is called once each
 288    time we enter readline.  Terminal is already setup in curses
 289    mode.  */
 290 static void
 291 tui_prep_terminal (int notused1)
 292 {
 293   /* Save the prompt registered in readline to correctly display it.
 294      (we can't use gdb_prompt() due to secondary prompts and can't use
 295      rl_prompt because it points to an alloca buffer).  */
 296   xfree (tui_rl_saved_prompt);
 297   tui_rl_saved_prompt = rl_prompt != NULL ? xstrdup (rl_prompt) : NULL;
 298 }
 299
 300 /* Readline callback to restore the terminal.  It is called once each
 301    time we leave readline.  There is nothing to do in curses mode.  */
 302 static void
 303 tui_deprep_terminal (void)
 304 {
 305 }
 306
 307 #ifdef TUI_USE_PIPE_FOR_READLINE
 308 /* Read readline output pipe and feed the command window with it.
 309    Should be removed when readline is clean.  */
 310 static void
 311 tui_readline_output (int error, gdb_client_data data)
 312 {
 313   int size;
 314   char buf[256];
 315
 316   size = read (tui_readline_pipe[0], buf, sizeof (buf) - 1);
 317   if (size > 0 && tui_active)
 318     {
 319       buf[size] = 0;
 320       tui_puts (buf);
 321     }
 322 }
 323 #endif
 324
 325 /* TUI version of displayer.crlf.  */
 326
 327 static void
 328 tui_mld_crlf (const struct match_list_displayer *displayer)
 329 {
 330   tui_putc ('\n');
 331 }
 332
 333 /* TUI version of displayer.putch.  */
 334
 335 static void
 336 tui_mld_putch (const struct match_list_displayer *displayer, int ch)
 337 {
 338   tui_putc (ch);
 339 }
 340
 341 /* TUI version of displayer.puts.  */
 342
 343 static void
 344 tui_mld_puts (const struct match_list_displayer *displayer, const char *s)
 345 {
 346   tui_puts (s);
 347 }
 348
 349 /* TUI version of displayer.flush.  */
 350
 351 static void
 352 tui_mld_flush (const struct match_list_displayer *displayer)
 353 {
 354   wrefresh (TUI_CMD_WIN->generic.handle);
 355 }
 356
 357 /* TUI version of displayer.erase_entire_line.  */
 358
 359 static void
 360 tui_mld_erase_entire_line (const struct match_list_displayer *displayer)
 361 {
 362   WINDOW *w = TUI_CMD_WIN->generic.handle;
 363   int cur_y = getcury (w);
 364
 365   wmove (w, cur_y, 0);
 366   wclrtoeol (w);
 367   wmove (w, cur_y, 0);
 368 }
 369
 370 /* TUI version of displayer.beep.  */
 371
 372 static void
 373 tui_mld_beep (const struct match_list_displayer *displayer)
 374 {
 375   beep ();
 376 }
 377
 378 /* Helper function for tui_mld_read_key.
 379    This temporarily replaces tui_getc for use during tab-completion
 380    match list display.  */
 381
 382 static int
 383 tui_mld_getc (FILE *fp)
 384 {
 385   WINDOW *w = TUI_CMD_WIN->generic.handle;
 386   int c = wgetch (w);
 387
 388   return c;
 389 }
 390
 391 /* TUI version of displayer.read_key.  */
 392
 393 static int
 394 tui_mld_read_key (const struct match_list_displayer *displayer)
 395 {
 396   rl_getc_func_t *prev = rl_getc_function;
 397   int c;
 398
 399   /* We can't use tui_getc as we need NEWLINE to not get emitted.  */
 400   rl_getc_function = tui_mld_getc;
 401   c = rl_read_key ();
 402   rl_getc_function = prev;
 403   return c;
 404 }
 405
 406 /* TUI version of rl_completion_display_matches_hook.
 407    See gdb_display_match_list for a description of the arguments.  */
 408
 409 static void
 410 tui_rl_display_match_list (char **matches, int len, int max)
 411 {
 412   struct match_list_displayer displayer;
 413
 414   rl_get_screen_size (&displayer.height, &displayer.width);
 415   displayer.crlf = tui_mld_crlf;
 416   displayer.putch = tui_mld_putch;
 417   displayer.puts = tui_mld_puts;
 418   displayer.flush = tui_mld_flush;
 419   displayer.erase_entire_line = tui_mld_erase_entire_line;
 420   displayer.beep = tui_mld_beep;
 421   displayer.read_key = tui_mld_read_key;
 422
 423   gdb_display_match_list (matches, len, max, &displayer);
 424 }
 425
 426 /* Setup the IO for curses or non-curses mode.
 427    - In non-curses mode, readline and gdb use the standard input and
 428    standard output/error directly.
 429    - In curses mode, the standard output/error is controlled by TUI
 430    with the tui_stdout and tui_stderr.  The output is redirected in
 431    the curses command window.  Several readline callbacks are installed
 432    so that readline asks for its input to the curses command window
 433    with wgetch().  */
 434 void
 435 tui_setup_io (int mode)
 436 {
 437   extern int _rl_echoing_p;
 438
 439   if (mode)
 440     {
 441       /* Redirect readline to TUI.  */
 442       tui_old_rl_redisplay_function = rl_redisplay_function;
 443       tui_old_rl_deprep_terminal = rl_deprep_term_function;
 444       tui_old_rl_prep_terminal = rl_prep_term_function;
 445       tui_old_rl_getc_function = rl_getc_function;
 446       tui_old_rl_display_matches_hook = rl_completion_display_matches_hook;
 447       tui_old_rl_outstream = rl_outstream;
 448       tui_old_rl_echoing_p = _rl_echoing_p;
 449       rl_redisplay_function = tui_redisplay_readline;
 450       rl_deprep_term_function = tui_deprep_terminal;
 451       rl_prep_term_function = tui_prep_terminal;
 452       rl_getc_function = tui_getc;
 453       _rl_echoing_p = 0;
 454       rl_outstream = tui_rl_outstream;
 455       rl_prompt = 0;
 456       rl_completion_display_matches_hook = tui_rl_display_match_list;
 457       rl_already_prompted = 0;
 458
 459       /* Keep track of previous gdb output.  */
 460       tui_old_stdout = gdb_stdout;
 461       tui_old_stderr = gdb_stderr;
 462       tui_old_uiout = current_uiout;
 463
 464       /* Reconfigure gdb output.  */
 465       gdb_stdout = tui_stdout;
 466       gdb_stderr = tui_stderr;
 467       gdb_stdlog = gdb_stdout;  /* for moment */
 468       gdb_stdtarg = gdb_stderr; /* for moment */
 469       gdb_stdtargerr = gdb_stderr;      /* for moment */
 470       current_uiout = tui_out;
 471
 472       /* Save tty for SIGCONT.  */
 473       savetty ();
 474     }
 475   else
 476     {
 477       /* Restore gdb output.  */
 478       gdb_stdout = tui_old_stdout;
 479       gdb_stderr = tui_old_stderr;
 480       gdb_stdlog = gdb_stdout;  /* for moment */
 481       gdb_stdtarg = gdb_stderr; /* for moment */
 482       gdb_stdtargerr = gdb_stderr;      /* for moment */
 483       current_uiout = tui_old_uiout;
 484
 485       /* Restore readline.  */
 486       rl_redisplay_function = tui_old_rl_redisplay_function;
 487       rl_deprep_term_function = tui_old_rl_deprep_terminal;
 488       rl_prep_term_function = tui_old_rl_prep_terminal;
 489       rl_getc_function = tui_old_rl_getc_function;
 490       rl_completion_display_matches_hook = tui_old_rl_display_matches_hook;
 491       rl_outstream = tui_old_rl_outstream;
 492       _rl_echoing_p = tui_old_rl_echoing_p;
 493       rl_already_prompted = 0;
 494
 495       /* Save tty for SIGCONT.  */
 496       savetty ();
 497     }
 498 }
 499
 500 #ifdef SIGCONT
 501 /* Catch SIGCONT to restore the terminal and refresh the screen.  */
 502 static void
 503 tui_cont_sig (int sig)
 504 {
 505   if (tui_active)
 506     {
 507       /* Restore the terminal setting because another process (shell)
 508          might have changed it.  */
 509       resetty ();
 510
 511       /* Force a refresh of the screen.  */
 512       tui_refresh_all_win ();
 513
 514       wrefresh (TUI_CMD_WIN->generic.handle);
 515     }
 516   signal (sig, tui_cont_sig);
 517 }
 518 #endif
 519
 520 /* Initialize the IO for gdb in curses mode.  */
 521 void
 522 tui_initialize_io (void)
 523 {
 524 #ifdef SIGCONT
 525   signal (SIGCONT, tui_cont_sig);
 526 #endif
 527
 528   /* Create tui output streams.  */
 529   tui_stdout = tui_fileopen (stdout);
 530   tui_stderr = tui_fileopen (stderr);
 531   tui_out = tui_out_new (tui_stdout);
 532
 533   /* Create the default UI.  */
 534   tui_old_uiout = cli_out_new (gdb_stdout);
 535
 536 #ifdef TUI_USE_PIPE_FOR_READLINE
 537   /* Temporary solution for readline writing to stdout: redirect
 538      readline output in a pipe, read that pipe and output the content
 539      in the curses command window.  */
 540   if (gdb_pipe_cloexec (tui_readline_pipe) != 0)
 541     error (_("Cannot create pipe for readline"));
 542
 543   tui_rl_outstream = fdopen (tui_readline_pipe[1], "w");
 544   if (tui_rl_outstream == 0)
 545     error (_("Cannot redirect readline output"));
 546
 547   setvbuf (tui_rl_outstream, (char*) NULL, _IOLBF, 0);
 548
 549 #ifdef O_NONBLOCK
 550   (void) fcntl (tui_readline_pipe[0], F_SETFL, O_NONBLOCK);
 551 #else
 552 #ifdef O_NDELAY
 553   (void) fcntl (tui_readline_pipe[0], F_SETFL, O_NDELAY);
 554 #endif
 555 #endif
 556   add_file_handler (tui_readline_pipe[0], tui_readline_output, 0);
 557 #else
 558   tui_rl_outstream = stdout;
 559 #endif
 560 }
 561
 562 /* Get a character from the command window.  This is called from the
 563    readline package.  */
 564 int
 565 tui_getc (FILE *fp)
 566 {
 567   int ch;
 568   WINDOW *w;
 569
 570   w = TUI_CMD_WIN->generic.handle;
 571
 572 #ifdef TUI_USE_PIPE_FOR_READLINE
 573   /* Flush readline output.  */
 574   tui_readline_output (0, 0);
 575 #endif
 576
 577   ch = wgetch (w);
 578
 579   /* The \n must be echoed because it will not be printed by
 580      readline.  */
 581   if (ch == '\n')
 582     {
 583       /* When hitting return with an empty input, gdb executes the last
 584          command.  If we emit a newline, this fills up the command window
 585          with empty lines with gdb prompt at beginning.  Instead of that,
 586          stay on the same line but provide a visual effect to show the
 587          user we recognized the command.  */
 588       if (rl_end == 0 && !gdb_in_secondary_prompt_p ())
 589         {
 590           wmove (w, getcury (w), 0);
 591
 592           /* Clear the line.  This will blink the gdb prompt since
 593              it will be redrawn at the same line.  */
 594           wclrtoeol (w);
 595           wrefresh (w);
 596           napms (20);
 597         }
 598       else
 599         {
 600           /* Move cursor to the end of the command line before emitting the
 601              newline.  We need to do so because when ncurses outputs a newline
 602              it truncates any text that appears past the end of the cursor.  */
 603           int px, py;
 604           getyx (w, py, px);
 605           px += rl_end - rl_point;
 606           py += px / TUI_CMD_WIN->generic.width;
 607           px %= TUI_CMD_WIN->generic.width;
 608           wmove (w, py, px);
 609           tui_putc ('\n');
 610         }
 611     }
 612
 613   /* Handle prev/next/up/down here.  */
 614   ch = tui_dispatch_ctrl_char (ch);
 615
 616   if (ch == KEY_BACKSPACE)
 617     return '\b';
 618
 619   if (async_command_editing_p && key_is_start_sequence (ch))
 620     {
 621       int ch_pending;
 622
 623       nodelay (w, TRUE);
 624       ch_pending = wgetch (w);
 625       nodelay (w, FALSE);
 626
 627       /* If we have pending input following a start sequence, call the stdin
 628          event handler again because ncurses may have already read and stored
 629          the input into its internal buffer, meaning that we won't get an stdin
 630          event for it.  If we don't compensate for this missed stdin event, key
 631          sequences as Alt_F (^[f) will not behave promptly.
 632
 633          (We only compensates for the missed 2nd byte of a key sequence because
 634          2-byte sequences are by far the most commonly used. ncurses may have
 635          buffered a larger, 3+-byte key sequence though it remains to be seen
 636          whether it is useful to compensate for all the bytes of such
 637          sequences.)  */
 638       if (ch_pending != ERR)
 639         {
 640           ungetch (ch_pending);
 641           call_stdin_event_handler_again_p = 1;
 642         }
 643     }
 644
 645   return ch;
 646 }
 647
 648 /* Utility function to expand TABs in a STRING into spaces.  STRING
 649    will be displayed starting at column COL, and is assumed to include
 650    no newlines.  The returned expanded string is malloc'ed.  */
 651
 652 char *
 653 tui_expand_tabs (const char *string, int col)
 654 {
 655   int n_adjust, ncol;
 656   const char *s;
 657   char *ret, *q;
 658
 659   /* 1. How many additional characters do we need?  */
 660   for (ncol = col, n_adjust = 0, s = string; s; )
 661     {
 662       s = strpbrk (s, "\t");
 663       if (s)
 664         {
 665           ncol += (s - string) + n_adjust;
 666           /* Adjustment for the next tab stop, minus one for the TAB
 667              we replace with spaces.  */
 668           n_adjust += 8 - (ncol % 8) - 1;
 669           s++;
 670         }
 671     }
 672
 673   /* Allocate the copy.  */
 674   ret = q = xmalloc (strlen (string) + n_adjust + 1);
 675
 676   /* 2. Copy the original string while replacing TABs with spaces.  */
 677   for (ncol = col, s = string; s; )
 678     {
 679       const char *s1 = strpbrk (s, "\t");
 680       if (s1)
 681         {
 682           if (s1 > s)
 683             {
 684               strncpy (q, s, s1 - s);
 685               q += s1 - s;
 686               ncol += s1 - s;
 687             }
 688           do {
 689             *q++ = ' ';
 690             ncol++;
 691           } while ((ncol % 8) != 0);
 692           s1++;
 693         }
 694       else
 695         strcpy (q, s);
 696       s = s1;
 697     }
 698
 699   return ret;
 700 }