| /* TUI display registers in window. |
| |
| Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software |
| Foundation, Inc. |
| |
| Contributed by Hewlett-Packard Company. |
| |
| This file is part of GDB. |
| |
| 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 |
| (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 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. */ |
| |
| #include "defs.h" |
| #include "tui/tui.h" |
| #include "tui/tui-data.h" |
| #include "symtab.h" |
| #include "gdbtypes.h" |
| #include "gdbcmd.h" |
| #include "frame.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 "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 enum tui_status tui_set_regs_content |
| (int, int, struct frame_info *, enum tui_register_display_type, int); |
| static const char *tui_register_name (int); |
| static enum tui_status tui_get_register_raw_value (int, char *, struct frame_info *); |
| static void tui_set_register_element |
| (int, struct frame_info *, struct tui_data_element *, int); |
| static void tui_display_register (int, struct tui_gen_win_info *, enum precision_type); |
| static void tui_register_format |
| (char *, int, int, struct tui_data_element *, enum precision_type); |
| static enum tui_status tui_set_general_regs_content (int); |
| static enum tui_status tui_set_special_regs_content (int); |
| static enum tui_status tui_set_general_and_special_regs_content (int); |
| static enum tui_status tui_set_float_regs_content (enum tui_register_display_type, int); |
| static int tui_reg_value_has_changed |
| (struct tui_data_element *, struct frame_info *, char *); |
| static void tui_show_float_command (char *, int); |
| static void tui_show_general_command (char *, int); |
| static void tui_show_special_command (char *, int); |
| static void tui_v_show_registers_command_support (enum tui_register_display_type); |
| static void _tui_toggle_float_regs_command (char *, int); |
| static void tui_scroll_regs_forward_command (char *, int); |
| static void tui_scroll_regs_backward_command (char *, int); |
| |
| |
| |
| /***************************************** |
| ** PUBLIC FUNCTIONS ** |
| ******************************************/ |
| |
| /* Answer the number of the last line in the regs display. If there |
| are no registers (-1) is returned. */ |
| int |
| tui_last_regs_line_no (void) |
| { |
| int num_lines = (-1); |
| |
| if (TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0) |
| { |
| 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 num_lines; |
| } |
| |
| |
| /* 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 element_no) |
| { |
| if (element_no < TUI_DATA_WIN->detail.data_display_info.regs_content_count) |
| { |
| int i, line = (-1); |
| |
| i = 1; |
| while (line == (-1)) |
| { |
| if (element_no < |
| (TUI_DATA_WIN->detail.data_display_info.regs_column_count * i)) |
| line = i - 1; |
| else |
| i++; |
| } |
| |
| return line; |
| } |
| else |
| return (-1); |
| } |
| |
| |
| /* 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 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) - |
| TUI_DATA_WIN->detail.data_display_info.regs_column_count; |
| else |
| return (-1); |
| } |
| |
| |
| /* 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); |
| } |
| |
| |
| /* Calculate the number of columns that should be used to display the |
| registers. */ |
| int |
| tui_calculate_regs_column_count (enum tui_register_display_type dpy_type) |
| { |
| int col_count, col_width; |
| |
| if (IS_64BIT || dpy_type == TUI_DFLOAT_REGS) |
| col_width = DOUBLE_FLOAT_VALUE_WIDTH + DOUBLE_FLOAT_LABEL_WIDTH; |
| else |
| { |
| if (dpy_type == TUI_SFLOAT_REGS) |
| col_width = SINGLE_FLOAT_VALUE_WIDTH + SINGLE_FLOAT_LABEL_WIDTH; |
| else |
| col_width = SINGLE_VALUE_WIDTH + SINGLE_LABEL_WIDTH; |
| } |
| col_count = (TUI_DATA_WIN->generic.width - 2) / col_width; |
| |
| return col_count; |
| } |
| |
| |
| /* Show the registers int the data window as indicated by dpy_type. If |
| there is any other registers being displayed, then they are |
| cleared. What registers are displayed is dependent upon dpy_type. */ |
| void |
| tui_show_registers (enum tui_register_display_type dpy_type) |
| { |
| enum tui_status ret = TUI_FAILURE; |
| int refresh_values_only = FALSE; |
| |
| /* Say that registers should be displayed, even if there is a problem */ |
| TUI_DATA_WIN->detail.data_display_info.display_regs = TRUE; |
| |
| if (target_has_registers) |
| { |
| refresh_values_only = |
| (dpy_type == TUI_DATA_WIN->detail.data_display_info.regs_display_type); |
| switch (dpy_type) |
| { |
| case TUI_GENERAL_REGS: |
| ret = tui_set_general_regs_content (refresh_values_only); |
| break; |
| case TUI_SFLOAT_REGS: |
| case TUI_DFLOAT_REGS: |
| ret = tui_set_float_regs_content (dpy_type, refresh_values_only); |
| break; |
| |
| /* could ifdef out */ |
| |
| case TUI_SPECIAL_REGS: |
| ret = tui_set_special_regs_content (refresh_values_only); |
| break; |
| case TUI_GENERAL_AND_SPECIAL_REGS: |
| ret = tui_set_general_and_special_regs_content (refresh_values_only); |
| break; |
| |
| /* end of potential if def */ |
| |
| default: |
| break; |
| } |
| } |
| if (ret == TUI_FAILURE) |
| { |
| TUI_DATA_WIN->detail.data_display_info.regs_display_type = TUI_UNDEFINED_REGS; |
| tui_erase_data_content (NO_REGS_STRING); |
| } |
| else |
| { |
| int i; |
| |
| /* Clear all notation of changed values */ |
| for (i = 0; (i < TUI_DATA_WIN->detail.data_display_info.regs_content_count); i++) |
| { |
| struct tui_gen_win_info * data_item_win; |
| |
| data_item_win = &TUI_DATA_WIN->detail.data_display_info. |
| regs_content[i]->which_element.data_window; |
| (&((struct tui_win_element *) |
| data_item_win->content[0])->which_element.data)->highlight = FALSE; |
| } |
| TUI_DATA_WIN->detail.data_display_info.regs_display_type = dpy_type; |
| tui_display_all_data (); |
| } |
| (tui_layout_def ())->regs_display_type = dpy_type; |
| |
| return; |
| } |
| |
| |
| /* 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) |
| { |
| 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 i = start_element_no; |
| int j, value_chars_wide, item_win_width, cur_y, label_width; |
| enum precision_type precision; |
| |
| precision = (TUI_DATA_WIN->detail.data_display_info.regs_display_type |
| == TUI_DFLOAT_REGS) ? |
| double_precision : unspecified_precision; |
| if (IS_64BIT || |
| TUI_DATA_WIN->detail.data_display_info.regs_display_type == TUI_DFLOAT_REGS) |
| { |
| value_chars_wide = DOUBLE_FLOAT_VALUE_WIDTH; |
| label_width = DOUBLE_FLOAT_LABEL_WIDTH; |
| } |
| else |
| { |
| if (TUI_DATA_WIN->detail.data_display_info.regs_display_type == |
| TUI_SFLOAT_REGS) |
| { |
| value_chars_wide = SINGLE_FLOAT_VALUE_WIDTH; |
| label_width = SINGLE_FLOAT_LABEL_WIDTH; |
| } |
| else |
| { |
| value_chars_wide = SINGLE_VALUE_WIDTH; |
| label_width = SINGLE_LABEL_WIDTH; |
| } |
| } |
| item_win_width = value_chars_wide + label_width; |
| /* |
| ** Now create each data "sub" window, and write the display into it. |
| */ |
| cur_y = 1; |
| while (i < TUI_DATA_WIN->detail.data_display_info.regs_content_count && |
| cur_y <= TUI_DATA_WIN->generic.viewport_height) |
| { |
| for (j = 0; |
| (j < TUI_DATA_WIN->detail.data_display_info.regs_column_count && |
| i < TUI_DATA_WIN->detail.data_display_info.regs_content_count); j++) |
| { |
| struct tui_gen_win_info * data_item_win; |
| struct tui_data_element * data_element_ptr; |
| |
| /* create the window if necessary */ |
| data_item_win = &TUI_DATA_WIN->detail.data_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 = (precision == double_precision) ? |
| item_win_width + 2 : item_win_width + 1; |
| 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 (data_item_win->handle); |
| |
| /* |
| ** Get the printable representation of the register |
| ** and display it |
| */ |
| tui_display_register ( |
| data_element_ptr->item_no, data_item_win, precision); |
| i++; /* next register */ |
| } |
| cur_y++; /* next row; */ |
| } |
| } |
| |
| return; |
| } |
| |
| |
| /* 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 |
| 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 && |
| TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0) |
| { |
| int element_no = start_element_no; |
| |
| if (start_element_no != 0 && start_line_no != 0) |
| { |
| 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 (element_no); |
| } |
| } |
| |
| |
| |
| /* 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 line_no, int force_display) |
| { |
| if (TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0) |
| { |
| int line, element_no; |
| |
| if (line_no < 0) |
| line = 0; |
| 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 ( |
| TUI_DATA_WIN->detail.data_display_info.regs_content_count - 1)) < 0) |
| line = 0; |
| } |
| else |
| line = line_no; |
| } |
| else |
| 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) |
| tui_display_reg_element_at_line (element_no, line); |
| else |
| line = (-1); |
| |
| return line; |
| } |
| |
| return (-1); /* nothing was displayed */ |
| } |
| |
| |
| /* 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 |
| tui_check_register_values (struct frame_info *frame) |
| { |
| if (TUI_DATA_WIN != NULL && TUI_DATA_WIN->generic.is_visible) |
| { |
| if (TUI_DATA_WIN->detail.data_display_info.regs_content_count <= 0 && |
| TUI_DATA_WIN->detail.data_display_info.display_regs) |
| tui_show_registers ((tui_layout_def ())->regs_display_type); |
| else |
| { |
| int i, j; |
| char raw_buf[MAX_REGISTER_SIZE]; |
| |
| for (i = 0; |
| (i < TUI_DATA_WIN->detail.data_display_info.regs_content_count); i++) |
| { |
| struct tui_data_element * data_element_ptr; |
| struct tui_gen_win_info * data_item_win_ptr; |
| int was_hilighted; |
| |
| data_item_win_ptr = &TUI_DATA_WIN->detail.data_display_info. |
| regs_content[i]->which_element.data_window; |
| data_element_ptr = &((struct tui_win_element *) |
| data_item_win_ptr->content[0])->which_element.data; |
| was_hilighted = data_element_ptr->highlight; |
| data_element_ptr->highlight = |
| tui_reg_value_has_changed (data_element_ptr, frame, &raw_buf[0]); |
| if (data_element_ptr->highlight) |
| { |
| int size; |
| |
| size = DEPRECATED_REGISTER_RAW_SIZE (data_element_ptr->item_no); |
| for (j = 0; j < size; j++) |
| ((char *) data_element_ptr->value)[j] = raw_buf[j]; |
| tui_display_register ( |
| data_element_ptr->item_no, |
| data_item_win_ptr, |
| ((TUI_DATA_WIN->detail.data_display_info.regs_display_type == |
| TUI_DFLOAT_REGS) ? |
| double_precision : unspecified_precision)); |
| } |
| else if (was_hilighted) |
| { |
| data_element_ptr->highlight = FALSE; |
| tui_display_register ( |
| data_element_ptr->item_no, |
| data_item_win_ptr, |
| ((TUI_DATA_WIN->detail.data_display_info.regs_display_type == |
| TUI_DFLOAT_REGS) ? |
| double_precision : unspecified_precision)); |
| } |
| } |
| } |
| } |
| return; |
| } |
| |
| |
| /* |
| ** tui_toggle_float_regs(). |
| */ |
| void |
| tui_toggle_float_regs (void) |
| { |
| struct tui_layout_def * layout_def = tui_layout_def (); |
| |
| if (layout_def->float_regs_display_type == TUI_SFLOAT_REGS) |
| layout_def->float_regs_display_type = TUI_DFLOAT_REGS; |
| else |
| layout_def->float_regs_display_type = TUI_SFLOAT_REGS; |
| |
| if (TUI_DATA_WIN != NULL && TUI_DATA_WIN->generic.is_visible && |
| (TUI_DATA_WIN->detail.data_display_info.regs_display_type == TUI_SFLOAT_REGS || |
| TUI_DATA_WIN->detail.data_display_info.regs_display_type == TUI_DFLOAT_REGS)) |
| tui_show_registers (layout_def->float_regs_display_type); |
| |
| return; |
| } /* tui_toggle_float_regs */ |
| |
| |
| void |
| _initialize_tui_regs (void) |
| { |
| if (xdb_commands) |
| { |
| add_com ("fr", class_tui, tui_show_float_command, |
| "Display only floating point registers\n"); |
| add_com ("gr", class_tui, tui_show_general_command, |
| "Display only general registers\n"); |
| add_com ("sr", class_tui, tui_show_special_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"); |
| add_com ("tf", class_tui, _tui_toggle_float_regs_command, |
| "Toggle between single and double precision floating point registers.\n"); |
| add_cmd (TUI_FLOAT_REGS_NAME_LOWER, |
| class_tui, |
| _tui_toggle_float_regs_command, |
| "Toggle between single and double precision floating point \ |
| registers.\n", |
| &togglelist); |
| } |
| } |
| |
| |
| /***************************************** |
| ** STATIC LOCAL FUNCTIONS ** |
| ******************************************/ |
| |
| |
| /* |
| ** tui_register_name(). |
| ** Return the register name. |
| */ |
| static const char * |
| tui_register_name (int reg_num) |
| { |
| return REGISTER_NAME (reg_num); |
| } |
| extern int pagination_enabled; |
| |
| static void |
| tui_restore_gdbout (void *ui) |
| { |
| ui_file_delete (gdb_stdout); |
| gdb_stdout = (struct ui_file*) ui; |
| pagination_enabled = 1; |
| } |
| |
| /* |
| ** tui_register_format |
| ** Function to format the register name and value into a buffer, |
| ** suitable for printing or display |
| */ |
| static void |
| tui_register_format (char *buf, int buf_len, int reg_num, |
| struct tui_data_element * data_element, |
| enum precision_type precision) |
| { |
| struct ui_file *stream; |
| struct ui_file *old_stdout; |
| const char *name; |
| struct cleanup *cleanups; |
| char *p; |
| int pos; |
| |
| name = REGISTER_NAME (reg_num); |
| if (name == 0) |
| { |
| strcpy (buf, ""); |
| return; |
| } |
| |
| pagination_enabled = 0; |
| old_stdout = gdb_stdout; |
| stream = tui_sfileopen (buf_len); |
| gdb_stdout = stream; |
| cleanups = make_cleanup (tui_restore_gdbout, (void*) old_stdout); |
| gdbarch_print_registers_info (current_gdbarch, stream, deprecated_selected_frame, |
| reg_num, 1); |
| |
| /* Save formatted output in the buffer. */ |
| p = tui_file_get_strbuf (stream); |
| pos = 0; |
| while (*p && *p == *name++ && buf_len) |
| { |
| *buf++ = *p++; |
| buf_len--; |
| pos++; |
| } |
| while (*p == ' ') |
| p++; |
| while (pos < 8 && buf_len) |
| { |
| *buf++ = ' '; |
| buf_len--; |
| pos++; |
| } |
| strncpy (buf, p, buf_len); |
| |
| /* Remove the possible \n. */ |
| p = strchr (buf, '\n'); |
| if (p) |
| *p = 0; |
| |
| do_cleanups (cleanups); |
| } |
| |
| |
| #define NUM_GENERAL_REGS 32 |
| /* Set the content of the data window to consist of the general |
| registers. */ |
| static enum tui_status |
| tui_set_general_regs_content (int refresh_values_only) |
| { |
| return (tui_set_regs_content (0, |
| NUM_GENERAL_REGS - 1, |
| deprecated_selected_frame, |
| TUI_GENERAL_REGS, |
| refresh_values_only)); |
| |
| } |
| |
| |
| #ifndef PCOQ_HEAD_REGNUM |
| #define START_SPECIAL_REGS 0 |
| #else |
| #define START_SPECIAL_REGS PCOQ_HEAD_REGNUM |
| #endif |
| |
| /* Set the content of the data window to consist of the special |
| registers. */ |
| static enum tui_status |
| tui_set_special_regs_content (int refresh_values_only) |
| { |
| enum tui_status ret = TUI_FAILURE; |
| int end_reg_num; |
| |
| end_reg_num = FP0_REGNUM - 1; |
| ret = tui_set_regs_content (START_SPECIAL_REGS, |
| end_reg_num, |
| deprecated_selected_frame, |
| TUI_SPECIAL_REGS, |
| refresh_values_only); |
| |
| return ret; |
| } |
| |
| |
| /* Set the content of the data window to consist of the special |
| registers. */ |
| static enum tui_status |
| tui_set_general_and_special_regs_content (int refresh_values_only) |
| { |
| enum tui_status ret = TUI_FAILURE; |
| int end_reg_num = (-1); |
| |
| end_reg_num = FP0_REGNUM - 1; |
| ret = tui_set_regs_content ( |
| 0, end_reg_num, deprecated_selected_frame, TUI_SPECIAL_REGS, refresh_values_only); |
| |
| return ret; |
| } |
| |
| /* Set the content of the data window to consist of the float |
| registers. */ |
| static enum tui_status |
| tui_set_float_regs_content (enum tui_register_display_type dpy_type, |
| int refresh_values_only) |
| { |
| enum tui_status ret = TUI_FAILURE; |
| int start_reg_num; |
| |
| start_reg_num = FP0_REGNUM; |
| ret = tui_set_regs_content (start_reg_num, |
| NUM_REGS - 1, |
| deprecated_selected_frame, |
| dpy_type, |
| refresh_values_only); |
| |
| return ret; |
| } |
| |
| |
| /* Answer TRUE if the register's value has changed, FALSE otherwise. |
| If TRUE, new_value is filled in with the new value. */ |
| static int |
| tui_reg_value_has_changed (struct tui_data_element * data_element, |
| struct frame_info *frame, char *new_value) |
| { |
| int has_changed = FALSE; |
| |
| if (data_element->item_no != UNDEFINED_ITEM && |
| tui_register_name (data_element->item_no) != (char *) NULL) |
| { |
| char raw_buf[MAX_REGISTER_SIZE]; |
| int i; |
| |
| if (tui_get_register_raw_value (data_element->item_no, raw_buf, frame) == TUI_SUCCESS) |
| { |
| int size = DEPRECATED_REGISTER_RAW_SIZE (data_element->item_no); |
| |
| for (i = 0; (i < size && !has_changed); i++) |
| has_changed = (((char *) data_element->value)[i] != raw_buf[i]); |
| if (has_changed && new_value != (char *) NULL) |
| { |
| for (i = 0; i < size; i++) |
| new_value[i] = raw_buf[i]; |
| } |
| } |
| } |
| return has_changed; |
| } |
| |
| |
| |
| /* Get the register raw value. The raw value is returned in reg_value. */ |
| static enum tui_status |
| tui_get_register_raw_value (int reg_num, char *reg_value, struct frame_info *frame) |
| { |
| enum tui_status ret = TUI_FAILURE; |
| |
| if (target_has_registers) |
| { |
| get_frame_register (frame, reg_num, reg_value); |
| /* 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 (reg_num) >= 0) |
| ret = TUI_SUCCESS; |
| } |
| return ret; |
| } |
| |
| |
| |
| /* Function to initialize a data element with the input and the |
| register value. */ |
| static void |
| tui_set_register_element (int reg_num, struct frame_info *frame, |
| struct tui_data_element * data_element, |
| int refresh_value_only) |
| { |
| if (data_element != (struct tui_data_element *) NULL) |
| { |
| if (!refresh_value_only) |
| { |
| data_element->item_no = reg_num; |
| data_element->name = tui_register_name (reg_num); |
| data_element->highlight = FALSE; |
| } |
| if (data_element->value == NULL) |
| data_element->value = xmalloc (MAX_REGISTER_SIZE); |
| if (data_element->value != NULL) |
| tui_get_register_raw_value (reg_num, data_element->value, frame); |
| } |
| } |
| |
| |
| /* Set the content of the data window to consist of the registers |
| numbered from start_reg_num to end_reg_num. Note that if |
| refresh_values_only is TRUE, start_reg_num and end_reg_num are |
| ignored. */ |
| static enum tui_status |
| tui_set_regs_content (int start_reg_num, int end_reg_num, |
| struct frame_info *frame, |
| enum tui_register_display_type dpy_type, |
| int refresh_values_only) |
| { |
| enum tui_status ret = TUI_FAILURE; |
| int num_regs = end_reg_num - start_reg_num + 1; |
| int allocated_here = FALSE; |
| |
| if (TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0 && |
| !refresh_values_only) |
| { |
| tui_free_data_content (TUI_DATA_WIN->detail.data_display_info.regs_content, |
| TUI_DATA_WIN->detail.data_display_info.regs_content_count); |
| TUI_DATA_WIN->detail.data_display_info.regs_content_count = 0; |
| } |
| if (TUI_DATA_WIN->detail.data_display_info.regs_content_count <= 0) |
| { |
| TUI_DATA_WIN->detail.data_display_info.regs_content = |
| tui_alloc_content (num_regs, DATA_WIN); |
| allocated_here = TRUE; |
| } |
| |
| if (TUI_DATA_WIN->detail.data_display_info.regs_content != (tui_win_content) NULL) |
| { |
| int i; |
| |
| if (!refresh_values_only || allocated_here) |
| { |
| TUI_DATA_WIN->generic.content = NULL; |
| TUI_DATA_WIN->generic.content_size = 0; |
| tui_add_content_elements (&TUI_DATA_WIN->generic, num_regs); |
| TUI_DATA_WIN->detail.data_display_info.regs_content = |
| (tui_win_content) TUI_DATA_WIN->generic.content; |
| TUI_DATA_WIN->detail.data_display_info.regs_content_count = num_regs; |
| } |
| /* |
| ** Now set the register names and values |
| */ |
| for (i = start_reg_num; (i <= end_reg_num); i++) |
| { |
| struct tui_gen_win_info * data_item_win; |
| |
| data_item_win = &TUI_DATA_WIN->detail.data_display_info. |
| regs_content[i - start_reg_num]->which_element.data_window; |
| tui_set_register_element ( |
| i, |
| frame, |
| &((struct tui_win_element *) data_item_win->content[0])->which_element.data, |
| !allocated_here && refresh_values_only); |
| } |
| TUI_DATA_WIN->detail.data_display_info.regs_column_count = |
| tui_calculate_regs_column_count (dpy_type); |
| #ifdef LATER |
| if (TUI_DATA_WIN->detail.data_display_info.data_content_count > 0) |
| { |
| /* delete all the windows? */ |
| /* realloc content equal to data_content_count + regs_content_count */ |
| /* append TUI_DATA_WIN->detail.data_display_info.data_content to content */ |
| } |
| #endif |
| TUI_DATA_WIN->generic.content_size = |
| TUI_DATA_WIN->detail.data_display_info.regs_content_count + |
| TUI_DATA_WIN->detail.data_display_info.data_content_count; |
| ret = TUI_SUCCESS; |
| } |
| |
| return ret; |
| } |
| |
| |
| /* Function to display a register in a window. If hilite is TRUE, |
| than the value will be displayed in reverse video. */ |
| static void |
| tui_display_register (int reg_num, |
| struct tui_gen_win_info * win_info, /* the data item window */ |
| enum precision_type precision) |
| { |
| if (win_info->handle != (WINDOW *) NULL) |
| { |
| int i; |
| char buf[40]; |
| int value_chars_wide, label_width; |
| struct tui_data_element * data_element_ptr = &((tui_win_content) |
| win_info->content)[0]->which_element.data; |
| |
| if (IS_64BIT || |
| TUI_DATA_WIN->detail.data_display_info.regs_display_type == TUI_DFLOAT_REGS) |
| { |
| value_chars_wide = DOUBLE_FLOAT_VALUE_WIDTH; |
| label_width = DOUBLE_FLOAT_LABEL_WIDTH; |
| } |
| else |
| { |
| if (TUI_DATA_WIN->detail.data_display_info.regs_display_type == |
| TUI_SFLOAT_REGS) |
| { |
| value_chars_wide = SINGLE_FLOAT_VALUE_WIDTH; |
| label_width = SINGLE_FLOAT_LABEL_WIDTH; |
| } |
| else |
| { |
| value_chars_wide = SINGLE_VALUE_WIDTH; |
| label_width = SINGLE_LABEL_WIDTH; |
| } |
| } |
| |
| buf[0] = (char) 0; |
| tui_register_format (buf, |
| value_chars_wide + label_width, |
| reg_num, |
| data_element_ptr, |
| precision); |
| |
| if (data_element_ptr->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); |
| waddstr (win_info->handle, buf); |
| |
| if (data_element_ptr->highlight) |
| wstandend (win_info->handle); |
| tui_refresh_win (win_info); |
| } |
| } |
| |
| |
| static void |
| tui_v_show_registers_command_support (enum tui_register_display_type dpy_type) |
| { |
| |
| if (TUI_DATA_WIN != NULL && TUI_DATA_WIN->generic.is_visible) |
| { /* Data window already displayed, show the registers */ |
| if (TUI_DATA_WIN->detail.data_display_info.regs_display_type != dpy_type) |
| tui_show_registers (dpy_type); |
| } |
| else |
| (tui_layout_def ())->regs_display_type = dpy_type; |
| |
| return; |
| } |
| |
| |
| static void |
| tui_show_float_command (char *arg, int from_tty) |
| { |
| if (TUI_DATA_WIN == NULL || !TUI_DATA_WIN->generic.is_visible || |
| (TUI_DATA_WIN->detail.data_display_info.regs_display_type != TUI_SFLOAT_REGS && |
| TUI_DATA_WIN->detail.data_display_info.regs_display_type != TUI_DFLOAT_REGS)) |
| tui_v_show_registers_command_support ((tui_layout_def ())->float_regs_display_type); |
| } |
| |
| |
| static void |
| tui_show_general_command (char *arg, int from_tty) |
| { |
| tui_v_show_registers_command_support (TUI_GENERAL_REGS); |
| } |
| |
| |
| static void |
| tui_show_special_command (char *arg, int from_tty) |
| { |
| tui_v_show_registers_command_support (TUI_SPECIAL_REGS); |
| } |
| |
| |
| static void |
| _tui_toggle_float_regs_command (char *arg, int from_tty) |
| { |
| if (TUI_DATA_WIN != NULL && TUI_DATA_WIN->generic.is_visible) |
| tui_toggle_float_regs (); |
| else |
| { |
| struct tui_layout_def * layout_def = tui_layout_def (); |
| |
| if (layout_def->float_regs_display_type == TUI_SFLOAT_REGS) |
| layout_def->float_regs_display_type = TUI_DFLOAT_REGS; |
| else |
| layout_def->float_regs_display_type = TUI_SFLOAT_REGS; |
| } |
| } |
| |
| |
| 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); |
| } |