/* TUI display registers in window.
- Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
- Foundation, Inc.
+ Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
+ Free Software Foundation, Inc.
Contributed by Hewlett-Packard Company.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "tui/tui.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 "reggroups.h"
-#ifdef HAVE_NCURSES_H
-#include <ncurses.h>
-#else
-#ifdef HAVE_CURSES_H
-#include <curses.h>
-#endif
-#endif
+#include "gdb_curses.h"
-/*****************************************
-** LOCAL DEFINITIONS **
-******************************************/
-#define DOUBLE_FLOAT_LABEL_WIDTH 6
-#define DOUBLE_FLOAT_LABEL_FMT "%6.6s: "
-#define DOUBLE_FLOAT_VALUE_WIDTH 30 /*min of 16 but may be in sci notation */
-
-#define SINGLE_FLOAT_LABEL_WIDTH 6
-#define SINGLE_FLOAT_LABEL_FMT "%6.6s: "
-#define SINGLE_FLOAT_VALUE_WIDTH 25 /* min of 8 but may be in sci notation */
-
-#define SINGLE_LABEL_WIDTH 16
-#define SINGLE_LABEL_FMT "%10.10s: "
-#define SINGLE_VALUE_WIDTH 20 /* minimum of 8 but may be in sci notation */
-
-/* In the code HP gave Cygnus, this was actually a function call to a
- PA-specific function, which was supposed to determine whether the
- target was a 64-bit or 32-bit processor. However, the 64-bit
- support wasn't complete, so we didn't merge that in, so we leave
- this here as a stub. */
-#define IS_64BIT 0
/*****************************************
-** STATIC DATA **
+** STATIC LOCAL FUNCTIONS FORWARD DECLS **
******************************************/
+static void
+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 LOCAL FUNCTIONS FORWARD DECLS **
-******************************************/
-static enum tui_status _tuiSetRegsContent
- (int, int, struct frame_info *, enum tui_register_display_type, int);
-static const char *_tuiRegisterName (int);
-static enum tui_status _tuiGetRegisterRawValue (int, char *, struct frame_info *);
-static void _tuiSetRegisterElement
- (int, struct frame_info *, struct tui_data_element *, int);
-static void _tuiDisplayRegister (int, struct tui_gen_win_info *, enum precision_type);
-static void _tuiRegisterFormat
- (char *, int, int, struct tui_data_element *, enum precision_type);
-static enum tui_status _tuiSetGeneralRegsContent (int);
-static enum tui_status _tuiSetSpecialRegsContent (int);
-static enum tui_status _tuiSetGeneralAndSpecialRegsContent (int);
-static enum tui_status _tuiSetFloatRegsContent (enum tui_register_display_type, int);
-static int _tuiRegValueHasChanged
- (struct tui_data_element *, struct frame_info *, char *);
-static void _tuiShowFloat_command (char *, int);
-static void _tuiShowGeneral_command (char *, int);
-static void _tuiShowSpecial_command (char *, int);
-static void _tui_vShowRegisters_commandSupport (enum tui_register_display_type);
-static void _tuiToggleFloatRegs_command (char *, int);
-static void _tuiScrollRegsForward_command (char *, int);
-static void _tuiScrollRegsBackward_command (char *, int);
+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);
int
tui_last_regs_line_no (void)
{
- register int numLines = (-1);
+ int num_lines = (-1);
- if (dataWin->detail.dataDisplayInfo.regsContentCount > 0)
+ if (TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
{
- numLines = (dataWin->detail.dataDisplayInfo.regsContentCount /
- dataWin->detail.dataDisplayInfo.regsColumnCount);
- if (dataWin->detail.dataDisplayInfo.regsContentCount %
- dataWin->detail.dataDisplayInfo.regsColumnCount)
- numLines++;
+ num_lines = (TUI_DATA_WIN->detail.data_display_info.regs_content_count /
+ TUI_DATA_WIN->detail.data_display_info.regs_column_count);
+ if (TUI_DATA_WIN->detail.data_display_info.regs_content_count %
+ TUI_DATA_WIN->detail.data_display_info.regs_column_count)
+ num_lines++;
}
- return numLines;
+ return num_lines;
}
-/* Answer the line number that the register element at elementNo is
- on. If elementNo is greater than the number of register elements
+/* Answer the line number that the register element at element_no is
+ on. If element_no is greater than the number of register elements
there are, -1 is returned. */
int
-tui_line_from_reg_element_no (int elementNo)
+tui_line_from_reg_element_no (int element_no)
{
- if (elementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
+ if (element_no < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
{
int i, line = (-1);
i = 1;
while (line == (-1))
{
- if (elementNo <
- (dataWin->detail.dataDisplayInfo.regsColumnCount * i))
+ if (element_no <
+ (TUI_DATA_WIN->detail.data_display_info.regs_column_count * i))
line = i - 1;
else
i++;
}
-/* Answer the index of the first element in lineNo. If lineNo is past
- the register area (-1) is returned. */
+/* Answer the index of the first element in line_no. If line_no is
+ past the register area (-1) is returned. */
int
-tui_first_reg_element_no_inline (int lineNo)
+tui_first_reg_element_no_inline (int line_no)
{
- if ((lineNo * dataWin->detail.dataDisplayInfo.regsColumnCount)
- <= dataWin->detail.dataDisplayInfo.regsContentCount)
- return ((lineNo + 1) *
- dataWin->detail.dataDisplayInfo.regsColumnCount) -
- dataWin->detail.dataDisplayInfo.regsColumnCount;
+ 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) -
+ TUI_DATA_WIN->detail.data_display_info.regs_column_count;
else
return (-1);
}
-/*
- ** tuiLastRegElementNoInLine()
- ** Answer the index of the last element in lineNo. If lineNo is past
- ** the register area (-1) is returned.
- */
+/* Answer the index of the last element in line_no. If line_no is
+ past the register area (-1) is returned. */
int
-tuiLastRegElementNoInLine (int lineNo)
+tui_last_reg_element_no_in_line (int line_no)
{
- if ((lineNo * dataWin->detail.dataDisplayInfo.regsColumnCount) <=
- dataWin->detail.dataDisplayInfo.regsContentCount)
- return ((lineNo + 1) *
- dataWin->detail.dataDisplayInfo.regsColumnCount) - 1;
+ 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);
-} /* tuiLastRegElementNoInLine */
-
+}
-/* Calculate the number of columns that should be used to display the
- registers. */
-int
-tui_calculate_regs_column_count (enum tui_register_display_type dpyType)
+/* Show the registers of the given group in the data window
+ and refresh the window. */
+void
+tui_show_registers (struct reggroup *group)
{
- int colCount, colWidth;
+ enum tui_status ret = TUI_FAILURE;
+ struct tui_data_info *display_info;
- if (IS_64BIT || dpyType == TUI_DFLOAT_REGS)
- colWidth = DOUBLE_FLOAT_VALUE_WIDTH + DOUBLE_FLOAT_LABEL_WIDTH;
- else
- {
- if (dpyType == TUI_SFLOAT_REGS)
- colWidth = SINGLE_FLOAT_VALUE_WIDTH + SINGLE_FLOAT_LABEL_WIDTH;
- else
- colWidth = SINGLE_VALUE_WIDTH + SINGLE_LABEL_WIDTH;
- }
- colCount = (dataWin->generic.width - 2) / colWidth;
+ /* Make sure the curses mode is enabled. */
+ tui_enable ();
- return colCount;
-} /* tuiCalulateRegsColumnCount */
+ /* 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);
+ display_info = &TUI_DATA_WIN->detail.data_display_info;
+ if (group == 0)
+ group = general_reggroup;
-/* Show the registers int the data window as indicated by dpyType. If
- there is any other registers being displayed, then they are
- cleared. What registers are displayed is dependent upon dpyType. */
-void
-tui_show_registers (enum tui_register_display_type dpyType)
-{
- enum tui_status ret = TUI_FAILURE;
- int refreshValuesOnly = FALSE;
-
- /* Say that registers should be displayed, even if there is a problem */
- dataWin->detail.dataDisplayInfo.displayRegs = TRUE;
+ /* Say that registers should be displayed, even if there is a
+ problem. */
+ display_info->display_regs = TRUE;
- if (target_has_registers)
+ if (target_has_registers && target_has_stack && target_has_memory)
{
- refreshValuesOnly =
- (dpyType == dataWin->detail.dataDisplayInfo.regsDisplayType);
- switch (dpyType)
- {
- case TUI_GENERAL_REGS:
- ret = _tuiSetGeneralRegsContent (refreshValuesOnly);
- break;
- case TUI_SFLOAT_REGS:
- case TUI_DFLOAT_REGS:
- ret = _tuiSetFloatRegsContent (dpyType, refreshValuesOnly);
- break;
-
-/* could ifdef out */
-
- case TUI_SPECIAL_REGS:
- ret = _tuiSetSpecialRegsContent (refreshValuesOnly);
- break;
- case TUI_GENERAL_AND_SPECIAL_REGS:
- ret = _tuiSetGeneralAndSpecialRegsContent (refreshValuesOnly);
- break;
-
-/* end of potential if def */
-
- default:
- break;
- }
+ ret = tui_show_register_group (current_gdbarch, group,
+ get_current_frame (),
+ group == display_info->current_group);
}
if (ret == TUI_FAILURE)
{
- dataWin->detail.dataDisplayInfo.regsDisplayType = TUI_UNDEFINED_REGS;
+ display_info->current_group = 0;
tui_erase_data_content (NO_REGS_STRING);
}
else
{
int i;
- /* Clear all notation of changed values */
- for (i = 0; (i < dataWin->detail.dataDisplayInfo.regsContentCount); i++)
+ /* Clear all notation of changed values. */
+ for (i = 0; i < display_info->regs_content_count; i++)
{
- struct tui_gen_win_info * dataItemWin;
+ struct tui_gen_win_info *data_item_win;
+ struct tui_win_element *win;
- dataItemWin = &dataWin->detail.dataDisplayInfo.
- regsContent[i]->whichElement.dataWindow;
- (&((struct tui_win_element *)
- dataItemWin->content[0])->whichElement.data)->highlight = FALSE;
+ data_item_win = &display_info->regs_content[i]
+ ->which_element.data_window;
+ win = (struct tui_win_element *) data_item_win->content[0];
+ win->which_element.data.highlight = FALSE;
}
- dataWin->detail.dataDisplayInfo.regsDisplayType = dpyType;
+ display_info->current_group = group;
tui_display_all_data ();
}
- (tui_layout_def ())->regsDisplayType = dpyType;
-
- return;
}
+/* Set the data window to display the registers of the register group
+ using the given frame. Values are refreshed only when
+ refresh_values_only is TRUE. */
+
+static enum tui_status
+tui_show_register_group (struct gdbarch *gdbarch,
+ struct reggroup *group,
+ struct frame_info *frame,
+ int refresh_values_only)
+{
+ enum tui_status ret = TUI_FAILURE;
+ int nr_regs;
+ int allocated_here = FALSE;
+ int regnum, pos;
+ char title[80];
+ struct tui_data_info *display_info = &TUI_DATA_WIN->detail.data_display_info;
+
+ /* Make a new title showing which group we display. */
+ snprintf (title, sizeof (title) - 1, "Register group: %s",
+ reggroup_name (group));
+ xfree (TUI_DATA_WIN->generic.title);
+ TUI_DATA_WIN->generic.title = xstrdup (title);
+
+ /* 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++)
+ {
+ /* 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++;
+ }
+
+ if (display_info->regs_content_count > 0 && !refresh_values_only)
+ {
+ tui_free_data_content (display_info->regs_content,
+ display_info->regs_content_count);
+ display_info->regs_content_count = 0;
+ }
+
+ if (display_info->regs_content_count <= 0)
+ {
+ display_info->regs_content = tui_alloc_content (nr_regs, DATA_WIN);
+ allocated_here = TRUE;
+ refresh_values_only = FALSE;
+ }
+
+ if (display_info->regs_content != (tui_win_content) NULL)
+ {
+ if (!refresh_values_only || allocated_here)
+ {
+ TUI_DATA_WIN->generic.content = (void*) 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_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++)
+ {
+ struct tui_gen_win_info *data_item_win;
+ struct tui_data_element *data;
+ const char *name;
+
+ if (!gdbarch_register_reggroup_p (gdbarch, regnum, group))
+ continue;
+
+ name = gdbarch_register_name (gdbarch, regnum);
+ if (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;
+ if (data)
+ {
+ if (!refresh_values_only)
+ {
+ data->item_no = regnum;
+ 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);
+ }
+ pos++;
+ }
+
+ TUI_DATA_WIN->generic.content_size =
+ display_info->regs_content_count + display_info->data_content_count;
+ ret = TUI_SUCCESS;
+ }
+
+ return ret;
+}
+
/* Function to display the registers in the content from
- 'startElementNo' until the end of the register content or the end
+ 'start_element_no' until the end of the register content or the end
of the display height. No checking for displaying past the end of
the registers is done here. */
void
-tui_display_registers_from (int startElementNo)
+tui_display_registers_from (int start_element_no)
{
- if (dataWin->detail.dataDisplayInfo.regsContent != (tui_win_content) NULL &&
- dataWin->detail.dataDisplayInfo.regsContentCount > 0)
+ struct tui_data_info *display_info = &TUI_DATA_WIN->detail.data_display_info;
+
+ if (display_info->regs_content != (tui_win_content) NULL
+ && display_info->regs_content_count > 0)
{
- register int i = startElementNo;
- int j, valueCharsWide, itemWinWidth, curY, labelWidth;
- enum precision_type precision;
-
- precision = (dataWin->detail.dataDisplayInfo.regsDisplayType
- == TUI_DFLOAT_REGS) ?
- double_precision : unspecified_precision;
- if (IS_64BIT ||
- dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_DFLOAT_REGS)
- {
- valueCharsWide = DOUBLE_FLOAT_VALUE_WIDTH;
- labelWidth = DOUBLE_FLOAT_LABEL_WIDTH;
- }
- else
- {
- if (dataWin->detail.dataDisplayInfo.regsDisplayType ==
- TUI_SFLOAT_REGS)
- {
- valueCharsWide = SINGLE_FLOAT_VALUE_WIDTH;
- labelWidth = SINGLE_FLOAT_LABEL_WIDTH;
- }
- else
- {
- valueCharsWide = SINGLE_VALUE_WIDTH;
- labelWidth = SINGLE_LABEL_WIDTH;
- }
- }
- itemWinWidth = valueCharsWide + labelWidth;
- /*
- ** Now create each data "sub" window, and write the display into it.
- */
- curY = 1;
- while (i < dataWin->detail.dataDisplayInfo.regsContentCount &&
- curY <= dataWin->generic.viewportHeight)
+ int i = start_element_no;
+ int j, value_chars_wide, item_win_width, cur_y;
+
+ int max_len = 0;
+ for (i = 0; i < display_info->regs_content_count; i++)
+ {
+ struct tui_data_element *data;
+ struct tui_gen_win_info *data_item_win;
+ 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;
+ len = 0;
+ p = data->content;
+ if (p != 0)
+ while (*p)
+ {
+ if (*p++ == '\t')
+ len = 8 * ((len / 8) + 1);
+ else
+ len++;
+ }
+
+ if (len > max_len)
+ max_len = len;
+ }
+ item_win_width = max_len + 1;
+ i = start_element_no;
+
+ display_info->regs_column_count =
+ (TUI_DATA_WIN->generic.width - 2) / item_win_width;
+ if (display_info->regs_column_count == 0)
+ display_info->regs_column_count = 1;
+ item_win_width =
+ (TUI_DATA_WIN->generic.width - 2) / display_info->regs_column_count;
+
+ /* Now create each data "sub" window, and write the display into
+ it. */
+ cur_y = 1;
+ while (i < display_info->regs_content_count
+ && cur_y <= TUI_DATA_WIN->generic.viewport_height)
{
for (j = 0;
- (j < dataWin->detail.dataDisplayInfo.regsColumnCount &&
- i < dataWin->detail.dataDisplayInfo.regsContentCount); j++)
+ j < display_info->regs_column_count
+ && i < display_info->regs_content_count;
+ j++)
{
- struct tui_gen_win_info * dataItemWin;
- struct tui_data_element * dataElementPtr;
-
- /* create the window if necessary */
- dataItemWin = &dataWin->detail.dataDisplayInfo.
- regsContent[i]->whichElement.dataWindow;
- dataElementPtr = &((struct tui_win_element *)
- dataItemWin->content[0])->whichElement.data;
- if (dataItemWin->handle == (WINDOW *) NULL)
+ struct tui_gen_win_info *data_item_win;
+ struct tui_data_element *data_element_ptr;
+
+ /* 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;
+ if (data_item_win->handle != (WINDOW*) NULL
+ && (data_item_win->height != 1
+ || data_item_win->width != item_win_width
+ || data_item_win->origin.x != (item_win_width * j) + 1
+ || data_item_win->origin.y != cur_y))
+ {
+ tui_delete_win (data_item_win->handle);
+ data_item_win->handle = 0;
+ }
+
+ if (data_item_win->handle == (WINDOW *) NULL)
{
- dataItemWin->height = 1;
- dataItemWin->width = (precision == double_precision) ?
- itemWinWidth + 2 : itemWinWidth + 1;
- dataItemWin->origin.x = (itemWinWidth * j) + 1;
- dataItemWin->origin.y = curY;
- tui_make_window (dataItemWin, DONT_BOX_WINDOW);
- scrollok (dataItemWin->handle, FALSE);
+ data_item_win->height = 1;
+ data_item_win->width = item_win_width;
+ data_item_win->origin.x = (item_win_width * j) + 1;
+ data_item_win->origin.y = cur_y;
+ tui_make_window (data_item_win, DONT_BOX_WINDOW);
+ scrollok (data_item_win->handle, FALSE);
}
- touchwin (dataItemWin->handle);
-
- /*
- ** Get the printable representation of the register
- ** and display it
- */
- _tuiDisplayRegister (
- dataElementPtr->itemNo, dataItemWin, precision);
- i++; /* next register */
+ touchwin (data_item_win->handle);
+
+ /* Get the printable representation of the register
+ and display it. */
+ tui_display_register (data_element_ptr, data_item_win);
+ i++; /* Next register. */
}
- curY++; /* next row; */
+ cur_y++; /* Next row. */
}
}
-
- return;
}
-/*
- ** tuiDisplayRegElementAtLine().
- ** Function to display the registers in the content from
- ** 'startElementNo' on 'startLineNo' until the end of the
- ** register content or the end of the display height.
- ** This function checks that we won't display off the end
- ** of the register display.
- */
+/* Function to display the registers in the content from
+ 'start_element_no' on 'start_line_no' until the end of the register
+ content or the end of the display height. This function checks
+ that we won't display off the end of the register display. */
void
-tuiDisplayRegElementAtLine (int startElementNo, int startLineNo)
+tui_display_reg_element_at_line (int start_element_no,
+ int start_line_no)
{
- if (dataWin->detail.dataDisplayInfo.regsContent != (tui_win_content) NULL &&
- dataWin->detail.dataDisplayInfo.regsContentCount > 0)
+ 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)
{
- register int elementNo = startElementNo;
+ int element_no = start_element_no;
- if (startElementNo != 0 && startLineNo != 0)
+ if (start_element_no != 0 && start_line_no != 0)
{
- register int lastLineNo, firstLineOnLastPage;
-
- lastLineNo = tui_last_regs_line_no ();
- firstLineOnLastPage = lastLineNo - (dataWin->generic.height - 2);
- if (firstLineOnLastPage < 0)
- firstLineOnLastPage = 0;
- /*
- ** If there is no other data displayed except registers,
- ** and the elementNo causes us to scroll past the end of the
- ** registers, adjust what element to really start the display at.
- */
- if (dataWin->detail.dataDisplayInfo.dataContentCount <= 0 &&
- startLineNo > firstLineOnLastPage)
- elementNo = tui_first_reg_element_no_inline (firstLineOnLastPage);
+ 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);
+ if (first_line_on_last_page < 0)
+ first_line_on_last_page = 0;
+
+ /* If there is no other data displayed except registers, and
+ the element_no causes us to scroll past the end of the
+ registers, adjust what element to really start the
+ 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);
}
- tui_display_registers_from (elementNo);
+ tui_display_registers_from (element_no);
}
-
- return;
-} /* tuiDisplayRegElementAtLine */
+}
-/* Function to display the registers starting at line lineNo in the
+/* Function to display the registers starting at line line_no in the
data window. Answers the line number that the display actually
started from. If nothing is displayed (-1) is returned. */
int
-tui_display_registers_from_line (int lineNo, int forceDisplay)
+tui_display_registers_from_line (int line_no,
+ int force_display)
{
- if (dataWin->detail.dataDisplayInfo.regsContentCount > 0)
+ if (TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
{
- int line, elementNo;
+ int line, element_no;
- if (lineNo < 0)
+ if (line_no < 0)
line = 0;
- else if (forceDisplay)
- { /*
- ** If we must display regs (forceDisplay is true), then make
- ** sure that we don't display off the end of the registers.
- */
- if (lineNo >= tui_last_regs_line_no ())
+ else if (force_display)
+ { /* If we must display regs (force_display is true), then
+ make sure that we don't display off the end of the
+ registers. */
+ if (line_no >= tui_last_regs_line_no ())
{
if ((line = tui_line_from_reg_element_no (
- dataWin->detail.dataDisplayInfo.regsContentCount - 1)) < 0)
+ TUI_DATA_WIN->detail.data_display_info.regs_content_count - 1)) < 0)
line = 0;
}
else
- line = lineNo;
+ line = line_no;
}
else
- line = lineNo;
+ line = line_no;
- elementNo = tui_first_reg_element_no_inline (line);
- if (elementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
- tuiDisplayRegElementAtLine (elementNo, line);
+ element_no = tui_first_reg_element_no_inline (line);
+ 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);
return line;
}
- return (-1); /* nothing was displayed */
+ return (-1); /* Nothing was displayed. */
}
void
tui_check_register_values (struct frame_info *frame)
{
- if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
+ if (TUI_DATA_WIN != NULL
+ && TUI_DATA_WIN->generic.is_visible)
{
- if (dataWin->detail.dataDisplayInfo.regsContentCount <= 0 &&
- dataWin->detail.dataDisplayInfo.displayRegs)
- tui_show_registers ((tui_layout_def ())->regsDisplayType);
+ struct tui_data_info *display_info
+ = &TUI_DATA_WIN->detail.data_display_info;
+
+ if (display_info->regs_content_count <= 0
+ && display_info->display_regs)
+ tui_show_registers (display_info->current_group);
else
{
int i, j;
- char rawBuf[MAX_REGISTER_SIZE];
- for (i = 0;
- (i < dataWin->detail.dataDisplayInfo.regsContentCount); i++)
+ for (i = 0; (i < display_info->regs_content_count); i++)
{
- struct tui_data_element * dataElementPtr;
- struct tui_gen_win_info * dataItemWinPtr;
- int wasHilighted;
-
- dataItemWinPtr = &dataWin->detail.dataDisplayInfo.
- regsContent[i]->whichElement.dataWindow;
- dataElementPtr = &((struct tui_win_element *)
- dataItemWinPtr->content[0])->whichElement.data;
- wasHilighted = dataElementPtr->highlight;
- dataElementPtr->highlight =
- _tuiRegValueHasChanged (dataElementPtr, frame, &rawBuf[0]);
- if (dataElementPtr->highlight)
- {
- int size;
-
- size = DEPRECATED_REGISTER_RAW_SIZE (dataElementPtr->itemNo);
- for (j = 0; j < size; j++)
- ((char *) dataElementPtr->value)[j] = rawBuf[j];
- _tuiDisplayRegister (
- dataElementPtr->itemNo,
- dataItemWinPtr,
- ((dataWin->detail.dataDisplayInfo.regsDisplayType ==
- TUI_DFLOAT_REGS) ?
- double_precision : unspecified_precision));
- }
- else if (wasHilighted)
+ struct tui_data_element *data;
+ struct tui_gen_win_info *data_item_win_ptr;
+ int was_hilighted;
+
+ 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;
+ was_hilighted = data->highlight;
+
+ tui_get_register (current_gdbarch, frame, data,
+ data->item_no, &data->highlight);
+
+ if (data->highlight || was_hilighted)
{
- dataElementPtr->highlight = FALSE;
- _tuiDisplayRegister (
- dataElementPtr->itemNo,
- dataItemWinPtr,
- ((dataWin->detail.dataDisplayInfo.regsDisplayType ==
- TUI_DFLOAT_REGS) ?
- double_precision : unspecified_precision));
+ tui_display_register (data, data_item_win_ptr);
}
}
}
}
- return;
}
+/* Display a register in a window. If hilite is TRUE, then the value
+ will be displayed in reverse video. */
+static void
+tui_display_register (struct tui_data_element *data,
+ struct tui_gen_win_info *win_info)
+{
+ if (win_info->handle != (WINDOW *) NULL)
+ {
+ int i;
-/*
- ** tuiToggleFloatRegs().
- */
-void
-tuiToggleFloatRegs (void)
+ if (data->highlight)
+ wstandout (win_info->handle);
+
+ wmove (win_info->handle, 0, 0);
+ for (i = 1; i < win_info->width; i++)
+ waddch (win_info->handle, ' ');
+ wmove (win_info->handle, 0, 0);
+ if (data->content)
+ waddstr (win_info->handle, data->content);
+
+ if (data->highlight)
+ wstandend (win_info->handle);
+ tui_refresh_win (win_info);
+ }
+}
+
+static void
+tui_reg_next_command (char *arg, int from_tty)
{
- struct tui_layout_def * layoutDef = tui_layout_def ();
+ if (TUI_DATA_WIN != 0)
+ {
+ struct reggroup *group
+ = TUI_DATA_WIN->detail.data_display_info.current_group;
- if (layoutDef->floatRegsDisplayType == TUI_SFLOAT_REGS)
- layoutDef->floatRegsDisplayType = TUI_DFLOAT_REGS;
- else
- layoutDef->floatRegsDisplayType = TUI_SFLOAT_REGS;
+ group = reggroup_next (current_gdbarch, group);
+ if (group == 0)
+ group = reggroup_next (current_gdbarch, 0);
- if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible &&
- (dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_SFLOAT_REGS ||
- dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_DFLOAT_REGS))
- tui_show_registers (layoutDef->floatRegsDisplayType);
+ if (group)
+ tui_show_registers (group);
+ }
+}
- return;
-} /* tuiToggleFloatRegs */
+static void
+tui_reg_float_command (char *arg, int from_tty)
+{
+ tui_show_registers (float_reggroup);
+}
+static void
+tui_reg_general_command (char *arg, int from_tty)
+{
+ tui_show_registers (general_reggroup);
+}
+
+static void
+tui_reg_system_command (char *arg, int from_tty)
+{
+ tui_show_registers (system_reggroup);
+}
+
+static struct cmd_list_element *tuireglist;
+
+static void
+tui_reg_command (char *args, int from_tty)
+{
+ printf_unfiltered (_("\"tui reg\" must be followed by the name of a "
+ "tui reg command.\n"));
+ help_list (tuireglist, "tui reg ", -1, gdb_stdout);
+}
void
-_initialize_tuiRegs (void)
+_initialize_tui_regs (void)
{
+ struct cmd_list_element **tuicmd;
+
+ 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, _tuiShowFloat_command,
- "Display only floating point registers\n");
- add_com ("gr", class_tui, _tuiShowGeneral_command,
- "Display only general registers\n");
- add_com ("sr", class_tui, _tuiShowSpecial_command,
- "Display only special registers\n");
- add_com ("+r", class_tui, _tuiScrollRegsForward_command,
- "Scroll the registers window forward\n");
- add_com ("-r", class_tui, _tuiScrollRegsBackward_command,
- "Scroll the register window backward\n");
- add_com ("tf", class_tui, _tuiToggleFloatRegs_command,
- "Toggle between single and double precision floating point registers.\n");
- add_cmd (TUI_FLOAT_REGS_NAME_LOWER,
- class_tui,
- _tuiToggleFloatRegs_command,
- "Toggle between single and double precision floating point \
-registers.\n",
- &togglelist);
+ 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"));
}
}
** STATIC LOCAL FUNCTIONS **
******************************************/
-
-/*
- ** _tuiRegisterName().
- ** Return the register name.
- */
-static const char *
-_tuiRegisterName (int regNum)
-{
- return REGISTER_NAME (regNum);
-}
extern int pagination_enabled;
static void
pagination_enabled = 1;
}
-/*
- ** _tuiRegisterFormat
- ** Function to format the register name and value into a buffer,
- ** suitable for printing or display
- */
+/* Get the register from the frame and make a printable representation
+ of it in the data element. */
static void
-_tuiRegisterFormat (char *buf, int bufLen, int regNum,
- struct tui_data_element * dataElement,
- enum precision_type precision)
+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;
+ char *p, *s;
int pos;
+ struct type *type = register_type (gdbarch, regnum);
- name = REGISTER_NAME (regNum);
+ name = gdbarch_register_name (gdbarch, regnum);
if (name == 0)
{
- strcpy (buf, "");
return;
}
pagination_enabled = 0;
old_stdout = gdb_stdout;
- stream = tui_sfileopen (bufLen);
+ stream = tui_sfileopen (256);
gdb_stdout = stream;
cleanups = make_cleanup (tui_restore_gdbout, (void*) old_stdout);
- gdbarch_print_registers_info (current_gdbarch, stream, deprecated_selected_frame,
- regNum, 1);
-
- /* Save formatted output in the buffer. */
- p = tui_file_get_strbuf (stream);
- pos = 0;
- while (*p && *p == *name++ && bufLen)
+ if (TYPE_VECTOR (type) != 0 && 0)
{
- *buf++ = *p++;
- bufLen--;
- pos++;
+ gdb_byte buf[MAX_REGISTER_SIZE];
+ int len;
+
+ len = register_size (current_gdbarch, regnum);
+ fprintf_filtered (stream, "%-14s ", name);
+ get_frame_register (frame, regnum, buf);
+ print_scalar_formatted (buf, type, 'f', len, stream);
}
- while (*p == ' ')
- p++;
- while (pos < 8 && bufLen)
+ else
{
- *buf++ = ' ';
- bufLen--;
- pos++;
+ gdbarch_print_registers_info (current_gdbarch, stream,
+ frame, regnum, 1);
}
- strncpy (buf, p, bufLen);
+
+ /* Save formatted output in the buffer. */
+ p = tui_file_get_strbuf (stream);
/* Remove the possible \n. */
- p = strchr (buf, '\n');
- if (p)
- *p = 0;
+ s = strrchr (p, '\n');
+ if (s && s[1] == 0)
+ *s = 0;
+ xfree (data_element->content);
+ data_element->content = xstrdup (p);
do_cleanups (cleanups);
}
-
-#define NUM_GENERAL_REGS 32
-/*
- ** _tuiSetGeneralRegsContent().
- ** Set the content of the data window to consist of the general registers.
- */
-static enum tui_status
-_tuiSetGeneralRegsContent (int refreshValuesOnly)
-{
- return (_tuiSetRegsContent (0,
- NUM_GENERAL_REGS - 1,
- deprecated_selected_frame,
- TUI_GENERAL_REGS,
- refreshValuesOnly));
-
-} /* _tuiSetGeneralRegsContent */
-
-
-#ifndef PCOQ_HEAD_REGNUM
-#define START_SPECIAL_REGS 0
-#else
-#define START_SPECIAL_REGS PCOQ_HEAD_REGNUM
-#endif
-
-/*
- ** _tuiSetSpecialRegsContent().
- ** Set the content of the data window to consist of the special registers.
- */
-static enum tui_status
-_tuiSetSpecialRegsContent (int refreshValuesOnly)
-{
- enum tui_status ret = TUI_FAILURE;
- int endRegNum;
-
- endRegNum = FP0_REGNUM - 1;
- ret = _tuiSetRegsContent (START_SPECIAL_REGS,
- endRegNum,
- deprecated_selected_frame,
- TUI_SPECIAL_REGS,
- refreshValuesOnly);
-
- return ret;
-} /* _tuiSetSpecialRegsContent */
-
-
-/*
- ** _tuiSetGeneralAndSpecialRegsContent().
- ** Set the content of the data window to consist of the special registers.
- */
-static enum tui_status
-_tuiSetGeneralAndSpecialRegsContent (int refreshValuesOnly)
-{
- enum tui_status ret = TUI_FAILURE;
- int endRegNum = (-1);
-
- endRegNum = FP0_REGNUM - 1;
- ret = _tuiSetRegsContent (
- 0, endRegNum, deprecated_selected_frame, TUI_SPECIAL_REGS, refreshValuesOnly);
-
- return ret;
-} /* _tuiSetGeneralAndSpecialRegsContent */
-
-/*
- ** _tuiSetFloatRegsContent().
- ** Set the content of the data window to consist of the float registers.
- */
-static enum tui_status
-_tuiSetFloatRegsContent (enum tui_register_display_type dpyType, int refreshValuesOnly)
-{
- enum tui_status ret = TUI_FAILURE;
- int startRegNum;
-
- startRegNum = FP0_REGNUM;
- ret = _tuiSetRegsContent (startRegNum,
- NUM_REGS - 1,
- deprecated_selected_frame,
- dpyType,
- refreshValuesOnly);
-
- return ret;
-} /* _tuiSetFloatRegsContent */
-
-
-/*
- ** _tuiRegValueHasChanged().
- ** Answer TRUE if the register's value has changed, FALSE otherwise.
- ** If TRUE, newValue is filled in with the new value.
- */
-static int
-_tuiRegValueHasChanged (struct tui_data_element * dataElement,
- struct frame_info *frame,
- char *newValue)
-{
- int hasChanged = FALSE;
-
- if (dataElement->itemNo != UNDEFINED_ITEM &&
- _tuiRegisterName (dataElement->itemNo) != (char *) NULL)
- {
- char rawBuf[MAX_REGISTER_SIZE];
- int i;
-
- if (_tuiGetRegisterRawValue (
- dataElement->itemNo, rawBuf, frame) == TUI_SUCCESS)
- {
- int size = DEPRECATED_REGISTER_RAW_SIZE (dataElement->itemNo);
-
- for (i = 0; (i < size && !hasChanged); i++)
- hasChanged = (((char *) dataElement->value)[i] != rawBuf[i]);
- if (hasChanged && newValue != (char *) NULL)
- {
- for (i = 0; i < size; i++)
- newValue[i] = rawBuf[i];
- }
- }
- }
- return hasChanged;
-} /* _tuiRegValueHasChanged */
-
-
-
-/*
- ** _tuiGetRegisterRawValue().
- ** Get the register raw value. The raw value is returned in regValue.
- */
+/* 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
-_tuiGetRegisterRawValue (int regNum, char *regValue, struct frame_info *frame)
+tui_get_register (struct gdbarch *gdbarch,
+ struct frame_info *frame,
+ struct tui_data_element *data,
+ int regnum, int *changedp)
{
enum tui_status ret = TUI_FAILURE;
+ if (changedp)
+ *changedp = FALSE;
if (target_has_registers)
{
- get_frame_register (frame, regNum, regValue);
- /* NOTE: cagney/2003-03-13: This is bogus. It is refering to
- the register cache and not the frame which could have pulled
- the register value off the stack. */
- if (register_cached (regNum) >= 0)
- ret = TUI_SUCCESS;
- }
- return ret;
-} /* _tuiGetRegisterRawValue */
-
-
+ gdb_byte buf[MAX_REGISTER_SIZE];
+ get_frame_register (frame, regnum, buf);
-/*
- ** _tuiSetRegisterElement().
- ** Function to initialize a data element with the input and
- ** the register value.
- */
-static void
-_tuiSetRegisterElement (int regNum, struct frame_info *frame,
- struct tui_data_element * dataElement,
- int refreshValueOnly)
-{
- if (dataElement != (struct tui_data_element *) NULL)
- {
- if (!refreshValueOnly)
+ if (changedp)
{
- dataElement->itemNo = regNum;
- dataElement->name = _tuiRegisterName (regNum);
- dataElement->highlight = FALSE;
+ int size = register_size (gdbarch, regnum);
+ char *old = (char*) data->value;
+ int i;
+
+ for (i = 0; i < size; i++)
+ if (buf[i] != old[i])
+ {
+ *changedp = TRUE;
+ old[i] = buf[i];
+ }
}
- if (dataElement->value == NULL)
- dataElement->value = xmalloc (MAX_REGISTER_SIZE);
- if (dataElement->value != NULL)
- _tuiGetRegisterRawValue (regNum, dataElement->value, frame);
- }
-
- return;
-} /* _tuiSetRegisterElement */
+ /* Reformat the data content if the value changed. */
+ if (changedp == 0 || *changedp == TRUE)
+ tui_register_format (gdbarch, frame, data, regnum);
-/*
- ** _tuiSetRegsContent().
- ** Set the content of the data window to consist of the registers
- ** numbered from startRegNum to endRegNum. Note that if
- ** refreshValuesOnly is TRUE, startRegNum and endRegNum are ignored.
- */
-static enum tui_status
-_tuiSetRegsContent (int startRegNum, int endRegNum,
- struct frame_info *frame,
- enum tui_register_display_type dpyType,
- int refreshValuesOnly)
-{
- enum tui_status ret = TUI_FAILURE;
- int numRegs = endRegNum - startRegNum + 1;
- int allocatedHere = FALSE;
-
- if (dataWin->detail.dataDisplayInfo.regsContentCount > 0 &&
- !refreshValuesOnly)
- {
- tui_free_data_content (dataWin->detail.dataDisplayInfo.regsContent,
- dataWin->detail.dataDisplayInfo.regsContentCount);
- dataWin->detail.dataDisplayInfo.regsContentCount = 0;
- }
- if (dataWin->detail.dataDisplayInfo.regsContentCount <= 0)
- {
- dataWin->detail.dataDisplayInfo.regsContent =
- tui_alloc_content (numRegs, DATA_WIN);
- allocatedHere = TRUE;
- }
-
- if (dataWin->detail.dataDisplayInfo.regsContent != (tui_win_content) NULL)
- {
- int i;
-
- if (!refreshValuesOnly || allocatedHere)
- {
- dataWin->generic.content = NULL;
- dataWin->generic.contentSize = 0;
- tui_add_content_elements (&dataWin->generic, numRegs);
- dataWin->detail.dataDisplayInfo.regsContent =
- (tui_win_content) dataWin->generic.content;
- dataWin->detail.dataDisplayInfo.regsContentCount = numRegs;
- }
- /*
- ** Now set the register names and values
- */
- for (i = startRegNum; (i <= endRegNum); i++)
- {
- struct tui_gen_win_info * dataItemWin;
-
- dataItemWin = &dataWin->detail.dataDisplayInfo.
- regsContent[i - startRegNum]->whichElement.dataWindow;
- _tuiSetRegisterElement (
- i,
- frame,
- &((struct tui_win_element *) dataItemWin->content[0])->whichElement.data,
- !allocatedHere && refreshValuesOnly);
- }
- dataWin->detail.dataDisplayInfo.regsColumnCount =
- tui_calculate_regs_column_count (dpyType);
-#ifdef LATER
- if (dataWin->detail.dataDisplayInfo.dataContentCount > 0)
- {
- /* delete all the windows? */
- /* realloc content equal to dataContentCount + regsContentCount */
- /* append dataWin->detail.dataDisplayInfo.dataContent to content */
- }
-#endif
- dataWin->generic.contentSize =
- dataWin->detail.dataDisplayInfo.regsContentCount +
- dataWin->detail.dataDisplayInfo.dataContentCount;
ret = TUI_SUCCESS;
}
-
return ret;
-} /* _tuiSetRegsContent */
-
-
-/*
- ** _tuiDisplayRegister().
- ** Function to display a register in a window. If hilite is TRUE,
- ** than the value will be displayed in reverse video
- */
-static void
-_tuiDisplayRegister (int regNum,
- struct tui_gen_win_info * winInfo, /* the data item window */
- enum precision_type precision)
-{
- if (winInfo->handle != (WINDOW *) NULL)
- {
- int i;
- char buf[40];
- int valueCharsWide, labelWidth;
- struct tui_data_element * dataElementPtr = &((tui_win_content)
- winInfo->content)[0]->whichElement.data;
-
- if (IS_64BIT ||
- dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_DFLOAT_REGS)
- {
- valueCharsWide = DOUBLE_FLOAT_VALUE_WIDTH;
- labelWidth = DOUBLE_FLOAT_LABEL_WIDTH;
- }
- else
- {
- if (dataWin->detail.dataDisplayInfo.regsDisplayType ==
- TUI_SFLOAT_REGS)
- {
- valueCharsWide = SINGLE_FLOAT_VALUE_WIDTH;
- labelWidth = SINGLE_FLOAT_LABEL_WIDTH;
- }
- else
- {
- valueCharsWide = SINGLE_VALUE_WIDTH;
- labelWidth = SINGLE_LABEL_WIDTH;
- }
- }
-
- buf[0] = (char) 0;
- _tuiRegisterFormat (buf,
- valueCharsWide + labelWidth,
- regNum,
- dataElementPtr,
- precision);
-
- if (dataElementPtr->highlight)
- wstandout (winInfo->handle);
-
- wmove (winInfo->handle, 0, 0);
- for (i = 1; i < winInfo->width; i++)
- waddch (winInfo->handle, ' ');
- wmove (winInfo->handle, 0, 0);
- waddstr (winInfo->handle, buf);
-
- if (dataElementPtr->highlight)
- wstandend (winInfo->handle);
- tui_refresh_win (winInfo);
- }
- return;
-} /* _tuiDisplayRegister */
-
-
-static void
-_tui_vShowRegisters_commandSupport (enum tui_register_display_type dpyType)
-{
-
- if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
- { /* Data window already displayed, show the registers */
- if (dataWin->detail.dataDisplayInfo.regsDisplayType != dpyType)
- tui_show_registers (dpyType);
- }
- else
- (tui_layout_def ())->regsDisplayType = dpyType;
-
- return;
-} /* _tui_vShowRegisters_commandSupport */
-
-
-static void
-_tuiShowFloat_command (char *arg, int fromTTY)
-{
- if (m_winPtrIsNull (dataWin) || !dataWin->generic.isVisible ||
- (dataWin->detail.dataDisplayInfo.regsDisplayType != TUI_SFLOAT_REGS &&
- dataWin->detail.dataDisplayInfo.regsDisplayType != TUI_DFLOAT_REGS))
- _tui_vShowRegisters_commandSupport ((tui_layout_def ())->floatRegsDisplayType);
-
- return;
-} /* _tuiShowFloat_command */
-
-
-static void
-_tuiShowGeneral_command (char *arg, int fromTTY)
-{
- _tui_vShowRegisters_commandSupport (TUI_GENERAL_REGS);
}
-
-static void
-_tuiShowSpecial_command (char *arg, int fromTTY)
-{
- _tui_vShowRegisters_commandSupport (TUI_SPECIAL_REGS);
-}
-
-
-static void
-_tuiToggleFloatRegs_command (char *arg, int fromTTY)
-{
- if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
- tuiToggleFloatRegs ();
- else
- {
- struct tui_layout_def * layoutDef = tui_layout_def ();
-
- if (layoutDef->floatRegsDisplayType == TUI_SFLOAT_REGS)
- layoutDef->floatRegsDisplayType = TUI_DFLOAT_REGS;
- else
- layoutDef->floatRegsDisplayType = TUI_SFLOAT_REGS;
- }
-
-
- return;
-} /* _tuiToggleFloatRegs_command */
-
-
static void
-_tuiScrollRegsForward_command (char *arg, int fromTTY)
+tui_scroll_regs_forward_command (char *arg, int from_tty)
{
- tui_scroll (FORWARD_SCROLL, dataWin, 1);
+ tui_scroll (FORWARD_SCROLL, TUI_DATA_WIN, 1);
}
static void
-_tuiScrollRegsBackward_command (char *arg, int fromTTY)
+tui_scroll_regs_backward_command (char *arg, int from_tty)
{
- tui_scroll (BACKWARD_SCROLL, dataWin, 1);
+ tui_scroll (BACKWARD_SCROLL, TUI_DATA_WIN, 1);
}
projects / thirdparty / binutils-gdb.git / blobdiff