/* TUI display registers in window.
- Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009
- Free Software Foundation, Inc.
+ Copyright (C) 1998-2019 Free Software Foundation, Inc.
Contributed by Hewlett-Packard Company.
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
+#include "arch-utils.h"
#include "tui/tui.h"
#include "tui/tui-data.h"
#include "symtab.h"
#include "regcache.h"
#include "inferior.h"
#include "target.h"
-#include "gdb_string.h"
#include "tui/tui-layout.h"
#include "tui/tui-win.h"
#include "tui/tui-windata.h"
#include "tui/tui-wingeneral.h"
#include "tui/tui-file.h"
#include "tui/tui-regs.h"
+#include "tui/tui-io.h"
#include "reggroups.h"
#include "valprint.h"
+#include "completer.h"
#include "gdb_curses.h"
tui_display_register (struct tui_data_element *data,
struct tui_gen_win_info *win_info);
-static enum tui_status
-tui_show_register_group (struct gdbarch *gdbarch,
- struct reggroup *group,
- struct frame_info *frame,
- int refresh_values_only);
+static enum tui_status tui_show_register_group (struct reggroup *group,
+ struct frame_info *frame,
+ int refresh_values_only);
-static enum tui_status
-tui_get_register (struct gdbarch *gdbarch,
- struct frame_info *frame,
- struct tui_data_element *data,
- int regnum, int *changedp);
-static void tui_register_format (struct gdbarch *,
- struct frame_info *,
- struct tui_data_element*,
- int);
-static void tui_scroll_regs_forward_command (char *, int);
-static void tui_scroll_regs_backward_command (char *, int);
+static enum tui_status tui_get_register (struct frame_info *frame,
+ struct tui_data_element *data,
+ int regnum, int *changedp);
}
-/* Answer the index of the last element in line_no. If line_no is
- past the register area (-1) is returned. */
-int
-tui_last_reg_element_no_in_line (int line_no)
-{
- if ((line_no * TUI_DATA_WIN->detail.data_display_info.regs_column_count) <=
- TUI_DATA_WIN->detail.data_display_info.regs_content_count)
- return ((line_no + 1) *
- TUI_DATA_WIN->detail.data_display_info.regs_column_count) - 1;
- else
- return (-1);
-}
-
/* Show the registers of the given group in the data window
and refresh the window. */
void
/* Make sure the register window is visible. If not, select an
appropriate layout. */
if (TUI_DATA_WIN == NULL || !TUI_DATA_WIN->generic.is_visible)
- tui_set_layout_for_display_command (DATA_NAME);
+ tui_set_layout_by_name (DATA_NAME);
display_info = &TUI_DATA_WIN->detail.data_display_info;
if (group == 0)
if (target_has_registers && target_has_stack && target_has_memory)
{
- ret = tui_show_register_group (current_gdbarch, group,
- get_current_frame (),
+ ret = tui_show_register_group (group, get_selected_frame (NULL),
group == display_info->current_group);
}
if (ret == TUI_FAILURE)
data_item_win = &display_info->regs_content[i]
->which_element.data_window;
- win = (struct tui_win_element *) data_item_win->content[0];
+ win = data_item_win->content[0];
win->which_element.data.highlight = FALSE;
}
display_info->current_group = group;
refresh_values_only is TRUE. */
static enum tui_status
-tui_show_register_group (struct gdbarch *gdbarch,
- struct reggroup *group,
+tui_show_register_group (struct reggroup *group,
struct frame_info *frame,
int refresh_values_only)
{
+ struct gdbarch *gdbarch = get_frame_arch (frame);
enum tui_status ret = TUI_FAILURE;
int nr_regs;
int allocated_here = FALSE;
/* See how many registers must be displayed. */
nr_regs = 0;
- for (regnum = 0;
- regnum < gdbarch_num_regs (current_gdbarch)
- + gdbarch_num_pseudo_regs (current_gdbarch);
- regnum++)
+ for (regnum = 0; regnum < gdbarch_num_cooked_regs (gdbarch); regnum++)
{
- /* Must be in the group and have a name. */
- if (gdbarch_register_reggroup_p (gdbarch, regnum, group)
- && gdbarch_register_name (gdbarch, regnum) != 0)
- nr_regs++;
+ const char *name;
+
+ /* Must be in the group. */
+ if (!gdbarch_register_reggroup_p (gdbarch, regnum, group))
+ continue;
+
+ /* If the register name is empty, it is undefined for this
+ processor, so don't display anything. */
+ name = gdbarch_register_name (gdbarch, regnum);
+ if (name == 0 || *name == '\0')
+ continue;
+
+ nr_regs++;
}
if (display_info->regs_content_count > 0 && !refresh_values_only)
{
if (!refresh_values_only || allocated_here)
{
- TUI_DATA_WIN->generic.content = (void*) NULL;
+ TUI_DATA_WIN->generic.content = NULL;
TUI_DATA_WIN->generic.content_size = 0;
tui_add_content_elements (&TUI_DATA_WIN->generic, nr_regs);
- display_info->regs_content
- = (tui_win_content) TUI_DATA_WIN->generic.content;
+ display_info->regs_content = TUI_DATA_WIN->generic.content;
display_info->regs_content_count = nr_regs;
}
/* Now set the register names and values. */
pos = 0;
- for (regnum = 0;
- regnum < gdbarch_num_regs (current_gdbarch)
- + gdbarch_num_pseudo_regs (current_gdbarch);
- regnum++)
+ for (regnum = 0; regnum < gdbarch_num_cooked_regs (gdbarch); regnum++)
{
struct tui_gen_win_info *data_item_win;
struct tui_data_element *data;
const char *name;
+ /* Must be in the group. */
if (!gdbarch_register_reggroup_p (gdbarch, regnum, group))
continue;
- name = gdbarch_register_name (gdbarch, regnum);
- if (name == 0)
- continue;
+ /* If the register name is empty, it is undefined for this
+ processor, so don't display anything. */
+ name = gdbarch_register_name (gdbarch, regnum);
+ if (name == 0 || *name == '\0')
+ continue;
data_item_win =
&display_info->regs_content[pos]->which_element.data_window;
- data =
- &((struct tui_win_element *) data_item_win->content[0])->which_element.data;
+ data = &data_item_win->content[0]->which_element.data;
if (data)
{
if (!refresh_values_only)
data->name = name;
data->highlight = FALSE;
}
- if (data->value == (void*) NULL)
- data->value = (void*) xmalloc (MAX_REGISTER_SIZE);
-
- tui_get_register (gdbarch, frame, data, regnum, 0);
+ tui_get_register (frame, data, regnum, 0);
}
pos++;
}
&& display_info->regs_content_count > 0)
{
int i = start_element_no;
- int j, value_chars_wide, item_win_width, cur_y;
+ int j, item_win_width, cur_y;
int max_len = 0;
for (i = 0; i < display_info->regs_content_count; i++)
char *p;
int len;
- data_item_win = &display_info->regs_content[i]->which_element.data_window;
- data = &((struct tui_win_element *)
- data_item_win->content[0])->which_element.data;
+ data_item_win
+ = &display_info->regs_content[i]->which_element.data_window;
+ data = &data_item_win->content[0]->which_element.data;
len = 0;
p = data->content;
if (p != 0)
/* Create the window if necessary. */
data_item_win = &display_info->regs_content[i]
->which_element.data_window;
- data_element_ptr = &((struct tui_win_element *)
- data_item_win->content[0])->which_element.data;
+ data_element_ptr = &data_item_win->content[0]->which_element.data;
if (data_item_win->handle != (WINDOW*) NULL
&& (data_item_win->height != 1
|| data_item_win->width != item_win_width
tui_display_reg_element_at_line (int start_element_no,
int start_line_no)
{
- if (TUI_DATA_WIN->detail.data_display_info.regs_content != (tui_win_content) NULL
+ if (TUI_DATA_WIN->detail.data_display_info.regs_content
+ != (tui_win_content) NULL
&& TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
{
int element_no = start_element_no;
int last_line_no, first_line_on_last_page;
last_line_no = tui_last_regs_line_no ();
- first_line_on_last_page = last_line_no - (TUI_DATA_WIN->generic.height - 2);
+ first_line_on_last_page
+ = last_line_no - (TUI_DATA_WIN->generic.height - 2);
if (first_line_on_last_page < 0)
first_line_on_last_page = 0;
display at. */
if (TUI_DATA_WIN->detail.data_display_info.data_content_count <= 0
&& start_line_no > first_line_on_last_page)
- element_no = tui_first_reg_element_no_inline (first_line_on_last_page);
+ element_no
+ = tui_first_reg_element_no_inline (first_line_on_last_page);
}
tui_display_registers_from (element_no);
}
line = line_no;
element_no = tui_first_reg_element_no_inline (line);
- if (element_no < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
+ if (element_no
+ < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
tui_display_reg_element_at_line (element_no, line);
else
line = (-1);
tui_show_registers (display_info->current_group);
else
{
- int i, j;
+ int i;
for (i = 0; (i < display_info->regs_content_count); i++)
{
data_item_win_ptr = &display_info->regs_content[i]->
which_element.data_window;
- data = &((struct tui_win_element *)
- data_item_win_ptr->content[0])->which_element.data;
+ data = &data_item_win_ptr->content[0]->which_element.data;
was_hilighted = data->highlight;
- tui_get_register (current_gdbarch, frame, data,
+ tui_get_register (frame, data,
data->item_no, &data->highlight);
if (data->highlight || was_hilighted)
int i;
if (data->highlight)
- wstandout (win_info->handle);
+ /* We ignore the return value, casting it to void in order to avoid
+ a compiler warning. The warning itself was introduced by a patch
+ to ncurses 5.7 dated 2009-08-29, changing this macro to expand
+ to code that causes the compiler to generate an unused-value
+ warning. */
+ (void) wstandout (win_info->handle);
wmove (win_info->handle, 0, 0);
for (i = 1; i < win_info->width; i++)
waddstr (win_info->handle, data->content);
if (data->highlight)
- wstandend (win_info->handle);
+ /* We ignore the return value, casting it to void in order to avoid
+ a compiler warning. The warning itself was introduced by a patch
+ to ncurses 5.7 dated 2009-08-29, changing this macro to expand
+ to code that causes the compiler to generate an unused-value
+ warning. */
+ (void) wstandend (win_info->handle);
tui_refresh_win (win_info);
}
}
-static void
-tui_reg_next_command (char *arg, int from_tty)
-{
- if (TUI_DATA_WIN != 0)
- {
- struct reggroup *group
- = TUI_DATA_WIN->detail.data_display_info.current_group;
+/* Helper for "tui reg next", wraps a call to REGGROUP_NEXT, but adds wrap
+ around behaviour. Returns the next register group, or NULL if the
+ register window is not currently being displayed. */
- group = reggroup_next (current_gdbarch, group);
- if (group == 0)
- group = reggroup_next (current_gdbarch, 0);
+static struct reggroup *
+tui_reg_next (struct gdbarch *gdbarch)
+{
+ struct reggroup *group = NULL;
- if (group)
- tui_show_registers (group);
+ if (TUI_DATA_WIN != NULL)
+ {
+ group = TUI_DATA_WIN->detail.data_display_info.current_group;
+ group = reggroup_next (gdbarch, group);
+ if (group == NULL)
+ group = reggroup_next (gdbarch, NULL);
}
+ return group;
}
-static void
-tui_reg_float_command (char *arg, int from_tty)
-{
- tui_show_registers (float_reggroup);
-}
+/* Helper for "tui reg prev", wraps a call to REGGROUP_PREV, but adds wrap
+ around behaviour. Returns the previous register group, or NULL if the
+ register window is not currently being displayed. */
-static void
-tui_reg_general_command (char *arg, int from_tty)
+static struct reggroup *
+tui_reg_prev (struct gdbarch *gdbarch)
{
- tui_show_registers (general_reggroup);
+ struct reggroup *group = NULL;
+
+ if (TUI_DATA_WIN != NULL)
+ {
+ group = TUI_DATA_WIN->detail.data_display_info.current_group;
+ group = reggroup_prev (gdbarch, group);
+ if (group == NULL)
+ group = reggroup_prev (gdbarch, NULL);
+ }
+ return group;
}
+/* Implement the 'tui reg' command. Changes the register group displayed
+ in the tui register window. Displays the tui register window if it is
+ not already on display. */
+
static void
-tui_reg_system_command (char *arg, int from_tty)
+tui_reg_command (const char *args, int from_tty)
{
- tui_show_registers (system_reggroup);
+ struct gdbarch *gdbarch = get_current_arch ();
+
+ if (args != NULL)
+ {
+ struct reggroup *group, *match = NULL;
+ size_t len = strlen (args);
+
+ /* Make sure the curses mode is enabled. */
+ tui_enable ();
+
+ /* Make sure the register window is visible. If not, select an
+ appropriate layout. We need to do this before trying to run the
+ 'next' or 'prev' commands. */
+ if (TUI_DATA_WIN == NULL || !TUI_DATA_WIN->generic.is_visible)
+ tui_set_layout_by_name (DATA_NAME);
+
+ if (strncmp (args, "next", len) == 0)
+ match = tui_reg_next (gdbarch);
+ else if (strncmp (args, "prev", len) == 0)
+ match = tui_reg_prev (gdbarch);
+
+ /* This loop matches on the initial part of a register group
+ name. If this initial part in ARGS matches only one register
+ group then the switch is made. */
+ for (group = reggroup_next (gdbarch, NULL);
+ group != NULL;
+ group = reggroup_next (gdbarch, group))
+ {
+ if (strncmp (reggroup_name (group), args, len) == 0)
+ {
+ if (match != NULL)
+ error (_("ambiguous register group name '%s'"), args);
+ match = group;
+ }
+ }
+
+ if (match == NULL)
+ error (_("unknown register group '%s'"), args);
+
+ tui_show_registers (match);
+ }
+ else
+ {
+ struct reggroup *group;
+ int first;
+
+ printf_unfiltered (_("\"tui reg\" must be followed by the name of "
+ "either a register group,\nor one of 'next' "
+ "or 'prev'. Known register groups are:\n"));
+
+ for (first = 1, group = reggroup_next (gdbarch, NULL);
+ group != NULL;
+ first = 0, group = reggroup_next (gdbarch, group))
+ {
+ if (!first)
+ printf_unfiltered (", ");
+ printf_unfiltered ("%s", reggroup_name (group));
+ }
+
+ printf_unfiltered ("\n");
+ }
}
-static struct cmd_list_element *tuireglist;
+/* Complete names of register groups, and add the special "prev" and "next"
+ names. */
static void
-tui_reg_command (char *args, int from_tty)
+tui_reggroup_completer (struct cmd_list_element *ignore,
+ completion_tracker &tracker,
+ const char *text, const char *word)
{
- printf_unfiltered (_("\"tui reg\" must be followed by the name of a "
- "tui reg command.\n"));
- help_list (tuireglist, "tui reg ", -1, gdb_stdout);
-}
+ static const char *extra[] = { "next", "prev", NULL };
+ size_t len = strlen (word);
+ const char **tmp;
+
+ reggroup_completer (ignore, tracker, text, word);
-/* Provide a prototype to silence -Wmissing-prototypes. */
-extern initialize_file_ftype _initialize_tui_regs;
+ /* XXXX use complete_on_enum instead? */
+ for (tmp = extra; *tmp != NULL; ++tmp)
+ {
+ if (strncmp (word, *tmp, len) == 0)
+ tracker.add_completion (gdb::unique_xmalloc_ptr<char> (xstrdup (*tmp)));
+ }
+}
void
_initialize_tui_regs (void)
{
- struct cmd_list_element **tuicmd;
+ struct cmd_list_element **tuicmd, *cmd;
tuicmd = tui_get_cmd_list ();
- add_prefix_cmd ("reg", class_tui, tui_reg_command,
- _("TUI commands to control the register window."),
- &tuireglist, "tui reg ", 0,
- tuicmd);
-
- add_cmd ("float", class_tui, tui_reg_float_command,
- _("Display only floating point registers."),
- &tuireglist);
- add_cmd ("general", class_tui, tui_reg_general_command,
- _("Display only general registers."),
- &tuireglist);
- add_cmd ("system", class_tui, tui_reg_system_command,
- _("Display only system registers."),
- &tuireglist);
- add_cmd ("next", class_tui, tui_reg_next_command,
- _("Display next register group."),
- &tuireglist);
-
- if (xdb_commands)
- {
- add_com ("fr", class_tui, tui_reg_float_command,
- _("Display only floating point registers\n"));
- add_com ("gr", class_tui, tui_reg_general_command,
- _("Display only general registers\n"));
- add_com ("sr", class_tui, tui_reg_system_command,
- _("Display only special registers\n"));
- add_com ("+r", class_tui, tui_scroll_regs_forward_command,
- _("Scroll the registers window forward\n"));
- add_com ("-r", class_tui, tui_scroll_regs_backward_command,
- _("Scroll the register window backward\n"));
- }
+ cmd = add_cmd ("reg", class_tui, tui_reg_command, _("\
+TUI command to control the register window."), tuicmd);
+ set_cmd_completer (cmd, tui_reggroup_completer);
}
** STATIC LOCAL FUNCTIONS **
******************************************/
-extern int pagination_enabled;
+/* Get the register from the frame and return a printable
+ representation of it. */
-static void
-tui_restore_gdbout (void *ui)
+static char *
+tui_register_format (struct frame_info *frame, int regnum)
{
- ui_file_delete (gdb_stdout);
- gdb_stdout = (struct ui_file*) ui;
- pagination_enabled = 1;
-}
+ struct gdbarch *gdbarch = get_frame_arch (frame);
-/* Get the register from the frame and make a printable representation
- of it in the data element. */
-static void
-tui_register_format (struct gdbarch *gdbarch,
- struct frame_info *frame,
- struct tui_data_element *data_element,
- int regnum)
-{
- struct ui_file *stream;
- struct ui_file *old_stdout;
- const char *name;
- struct cleanup *cleanups;
- char *p, *s;
- int pos;
- struct type *type = register_type (gdbarch, regnum);
-
- name = gdbarch_register_name (gdbarch, regnum);
- if (name == 0)
- {
- return;
- }
-
- pagination_enabled = 0;
- old_stdout = gdb_stdout;
- stream = tui_sfileopen (256);
- gdb_stdout = stream;
- cleanups = make_cleanup (tui_restore_gdbout, (void*) old_stdout);
- if (TYPE_VECTOR (type) != 0 && 0)
- {
- gdb_byte buf[MAX_REGISTER_SIZE];
- int len;
- struct value_print_options opts;
-
- len = register_size (current_gdbarch, regnum);
- fprintf_filtered (stream, "%-14s ", name);
- get_frame_register (frame, regnum, buf);
- get_formatted_print_options (&opts, 'f');
- print_scalar_formatted (buf, type, &opts, len, stream);
- }
- else
- {
- gdbarch_print_registers_info (current_gdbarch, stream,
- frame, regnum, 1);
- }
+ string_file stream;
+
+ scoped_restore save_pagination
+ = make_scoped_restore (&pagination_enabled, 0);
+ scoped_restore save_stdout
+ = make_scoped_restore (&gdb_stdout, &stream);
- /* Save formatted output in the buffer. */
- p = tui_file_get_strbuf (stream);
+ gdbarch_print_registers_info (gdbarch, &stream, frame, regnum, 1);
/* Remove the possible \n. */
- s = strrchr (p, '\n');
- if (s && s[1] == 0)
- *s = 0;
+ std::string &str = stream.string ();
+ if (!str.empty () && str.back () == '\n')
+ str.resize (str.size () - 1);
- xfree (data_element->content);
- data_element->content = xstrdup (p);
- do_cleanups (cleanups);
+ /* Expand tabs into spaces, since ncurses on MS-Windows doesn't. */
+ return tui_expand_tabs (str.c_str (), 0);
}
/* Get the register value from the given frame and format it for the
display. When changep is set, check if the new register value has
changed with respect to the previous call. */
static enum tui_status
-tui_get_register (struct gdbarch *gdbarch,
- struct frame_info *frame,
+tui_get_register (struct frame_info *frame,
struct tui_data_element *data,
int regnum, int *changedp)
{
*changedp = FALSE;
if (target_has_registers)
{
- gdb_byte buf[MAX_REGISTER_SIZE];
- get_frame_register (frame, regnum, buf);
+ char *prev_content = data->content;
- if (changedp)
- {
- int size = register_size (gdbarch, regnum);
- char *old = (char*) data->value;
- int i;
+ data->content = tui_register_format (frame, regnum);
- for (i = 0; i < size; i++)
- if (buf[i] != old[i])
- {
- *changedp = TRUE;
- old[i] = buf[i];
- }
- }
+ if (changedp != NULL
+ && strcmp (prev_content, data->content) != 0)
+ *changedp = 1;
- /* Reformat the data content if the value changed. */
- if (changedp == 0 || *changedp == TRUE)
- tui_register_format (gdbarch, frame, data, regnum);
+ xfree (prev_content);
ret = TUI_SUCCESS;
}
return ret;
}
-
-static void
-tui_scroll_regs_forward_command (char *arg, int from_tty)
-{
- tui_scroll (FORWARD_SCROLL, TUI_DATA_WIN, 1);
-}
-
-
-static void
-tui_scroll_regs_backward_command (char *arg, int from_tty)
-{
- tui_scroll (BACKWARD_SCROLL, TUI_DATA_WIN, 1);
-}