From: Andrew Cagney <cagney@redhat.com>
Date: Sat, 7 Feb 2004 20:57:02 +0000 (+0000)
Subject: 2004-02-07  Andrew Cagney  <cagney@redhat.com>
X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=6d012f143df40b0870ee1f64940080c1591801a3;p=binutils-gdb.git

2004-02-07  Andrew Cagney  <cagney@redhat.com>

	* tui/tui.h: Do not include <stdarg.h>, <string.h>, and
	"ansidecl.h".  Do not undef "reg" and "chtype".  Fix case of
	fields and variables.
	* tui/tui-wingeneral.h (m_beVisible): Delete macro.
	(m_beInvisible): Delete macro.
	* tui/tui-data.h: Fix case case fields and variables.
	(m_genWinPtrIsNull): Delete macro.
	(tui_win_list): Rename winList.
	(TUI_SRC_WIN): Rename srcWin.
	(TUI_DISASM_WIN): Rename disassemWin.
	(TUI_DATA_WIN): Rename dataWin.
	(TUI_CMD_WIN): Rename cmdWin.
	(m_genWinPtrNotNull): Delete macro.
	(m_winPtrIsNull): Delete macro.
	(m_winPtrNotNull): Delete macro.
	(tui_win_is_source_type): Replace m_winIsSourceType
	(tui_win_is_auxillary): Replace m_winIsAuzillary.
	(tui_win_has_locator): Replace m_hasLocator.
	(tui_set_win_highlight): Replace m_setWinHighlightOn and
	m_setWinHighlightOff.
	* tui/tui-data.c: Update references.
	(tui_win_is_source_type, tui_set_win_highlight): New functions.
	(tui_win_has_locator, tui_win_is_auxillary): New functions.
	* tui/tui-command.c, tui/tui-disasm.c: Update references.
	* tui/tui-io.c, tui/tui-layout.c, tui/tui-regs.c: Ditto.
	* tui/tui-regs.h, tui/tui-source.c, tui/tui-stack.c: Ditto.
	* tui/tui-win.c, tui/tui-windata.c, tui/tui-wingeneral.c: Ditto.
	* tui/tui-winsource.c, tui/tui.c: Ditto.
---

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index edf959accc7..73369239686 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,34 @@
+2004-02-07  Andrew Cagney  <cagney@redhat.com>
+
+	* tui/tui.h: Do not include <stdarg.h>, <string.h>, and
+	"ansidecl.h".  Do not undef "reg" and "chtype".  Fix case of
+	fields and variables.
+	* tui/tui-wingeneral.h (m_beVisible): Delete macro.
+	(m_beInvisible): Delete macro.
+	* tui/tui-data.h: Fix case case fields and variables.
+	(m_genWinPtrIsNull): Delete macro.
+	(tui_win_list): Rename winList.
+	(TUI_SRC_WIN): Rename srcWin.
+	(TUI_DISASM_WIN): Rename disassemWin.
+	(TUI_DATA_WIN): Rename dataWin.
+	(TUI_CMD_WIN): Rename cmdWin.
+	(m_genWinPtrNotNull): Delete macro.
+	(m_winPtrIsNull): Delete macro.
+	(m_winPtrNotNull): Delete macro.
+	(tui_win_is_source_type): Replace m_winIsSourceType
+	(tui_win_is_auxillary): Replace m_winIsAuzillary.
+	(tui_win_has_locator): Replace m_hasLocator.
+	(tui_set_win_highlight): Replace m_setWinHighlightOn and
+	m_setWinHighlightOff.
+	* tui/tui-data.c: Update references.
+	(tui_win_is_source_type, tui_set_win_highlight): New functions.
+	(tui_win_has_locator, tui_win_is_auxillary): New functions.
+	* tui/tui-command.c, tui/tui-disasm.c: Update references.
+	* tui/tui-io.c, tui/tui-layout.c, tui/tui-regs.c: Ditto.
+	* tui/tui-regs.h, tui/tui-source.c, tui/tui-stack.c: Ditto.
+	* tui/tui-win.c, tui/tui-windata.c, tui/tui-wingeneral.c: Ditto.
+	* tui/tui-winsource.c, tui/tui.c: Ditto.
+
 2004-02-07  Mark Kettenis  <kettenis@gnu.org>
 
 	* sparc-tdep.h (sparc_fetch_wcookie): New prototype.
diff --git a/gdb/tui/tui-command.c b/gdb/tui/tui-command.c
index 820126ec955..2a51fc8aca3 100644
--- a/gdb/tui/tui-command.c
+++ b/gdb/tui/tui-command.c
@@ -52,15 +52,15 @@
 unsigned int
 tui_dispatch_ctrl_char (unsigned int ch)
 {
-  struct tui_win_info * winInfo = tui_win_with_focus ();
-  WINDOW *w = cmdWin->generic.handle;
+  struct tui_win_info *win_info = tui_win_with_focus ();
+  WINDOW *w = TUI_CMD_WIN->generic.handle;
 
   /*
      ** If the command window has the logical focus, or no-one does
      ** assume it is the command window; in this case, pass the
      ** character on through and do nothing here.
    */
-  if (winInfo == (struct tui_win_info *) NULL || winInfo == cmdWin)
+  if (win_info == NULL || win_info == TUI_CMD_WIN)
     return ch;
   else
     {
@@ -104,24 +104,24 @@ tui_dispatch_ctrl_char (unsigned int ch)
       switch (chCopy)
 	{
 	case KEY_NPAGE:
-	  tui_scroll_forward (winInfo, 0);
+	  tui_scroll_forward (win_info, 0);
 	  break;
 	case KEY_PPAGE:
-	  tui_scroll_backward (winInfo, 0);
+	  tui_scroll_backward (win_info, 0);
 	  break;
 	case KEY_DOWN:
 	case KEY_SF:
-	  tui_scroll_forward (winInfo, 1);
+	  tui_scroll_forward (win_info, 1);
 	  break;
 	case KEY_UP:
 	case KEY_SR:
-	  tui_scroll_backward (winInfo, 1);
+	  tui_scroll_backward (win_info, 1);
 	  break;
 	case KEY_RIGHT:
-	  tui_scroll_left (winInfo, 1);
+	  tui_scroll_left (win_info, 1);
 	  break;
 	case KEY_LEFT:
-	  tui_scroll_right (winInfo, 1);
+	  tui_scroll_right (win_info, 1);
 	  break;
 	case '\f':
 	  tui_refresh_all_win ();
diff --git a/gdb/tui/tui-data.c b/gdb/tui/tui-data.c
index 752f4ceb726..7b901d39750 100644
--- a/gdb/tui/tui-data.c
+++ b/gdb/tui/tui-data.c
@@ -1,7 +1,7 @@
 /* TUI data manipulation routines.
 
-   Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
-   Inc.
+   Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
+   Foundation, Inc.
 
    Contributed by Hewlett-Packard Company.
 
@@ -28,6 +28,8 @@
 #include "tui/tui-data.h"
 #include "tui/tui-wingeneral.h"
 
+#include "gdb_string.h"
+
 #ifdef HAVE_NCURSES_H       
 #include <ncurses.h>
 #else
@@ -39,7 +41,7 @@
 /****************************
 ** GLOBAL DECLARATIONS
 ****************************/
-struct tui_win_info *(winList[MAX_MAJOR_WINDOWS]);
+struct tui_win_info *(tui_win_list[MAX_MAJOR_WINDOWS]);
 
 /***************************
 ** Private data
@@ -72,6 +74,32 @@ static void freeContentElements (tui_win_content, int, enum tui_win_type);
 ** PUBLIC FUNCTIONS
 **********************************/
 
+int
+tui_win_is_source_type (enum tui_win_type win_type)
+{
+  return (win_type == SRC_WIN || win_type == DISASSEM_WIN);
+}
+
+int
+tui_win_is_auxillary (enum tui_win_type win_type)
+{
+  return (win_type > MAX_MAJOR_WINDOWS);
+}
+
+int
+tui_win_has_locator (struct tui_win_info *win_info)
+{
+  return (win_info != NULL \
+	  && win_info->detail.source_info.has_locator);
+}
+
+void
+tui_set_win_highlight (struct tui_win_info *win_info, int highlight)
+{
+  if (win_info != NULL)
+    win_info->is_highlighted = highlight;
+}
+
 /******************************************
 ** ACCESSORS & MUTATORS FOR PRIVATE DATA
 ******************************************/
@@ -110,9 +138,9 @@ tui_win_with_focus (void)
 
 /* Set the window that has the logical focus.   */
 void
-tui_set_win_with_focus (struct tui_win_info * winInfo)
+tui_set_win_with_focus (struct tui_win_info * win_info)
 {
-  _winWithFocus = winInfo;
+  _winWithFocus = win_info;
 }
 
 
@@ -172,41 +200,41 @@ tui_clear_source_windows_detail (void)
    one source window (either source or disassembly), but both can be
    displayed at the same time.  */
 void
-tui_add_to_source_windows (struct tui_win_info * winInfo)
+tui_add_to_source_windows (struct tui_win_info * win_info)
 {
   if (_sourceWindows.count < 2)
-    _sourceWindows.list[_sourceWindows.count++] = (void *) winInfo;
+    _sourceWindows.list[_sourceWindows.count++] = (void *) win_info;
 }
 
 
 /* Clear the pertinant detail in the windows.   */
 void
-tui_clear_win_detail (struct tui_win_info * winInfo)
+tui_clear_win_detail (struct tui_win_info * win_info)
 {
-  if (m_winPtrNotNull (winInfo))
+  if (win_info != NULL)
     {
-      switch (winInfo->generic.type)
+      switch (win_info->generic.type)
 	{
 	case SRC_WIN:
 	case DISASSEM_WIN:
-	  winInfo->detail.sourceInfo.startLineOrAddr.addr = 0;
-	  winInfo->detail.sourceInfo.horizontalOffset = 0;
+	  win_info->detail.source_info.start_line_or_addr.addr = 0;
+	  win_info->detail.source_info.horizontal_offset = 0;
 	  break;
 	case CMD_WIN:
-	  winInfo->detail.commandInfo.curLine =
-	    winInfo->detail.commandInfo.curch = 0;
+	  win_info->detail.command_info.cur_line =
+	    win_info->detail.command_info.curch = 0;
 	  break;
 	case DATA_WIN:
-	  winInfo->detail.dataDisplayInfo.dataContent =
+	  win_info->detail.data_display_info.data_content =
 	    (tui_win_content) NULL;
-	  winInfo->detail.dataDisplayInfo.dataContentCount = 0;
-	  winInfo->detail.dataDisplayInfo.regsContent =
+	  win_info->detail.data_display_info.data_content_count = 0;
+	  win_info->detail.data_display_info.regs_content =
 	    (tui_win_content) NULL;
-	  winInfo->detail.dataDisplayInfo.regsContentCount = 0;
-	  winInfo->detail.dataDisplayInfo.regsDisplayType =
+	  win_info->detail.data_display_info.regs_content_count = 0;
+	  win_info->detail.data_display_info.regs_display_type =
 	    TUI_UNDEFINED_REGS;
-	  winInfo->detail.dataDisplayInfo.regsColumnCount = 1;
-	  winInfo->detail.dataDisplayInfo.displayRegs = FALSE;
+	  win_info->detail.data_display_info.regs_column_count = 1;
+	  win_info->detail.data_display_info.display_regs = FALSE;
 	  break;
 	default:
 	  break;
@@ -301,10 +329,10 @@ tui_set_current_layout_to (enum tui_layout_type newLayout)
    **        Set the origin of the window
  */
 void
-setGenWinOrigin (struct tui_gen_win_info * winInfo, int x, int y)
+setGenWinOrigin (struct tui_gen_win_info * win_info, int x, int y)
 {
-  winInfo->origin.x = x;
-  winInfo->origin.y = y;
+  win_info->origin.x = x;
+  win_info->origin.y = y;
 
   return;
 }				/* setGenWinOrigin */
@@ -327,10 +355,10 @@ tui_next_win (struct tui_win_info * curWin)
     type = SRC_WIN;
   else
     type = curWin->generic.type + 1;
-  while (type != curWin->generic.type && m_winPtrIsNull (nextWin))
+  while (type != curWin->generic.type && (nextWin == NULL))
     {
-      if (winList[type] && winList[type]->generic.isVisible)
-	nextWin = winList[type];
+      if (tui_win_list[type] && tui_win_list[type]->generic.is_visible)
+	nextWin = tui_win_list[type];
       else
 	{
 	  if (type == CMD_WIN)
@@ -356,10 +384,10 @@ tui_prev_win (struct tui_win_info * curWin)
     type = CMD_WIN;
   else
     type = curWin->generic.type - 1;
-  while (type != curWin->generic.type && m_winPtrIsNull (prev))
+  while (type != curWin->generic.type && (prev == NULL))
     {
-      if (winList[type]->generic.isVisible)
-	prev = winList[type];
+      if (tui_win_list[type]->generic.is_visible)
+	prev = tui_win_list[type];
       else
 	{
 	  if (type == SRC_WIN)
@@ -377,26 +405,26 @@ tui_prev_win (struct tui_win_info * curWin)
 struct tui_win_info *
 tui_partial_win_by_name (char *name)
 {
-  struct tui_win_info * winInfo = (struct tui_win_info *) NULL;
+  struct tui_win_info * win_info = (struct tui_win_info *) NULL;
 
   if (name != (char *) NULL)
     {
       int i = 0;
 
-      while (i < MAX_MAJOR_WINDOWS && m_winPtrIsNull (winInfo))
+      while (i < MAX_MAJOR_WINDOWS && win_info == NULL)
 	{
-          if (winList[i] != 0)
+          if (tui_win_list[i] != 0)
             {
-              char *curName = tui_win_name (&winList[i]->generic);
+              char *curName = tui_win_name (&tui_win_list[i]->generic);
               if (strlen (name) <= strlen (curName) &&
                   strncmp (name, curName, strlen (name)) == 0)
-                winInfo = winList[i];
+                win_info = tui_win_list[i];
             }
 	  i++;
 	}
     }
 
-  return winInfo;
+  return win_info;
 }				/* partialWinByName */
 
 
@@ -405,11 +433,11 @@ tui_partial_win_by_name (char *name)
    **      Answer the name of the window
  */
 char *
-tui_win_name (struct tui_gen_win_info * winInfo)
+tui_win_name (struct tui_gen_win_info * win_info)
 {
   char *name = (char *) NULL;
 
-  switch (winInfo->type)
+  switch (win_info->type)
     {
     case SRC_WIN:
       name = SRC_NAME;
@@ -464,13 +492,13 @@ tui_init_generic_part (struct tui_gen_win_info * win)
     win->height =
     win->origin.x =
     win->origin.y =
-    win->viewportHeight =
-    win->contentSize =
-    win->lastVisibleLine = 0;
+    win->viewport_height =
+    win->content_size =
+    win->last_visible_line = 0;
   win->handle = (WINDOW *) NULL;
   win->content = NULL;
-  win->contentInUse =
-    win->isVisible = FALSE;
+  win->content_in_use =
+    win->is_visible = FALSE;
   win->title = 0;
 }
 
@@ -486,38 +514,38 @@ initContentElement (struct tui_win_element * element, enum tui_win_type type)
     {
     case SRC_WIN:
     case DISASSEM_WIN:
-      element->whichElement.source.line = (char *) NULL;
-      element->whichElement.source.lineOrAddr.lineNo = 0;
-      element->whichElement.source.isExecPoint = FALSE;
-      element->whichElement.source.hasBreak = FALSE;
+      element->which_element.source.line = (char *) NULL;
+      element->which_element.source.line_or_addr.line_no = 0;
+      element->which_element.source.is_exec_point = FALSE;
+      element->which_element.source.has_break = FALSE;
       break;
     case DATA_WIN:
-      tui_init_generic_part (&element->whichElement.dataWindow);
-      element->whichElement.dataWindow.type = DATA_ITEM_WIN;
-      ((struct tui_gen_win_info *) & element->whichElement.dataWindow)->content =
+      tui_init_generic_part (&element->which_element.data_window);
+      element->which_element.data_window.type = DATA_ITEM_WIN;
+      ((struct tui_gen_win_info *) & element->which_element.data_window)->content =
 	(void **) tui_alloc_content (1, DATA_ITEM_WIN);
       ((struct tui_gen_win_info *)
-       & element->whichElement.dataWindow)->contentSize = 1;
+       & element->which_element.data_window)->content_size = 1;
       break;
     case CMD_WIN:
-      element->whichElement.command.line = (char *) NULL;
+      element->which_element.command.line = (char *) NULL;
       break;
     case DATA_ITEM_WIN:
-      element->whichElement.data.name = (char *) NULL;
-      element->whichElement.data.type = TUI_REGISTER;
-      element->whichElement.data.itemNo = UNDEFINED_ITEM;
-      element->whichElement.data.value = NULL;
-      element->whichElement.data.highlight = FALSE;
+      element->which_element.data.name = (char *) NULL;
+      element->which_element.data.type = TUI_REGISTER;
+      element->which_element.data.item_no = UNDEFINED_ITEM;
+      element->which_element.data.value = NULL;
+      element->which_element.data.highlight = FALSE;
       break;
     case LOCATOR_WIN:
-      element->whichElement.locator.fileName[0] =
-	element->whichElement.locator.procName[0] = (char) 0;
-      element->whichElement.locator.lineNo = 0;
-      element->whichElement.locator.addr = 0;
+      element->which_element.locator.file_name[0] =
+	element->which_element.locator.proc_name[0] = (char) 0;
+      element->which_element.locator.line_no = 0;
+      element->which_element.locator.addr = 0;
       break;
     case EXEC_INFO_WIN:
-      memset(element->whichElement.simpleString, ' ',
-             sizeof(element->whichElement.simpleString));
+      memset(element->which_element.simple_string, ' ',
+             sizeof(element->which_element.simple_string));
       break;
     default:
       break;
@@ -529,37 +557,37 @@ initContentElement (struct tui_win_element * element, enum tui_win_type type)
    ** initWinInfo().
  */
 void
-initWinInfo (struct tui_win_info * winInfo)
+initWinInfo (struct tui_win_info * win_info)
 {
-  tui_init_generic_part (&winInfo->generic);
-  winInfo->canHighlight =
-    winInfo->isHighlighted = FALSE;
-  switch (winInfo->generic.type)
+  tui_init_generic_part (&win_info->generic);
+  win_info->can_highlight =
+    win_info->is_highlighted = FALSE;
+  switch (win_info->generic.type)
     {
     case SRC_WIN:
     case DISASSEM_WIN:
-      winInfo->detail.sourceInfo.executionInfo = (struct tui_gen_win_info *) NULL;
-      winInfo->detail.sourceInfo.hasLocator = FALSE;
-      winInfo->detail.sourceInfo.horizontalOffset = 0;
-      winInfo->detail.sourceInfo.startLineOrAddr.addr = 0;
-      winInfo->detail.sourceInfo.filename = 0;
+      win_info->detail.source_info.execution_info = (struct tui_gen_win_info *) NULL;
+      win_info->detail.source_info.has_locator = FALSE;
+      win_info->detail.source_info.horizontal_offset = 0;
+      win_info->detail.source_info.start_line_or_addr.addr = 0;
+      win_info->detail.source_info.filename = 0;
       break;
     case DATA_WIN:
-      winInfo->detail.dataDisplayInfo.dataContent = (tui_win_content) NULL;
-      winInfo->detail.dataDisplayInfo.dataContentCount = 0;
-      winInfo->detail.dataDisplayInfo.regsContent = (tui_win_content) NULL;
-      winInfo->detail.dataDisplayInfo.regsContentCount = 0;
-      winInfo->detail.dataDisplayInfo.regsDisplayType =
+      win_info->detail.data_display_info.data_content = (tui_win_content) NULL;
+      win_info->detail.data_display_info.data_content_count = 0;
+      win_info->detail.data_display_info.regs_content = (tui_win_content) NULL;
+      win_info->detail.data_display_info.regs_content_count = 0;
+      win_info->detail.data_display_info.regs_display_type =
 	TUI_UNDEFINED_REGS;
-      winInfo->detail.dataDisplayInfo.regsColumnCount = 1;
-      winInfo->detail.dataDisplayInfo.displayRegs = FALSE;
+      win_info->detail.data_display_info.regs_column_count = 1;
+      win_info->detail.data_display_info.display_regs = FALSE;
       break;
     case CMD_WIN:
-      winInfo->detail.commandInfo.curLine = 0;
-      winInfo->detail.commandInfo.curch = 0;
+      win_info->detail.command_info.cur_line = 0;
+      win_info->detail.command_info.curch = 0;
       break;
     default:
-      winInfo->detail.opaque = NULL;
+      win_info->detail.opaque = NULL;
       break;
     }
 
@@ -570,16 +598,16 @@ initWinInfo (struct tui_win_info * winInfo)
 struct tui_win_info *
 tui_alloc_win_info (enum tui_win_type type)
 {
-  struct tui_win_info * winInfo = (struct tui_win_info *) NULL;
+  struct tui_win_info * win_info = (struct tui_win_info *) NULL;
 
-  winInfo = (struct tui_win_info *) xmalloc (sizeof (struct tui_win_info));
-  if (m_winPtrNotNull (winInfo))
+  win_info = (struct tui_win_info *) xmalloc (sizeof (struct tui_win_info));
+  if ((win_info != NULL))
     {
-      winInfo->generic.type = type;
-      initWinInfo (winInfo);
+      win_info->generic.type = type;
+      initWinInfo (win_info);
     }
 
-  return winInfo;
+  return win_info;
 }				/* allocWinInfo */
 
 
@@ -631,28 +659,28 @@ tui_alloc_content (int numElements, enum tui_win_type type)
    there is a memory allocation error, in which case, (-1) is
    returned.  */
 int
-tui_add_content_elements (struct tui_gen_win_info * winInfo, int numElements)
+tui_add_content_elements (struct tui_gen_win_info * win_info, int numElements)
 {
   struct tui_win_element * elementPtr;
   int i, indexStart;
 
-  if (winInfo->content == NULL)
+  if (win_info->content == NULL)
     {
-      winInfo->content = (void **) tui_alloc_content (numElements, winInfo->type);
+      win_info->content = (void **) tui_alloc_content (numElements, win_info->type);
       indexStart = 0;
     }
   else
-    indexStart = winInfo->contentSize;
-  if (winInfo->content != NULL)
+    indexStart = win_info->content_size;
+  if (win_info->content != NULL)
     {
       for (i = indexStart; (i < numElements + indexStart); i++)
 	{
 	  if ((elementPtr = (struct tui_win_element *)
 	       xmalloc (sizeof (struct tui_win_element))) != (struct tui_win_element *) NULL)
 	    {
-	      winInfo->content[i] = (void *) elementPtr;
-	      initContentElement (elementPtr, winInfo->type);
-	      winInfo->contentSize++;
+	      win_info->content[i] = (void *) elementPtr;
+	      initContentElement (elementPtr, win_info->type);
+	      win_info->content_size++;
 	    }
 	  else			/* things must be really hosed now! We ran out of memory!? */
 	    return (-1);
@@ -663,14 +691,14 @@ tui_add_content_elements (struct tui_gen_win_info * winInfo, int numElements)
 }				/* addContentElements */
 
 
-/* Delete all curses windows associated with winInfo, leaving everything
+/* Delete all curses windows associated with win_info, leaving everything
    else intact.  */
 void
-tuiDelWindow (struct tui_win_info * winInfo)
+tuiDelWindow (struct tui_win_info * win_info)
 {
   struct tui_gen_win_info * genericWin;
 
-  switch (winInfo->generic.type)
+  switch (win_info->generic.type)
     {
     case SRC_WIN:
     case DISASSEM_WIN:
@@ -679,48 +707,48 @@ tuiDelWindow (struct tui_win_info * winInfo)
 	{
 	  tui_delete_win (genericWin->handle);
 	  genericWin->handle = (WINDOW *) NULL;
-	  genericWin->isVisible = FALSE;
+	  genericWin->is_visible = FALSE;
 	}
-      if (winInfo->detail.sourceInfo.filename)
+      if (win_info->detail.source_info.filename)
         {
-          xfree (winInfo->detail.sourceInfo.filename);
-          winInfo->detail.sourceInfo.filename = 0;
+          xfree (win_info->detail.source_info.filename);
+          win_info->detail.source_info.filename = 0;
         }
-      genericWin = winInfo->detail.sourceInfo.executionInfo;
+      genericWin = win_info->detail.source_info.execution_info;
       if (genericWin != (struct tui_gen_win_info *) NULL)
 	{
 	  tui_delete_win (genericWin->handle);
 	  genericWin->handle = (WINDOW *) NULL;
-	  genericWin->isVisible = FALSE;
+	  genericWin->is_visible = FALSE;
 	}
       break;
     case DATA_WIN:
-      if (winInfo->generic.content != NULL)
+      if (win_info->generic.content != NULL)
 	{
-	  tui_del_data_windows (winInfo->detail.dataDisplayInfo.regsContent,
-				winInfo->detail.dataDisplayInfo.regsContentCount);
-	  tui_del_data_windows (winInfo->detail.dataDisplayInfo.dataContent,
-				winInfo->detail.dataDisplayInfo.dataContentCount);
+	  tui_del_data_windows (win_info->detail.data_display_info.regs_content,
+				win_info->detail.data_display_info.regs_content_count);
+	  tui_del_data_windows (win_info->detail.data_display_info.data_content,
+				win_info->detail.data_display_info.data_content_count);
 	}
       break;
     default:
       break;
     }
-  if (winInfo->generic.handle != (WINDOW *) NULL)
+  if (win_info->generic.handle != (WINDOW *) NULL)
     {
-      tui_delete_win (winInfo->generic.handle);
-      winInfo->generic.handle = (WINDOW *) NULL;
-      winInfo->generic.isVisible = FALSE;
+      tui_delete_win (win_info->generic.handle);
+      win_info->generic.handle = (WINDOW *) NULL;
+      win_info->generic.is_visible = FALSE;
     }
 }
 
 
 void
-tui_free_window (struct tui_win_info * winInfo)
+tui_free_window (struct tui_win_info * win_info)
 {
   struct tui_gen_win_info * genericWin;
 
-  switch (winInfo->generic.type)
+  switch (win_info->generic.type)
     {
     case SRC_WIN:
     case DISASSEM_WIN:
@@ -731,12 +759,12 @@ tui_free_window (struct tui_win_info * winInfo)
 	  genericWin->handle = (WINDOW *) NULL;
 	}
       tui_free_win_content (genericWin);
-      if (winInfo->detail.sourceInfo.filename)
+      if (win_info->detail.source_info.filename)
         {
-          xfree (winInfo->detail.sourceInfo.filename);
-          winInfo->detail.sourceInfo.filename = 0;
+          xfree (win_info->detail.source_info.filename);
+          win_info->detail.source_info.filename = 0;
         }
-      genericWin = winInfo->detail.sourceInfo.executionInfo;
+      genericWin = win_info->detail.source_info.execution_info;
       if (genericWin != (struct tui_gen_win_info *) NULL)
 	{
 	  tui_delete_win (genericWin->handle);
@@ -745,38 +773,38 @@ tui_free_window (struct tui_win_info * winInfo)
 	}
       break;
     case DATA_WIN:
-      if (winInfo->generic.content != NULL)
+      if (win_info->generic.content != NULL)
 	{
-	  tui_free_data_content (winInfo->detail.dataDisplayInfo.regsContent,
-				 winInfo->detail.dataDisplayInfo.regsContentCount);
-	  winInfo->detail.dataDisplayInfo.regsContent =
+	  tui_free_data_content (win_info->detail.data_display_info.regs_content,
+				 win_info->detail.data_display_info.regs_content_count);
+	  win_info->detail.data_display_info.regs_content =
 	    (tui_win_content) NULL;
-	  winInfo->detail.dataDisplayInfo.regsContentCount = 0;
-	  tui_free_data_content (winInfo->detail.dataDisplayInfo.dataContent,
-				 winInfo->detail.dataDisplayInfo.dataContentCount);
-	  winInfo->detail.dataDisplayInfo.dataContent =
+	  win_info->detail.data_display_info.regs_content_count = 0;
+	  tui_free_data_content (win_info->detail.data_display_info.data_content,
+				 win_info->detail.data_display_info.data_content_count);
+	  win_info->detail.data_display_info.data_content =
 	    (tui_win_content) NULL;
-	  winInfo->detail.dataDisplayInfo.dataContentCount = 0;
-	  winInfo->detail.dataDisplayInfo.regsDisplayType =
+	  win_info->detail.data_display_info.data_content_count = 0;
+	  win_info->detail.data_display_info.regs_display_type =
 	    TUI_UNDEFINED_REGS;
-	  winInfo->detail.dataDisplayInfo.regsColumnCount = 1;
-	  winInfo->detail.dataDisplayInfo.displayRegs = FALSE;
-	  winInfo->generic.content = NULL;
-	  winInfo->generic.contentSize = 0;
+	  win_info->detail.data_display_info.regs_column_count = 1;
+	  win_info->detail.data_display_info.display_regs = FALSE;
+	  win_info->generic.content = NULL;
+	  win_info->generic.content_size = 0;
 	}
       break;
     default:
       break;
     }
-  if (winInfo->generic.handle != (WINDOW *) NULL)
+  if (win_info->generic.handle != (WINDOW *) NULL)
     {
-      tui_delete_win (winInfo->generic.handle);
-      winInfo->generic.handle = (WINDOW *) NULL;
-      tui_free_win_content (&winInfo->generic);
+      tui_delete_win (win_info->generic.handle);
+      win_info->generic.handle = (WINDOW *) NULL;
+      tui_free_win_content (&win_info->generic);
     }
-  if (winInfo->generic.title)
-    xfree (winInfo->generic.title);
-  xfree (winInfo);
+  if (win_info->generic.title)
+    xfree (win_info->generic.title);
+  xfree (win_info);
 }
 
 
@@ -787,28 +815,28 @@ tui_free_all_source_wins_content (void)
 
   for (i = 0; i < (tui_source_windows ())->count; i++)
     {
-      struct tui_win_info * winInfo = (struct tui_win_info *) (tui_source_windows ())->list[i];
+      struct tui_win_info * win_info = (struct tui_win_info *) (tui_source_windows ())->list[i];
 
-      if (m_winPtrNotNull (winInfo))
+      if (win_info != NULL)
 	{
-	  tui_free_win_content (&(winInfo->generic));
-	  tui_free_win_content (winInfo->detail.sourceInfo.executionInfo);
+	  tui_free_win_content (&(win_info->generic));
+	  tui_free_win_content (win_info->detail.source_info.execution_info);
 	}
     }
 }
 
 
 void
-tui_free_win_content (struct tui_gen_win_info * winInfo)
+tui_free_win_content (struct tui_gen_win_info * win_info)
 {
-  if (winInfo->content != NULL)
+  if (win_info->content != NULL)
     {
-      freeContent ((tui_win_content) winInfo->content,
-		   winInfo->contentSize,
-		   winInfo->type);
-      winInfo->content = NULL;
+      freeContent ((tui_win_content) win_info->content,
+		   win_info->content_size,
+		   win_info->type);
+      win_info->content = NULL;
     }
-  winInfo->contentSize = 0;
+  win_info->content_size = 0;
 
   return;
 }				/* freeWinContent */
@@ -825,13 +853,13 @@ tui_del_data_windows (tui_win_content content, int contentSize)
    */
   for (i = 0; i < contentSize; i++)
     {
-      struct tui_gen_win_info * genericWin = &content[i]->whichElement.dataWindow;
+      struct tui_gen_win_info * genericWin = &content[i]->which_element.data_window;
 
       if (genericWin != (struct tui_gen_win_info *) NULL)
 	{
 	  tui_delete_win (genericWin->handle);
 	  genericWin->handle = (WINDOW *) NULL;
-	  genericWin->isVisible = FALSE;
+	  genericWin->is_visible = FALSE;
 	}
     }
 }
@@ -848,7 +876,7 @@ tui_free_data_content (tui_win_content content, int contentSize)
    */
   for (i = 0; i < contentSize; i++)
     {
-      struct tui_gen_win_info * genericWin = &content[i]->whichElement.dataWindow;
+      struct tui_gen_win_info * genericWin = &content[i]->which_element.data_window;
 
       if (genericWin != (struct tui_gen_win_info *) NULL)
 	{
@@ -899,7 +927,7 @@ freeContentElements (tui_win_content content, int contentSize, enum tui_win_type
       if (type == SRC_WIN || type == DISASSEM_WIN)
 	{
 	  /* free whole source block */
-	  xfree (content[0]->whichElement.source.line);
+	  xfree (content[0]->which_element.source.line);
 	}
       else
 	{
@@ -920,13 +948,13 @@ freeContentElements (tui_win_content content, int contentSize, enum tui_win_type
 		         ** Note that data elements are not allocated
 		         ** in a single block, but individually, as needed.
 		       */
-		      if (element->whichElement.data.type != TUI_REGISTER)
-			xfree ((void *)element->whichElement.data.name);
-		      xfree (element->whichElement.data.value);
+		      if (element->which_element.data.type != TUI_REGISTER)
+			xfree ((void *)element->which_element.data.name);
+		      xfree (element->which_element.data.value);
 		      xfree (element);
 		      break;
 		    case CMD_WIN:
-		      xfree (element->whichElement.command.line);
+		      xfree (element->which_element.command.line);
 		      break;
 		    default:
 		      break;
diff --git a/gdb/tui/tui-data.h b/gdb/tui/tui-data.h
index 82c03ad683c..8628172ff3b 100644
--- a/gdb/tui/tui-data.h
+++ b/gdb/tui/tui-data.h
@@ -40,12 +40,12 @@ struct tui_gen_win_info
   int height;		/* window height */
   struct tui_point origin;	/* origin of window */
   void **content;	/* content of window */
-  int contentSize;	/* Size of content (# of elements) */
-  int contentInUse;	/* Can it be used, or is it already used? */
-  int viewportHeight;	/* viewport height */
-  int lastVisibleLine;	/* index of last visible line */
-  int isVisible;		/* whether the window is visible or not */
-  char* title;          /* Window title to display.  */
+  int content_size;	/* Size of content (# of elements) */
+  int content_in_use;	/* Can it be used, or is it already used? */
+  int viewport_height;	/* viewport height */
+  int last_visible_line;	/* index of last visible line */
+  int is_visible;		/* whether the window is visible or not */
+  char *title;          /* Window title to display.  */
 };
 
 /* Constant definitions */
@@ -146,26 +146,26 @@ enum tui_register_display_type
 /* Structure describing source line or line address */
 union tui_line_or_address
 {
-  int lineNo;
+  int line_no;
   CORE_ADDR addr;
 };
 
 /* Current Layout definition */
 struct tui_layout_def
 {
-  enum tui_win_type displayMode;
+  enum tui_win_type display_mode;
   int split;
-  enum tui_register_display_type regsDisplayType;
-  enum tui_register_display_type floatRegsDisplayType;
+  enum tui_register_display_type regs_display_type;
+  enum tui_register_display_type float_regs_display_type;
 };
 
 /* Elements in the Source/Disassembly Window */
 struct tui_source_element
 {
   char *line;
-  union tui_line_or_address lineOrAddr;
-  int isExecPoint;
-  int hasBreak;
+  union tui_line_or_address line_or_addr;
+  int is_exec_point;
+  int has_break;
 };
 
 
@@ -173,7 +173,7 @@ struct tui_source_element
 struct tui_data_element
 {
   const char *name;
-  int itemNo;			/* the register number, or data display number */
+  int item_no;			/* the register number, or data display number */
   enum tui_data_type type;
   void *value;
   int highlight;
@@ -192,9 +192,9 @@ struct tui_command_element
 /* Elements in the locator window content */
 struct tui_locator_element
 {
-  char fileName[MAX_LOCATOR_ELEMENT_LEN];
-  char procName[MAX_LOCATOR_ELEMENT_LEN];
-  int lineNo;
+  char file_name[MAX_LOCATOR_ELEMENT_LEN];
+  char proc_name[MAX_LOCATOR_ELEMENT_LEN];
+  int line_no;
   CORE_ADDR addr;
 };
 
@@ -217,17 +217,17 @@ typedef char tui_exec_info_content[TUI_EXECINFO_SIZE];
 union tui_which_element
 {
   struct tui_source_element source;	/* the source elements */
-  struct tui_gen_win_info dataWindow;	/* data display elements */
-  struct tui_data_element data;	/* elements of dataWindow */
+  struct tui_gen_win_info data_window;	/* data display elements */
+  struct tui_data_element data;	/* elements of data_window */
   struct tui_command_element command;	/* command elements */
   struct tui_locator_element locator;	/* locator elements */
-  tui_exec_info_content simpleString;	/* simple char based elements */
+  tui_exec_info_content simple_string;	/* simple char based elements */
 };
 
 struct tui_win_element
 {
   int highlight;
-  union tui_which_element whichElement;
+  union tui_which_element which_element;
 };
 
 
@@ -238,30 +238,30 @@ typedef struct tui_win_element **tui_win_content;
 /* This struct defines the specific information about a data display window */
 struct tui_data_info
 {
-  tui_win_content dataContent;	/* start of data display content */
-  int dataContentCount;
-  tui_win_content regsContent;	/* start of regs display content */
-  int regsContentCount;
-  enum tui_register_display_type regsDisplayType;
-  int regsColumnCount;
-  int displayRegs;		/* Should regs be displayed at all? */
+  tui_win_content data_content;	/* start of data display content */
+  int data_content_count;
+  tui_win_content regs_content;	/* start of regs display content */
+  int regs_content_count;
+  enum tui_register_display_type regs_display_type;
+  int regs_column_count;
+  int display_regs;		/* Should regs be displayed at all? */
 };
 
 
 struct tui_source_info
 {
-  int hasLocator;		/* Does locator belongs to this window? */
+  int has_locator;		/* Does locator belongs to this window? */
   /* Execution information window.  */
-  struct tui_gen_win_info *executionInfo;
-  int horizontalOffset;	/* used for horizontal scroll */
-  union tui_line_or_address startLineOrAddr;
+  struct tui_gen_win_info *execution_info;
+  int horizontal_offset;	/* used for horizontal scroll */
+  union tui_line_or_address start_line_or_addr;
   char* filename;
 };
 
 
 struct tui_command_info
 {
-  int curLine;		/* The current line position */
+  int cur_line;		/* The current line position */
   int curch;			/* The current cursor position */
   int start_line;
 };
@@ -273,53 +273,30 @@ struct tui_win_info
   struct tui_gen_win_info generic;	/* general window information */
   union
   {
-    struct tui_source_info sourceInfo;
-    struct tui_data_info dataDisplayInfo;
-    struct tui_command_info commandInfo;
+    struct tui_source_info source_info;
+    struct tui_data_info data_display_info;
+    struct tui_command_info command_info;
     void *opaque;
   }
   detail;
-  int canHighlight;		/* Can this window ever be highlighted? */
-  int isHighlighted;		/* Is this window highlighted? */
+  int can_highlight;		/* Can this window ever be highlighted? */
+  int is_highlighted;		/* Is this window highlighted? */
 };
 
-/* MACROS (prefixed with m_) */
-
-/* Testing macros */
-#define        m_genWinPtrIsNull(winInfo) \
-                ((winInfo) == (struct tui_gen_win_info *)NULL)
-#define        m_genWinPtrNotNull(winInfo) \
-                ((winInfo) != (struct tui_gen_win_info *)NULL)
-#define        m_winPtrIsNull(winInfo) \
-                ((winInfo) == (struct tui_win_info *)NULL)
-#define        m_winPtrNotNull(winInfo) \
-                ((winInfo) != (struct tui_win_info *)NULL)
-
-#define        m_winIsSourceType(type) \
-                (type == SRC_WIN || type == DISASSEM_WIN)
-#define        m_winIsAuxillary(winType) \
-                (winType > MAX_MAJOR_WINDOWS)
-#define        m_hasLocator(winInfo) \
-                ( ((winInfo) != (struct tui_win_info *)NULL) ? \
-                    (winInfo->detail.sourceInfo.hasLocator) : \
-                    FALSE )
-
-#define     m_setWinHighlightOn(winInfo) \
-                if ((winInfo) != (struct tui_win_info *)NULL) \
-                              (winInfo)->isHighlighted = TRUE
-#define     m_setWinHighlightOff(winInfo) \
-                if ((winInfo) != (struct tui_win_info *)NULL) \
-                              (winInfo)->isHighlighted = FALSE
+extern int tui_win_is_source_type (enum tui_win_type win_type);
+extern int tui_win_is_auxillary (enum tui_win_type win_type);
+extern int tui_win_has_locator (struct tui_win_info *win_info);
+extern void tui_set_win_highlight (struct tui_win_info *win_info,
+				   int highlight);
 
 
 /* Global Data */
-extern struct tui_win_info *(winList[MAX_MAJOR_WINDOWS]);
+extern struct tui_win_info *(tui_win_list[MAX_MAJOR_WINDOWS]);
 
-/* Macros */
-#define srcWin            winList[SRC_WIN]
-#define disassemWin       winList[DISASSEM_WIN]
-#define dataWin           winList[DATA_WIN]
-#define cmdWin            winList[CMD_WIN]
+#define TUI_SRC_WIN            tui_win_list[SRC_WIN]
+#define TUI_DISASM_WIN       tui_win_list[DISASSEM_WIN]
+#define TUI_DATA_WIN           tui_win_list[DATA_WIN]
+#define TUI_CMD_WIN            tui_win_list[CMD_WIN]
 
 /* Data Manipulation Functions */
 extern void tui_initialize_static_data (void);
@@ -351,7 +328,7 @@ extern struct tui_gen_win_info *tui_disassem_exec_info_win_ptr (void);
 extern struct tui_list * tui_source_windows (void);
 extern void tui_clear_source_windows (void);
 extern void tui_clear_source_windows_detail (void);
-extern void tui_clear_win_detail (struct tui_win_info * winInfo);
+extern void tui_clear_win_detail (struct tui_win_info * win_info);
 extern void tui_add_to_source_windows (struct tui_win_info *);
 extern int tui_default_tab_len (void);
 extern void tui_set_default_tab_len (int);
@@ -364,6 +341,6 @@ extern void tui_set_win_resized_to (int);
 extern struct tui_win_info *tui_next_win (struct tui_win_info *);
 extern struct tui_win_info *tui_prev_win (struct tui_win_info *);
 
-extern void tui_add_to_source_windows (struct tui_win_info * winInfo);
+extern void tui_add_to_source_windows (struct tui_win_info * win_info);
 
 #endif /* TUI_DATA_H */
diff --git a/gdb/tui/tui-disasm.c b/gdb/tui/tui-disasm.c
index 1143ba2b7f3..81c849af540 100644
--- a/gdb/tui/tui-disasm.c
+++ b/gdb/tui/tui-disasm.c
@@ -29,7 +29,7 @@
 #include "value.h"
 #include "source.h"
 #include "disasm.h"
-
+#include "gdb_string.h"
 #include "tui/tui.h"
 #include "tui/tui-data.h"
 #include "tui/tui-win.h"
@@ -177,7 +177,7 @@ tui_set_disassem_content (CORE_ADDR pc)
 {
   enum tui_status ret = TUI_FAILURE;
   register int i;
-  register int offset = disassemWin->detail.sourceInfo.horizontalOffset;
+  int offset = TUI_DISASM_WIN->detail.source_info.horizontal_offset;
   register int lineWidth, maxLines;
   CORE_ADDR cur_pc;
   struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
@@ -190,22 +190,22 @@ tui_set_disassem_content (CORE_ADDR pc)
   if (pc == 0)
     return TUI_FAILURE;
 
-  ret = tui_alloc_source_buffer (disassemWin);
+  ret = tui_alloc_source_buffer (TUI_DISASM_WIN);
   if (ret != TUI_SUCCESS)
     return ret;
 
-  disassemWin->detail.sourceInfo.startLineOrAddr.addr = pc;
+  TUI_DISASM_WIN->detail.source_info.start_line_or_addr.addr = pc;
   cur_pc = (CORE_ADDR)
-    (((struct tui_win_element *) locator->content[0])->whichElement.locator.addr);
+    (((struct tui_win_element *) locator->content[0])->which_element.locator.addr);
 
-  maxLines = disassemWin->generic.height - 2;	/* account for hilite */
+  maxLines = TUI_DISASM_WIN->generic.height - 2;	/* account for hilite */
 
   /* Get temporary table that will hold all strings (addr & insn).  */
   lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line)
                                          * maxLines);
   memset (lines, 0, sizeof (struct tui_asm_line) * maxLines);
 
-  lineWidth = disassemWin->generic.width - 1;
+  lineWidth = TUI_DISASM_WIN->generic.width - 1;
 
   tui_disassemble (lines, pc, maxLines);
 
@@ -235,8 +235,8 @@ tui_set_disassem_content (CORE_ADDR pc)
       struct tui_source_element* src;
       int curLen;
 
-      element = (struct tui_win_element *) disassemWin->generic.content[i];
-      src = &element->whichElement.source;
+      element = (struct tui_win_element *) TUI_DISASM_WIN->generic.content[i];
+      src = &element->which_element.source;
       strcpy (line, lines[i].addr_string);
       curLen = strlen (line);
 
@@ -255,17 +255,17 @@ tui_set_disassem_content (CORE_ADDR pc)
       else
         src->line[0] = '\0';
 
-      src->lineOrAddr.addr = lines[i].addr;
-      src->isExecPoint = lines[i].addr == cur_pc;
+      src->line_or_addr.addr = lines[i].addr;
+      src->is_exec_point = lines[i].addr == cur_pc;
 
       /* See whether there is a breakpoint installed.  */
-      src->hasBreak = (!src->isExecPoint
+      src->has_break = (!src->is_exec_point
                        && breakpoint_here_p (pc) != no_breakpoint_here);
 
       xfree (lines[i].addr_string);
       xfree (lines[i].insn);
     }
-  disassemWin->generic.contentSize = i;
+  TUI_DISASM_WIN->generic.content_size = i;
   return TUI_SUCCESS;
 }
 
@@ -280,13 +280,13 @@ tui_show_disassem (CORE_ADDR startAddr)
 
   val.addr = startAddr;
   tui_add_win_to_layout (DISASSEM_WIN);
-  tui_update_source_window (disassemWin, s, val, FALSE);
+  tui_update_source_window (TUI_DISASM_WIN, s, val, FALSE);
   /*
      ** if the focus was in the src win, put it in the asm win, if the
      ** source view isn't split
    */
-  if (tui_current_layout () != SRC_DISASSEM_COMMAND && winWithFocus == srcWin)
-    tui_set_win_focus_to (disassemWin);
+  if (tui_current_layout () != SRC_DISASSEM_COMMAND && winWithFocus == TUI_SRC_WIN)
+    tui_set_win_focus_to (TUI_DISASM_WIN);
 
   return;
 }
@@ -308,8 +308,8 @@ tui_show_disassem_and_update_source (CORE_ADDR startAddr)
          ** note that it follows what is in the disassembly window and visa-versa
        */
       sal = find_pc_line (startAddr, 0);
-      val.lineNo = sal.line;
-      tui_update_source_window (srcWin, sal.symtab, val, TRUE);
+      val.line_no = sal.line;
+      tui_update_source_window (TUI_SRC_WIN, sal.symtab, val, TRUE);
       if (sal.symtab)
 	{
 	  set_current_source_symtab_and_line (&sal);
@@ -330,7 +330,7 @@ tui_get_begin_asm_address (void)
   CORE_ADDR addr;
 
   locator = tui_locator_win_info_ptr ();
-  element = &((struct tui_win_element *) locator->content[0])->whichElement.locator;
+  element = &((struct tui_win_element *) locator->content[0])->which_element.locator;
 
   if (element->addr == 0)
     {
@@ -377,7 +377,7 @@ void
 tui_vertical_disassem_scroll (enum tui_scroll_direction scrollDirection,
 			      int numToScroll)
 {
-  if (disassemWin->generic.content != NULL)
+  if (TUI_DISASM_WIN->generic.content != NULL)
     {
       CORE_ADDR pc;
       tui_win_content content;
@@ -386,18 +386,18 @@ tui_vertical_disassem_scroll (enum tui_scroll_direction scrollDirection,
       int maxLines, dir;
       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
 
-      content = (tui_win_content) disassemWin->generic.content;
+      content = (tui_win_content) TUI_DISASM_WIN->generic.content;
       if (cursal.symtab == (struct symtab *) NULL)
 	s = find_pc_symtab (get_frame_pc (deprecated_selected_frame));
       else
 	s = cursal.symtab;
 
       /* account for hilite */
-      maxLines = disassemWin->generic.height - 2;
-      pc = content[0]->whichElement.source.lineOrAddr.addr;
+      maxLines = TUI_DISASM_WIN->generic.height - 2;
+      pc = content[0]->which_element.source.line_or_addr.addr;
       dir = (scrollDirection == FORWARD_SCROLL) ? maxLines : - maxLines;
 
       val.addr = tui_find_disassembly_address (pc, dir);
-      tui_update_source_window_as_is (disassemWin, s, val, FALSE);
+      tui_update_source_window_as_is (TUI_DISASM_WIN, s, val, FALSE);
     }
 }
diff --git a/gdb/tui/tui-io.c b/gdb/tui/tui-io.c
index 1a7d0969e9f..bc52ce71f52 100644
--- a/gdb/tui/tui-io.c
+++ b/gdb/tui/tui-io.c
@@ -167,7 +167,7 @@ tui_puts (const char *string)
   char c;
   WINDOW *w;
 
-  w = cmdWin->generic.handle;
+  w = TUI_CMD_WIN->generic.handle;
   while ((c = *string++) != 0)
     {
       /* Catch annotation and discard them.  We need two \032 and
@@ -184,9 +184,9 @@ tui_puts (const char *string)
       else if (c == '\n')
         tui_skip_line = -1;
     }
-  getyx (w, cmdWin->detail.commandInfo.curLine,
-         cmdWin->detail.commandInfo.curch);
-  cmdWin->detail.commandInfo.start_line = cmdWin->detail.commandInfo.curLine;
+  getyx (w, TUI_CMD_WIN->detail.command_info.cur_line,
+         TUI_CMD_WIN->detail.command_info.curch);
+  TUI_CMD_WIN->detail.command_info.start_line = TUI_CMD_WIN->detail.command_info.cur_line;
 
   /* We could defer the following.  */
   wrefresh (w);
@@ -211,18 +211,18 @@ tui_redisplay_readline (void)
 
   /* Detect when we temporarily left SingleKey and now the readline
      edit buffer is empty, automatically restore the SingleKey mode.  */
-  if (tui_current_key_mode == tui_one_command_mode && rl_end == 0)
-    tui_set_key_mode (tui_single_key_mode);
+  if (tui_current_key_mode == TUI_ONE_COMMAND_MODE && rl_end == 0)
+    tui_set_key_mode (TUI_SINGLE_KEY_MODE);
 
-  if (tui_current_key_mode == tui_single_key_mode)
+  if (tui_current_key_mode == TUI_SINGLE_KEY_MODE)
     prompt = "";
   else
     prompt = tui_rl_saved_prompt;
   
   c_pos = -1;
   c_line = -1;
-  w = cmdWin->generic.handle;
-  start_line = cmdWin->detail.commandInfo.start_line;
+  w = TUI_CMD_WIN->generic.handle;
+  start_line = TUI_CMD_WIN->detail.command_info.start_line;
   wmove (w, start_line, 0);
   prev_col = 0;
   height = 1;
@@ -255,8 +255,8 @@ tui_redisplay_readline (void)
 	}
       if (c == '\n')
         {
-          getyx (w, cmdWin->detail.commandInfo.start_line,
-                 cmdWin->detail.commandInfo.curch);
+          getyx (w, TUI_CMD_WIN->detail.command_info.start_line,
+                 TUI_CMD_WIN->detail.command_info.curch);
         }
       getyx (w, line, col);
       if (col < prev_col)
@@ -264,15 +264,15 @@ tui_redisplay_readline (void)
       prev_col = col;
     }
   wclrtobot (w);
-  getyx (w, cmdWin->detail.commandInfo.start_line,
-         cmdWin->detail.commandInfo.curch);
+  getyx (w, TUI_CMD_WIN->detail.command_info.start_line,
+         TUI_CMD_WIN->detail.command_info.curch);
   if (c_line >= 0)
     {
       wmove (w, c_line, c_pos);
-      cmdWin->detail.commandInfo.curLine = c_line;
-      cmdWin->detail.commandInfo.curch = c_pos;
+      TUI_CMD_WIN->detail.command_info.cur_line = c_line;
+      TUI_CMD_WIN->detail.command_info.curch = c_pos;
     }
-  cmdWin->detail.commandInfo.start_line -= height - 1;
+  TUI_CMD_WIN->detail.command_info.start_line -= height - 1;
 
   wrefresh (w);
   fflush(stdout);
@@ -415,7 +415,7 @@ tui_rl_display_match_list (matches, len, max)
   char *temp;
 
   /* Screen dimension correspond to the TUI command window.  */
-  int screenwidth = cmdWin->generic.width;
+  int screenwidth = TUI_CMD_WIN->generic.width;
 
   /* If there are many items, then ask the user if she really wants to
      see them all. */
@@ -587,10 +587,10 @@ tui_cont_sig (int sig)
       tui_refresh_all_win ();
 
       /* Update cursor position on the screen.  */
-      wmove (cmdWin->generic.handle,
-             cmdWin->detail.commandInfo.start_line,
-             cmdWin->detail.commandInfo.curch);
-      wrefresh (cmdWin->generic.handle);
+      wmove (TUI_CMD_WIN->generic.handle,
+             TUI_CMD_WIN->detail.command_info.start_line,
+             TUI_CMD_WIN->detail.command_info.curch);
+      wrefresh (TUI_CMD_WIN->generic.handle);
     }
   signal (sig, tui_cont_sig);
 }
@@ -651,7 +651,7 @@ tui_getc (FILE *fp)
   int ch;
   WINDOW *w;
 
-  w = cmdWin->generic.handle;
+  w = TUI_CMD_WIN->generic.handle;
 
 #ifdef TUI_USE_PIPE_FOR_READLINE
   /* Flush readline output.  */
@@ -671,7 +671,7 @@ tui_getc (FILE *fp)
          user we recognized the command.  */
       if (rl_end == 0)
         {
-          wmove (w, cmdWin->detail.commandInfo.curLine, 0);
+          wmove (w, TUI_CMD_WIN->detail.command_info.cur_line, 0);
 
           /* Clear the line.  This will blink the gdb prompt since
              it will be redrawn at the same line.  */
@@ -681,8 +681,8 @@ tui_getc (FILE *fp)
         }
       else
         {
-          wmove (w, cmdWin->detail.commandInfo.curLine,
-                 cmdWin->detail.commandInfo.curch);
+          wmove (w, TUI_CMD_WIN->detail.command_info.cur_line,
+                 TUI_CMD_WIN->detail.command_info.curch);
           waddch (w, ch);
         }
     }
@@ -693,7 +693,7 @@ tui_getc (FILE *fp)
     }
   
   if (ch == '\n' || ch == '\r' || ch == '\f')
-    cmdWin->detail.commandInfo.curch = 0;
+    TUI_CMD_WIN->detail.command_info.curch = 0;
 #if 0
   else
     tuiIncrCommandCharCountBy (1);
diff --git a/gdb/tui/tui-layout.c b/gdb/tui/tui-layout.c
index f6dde02a7b1..3c1e2308d5a 100644
--- a/gdb/tui/tui-layout.c
+++ b/gdb/tui/tui-layout.c
@@ -96,7 +96,7 @@ showLayout (enum tui_layout_type layout)
       if (layout == SRC_DATA_COMMAND || layout == DISASSEM_DATA_COMMAND)
 	{
 	  _showData (layout);
-	  tui_refresh_all (winList);
+	  tui_refresh_all (tui_win_list);
 	}
       else
 	{
@@ -109,16 +109,16 @@ showLayout (enum tui_layout_type layout)
 	      /* Now show the new layout */
 	    case SRC_COMMAND:
 	      _showSourceCommand ();
-	      tui_add_to_source_windows (srcWin);
+	      tui_add_to_source_windows (TUI_SRC_WIN);
 	      break;
 	    case DISASSEM_COMMAND:
 	      _showDisassemCommand ();
-	      tui_add_to_source_windows (disassemWin);
+	      tui_add_to_source_windows (TUI_DISASM_WIN);
 	      break;
 	    case SRC_DISASSEM_COMMAND:
 	      _showSourceDisassemCommand ();
-	      tui_add_to_source_windows (srcWin);
-	      tui_add_to_source_windows (disassemWin);
+	      tui_add_to_source_windows (TUI_SRC_WIN);
+	      tui_add_to_source_windows (TUI_DISASM_WIN);
 	      break;
 	    default:
 	      break;
@@ -132,14 +132,14 @@ showLayout (enum tui_layout_type layout)
    SRC_DISASSEM_COMMAND, SRC_DATA_COMMAND, or DISASSEM_DATA_COMMAND.
    If the layout is SRC_DATA_COMMAND, DISASSEM_DATA_COMMAND, or
    UNDEFINED_LAYOUT, then the data window is populated according to
-   regsDisplayType.  */
+   regs_display_type.  */
 enum tui_status
 tui_set_layout (enum tui_layout_type layoutType,
-		enum tui_register_display_type regsDisplayType)
+		enum tui_register_display_type regs_display_type)
 {
   enum tui_status status = TUI_SUCCESS;
 
-  if (layoutType != UNDEFINED_LAYOUT || regsDisplayType != TUI_UNDEFINED_REGS)
+  if (layoutType != UNDEFINED_LAYOUT || regs_display_type != TUI_UNDEFINED_REGS)
     {
       enum tui_layout_type curLayout = tui_current_layout (), newLayout = UNDEFINED_LAYOUT;
       int regsPopulate = FALSE;
@@ -150,7 +150,7 @@ tui_set_layout (enum tui_layout_type layoutType,
 
 
       if (layoutType == UNDEFINED_LAYOUT &&
-	  regsDisplayType != TUI_UNDEFINED_REGS)
+	  regs_display_type != TUI_UNDEFINED_REGS)
 	{
 	  if (curLayout == SRC_DISASSEM_COMMAND)
 	    newLayout = DISASSEM_DATA_COMMAND;
@@ -165,8 +165,8 @@ tui_set_layout (enum tui_layout_type layoutType,
 
       regsPopulate = (newLayout == SRC_DATA_COMMAND ||
 		      newLayout == DISASSEM_DATA_COMMAND ||
-		      regsDisplayType != TUI_UNDEFINED_REGS);
-      if (newLayout != curLayout || regsDisplayType != TUI_UNDEFINED_REGS)
+		      regs_display_type != TUI_UNDEFINED_REGS);
+      if (newLayout != curLayout || regs_display_type != TUI_UNDEFINED_REGS)
 	{
 	  if (newLayout != curLayout)
 	    {
@@ -174,13 +174,13 @@ tui_set_layout (enum tui_layout_type layoutType,
 	      /*
 	         ** Now determine where focus should be
 	       */
-	      if (winWithFocus != cmdWin)
+	      if (winWithFocus != TUI_CMD_WIN)
 		{
 		  switch (newLayout)
 		    {
 		    case SRC_COMMAND:
-		      tui_set_win_focus_to (srcWin);
-		      layoutDef->displayMode = SRC_WIN;
+		      tui_set_win_focus_to (TUI_SRC_WIN);
+		      layoutDef->display_mode = SRC_WIN;
 		      layoutDef->split = FALSE;
 		      break;
 		    case DISASSEM_COMMAND:
@@ -192,8 +192,8 @@ tui_set_layout (enum tui_layout_type layoutType,
 		         ** We still want to show the assembly though!
 		       */
 		      addr = tui_get_begin_asm_address ();
-		      tui_set_win_focus_to (disassemWin);
-		      layoutDef->displayMode = DISASSEM_WIN;
+		      tui_set_win_focus_to (TUI_DISASM_WIN);
+		      layoutDef->display_mode = DISASSEM_WIN;
 		      layoutDef->split = FALSE;
 		      break;
 		    case SRC_DISASSEM_COMMAND:
@@ -205,18 +205,18 @@ tui_set_layout (enum tui_layout_type layoutType,
 		         ** We still want to show the assembly though!
 		       */
 		      addr = tui_get_begin_asm_address ();
-		      if (winWithFocus == srcWin)
-			tui_set_win_focus_to (srcWin);
+		      if (winWithFocus == TUI_SRC_WIN)
+			tui_set_win_focus_to (TUI_SRC_WIN);
 		      else
-			tui_set_win_focus_to (disassemWin);
+			tui_set_win_focus_to (TUI_DISASM_WIN);
 		      layoutDef->split = TRUE;
 		      break;
 		    case SRC_DATA_COMMAND:
-		      if (winWithFocus != dataWin)
-			tui_set_win_focus_to (srcWin);
+		      if (winWithFocus != TUI_DATA_WIN)
+			tui_set_win_focus_to (TUI_SRC_WIN);
 		      else
-			tui_set_win_focus_to (dataWin);
-		      layoutDef->displayMode = SRC_WIN;
+			tui_set_win_focus_to (TUI_DATA_WIN);
+		      layoutDef->display_mode = SRC_WIN;
 		      layoutDef->split = FALSE;
 		      break;
 		    case DISASSEM_DATA_COMMAND:
@@ -228,11 +228,11 @@ tui_set_layout (enum tui_layout_type layoutType,
 		         ** We still want to show the assembly though!
 		       */
 		      addr = tui_get_begin_asm_address ();
-		      if (winWithFocus != dataWin)
-			tui_set_win_focus_to (disassemWin);
+		      if (winWithFocus != TUI_DATA_WIN)
+			tui_set_win_focus_to (TUI_DISASM_WIN);
 		      else
-			tui_set_win_focus_to (dataWin);
-		      layoutDef->displayMode = DISASSEM_WIN;
+			tui_set_win_focus_to (TUI_DATA_WIN);
+		      layoutDef->display_mode = DISASSEM_WIN;
 		      layoutDef->split = FALSE;
 		      break;
 		    default:
@@ -253,10 +253,10 @@ tui_set_layout (enum tui_layout_type layoutType,
 	    }
 	  if (regsPopulate)
 	    {
-	      layoutDef->regsDisplayType =
-		(regsDisplayType == TUI_UNDEFINED_REGS ?
-		 TUI_GENERAL_REGS : regsDisplayType);
-	      tui_show_registers (layoutDef->regsDisplayType);
+	      layoutDef->regs_display_type =
+		(regs_display_type == TUI_UNDEFINED_REGS ?
+		 TUI_GENERAL_REGS : regs_display_type);
+	      tui_show_registers (layoutDef->regs_display_type);
 	    }
 	}
     }
@@ -329,26 +329,26 @@ tuiDefaultWinHeight (enum tui_win_type type, enum tui_layout_type layout)
 {
   int h;
 
-  if (winList[type] != (struct tui_win_info *) NULL)
-    h = winList[type]->generic.height;
+  if (tui_win_list[type] != (struct tui_win_info *) NULL)
+    h = tui_win_list[type]->generic.height;
   else
     {
       switch (layout)
 	{
 	case SRC_COMMAND:
 	case DISASSEM_COMMAND:
-	  if (m_winPtrIsNull (cmdWin))
+	  if (TUI_CMD_WIN == NULL)
 	    h = tui_term_height () / 2;
 	  else
-	    h = tui_term_height () - cmdWin->generic.height;
+	    h = tui_term_height () - TUI_CMD_WIN->generic.height;
 	  break;
 	case SRC_DISASSEM_COMMAND:
 	case SRC_DATA_COMMAND:
 	case DISASSEM_DATA_COMMAND:
-	  if (m_winPtrIsNull (cmdWin))
+	  if (TUI_CMD_WIN == NULL)
 	    h = tui_term_height () / 3;
 	  else
-	    h = (tui_term_height () - cmdWin->generic.height) / 2;
+	    h = (tui_term_height () - TUI_CMD_WIN->generic.height) / 2;
 	  break;
 	default:
 	  h = 0;
@@ -371,7 +371,7 @@ tui_default_win_viewport_height (enum tui_win_type type,
 
   h = tuiDefaultWinHeight (type, layout);
 
-  if (winList[type] == cmdWin)
+  if (tui_win_list[type] == TUI_CMD_WIN)
     h -= 1;
   else
     h -= 2;
@@ -471,14 +471,14 @@ tui_set_layout_for_display_command (const char *layoutName)
  */
 	      if (subset_compare (bufPtr, TUI_FLOAT_REGS_NAME))
 		{
-		  if (dataWin->detail.dataDisplayInfo.regsDisplayType !=
+		  if (TUI_DATA_WIN->detail.data_display_info.regs_display_type !=
 		      TUI_SFLOAT_REGS &&
-		      dataWin->detail.dataDisplayInfo.regsDisplayType !=
+		      TUI_DATA_WIN->detail.data_display_info.regs_display_type !=
 		      TUI_DFLOAT_REGS)
 		    dpyType = TUI_SFLOAT_REGS;
 		  else
 		    dpyType =
-		      dataWin->detail.dataDisplayInfo.regsDisplayType;
+		      TUI_DATA_WIN->detail.data_display_info.regs_display_type;
 		}
 	      else if (subset_compare (bufPtr,
 				      TUI_GENERAL_SPECIAL_REGS_NAME))
@@ -487,12 +487,12 @@ tui_set_layout_for_display_command (const char *layoutName)
 		dpyType = TUI_GENERAL_REGS;
 	      else if (subset_compare (bufPtr, TUI_SPECIAL_REGS_NAME))
 		dpyType = TUI_SPECIAL_REGS;
-	      else if (dataWin)
+	      else if (TUI_DATA_WIN)
 		{
-		  if (dataWin->detail.dataDisplayInfo.regsDisplayType !=
+		  if (TUI_DATA_WIN->detail.data_display_info.regs_display_type !=
 		      TUI_UNDEFINED_REGS)
 		    dpyType =
-		      dataWin->detail.dataDisplayInfo.regsDisplayType;
+		      TUI_DATA_WIN->detail.data_display_info.regs_display_type;
 		  else
 		    dpyType = TUI_GENERAL_REGS;
 		}
@@ -538,14 +538,14 @@ _extractDisplayStartAddr (void)
     case SRC_COMMAND:
     case SRC_DATA_COMMAND:
       find_line_pc (cursal.symtab,
-		    srcWin->detail.sourceInfo.startLineOrAddr.lineNo,
+		    TUI_SRC_WIN->detail.source_info.start_line_or_addr.line_no,
 		    &pc);
       addr = pc;
       break;
     case DISASSEM_COMMAND:
     case SRC_DISASSEM_COMMAND:
     case DISASSEM_DATA_COMMAND:
-      addr = disassemWin->detail.sourceInfo.startLineOrAddr.addr;
+      addr = TUI_DISASM_WIN->detail.source_info.start_line_or_addr.addr;
       break;
     default:
       addr = 0;
@@ -562,14 +562,14 @@ _tuiHandleXDBLayout (struct tui_layout_def * layoutDef)
   if (layoutDef->split)
     {
       tui_set_layout (SRC_DISASSEM_COMMAND, TUI_UNDEFINED_REGS);
-      tui_set_win_focus_to (winList[layoutDef->displayMode]);
+      tui_set_win_focus_to (tui_win_list[layoutDef->display_mode]);
     }
   else
     {
-      if (layoutDef->displayMode == SRC_WIN)
+      if (layoutDef->display_mode == SRC_WIN)
 	tui_set_layout (SRC_COMMAND, TUI_UNDEFINED_REGS);
       else
-	tui_set_layout (DISASSEM_DATA_COMMAND, layoutDef->regsDisplayType);
+	tui_set_layout (DISASSEM_DATA_COMMAND, layoutDef->regs_display_type);
     }
 
 
@@ -584,10 +584,10 @@ _tuiToggleLayout_command (char *arg, int fromTTY)
 
   /* Make sure the curses mode is enabled.  */
   tui_enable ();
-  if (layoutDef->displayMode == SRC_WIN)
-    layoutDef->displayMode = DISASSEM_WIN;
+  if (layoutDef->display_mode == SRC_WIN)
+    layoutDef->display_mode = DISASSEM_WIN;
   else
-    layoutDef->displayMode = SRC_WIN;
+    layoutDef->display_mode = SRC_WIN;
 
   if (!layoutDef->split)
     _tuiHandleXDBLayout (layoutDef);
@@ -681,7 +681,7 @@ _makeCommandWindow (struct tui_win_info * * winInfoPtr, int height, int originY)
 		   originY,
 		   DONT_BOX_WINDOW);
 
-  (*winInfoPtr)->canHighlight = FALSE;
+  (*winInfoPtr)->can_highlight = FALSE;
 
   return;
 }				/* _makeCommandWindow */
@@ -767,43 +767,43 @@ _showSourceDisassemCommand (void)
     {
       int cmdHeight, srcHeight, asmHeight;
 
-      if (m_winPtrNotNull (cmdWin))
-	cmdHeight = cmdWin->generic.height;
+      if (TUI_CMD_WIN != NULL)
+	cmdHeight = TUI_CMD_WIN->generic.height;
       else
 	cmdHeight = tui_term_height () / 3;
 
       srcHeight = (tui_term_height () - cmdHeight) / 2;
       asmHeight = tui_term_height () - (srcHeight + cmdHeight);
 
-      if (m_winPtrIsNull (srcWin))
-	_makeSourceWindow (&srcWin, srcHeight, 0);
+      if (TUI_SRC_WIN == NULL)
+	_makeSourceWindow (&TUI_SRC_WIN, srcHeight, 0);
       else
 	{
-	  _initGenWinInfo (&srcWin->generic,
-			   srcWin->generic.type,
+	  _initGenWinInfo (&TUI_SRC_WIN->generic,
+			   TUI_SRC_WIN->generic.type,
 			   srcHeight,
-			   srcWin->generic.width,
-			   srcWin->detail.sourceInfo.executionInfo->width,
+			   TUI_SRC_WIN->generic.width,
+			   TUI_SRC_WIN->detail.source_info.execution_info->width,
 			   0);
-	  srcWin->canHighlight = TRUE;
-	  _initGenWinInfo (srcWin->detail.sourceInfo.executionInfo,
+	  TUI_SRC_WIN->can_highlight = TRUE;
+	  _initGenWinInfo (TUI_SRC_WIN->detail.source_info.execution_info,
 			   EXEC_INFO_WIN,
 			   srcHeight,
 			   3,
 			   0,
 			   0);
-	  tui_make_visible (&srcWin->generic);
-	  tui_make_visible (srcWin->detail.sourceInfo.executionInfo);
-	  srcWin->detail.sourceInfo.hasLocator = FALSE;;
+	  tui_make_visible (&TUI_SRC_WIN->generic);
+	  tui_make_visible (TUI_SRC_WIN->detail.source_info.execution_info);
+	  TUI_SRC_WIN->detail.source_info.has_locator = FALSE;;
 	}
-      if (m_winPtrNotNull (srcWin))
+      if (TUI_SRC_WIN != NULL)
 	{
 	  struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
 
-	  tui_show_source_content (srcWin);
-	  if (m_winPtrIsNull (disassemWin))
+	  tui_show_source_content (TUI_SRC_WIN);
+	  if (TUI_DISASM_WIN == NULL)
 	    {
-	      _makeDisassemWindow (&disassemWin, asmHeight, srcHeight - 1);
+	      _makeDisassemWindow (&TUI_DISASM_WIN, asmHeight, srcHeight - 1);
 	      _initAndMakeWin ((void **) & locator,
 			       LOCATOR_WIN,
 			       2 /* 1 */ ,
@@ -820,49 +820,49 @@ _showSourceDisassemCommand (void)
 			       tui_term_width (),
 			       0,
 			       (srcHeight + asmHeight) - 1);
-	      disassemWin->detail.sourceInfo.hasLocator = TRUE;
+	      TUI_DISASM_WIN->detail.source_info.has_locator = TRUE;
 	      _initGenWinInfo (
-				&disassemWin->generic,
-				disassemWin->generic.type,
+				&TUI_DISASM_WIN->generic,
+				TUI_DISASM_WIN->generic.type,
 				asmHeight,
-				disassemWin->generic.width,
-			disassemWin->detail.sourceInfo.executionInfo->width,
+				TUI_DISASM_WIN->generic.width,
+			TUI_DISASM_WIN->detail.source_info.execution_info->width,
 				srcHeight - 1);
-	      _initGenWinInfo (disassemWin->detail.sourceInfo.executionInfo,
+	      _initGenWinInfo (TUI_DISASM_WIN->detail.source_info.execution_info,
 			       EXEC_INFO_WIN,
 			       asmHeight,
 			       3,
 			       0,
 			       srcHeight - 1);
-	      disassemWin->canHighlight = TRUE;
-	      tui_make_visible (&disassemWin->generic);
-	      tui_make_visible (disassemWin->detail.sourceInfo.executionInfo);
+	      TUI_DISASM_WIN->can_highlight = TRUE;
+	      tui_make_visible (&TUI_DISASM_WIN->generic);
+	      tui_make_visible (TUI_DISASM_WIN->detail.source_info.execution_info);
 	    }
-	  if (m_winPtrNotNull (disassemWin))
+	  if (TUI_DISASM_WIN != NULL)
 	    {
-	      srcWin->detail.sourceInfo.hasLocator = FALSE;
-	      disassemWin->detail.sourceInfo.hasLocator = TRUE;
+	      TUI_SRC_WIN->detail.source_info.has_locator = FALSE;
+	      TUI_DISASM_WIN->detail.source_info.has_locator = TRUE;
 	      tui_make_visible (locator);
 	      tui_show_locator_content ();
-	      tui_show_source_content (disassemWin);
+	      tui_show_source_content (TUI_DISASM_WIN);
 
-	      if (m_winPtrIsNull (cmdWin))
-		_makeCommandWindow (&cmdWin,
+	      if (TUI_CMD_WIN == NULL)
+		_makeCommandWindow (&TUI_CMD_WIN,
 				    cmdHeight,
 				    tui_term_height () - cmdHeight);
 	      else
 		{
-		  _initGenWinInfo (&cmdWin->generic,
-				   cmdWin->generic.type,
-				   cmdWin->generic.height,
-				   cmdWin->generic.width,
+		  _initGenWinInfo (&TUI_CMD_WIN->generic,
+				   TUI_CMD_WIN->generic.type,
+				   TUI_CMD_WIN->generic.height,
+				   TUI_CMD_WIN->generic.width,
 				   0,
-				   cmdWin->generic.origin.y);
-		  cmdWin->canHighlight = FALSE;
-		  tui_make_visible (&cmdWin->generic);
+				   TUI_CMD_WIN->generic.origin.y);
+		  TUI_CMD_WIN->can_highlight = FALSE;
+		  tui_make_visible (&TUI_CMD_WIN->generic);
 		}
-	      if (m_winPtrNotNull (cmdWin))
-		tui_refresh_win (&cmdWin->generic);
+	      if (TUI_CMD_WIN != NULL)
+		tui_refresh_win (&TUI_CMD_WIN->generic);
 	    }
 	}
       tui_set_current_layout_to (SRC_DISASSEM_COMMAND);
@@ -879,7 +879,7 @@ _showSourceDisassemCommand (void)
 static void
 _showData (enum tui_layout_type newLayout)
 {
-  int totalHeight = (tui_term_height () - cmdWin->generic.height);
+  int totalHeight = (tui_term_height () - TUI_CMD_WIN->generic.height);
   int srcHeight, dataHeight;
   enum tui_win_type winType;
   struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
@@ -889,18 +889,18 @@ _showData (enum tui_layout_type newLayout)
   srcHeight = totalHeight - dataHeight;
   tui_make_all_invisible ();
   tui_make_invisible (locator);
-  _makeDataWindow (&dataWin, dataHeight, 0);
-  dataWin->canHighlight = TRUE;
+  _makeDataWindow (&TUI_DATA_WIN, dataHeight, 0);
+  TUI_DATA_WIN->can_highlight = TRUE;
   if (newLayout == SRC_DATA_COMMAND)
     winType = SRC_WIN;
   else
     winType = DISASSEM_WIN;
-  if (m_winPtrIsNull (winList[winType]))
+  if (tui_win_list[winType] == NULL)
     {
       if (winType == SRC_WIN)
-	_makeSourceWindow (&winList[winType], srcHeight, dataHeight - 1);
+	_makeSourceWindow (&tui_win_list[winType], srcHeight, dataHeight - 1);
       else
-	_makeDisassemWindow (&winList[winType], srcHeight, dataHeight - 1);
+	_makeDisassemWindow (&tui_win_list[winType], srcHeight, dataHeight - 1);
       _initAndMakeWin ((void **) & locator,
 		       LOCATOR_WIN,
 		       2 /* 1 */ ,
@@ -911,20 +911,20 @@ _showData (enum tui_layout_type newLayout)
     }
   else
     {
-      _initGenWinInfo (&winList[winType]->generic,
-		       winList[winType]->generic.type,
+      _initGenWinInfo (&tui_win_list[winType]->generic,
+		       tui_win_list[winType]->generic.type,
 		       srcHeight,
-		       winList[winType]->generic.width,
-		   winList[winType]->detail.sourceInfo.executionInfo->width,
+		       tui_win_list[winType]->generic.width,
+		   tui_win_list[winType]->detail.source_info.execution_info->width,
 		       dataHeight - 1);
-      _initGenWinInfo (winList[winType]->detail.sourceInfo.executionInfo,
+      _initGenWinInfo (tui_win_list[winType]->detail.source_info.execution_info,
 		       EXEC_INFO_WIN,
 		       srcHeight,
 		       3,
 		       0,
 		       dataHeight - 1);
-      tui_make_visible (&winList[winType]->generic);
-      tui_make_visible (winList[winType]->detail.sourceInfo.executionInfo);
+      tui_make_visible (&tui_win_list[winType]->generic);
+      tui_make_visible (tui_win_list[winType]->detail.source_info.execution_info);
       _initGenWinInfo (locator,
 		       LOCATOR_WIN,
 		       2 /* 1 */ ,
@@ -932,10 +932,10 @@ _showData (enum tui_layout_type newLayout)
 		       0,
 		       totalHeight - 1);
     }
-  winList[winType]->detail.sourceInfo.hasLocator = TRUE;
+  tui_win_list[winType]->detail.source_info.has_locator = TRUE;
   tui_make_visible (locator);
   tui_show_locator_content ();
-  tui_add_to_source_windows (winList[winType]);
+  tui_add_to_source_windows (tui_win_list[winType]);
   tui_set_current_layout_to (newLayout);
 
   return;
@@ -955,12 +955,12 @@ _initGenWinInfo (struct tui_gen_win_info * winInfo, enum tui_win_type type,
   winInfo->height = h;
   if (h > 1)
     {
-      winInfo->viewportHeight = h - 1;
+      winInfo->viewport_height = h - 1;
       if (winInfo->type != CMD_WIN)
-	winInfo->viewportHeight--;
+	winInfo->viewport_height--;
     }
   else
-    winInfo->viewportHeight = 1;
+    winInfo->viewport_height = 1;
   winInfo->origin.x = originX;
   winInfo->origin.y = originY;
 
@@ -979,12 +979,12 @@ _initAndMakeWin (void ** winInfoPtr, enum tui_win_type winType,
 
   if (opaqueWinInfo == NULL)
     {
-      if (m_winIsAuxillary (winType))
+      if (tui_win_is_auxillary (winType))
 	opaqueWinInfo = (void *) tui_alloc_generic_win_info ();
       else
 	opaqueWinInfo = (void *) tui_alloc_win_info (winType);
     }
-  if (m_winIsAuxillary (winType))
+  if (tui_win_is_auxillary (winType))
     generic = (struct tui_gen_win_info *) opaqueWinInfo;
   else
     generic = &((struct tui_win_info *) opaqueWinInfo)->generic;
@@ -992,12 +992,12 @@ _initAndMakeWin (void ** winInfoPtr, enum tui_win_type winType,
   if (opaqueWinInfo != NULL)
     {
       _initGenWinInfo (generic, winType, height, width, originX, originY);
-      if (!m_winIsAuxillary (winType))
+      if (!tui_win_is_auxillary (winType))
 	{
 	  if (generic->type == CMD_WIN)
-	    ((struct tui_win_info *) opaqueWinInfo)->canHighlight = FALSE;
+	    ((struct tui_win_info *) opaqueWinInfo)->can_highlight = FALSE;
 	  else
-	    ((struct tui_win_info *) opaqueWinInfo)->canHighlight = TRUE;
+	    ((struct tui_win_info *) opaqueWinInfo)->can_highlight = TRUE;
 	}
       tui_make_window (generic, boxIt);
     }
@@ -1012,16 +1012,16 @@ static void
 _makeSourceOrDisassemWindow (struct tui_win_info * * winInfoPtr, enum tui_win_type type,
                              int height, int originY)
 {
-  struct tui_gen_win_info * executionInfo = (struct tui_gen_win_info *) NULL;
+  struct tui_gen_win_info * execution_info = (struct tui_gen_win_info *) NULL;
 
   /*
      ** Create the exeuction info window.
    */
   if (type == SRC_WIN)
-    executionInfo = tui_source_exec_info_win_ptr ();
+    execution_info = tui_source_exec_info_win_ptr ();
   else
-    executionInfo = tui_disassem_exec_info_win_ptr ();
-  _initAndMakeWin ((void **) & executionInfo,
+    execution_info = tui_disassem_exec_info_win_ptr ();
+  _initAndMakeWin ((void **) & execution_info,
 		   EXEC_INFO_WIN,
 		   height,
 		   3,
@@ -1034,12 +1034,12 @@ _makeSourceOrDisassemWindow (struct tui_win_info * * winInfoPtr, enum tui_win_ty
   _initAndMakeWin ((void **) winInfoPtr,
 		   type,
 		   height,
-		   tui_term_width () - executionInfo->width,
-		   executionInfo->width,
+		   tui_term_width () - execution_info->width,
+		   execution_info->width,
 		   originY,
 		   BOX_WINDOW);
 
-  (*winInfoPtr)->detail.sourceInfo.executionInfo = executionInfo;
+  (*winInfoPtr)->detail.source_info.execution_info = execution_info;
 
   return;
 }				/* _makeSourceOrDisassemWindow */
@@ -1058,19 +1058,19 @@ _showSourceOrDisassemAndCommand (enum tui_layout_type layoutType)
       int srcHeight, cmdHeight;
       struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
 
-      if (m_winPtrNotNull (cmdWin))
-	cmdHeight = cmdWin->generic.height;
+      if (TUI_CMD_WIN != NULL)
+	cmdHeight = TUI_CMD_WIN->generic.height;
       else
 	cmdHeight = tui_term_height () / 3;
       srcHeight = tui_term_height () - cmdHeight;
 
 
       if (layoutType == SRC_COMMAND)
-	winInfoPtr = &srcWin;
+	winInfoPtr = &TUI_SRC_WIN;
       else
-	winInfoPtr = &disassemWin;
+	winInfoPtr = &TUI_DISASM_WIN;
 
-      if (m_winPtrIsNull (*winInfoPtr))
+      if ((*winInfoPtr) == NULL)
 	{
 	  if (layoutType == SRC_COMMAND)
 	    _makeSourceWindow (winInfoPtr, srcHeight - 1, 0);
@@ -1092,46 +1092,46 @@ _showSourceOrDisassemAndCommand (enum tui_layout_type layoutType)
 			   tui_term_width (),
 			   0,
 			   srcHeight - 1);
-	  (*winInfoPtr)->detail.sourceInfo.hasLocator = TRUE;
+	  (*winInfoPtr)->detail.source_info.has_locator = TRUE;
 	  _initGenWinInfo (
 			    &(*winInfoPtr)->generic,
 			    (*winInfoPtr)->generic.type,
 			    srcHeight - 1,
 			    (*winInfoPtr)->generic.width,
-		      (*winInfoPtr)->detail.sourceInfo.executionInfo->width,
+		      (*winInfoPtr)->detail.source_info.execution_info->width,
 			    0);
-	  _initGenWinInfo ((*winInfoPtr)->detail.sourceInfo.executionInfo,
+	  _initGenWinInfo ((*winInfoPtr)->detail.source_info.execution_info,
 			   EXEC_INFO_WIN,
 			   srcHeight - 1,
 			   3,
 			   0,
 			   0);
-	  (*winInfoPtr)->canHighlight = TRUE;
+	  (*winInfoPtr)->can_highlight = TRUE;
 	  tui_make_visible (&(*winInfoPtr)->generic);
-	  tui_make_visible ((*winInfoPtr)->detail.sourceInfo.executionInfo);
+	  tui_make_visible ((*winInfoPtr)->detail.source_info.execution_info);
 	}
-      if (m_winPtrNotNull (*winInfoPtr))
+      if ((*winInfoPtr) != NULL)
 	{
-	  (*winInfoPtr)->detail.sourceInfo.hasLocator = TRUE;
+	  (*winInfoPtr)->detail.source_info.has_locator = TRUE;
 	  tui_make_visible (locator);
 	  tui_show_locator_content ();
 	  tui_show_source_content (*winInfoPtr);
 
-	  if (m_winPtrIsNull (cmdWin))
+	  if (TUI_CMD_WIN == NULL)
 	    {
-	      _makeCommandWindow (&cmdWin, cmdHeight, srcHeight);
-	      tui_refresh_win (&cmdWin->generic);
+	      _makeCommandWindow (&TUI_CMD_WIN, cmdHeight, srcHeight);
+	      tui_refresh_win (&TUI_CMD_WIN->generic);
 	    }
 	  else
 	    {
-	      _initGenWinInfo (&cmdWin->generic,
-			       cmdWin->generic.type,
-			       cmdWin->generic.height,
-			       cmdWin->generic.width,
-			       cmdWin->generic.origin.x,
-			       cmdWin->generic.origin.y);
-	      cmdWin->canHighlight = FALSE;
-	      tui_make_visible (&cmdWin->generic);
+	      _initGenWinInfo (&TUI_CMD_WIN->generic,
+			       TUI_CMD_WIN->generic.type,
+			       TUI_CMD_WIN->generic.height,
+			       TUI_CMD_WIN->generic.width,
+			       TUI_CMD_WIN->generic.origin.x,
+			       TUI_CMD_WIN->generic.origin.y);
+	      TUI_CMD_WIN->can_highlight = FALSE;
+	      tui_make_visible (&TUI_CMD_WIN->generic);
 	    }
 	}
       tui_set_current_layout_to (layoutType);
diff --git a/gdb/tui/tui-regs.c b/gdb/tui/tui-regs.c
index e5222c297ca..ad70a880b68 100644
--- a/gdb/tui/tui-regs.c
+++ b/gdb/tui/tui-regs.c
@@ -32,6 +32,7 @@
 #include "regcache.h"
 #include "inferior.h"
 #include "target.h"
+#include "gdb_string.h"
 #include "tui/tui-layout.h"
 #include "tui/tui-win.h"
 #include "tui/tui-windata.h"
@@ -112,12 +113,12 @@ tui_last_regs_line_no (void)
 {
   register int numLines = (-1);
 
-  if (dataWin->detail.dataDisplayInfo.regsContentCount > 0)
+  if (TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
     {
-      numLines = (dataWin->detail.dataDisplayInfo.regsContentCount /
-		  dataWin->detail.dataDisplayInfo.regsColumnCount);
-      if (dataWin->detail.dataDisplayInfo.regsContentCount %
-	  dataWin->detail.dataDisplayInfo.regsColumnCount)
+      numLines = (TUI_DATA_WIN->detail.data_display_info.regs_content_count /
+		  TUI_DATA_WIN->detail.data_display_info.regs_column_count);
+      if (TUI_DATA_WIN->detail.data_display_info.regs_content_count %
+	  TUI_DATA_WIN->detail.data_display_info.regs_column_count)
 	numLines++;
     }
   return numLines;
@@ -130,7 +131,7 @@ tui_last_regs_line_no (void)
 int
 tui_line_from_reg_element_no (int elementNo)
 {
-  if (elementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
+  if (elementNo < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
     {
       int i, line = (-1);
 
@@ -138,7 +139,7 @@ tui_line_from_reg_element_no (int elementNo)
       while (line == (-1))
 	{
 	  if (elementNo <
-	      (dataWin->detail.dataDisplayInfo.regsColumnCount * i))
+	      (TUI_DATA_WIN->detail.data_display_info.regs_column_count * i))
 	    line = i - 1;
 	  else
 	    i++;
@@ -156,11 +157,11 @@ tui_line_from_reg_element_no (int elementNo)
 int
 tui_first_reg_element_no_inline (int lineNo)
 {
-  if ((lineNo * dataWin->detail.dataDisplayInfo.regsColumnCount)
-      <= dataWin->detail.dataDisplayInfo.regsContentCount)
+  if ((lineNo * TUI_DATA_WIN->detail.data_display_info.regs_column_count)
+      <= TUI_DATA_WIN->detail.data_display_info.regs_content_count)
     return ((lineNo + 1) *
-	    dataWin->detail.dataDisplayInfo.regsColumnCount) -
-      dataWin->detail.dataDisplayInfo.regsColumnCount;
+	    TUI_DATA_WIN->detail.data_display_info.regs_column_count) -
+      TUI_DATA_WIN->detail.data_display_info.regs_column_count;
   else
     return (-1);
 }
@@ -174,10 +175,10 @@ tui_first_reg_element_no_inline (int lineNo)
 int
 tuiLastRegElementNoInLine (int lineNo)
 {
-  if ((lineNo * dataWin->detail.dataDisplayInfo.regsColumnCount) <=
-      dataWin->detail.dataDisplayInfo.regsContentCount)
+  if ((lineNo * TUI_DATA_WIN->detail.data_display_info.regs_column_count) <=
+      TUI_DATA_WIN->detail.data_display_info.regs_content_count)
     return ((lineNo + 1) *
-	    dataWin->detail.dataDisplayInfo.regsColumnCount) - 1;
+	    TUI_DATA_WIN->detail.data_display_info.regs_column_count) - 1;
   else
     return (-1);
 }				/* tuiLastRegElementNoInLine */
@@ -199,10 +200,10 @@ tui_calculate_regs_column_count (enum tui_register_display_type dpyType)
       else
 	colWidth = SINGLE_VALUE_WIDTH + SINGLE_LABEL_WIDTH;
     }
-  colCount = (dataWin->generic.width - 2) / colWidth;
+  colCount = (TUI_DATA_WIN->generic.width - 2) / colWidth;
 
   return colCount;
-}				/* tuiCalulateRegsColumnCount */
+}				/* tuiCalulateRegs_column_count */
 
 
 /* Show the registers int the data window as indicated by dpyType.  If
@@ -215,12 +216,12 @@ tui_show_registers (enum tui_register_display_type dpyType)
   int refreshValuesOnly = FALSE;
 
   /* Say that registers should be displayed, even if there is a problem */
-  dataWin->detail.dataDisplayInfo.displayRegs = TRUE;
+  TUI_DATA_WIN->detail.data_display_info.display_regs = TRUE;
 
   if (target_has_registers)
     {
       refreshValuesOnly =
-	(dpyType == dataWin->detail.dataDisplayInfo.regsDisplayType);
+	(dpyType == TUI_DATA_WIN->detail.data_display_info.regs_display_type);
       switch (dpyType)
 	{
 	case TUI_GENERAL_REGS:
@@ -248,7 +249,7 @@ tui_show_registers (enum tui_register_display_type dpyType)
     }
   if (ret == TUI_FAILURE)
     {
-      dataWin->detail.dataDisplayInfo.regsDisplayType = TUI_UNDEFINED_REGS;
+      TUI_DATA_WIN->detail.data_display_info.regs_display_type = TUI_UNDEFINED_REGS;
       tui_erase_data_content (NO_REGS_STRING);
     }
   else
@@ -256,19 +257,19 @@ tui_show_registers (enum tui_register_display_type dpyType)
       int i;
 
       /* Clear all notation of changed values */
-      for (i = 0; (i < dataWin->detail.dataDisplayInfo.regsContentCount); i++)
+      for (i = 0; (i < TUI_DATA_WIN->detail.data_display_info.regs_content_count); i++)
 	{
 	  struct tui_gen_win_info * dataItemWin;
 
-	  dataItemWin = &dataWin->detail.dataDisplayInfo.
-	    regsContent[i]->whichElement.dataWindow;
+	  dataItemWin = &TUI_DATA_WIN->detail.data_display_info.
+	    regs_content[i]->which_element.data_window;
 	  (&((struct tui_win_element *)
-	     dataItemWin->content[0])->whichElement.data)->highlight = FALSE;
+	     dataItemWin->content[0])->which_element.data)->highlight = FALSE;
 	}
-      dataWin->detail.dataDisplayInfo.regsDisplayType = dpyType;
+      TUI_DATA_WIN->detail.data_display_info.regs_display_type = dpyType;
       tui_display_all_data ();
     }
-  (tui_layout_def ())->regsDisplayType = dpyType;
+  (tui_layout_def ())->regs_display_type = dpyType;
 
   return;
 }
@@ -281,25 +282,25 @@ tui_show_registers (enum tui_register_display_type dpyType)
 void
 tui_display_registers_from (int startElementNo)
 {
-  if (dataWin->detail.dataDisplayInfo.regsContent != (tui_win_content) NULL &&
-      dataWin->detail.dataDisplayInfo.regsContentCount > 0)
+  if (TUI_DATA_WIN->detail.data_display_info.regs_content != (tui_win_content) NULL &&
+      TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
     {
       register int i = startElementNo;
       int j, valueCharsWide, itemWinWidth, curY, labelWidth;
       enum precision_type precision;
 
-      precision = (dataWin->detail.dataDisplayInfo.regsDisplayType
+      precision = (TUI_DATA_WIN->detail.data_display_info.regs_display_type
 		   == TUI_DFLOAT_REGS) ?
 	double_precision : unspecified_precision;
       if (IS_64BIT ||
-	  dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_DFLOAT_REGS)
+	  TUI_DATA_WIN->detail.data_display_info.regs_display_type == TUI_DFLOAT_REGS)
 	{
 	  valueCharsWide = DOUBLE_FLOAT_VALUE_WIDTH;
 	  labelWidth = DOUBLE_FLOAT_LABEL_WIDTH;
 	}
       else
 	{
-	  if (dataWin->detail.dataDisplayInfo.regsDisplayType ==
+	  if (TUI_DATA_WIN->detail.data_display_info.regs_display_type ==
 	      TUI_SFLOAT_REGS)
 	    {
 	      valueCharsWide = SINGLE_FLOAT_VALUE_WIDTH;
@@ -316,21 +317,21 @@ tui_display_registers_from (int startElementNo)
          ** Now create each data "sub" window, and write the display into it.
        */
       curY = 1;
-      while (i < dataWin->detail.dataDisplayInfo.regsContentCount &&
-	     curY <= dataWin->generic.viewportHeight)
+      while (i < TUI_DATA_WIN->detail.data_display_info.regs_content_count &&
+	     curY <= TUI_DATA_WIN->generic.viewport_height)
 	{
 	  for (j = 0;
-	       (j < dataWin->detail.dataDisplayInfo.regsColumnCount &&
-		i < dataWin->detail.dataDisplayInfo.regsContentCount); j++)
+	       (j < TUI_DATA_WIN->detail.data_display_info.regs_column_count &&
+		i < TUI_DATA_WIN->detail.data_display_info.regs_content_count); j++)
 	    {
 	      struct tui_gen_win_info * dataItemWin;
 	      struct tui_data_element * dataElementPtr;
 
 	      /* create the window if necessary */
-	      dataItemWin = &dataWin->detail.dataDisplayInfo.
-		regsContent[i]->whichElement.dataWindow;
+	      dataItemWin = &TUI_DATA_WIN->detail.data_display_info.
+		regs_content[i]->which_element.data_window;
 	      dataElementPtr = &((struct tui_win_element *)
-				 dataItemWin->content[0])->whichElement.data;
+				 dataItemWin->content[0])->which_element.data;
 	      if (dataItemWin->handle == (WINDOW *) NULL)
 		{
 		  dataItemWin->height = 1;
@@ -348,7 +349,7 @@ tui_display_registers_from (int startElementNo)
 	         ** and display it
 	       */
 	      _tuiDisplayRegister (
-			    dataElementPtr->itemNo, dataItemWin, precision);
+			    dataElementPtr->item_no, dataItemWin, precision);
 	      i++;		/* next register */
 	    }
 	  curY++;		/* next row; */
@@ -370,8 +371,8 @@ tui_display_registers_from (int startElementNo)
 void
 tuiDisplayRegElementAtLine (int startElementNo, int startLineNo)
 {
-  if (dataWin->detail.dataDisplayInfo.regsContent != (tui_win_content) NULL &&
-      dataWin->detail.dataDisplayInfo.regsContentCount > 0)
+  if (TUI_DATA_WIN->detail.data_display_info.regs_content != (tui_win_content) NULL &&
+      TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
     {
       register int elementNo = startElementNo;
 
@@ -380,7 +381,7 @@ tuiDisplayRegElementAtLine (int startElementNo, int startLineNo)
 	  register int lastLineNo, firstLineOnLastPage;
 
 	  lastLineNo = tui_last_regs_line_no ();
-	  firstLineOnLastPage = lastLineNo - (dataWin->generic.height - 2);
+	  firstLineOnLastPage = lastLineNo - (TUI_DATA_WIN->generic.height - 2);
 	  if (firstLineOnLastPage < 0)
 	    firstLineOnLastPage = 0;
 	  /*
@@ -388,7 +389,7 @@ tuiDisplayRegElementAtLine (int startElementNo, int startLineNo)
 	     ** and the elementNo causes us to scroll past the end of the
 	     ** registers, adjust what element to really start the display at.
 	   */
-	  if (dataWin->detail.dataDisplayInfo.dataContentCount <= 0 &&
+	  if (TUI_DATA_WIN->detail.data_display_info.data_content_count <= 0 &&
 	      startLineNo > firstLineOnLastPage)
 	    elementNo = tui_first_reg_element_no_inline (firstLineOnLastPage);
 	}
@@ -406,7 +407,7 @@ tuiDisplayRegElementAtLine (int startElementNo, int startLineNo)
 int
 tui_display_registers_from_line (int lineNo, int forceDisplay)
 {
-  if (dataWin->detail.dataDisplayInfo.regsContentCount > 0)
+  if (TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
     {
       int line, elementNo;
 
@@ -420,7 +421,7 @@ tui_display_registers_from_line (int lineNo, int forceDisplay)
 	  if (lineNo >= tui_last_regs_line_no ())
 	    {
 	      if ((line = tui_line_from_reg_element_no (
-		 dataWin->detail.dataDisplayInfo.regsContentCount - 1)) < 0)
+		 TUI_DATA_WIN->detail.data_display_info.regs_content_count - 1)) < 0)
 		line = 0;
 	    }
 	  else
@@ -430,7 +431,7 @@ tui_display_registers_from_line (int lineNo, int forceDisplay)
 	line = lineNo;
 
       elementNo = tui_first_reg_element_no_inline (line);
-      if (elementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
+      if (elementNo < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
 	tuiDisplayRegElementAtLine (elementNo, line);
       else
 	line = (-1);
@@ -448,27 +449,27 @@ tui_display_registers_from_line (int lineNo, int forceDisplay)
 void
 tui_check_register_values (struct frame_info *frame)
 {
-  if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
+  if (TUI_DATA_WIN != NULL && TUI_DATA_WIN->generic.is_visible)
     {
-      if (dataWin->detail.dataDisplayInfo.regsContentCount <= 0 &&
-	  dataWin->detail.dataDisplayInfo.displayRegs)
-	tui_show_registers ((tui_layout_def ())->regsDisplayType);
+      if (TUI_DATA_WIN->detail.data_display_info.regs_content_count <= 0 &&
+	  TUI_DATA_WIN->detail.data_display_info.display_regs)
+	tui_show_registers ((tui_layout_def ())->regs_display_type);
       else
 	{
 	  int i, j;
 	  char rawBuf[MAX_REGISTER_SIZE];
 
 	  for (i = 0;
-	       (i < dataWin->detail.dataDisplayInfo.regsContentCount); i++)
+	       (i < TUI_DATA_WIN->detail.data_display_info.regs_content_count); i++)
 	    {
 	      struct tui_data_element * dataElementPtr;
 	      struct tui_gen_win_info * dataItemWinPtr;
 	      int wasHilighted;
 
-	      dataItemWinPtr = &dataWin->detail.dataDisplayInfo.
-		regsContent[i]->whichElement.dataWindow;
+	      dataItemWinPtr = &TUI_DATA_WIN->detail.data_display_info.
+		regs_content[i]->which_element.data_window;
 	      dataElementPtr = &((struct tui_win_element *)
-			     dataItemWinPtr->content[0])->whichElement.data;
+			     dataItemWinPtr->content[0])->which_element.data;
 	      wasHilighted = dataElementPtr->highlight;
 	      dataElementPtr->highlight =
 		_tuiRegValueHasChanged (dataElementPtr, frame, &rawBuf[0]);
@@ -476,13 +477,13 @@ tui_check_register_values (struct frame_info *frame)
 		{
                   int size;
 
-                  size = DEPRECATED_REGISTER_RAW_SIZE (dataElementPtr->itemNo);
+                  size = DEPRECATED_REGISTER_RAW_SIZE (dataElementPtr->item_no);
 		  for (j = 0; j < size; j++)
 		    ((char *) dataElementPtr->value)[j] = rawBuf[j];
 		  _tuiDisplayRegister (
-					dataElementPtr->itemNo,
+					dataElementPtr->item_no,
 					dataItemWinPtr,
-			((dataWin->detail.dataDisplayInfo.regsDisplayType ==
+			((TUI_DATA_WIN->detail.data_display_info.regs_display_type ==
 			  TUI_DFLOAT_REGS) ?
 			 double_precision : unspecified_precision));
 		}
@@ -490,9 +491,9 @@ tui_check_register_values (struct frame_info *frame)
 		{
 		  dataElementPtr->highlight = FALSE;
 		  _tuiDisplayRegister (
-					dataElementPtr->itemNo,
+					dataElementPtr->item_no,
 					dataItemWinPtr,
-			((dataWin->detail.dataDisplayInfo.regsDisplayType ==
+			((TUI_DATA_WIN->detail.data_display_info.regs_display_type ==
 			  TUI_DFLOAT_REGS) ?
 			 double_precision : unspecified_precision));
 		}
@@ -511,15 +512,15 @@ tuiToggleFloatRegs (void)
 {
   struct tui_layout_def * layoutDef = tui_layout_def ();
 
-  if (layoutDef->floatRegsDisplayType == TUI_SFLOAT_REGS)
-    layoutDef->floatRegsDisplayType = TUI_DFLOAT_REGS;
+  if (layoutDef->float_regs_display_type == TUI_SFLOAT_REGS)
+    layoutDef->float_regs_display_type = TUI_DFLOAT_REGS;
   else
-    layoutDef->floatRegsDisplayType = TUI_SFLOAT_REGS;
+    layoutDef->float_regs_display_type = TUI_SFLOAT_REGS;
 
-  if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible &&
-      (dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_SFLOAT_REGS ||
-       dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_DFLOAT_REGS))
-    tui_show_registers (layoutDef->floatRegsDisplayType);
+  if (TUI_DATA_WIN != NULL && TUI_DATA_WIN->generic.is_visible &&
+      (TUI_DATA_WIN->detail.data_display_info.regs_display_type == TUI_SFLOAT_REGS ||
+       TUI_DATA_WIN->detail.data_display_info.regs_display_type == TUI_DFLOAT_REGS))
+    tui_show_registers (layoutDef->float_regs_display_type);
 
   return;
 }				/* tuiToggleFloatRegs */
@@ -730,16 +731,16 @@ _tuiRegValueHasChanged (struct tui_data_element * dataElement,
 {
   int hasChanged = FALSE;
 
-  if (dataElement->itemNo != UNDEFINED_ITEM &&
-      _tuiRegisterName (dataElement->itemNo) != (char *) NULL)
+  if (dataElement->item_no != UNDEFINED_ITEM &&
+      _tuiRegisterName (dataElement->item_no) != (char *) NULL)
     {
       char rawBuf[MAX_REGISTER_SIZE];
       int i;
 
       if (_tuiGetRegisterRawValue (
-			 dataElement->itemNo, rawBuf, frame) == TUI_SUCCESS)
+			 dataElement->item_no, rawBuf, frame) == TUI_SUCCESS)
 	{
-          int size = DEPRECATED_REGISTER_RAW_SIZE (dataElement->itemNo);
+          int size = DEPRECATED_REGISTER_RAW_SIZE (dataElement->item_no);
           
 	  for (i = 0; (i < size && !hasChanged); i++)
 	    hasChanged = (((char *) dataElement->value)[i] != rawBuf[i]);
@@ -792,7 +793,7 @@ _tuiSetRegisterElement (int regNum, struct frame_info *frame,
     {
       if (!refreshValueOnly)
 	{
-	  dataElement->itemNo = regNum;
+	  dataElement->item_no = regNum;
 	  dataElement->name = _tuiRegisterName (regNum);
 	  dataElement->highlight = FALSE;
 	}
@@ -822,32 +823,32 @@ _tuiSetRegsContent (int startRegNum, int endRegNum,
   int numRegs = endRegNum - startRegNum + 1;
   int allocatedHere = FALSE;
 
-  if (dataWin->detail.dataDisplayInfo.regsContentCount > 0 &&
+  if (TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0 &&
       !refreshValuesOnly)
     {
-      tui_free_data_content (dataWin->detail.dataDisplayInfo.regsContent,
-			     dataWin->detail.dataDisplayInfo.regsContentCount);
-      dataWin->detail.dataDisplayInfo.regsContentCount = 0;
+      tui_free_data_content (TUI_DATA_WIN->detail.data_display_info.regs_content,
+			     TUI_DATA_WIN->detail.data_display_info.regs_content_count);
+      TUI_DATA_WIN->detail.data_display_info.regs_content_count = 0;
     }
-  if (dataWin->detail.dataDisplayInfo.regsContentCount <= 0)
+  if (TUI_DATA_WIN->detail.data_display_info.regs_content_count <= 0)
     {
-      dataWin->detail.dataDisplayInfo.regsContent =
+      TUI_DATA_WIN->detail.data_display_info.regs_content =
 	tui_alloc_content (numRegs, DATA_WIN);
       allocatedHere = TRUE;
     }
 
-  if (dataWin->detail.dataDisplayInfo.regsContent != (tui_win_content) NULL)
+  if (TUI_DATA_WIN->detail.data_display_info.regs_content != (tui_win_content) NULL)
     {
       int i;
 
       if (!refreshValuesOnly || allocatedHere)
 	{
-	  dataWin->generic.content = NULL;
-	  dataWin->generic.contentSize = 0;
-	  tui_add_content_elements (&dataWin->generic, numRegs);
-	  dataWin->detail.dataDisplayInfo.regsContent =
-	    (tui_win_content) dataWin->generic.content;
-	  dataWin->detail.dataDisplayInfo.regsContentCount = numRegs;
+	  TUI_DATA_WIN->generic.content = NULL;
+	  TUI_DATA_WIN->generic.content_size = 0;
+	  tui_add_content_elements (&TUI_DATA_WIN->generic, numRegs);
+	  TUI_DATA_WIN->detail.data_display_info.regs_content =
+	    (tui_win_content) TUI_DATA_WIN->generic.content;
+	  TUI_DATA_WIN->detail.data_display_info.regs_content_count = numRegs;
 	}
       /*
          ** Now set the register names and values
@@ -856,27 +857,27 @@ _tuiSetRegsContent (int startRegNum, int endRegNum,
 	{
 	  struct tui_gen_win_info * dataItemWin;
 
-	  dataItemWin = &dataWin->detail.dataDisplayInfo.
-	    regsContent[i - startRegNum]->whichElement.dataWindow;
+	  dataItemWin = &TUI_DATA_WIN->detail.data_display_info.
+	    regs_content[i - startRegNum]->which_element.data_window;
 	  _tuiSetRegisterElement (
 				   i,
 				   frame,
-	   &((struct tui_win_element *) dataItemWin->content[0])->whichElement.data,
+	   &((struct tui_win_element *) dataItemWin->content[0])->which_element.data,
 				   !allocatedHere && refreshValuesOnly);
 	}
-      dataWin->detail.dataDisplayInfo.regsColumnCount =
+      TUI_DATA_WIN->detail.data_display_info.regs_column_count =
 	tui_calculate_regs_column_count (dpyType);
 #ifdef LATER
-      if (dataWin->detail.dataDisplayInfo.dataContentCount > 0)
+      if (TUI_DATA_WIN->detail.data_display_info.data_content_count > 0)
 	{
 	  /* delete all the windows? */
-	  /* realloc content equal to dataContentCount + regsContentCount */
-	  /* append dataWin->detail.dataDisplayInfo.dataContent to content */
+	  /* realloc content equal to data_content_count + regs_content_count */
+	  /* append TUI_DATA_WIN->detail.data_display_info.dataContent to content */
 	}
 #endif
-      dataWin->generic.contentSize =
-	dataWin->detail.dataDisplayInfo.regsContentCount +
-	dataWin->detail.dataDisplayInfo.dataContentCount;
+      TUI_DATA_WIN->generic.content_size =
+	TUI_DATA_WIN->detail.data_display_info.regs_content_count +
+	TUI_DATA_WIN->detail.data_display_info.data_content_count;
       ret = TUI_SUCCESS;
     }
 
@@ -900,17 +901,17 @@ _tuiDisplayRegister (int regNum,
       char buf[40];
       int valueCharsWide, labelWidth;
       struct tui_data_element * dataElementPtr = &((tui_win_content)
-				    winInfo->content)[0]->whichElement.data;
+				    winInfo->content)[0]->which_element.data;
 
       if (IS_64BIT ||
-	  dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_DFLOAT_REGS)
+	  TUI_DATA_WIN->detail.data_display_info.regs_display_type == TUI_DFLOAT_REGS)
 	{
 	  valueCharsWide = DOUBLE_FLOAT_VALUE_WIDTH;
 	  labelWidth = DOUBLE_FLOAT_LABEL_WIDTH;
 	}
       else
 	{
-	  if (dataWin->detail.dataDisplayInfo.regsDisplayType ==
+	  if (TUI_DATA_WIN->detail.data_display_info.regs_display_type ==
 	      TUI_SFLOAT_REGS)
 	    {
 	      valueCharsWide = SINGLE_FLOAT_VALUE_WIDTH;
@@ -951,13 +952,13 @@ static void
 _tui_vShowRegisters_commandSupport (enum tui_register_display_type dpyType)
 {
 
-  if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
+  if (TUI_DATA_WIN != NULL && TUI_DATA_WIN->generic.is_visible)
     {				/* Data window already displayed, show the registers */
-      if (dataWin->detail.dataDisplayInfo.regsDisplayType != dpyType)
+      if (TUI_DATA_WIN->detail.data_display_info.regs_display_type != dpyType)
 	tui_show_registers (dpyType);
     }
   else
-    (tui_layout_def ())->regsDisplayType = dpyType;
+    (tui_layout_def ())->regs_display_type = dpyType;
 
   return;
 }				/* _tui_vShowRegisters_commandSupport */
@@ -966,10 +967,10 @@ _tui_vShowRegisters_commandSupport (enum tui_register_display_type dpyType)
 static void
 _tuiShowFloat_command (char *arg, int fromTTY)
 {
-  if (m_winPtrIsNull (dataWin) || !dataWin->generic.isVisible ||
-      (dataWin->detail.dataDisplayInfo.regsDisplayType != TUI_SFLOAT_REGS &&
-       dataWin->detail.dataDisplayInfo.regsDisplayType != TUI_DFLOAT_REGS))
-    _tui_vShowRegisters_commandSupport ((tui_layout_def ())->floatRegsDisplayType);
+  if (TUI_DATA_WIN == NULL || !TUI_DATA_WIN->generic.is_visible ||
+      (TUI_DATA_WIN->detail.data_display_info.regs_display_type != TUI_SFLOAT_REGS &&
+       TUI_DATA_WIN->detail.data_display_info.regs_display_type != TUI_DFLOAT_REGS))
+    _tui_vShowRegisters_commandSupport ((tui_layout_def ())->float_regs_display_type);
 
   return;
 }				/* _tuiShowFloat_command */
@@ -992,16 +993,16 @@ _tuiShowSpecial_command (char *arg, int fromTTY)
 static void
 _tuiToggleFloatRegs_command (char *arg, int fromTTY)
 {
-  if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
+  if (TUI_DATA_WIN != NULL && TUI_DATA_WIN->generic.is_visible)
     tuiToggleFloatRegs ();
   else
     {
       struct tui_layout_def * layoutDef = tui_layout_def ();
 
-      if (layoutDef->floatRegsDisplayType == TUI_SFLOAT_REGS)
-	layoutDef->floatRegsDisplayType = TUI_DFLOAT_REGS;
+      if (layoutDef->float_regs_display_type == TUI_SFLOAT_REGS)
+	layoutDef->float_regs_display_type = TUI_DFLOAT_REGS;
       else
-	layoutDef->floatRegsDisplayType = TUI_SFLOAT_REGS;
+	layoutDef->float_regs_display_type = TUI_SFLOAT_REGS;
     }
 
 
@@ -1012,12 +1013,12 @@ _tuiToggleFloatRegs_command (char *arg, int fromTTY)
 static void
 _tuiScrollRegsForward_command (char *arg, int fromTTY)
 {
-  tui_scroll (FORWARD_SCROLL, dataWin, 1);
+  tui_scroll (FORWARD_SCROLL, TUI_DATA_WIN, 1);
 }
 
 
 static void
 _tuiScrollRegsBackward_command (char *arg, int fromTTY)
 {
-  tui_scroll (BACKWARD_SCROLL, dataWin, 1);
+  tui_scroll (BACKWARD_SCROLL, TUI_DATA_WIN, 1);
 }
diff --git a/gdb/tui/tui-regs.h b/gdb/tui/tui-regs.h
index 19703a2ccbc..c4de1239c05 100644
--- a/gdb/tui/tui-regs.h
+++ b/gdb/tui/tui-regs.h
@@ -25,7 +25,7 @@
 #ifndef TUI_REGS_H
 #define TUI_REGS_H
 
-#include "tui/tui-data.h"	/* For TuiRegisterDisplayType.  */
+#include "tui/tui-data.h"	/* For struct tui_register_display_type.  */
 
 extern void tui_check_register_values (struct frame_info *);
 extern void tui_show_registers (enum tui_register_display_type);
diff --git a/gdb/tui/tui-source.c b/gdb/tui/tui-source.c
index 530ee434455..7045f711473 100644
--- a/gdb/tui/tui-source.c
+++ b/gdb/tui/tui-source.c
@@ -46,7 +46,7 @@
 
 /* Function to display source in the source window.  */
 enum tui_status
-tui_set_source_content (struct symtab *s, int lineNo, int noerror)
+tui_set_source_content (struct symtab *s, int line_no, int noerror)
 {
   enum tui_status ret = TUI_FAILURE;
 
@@ -56,19 +56,19 @@ tui_set_source_content (struct symtab *s, int lineNo, int noerror)
       register int i, desc, c, lineWidth, nlines;
       register char *srcLine = 0;
 
-      if ((ret = tui_alloc_source_buffer (srcWin)) == TUI_SUCCESS)
+      if ((ret = tui_alloc_source_buffer (TUI_SRC_WIN)) == TUI_SUCCESS)
 	{
-	  lineWidth = srcWin->generic.width - 1;
+	  lineWidth = TUI_SRC_WIN->generic.width - 1;
 	  /* Take hilite (window border) into account, when calculating
 	     the number of lines  */
-	  nlines = (lineNo + (srcWin->generic.height - 2)) - lineNo;
+	  nlines = (line_no + (TUI_SRC_WIN->generic.height - 2)) - line_no;
 	  desc = open_source_file (s);
 	  if (desc < 0)
 	    {
 	      if (!noerror)
 		{
 		  char *name = alloca (strlen (s->filename) + 100);
-		  sprintf (name, "%s:%d", s->filename, lineNo);
+		  sprintf (name, "%s:%d", s->filename, line_no);
 		  print_sys_errmsg (name, errno);
 		}
 	      ret = TUI_FAILURE;
@@ -78,14 +78,14 @@ tui_set_source_content (struct symtab *s, int lineNo, int noerror)
 	      if (s->line_charpos == 0)
 		find_source_lines (s, desc);
 
-	      if (lineNo < 1 || lineNo > s->nlines)
+	      if (line_no < 1 || line_no > s->nlines)
 		{
 		  close (desc);
 		  printf_unfiltered (
 			  "Line number %d out of range; %s has %d lines.\n",
-				      lineNo, s->filename, s->nlines);
+				      line_no, s->filename, s->nlines);
 		}
-	      else if (lseek (desc, s->line_charpos[lineNo - 1], 0) < 0)
+	      else if (lseek (desc, s->line_charpos[line_no - 1], 0) < 0)
 		{
 		  close (desc);
 		  perror_with_name (s->filename);
@@ -94,11 +94,11 @@ tui_set_source_content (struct symtab *s, int lineNo, int noerror)
 		{
 		  register int offset, curLineNo, curLine, curLen, threshold;
 		  struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
-                  struct tui_source_info * src = &srcWin->detail.sourceInfo;
+                  struct tui_source_info * src = &TUI_SRC_WIN->detail.source_info;
 
-                  if (srcWin->generic.title)
-                    xfree (srcWin->generic.title);
-                  srcWin->generic.title = xstrdup (s->filename);
+                  if (TUI_SRC_WIN->generic.title)
+                    xfree (TUI_SRC_WIN->generic.title);
+                  TUI_SRC_WIN->generic.title = xstrdup (s->filename);
 
                   if (src->filename)
                     xfree (src->filename);
@@ -106,27 +106,27 @@ tui_set_source_content (struct symtab *s, int lineNo, int noerror)
 
 		  /* Determine the threshold for the length of the line
                      and the offset to start the display.  */
-		  offset = src->horizontalOffset;
+		  offset = src->horizontal_offset;
 		  threshold = (lineWidth - 1) + offset;
 		  stream = fdopen (desc, FOPEN_RT);
 		  clearerr (stream);
 		  curLine = 0;
-		  curLineNo = src->startLineOrAddr.lineNo = lineNo;
+		  curLineNo = src->start_line_or_addr.line_no = line_no;
 		  if (offset > 0)
 		    srcLine = (char *) xmalloc (
 					   (threshold + 1) * sizeof (char));
 		  while (curLine < nlines)
 		    {
 		      struct tui_win_element * element = (struct tui_win_element *)
-		      srcWin->generic.content[curLine];
+		      TUI_SRC_WIN->generic.content[curLine];
 
 		      /* get the first character in the line */
 		      c = fgetc (stream);
 
 		      if (offset == 0)
 			srcLine = ((struct tui_win_element *)
-				   srcWin->generic.content[
-					curLine])->whichElement.source.line;
+				   TUI_SRC_WIN->generic.content[
+					curLine])->which_element.source.line;
 		      /* Init the line with the line number */
 		      sprintf (srcLine, "%-6d", curLineNo);
 		      curLen = strlen (srcLine);
@@ -142,14 +142,14 @@ tui_set_source_content (struct symtab *s, int lineNo, int noerror)
 
 		      /* Set whether element is the execution point and
 		         whether there is a break point on it.  */
-		      element->whichElement.source.lineOrAddr.lineNo =
+		      element->which_element.source.line_or_addr.line_no =
 			curLineNo;
-		      element->whichElement.source.isExecPoint =
+		      element->which_element.source.is_exec_point =
 			(strcmp (((struct tui_win_element *)
-			locator->content[0])->whichElement.locator.fileName,
+			locator->content[0])->which_element.locator.file_name,
 				 s->filename) == 0
 			 && curLineNo == ((struct tui_win_element *)
-			 locator->content[0])->whichElement.locator.lineNo);
+			 locator->content[0])->which_element.locator.line_no);
 		      if (c != EOF)
 			{
 			  i = strlen (srcLine) - 1;
@@ -203,20 +203,20 @@ tui_set_source_content (struct symtab *s, int lineNo, int noerror)
 			}
 		      /* Now copy the line taking the offset into account */
 		      if (strlen (srcLine) > offset)
-			strcpy (((struct tui_win_element *) srcWin->generic.content[
-					curLine])->whichElement.source.line,
+			strcpy (((struct tui_win_element *) TUI_SRC_WIN->generic.content[
+					curLine])->which_element.source.line,
 				&srcLine[offset]);
 		      else
 			((struct tui_win_element *)
-			 srcWin->generic.content[
-			  curLine])->whichElement.source.line[0] = (char) 0;
+			 TUI_SRC_WIN->generic.content[
+			  curLine])->which_element.source.line[0] = (char) 0;
 		      curLine++;
 		      curLineNo++;
 		    }
 		  if (offset > 0)
 		    xfree (srcLine);
 		  fclose (stream);
-		  srcWin->generic.contentSize = nlines;
+		  TUI_SRC_WIN->generic.content_size = nlines;
 		  ret = TUI_SUCCESS;
 		}
 	    }
@@ -244,7 +244,7 @@ tui_set_source_content_nil (struct tui_win_info * winInfo, char *warning_string)
 
   /* set to empty each line in the window, except for the one
      which contains the message */
-  while (curr_line < winInfo->generic.contentSize)
+  while (curr_line < winInfo->generic.content_size)
     {
       /* set the information related to each displayed line
          to null: i.e. the line number is 0, there is no bp,
@@ -252,12 +252,12 @@ tui_set_source_content_nil (struct tui_win_info * winInfo, char *warning_string)
 
       struct tui_win_element * element =
       (struct tui_win_element *) winInfo->generic.content[curr_line];
-      element->whichElement.source.lineOrAddr.lineNo = 0;
-      element->whichElement.source.isExecPoint = FALSE;
-      element->whichElement.source.hasBreak = FALSE;
+      element->which_element.source.line_or_addr.line_no = 0;
+      element->which_element.source.is_exec_point = FALSE;
+      element->which_element.source.has_break = FALSE;
 
       /* set the contents of the line to blank */
-      element->whichElement.source.line[0] = (char) 0;
+      element->which_element.source.line[0] = (char) 0;
 
       /* if the current line is in the middle of the screen, then we want to
          display the 'no source available' message in it.
@@ -272,7 +272,7 @@ tui_set_source_content_nil (struct tui_win_info * winInfo, char *warning_string)
 	  int warning_length = strlen (warning_string);
 	  char *srcLine;
 
-	  srcLine = element->whichElement.source.line;
+	  srcLine = element->which_element.source.line;
 
 	  if (warning_length >= ((lineWidth - 1) / 2))
 	    xpos = 1;
@@ -302,8 +302,8 @@ tui_set_source_content_nil (struct tui_win_info * winInfo, char *warning_string)
 void
 tui_show_symtab_source (struct symtab *s, union tui_line_or_address line, int noerror)
 {
-  srcWin->detail.sourceInfo.horizontalOffset = 0;
-  tui_update_source_window_as_is (srcWin, s, line, noerror);
+  TUI_SRC_WIN->detail.source_info.horizontal_offset = 0;
+  tui_update_source_window_as_is (TUI_SRC_WIN, s, line, noerror);
 }
 
 
@@ -312,9 +312,9 @@ tui_show_symtab_source (struct symtab *s, union tui_line_or_address line, int no
 int
 tui_source_is_displayed (char *fname)
 {
-  return (srcWin->generic.contentInUse &&
+  return (TUI_SRC_WIN->generic.content_in_use &&
 	  (strcmp (((struct tui_win_element *) (tui_locator_win_info_ptr ())->
-		  content[0])->whichElement.locator.fileName, fname) == 0));
+		  content[0])->which_element.locator.file_name, fname) == 0));
 }
 
 
@@ -323,11 +323,11 @@ void
 tui_vertical_source_scroll (enum tui_scroll_direction scrollDirection,
 			    int numToScroll)
 {
-  if (srcWin->generic.content != NULL)
+  if (TUI_SRC_WIN->generic.content != NULL)
     {
       union tui_line_or_address l;
       struct symtab *s;
-      tui_win_content content = (tui_win_content) srcWin->generic.content;
+      tui_win_content content = (tui_win_content) TUI_SRC_WIN->generic.content;
       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
 
       if (cursal.symtab == (struct symtab *) NULL)
@@ -337,21 +337,21 @@ tui_vertical_source_scroll (enum tui_scroll_direction scrollDirection,
 
       if (scrollDirection == FORWARD_SCROLL)
 	{
-	  l.lineNo = content[0]->whichElement.source.lineOrAddr.lineNo +
+	  l.line_no = content[0]->which_element.source.line_or_addr.line_no +
 	    numToScroll;
-	  if (l.lineNo > s->nlines)
-	    /*line = s->nlines - winInfo->generic.contentSize + 1; */
+	  if (l.line_no > s->nlines)
+	    /*line = s->nlines - winInfo->generic.content_size + 1; */
 	    /*elz: fix for dts 23398 */
-	    l.lineNo = content[0]->whichElement.source.lineOrAddr.lineNo;
+	    l.line_no = content[0]->which_element.source.line_or_addr.line_no;
 	}
       else
 	{
-	  l.lineNo = content[0]->whichElement.source.lineOrAddr.lineNo -
+	  l.line_no = content[0]->which_element.source.line_or_addr.line_no -
 	    numToScroll;
-	  if (l.lineNo <= 0)
-	    l.lineNo = 1;
+	  if (l.line_no <= 0)
+	    l.line_no = 1;
 	}
 
-      print_source_lines (s, l.lineNo, l.lineNo + 1, 0);
+      print_source_lines (s, l.line_no, l.line_no + 1, 0);
     }
 }
diff --git a/gdb/tui/tui-stack.c b/gdb/tui/tui-stack.c
index e8cf9272f29..7183bc29545 100644
--- a/gdb/tui/tui-stack.c
+++ b/gdb/tui/tui-stack.c
@@ -30,7 +30,7 @@
 #include "inferior.h"
 #include "target.h"
 #include "top.h"
-
+#include "gdb_string.h"
 #include "tui/tui.h"
 #include "tui/tui-data.h"
 #include "tui/tui-stack.h"
@@ -99,8 +99,8 @@ tui_make_status_line (struct tui_locator_element* loc)
   buf = (char*) alloca (status_size + 1);
 
   /* Translate line number and obtain its size.  */
-  if (loc->lineNo > 0)
-    sprintf (line_buf, "%d", loc->lineNo);
+  if (loc->line_no > 0)
+    sprintf (line_buf, "%d", loc->line_no);
   else
     strcpy (line_buf, "??");
   line_width = strlen (line_buf);
@@ -122,7 +122,7 @@ tui_make_status_line (struct tui_locator_element* loc)
                 - (sizeof (PROC_PREFIX) - 1 + 1)
                 - (sizeof (LINE_PREFIX) - 1 + line_width + 1)
                 - (sizeof (PC_PREFIX) - 1 + pc_width + 1)
-                - (tui_current_key_mode == tui_single_key_mode
+                - (tui_current_key_mode == TUI_SINGLE_KEY_MODE
                    ? (sizeof (SINGLE_KEY) - 1 + 1)
                    : 0));
 
@@ -152,7 +152,7 @@ tui_make_status_line (struct tui_locator_element* loc)
     }
 
   /* Now convert elements to string form */
-  pname = loc->procName;
+  pname = loc->proc_name;
 
   /* Now create the locator line from the string version
      of the elements.  We could use sprintf() here but
@@ -174,7 +174,7 @@ tui_make_status_line (struct tui_locator_element* loc)
     }
   
   /* Show whether we are in SingleKey mode.  */
-  if (tui_current_key_mode == tui_single_key_mode)
+  if (tui_current_key_mode == TUI_SINGLE_KEY_MODE)
     {
       strcat_to_buf (string, status_size, SINGLE_KEY);
       strcat_to_buf (string, status_size, " ");
@@ -253,13 +253,13 @@ tui_show_locator_content (void)
 
   locator = tui_locator_win_info_ptr ();
 
-  if (m_genWinPtrNotNull (locator) && locator->handle != (WINDOW *) NULL)
+  if (locator != NULL && locator->handle != (WINDOW *) NULL)
     {
       struct tui_win_element * element;
 
       element = (struct tui_win_element *) locator->content[0];
 
-      string = tui_make_status_line (&element->whichElement.locator);
+      string = tui_make_status_line (&element->which_element.locator);
       wmove (locator->handle, 0, 0);
       wstandout (locator->handle);
       waddstr (locator->handle, string);
@@ -268,7 +268,7 @@ tui_show_locator_content (void)
       tui_refresh_win (locator);
       wmove (locator->handle, 0, 0);
       xfree (string);
-      locator->contentInUse = TRUE;
+      locator->content_in_use = TRUE;
     }
 }
 
@@ -286,9 +286,9 @@ tui_set_locator_filename (const char *filename)
       return;
     }
 
-  element = &((struct tui_win_element *) locator->content[0])->whichElement.locator;
-  element->fileName[0] = 0;
-  strcat_to_buf (element->fileName, MAX_LOCATOR_ELEMENT_LEN, filename);
+  element = &((struct tui_win_element *) locator->content[0])->which_element.locator;
+  element->file_name[0] = 0;
+  strcat_to_buf (element->file_name, MAX_LOCATOR_ELEMENT_LEN, filename);
 }
 
 /* Update the locator, with the provided arguments.  */
@@ -300,16 +300,16 @@ tui_set_locator_info (const char *filename, const char *procname, int lineno,
   struct tui_locator_element * element;
 
   /* Allocate the locator content if necessary.  */
-  if (locator->contentSize <= 0)
+  if (locator->content_size <= 0)
     {
       locator->content = (void **) tui_alloc_content (1, locator->type);
-      locator->contentSize = 1;
+      locator->content_size = 1;
     }
 
-  element = &((struct tui_win_element *) locator->content[0])->whichElement.locator;
-  element->procName[0] = (char) 0;
-  strcat_to_buf (element->procName, MAX_LOCATOR_ELEMENT_LEN, procname);
-  element->lineNo = lineno;
+  element = &((struct tui_win_element *) locator->content[0])->which_element.locator;
+  element->proc_name[0] = (char) 0;
+  strcat_to_buf (element->proc_name, MAX_LOCATOR_ELEMENT_LEN, procname);
+  element->line_no = lineno;
   element->addr = addr;
   tui_set_locator_filename (filename);
 }
@@ -326,12 +326,12 @@ tui_update_locator_filename (const char *filename)
 void
 tui_show_frame_info (struct frame_info *fi)
 {
-  struct tui_win_info * winInfo;
+  struct tui_win_info * win_info;
   register int i;
 
   if (fi)
     {
-      register int startLine, i;
+      register int start_line, i;
       CORE_ADDR low;
       struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
       int sourceAlreadyDisplayed;
@@ -346,19 +346,19 @@ tui_show_frame_info (struct frame_info *fi)
                             sal.line,
                             get_frame_pc (fi));
       tui_show_locator_content ();
-      startLine = 0;
+      start_line = 0;
       for (i = 0; i < (tui_source_windows ())->count; i++)
 	{
 	  union tui_which_element *item;
-	  winInfo = (struct tui_win_info *) (tui_source_windows ())->list[i];
+	  win_info = (struct tui_win_info *) (tui_source_windows ())->list[i];
 
-	  item = &((struct tui_win_element *) locator->content[0])->whichElement;
-	  if (winInfo == srcWin)
+	  item = &((struct tui_win_element *) locator->content[0])->which_element;
+	  if (win_info == TUI_SRC_WIN)
 	    {
-	      startLine = (item->locator.lineNo -
-			   (winInfo->generic.viewportHeight / 2)) + 1;
-	      if (startLine <= 0)
-		startLine = 1;
+	      start_line = (item->locator.line_no -
+			   (win_info->generic.viewport_height / 2)) + 1;
+	      if (start_line <= 0)
+		start_line = 1;
 	    }
 	  else
 	    {
@@ -369,35 +369,35 @@ tui_show_frame_info (struct frame_info *fi)
 		low = tui_get_low_disassembly_address (low, get_frame_pc (fi));
 	    }
 
-	  if (winInfo == srcWin)
+	  if (win_info == TUI_SRC_WIN)
 	    {
 	      union tui_line_or_address l;
-	      l.lineNo = startLine;
+	      l.line_no = start_line;
 	      if (!(sourceAlreadyDisplayed
-		    && tui_line_is_displayed (item->locator.lineNo, winInfo, TRUE)))
-		tui_update_source_window (winInfo, sal.symtab, l, TRUE);
+		    && tui_line_is_displayed (item->locator.line_no, win_info, TRUE)))
+		tui_update_source_window (win_info, sal.symtab, l, TRUE);
 	      else
 		{
-		  l.lineNo = item->locator.lineNo;
-		  tui_set_is_exec_point_at (l, winInfo);
+		  l.line_no = item->locator.line_no;
+		  tui_set_is_exec_point_at (l, win_info);
 		}
 	    }
 	  else
 	    {
-	      if (winInfo == disassemWin)
+	      if (win_info == TUI_DISASM_WIN)
 		{
 		  union tui_line_or_address a;
 		  a.addr = low;
-		  if (!tui_addr_is_displayed (item->locator.addr, winInfo, TRUE))
-		    tui_update_source_window (winInfo, sal.symtab, a, TRUE);
+		  if (!tui_addr_is_displayed (item->locator.addr, win_info, TRUE))
+		    tui_update_source_window (win_info, sal.symtab, a, TRUE);
 		  else
 		    {
 		      a.addr = item->locator.addr;
-		      tui_set_is_exec_point_at (a, winInfo);
+		      tui_set_is_exec_point_at (a, win_info);
 		    }
 		}
 	    }
-	  tui_update_exec_info (winInfo);
+	  tui_update_exec_info (win_info);
 	}
     }
   else
@@ -406,9 +406,9 @@ tui_show_frame_info (struct frame_info *fi)
       tui_show_locator_content ();
       for (i = 0; i < (tui_source_windows ())->count; i++)
 	{
-	  winInfo = (struct tui_win_info *) (tui_source_windows ())->list[i];
-	  tui_clear_source_content (winInfo, EMPTY_SOURCE_PROMPT);
-	  tui_update_exec_info (winInfo);
+	  win_info = (struct tui_win_info *) (tui_source_windows ())->list[i];
+	  tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
+	  tui_update_exec_info (win_info);
 	}
     }
 }
diff --git a/gdb/tui/tui-win.c b/gdb/tui/tui-win.c
index d95c38a11ef..6e5f204c93b 100644
--- a/gdb/tui/tui-win.c
+++ b/gdb/tui/tui-win.c
@@ -415,28 +415,28 @@ tui_update_gdb_sizes ()
   rl_get_screen_size (&screenheight, &screenwidth);
   /* Set to TUI command window dimension or use readline values.  */
   sprintf (cmd, "set width %d",
-           tui_active ? cmdWin->generic.width : screenwidth);
+           tui_active ? TUI_CMD_WIN->generic.width : screenwidth);
   execute_command (cmd, 0);
   sprintf (cmd, "set height %d",
-           tui_active ? cmdWin->generic.height : screenheight);
+           tui_active ? TUI_CMD_WIN->generic.height : screenheight);
   execute_command (cmd, 0);
 }
 
 
-/* Set the logical focus to winInfo.    */
+/* Set the logical focus to win_info.    */
 void
-tui_set_win_focus_to (struct tui_win_info * winInfo)
+tui_set_win_focus_to (struct tui_win_info * win_info)
 {
-  if (m_winPtrNotNull (winInfo))
+  if (win_info != NULL)
     {
       struct tui_win_info * winWithFocus = tui_win_with_focus ();
 
-      if (m_winPtrNotNull (winWithFocus) &&
-	  winWithFocus->generic.type != CMD_WIN)
+      if (winWithFocus != NULL
+	  && winWithFocus->generic.type != CMD_WIN)
 	tui_unhighlight_win (winWithFocus);
-      tui_set_win_with_focus (winInfo);
-      if (winInfo->generic.type != CMD_WIN)
-	tui_highlight_win (winInfo);
+      tui_set_win_with_focus (win_info);
+      if (win_info->generic.type != CMD_WIN)
+	tui_highlight_win (win_info);
     }
 
   return;
@@ -446,7 +446,7 @@ tui_set_win_focus_to (struct tui_win_info * winInfo)
 void
 tui_scroll_forward (struct tui_win_info * winToScroll, int numToScroll)
 {
-  if (winToScroll != cmdWin)
+  if (winToScroll != TUI_CMD_WIN)
     {
       int _numToScroll = numToScroll;
 
@@ -458,11 +458,11 @@ tui_scroll_forward (struct tui_win_info * winToScroll, int numToScroll)
          ** only what is in the viewport.  If winToScroll is the
          ** command window do nothing since the term should handle it.
        */
-      if (winToScroll == srcWin)
+      if (winToScroll == TUI_SRC_WIN)
 	tui_vertical_source_scroll (FORWARD_SCROLL, _numToScroll);
-      else if (winToScroll == disassemWin)
+      else if (winToScroll == TUI_DISASM_WIN)
 	tui_vertical_disassem_scroll (FORWARD_SCROLL, _numToScroll);
-      else if (winToScroll == dataWin)
+      else if (winToScroll == TUI_DATA_WIN)
 	tui_vertical_data_scroll (FORWARD_SCROLL, _numToScroll);
     }
 }
@@ -470,7 +470,7 @@ tui_scroll_forward (struct tui_win_info * winToScroll, int numToScroll)
 void
 tui_scroll_backward (struct tui_win_info * winToScroll, int numToScroll)
 {
-  if (winToScroll != cmdWin)
+  if (winToScroll != TUI_CMD_WIN)
     {
       int _numToScroll = numToScroll;
 
@@ -482,11 +482,11 @@ tui_scroll_backward (struct tui_win_info * winToScroll, int numToScroll)
          ** only what is in the viewport.  If winToScroll is the
          ** command window do nothing since the term should handle it.
        */
-      if (winToScroll == srcWin)
+      if (winToScroll == TUI_SRC_WIN)
 	tui_vertical_source_scroll (BACKWARD_SCROLL, _numToScroll);
-      else if (winToScroll == disassemWin)
+      else if (winToScroll == TUI_DISASM_WIN)
 	tui_vertical_disassem_scroll (BACKWARD_SCROLL, _numToScroll);
-      else if (winToScroll == dataWin)
+      else if (winToScroll == TUI_DATA_WIN)
 	tui_vertical_data_scroll (BACKWARD_SCROLL, _numToScroll);
     }
 }
@@ -495,7 +495,7 @@ tui_scroll_backward (struct tui_win_info * winToScroll, int numToScroll)
 void
 tui_scroll_left (struct tui_win_info * winToScroll, int numToScroll)
 {
-  if (winToScroll != cmdWin)
+  if (winToScroll != TUI_CMD_WIN)
     {
       int _numToScroll = numToScroll;
 
@@ -507,7 +507,7 @@ tui_scroll_left (struct tui_win_info * winToScroll, int numToScroll)
          ** only what is in the viewport. If winToScroll is the
          ** command window do nothing since the term should handle it.
        */
-      if (winToScroll == srcWin || winToScroll == disassemWin)
+      if (winToScroll == TUI_SRC_WIN || winToScroll == TUI_DISASM_WIN)
 	tui_horizontal_source_scroll (winToScroll, LEFT_SCROLL, _numToScroll);
     }
 }
@@ -516,7 +516,7 @@ tui_scroll_left (struct tui_win_info * winToScroll, int numToScroll)
 void
 tui_scroll_right (struct tui_win_info * winToScroll, int numToScroll)
 {
-  if (winToScroll != cmdWin)
+  if (winToScroll != TUI_CMD_WIN)
     {
       int _numToScroll = numToScroll;
 
@@ -528,7 +528,7 @@ tui_scroll_right (struct tui_win_info * winToScroll, int numToScroll)
          ** only what is in the viewport. If winToScroll is the
          ** command window do nothing since the term should handle it.
        */
-      if (winToScroll == srcWin || winToScroll == disassemWin)
+      if (winToScroll == TUI_SRC_WIN || winToScroll == TUI_DISASM_WIN)
 	tui_horizontal_source_scroll (winToScroll, RIGHT_SCROLL, _numToScroll);
     }
 }
@@ -566,19 +566,19 @@ tui_refresh_all_win (void)
   enum tui_win_type type;
 
   clearok (curscr, TRUE);
-  tui_refresh_all (winList);
+  tui_refresh_all (tui_win_list);
   for (type = SRC_WIN; type < MAX_MAJOR_WINDOWS; type++)
     {
-      if (winList[type] && winList[type]->generic.isVisible)
+      if (tui_win_list[type] && tui_win_list[type]->generic.is_visible)
 	{
 	  switch (type)
 	    {
 	    case SRC_WIN:
 	    case DISASSEM_WIN:
-	      tui_show_source_content (winList[type]);
-	      tui_check_and_display_highlight_if_needed (winList[type]);
-	      tui_erase_exec_info_content (winList[type]);
-	      tui_update_exec_info (winList[type]);
+	      tui_show_source_content (tui_win_list[type]);
+	      tui_check_and_display_highlight_if_needed (tui_win_list[type]);
+	      tui_erase_exec_info_content (tui_win_list[type]);
+	      tui_update_exec_info (tui_win_list[type]);
 	      break;
 	    case DATA_WIN:
 	      tui_refresh_data_win ();
@@ -617,8 +617,8 @@ tuiResizeAll (void)
       int newHeight, splitDiff, cmdSplitDiff, numWinsDisplayed = 2;
 
       /* turn keypad off while we resize */
-      if (winWithFocus != cmdWin)
-	keypad (cmdWin->generic.handle, FALSE);
+      if (winWithFocus != TUI_CMD_WIN)
+	keypad (TUI_CMD_WIN->generic.handle, FALSE);
       tui_update_gdb_sizes ();
       tui_set_term_height_to (screenheight);
       tui_set_term_width_to (screenwidth);
@@ -656,26 +656,26 @@ tuiResizeAll (void)
 	    newHeight = firstWin->generic.height + splitDiff;
 
 	  _makeInvisibleAndSetNewHeight (firstWin, newHeight);
-	  cmdWin->generic.origin.y = locator->origin.y + 1;
-	  cmdWin->generic.width += widthDiff;
-	  newHeight = screenheight - cmdWin->generic.origin.y;
-	  _makeInvisibleAndSetNewHeight (cmdWin, newHeight);
+	  TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
+	  TUI_CMD_WIN->generic.width += widthDiff;
+	  newHeight = screenheight - TUI_CMD_WIN->generic.origin.y;
+	  _makeInvisibleAndSetNewHeight (TUI_CMD_WIN, newHeight);
 	  _makeVisibleWithNewHeight (firstWin);
-	  _makeVisibleWithNewHeight (cmdWin);
-	  if (firstWin->generic.contentSize <= 0)
+	  _makeVisibleWithNewHeight (TUI_CMD_WIN);
+	  if (firstWin->generic.content_size <= 0)
 	    tui_erase_source_content (firstWin, EMPTY_SOURCE_PROMPT);
 	  break;
 	default:
 	  if (curLayout == SRC_DISASSEM_COMMAND)
 	    {
-	      firstWin = srcWin;
+	      firstWin = TUI_SRC_WIN;
 	      firstWin->generic.width += widthDiff;
-	      secondWin = disassemWin;
+	      secondWin = TUI_DISASM_WIN;
 	      secondWin->generic.width += widthDiff;
 	    }
 	  else
 	    {
-	      firstWin = dataWin;
+	      firstWin = TUI_DATA_WIN;
 	      firstWin->generic.width += widthDiff;
 	      secondWin = (struct tui_win_info *) (tui_source_windows ())->list[0];
 	      secondWin->generic.width += widthDiff;
@@ -694,10 +694,10 @@ tuiResizeAll (void)
 	    newHeight = firstWin->generic.height + splitDiff;
 	  _makeInvisibleAndSetNewHeight (firstWin, newHeight);
 
-	  if (firstWin == dataWin && widthDiff != 0)
-	    firstWin->detail.dataDisplayInfo.regsColumnCount =
+	  if (firstWin == TUI_DATA_WIN && widthDiff != 0)
+	    firstWin->detail.data_display_info.regs_column_count =
 	      tui_calculate_regs_column_count (
-			  firstWin->detail.dataDisplayInfo.regsDisplayType);
+			  firstWin->detail.data_display_info.regs_display_type);
 	  locator->width += widthDiff;
 
 	  /* Change the second window's height/width */
@@ -722,15 +722,15 @@ tuiResizeAll (void)
 	  _makeInvisibleAndSetNewHeight (secondWin, newHeight);
 
 	  /* Change the command window's height/width */
-	  cmdWin->generic.origin.y = locator->origin.y + 1;
+	  TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
 	  _makeInvisibleAndSetNewHeight (
-			     cmdWin, cmdWin->generic.height + cmdSplitDiff);
+			     TUI_CMD_WIN, TUI_CMD_WIN->generic.height + cmdSplitDiff);
 	  _makeVisibleWithNewHeight (firstWin);
 	  _makeVisibleWithNewHeight (secondWin);
-	  _makeVisibleWithNewHeight (cmdWin);
-	  if (firstWin->generic.contentSize <= 0)
+	  _makeVisibleWithNewHeight (TUI_CMD_WIN);
+	  if (firstWin->generic.content_size <= 0)
 	    tui_erase_source_content (firstWin, EMPTY_SOURCE_PROMPT);
-	  if (secondWin->generic.contentSize <= 0)
+	  if (secondWin->generic.content_size <= 0)
 	    tui_erase_source_content (secondWin, EMPTY_SOURCE_PROMPT);
 	  break;
 	}
@@ -740,17 +740,17 @@ tuiResizeAll (void)
        */
       for (winType = SRC_WIN; (winType < MAX_MAJOR_WINDOWS); winType++)
 	{
-	  if (winType != CMD_WIN && m_winPtrNotNull (winList[winType]) &&
-	      !winList[winType]->generic.isVisible)
+	  if (winType != CMD_WIN && (tui_win_list[winType] != NULL)
+	      && !tui_win_list[winType]->generic.is_visible)
 	    {
-	      tui_free_window (winList[winType]);
-	      winList[winType] = (struct tui_win_info *) NULL;
+	      tui_free_window (tui_win_list[winType]);
+	      tui_win_list[winType] = (struct tui_win_info *) NULL;
 	    }
 	}
       tui_set_win_resized_to (TRUE);
       /* turn keypad back on, unless focus is in the command window */
-      if (winWithFocus != cmdWin)
-	keypad (cmdWin->generic.handle, TRUE);
+      if (winWithFocus != TUI_CMD_WIN)
+	keypad (TUI_CMD_WIN->generic.handle, TRUE);
     }
   return;
 }				/* tuiResizeAll */
@@ -862,28 +862,28 @@ _tuiSetFocus (char *arg, int fromTTY)
     {
       char *bufPtr = (char *) xstrdup (arg);
       int i;
-      struct tui_win_info * winInfo = (struct tui_win_info *) NULL;
+      struct tui_win_info * win_info = (struct tui_win_info *) NULL;
 
       for (i = 0; (i < strlen (bufPtr)); i++)
 	bufPtr[i] = toupper (arg[i]);
 
       if (subset_compare (bufPtr, "NEXT"))
-	winInfo = tui_next_win (tui_win_with_focus ());
+	win_info = tui_next_win (tui_win_with_focus ());
       else if (subset_compare (bufPtr, "PREV"))
-	winInfo = tui_prev_win (tui_win_with_focus ());
+	win_info = tui_prev_win (tui_win_with_focus ());
       else
-	winInfo = tui_partial_win_by_name (bufPtr);
+	win_info = tui_partial_win_by_name (bufPtr);
 
-      if (winInfo == (struct tui_win_info *) NULL || !winInfo->generic.isVisible)
+      if (win_info == (struct tui_win_info *) NULL || !win_info->generic.is_visible)
 	warning ("Invalid window specified. \n\
 The window name specified must be valid and visible.\n");
       else
 	{
-	  tui_set_win_focus_to (winInfo);
-	  keypad (cmdWin->generic.handle, (winInfo != cmdWin));
+	  tui_set_win_focus_to (win_info);
+	  keypad (TUI_CMD_WIN->generic.handle, (win_info != TUI_CMD_WIN));
 	}
 
-      if (dataWin && dataWin->generic.isVisible)
+      if (TUI_DATA_WIN && TUI_DATA_WIN->generic.is_visible)
 	tui_refresh_data_win ();
       xfree (bufPtr);
       printf_filtered ("Focus set to %s window.\n",
@@ -917,16 +917,16 @@ _tuiAllWindowsInfo (char *arg, int fromTTY)
   struct tui_win_info * winWithFocus = tui_win_with_focus ();
 
   for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
-    if (winList[type] && winList[type]->generic.isVisible)
+    if (tui_win_list[type] && tui_win_list[type]->generic.is_visible)
       {
-	if (winWithFocus == winList[type])
+	if (winWithFocus == tui_win_list[type])
 	  printf_filtered ("        %s\t(%d lines)  <has focus>\n",
-			   tui_win_name (&winList[type]->generic),
-			   winList[type]->generic.height);
+			   tui_win_name (&tui_win_list[type]->generic),
+			   tui_win_list[type]->generic.height);
 	else
 	  printf_filtered ("        %s\t(%d lines)\n",
-			   tui_win_name (&winList[type]->generic),
-			   winList[type]->generic.height);
+			   tui_win_name (&tui_win_list[type]->generic),
+			   tui_win_list[type]->generic.height);
       }
 
   return;
@@ -985,7 +985,7 @@ _tuiSetWinHeight (char *arg, int fromTTY)
       char *bufPtr = buf;
       char *wname = (char *) NULL;
       int newHeight, i;
-      struct tui_win_info * winInfo;
+      struct tui_win_info * win_info;
 
       wname = bufPtr;
       bufPtr = strchr (bufPtr, ' ');
@@ -998,9 +998,9 @@ _tuiSetWinHeight (char *arg, int fromTTY)
 	   */
 	  for (i = 0; i < strlen (wname); i++)
 	    wname[i] = toupper (wname[i]);
-	  winInfo = tui_partial_win_by_name (wname);
+	  win_info = tui_partial_win_by_name (wname);
 
-	  if (winInfo == (struct tui_win_info *) NULL || !winInfo->generic.isVisible)
+	  if (win_info == (struct tui_win_info *) NULL || !win_info->generic.is_visible)
 	    warning ("Invalid window specified. \n\
 The window name specified must be valid and visible.\n");
 	  else
@@ -1030,12 +1030,12 @@ The window name specified must be valid and visible.\n");
 		      if (fixedSize)
 			newHeight = inputNo;
 		      else
-			newHeight = winInfo->generic.height + inputNo;
+			newHeight = win_info->generic.height + inputNo;
 		      /*
 		         ** Now change the window's height, and adjust all
 		         ** other windows around it
 		       */
-		      if (_tuiAdjustWinHeights (winInfo,
+		      if (_tuiAdjustWinHeights (win_info,
 						newHeight) == TUI_FAILURE)
 			warning ("Invalid window height specified.\n%s",
 				 WIN_HEIGHT_USAGE);
@@ -1091,8 +1091,8 @@ _tuiXDBsetWinHeight (char *arg, int fromTTY)
 	{			/* Add 1 for the locator */
 	  int newHeight = tui_term_height () - (inputNo + 1);
 
-	  if (!_newHeightOk (winList[CMD_WIN], newHeight) ||
-	      _tuiAdjustWinHeights (winList[CMD_WIN],
+	  if (!_newHeightOk (tui_win_list[CMD_WIN], newHeight) ||
+	      _tuiAdjustWinHeights (tui_win_list[CMD_WIN],
 				    newHeight) == TUI_FAILURE)
 	    warning ("Invalid window height specified.\n%s",
 		     XDBWIN_HEIGHT_USAGE);
@@ -1133,7 +1133,7 @@ _tuiAdjustWinHeights (struct tui_win_info * primaryWinInfo, int newHeight)
       if (newHeight != primaryWinInfo->generic.height)
 	{
 	  int diff;
-	  struct tui_win_info * winInfo;
+	  struct tui_win_info * win_info;
 	  struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
 	  enum tui_layout_type curLayout = tui_current_layout ();
 
@@ -1145,20 +1145,20 @@ _tuiAdjustWinHeights (struct tui_win_info * primaryWinInfo, int newHeight)
 	      _makeInvisibleAndSetNewHeight (primaryWinInfo, newHeight);
 	      if (primaryWinInfo->generic.type == CMD_WIN)
 		{
-		  winInfo = (struct tui_win_info *) (tui_source_windows ())->list[0];
-		  srcWinInfo = winInfo;
+		  win_info = (struct tui_win_info *) (tui_source_windows ())->list[0];
+		  srcWinInfo = win_info;
 		}
 	      else
 		{
-		  winInfo = winList[CMD_WIN];
+		  win_info = tui_win_list[CMD_WIN];
 		  srcWinInfo = primaryWinInfo;
 		}
-	      _makeInvisibleAndSetNewHeight (winInfo,
-					     winInfo->generic.height + diff);
-	      cmdWin->generic.origin.y = locator->origin.y + 1;
-	      _makeVisibleWithNewHeight (winInfo);
+	      _makeInvisibleAndSetNewHeight (win_info,
+					     win_info->generic.height + diff);
+	      TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
+	      _makeVisibleWithNewHeight (win_info);
 	      _makeVisibleWithNewHeight (primaryWinInfo);
-	      if (srcWinInfo->generic.contentSize <= 0)
+	      if (srcWinInfo->generic.content_size <= 0)
 		tui_erase_source_content (srcWinInfo, EMPTY_SOURCE_PROMPT);
 	    }
 	  else
@@ -1168,15 +1168,15 @@ _tuiAdjustWinHeights (struct tui_win_info * primaryWinInfo, int newHeight)
 
 	      if (curLayout == SRC_DISASSEM_COMMAND)
 		{
-		  firstWin = srcWin;
-		  secondWin = disassemWin;
+		  firstWin = TUI_SRC_WIN;
+		  secondWin = TUI_DISASM_WIN;
 		}
 	      else
 		{
-		  firstWin = dataWin;
+		  firstWin = TUI_DATA_WIN;
 		  secondWin = (struct tui_win_info *) (tui_source_windows ())->list[0];
 		}
-	      if (primaryWinInfo == cmdWin)
+	      if (primaryWinInfo == TUI_CMD_WIN)
 		{		/*
 				   ** Split the change in height accross the 1st & 2nd windows
 				   ** adjusting them as well.
@@ -1217,20 +1217,20 @@ _tuiAdjustWinHeights (struct tui_win_info * primaryWinInfo, int newHeight)
 		  secondWin->generic.origin.y = firstWin->generic.height - 1;
 		  _makeInvisibleAndSetNewHeight (
 		    secondWin, secondWin->generic.height + secondSplitDiff);
-		  cmdWin->generic.origin.y = locator->origin.y + 1;
-		  _makeInvisibleAndSetNewHeight (cmdWin, newHeight);
+		  TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
+		  _makeInvisibleAndSetNewHeight (TUI_CMD_WIN, newHeight);
 		}
 	      else
 		{
-		  if ((cmdWin->generic.height + diff) < 1)
+		  if ((TUI_CMD_WIN->generic.height + diff) < 1)
 		    {		/*
 				   ** If there is no way to increase the command window
 				   ** take real estate from the 1st or 2nd window.
 				 */
-		      if ((cmdWin->generic.height + diff) < 1)
+		      if ((TUI_CMD_WIN->generic.height + diff) < 1)
 			{
 			  int i;
-			  for (i = cmdWin->generic.height + diff;
+			  for (i = TUI_CMD_WIN->generic.height + diff;
 			       (i < 1); i++)
 			    if (primaryWinInfo == firstWin)
 			      secondWin->generic.height--;
@@ -1250,19 +1250,19 @@ _tuiAdjustWinHeights (struct tui_win_info * primaryWinInfo, int newHeight)
 		  else
 		    _makeInvisibleAndSetNewHeight (
 				      secondWin, secondWin->generic.height);
-		  cmdWin->generic.origin.y = locator->origin.y + 1;
-		  if ((cmdWin->generic.height + diff) < 1)
-		    _makeInvisibleAndSetNewHeight (cmdWin, 1);
+		  TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
+		  if ((TUI_CMD_WIN->generic.height + diff) < 1)
+		    _makeInvisibleAndSetNewHeight (TUI_CMD_WIN, 1);
 		  else
 		    _makeInvisibleAndSetNewHeight (
-				     cmdWin, cmdWin->generic.height + diff);
+				     TUI_CMD_WIN, TUI_CMD_WIN->generic.height + diff);
 		}
-	      _makeVisibleWithNewHeight (cmdWin);
+	      _makeVisibleWithNewHeight (TUI_CMD_WIN);
 	      _makeVisibleWithNewHeight (secondWin);
 	      _makeVisibleWithNewHeight (firstWin);
-	      if (firstWin->generic.contentSize <= 0)
+	      if (firstWin->generic.content_size <= 0)
 		tui_erase_source_content (firstWin, EMPTY_SOURCE_PROMPT);
-	      if (secondWin->generic.contentSize <= 0)
+	      if (secondWin->generic.content_size <= 0)
 		tui_erase_source_content (secondWin, EMPTY_SOURCE_PROMPT);
 	    }
 	}
@@ -1278,49 +1278,49 @@ _tuiAdjustWinHeights (struct tui_win_info * primaryWinInfo, int newHeight)
    **        with the targer) invisible, and set the new height and location.
  */
 static void
-_makeInvisibleAndSetNewHeight (struct tui_win_info * winInfo, int height)
+_makeInvisibleAndSetNewHeight (struct tui_win_info * win_info, int height)
 {
   int i;
   struct tui_gen_win_info * genWinInfo;
 
-  tui_make_invisible (&winInfo->generic);
-  winInfo->generic.height = height;
+  tui_make_invisible (&win_info->generic);
+  win_info->generic.height = height;
   if (height > 1)
-    winInfo->generic.viewportHeight = height - 1;
+    win_info->generic.viewport_height = height - 1;
   else
-    winInfo->generic.viewportHeight = height;
-  if (winInfo != cmdWin)
-    winInfo->generic.viewportHeight--;
+    win_info->generic.viewport_height = height;
+  if (win_info != TUI_CMD_WIN)
+    win_info->generic.viewport_height--;
 
-  /* Now deal with the auxillary windows associated with winInfo */
-  switch (winInfo->generic.type)
+  /* Now deal with the auxillary windows associated with win_info */
+  switch (win_info->generic.type)
     {
     case SRC_WIN:
     case DISASSEM_WIN:
-      genWinInfo = winInfo->detail.sourceInfo.executionInfo;
+      genWinInfo = win_info->detail.source_info.execution_info;
       tui_make_invisible (genWinInfo);
       genWinInfo->height = height;
-      genWinInfo->origin.y = winInfo->generic.origin.y;
+      genWinInfo->origin.y = win_info->generic.origin.y;
       if (height > 1)
-	genWinInfo->viewportHeight = height - 1;
+	genWinInfo->viewport_height = height - 1;
       else
-	genWinInfo->viewportHeight = height;
-      if (winInfo != cmdWin)
-	genWinInfo->viewportHeight--;
+	genWinInfo->viewport_height = height;
+      if (win_info != TUI_CMD_WIN)
+	genWinInfo->viewport_height--;
 
-      if (m_hasLocator (winInfo))
+      if (tui_win_has_locator (win_info))
 	{
 	  genWinInfo = tui_locator_win_info_ptr ();
 	  tui_make_invisible (genWinInfo);
-	  genWinInfo->origin.y = winInfo->generic.origin.y + height;
+	  genWinInfo->origin.y = win_info->generic.origin.y + height;
 	}
       break;
     case DATA_WIN:
       /* delete all data item windows */
-      for (i = 0; i < winInfo->generic.contentSize; i++)
+      for (i = 0; i < win_info->generic.content_size; i++)
 	{
 	  genWinInfo = (struct tui_gen_win_info *) & ((struct tui_win_element *)
-		      winInfo->generic.content[i])->whichElement.dataWindow;
+		      win_info->generic.content[i])->which_element.data_window;
 	  tui_delete_win (genWinInfo->handle);
 	  genWinInfo->handle = (WINDOW *) NULL;
 	}
@@ -1338,32 +1338,32 @@ _makeInvisibleAndSetNewHeight (struct tui_win_info * winInfo, int height)
    **        had to be destroyed to be made invisible.
  */
 static void
-_makeVisibleWithNewHeight (struct tui_win_info * winInfo)
+_makeVisibleWithNewHeight (struct tui_win_info * win_info)
 {
   struct symtab *s;
 
-  tui_make_visible (&winInfo->generic);
-  tui_check_and_display_highlight_if_needed (winInfo);
-  switch (winInfo->generic.type)
+  tui_make_visible (&win_info->generic);
+  tui_check_and_display_highlight_if_needed (win_info);
+  switch (win_info->generic.type)
     {
     case SRC_WIN:
     case DISASSEM_WIN:
-      tui_free_win_content (winInfo->detail.sourceInfo.executionInfo);
-      tui_make_visible (winInfo->detail.sourceInfo.executionInfo);
-      if (winInfo->generic.content != NULL)
+      tui_free_win_content (win_info->detail.source_info.execution_info);
+      tui_make_visible (win_info->detail.source_info.execution_info);
+      if (win_info->generic.content != NULL)
 	{
 	  union tui_line_or_address lineOrAddr;
 	  struct symtab_and_line cursal
 	    = get_current_source_symtab_and_line ();
 
-	  if (winInfo->generic.type == SRC_WIN)
-	    lineOrAddr.lineNo =
-	      winInfo->detail.sourceInfo.startLineOrAddr.lineNo;
+	  if (win_info->generic.type == SRC_WIN)
+	    lineOrAddr.line_no =
+	      win_info->detail.source_info.start_line_or_addr.line_no;
 	  else
 	    lineOrAddr.addr =
-	      winInfo->detail.sourceInfo.startLineOrAddr.addr;
-	  tui_free_win_content (&winInfo->generic);
-	  tui_update_source_window (winInfo, cursal.symtab, lineOrAddr, TRUE);
+	      win_info->detail.source_info.start_line_or_addr.addr;
+	  tui_free_win_content (&win_info->generic);
+	  tui_update_source_window (win_info, cursal.symtab, lineOrAddr, TRUE);
 	}
       else if (deprecated_selected_frame != (struct frame_info *) NULL)
 	{
@@ -1372,15 +1372,15 @@ _makeVisibleWithNewHeight (struct tui_win_info * winInfo)
 
 
 	  s = find_pc_symtab (get_frame_pc (deprecated_selected_frame));
-	  if (winInfo->generic.type == SRC_WIN)
-	    line.lineNo = cursal.line;
+	  if (win_info->generic.type == SRC_WIN)
+	    line.line_no = cursal.line;
 	  else
 	    {
 	      find_line_pc (s, cursal.line, &line.addr);
 	    }
-	  tui_update_source_window (winInfo, s, line, TRUE);
+	  tui_update_source_window (win_info, s, line, TRUE);
 	}
-      if (m_hasLocator (winInfo))
+      if (tui_win_has_locator (win_info))
 	{
 	  tui_make_visible (tui_locator_win_info_ptr ());
 	  tui_show_locator_content ();
@@ -1390,11 +1390,11 @@ _makeVisibleWithNewHeight (struct tui_win_info * winInfo)
       tui_display_all_data ();
       break;
     case CMD_WIN:
-      winInfo->detail.commandInfo.curLine = 0;
-      winInfo->detail.commandInfo.curch = 0;
-      wmove (winInfo->generic.handle,
-	     winInfo->detail.commandInfo.curLine,
-	     winInfo->detail.commandInfo.curch);
+      win_info->detail.command_info.cur_line = 0;
+      win_info->detail.command_info.curch = 0;
+      wmove (win_info->generic.handle,
+	     win_info->detail.command_info.cur_line,
+	     win_info->detail.command_info.curch);
       break;
     default:
       break;
@@ -1412,10 +1412,10 @@ _newHeightOk (struct tui_win_info * primaryWinInfo, int newHeight)
   if (ok)
     {
       int diff;
-      enum tui_layout_type curLayout = tui_current_layout ();
+      enum tui_layout_type cur_layout = tui_current_layout ();
 
       diff = (newHeight - primaryWinInfo->generic.height) * (-1);
-      if (curLayout == SRC_COMMAND || curLayout == DISASSEM_COMMAND)
+      if (cur_layout == SRC_COMMAND || cur_layout == DISASSEM_COMMAND)
 	{
 	  ok = ((primaryWinInfo->generic.type == CMD_WIN &&
 		 newHeight <= (tui_term_height () - 4) &&
@@ -1425,14 +1425,14 @@ _newHeightOk (struct tui_win_info * primaryWinInfo, int newHeight)
 		 newHeight >= MIN_WIN_HEIGHT));
 	  if (ok)
 	    {			/* check the total height */
-	      struct tui_win_info * winInfo;
+	      struct tui_win_info * win_info;
 
-	      if (primaryWinInfo == cmdWin)
-		winInfo = (struct tui_win_info *) (tui_source_windows ())->list[0];
+	      if (primaryWinInfo == TUI_CMD_WIN)
+		win_info = (struct tui_win_info *) (tui_source_windows ())->list[0];
 	      else
-		winInfo = cmdWin;
+		win_info = TUI_CMD_WIN;
 	      ok = ((newHeight +
-		     (winInfo->generic.height + diff)) <= tui_term_height ());
+		     (win_info->generic.height + diff)) <= tui_term_height ());
 	    }
 	}
       else
@@ -1441,14 +1441,14 @@ _newHeightOk (struct tui_win_info * primaryWinInfo, int newHeight)
 	  struct tui_win_info *firstWin;
 	  struct tui_win_info *secondWin;
 
-	  if (curLayout == SRC_DISASSEM_COMMAND)
+	  if (cur_layout == SRC_DISASSEM_COMMAND)
 	    {
-	      firstWin = srcWin;
-	      secondWin = disassemWin;
+	      firstWin = TUI_SRC_WIN;
+	      secondWin = TUI_DISASM_WIN;
 	    }
 	  else
 	    {
-	      firstWin = dataWin;
+	      firstWin = TUI_DATA_WIN;
 	      secondWin = (struct tui_win_info *) (tui_source_windows ())->list[0];
 	    }
 	  /*
@@ -1459,8 +1459,8 @@ _newHeightOk (struct tui_win_info * primaryWinInfo, int newHeight)
 	   */
 	  totalHeight = curTotalHeight =
 	    (firstWin->generic.height + secondWin->generic.height - 1)
-	    + cmdWin->generic.height + 1 /*locator */ ;
-	  if (primaryWinInfo == cmdWin)
+	    + TUI_CMD_WIN->generic.height + 1 /*locator */ ;
+	  if (primaryWinInfo == TUI_CMD_WIN)
 	    {
 	      /* locator included since first & second win share a line */
 	      ok = ((firstWin->generic.height +
@@ -1482,7 +1482,7 @@ _newHeightOk (struct tui_win_info * primaryWinInfo, int newHeight)
 	         ** window.  And make sure that the command window is
 	         ** at least 1 line
 	       */
-	      ok = ((cmdWin->generic.height + diff) > 0);
+	      ok = ((TUI_CMD_WIN->generic.height + diff) > 0);
 	      if (!ok)
 		{		/*
 				   ** Looks like we have to increase/decrease one of
@@ -1498,11 +1498,11 @@ _newHeightOk (struct tui_win_info * primaryWinInfo, int newHeight)
 		  if (primaryWinInfo == firstWin)
 		    totalHeight = newHeight +
 		      secondWin->generic.height +
-		      cmdWin->generic.height + diff;
+		      TUI_CMD_WIN->generic.height + diff;
 		  else
 		    totalHeight = newHeight +
 		      firstWin->generic.height +
-		      cmdWin->generic.height + diff;
+		      TUI_CMD_WIN->generic.height + diff;
 		}
 	    }
 	  /*
@@ -1576,10 +1576,10 @@ _parseScrollingArgs (char *arg, struct tui_win_info * * winToScroll, int *numToS
 	  *winToScroll = tui_partial_win_by_name (wname);
 
 	  if (*winToScroll == (struct tui_win_info *) NULL ||
-	      !(*winToScroll)->generic.isVisible)
+	      !(*winToScroll)->generic.is_visible)
 	    warning ("Invalid window specified. \n\
 The window name specified must be valid and visible.\n");
-	  else if (*winToScroll == cmdWin)
+	  else if (*winToScroll == TUI_CMD_WIN)
 	    *winToScroll = (struct tui_win_info *) (tui_source_windows ())->list[0];
 	}
       xfree (buf);
diff --git a/gdb/tui/tui-windata.c b/gdb/tui/tui-windata.c
index 93993af1398..05485366a8e 100644
--- a/gdb/tui/tui-windata.c
+++ b/gdb/tui/tui-windata.c
@@ -59,13 +59,13 @@ tuiFirstDataItemDisplayed (void)
   int elementNo = (-1);
   int i;
 
-  for (i = 0; (i < dataWin->generic.contentSize && elementNo < 0); i++)
+  for (i = 0; (i < TUI_DATA_WIN->generic.content_size && elementNo < 0); i++)
     {
       struct tui_gen_win_info * dataItemWin;
 
       dataItemWin = &((tui_win_content)
-		      dataWin->generic.content)[i]->whichElement.dataWindow;
-      if (dataItemWin->handle != (WINDOW *) NULL && dataItemWin->isVisible)
+		      TUI_DATA_WIN->generic.content)[i]->which_element.data_window;
+      if (dataItemWin->handle != (WINDOW *) NULL && dataItemWin->is_visible)
 	elementNo = i;
     }
 
@@ -108,13 +108,13 @@ tuiDeleteDataContentWindows (void)
   int i;
   struct tui_gen_win_info * dataItemWinPtr;
 
-  for (i = 0; (i < dataWin->generic.contentSize); i++)
+  for (i = 0; (i < TUI_DATA_WIN->generic.content_size); i++)
     {
       dataItemWinPtr = &((tui_win_content)
-		      dataWin->generic.content)[i]->whichElement.dataWindow;
+		      TUI_DATA_WIN->generic.content)[i]->which_element.data_window;
       tui_delete_win (dataItemWinPtr->handle);
       dataItemWinPtr->handle = (WINDOW *) NULL;
-      dataItemWinPtr->isVisible = FALSE;
+      dataItemWinPtr->is_visible = FALSE;
     }
 
   return;
@@ -124,23 +124,23 @@ tuiDeleteDataContentWindows (void)
 void
 tui_erase_data_content (char *prompt)
 {
-  werase (dataWin->generic.handle);
-  tui_check_and_display_highlight_if_needed (dataWin);
+  werase (TUI_DATA_WIN->generic.handle);
+  tui_check_and_display_highlight_if_needed (TUI_DATA_WIN);
   if (prompt != (char *) NULL)
     {
-      int halfWidth = (dataWin->generic.width - 2) / 2;
+      int halfWidth = (TUI_DATA_WIN->generic.width - 2) / 2;
       int xPos;
 
       if (strlen (prompt) >= halfWidth)
 	xPos = 1;
       else
 	xPos = halfWidth - strlen (prompt);
-      mvwaddstr (dataWin->generic.handle,
-		 (dataWin->generic.height / 2),
+      mvwaddstr (TUI_DATA_WIN->generic.handle,
+		 (TUI_DATA_WIN->generic.height / 2),
 		 xPos,
 		 prompt);
     }
-  wrefresh (dataWin->generic.handle);
+  wrefresh (TUI_DATA_WIN->generic.handle);
 }
 
 
@@ -149,20 +149,20 @@ tui_erase_data_content (char *prompt)
 void
 tui_display_all_data (void)
 {
-  if (dataWin->generic.contentSize <= 0)
+  if (TUI_DATA_WIN->generic.content_size <= 0)
     tui_erase_data_content (NO_DATA_STRING);
   else
     {
       tui_erase_data_content ((char *) NULL);
       tuiDeleteDataContentWindows ();
-      tui_check_and_display_highlight_if_needed (dataWin);
+      tui_check_and_display_highlight_if_needed (TUI_DATA_WIN);
       tui_display_registers_from (0);
       /*
          ** Then display the other data
        */
-      if (dataWin->detail.dataDisplayInfo.dataContent !=
+      if (TUI_DATA_WIN->detail.data_display_info.data_content !=
 	  (tui_win_content) NULL &&
-	  dataWin->detail.dataDisplayInfo.dataContentCount > 0)
+	  TUI_DATA_WIN->detail.data_display_info.data_content_count > 0)
 	{
 	}
     }
@@ -182,10 +182,10 @@ tuiDisplayDataFromLine (int lineNo)
   if (lineNo < 0)
     _lineNo = 0;
 
-  tui_check_and_display_highlight_if_needed (dataWin);
+  tui_check_and_display_highlight_if_needed (TUI_DATA_WIN);
 
   /* there is no general data, force regs to display (if there are any) */
-  if (dataWin->detail.dataDisplayInfo.dataContentCount <= 0)
+  if (TUI_DATA_WIN->detail.data_display_info.data_content_count <= 0)
     tui_display_registers_from_line (_lineNo, TRUE);
   else
     {
@@ -227,7 +227,7 @@ tuiDisplayDataFrom (int elementNo, int reuseWindows)
 {
   int firstLine = (-1);
 
-  if (elementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
+  if (elementNo < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
     firstLine = tui_line_from_reg_element_no (elementNo);
   else
     {				/* calculate the firstLine from the element number */
@@ -250,7 +250,7 @@ void
 tui_refresh_data_win (void)
 {
   tui_erase_data_content ((char *) NULL);
-  if (dataWin->generic.contentSize > 0)
+  if (TUI_DATA_WIN->generic.content_size > 0)
     {
       int firstElement = tuiFirstDataItemDisplayed ();
 
@@ -267,21 +267,21 @@ tui_check_data_values (struct frame_info *frame)
   tui_check_register_values (frame);
 
   /* Now check any other data values that there are */
-  if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
+  if (TUI_DATA_WIN != NULL && TUI_DATA_WIN->generic.is_visible)
     {
       int i;
 
-      for (i = 0; dataWin->detail.dataDisplayInfo.dataContentCount; i++)
+      for (i = 0; TUI_DATA_WIN->detail.data_display_info.data_content_count; i++)
 	{
 #ifdef LATER
 	  TuiDataElementPtr dataElementPtr;
 	  struct tui_gen_win_info * dataItemWinPtr;
 	  Opaque newValue;
 
-	  dataItemPtr = &dataWin->detail.dataDisplayInfo.
-	    dataContent[i]->whichElement.dataWindow;
+	  dataItemPtr = &TUI_DATA_WIN->detail.data_display_info.
+	    data_content[i]->which_element.data_window;
 	  dataElementPtr = &((tui_win_content)
-			     dataItemWinPtr->content)[0]->whichElement.data;
+			     dataItemWinPtr->content)[0]->which_element.data;
 	  if value
 	    has changed (dataElementPtr, frame, &newValue)
 	    {
@@ -302,7 +302,7 @@ tui_vertical_data_scroll (enum tui_scroll_direction scrollDirection, int numToSc
   int firstLine = (-1);
 
   firstElementNo = tuiFirstDataItemDisplayed ();
-  if (firstElementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
+  if (firstElementNo < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
     firstLine = tui_line_from_reg_element_no (firstElementNo);
   else
     {				/* calculate the first line from the element number which is in
diff --git a/gdb/tui/tui-wingeneral.c b/gdb/tui/tui-wingeneral.c
index 12fc4158482..9239a0519a0 100644
--- a/gdb/tui/tui-wingeneral.c
+++ b/gdb/tui/tui-wingeneral.c
@@ -42,31 +42,31 @@
 
 /* Refresh the window.   */
 void
-tui_refresh_win (struct tui_gen_win_info * winInfo)
+tui_refresh_win (struct tui_gen_win_info * win_info)
 {
-  if (winInfo->type == DATA_WIN && winInfo->contentSize > 0)
+  if (win_info->type == DATA_WIN && win_info->content_size > 0)
     {
       int i;
 
-      for (i = 0; (i < winInfo->contentSize); i++)
+      for (i = 0; (i < win_info->content_size); i++)
 	{
 	  struct tui_gen_win_info * dataItemWinPtr;
 
 	  dataItemWinPtr = &((tui_win_content)
-			     winInfo->content)[i]->whichElement.dataWindow;
-	  if (m_genWinPtrNotNull (dataItemWinPtr) &&
-	      dataItemWinPtr->handle != (WINDOW *) NULL)
+			     win_info->content)[i]->which_element.data_window;
+	  if (dataItemWinPtr != NULL
+	      && dataItemWinPtr->handle != (WINDOW *) NULL)
 	    wrefresh (dataItemWinPtr->handle);
 	}
     }
-  else if (winInfo->type == CMD_WIN)
+  else if (win_info->type == CMD_WIN)
     {
       /* Do nothing */
     }
   else
     {
-      if (winInfo->handle != (WINDOW *) NULL)
-	wrefresh (winInfo->handle);
+      if (win_info->handle != (WINDOW *) NULL)
+	wrefresh (win_info->handle);
     }
 
   return;
@@ -86,14 +86,14 @@ tui_delete_win (WINDOW * window)
 
 /* Draw a border arround the window.  */
 void
-boxWin (struct tui_gen_win_info * winInfo, int highlightFlag)
+boxWin (struct tui_gen_win_info * win_info, int highlightFlag)
 {
-  if (winInfo && winInfo->handle)
+  if (win_info && win_info->handle)
     {
       WINDOW *win;
       int attrs;
 
-      win = winInfo->handle;
+      win = win_info->handle;
       if (highlightFlag == HILITE)
         attrs = tui_active_border_attrs;
       else
@@ -104,46 +104,47 @@ boxWin (struct tui_gen_win_info * winInfo, int highlightFlag)
                tui_border_hline, tui_border_hline,
                tui_border_ulcorner, tui_border_urcorner,
                tui_border_llcorner, tui_border_lrcorner);
-      if (winInfo->title)
-        mvwaddstr (win, 0, 3, winInfo->title);
+      if (win_info->title)
+        mvwaddstr (win, 0, 3, win_info->title);
       wattroff (win, attrs);
     }
 }
 
 
 void
-tui_unhighlight_win (struct tui_win_info * winInfo)
+tui_unhighlight_win (struct tui_win_info * win_info)
 {
-  if (m_winPtrNotNull (winInfo) && winInfo->generic.handle != (WINDOW *) NULL)
+  if (win_info != NULL && win_info->generic.handle != (WINDOW *) NULL)
     {
-      boxWin ((struct tui_gen_win_info *) winInfo, NO_HILITE);
-      wrefresh (winInfo->generic.handle);
-      m_setWinHighlightOff (winInfo);
+      boxWin ((struct tui_gen_win_info *) win_info, NO_HILITE);
+      wrefresh (win_info->generic.handle);
+      tui_set_win_highlight (win_info, 0);
     }
 }
 
 
 void
-tui_highlight_win (struct tui_win_info * winInfo)
+tui_highlight_win (struct tui_win_info * win_info)
 {
-  if (m_winPtrNotNull (winInfo) &&
-      winInfo->canHighlight && winInfo->generic.handle != (WINDOW *) NULL)
+  if (win_info != NULL
+      && win_info->can_highlight
+      && win_info->generic.handle != (WINDOW *) NULL)
     {
-      boxWin ((struct tui_gen_win_info *) winInfo, HILITE);
-      wrefresh (winInfo->generic.handle);
-      m_setWinHighlightOn (winInfo);
+      boxWin ((struct tui_gen_win_info *) win_info, HILITE);
+      wrefresh (win_info->generic.handle);
+      tui_set_win_highlight (win_info, 1);
     }
 }
 
 void
-tui_check_and_display_highlight_if_needed (struct tui_win_info * winInfo)
+tui_check_and_display_highlight_if_needed (struct tui_win_info * win_info)
 {
-  if (m_winPtrNotNull (winInfo) && winInfo->generic.type != CMD_WIN)
+  if (win_info != NULL && win_info->generic.type != CMD_WIN)
     {
-      if (winInfo->isHighlighted)
-	tui_highlight_win (winInfo);
+      if (win_info->is_highlighted)
+	tui_highlight_win (win_info);
       else
-	tui_unhighlight_win (winInfo);
+	tui_unhighlight_win (win_info);
 
     }
   return;
@@ -151,20 +152,20 @@ tui_check_and_display_highlight_if_needed (struct tui_win_info * winInfo)
 
 
 void
-tui_make_window (struct tui_gen_win_info * winInfo, int boxIt)
+tui_make_window (struct tui_gen_win_info * win_info, int boxIt)
 {
   WINDOW *handle;
 
-  handle = newwin (winInfo->height,
-		   winInfo->width,
-		   winInfo->origin.y,
-		   winInfo->origin.x);
-  winInfo->handle = handle;
+  handle = newwin (win_info->height,
+		   win_info->width,
+		   win_info->origin.y,
+		   win_info->origin.x);
+  win_info->handle = handle;
   if (handle != (WINDOW *) NULL)
     {
       if (boxIt == BOX_WINDOW)
-	boxWin (winInfo, NO_HILITE);
-      winInfo->isVisible = TRUE;
+	boxWin (win_info, NO_HILITE);
+      win_info->is_visible = TRUE;
       scrollok (handle, TRUE);
     }
 }
@@ -182,18 +183,18 @@ make_visible (struct tui_gen_win_info *win_info, int visible)
 
   if (visible)
     {
-      if (!win_info->isVisible)
+      if (!win_info->is_visible)
 	{
 	  tui_make_window (win_info,
 			   (win_info->type != CMD_WIN
-			    && !m_winIsAuxillary (win_info->type)));
-	  win_info->isVisible = TRUE;
+			    && !tui_win_is_auxillary (win_info->type)));
+	  win_info->is_visible = TRUE;
 	}
     }
   else if (!visible &&
-	   win_info->isVisible && win_info->handle != (WINDOW *) NULL)
+	   win_info->is_visible && win_info->handle != (WINDOW *) NULL)
     {
-      win_info->isVisible = FALSE;
+      win_info->is_visible = FALSE;
       tui_delete_win (win_info->handle);
       win_info->handle = (WINDOW *) NULL;
     }
@@ -222,13 +223,13 @@ make_all_visible (int visible)
 
   for (i = 0; i < MAX_MAJOR_WINDOWS; i++)
     {
-      if (m_winPtrNotNull (winList[i]) &&
-	  ((winList[i])->generic.type) != CMD_WIN)
+      if (tui_win_list[i] != NULL
+	  && ((tui_win_list[i])->generic.type) != CMD_WIN)
 	{
-	  if (m_winIsSourceType ((winList[i])->generic.type))
-	    make_visible ((winList[i])->detail.sourceInfo.executionInfo,
+	  if (tui_win_is_source_type ((tui_win_list[i])->generic.type))
+	    make_visible ((tui_win_list[i])->detail.source_info.execution_info,
 			  visible);
-	  make_visible ((struct tui_gen_win_info *) winList[i], visible);
+	  make_visible ((struct tui_gen_win_info *) tui_win_list[i], visible);
 	}
     }
 
@@ -257,18 +258,18 @@ tui_refresh_all (struct tui_win_info * * list)
 
   for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
     {
-      if (list[type] && list[type]->generic.isVisible)
+      if (list[type] && list[type]->generic.is_visible)
 	{
 	  if (type == SRC_WIN || type == DISASSEM_WIN)
 	    {
-	      touchwin (list[type]->detail.sourceInfo.executionInfo->handle);
-	      tui_refresh_win (list[type]->detail.sourceInfo.executionInfo);
+	      touchwin (list[type]->detail.source_info.execution_info->handle);
+	      tui_refresh_win (list[type]->detail.source_info.execution_info);
 	    }
 	  touchwin (list[type]->generic.handle);
 	  tui_refresh_win (&list[type]->generic);
 	}
     }
-  if (locator->isVisible)
+  if (locator->is_visible)
     {
       touchwin (locator->handle);
       tui_refresh_win (locator);
diff --git a/gdb/tui/tui-wingeneral.h b/gdb/tui/tui-wingeneral.h
index f91095dae94..306d79402c0 100644
--- a/gdb/tui/tui-wingeneral.h
+++ b/gdb/tui/tui-wingeneral.h
@@ -42,11 +42,4 @@ extern void tui_refresh_all (struct tui_win_info **);
 extern void tui_delete_win (WINDOW * window);
 extern void tui_refresh_win (struct tui_gen_win_info *);
 
-/*
-   ** Macros
- */
-#define    m_beVisible(winInfo)   makeVisible((struct tui_gen_win_info *)(winInfo), TRUE)
-#define    m_beInvisible(winInfo) \
-                            makeVisible((struct tui_gen_win_info *)(winInfo), FALSE)
-
 #endif
diff --git a/gdb/tui/tui-winsource.c b/gdb/tui/tui-winsource.c
index 0a943998555..1a8775eafc1 100644
--- a/gdb/tui/tui-winsource.c
+++ b/gdb/tui/tui-winsource.c
@@ -75,11 +75,11 @@ 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 (struct tui_win_info * winInfo, struct symtab *s,
+tui_update_source_window (struct tui_win_info * win_info, struct symtab *s,
 			  union tui_line_or_address lineOrAddr, 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, s, lineOrAddr, noerror);
 
   return;
 }
@@ -88,41 +88,41 @@ tui_update_source_window (struct tui_win_info * 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 (struct tui_win_info * winInfo, struct symtab *s,
+tui_update_source_window_as_is (struct tui_win_info * win_info, struct symtab *s,
 				union tui_line_or_address lineOrAddr, int noerror)
 {
   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, lineOrAddr.line_no, noerror);
   else
     ret = tui_set_disassem_content (lineOrAddr.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);
+	  sal.line = lineOrAddr.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 &&
+	  if (tui_win_with_focus () == TUI_DISASM_WIN &&
 	      tui_current_layout () != SRC_DISASSEM_COMMAND)
-	    tui_set_win_focus_to (srcWin);
+	    tui_set_win_focus_to (TUI_SRC_WIN);
 	}
     }
 
@@ -152,7 +152,7 @@ tui_update_source_windows_with_addr (CORE_ADDR addr)
 	  break;
 	default:
 	  sal = find_pc_line (addr, 0);
-	  l.lineNo = sal.line;
+	  l.line_no = sal.line;
 	  tui_show_symtab_source (sal.symtab, l, FALSE);
 	  break;
 	}
@@ -163,10 +163,10 @@ tui_update_source_windows_with_addr (CORE_ADDR addr)
 
       for (i = 0; i < (tui_source_windows ())->count; i++)
 	{
-	  struct tui_win_info * winInfo = (struct tui_win_info *) (tui_source_windows ())->list[i];
+	  struct tui_win_info * win_info = (struct tui_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);
 	}
     }
 
@@ -189,7 +189,7 @@ tui_update_source_windows_with_line (struct symtab *s, int line)
       tui_update_source_windows_with_addr (pc);
       break;
     default:
-      l.lineNo = line;
+      l.line_no = line;
       tui_show_symtab_source (s, l, FALSE);
       if (tui_current_layout () == SRC_DISASSEM_COMMAND)
 	{
@@ -203,20 +203,20 @@ tui_update_source_windows_with_line (struct symtab *s, int line)
 }
 
 void
-tui_clear_source_content (struct tui_win_info * winInfo, int displayPrompt)
+tui_clear_source_content (struct tui_win_info * win_info, int displayPrompt)
 {
-  if (m_winPtrNotNull (winInfo))
+  if (win_info != NULL)
     {
       register 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, displayPrompt);
+      for (i = 0; i < win_info->generic.content_size; i++)
 	{
 	  struct tui_win_element * element =
-	  (struct tui_win_element *) winInfo->generic.content[i];
-	  element->whichElement.source.hasBreak = FALSE;
-	  element->whichElement.source.isExecPoint = FALSE;
+	  (struct tui_win_element *) win_info->generic.content[i];
+	  element->which_element.source.has_break = FALSE;
+	  element->which_element.source.is_exec_point = FALSE;
 	}
     }
 
@@ -225,20 +225,20 @@ tui_clear_source_content (struct tui_win_info * winInfo, int displayPrompt)
 
 
 void
-tui_erase_source_content (struct tui_win_info * winInfo, int displayPrompt)
+tui_erase_source_content (struct tui_win_info * win_info, int displayPrompt)
 {
   int xPos;
-  int halfWidth = (winInfo->generic.width - 2) / 2;
+  int halfWidth = (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);
+      werase (win_info->generic.handle);
+      tui_check_and_display_highlight_if_needed (win_info);
       if (displayPrompt == EMPTY_SOURCE_PROMPT)
 	{
 	  char *noSrcStr;
 
-	  if (winInfo->generic.type == SRC_WIN)
+	  if (win_info->generic.type == SRC_WIN)
 	    noSrcStr = NO_SRC_STRING;
 	  else
 	    noSrcStr = NO_DISASSEM_STRING;
@@ -246,8 +246,8 @@ tui_erase_source_content (struct tui_win_info * winInfo, int displayPrompt)
 	    xPos = 1;
 	  else
 	    xPos = halfWidth - strlen (noSrcStr);
-	  mvwaddstr (winInfo->generic.handle,
-		     (winInfo->generic.height / 2),
+	  mvwaddstr (win_info->generic.handle,
+		     (win_info->generic.height / 2),
 		     xPos,
 		     noSrcStr);
 
@@ -256,9 +256,9 @@ tui_erase_source_content (struct tui_win_info * winInfo, int displayPrompt)
 	     to refresh, do display
 	     the correct stuff, and not the old image */
 
-	  tui_set_source_content_nil (winInfo, noSrcStr);
+	  tui_set_source_content_nil (win_info, noSrcStr);
 	}
-      tui_refresh_win (&winInfo->generic);
+      tui_refresh_win (&win_info->generic);
     }
   return;
 }				/* tuiEraseSourceContent */
@@ -266,55 +266,55 @@ tui_erase_source_content (struct tui_win_info * winInfo, int displayPrompt)
 
 /* Redraw the complete line of a source or disassembly window.  */
 static void
-tui_show_source_line (struct tui_win_info * winInfo, int lineno)
+tui_show_source_line (struct tui_win_info * win_info, int lineno)
 {
   struct tui_win_element * line;
   int x, y;
 
-  line = (struct tui_win_element *) 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 (struct tui_win_info * 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 (struct tui_win_info * winInfo,
+tui_horizontal_source_scroll (struct tui_win_info * win_info,
 			      enum tui_scroll_direction direction,
 			      int numToScroll)
 {
-  if (winInfo->generic.content != NULL)
+  if (win_info->generic.content != NULL)
     {
       int offset;
       struct symtab *s;
@@ -326,17 +326,17 @@ tui_horizontal_source_scroll (struct tui_win_info * winInfo,
 	s = cursal.symtab;
 
       if (direction == LEFT_SCROLL)
-	offset = winInfo->detail.sourceInfo.horizontalOffset + numToScroll;
+	offset = win_info->detail.source_info.horizontal_offset + numToScroll;
       else
 	{
 	  if ((offset =
-	     winInfo->detail.sourceInfo.horizontalOffset - numToScroll) < 0)
+	     win_info->detail.source_info.horizontal_offset - numToScroll) < 0)
 	    offset = 0;
 	}
-      winInfo->detail.sourceInfo.horizontalOffset = offset;
-      tui_update_source_window_as_is (winInfo, s,
+      win_info->detail.source_info.horizontal_offset = offset;
+      tui_update_source_window_as_is (win_info, s,
 				      ((struct tui_win_element *)
-				       winInfo->generic.content[0])->whichElement.source.lineOrAddr,
+				       win_info->generic.content[0])->which_element.source.line_or_addr,
 				      FALSE);
     }
 
@@ -344,33 +344,33 @@ tui_horizontal_source_scroll (struct tui_win_info * winInfo,
 }				/* 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 (union tui_line_or_address l, struct tui_win_info * winInfo)
+tui_set_is_exec_point_at (union tui_line_or_address l, struct tui_win_info * win_info)
 {
   int changed = 0;
   int i;
-  tui_win_content content = (tui_win_content) 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)
+      if (content[i]->which_element.source.line_or_addr.addr == l.addr)
         newState = TRUE;
       else
 	newState = FALSE;
-      if (newState != content[i]->whichElement.source.isExecPoint)
+      if (newState != 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 = newState;
+          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.
@@ -395,7 +395,7 @@ tui_update_all_breakpoint_info ()
 
 
 /* Scan the source window and the breakpoints to update the
-   hasBreak information for each line.
+   has_break information for each line.
    Returns 1 if something changed and the execution window
    must be refreshed.  */
 int
@@ -403,17 +403,17 @@ tui_update_breakpoint_info (struct tui_win_info * win, int current_only)
 {
   int i;
   int need_refresh = 0;
-  struct tui_source_info * 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;
       struct tui_source_element* line;
 
-      line = &((struct tui_win_element *) 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,12 +424,12 @@ tui_update_breakpoint_info (struct tui_win_info * win, int current_only)
            bp != (struct breakpoint *) NULL;
            bp = bp->next)
         {
-          if ((win == srcWin
+          if ((win == TUI_SRC_WIN
                && bp->source_file
                && (strcmp (src->filename, bp->source_file) == 0)
-               && bp->line_number == line->lineOrAddr.lineNo)
-              || (win == disassemWin
-                  && bp->loc->address == line->lineOrAddr.addr))
+               && bp->line_number == line->line_or_addr.line_no)
+              || (win == TUI_DISASM_WIN
+                  && bp->loc->address == line->line_or_addr.addr))
             {
               if (bp->enable_state == bp_disabled)
                 mode |= TUI_BP_DISABLED;
@@ -443,9 +443,9 @@ tui_update_breakpoint_info (struct tui_win_info * win, int current_only)
                 mode |= TUI_BP_HARDWARE;
             }
         }
-      if (line->hasBreak != mode)
+      if (line->has_break != mode)
         {
-          line->hasBreak = mode;
+          line->has_break = mode;
           need_refresh = 1;
         }
     }
@@ -460,55 +460,55 @@ tui_update_breakpoint_info (struct tui_win_info * win, int current_only)
    **      disassembly window.
  */
 enum tui_status
-tuiSetExecInfoContent (struct tui_win_info * winInfo)
+tuiSetExecInfoContent (struct tui_win_info * win_info)
 {
   enum tui_status ret = TUI_SUCCESS;
 
-  if (winInfo->detail.sourceInfo.executionInfo != (struct tui_gen_win_info *) NULL)
+  if (win_info->detail.source_info.execution_info != (struct tui_gen_win_info *) NULL)
     {
-      struct tui_gen_win_info * execInfoPtr = winInfo->detail.sourceInfo.executionInfo;
+      struct tui_gen_win_info * execInfoPtr = win_info->detail.source_info.execution_info;
 
       if (execInfoPtr->content == NULL)
 	execInfoPtr->content =
-	  (void **) tui_alloc_content (winInfo->generic.height,
+	  (void **) tui_alloc_content (win_info->generic.height,
 					 execInfoPtr->type);
       if (execInfoPtr->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++)
 	    {
 	      struct tui_win_element * element;
 	      struct tui_win_element * srcElement;
               int mode;
 
 	      element = (struct tui_win_element *) execInfoPtr->content[i];
-	      srcElement = (struct tui_win_element *) winInfo->generic.content[i];
+	      srcElement = (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 = srcElement->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 (srcElement->which_element.source.is_exec_point)
+                element->which_element.simple_string[TUI_EXEC_POS] = '>';
 	    }
-	  execInfoPtr->contentSize = winInfo->generic.contentSize;
+	  execInfoPtr->content_size = win_info->generic.content_size;
 	}
       else
 	ret = TUI_FAILURE;
@@ -522,30 +522,30 @@ tuiSetExecInfoContent (struct tui_win_info * winInfo)
    ** tuiShowExecInfoContent().
  */
 void
-tuiShowExecInfoContent (struct tui_win_info * winInfo)
+tuiShowExecInfoContent (struct tui_win_info * win_info)
 {
-  struct tui_gen_win_info * execInfo = winInfo->detail.sourceInfo.executionInfo;
+  struct tui_gen_win_info * execInfo = win_info->detail.source_info.execution_info;
   int curLine;
 
   werase (execInfo->handle);
   tui_refresh_win (execInfo);
-  for (curLine = 1; (curLine <= execInfo->contentSize); curLine++)
+  for (curLine = 1; (curLine <= execInfo->content_size); curLine++)
     mvwaddstr (execInfo->handle,
 	       curLine,
 	       0,
 	       ((struct tui_win_element *)
-		execInfo->content[curLine - 1])->whichElement.simpleString);
+		execInfo->content[curLine - 1])->which_element.simple_string);
   tui_refresh_win (execInfo);
-  execInfo->contentInUse = TRUE;
+  execInfo->content_in_use = TRUE;
 
   return;
 }
 
 
 void
-tui_erase_exec_info_content (struct tui_win_info * winInfo)
+tui_erase_exec_info_content (struct tui_win_info * win_info)
 {
-  struct tui_gen_win_info * execInfo = winInfo->detail.sourceInfo.executionInfo;
+  struct tui_gen_win_info * execInfo = win_info->detail.source_info.execution_info;
 
   werase (execInfo->handle);
   tui_refresh_win (execInfo);
@@ -554,37 +554,37 @@ tui_erase_exec_info_content (struct tui_win_info * winInfo)
 }
 
 void
-tui_clear_exec_info_content (struct tui_win_info * 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 (struct tui_win_info * winInfo)
+tui_update_exec_info (struct tui_win_info * win_info)
 {
-  tuiSetExecInfoContent (winInfo);
-  tuiShowExecInfoContent (winInfo);
+  tuiSetExecInfoContent (win_info);
+  tuiShowExecInfoContent (win_info);
 }				/* tuiUpdateExecInfo */
 
 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;
   enum tui_status ret = TUI_FAILURE;
 
-  maxLines = winInfo->generic.height;	/* less the highlight box */
-  lineWidth = winInfo->generic.width - 1;
+  maxLines = win_info->generic.height;	/* less the highlight box */
+  lineWidth = 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.
    */
-  if (winInfo->generic.content == NULL)
+  if (win_info->generic.content == NULL)
     {
       srcLineBuf = (char *) xmalloc ((maxLines * lineWidth) * sizeof (char));
       if (srcLineBuf == (char *) NULL)
@@ -594,7 +594,7 @@ tui_alloc_source_buffer (struct tui_win_info *winInfo)
       else
 	{
 	  /* allocate the content list */
-	  if ((winInfo->generic.content =
+	  if ((win_info->generic.content =
 	  (void **) tui_alloc_content (maxLines, SRC_WIN)) == NULL)
 	    {
 	      xfree (srcLineBuf);
@@ -606,7 +606,7 @@ tui_alloc_source_buffer (struct tui_win_info *winInfo)
 	}
       for (i = 0; i < maxLines; i++)
 	((struct tui_win_element *)
-	 winInfo->generic.content[i])->whichElement.source.line =
+	 win_info->generic.content[i])->which_element.source.line =
 	  srcLineBuf + (lineWidth * i);
       ret = TUI_SUCCESS;
     }
@@ -620,7 +620,7 @@ tui_alloc_source_buffer (struct tui_win_info *winInfo)
 /* Answer whether the a particular line number or address is displayed
    in the current source window.  */
 int
-tui_line_is_displayed (int line, struct tui_win_info * winInfo,
+tui_line_is_displayed (int line, struct tui_win_info * win_info,
 		       int checkThreshold)
 {
   int isDisplayed = FALSE;
@@ -631,10 +631,10 @@ tui_line_is_displayed (int line, struct tui_win_info * winInfo,
   else
     threshold = 0;
   i = 0;
-  while (i < winInfo->generic.contentSize - threshold && !isDisplayed)
+  while (i < win_info->generic.content_size - threshold && !isDisplayed)
     {
       isDisplayed = (((struct tui_win_element *)
-		      winInfo->generic.content[i])->whichElement.source.lineOrAddr.lineNo
+		      win_info->generic.content[i])->which_element.source.line_or_addr.line_no
 		     == (int) line);
       i++;
     }
@@ -646,7 +646,7 @@ tui_line_is_displayed (int line, struct tui_win_info * winInfo,
 /* Answer whether the a particular line number or address is displayed
    in the current source window.  */
 int
-tui_addr_is_displayed (CORE_ADDR addr, struct tui_win_info * winInfo,
+tui_addr_is_displayed (CORE_ADDR addr, struct tui_win_info * win_info,
 		    int checkThreshold)
 {
   int isDisplayed = FALSE;
@@ -657,10 +657,10 @@ tui_addr_is_displayed (CORE_ADDR addr, struct tui_win_info * winInfo,
   else
     threshold = 0;
   i = 0;
-  while (i < winInfo->generic.contentSize - threshold && !isDisplayed)
+  while (i < win_info->generic.content_size - threshold && !isDisplayed)
     {
       isDisplayed = (((struct tui_win_element *)
-		      winInfo->generic.content[i])->whichElement.source.lineOrAddr.addr
+		      win_info->generic.content[i])->which_element.source.line_or_addr.addr
 		     == addr);
       i++;
     }
diff --git a/gdb/tui/tui.c b/gdb/tui/tui.c
index 49a9937cb7e..0e413d4071c 100644
--- a/gdb/tui/tui.c
+++ b/gdb/tui/tui.c
@@ -66,7 +66,7 @@
 int tui_active = 0;
 static int tui_finish_init = 1;
 
-enum tui_key_mode tui_current_key_mode = tui_command_mode;
+enum tui_key_mode tui_current_key_mode = TUI_COMMAND_MODE;
 
 struct tui_char_command
 {
@@ -224,9 +224,9 @@ tui_rl_other_window (int count, int key)
   if (winInfo)
     {
       tui_set_win_focus_to (winInfo);
-      if (dataWin && dataWin->generic.isVisible)
+      if (TUI_DATA_WIN && TUI_DATA_WIN->generic.is_visible)
         tui_refresh_data_win ();
-      keypad (cmdWin->generic.handle, (winInfo != cmdWin));
+      keypad (TUI_CMD_WIN->generic.handle, (winInfo != TUI_CMD_WIN));
     }
   return 0;
 }
@@ -261,7 +261,7 @@ tui_rl_command_key (int count, int key)
 static int
 tui_rl_command_mode (int count, int key)
 {
-  tui_set_key_mode (tui_one_command_mode);
+  tui_set_key_mode (TUI_ONE_COMMAND_MODE);
   return rl_insert (count, key);
 }
 
@@ -273,8 +273,8 @@ tui_rl_next_keymap (int notused1, int notused2)
   if (!tui_active)
     tui_rl_switch_mode (0/*notused*/, 0/*notused*/);
 
-  tui_set_key_mode (tui_current_key_mode == tui_command_mode
-                    ? tui_single_key_mode : tui_command_mode);
+  tui_set_key_mode (tui_current_key_mode == TUI_COMMAND_MODE
+                    ? TUI_SINGLE_KEY_MODE : TUI_COMMAND_MODE);
   return 0;
 }
 
@@ -286,8 +286,8 @@ static int
 tui_rl_startup_hook ()
 {
   rl_already_prompted = 1;
-  if (tui_current_key_mode != tui_command_mode)
-    tui_set_key_mode (tui_single_key_mode);
+  if (tui_current_key_mode != TUI_COMMAND_MODE)
+    tui_set_key_mode (TUI_SINGLE_KEY_MODE);
   tui_redisplay_readline ();
   return 0;
 }
@@ -297,7 +297,7 @@ void
 tui_set_key_mode (enum tui_key_mode mode)
 {
   tui_current_key_mode = mode;
-  rl_set_keymap (mode == tui_single_key_mode
+  rl_set_keymap (mode == TUI_SINGLE_KEY_MODE
                  ? tui_keymap : tui_readline_standard_keymap);
   tui_show_locator_content ();
 }
@@ -390,9 +390,9 @@ tui_enable (void)
 
       tui_show_frame_info (0);
       tui_set_layout (SRC_COMMAND, TUI_UNDEFINED_REGS);
-      tui_set_win_focus_to (srcWin);
-      keypad (cmdWin->generic.handle, TRUE);
-      wrefresh (cmdWin->generic.handle);
+      tui_set_win_focus_to (TUI_SRC_WIN);
+      keypad (TUI_CMD_WIN->generic.handle, TRUE);
+      wrefresh (TUI_CMD_WIN->generic.handle);
       tui_finish_init = 0;
     }
   else
@@ -571,21 +571,21 @@ tui_is_window_visible (enum tui_win_type type)
   if (tui_active == 0)
     return 0;
 
-  if (winList[type] == 0)
+  if (tui_win_list[type] == 0)
     return 0;
   
-  return winList[type]->generic.isVisible;
+  return tui_win_list[type]->generic.is_visible;
 }
 
 int
 tui_get_command_dimension (int *width, int *height)
 {
-  if (!tui_active || !m_winPtrNotNull (cmdWin))
+  if (!tui_active || (TUI_CMD_WIN == NULL))
     {
       return 0;
     }
   
-  *width = cmdWin->generic.width;
-  *height = cmdWin->generic.height;
+  *width = TUI_CMD_WIN->generic.width;
+  *height = TUI_CMD_WIN->generic.height;
   return 1;
 }
diff --git a/gdb/tui/tui.h b/gdb/tui/tui.h
index d6221b74f91..9ba1a35ef09 100644
--- a/gdb/tui/tui.h
+++ b/gdb/tui/tui.h
@@ -25,17 +25,6 @@
 #ifndef TUI_H
 #define TUI_H
 
-#include <stdarg.h>
-#include <string.h>
-#include "ansidecl.h"
-
-#if defined(reg)
-#undef reg
-#endif
-#if defined(chtype)
-#undef chtype
-#endif
-
 struct ui_file;
 
 extern void strcat_to_buf (char *, int, const char *);
@@ -91,13 +80,13 @@ extern void tui_disable (void);
 enum tui_key_mode
 {
   /* Plain command mode to enter gdb commands.  */
-  tui_command_mode,
+  TUI_COMMAND_MODE,
 
   /* SingleKey mode with some keys bound to gdb commands.  */
-  tui_single_key_mode,
+  TUI_SINGLE_KEY_MODE,
 
   /* Read/edit one command and return to SingleKey after it's processed.  */
-  tui_one_command_mode
+  TUI_ONE_COMMAND_MODE
 };
 
 extern enum tui_key_mode tui_current_key_mode;
@@ -124,4 +113,5 @@ extern enum tui_status tui_set_layout_for_display_command (const char *name);
 /* tui-winsource.c */
 extern void tui_update_all_exec_infos (void);
 
-#endif /* TUI_H */
+#endif
+