1 /* TUI display registers in window.
3 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
4 Free Software Foundation, Inc.
6 Contributed by Hewlett-Packard Company.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor,
23 Boston, MA 02110-1301, USA. */
27 #include "tui/tui-data.h"
35 #include "gdb_string.h"
36 #include "tui/tui-layout.h"
37 #include "tui/tui-win.h"
38 #include "tui/tui-windata.h"
39 #include "tui/tui-wingeneral.h"
40 #include "tui/tui-file.h"
41 #include "reggroups.h"
43 #include "gdb_curses.h"
46 /*****************************************
47 ** STATIC LOCAL FUNCTIONS FORWARD DECLS **
48 ******************************************/
50 tui_display_register (struct tui_data_element
*data
,
51 struct tui_gen_win_info
*win_info
);
53 static enum tui_status
54 tui_show_register_group (struct gdbarch
*gdbarch
, struct reggroup
*group
,
55 struct frame_info
*frame
, int refresh_values_only
);
57 static enum tui_status
58 tui_get_register (struct gdbarch
*gdbarch
, struct frame_info
*frame
,
59 struct tui_data_element
*data
, int regnum
, int *changedp
);
60 static void tui_register_format
61 (struct gdbarch
*, struct frame_info
*, struct tui_data_element
*, int);
62 static void tui_scroll_regs_forward_command (char *, int);
63 static void tui_scroll_regs_backward_command (char *, int);
67 /*****************************************
68 ** PUBLIC FUNCTIONS **
69 ******************************************/
71 /* Answer the number of the last line in the regs display. If there
72 are no registers (-1) is returned. */
74 tui_last_regs_line_no (void)
78 if (TUI_DATA_WIN
->detail
.data_display_info
.regs_content_count
> 0)
80 num_lines
= (TUI_DATA_WIN
->detail
.data_display_info
.regs_content_count
/
81 TUI_DATA_WIN
->detail
.data_display_info
.regs_column_count
);
82 if (TUI_DATA_WIN
->detail
.data_display_info
.regs_content_count
%
83 TUI_DATA_WIN
->detail
.data_display_info
.regs_column_count
)
90 /* Answer the line number that the register element at element_no is
91 on. If element_no is greater than the number of register elements
92 there are, -1 is returned. */
94 tui_line_from_reg_element_no (int element_no
)
96 if (element_no
< TUI_DATA_WIN
->detail
.data_display_info
.regs_content_count
)
104 (TUI_DATA_WIN
->detail
.data_display_info
.regs_column_count
* i
))
117 /* Answer the index of the first element in line_no. If line_no is past
118 the register area (-1) is returned. */
120 tui_first_reg_element_no_inline (int line_no
)
122 if ((line_no
* TUI_DATA_WIN
->detail
.data_display_info
.regs_column_count
)
123 <= TUI_DATA_WIN
->detail
.data_display_info
.regs_content_count
)
124 return ((line_no
+ 1) *
125 TUI_DATA_WIN
->detail
.data_display_info
.regs_column_count
) -
126 TUI_DATA_WIN
->detail
.data_display_info
.regs_column_count
;
132 /* Answer the index of the last element in line_no. If line_no is
133 past the register area (-1) is returned. */
135 tui_last_reg_element_no_in_line (int line_no
)
137 if ((line_no
* TUI_DATA_WIN
->detail
.data_display_info
.regs_column_count
) <=
138 TUI_DATA_WIN
->detail
.data_display_info
.regs_content_count
)
139 return ((line_no
+ 1) *
140 TUI_DATA_WIN
->detail
.data_display_info
.regs_column_count
) - 1;
145 /* Show the registers of the given group in the data window
146 and refresh the window. */
148 tui_show_registers (struct reggroup
*group
)
150 enum tui_status ret
= TUI_FAILURE
;
151 struct tui_data_info
*display_info
;
153 /* Make sure the curses mode is enabled. */
156 /* Make sure the register window is visible. If not, select an
157 appropriate layout. */
158 if (TUI_DATA_WIN
== NULL
|| !TUI_DATA_WIN
->generic
.is_visible
)
159 tui_set_layout_for_display_command (DATA_NAME
);
161 display_info
= &TUI_DATA_WIN
->detail
.data_display_info
;
163 group
= general_reggroup
;
165 /* Say that registers should be displayed, even if there is a problem. */
166 display_info
->display_regs
= TRUE
;
168 if (target_has_registers
&& target_has_stack
&& target_has_memory
)
170 ret
= tui_show_register_group (current_gdbarch
, group
,
171 get_current_frame (),
172 group
== display_info
->current_group
);
174 if (ret
== TUI_FAILURE
)
176 display_info
->current_group
= 0;
177 tui_erase_data_content (NO_REGS_STRING
);
183 /* Clear all notation of changed values */
184 for (i
= 0; i
< display_info
->regs_content_count
; i
++)
186 struct tui_gen_win_info
*data_item_win
;
187 struct tui_win_element
*win
;
189 data_item_win
= &display_info
->regs_content
[i
]
190 ->which_element
.data_window
;
191 win
= (struct tui_win_element
*) data_item_win
->content
[0];
192 win
->which_element
.data
.highlight
= FALSE
;
194 display_info
->current_group
= group
;
195 tui_display_all_data ();
200 /* Set the data window to display the registers of the register group
201 using the given frame. Values are refreshed only when refresh_values_only
204 static enum tui_status
205 tui_show_register_group (struct gdbarch
*gdbarch
, struct reggroup
*group
,
206 struct frame_info
*frame
, int refresh_values_only
)
208 enum tui_status ret
= TUI_FAILURE
;
210 int allocated_here
= FALSE
;
213 struct tui_data_info
*display_info
= &TUI_DATA_WIN
->detail
.data_display_info
;
215 /* Make a new title showing which group we display. */
216 snprintf (title
, sizeof (title
) - 1, "Register group: %s",
217 reggroup_name (group
));
218 xfree (TUI_DATA_WIN
->generic
.title
);
219 TUI_DATA_WIN
->generic
.title
= xstrdup (title
);
221 /* See how many registers must be displayed. */
223 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
225 /* Must be in the group and have a name. */
226 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
)
227 && gdbarch_register_name (gdbarch
, regnum
) != 0)
231 if (display_info
->regs_content_count
> 0 && !refresh_values_only
)
233 tui_free_data_content (display_info
->regs_content
,
234 display_info
->regs_content_count
);
235 display_info
->regs_content_count
= 0;
238 if (display_info
->regs_content_count
<= 0)
240 display_info
->regs_content
= tui_alloc_content (nr_regs
, DATA_WIN
);
241 allocated_here
= TRUE
;
242 refresh_values_only
= FALSE
;
245 if (display_info
->regs_content
!= (tui_win_content
) NULL
)
247 if (!refresh_values_only
|| allocated_here
)
249 TUI_DATA_WIN
->generic
.content
= (void*) NULL
;
250 TUI_DATA_WIN
->generic
.content_size
= 0;
251 tui_add_content_elements (&TUI_DATA_WIN
->generic
, nr_regs
);
252 display_info
->regs_content
253 = (tui_win_content
) TUI_DATA_WIN
->generic
.content
;
254 display_info
->regs_content_count
= nr_regs
;
257 /* Now set the register names and values */
259 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
261 struct tui_gen_win_info
*data_item_win
;
262 struct tui_data_element
*data
;
265 if (!gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
268 name
= gdbarch_register_name (gdbarch
, regnum
);
273 &display_info
->regs_content
[pos
]->which_element
.data_window
;
275 &((struct tui_win_element
*) data_item_win
->content
[0])->which_element
.data
;
278 if (!refresh_values_only
)
280 data
->item_no
= regnum
;
282 data
->highlight
= FALSE
;
284 if (data
->value
== (void*) NULL
)
285 data
->value
= (void*) xmalloc (MAX_REGISTER_SIZE
);
287 tui_get_register (gdbarch
, frame
, data
, regnum
, 0);
292 TUI_DATA_WIN
->generic
.content_size
=
293 display_info
->regs_content_count
+ display_info
->data_content_count
;
300 /* Function to display the registers in the content from
301 'start_element_no' until the end of the register content or the end
302 of the display height. No checking for displaying past the end of
303 the registers is done here. */
305 tui_display_registers_from (int start_element_no
)
307 struct tui_data_info
*display_info
= &TUI_DATA_WIN
->detail
.data_display_info
;
309 if (display_info
->regs_content
!= (tui_win_content
) NULL
&&
310 display_info
->regs_content_count
> 0)
312 int i
= start_element_no
;
313 int j
, value_chars_wide
, item_win_width
, cur_y
;
316 for (i
= 0; i
< display_info
->regs_content_count
; i
++)
318 struct tui_data_element
*data
;
319 struct tui_gen_win_info
*data_item_win
;
323 data_item_win
= &display_info
->regs_content
[i
]->which_element
.data_window
;
324 data
= &((struct tui_win_element
*)
325 data_item_win
->content
[0])->which_element
.data
;
332 len
= 8 * ((len
/ 8) + 1);
340 item_win_width
= max_len
+ 1;
341 i
= start_element_no
;
343 display_info
->regs_column_count
=
344 (TUI_DATA_WIN
->generic
.width
- 2) / item_win_width
;
345 if (display_info
->regs_column_count
== 0)
346 display_info
->regs_column_count
= 1;
348 (TUI_DATA_WIN
->generic
.width
- 2) / display_info
->regs_column_count
;
351 ** Now create each data "sub" window, and write the display into it.
354 while (i
< display_info
->regs_content_count
&&
355 cur_y
<= TUI_DATA_WIN
->generic
.viewport_height
)
358 (j
< display_info
->regs_column_count
&&
359 i
< display_info
->regs_content_count
); j
++)
361 struct tui_gen_win_info
* data_item_win
;
362 struct tui_data_element
* data_element_ptr
;
364 /* create the window if necessary */
365 data_item_win
= &display_info
->regs_content
[i
]
366 ->which_element
.data_window
;
367 data_element_ptr
= &((struct tui_win_element
*)
368 data_item_win
->content
[0])->which_element
.data
;
369 if (data_item_win
->handle
!= (WINDOW
*) NULL
370 && (data_item_win
->height
!= 1
371 || data_item_win
->width
!= item_win_width
372 || data_item_win
->origin
.x
!= (item_win_width
* j
) + 1
373 || data_item_win
->origin
.y
!= cur_y
))
375 tui_delete_win (data_item_win
->handle
);
376 data_item_win
->handle
= 0;
379 if (data_item_win
->handle
== (WINDOW
*) NULL
)
381 data_item_win
->height
= 1;
382 data_item_win
->width
= item_win_width
;
383 data_item_win
->origin
.x
= (item_win_width
* j
) + 1;
384 data_item_win
->origin
.y
= cur_y
;
385 tui_make_window (data_item_win
, DONT_BOX_WINDOW
);
386 scrollok (data_item_win
->handle
, FALSE
);
388 touchwin (data_item_win
->handle
);
390 /* Get the printable representation of the register
392 tui_display_register (data_element_ptr
, data_item_win
);
393 i
++; /* next register */
395 cur_y
++; /* next row; */
401 /* Function to display the registers in the content from
402 'start_element_no' on 'start_line_no' until the end of the register
403 content or the end of the display height. This function checks
404 that we won't display off the end of the register display. */
406 tui_display_reg_element_at_line (int start_element_no
, int start_line_no
)
408 if (TUI_DATA_WIN
->detail
.data_display_info
.regs_content
!= (tui_win_content
) NULL
&&
409 TUI_DATA_WIN
->detail
.data_display_info
.regs_content_count
> 0)
411 int element_no
= start_element_no
;
413 if (start_element_no
!= 0 && start_line_no
!= 0)
415 int last_line_no
, first_line_on_last_page
;
417 last_line_no
= tui_last_regs_line_no ();
418 first_line_on_last_page
= last_line_no
- (TUI_DATA_WIN
->generic
.height
- 2);
419 if (first_line_on_last_page
< 0)
420 first_line_on_last_page
= 0;
422 ** If there is no other data displayed except registers,
423 ** and the element_no causes us to scroll past the end of the
424 ** registers, adjust what element to really start the display at.
426 if (TUI_DATA_WIN
->detail
.data_display_info
.data_content_count
<= 0 &&
427 start_line_no
> first_line_on_last_page
)
428 element_no
= tui_first_reg_element_no_inline (first_line_on_last_page
);
430 tui_display_registers_from (element_no
);
436 /* Function to display the registers starting at line line_no in the
437 data window. Answers the line number that the display actually
438 started from. If nothing is displayed (-1) is returned. */
440 tui_display_registers_from_line (int line_no
, int force_display
)
442 if (TUI_DATA_WIN
->detail
.data_display_info
.regs_content_count
> 0)
444 int line
, element_no
;
448 else if (force_display
)
450 ** If we must display regs (force_display is true), then make
451 ** sure that we don't display off the end of the registers.
453 if (line_no
>= tui_last_regs_line_no ())
455 if ((line
= tui_line_from_reg_element_no (
456 TUI_DATA_WIN
->detail
.data_display_info
.regs_content_count
- 1)) < 0)
465 element_no
= tui_first_reg_element_no_inline (line
);
466 if (element_no
< TUI_DATA_WIN
->detail
.data_display_info
.regs_content_count
)
467 tui_display_reg_element_at_line (element_no
, line
);
474 return (-1); /* nothing was displayed */
478 /* This function check all displayed registers for changes in values,
479 given a particular frame. If the values have changed, they are
480 updated with the new value and highlighted. */
482 tui_check_register_values (struct frame_info
*frame
)
484 if (TUI_DATA_WIN
!= NULL
&& TUI_DATA_WIN
->generic
.is_visible
)
486 struct tui_data_info
*display_info
487 = &TUI_DATA_WIN
->detail
.data_display_info
;
489 if (display_info
->regs_content_count
<= 0 && display_info
->display_regs
)
490 tui_show_registers (display_info
->current_group
);
495 for (i
= 0; (i
< display_info
->regs_content_count
); i
++)
497 struct tui_data_element
*data
;
498 struct tui_gen_win_info
*data_item_win_ptr
;
501 data_item_win_ptr
= &display_info
->regs_content
[i
]->
502 which_element
.data_window
;
503 data
= &((struct tui_win_element
*)
504 data_item_win_ptr
->content
[0])->which_element
.data
;
505 was_hilighted
= data
->highlight
;
507 tui_get_register (current_gdbarch
, frame
, data
,
508 data
->item_no
, &data
->highlight
);
510 if (data
->highlight
|| was_hilighted
)
512 tui_display_register (data
, data_item_win_ptr
);
519 /* Display a register in a window. If hilite is TRUE,
520 then the value will be displayed in reverse video */
522 tui_display_register (struct tui_data_element
*data
,
523 struct tui_gen_win_info
*win_info
)
525 if (win_info
->handle
!= (WINDOW
*) NULL
)
530 wstandout (win_info
->handle
);
532 wmove (win_info
->handle
, 0, 0);
533 for (i
= 1; i
< win_info
->width
; i
++)
534 waddch (win_info
->handle
, ' ');
535 wmove (win_info
->handle
, 0, 0);
537 waddstr (win_info
->handle
, data
->content
);
540 wstandend (win_info
->handle
);
541 tui_refresh_win (win_info
);
546 tui_reg_next_command (char *arg
, int from_tty
)
548 if (TUI_DATA_WIN
!= 0)
550 struct reggroup
*group
551 = TUI_DATA_WIN
->detail
.data_display_info
.current_group
;
553 group
= reggroup_next (current_gdbarch
, group
);
555 group
= reggroup_next (current_gdbarch
, 0);
558 tui_show_registers (group
);
563 tui_reg_float_command (char *arg
, int from_tty
)
565 tui_show_registers (float_reggroup
);
569 tui_reg_general_command (char *arg
, int from_tty
)
571 tui_show_registers (general_reggroup
);
575 tui_reg_system_command (char *arg
, int from_tty
)
577 tui_show_registers (system_reggroup
);
580 static struct cmd_list_element
*tuireglist
;
583 tui_reg_command (char *args
, int from_tty
)
585 printf_unfiltered (_("\"tui reg\" must be followed by the name of a "
586 "tui reg command.\n"));
587 help_list (tuireglist
, "tui reg ", -1, gdb_stdout
);
591 _initialize_tui_regs (void)
593 struct cmd_list_element
**tuicmd
;
595 tuicmd
= tui_get_cmd_list ();
597 add_prefix_cmd ("reg", class_tui
, tui_reg_command
,
598 _("TUI commands to control the register window."),
599 &tuireglist
, "tui reg ", 0,
602 add_cmd ("float", class_tui
, tui_reg_float_command
,
603 _("Display only floating point registers."),
605 add_cmd ("general", class_tui
, tui_reg_general_command
,
606 _("Display only general registers."),
608 add_cmd ("system", class_tui
, tui_reg_system_command
,
609 _("Display only system registers."),
611 add_cmd ("next", class_tui
, tui_reg_next_command
,
612 _("Display next register group."),
617 add_com ("fr", class_tui
, tui_reg_float_command
,
618 _("Display only floating point registers\n"));
619 add_com ("gr", class_tui
, tui_reg_general_command
,
620 _("Display only general registers\n"));
621 add_com ("sr", class_tui
, tui_reg_system_command
,
622 _("Display only special registers\n"));
623 add_com ("+r", class_tui
, tui_scroll_regs_forward_command
,
624 _("Scroll the registers window forward\n"));
625 add_com ("-r", class_tui
, tui_scroll_regs_backward_command
,
626 _("Scroll the register window backward\n"));
631 /*****************************************
632 ** STATIC LOCAL FUNCTIONS **
633 ******************************************/
635 extern int pagination_enabled
;
638 tui_restore_gdbout (void *ui
)
640 ui_file_delete (gdb_stdout
);
641 gdb_stdout
= (struct ui_file
*) ui
;
642 pagination_enabled
= 1;
645 /* Get the register from the frame and make a printable representation
646 of it in the data element. */
648 tui_register_format (struct gdbarch
*gdbarch
, struct frame_info
*frame
,
649 struct tui_data_element
*data_element
, int regnum
)
651 struct ui_file
*stream
;
652 struct ui_file
*old_stdout
;
654 struct cleanup
*cleanups
;
657 struct type
*type
= gdbarch_register_type (gdbarch
, regnum
);
659 name
= gdbarch_register_name (gdbarch
, regnum
);
665 pagination_enabled
= 0;
666 old_stdout
= gdb_stdout
;
667 stream
= tui_sfileopen (256);
669 cleanups
= make_cleanup (tui_restore_gdbout
, (void*) old_stdout
);
670 if (TYPE_VECTOR (type
) != 0 && 0)
672 gdb_byte buf
[MAX_REGISTER_SIZE
];
675 len
= register_size (current_gdbarch
, regnum
);
676 fprintf_filtered (stream
, "%-14s ", name
);
677 get_frame_register (frame
, regnum
, buf
);
678 print_scalar_formatted (buf
, type
, 'f', len
, stream
);
682 gdbarch_print_registers_info (current_gdbarch
, stream
,
686 /* Save formatted output in the buffer. */
687 p
= tui_file_get_strbuf (stream
);
689 /* Remove the possible \n. */
690 s
= strrchr (p
, '\n');
694 xfree (data_element
->content
);
695 data_element
->content
= xstrdup (p
);
696 do_cleanups (cleanups
);
699 /* Get the register value from the given frame and format it for
700 the display. When changep is set, check if the new register value
701 has changed with respect to the previous call. */
702 static enum tui_status
703 tui_get_register (struct gdbarch
*gdbarch
, struct frame_info
*frame
,
704 struct tui_data_element
*data
, int regnum
, int *changedp
)
706 enum tui_status ret
= TUI_FAILURE
;
710 if (target_has_registers
)
712 gdb_byte buf
[MAX_REGISTER_SIZE
];
714 get_frame_register (frame
, regnum
, buf
);
715 /* NOTE: cagney/2003-03-13: This is bogus. It is refering to
716 the register cache and not the frame which could have pulled
717 the register value off the stack. */
718 if (register_cached (regnum
) >= 0)
722 int size
= register_size (gdbarch
, regnum
);
723 char *old
= (char*) data
->value
;
726 for (i
= 0; i
< size
; i
++)
727 if (buf
[i
] != old
[i
])
734 /* Reformat the data content if the value changed. */
735 if (changedp
== 0 || *changedp
== TRUE
)
736 tui_register_format (gdbarch
, frame
, data
, regnum
);
744 tui_scroll_regs_forward_command (char *arg
, int from_tty
)
746 tui_scroll (FORWARD_SCROLL
, TUI_DATA_WIN
, 1);
751 tui_scroll_regs_backward_command (char *arg
, int from_tty
)
753 tui_scroll (BACKWARD_SCROLL
, TUI_DATA_WIN
, 1);