* tui/tui-disasm.c: %s/lines/asm_lines/g to avoid a collision

[thirdparty/binutils-gdb.git] / gdb / tui / tui-regs.c

/* 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;
      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;
      /*
         ** 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;
      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)
{
  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);
}