/* TUI display registers in window.
- Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
- Inc.
+ Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
+ Free Software Foundation, Inc.
Contributed by Hewlett-Packard Company.
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. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
#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 TuiStatus _tuiSetRegsContent
- (int, int, struct frame_info *, TuiRegisterDisplayType, int);
-static const char *_tuiRegisterName (int);
-static TuiStatus _tuiGetRegisterRawValue (int, char *, struct frame_info *);
-static void _tuiSetRegisterElement
- (int, struct frame_info *, TuiDataElementPtr, int);
-static void _tuiDisplayRegister (int, TuiGenWinInfoPtr, enum precision_type);
-static void _tuiRegisterFormat
- (char *, int, int, TuiDataElementPtr, enum precision_type);
-static TuiStatus _tuiSetGeneralRegsContent (int);
-static TuiStatus _tuiSetSpecialRegsContent (int);
-static TuiStatus _tuiSetGeneralAndSpecialRegsContent (int);
-static TuiStatus _tuiSetFloatRegsContent (TuiRegisterDisplayType, int);
-static int _tuiRegValueHasChanged
- (TuiDataElementPtr, 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 (TuiRegisterDisplayType);
-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);
** PUBLIC FUNCTIONS **
******************************************/
-/*
- ** tuiLastRegsLineNo()
- ** Answer the number of the last line in the regs display.
- ** If there are no registers (-1) is returned.
- */
+/* Answer the number of the last line in the regs display. If there
+ are no registers (-1) is returned. */
int
-tuiLastRegsLineNo (void)
+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;
-} /* tuiLastRegsLineNo */
+ return num_lines;
+}
-/*
- ** tuiLineFromRegElementNo()
- ** Answer the line number that the register element at elementNo is
- ** on. If elementNo is greater than the number of register elements
- ** there are, -1 is returned.
- */
+/* 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
-tuiLineFromRegElementNo (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++;
}
else
return (-1);
-} /* tuiLineFromRegElementNo */
+}
-/*
- ** tuiFirstRegElementNoInLine()
- ** 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
-tuiFirstRegElementNoInLine (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);
-} /* tuiFirstRegElementNoInLine */
+}
-/*
- ** 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 */
-
+}
-/*
- ** tuiCalculateRegsColumnCount
- ** Calculate the number of columns that should be used to display
- ** the registers.
- */
-int
-tuiCalculateRegsColumnCount (TuiRegisterDisplayType 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;
-
- 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;
+ enum tui_status ret = TUI_FAILURE;
+ struct tui_data_info *display_info;
- return colCount;
-} /* tuiCalulateRegsColumnCount */
+ /* Make sure the curses mode is enabled. */
+ tui_enable ();
+ /* 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);
-/*
- ** tuiShowRegisters().
- ** 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
-tuiShowRegisters (TuiRegisterDisplayType dpyType)
-{
- TuiStatus ret = TUI_FAILURE;
- int refreshValuesOnly = FALSE;
+ display_info = &TUI_DATA_WIN->detail.data_display_info;
+ if (group == 0)
+ group = general_reggroup;
- /* 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;
- tuiEraseDataContent (NO_REGS_STRING);
+ 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++)
+ for (i = 0; i < display_info->regs_content_count; i++)
{
- TuiGenWinInfoPtr dataItemWin;
+ struct tui_gen_win_info *data_item_win;
+ struct tui_win_element *win;
- dataItemWin = &dataWin->detail.dataDisplayInfo.
- regsContent[i]->whichElement.dataWindow;
- (&((TuiWinElementPtr)
- 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;
- tuiDisplayAllData ();
+ display_info->current_group = group;
+ tui_display_all_data ();
}
- (tuiLayoutDef ())->regsDisplayType = dpyType;
+}
- return;
-} /* tuiShowRegisters */
+/* 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. */
-/*
- ** tuiDisplayRegistersFrom().
- ** Function to display the registers in the content from
- ** 'startElementNo' 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
-tuiDisplayRegistersFrom (int startElementNo)
+static enum tui_status
+tui_show_register_group (struct gdbarch *gdbarch, struct reggroup *group,
+ struct frame_info *frame, int refresh_values_only)
{
- if (dataWin->detail.dataDisplayInfo.regsContent != (TuiWinContent) NULL &&
- dataWin->detail.dataDisplayInfo.regsContentCount > 0)
+ 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)
{
- 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)
+ 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)
{
- valueCharsWide = DOUBLE_FLOAT_VALUE_WIDTH;
- labelWidth = DOUBLE_FLOAT_LABEL_WIDTH;
+ 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;
}
- 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;
- }
+
+ /* 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++;
}
- itemWinWidth = valueCharsWide + labelWidth;
+
+ 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
+ '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 start_element_no)
+{
+ 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)
+ {
+ 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.
*/
- curY = 1;
- while (i < dataWin->detail.dataDisplayInfo.regsContentCount &&
- curY <= dataWin->generic.viewportHeight)
+ 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++)
{
- TuiGenWinInfoPtr dataItemWin;
- TuiDataElementPtr dataElementPtr;
+ struct tui_gen_win_info * data_item_win;
+ struct tui_data_element * data_element_ptr;
/* create the window if necessary */
- dataItemWin = &dataWin->detail.dataDisplayInfo.
- regsContent[i]->whichElement.dataWindow;
- dataElementPtr = &((TuiWinElementPtr)
- dataItemWin->content[0])->whichElement.data;
- if (dataItemWin->handle == (WINDOW *) NULL)
+ 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;
- makeWindow (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);
+ 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;
-} /* tuiDisplayRegistersFrom */
+}
-/*
- ** 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 != (TuiWinContent) 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;
+ int last_line_no, first_line_on_last_page;
- lastLineNo = tuiLastRegsLineNo ();
- firstLineOnLastPage = lastLineNo - (dataWin->generic.height - 2);
- if (firstLineOnLastPage < 0)
- firstLineOnLastPage = 0;
+ 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 elementNo causes us to scroll past the end of the
+ ** and the element_no 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 = tuiFirstRegElementNoInLine (firstLineOnLastPage);
+ 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);
}
- tuiDisplayRegistersFrom (elementNo);
+ tui_display_registers_from (element_no);
}
-
- return;
-} /* tuiDisplayRegElementAtLine */
+}
-/*
- ** tuiDisplayRegistersFromLine().
- ** Function to display the registers starting at line lineNo in
- ** the data window. Answers the line number that the display
- ** actually started from. If nothing is displayed (-1) is returned.
- */
+/* 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
-tuiDisplayRegistersFromLine (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)
+ else if (force_display)
{ /*
- ** If we must display regs (forceDisplay is true), then make
+ ** If we must display regs (force_display is true), then make
** sure that we don't display off the end of the registers.
*/
- if (lineNo >= tuiLastRegsLineNo ())
+ if (line_no >= tui_last_regs_line_no ())
{
- if ((line = tuiLineFromRegElementNo (
- dataWin->detail.dataDisplayInfo.regsContentCount - 1)) < 0)
+ if ((line = tui_line_from_reg_element_no (
+ 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 = tuiFirstRegElementNoInLine (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 (-1); /* nothing was displayed */
-} /* tuiDisplayRegistersFromLine */
+}
-/*
- ** tuiCheckRegisterValues()
- ** This function check all displayed registers for changes in
- ** values, given a particular frame. If the values have changed,
- ** they are updated with the new value and highlighted.
- */
+/* This function check all displayed registers for changes in values,
+ given a particular frame. If the values have changed, they are
+ updated with the new value and highlighted. */
void
-tuiCheckRegisterValues (struct frame_info *frame)
+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)
- tuiShowRegisters ((tuiLayoutDef ())->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++)
{
- TuiDataElementPtr dataElementPtr;
- TuiGenWinInfoPtr dataItemWinPtr;
- int wasHilighted;
-
- dataItemWinPtr = &dataWin->detail.dataDisplayInfo.
- regsContent[i]->whichElement.dataWindow;
- dataElementPtr = &((TuiWinElementPtr)
- 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;
-} /* tuiCheckRegisterValues */
+}
+/* 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)
{
- TuiLayoutDefPtr layoutDef = tuiLayoutDef ();
+ 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))
- tuiShowRegisters (layoutDef->floatRegsDisplayType);
+ if (group)
+ tui_show_registers (group);
+ }
+}
+
+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);
+}
- return;
-} /* tuiToggleFloatRegs */
+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,
- TuiDataElementPtr 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 TuiStatus
-_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 TuiStatus
-_tuiSetSpecialRegsContent (int refreshValuesOnly)
-{
- TuiStatus 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 TuiStatus
-_tuiSetGeneralAndSpecialRegsContent (int refreshValuesOnly)
-{
- TuiStatus 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 TuiStatus
-_tuiSetFloatRegsContent (TuiRegisterDisplayType dpyType, int refreshValuesOnly)
-{
- TuiStatus 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 (TuiDataElementPtr dataElement,
- struct frame_info *frame,
- char *newValue)
+/* 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,
+ struct tui_data_element *data, int regnum, int *changedp)
{
- 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.
- */
-static TuiStatus
-_tuiGetRegisterRawValue (int regNum, char *regValue, struct frame_info *frame)
-{
- TuiStatus ret = TUI_FAILURE;
+ 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,
- TuiDataElementPtr dataElement,
- int refreshValueOnly)
-{
- if (dataElement != (TuiDataElementPtr) 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 == (Opaque) NULL)
- dataElement->value = (Opaque) xmalloc (MAX_REGISTER_SIZE);
- if (dataElement->value != (Opaque) NULL)
- _tuiGetRegisterRawValue (regNum, dataElement->value, frame);
- }
- return;
-} /* _tuiSetRegisterElement */
-
-
-/*
- ** _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 TuiStatus
-_tuiSetRegsContent (int startRegNum, int endRegNum,
- struct frame_info *frame,
- TuiRegisterDisplayType dpyType,
- int refreshValuesOnly)
-{
- TuiStatus ret = TUI_FAILURE;
- int numRegs = endRegNum - startRegNum + 1;
- int allocatedHere = FALSE;
+ /* Reformat the data content if the value changed. */
+ if (changedp == 0 || *changedp == TRUE)
+ tui_register_format (gdbarch, frame, data, regnum);
- if (dataWin->detail.dataDisplayInfo.regsContentCount > 0 &&
- !refreshValuesOnly)
- {
- freeDataContent (dataWin->detail.dataDisplayInfo.regsContent,
- dataWin->detail.dataDisplayInfo.regsContentCount);
- dataWin->detail.dataDisplayInfo.regsContentCount = 0;
- }
- if (dataWin->detail.dataDisplayInfo.regsContentCount <= 0)
- {
- dataWin->detail.dataDisplayInfo.regsContent =
- allocContent (numRegs, DATA_WIN);
- allocatedHere = TRUE;
- }
-
- if (dataWin->detail.dataDisplayInfo.regsContent != (TuiWinContent) NULL)
- {
- int i;
-
- if (!refreshValuesOnly || allocatedHere)
- {
- dataWin->generic.content = (OpaquePtr) NULL;
- dataWin->generic.contentSize = 0;
- addContentElements (&dataWin->generic, numRegs);
- dataWin->detail.dataDisplayInfo.regsContent =
- (TuiWinContent) dataWin->generic.content;
- dataWin->detail.dataDisplayInfo.regsContentCount = numRegs;
- }
- /*
- ** Now set the register names and values
- */
- for (i = startRegNum; (i <= endRegNum); i++)
- {
- TuiGenWinInfoPtr dataItemWin;
-
- dataItemWin = &dataWin->detail.dataDisplayInfo.
- regsContent[i - startRegNum]->whichElement.dataWindow;
- _tuiSetRegisterElement (
- i,
- frame,
- &((TuiWinElementPtr) dataItemWin->content[0])->whichElement.data,
- !allocatedHere && refreshValuesOnly);
- }
- dataWin->detail.dataDisplayInfo.regsColumnCount =
- tuiCalculateRegsColumnCount (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,
- TuiGenWinInfoPtr winInfo, /* the data item window */
- enum precision_type precision)
-{
- if (winInfo->handle != (WINDOW *) NULL)
- {
- int i;
- char buf[40];
- int valueCharsWide, labelWidth;
- TuiDataElementPtr dataElementPtr = &((TuiWinContent)
- 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);
- tuiRefreshWin (winInfo);
- }
- return;
-} /* _tuiDisplayRegister */
-
-
-static void
-_tui_vShowRegisters_commandSupport (TuiRegisterDisplayType dpyType)
-{
-
- if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
- { /* Data window already displayed, show the registers */
- if (dataWin->detail.dataDisplayInfo.regsDisplayType != dpyType)
- tuiShowRegisters (dpyType);
- }
- else
- (tuiLayoutDef ())->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 ((tuiLayoutDef ())->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
- {
- TuiLayoutDefPtr layoutDef = tuiLayoutDef ();
-
- 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);
}