1 /* TUI support I/O functions. 2 3 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009, 4 2010 Free Software Foundation, Inc. 5 6 Contributed by Hewlett-Packard Company. 7 8 This file is part of GDB. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 22 23 #include "defs.h" 24 #include "target.h" 25 #include "event-loop.h" 26 #include "event-top.h" 27 #include "command.h" 28 #include "top.h" 29 #include "tui/tui.h" 30 #include "tui/tui-data.h" 31 #include "tui/tui-io.h" 32 #include "tui/tui-command.h" 33 #include "tui/tui-win.h" 34 #include "tui/tui-wingeneral.h" 35 #include "tui/tui-file.h" 36 #include "ui-out.h" 37 #include "cli-out.h" 38 #include <fcntl.h> 39 #include <signal.h> 40 #include <stdio.h> 41 42 #include "gdb_curses.h" 43 44 /* This redefines CTRL if it is not already defined, so it must come 45 after terminal state releated include files like <term.h> and 46 "gdb_curses.h". */ 47 #include "readline/readline.h" 48 49 int 50 key_is_start_sequence (int ch) 51 { 52 return (ch == 27); 53 } 54 55 int 56 key_is_end_sequence (int ch) 57 { 58 return (ch == 126); 59 } 60 61 int 62 key_is_backspace (int ch) 63 { 64 return (ch == 8); 65 } 66 67 int 68 key_is_command_char (int ch) 69 { 70 return ((ch == KEY_NPAGE) || (ch == KEY_PPAGE) 71 || (ch == KEY_LEFT) || (ch == KEY_RIGHT) 72 || (ch == KEY_UP) || (ch == KEY_DOWN) 73 || (ch == KEY_SF) || (ch == KEY_SR) 74 || (ch == (int)'\f') 75 || key_is_start_sequence (ch)); 76 } 77 78 /* Use definition from readline 4.3. */ 79 #undef CTRL_CHAR 80 #define CTRL_CHAR(c) \ 81 ((c) < control_character_threshold && (((c) & 0x80) == 0)) 82 83 /* This file controls the IO interactions between gdb and curses. 84 When the TUI is enabled, gdb has two modes a curses and a standard 85 mode. 86 87 In curses mode, the gdb outputs are made in a curses command 88 window. For this, the gdb_stdout and gdb_stderr are redirected to 89 the specific ui_file implemented by TUI. The output is handled by 90 tui_puts(). The input is also controlled by curses with 91 tui_getc(). The readline library uses this function to get its 92 input. Several readline hooks are installed to redirect readline 93 output to the TUI (see also the note below). 94 95 In normal mode, the gdb outputs are restored to their origin, that 96 is as if TUI is not used. Readline also uses its original getc() 97 function with stdin. 98 99 Note SCz/2001-07-21: the current readline is not clean in its 100 management of the output. Even if we install a redisplay handler, 101 it sometimes writes on a stdout file. It is important to redirect 102 every output produced by readline, otherwise the curses window will 103 be garbled. This is implemented with a pipe that TUI reads and 104 readline writes to. A gdb input handler is created so that reading 105 the pipe is handled automatically. This will probably not work on 106 non-Unix platforms. The best fix is to make readline clean enougth 107 so that is never write on stdout. 108 109 Note SCz/2002-09-01: we now use more readline hooks and it seems 110 that with them we don't need the pipe anymore (verified by creating 111 the pipe and closing its end so that write causes a SIGPIPE). The 112 old pipe code is still there and can be conditionally removed by 113 #undef TUI_USE_PIPE_FOR_READLINE. */ 114 115 /* For gdb 5.3, prefer to continue the pipe hack as a backup wheel. */ 116 #ifdef HAVE_PIPE 117 #define TUI_USE_PIPE_FOR_READLINE 118 #endif 119 /* #undef TUI_USE_PIPE_FOR_READLINE */ 120 121 /* TUI output files. */ 122 static struct ui_file *tui_stdout; 123 static struct ui_file *tui_stderr; 124 struct ui_out *tui_out; 125 126 /* GDB output files in non-curses mode. */ 127 static struct ui_file *tui_old_stdout; 128 static struct ui_file *tui_old_stderr; 129 struct ui_out *tui_old_uiout; 130 131 /* Readline previous hooks. */ 132 static Function *tui_old_rl_getc_function; 133 static VFunction *tui_old_rl_redisplay_function; 134 static VFunction *tui_old_rl_prep_terminal; 135 static VFunction *tui_old_rl_deprep_terminal; 136 static int tui_old_readline_echoing_p; 137 138 /* Readline output stream. 139 Should be removed when readline is clean. */ 140 static FILE *tui_rl_outstream; 141 static FILE *tui_old_rl_outstream; 142 #ifdef TUI_USE_PIPE_FOR_READLINE 143 static int tui_readline_pipe[2]; 144 #endif 145 146 /* The last gdb prompt that was registered in readline. 147 This may be the main gdb prompt or a secondary prompt. */ 148 static char *tui_rl_saved_prompt; 149 150 static unsigned int tui_handle_resize_during_io (unsigned int); 151 152 static void 153 tui_putc (char c) 154 { 155 char buf[2]; 156 157 buf[0] = c; 158 buf[1] = 0; 159 tui_puts (buf); 160 } 161 162 /* Print the string in the curses command window. */ 163 void 164 tui_puts (const char *string) 165 { 166 static int tui_skip_line = -1; 167 char c; 168 WINDOW *w; 169 170 w = TUI_CMD_WIN->generic.handle; 171 while ((c = *string++) != 0) 172 { 173 /* Catch annotation and discard them. We need two \032 and 174 discard until a \n is seen. */ 175 if (c == '\032') 176 { 177 tui_skip_line++; 178 } 179 else if (tui_skip_line != 1) 180 { 181 tui_skip_line = -1; 182 waddch (w, c); 183 } 184 else if (c == '\n') 185 tui_skip_line = -1; 186 } 187 getyx (w, TUI_CMD_WIN->detail.command_info.cur_line, 188 TUI_CMD_WIN->detail.command_info.curch); 189 TUI_CMD_WIN->detail.command_info.start_line = TUI_CMD_WIN->detail.command_info.cur_line; 190 191 /* We could defer the following. */ 192 wrefresh (w); 193 fflush (stdout); 194 } 195 196 /* Readline callback. 197 Redisplay the command line with its prompt after readline has 198 changed the edited text. */ 199 void 200 tui_redisplay_readline (void) 201 { 202 int prev_col; 203 int height; 204 int col, line; 205 int c_pos; 206 int c_line; 207 int in; 208 WINDOW *w; 209 char *prompt; 210 int start_line; 211 212 /* Detect when we temporarily left SingleKey and now the readline 213 edit buffer is empty, automatically restore the SingleKey 214 mode. */ 215 if (tui_current_key_mode == TUI_ONE_COMMAND_MODE && rl_end == 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 c = (unsigned char) rl_line_buffer[in]; 243 if (in == rl_point) 244 { 245 getyx (w, c_line, c_pos); 246 } 247 248 if (CTRL_CHAR (c) || c == RUBOUT) 249 { 250 waddch (w, '^'); 251 waddch (w, CTRL_CHAR (c) ? UNCTRL (c) : '?'); 252 } 253 else 254 { 255 waddch (w, c); 256 } 257 if (c == '\n') 258 { 259 getyx (w, TUI_CMD_WIN->detail.command_info.start_line, 260 TUI_CMD_WIN->detail.command_info.curch); 261 } 262 getyx (w, line, col); 263 if (col < prev_col) 264 height++; 265 prev_col = col; 266 } 267 wclrtobot (w); 268 getyx (w, TUI_CMD_WIN->detail.command_info.start_line, 269 TUI_CMD_WIN->detail.command_info.curch); 270 if (c_line >= 0) 271 { 272 wmove (w, c_line, c_pos); 273 TUI_CMD_WIN->detail.command_info.cur_line = c_line; 274 TUI_CMD_WIN->detail.command_info.curch = c_pos; 275 } 276 TUI_CMD_WIN->detail.command_info.start_line -= height - 1; 277 278 wrefresh (w); 279 fflush(stdout); 280 } 281 282 /* Readline callback to prepare the terminal. It is called once each 283 time we enter readline. Terminal is already setup in curses 284 mode. */ 285 static void 286 tui_prep_terminal (int notused1) 287 { 288 /* Save the prompt registered in readline to correctly display it. 289 (we can't use gdb_prompt() due to secondary prompts and can't use 290 rl_prompt because it points to an alloca buffer). */ 291 xfree (tui_rl_saved_prompt); 292 tui_rl_saved_prompt = xstrdup (rl_prompt); 293 } 294 295 /* Readline callback to restore the terminal. It is called once each 296 time we leave readline. There is nothing to do in curses mode. */ 297 static void 298 tui_deprep_terminal (void) 299 { 300 } 301 302 #ifdef TUI_USE_PIPE_FOR_READLINE 303 /* Read readline output pipe and feed the command window with it. 304 Should be removed when readline is clean. */ 305 static void 306 tui_readline_output (int error, gdb_client_data data) 307 { 308 int size; 309 char buf[256]; 310 311 size = read (tui_readline_pipe[0], buf, sizeof (buf) - 1); 312 if (size > 0 && tui_active) 313 { 314 buf[size] = 0; 315 tui_puts (buf); 316 } 317 } 318 #endif 319 320 /* Return the portion of PATHNAME that should be output when listing 321 possible completions. If we are hacking filename completion, we 322 are only interested in the basename, the portion following the 323 final slash. Otherwise, we return what we were passed. 324 325 Comes from readline/complete.c. */ 326 static char * 327 printable_part (char *pathname) 328 { 329 char *temp; 330 331 temp = rl_filename_completion_desired ? strrchr (pathname, '/') : (char *)NULL; 332 #if defined (__MSDOS__) 333 if (rl_filename_completion_desired 334 && temp == 0 && isalpha (pathname[0]) 335 && pathname[1] == ':') 336 temp = pathname + 1; 337 #endif 338 return (temp ? ++temp : pathname); 339 } 340 341 /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and 342 we are using it, check for and output a single character for 343 `special' filenames. Return the number of characters we 344 output. */ 345 346 #define PUTX(c) \ 347 do { \ 348 if (CTRL_CHAR (c)) \ 349 { \ 350 tui_puts ("^"); \ 351 tui_putc (UNCTRL (c)); \ 352 printed_len += 2; \ 353 } \ 354 else if (c == RUBOUT) \ 355 { \ 356 tui_puts ("^?"); \ 357 printed_len += 2; \ 358 } \ 359 else \ 360 { \ 361 tui_putc (c); \ 362 printed_len++; \ 363 } \ 364 } while (0) 365 366 static int 367 print_filename (char *to_print, char *full_pathname) 368 { 369 int printed_len = 0; 370 char *s; 371 372 for (s = to_print; *s; s++) 373 { 374 PUTX (*s); 375 } 376 return printed_len; 377 } 378 379 /* The user must press "y" or "n". Non-zero return means "y" pressed. 380 Comes from readline/complete.c. */ 381 static int 382 get_y_or_n (void) 383 { 384 extern int _rl_abort_internal (); 385 int c; 386 387 for (;;) 388 { 389 c = rl_read_key (); 390 if (c == 'y' || c == 'Y' || c == ' ') 391 return (1); 392 if (c == 'n' || c == 'N' || c == RUBOUT) 393 return (0); 394 if (c == ABORT_CHAR) 395 _rl_abort_internal (); 396 beep (); 397 } 398 } 399 400 /* A convenience function for displaying a list of strings in 401 columnar format on readline's output stream. MATCHES is the list 402 of strings, in argv format, LEN is the number of strings in MATCHES, 403 and MAX is the length of the longest string in MATCHES. 404 405 Comes from readline/complete.c and modified to write in 406 the TUI command window using tui_putc/tui_puts. */ 407 static void 408 tui_rl_display_match_list (char **matches, int len, int max) 409 { 410 typedef int QSFUNC (const void *, const void *); 411 412 int count, limit, printed_len; 413 int i, j, k, l; 414 char *temp; 415 416 /* Screen dimension correspond to the TUI command window. */ 417 int screenwidth = TUI_CMD_WIN->generic.width; 418 419 /* If there are many items, then ask the user if she really wants to 420 see them all. */ 421 if (len >= rl_completion_query_items) 422 { 423 char msg[256]; 424 425 sprintf (msg, "\nDisplay all %d possibilities? (y or n)", len); 426 tui_puts (msg); 427 if (get_y_or_n () == 0) 428 { 429 tui_puts ("\n"); 430 return; 431 } 432 } 433 434 /* How many items of MAX length can we fit in the screen window? */ 435 max += 2; 436 limit = screenwidth / max; 437 if (limit != 1 && (limit * max == screenwidth)) 438 limit--; 439 440 /* Avoid a possible floating exception. If max > screenwidth, limit 441 will be 0 and a divide-by-zero fault will result. */ 442 if (limit == 0) 443 limit = 1; 444 445 /* How many iterations of the printing loop? */ 446 count = (len + (limit - 1)) / limit; 447 448 /* Watch out for special case. If LEN is less than LIMIT, then 449 just do the inner printing loop. 450 0 < len <= limit implies count = 1. */ 451 452 /* Sort the items if they are not already sorted. */ 453 if (rl_ignore_completion_duplicates == 0) 454 qsort (matches + 1, len, sizeof (char *), 455 (QSFUNC *)_rl_qsort_string_compare); 456 457 tui_putc ('\n'); 458 459 if (_rl_print_completions_horizontally == 0) 460 { 461 /* Print the sorted items, up-and-down alphabetically, like ls. */ 462 for (i = 1; i <= count; i++) 463 { 464 for (j = 0, l = i; j < limit; j++) 465 { 466 if (l > len || matches[l] == 0) 467 break; 468 else 469 { 470 temp = printable_part (matches[l]); 471 printed_len = print_filename (temp, matches[l]); 472 473 if (j + 1 < limit) 474 for (k = 0; k < max - printed_len; k++) 475 tui_putc (' '); 476 } 477 l += count; 478 } 479 tui_putc ('\n'); 480 } 481 } 482 else 483 { 484 /* Print the sorted items, across alphabetically, like ls -x. */ 485 for (i = 1; matches[i]; i++) 486 { 487 temp = printable_part (matches[i]); 488 printed_len = print_filename (temp, matches[i]); 489 /* Have we reached the end of this line? */ 490 if (matches[i+1]) 491 { 492 if (i && (limit > 1) && (i % limit) == 0) 493 tui_putc ('\n'); 494 else 495 for (k = 0; k < max - printed_len; k++) 496 tui_putc (' '); 497 } 498 } 499 tui_putc ('\n'); 500 } 501 } 502 503 /* Setup the IO for curses or non-curses mode. 504 - In non-curses mode, readline and gdb use the standard input and 505 standard output/error directly. 506 - In curses mode, the standard output/error is controlled by TUI 507 with the tui_stdout and tui_stderr. The output is redirected in 508 the curses command window. Several readline callbacks are installed 509 so that readline asks for its input to the curses command window 510 with wgetch(). */ 511 void 512 tui_setup_io (int mode) 513 { 514 extern int readline_echoing_p; 515 516 if (mode) 517 { 518 /* Redirect readline to TUI. */ 519 tui_old_rl_redisplay_function = rl_redisplay_function; 520 tui_old_rl_deprep_terminal = rl_deprep_term_function; 521 tui_old_rl_prep_terminal = rl_prep_term_function; 522 tui_old_rl_getc_function = rl_getc_function; 523 tui_old_rl_outstream = rl_outstream; 524 tui_old_readline_echoing_p = readline_echoing_p; 525 rl_redisplay_function = tui_redisplay_readline; 526 rl_deprep_term_function = tui_deprep_terminal; 527 rl_prep_term_function = tui_prep_terminal; 528 rl_getc_function = tui_getc; 529 readline_echoing_p = 0; 530 rl_outstream = tui_rl_outstream; 531 rl_prompt = 0; 532 rl_completion_display_matches_hook = tui_rl_display_match_list; 533 rl_already_prompted = 0; 534 535 /* Keep track of previous gdb output. */ 536 tui_old_stdout = gdb_stdout; 537 tui_old_stderr = gdb_stderr; 538 tui_old_uiout = uiout; 539 540 /* Reconfigure gdb output. */ 541 gdb_stdout = tui_stdout; 542 gdb_stderr = tui_stderr; 543 gdb_stdlog = gdb_stdout; /* for moment */ 544 gdb_stdtarg = gdb_stderr; /* for moment */ 545 uiout = tui_out; 546 547 /* Save tty for SIGCONT. */ 548 savetty (); 549 } 550 else 551 { 552 /* Restore gdb output. */ 553 gdb_stdout = tui_old_stdout; 554 gdb_stderr = tui_old_stderr; 555 gdb_stdlog = gdb_stdout; /* for moment */ 556 gdb_stdtarg = gdb_stderr; /* for moment */ 557 uiout = tui_old_uiout; 558 559 /* Restore readline. */ 560 rl_redisplay_function = tui_old_rl_redisplay_function; 561 rl_deprep_term_function = tui_old_rl_deprep_terminal; 562 rl_prep_term_function = tui_old_rl_prep_terminal; 563 rl_getc_function = tui_old_rl_getc_function; 564 rl_outstream = tui_old_rl_outstream; 565 rl_completion_display_matches_hook = 0; 566 readline_echoing_p = tui_old_readline_echoing_p; 567 rl_already_prompted = 0; 568 569 /* Save tty for SIGCONT. */ 570 savetty (); 571 } 572 } 573 574 #ifdef SIGCONT 575 /* Catch SIGCONT to restore the terminal and refresh the screen. */ 576 static void 577 tui_cont_sig (int sig) 578 { 579 if (tui_active) 580 { 581 /* Restore the terminal setting because another process (shell) 582 might have changed it. */ 583 resetty (); 584 585 /* Force a refresh of the screen. */ 586 tui_refresh_all_win (); 587 588 /* Update cursor position on the screen. */ 589 wmove (TUI_CMD_WIN->generic.handle, 590 TUI_CMD_WIN->detail.command_info.start_line, 591 TUI_CMD_WIN->detail.command_info.curch); 592 wrefresh (TUI_CMD_WIN->generic.handle); 593 } 594 signal (sig, tui_cont_sig); 595 } 596 #endif 597 598 /* Initialize the IO for gdb in curses mode. */ 599 void 600 tui_initialize_io (void) 601 { 602 #ifdef SIGCONT 603 signal (SIGCONT, tui_cont_sig); 604 #endif 605 606 /* Create tui output streams. */ 607 tui_stdout = tui_fileopen (stdout); 608 tui_stderr = tui_fileopen (stderr); 609 tui_out = tui_out_new (tui_stdout); 610 611 /* Create the default UI. It is not created because we installed a 612 deprecated_init_ui_hook. */ 613 tui_old_uiout = uiout = cli_out_new (gdb_stdout); 614 615 #ifdef TUI_USE_PIPE_FOR_READLINE 616 /* Temporary solution for readline writing to stdout: redirect 617 readline output in a pipe, read that pipe and output the content 618 in the curses command window. */ 619 if (pipe (tui_readline_pipe) != 0) 620 { 621 fprintf_unfiltered (gdb_stderr, "Cannot create pipe for readline"); 622 exit (1); 623 } 624 tui_rl_outstream = fdopen (tui_readline_pipe[1], "w"); 625 if (tui_rl_outstream == 0) 626 { 627 fprintf_unfiltered (gdb_stderr, "Cannot redirect readline output"); 628 exit (1); 629 } 630 setvbuf (tui_rl_outstream, (char*) NULL, _IOLBF, 0); 631 632 #ifdef O_NONBLOCK 633 (void) fcntl (tui_readline_pipe[0], F_SETFL, O_NONBLOCK); 634 #else 635 #ifdef O_NDELAY 636 (void) fcntl (tui_readline_pipe[0], F_SETFL, O_NDELAY); 637 #endif 638 #endif 639 add_file_handler (tui_readline_pipe[0], tui_readline_output, 0); 640 #else 641 tui_rl_outstream = stdout; 642 #endif 643 } 644 645 /* Get a character from the command window. This is called from the 646 readline package. */ 647 int 648 tui_getc (FILE *fp) 649 { 650 int ch; 651 WINDOW *w; 652 653 w = TUI_CMD_WIN->generic.handle; 654 655 #ifdef TUI_USE_PIPE_FOR_READLINE 656 /* Flush readline output. */ 657 tui_readline_output (0, 0); 658 #endif 659 660 ch = wgetch (w); 661 ch = tui_handle_resize_during_io (ch); 662 663 /* The \n must be echoed because it will not be printed by 664 readline. */ 665 if (ch == '\n') 666 { 667 /* When hitting return with an empty input, gdb executes the last 668 command. If we emit a newline, this fills up the command window 669 with empty lines with gdb prompt at beginning. Instead of that, 670 stay on the same line but provide a visual effect to show the 671 user we recognized the command. */ 672 if (rl_end == 0) 673 { 674 wmove (w, TUI_CMD_WIN->detail.command_info.cur_line, 0); 675 676 /* Clear the line. This will blink the gdb prompt since 677 it will be redrawn at the same line. */ 678 wclrtoeol (w); 679 wrefresh (w); 680 napms (20); 681 } 682 else 683 { 684 wmove (w, TUI_CMD_WIN->detail.command_info.cur_line, 685 TUI_CMD_WIN->detail.command_info.curch); 686 waddch (w, ch); 687 } 688 } 689 690 if (key_is_command_char (ch)) 691 { /* Handle prev/next/up/down here. */ 692 ch = tui_dispatch_ctrl_char (ch); 693 } 694 695 if (ch == '\n' || ch == '\r' || ch == '\f') 696 TUI_CMD_WIN->detail.command_info.curch = 0; 697 if (ch == KEY_BACKSPACE) 698 return '\b'; 699 700 return ch; 701 } 702 703 704 /* Cleanup when a resize has occured. 705 Returns the character that must be processed. */ 706 static unsigned int 707 tui_handle_resize_during_io (unsigned int original_ch) 708 { 709 if (tui_win_resized ()) 710 { 711 tui_refresh_all_win (); 712 dont_repeat (); 713 tui_set_win_resized_to (FALSE); 714 return '\n'; 715 } 716 else 717 return original_ch; 718 } 719