Subversion Repositories or1k

/*

   ** tuiRegs.c

   **         This module contains functions to support display of registers

   **         in the data window.

 */

#include "defs.h"

#include "tui.h"

#include "tuiData.h"

#include "symtab.h"

#include "gdbtypes.h"

#include "gdbcmd.h"

#include "frame.h"

#include "inferior.h"

#include "target.h"

#include "tuiLayout.h"

#include "tuiWin.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    10

#define SINGLE_LABEL_FMT      "%10.10s: "

#define SINGLE_VALUE_WIDTH    14        /* 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 TuiStatus _tuiSetRegsContent

  (int, int, struct frame_info *, TuiRegisterDisplayType, int);

static char *_tuiRegisterName (int);

static TuiStatus _tuiGetRegisterRawValue (int, char *, struct frame_info *);

static void _tuiSetRegisterElement

  (int, struct frame_info *, TuiDataElementPtr, int);

static void _tuiDisplayRegister (int, TuiGenWinInfoPtr, enum precision_type);

static void _tuiRegisterFormat

  (char *, int, int, TuiDataElementPtr, enum precision_type);

static TuiStatus _tuiSetGeneralRegsContent (int);

static TuiStatus _tuiSetSpecialRegsContent (int);

static TuiStatus _tuiSetGeneralAndSpecialRegsContent (int);

static TuiStatus _tuiSetFloatRegsContent (TuiRegisterDisplayType, int);

static int _tuiRegValueHasChanged

  (TuiDataElementPtr, struct frame_info *, char *);

static void _tuiShowFloat_command (char *, int);

static void _tuiShowGeneral_command (char *, int);

static void _tuiShowSpecial_command (char *, int);

static void _tui_vShowRegisters_commandSupport (va_list);

static void _tuiToggleFloatRegs_command (char *, int);

static void _tuiScrollRegsForward_command (char *, int);

static void _tuiScrollRegsBackward_command (char *, int);

static void _tui_vShowRegisters_commandSupport (va_list);

/*****************************************

** PUBLIC FUNCTIONS                     **

******************************************/

/*

   ** tuiLastRegsLineNo()

   **        Answer the number of the last line in the regs display.

   **        If there are no registers (-1) is returned.

 */

int

#ifdef __STDC__

tuiLastRegsLineNo (void)

#else

tuiLastRegsLineNo ()

#endif

{

  register int numLines = (-1);

  if (dataWin->detail.dataDisplayInfo.regsContentCount > 0)

    {

      numLines = (dataWin->detail.dataDisplayInfo.regsContentCount /

                  dataWin->detail.dataDisplayInfo.regsColumnCount);

      if (dataWin->detail.dataDisplayInfo.regsContentCount %

          dataWin->detail.dataDisplayInfo.regsColumnCount)

        numLines++;

    }

  return numLines;

}                               /* tuiLastRegsLineNo */

/*

   ** tuiLineFromRegElementNo()

   **        Answer the line number that the register element at elementNo is

   **        on.  If elementNo is greater than the number of register elements

   **        there are, -1 is returned.

 */

int

#ifdef __STDC__

tuiLineFromRegElementNo (

                          int elementNo)

#else

tuiLineFromRegElementNo (elementNo)

     int elementNo;

#endif

{

  if (elementNo < dataWin->detail.dataDisplayInfo.regsContentCount)

    {

      int i, line = (-1);

      i = 1;

      while (line == (-1))

        {

          if (elementNo <

              (dataWin->detail.dataDisplayInfo.regsColumnCount * i))

            line = i - 1;

          else

            i++;

        }

      return line;

    }

  else

    return (-1);

}                               /* tuiLineFromRegElementNo */

/*

   ** tuiFirstRegElementNoInLine()

   **        Answer the index of the first element in lineNo.  If lineNo is

   **        past the register area (-1) is returned.

 */

int

#ifdef __STDC__

tuiFirstRegElementNoInLine (

                             int lineNo)

#else

tuiFirstRegElementNoInLine (lineNo)

     int lineNo;

#endif

{

  if ((lineNo * dataWin->detail.dataDisplayInfo.regsColumnCount)

      <= dataWin->detail.dataDisplayInfo.regsContentCount)

    return ((lineNo + 1) *

            dataWin->detail.dataDisplayInfo.regsColumnCount) -

      dataWin->detail.dataDisplayInfo.regsColumnCount;

  else

    return (-1);

}                               /* tuiFirstRegElementNoInLine */

/*

   ** tuiLastRegElementNoInLine()

   **        Answer the index of the last element in lineNo.  If lineNo is past

   **        the register area (-1) is returned.

 */

int

#ifdef __STDC__

tuiLastRegElementNoInLine (

                            int lineNo)

#else

tuiLastRegElementNoInLine (lineNo)

     int lineNo;

#endif

{

  if ((lineNo * dataWin->detail.dataDisplayInfo.regsColumnCount) <=

      dataWin->detail.dataDisplayInfo.regsContentCount)

    return ((lineNo + 1) *

            dataWin->detail.dataDisplayInfo.regsColumnCount) - 1;

  else

    return (-1);

}                               /* tuiLastRegElementNoInLine */

/*

   ** tuiCalculateRegsColumnCount

   **        Calculate the number of columns that should be used to display

   **        the registers.

 */

int

#ifdef __STDC__

tuiCalculateRegsColumnCount (

                              TuiRegisterDisplayType dpyType)

#else

tuiCalculateRegsColumnCount (dpyType)

     TuiRegisterDisplayType dpyType;

#endif

{

  int colCount, colWidth;

  if (IS_64BIT || dpyType == TUI_DFLOAT_REGS)

    colWidth = DOUBLE_FLOAT_VALUE_WIDTH + DOUBLE_FLOAT_LABEL_WIDTH;

  else

    {

      if (dpyType == TUI_SFLOAT_REGS)

        colWidth = SINGLE_FLOAT_VALUE_WIDTH + SINGLE_FLOAT_LABEL_WIDTH;

      else

        colWidth = SINGLE_VALUE_WIDTH + SINGLE_LABEL_WIDTH;

    }

  colCount = (dataWin->generic.width - 2) / colWidth;

  return colCount;

}                               /* tuiCalulateRegsColumnCount */

/*

   ** tuiShowRegisters().

   **        Show the registers int the data window as indicated by dpyType.

   **        If there is any other registers being displayed, then they are

   **        cleared.  What registers are displayed is dependent upon dpyType.

 */

void

#ifdef __STDC__

tuiShowRegisters (

                   TuiRegisterDisplayType dpyType)

#else

tuiShowRegisters (dpyType)

     TuiRegisterDisplayType dpyType;

#endif

{

  TuiStatus ret = TUI_FAILURE;

  int refreshValuesOnly = FALSE;

  /* Say that registers should be displayed, even if there is a problem */

  dataWin->detail.dataDisplayInfo.displayRegs = TRUE;

  if (target_has_registers)

    {

      refreshValuesOnly =

        (dpyType == dataWin->detail.dataDisplayInfo.regsDisplayType);

      switch (dpyType)

        {

        case TUI_GENERAL_REGS:

          ret = _tuiSetGeneralRegsContent (refreshValuesOnly);

          break;

        case TUI_SFLOAT_REGS:

        case TUI_DFLOAT_REGS:

          ret = _tuiSetFloatRegsContent (dpyType, refreshValuesOnly);

          break;

/* could ifdef out */

        case TUI_SPECIAL_REGS:

          ret = _tuiSetSpecialRegsContent (refreshValuesOnly);

          break;

        case TUI_GENERAL_AND_SPECIAL_REGS:

          ret = _tuiSetGeneralAndSpecialRegsContent (refreshValuesOnly);

          break;

/* end of potential if def */

        default:

          break;

        }

    }

  if (ret == TUI_FAILURE)

    {

      dataWin->detail.dataDisplayInfo.regsDisplayType = TUI_UNDEFINED_REGS;

      tuiEraseDataContent (NO_REGS_STRING);

    }

  else

    {

      int i;

      /* Clear all notation of changed values */

      for (i = 0; (i < dataWin->detail.dataDisplayInfo.regsContentCount); i++)

        {

          TuiGenWinInfoPtr dataItemWin;

          dataItemWin = &dataWin->detail.dataDisplayInfo.

            regsContent[i]->whichElement.dataWindow;

          (&((TuiWinElementPtr)

             dataItemWin->content[0])->whichElement.data)->highlight = FALSE;

        }

      dataWin->detail.dataDisplayInfo.regsDisplayType = dpyType;

      tuiDisplayAllData ();

    }

  (tuiLayoutDef ())->regsDisplayType = dpyType;

  return;

}                               /* tuiShowRegisters */

/*

   ** tuiDisplayRegistersFrom().

   **        Function to display the registers in the content from

   **        'startElementNo' until the end of the register content or the

   **        end of the display height.  No checking for displaying past

   **        the end of the registers is done here.

 */

void

#ifdef __STDC__

tuiDisplayRegistersFrom (

                          int startElementNo)

#else

tuiDisplayRegistersFrom (startElementNo)

     int startElementNo;

#endif

{

  if (dataWin->detail.dataDisplayInfo.regsContent != (TuiWinContent) NULL &&

      dataWin->detail.dataDisplayInfo.regsContentCount > 0)

    {

      register int i = startElementNo;

      int j, valueCharsWide, charsWide, itemWinWidth, curY, labelWidth;

      enum precision_type precision;

      precision = (dataWin->detail.dataDisplayInfo.regsDisplayType

                   == TUI_DFLOAT_REGS) ?

        double_precision : unspecified_precision;

      if (IS_64BIT ||

          dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_DFLOAT_REGS)

        {

          valueCharsWide = DOUBLE_FLOAT_VALUE_WIDTH;

          labelWidth = DOUBLE_FLOAT_LABEL_WIDTH;

        }

      else

        {

          if (dataWin->detail.dataDisplayInfo.regsDisplayType ==

              TUI_SFLOAT_REGS)

            {

              valueCharsWide = SINGLE_FLOAT_VALUE_WIDTH;

              labelWidth = SINGLE_FLOAT_LABEL_WIDTH;

            }

          else

            {

              valueCharsWide = SINGLE_VALUE_WIDTH;

              labelWidth = SINGLE_LABEL_WIDTH;

            }

        }

      itemWinWidth = valueCharsWide + labelWidth;

      /*

         ** Now create each data "sub" window, and write the display into it.

       */

      curY = 1;

      while (i < dataWin->detail.dataDisplayInfo.regsContentCount &&

             curY <= dataWin->generic.viewportHeight)

        {

          for (j = 0;

               (j < dataWin->detail.dataDisplayInfo.regsColumnCount &&

                i < dataWin->detail.dataDisplayInfo.regsContentCount); j++)

            {

              TuiGenWinInfoPtr dataItemWin;

              TuiDataElementPtr dataElementPtr;

              /* create the window if necessary */

              dataItemWin = &dataWin->detail.dataDisplayInfo.

                regsContent[i]->whichElement.dataWindow;

              dataElementPtr = &((TuiWinElementPtr)

                                 dataItemWin->content[0])->whichElement.data;

              if (dataItemWin->handle == (WINDOW *) NULL)

                {

                  dataItemWin->height = 1;

                  dataItemWin->width = (precision == double_precision) ?

                    itemWinWidth + 2 : itemWinWidth + 1;

                  dataItemWin->origin.x = (itemWinWidth * j) + 1;

                  dataItemWin->origin.y = curY;

                  makeWindow (dataItemWin, DONT_BOX_WINDOW);

                }

              /*

                 ** Get the printable representation of the register

                 ** and display it

               */

              _tuiDisplayRegister (

                            dataElementPtr->itemNo, dataItemWin, precision);

              i++;              /* next register */

            }

          curY++;               /* next row; */

        }

    }

  return;

}                               /* tuiDisplayRegistersFrom */

/*

   ** tuiDisplayRegElementAtLine().

   **        Function to display the registers in the content from

   **        'startElementNo' on 'startLineNo' until the end of the

   **        register content or the end of the display height.

   **        This function checks that we won't display off the end

   **        of the register display.

 */

void

#ifdef __STDC__

tuiDisplayRegElementAtLine (

                             int startElementNo,

                             int startLineNo)

#else

tuiDisplayRegElementAtLine (startElementNo, startLineNo)

     int startElementNo;

     int startLineNo;

#endif

{

  if (dataWin->detail.dataDisplayInfo.regsContent != (TuiWinContent) NULL &&

      dataWin->detail.dataDisplayInfo.regsContentCount > 0)

    {

      register int elementNo = startElementNo;

      if (startElementNo != 0 && startLineNo != 0)

        {

          register int lastLineNo, firstLineOnLastPage;

          lastLineNo = tuiLastRegsLineNo ();

          firstLineOnLastPage = lastLineNo - (dataWin->generic.height - 2);

          if (firstLineOnLastPage < 0)

            firstLineOnLastPage = 0;

          /*

             ** If there is no other data displayed except registers,

             ** and the elementNo causes us to scroll past the end of the

             ** registers, adjust what element to really start the display at.

           */

          if (dataWin->detail.dataDisplayInfo.dataContentCount <= 0 &&

              startLineNo > firstLineOnLastPage)

            elementNo = tuiFirstRegElementNoInLine (firstLineOnLastPage);

        }

      tuiDisplayRegistersFrom (elementNo);

    }

  return;

}                               /* tuiDisplayRegElementAtLine */

/*

   ** tuiDisplayRegistersFromLine().

   **        Function to display the registers starting at line lineNo in

   **        the data window.  Answers the line number that the display

   **        actually started from.  If nothing is displayed (-1) is returned.

 */

int

#ifdef __STDC__

tuiDisplayRegistersFromLine (

                              int lineNo,

                              int forceDisplay)

#else

tuiDisplayRegistersFromLine (lineNo, forceDisplay)

     int lineNo;

     int forceDisplay;

#endif

{

  int elementNo;

  if (dataWin->detail.dataDisplayInfo.regsContentCount > 0)

    {

      int line, elementNo;

      if (lineNo < 0)

        line = 0;

      else if (forceDisplay)

        {                       /*

                                   ** If we must display regs (forceDisplay is true), then make

                                   ** sure that we don't display off the end of the registers.

                                 */

          if (lineNo >= tuiLastRegsLineNo ())

            {

              if ((line = tuiLineFromRegElementNo (

                 dataWin->detail.dataDisplayInfo.regsContentCount - 1)) < 0)

                line = 0;

            }

          else

            line = lineNo;

        }

      else

        line = lineNo;

      elementNo = tuiFirstRegElementNoInLine (line);

      if (elementNo < dataWin->detail.dataDisplayInfo.regsContentCount)

        tuiDisplayRegElementAtLine (elementNo, line);

      else

        line = (-1);

      return line;

    }

  return (-1);                  /* nothing was displayed */

}                               /* tuiDisplayRegistersFromLine */

/*

   ** tuiCheckRegisterValues()

   **        This function check all displayed registers for changes in

   **        values, given a particular frame.  If the values have changed,

   **        they are updated with the new value and highlighted.

 */

void

#ifdef __STDC__

tuiCheckRegisterValues (

                         struct frame_info *frame)

#else

tuiCheckRegisterValues (frame)

     struct frame_info *frame;

#endif

{

  if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)

    {

      if (dataWin->detail.dataDisplayInfo.regsContentCount <= 0 &&

          dataWin->detail.dataDisplayInfo.displayRegs)

        tuiShowRegisters ((tuiLayoutDef ())->regsDisplayType);

      else

        {

          int i, j;

          char rawBuf[MAX_REGISTER_RAW_SIZE];

          for (i = 0;

               (i < dataWin->detail.dataDisplayInfo.regsContentCount); i++)

            {

              TuiDataElementPtr dataElementPtr;

              TuiGenWinInfoPtr dataItemWinPtr;

              int wasHilighted;

              dataItemWinPtr = &dataWin->detail.dataDisplayInfo.

                regsContent[i]->whichElement.dataWindow;

              dataElementPtr = &((TuiWinElementPtr)

                             dataItemWinPtr->content[0])->whichElement.data;

              wasHilighted = dataElementPtr->highlight;

              dataElementPtr->highlight =

                _tuiRegValueHasChanged (dataElementPtr, frame, &rawBuf[0]);

              if (dataElementPtr->highlight)

                {

                  for (j = 0; j < MAX_REGISTER_RAW_SIZE; j++)

                    ((char *) dataElementPtr->value)[j] = rawBuf[j];

                  _tuiDisplayRegister (

                                        dataElementPtr->itemNo,

                                        dataItemWinPtr,

                        ((dataWin->detail.dataDisplayInfo.regsDisplayType ==

                          TUI_DFLOAT_REGS) ?

                         double_precision : unspecified_precision));

                }

              else if (wasHilighted)

                {

                  dataElementPtr->highlight = FALSE;

                  _tuiDisplayRegister (

                                        dataElementPtr->itemNo,

                                        dataItemWinPtr,

                        ((dataWin->detail.dataDisplayInfo.regsDisplayType ==

                          TUI_DFLOAT_REGS) ?

                         double_precision : unspecified_precision));

                }

            }

        }

    }

  return;

}                               /* tuiCheckRegisterValues */

/*

   ** tuiToggleFloatRegs().

 */

void

#ifdef __STDC__

tuiToggleFloatRegs (void)

#else

tuiToggleFloatRegs ()

#endif

{

  TuiLayoutDefPtr layoutDef = tuiLayoutDef ();

  if (layoutDef->floatRegsDisplayType == TUI_SFLOAT_REGS)

    layoutDef->floatRegsDisplayType = TUI_DFLOAT_REGS;

  else

    layoutDef->floatRegsDisplayType = TUI_SFLOAT_REGS;

  if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible &&

      (dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_SFLOAT_REGS ||

       dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_DFLOAT_REGS))

    tuiShowRegisters (layoutDef->floatRegsDisplayType);

  return;

}                               /* tuiToggleFloatRegs */

void

_initialize_tuiRegs (void)

{

  if (tui_version && xdb_commands)

    {

      add_com ("fr", class_tui, _tuiShowFloat_command,

               "Display only floating point registers\n");

      add_com ("gr", class_tui, _tuiShowGeneral_command,

               "Display only general registers\n");

      add_com ("sr", class_tui, _tuiShowSpecial_command,

               "Display only special registers\n");

      add_com ("+r", class_tui, _tuiScrollRegsForward_command,

               "Scroll the registers window forward\n");

      add_com ("-r", class_tui, _tuiScrollRegsBackward_command,

               "Scroll the register window backward\n");

      add_com ("tf", class_tui, _tuiToggleFloatRegs_command,

               "Toggle between single and double precision floating point registers.\n");

      add_cmd (TUI_FLOAT_REGS_NAME_LOWER,

               class_tui,

               _tuiToggleFloatRegs_command,

               "Toggle between single and double precision floating point \

registers.\n",

               &togglelist);

    }

  return;

}                               /* _initialize_tuiRegs */

/*****************************************

** STATIC LOCAL FUNCTIONS                 **

******************************************/

/*

   ** _tuiRegisterName().

   **        Return the register name.

 */

static char *

#ifdef __STDC__

_tuiRegisterName (

                   int regNum)

#else

_tuiRegisterName (regNum)

     int regNum;

#endif

{

  if (reg_names[regNum] != (char *) NULL && *(reg_names[regNum]) != (char) 0)

    return reg_names[regNum];

  else

    return ((char *) NULL);

}                               /* tuiGetRegisterName */

/*

   ** _tuiRegisterFormat

   **        Function to format the register name and value into a buffer,

   **        suitable for printing or display

 */

static void

#ifdef __STDC__

_tuiRegisterFormat (

                     char *buf,

                     int bufLen,

                     int regNum,

                     TuiDataElementPtr dataElement,

                     enum precision_type precision)

#else

_tuiRegisterFormat (buf, bufLen, regNum, dataElement, precision)

     char *buf;

     int bufLen;

     int regNum;

     TuiDataElementPtr dataElement;

     enum precision_type precision;

#endif

{

  char tmpBuf[15];

  char *fmt;

  struct ui_file *stream;

  stream = tui_sfileopen (bufLen);

  pa_do_strcat_registers_info (regNum, 0, stream, precision);

  strcpy (buf, tui_file_get_strbuf (stream));

  ui_file_delete (stream);

  return;

}                               /* _tuiRegisterFormat */

#define NUM_GENERAL_REGS    32

/*

   ** _tuiSetGeneralRegsContent().

   **      Set the content of the data window to consist of the general registers.

 */

static TuiStatus

#ifdef __STDC__

_tuiSetGeneralRegsContent (

                            int refreshValuesOnly)

#else

_tuiSetGeneralRegsContent (refreshValuesOnly)

     int refreshValuesOnly;

#endif

{

  return (_tuiSetRegsContent (0,

                              NUM_GENERAL_REGS - 1,

                              selected_frame,

                              TUI_GENERAL_REGS,

                              refreshValuesOnly));

}                               /* _tuiSetGeneralRegsContent */

#define START_SPECIAL_REGS    PCOQ_HEAD_REGNUM

/*

   ** _tuiSetSpecialRegsContent().

   **      Set the content of the data window to consist of the special registers.

 */

static TuiStatus

#ifdef __STDC__

_tuiSetSpecialRegsContent (

                            int refreshValuesOnly)

#else

_tuiSetSpecialRegsContent (refreshValuesOnly)

     int refreshValuesOnly;

#endif

{

  TuiStatus ret = TUI_FAILURE;

  int i, endRegNum;

  endRegNum = FP0_REGNUM - 1;

#if 0

  endRegNum = (-1);