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