/* TUI display source/assembly window.
- Copyright (C) 1998-2019 Free Software Foundation, Inc.
+ Copyright (C) 1998-2023 Free Software Foundation, Inc.
Contributed by Hewlett-Packard Company.
#include "source.h"
#include "objfiles.h"
#include "filenames.h"
+#include "safe-ctype.h"
#include "tui/tui.h"
#include "tui/tui-data.h"
#include "tui/tui-winsource.h"
#include "tui/tui-source.h"
#include "tui/tui-disasm.h"
+#include "tui/tui-location.h"
#include "gdb_curses.h"
/* Function to display the "main" routine. */
tui_update_source_windows_with_addr (gdbarch, addr);
s = find_pc_line_symtab (addr);
- if (s != NULL)
- tui_update_locator_fullname (symtab_to_fullname (s));
- else
- tui_update_locator_fullname ("??");
+ tui_location.set_location (s);
}
}
}
+/* See tui-winsource.h. */
+
+std::string
+tui_copy_source_line (const char **ptr, int *length)
+{
+ const char *lineptr = *ptr;
+
+ /* Init the line with the line number. */
+ std::string result;
+
+ int column = 0;
+ char c;
+ do
+ {
+ int skip_bytes;
+
+ c = *lineptr;
+ if (c == '\033' && skip_ansi_escape (lineptr, &skip_bytes))
+ {
+ /* We always have to preserve escapes. */
+ result.append (lineptr, lineptr + skip_bytes);
+ lineptr += skip_bytes;
+ continue;
+ }
+ if (c == '\0')
+ break;
+
+ ++lineptr;
+ ++column;
+
+ auto process_tab = [&] ()
+ {
+ int max_tab_len = tui_tab_width;
+
+ --column;
+ for (int j = column % max_tab_len;
+ j < max_tab_len;
+ column++, j++)
+ result.push_back (' ');
+ };
+
+ if (c == '\n' || c == '\r' || c == '\0')
+ {
+ /* Nothing. */
+ }
+ else if (c == '\t')
+ process_tab ();
+ else if (ISCNTRL (c))
+ {
+ result.push_back ('^');
+ result.push_back (c + 0100);
+ ++column;
+ }
+ else if (c == 0177)
+ {
+ result.push_back ('^');
+ result.push_back ('?');
+ ++column;
+ }
+ else
+ result.push_back (c);
+ }
+ while (c != '\0' && c != '\n' && c != '\r');
+
+ if (c == '\r' && *lineptr == '\n')
+ ++lineptr;
+ *ptr = lineptr;
+ if (length != nullptr)
+ *length = column;
+
+ return result;
+}
+
+void
+tui_source_window_base::style_changed ()
+{
+ if (tui_active && is_visible ())
+ refill ();
+}
/* Function to display source in the source window. This function
initializes the horizontal scroll to 0. */
void
tui_source_window_base::update_source_window
(struct gdbarch *gdbarch,
- struct symtab *s,
- struct tui_line_or_address line_or_addr)
+ const struct symtab_and_line &sal)
{
- horizontal_offset = 0;
- update_source_window_as_is (gdbarch, s, line_or_addr);
+ m_horizontal_offset = 0;
+ update_source_window_as_is (gdbarch, sal);
}
void
tui_source_window_base::update_source_window_as_is
(struct gdbarch *gdbarch,
- struct symtab *s,
- struct tui_line_or_address line_or_addr)
+ const struct symtab_and_line &sal)
{
- enum tui_status ret
- = set_contents (gdbarch, s, line_or_addr);
+ bool ret = set_contents (gdbarch, sal);
- if (ret == TUI_FAILURE)
+ if (!ret)
erase_source_content ();
else
{
update_breakpoint_info (nullptr, false);
show_source_content ();
update_exec_info ();
- if (type == SRC_WIN)
- {
- symtab_and_line sal;
-
- sal.line = line_or_addr.u.line_no + (content.size () - 2);
- sal.symtab = s;
- sal.pspace = SYMTAB_PSPACE (s);
- set_current_source_symtab_and_line (sal);
- /* If the focus was in the asm win, put it in the src win if
- we don't have a split layout. */
- if (tui_win_with_focus () == TUI_DISASM_WIN
- && tui_current_layout () != SRC_DISASSEM_COMMAND)
- tui_set_win_focus_to (this);
- }
}
}
void
tui_update_source_windows_with_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
{
+ struct symtab_and_line sal {};
if (addr != 0)
- {
- struct symtab_and_line sal;
- struct tui_line_or_address l;
-
- switch (tui_current_layout ())
- {
- case DISASSEM_COMMAND:
- case DISASSEM_DATA_COMMAND:
- tui_show_disassem (gdbarch, addr);
- break;
- case SRC_DISASSEM_COMMAND:
- tui_show_disassem_and_update_source (gdbarch, addr);
- break;
- default:
- sal = find_pc_line (addr, 0);
- l.loa = LOA_LINE;
- l.u.line_no = sal.line;
- TUI_SRC_WIN->show_symtab_source (gdbarch, sal.symtab, l);
- break;
- }
- }
- else
- {
- for (struct tui_source_window_base *win_info : tui_source_windows ())
- win_info->erase_source_content ();
- }
+ sal = find_pc_line (addr, 0);
+
+ for (struct tui_source_window_base *win_info : tui_source_windows ())
+ win_info->update_source_window (gdbarch, sal);
}
-/* Function to ensure that the source and/or disassemly windows
- reflect the input address. */
+/* Function to ensure that the source and/or disassembly windows
+ reflect the symtab and line. */
void
-tui_update_source_windows_with_line (struct symtab *s, int line)
+tui_update_source_windows_with_line (struct symtab_and_line sal)
{
- struct gdbarch *gdbarch;
- CORE_ADDR pc;
- struct tui_line_or_address l;
-
- if (!s)
- return;
-
- gdbarch = get_objfile_arch (SYMTAB_OBJFILE (s));
-
- switch (tui_current_layout ())
+ struct gdbarch *gdbarch = nullptr;
+ if (sal.symtab != nullptr)
{
- case DISASSEM_COMMAND:
- case DISASSEM_DATA_COMMAND:
- find_line_pc (s, line, &pc);
- tui_update_source_windows_with_addr (gdbarch, pc);
- break;
- default:
- l.loa = LOA_LINE;
- l.u.line_no = line;
- TUI_SRC_WIN->show_symtab_source (gdbarch, s, l);
- if (tui_current_layout () == SRC_DISASSEM_COMMAND)
- {
- find_line_pc (s, line, &pc);
- tui_show_disassem (gdbarch, pc);
- }
- break;
+ find_line_pc (sal.symtab, sal.line, &sal.pc);
+ gdbarch = sal.symtab->compunit ()->objfile ()->arch ();
}
+
+ for (struct tui_source_window_base *win_info : tui_source_windows ())
+ win_info->update_source_window (gdbarch, sal);
}
void
int x_pos;
int half_width = (width - 2) / 2;
- content.clear ();
+ m_content.clear ();
if (handle != NULL)
{
- werase (handle);
+ werase (handle.get ());
check_and_display_highlight_if_needed ();
if (strlen (str) >= half_width)
x_pos = 1;
else
x_pos = half_width - strlen (str);
- mvwaddstr (handle,
+ mvwaddstr (handle.get (),
(height / 2),
x_pos,
(char *) str);
/* Redraw the complete line of a source or disassembly window. */
-static void
-tui_show_source_line (struct tui_source_window_base *win_info, int lineno)
+void
+tui_source_window_base::show_source_line (int lineno)
{
struct tui_source_element *line;
- int x;
- line = &win_info->content[lineno - 1];
+ line = &m_content[lineno];
if (line->is_exec_point)
- tui_set_reverse_mode (win_info->handle, true);
+ tui_set_reverse_mode (m_pad.get (), true);
- wmove (win_info->handle, lineno, TUI_EXECINFO_SIZE);
- tui_puts (line->line.get (), win_info->handle);
+ wmove (m_pad.get (), lineno, 0);
+ tui_puts (line->line.c_str (), m_pad.get ());
if (line->is_exec_point)
- tui_set_reverse_mode (win_info->handle, false);
+ tui_set_reverse_mode (m_pad.get (), false);
+}
- /* Clear to end of line but stop before the border. */
- x = getcurx (win_info->handle);
- while (x + 1 < win_info->width)
- {
- waddch (win_info->handle, ' ');
- x = getcurx (win_info->handle);
- }
+/* See tui-winsource.h. */
+
+void
+tui_source_window_base::refresh_window ()
+{
+ /* tui_win_info::refresh_window would draw the empty background window to
+ the screen, potentially creating a flicker. */
+ wnoutrefresh (handle.get ());
+
+ int pad_width = std::max (m_max_length, width);
+ int left_margin = 1 + TUI_EXECINFO_SIZE + extra_margin ();
+ int view_width = width - left_margin - 1;
+ int pad_x = std::min (pad_width - view_width, m_horizontal_offset);
+ /* Ensure that an equal number of scrolls will work if the user
+ scrolled beyond where we clip. */
+ m_horizontal_offset = pad_x;
+ prefresh (m_pad.get (), 0, pad_x, y + 1, x + left_margin,
+ y + m_content.size (), x + left_margin + view_width - 1);
}
void
tui_source_window_base::show_source_content ()
{
- if (!content.empty ())
- {
- int lineno;
-
- for (lineno = 1; lineno <= content.size (); lineno++)
- tui_show_source_line (this, lineno);
- }
- else
- erase_source_content ();
+ gdb_assert (!m_content.empty ());
check_and_display_highlight_if_needed ();
+
+ int pad_width = std::max (m_max_length, width);
+ if (m_pad == nullptr || pad_width > getmaxx (m_pad.get ())
+ || m_content.size () > getmaxy (m_pad.get ()))
+ m_pad.reset (newpad (m_content.size (), pad_width));
+
+ werase (m_pad.get ());
+ for (int lineno = 0; lineno < m_content.size (); lineno++)
+ show_source_line (lineno);
+
refresh_window ();
}
-tui_source_window_base::tui_source_window_base (enum tui_win_type type)
- : tui_win_info (type)
+tui_source_window_base::tui_source_window_base ()
{
- gdb_assert (type == SRC_WIN || type == DISASSEM_WIN);
- start_line_or_addr.loa = LOA_ADDRESS;
- start_line_or_addr.u.addr = 0;
-}
+ m_start_line_or_addr.loa = LOA_ADDRESS;
+ m_start_line_or_addr.u.addr = 0;
+ gdb::observers::styling_changed.attach
+ (std::bind (&tui_source_window::style_changed, this),
+ m_observable, "tui-winsource");
+}
tui_source_window_base::~tui_source_window_base ()
{
- xfree (fullname);
-}
+ gdb::observers::styling_changed.detach (m_observable);
+}
/* See tui-data.h. */
void
tui_source_window_base::update_tab_width ()
{
- werase (handle);
+ werase (handle.get ());
rerender ();
}
void
tui_source_window_base::rerender ()
{
- if (!content.empty ())
+ if (!m_content.empty ())
{
- struct tui_line_or_address line_or_addr;
struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
- line_or_addr = start_line_or_addr;
- update_source_window (gdbarch, cursal.symtab, line_or_addr);
+ if (m_start_line_or_addr.loa == LOA_LINE)
+ cursal.line = m_start_line_or_addr.u.line_no;
+ else
+ cursal.pc = m_start_line_or_addr.u.addr;
+ update_source_window (m_gdbarch, cursal);
}
else if (deprecated_safe_get_selected_frame () != NULL)
{
- struct tui_line_or_address line;
struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
- struct frame_info *frame = deprecated_safe_get_selected_frame ();
+ frame_info_ptr frame = deprecated_safe_get_selected_frame ();
struct gdbarch *gdbarch = get_frame_arch (frame);
struct symtab *s = find_pc_line_symtab (get_frame_pc (frame));
- if (type == SRC_WIN)
- {
- line.loa = LOA_LINE;
- line.u.line_no = cursal.line;
- }
- else
- {
- line.loa = LOA_ADDRESS;
- find_line_pc (s, cursal.line, &line.u.addr);
- }
- update_source_window (gdbarch, s, line);
+ if (this != TUI_SRC_WIN)
+ find_line_pc (s, cursal.line, &cursal.pc);
+ update_source_window (gdbarch, cursal);
}
else
erase_source_content ();
void
tui_source_window_base::refill ()
{
- symtab *s = nullptr;
+ symtab_and_line sal {};
- if (type == SRC_WIN)
+ if (this == TUI_SRC_WIN)
{
- symtab_and_line cursal = get_current_source_symtab_and_line ();
- s = (cursal.symtab == NULL
- ? find_pc_line_symtab (get_frame_pc (get_selected_frame (NULL)))
- : cursal.symtab);
+ sal = get_current_source_symtab_and_line ();
+ if (sal.symtab == NULL)
+ {
+ frame_info_ptr fi = deprecated_safe_get_selected_frame ();
+ if (fi != nullptr)
+ sal = find_pc_line (get_frame_pc (fi), 0);
+ }
}
- update_source_window_as_is (gdbarch, s, content[0].line_or_addr);
+ if (sal.pspace == nullptr)
+ sal.pspace = current_program_space;
+
+ if (m_start_line_or_addr.loa == LOA_LINE)
+ sal.line = m_start_line_or_addr.u.line_no;
+ else
+ sal.pc = m_start_line_or_addr.u.addr;
+
+ update_source_window_as_is (m_gdbarch, sal);
}
/* Scroll the source forward or backward horizontally. */
void
tui_source_window_base::do_scroll_horizontal (int num_to_scroll)
{
- if (!content.empty ())
+ if (!m_content.empty ())
{
- int offset = horizontal_offset + num_to_scroll;
+ int offset = m_horizontal_offset + num_to_scroll;
if (offset < 0)
offset = 0;
- horizontal_offset = offset;
- refill ();
+ m_horizontal_offset = offset;
+ refresh_window ();
}
}
int i;
i = 0;
- while (i < content.size ())
+ while (i < m_content.size ())
{
bool new_state;
struct tui_line_or_address content_loa =
- content[i].line_or_addr;
+ m_content[i].line_or_addr;
- gdb_assert (l.loa == LOA_ADDRESS || l.loa == LOA_LINE);
- gdb_assert (content_loa.loa == LOA_LINE
- || content_loa.loa == LOA_ADDRESS);
if (content_loa.loa == l.loa
&& ((l.loa == LOA_LINE && content_loa.u.line_no == l.u.line_no)
- || (l.loa == LOA_ADDRESS && content_loa.u.addr == l.u.addr)))
- new_state = true;
+ || (l.loa == LOA_ADDRESS && content_loa.u.addr == l.u.addr)))
+ new_state = true;
else
new_state = false;
- if (new_state != content[i].is_exec_point)
- {
- changed = true;
- content[i].is_exec_point = new_state;
- tui_show_source_line (this, i + 1);
- }
+ if (new_state != m_content[i].is_exec_point)
+ {
+ changed = true;
+ m_content[i].is_exec_point = new_state;
+ }
i++;
}
if (changed)
int i;
bool need_refresh = false;
- for (i = 0; i < content.size (); i++)
+ for (i = 0; i < m_content.size (); i++)
{
- struct breakpoint *bp;
- extern struct breakpoint *breakpoint_chain;
struct tui_source_element *line;
- line = &content[i];
+ line = &m_content[i];
if (current_only && !line->is_exec_point)
- continue;
+ continue;
/* Scan each breakpoint to see if the current line has something to
- do with it. Identify enable/disabled breakpoints as well as
- those that we already hit. */
+ do with it. Identify enable/disabled breakpoints as well as
+ those that we already hit. */
tui_bp_flags mode = 0;
- for (bp = breakpoint_chain;
- bp != NULL;
- bp = bp->next)
- {
- struct bp_location *loc;
-
- gdb_assert (line->line_or_addr.loa == LOA_LINE
- || line->line_or_addr.loa == LOA_ADDRESS);
-
+ for (breakpoint *bp : all_breakpoints ())
+ {
if (bp == being_deleted)
continue;
- for (loc = bp->loc; loc != NULL; loc = loc->next)
+ for (bp_location *loc : bp->locations ())
{
if (location_matches_p (loc, i))
{
mode |= TUI_BP_HARDWARE;
}
}
- }
+ }
+
if (line->break_mode != mode)
- {
- line->break_mode = mode;
- need_refresh = true;
- }
+ {
+ line->break_mode = mode;
+ need_refresh = true;
+ }
}
return need_refresh;
}
tui_source_window_base::update_exec_info ()
{
update_breakpoint_info (nullptr, true);
- for (int i = 0; i < content.size (); i++)
+ for (int i = 0; i < m_content.size (); i++)
{
- struct tui_source_element *src_element = &content[i];
+ struct tui_source_element *src_element = &m_content[i];
char element[TUI_EXECINFO_SIZE] = " ";
/* Now update the exec info content based upon the state
if (src_element->is_exec_point)
element[TUI_EXEC_POS] = '>';
- mvwaddstr (handle, i + 1, 1, element);
+ mvwaddstr (handle.get (), i + 1, 1, element);
+
+ show_line_number (i);
}
refresh_window ();
}
projects / binutils-gdb.git / blobdiff