#ifdef __MINGW32__
#include <windows.h>
#endif
-#include "common/filestuff.h"
+#include "gdbsupport/filestuff.h"
#include "completer.h"
#include "gdb_curses.h"
#include <map>
be garbled. This is implemented with a pipe that TUI reads and
readline writes to. A gdb input handler is created so that reading
the pipe is handled automatically. This will probably not work on
- non-Unix platforms. The best fix is to make readline clean enougth
+ non-Unix platforms. The best fix is to make readline clean enough
so that is never write on stdout.
Note SCz/2002-09-01: we now use more readline hooks and it seems
static void
update_cmdwin_start_line ()
{
- TUI_CMD_WIN->detail.command_info.start_line
- = getcury (TUI_CMD_WIN->generic.handle);
+ TUI_CMD_WIN->start_line = getcury (TUI_CMD_WIN->handle.get ());
}
/* Print a character in the curses command window. The output is
static void
tui_putc (char c)
{
- WINDOW *w = TUI_CMD_WIN->generic.handle;
-
- do_tui_putc (w, c);
+ do_tui_putc (TUI_CMD_WIN->handle.get (), c);
update_cmdwin_start_line ();
}
static ui_file_style last_style;
+/* If true, we're highlighting the current source line in reverse
+ video mode. */
+static bool reverse_mode_p = false;
+
+/* The background/foreground colors before we entered reverse
+ mode. */
+static ui_file_style::color reverse_save_bg (ui_file_style::NONE);
+static ui_file_style::color reverse_save_fg (ui_file_style::NONE);
+
/* Given two colors, return their color pair index; making a new one
if necessary. */
return it->second;
}
-/* Apply an ANSI escape sequence from BUF to W. BUF must start with
- the ESC character. If BUF does not start with an ANSI escape,
- return 0. Otherwise, apply the sequence if it is recognized, or
- simply ignore it if not. In this case, the number of bytes read
- from BUF is returned. */
+/* Apply STYLE to W. */
-static size_t
-apply_ansi_escape (WINDOW *w, const char *buf)
+void
+tui_apply_style (WINDOW *w, ui_file_style style)
{
- ui_file_style style = last_style;
- size_t n_read;
-
- if (!style.parse (buf, &n_read))
- return n_read;
-
/* Reset. */
wattron (w, A_NORMAL);
wattroff (w, A_BOLD);
wattron (w, A_REVERSE);
last_style = style;
+}
+
+/* Apply an ANSI escape sequence from BUF to W. BUF must start with
+ the ESC character. If BUF does not start with an ANSI escape,
+ return 0. Otherwise, apply the sequence if it is recognized, or
+ simply ignore it if not. In this case, the number of bytes read
+ from BUF is returned. */
+
+static size_t
+apply_ansi_escape (WINDOW *w, const char *buf)
+{
+ ui_file_style style = last_style;
+ size_t n_read;
+
+ if (!style.parse (buf, &n_read))
+ return n_read;
+
+ if (reverse_mode_p)
+ {
+ /* We want to reverse _only_ the default foreground/background
+ colors. If the foreground color is not the default (because
+ the text was styled), we want to leave it as is. If e.g.,
+ the terminal is fg=BLACK, and bg=WHITE, and the style wants
+ to print text in RED, we want to reverse the background color
+ (print in BLACK), but still print the text in RED. To do
+ that, we enable the A_REVERSE attribute, and re-reverse the
+ parsed-style's fb/bg colors.
+
+ Notes on the approach:
+
+ - there's no portable way to know which colors the default
+ fb/bg colors map to.
+
+ - this approach does the right thing even if you change the
+ terminal colors while GDB is running -- the reversed
+ colors automatically adapt.
+ */
+ if (!style.is_default ())
+ {
+ ui_file_style::color bg = style.get_background ();
+ ui_file_style::color fg = style.get_foreground ();
+ style.set_fg (bg);
+ style.set_bg (fg);
+ }
+
+ /* Enable A_REVERSE. */
+ style.set_reverse (true);
+ }
+
+ tui_apply_style (w, style);
return n_read;
}
+/* See tui.io.h. */
+
+void
+tui_set_reverse_mode (WINDOW *w, bool reverse)
+{
+ ui_file_style style = last_style;
+
+ reverse_mode_p = reverse;
+ style.set_reverse (reverse);
+
+ if (reverse)
+ {
+ reverse_save_bg = style.get_background ();
+ reverse_save_fg = style.get_foreground ();
+ }
+ else
+ {
+ style.set_bg (reverse_save_bg);
+ style.set_fg (reverse_save_fg);
+ }
+
+ tui_apply_style (w, style);
+}
+
/* Print LENGTH characters from the buffer pointed to by BUF to the
curses command window. The output is buffered. It is up to the
caller to refresh the screen if necessary. */
{
char c;
int prev_col = 0;
+ bool saw_nl = false;
while ((c = *string++) != 0)
{
+ if (c == '\n')
+ saw_nl = true;
+
if (c == '\1' || c == '\2')
{
/* Ignore these, they are readline escape-marking
}
}
}
- update_cmdwin_start_line ();
+ if (TUI_CMD_WIN != nullptr && w == TUI_CMD_WIN->handle.get ())
+ update_cmdwin_start_line ();
+ if (saw_nl)
+ wrefresh (w);
}
/* Print a string in the curses command window. The output is
tui_puts (const char *string, WINDOW *w)
{
if (w == nullptr)
- w = TUI_CMD_WIN->generic.handle;
+ w = TUI_CMD_WIN->handle.get ();
tui_puts_internal (w, string, nullptr);
}
c_pos = -1;
c_line = -1;
- w = TUI_CMD_WIN->generic.handle;
- start_line = TUI_CMD_WIN->detail.command_info.start_line;
+ w = TUI_CMD_WIN->handle.get ();
+ start_line = TUI_CMD_WIN->start_line;
wmove (w, start_line, 0);
prev_col = 0;
height = 1;
if (prompt != nullptr)
- tui_puts_internal (TUI_CMD_WIN->generic.handle, prompt, &height);
+ tui_puts_internal (w, prompt, &height);
prev_col = getcurx (w);
for (in = 0; in <= rl_end; in++)
waddch (w, c);
}
if (c == '\n')
- TUI_CMD_WIN->detail.command_info.start_line = getcury (w);
+ TUI_CMD_WIN->start_line = getcury (w);
col = getcurx (w);
if (col < prev_col)
height++;
prev_col = col;
}
wclrtobot (w);
- TUI_CMD_WIN->detail.command_info.start_line = getcury (w);
+ TUI_CMD_WIN->start_line = getcury (w);
if (c_line >= 0)
wmove (w, c_line, c_pos);
- TUI_CMD_WIN->detail.command_info.start_line -= height - 1;
+ TUI_CMD_WIN->start_line -= height - 1;
wrefresh (w);
fflush(stdout);
static void
tui_mld_flush (const struct match_list_displayer *displayer)
{
- wrefresh (TUI_CMD_WIN->generic.handle);
+ wrefresh (TUI_CMD_WIN->handle.get ());
}
/* TUI version of displayer.erase_entire_line. */
static void
tui_mld_erase_entire_line (const struct match_list_displayer *displayer)
{
- WINDOW *w = TUI_CMD_WIN->generic.handle;
+ WINDOW *w = TUI_CMD_WIN->handle.get ();
int cur_y = getcury (w);
wmove (w, cur_y, 0);
nonl ();
int r = wgetch (win);
nl ();
- /* In nonl mode, if the user types Enter, it will not be echoed
- properly. This will result in gdb output appearing immediately
- after the command. So, if we read \r, emit a \r now, after nl
- mode has been re-entered, so that the output looks correct. */
- if (r == '\r')
- puts ("\r");
return r;
}
static int
tui_mld_getc (FILE *fp)
{
- WINDOW *w = TUI_CMD_WIN->generic.handle;
+ WINDOW *w = TUI_CMD_WIN->handle.get ();
int c = gdb_wgetch (w);
return c;
/* Force a refresh of the screen. */
tui_refresh_all_win ();
-
- wrefresh (TUI_CMD_WIN->generic.handle);
}
signal (sig, tui_cont_sig);
}
if (tui_rl_outstream == 0)
error (_("Cannot redirect readline output"));
- setvbuf (tui_rl_outstream, (char*) NULL, _IOLBF, 0);
+ setvbuf (tui_rl_outstream, NULL, _IOLBF, 0);
#ifdef O_NONBLOCK
(void) fcntl (tui_readline_pipe[0], F_SETFL, O_NONBLOCK);
#endif
}
+/* Dispatch the correct tui function based upon the control
+ character. */
+static unsigned int
+tui_dispatch_ctrl_char (unsigned int ch)
+{
+ struct tui_win_info *win_info = tui_win_with_focus ();
+
+ /* Handle the CTRL-L refresh for each window. */
+ if (ch == '\f')
+ tui_refresh_all_win ();
+
+ /* If no window has the focus, or if the focus window can't scroll,
+ just pass the character through. */
+ if (win_info == NULL || !win_info->can_scroll ())
+ return ch;
+
+ switch (ch)
+ {
+ case KEY_NPAGE:
+ win_info->forward_scroll (0);
+ break;
+ case KEY_PPAGE:
+ win_info->backward_scroll (0);
+ break;
+ case KEY_DOWN:
+ case KEY_SF:
+ win_info->forward_scroll (1);
+ break;
+ case KEY_UP:
+ case KEY_SR:
+ win_info->backward_scroll (1);
+ break;
+ case KEY_RIGHT:
+ win_info->left_scroll (1);
+ break;
+ case KEY_LEFT:
+ win_info->right_scroll (1);
+ break;
+ case '\f':
+ break;
+ default:
+ /* We didn't recognize the character as a control character, so pass it
+ through. */
+ return ch;
+ }
+
+ /* We intercepted the control character, so return 0 (which readline
+ will interpret as a no-op). */
+ return 0;
+}
+
/* Get a character from the command window. This is called from the
readline package. */
static int
int ch;
WINDOW *w;
- w = TUI_CMD_WIN->generic.handle;
+ w = TUI_CMD_WIN->handle.get ();
#ifdef TUI_USE_PIPE_FOR_READLINE
/* Flush readline output. */
/* The \n must be echoed because it will not be printed by
readline. */
- if (ch == '\n')
+ if (ch == '\n' || ch == '\r')
{
/* When hitting return with an empty input, gdb executes the last
command. If we emit a newline, this fills up the command window
int px, py;
getyx (w, py, px);
px += rl_end - rl_point;
- py += px / TUI_CMD_WIN->generic.width;
- px %= TUI_CMD_WIN->generic.width;
+ py += px / TUI_CMD_WIN->width;
+ px %= TUI_CMD_WIN->width;
wmove (w, py, px);
tui_putc ('\n');
}
return ch;
}
-/* Utility function to expand TABs in a STRING into spaces. STRING
- will be displayed starting at column COL, and is assumed to include
- no newlines. The returned expanded string is malloc'ed. */
+/* See tui-io.h. */
-char *
-tui_expand_tabs (const char *string, int col)
+gdb::unique_xmalloc_ptr<char>
+tui_expand_tabs (const char *string)
{
int n_adjust, ncol;
const char *s;
char *ret, *q;
/* 1. How many additional characters do we need? */
- for (ncol = col, n_adjust = 0, s = string; s; )
+ for (ncol = 0, n_adjust = 0, s = string; s; )
{
s = strpbrk (s, "\t");
if (s)
ret = q = (char *) xmalloc (strlen (string) + n_adjust + 1);
/* 2. Copy the original string while replacing TABs with spaces. */
- for (ncol = col, s = string; s; )
+ for (ncol = 0, s = string; s; )
{
const char *s1 = strpbrk (s, "\t");
if (s1)
s = s1;
}
- return ret;
+ return gdb::unique_xmalloc_ptr<char> (ret);
}
projects / deliverable / binutils-gdb.git / blobdiff