This is the mail archive of the gdb-patches@sources.redhat.com mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[RFC]: Fix TUI register display


Hi!

Below is the TUI patch I would like to commit to fix the register display
(the TUI register fix I was speaking about some months ago).

- the TUI uses the gdb register groups to know which register to
  display.  This solves the HP specific code for floating point regs
  and special regs (which was broken).  This gives more functionalities
  to us as the register groups are target specific.

- new gdb TUI commands:

    tui reg general
    tui reg float
    tui reg system
    tui reg next

(don't worry, I'll update the doc and send a separate doc patch soon)

- all deprecated_* are removed

I've tested this patch on mainline on the following platforms:

  --target=m6811-elf
  --target=sparc-unknown-netbsdelf1.6.1
  --target=i686-linux

I'll commit this in a week (in main and 6_1 branch too).

Stephane

2004-03-05 Stephane Carrez <stcarrez@nerim.fr>

	* tui/tui-win.h (tui_get_cmd_list): Declare.
	* tui/tui-win.c (tui_command): New function.
	(tui_get_cmd_list): New function.
	(_initialize_tui_win): Moved initialization of tui command in
	tui_get_cmd_list.

	* tui/tui-data.c (init_content_element): Setup new data members.
	(init_win_info): Likewise.
	(free_content_elements): Free it.
	* tui/tui-data.h (struct tui_data_element): Store the register
	content to print.
	(struct tui_data_info): Keep the current register group.

* tui/tui-layout.c (tui_set_layout): Update call to tui_show_registers.

	* tui/tui-regs.h (tui_show_registers): Update prototype.
	(tui_toggle_float_regs, tui_calculate_regs_column_count): Remove.
	(tui_resize_all): No need to calculate anything for register window.
	* tui/tui-regs.c (tui_calculate_regs_column_count): Remove.
	(tui_set_register_element, tui_set_general_regs_content): Remove.
	(tui_set_special_regs_content): Remove.
	(tui_set_general_and_special_regs_content): Remove.
	(tui_set_float_regs_content): Remove.
	(tui_reg_value_has_changed, tui_get_register_raw_value): Remove.
	(tui_set_regs_content): Remove.
	(tui_toggle_float_regs, _tui_toggle_float_regs_command): Remove.
	(tui_v_show_registers_command_support): Remove.
	(tui_show_registers): Use a reggroup to specify the registers to show.
	(tui_show_register_group): New function.
	(tui_display_registers_from): Compute the layout of register window
	and refresh with new API; be sure to delete old register windows.
	(tui_check_register_values): Update to use tui_get_register and
	tui_display_data.
	(tui_display_register): Just refresh the register window part.
	(tui_register_format): Format registers and save in tui_data_element.
	(tui_get_register): New to combine tui_reg_value_has_changed and
	tui_get_register_raw_value; fix to use the new gdb API.
	(tui_show_float_command): Renamed tui_reg_float_command.
	(tui_show_general_command): Renamed tui_reg_general_command.
	(tui_show_special_command): Renamed tui_reg_system_command.
	(_initialize_tui_regs): Remove unused commands.

Index: tui/tui-data.c
===================================================================
RCS file: /cvs/src/src/gdb/tui/tui-data.c,v
retrieving revision 1.8
diff -u -p -r1.8 tui-data.c
--- tui/tui-data.c	10 Feb 2004 19:08:15 -0000	1.8
+++ tui/tui-data.c	5 Mar 2004 22:05:39 -0000
@@ -507,6 +507,7 @@ init_content_element (struct tui_win_ele
       element->which_element.data.item_no = UNDEFINED_ITEM;
       element->which_element.data.value = NULL;
       element->which_element.data.highlight = FALSE;
+      element->which_element.data.content = (char*) NULL;
       break;
     case LOCATOR_WIN:
       element->which_element.locator.file_name[0] =
@@ -548,6 +549,7 @@ init_win_info (struct tui_win_info * win
 	TUI_UNDEFINED_REGS;
       win_info->detail.data_display_info.regs_column_count = 1;
       win_info->detail.data_display_info.display_regs = FALSE;
+      win_info->detail.data_display_info.current_group = 0;
       break;
     case CMD_WIN:
       win_info->detail.command_info.cur_line = 0;
@@ -904,6 +906,7 @@ free_content_elements (tui_win_content c
 		      if (element->which_element.data.type != TUI_REGISTER)
 			xfree ((void *)element->which_element.data.name);
 		      xfree (element->which_element.data.value);
+                      xfree (element->which_element.data.content);
 		      xfree (element);
 		      break;
 		    case CMD_WIN:
Index: tui/tui-data.h
===================================================================
RCS file: /cvs/src/src/gdb/tui/tui-data.h,v
retrieving revision 1.11
diff -u -p -r1.11 tui-data.h
--- tui/tui-data.h	10 Feb 2004 19:08:15 -0000	1.11
+++ tui/tui-data.h	5 Mar 2004 22:05:39 -0000
@@ -180,6 +180,7 @@ struct tui_data_element
   enum tui_data_type type;
   void *value;
   int highlight;
+  char *content;
 };
 
 
@@ -248,6 +249,7 @@ struct tui_data_info
   enum tui_register_display_type regs_display_type;
   int regs_column_count;
   int display_regs;		/* Should regs be displayed at all? */
+  struct reggroup *current_group;
 };
 
 
Index: tui/tui-layout.c
===================================================================
RCS file: /cvs/src/src/gdb/tui/tui-layout.c,v
retrieving revision 1.17
diff -u -p -r1.17 tui-layout.c
--- tui/tui-layout.c	16 Feb 2004 21:05:09 -0000	1.17
+++ tui/tui-layout.c	5 Mar 2004 22:05:40 -0000
@@ -248,10 +248,7 @@ tui_set_layout (enum tui_layout_type lay
 	    }
 	  if (regs_populate)
 	    {
-	      layout_def->regs_display_type =
-		(regs_display_type == TUI_UNDEFINED_REGS ?
-		 TUI_GENERAL_REGS : regs_display_type);
-	      tui_show_registers (layout_def->regs_display_type);
+              tui_show_registers (TUI_DATA_WIN->detail.data_display_info.current_group);
 	    }
 	}
     }
Index: tui/tui-regs.c
===================================================================
RCS file: /cvs/src/src/gdb/tui/tui-regs.c,v
retrieving revision 1.12
diff -u -p -r1.12 tui-regs.c
--- tui/tui-regs.c	25 Feb 2004 01:10:01 -0000	1.12
+++ tui/tui-regs.c	5 Mar 2004 22:05:40 -0000
@@ -38,59 +38,27 @@
 #include "tui/tui-windata.h"
 #include "tui/tui-wingeneral.h"
 #include "tui/tui-file.h"
+#include "reggroups.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 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 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 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
-  (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);
+  (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);
 
@@ -174,73 +142,29 @@ tui_last_reg_element_no_in_line (int lin
     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.  */
+/* Show the registers of the given group in the data window
+   and refresh the window.  */
 void
-tui_show_registers (enum tui_register_display_type dpy_type)
+tui_show_registers (struct reggroup *group)
 {
   enum tui_status ret = TUI_FAILURE;
-  int refresh_values_only = FALSE;
+  struct tui_data_info *display_info = &TUI_DATA_WIN->detail.data_display_info;
 
-  /* Say that registers should be displayed, even if there is a problem */
-  TUI_DATA_WIN->detail.data_display_info.display_regs = TRUE;
+  if (group == 0)
+    group = general_reggroup;
 
-  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;
+  /* Say that registers should be displayed, even if there is a problem.  */
+  display_info->display_regs = TRUE;
 
-/* end of potential if def */
-
-	default:
-	  break;
-	}
+  if (target_has_registers && target_has_stack && target_has_memory)
+    {
+      ret = tui_show_register_group (current_gdbarch, group,
+                                     get_current_frame (),
+                                     group == display_info->current_group);
     }
   if (ret == TUI_FAILURE)
     {
-      TUI_DATA_WIN->detail.data_display_info.regs_display_type = TUI_UNDEFINED_REGS;
+      display_info->current_group = 0;
       tui_erase_data_content (NO_REGS_STRING);
     }
   else
@@ -248,24 +172,122 @@ tui_show_registers (enum tui_register_di
       int i;
 
       /* Clear all notation of changed values */
-      for (i = 0; (i < TUI_DATA_WIN->detail.data_display_info.regs_content_count); i++)
+      for (i = 0; i < display_info->regs_content_count; i++)
 	{
-	  struct tui_gen_win_info * data_item_win;
+	  struct tui_gen_win_info *data_item_win;
+          struct tui_win_element *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;
+	  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;
 	}
-      TUI_DATA_WIN->detail.data_display_info.regs_display_type = dpy_type;
+      display_info->current_group = group;
       tui_display_all_data ();
     }
-  (tui_layout_def ())->regs_display_type = dpy_type;
-
-  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 < NUM_REGS + NUM_PSEUDO_REGS; 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 < NUM_REGS + NUM_PSEUDO_REGS; 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
    '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
@@ -273,67 +295,82 @@ tui_show_registers (enum tui_register_di
 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)
+  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;
-      enum precision_type precision;
 
-      /* Do not rename the following variable into "label_width".
-         Unfortunately, term.h on AiX systems defines a macro with
-         the same name, which causes a build failure if we use the
-         same name for this variable.  */
-      int tui_label_width;
-
-      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;
-	  tui_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;
-	      tui_label_width = SINGLE_FLOAT_LABEL_WIDTH;
-	    }
-	  else
-	    {
-	      value_chars_wide = SINGLE_VALUE_WIDTH;
-	      tui_label_width = SINGLE_LABEL_WIDTH;
-	    }
-	}
-      item_win_width = value_chars_wide + tui_label_width;
+      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 < TUI_DATA_WIN->detail.data_display_info.regs_content_count &&
+      while (i < 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++)
+	       (j < display_info->regs_column_count &&
+		i < 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_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)
 		{
 		  data_item_win->height = 1;
-		  data_item_win->width = (precision == double_precision) ?
-		    item_win_width + 2 : item_win_width + 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);
@@ -341,19 +378,14 @@ tui_display_registers_from (int start_el
 		}
               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);
+	      /* Get the printable representation of the register
+                 and display it.  */
+              tui_display_register (data_element_ptr, data_item_win);
 	      i++;		/* next register */
 	    }
 	  cur_y++;		/* next row; */
 	}
     }
-
-  return;
 }
 
 
@@ -442,104 +474,147 @@ tui_check_register_values (struct 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);
+      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 raw_buf[MAX_REGISTER_SIZE];
 
-	  for (i = 0;
-	       (i < TUI_DATA_WIN->detail.data_display_info.regs_content_count); i++)
+	  for (i = 0; (i < display_info->regs_content_count); i++)
 	    {
-	      struct tui_data_element * data_element_ptr;
-	      struct tui_gen_win_info * data_item_win_ptr;
+	      struct tui_data_element *data;
+	      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;
+	      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;
 
-                  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)
+              tui_get_register (current_gdbarch, frame, data,
+                                data->item_no, &data->highlight);
+
+	      if (data->highlight || 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));
+                  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;
+
+      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);
 
-/*
-   ** tui_toggle_float_regs().
- */
-void
-tui_toggle_float_regs (void)
+      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 * layout_def = tui_layout_def ();
+  if (TUI_DATA_WIN != 0)
+    {
+      struct reggroup *group
+        = TUI_DATA_WIN->detail.data_display_info.current_group;
 
-  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;
+      group = reggroup_next (current_gdbarch, group);
+      if (group == 0)
+        group = reggroup_next (current_gdbarch, 0);
+
+      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);
+}
 
-  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);
+static void
+tui_reg_system_command (char *arg, int from_tty)
+{
+  tui_show_registers (system_reggroup);
+}
 
-  return;
-}				/* tui_toggle_float_regs */
+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_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\n",
+           &tuireglist);
+  add_cmd ("general", class_tui, tui_reg_general_command,
+           "Display only general registers\n",
+           &tuireglist);
+  add_cmd ("system", class_tui, tui_reg_system_command,
+           "Display only system registers\n",
+           &tuireglist);
+  add_cmd ("next", class_tui, tui_reg_next_command,
+           "Display next register group\n",
+           &tuireglist);
+
   if (xdb_commands)
     {
-      add_com ("fr", class_tui, tui_show_float_command,
+      add_com ("fr", class_tui, tui_reg_float_command,
 	       "Display only floating point registers\n");
-      add_com ("gr", class_tui, tui_show_general_command,
+      add_com ("gr", class_tui, tui_reg_general_command,
 	       "Display only general registers\n");
-      add_com ("sr", class_tui, tui_show_special_command,
+      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");
-      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);
     }
 }
 
@@ -548,16 +623,6 @@ registers.\n",
 ** 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
@@ -568,413 +633,103 @@ tui_restore_gdbout (void *ui)
   pagination_enabled = 1;
 }
 
-/*
-   ** tui_register_format
-   **        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
-tui_register_format (char *buf, int buf_len, int reg_num,
-                    struct tui_data_element * data_element,
-                    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 = gdbarch_register_type (gdbarch, regnum);
 
-  name = REGISTER_NAME (reg_num);
+  name = gdbarch_register_name (gdbarch, regnum);
   if (name == 0)
     {
-      strcpy (buf, "");
       return;
     }
   
   pagination_enabled = 0;
   old_stdout = gdb_stdout;
-  stream = tui_sfileopen (buf_len);
+  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,
-                                reg_num, 1);
+  if (TYPE_VECTOR (type) != 0 && 0)
+    {
+      char buf[MAX_REGISTER_SIZE];
+      int len;
 
-  /* Save formatted output in the buffer.  */
-  p = tui_file_get_strbuf (stream);
-  pos = 0;
-  while (*p && *p == *name++ && buf_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);
+    }
+  else
     {
-      *buf++ = *p++;
-      buf_len--;
-      pos++;
-    }
-  while (*p == ' ')
-    p++;
-  while (pos < 8 && buf_len)
-    {
-      *buf++ = ' ';
-      buf_len--;
-      pos++;
+      gdbarch_print_registers_info (current_gdbarch, stream,
+                                    frame, regnum, 1);
     }
-  strncpy (buf, p, buf_len);
+
+  /* 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
-/* 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.  */
+/* 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_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)
+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, reg_num, reg_value);
+      char buf[MAX_REGISTER_SIZE];
+
+      get_frame_register (frame, regnum, buf);
       /* 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;
+      if (register_cached (regnum) >= 0)
+        {
+          if (changedp)
+            {
+              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];
+                  }
+            }
+
+          /* Reformat the data content if the value changed.  */
+          if (changedp == 0 || *changedp == TRUE)
+            tui_register_format (gdbarch, frame, data, regnum);
+          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;
-      struct tui_data_element * data_element_ptr = &((tui_win_content)
-				    win_info->content)[0]->which_element.data;
-
-      /* Do not rename the following variable into "label_width".
-         Unfortunately, term.h on AiX systems defines a macro with
-         the same name, which causes a build failure if we use the
-         same name for this variable.  */
-      int tui_label_width;
-
-      if (IS_64BIT ||
-	  TUI_DATA_WIN->detail.data_display_info.regs_display_type == TUI_DFLOAT_REGS)
-	{
-	  value_chars_wide = DOUBLE_FLOAT_VALUE_WIDTH;
-	  tui_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;
-	      tui_label_width = SINGLE_FLOAT_LABEL_WIDTH;
-	    }
-	  else
-	    {
-	      value_chars_wide = SINGLE_VALUE_WIDTH;
-	      tui_label_width = SINGLE_LABEL_WIDTH;
-	    }
-	}
-
-      buf[0] = (char) 0;
-      tui_register_format (buf,
-			  value_chars_wide + tui_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)
Index: tui/tui-regs.h
===================================================================
RCS file: /cvs/src/src/gdb/tui/tui-regs.h,v
retrieving revision 1.3
diff -u -p -r1.3 tui-regs.h
--- tui/tui-regs.h	7 Feb 2004 20:57:02 -0000	1.3
+++ tui/tui-regs.h	5 Mar 2004 22:05:40 -0000
@@ -28,14 +28,12 @@
 #include "tui/tui-data.h"	/* For struct tui_register_display_type.  */
 
 extern void tui_check_register_values (struct frame_info *);
-extern void tui_show_registers (enum tui_register_display_type);
+extern void tui_show_registers (struct reggroup *group);
 extern void tui_display_registers_from (int);
 extern int tui_display_registers_from_line (int, int);
 extern int tui_last_regs_line_no (void);
 extern int tui_first_reg_element_inline (int);
 extern int tui_line_from_reg_element_no (int);
-extern void tui_toggle_float_regs (void);
-extern int tui_calculate_regs_column_count (enum tui_register_display_type);
 extern int tui_first_reg_element_no_inline (int lineno);
 
 #endif
Index: tui/tui-win.c
===================================================================
RCS file: /cvs/src/src/gdb/tui/tui-win.c,v
retrieving revision 1.17
diff -u -p -r1.17 tui-win.c
--- tui/tui-win.c	28 Feb 2004 18:04:37 -0000	1.17
+++ tui/tui-win.c	5 Mar 2004 22:05:40 -0000
@@ -290,6 +290,26 @@ show_tui_cmd (char *args, int from_tty)
 {
 }
 
+static struct cmd_list_element *tuilist;
+
+static void
+tui_command (char *args, int from_tty)
+{
+  printf_unfiltered ("\"tui\" must be followed by the name of a "
+                     "tui command.\n");
+  help_list (tuilist, "tui ", -1, gdb_stdout);
+}
+
+struct cmd_list_element **
+tui_get_cmd_list ()
+{
+  if (tuilist == 0)
+    add_prefix_cmd ("tui", class_tui, tui_command,
+                    "Text User Interface commands.",
+                    &tuilist, "tui ", 0, &cmdlist);
+  return &tuilist;
+}
+
 /* Function to initialize gdb commands, for tui window manipulation.  */
 void
 _initialize_tui_win (void)
@@ -300,10 +320,6 @@ _initialize_tui_win (void)
 
   /* Define the classes of commands.
      They will appear in the help list in the reverse of this order.  */
-  add_cmd ("tui", class_tui, NULL,
-	   "Text User Interface commands.",
-	   &cmdlist);
-
   add_prefix_cmd ("tui", class_tui, set_tui_cmd,
                   "TUI configuration variables",
 		  &tui_setlist, "set tui ",
@@ -602,6 +618,9 @@ tui_resize_all (void)
       enum tui_win_type win_type;
       int new_height, split_diff, cmd_split_diff, num_wins_displayed = 2;
 
+#ifdef HAVE_RESIZE_TERM
+      resize_term (screenheight, screenwidth);
+#endif      
       /* turn keypad off while we resize */
       if (win_with_focus != TUI_CMD_WIN)
 	keypad (TUI_CMD_WIN->generic.handle, FALSE);
@@ -680,10 +699,6 @@ tui_resize_all (void)
 	    new_height = first_win->generic.height + split_diff;
 	  make_invisible_and_set_new_height (first_win, new_height);
 
-	  if (first_win == TUI_DATA_WIN && width_diff != 0)
-	    first_win->detail.data_display_info.regs_column_count =
-	      tui_calculate_regs_column_count (
-			  first_win->detail.data_display_info.regs_display_type);
 	  locator->width += width_diff;
 
 	  /* Change the second window's height/width */
Index: tui/tui-win.h
===================================================================
RCS file: /cvs/src/src/gdb/tui/tui-win.h,v
retrieving revision 1.2
diff -u -p -r1.2 tui-win.h
--- tui/tui-win.h	7 Feb 2004 01:02:54 -0000	1.2
+++ tui/tui-win.h	5 Mar 2004 22:05:40 -0000
@@ -53,4 +53,7 @@ extern int tui_update_variables (void);
 /* Update gdb's knowledge of the terminal size.  */
 extern void tui_update_gdb_sizes (void);
 
+/* Create or get the TUI command list.  */
+struct cmd_list_element **tui_get_cmd_list ();
+
 #endif

Attachment: pgp00000.pgp
Description: PGP signature


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]