GDB (xrefs)
tui-io.c
Go to the documentation of this file.
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
50 {
51  return (ch == 27);
52 }
53 
54 int
56 {
57  return (ch == 126);
58 }
59 
60 int
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;
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;
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  getyx (w, TUI_CMD_WIN->detail.command_info.cur_line,
191  TUI_CMD_WIN->detail.command_info.curch);
192  TUI_CMD_WIN->detail.command_info.start_line
193  = TUI_CMD_WIN->detail.command_info.cur_line;
194 }
195 
196 /* Readline callback.
197  Redisplay the command line with its prompt after readline has
198  changed the edited text. */
199 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. The restore must only be done if the command has finished.
215  The command could call prompt_for_continue and we must not
216  restore SingleKey so that the prompt and normal keymap are used. */
217  if (tui_current_key_mode == TUI_ONE_COMMAND_MODE && rl_end == 0
218  && immediate_quit == 0)
220 
222  prompt = "";
223  else
224  prompt = tui_rl_saved_prompt;
225 
226  c_pos = -1;
227  c_line = -1;
228  w = TUI_CMD_WIN->generic.handle;
229  start_line = TUI_CMD_WIN->detail.command_info.start_line;
230  wmove (w, start_line, 0);
231  prev_col = 0;
232  height = 1;
233  for (in = 0; prompt && prompt[in]; in++)
234  {
235  waddch (w, prompt[in]);
236  getyx (w, line, col);
237  if (col <= prev_col)
238  height++;
239  prev_col = col;
240  }
241  for (in = 0; in <= rl_end; in++)
242  {
243  unsigned char c;
244 
245  if (in == rl_point)
246  {
247  getyx (w, c_line, c_pos);
248  }
249 
250  if (in == rl_end)
251  break;
252 
253  c = (unsigned char) rl_line_buffer[in];
254  if (CTRL_CHAR (c) || c == RUBOUT)
255  {
256  waddch (w, '^');
257  waddch (w, CTRL_CHAR (c) ? UNCTRL (c) : '?');
258  }
259  else if (c == '\t')
260  {
261  /* Expand TABs, since ncurses on MS-Windows doesn't. */
262  getyx (w, line, col);
263  do
264  {
265  waddch (w, ' ');
266  col++;
267  } while ((col % 8) != 0);
268  }
269  else
270  {
271  waddch (w, c);
272  }
273  if (c == '\n')
274  {
275  getyx (w, TUI_CMD_WIN->detail.command_info.start_line,
276  TUI_CMD_WIN->detail.command_info.curch);
277  }
278  getyx (w, line, col);
279  if (col < prev_col)
280  height++;
281  prev_col = col;
282  }
283  wclrtobot (w);
284  getyx (w, TUI_CMD_WIN->detail.command_info.start_line,
285  TUI_CMD_WIN->detail.command_info.curch);
286  if (c_line >= 0)
287  {
288  wmove (w, c_line, c_pos);
289  TUI_CMD_WIN->detail.command_info.cur_line = c_line;
290  TUI_CMD_WIN->detail.command_info.curch = c_pos;
291  }
292  TUI_CMD_WIN->detail.command_info.start_line -= height - 1;
293 
294  wrefresh (w);
295  fflush(stdout);
296 }
297 
298 /* Readline callback to prepare the terminal. It is called once each
299  time we enter readline. Terminal is already setup in curses
300  mode. */
301 static void
302 tui_prep_terminal (int notused1)
303 {
304  /* Save the prompt registered in readline to correctly display it.
305  (we can't use gdb_prompt() due to secondary prompts and can't use
306  rl_prompt because it points to an alloca buffer). */
307  xfree (tui_rl_saved_prompt);
308  tui_rl_saved_prompt = rl_prompt != NULL ? xstrdup (rl_prompt) : NULL;
309 }
310 
311 /* Readline callback to restore the terminal. It is called once each
312  time we leave readline. There is nothing to do in curses mode. */
313 static void
315 {
316 }
317 
318 #ifdef TUI_USE_PIPE_FOR_READLINE
319 /* Read readline output pipe and feed the command window with it.
320  Should be removed when readline is clean. */
321 static void
323 {
324  int size;
325  char buf[256];
326 
327  size = read (tui_readline_pipe[0], buf, sizeof (buf) - 1);
328  if (size > 0 && tui_active)
329  {
330  buf[size] = 0;
331  tui_puts (buf);
332  }
333 }
334 #endif
335 
336 /* TUI version of displayer.crlf. */
337 
338 static void
339 tui_mld_crlf (const struct match_list_displayer *displayer)
340 {
341  tui_putc ('\n');
342 }
343 
344 /* TUI version of displayer.putch. */
345 
346 static void
347 tui_mld_putch (const struct match_list_displayer *displayer, int ch)
348 {
349  tui_putc (ch);
350 }
351 
352 /* TUI version of displayer.puts. */
353 
354 static void
355 tui_mld_puts (const struct match_list_displayer *displayer, const char *s)
356 {
357  tui_puts (s);
358 }
359 
360 /* TUI version of displayer.flush. */
361 
362 static void
363 tui_mld_flush (const struct match_list_displayer *displayer)
364 {
365  wrefresh (TUI_CMD_WIN->generic.handle);
366 }
367 
368 /* TUI version of displayer.erase_entire_line. */
369 
370 static void
372 {
373  WINDOW *w = TUI_CMD_WIN->generic.handle;
374 
375  wmove (w, TUI_CMD_WIN->detail.command_info.cur_line, 0);
376  wclrtoeol (w);
377  wmove (w, TUI_CMD_WIN->detail.command_info.cur_line, 0);
378 }
379 
380 /* TUI version of displayer.beep. */
381 
382 static void
383 tui_mld_beep (const struct match_list_displayer *displayer)
384 {
385  beep ();
386 }
387 
388 /* Helper function for tui_mld_read_key.
389  This temporarily replaces tui_getc for use during tab-completion
390  match list display. */
391 
392 static int
393 tui_mld_getc (FILE *fp)
394 {
395  WINDOW *w = TUI_CMD_WIN->generic.handle;
396  int c = wgetch (w);
397 
398  return c;
399 }
400 
401 /* TUI version of displayer.read_key. */
402 
403 static int
404 tui_mld_read_key (const struct match_list_displayer *displayer)
405 {
406  rl_getc_func_t *prev = rl_getc_function;
407  int c;
408 
409  /* We can't use tui_getc as we need NEWLINE to not get emitted. */
410  rl_getc_function = tui_mld_getc;
411  c = rl_read_key ();
412  rl_getc_function = prev;
413  return c;
414 }
415 
416 /* TUI version of rl_completion_display_matches_hook.
417  See gdb_display_match_list for a description of the arguments. */
418 
419 static void
420 tui_rl_display_match_list (char **matches, int len, int max)
421 {
422  struct match_list_displayer displayer;
423 
424  rl_get_screen_size (&displayer.height, &displayer.width);
425  displayer.crlf = tui_mld_crlf;
426  displayer.putch = tui_mld_putch;
427  displayer.puts = tui_mld_puts;
428  displayer.flush = tui_mld_flush;
430  displayer.beep = tui_mld_beep;
431  displayer.read_key = tui_mld_read_key;
432 
433  gdb_display_match_list (matches, len, max, &displayer);
434 }
435 
436 /* Setup the IO for curses or non-curses mode.
437  - In non-curses mode, readline and gdb use the standard input and
438  standard output/error directly.
439  - In curses mode, the standard output/error is controlled by TUI
440  with the tui_stdout and tui_stderr. The output is redirected in
441  the curses command window. Several readline callbacks are installed
442  so that readline asks for its input to the curses command window
443  with wgetch(). */
444 void
445 tui_setup_io (int mode)
446 {
447  extern int _rl_echoing_p;
448 
449  if (mode)
450  {
451  /* Redirect readline to TUI. */
452  tui_old_rl_redisplay_function = rl_redisplay_function;
453  tui_old_rl_deprep_terminal = rl_deprep_term_function;
454  tui_old_rl_prep_terminal = rl_prep_term_function;
455  tui_old_rl_getc_function = rl_getc_function;
456  tui_old_rl_display_matches_hook = rl_completion_display_matches_hook;
457  tui_old_rl_outstream = rl_outstream;
458  tui_old_rl_echoing_p = _rl_echoing_p;
459  rl_redisplay_function = tui_redisplay_readline;
460  rl_deprep_term_function = tui_deprep_terminal;
461  rl_prep_term_function = tui_prep_terminal;
462  rl_getc_function = tui_getc;
463  _rl_echoing_p = 0;
464  rl_outstream = tui_rl_outstream;
465  rl_prompt = 0;
466  rl_completion_display_matches_hook = tui_rl_display_match_list;
467  rl_already_prompted = 0;
468 
469  /* Keep track of previous gdb output. */
470  tui_old_stdout = gdb_stdout;
471  tui_old_stderr = gdb_stderr;
472  tui_old_uiout = current_uiout;
473 
474  /* Reconfigure gdb output. */
477  gdb_stdlog = gdb_stdout; /* for moment */
478  gdb_stdtarg = gdb_stderr; /* for moment */
479  gdb_stdtargerr = gdb_stderr; /* for moment */
481 
482  /* Save tty for SIGCONT. */
483  savetty ();
484  }
485  else
486  {
487  /* Restore gdb output. */
490  gdb_stdlog = gdb_stdout; /* for moment */
491  gdb_stdtarg = gdb_stderr; /* for moment */
492  gdb_stdtargerr = gdb_stderr; /* for moment */
494 
495  /* Restore readline. */
496  rl_redisplay_function = tui_old_rl_redisplay_function;
497  rl_deprep_term_function = tui_old_rl_deprep_terminal;
498  rl_prep_term_function = tui_old_rl_prep_terminal;
499  rl_getc_function = tui_old_rl_getc_function;
500  rl_completion_display_matches_hook = tui_old_rl_display_matches_hook;
501  rl_outstream = tui_old_rl_outstream;
502  _rl_echoing_p = tui_old_rl_echoing_p;
503  rl_already_prompted = 0;
504 
505  /* Save tty for SIGCONT. */
506  savetty ();
507  }
508 }
509 
510 #ifdef SIGCONT
511 /* Catch SIGCONT to restore the terminal and refresh the screen. */
512 static void
513 tui_cont_sig (int sig)
514 {
515  if (tui_active)
516  {
517  /* Restore the terminal setting because another process (shell)
518  might have changed it. */
519  resetty ();
520 
521  /* Force a refresh of the screen. */
523 
524  /* Update cursor position on the screen. */
525  wmove (TUI_CMD_WIN->generic.handle,
526  TUI_CMD_WIN->detail.command_info.start_line,
527  TUI_CMD_WIN->detail.command_info.curch);
528  wrefresh (TUI_CMD_WIN->generic.handle);
529  }
530  signal (sig, tui_cont_sig);
531 }
532 #endif
533 
534 /* Initialize the IO for gdb in curses mode. */
535 void
537 {
538 #ifdef SIGCONT
539  signal (SIGCONT, tui_cont_sig);
540 #endif
541 
542  /* Create tui output streams. */
543  tui_stdout = tui_fileopen (stdout);
544  tui_stderr = tui_fileopen (stderr);
545  tui_out = tui_out_new (tui_stdout);
546 
547  /* Create the default UI. */
548  tui_old_uiout = cli_out_new (gdb_stdout);
549 
550 #ifdef TUI_USE_PIPE_FOR_READLINE
551  /* Temporary solution for readline writing to stdout: redirect
552  readline output in a pipe, read that pipe and output the content
553  in the curses command window. */
554  if (gdb_pipe_cloexec (tui_readline_pipe) != 0)
555  error (_("Cannot create pipe for readline"));
556 
557  tui_rl_outstream = fdopen (tui_readline_pipe[1], "w");
558  if (tui_rl_outstream == 0)
559  error (_("Cannot redirect readline output"));
560 
561  setvbuf (tui_rl_outstream, (char*) NULL, _IOLBF, 0);
562 
563 #ifdef O_NONBLOCK
564  (void) fcntl (tui_readline_pipe[0], F_SETFL, O_NONBLOCK);
565 #else
566 #ifdef O_NDELAY
567  (void) fcntl (tui_readline_pipe[0], F_SETFL, O_NDELAY);
568 #endif
569 #endif
570  add_file_handler (tui_readline_pipe[0], tui_readline_output, 0);
571 #else
572  tui_rl_outstream = stdout;
573 #endif
574 }
575 
576 /* Get a character from the command window. This is called from the
577  readline package. */
578 int
579 tui_getc (FILE *fp)
580 {
581  int ch;
582  WINDOW *w;
583 
584  w = TUI_CMD_WIN->generic.handle;
585 
586 #ifdef TUI_USE_PIPE_FOR_READLINE
587  /* Flush readline output. */
588  tui_readline_output (0, 0);
589 #endif
590 
591  ch = wgetch (w);
592 
593  /* The \n must be echoed because it will not be printed by
594  readline. */
595  if (ch == '\n')
596  {
597  /* When hitting return with an empty input, gdb executes the last
598  command. If we emit a newline, this fills up the command window
599  with empty lines with gdb prompt at beginning. Instead of that,
600  stay on the same line but provide a visual effect to show the
601  user we recognized the command. */
602  if (rl_end == 0)
603  {
604  wmove (w, TUI_CMD_WIN->detail.command_info.cur_line, 0);
605 
606  /* Clear the line. This will blink the gdb prompt since
607  it will be redrawn at the same line. */
608  wclrtoeol (w);
609  wrefresh (w);
610  napms (20);
611  }
612  else
613  {
614  /* Move cursor to the end of the command line before emitting the
615  newline. We need to do so because when ncurses outputs a newline
616  it truncates any text that appears past the end of the cursor. */
617  int px = TUI_CMD_WIN->detail.command_info.curch;
618  int py = TUI_CMD_WIN->detail.command_info.cur_line;
619  px += rl_end - rl_point;
620  py += px / TUI_CMD_WIN->generic.width;
621  px %= TUI_CMD_WIN->generic.width;
622  wmove (w, py, px);
623  waddch (w, ch);
624  }
625  }
626 
627  /* Handle prev/next/up/down here. */
628  ch = tui_dispatch_ctrl_char (ch);
629 
630  if (ch == '\n' || ch == '\r' || ch == '\f')
631  TUI_CMD_WIN->detail.command_info.curch = 0;
632  if (ch == KEY_BACKSPACE)
633  return '\b';
634 
636  {
637  int ch_pending;
638 
639  nodelay (w, TRUE);
640  ch_pending = wgetch (w);
641  nodelay (w, FALSE);
642 
643  /* If we have pending input following a start sequence, call the stdin
644  event handler again because ncurses may have already read and stored
645  the input into its internal buffer, meaning that we won't get an stdin
646  event for it. If we don't compensate for this missed stdin event, key
647  sequences as Alt_F (^[f) will not behave promptly.
648 
649  (We only compensates for the missed 2nd byte of a key sequence because
650  2-byte sequences are by far the most commonly used. ncurses may have
651  buffered a larger, 3+-byte key sequence though it remains to be seen
652  whether it is useful to compensate for all the bytes of such
653  sequences.) */
654  if (ch_pending != ERR)
655  {
656  ungetch (ch_pending);
658  }
659  }
660 
661  return ch;
662 }
663 
664 /* Utility function to expand TABs in a STRING into spaces. STRING
665  will be displayed starting at column COL, and is assumed to include
666  no newlines. The returned expanded string is malloc'ed. */
667 
668 char *
669 tui_expand_tabs (const char *string, int col)
670 {
671  int n_adjust, ncol;
672  const char *s;
673  char *ret, *q;
674 
675  /* 1. How many additional characters do we need? */
676  for (ncol = col, n_adjust = 0, s = string; s; )
677  {
678  s = strpbrk (s, "\t");
679  if (s)
680  {
681  ncol += (s - string) + n_adjust;
682  /* Adjustment for the next tab stop, minus one for the TAB
683  we replace with spaces. */
684  n_adjust += 8 - (ncol % 8) - 1;
685  s++;
686  }
687  }
688 
689  /* Allocate the copy. */
690  ret = q = xmalloc (strlen (string) + n_adjust + 1);
691 
692  /* 2. Copy the original string while replacing TABs with spaces. */
693  for (ncol = col, s = string; s; )
694  {
695  const char *s1 = strpbrk (s, "\t");
696  if (s1)
697  {
698  if (s1 > s)
699  {
700  strncpy (q, s, s1 - s);
701  q += s1 - s;
702  ncol += s1 - s;
703  }
704  do {
705  *q++ = ' ';
706  ncol++;
707  } while ((ncol % 8) != 0);
708  s1++;
709  }
710  else
711  strcpy (q, s);
712  s = s1;
713  }
714 
715  return ret;
716 }
static FILE * tui_rl_outstream
Definition: tui-io.c:129
const char * string
Definition: signals.c:50
ssize_t read(int fd, void *buf, size_t count)
Definition: expect-read1.c:26
mld_putch_ftype * putch
Definition: completer.h:47
static rl_vintfunc_t * tui_old_rl_prep_terminal
Definition: tui-io.c:122
static struct ui_file * tui_stderr
Definition: tui-io.c:111
void xfree(void *)
Definition: common-utils.c:97
int tui_active
Definition: tui.c:59
mld_crlf_ftype * crlf
Definition: completer.h:44
static struct ui_file * tui_stdout
Definition: tui-io.c:110
static rl_voidfunc_t * tui_old_rl_deprep_terminal
Definition: tui-io.c:123
static int tui_readline_pipe[2]
Definition: tui-io.c:132
int gdb_pipe_cloexec(int filedes[2])
Definition: filestuff.c:381
struct ui_file * gdb_stdout
Definition: main.c:71
struct ui_out * cli_out_new(struct ui_file *stream)
Definition: cli-out.c:400
static int tui_mld_read_key(const struct match_list_displayer *displayer)
Definition: tui-io.c:404
static char * tui_rl_saved_prompt
Definition: tui-io.c:137
static void tui_prep_terminal(int notused1)
Definition: tui-io.c:302
#define _(String)
Definition: gdb_locale.h:40
static void tui_mld_crlf(const struct match_list_displayer *displayer)
Definition: tui-io.c:339
static void tui_mld_puts(const struct match_list_displayer *displayer, const char *s)
Definition: tui-io.c:355
void tui_redisplay_readline(void)
Definition: tui-io.c:200
Definition: ui-out.c:99
void tui_puts(const char *string)
Definition: tui-io.c:154
mld_read_key_ftype * read_key
Definition: completer.h:63
void add_file_handler(int fd, handler_func *proc, gdb_client_data client_data)
Definition: event-loop.c:388
int key_is_end_sequence(int ch)
Definition: tui-io.c:55
void tui_refresh_all_win(void)
Definition: tui-win.c:694
static void tui_mld_flush(const struct match_list_displayer *displayer)
Definition: tui-io.c:363
static FILE * tui_old_rl_outstream
Definition: tui-io.c:130
void * data
Definition: ui-out.c:104
void tui_set_key_mode(enum tui_key_mode mode)
Definition: tui.c:314
static void tui_mld_erase_entire_line(const struct match_list_displayer *displayer)
Definition: tui-io.c:371
mld_beep_ftype * beep
Definition: completer.h:60
static void tui_putc(char c)
Definition: tui-io.c:140
mld_puts_ftype * puts
Definition: completer.h:50
static int tui_old_rl_echoing_p
Definition: tui-io.c:125
static struct ui_file * tui_old_stdout
Definition: tui-io.c:115
struct ui_out * tui_old_uiout
Definition: tui-io.c:117
int async_command_editing_p
Definition: event-top.c:108
static void tui_mld_beep(const struct match_list_displayer *displayer)
Definition: tui-io.c:383
static void tui_rl_display_match_list(char **matches, int len, int max)
Definition: tui-io.c:420
void tui_setup_io(int mode)
Definition: tui-io.c:445
void * xmalloc(YYSIZE_T)
struct ui_file * gdb_stdlog
Definition: main.c:73
static rl_getc_func_t * tui_old_rl_getc_function
Definition: tui-io.c:120
void * gdb_client_data
Definition: event-loop.h:70
#define TUI_CMD_WIN
Definition: tui-data.h:303
void tui_initialize_io(void)
Definition: tui-io.c:536
unsigned int tui_dispatch_ctrl_char(unsigned int ch)
Definition: tui-command.c:43
static rl_voidfunc_t * tui_old_rl_redisplay_function
Definition: tui-io.c:121
static rl_compdisp_func_t * tui_old_rl_display_matches_hook
Definition: tui-io.c:124
int immediate_quit
static struct ui_file * tui_old_stderr
Definition: tui-io.c:116
#define max(a, b)
Definition: defs.h:109
char * tui_expand_tabs(const char *string, int col)
Definition: tui-io.c:669
struct ui_file * gdb_stderr
Definition: main.c:72
static int tui_mld_getc(FILE *fp)
Definition: tui-io.c:393
struct ui_file * tui_fileopen(FILE *stream)
Definition: tui-file.c:88
static void tui_deprep_terminal(void)
Definition: tui-io.c:314
int line
Definition: symtab.h:1570
struct ui_out * tui_out
Definition: tui-io.c:112
int call_stdin_event_handler_again_p
Definition: event-top.c:125
struct ui_file * gdb_stdtarg
Definition: main.c:77
int key_is_backspace(int ch)
Definition: tui-io.c:61
mld_erase_entire_line_ftype * erase_entire_line
Definition: completer.h:57
mld_flush_ftype * flush
Definition: completer.h:53
static void tui_readline_output(int error, gdb_client_data data)
Definition: tui-io.c:322
struct ui_file * gdb_stdtargerr
Definition: main.c:78
static void tui_mld_putch(const struct match_list_displayer *displayer, int ch)
Definition: tui-io.c:347
struct ui_out * current_uiout
Definition: ui-out.c:233
int tui_getc(FILE *fp)
Definition: tui-io.c:579
void gdb_display_match_list(char **matches, int len, int max, const struct match_list_displayer *displayer)
Definition: completer.c:1728
struct ui_out * tui_out_new(struct ui_file *stream)
Definition: tui-out.c:146
enum tui_key_mode tui_current_key_mode
Definition: tui.c:62
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
const ULONGEST const LONGEST len
Definition: target.h:309
#define CTRL_CHAR(c)
Definition: tui-io.c:68
int key_is_start_sequence(int ch)
Definition: tui-io.c:49