X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Ftui%2Ftui-winsource.c;h=ee6827ea047775955408e86a970fa0b7c5fa9ba8;hb=56d397a3824d826cdbaa02dba633bd86da6308c5;hp=96279b746ed863cc1da41338062329fd925a593f;hpb=dd1abb8c9ec3fa79e36e4e14033f4309741442c1;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/tui/tui-winsource.c b/gdb/tui/tui-winsource.c
index 96279b746e..ee6827ea04 100644
--- a/gdb/tui/tui-winsource.c
+++ b/gdb/tui/tui-winsource.c
@@ -1,7 +1,6 @@
 /* TUI display source/assembly window.
 
-   Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
-   Foundation, Inc.
+   Copyright (C) 1998-2013 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>
@@ -29,6 +26,8 @@
 #include "breakpoint.h"
 #include "value.h"
 #include "source.h"
+#include "objfiles.h"
+#include "filenames.h"
 
 #include "tui/tui.h"
 #include "tui/tui-data.h"
@@ -39,13 +38,9 @@
 #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_string.h"
+#include "gdb_curses.h"
+#include "gdb_assert.h"
 
 /* Function to display the "main" routine.  */
 void
@@ -53,19 +48,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;
 
-	  tui_update_source_windows_with_addr (addr);
+	  tui_update_source_windows_with_addr (gdbarch, addr);
 	  sal = find_pc_line (addr, 0);
           if (sal.symtab)
-             tui_update_locator_filename (sal.symtab->filename);
+             tui_update_locator_fullname (symtab_to_fullname (sal.symtab));
           else
-             tui_update_locator_filename ("??");
+             tui_update_locator_fullname ("??");
 	}
     }
 }
@@ -75,11 +71,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 +87,44 @@ 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);
+	  init_sal (&sal);
+	  sal.line = line_or_addr.u.line_no +
+	    (win_info->generic.content_size - 2);
 	  sal.symtab = s;
+	  sal.pspace = s->objfile->pspace;
 	  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);
+	  /* 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 +136,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 +166,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 (s->objfile);
+
   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 +211,206 @@ 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 =
+	    (struct tui_win_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;
+	  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,
+		     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;
+  struct tui_win_element *line;
   int x, y;
 
-  line = (TuiWinElementPtr) winInfo->generic.content[lineno - 1];
-  if (line->whichElement.source.isExecPoint)
-    wattron (winInfo->generic.handle, A_STANDOUT);
+  line = (struct tui_win_element *) win_info->generic.content[lineno - 1];
+  if (line->which_element.source.is_exec_point)
+    wattron (win_info->generic.handle, A_STANDOUT);
 
-  mvwaddstr (winInfo->generic.handle, lineno, 1,
-             line->whichElement.source.line);
-  if (line->whichElement.source.isExecPoint)
-    wattroff (winInfo->generic.handle, A_STANDOUT);
+  mvwaddstr (win_info->generic.handle, lineno, 1,
+             line->which_element.source.line);
+  if (line->which_element.source.is_exec_point)
+    wattroff (win_info->generic.handle, A_STANDOUT);
 
   /* Clear to end of line but stop before the border.  */
-  getyx (winInfo->generic.handle, y, x);
-  while (x + 1 < winInfo->generic.width)
+  getyx (win_info->generic.handle, y, x);
+  while (x + 1 < win_info->generic.width)
     {
-      waddch (winInfo->generic.handle, ' ');
-      getyx (winInfo->generic.handle, y, x);
+      waddch (win_info->generic.handle, ' ');
+      getyx (win_info->generic.handle, y, x);
     }
 }
 
 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;
 }
 
 
 /* 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)
     {
+      struct gdbarch *gdbarch = win_info->detail.source_info.gdbarch;
       int offset;
-      struct symtab *s;
-      struct symtab_and_line cursal = get_current_source_symtab_and_line ();
+      struct symtab *s = NULL;
 
-      if (cursal.symtab == (struct symtab *) NULL)
-	s = find_pc_symtab (get_frame_pc (deprecated_selected_frame));
-      else
-	s = cursal.symtab;
+      if (win_info->generic.type == SRC_WIN)
+	{
+	  struct symtab_and_line cursal
+	    = get_current_source_symtab_and_line ();
+
+	  if (cursal.symtab == NULL)
+	    s = find_pc_symtab (get_frame_pc (get_selected_frame (NULL)));
+	  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,
+      win_info->detail.source_info.horizontal_offset = offset;
+      tui_update_source_window_as_is (win_info, gdbarch, s,
+				      ((struct tui_win_element *)
+				       win_info->generic.content[0])->which_element.source.line_or_addr,
 				      FALSE);
     }
 
   return;
-}				/* tuiHorizontalSourceScroll */
+}
 
 
-/* Set or clear the hasBreak flag in the line whose line is lineNo.  */
+/* Set or clear the has_break flag in the line whose line is
+   line_no.  */
+
 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 = (tui_win_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_refresh_win (&win_info->generic);
 }
 
 /* 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 +420,30 @@ 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 = &((struct tui_win_element *)
+	       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 +454,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 +494,62 @@ 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;
-
-      if (execInfoPtr->content == (OpaquePtr) NULL)
-	execInfoPtr->content =
-	  (OpaquePtr) tui_alloc_content (winInfo->generic.height,
-					 execInfoPtr->type);
-      if (execInfoPtr->content != (OpaquePtr) NULL)
+      struct tui_gen_win_info *exec_info_ptr
+	= win_info->detail.source_info.execution_info;
+
+      if (exec_info_ptr->content == NULL)
+	exec_info_ptr->content =
+	  (void **) 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 = (struct tui_win_element *) exec_info_ptr->content[i];
+	      src_element = (struct tui_win_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,156 @@ 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;
+	       ((struct tui_win_element *)
+		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;
-
-  werase (execInfo->handle);
-  tui_refresh_win (execInfo);
+  struct tui_gen_win_info *exec_info
+    = win_info->detail.source_info.execution_info;
 
-  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;
+  char *src_line_buf;
+  int i, line_width, max_lines;
 
-  maxLines = winInfo->generic.height;	/* less the highlight box */
-  lineWidth = winInfo->generic.width - 1;
+  max_lines = win_info->generic.height;	/* Less the highlight box.  */
+  line_width = win_info->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.
+   * 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)
+  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
+      src_line_buf = (char *) 
+	xmalloc ((max_lines * line_width) * sizeof (char));
+      if (src_line_buf == (char *) NULL)
 	{
-	  /* 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);
-	    }
+	  fputs_unfiltered ("Unable to Allocate Memory for "
+			    "Source or Disassembly Display.\n",
+			    gdb_stderr);
+	  return TUI_FAILURE;
 	}
-      for (i = 0; i < maxLines; i++)
-	((TuiWinElementPtr)
-	 winInfo->generic.content[i])->whichElement.source.line =
-	  srcLineBuf + (lineWidth * i);
-      ret = TUI_SUCCESS;
+      /* Allocate the content list.  */
+      if ((win_info->generic.content =
+	   (void **) tui_alloc_content (max_lines, SRC_WIN)) == NULL)
+	{
+	  xfree (src_line_buf);
+	  fputs_unfiltered ("Unable to Allocate Memory for "
+			    "Source or Disassembly Display.\n",
+			    gdb_stderr);
+	  return TUI_FAILURE;
+	}
+      for (i = 0; i < max_lines; i++)
+	((struct tui_win_element *)
+	 win_info->generic.content[i])->which_element.source.line =
+	  src_line_buf + (line_width * i);
     }
-  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 = (((struct tui_win_element *)
+		       win_info->generic.content[i])->which_element.source.line_or_addr.loa
+		      == LOA_LINE)
+	&& (((struct tui_win_element *)
+	     win_info->generic.content[i])->which_element.source.line_or_addr.u.line_no
+	    == (int) 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 = (((struct tui_win_element *)
+		       win_info->generic.content[i])->which_element.source.line_or_addr.loa
+		      == LOA_ADDRESS)
+	&& (((struct tui_win_element *)
+	     win_info->generic.content[i])->which_element.source.line_or_addr.u.addr
+	    == addr);
       i++;
     }
 
-  return isDisplayed;
+  return is_displayed;
 }