[deliverable/binutils-gdb.git] / gdb / tui / tui-winsource.c

/* TUI display source/assembly window.

   Copyright (C) 1998-2020 Free Software Foundation, Inc.

   Contributed by Hewlett-Packard Company.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include <ctype.h>
#include "symtab.h"
#include "frame.h"
#include "breakpoint.h"
#include "value.h"
#include "source.h"
#include "objfiles.h"
#include "filenames.h"

#include "tui/tui.h"
#include "tui/tui-data.h"
#include "tui/tui-io.h"
#include "tui/tui-stack.h"
#include "tui/tui-win.h"
#include "tui/tui-wingeneral.h"
#include "tui/tui-winsource.h"
#include "tui/tui-source.h"
#include "tui/tui-disasm.h"
#include "gdb_curses.h"

/* Function to display the "main" routine.  */
void
tui_display_main ()
{
  auto adapter = tui_source_windows ();
  if (adapter.begin () != adapter.end ())
    {
      struct gdbarch *gdbarch;
      CORE_ADDR addr;

      tui_get_begin_asm_address (&gdbarch, &addr);
      if (addr != (CORE_ADDR) 0)
	{
	  struct symtab *s;

	  tui_update_source_windows_with_addr (gdbarch, addr);
	  s = find_pc_line_symtab (addr);
	  tui_update_locator_fullname (s);
	}
    }
}

/* See tui-winsource.h.  */

std::string
tui_copy_source_line (const char **ptr, int line_no, int first_col,
		      int line_width, int ndigits)
{
  const char *lineptr = *ptr;

  /* Init the line with the line number.  */
  std::string result;

  if (line_no > 0)
    {
      if (ndigits > 0)
	result = string_printf ("%*d ", ndigits, line_no);
      else
	{
	  result = string_printf ("%-6d", line_no);
	  int len = result.size ();
	  len = len - ((len / tui_tab_width) * tui_tab_width);
	  result.append (len, ' ');
	}
    }

  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 < first_col + line_width;
	       column++, j++)
	    if (column >= first_col)
	      result.push_back (' ');
	};

      /* We have to process all the text in order to pick up all the
	 escapes.  */
      if (column <= first_col || column > first_col + line_width)
	{
	  if (c == '\t')
	    process_tab ();
	  continue;
	}

      if (c == '\n' || c == '\r' || c == '\0')
	{
	  /* Nothing.  */
	}
      else if (c < 040 && c != '\t')
	{
	  result.push_back ('^');
	  result.push_back (c + 0100);
	}
      else if (c == 0177)
	{
	  result.push_back ('^');
	  result.push_back ('?');
	}
      else if (c == '\t')
	process_tab ();
      else
	result.push_back (c);
    }
  while (c != '\0' && c != '\n' && c != '\r');

  if (c == '\r' && *lineptr == '\n')
    ++lineptr;
  *ptr = lineptr;

  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,
   const struct symtab_and_line &sal)
{
  horizontal_offset = 0;
  update_source_window_as_is (gdbarch, sal);
}


/* Function to display source in the source/asm window.  This function
   shows the source as specified by the horizontal offset.  */
void
tui_source_window_base::update_source_window_as_is
  (struct gdbarch *gdbarch,
   const struct symtab_and_line &sal)
{
  bool ret = set_contents (gdbarch, sal);

  if (!ret)
    erase_source_content ();
  else
    {
      update_breakpoint_info (nullptr, false);
      show_source_content ();
      update_exec_info ();
    }
}


/* Function to ensure that the source and/or disassemly windows
   reflect the input address.  */
void
tui_update_source_windows_with_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
{
  struct symtab_and_line sal {};
  if (addr != 0)
    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 disassembly windows
   reflect the symtab and line.  */
void
tui_update_source_windows_with_line (struct symtab_and_line sal)
{
  if (!sal.symtab)
    return;

  find_line_pc (sal.symtab, sal.line, &sal.pc);
  struct gdbarch *gdbarch = get_objfile_arch (SYMTAB_OBJFILE (sal.symtab));

  for (struct tui_source_window_base *win_info : tui_source_windows ())
    win_info->update_source_window (gdbarch, sal);
}

void
tui_source_window_base::do_erase_source_content (const char *str)
{
  int x_pos;
  int half_width = (width - 2) / 2;

  content.clear ();
  if (handle != NULL)
    {
      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.get (),
		 (height / 2),
		 x_pos,
		 (char *) str);

      refresh_window ();
    }
}


/* 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)
{
  struct tui_source_element *line;
  int x;

  line = &win_info->content[lineno - 1];
  if (line->is_exec_point)
    tui_set_reverse_mode (win_info->handle.get (), true);

  wmove (win_info->handle.get (), lineno, TUI_EXECINFO_SIZE);
  tui_puts (line->line.c_str (), win_info->handle.get ());
  if (line->is_exec_point)
    tui_set_reverse_mode (win_info->handle.get (), false);

  /* Clear to end of line but stop before the border.  */
  x = getcurx (win_info->handle.get ());
  while (x + 1 < win_info->width)
    {
      waddch (win_info->handle.get (), ' ');
      x = getcurx (win_info->handle.get ());
    }
}

void
tui_source_window_base::show_source_content ()
{
  gdb_assert (!content.empty ());

  for (int lineno = 1; lineno <= content.size (); lineno++)
    tui_show_source_line (this, lineno);

  check_and_display_highlight_if_needed ();
  refresh_window ();
}

tui_source_window_base::tui_source_window_base (enum tui_win_type type)
  : tui_win_info (type)
{
  gdb_assert (type == SRC_WIN || type == DISASSEM_WIN);
  start_line_or_addr.loa = LOA_ADDRESS;
  start_line_or_addr.u.addr = 0;

  gdb::observers::source_styling_changed.attach
    (std::bind (&tui_source_window::style_changed, this),
     m_observable);
}

tui_source_window_base::~tui_source_window_base ()
{
  gdb::observers::source_styling_changed.detach (m_observable);
}

/* See tui-data.h.  */

void
tui_source_window_base::update_tab_width ()
{
  werase (handle.get ());
  rerender ();
}

void
tui_source_window_base::rerender ()
{
  if (!content.empty ())
    {
      struct symtab_and_line cursal
	= get_current_source_symtab_and_line ();

      if (start_line_or_addr.loa == LOA_LINE)
	cursal.line = start_line_or_addr.u.line_no;
      else
	cursal.pc = start_line_or_addr.u.addr;
      update_source_window (gdbarch, cursal);
    }
  else if (deprecated_safe_get_selected_frame () != NULL)
    {
      struct symtab_and_line cursal
	= get_current_source_symtab_and_line ();
      struct frame_info *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)
	find_line_pc (s, cursal.line, &cursal.pc);
      update_source_window (gdbarch, cursal);
    }
  else
    erase_source_content ();
}

/* See tui-data.h.  */

void
tui_source_window_base::refill ()
{
  symtab_and_line sal {};

  if (type == SRC_WIN)
    {
      sal = get_current_source_symtab_and_line ();
      if (sal.symtab == NULL)
	{
	  struct frame_info *fi = deprecated_safe_get_selected_frame ();
	  if (fi != nullptr)
	    sal = find_pc_line (get_frame_pc (fi), 0);
	}
    }

  if (sal.pspace == nullptr)
    sal.pspace = current_program_space;

  if (start_line_or_addr.loa == LOA_LINE)
    sal.line = start_line_or_addr.u.line_no;
  else
    sal.pc = start_line_or_addr.u.addr;

  update_source_window_as_is (gdbarch, sal);
}

/* Scroll the source forward or backward horizontally.  */

void
tui_source_window_base::do_scroll_horizontal (int num_to_scroll)
{
  if (!content.empty ())
    {
      int offset = horizontal_offset + num_to_scroll;
      if (offset < 0)
	offset = 0;
      horizontal_offset = offset;
      refill ();
    }
}


/* Set or clear the is_exec_point flag in the line whose line is
   line_no.  */

void
tui_source_window_base::set_is_exec_point_at (struct tui_line_or_address l)
{
  bool changed = false;
  int i;

  i = 0;
  while (i < content.size ())
    {
      bool new_state;
      struct tui_line_or_address content_loa =
	content[i].line_or_addr;

      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;
      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);
        }
      i++;
    }
  if (changed)
    refill ();
}

/* See tui-winsource.h.  */

void
tui_update_all_breakpoint_info (struct breakpoint *being_deleted)
{
  for (tui_source_window_base *win : tui_source_windows ())
    {
      if (win->update_breakpoint_info (being_deleted, false))
	win->update_exec_info ();
    }
}


/* Scan the source window and the breakpoints to update the break_mode
   information for each line.

   Returns true if something changed and the execution window must be
   refreshed.  */

bool
tui_source_window_base::update_breakpoint_info
  (struct breakpoint *being_deleted, bool current_only)
{
  int i;
  bool need_refresh = false;

  for (i = 0; i < content.size (); i++)
    {
      struct tui_source_element *line;

      line = &content[i];
      if (current_only && !line->is_exec_point)
         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.  */
      tui_bp_flags mode = 0;
      iterate_over_breakpoints ([&] (breakpoint *bp) -> bool
        {
	  struct bp_location *loc;

	  if (bp == being_deleted)
	    return false;

	  for (loc = bp->loc; loc != NULL; loc = loc->next)
	    {
	      if (location_matches_p (loc, i))
		{
		  if (bp->enable_state == bp_disabled)
		    mode |= TUI_BP_DISABLED;
		  else
		    mode |= TUI_BP_ENABLED;
		  if (bp->hit_count)
		    mode |= TUI_BP_HIT;
		  if (bp->loc->cond)
		    mode |= TUI_BP_CONDITIONAL;
		  if (bp->type == bp_hardware_breakpoint)
		    mode |= TUI_BP_HARDWARE;
		}
	    }
	  return false;
        });
      if (line->break_mode != mode)
        {
          line->break_mode = mode;
          need_refresh = true;
        }
    }
  return need_refresh;
}

/* Function to initialize the content of the execution info window,
   based upon the input window which is either the source or
   disassembly window.  */
void
tui_source_window_base::update_exec_info ()
{
  update_breakpoint_info (nullptr, true);
  for (int i = 0; i < content.size (); i++)
    {
      struct tui_source_element *src_element = &content[i];
      char element[TUI_EXECINFO_SIZE] = "   ";

      /* Now update the exec info content based upon the state
	 of each line as indicated by the source content.  */
      tui_bp_flags mode = src_element->break_mode;
      if (mode & TUI_BP_HIT)
	element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'H' : 'B';
      else if (mode & (TUI_BP_ENABLED | TUI_BP_DISABLED))
	element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'h' : 'b';

      if (mode & TUI_BP_ENABLED)
	element[TUI_BP_BREAK_POS] = '+';
      else if (mode & TUI_BP_DISABLED)
	element[TUI_BP_BREAK_POS] = '-';

      if (src_element->is_exec_point)
	element[TUI_EXEC_POS] = '>';

      mvwaddstr (handle.get (), i + 1, 1, element);
    }
  refresh_window ();
}
Commit	Line	Data
	1	/* TUI display source/assembly window.
	2
	3	Copyright (C) 1998-2020 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
	32	#include "tui/tui.h"
	33	#include "tui/tui-data.h"
	34	#include "tui/tui-io.h"
	35	#include "tui/tui-stack.h"
	36	#include "tui/tui-win.h"
	37	#include "tui/tui-wingeneral.h"
	38	#include "tui/tui-winsource.h"
	39	#include "tui/tui-source.h"
	40	#include "tui/tui-disasm.h"
	41	#include "gdb_curses.h"
	42
	43	/* Function to display the "main" routine. */
	44	void
	45	tui_display_main ()
	46	{
	47	auto adapter = tui_source_windows ();
	48	if (adapter.begin () != adapter.end ())
	49	{
	50	struct gdbarch *gdbarch;
	51	CORE_ADDR addr;
	52
	53	tui_get_begin_asm_address (&gdbarch, &addr);
	54	if (addr != (CORE_ADDR) 0)
	55	{
	56	struct symtab *s;
	57
	58	tui_update_source_windows_with_addr (gdbarch, addr);
	59	s = find_pc_line_symtab (addr);
	60	tui_update_locator_fullname (s);
	61	}
	62	}
	63	}
	64
	65	/* See tui-winsource.h. */
	66
	67	std::string
	68	tui_copy_source_line (const char **ptr, int line_no, int first_col,
	69	int line_width, int ndigits)
	70	{
	71	const char lineptr = ptr;
	72
	73	/* Init the line with the line number. */
	74	std::string result;
	75
	76	if (line_no > 0)
	77	{
	78	if (ndigits > 0)
	79	result = string_printf ("%*d ", ndigits, line_no);
	80	else
	81	{
	82	result = string_printf ("%-6d", line_no);
	83	int len = result.size ();
	84	len = len - ((len / tui_tab_width) * tui_tab_width);
	85	result.append (len, ' ');
	86	}
	87	}
	88
	89	int column = 0;
	90	char c;
	91	do
	92	{
	93	int skip_bytes;
	94
	95	c = *lineptr;
	96	if (c == '\033' && skip_ansi_escape (lineptr, &skip_bytes))
	97	{
	98	/* We always have to preserve escapes. */
	99	result.append (lineptr, lineptr + skip_bytes);
	100	lineptr += skip_bytes;
	101	continue;
	102	}
	103	if (c == '\0')
	104	break;
	105
	106	++lineptr;
	107	++column;
	108
	109	auto process_tab = [&] ()
	110	{
	111	int max_tab_len = tui_tab_width;
	112
	113	--column;
	114	for (int j = column % max_tab_len;
	115	j < max_tab_len && column < first_col + line_width;
	116	column++, j++)
	117	if (column >= first_col)
	118	result.push_back (' ');
	119	};
	120
	121	/* We have to process all the text in order to pick up all the
	122	escapes. */
	123	if (column <= first_col \|\| column > first_col + line_width)
	124	{
	125	if (c == '\t')
	126	process_tab ();
	127	continue;
	128	}
	129
	130	if (c == '\n' \|\| c == '\r' \|\| c == '\0')
	131	{
	132	/* Nothing. */
	133	}
	134	else if (c < 040 && c != '\t')
	135	{
	136	result.push_back ('^');
	137	result.push_back (c + 0100);
	138	}
	139	else if (c == 0177)
	140	{
	141	result.push_back ('^');
	142	result.push_back ('?');
	143	}
	144	else if (c == '\t')
	145	process_tab ();
	146	else
	147	result.push_back (c);
	148	}
	149	while (c != '\0' && c != '\n' && c != '\r');
	150
	151	if (c == '\r' && *lineptr == '\n')
	152	++lineptr;
	153	*ptr = lineptr;
	154
	155	return result;
	156	}
	157
	158	void
	159	tui_source_window_base::style_changed ()
	160	{
	161	if (tui_active && is_visible ())
	162	refill ();
	163	}
	164
	165	/* Function to display source in the source window. This function
	166	initializes the horizontal scroll to 0. */
	167	void
	168	tui_source_window_base::update_source_window
	169	(struct gdbarch *gdbarch,
	170	const struct symtab_and_line &sal)
	171	{
	172	horizontal_offset = 0;
	173	update_source_window_as_is (gdbarch, sal);
	174	}
	175
	176
	177	/* Function to display source in the source/asm window. This function
	178	shows the source as specified by the horizontal offset. */
	179	void
	180	tui_source_window_base::update_source_window_as_is
	181	(struct gdbarch *gdbarch,
	182	const struct symtab_and_line &sal)
	183	{
	184	bool ret = set_contents (gdbarch, sal);
	185
	186	if (!ret)
	187	erase_source_content ();
	188	else
	189	{
	190	update_breakpoint_info (nullptr, false);
	191	show_source_content ();
	192	update_exec_info ();
	193	}
	194	}
	195
	196
	197	/* Function to ensure that the source and/or disassemly windows
	198	reflect the input address. */
	199	void
	200	tui_update_source_windows_with_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
	201	{
	202	struct symtab_and_line sal {};
	203	if (addr != 0)
	204	sal = find_pc_line (addr, 0);
	205
	206	for (struct tui_source_window_base *win_info : tui_source_windows ())
	207	win_info->update_source_window (gdbarch, sal);
	208	}
	209
	210	/* Function to ensure that the source and/or disassembly windows
	211	reflect the symtab and line. */
	212	void
	213	tui_update_source_windows_with_line (struct symtab_and_line sal)
	214	{
	215	if (!sal.symtab)
	216	return;
	217
	218	find_line_pc (sal.symtab, sal.line, &sal.pc);
	219	struct gdbarch *gdbarch = get_objfile_arch (SYMTAB_OBJFILE (sal.symtab));
	220
	221	for (struct tui_source_window_base *win_info : tui_source_windows ())
	222	win_info->update_source_window (gdbarch, sal);
	223	}
	224
	225	void
	226	tui_source_window_base::do_erase_source_content (const char *str)
	227	{
	228	int x_pos;
	229	int half_width = (width - 2) / 2;
	230
	231	content.clear ();
	232	if (handle != NULL)
	233	{
	234	werase (handle.get ());
	235	check_and_display_highlight_if_needed ();
	236
	237	if (strlen (str) >= half_width)
	238	x_pos = 1;
	239	else
	240	x_pos = half_width - strlen (str);
	241	mvwaddstr (handle.get (),
	242	(height / 2),
	243	x_pos,
	244	(char *) str);
	245
	246	refresh_window ();
	247	}
	248	}
	249
	250
	251	/* Redraw the complete line of a source or disassembly window. */
	252	static void
	253	tui_show_source_line (struct tui_source_window_base *win_info, int lineno)
	254	{
	255	struct tui_source_element *line;
	256	int x;
	257
	258	line = &win_info->content[lineno - 1];
	259	if (line->is_exec_point)
	260	tui_set_reverse_mode (win_info->handle.get (), true);
	261
	262	wmove (win_info->handle.get (), lineno, TUI_EXECINFO_SIZE);
	263	tui_puts (line->line.c_str (), win_info->handle.get ());
	264	if (line->is_exec_point)
	265	tui_set_reverse_mode (win_info->handle.get (), false);
	266
	267	/* Clear to end of line but stop before the border. */
	268	x = getcurx (win_info->handle.get ());
	269	while (x + 1 < win_info->width)
	270	{
	271	waddch (win_info->handle.get (), ' ');
	272	x = getcurx (win_info->handle.get ());
	273	}
	274	}
	275
	276	void
	277	tui_source_window_base::show_source_content ()
	278	{
	279	gdb_assert (!content.empty ());
	280
	281	for (int lineno = 1; lineno <= content.size (); lineno++)
	282	tui_show_source_line (this, lineno);
	283
	284	check_and_display_highlight_if_needed ();
	285	refresh_window ();
	286	}
	287
	288	tui_source_window_base::tui_source_window_base (enum tui_win_type type)
	289	: tui_win_info (type)
	290	{
	291	gdb_assert (type == SRC_WIN \|\| type == DISASSEM_WIN);
	292	start_line_or_addr.loa = LOA_ADDRESS;
	293	start_line_or_addr.u.addr = 0;
	294
	295	gdb::observers::source_styling_changed.attach
	296	(std::bind (&tui_source_window::style_changed, this),
	297	m_observable);
	298	}
	299
	300	tui_source_window_base::~tui_source_window_base ()
	301	{
	302	gdb::observers::source_styling_changed.detach (m_observable);
	303	}
	304
	305	/* See tui-data.h. */
	306
	307	void
	308	tui_source_window_base::update_tab_width ()
	309	{
	310	werase (handle.get ());
	311	rerender ();
	312	}
	313
	314	void
	315	tui_source_window_base::rerender ()
	316	{
	317	if (!content.empty ())
	318	{
	319	struct symtab_and_line cursal
	320	= get_current_source_symtab_and_line ();
	321
	322	if (start_line_or_addr.loa == LOA_LINE)
	323	cursal.line = start_line_or_addr.u.line_no;
	324	else
	325	cursal.pc = start_line_or_addr.u.addr;
	326	update_source_window (gdbarch, cursal);
	327	}
	328	else if (deprecated_safe_get_selected_frame () != NULL)
	329	{
	330	struct symtab_and_line cursal
	331	= get_current_source_symtab_and_line ();
	332	struct frame_info *frame = deprecated_safe_get_selected_frame ();
	333	struct gdbarch *gdbarch = get_frame_arch (frame);
	334
	335	struct symtab *s = find_pc_line_symtab (get_frame_pc (frame));
	336	if (type != SRC_WIN)
	337	find_line_pc (s, cursal.line, &cursal.pc);
	338	update_source_window (gdbarch, cursal);
	339	}
	340	else
	341	erase_source_content ();
	342	}
	343
	344	/* See tui-data.h. */
	345
	346	void
	347	tui_source_window_base::refill ()
	348	{
	349	symtab_and_line sal {};
	350
	351	if (type == SRC_WIN)
	352	{
	353	sal = get_current_source_symtab_and_line ();
	354	if (sal.symtab == NULL)
	355	{
	356	struct frame_info *fi = deprecated_safe_get_selected_frame ();
	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
	365	if (start_line_or_addr.loa == LOA_LINE)
	366	sal.line = start_line_or_addr.u.line_no;
	367	else
	368	sal.pc = start_line_or_addr.u.addr;
	369
	370	update_source_window_as_is (gdbarch, sal);
	371	}
	372
	373	/* Scroll the source forward or backward horizontally. */
	374
	375	void
	376	tui_source_window_base::do_scroll_horizontal (int num_to_scroll)
	377	{
	378	if (!content.empty ())
	379	{
	380	int offset = horizontal_offset + num_to_scroll;
	381	if (offset < 0)
	382	offset = 0;
	383	horizontal_offset = offset;
	384	refill ();
	385	}
	386	}
	387
	388
	389	/* Set or clear the is_exec_point flag in the line whose line is
	390	line_no. */
	391
	392	void
	393	tui_source_window_base::set_is_exec_point_at (struct tui_line_or_address l)
	394	{
	395	bool changed = false;
	396	int i;
	397
	398	i = 0;
	399	while (i < content.size ())
	400	{
	401	bool new_state;
	402	struct tui_line_or_address content_loa =
	403	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 != content[i].is_exec_point)
	412	{
	413	changed = true;
	414	content[i].is_exec_point = new_state;
	415	tui_show_source_line (this, i + 1);
	416	}
	417	i++;
	418	}
	419	if (changed)
	420	refill ();
	421	}
	422
	423	/* See tui-winsource.h. */
	424
	425	void
	426	tui_update_all_breakpoint_info (struct breakpoint *being_deleted)
	427	{
	428	for (tui_source_window_base *win : tui_source_windows ())
	429	{
	430	if (win->update_breakpoint_info (being_deleted, false))
	431	win->update_exec_info ();
	432	}
	433	}
	434
	435
	436	/* Scan the source window and the breakpoints to update the break_mode
	437	information for each line.
	438
	439	Returns true if something changed and the execution window must be
	440	refreshed. */
	441
	442	bool
	443	tui_source_window_base::update_breakpoint_info
	444	(struct breakpoint *being_deleted, bool current_only)
	445	{
	446	int i;
	447	bool need_refresh = false;
	448
	449	for (i = 0; i < content.size (); i++)
	450	{
	451	struct tui_source_element *line;
	452
	453	line = &content[i];
	454	if (current_only && !line->is_exec_point)
	455	continue;
	456
	457	/* Scan each breakpoint to see if the current line has something to
	458	do with it. Identify enable/disabled breakpoints as well as
	459	those that we already hit. */
	460	tui_bp_flags mode = 0;
	461	iterate_over_breakpoints ([&] (breakpoint *bp) -> bool
	462	{
	463	struct bp_location *loc;
	464
	465	if (bp == being_deleted)
	466	return false;
	467
	468	for (loc = bp->loc; loc != NULL; loc = loc->next)
	469	{
	470	if (location_matches_p (loc, i))
	471	{
	472	if (bp->enable_state == bp_disabled)
	473	mode \|= TUI_BP_DISABLED;
	474	else
	475	mode \|= TUI_BP_ENABLED;
	476	if (bp->hit_count)
	477	mode \|= TUI_BP_HIT;
	478	if (bp->loc->cond)
	479	mode \|= TUI_BP_CONDITIONAL;
	480	if (bp->type == bp_hardware_breakpoint)
	481	mode \|= TUI_BP_HARDWARE;
	482	}
	483	}
	484	return false;
	485	});
	486	if (line->break_mode != mode)
	487	{
	488	line->break_mode = mode;
	489	need_refresh = true;
	490	}
	491	}
	492	return need_refresh;
	493	}
	494
	495	/* Function to initialize the content of the execution info window,
	496	based upon the input window which is either the source or
	497	disassembly window. */
	498	void
	499	tui_source_window_base::update_exec_info ()
	500	{
	501	update_breakpoint_info (nullptr, true);
	502	for (int i = 0; i < content.size (); i++)
	503	{
	504	struct tui_source_element *src_element = &content[i];
	505	char element[TUI_EXECINFO_SIZE] = " ";
	506
	507	/* Now update the exec info content based upon the state
	508	of each line as indicated by the source content. */
	509	tui_bp_flags mode = src_element->break_mode;
	510	if (mode & TUI_BP_HIT)
	511	element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'H' : 'B';
	512	else if (mode & (TUI_BP_ENABLED \| TUI_BP_DISABLED))
	513	element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'h' : 'b';
	514
	515	if (mode & TUI_BP_ENABLED)
	516	element[TUI_BP_BREAK_POS] = '+';
	517	else if (mode & TUI_BP_DISABLED)
	518	element[TUI_BP_BREAK_POS] = '-';
	519
	520	if (src_element->is_exec_point)
	521	element[TUI_EXEC_POS] = '>';
	522
	523	mvwaddstr (handle.get (), i + 1, 1, element);
	524	}
	525	refresh_window ();
	526	}