Improve/fix the TUI's current source line highlight
[deliverable/binutils-gdb.git] / gdb / tui / tui-winsource.c
index 96279b746ed863cc1da41338062329fd925a593f..e31a0164cf267729a23434289f7acc49b0940206 100644 (file)
@@ -1,7 +1,6 @@
 /* TUI display source/assembly window.
 
-   Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
-   Foundation, Inc.
+   Copyright (C) 1998-2019 Free Software Foundation, Inc.
 
    Contributed by Hewlett-Packard Company.
 
@@ -9,7 +8,7 @@
 
    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 2 of the License, or
+   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,
@@ -18,9 +17,7 @@
    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, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include <ctype.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"
-
-#ifdef HAVE_NCURSES_H       
-#include <ncurses.h>
-#else
-#ifdef HAVE_CURSES_H
-#include <curses.h>
-#endif
-#endif
+#include "gdb_curses.h"
 
 /* Function to display the "main" routine.  */
 void
@@ -53,19 +46,20 @@ tui_display_main (void)
 {
   if ((tui_source_windows ())->count > 0)
     {
+      struct gdbarch *gdbarch;
       CORE_ADDR addr;
 
-      addr = tui_get_begin_asm_address ();
+      tui_get_begin_asm_address (&gdbarch, &addr);
       if (addr != (CORE_ADDR) 0)
        {
-         struct symtab_and_line sal;
+         struct symtab *s;
 
-         tui_update_source_windows_with_addr (addr);
-         sal = find_pc_line (addr, 0);
-          if (sal.symtab)
-             tui_update_locator_filename (sal.symtab->filename);
+         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_filename ("??");
+             tui_update_locator_fullname ("??");
        }
     }
 }
@@ -75,11 +69,14 @@ tui_display_main (void)
 /* Function to display source in the source window.  This function
    initializes the horizontal scroll to 0.  */
 void
-tui_update_source_window (TuiWinInfoPtr winInfo, struct symtab *s,
-                         TuiLineOrAddress lineOrAddr, int noerror)
+tui_update_source_window (struct tui_win_info *win_info,
+                         struct gdbarch *gdbarch,
+                         struct symtab *s,
+                         struct tui_line_or_address line_or_addr,
+                         int noerror)
 {
-  winInfo->detail.sourceInfo.horizontalOffset = 0;
-  tui_update_source_window_as_is (winInfo, s, lineOrAddr, noerror);
+  win_info->detail.source_info.horizontal_offset = 0;
+  tui_update_source_window_as_is (win_info, gdbarch, s, line_or_addr, noerror);
 
   return;
 }
@@ -88,41 +85,43 @@ tui_update_source_window (TuiWinInfoPtr winInfo, struct symtab *s,
 /* 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 (TuiWinInfoPtr winInfo, struct symtab *s,
-                               TuiLineOrAddress lineOrAddr, int noerror)
+tui_update_source_window_as_is (struct tui_win_info *win_info, 
+                               struct gdbarch *gdbarch,
+                               struct symtab *s,
+                               struct tui_line_or_address line_or_addr, 
+                               int noerror)
 {
-  TuiStatus ret;
+  enum tui_status ret;
 
-  if (winInfo->generic.type == SRC_WIN)
-    ret = tui_set_source_content (s, lineOrAddr.lineNo, noerror);
+  if (win_info->generic.type == SRC_WIN)
+    ret = tui_set_source_content (s, line_or_addr.u.line_no, noerror);
   else
-    ret = tui_set_disassem_content (lineOrAddr.addr);
+    ret = tui_set_disassem_content (gdbarch, line_or_addr.u.addr);
 
   if (ret == TUI_FAILURE)
     {
-      tui_clear_source_content (winInfo, EMPTY_SOURCE_PROMPT);
-      tui_clear_exec_info_content (winInfo);
+      tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
+      tui_clear_exec_info_content (win_info);
     }
   else
     {
-      tui_update_breakpoint_info (winInfo, 0);
-      tui_show_source_content (winInfo);
-      tui_update_exec_info (winInfo);
-      if (winInfo->generic.type == SRC_WIN)
+      tui_update_breakpoint_info (win_info, 0);
+      tui_show_source_content (win_info);
+      tui_update_exec_info (win_info);
+      if (win_info->generic.type == SRC_WIN)
        {
-         struct symtab_and_line sal;
-         
-         sal.line = lineOrAddr.lineNo +
-           (winInfo->generic.contentSize - 2);
+         symtab_and_line sal;
+
+         sal.line = line_or_addr.u.line_no +
+           (win_info->generic.content_size - 2);
          sal.symtab = 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 () == disassemWin &&
-             tui_current_layout () != SRC_DISASSEM_COMMAND)
-           tui_set_win_focus_to (srcWin);
+         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 (TUI_SRC_WIN);
        }
     }
 
@@ -134,26 +133,27 @@ tui_update_source_window_as_is (TuiWinInfoPtr winInfo, struct symtab *s,
 /* Function to ensure that the source and/or disassemly windows
    reflect the input address.  */
 void
-tui_update_source_windows_with_addr (CORE_ADDR addr)
+tui_update_source_windows_with_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
 {
   if (addr != 0)
     {
       struct symtab_and_line sal;
-      TuiLineOrAddress l;
+      struct tui_line_or_address l;
       
       switch (tui_current_layout ())
        {
        case DISASSEM_COMMAND:
        case DISASSEM_DATA_COMMAND:
-         tui_show_disassem (addr);
+         tui_show_disassem (gdbarch, addr);
          break;
        case SRC_DISASSEM_COMMAND:
-         tui_show_disassem_and_update_source (addr);
+         tui_show_disassem_and_update_source (gdbarch, addr);
          break;
        default:
          sal = find_pc_line (addr, 0);
-         l.lineNo = sal.line;
-         tui_show_symtab_source (sal.symtab, l, FALSE);
+         l.loa = LOA_LINE;
+         l.u.line_no = sal.line;
+         tui_show_symtab_source (gdbarch, sal.symtab, l, FALSE);
          break;
        }
     }
@@ -163,38 +163,43 @@ tui_update_source_windows_with_addr (CORE_ADDR addr)
 
       for (i = 0; i < (tui_source_windows ())->count; i++)
        {
-         TuiWinInfoPtr winInfo = (TuiWinInfoPtr) (tui_source_windows ())->list[i];
+         struct tui_win_info *win_info = (tui_source_windows ())->list[i];
 
-         tui_clear_source_content (winInfo, EMPTY_SOURCE_PROMPT);
-         tui_clear_exec_info_content (winInfo);
+         tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
+         tui_clear_exec_info_content (win_info);
        }
     }
-
-  return;
-}                              /* tuiUpdateSourceWindowsWithAddr */
+}
 
 /* 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)
 {
+  struct gdbarch *gdbarch;
   CORE_ADDR pc;
-  TuiLineOrAddress l;
-  
+  struct tui_line_or_address l;
+
+  if (!s)
+    return;
+
+  gdbarch = get_objfile_arch (SYMTAB_OBJFILE (s));
+
   switch (tui_current_layout ())
     {
     case DISASSEM_COMMAND:
     case DISASSEM_DATA_COMMAND:
       find_line_pc (s, line, &pc);
-      tui_update_source_windows_with_addr (pc);
+      tui_update_source_windows_with_addr (gdbarch, pc);
       break;
     default:
-      l.lineNo = line;
-      tui_show_symtab_source (s, l, FALSE);
+      l.loa = LOA_LINE;
+      l.u.line_no = line;
+      tui_show_symtab_source (gdbarch, s, l, FALSE);
       if (tui_current_layout () == SRC_DISASSEM_COMMAND)
        {
          find_line_pc (s, line, &pc);
-         tui_show_disassem (pc);
+         tui_show_disassem (gdbarch, pc);
        }
       break;
     }
@@ -203,188 +208,212 @@ tui_update_source_windows_with_line (struct symtab *s, int line)
 }
 
 void
-tui_clear_source_content (TuiWinInfoPtr winInfo, int displayPrompt)
+tui_clear_source_content (struct tui_win_info *win_info, 
+                         int display_prompt)
 {
-  if (m_winPtrNotNull (winInfo))
+  if (win_info != NULL)
     {
-      register int i;
+      int i;
 
-      winInfo->generic.contentInUse = FALSE;
-      tui_erase_source_content (winInfo, displayPrompt);
-      for (i = 0; i < winInfo->generic.contentSize; i++)
+      win_info->generic.content_in_use = FALSE;
+      tui_erase_source_content (win_info, display_prompt);
+      for (i = 0; i < win_info->generic.content_size; i++)
        {
-         TuiWinElementPtr element =
-         (TuiWinElementPtr) winInfo->generic.content[i];
-         element->whichElement.source.hasBreak = FALSE;
-         element->whichElement.source.isExecPoint = FALSE;
+         struct tui_win_element *element = win_info->generic.content[i];
+
+         element->which_element.source.has_break = FALSE;
+         element->which_element.source.is_exec_point = FALSE;
        }
     }
-
-  return;
-}                              /* tuiClearSourceContent */
+}
 
 
 void
-tui_erase_source_content (TuiWinInfoPtr winInfo, int displayPrompt)
+tui_erase_source_content (struct tui_win_info *win_info, 
+                         int display_prompt)
 {
-  int xPos;
-  int halfWidth = (winInfo->generic.width - 2) / 2;
+  int x_pos;
+  int half_width = (win_info->generic.width - 2) / 2;
 
-  if (winInfo->generic.handle != (WINDOW *) NULL)
+  if (win_info->generic.handle != (WINDOW *) NULL)
     {
-      werase (winInfo->generic.handle);
-      tui_check_and_display_highlight_if_needed (winInfo);
-      if (displayPrompt == EMPTY_SOURCE_PROMPT)
+      werase (win_info->generic.handle);
+      tui_check_and_display_highlight_if_needed (win_info);
+      if (display_prompt == EMPTY_SOURCE_PROMPT)
        {
-         char *noSrcStr;
+         const char *no_src_str;
 
-         if (winInfo->generic.type == SRC_WIN)
-           noSrcStr = NO_SRC_STRING;
+         if (win_info->generic.type == SRC_WIN)
+           no_src_str = NO_SRC_STRING;
          else
-           noSrcStr = NO_DISASSEM_STRING;
-         if (strlen (noSrcStr) >= halfWidth)
-           xPos = 1;
+           no_src_str = NO_DISASSEM_STRING;
+         if (strlen (no_src_str) >= half_width)
+           x_pos = 1;
          else
-           xPos = halfWidth - strlen (noSrcStr);
-         mvwaddstr (winInfo->generic.handle,
-                    (winInfo->generic.height / 2),
-                    xPos,
-                    noSrcStr);
-
-         /* elz: added this function call to set the real contents of
-            the window to what is on the  screen, so that later calls
-            to refresh, do display
-            the correct stuff, and not the old image */
-
-         tui_set_source_content_nil (winInfo, noSrcStr);
+           x_pos = half_width - strlen (no_src_str);
+         mvwaddstr (win_info->generic.handle,
+                    (win_info->generic.height / 2),
+                    x_pos,
+                    (char *) no_src_str);
+
+         /* elz: Added this function call to set the real contents of
+            the window to what is on the screen, so that later calls
+            to refresh, do display the correct stuff, and not the old
+            image.  */
+
+         tui_set_source_content_nil (win_info, no_src_str);
        }
-      tui_refresh_win (&winInfo->generic);
+      tui_refresh_win (&win_info->generic);
     }
-  return;
-}                              /* tuiEraseSourceContent */
+}
 
 
 /* Redraw the complete line of a source or disassembly window.  */
 static void
-tui_show_source_line (TuiWinInfoPtr winInfo, int lineno)
+tui_show_source_line (struct tui_win_info *win_info, int lineno)
 {
-  TuiWinElementPtr line;
-  int x, y;
+  struct tui_win_element *line;
+  int x;
 
-  line = (TuiWinElementPtr) winInfo->generic.content[lineno - 1];
-  if (line->whichElement.source.isExecPoint)
-    wattron (winInfo->generic.handle, A_STANDOUT);
+  line = win_info->generic.content[lineno - 1];
+  if (line->which_element.source.is_exec_point)
+    tui_set_reverse_mode (win_info->generic.handle, true);
 
-  mvwaddstr (winInfo->generic.handle, lineno, 1,
-             line->whichElement.source.line);
-  if (line->whichElement.source.isExecPoint)
-    wattroff (winInfo->generic.handle, A_STANDOUT);
+  wmove (win_info->generic.handle, lineno, 1);
+  tui_puts (line->which_element.source.line,
+           win_info->generic.handle);
+  if (line->which_element.source.is_exec_point)
+    tui_set_reverse_mode (win_info->generic.handle, false);
 
   /* Clear to end of line but stop before the border.  */
-  getyx (winInfo->generic.handle, y, x);
-  while (x + 1 < winInfo->generic.width)
+  x = getcurx (win_info->generic.handle);
+  while (x + 1 < win_info->generic.width)
     {
-      waddch (winInfo->generic.handle, ' ');
-      getyx (winInfo->generic.handle, y, x);
+      waddch (win_info->generic.handle, ' ');
+      x = getcurx (win_info->generic.handle);
     }
 }
 
 void
-tui_show_source_content (TuiWinInfoPtr winInfo)
+tui_show_source_content (struct tui_win_info *win_info)
 {
-  if (winInfo->generic.contentSize > 0)
+  if (win_info->generic.content_size > 0)
     {
       int lineno;
 
-      for (lineno = 1; lineno <= winInfo->generic.contentSize; lineno++)
-        tui_show_source_line (winInfo, lineno);
+      for (lineno = 1; lineno <= win_info->generic.content_size; lineno++)
+        tui_show_source_line (win_info, lineno);
     }
   else
-    tui_erase_source_content (winInfo, TRUE);
+    tui_erase_source_content (win_info, TRUE);
 
-  tui_check_and_display_highlight_if_needed (winInfo);
-  tui_refresh_win (&winInfo->generic);
-  winInfo->generic.contentInUse = TRUE;
+  tui_check_and_display_highlight_if_needed (win_info);
+  tui_refresh_win (&win_info->generic);
+  win_info->generic.content_in_use = TRUE;
 }
 
+/* Refill the source window's source cache and update it.  If WIN_INFO
+   is a disassembly window, then just update it.  */
+
+void
+tui_refill_source_window (struct tui_win_info *win_info)
+{
+  symtab *s = nullptr;
+
+  if (win_info->generic.type == 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);
+    }
+
+  tui_update_source_window_as_is (win_info,
+                                 win_info->detail.source_info.gdbarch,
+                                 s,
+                                 win_info->generic.content[0]
+                                   ->which_element.source.line_or_addr,
+                                 FALSE);
+}
 
 /* Scroll the source forward or backward horizontally.  */
+
 void
-tui_horizontal_source_scroll (TuiWinInfoPtr winInfo,
-                             TuiScrollDirection direction,
-                             int numToScroll)
+tui_horizontal_source_scroll (struct tui_win_info *win_info,
+                             enum tui_scroll_direction direction,
+                             int num_to_scroll)
 {
-  if (winInfo->generic.content != (OpaquePtr) NULL)
+  if (win_info->generic.content != NULL)
     {
       int offset;
-      struct symtab *s;
-      struct symtab_and_line cursal = get_current_source_symtab_and_line ();
-
-      if (cursal.symtab == (struct symtab *) NULL)
-       s = find_pc_symtab (get_frame_pc (deprecated_selected_frame));
-      else
-       s = cursal.symtab;
 
       if (direction == LEFT_SCROLL)
-       offset = winInfo->detail.sourceInfo.horizontalOffset + numToScroll;
+       offset = win_info->detail.source_info.horizontal_offset
+         + num_to_scroll;
       else
        {
-         if ((offset =
-            winInfo->detail.sourceInfo.horizontalOffset - numToScroll) < 0)
+         offset = win_info->detail.source_info.horizontal_offset
+           - num_to_scroll;
+         if (offset < 0)
            offset = 0;
        }
-      winInfo->detail.sourceInfo.horizontalOffset = offset;
-      tui_update_source_window_as_is (winInfo, s,
-                                     ((TuiWinElementPtr)
-                                      winInfo->generic.content[0])->whichElement.source.lineOrAddr,
-                                     FALSE);
+      win_info->detail.source_info.horizontal_offset = offset;
+      tui_refill_source_window (win_info);
     }
+}
 
-  return;
-}                              /* tuiHorizontalSourceScroll */
 
+/* Set or clear the has_break flag in the line whose line is
+   line_no.  */
 
-/* Set or clear the hasBreak flag in the line whose line is lineNo.  */
 void
-tui_set_is_exec_point_at (TuiLineOrAddress l, TuiWinInfoPtr winInfo)
+tui_set_is_exec_point_at (struct tui_line_or_address l, 
+                         struct tui_win_info *win_info)
 {
   int changed = 0;
   int i;
-  TuiWinContent content = (TuiWinContent) winInfo->generic.content;
+  tui_win_content content = win_info->generic.content;
 
   i = 0;
-  while (i < winInfo->generic.contentSize)
+  while (i < win_info->generic.content_size)
     {
-      int newState;
-
-      if (content[i]->whichElement.source.lineOrAddr.addr == l.addr)
-        newState = TRUE;
+      int new_state;
+      struct tui_line_or_address content_loa =
+       content[i]->which_element.source.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)
+              || (content_loa.u.addr == l.u.addr)))
+        new_state = TRUE;
       else
-       newState = FALSE;
-      if (newState != content[i]->whichElement.source.isExecPoint)
+       new_state = FALSE;
+      if (new_state != content[i]->which_element.source.is_exec_point)
         {
           changed++;
-          content[i]->whichElement.source.isExecPoint = newState;
-          tui_show_source_line (winInfo, i + 1);
+          content[i]->which_element.source.is_exec_point = new_state;
+          tui_show_source_line (win_info, i + 1);
         }
       i++;
     }
   if (changed)
-    tui_refresh_win (&winInfo->generic);
+    tui_refill_source_window (win_info);
 }
 
 /* Update the execution windows to show the active breakpoints.
    This is called whenever a breakpoint is inserted, removed or
    has its state changed.  */
 void
-tui_update_all_breakpoint_info ()
+tui_update_all_breakpoint_info (void)
 {
-  TuiList* list = tui_source_windows ();
+  struct tui_list *list = tui_source_windows ();
   int i;
 
   for (i = 0; i < list->count; i++)
     {
-      TuiWinInfoPtr win = (TuiWinInfoPtr) list->list[i];
+      struct tui_win_info *win = list->list[i];
 
       if (tui_update_breakpoint_info (win, FALSE))
         {
@@ -394,26 +423,29 @@ tui_update_all_breakpoint_info ()
 }
 
 
-/* Scan the source window and the breakpoints to update the
-   hasBreak information for each line.
-   Returns 1 if something changed and the execution window
-   must be refreshed.  */
+/* Scan the source window and the breakpoints to update the has_break
+   information for each line.
+
+   Returns 1 if something changed and the execution window must be
+   refreshed.  */
+
 int
-tui_update_breakpoint_info (TuiWinInfoPtr win, int current_only)
+tui_update_breakpoint_info (struct tui_win_info *win, 
+                           int current_only)
 {
   int i;
   int need_refresh = 0;
-  TuiSourceInfoPtr src = &win->detail.sourceInfo;
+  struct tui_source_info *src = &win->detail.source_info;
 
-  for (i = 0; i < win->generic.contentSize; i++)
+  for (i = 0; i < win->generic.content_size; i++)
     {
       struct breakpoint *bp;
       extern struct breakpoint *breakpoint_chain;
       int mode;
-      TuiSourceElement* line;
+      struct tui_source_element *line;
 
-      line = &((TuiWinElementPtr) win->generic.content[i])->whichElement.source;
-      if (current_only && !line->isExecPoint)
+      line = &win->generic.content[i]->which_element.source;
+      if (current_only && !line->is_exec_point)
          continue;
 
       /* Scan each breakpoint to see if the current line has something to
@@ -424,28 +456,39 @@ tui_update_breakpoint_info (TuiWinInfoPtr win, int current_only)
            bp != (struct breakpoint *) NULL;
            bp = bp->next)
         {
-          if ((win == srcWin
-               && bp->source_file
-               && (strcmp (src->filename, bp->source_file) == 0)
-               && bp->line_number == line->lineOrAddr.lineNo)
-              || (win == disassemWin
-                  && bp->loc->address == line->lineOrAddr.addr))
-            {
-              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->cond)
-                mode |= TUI_BP_CONDITIONAL;
-              if (bp->type == bp_hardware_breakpoint)
-                mode |= TUI_BP_HARDWARE;
-            }
+         struct bp_location *loc;
+
+         gdb_assert (line->line_or_addr.loa == LOA_LINE
+                     || line->line_or_addr.loa == LOA_ADDRESS);
+
+         for (loc = bp->loc; loc != NULL; loc = loc->next)
+           {
+             if ((win == TUI_SRC_WIN
+                  && loc->symtab != NULL
+                  && filename_cmp (src->fullname,
+                                   symtab_to_fullname (loc->symtab)) == 0
+                  && line->line_or_addr.loa == LOA_LINE
+                  && loc->line_number == line->line_or_addr.u.line_no)
+                 || (win == TUI_DISASM_WIN
+                     && line->line_or_addr.loa == LOA_ADDRESS
+                     && loc->address == line->line_or_addr.u.addr))
+               {
+                 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;
+               }
+           }
         }
-      if (line->hasBreak != mode)
+      if (line->has_break != mode)
         {
-          line->hasBreak = mode;
+          line->has_break = mode;
           need_refresh = 1;
         }
     }
@@ -453,62 +496,60 @@ tui_update_breakpoint_info (TuiWinInfoPtr win, int current_only)
 }
 
 
-/*
-   ** tuiSetExecInfoContent().
-   **      Function to initialize the content of the execution info window,
-   **      based upon the input window which is either the source or
-   **      disassembly window.
- */
-TuiStatus
-tuiSetExecInfoContent (TuiWinInfoPtr winInfo)
+/* Function to initialize the content of the execution info window,
+   based upon the input window which is either the source or
+   disassembly window.  */
+enum tui_status
+tui_set_exec_info_content (struct tui_win_info *win_info)
 {
-  TuiStatus ret = TUI_SUCCESS;
+  enum tui_status ret = TUI_SUCCESS;
 
-  if (winInfo->detail.sourceInfo.executionInfo != (TuiGenWinInfoPtr) NULL)
+  if (win_info->detail.source_info.execution_info
+      != (struct tui_gen_win_info *) NULL)
     {
-      TuiGenWinInfoPtr execInfoPtr = winInfo->detail.sourceInfo.executionInfo;
+      struct tui_gen_win_info *exec_info_ptr
+       = win_info->detail.source_info.execution_info;
 
-      if (execInfoPtr->content == (OpaquePtr) NULL)
-       execInfoPtr->content =
-         (OpaquePtr) tui_alloc_content (winInfo->generic.height,
-                                        execInfoPtr->type);
-      if (execInfoPtr->content != (OpaquePtr) NULL)
+      if (exec_info_ptr->content == NULL)
+       exec_info_ptr->content =
+         tui_alloc_content (win_info->generic.height, exec_info_ptr->type);
+      if (exec_info_ptr->content != NULL)
        {
          int i;
 
-          tui_update_breakpoint_info (winInfo, 1);
-         for (i = 0; i < winInfo->generic.contentSize; i++)
+          tui_update_breakpoint_info (win_info, 1);
+         for (i = 0; i < win_info->generic.content_size; i++)
            {
-             TuiWinElementPtr element;
-             TuiWinElementPtr srcElement;
+             struct tui_win_element *element;
+             struct tui_win_element *src_element;
               int mode;
 
-             element = (TuiWinElementPtr) execInfoPtr->content[i];
-             srcElement = (TuiWinElementPtr) winInfo->generic.content[i];
+             element = exec_info_ptr->content[i];
+             src_element = win_info->generic.content[i];
 
-              memset(element->whichElement.simpleString, ' ',
-                     sizeof(element->whichElement.simpleString));
-              element->whichElement.simpleString[TUI_EXECINFO_SIZE - 1] = 0;
+              memset(element->which_element.simple_string, ' ',
+                     sizeof(element->which_element.simple_string));
+              element->which_element.simple_string[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 = srcElement->whichElement.source.hasBreak;
+              mode = src_element->which_element.source.has_break;
               if (mode & TUI_BP_HIT)
-                element->whichElement.simpleString[TUI_BP_HIT_POS] =
+                element->which_element.simple_string[TUI_BP_HIT_POS] =
                   (mode & TUI_BP_HARDWARE) ? 'H' : 'B';
               else if (mode & (TUI_BP_ENABLED | TUI_BP_DISABLED))
-                element->whichElement.simpleString[TUI_BP_HIT_POS] =
+                element->which_element.simple_string[TUI_BP_HIT_POS] =
                   (mode & TUI_BP_HARDWARE) ? 'h' : 'b';
 
               if (mode & TUI_BP_ENABLED)
-                element->whichElement.simpleString[TUI_BP_BREAK_POS] = '+';
+                element->which_element.simple_string[TUI_BP_BREAK_POS] = '+';
               else if (mode & TUI_BP_DISABLED)
-                element->whichElement.simpleString[TUI_BP_BREAK_POS] = '-';
+                element->which_element.simple_string[TUI_BP_BREAK_POS] = '-';
 
-              if (srcElement->whichElement.source.isExecPoint)
-                element->whichElement.simpleString[TUI_EXEC_POS] = '>';
+              if (src_element->which_element.source.is_exec_point)
+                element->which_element.simple_string[TUI_EXEC_POS] = '>';
            }
-         execInfoPtr->contentSize = winInfo->generic.contentSize;
+         exec_info_ptr->content_size = win_info->generic.content_size;
        }
       else
        ret = TUI_FAILURE;
@@ -518,154 +559,134 @@ tuiSetExecInfoContent (TuiWinInfoPtr winInfo)
 }
 
 
-/*
-   ** tuiShowExecInfoContent().
- */
 void
-tuiShowExecInfoContent (TuiWinInfoPtr winInfo)
+tui_show_exec_info_content (struct tui_win_info *win_info)
 {
-  TuiGenWinInfoPtr execInfo = winInfo->detail.sourceInfo.executionInfo;
-  int curLine;
-
-  werase (execInfo->handle);
-  tui_refresh_win (execInfo);
-  for (curLine = 1; (curLine <= execInfo->contentSize); curLine++)
-    mvwaddstr (execInfo->handle,
-              curLine,
+  struct tui_gen_win_info *exec_info
+    = win_info->detail.source_info.execution_info;
+  int cur_line;
+
+  werase (exec_info->handle);
+  tui_refresh_win (exec_info);
+  for (cur_line = 1; (cur_line <= exec_info->content_size); cur_line++)
+    mvwaddstr (exec_info->handle,
+              cur_line,
               0,
-              ((TuiWinElementPtr)
-               execInfo->content[curLine - 1])->whichElement.simpleString);
-  tui_refresh_win (execInfo);
-  execInfo->contentInUse = TRUE;
-
-  return;
+              (char *) exec_info->content[cur_line - 1]
+                         ->which_element.simple_string);
+  tui_refresh_win (exec_info);
+  exec_info->content_in_use = TRUE;
 }
 
 
 void
-tui_erase_exec_info_content (TuiWinInfoPtr winInfo)
+tui_erase_exec_info_content (struct tui_win_info *win_info)
 {
-  TuiGenWinInfoPtr execInfo = winInfo->detail.sourceInfo.executionInfo;
+  struct tui_gen_win_info *exec_info
+    = win_info->detail.source_info.execution_info;
 
-  werase (execInfo->handle);
-  tui_refresh_win (execInfo);
-
-  return;
+  werase (exec_info->handle);
+  tui_refresh_win (exec_info);
 }
 
 void
-tui_clear_exec_info_content (TuiWinInfoPtr winInfo)
+tui_clear_exec_info_content (struct tui_win_info *win_info)
 {
-  winInfo->detail.sourceInfo.executionInfo->contentInUse = FALSE;
-  tui_erase_exec_info_content (winInfo);
+  win_info->detail.source_info.execution_info->content_in_use = FALSE;
+  tui_erase_exec_info_content (win_info);
 
   return;
 }
 
 /* Function to update the execution info window.  */
 void
-tui_update_exec_info (TuiWinInfoPtr winInfo)
+tui_update_exec_info (struct tui_win_info *win_info)
 {
-  tuiSetExecInfoContent (winInfo);
-  tuiShowExecInfoContent (winInfo);
-}                              /* tuiUpdateExecInfo */
+  tui_set_exec_info_content (win_info);
+  tui_show_exec_info_content (win_info);
+}
 
 enum tui_status
-tui_alloc_source_buffer (struct tui_win_info *winInfo)
+tui_alloc_source_buffer (struct tui_win_info *win_info)
 {
-  register char *srcLineBuf;
-  register int i, lineWidth, maxLines;
-  TuiStatus ret = TUI_FAILURE;
-
-  maxLines = winInfo->generic.height;  /* less the highlight box */
-  lineWidth = winInfo->generic.width - 1;
-  /*
-     ** Allocate the buffer for the source lines.  Do this only once since they
-     ** will be re-used for all source displays.  The only other time this will
-     ** be done is when a window's size changes.
-   */
-  if (winInfo->generic.content == (OpaquePtr) NULL)
+  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->generic.height - 2;
+  line_width = win_info->generic.width - 2 + 1;
+
+  /* Allocate the buffer for the source lines.  */
+  if (win_info->generic.content == NULL)
     {
-      srcLineBuf = (char *) xmalloc ((maxLines * lineWidth) * sizeof (char));
-      if (srcLineBuf == (char *) NULL)
-       fputs_unfiltered (
-          "Unable to Allocate Memory for Source or Disassembly Display.\n",
-                          gdb_stderr);
-      else
-       {
-         /* allocate the content list */
-         if ((winInfo->generic.content =
-         (OpaquePtr) tui_alloc_content (maxLines, SRC_WIN)) == (OpaquePtr) NULL)
-           {
-             tuiFree (srcLineBuf);
-             srcLineBuf = (char *) NULL;
-             fputs_unfiltered (
-                                "Unable to Allocate Memory for Source or Disassembly Display.\n",
-                                gdb_stderr);
-           }
-       }
-      for (i = 0; i < maxLines; i++)
-       ((TuiWinElementPtr)
-        winInfo->generic.content[i])->whichElement.source.line =
-         srcLineBuf + (lineWidth * i);
-      ret = TUI_SUCCESS;
+      /* Allocate the content list.  */
+      win_info->generic.content = tui_alloc_content (max_lines, SRC_WIN);
+      for (i = 0; i < max_lines; i++)
+       win_info->generic.content[i]->which_element.source.line
+         = (char *) xmalloc (line_width);
     }
-  else
-    ret = TUI_SUCCESS;
 
-  return ret;
-}                              /* tuiAllocSourceBuffer */
+  return TUI_SUCCESS;
+}
 
 
-/* Answer whether the a particular line number or address is displayed
+/* Answer whether a particular line number or address is displayed
    in the current source window.  */
 int
-tui_line_is_displayed (int line, TuiWinInfoPtr winInfo,
-                      int checkThreshold)
+tui_line_is_displayed (int line, 
+                      struct tui_win_info *win_info,
+                      int check_threshold)
 {
-  int isDisplayed = FALSE;
+  int is_displayed = FALSE;
   int i, threshold;
 
-  if (checkThreshold)
+  if (check_threshold)
     threshold = SCROLL_THRESHOLD;
   else
     threshold = 0;
   i = 0;
-  while (i < winInfo->generic.contentSize - threshold && !isDisplayed)
+  while (i < win_info->generic.content_size - threshold
+        && !is_displayed)
     {
-      isDisplayed = (((TuiWinElementPtr)
-                     winInfo->generic.content[i])->whichElement.source.lineOrAddr.lineNo
-                    == (int) line);
+      is_displayed
+       = win_info->generic.content[i]
+           ->which_element.source.line_or_addr.loa == LOA_LINE
+         && win_info->generic.content[i]
+              ->which_element.source.line_or_addr.u.line_no == line;
       i++;
     }
 
-  return isDisplayed;
+  return is_displayed;
 }
 
 
-/* Answer whether the a particular line number or address is displayed
+/* Answer whether a particular line number or address is displayed
    in the current source window.  */
 int
-tui_addr_is_displayed (CORE_ADDR addr, TuiWinInfoPtr winInfo,
-                   int checkThreshold)
+tui_addr_is_displayed (CORE_ADDR addr, 
+                      struct tui_win_info *win_info,
+                      int check_threshold)
 {
-  int isDisplayed = FALSE;
+  int is_displayed = FALSE;
   int i, threshold;
 
-  if (checkThreshold)
+  if (check_threshold)
     threshold = SCROLL_THRESHOLD;
   else
     threshold = 0;
   i = 0;
-  while (i < winInfo->generic.contentSize - threshold && !isDisplayed)
+  while (i < win_info->generic.content_size - threshold
+        && !is_displayed)
     {
-      isDisplayed = (((TuiWinElementPtr)
-                     winInfo->generic.content[i])->whichElement.source.lineOrAddr.addr
-                    == addr);
+      is_displayed
+       = win_info->generic.content[i]
+           ->which_element.source.line_or_addr.loa == LOA_ADDRESS
+         && win_info->generic.content[i]
+              ->which_element.source.line_or_addr.u.addr == addr;
       i++;
     }
 
-  return isDisplayed;
+  return is_displayed;
 }
 
 
This page took 0.038434 seconds and 4 git commands to generate.