4 ** This module contains functions to support display of registers
18 #include "tuiLayout.h"
22 /*****************************************
23 ** LOCAL DEFINITIONS **
24 ******************************************/
25 #define DOUBLE_FLOAT_LABEL_WIDTH 6
26 #define DOUBLE_FLOAT_LABEL_FMT "%6.6s: "
27 #define DOUBLE_FLOAT_VALUE_WIDTH 30 /*min of 16 but may be in sci notation */
29 #define SINGLE_FLOAT_LABEL_WIDTH 6
30 #define SINGLE_FLOAT_LABEL_FMT "%6.6s: "
31 #define SINGLE_FLOAT_VALUE_WIDTH 25 /* min of 8 but may be in sci notation */
33 #define SINGLE_LABEL_WIDTH 10
34 #define SINGLE_LABEL_FMT "%10.10s: "
35 #define SINGLE_VALUE_WIDTH 14 /* minimum of 8 but may be in sci notation */
37 /* In the code HP gave Cygnus, this was actually a function call to a
38 PA-specific function, which was supposed to determine whether the
39 target was a 64-bit or 32-bit processor. However, the 64-bit
40 support wasn't complete, so we didn't merge that in, so we leave
41 this here as a stub. */
44 /*****************************************
46 ******************************************/
49 /*****************************************
50 ** STATIC LOCAL FUNCTIONS FORWARD DECLS **
51 ******************************************/
52 static TuiStatus _tuiSetRegsContent
53 (int, int, struct frame_info
*, TuiRegisterDisplayType
, int);
54 static char *_tuiRegisterName (int);
55 static TuiStatus
_tuiGetRegisterRawValue (int, char *, struct frame_info
*);
56 static void _tuiSetRegisterElement
57 (int, struct frame_info
*, TuiDataElementPtr
, int);
58 static void _tuiDisplayRegister (int, TuiGenWinInfoPtr
, enum precision_type
);
59 static void _tuiRegisterFormat
60 (char *, int, int, TuiDataElementPtr
, enum precision_type
);
61 static TuiStatus
_tuiSetGeneralRegsContent (int);
62 static TuiStatus
_tuiSetSpecialRegsContent (int);
63 static TuiStatus
_tuiSetGeneralAndSpecialRegsContent (int);
64 static TuiStatus
_tuiSetFloatRegsContent (TuiRegisterDisplayType
, int);
65 static int _tuiRegValueHasChanged
66 (TuiDataElementPtr
, struct frame_info
*, char *);
67 static void _tuiShowFloat_command (char *, int);
68 static void _tuiShowGeneral_command (char *, int);
69 static void _tuiShowSpecial_command (char *, int);
70 static void _tui_vShowRegisters_commandSupport (va_list);
71 static void _tuiToggleFloatRegs_command (char *, int);
72 static void _tuiScrollRegsForward_command (char *, int);
73 static void _tuiScrollRegsBackward_command (char *, int);
74 static void _tui_vShowRegisters_commandSupport (va_list);
78 /*****************************************
79 ** PUBLIC FUNCTIONS **
80 ******************************************/
83 ** tuiLastRegsLineNo()
84 ** Answer the number of the last line in the regs display.
85 ** If there are no registers (-1) is returned.
89 tuiLastRegsLineNo (void)
94 register int numLines
= (-1);
96 if (dataWin
->detail
.dataDisplayInfo
.regsContentCount
> 0)
98 numLines
= (dataWin
->detail
.dataDisplayInfo
.regsContentCount
/
99 dataWin
->detail
.dataDisplayInfo
.regsColumnCount
);
100 if (dataWin
->detail
.dataDisplayInfo
.regsContentCount
%
101 dataWin
->detail
.dataDisplayInfo
.regsColumnCount
)
105 } /* tuiLastRegsLineNo */
109 ** tuiLineFromRegElementNo()
110 ** Answer the line number that the register element at elementNo is
111 ** on. If elementNo is greater than the number of register elements
112 ** there are, -1 is returned.
116 tuiLineFromRegElementNo (
119 tuiLineFromRegElementNo (elementNo
)
123 if (elementNo
< dataWin
->detail
.dataDisplayInfo
.regsContentCount
)
131 (dataWin
->detail
.dataDisplayInfo
.regsColumnCount
* i
))
141 } /* tuiLineFromRegElementNo */
145 ** tuiFirstRegElementNoInLine()
146 ** Answer the index of the first element in lineNo. If lineNo is
147 ** past the register area (-1) is returned.
151 tuiFirstRegElementNoInLine (
154 tuiFirstRegElementNoInLine (lineNo
)
158 if ((lineNo
* dataWin
->detail
.dataDisplayInfo
.regsColumnCount
)
159 <= dataWin
->detail
.dataDisplayInfo
.regsContentCount
)
160 return ((lineNo
+ 1) *
161 dataWin
->detail
.dataDisplayInfo
.regsColumnCount
) -
162 dataWin
->detail
.dataDisplayInfo
.regsColumnCount
;
165 } /* tuiFirstRegElementNoInLine */
169 ** tuiLastRegElementNoInLine()
170 ** Answer the index of the last element in lineNo. If lineNo is past
171 ** the register area (-1) is returned.
175 tuiLastRegElementNoInLine (
178 tuiLastRegElementNoInLine (lineNo
)
182 if ((lineNo
* dataWin
->detail
.dataDisplayInfo
.regsColumnCount
) <=
183 dataWin
->detail
.dataDisplayInfo
.regsContentCount
)
184 return ((lineNo
+ 1) *
185 dataWin
->detail
.dataDisplayInfo
.regsColumnCount
) - 1;
188 } /* tuiLastRegElementNoInLine */
192 ** tuiCalculateRegsColumnCount
193 ** Calculate the number of columns that should be used to display
198 tuiCalculateRegsColumnCount (
199 TuiRegisterDisplayType dpyType
)
201 tuiCalculateRegsColumnCount (dpyType
)
202 TuiRegisterDisplayType dpyType
;
205 int colCount
, colWidth
;
207 if (IS_64BIT
|| dpyType
== TUI_DFLOAT_REGS
)
208 colWidth
= DOUBLE_FLOAT_VALUE_WIDTH
+ DOUBLE_FLOAT_LABEL_WIDTH
;
211 if (dpyType
== TUI_SFLOAT_REGS
)
212 colWidth
= SINGLE_FLOAT_VALUE_WIDTH
+ SINGLE_FLOAT_LABEL_WIDTH
;
214 colWidth
= SINGLE_VALUE_WIDTH
+ SINGLE_LABEL_WIDTH
;
216 colCount
= (dataWin
->generic
.width
- 2) / colWidth
;
219 } /* tuiCalulateRegsColumnCount */
223 ** tuiShowRegisters().
224 ** Show the registers int the data window as indicated by dpyType.
225 ** If there is any other registers being displayed, then they are
226 ** cleared. What registers are displayed is dependent upon dpyType.
231 TuiRegisterDisplayType dpyType
)
233 tuiShowRegisters (dpyType
)
234 TuiRegisterDisplayType dpyType
;
237 TuiStatus ret
= TUI_FAILURE
;
238 int refreshValuesOnly
= FALSE
;
240 /* Say that registers should be displayed, even if there is a problem */
241 dataWin
->detail
.dataDisplayInfo
.displayRegs
= TRUE
;
243 if (target_has_registers
)
246 (dpyType
== dataWin
->detail
.dataDisplayInfo
.regsDisplayType
);
249 case TUI_GENERAL_REGS
:
250 ret
= _tuiSetGeneralRegsContent (refreshValuesOnly
);
252 case TUI_SFLOAT_REGS
:
253 case TUI_DFLOAT_REGS
:
254 ret
= _tuiSetFloatRegsContent (dpyType
, refreshValuesOnly
);
257 /* could ifdef out */
259 case TUI_SPECIAL_REGS
:
260 ret
= _tuiSetSpecialRegsContent (refreshValuesOnly
);
262 case TUI_GENERAL_AND_SPECIAL_REGS
:
263 ret
= _tuiSetGeneralAndSpecialRegsContent (refreshValuesOnly
);
266 /* end of potential if def */
272 if (ret
== TUI_FAILURE
)
274 dataWin
->detail
.dataDisplayInfo
.regsDisplayType
= TUI_UNDEFINED_REGS
;
275 tuiEraseDataContent (NO_REGS_STRING
);
281 /* Clear all notation of changed values */
282 for (i
= 0; (i
< dataWin
->detail
.dataDisplayInfo
.regsContentCount
); i
++)
284 TuiGenWinInfoPtr dataItemWin
;
286 dataItemWin
= &dataWin
->detail
.dataDisplayInfo
.
287 regsContent
[i
]->whichElement
.dataWindow
;
288 (&((TuiWinElementPtr
)
289 dataItemWin
->content
[0])->whichElement
.data
)->highlight
= FALSE
;
291 dataWin
->detail
.dataDisplayInfo
.regsDisplayType
= dpyType
;
292 tuiDisplayAllData ();
294 (tuiLayoutDef ())->regsDisplayType
= dpyType
;
297 } /* tuiShowRegisters */
301 ** tuiDisplayRegistersFrom().
302 ** Function to display the registers in the content from
303 ** 'startElementNo' until the end of the register content or the
304 ** end of the display height. No checking for displaying past
305 ** the end of the registers is done here.
309 tuiDisplayRegistersFrom (
312 tuiDisplayRegistersFrom (startElementNo
)
316 if (dataWin
->detail
.dataDisplayInfo
.regsContent
!= (TuiWinContent
) NULL
&&
317 dataWin
->detail
.dataDisplayInfo
.regsContentCount
> 0)
319 register int i
= startElementNo
;
320 int j
, valueCharsWide
, charsWide
, itemWinWidth
, curY
, labelWidth
;
321 enum precision_type precision
;
323 precision
= (dataWin
->detail
.dataDisplayInfo
.regsDisplayType
324 == TUI_DFLOAT_REGS
) ?
325 double_precision
: unspecified_precision
;
327 dataWin
->detail
.dataDisplayInfo
.regsDisplayType
== TUI_DFLOAT_REGS
)
329 valueCharsWide
= DOUBLE_FLOAT_VALUE_WIDTH
;
330 labelWidth
= DOUBLE_FLOAT_LABEL_WIDTH
;
334 if (dataWin
->detail
.dataDisplayInfo
.regsDisplayType
==
337 valueCharsWide
= SINGLE_FLOAT_VALUE_WIDTH
;
338 labelWidth
= SINGLE_FLOAT_LABEL_WIDTH
;
342 valueCharsWide
= SINGLE_VALUE_WIDTH
;
343 labelWidth
= SINGLE_LABEL_WIDTH
;
346 itemWinWidth
= valueCharsWide
+ labelWidth
;
348 ** Now create each data "sub" window, and write the display into it.
351 while (i
< dataWin
->detail
.dataDisplayInfo
.regsContentCount
&&
352 curY
<= dataWin
->generic
.viewportHeight
)
355 (j
< dataWin
->detail
.dataDisplayInfo
.regsColumnCount
&&
356 i
< dataWin
->detail
.dataDisplayInfo
.regsContentCount
); j
++)
358 TuiGenWinInfoPtr dataItemWin
;
359 TuiDataElementPtr dataElementPtr
;
361 /* create the window if necessary */
362 dataItemWin
= &dataWin
->detail
.dataDisplayInfo
.
363 regsContent
[i
]->whichElement
.dataWindow
;
364 dataElementPtr
= &((TuiWinElementPtr
)
365 dataItemWin
->content
[0])->whichElement
.data
;
366 if (dataItemWin
->handle
== (WINDOW
*) NULL
)
368 dataItemWin
->height
= 1;
369 dataItemWin
->width
= (precision
== double_precision
) ?
370 itemWinWidth
+ 2 : itemWinWidth
+ 1;
371 dataItemWin
->origin
.x
= (itemWinWidth
* j
) + 1;
372 dataItemWin
->origin
.y
= curY
;
373 makeWindow (dataItemWin
, DONT_BOX_WINDOW
);
376 ** Get the printable representation of the register
379 _tuiDisplayRegister (
380 dataElementPtr
->itemNo
, dataItemWin
, precision
);
381 i
++; /* next register */
383 curY
++; /* next row; */
388 } /* tuiDisplayRegistersFrom */
392 ** tuiDisplayRegElementAtLine().
393 ** Function to display the registers in the content from
394 ** 'startElementNo' on 'startLineNo' until the end of the
395 ** register content or the end of the display height.
396 ** This function checks that we won't display off the end
397 ** of the register display.
401 tuiDisplayRegElementAtLine (
405 tuiDisplayRegElementAtLine (startElementNo
, startLineNo
)
410 if (dataWin
->detail
.dataDisplayInfo
.regsContent
!= (TuiWinContent
) NULL
&&
411 dataWin
->detail
.dataDisplayInfo
.regsContentCount
> 0)
413 register int elementNo
= startElementNo
;
415 if (startElementNo
!= 0 && startLineNo
!= 0)
417 register int lastLineNo
, firstLineOnLastPage
;
419 lastLineNo
= tuiLastRegsLineNo ();
420 firstLineOnLastPage
= lastLineNo
- (dataWin
->generic
.height
- 2);
421 if (firstLineOnLastPage
< 0)
422 firstLineOnLastPage
= 0;
424 ** If there is no other data displayed except registers,
425 ** and the elementNo causes us to scroll past the end of the
426 ** registers, adjust what element to really start the display at.
428 if (dataWin
->detail
.dataDisplayInfo
.dataContentCount
<= 0 &&
429 startLineNo
> firstLineOnLastPage
)
430 elementNo
= tuiFirstRegElementNoInLine (firstLineOnLastPage
);
432 tuiDisplayRegistersFrom (elementNo
);
436 } /* tuiDisplayRegElementAtLine */
441 ** tuiDisplayRegistersFromLine().
442 ** Function to display the registers starting at line lineNo in
443 ** the data window. Answers the line number that the display
444 ** actually started from. If nothing is displayed (-1) is returned.
448 tuiDisplayRegistersFromLine (
452 tuiDisplayRegistersFromLine (lineNo
, forceDisplay
)
459 if (dataWin
->detail
.dataDisplayInfo
.regsContentCount
> 0)
465 else if (forceDisplay
)
467 ** If we must display regs (forceDisplay is true), then make
468 ** sure that we don't display off the end of the registers.
470 if (lineNo
>= tuiLastRegsLineNo ())
472 if ((line
= tuiLineFromRegElementNo (
473 dataWin
->detail
.dataDisplayInfo
.regsContentCount
- 1)) < 0)
482 elementNo
= tuiFirstRegElementNoInLine (line
);
483 if (elementNo
< dataWin
->detail
.dataDisplayInfo
.regsContentCount
)
484 tuiDisplayRegElementAtLine (elementNo
, line
);
491 return (-1); /* nothing was displayed */
492 } /* tuiDisplayRegistersFromLine */
496 ** tuiCheckRegisterValues()
497 ** This function check all displayed registers for changes in
498 ** values, given a particular frame. If the values have changed,
499 ** they are updated with the new value and highlighted.
503 tuiCheckRegisterValues (
504 struct frame_info
*frame
)
506 tuiCheckRegisterValues (frame
)
507 struct frame_info
*frame
;
510 if (m_winPtrNotNull (dataWin
) && dataWin
->generic
.isVisible
)
512 if (dataWin
->detail
.dataDisplayInfo
.regsContentCount
<= 0 &&
513 dataWin
->detail
.dataDisplayInfo
.displayRegs
)
514 tuiShowRegisters ((tuiLayoutDef ())->regsDisplayType
);
518 char rawBuf
[MAX_REGISTER_RAW_SIZE
];
521 (i
< dataWin
->detail
.dataDisplayInfo
.regsContentCount
); i
++)
523 TuiDataElementPtr dataElementPtr
;
524 TuiGenWinInfoPtr dataItemWinPtr
;
527 dataItemWinPtr
= &dataWin
->detail
.dataDisplayInfo
.
528 regsContent
[i
]->whichElement
.dataWindow
;
529 dataElementPtr
= &((TuiWinElementPtr
)
530 dataItemWinPtr
->content
[0])->whichElement
.data
;
531 wasHilighted
= dataElementPtr
->highlight
;
532 dataElementPtr
->highlight
=
533 _tuiRegValueHasChanged (dataElementPtr
, frame
, &rawBuf
[0]);
534 if (dataElementPtr
->highlight
)
536 for (j
= 0; j
< MAX_REGISTER_RAW_SIZE
; j
++)
537 ((char *) dataElementPtr
->value
)[j
] = rawBuf
[j
];
538 _tuiDisplayRegister (
539 dataElementPtr
->itemNo
,
541 ((dataWin
->detail
.dataDisplayInfo
.regsDisplayType
==
543 double_precision
: unspecified_precision
));
545 else if (wasHilighted
)
547 dataElementPtr
->highlight
= FALSE
;
548 _tuiDisplayRegister (
549 dataElementPtr
->itemNo
,
551 ((dataWin
->detail
.dataDisplayInfo
.regsDisplayType
==
553 double_precision
: unspecified_precision
));
559 } /* tuiCheckRegisterValues */
563 ** tuiToggleFloatRegs().
567 tuiToggleFloatRegs (void)
569 tuiToggleFloatRegs ()
572 TuiLayoutDefPtr layoutDef
= tuiLayoutDef ();
574 if (layoutDef
->floatRegsDisplayType
== TUI_SFLOAT_REGS
)
575 layoutDef
->floatRegsDisplayType
= TUI_DFLOAT_REGS
;
577 layoutDef
->floatRegsDisplayType
= TUI_SFLOAT_REGS
;
579 if (m_winPtrNotNull (dataWin
) && dataWin
->generic
.isVisible
&&
580 (dataWin
->detail
.dataDisplayInfo
.regsDisplayType
== TUI_SFLOAT_REGS
||
581 dataWin
->detail
.dataDisplayInfo
.regsDisplayType
== TUI_DFLOAT_REGS
))
582 tuiShowRegisters (layoutDef
->floatRegsDisplayType
);
585 } /* tuiToggleFloatRegs */
589 _initialize_tuiRegs (void)
591 if (tui_version
&& xdb_commands
)
593 add_com ("fr", class_tui
, _tuiShowFloat_command
,
594 "Display only floating point registers\n");
595 add_com ("gr", class_tui
, _tuiShowGeneral_command
,
596 "Display only general registers\n");
597 add_com ("sr", class_tui
, _tuiShowSpecial_command
,
598 "Display only special registers\n");
599 add_com ("+r", class_tui
, _tuiScrollRegsForward_command
,
600 "Scroll the registers window forward\n");
601 add_com ("-r", class_tui
, _tuiScrollRegsBackward_command
,
602 "Scroll the register window backward\n");
603 add_com ("tf", class_tui
, _tuiToggleFloatRegs_command
,
604 "Toggle between single and double precision floating point registers.\n");
605 add_cmd (TUI_FLOAT_REGS_NAME_LOWER
,
607 _tuiToggleFloatRegs_command
,
608 "Toggle between single and double precision floating point \
614 } /* _initialize_tuiRegs */
617 /*****************************************
618 ** STATIC LOCAL FUNCTIONS **
619 ******************************************/
623 ** _tuiRegisterName().
624 ** Return the register name.
631 _tuiRegisterName (regNum
)
635 if (reg_names
[regNum
] != (char *) NULL
&& *(reg_names
[regNum
]) != (char) 0)
636 return reg_names
[regNum
];
638 return ((char *) NULL
);
639 } /* tuiGetRegisterName */
643 ** _tuiRegisterFormat
644 ** Function to format the register name and value into a buffer,
645 ** suitable for printing or display
653 TuiDataElementPtr dataElement
,
654 enum precision_type precision
)
656 _tuiRegisterFormat (buf
, bufLen
, regNum
, dataElement
, precision
)
660 TuiDataElementPtr dataElement
;
661 enum precision_type precision
;
666 struct ui_file
*stream
;
668 stream
= tui_sfileopen (bufLen
);
669 pa_do_strcat_registers_info (regNum
, 0, stream
, precision
);
670 strcpy (buf
, tui_file_get_strbuf (stream
));
671 ui_file_delete (stream
);
674 } /* _tuiRegisterFormat */
677 #define NUM_GENERAL_REGS 32
679 ** _tuiSetGeneralRegsContent().
680 ** Set the content of the data window to consist of the general registers.
684 _tuiSetGeneralRegsContent (
685 int refreshValuesOnly
)
687 _tuiSetGeneralRegsContent (refreshValuesOnly
)
688 int refreshValuesOnly
;
691 return (_tuiSetRegsContent (0,
692 NUM_GENERAL_REGS
- 1,
697 } /* _tuiSetGeneralRegsContent */
700 #define START_SPECIAL_REGS PCOQ_HEAD_REGNUM
702 ** _tuiSetSpecialRegsContent().
703 ** Set the content of the data window to consist of the special registers.
707 _tuiSetSpecialRegsContent (
708 int refreshValuesOnly
)
710 _tuiSetSpecialRegsContent (refreshValuesOnly
)
711 int refreshValuesOnly
;
714 TuiStatus ret
= TUI_FAILURE
;
717 endRegNum
= FP0_REGNUM
- 1;
720 for (i
= START_SPECIAL_REGS
; (i
< NUM_REGS
&& endRegNum
< 0); i
++)
721 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i
)) == TYPE_CODE_FLT
)
724 ret
= _tuiSetRegsContent (START_SPECIAL_REGS
,
731 } /* _tuiSetSpecialRegsContent */
735 ** _tuiSetGeneralAndSpecialRegsContent().
736 ** Set the content of the data window to consist of the special registers.
740 _tuiSetGeneralAndSpecialRegsContent (
741 int refreshValuesOnly
)
743 _tuiSetGeneralAndSpecialRegsContent (refreshValuesOnly
)
744 int refreshValuesOnly
;
747 TuiStatus ret
= TUI_FAILURE
;
748 int i
, endRegNum
= (-1);
750 endRegNum
= FP0_REGNUM
- 1;
753 for (i
= 0; (i
< NUM_REGS
&& endRegNum
< 0); i
++)
754 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i
)) == TYPE_CODE_FLT
)
757 ret
= _tuiSetRegsContent (
758 0, endRegNum
, selected_frame
, TUI_SPECIAL_REGS
, refreshValuesOnly
);
761 } /* _tuiSetGeneralAndSpecialRegsContent */
764 ** _tuiSetFloatRegsContent().
765 ** Set the content of the data window to consist of the float registers.
769 _tuiSetFloatRegsContent (
770 TuiRegisterDisplayType dpyType
,
771 int refreshValuesOnly
)
773 _tuiSetFloatRegsContent (dpyType
, refreshValuesOnly
)
774 TuiRegisterDisplayType dpyType
;
775 int refreshValuesOnly
;
778 TuiStatus ret
= TUI_FAILURE
;
781 startRegNum
= FP0_REGNUM
;
784 for (i
= NUM_REGS
- 1; (i
>= 0 && startRegNum
< 0); i
--)
785 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i
)) != TYPE_CODE_FLT
)
788 ret
= _tuiSetRegsContent (startRegNum
,
795 } /* _tuiSetFloatRegsContent */
799 ** _tuiRegValueHasChanged().
800 ** Answer TRUE if the register's value has changed, FALSE otherwise.
801 ** If TRUE, newValue is filled in with the new value.
805 _tuiRegValueHasChanged (
806 TuiDataElementPtr dataElement
,
807 struct frame_info
*frame
,
810 _tuiRegValueHasChanged (dataElement
, frame
, newValue
)
811 TuiDataElementPtr dataElement
;
812 struct frame_info
*frame
;
816 int hasChanged
= FALSE
;
818 if (dataElement
->itemNo
!= UNDEFINED_ITEM
&&
819 _tuiRegisterName (dataElement
->itemNo
) != (char *) NULL
)
821 char rawBuf
[MAX_REGISTER_RAW_SIZE
];
824 if (_tuiGetRegisterRawValue (
825 dataElement
->itemNo
, rawBuf
, frame
) == TUI_SUCCESS
)
827 for (i
= 0; (i
< MAX_REGISTER_RAW_SIZE
&& !hasChanged
); i
++)
828 hasChanged
= (((char *) dataElement
->value
)[i
] != rawBuf
[i
]);
829 if (hasChanged
&& newValue
!= (char *) NULL
)
831 for (i
= 0; (i
< MAX_REGISTER_RAW_SIZE
); i
++)
832 newValue
[i
] = rawBuf
[i
];
837 } /* _tuiRegValueHasChanged */
842 ** _tuiGetRegisterRawValue().
843 ** Get the register raw value. The raw value is returned in regValue.
847 _tuiGetRegisterRawValue (
850 struct frame_info
*frame
)
852 _tuiGetRegisterRawValue (regNum
, regValue
, frame
)
855 struct frame_info
*frame
;
858 TuiStatus ret
= TUI_FAILURE
;
860 if (target_has_registers
)
862 read_relative_register_raw_bytes_for_frame (regNum
, regValue
, frame
);
867 } /* _tuiGetRegisterRawValue */
872 ** _tuiSetRegisterElement().
873 ** Function to initialize a data element with the input and
874 ** the register value.
878 _tuiSetRegisterElement (
880 struct frame_info
*frame
,
881 TuiDataElementPtr dataElement
,
882 int refreshValueOnly
)
884 _tuiSetRegisterElement (regNum
, frame
, dataElement
, refreshValueOnly
)
886 struct frame_info
*frame
;
887 TuiDataElementPtr dataElement
;
888 int refreshValueOnly
;
891 if (dataElement
!= (TuiDataElementPtr
) NULL
)
893 if (!refreshValueOnly
)
895 dataElement
->itemNo
= regNum
;
896 dataElement
->name
= _tuiRegisterName (regNum
);
897 dataElement
->highlight
= FALSE
;
899 if (dataElement
->value
== (Opaque
) NULL
)
900 dataElement
->value
= (Opaque
) xmalloc (MAX_REGISTER_RAW_SIZE
);
901 if (dataElement
->value
!= (Opaque
) NULL
)
902 _tuiGetRegisterRawValue (regNum
, dataElement
->value
, frame
);
906 } /* _tuiSetRegisterElement */
910 ** _tuiSetRegsContent().
911 ** Set the content of the data window to consist of the registers
912 ** numbered from startRegNum to endRegNum. Note that if
913 ** refreshValuesOnly is TRUE, startRegNum and endRegNum are ignored.
920 struct frame_info
*frame
,
921 TuiRegisterDisplayType dpyType
,
922 int refreshValuesOnly
)
924 _tuiSetRegsContent (startRegNum
, endRegNum
, frame
, dpyType
, refreshValuesOnly
)
927 struct frame_info
*frame
;
928 TuiRegisterDisplayType dpyType
;
929 int refreshValuesOnly
;
932 TuiStatus ret
= TUI_FAILURE
;
933 int numRegs
= endRegNum
- startRegNum
+ 1;
934 int allocatedHere
= FALSE
;
936 if (dataWin
->detail
.dataDisplayInfo
.regsContentCount
> 0 &&
939 freeDataContent (dataWin
->detail
.dataDisplayInfo
.regsContent
,
940 dataWin
->detail
.dataDisplayInfo
.regsContentCount
);
941 dataWin
->detail
.dataDisplayInfo
.regsContentCount
= 0;
943 if (dataWin
->detail
.dataDisplayInfo
.regsContentCount
<= 0)
945 dataWin
->detail
.dataDisplayInfo
.regsContent
=
946 allocContent (numRegs
, DATA_WIN
);
947 allocatedHere
= TRUE
;
950 if (dataWin
->detail
.dataDisplayInfo
.regsContent
!= (TuiWinContent
) NULL
)
954 if (!refreshValuesOnly
|| allocatedHere
)
956 dataWin
->generic
.content
= (OpaquePtr
) NULL
;
957 dataWin
->generic
.contentSize
= 0;
958 addContentElements (&dataWin
->generic
, numRegs
);
959 dataWin
->detail
.dataDisplayInfo
.regsContent
=
960 (TuiWinContent
) dataWin
->generic
.content
;
961 dataWin
->detail
.dataDisplayInfo
.regsContentCount
= numRegs
;
964 ** Now set the register names and values
966 for (i
= startRegNum
; (i
<= endRegNum
); i
++)
968 TuiGenWinInfoPtr dataItemWin
;
970 dataItemWin
= &dataWin
->detail
.dataDisplayInfo
.
971 regsContent
[i
- startRegNum
]->whichElement
.dataWindow
;
972 _tuiSetRegisterElement (
975 &((TuiWinElementPtr
) dataItemWin
->content
[0])->whichElement
.data
,
976 !allocatedHere
&& refreshValuesOnly
);
978 dataWin
->detail
.dataDisplayInfo
.regsColumnCount
=
979 tuiCalculateRegsColumnCount (dpyType
);
981 if (dataWin
->detail
.dataDisplayInfo
.dataContentCount
> 0)
983 /* delete all the windows? */
984 /* realloc content equal to dataContentCount + regsContentCount */
985 /* append dataWin->detail.dataDisplayInfo.dataContent to content */
988 dataWin
->generic
.contentSize
=
989 dataWin
->detail
.dataDisplayInfo
.regsContentCount
+
990 dataWin
->detail
.dataDisplayInfo
.dataContentCount
;
995 } /* _tuiSetRegsContent */
999 ** _tuiDisplayRegister().
1000 ** Function to display a register in a window. If hilite is TRUE,
1001 ** than the value will be displayed in reverse video
1005 _tuiDisplayRegister (
1007 TuiGenWinInfoPtr winInfo
, /* the data item window */
1008 enum precision_type precision
)
1010 _tuiDisplayRegister (regNum
, winInfo
, precision
)
1012 TuiGenWinInfoPtr winInfo
; /* the data item window */
1013 enum precision_type precision
;
1016 if (winInfo
->handle
!= (WINDOW
*) NULL
)
1019 int valueCharsWide
, labelWidth
;
1020 TuiDataElementPtr dataElementPtr
= &((TuiWinContent
)
1021 winInfo
->content
)[0]->whichElement
.data
;
1024 dataWin
->detail
.dataDisplayInfo
.regsDisplayType
== TUI_DFLOAT_REGS
)
1026 valueCharsWide
= DOUBLE_FLOAT_VALUE_WIDTH
;
1027 labelWidth
= DOUBLE_FLOAT_LABEL_WIDTH
;
1031 if (dataWin
->detail
.dataDisplayInfo
.regsDisplayType
==
1034 valueCharsWide
= SINGLE_FLOAT_VALUE_WIDTH
;
1035 labelWidth
= SINGLE_FLOAT_LABEL_WIDTH
;
1039 valueCharsWide
= SINGLE_VALUE_WIDTH
;
1040 labelWidth
= SINGLE_LABEL_WIDTH
;
1045 _tuiRegisterFormat (buf
,
1046 valueCharsWide
+ labelWidth
,
1050 if (dataElementPtr
->highlight
)
1051 wstandout (winInfo
->handle
);
1053 werase (winInfo
->handle
);
1054 wmove (winInfo
->handle
, 0, 0);
1055 waddstr (winInfo
->handle
, buf
);
1057 if (dataElementPtr
->highlight
)
1058 wstandend (winInfo
->handle
);
1059 tuiRefreshWin (winInfo
);
1062 } /* _tuiDisplayRegister */
1067 _tui_vShowRegisters_commandSupport (
1070 _tui_vShowRegisters_commandSupport (args
)
1074 TuiRegisterDisplayType dpyType
= va_arg (args
, TuiRegisterDisplayType
);
1076 if (m_winPtrNotNull (dataWin
) && dataWin
->generic
.isVisible
)
1077 { /* Data window already displayed, show the registers */
1078 if (dataWin
->detail
.dataDisplayInfo
.regsDisplayType
!= dpyType
)
1079 tuiShowRegisters (dpyType
);
1082 (tuiLayoutDef ())->regsDisplayType
= dpyType
;
1085 } /* _tui_vShowRegisters_commandSupport */
1090 _tuiShowFloat_command (
1094 _tuiShowFloat_command (arg
, fromTTY
)
1099 if (m_winPtrIsNull (dataWin
) || !dataWin
->generic
.isVisible
||
1100 (dataWin
->detail
.dataDisplayInfo
.regsDisplayType
!= TUI_SFLOAT_REGS
&&
1101 dataWin
->detail
.dataDisplayInfo
.regsDisplayType
!= TUI_DFLOAT_REGS
))
1102 tuiDo ((TuiOpaqueFuncPtr
) _tui_vShowRegisters_commandSupport
,
1103 (tuiLayoutDef ())->floatRegsDisplayType
);
1106 } /* _tuiShowFloat_command */
1111 _tuiShowGeneral_command (
1115 _tuiShowGeneral_command (arg
, fromTTY
)
1120 tuiDo ((TuiOpaqueFuncPtr
) _tui_vShowRegisters_commandSupport
,
1124 } /* _tuiShowGeneral_command */
1129 _tuiShowSpecial_command (
1133 _tuiShowSpecial_command (arg
, fromTTY
)
1138 tuiDo ((TuiOpaqueFuncPtr
) _tui_vShowRegisters_commandSupport
,
1142 } /* _tuiShowSpecial_command */
1147 _tuiToggleFloatRegs_command (
1151 _tuiToggleFloatRegs_command (arg
, fromTTY
)
1156 if (m_winPtrNotNull (dataWin
) && dataWin
->generic
.isVisible
)
1157 tuiDo ((TuiOpaqueFuncPtr
) tuiToggleFloatRegs
);
1160 TuiLayoutDefPtr layoutDef
= tuiLayoutDef ();
1162 if (layoutDef
->floatRegsDisplayType
== TUI_SFLOAT_REGS
)
1163 layoutDef
->floatRegsDisplayType
= TUI_DFLOAT_REGS
;
1165 layoutDef
->floatRegsDisplayType
= TUI_SFLOAT_REGS
;
1170 } /* _tuiToggleFloatRegs_command */
1175 _tuiScrollRegsForward_command (
1179 _tuiScrollRegsForward_command (arg
, fromTTY
)
1184 tuiDo ((TuiOpaqueFuncPtr
) tui_vScroll
, FORWARD_SCROLL
, dataWin
, 1);
1187 } /* _tuiScrollRegsForward_command */
1192 _tuiScrollRegsBackward_command (
1196 _tuiScrollRegsBackward_command (arg
, fromTTY
)
1201 tuiDo ((TuiOpaqueFuncPtr
) tui_vScroll
, BACKWARD_SCROLL
, dataWin
, 1);
1204 } /* _tuiScrollRegsBackward_command */