X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Ftui%2Ftui-winsource.c;h=db0add996883d416c8e733a492e0bfbe706d2d2d;hb=359157df2087894563a900e5f63299b42f460be2;hp=38d5532912d76bdd5917d1a2ef0236d8eeff83df;hpb=fd6c75eecd92ad888cc369489b31d2ed9015130e;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/tui/tui-winsource.c b/gdb/tui/tui-winsource.c
index 38d5532912..db0add9968 100644
--- a/gdb/tui/tui-winsource.c
+++ b/gdb/tui/tui-winsource.c
@@ -1,6 +1,6 @@
 /* TUI display source/assembly window.
 
-   Copyright (C) 1998-2019 Free Software Foundation, Inc.
+   Copyright (C) 1998-2020 Free Software Foundation, Inc.
 
    Contributed by Hewlett-Packard Company.
 
@@ -44,7 +44,8 @@
 void
 tui_display_main ()
 {
-  if (!tui_source_windows ().empty ())
+  auto adapter = tui_source_windows ();
+  if (adapter.begin () != adapter.end ())
     {
       struct gdbarch *gdbarch;
       CORE_ADDR addr;
@@ -56,246 +57,287 @@ tui_display_main ()
 
 	  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_update_locator_fullname (s);
 	}
     }
 }
 
+/* See tui-winsource.h.  */
 
-
-/* Function to display source in the source window.  This function
-   initializes the horizontal scroll to 0.  */
-void
-tui_update_source_window (struct tui_source_window_base *win_info,
-			  struct gdbarch *gdbarch,
-			  struct symtab *s,
-			  struct tui_line_or_address line_or_addr,
-			  int noerror)
+std::string
+tui_copy_source_line (const char **ptr, int line_no, int first_col,
+		      int line_width, int ndigits)
 {
-  win_info->horizontal_offset = 0;
-  tui_update_source_window_as_is (win_info, gdbarch, s, line_or_addr, noerror);
+  const char *lineptr = *ptr;
 
-  return;
-}
+  /* Init the line with the line number.  */
+  std::string result;
 
-
-/* Function to display source in the source/asm window.  This function
-   shows the source as specified by the horizontal offset.  */
-void
-tui_update_source_window_as_is (struct tui_source_window_base *win_info, 
-				struct gdbarch *gdbarch,
-				struct symtab *s,
-				struct tui_line_or_address line_or_addr, 
-				int noerror)
-{
-  enum tui_status ret;
-
-  if (win_info->type == SRC_WIN)
-    ret = tui_set_source_content (win_info, s, line_or_addr.u.line_no,
-				  noerror);
-  else
-    ret = tui_set_disassem_content (win_info, gdbarch, line_or_addr.u.addr);
-
-  if (ret == TUI_FAILURE)
-    {
-      tui_clear_source_content (win_info);
-      tui_clear_exec_info_content (win_info);
-    }
-  else
+  if (line_no > 0)
     {
-      tui_update_breakpoint_info (win_info, nullptr, false);
-      tui_show_source_content (win_info);
-      tui_update_exec_info (win_info);
-      if (win_info->type == SRC_WIN)
+      if (ndigits > 0)
+	result = string_printf ("%*d ", ndigits, line_no);
+      else
 	{
-	  symtab_and_line sal;
-
-	  sal.line = line_or_addr.u.line_no +
-	    (win_info->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 (win_info);
+	  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;
 
-  return;
-}
+      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;
 
-/* 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)
-{
-  if (addr != 0)
-    {
-      struct symtab_and_line sal;
-      struct tui_line_or_address l;
-      
-      switch (tui_current_layout ())
+      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)
 	{
-	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_show_symtab_source (TUI_SRC_WIN, gdbarch, sal.symtab, l, FALSE);
-	  break;
+	  if (c == '\t')
+	    process_tab ();
+	  continue;
 	}
-    }
-  else
-    {
-      for (struct tui_source_window_base *win_info : tui_source_windows ())
+
+      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)
 	{
-	  tui_clear_source_content (win_info);
-	  tui_clear_exec_info_content (win_info);
+	  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;
 }
 
-/* Function to ensure that the source and/or disassemly windows
-   reflect the input address.  */
 void
-tui_update_source_windows_with_line (struct symtab *s, int line)
+tui_source_window_base::style_changed ()
 {
-  struct gdbarch *gdbarch;
-  CORE_ADDR pc;
-  struct tui_line_or_address l;
+  if (tui_active && is_visible ())
+    refill ();
+}
 
-  if (!s)
-    return;
+/* 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)
+{
+  m_horizontal_offset = 0;
+  update_source_window_as_is (gdbarch, sal);
+}
 
-  gdbarch = get_objfile_arch (SYMTAB_OBJFILE (s));
 
-  switch (tui_current_layout ())
+/* 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
     {
-    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_show_symtab_source (TUI_SRC_WIN, gdbarch, s, l, FALSE);
-      if (tui_current_layout () == SRC_DISASSEM_COMMAND)
-	{
-	  find_line_pc (s, line, &pc);
-	  tui_show_disassem (gdbarch, pc);
-	}
-      break;
+      update_breakpoint_info (nullptr, false);
+      show_source_content ();
+      update_exec_info ();
     }
-
-  return;
 }
 
+
+/* Function to ensure that the source and/or disassemly windows
+   reflect the input address.  */
 void
-tui_clear_source_content (struct tui_source_window_base *win_info)
+tui_update_source_windows_with_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
 {
-  if (win_info != NULL)
-    {
-      int i;
+  struct symtab_and_line sal {};
+  if (addr != 0)
+    sal = find_pc_line (addr, 0);
 
-      tui_erase_source_content (win_info);
-      for (i = 0; i < win_info->content.size (); i++)
-	{
-	  struct tui_source_element *element = &win_info->content[i];
+  for (struct tui_source_window_base *win_info : tui_source_windows ())
+    win_info->update_source_window (gdbarch, sal);
+}
 
-	  element->break_mode = 0;
-	  element->is_exec_point = false;
-	}
+/* 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)
+{
+  struct gdbarch *gdbarch = nullptr;
+  if (sal.symtab != nullptr)
+    {
+      find_line_pc (sal.symtab, sal.line, &sal.pc);
+      gdbarch = SYMTAB_OBJFILE (sal.symtab)->arch ();
     }
-}
 
+  for (struct tui_source_window_base *win_info : tui_source_windows ())
+    win_info->update_source_window (gdbarch, sal);
+}
 
 void
-tui_erase_source_content (struct tui_source_window_base *win_info)
+tui_source_window_base::do_erase_source_content (const char *str)
 {
   int x_pos;
-  int half_width = (win_info->width - 2) / 2;
+  int half_width = (width - 2) / 2;
 
-  if (win_info->handle != NULL)
+  m_content.clear ();
+  if (handle != NULL)
     {
-      werase (win_info->handle);
-      tui_check_and_display_highlight_if_needed (win_info);
-
-      const char *no_src_str;
+      werase (handle.get ());
+      check_and_display_highlight_if_needed ();
 
-      if (win_info->type == SRC_WIN)
-	no_src_str = NO_SRC_STRING;
-      else
-	no_src_str = NO_DISASSEM_STRING;
-      if (strlen (no_src_str) >= half_width)
+      if (strlen (str) >= half_width)
 	x_pos = 1;
       else
-	x_pos = half_width - strlen (no_src_str);
-      mvwaddstr (win_info->handle,
-		 (win_info->height / 2),
+	x_pos = half_width - strlen (str);
+      mvwaddstr (handle.get (),
+		 (height / 2),
 		 x_pos,
-		 (char *) no_src_str);
+		 (char *) str);
 
-      win_info->content.clear ();
-      win_info->refresh_window ();
+      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)
+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 - 1];
   if (line->is_exec_point)
-    tui_set_reverse_mode (win_info->handle, true);
+    tui_set_reverse_mode (handle.get (), true);
 
-  wmove (win_info->handle, lineno, 1);
-  tui_puts (line->line,
-	    win_info->handle);
+  wmove (handle.get (), lineno, TUI_EXECINFO_SIZE);
+  tui_puts (line->line.c_str (), handle.get ());
   if (line->is_exec_point)
-    tui_set_reverse_mode (win_info->handle, false);
+    tui_set_reverse_mode (handle.get (), false);
 
   /* Clear to end of line but stop before the border.  */
-  x = getcurx (win_info->handle);
-  while (x + 1 < win_info->width)
+  x = getcurx (handle.get ());
+  while (x + 1 < width)
     {
-      waddch (win_info->handle, ' ');
-      x = getcurx (win_info->handle);
+      waddch (handle.get (), ' ');
+      x = getcurx (handle.get ());
     }
 }
 
 void
-tui_show_source_content (struct tui_source_window_base *win_info)
+tui_source_window_base::show_source_content ()
+{
+  gdb_assert (!m_content.empty ());
+
+  for (int lineno = 1; lineno <= m_content.size (); lineno++)
+    show_source_line (lineno);
+
+  check_and_display_highlight_if_needed ();
+  refresh_window ();
+}
+
+tui_source_window_base::tui_source_window_base ()
+{
+  m_start_line_or_addr.loa = LOA_ADDRESS;
+  m_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 (!win_info->content.empty ())
+  if (!m_content.empty ())
     {
-      int lineno;
+      struct symtab_and_line cursal
+	= get_current_source_symtab_and_line ();
 
-      for (lineno = 1; lineno <= win_info->content.size (); lineno++)
-        tui_show_source_line (win_info, lineno);
+      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 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 (this != TUI_SRC_WIN)
+	find_line_pc (s, cursal.line, &cursal.pc);
+      update_source_window (gdbarch, cursal);
     }
   else
-    tui_erase_source_content (win_info);
-
-  tui_check_and_display_highlight_if_needed (win_info);
-  win_info->refresh_window ();
+    erase_source_content ();
 }
 
 /* See tui-data.h.  */
@@ -303,19 +345,28 @@ tui_show_source_content (struct tui_source_window_base *win_info)
 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)
+	{
+	  struct frame_info *fi = deprecated_safe_get_selected_frame ();
+	  if (fi != nullptr)
+	    sal = find_pc_line (get_frame_pc (fi), 0);
+	}
     }
 
-  tui_update_source_window_as_is (this, gdbarch, s,
-				  content[0].line_or_addr,
-				  FALSE);
+  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.  */
@@ -323,12 +374,12 @@ tui_source_window_base::refill ()
 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;
+      m_horizontal_offset = offset;
       refill ();
     }
 }
@@ -344,26 +395,23 @@ tui_source_window_base::set_is_exec_point_at (struct tui_line_or_address l)
   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;
       else
 	new_state = false;
-      if (new_state != content[i].is_exec_point)
+      if (new_state != m_content[i].is_exec_point)
         {
           changed = true;
-          content[i].is_exec_point = new_state;
-          tui_show_source_line (this, i + 1);
+          m_content[i].is_exec_point = new_state;
+          show_source_line (i + 1);
         }
       i++;
     }
@@ -378,10 +426,8 @@ tui_update_all_breakpoint_info (struct breakpoint *being_deleted)
 {
   for (tui_source_window_base *win : tui_source_windows ())
     {
-      if (tui_update_breakpoint_info (win, being_deleted, false))
-        {
-          tui_update_exec_info (win);
-        }
+      if (win->update_breakpoint_info (being_deleted, false))
+	win->update_exec_info ();
     }
 }
 
@@ -393,20 +439,17 @@ tui_update_all_breakpoint_info (struct breakpoint *being_deleted)
    refreshed.  */
 
 bool
-tui_update_breakpoint_info (struct tui_source_window_base *win,
-			    struct breakpoint *being_deleted,
-			    bool current_only)
+tui_source_window_base::update_breakpoint_info
+  (struct breakpoint *being_deleted, bool current_only)
 {
   int i;
   bool need_refresh = false;
 
-  for (i = 0; i < win->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 = &win->content[i];
+      line = &m_content[i];
       if (current_only && !line->is_exec_point)
          continue;
 
@@ -414,21 +457,16 @@ tui_update_breakpoint_info (struct tui_source_window_base *win,
          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)
+      iterate_over_breakpoints ([&] (breakpoint *bp) -> bool
         {
 	  struct bp_location *loc;
 
-	  gdb_assert (line->line_or_addr.loa == LOA_LINE
-		      || line->line_or_addr.loa == LOA_ADDRESS);
-
 	  if (bp == being_deleted)
-	    continue;
+	    return false;
 
 	  for (loc = bp->loc; loc != NULL; loc = loc->next)
 	    {
-	      if (win->location_matches_p (loc, i))
+	      if (location_matches_p (loc, i))
 		{
 		  if (bp->enable_state == bp_disabled)
 		    mode |= TUI_BP_DISABLED;
@@ -442,7 +480,8 @@ tui_update_breakpoint_info (struct tui_source_window_base *win,
 		    mode |= TUI_BP_HARDWARE;
 		}
 	    }
-        }
+	  return false;
+        });
       if (line->break_mode != mode)
         {
           line->break_mode = mode;
@@ -452,175 +491,35 @@ tui_update_breakpoint_info (struct tui_source_window_base *win,
   return need_refresh;
 }
 
-/* See tui-data.h.  */
-
-tui_exec_info_content *
-tui_exec_info_window::maybe_allocate_content (int n_elements)
-{
-  if (m_content == nullptr)
-    m_content = XNEWVEC (tui_exec_info_content, n_elements);
-  return m_content;
-}
-
-
 /* 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_set_exec_info_content (struct tui_source_window_base *win_info)
-{
-  if (win_info->execution_info != NULL)
-    {
-      tui_exec_info_content *content
-	= win_info->execution_info->maybe_allocate_content (win_info->height);
-
-      tui_update_breakpoint_info (win_info, nullptr, true);
-      for (int i = 0; i < win_info->content.size (); i++)
-	{
-	  tui_exec_info_content &element = content[i];
-	  struct tui_source_element *src_element;
-	  tui_bp_flags mode;
-
-	  src_element = &win_info->content[i];
-
-	  memset (element, ' ', sizeof (tui_exec_info_content));
-	  element[TUI_EXECINFO_SIZE - 1] = 0;
-
-	  /* Now update the exec info content based upon the state
-	     of each line as indicated by the source content.  */
-	  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] = '>';
-	}
-    }
-}
-
-
-void
-tui_show_exec_info_content (struct tui_source_window_base *win_info)
-{
-  struct tui_exec_info_window *exec_info = win_info->execution_info;
-  const tui_exec_info_content *content = exec_info->get_content ();
-
-  werase (exec_info->handle);
-  for (int cur_line = 1; cur_line <= win_info->content.size (); cur_line++)
-    mvwaddstr (exec_info->handle,
-	       cur_line,
-	       0,
-	       content[cur_line - 1]);
-  exec_info->refresh_window ();
-}
-
-
-void
-tui_erase_exec_info_content (struct tui_source_window_base *win_info)
-{
-  struct tui_gen_win_info *exec_info = win_info->execution_info;
-
-  werase (exec_info->handle);
-  exec_info->refresh_window ();
-}
-
-void
-tui_clear_exec_info_content (struct tui_source_window_base *win_info)
-{
-  tui_erase_exec_info_content (win_info);
-}
-
-/* Function to update the execution info window.  */
-void
-tui_update_exec_info (struct tui_source_window_base *win_info)
-{
-  tui_set_exec_info_content (win_info);
-  tui_show_exec_info_content (win_info);
-}
-
-void
-tui_alloc_source_buffer (struct tui_source_window_base *win_info)
-{
-  int i, line_width, max_lines;
-
-  /* The window width/height includes the highlight box.  Determine actual
-     content dimensions, including string null-terminators.  */
-  max_lines = win_info->height - 2;
-  line_width = win_info->width - 2 + 1;
-
-  /* Allocate the buffer for the source lines.  */
-  win_info->content.resize (max_lines);
-  for (i = 0; i < max_lines; i++)
-    {
-      if (win_info->content[i].line == nullptr)
-	win_info->content[i].line = (char *) xmalloc (line_width);
-    }
-}
-
-
-/* Answer whether a particular line number or address is displayed
-   in the current source window.  */
-int
-tui_line_is_displayed (int line, 
-		       struct tui_source_window_base *win_info,
-		       int check_threshold)
+tui_source_window_base::update_exec_info ()
 {
-  int is_displayed = FALSE;
-  int i, threshold;
-
-  if (check_threshold)
-    threshold = SCROLL_THRESHOLD;
-  else
-    threshold = 0;
-  i = 0;
-  while (i < win_info->content.size () - threshold
-	 && !is_displayed)
+  update_breakpoint_info (nullptr, true);
+  for (int i = 0; i < m_content.size (); i++)
     {
-      is_displayed
-	= win_info->content[i].line_or_addr.loa == LOA_LINE
-	  && win_info->content[i].line_or_addr.u.line_no == line;
-      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
+	 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);
     }
-
-  return is_displayed;
+  refresh_window ();
 }
-
-
-/* Answer whether a particular line number or address is displayed
-   in the current source window.  */
-int
-tui_addr_is_displayed (CORE_ADDR addr, 
-		       struct tui_source_window_base *win_info,
-		       int check_threshold)
-{
-  int is_displayed = FALSE;
-  int i, threshold;
-
-  if (check_threshold)
-    threshold = SCROLL_THRESHOLD;
-  else
-    threshold = 0;
-  i = 0;
-  while (i < win_info->content.size () - threshold
-	 && !is_displayed)
-    {
-      is_displayed
-	= win_info->content[i].line_or_addr.loa == LOA_ADDRESS
-	  && win_info->content[i].line_or_addr.u.addr == addr;
-      i++;
-    }
-
-  return is_displayed;
-}
-
-
-/*****************************************
-** STATIC LOCAL FUNCTIONS               **
-******************************************/