1 /* TUI support I/O functions.
3 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
6 Contributed by Hewlett-Packard Company.
8 This file is part of GDB.
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 2 of the License, or
13 (at your option) any later version.
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.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
28 #include "event-loop.h"
29 #include "event-top.h"
32 #include "readline/readline.h"
34 #include "tui/tui-data.h"
35 #include "tui/tui-io.h"
36 #include "tui/tui-command.h"
37 #include "tui/tui-win.h"
38 #include "tui/tui-wingeneral.h"
39 #include "tui/tui-file.h"
46 #include "gdb_curses.h"
49 key_is_start_sequence (int ch)
55 key_is_end_sequence (int ch)
61 key_is_backspace (int ch)
67 key_is_command_char (int ch)
69 return ((ch == KEY_NPAGE) || (ch == KEY_PPAGE)
70 || (ch == KEY_LEFT) || (ch == KEY_RIGHT)
71 || (ch == KEY_UP) || (ch == KEY_DOWN)
72 || (ch == KEY_SF) || (ch == KEY_SR)
73 || (ch == (int)'\f') || key_is_start_sequence (ch));
76 /* Use definition from readline 4.3. */
78 #define CTRL_CHAR(c) ((c) < control_character_threshold && (((c) & 0x80) == 0))
80 /* This file controls the IO interactions between gdb and curses.
81 When the TUI is enabled, gdb has two modes a curses and a standard
84 In curses mode, the gdb outputs are made in a curses command window.
85 For this, the gdb_stdout and gdb_stderr are redirected to the specific
86 ui_file implemented by TUI. The output is handled by tui_puts().
87 The input is also controlled by curses with tui_getc(). The readline
88 library uses this function to get its input. Several readline hooks
89 are installed to redirect readline output to the TUI (see also the
92 In normal mode, the gdb outputs are restored to their origin, that
93 is as if TUI is not used. Readline also uses its original getc()
96 Note SCz/2001-07-21: the current readline is not clean in its management of
97 the output. Even if we install a redisplay handler, it sometimes writes on
98 a stdout file. It is important to redirect every output produced by
99 readline, otherwise the curses window will be garbled. This is implemented
100 with a pipe that TUI reads and readline writes to. A gdb input handler
101 is created so that reading the pipe is handled automatically.
102 This will probably not work on non-Unix platforms. The best fix is
103 to make readline clean enougth so that is never write on stdout.
105 Note SCz/2002-09-01: we now use more readline hooks and it seems that
106 with them we don't need the pipe anymore (verified by creating the pipe
107 and closing its end so that write causes a SIGPIPE). The old pipe code
108 is still there and can be conditionally removed by
109 #undef TUI_USE_PIPE_FOR_READLINE. */
111 /* For gdb 5.3, prefer to continue the pipe hack as a backup wheel. */
112 #define TUI_USE_PIPE_FOR_READLINE
113 /*#undef TUI_USE_PIPE_FOR_READLINE*/
115 /* TUI output files. */
116 static struct ui_file *tui_stdout;
117 static struct ui_file *tui_stderr;
118 struct ui_out *tui_out;
120 /* GDB output files in non-curses mode. */
121 static struct ui_file *tui_old_stdout;
122 static struct ui_file *tui_old_stderr;
123 struct ui_out *tui_old_uiout;
125 /* Readline previous hooks. */
126 static Function *tui_old_rl_getc_function;
127 static VFunction *tui_old_rl_redisplay_function;
128 static VFunction *tui_old_rl_prep_terminal;
129 static VFunction *tui_old_rl_deprep_terminal;
130 static int tui_old_readline_echoing_p;
132 /* Readline output stream.
133 Should be removed when readline is clean. */
134 static FILE *tui_rl_outstream;
135 static FILE *tui_old_rl_outstream;
136 #ifdef TUI_USE_PIPE_FOR_READLINE
137 static int tui_readline_pipe[2];
140 /* The last gdb prompt that was registered in readline.
141 This may be the main gdb prompt or a secondary prompt. */
142 static char *tui_rl_saved_prompt;
144 static unsigned int tui_handle_resize_during_io (unsigned int);
156 /* Print the string in the curses command window. */
158 tui_puts (const char *string)
160 static int tui_skip_line = -1;
164 w = TUI_CMD_WIN->generic.handle;
165 while ((c = *string++) != 0)
167 /* Catch annotation and discard them. We need two \032 and
168 discard until a \n is seen. */
173 else if (tui_skip_line != 1)
181 getyx (w, TUI_CMD_WIN->detail.command_info.cur_line,
182 TUI_CMD_WIN->detail.command_info.curch);
183 TUI_CMD_WIN->detail.command_info.start_line = TUI_CMD_WIN->detail.command_info.cur_line;
185 /* We could defer the following. */
190 /* Readline callback.
191 Redisplay the command line with its prompt after readline has
192 changed the edited text. */
194 tui_redisplay_readline (void)
206 /* Detect when we temporarily left SingleKey and now the readline
207 edit buffer is empty, automatically restore the SingleKey mode. */
208 if (tui_current_key_mode == TUI_ONE_COMMAND_MODE && rl_end == 0)
209 tui_set_key_mode (TUI_SINGLE_KEY_MODE);
211 if (tui_current_key_mode == TUI_SINGLE_KEY_MODE)
214 prompt = tui_rl_saved_prompt;
218 w = TUI_CMD_WIN->generic.handle;
219 start_line = TUI_CMD_WIN->detail.command_info.start_line;
220 wmove (w, start_line, 0);
223 for (in = 0; prompt && prompt[in]; in++)
225 waddch (w, prompt[in]);
226 getyx (w, line, col);
231 for (in = 0; in < rl_end; in++)
235 c = (unsigned char) rl_line_buffer[in];
238 getyx (w, c_line, c_pos);
241 if (CTRL_CHAR (c) || c == RUBOUT)
244 waddch (w, CTRL_CHAR (c) ? UNCTRL (c) : '?');
252 getyx (w, TUI_CMD_WIN->detail.command_info.start_line,
253 TUI_CMD_WIN->detail.command_info.curch);
255 getyx (w, line, col);
261 getyx (w, TUI_CMD_WIN->detail.command_info.start_line,
262 TUI_CMD_WIN->detail.command_info.curch);
265 wmove (w, c_line, c_pos);
266 TUI_CMD_WIN->detail.command_info.cur_line = c_line;
267 TUI_CMD_WIN->detail.command_info.curch = c_pos;
269 TUI_CMD_WIN->detail.command_info.start_line -= height - 1;
275 /* Readline callback to prepare the terminal. It is called once
276 each time we enter readline. Terminal is already setup in curses mode. */
278 tui_prep_terminal (int notused1)
280 /* Save the prompt registered in readline to correctly display it.
281 (we can't use gdb_prompt() due to secondary prompts and can't use
282 rl_prompt because it points to an alloca buffer). */
283 xfree (tui_rl_saved_prompt);
284 tui_rl_saved_prompt = xstrdup (rl_prompt);
287 /* Readline callback to restore the terminal. It is called once
288 each time we leave readline. There is nothing to do in curses mode. */
290 tui_deprep_terminal (void)
294 #ifdef TUI_USE_PIPE_FOR_READLINE
295 /* Read readline output pipe and feed the command window with it.
296 Should be removed when readline is clean. */
298 tui_readline_output (int code, gdb_client_data data)
303 size = read (tui_readline_pipe[0], buf, sizeof (buf) - 1);
304 if (size > 0 && tui_active)
312 /* Return the portion of PATHNAME that should be output when listing
313 possible completions. If we are hacking filename completion, we
314 are only interested in the basename, the portion following the
315 final slash. Otherwise, we return what we were passed.
317 Comes from readline/complete.c */
319 printable_part (char *pathname)
323 temp = rl_filename_completion_desired ? strrchr (pathname, '/') : (char *)NULL;
324 #if defined (__MSDOS__)
325 if (rl_filename_completion_desired && temp == 0 && isalpha (pathname[0]) && pathname[1] == ':')
328 return (temp ? ++temp : pathname);
331 /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
332 are using it, check for and output a single character for `special'
333 filenames. Return the number of characters we output. */
340 tui_putc (UNCTRL (c)); \
343 else if (c == RUBOUT) \
356 print_filename (char *to_print, char *full_pathname)
361 for (s = to_print; *s; s++)
368 /* The user must press "y" or "n". Non-zero return means "y" pressed.
369 Comes from readline/complete.c */
373 extern int _rl_abort_internal ();
379 if (c == 'y' || c == 'Y' || c == ' ')
381 if (c == 'n' || c == 'N' || c == RUBOUT)
384 _rl_abort_internal ();
389 /* A convenience function for displaying a list of strings in
390 columnar format on readline's output stream. MATCHES is the list
391 of strings, in argv format, LEN is the number of strings in MATCHES,
392 and MAX is the length of the longest string in MATCHES.
394 Comes from readline/complete.c and modified to write in
395 the TUI command window using tui_putc/tui_puts. */
397 tui_rl_display_match_list (char **matches, int len, int max)
399 typedef int QSFUNC (const void *, const void *);
400 extern int _rl_qsort_string_compare (const void*, const void*);
401 extern int _rl_print_completions_horizontally;
403 int count, limit, printed_len;
407 /* Screen dimension correspond to the TUI command window. */
408 int screenwidth = TUI_CMD_WIN->generic.width;
410 /* If there are many items, then ask the user if she really wants to
412 if (len >= rl_completion_query_items)
416 sprintf (msg, "\nDisplay all %d possibilities? (y or n)", len);
418 if (get_y_or_n () == 0)
425 /* How many items of MAX length can we fit in the screen window? */
427 limit = screenwidth / max;
428 if (limit != 1 && (limit * max == screenwidth))
431 /* Avoid a possible floating exception. If max > screenwidth,
432 limit will be 0 and a divide-by-zero fault will result. */
436 /* How many iterations of the printing loop? */
437 count = (len + (limit - 1)) / limit;
439 /* Watch out for special case. If LEN is less than LIMIT, then
440 just do the inner printing loop.
441 0 < len <= limit implies count = 1. */
443 /* Sort the items if they are not already sorted. */
444 if (rl_ignore_completion_duplicates == 0)
445 qsort (matches + 1, len, sizeof (char *),
446 (QSFUNC *)_rl_qsort_string_compare);
450 if (_rl_print_completions_horizontally == 0)
452 /* Print the sorted items, up-and-down alphabetically, like ls. */
453 for (i = 1; i <= count; i++)
455 for (j = 0, l = i; j < limit; j++)
457 if (l > len || matches[l] == 0)
461 temp = printable_part (matches[l]);
462 printed_len = print_filename (temp, matches[l]);
465 for (k = 0; k < max - printed_len; k++)
475 /* Print the sorted items, across alphabetically, like ls -x. */
476 for (i = 1; matches[i]; i++)
478 temp = printable_part (matches[i]);
479 printed_len = print_filename (temp, matches[i]);
480 /* Have we reached the end of this line? */
483 if (i && (limit > 1) && (i % limit) == 0)
486 for (k = 0; k < max - printed_len; k++)
494 /* Setup the IO for curses or non-curses mode.
495 - In non-curses mode, readline and gdb use the standard input and
496 standard output/error directly.
497 - In curses mode, the standard output/error is controlled by TUI
498 with the tui_stdout and tui_stderr. The output is redirected in
499 the curses command window. Several readline callbacks are installed
500 so that readline asks for its input to the curses command window
503 tui_setup_io (int mode)
505 extern int readline_echoing_p;
509 /* Redirect readline to TUI. */
510 tui_old_rl_redisplay_function = rl_redisplay_function;
511 tui_old_rl_deprep_terminal = rl_deprep_term_function;
512 tui_old_rl_prep_terminal = rl_prep_term_function;
513 tui_old_rl_getc_function = rl_getc_function;
514 tui_old_rl_outstream = rl_outstream;
515 tui_old_readline_echoing_p = readline_echoing_p;
516 rl_redisplay_function = tui_redisplay_readline;
517 rl_deprep_term_function = tui_deprep_terminal;
518 rl_prep_term_function = tui_prep_terminal;
519 rl_getc_function = tui_getc;
520 readline_echoing_p = 0;
521 rl_outstream = tui_rl_outstream;
523 rl_completion_display_matches_hook = tui_rl_display_match_list;
524 rl_already_prompted = 0;
526 /* Keep track of previous gdb output. */
527 tui_old_stdout = gdb_stdout;
528 tui_old_stderr = gdb_stderr;
529 tui_old_uiout = uiout;
531 /* Reconfigure gdb output. */
532 gdb_stdout = tui_stdout;
533 gdb_stderr = tui_stderr;
534 gdb_stdlog = gdb_stdout; /* for moment */
535 gdb_stdtarg = gdb_stderr; /* for moment */
538 /* Save tty for SIGCONT. */
543 /* Restore gdb output. */
544 gdb_stdout = tui_old_stdout;
545 gdb_stderr = tui_old_stderr;
546 gdb_stdlog = gdb_stdout; /* for moment */
547 gdb_stdtarg = gdb_stderr; /* for moment */
548 uiout = tui_old_uiout;
550 /* Restore readline. */
551 rl_redisplay_function = tui_old_rl_redisplay_function;
552 rl_deprep_term_function = tui_old_rl_deprep_terminal;
553 rl_prep_term_function = tui_old_rl_prep_terminal;
554 rl_getc_function = tui_old_rl_getc_function;
555 rl_outstream = tui_old_rl_outstream;
556 rl_completion_display_matches_hook = 0;
557 readline_echoing_p = tui_old_readline_echoing_p;
558 rl_already_prompted = 0;
560 /* Save tty for SIGCONT. */
566 /* Catch SIGCONT to restore the terminal and refresh the screen. */
568 tui_cont_sig (int sig)
572 /* Restore the terminal setting because another process (shell)
573 might have changed it. */
576 /* Force a refresh of the screen. */
577 tui_refresh_all_win ();
579 /* Update cursor position on the screen. */
580 wmove (TUI_CMD_WIN->generic.handle,
581 TUI_CMD_WIN->detail.command_info.start_line,
582 TUI_CMD_WIN->detail.command_info.curch);
583 wrefresh (TUI_CMD_WIN->generic.handle);
585 signal (sig, tui_cont_sig);
589 /* Initialize the IO for gdb in curses mode. */
591 tui_initialize_io (void)
594 signal (SIGCONT, tui_cont_sig);
597 /* Create tui output streams. */
598 tui_stdout = tui_fileopen (stdout);
599 tui_stderr = tui_fileopen (stderr);
600 tui_out = tui_out_new (tui_stdout);
602 /* Create the default UI. It is not created because we installed
604 tui_old_uiout = uiout = cli_out_new (gdb_stdout);
606 #ifdef TUI_USE_PIPE_FOR_READLINE
607 /* Temporary solution for readline writing to stdout:
608 redirect readline output in a pipe, read that pipe and
609 output the content in the curses command window. */
610 if (pipe (tui_readline_pipe) != 0)
612 fprintf_unfiltered (gdb_stderr, "Cannot create pipe for readline");
615 tui_rl_outstream = fdopen (tui_readline_pipe[1], "w");
616 if (tui_rl_outstream == 0)
618 fprintf_unfiltered (gdb_stderr, "Cannot redirect readline output");
621 setvbuf (tui_rl_outstream, (char*) NULL, _IOLBF, 0);
624 (void) fcntl (tui_readline_pipe[0], F_SETFL, O_NONBLOCK);
627 (void) fcntl (tui_readline_pipe[0], F_SETFL, O_NDELAY);
630 add_file_handler (tui_readline_pipe[0], tui_readline_output, 0);
632 tui_rl_outstream = stdout;
636 /* Get a character from the command window. This is called from the readline
644 w = TUI_CMD_WIN->generic.handle;
646 #ifdef TUI_USE_PIPE_FOR_READLINE
647 /* Flush readline output. */
648 tui_readline_output (GDB_READABLE, 0);
652 ch = tui_handle_resize_during_io (ch);
654 /* The \n must be echoed because it will not be printed by readline. */
657 /* When hitting return with an empty input, gdb executes the last
658 command. If we emit a newline, this fills up the command window
659 with empty lines with gdb prompt at beginning. Instead of that,
660 stay on the same line but provide a visual effect to show the
661 user we recognized the command. */
664 wmove (w, TUI_CMD_WIN->detail.command_info.cur_line, 0);
666 /* Clear the line. This will blink the gdb prompt since
667 it will be redrawn at the same line. */
674 wmove (w, TUI_CMD_WIN->detail.command_info.cur_line,
675 TUI_CMD_WIN->detail.command_info.curch);
680 if (key_is_command_char (ch))
681 { /* Handle prev/next/up/down here */
682 ch = tui_dispatch_ctrl_char (ch);
685 if (ch == '\n' || ch == '\r' || ch == '\f')
686 TUI_CMD_WIN->detail.command_info.curch = 0;
687 if (ch == KEY_BACKSPACE)
694 /* Cleanup when a resize has occured.
695 Returns the character that must be processed. */
697 tui_handle_resize_during_io (unsigned int original_ch)
699 if (tui_win_resized ())
701 tui_refresh_all_win ();
703 tui_set_win_resized_to (FALSE);