GDB (xrefs)
Loading...
Searching...
No Matches
tui-winsource.c
Go to the documentation of this file.
1/* TUI display source/assembly window.
2
3 Copyright (C) 1998-2023 Free Software Foundation, Inc.
4
5 Contributed by Hewlett-Packard Company.
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21
22#include "defs.h"
23#include <ctype.h>
24#include "symtab.h"
25#include "frame.h"
26#include "breakpoint.h"
27#include "value.h"
28#include "source.h"
29#include "objfiles.h"
30#include "filenames.h"
31#include "safe-ctype.h"
32
33#include "tui/tui.h"
34#include "tui/tui-data.h"
35#include "tui/tui-io.h"
36#include "tui/tui-stack.h"
37#include "tui/tui-win.h"
38#include "tui/tui-wingeneral.h"
39#include "tui/tui-winsource.h"
40#include "tui/tui-source.h"
41#include "tui/tui-disasm.h"
42#include "tui/tui-location.h"
43#include "gdb_curses.h"
44
45/* Function to display the "main" routine. */
46void
48{
49 auto adapter = tui_source_windows ();
50 if (adapter.begin () != adapter.end ())
51 {
52 struct gdbarch *gdbarch;
53 CORE_ADDR addr;
54
56 if (addr != (CORE_ADDR) 0)
57 {
58 struct symtab *s;
59
61 s = find_pc_line_symtab (addr);
63 }
64 }
65}
66
67/* See tui-winsource.h. */
68
69std::string
70tui_copy_source_line (const char **ptr, int *length)
71{
72 const char *lineptr = *ptr;
73
74 /* Init the line with the line number. */
75 std::string result;
76
77 int column = 0;
78 char c;
79 do
80 {
81 int skip_bytes;
82
83 c = *lineptr;
84 if (c == '\033' && skip_ansi_escape (lineptr, &skip_bytes))
85 {
86 /* We always have to preserve escapes. */
87 result.append (lineptr, lineptr + skip_bytes);
88 lineptr += skip_bytes;
89 continue;
90 }
91 if (c == '\0')
92 break;
93
94 ++lineptr;
95 ++column;
96
97 auto process_tab = [&] ()
98 {
99 int max_tab_len = tui_tab_width;
100
101 --column;
102 for (int j = column % max_tab_len;
103 j < max_tab_len;
104 column++, j++)
105 result.push_back (' ');
106 };
107
108 if (c == '\n' || c == '\r' || c == '\0')
109 {
110 /* Nothing. */
111 }
112 else if (c == '\t')
113 process_tab ();
114 else if (ISCNTRL (c))
115 {
116 result.push_back ('^');
117 result.push_back (c + 0100);
118 ++column;
119 }
120 else if (c == 0177)
121 {
122 result.push_back ('^');
123 result.push_back ('?');
124 ++column;
125 }
126 else
127 result.push_back (c);
128 }
129 while (c != '\0' && c != '\n' && c != '\r');
130
131 if (c == '\r' && *lineptr == '\n')
132 ++lineptr;
133 *ptr = lineptr;
134
135 if (length != nullptr)
136 *length = column;
137
138 return result;
139}
140
141void
143{
144 if (tui_active && is_visible ())
145 refill ();
146}
147
148/* Function to display source in the source window. This function
149 initializes the horizontal scroll to 0. */
150void
152 (struct gdbarch *gdbarch,
153 const struct symtab_and_line &sal)
154{
157}
158
159
160/* Function to display source in the source/asm window. This function
161 shows the source as specified by the horizontal offset. */
162void
164 (struct gdbarch *gdbarch,
165 const struct symtab_and_line &sal)
166{
167 bool ret = set_contents (gdbarch, sal);
168
169 if (!ret)
171 else
172 {
173 update_breakpoint_info (nullptr, false);
176 }
177}
178
179
180/* Function to ensure that the source and/or disassemly windows
181 reflect the input address. */
182void
184{
185 struct symtab_and_line sal {};
186 if (addr != 0)
187 sal = find_pc_line (addr, 0);
188
189 for (struct tui_source_window_base *win_info : tui_source_windows ())
190 win_info->update_source_window (gdbarch, sal);
191}
192
193/* Function to ensure that the source and/or disassembly windows
194 reflect the symtab and line. */
195void
197{
198 struct gdbarch *gdbarch = nullptr;
199 if (sal.symtab != nullptr)
200 {
201 find_line_pc (sal.symtab, sal.line, &sal.pc);
202 gdbarch = sal.symtab->compunit ()->objfile ()->arch ();
203 }
204
205 for (struct tui_source_window_base *win_info : tui_source_windows ())
206 win_info->update_source_window (gdbarch, sal);
207}
208
209void
211{
212 int x_pos;
213 int half_width = (width - 2) / 2;
214
215 m_content.clear ();
216 if (handle != NULL)
217 {
218 werase (handle.get ());
220
221 if (strlen (str) >= half_width)
222 x_pos = 1;
223 else
224 x_pos = half_width - strlen (str);
225 mvwaddstr (handle.get (),
226 (height / 2),
227 x_pos,
228 (char *) str);
229
231 }
232}
233
234
235/* Redraw the complete line of a source or disassembly window. */
236void
238{
239 struct tui_source_element *line;
240
241 line = &m_content[lineno];
242 if (line->is_exec_point)
243 tui_set_reverse_mode (m_pad.get (), true);
244
245 wmove (m_pad.get (), lineno, 0);
246 tui_puts (line->line.c_str (), m_pad.get ());
247 if (line->is_exec_point)
248 tui_set_reverse_mode (m_pad.get (), false);
249}
250
251/* See tui-winsource.h. */
252
253void
255{
256 /* tui_win_info::refresh_window would draw the empty background window to
257 the screen, potentially creating a flicker. */
258 wnoutrefresh (handle.get ());
259
260 int pad_width = std::max (m_max_length, width);
261 int left_margin = 1 + TUI_EXECINFO_SIZE + extra_margin ();
262 int view_width = width - left_margin - 1;
263 int pad_x = std::min (pad_width - view_width, m_horizontal_offset);
264 /* Ensure that an equal number of scrolls will work if the user
265 scrolled beyond where we clip. */
266 m_horizontal_offset = pad_x;
267 prefresh (m_pad.get (), 0, pad_x, y + 1, x + left_margin,
268 y + m_content.size (), x + left_margin + view_width - 1);
269}
270
271void
273{
274 gdb_assert (!m_content.empty ());
275
277
278 int pad_width = std::max (m_max_length, width);
279 if (m_pad == nullptr || pad_width > getmaxx (m_pad.get ())
280 || m_content.size () > getmaxy (m_pad.get ()))
281 m_pad.reset (newpad (m_content.size (), pad_width));
282
283 werase (m_pad.get ());
284 for (int lineno = 0; lineno < m_content.size (); lineno++)
285 show_source_line (lineno);
286
288}
289
291{
294
296 (std::bind (&tui_source_window::style_changed, this),
297 m_observable, "tui-winsource");
298}
299
301{
303}
304
305/* See tui-data.h. */
306
307void
309{
310 werase (handle.get ());
311 rerender ();
312}
313
314void
316{
317 if (!m_content.empty ())
318 {
319 struct symtab_and_line cursal
321
324 else
325 cursal.pc = m_start_line_or_addr.u.addr;
327 }
328 else if (deprecated_safe_get_selected_frame () != NULL)
329 {
330 struct symtab_and_line cursal
333 struct gdbarch *gdbarch = get_frame_arch (frame);
334
335 struct symtab *s = find_pc_line_symtab (get_frame_pc (frame));
336 if (this != TUI_SRC_WIN)
337 find_line_pc (s, cursal.line, &cursal.pc);
339 }
340 else
342}
343
344/* See tui-data.h. */
345
346void
348{
349 symtab_and_line sal {};
350
351 if (this == TUI_SRC_WIN)
352 {
354 if (sal.symtab == NULL)
355 {
357 if (fi != nullptr)
358 sal = find_pc_line (get_frame_pc (fi), 0);
359 }
360 }
361
362 if (sal.pspace == nullptr)
363 sal.pspace = current_program_space;
364
366 sal.line = m_start_line_or_addr.u.line_no;
367 else
368 sal.pc = m_start_line_or_addr.u.addr;
369
371}
372
373/* Scroll the source forward or backward horizontally. */
374
375void
377{
378 if (!m_content.empty ())
379 {
380 int offset = m_horizontal_offset + num_to_scroll;
381 if (offset < 0)
382 offset = 0;
383 m_horizontal_offset = offset;
385 }
386}
387
388
389/* Set or clear the is_exec_point flag in the line whose line is
390 line_no. */
391
392void
394{
395 bool changed = false;
396 int i;
397
398 i = 0;
399 while (i < m_content.size ())
400 {
401 bool new_state;
402 struct tui_line_or_address content_loa =
403 m_content[i].line_or_addr;
404
405 if (content_loa.loa == l.loa
406 && ((l.loa == LOA_LINE && content_loa.u.line_no == l.u.line_no)
407 || (l.loa == LOA_ADDRESS && content_loa.u.addr == l.u.addr)))
408 new_state = true;
409 else
410 new_state = false;
411 if (new_state != m_content[i].is_exec_point)
412 {
413 changed = true;
414 m_content[i].is_exec_point = new_state;
415 }
416 i++;
417 }
418 if (changed)
419 refill ();
420}
421
422/* See tui-winsource.h. */
423
424void
426{
428 {
429 if (win->update_breakpoint_info (being_deleted, false))
430 win->update_exec_info ();
431 }
432}
433
434
435/* Scan the source window and the breakpoints to update the break_mode
436 information for each line.
437
438 Returns true if something changed and the execution window must be
439 refreshed. */
440
441bool
443 (struct breakpoint *being_deleted, bool current_only)
444{
445 int i;
446 bool need_refresh = false;
447
448 for (i = 0; i < m_content.size (); i++)
449 {
450 struct tui_source_element *line;
451
452 line = &m_content[i];
453 if (current_only && !line->is_exec_point)
454 continue;
455
456 /* Scan each breakpoint to see if the current line has something to
457 do with it. Identify enable/disabled breakpoints as well as
458 those that we already hit. */
459 tui_bp_flags mode = 0;
460 for (breakpoint *bp : all_breakpoints ())
461 {
462 if (bp == being_deleted)
463 continue;
464
465 for (bp_location *loc : bp->locations ())
466 {
467 if (location_matches_p (loc, i))
468 {
469 if (bp->enable_state == bp_disabled)
470 mode |= TUI_BP_DISABLED;
471 else
472 mode |= TUI_BP_ENABLED;
473 if (bp->hit_count)
474 mode |= TUI_BP_HIT;
475 if (bp->loc->cond)
476 mode |= TUI_BP_CONDITIONAL;
477 if (bp->type == bp_hardware_breakpoint)
478 mode |= TUI_BP_HARDWARE;
479 }
480 }
481 }
482
483 if (line->break_mode != mode)
484 {
485 line->break_mode = mode;
486 need_refresh = true;
487 }
488 }
489 return need_refresh;
490}
491
492/* Function to initialize the content of the execution info window,
493 based upon the input window which is either the source or
494 disassembly window. */
495void
497{
498 update_breakpoint_info (nullptr, true);
499 for (int i = 0; i < m_content.size (); i++)
500 {
501 struct tui_source_element *src_element = &m_content[i];
502 char element[TUI_EXECINFO_SIZE] = " ";
503
504 /* Now update the exec info content based upon the state
505 of each line as indicated by the source content. */
506 tui_bp_flags mode = src_element->break_mode;
507 if (mode & TUI_BP_HIT)
508 element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'H' : 'B';
509 else if (mode & (TUI_BP_ENABLED | TUI_BP_DISABLED))
510 element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'h' : 'b';
511
512 if (mode & TUI_BP_ENABLED)
513 element[TUI_BP_BREAK_POS] = '+';
514 else if (mode & TUI_BP_DISABLED)
515 element[TUI_BP_BREAK_POS] = '-';
516
517 if (src_element->is_exec_point)
518 element[TUI_EXEC_POS] = '>';
519
520 mvwaddstr (handle.get (), i + 1, 1, element);
521
523 }
525}
breakpoint_range all_breakpoints()
Definition: breakpoint.c:629
@ bp_hardware_breakpoint
Definition: breakpoint.h:87
@ bp_disabled
Definition: breakpoint.h:218
frame_info_ptr deprecated_safe_get_selected_frame(void)
Definition: frame.c:1832
CORE_ADDR get_frame_pc(frame_info_ptr frame)
Definition: frame.c:2592
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition: frame.c:2907
observable styling_changed
struct program_space * current_program_space
Definition: progspace.c:39
struct symtab_and_line get_current_source_symtab_and_line(void)
Definition: source.c:238
struct objfile * objfile() const
Definition: symtab.h:1714
struct gdbarch * arch() const
Definition: objfiles.h:482
struct symtab * symtab
Definition: symtab.h:2263
CORE_ADDR pc
Definition: symtab.h:2272
struct compunit_symtab * compunit() const
Definition: symtab.h:1603
enum tui_line_or_address_kind loa
Definition: tui-winsource.h:37
union tui_line_or_address::@187 u
bool set_location(struct gdbarch *gdbarch, const struct symtab_and_line &sal, const char *procname)
Definition: tui-location.c:33
std::string line
Definition: tui-winsource.h:82
tui_bp_flags break_mode
Definition: tui-winsource.h:85
virtual bool set_contents(struct gdbarch *gdbarch, const struct symtab_and_line &sal)=0
void do_erase_source_content(const char *string)
void show_source_line(int lineno)
void do_scroll_horizontal(int num_to_scroll) override
struct tui_line_or_address m_start_line_or_addr
void refresh_window() override
void update_source_window(struct gdbarch *gdbarch, const struct symtab_and_line &sal)
gdb::observers::token m_observable
struct gdbarch * m_gdbarch
virtual void erase_source_content()=0
void update_tab_width() override
std::vector< tui_source_element > m_content
virtual bool location_matches_p(struct bp_location *loc, int line_no)=0
std::unique_ptr< WINDOW, curses_deleter > m_pad
void set_is_exec_point_at(struct tui_line_or_address l)
bool update_breakpoint_info(struct breakpoint *being_deleted, bool current_only)
virtual int extra_margin() const
void update_source_window_as_is(struct gdbarch *gdbarch, const struct symtab_and_line &sal)
void rerender() override
virtual void show_line_number(int offset) const
void check_and_display_highlight_if_needed()
bool is_visible() const
Definition: tui-data.h:97
std::unique_ptr< WINDOW, curses_deleter > handle
Definition: tui-data.h:150
bool find_line_pc(struct symtab *symtab, int line, CORE_ADDR *pc)
Definition: symtab.c:3473
struct symtab * find_pc_line_symtab(CORE_ADDR pc)
Definition: symtab.c:3319
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3297
#define TUI_SRC_WIN
Definition: tui-data.h:186
unsigned int tui_tab_width
Definition: tui-win.c:780
void tui_get_begin_asm_address(struct gdbarch **gdbarch_p, CORE_ADDR *addr_p)
Definition: tui-disasm.c:386
void tui_set_reverse_mode(WINDOW *w, bool reverse)
Definition: tui-io.c:412
void tui_puts(const char *string, WINDOW *w)
Definition: tui-io.c:458
tui_location_tracker tui_location
Definition: tui-location.c:28
void tui_update_all_breakpoint_info(struct breakpoint *being_deleted)
void tui_update_source_windows_with_line(struct symtab_and_line sal)
void tui_update_source_windows_with_addr(struct gdbarch *gdbarch, CORE_ADDR addr)
std::string tui_copy_source_line(const char **ptr, int *length)
Definition: tui-winsource.c:70
void tui_display_main()
Definition: tui-winsource.c:47
#define TUI_BP_HIT_POS
Definition: tui-winsource.h:58
@ LOA_LINE
Definition: tui-winsource.h:30
@ LOA_ADDRESS
Definition: tui-winsource.h:31
#define TUI_EXECINFO_SIZE
Definition: tui-winsource.h:61
#define TUI_EXEC_POS
Definition: tui-winsource.h:60
@ TUI_BP_HARDWARE
Definition: tui-winsource.h:52
@ TUI_BP_HIT
Definition: tui-winsource.h:50
@ TUI_BP_ENABLED
Definition: tui-winsource.h:48
@ TUI_BP_CONDITIONAL
Definition: tui-winsource.h:51
@ TUI_BP_DISABLED
Definition: tui-winsource.h:49
#define TUI_BP_BREAK_POS
Definition: tui-winsource.h:59
bool tui_active
Definition: tui.c:72
bool skip_ansi_escape(const char *buf, int *n_read)
Definition: ui-style.c:395