merge mainline changes to branch

46 files changed, 7030 insertions, 7821 deletions

diff --git a/gdb/tui/ChangeLog b/gdb/tui/ChangeLog-1998-2003
index 68386a49786..fc5886c1ae1 100644
--- a/gdb/tui/ChangeLog
+++ b/gdb/tui/ChangeLog-1998-2003
@@ -1,3 +1,8 @@
+2003-09-27  Andrew Cagney  <cagney@redhat.com>
+
+	* tuiRegs.c: Rename REGISTER_RAW_SIZE to
+	DEPRECATED_REGISTER_RAW_SIZE.
+
 2003-09-13  Andrew Cagney  <cagney@redhat.com>
 
 	* tui.h (struct ui_file): Add opaque declaration.
diff --git a/gdb/tui/tuiCommand.c b/gdb/tui/tui-command.c
index 675b34c5443..399ef85b8c5 100644
--- a/gdb/tui/tuiCommand.c
+++ b/gdb/tui/tui-command.c
@@ -1,7 +1,7 @@
 /* Specific command window processing.
 
-   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.
 
@@ -24,18 +24,13 @@
 
 #include "defs.h"
 #include <ctype.h>
-#include "tui.h"
-#include "tuiData.h"
-#include "tuiWin.h"
-#include "tuiIO.h"
+#include "tui/tui.h"
+#include "tui/tui-data.h"
+#include "tui/tui-win.h"
+#include "tui/tui-io.h"
 
-#ifdef HAVE_NCURSES_H       
-#include <ncurses.h>
-#else
-#ifdef HAVE_CURSES_H
-#include <curses.h>
-#endif
-#endif
+#include "gdb_curses.h"
+#include "gdb_string.h"
 
 
 /*****************************************
@@ -48,27 +43,24 @@
 ** PUBLIC FUNCTIONS                        **
 ******************************************/
 
-/*
-   ** tuiDispatchCtrlChar().
-   **        Dispatch the correct tui function based upon the control character.
- */
+/* Dispatch the correct tui function based upon the control character.   */
 unsigned int
-tuiDispatchCtrlChar (unsigned int ch)
+tui_dispatch_ctrl_char (unsigned int ch)
 {
-  TuiWinInfoPtr winInfo = tuiWinWithFocus ();
-  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 == (TuiWinInfoPtr) NULL || winInfo == cmdWin)
+  if (win_info == NULL || win_info == TUI_CMD_WIN)
     return ch;
   else
     {
-      unsigned int c = 0, chCopy = ch;
-      register int i;
+      unsigned int c = 0, ch_copy = ch;
+      int i;
       char *term;
 
       /* If this is an xterm, page next/prev keys aren't returned
@@ -78,59 +70,60 @@ tuiDispatchCtrlChar (unsigned int ch)
       term = (char *) getenv ("TERM");
       for (i = 0; (term && term[i]); i++)
 	term[i] = toupper (term[i]);
-      if ((strcmp (term, "XTERM") == 0) && m_isStartSequence (ch))
+      if ((strcmp (term, "XTERM") == 0) && key_is_start_sequence (ch))
 	{
-	  unsigned int pageCh = 0, tmpChar;
+	  unsigned int page_ch = 0;
+	  unsigned int tmp_char;
 
-	  tmpChar = 0;
-	  while (!m_isEndSequence (tmpChar))
+	  tmp_char = 0;
+	  while (!key_is_end_sequence (tmp_char))
 	    {
-	      tmpChar = (int) wgetch (w);
-	      if (tmpChar == ERR)
+	      tmp_char = (int) wgetch (w);
+	      if (tmp_char == ERR)
 		{
 		  return ch;
 		}
-	      if (!tmpChar)
+	      if (!tmp_char)
 		break;
-	      if (tmpChar == 53)
-		pageCh = KEY_PPAGE;
-	      else if (tmpChar == 54)
-		pageCh = KEY_NPAGE;
+	      if (tmp_char == 53)
+		page_ch = KEY_PPAGE;
+	      else if (tmp_char == 54)
+		page_ch = KEY_NPAGE;
 	      else
 		{
 		  return 0;
 		}
 	    }
-	  chCopy = pageCh;
+	  ch_copy = page_ch;
 	}
 
-      switch (chCopy)
+      switch (ch_copy)
 	{
 	case KEY_NPAGE:
-	  tuiScrollForward (winInfo, 0);
+	  tui_scroll_forward (win_info, 0);
 	  break;
 	case KEY_PPAGE:
-	  tuiScrollBackward (winInfo, 0);
+	  tui_scroll_backward (win_info, 0);
 	  break;
 	case KEY_DOWN:
 	case KEY_SF:
-	  tuiScrollForward (winInfo, 1);
+	  tui_scroll_forward (win_info, 1);
 	  break;
 	case KEY_UP:
 	case KEY_SR:
-	  tuiScrollBackward (winInfo, 1);
+	  tui_scroll_backward (win_info, 1);
 	  break;
 	case KEY_RIGHT:
-	  tuiScrollLeft (winInfo, 1);
+	  tui_scroll_left (win_info, 1);
 	  break;
 	case KEY_LEFT:
-	  tuiScrollRight (winInfo, 1);
+	  tui_scroll_right (win_info, 1);
 	  break;
 	case '\f':
-	  tuiRefreshAll ();
+	  tui_refresh_all_win ();
 	  break;
 	default:
-	  c = chCopy;
+	  c = ch_copy;
 	  break;
 	}
       return c;
diff --git a/gdb/tui/tuiSource.h b/gdb/tui/tui-command.h
index 96cf8652aca..9653bf07ee5 100644
--- a/gdb/tui/tuiSource.h
+++ b/gdb/tui/tui-command.h
@@ -1,5 +1,8 @@
-/* TUI display source window.
-   Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+/* Specific command window processing.
+
+   Copyright 1998, 1999, 2000, 2001, 2004 Free Software Foundation,
+   Inc.
+
    Contributed by Hewlett-Packard Company.
 
    This file is part of GDB.
@@ -19,15 +22,9 @@
    Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
-#ifndef _TUI_SOURCE_H
-#define _TUI_SOURCE_H
-
-#include "defs.h"
+#ifndef TUI_COMMAND_H
+#define TUI_COMMAND_H
 
-extern TuiStatus tuiSetSourceContent (struct symtab *, int, int);
-extern void tuiShowSource (struct symtab *, TuiLineOrAddress, int);
-extern int tuiSourceIsDisplayed (char *);
-extern void tuiVerticalSourceScroll (TuiScrollDirection, int);
+extern unsigned int tui_dispatch_ctrl_char (unsigned int);
 
 #endif
-/*_TUI_SOURCE_H*/
diff --git a/gdb/tui/tui-data.c b/gdb/tui/tui-data.c
new file mode 100644
index 00000000000..800d72a069f
--- /dev/null
+++ b/gdb/tui/tui-data.c
@@ -0,0 +1,924 @@
+/* TUI data manipulation routines.
+
+   Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
+   Foundation, Inc.
+
+   Contributed by Hewlett-Packard Company.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "symtab.h"
+#include "tui/tui.h"
+#include "tui/tui-data.h"
+#include "tui/tui-wingeneral.h"
+
+#include "gdb_string.h"
+#include "gdb_curses.h"
+
+/****************************
+** GLOBAL DECLARATIONS
+****************************/
+struct tui_win_info *(tui_win_list[MAX_MAJOR_WINDOWS]);
+
+/***************************
+** Private data
+****************************/
+static enum tui_layout_type current_layout = UNDEFINED_LAYOUT;
+static int term_height, term_width;
+static struct tui_gen_win_info _locator;
+static struct tui_gen_win_info exec_info[2];
+static struct tui_win_info * src_win_list[2];
+static struct tui_list source_windows = {(void **) src_win_list, 0};
+static int default_tab_len = DEFAULT_TAB_LEN;
+static struct tui_win_info * win_with_focus = (struct tui_win_info *) NULL;
+static struct tui_layout_def layout_def =
+{SRC_WIN,			/* DISPLAY_MODE */
+ FALSE,				/* SPLIT */
+ TUI_UNDEFINED_REGS,		/* REGS_DISPLAY_TYPE */
+ TUI_SFLOAT_REGS};		/* FLOAT_REGS_DISPLAY_TYPE */
+static int win_resized = FALSE;
+
+
+/*********************************
+** Static function forward decls
+**********************************/
+static void free_content (tui_win_content, int, enum tui_win_type);
+static void free_content_elements (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
+******************************************/
+
+/* Answer a whether the terminal window has been resized or not.   */
+int
+tui_win_resized (void)
+{
+  return win_resized;
+}
+
+
+/* Set a whether the terminal window has been resized or not.   */
+void
+tui_set_win_resized_to (int resized)
+{
+  win_resized = resized;
+}
+
+
+/* Answer a pointer to the current layout definition.   */
+struct tui_layout_def *
+tui_layout_def (void)
+{
+  return &layout_def;
+}
+
+
+/* Answer the window with the logical focus.    */
+struct tui_win_info *
+tui_win_with_focus (void)
+{
+  return win_with_focus;
+}
+
+
+/* Set the window that has the logical focus.   */
+void
+tui_set_win_with_focus (struct tui_win_info * win_info)
+{
+  win_with_focus = win_info;
+}
+
+
+/* Answer the length in chars, of tabs.    */
+int
+tui_default_tab_len (void)
+{
+  return default_tab_len;
+}
+
+
+/* Set the length in chars, of tabs.   */
+void
+tui_set_default_tab_len (int len)
+{
+  default_tab_len = len;
+}
+
+
+/* Accessor for the current source window.  Usually there is only one
+   source window (either source or disassembly), but both can be
+   displayed at the same time.  */
+struct tui_list *
+tui_source_windows (void)
+{
+  return &source_windows;
+}
+
+
+/* Clear the list of source windows.  Usually there is only one source
+   window (either source or disassembly), but both can be displayed at
+   the same time.  */
+void
+tui_clear_source_windows (void)
+{
+  source_windows.list[0] = NULL;
+  source_windows.list[1] = NULL;
+  source_windows.count = 0;
+}
+
+
+/* Clear the pertinant detail in the source windows.   */
+void
+tui_clear_source_windows_detail (void)
+{
+  int i;
+
+  for (i = 0; i < (tui_source_windows ())->count; i++)
+    tui_clear_win_detail ((struct tui_win_info *) (tui_source_windows ())->list[i]);
+}
+
+
+/* Add a window to the list of source windows.  Usually there is only
+   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 * win_info)
+{
+  if (source_windows.count < 2)
+    source_windows.list[source_windows.count++] = (void *) win_info;
+}
+
+
+/* Clear the pertinant detail in the windows.   */
+void
+tui_clear_win_detail (struct tui_win_info * win_info)
+{
+  if (win_info != NULL)
+    {
+      switch (win_info->generic.type)
+	{
+	case SRC_WIN:
+	case DISASSEM_WIN:
+	  win_info->detail.source_info.start_line_or_addr.addr = 0;
+	  win_info->detail.source_info.horizontal_offset = 0;
+	  break;
+	case CMD_WIN:
+	  win_info->detail.command_info.cur_line =
+	    win_info->detail.command_info.curch = 0;
+	  break;
+	case DATA_WIN:
+	  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;
+	  win_info->detail.data_display_info.regs_column_count = 1;
+	  win_info->detail.data_display_info.display_regs = FALSE;
+	  break;
+	default:
+	  break;
+	}
+    }
+}
+
+
+/* Accessor for the source execution info ptr.  */
+struct tui_gen_win_info *
+tui_source_exec_info_win_ptr (void)
+{
+  return &exec_info[0];
+}
+
+
+/* Accessor for the disassem execution info ptr.  */
+struct tui_gen_win_info *
+tui_disassem_exec_info_win_ptr (void)
+{
+  return &exec_info[1];
+}
+
+
+/* Accessor for the locator win info.  Answers a pointer to the static
+   locator win info struct.  */
+struct tui_gen_win_info *
+tui_locator_win_info_ptr (void)
+{
+  return &_locator;
+}
+
+
+/* Accessor for the term_height.  */
+int
+tui_term_height (void)
+{
+  return term_height;
+}
+
+
+/* Mutator for the term height.   */
+void
+tui_set_term_height_to (int h)
+{
+  term_height = h;
+}
+
+
+/* Accessor for the term_width.   */
+int
+tui_term_width (void)
+{
+  return term_width;
+}
+
+
+/* Mutator for the term_width.  */
+void
+tui_set_term_width_to (int w)
+{
+  term_width = w;
+}
+
+
+/* Accessor for the current layout.   */
+enum tui_layout_type
+tui_current_layout (void)
+{
+  return current_layout;
+}
+
+
+/* Mutator for the current layout.  */
+void
+tui_set_current_layout_to (enum tui_layout_type new_layout)
+{
+  current_layout = new_layout;
+}
+
+
+/* Set the origin of the window.  */
+void
+set_gen_win_origin (struct tui_gen_win_info * win_info, int x, int y)
+{
+  win_info->origin.x = x;
+  win_info->origin.y = y;
+}
+
+
+/*****************************
+** OTHER PUBLIC FUNCTIONS
+*****************************/
+
+
+/* Answer the next window in the list, cycling back to the top if
+   necessary.  */
+struct tui_win_info *
+tui_next_win (struct tui_win_info * cur_win)
+{
+  enum tui_win_type type = cur_win->generic.type;
+  struct tui_win_info * next_win = (struct tui_win_info *) NULL;
+
+  if (cur_win->generic.type == CMD_WIN)
+    type = SRC_WIN;
+  else
+    type = cur_win->generic.type + 1;
+  while (type != cur_win->generic.type && (next_win == NULL))
+    {
+      if (tui_win_list[type] && tui_win_list[type]->generic.is_visible)
+	next_win = tui_win_list[type];
+      else
+	{
+	  if (type == CMD_WIN)
+	    type = SRC_WIN;
+	  else
+	    type++;
+	}
+    }
+
+  return next_win;
+}
+
+
+/* Answer the prev window in the list, cycling back to the bottom if
+   necessary.  */
+struct tui_win_info *
+tui_prev_win (struct tui_win_info * cur_win)
+{
+  enum tui_win_type type = cur_win->generic.type;
+  struct tui_win_info * prev = (struct tui_win_info *) NULL;
+
+  if (cur_win->generic.type == SRC_WIN)
+    type = CMD_WIN;
+  else
+    type = cur_win->generic.type - 1;
+  while (type != cur_win->generic.type && (prev == NULL))
+    {
+      if (tui_win_list[type]->generic.is_visible)
+	prev = tui_win_list[type];
+      else
+	{
+	  if (type == SRC_WIN)
+	    type = CMD_WIN;
+	  else
+	    type--;
+	}
+    }
+
+  return prev;
+}
+
+
+/* Answer the window represented by name.    */
+struct tui_win_info *
+tui_partial_win_by_name (char *name)
+{
+  struct tui_win_info * win_info = (struct tui_win_info *) NULL;
+
+  if (name != (char *) NULL)
+    {
+      int i = 0;
+
+      while (i < MAX_MAJOR_WINDOWS && win_info == NULL)
+	{
+          if (tui_win_list[i] != 0)
+            {
+              char *cur_name = tui_win_name (&tui_win_list[i]->generic);
+              if (strlen (name) <= strlen (cur_name) &&
+                  strncmp (name, cur_name, strlen (name)) == 0)
+                win_info = tui_win_list[i];
+            }
+	  i++;
+	}
+    }
+
+  return win_info;
+}
+
+
+/* Answer the name of the window.  */
+char *
+tui_win_name (struct tui_gen_win_info * win_info)
+{
+  char *name = (char *) NULL;
+
+  switch (win_info->type)
+    {
+    case SRC_WIN:
+      name = SRC_NAME;
+      break;
+    case CMD_WIN:
+      name = CMD_NAME;
+      break;
+    case DISASSEM_WIN:
+      name = DISASSEM_NAME;
+      break;
+    case DATA_WIN:
+      name = DATA_NAME;
+      break;
+    default:
+      name = "";
+      break;
+    }
+
+  return name;
+}
+
+
+void
+tui_initialize_static_data (void)
+{
+  tui_init_generic_part (tui_source_exec_info_win_ptr ());
+  tui_init_generic_part (tui_disassem_exec_info_win_ptr ());
+  tui_init_generic_part (tui_locator_win_info_ptr ());
+}
+
+
+struct tui_gen_win_info *
+tui_alloc_generic_win_info (void)
+{
+  struct tui_gen_win_info * win;
+
+  if ((win = (struct tui_gen_win_info *) xmalloc (
+		     sizeof (struct tui_gen_win_info *))) != (struct tui_gen_win_info *) NULL)
+    tui_init_generic_part (win);
+
+  return win;
+}
+
+
+void
+tui_init_generic_part (struct tui_gen_win_info * win)
+{
+  win->width =
+    win->height =
+    win->origin.x =
+    win->origin.y =
+    win->viewport_height =
+    win->content_size =
+    win->last_visible_line = 0;
+  win->handle = (WINDOW *) NULL;
+  win->content = NULL;
+  win->content_in_use =
+    win->is_visible = FALSE;
+  win->title = 0;
+}
+
+
+/*
+   ** init_content_element().
+ */
+void
+init_content_element (struct tui_win_element * element, enum tui_win_type type)
+{
+  element->highlight = FALSE;
+  switch (type)
+    {
+    case SRC_WIN:
+    case DISASSEM_WIN:
+      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->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->which_element.data_window)->content_size = 1;
+      break;
+    case CMD_WIN:
+      element->which_element.command.line = (char *) NULL;
+      break;
+    case DATA_ITEM_WIN:
+      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;
+      element->which_element.data.content = (char*) NULL;
+      break;
+    case LOCATOR_WIN:
+      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->which_element.simple_string, ' ',
+             sizeof(element->which_element.simple_string));
+      break;
+    default:
+      break;
+    }
+}
+
+void
+init_win_info (struct tui_win_info * win_info)
+{
+  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:
+      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:
+      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;
+      win_info->detail.data_display_info.regs_column_count = 1;
+      win_info->detail.data_display_info.display_regs = FALSE;
+      win_info->detail.data_display_info.current_group = 0;
+      break;
+    case CMD_WIN:
+      win_info->detail.command_info.cur_line = 0;
+      win_info->detail.command_info.curch = 0;
+      break;
+    default:
+      win_info->detail.opaque = NULL;
+      break;
+    }
+}
+
+
+struct tui_win_info *
+tui_alloc_win_info (enum tui_win_type type)
+{
+  struct tui_win_info * win_info = (struct tui_win_info *) NULL;
+
+  win_info = (struct tui_win_info *) xmalloc (sizeof (struct tui_win_info));
+  if ((win_info != NULL))
+    {
+      win_info->generic.type = type;
+      init_win_info (win_info);
+    }
+
+  return win_info;
+}
+
+
+/* Allocates the content and elements in a block.  */
+tui_win_content
+tui_alloc_content (int num_elements, enum tui_win_type type)
+{
+  tui_win_content content = (tui_win_content) NULL;
+  char *element_block_ptr = (char *) NULL;
+  int i;
+
+  if ((content = (tui_win_content)
+  xmalloc (sizeof (struct tui_win_element *) * num_elements)) != (tui_win_content) NULL)
+    {				/*
+				   ** All windows, except the data window, can allocate the elements
+				   ** in a chunk.  The data window cannot because items can be
+				   ** added/removed from the data display by the user at any time.
+				 */
+      if (type != DATA_WIN)
+	{
+	  if ((element_block_ptr = (char *)
+	   xmalloc (sizeof (struct tui_win_element) * num_elements)) != (char *) NULL)
+	    {
+	      for (i = 0; i < num_elements; i++)
+		{
+		  content[i] = (struct tui_win_element *) element_block_ptr;
+		  init_content_element (content[i], type);
+		  element_block_ptr += sizeof (struct tui_win_element);
+		}
+	    }
+	  else
+	    {
+	      xfree (content);
+	      content = (tui_win_content) NULL;
+	    }
+	}
+    }
+
+  return content;
+}
+
+
+/* Adds the input number of elements to the windows's content.  If no
+   content has been allocated yet, alloc_content() is called to do
+   this.  The index of the first element added is returned, unless
+   there is a memory allocation error, in which case, (-1) is
+   returned.  */
+int
+tui_add_content_elements (struct tui_gen_win_info * win_info, int num_elements)
+{
+  struct tui_win_element * element_ptr;
+  int i, index_start;
+
+  if (win_info->content == NULL)
+    {
+      win_info->content = (void **) tui_alloc_content (num_elements, win_info->type);
+      index_start = 0;
+    }
+  else
+    index_start = win_info->content_size;
+  if (win_info->content != NULL)
+    {
+      for (i = index_start; (i < num_elements + index_start); i++)
+	{
+	  if ((element_ptr = (struct tui_win_element *)
+	       xmalloc (sizeof (struct tui_win_element))) != (struct tui_win_element *) NULL)
+	    {
+	      win_info->content[i] = (void *) element_ptr;
+	      init_content_element (element_ptr, win_info->type);
+	      win_info->content_size++;
+	    }
+	  else			/* things must be really hosed now! We ran out of memory!? */
+	    return (-1);
+	}
+    }
+
+  return index_start;
+}
+
+
+/* Delete all curses windows associated with win_info, leaving everything
+   else intact.  */
+void
+tui_del_window (struct tui_win_info * win_info)
+{
+  struct tui_gen_win_info * generic_win;
+
+  switch (win_info->generic.type)
+    {
+    case SRC_WIN:
+    case DISASSEM_WIN:
+      generic_win = tui_locator_win_info_ptr ();
+      if (generic_win != (struct tui_gen_win_info *) NULL)
+	{
+	  tui_delete_win (generic_win->handle);
+	  generic_win->handle = (WINDOW *) NULL;
+	  generic_win->is_visible = FALSE;
+	}
+      if (win_info->detail.source_info.filename)
+        {
+          xfree (win_info->detail.source_info.filename);
+          win_info->detail.source_info.filename = 0;
+        }
+      generic_win = win_info->detail.source_info.execution_info;
+      if (generic_win != (struct tui_gen_win_info *) NULL)
+	{
+	  tui_delete_win (generic_win->handle);
+	  generic_win->handle = (WINDOW *) NULL;
+	  generic_win->is_visible = FALSE;
+	}
+      break;
+    case DATA_WIN:
+      if (win_info->generic.content != NULL)
+	{
+	  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 (win_info->generic.handle != (WINDOW *) NULL)
+    {
+      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 * win_info)
+{
+  struct tui_gen_win_info * generic_win;
+
+  switch (win_info->generic.type)
+    {
+    case SRC_WIN:
+    case DISASSEM_WIN:
+      generic_win = tui_locator_win_info_ptr ();
+      if (generic_win != (struct tui_gen_win_info *) NULL)
+	{
+	  tui_delete_win (generic_win->handle);
+	  generic_win->handle = (WINDOW *) NULL;
+	}
+      tui_free_win_content (generic_win);
+      if (win_info->detail.source_info.filename)
+        {
+          xfree (win_info->detail.source_info.filename);
+          win_info->detail.source_info.filename = 0;
+        }
+      generic_win = win_info->detail.source_info.execution_info;
+      if (generic_win != (struct tui_gen_win_info *) NULL)
+	{
+	  tui_delete_win (generic_win->handle);
+	  generic_win->handle = (WINDOW *) NULL;
+	  tui_free_win_content (generic_win);
+	}
+      break;
+    case DATA_WIN:
+      if (win_info->generic.content != NULL)
+	{
+	  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;
+	  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;
+	  win_info->detail.data_display_info.data_content_count = 0;
+	  win_info->detail.data_display_info.regs_display_type =
+	    TUI_UNDEFINED_REGS;
+	  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 (win_info->generic.handle != (WINDOW *) NULL)
+    {
+      tui_delete_win (win_info->generic.handle);
+      win_info->generic.handle = (WINDOW *) NULL;
+      tui_free_win_content (&win_info->generic);
+    }
+  if (win_info->generic.title)
+    xfree (win_info->generic.title);
+  xfree (win_info);
+}
+
+
+void
+tui_free_all_source_wins_content (void)
+{
+  int i;
+
+  for (i = 0; i < (tui_source_windows ())->count; i++)
+    {
+      struct tui_win_info * win_info = (struct tui_win_info *) (tui_source_windows ())->list[i];
+
+      if (win_info != NULL)
+	{
+	  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 * win_info)
+{
+  if (win_info->content != NULL)
+    {
+      free_content ((tui_win_content) win_info->content,
+		   win_info->content_size,
+		   win_info->type);
+      win_info->content = NULL;
+    }
+  win_info->content_size = 0;
+}
+
+
+void
+tui_del_data_windows (tui_win_content content, int content_size)
+{
+  int i;
+
+  /*
+     ** Remember that data window content elements are of type struct tui_gen_win_info *,
+     ** each of which whose single element is a data element.
+   */
+  for (i = 0; i < content_size; i++)
+    {
+      struct tui_gen_win_info * generic_win = &content[i]->which_element.data_window;
+
+      if (generic_win != (struct tui_gen_win_info *) NULL)
+	{
+	  tui_delete_win (generic_win->handle);
+	  generic_win->handle = (WINDOW *) NULL;
+	  generic_win->is_visible = FALSE;
+	}
+    }
+}
+
+
+void
+tui_free_data_content (tui_win_content content, int content_size)
+{
+  int i;
+
+  /*
+     ** Remember that data window content elements are of type struct tui_gen_win_info *,
+     ** each of which whose single element is a data element.
+   */
+  for (i = 0; i < content_size; i++)
+    {
+      struct tui_gen_win_info * generic_win = &content[i]->which_element.data_window;
+
+      if (generic_win != (struct tui_gen_win_info *) NULL)
+	{
+	  tui_delete_win (generic_win->handle);
+	  generic_win->handle = (WINDOW *) NULL;
+	  tui_free_win_content (generic_win);
+	}
+    }
+  free_content (content,
+	       content_size,
+	       DATA_WIN);
+}
+
+
+/**********************************
+** LOCAL STATIC FUNCTIONS        **
+**********************************/
+
+
+static void
+free_content (tui_win_content content, int content_size, enum tui_win_type win_type)
+{
+  if (content != (tui_win_content) NULL)
+    {
+      free_content_elements (content, content_size, win_type);
+      xfree (content);
+    }
+}
+
+
+/*
+   ** free_content_elements().
+ */
+static void
+free_content_elements (tui_win_content content, int content_size, enum tui_win_type type)
+{
+  if (content != (tui_win_content) NULL)
+    {
+      int i;
+
+      if (type == SRC_WIN || type == DISASSEM_WIN)
+	{
+	  /* free whole source block */
+	  xfree (content[0]->which_element.source.line);
+	}
+      else
+	{
+	  for (i = 0; i < content_size; i++)
+	    {
+	      struct tui_win_element * element;
+
+	      element = content[i];
+	      if (element != (struct tui_win_element *) NULL)
+		{
+		  switch (type)
+		    {
+		    case DATA_WIN:
+		      xfree (element);
+		      break;
+		    case DATA_ITEM_WIN:
+		      /*
+		         ** Note that data elements are not allocated
+		         ** in a single block, but individually, as needed.
+		       */
+		      if (element->which_element.data.type != TUI_REGISTER)
+			xfree ((void *)element->which_element.data.name);
+		      xfree (element->which_element.data.value);
+                      xfree (element->which_element.data.content);
+		      xfree (element);
+		      break;
+		    case CMD_WIN:
+		      xfree (element->which_element.command.line);
+		      break;
+		    default:
+		      break;
+		    }
+		}
+	    }
+	}
+      if (type != DATA_WIN && type != DATA_ITEM_WIN)
+	xfree (content[0]);	/* free the element block */
+    }
+}
diff --git a/gdb/tui/tui-data.h b/gdb/tui/tui-data.h
new file mode 100644
index 00000000000..02bebb4e2be
--- /dev/null
+++ b/gdb/tui/tui-data.h
@@ -0,0 +1,351 @@
+/* TUI data manipulation routines.
+
+   Copyright 1998, 1999, 2000, 2001, 2002, 2004 Free Software
+   Foundation, Inc.
+
+   Contributed by Hewlett-Packard Company.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#ifndef TUI_DATA_H
+#define TUI_DATA_H
+
+#include "tui/tui.h"	/* For enum tui_win_type.  */
+#include "gdb_curses.h"	/* For WINDOW.  */
+
+/* This is a point definition.  */
+struct tui_point
+{
+  int x, y;
+};
+
+/* Generic window information */
+struct tui_gen_win_info
+{
+  WINDOW *handle;	/* window handle */
+  enum tui_win_type type;	/* type of window */
+  int width;		/* window width */
+  int height;		/* window height */
+  struct tui_point origin;	/* origin of window */
+  void **content;	/* content of window */
+  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 */
+#define DEFAULT_TAB_LEN                8
+#define NO_SRC_STRING                  "[ No Source Available ]"
+#define NO_DISASSEM_STRING             "[ No Assembly Available ]"
+#define NO_REGS_STRING                 "[ Register Values Unavailable ]"
+#define NO_DATA_STRING                 "[ No Data Values Displayed ]"
+#define MAX_CONTENT_COUNT              100
+#define SRC_NAME                       "SRC"
+#define CMD_NAME                       "CMD"
+#define DATA_NAME                      "REGS"
+#define DISASSEM_NAME                  "ASM"
+#define TUI_NULL_STR                   ""
+#define DEFAULT_HISTORY_COUNT          25
+#define BOX_WINDOW                     TRUE
+#define DONT_BOX_WINDOW                FALSE
+#define HILITE                         TRUE
+#define NO_HILITE                      FALSE
+#define WITH_LOCATOR                   TRUE
+#define NO_LOCATOR                     FALSE
+#define EMPTY_SOURCE_PROMPT            TRUE
+#define NO_EMPTY_SOURCE_PROMPT         FALSE
+#define UNDEFINED_ITEM                 -1
+#define MIN_WIN_HEIGHT                 3
+#define MIN_CMD_WIN_HEIGHT             3
+
+/* Strings to display in the TUI status line.  */
+#define PROC_PREFIX                    "In: "
+#define LINE_PREFIX                    "Line: "
+#define PC_PREFIX                      "PC: "
+#define SINGLE_KEY                     "(SingleKey)"
+
+/* Minimum/Maximum length of some fields displayed in the TUI status line.  */
+#define MIN_LINE_WIDTH     4 /* Use at least 4 digits for line numbers.  */
+#define MIN_PROC_WIDTH    12
+#define MAX_TARGET_WIDTH  10
+#define MAX_PID_WIDTH     14
+
+#define TUI_FLOAT_REGS_NAME                  "$FREGS"
+#define TUI_FLOAT_REGS_NAME_LOWER            "$fregs"
+#define TUI_GENERAL_REGS_NAME                "$GREGS"
+#define TUI_GENERAL_REGS_NAME_LOWER          "$gregs"
+#define TUI_SPECIAL_REGS_NAME                "$SREGS"
+#define TUI_SPECIAL_REGS_NAME_LOWER          "$sregs"
+#define TUI_GENERAL_SPECIAL_REGS_NAME        "$REGS"
+#define TUI_GENERAL_SPECIAL_REGS_NAME_LOWER  "$regs"
+
+/* Scroll direction enum.  */
+enum tui_scroll_direction
+{
+  FORWARD_SCROLL,
+  BACKWARD_SCROLL,
+  LEFT_SCROLL,
+  RIGHT_SCROLL
+};
+
+
+/* General list struct.  */
+struct tui_list
+{
+  void **list;
+  int count;
+};
+
+
+/* The kinds of layouts available */
+enum tui_layout_type
+{
+  SRC_COMMAND,
+  DISASSEM_COMMAND,
+  SRC_DISASSEM_COMMAND,
+  SRC_DATA_COMMAND,
+  DISASSEM_DATA_COMMAND,
+  UNDEFINED_LAYOUT
+};
+
+/* Basic data types that can be displayed in the data window. */
+enum tui_data_type
+{
+  TUI_REGISTER,
+  TUI_SCALAR,
+  TUI_COMPLEX,
+  TUI_STRUCT
+};
+
+/* Types of register displays */
+enum tui_register_display_type
+{
+  TUI_UNDEFINED_REGS,
+  TUI_GENERAL_REGS,
+  TUI_SFLOAT_REGS,
+  TUI_DFLOAT_REGS,
+  TUI_SPECIAL_REGS,
+  TUI_GENERAL_AND_SPECIAL_REGS
+};
+
+/* Structure describing source line or line address */
+union tui_line_or_address
+{
+  int line_no;
+  CORE_ADDR addr;
+};
+
+/* Current Layout definition */
+struct tui_layout_def
+{
+  enum tui_win_type display_mode;
+  int split;
+  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 line_or_addr;
+  int is_exec_point;
+  int has_break;
+};
+
+
+/* Elements in the data display window content */
+struct tui_data_element
+{
+  const char *name;
+  int item_no;			/* the register number, or data display number */
+  enum tui_data_type type;
+  void *value;
+  int highlight;
+  char *content;
+};
+
+
+/* Elements in the command window content */
+struct tui_command_element
+{
+  char *line;
+};
+
+
+#define MAX_LOCATOR_ELEMENT_LEN        100
+
+/* Elements in the locator window content */
+struct tui_locator_element
+{
+  char file_name[MAX_LOCATOR_ELEMENT_LEN];
+  char proc_name[MAX_LOCATOR_ELEMENT_LEN];
+  int line_no;
+  CORE_ADDR addr;
+};
+
+/* Flags to tell what kind of breakpoint is at current line.  */
+#define TUI_BP_ENABLED      0x01
+#define TUI_BP_DISABLED     0x02
+#define TUI_BP_HIT          0x04
+#define TUI_BP_CONDITIONAL  0x08
+#define TUI_BP_HARDWARE     0x10
+
+/* Position of breakpoint markers in the exec info string.  */
+#define TUI_BP_HIT_POS      0
+#define TUI_BP_BREAK_POS    1
+#define TUI_EXEC_POS        2
+#define TUI_EXECINFO_SIZE   4
+
+typedef char tui_exec_info_content[TUI_EXECINFO_SIZE];
+
+/* An content element in a window */
+union tui_which_element
+{
+  struct tui_source_element source;	/* the source elements */
+  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 simple_string;	/* simple char based elements */
+};
+
+struct tui_win_element
+{
+  int highlight;
+  union tui_which_element which_element;
+};
+
+
+/* This describes the content of the window. */
+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 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 reggroup *current_group;
+};
+
+
+struct tui_source_info
+{
+  int has_locator;		/* Does locator belongs to this window? */
+  /* Execution information window.  */
+  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 cur_line;		/* The current line position */
+  int curch;			/* The current cursor position */
+  int start_line;
+};
+
+
+/* This defines information about each logical window */
+struct tui_win_info
+{
+  struct tui_gen_win_info generic;	/* general window information */
+  union
+  {
+    struct tui_source_info source_info;
+    struct tui_data_info data_display_info;
+    struct tui_command_info command_info;
+    void *opaque;
+  }
+  detail;
+  int can_highlight;		/* Can this window ever be highlighted? */
+  int is_highlighted;		/* Is this window highlighted? */
+};
+
+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 *(tui_win_list[MAX_MAJOR_WINDOWS]);
+
+#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);
+extern struct tui_gen_win_info *tui_alloc_generic_win_info (void);
+extern struct tui_win_info *tui_alloc_win_info (enum tui_win_type);
+extern void tui_init_generic_part (struct tui_gen_win_info *);
+extern void tui_init_win_info (struct tui_win_info *);
+extern tui_win_content tui_alloc_content (int, enum tui_win_type);
+extern int tui_add_content_elements (struct tui_gen_win_info *, int);
+extern void tui_init_content_element (struct tui_win_element *, enum tui_win_type);
+extern void tui_free_window (struct tui_win_info *);
+extern void tui_free_win_content (struct tui_gen_win_info *);
+extern void tui_free_data_content (tui_win_content, int);
+extern void tui_free_all_source_wins_content (void);
+extern void tui_del_window (struct tui_win_info *);
+extern void tui_del_data_windows (tui_win_content, int);
+extern struct tui_win_info *tui_partial_win_by_name (char *);
+extern char *tui_win_name (struct tui_gen_win_info *);
+extern enum tui_layout_type tui_current_layout (void);
+extern void tui_set_current_layout_to (enum tui_layout_type);
+extern int tui_term_height (void);
+extern void tui_set_term_height_to (int);
+extern int tui_term_width (void);
+extern void tui_set_term_width_to (int);
+extern void tui_set_gen_win_origin (struct tui_gen_win_info *, int, int);
+extern struct tui_gen_win_info *tui_locator_win_info_ptr (void);
+extern struct tui_gen_win_info *tui_source_exec_info_win_ptr (void);
+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 * 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);
+extern struct tui_win_info *tui_win_with_focus (void);
+extern void tui_set_win_with_focus (struct tui_win_info *);
+extern struct tui_layout_def * tui_layout_def (void);
+extern int tui_win_resized (void);
+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 * win_info);
+
+#endif /* TUI_DATA_H */
diff --git a/gdb/tui/tuiDisassem.c b/gdb/tui/tui-disasm.c
index e36c5df521b..9c3072bf74e 100644
--- a/gdb/tui/tuiDisassem.c
+++ b/gdb/tui/tui-disasm.c
@@ -1,7 +1,7 @@
 /* Disassembly display.
 
-   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.
 
@@ -29,22 +29,16 @@
 #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"
+#include "tui/tui-layout.h"
+#include "tui/tui-winsource.h"
+#include "tui/tui-stack.h"
+#include "tui/tui-file.h"
 
-#include "tui.h"
-#include "tuiData.h"
-#include "tuiWin.h"
-#include "tuiLayout.h"
-#include "tuiSourceWin.h"
-#include "tuiStack.h"
-#include "tui-file.h"
-
-#ifdef HAVE_NCURSES_H       
-#include <ncurses.h>
-#else
-#ifdef HAVE_CURSES_H
-#include <curses.h>
-#endif
-#endif
+#include "gdb_curses.h"
 
 struct tui_asm_line 
 {
@@ -57,7 +51,7 @@ struct tui_asm_line
    Disassemble count lines starting at pc.
    Return address of the count'th instruction after pc.  */
 static CORE_ADDR
-tui_disassemble (struct tui_asm_line* lines, CORE_ADDR pc, int count)
+tui_disassemble (struct tui_asm_line* asm_lines, CORE_ADDR pc, int count)
 {
   struct ui_file *gdb_dis_out;
 
@@ -65,22 +59,22 @@ tui_disassemble (struct tui_asm_line* lines, CORE_ADDR pc, int count)
   gdb_dis_out = tui_sfileopen (256);
 
   /* Now construct each line */
-  for (; count > 0; count--, lines++)
+  for (; count > 0; count--, asm_lines++)
     {
-      if (lines->addr_string)
-        xfree (lines->addr_string);
-      if (lines->insn)
-        xfree (lines->insn);
+      if (asm_lines->addr_string)
+        xfree (asm_lines->addr_string);
+      if (asm_lines->insn)
+        xfree (asm_lines->insn);
       
       print_address (pc, gdb_dis_out);
-      lines->addr = pc;
-      lines->addr_string = xstrdup (tui_file_get_strbuf (gdb_dis_out));
+      asm_lines->addr = pc;
+      asm_lines->addr_string = xstrdup (tui_file_get_strbuf (gdb_dis_out));
 
       ui_file_rewind (gdb_dis_out);
 
       pc = pc + gdb_print_insn (pc, gdb_dis_out);
 
-      lines->insn = xstrdup (tui_file_get_strbuf (gdb_dis_out));
+      asm_lines->insn = xstrdup (tui_file_get_strbuf (gdb_dis_out));
 
       /* reset the buffer to empty */
       ui_file_rewind (gdb_dis_out);
@@ -95,24 +89,24 @@ tui_disassemble (struct tui_asm_line* lines, CORE_ADDR pc, int count)
 static CORE_ADDR
 tui_find_disassembly_address (CORE_ADDR pc, int from)
 {
-  register CORE_ADDR newLow;
-  int maxLines;
+  CORE_ADDR new_low;
+  int max_lines;
   int i;
-  struct tui_asm_line* lines;
+  struct tui_asm_line* asm_lines;
 
-  maxLines = (from > 0) ? from : - from;
-  if (maxLines <= 1)
+  max_lines = (from > 0) ? from : - from;
+  if (max_lines <= 1)
      return pc;
 
-  lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line)
-                                         * maxLines);
-  memset (lines, 0, sizeof (struct tui_asm_line) * maxLines);
+  asm_lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line)
+                                         * max_lines);
+  memset (asm_lines, 0, sizeof (struct tui_asm_line) * max_lines);
 
-  newLow = pc;
+  new_low = pc;
   if (from > 0)
     {
-      tui_disassemble (lines, pc, maxLines);
-      newLow = lines[maxLines - 1].addr;
+      tui_disassemble (asm_lines, pc, max_lines);
+      new_low = asm_lines[max_lines - 1].addr;
     }
   else
     {
@@ -123,18 +117,18 @@ tui_find_disassembly_address (CORE_ADDR pc, int from)
       /* Find backward an address which is a symbol
          and for which disassembling from that address will fill
          completely the window.  */
-      pos = maxLines - 1;
+      pos = max_lines - 1;
       do {
-         newLow -= 1 * maxLines;
-         msymbol = lookup_minimal_symbol_by_pc_section (newLow, 0);
+         new_low -= 1 * max_lines;
+         msymbol = lookup_minimal_symbol_by_pc_section (new_low, 0);
 
          if (msymbol)
-            newLow = SYMBOL_VALUE_ADDRESS (msymbol);
+            new_low = SYMBOL_VALUE_ADDRESS (msymbol);
          else
-            newLow += 1 * maxLines;
+            new_low += 1 * max_lines;
 
-         tui_disassemble (lines, newLow, maxLines);
-         last_addr = lines[pos].addr;
+         tui_disassemble (asm_lines, new_low, max_lines);
+         last_addr = asm_lines[pos].addr;
       } while (last_addr > pc && msymbol);
 
       /* Scan forward disassembling one instruction at a time
@@ -148,10 +142,10 @@ tui_find_disassembly_address (CORE_ADDR pc, int from)
             CORE_ADDR next_addr;
                  
             pos++;
-            if (pos >= maxLines)
+            if (pos >= max_lines)
               pos = 0;
 
-            next_addr = tui_disassemble (&lines[pos], last_addr, 1);
+            next_addr = tui_disassemble (&asm_lines[pos], last_addr, 1);
 
             /* If there are some problems while disassembling exit.  */
             if (next_addr <= last_addr)
@@ -159,30 +153,30 @@ tui_find_disassembly_address (CORE_ADDR pc, int from)
             last_addr = next_addr;
           } while (last_addr <= pc);
       pos++;
-      if (pos >= maxLines)
+      if (pos >= max_lines)
          pos = 0;
-      newLow = lines[pos].addr;
+      new_low = asm_lines[pos].addr;
     }
-  for (i = 0; i < maxLines; i++)
+  for (i = 0; i < max_lines; i++)
     {
-      xfree (lines[i].addr_string);
-      xfree (lines[i].insn);
+      xfree (asm_lines[i].addr_string);
+      xfree (asm_lines[i].insn);
     }
-  return newLow;
+  return new_low;
 }
 
 /* Function to set the disassembly window's content.  */
-TuiStatus
-tuiSetDisassemContent (CORE_ADDR pc)
+enum tui_status
+tui_set_disassem_content (CORE_ADDR pc)
 {
-  TuiStatus ret = TUI_FAILURE;
-  register int i;
-  register int offset = disassemWin->detail.sourceInfo.horizontalOffset;
-  register int lineWidth, maxLines;
+  enum tui_status ret = TUI_FAILURE;
+  int i;
+  int offset = TUI_DISASM_WIN->detail.source_info.horizontal_offset;
+  int line_width, max_lines;
   CORE_ADDR cur_pc;
-  TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
-  int tab_len = tuiDefaultTabLen ();
-  struct tui_asm_line* lines;
+  struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
+  int tab_len = tui_default_tab_len ();
+  struct tui_asm_line* asm_lines;
   int insn_pos;
   int addr_size, max_size;
   char* line;
@@ -190,35 +184,35 @@ tuiSetDisassemContent (CORE_ADDR pc)
   if (pc == 0)
     return TUI_FAILURE;
 
-  ret = tuiAllocSourceBuffer (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)
-    (((TuiWinElementPtr) 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 */
+  max_lines = 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);
+  asm_lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line)
+                                         * max_lines);
+  memset (asm_lines, 0, sizeof (struct tui_asm_line) * max_lines);
 
-  lineWidth = disassemWin->generic.width - 1;
+  line_width = TUI_DISASM_WIN->generic.width - 1;
 
-  tui_disassemble (lines, pc, maxLines);
+  tui_disassemble (asm_lines, pc, max_lines);
 
   /* See what is the maximum length of an address and of a line.  */
   addr_size = 0;
   max_size = 0;
-  for (i = 0; i < maxLines; i++)
+  for (i = 0; i < max_lines; i++)
     {
-      size_t len = strlen (lines[i].addr_string);
+      size_t len = strlen (asm_lines[i].addr_string);
       if (len > addr_size)
         addr_size = len;
 
-      len = strlen (lines[i].insn) + tab_len;
+      len = strlen (asm_lines[i].insn) + tab_len;
       if (len > max_size)
         max_size = len;
     }
@@ -229,25 +223,25 @@ tuiSetDisassemContent (CORE_ADDR pc)
   insn_pos = (1 + (addr_size / tab_len)) * tab_len;
 
   /* Now construct each line */
-  for (i = 0; i < maxLines; i++)
+  for (i = 0; i < max_lines; i++)
     {
-      TuiWinElementPtr element;
-      TuiSourceElement* src;
-      int curLen;
+      struct tui_win_element * element;
+      struct tui_source_element* src;
+      int cur_len;
 
-      element = (TuiWinElementPtr) disassemWin->generic.content[i];
-      src = &element->whichElement.source;
-      strcpy (line, lines[i].addr_string);
-      curLen = strlen (line);
+      element = (struct tui_win_element *) TUI_DISASM_WIN->generic.content[i];
+      src = &element->which_element.source;
+      strcpy (line, asm_lines[i].addr_string);
+      cur_len = strlen (line);
 
       /* Add spaces to make the instructions start on the same column */
-      while (curLen < insn_pos)
+      while (cur_len < insn_pos)
         {
           strcat (line, " ");
-          curLen++;
+          cur_len++;
         }
 
-      strcat (line, lines[i].insn);
+      strcat (line, asm_lines[i].insn);
 
       /* Now copy the line taking the offset into account */
       if (strlen (line) > offset)
@@ -255,91 +249,82 @@ tuiSetDisassemContent (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 = asm_lines[i].addr;
+      src->is_exec_point = asm_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);
+      xfree (asm_lines[i].addr_string);
+      xfree (asm_lines[i].insn);
     }
-  disassemWin->generic.contentSize = i;
+  TUI_DISASM_WIN->generic.content_size = i;
   return TUI_SUCCESS;
 }
 
 
-/*
-   ** tuiShowDisassem().
-   **        Function to display the disassembly window with disassembled code.
- */
+/* Function to display the disassembly window with disassembled code.   */
 void
-tuiShowDisassem (CORE_ADDR startAddr)
+tui_show_disassem (CORE_ADDR start_addr)
 {
-  struct symtab *s = find_pc_symtab (startAddr);
-  TuiWinInfoPtr winWithFocus = tuiWinWithFocus ();
-  TuiLineOrAddress val;
+  struct symtab *s = find_pc_symtab (start_addr);
+  struct tui_win_info * win_with_focus = tui_win_with_focus ();
+  union tui_line_or_address val;
 
-  val.addr = startAddr;
-  tuiAddWinToLayout (DISASSEM_WIN);
-  tuiUpdateSourceWindow (disassemWin, s, val, FALSE);
+  val.addr = start_addr;
+  tui_add_win_to_layout (DISASSEM_WIN);
+  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 (currentLayout () != SRC_DISASSEM_COMMAND && winWithFocus == srcWin)
-    tuiSetWinFocusTo (disassemWin);
+  if (tui_current_layout () != SRC_DISASSEM_COMMAND && win_with_focus == TUI_SRC_WIN)
+    tui_set_win_focus_to (TUI_DISASM_WIN);
 
   return;
-}				/* tuiShowDisassem */
+}
 
 
-/*
-   ** tuiShowDisassemAndUpdateSource().
-   **        Function to display the disassembly window.
- */
+/* Function to display the disassembly window.   */
 void
-tuiShowDisassemAndUpdateSource (CORE_ADDR startAddr)
+tui_show_disassem_and_update_source (CORE_ADDR start_addr)
 {
   struct symtab_and_line sal;
 
-  tuiShowDisassem (startAddr);
-  if (currentLayout () == SRC_DISASSEM_COMMAND)
+  tui_show_disassem (start_addr);
+  if (tui_current_layout () == SRC_DISASSEM_COMMAND)
     {
-      TuiLineOrAddress val;
+      union tui_line_or_address val;
 
       /*
          ** Update what is in the source window if it is displayed too,
          ** note that it follows what is in the disassembly window and visa-versa
        */
-      sal = find_pc_line (startAddr, 0);
-      val.lineNo = sal.line;
-      tuiUpdateSourceWindow (srcWin, sal.symtab, val, TRUE);
+      sal = find_pc_line (start_addr, 0);
+      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);
-	  tuiUpdateLocatorFilename (sal.symtab->filename);
+	  tui_update_locator_filename (sal.symtab->filename);
 	}
       else
-	tuiUpdateLocatorFilename ("?");
+	tui_update_locator_filename ("?");
     }
 
   return;
-}				/* tuiShowDisassemAndUpdateSource */
+}
 
-/*
-   ** tuiGetBeginAsmAddress().
- */
 CORE_ADDR
-tuiGetBeginAsmAddress (void)
+tui_get_begin_asm_address (void)
 {
-  TuiGenWinInfoPtr locator;
-  TuiLocatorElementPtr element;
+  struct tui_gen_win_info * locator;
+  struct tui_locator_element * element;
   CORE_ADDR addr;
 
-  locator = locatorWinInfoPtr ();
-  element = &((TuiWinElementPtr) locator->content[0])->whichElement.locator;
+  locator = tui_locator_win_info_ptr ();
+  element = &((struct tui_win_element *) locator->content[0])->which_element.locator;
 
   if (element->addr == 0)
     {
@@ -361,19 +346,19 @@ tuiGetBeginAsmAddress (void)
     addr = element->addr;
 
   return addr;
-}				/* tuiGetBeginAsmAddress */
+}
 
 /* Determine what the low address will be to display in the TUI's
    disassembly window.  This may or may not be the same as the
    low address input.  */
 CORE_ADDR
-tuiGetLowDisassemblyAddress (CORE_ADDR low, CORE_ADDR pc)
+tui_get_low_disassembly_address (CORE_ADDR low, CORE_ADDR pc)
 {
   int pos;
 
   /* Determine where to start the disassembly so that the pc is about in the
      middle of the viewport.  */
-  pos = tuiDefaultWinViewportHeight (DISASSEM_WIN, DISASSEM_COMMAND) / 2;
+  pos = tui_default_win_viewport_height (DISASSEM_WIN, DISASSEM_COMMAND) / 2;
   pc = tui_find_disassembly_address (pc, -pos);
 
   if (pc < low)
@@ -381,35 +366,32 @@ tuiGetLowDisassemblyAddress (CORE_ADDR low, CORE_ADDR pc)
   return pc;
 }
 
-/*
-   ** tuiVerticalDisassemScroll().
-   **      Scroll the disassembly forward or backward vertically
- */
+/* Scroll the disassembly forward or backward vertically.  */
 void
-tuiVerticalDisassemScroll (TuiScrollDirection scrollDirection,
-                           int numToScroll)
+tui_vertical_disassem_scroll (enum tui_scroll_direction scroll_direction,
+			      int num_to_scroll)
 {
-  if (disassemWin->generic.content != (OpaquePtr) NULL)
+  if (TUI_DISASM_WIN->generic.content != NULL)
     {
       CORE_ADDR pc;
-      TuiWinContent content;
+      tui_win_content content;
       struct symtab *s;
-      TuiLineOrAddress val;
-      int maxLines, dir;
+      union tui_line_or_address val;
+      int max_lines, dir;
       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
 
-      content = (TuiWinContent) 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;
-      dir = (scrollDirection == FORWARD_SCROLL) ? maxLines : - maxLines;
+      max_lines = TUI_DISASM_WIN->generic.height - 2;
+      pc = content[0]->which_element.source.line_or_addr.addr;
+      dir = (scroll_direction == FORWARD_SCROLL) ? max_lines : - max_lines;
 
       val.addr = tui_find_disassembly_address (pc, dir);
-      tuiUpdateSourceWindowAsIs (disassemWin, s, val, FALSE);
+      tui_update_source_window_as_is (TUI_DISASM_WIN, s, val, FALSE);
     }
 }
diff --git a/gdb/tui/tuiCommand.h b/gdb/tui/tui-disasm.h
index 7afeb1bb395..e72aba1f3f1 100644
--- a/gdb/tui/tuiCommand.h
+++ b/gdb/tui/tui-disasm.h
@@ -1,5 +1,8 @@
-/* Specific command window processing.
-   Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+/* Disassembly display.
+
+   Copyright 1998, 1999, 2000, 2001, 2004 Free Software Foundation,
+   Inc.
+   
    Contributed by Hewlett-Packard Company.
 
    This file is part of GDB.
@@ -19,24 +22,16 @@
    Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
-#ifndef _TUI_COMMAND_H
-#define _TUI_COMMAND_H
-/*
-   ** This header file supports
- */
-
-
-/*****************************************
-** TYPE DEFINITIONS                        **
-******************************************/
-
-
+#ifndef TUI_DISASM_H
+#define TUI_DISASM_H
 
-/*****************************************
-** PUBLIC FUNCTION EXTERNAL DECLS        **
-******************************************/
+#include "tui/tui.h"		/* For enum tui_status.  */
+#include "tui/tui-data.h"	/* For enum tui_scroll_direction.  */
 
-extern unsigned int tuiDispatchCtrlChar (unsigned int);
+extern enum tui_status tui_set_disassem_content (CORE_ADDR);
+extern void tui_show_disassem (CORE_ADDR);
+extern void tui_show_disassem_and_update_source (CORE_ADDR);
+extern void tui_vertical_disassem_scroll (enum tui_scroll_direction, int);
+extern CORE_ADDR tui_get_begin_asm_address (void);
 
 #endif
-/*_TUI_COMMAND_H*/
diff --git a/gdb/tui/tui-file.c b/gdb/tui/tui-file.c
index 1a72d01f856..5d2740ef066 100644
--- a/gdb/tui/tui-file.c
+++ b/gdb/tui/tui-file.c
@@ -21,11 +21,11 @@
 #include "defs.h"
 #include "ui-file.h"
 #include "tui/tui-file.h"
-#include "tui/tuiIO.h"
+#include "tui/tui-io.h"
 
 #include "tui.h"
 
-#include <string.h>
+#include "gdb_string.h"
 
 /* A ``struct ui_file'' that is compatible with all the legacy
    code. */
diff --git a/gdb/tui/tui-hooks.c b/gdb/tui/tui-hooks.c
index e00ba857773..a864be28276 100644
--- a/gdb/tui/tui-hooks.c
+++ b/gdb/tui/tui-hooks.c
@@ -1,6 +1,6 @@
 /* GDB hooks for TUI.
 
-   Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
+   Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -35,27 +35,22 @@
 #include "gdb-events.h"
 #include "ui-out.h"
 #include "top.h"
-#include <readline/readline.h>
+#include "readline/readline.h"
 #include <unistd.h>
 #include <fcntl.h>
 
-#include "tui.h"
-#include "tuiData.h"
-#include "tuiLayout.h"
-#include "tuiIO.h"
-#include "tuiRegs.h"
-#include "tuiWin.h"
-#include "tuiStack.h"
-#include "tuiDataWin.h"
-#include "tuiSourceWin.h"
-
-#ifdef HAVE_NCURSES_H
-#include <ncurses.h>
-#else
-#ifdef HAVE_CURSES_H
-#include <curses.h>
-#endif
-#endif
+#include "tui/tui.h"
+#include "tui/tui-hooks.h"
+#include "tui/tui-data.h"
+#include "tui/tui-layout.h"
+#include "tui/tui-io.h"
+#include "tui/tui-regs.h"
+#include "tui/tui-win.h"
+#include "tui/tui-stack.h"
+#include "tui/tui-windata.h"
+#include "tui/tui-winsource.h"
+
+#include "gdb_curses.h"
 
 int tui_target_has_run = 0;
 
@@ -141,7 +136,7 @@ tui_registers_changed_hook (void)
     {
       tui_refreshing_registers = 1;
 #if 0
-      tuiCheckDataValues (fi);
+      tui_check_data_values (fi);
 #endif
       tui_refreshing_registers = 0;
     }
@@ -156,7 +151,7 @@ tui_register_changed_hook (int regno)
   if (fi && tui_refreshing_registers == 0)
     {
       tui_refreshing_registers = 1;
-      tuiCheckDataValues (fi);
+      tui_check_data_values (fi);
       tui_refreshing_registers = 0;
     }
 }
@@ -250,13 +245,13 @@ tui_selected_frame_level_changed_hook (int level)
         select_source_symtab (s);
 
       /* Display the frame position (even if there is no symbols).  */
-      tuiShowFrameInfo (fi);
+      tui_show_frame_info (fi);
 
       /* Refresh the register window if it's visible.  */
       if (tui_is_window_visible (DATA_WIN))
         {
           tui_refreshing_registers = 1;
-          tuiCheckDataValues (fi);
+          tui_check_data_values (fi);
           tui_refreshing_registers = 0;
         }
     }
@@ -268,7 +263,7 @@ tui_print_frame_info_listing_hook (struct symtab *s, int line,
                                    int stopline, int noerror)
 {
   select_source_symtab (s);
-  tuiShowFrameInfo (deprecated_selected_frame);
+  tui_show_frame_info (deprecated_selected_frame);
 }
 
 /* Called when the target process died or is detached.
@@ -276,7 +271,7 @@ tui_print_frame_info_listing_hook (struct symtab *s, int line,
 static void
 tui_detach_hook (void)
 {
-  tuiShowFrameInfo (0);
+  tui_show_frame_info (0);
   tui_display_main ();
 }
 
diff --git a/gdb/tui/tui-hooks.h b/gdb/tui/tui-hooks.h
new file mode 100644
index 00000000000..fa1137dfa22
--- /dev/null
+++ b/gdb/tui/tui-hooks.h
@@ -0,0 +1,28 @@
+/* External/Public TUI hools header file, for GDB the GNU debugger.
+
+   Copyright 2004 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#ifndef TUI_HOOKS_H
+#define TUI_HOOKS_H
+
+extern void tui_install_hooks (void);
+extern void tui_remove_hooks (void);
+
+#endif
diff --git a/gdb/tui/tui-interp.c b/gdb/tui/tui-interp.c
index 986ebb3b133..1e1d6432321 100644
--- a/gdb/tui/tui-interp.c
+++ b/gdb/tui/tui-interp.c
@@ -26,11 +26,11 @@
 #include "event-loop.h"
 #include "ui-out.h"
 #include "cli-out.h"
-#include "tui/tuiData.h"
+#include "tui/tui-data.h"
 #include "readline/readline.h"
-#include "tui/tuiWin.h"
+#include "tui/tui-win.h"
 #include "tui/tui.h"
-#include "tui/tuiIO.h"
+#include "tui/tui-io.h"
 
 /* Set to 1 when the TUI mode must be activated when we first start gdb.  */
 static int tui_start_enabled = 0;
@@ -53,7 +53,7 @@ tui_init (void)
   /* Install exit handler to leave the screen in a good shape.  */
   atexit (tui_exit);
 
-  initializeStaticData ();
+  tui_initialize_static_data ();
 
   tui_initialize_io ();
   tui_initialize_readline ();
diff --git a/gdb/tui/tuiIO.c b/gdb/tui/tui-io.c
index 1a8bbc2037a..addb3b003c4 100644
--- a/gdb/tui/tuiIO.c
+++ b/gdb/tui/tui-io.c
@@ -1,7 +1,7 @@
 /* TUI support I/O functions.
 
-   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.
 
@@ -30,26 +30,48 @@
 #include "command.h"
 #include "top.h"
 #include "readline/readline.h"
-#include "tui.h"
-#include "tuiData.h"
-#include "tuiIO.h"
-#include "tuiCommand.h"
-#include "tuiWin.h"
-#include "tuiGeneralWin.h"
-#include "tui-file.h"
+#include "tui/tui.h"
+#include "tui/tui-data.h"
+#include "tui/tui-io.h"
+#include "tui/tui-command.h"
+#include "tui/tui-win.h"
+#include "tui/tui-wingeneral.h"
+#include "tui/tui-file.h"
 #include "ui-out.h"
 #include "cli-out.h"
 #include <fcntl.h>
 #include <signal.h>
 #include <stdio.h>
 
-#ifdef HAVE_NCURSES_H       
-#include <ncurses.h>
-#else
-#ifdef HAVE_CURSES_H
-#include <curses.h>
-#endif
-#endif
+#include "gdb_curses.h"
+
+int
+key_is_start_sequence (int ch)
+{
+  return (ch == 27);
+}
+
+int
+key_is_end_sequence (int ch)
+{
+  return (ch == 126);
+}
+
+int
+key_is_backspace (int ch)
+{
+  return (ch == 8);
+}
+
+int
+key_is_command_char (int ch)
+{
+  return ((ch == KEY_NPAGE) || (ch == KEY_PPAGE)
+	  || (ch == KEY_LEFT) || (ch == KEY_RIGHT)
+	  || (ch == KEY_UP) || (ch == KEY_DOWN)
+	  || (ch == KEY_SF) || (ch == KEY_SR)
+	  || (ch == (int)'\f') || key_is_start_sequence (ch));
+}
 
 /* Use definition from readline 4.3.  */
 #undef CTRL_CHAR
@@ -119,7 +141,7 @@ static int tui_readline_pipe[2];
    This may be the main gdb prompt or a secondary prompt.  */
 static char *tui_rl_saved_prompt;
 
-static unsigned int _tuiHandleResizeDuringIO (unsigned int);
+static unsigned int tui_handle_resize_during_io (unsigned int);
 
 static void
 tui_putc (char c)
@@ -139,7 +161,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
@@ -156,9 +178,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);
@@ -183,18 +205,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;
@@ -227,8 +249,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)
@@ -236,15 +258,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);
@@ -294,8 +316,7 @@ tui_readline_output (int code, gdb_client_data data)
 
    Comes from readline/complete.c  */
 static char *
-printable_part (pathname)
-     char *pathname;
+printable_part (char *pathname)
 {
   char *temp;
 
@@ -332,8 +353,7 @@ printable_part (pathname)
     } while (0)
 
 static int
-print_filename (to_print, full_pathname)
-     char *to_print, *full_pathname;
+print_filename (char *to_print, char *full_pathname)
 {
   int printed_len = 0;
   char *s;
@@ -348,7 +368,7 @@ print_filename (to_print, full_pathname)
 /* The user must press "y" or "n".  Non-zero return means "y" pressed.
    Comes from readline/complete.c  */
 static int
-get_y_or_n ()
+get_y_or_n (void)
 {
   extern int _rl_abort_internal ();
   int c;
@@ -374,9 +394,7 @@ get_y_or_n ()
    Comes from readline/complete.c and modified to write in
    the TUI command window using tui_putc/tui_puts.  */
 static void
-tui_rl_display_match_list (matches, len, max)
-     char **matches;
-     int len, max;
+tui_rl_display_match_list (char **matches, int len, int max)
 {
   typedef int QSFUNC (const void *, const void *);
   extern int _rl_qsort_string_compare (const void*, const void*);
@@ -387,7 +405,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. */
@@ -556,13 +574,13 @@ tui_cont_sig (int sig)
       resetty ();
 
       /* Force a refresh of the screen.  */
-      tuiRefreshAll ();
+      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);
 }
@@ -570,7 +588,7 @@ tui_cont_sig (int sig)
 
 /* Initialize the IO for gdb in curses mode.  */
 void
-tui_initialize_io ()
+tui_initialize_io (void)
 {
 #ifdef SIGCONT
   signal (SIGCONT, tui_cont_sig);
@@ -623,7 +641,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.  */
@@ -631,7 +649,7 @@ tui_getc (FILE *fp)
 #endif
 
   ch = wgetch (w);
-  ch = _tuiHandleResizeDuringIO (ch);
+  ch = tui_handle_resize_during_io (ch);
 
   /* The \n must be echoed because it will not be printed by readline.  */
   if (ch == '\n')
@@ -643,7 +661,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.  */
@@ -653,23 +671,19 @@ 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);
         }
     }
   
-  if (m_isCommandChar (ch))
+  if (key_is_command_char (ch))
     {				/* Handle prev/next/up/down here */
-      ch = tuiDispatchCtrlChar (ch);
+      ch = tui_dispatch_ctrl_char (ch);
     }
   
   if (ch == '\n' || ch == '\r' || ch == '\f')
-    cmdWin->detail.commandInfo.curch = 0;
-#if 0
-  else
-    tuiIncrCommandCharCountBy (1);
-#endif
+    TUI_CMD_WIN->detail.command_info.curch = 0;
   if (ch == KEY_BACKSPACE)
     return '\b';
   
@@ -680,15 +694,15 @@ tui_getc (FILE *fp)
 /* Cleanup when a resize has occured.
    Returns the character that must be processed.  */
 static unsigned int
-_tuiHandleResizeDuringIO (unsigned int originalCh)
+tui_handle_resize_during_io (unsigned int original_ch)
 {
-  if (tuiWinResized ())
+  if (tui_win_resized ())
     {
-      tuiRefreshAll ();
+      tui_refresh_all_win ();
       dont_repeat ();
-      tuiSetWinResizedTo (FALSE);
+      tui_set_win_resized_to (FALSE);
       return '\n';
     }
   else
-    return originalCh;
+    return original_ch;
 }
diff --git a/gdb/tui/tuiIO.h b/gdb/tui/tui-io.h
index 40970b6b7e2..06d085de93f 100644
--- a/gdb/tui/tuiIO.h
+++ b/gdb/tui/tui-io.h
@@ -1,5 +1,8 @@
 /* TUI support I/O functions.
-   Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+
+   Copyright 1998, 1999, 2000, 2001, 2002, 2004 Free Software
+   Foundation, Inc.
+
    Contributed by Hewlett-Packard Company.
 
    This file is part of GDB.
@@ -19,10 +22,10 @@
    Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
-#ifndef _TUI_IO_H
-#define _TUI_IO_H
+#ifndef TUI_IO_H
+#define TUI_IO_H
 
-#include <stdio.h>
+struct ui_out;
 
 /* Print the string in the curses command window.  */
 extern void tui_puts (const char *);
@@ -34,7 +37,7 @@ extern void tui_setup_io (int mode);
 extern void tui_initialize_io (void);
 
 /* Get a character from the command window.  */
-extern int tui_getc (FILE*);
+extern int tui_getc (FILE *);
 
 /* Readline callback.
    Redisplay the command line with its prompt after readline has
@@ -44,26 +47,9 @@ extern void tui_redisplay_readline (void);
 extern struct ui_out *tui_out;
 extern struct ui_out *tui_old_uiout;
 
-#define m_tuiStartNewLine       tuiStartNewLines(1)
-#define m_isStartSequence(ch)   (ch == 27)
-#define m_isEndSequence(ch)     (ch == 126)
-#define m_isBackspace(ch)       (ch == 8)
-#define m_isDeleteChar(ch)      (ch == KEY_DC)
-#define m_isDeleteLine(ch)      (ch == KEY_DL)
-#define m_isDeleteToEol(ch)     (ch == KEY_EOL)
-#define m_isNextPage(ch)        (ch == KEY_NPAGE)
-#define m_isPrevPage(ch)        (ch == KEY_PPAGE)
-#define m_isLeftArrow(ch)       (ch == KEY_LEFT)
-#define m_isRightArrow(ch)      (ch == KEY_RIGHT)
-
-#define m_isCommandChar(ch)     (m_isNextPage(ch) || m_isPrevPage(ch) || \
-                                m_isLeftArrow(ch) || m_isRightArrow(ch) || \
-                                (ch == KEY_UP) || (ch == KEY_DOWN) || \
-                                (ch == KEY_SF) || (ch == KEY_SR) || \
-                                (ch == (int)'\f') || m_isStartSequence(ch))
-
-#define m_isXdbStyleCommandChar(ch)     (m_isNextPage(ch) || m_isPrevPage(ch))
-
+extern int key_is_start_sequence (int ch);
+extern int key_is_end_sequence (int ch);
+extern int key_is_backspace (int ch);
+extern int key_is_command_char (int ch);
 
 #endif
-
diff --git a/gdb/tui/tui-layout.c b/gdb/tui/tui-layout.c
new file mode 100644
index 00000000000..f2d4412414d
--- /dev/null
+++ b/gdb/tui/tui-layout.c
@@ -0,0 +1,1072 @@
+/* TUI layout window management.
+
+   Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
+   Foundation, Inc.
+
+   Contributed by Hewlett-Packard Company.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "command.h"
+#include "symtab.h"
+#include "frame.h"
+#include "source.h"
+#include <ctype.h>
+
+#include "tui/tui.h"
+#include "tui/tui-data.h"
+#include "tui/tui-windata.h"
+#include "tui/tui-wingeneral.h"
+#include "tui/tui-stack.h"
+#include "tui/tui-regs.h"
+#include "tui/tui-win.h"
+#include "tui/tui-winsource.h"
+#include "tui/tui-disasm.h"
+
+#include "gdb_string.h"
+#include "gdb_curses.h"
+
+/*******************************
+** Static Local Decls
+********************************/
+static void show_layout (enum tui_layout_type);
+static void init_gen_win_info (struct tui_gen_win_info *, enum tui_win_type, int, int, int, int);
+static void init_and_make_win (void **, enum tui_win_type, int, int, int, int, int);
+static void show_source_or_disasm_and_command (enum tui_layout_type);
+static void make_source_or_disasm_window (struct tui_win_info * *, enum tui_win_type, int, int);
+static void make_command_window (struct tui_win_info * *, int, int);
+static void make_source_window (struct tui_win_info * *, int, int);
+static void make_disasm_window (struct tui_win_info * *, int, int);
+static void make_data_window (struct tui_win_info * *, int, int);
+static void show_source_command (void);
+static void show_disasm_command (void);
+static void show_source_disasm_command (void);
+static void show_data (enum tui_layout_type);
+static enum tui_layout_type next_layout (void);
+static enum tui_layout_type prev_layout (void);
+static void tui_layout_command (char *, int);
+static void tui_toggle_layout_command (char *, int);
+static void tui_toggle_split_layout_command (char *, int);
+static CORE_ADDR extract_display_start_addr (void);
+static void tui_handle_xdb_layout (struct tui_layout_def *);
+
+
+/***************************************
+** DEFINITIONS
+***************************************/
+
+#define LAYOUT_USAGE     "Usage: layout prev | next | <layout_name> \n"
+
+/* Show the screen layout defined.  */
+static void
+show_layout (enum tui_layout_type layout)
+{
+  enum tui_layout_type cur_layout = tui_current_layout ();
+
+  if (layout != cur_layout)
+    {
+      /*
+         ** Since the new layout may cause changes in window size, we
+         ** should free the content and reallocate on next display of
+         ** source/asm
+       */
+      tui_free_all_source_wins_content ();
+      tui_clear_source_windows ();
+      if (layout == SRC_DATA_COMMAND || layout == DISASSEM_DATA_COMMAND)
+	{
+	  show_data (layout);
+	  tui_refresh_all (tui_win_list);
+	}
+      else
+	{
+	  /* First make the current layout be invisible */
+	  tui_make_all_invisible ();
+	  tui_make_invisible (tui_locator_win_info_ptr ());
+
+	  switch (layout)
+	    {
+	      /* Now show the new layout */
+	    case SRC_COMMAND:
+	      show_source_command ();
+	      tui_add_to_source_windows (TUI_SRC_WIN);
+	      break;
+	    case DISASSEM_COMMAND:
+	      show_disasm_command ();
+	      tui_add_to_source_windows (TUI_DISASM_WIN);
+	      break;
+	    case SRC_DISASSEM_COMMAND:
+	      show_source_disasm_command ();
+	      tui_add_to_source_windows (TUI_SRC_WIN);
+	      tui_add_to_source_windows (TUI_DISASM_WIN);
+	      break;
+	    default:
+	      break;
+	    }
+	}
+    }
+}
+
+
+/* Function to set the layout to SRC_COMMAND, DISASSEM_COMMAND,
+   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
+   regs_display_type.  */
+enum tui_status
+tui_set_layout (enum tui_layout_type layout_type,
+		enum tui_register_display_type regs_display_type)
+{
+  enum tui_status status = TUI_SUCCESS;
+
+  if (layout_type != UNDEFINED_LAYOUT || regs_display_type != TUI_UNDEFINED_REGS)
+    {
+      enum tui_layout_type cur_layout = tui_current_layout (), new_layout = UNDEFINED_LAYOUT;
+      int regs_populate = FALSE;
+      CORE_ADDR addr = extract_display_start_addr ();
+      struct tui_win_info * new_win_with_focus = (struct tui_win_info *) NULL;
+      struct tui_win_info * win_with_focus = tui_win_with_focus ();
+      struct tui_layout_def * layout_def = tui_layout_def ();
+
+
+      if (layout_type == UNDEFINED_LAYOUT &&
+	  regs_display_type != TUI_UNDEFINED_REGS)
+	{
+	  if (cur_layout == SRC_DISASSEM_COMMAND)
+	    new_layout = DISASSEM_DATA_COMMAND;
+	  else if (cur_layout == SRC_COMMAND || cur_layout == SRC_DATA_COMMAND)
+	    new_layout = SRC_DATA_COMMAND;
+	  else if (cur_layout == DISASSEM_COMMAND ||
+		   cur_layout == DISASSEM_DATA_COMMAND)
+	    new_layout = DISASSEM_DATA_COMMAND;
+	}
+      else
+	new_layout = layout_type;
+
+      regs_populate = (new_layout == SRC_DATA_COMMAND ||
+		      new_layout == DISASSEM_DATA_COMMAND ||
+		      regs_display_type != TUI_UNDEFINED_REGS);
+      if (new_layout != cur_layout || regs_display_type != TUI_UNDEFINED_REGS)
+	{
+	  if (new_layout != cur_layout)
+	    {
+	      show_layout (new_layout);
+	      /*
+	         ** Now determine where focus should be
+	       */
+	      if (win_with_focus != TUI_CMD_WIN)
+		{
+		  switch (new_layout)
+		    {
+		    case SRC_COMMAND:
+		      tui_set_win_focus_to (TUI_SRC_WIN);
+		      layout_def->display_mode = SRC_WIN;
+		      layout_def->split = FALSE;
+		      break;
+		    case DISASSEM_COMMAND:
+		      /* the previous layout was not showing
+		         ** code. this can happen if there is no
+		         ** source available:
+		         ** 1. if the source file is in another dir OR
+		         ** 2. if target was compiled without -g
+		         ** We still want to show the assembly though!
+		       */
+		      addr = tui_get_begin_asm_address ();
+		      tui_set_win_focus_to (TUI_DISASM_WIN);
+		      layout_def->display_mode = DISASSEM_WIN;
+		      layout_def->split = FALSE;
+		      break;
+		    case SRC_DISASSEM_COMMAND:
+		      /* the previous layout was not showing
+		         ** code. this can happen if there is no
+		         ** source available:
+		         ** 1. if the source file is in another dir OR
+		         ** 2. if target was compiled without -g
+		         ** We still want to show the assembly though!
+		       */
+		      addr = tui_get_begin_asm_address ();
+		      if (win_with_focus == TUI_SRC_WIN)
+			tui_set_win_focus_to (TUI_SRC_WIN);
+		      else
+			tui_set_win_focus_to (TUI_DISASM_WIN);
+		      layout_def->split = TRUE;
+		      break;
+		    case SRC_DATA_COMMAND:
+		      if (win_with_focus != TUI_DATA_WIN)
+			tui_set_win_focus_to (TUI_SRC_WIN);
+		      else
+			tui_set_win_focus_to (TUI_DATA_WIN);
+		      layout_def->display_mode = SRC_WIN;
+		      layout_def->split = FALSE;
+		      break;
+		    case DISASSEM_DATA_COMMAND:
+		      /* the previous layout was not showing
+		         ** code. this can happen if there is no
+		         ** source available:
+		         ** 1. if the source file is in another dir OR
+		         ** 2. if target was compiled without -g
+		         ** We still want to show the assembly though!
+		       */
+		      addr = tui_get_begin_asm_address ();
+		      if (win_with_focus != TUI_DATA_WIN)
+			tui_set_win_focus_to (TUI_DISASM_WIN);
+		      else
+			tui_set_win_focus_to (TUI_DATA_WIN);
+		      layout_def->display_mode = DISASSEM_WIN;
+		      layout_def->split = FALSE;
+		      break;
+		    default:
+		      break;
+		    }
+		}
+	      if (new_win_with_focus != (struct tui_win_info *) NULL)
+		tui_set_win_focus_to (new_win_with_focus);
+	      /*
+	         ** Now update the window content
+	       */
+	      if (!regs_populate &&
+		  (new_layout == SRC_DATA_COMMAND ||
+		   new_layout == DISASSEM_DATA_COMMAND))
+		tui_display_all_data ();
+
+	      tui_update_source_windows_with_addr (addr);
+	    }
+	  if (regs_populate)
+	    {
+              tui_show_registers (TUI_DATA_WIN->detail.data_display_info.current_group);
+	    }
+	}
+    }
+  else
+    status = TUI_FAILURE;
+
+  return status;
+}
+
+/* Add the specified window to the layout in a logical way.  This
+   means setting up the most logical layout given the window to be
+   added.  */
+void
+tui_add_win_to_layout (enum tui_win_type type)
+{
+  enum tui_layout_type cur_layout = tui_current_layout ();
+
+  switch (type)
+    {
+    case SRC_WIN:
+      if (cur_layout != SRC_COMMAND &&
+	  cur_layout != SRC_DISASSEM_COMMAND &&
+	  cur_layout != SRC_DATA_COMMAND)
+	{
+	  tui_clear_source_windows_detail ();
+	  if (cur_layout == DISASSEM_DATA_COMMAND)
+	    show_layout (SRC_DATA_COMMAND);
+	  else
+	    show_layout (SRC_COMMAND);
+	}
+      break;
+    case DISASSEM_WIN:
+      if (cur_layout != DISASSEM_COMMAND &&
+	  cur_layout != SRC_DISASSEM_COMMAND &&
+	  cur_layout != DISASSEM_DATA_COMMAND)
+	{
+	  tui_clear_source_windows_detail ();
+	  if (cur_layout == SRC_DATA_COMMAND)
+	    show_layout (DISASSEM_DATA_COMMAND);
+	  else
+	    show_layout (DISASSEM_COMMAND);
+	}
+      break;
+    case DATA_WIN:
+      if (cur_layout != SRC_DATA_COMMAND &&
+	  cur_layout != DISASSEM_DATA_COMMAND)
+	{
+	  if (cur_layout == DISASSEM_COMMAND)
+	    show_layout (DISASSEM_DATA_COMMAND);
+	  else
+	    show_layout (SRC_DATA_COMMAND);
+	}
+      break;
+    default:
+      break;
+    }
+}
+
+
+/* Answer the height of a window.  If it hasn't been created yet,
+   answer what the height of a window would be based upon its type and
+   the layout.  */
+int
+tui_default_win_height (enum tui_win_type type, enum tui_layout_type layout)
+{
+  int h;
+
+  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 (TUI_CMD_WIN == NULL)
+	    h = tui_term_height () / 2;
+	  else
+	    h = tui_term_height () - TUI_CMD_WIN->generic.height;
+	  break;
+	case SRC_DISASSEM_COMMAND:
+	case SRC_DATA_COMMAND:
+	case DISASSEM_DATA_COMMAND:
+	  if (TUI_CMD_WIN == NULL)
+	    h = tui_term_height () / 3;
+	  else
+	    h = (tui_term_height () - TUI_CMD_WIN->generic.height) / 2;
+	  break;
+	default:
+	  h = 0;
+	  break;
+	}
+    }
+
+  return h;
+}
+
+
+/* Answer the height of a window.  If it hasn't been created yet,
+   answer what the height of a window would be based upon its type and
+   the layout.  */
+int
+tui_default_win_viewport_height (enum tui_win_type type,
+				 enum tui_layout_type layout)
+{
+  int h;
+
+  h = tui_default_win_height (type, layout);
+
+  if (tui_win_list[type] == TUI_CMD_WIN)
+    h -= 1;
+  else
+    h -= 2;
+
+  return h;
+}
+
+
+/* Function to initialize gdb commands, for tui window layout
+   manipulation.  */
+void
+_initialize_tui_layout (void)
+{
+  add_com ("layout", class_tui, tui_layout_command,
+           "Change the layout of windows.\n\
+Usage: layout prev | next | <layout_name> \n\
+Layout names are:\n\
+   src   : Displays source and command windows.\n\
+   asm   : Displays disassembly and command windows.\n\
+   split : Displays source, disassembly and command windows.\n\
+   regs  : Displays register window. If existing layout\n\
+           is source/command or assembly/command, the \n\
+           register window is displayed. If the\n\
+           source/assembly/command (split) is displayed, \n\
+           the register window is displayed with \n\
+           the window that has current logical focus.\n");
+  if (xdb_commands)
+    {
+      add_com ("td", class_tui, tui_toggle_layout_command,
+               "Toggle between Source/Command and Disassembly/Command layouts.\n");
+      add_com ("ts", class_tui, tui_toggle_split_layout_command,
+               "Toggle between Source/Command or Disassembly/Command and \n\
+Source/Disassembly/Command layouts.\n");
+    }
+}
+
+
+/*************************
+** STATIC LOCAL FUNCTIONS
+**************************/
+
+
+/* Function to set the layout to SRC, ASM, SPLIT, NEXT, PREV, DATA,
+   REGS, $REGS, $GREGS, $FREGS, $SREGS.  */
+enum tui_status
+tui_set_layout_for_display_command (const char *layout_name)
+{
+  enum tui_status status = TUI_SUCCESS;
+
+  if (layout_name != (char *) NULL)
+    {
+      int i;
+      char *buf_ptr;
+      enum tui_layout_type new_layout = UNDEFINED_LAYOUT;
+      enum tui_register_display_type dpy_type = TUI_UNDEFINED_REGS;
+      enum tui_layout_type cur_layout = tui_current_layout ();
+
+      buf_ptr = (char *) xstrdup (layout_name);
+      for (i = 0; (i < strlen (layout_name)); i++)
+	buf_ptr[i] = toupper (buf_ptr[i]);
+
+      /* First check for ambiguous input */
+      if (strlen (buf_ptr) <= 1 && (*buf_ptr == 'S' || *buf_ptr == '$'))
+	{
+	  warning ("Ambiguous command input.\n");
+	  status = TUI_FAILURE;
+	}
+      else
+	{
+	  if (subset_compare (buf_ptr, "SRC"))
+	    new_layout = SRC_COMMAND;
+	  else if (subset_compare (buf_ptr, "ASM"))
+	    new_layout = DISASSEM_COMMAND;
+	  else if (subset_compare (buf_ptr, "SPLIT"))
+	    new_layout = SRC_DISASSEM_COMMAND;
+	  else if (subset_compare (buf_ptr, "REGS") ||
+		   subset_compare (buf_ptr, TUI_GENERAL_SPECIAL_REGS_NAME) ||
+		   subset_compare (buf_ptr, TUI_GENERAL_REGS_NAME) ||
+		   subset_compare (buf_ptr, TUI_FLOAT_REGS_NAME) ||
+		   subset_compare (buf_ptr, TUI_SPECIAL_REGS_NAME))
+	    {
+	      if (cur_layout == SRC_COMMAND || cur_layout == SRC_DATA_COMMAND)
+		new_layout = SRC_DATA_COMMAND;
+	      else
+		new_layout = DISASSEM_DATA_COMMAND;
+
+/* could ifdef out the following code. when compile with -z, there are null 
+   pointer references that cause a core dump if 'layout regs' is the first 
+   layout command issued by the user. HP has asked us to hook up this code 
+   - edie epstein
+ */
+	      if (subset_compare (buf_ptr, TUI_FLOAT_REGS_NAME))
+		{
+		  if (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)
+		    dpy_type = TUI_SFLOAT_REGS;
+		  else
+		    dpy_type =
+		      TUI_DATA_WIN->detail.data_display_info.regs_display_type;
+		}
+	      else if (subset_compare (buf_ptr,
+				      TUI_GENERAL_SPECIAL_REGS_NAME))
+		dpy_type = TUI_GENERAL_AND_SPECIAL_REGS;
+	      else if (subset_compare (buf_ptr, TUI_GENERAL_REGS_NAME))
+		dpy_type = TUI_GENERAL_REGS;
+	      else if (subset_compare (buf_ptr, TUI_SPECIAL_REGS_NAME))
+		dpy_type = TUI_SPECIAL_REGS;
+	      else if (TUI_DATA_WIN)
+		{
+		  if (TUI_DATA_WIN->detail.data_display_info.regs_display_type !=
+		      TUI_UNDEFINED_REGS)
+		    dpy_type =
+		      TUI_DATA_WIN->detail.data_display_info.regs_display_type;
+		  else
+		    dpy_type = TUI_GENERAL_REGS;
+		}
+
+/* end of potential ifdef 
+ */
+
+/* if ifdefed out code above, then assume that the user wishes to display the 
+   general purpose registers 
+ */
+
+/*              dpy_type = TUI_GENERAL_REGS; 
+ */
+	    }
+	  else if (subset_compare (buf_ptr, "NEXT"))
+	    new_layout = next_layout ();
+	  else if (subset_compare (buf_ptr, "PREV"))
+	    new_layout = prev_layout ();
+	  else
+	    status = TUI_FAILURE;
+	  xfree (buf_ptr);
+
+	  tui_set_layout (new_layout, dpy_type);
+	}
+    }
+  else
+    status = TUI_FAILURE;
+
+  return status;
+}
+
+
+static CORE_ADDR
+extract_display_start_addr (void)
+{
+  enum tui_layout_type cur_layout = tui_current_layout ();
+  CORE_ADDR addr;
+  CORE_ADDR pc;
+  struct symtab_and_line cursal = get_current_source_symtab_and_line ();
+
+  switch (cur_layout)
+    {
+    case SRC_COMMAND:
+    case SRC_DATA_COMMAND:
+      find_line_pc (cursal.symtab,
+		    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 = TUI_DISASM_WIN->detail.source_info.start_line_or_addr.addr;
+      break;
+    default:
+      addr = 0;
+      break;
+    }
+
+  return addr;
+}
+
+
+static void
+tui_handle_xdb_layout (struct tui_layout_def * layout_def)
+{
+  if (layout_def->split)
+    {
+      tui_set_layout (SRC_DISASSEM_COMMAND, TUI_UNDEFINED_REGS);
+      tui_set_win_focus_to (tui_win_list[layout_def->display_mode]);
+    }
+  else
+    {
+      if (layout_def->display_mode == SRC_WIN)
+	tui_set_layout (SRC_COMMAND, TUI_UNDEFINED_REGS);
+      else
+	tui_set_layout (DISASSEM_DATA_COMMAND, layout_def->regs_display_type);
+    }
+}
+
+
+static void
+tui_toggle_layout_command (char *arg, int from_tty)
+{
+  struct tui_layout_def * layout_def = tui_layout_def ();
+
+  /* Make sure the curses mode is enabled.  */
+  tui_enable ();
+  if (layout_def->display_mode == SRC_WIN)
+    layout_def->display_mode = DISASSEM_WIN;
+  else
+    layout_def->display_mode = SRC_WIN;
+
+  if (!layout_def->split)
+    tui_handle_xdb_layout (layout_def);
+}
+
+
+static void
+tui_toggle_split_layout_command (char *arg, int from_tty)
+{
+  struct tui_layout_def * layout_def = tui_layout_def ();
+
+  /* Make sure the curses mode is enabled.  */
+  tui_enable ();
+  layout_def->split = (!layout_def->split);
+  tui_handle_xdb_layout (layout_def);
+}
+
+
+static void
+tui_layout_command (char *arg, int from_tty)
+{
+  /* Make sure the curses mode is enabled.  */
+  tui_enable ();
+
+  /* Switch to the selected layout.  */
+  if (tui_set_layout_for_display_command (arg) != TUI_SUCCESS)
+    warning ("Invalid layout specified.\n%s", LAYOUT_USAGE);
+
+}
+
+/* Answer the previous layout to cycle to.  */
+static enum tui_layout_type
+next_layout (void)
+{
+  enum tui_layout_type new_layout;
+
+  new_layout = tui_current_layout ();
+  if (new_layout == UNDEFINED_LAYOUT)
+    new_layout = SRC_COMMAND;
+  else
+    {
+      new_layout++;
+      if (new_layout == UNDEFINED_LAYOUT)
+	new_layout = SRC_COMMAND;
+    }
+
+  return new_layout;
+}
+
+
+/* Answer the next layout to cycle to.  */
+static enum tui_layout_type
+prev_layout (void)
+{
+  enum tui_layout_type new_layout;
+
+  new_layout = tui_current_layout ();
+  if (new_layout == SRC_COMMAND)
+    new_layout = DISASSEM_DATA_COMMAND;
+  else
+    {
+      new_layout--;
+      if (new_layout == UNDEFINED_LAYOUT)
+	new_layout = DISASSEM_DATA_COMMAND;
+    }
+
+  return new_layout;
+}
+
+
+
+static void
+make_command_window (struct tui_win_info * * win_info_ptr, int height, int origin_y)
+{
+  init_and_make_win ((void **) win_info_ptr,
+		   CMD_WIN,
+		   height,
+		   tui_term_width (),
+		   0,
+		   origin_y,
+		   DONT_BOX_WINDOW);
+
+  (*win_info_ptr)->can_highlight = FALSE;
+}
+
+
+/*
+   ** make_source_window().
+ */
+static void
+make_source_window (struct tui_win_info * * win_info_ptr, int height, int origin_y)
+{
+  make_source_or_disasm_window (win_info_ptr, SRC_WIN, height, origin_y);
+
+  return;
+}				/* make_source_window */
+
+
+/*
+   ** make_disasm_window().
+ */
+static void
+make_disasm_window (struct tui_win_info * * win_info_ptr, int height, int origin_y)
+{
+  make_source_or_disasm_window (win_info_ptr, DISASSEM_WIN, height, origin_y);
+
+  return;
+}				/* make_disasm_window */
+
+
+static void
+make_data_window (struct tui_win_info * * win_info_ptr, int height, int origin_y)
+{
+  init_and_make_win ((void **) win_info_ptr,
+		   DATA_WIN,
+		   height,
+		   tui_term_width (),
+		   0,
+		   origin_y,
+		   BOX_WINDOW);
+}
+
+
+
+/* Show the Source/Command layout.  */
+static void
+show_source_command (void)
+{
+  show_source_or_disasm_and_command (SRC_COMMAND);
+}
+
+
+/* Show the Dissassem/Command layout.  */
+static void
+show_disasm_command (void)
+{
+  show_source_or_disasm_and_command (DISASSEM_COMMAND);
+}
+
+
+/* Show the Source/Disassem/Command layout.  */
+static void
+show_source_disasm_command (void)
+{
+  if (tui_current_layout () != SRC_DISASSEM_COMMAND)
+    {
+      int cmd_height, src_height, asm_height;
+
+      if (TUI_CMD_WIN != NULL)
+	cmd_height = TUI_CMD_WIN->generic.height;
+      else
+	cmd_height = tui_term_height () / 3;
+
+      src_height = (tui_term_height () - cmd_height) / 2;
+      asm_height = tui_term_height () - (src_height + cmd_height);
+
+      if (TUI_SRC_WIN == NULL)
+	make_source_window (&TUI_SRC_WIN, src_height, 0);
+      else
+	{
+	  init_gen_win_info (&TUI_SRC_WIN->generic,
+			   TUI_SRC_WIN->generic.type,
+			   src_height,
+			   TUI_SRC_WIN->generic.width,
+			   TUI_SRC_WIN->detail.source_info.execution_info->width,
+			   0);
+	  TUI_SRC_WIN->can_highlight = TRUE;
+	  init_gen_win_info (TUI_SRC_WIN->detail.source_info.execution_info,
+			   EXEC_INFO_WIN,
+			   src_height,
+			   3,
+			   0,
+			   0);
+	  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 (TUI_SRC_WIN != NULL)
+	{
+	  struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
+
+	  tui_show_source_content (TUI_SRC_WIN);
+	  if (TUI_DISASM_WIN == NULL)
+	    {
+	      make_disasm_window (&TUI_DISASM_WIN, asm_height, src_height - 1);
+	      init_and_make_win ((void **) & locator,
+			       LOCATOR_WIN,
+			       2 /* 1 */ ,
+			       tui_term_width (),
+			       0,
+			       (src_height + asm_height) - 1,
+			       DONT_BOX_WINDOW);
+	    }
+	  else
+	    {
+	      init_gen_win_info (locator,
+			       LOCATOR_WIN,
+			       2 /* 1 */ ,
+			       tui_term_width (),
+			       0,
+			       (src_height + asm_height) - 1);
+	      TUI_DISASM_WIN->detail.source_info.has_locator = TRUE;
+	      init_gen_win_info (
+				&TUI_DISASM_WIN->generic,
+				TUI_DISASM_WIN->generic.type,
+				asm_height,
+				TUI_DISASM_WIN->generic.width,
+			TUI_DISASM_WIN->detail.source_info.execution_info->width,
+				src_height - 1);
+	      init_gen_win_info (TUI_DISASM_WIN->detail.source_info.execution_info,
+			       EXEC_INFO_WIN,
+			       asm_height,
+			       3,
+			       0,
+			       src_height - 1);
+	      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 (TUI_DISASM_WIN != NULL)
+	    {
+	      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 (TUI_DISASM_WIN);
+
+	      if (TUI_CMD_WIN == NULL)
+		make_command_window (&TUI_CMD_WIN,
+				    cmd_height,
+				    tui_term_height () - cmd_height);
+	      else
+		{
+		  init_gen_win_info (&TUI_CMD_WIN->generic,
+				   TUI_CMD_WIN->generic.type,
+				   TUI_CMD_WIN->generic.height,
+				   TUI_CMD_WIN->generic.width,
+				   0,
+				   TUI_CMD_WIN->generic.origin.y);
+		  TUI_CMD_WIN->can_highlight = FALSE;
+		  tui_make_visible (&TUI_CMD_WIN->generic);
+		}
+	      if (TUI_CMD_WIN != NULL)
+		tui_refresh_win (&TUI_CMD_WIN->generic);
+	    }
+	}
+      tui_set_current_layout_to (SRC_DISASSEM_COMMAND);
+    }
+}
+
+
+/* Show the Source/Data/Command or the Dissassembly/Data/Command
+   layout.  */
+static void
+show_data (enum tui_layout_type new_layout)
+{
+  int total_height = (tui_term_height () - TUI_CMD_WIN->generic.height);
+  int src_height, data_height;
+  enum tui_win_type win_type;
+  struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
+
+
+  data_height = total_height / 2;
+  src_height = total_height - data_height;
+  tui_make_all_invisible ();
+  tui_make_invisible (locator);
+  make_data_window (&TUI_DATA_WIN, data_height, 0);
+  TUI_DATA_WIN->can_highlight = TRUE;
+  if (new_layout == SRC_DATA_COMMAND)
+    win_type = SRC_WIN;
+  else
+    win_type = DISASSEM_WIN;
+  if (tui_win_list[win_type] == NULL)
+    {
+      if (win_type == SRC_WIN)
+	make_source_window (&tui_win_list[win_type], src_height, data_height - 1);
+      else
+	make_disasm_window (&tui_win_list[win_type], src_height, data_height - 1);
+      init_and_make_win ((void **) & locator,
+		       LOCATOR_WIN,
+		       2 /* 1 */ ,
+		       tui_term_width (),
+		       0,
+		       total_height - 1,
+		       DONT_BOX_WINDOW);
+    }
+  else
+    {
+      init_gen_win_info (&tui_win_list[win_type]->generic,
+		       tui_win_list[win_type]->generic.type,
+		       src_height,
+		       tui_win_list[win_type]->generic.width,
+		   tui_win_list[win_type]->detail.source_info.execution_info->width,
+		       data_height - 1);
+      init_gen_win_info (tui_win_list[win_type]->detail.source_info.execution_info,
+		       EXEC_INFO_WIN,
+		       src_height,
+		       3,
+		       0,
+		       data_height - 1);
+      tui_make_visible (&tui_win_list[win_type]->generic);
+      tui_make_visible (tui_win_list[win_type]->detail.source_info.execution_info);
+      init_gen_win_info (locator,
+		       LOCATOR_WIN,
+		       2 /* 1 */ ,
+		       tui_term_width (),
+		       0,
+		       total_height - 1);
+    }
+  tui_win_list[win_type]->detail.source_info.has_locator = TRUE;
+  tui_make_visible (locator);
+  tui_show_locator_content ();
+  tui_add_to_source_windows (tui_win_list[win_type]);
+  tui_set_current_layout_to (new_layout);
+}
+
+/*
+   ** init_gen_win_info().
+ */
+static void
+init_gen_win_info (struct tui_gen_win_info * win_info, enum tui_win_type type,
+                 int height, int width, int origin_x, int origin_y)
+{
+  int h = height;
+
+  win_info->type = type;
+  win_info->width = width;
+  win_info->height = h;
+  if (h > 1)
+    {
+      win_info->viewport_height = h - 1;
+      if (win_info->type != CMD_WIN)
+	win_info->viewport_height--;
+    }
+  else
+    win_info->viewport_height = 1;
+  win_info->origin.x = origin_x;
+  win_info->origin.y = origin_y;
+
+  return;
+}				/* init_gen_win_info */
+
+/*
+   ** init_and_make_win().
+ */
+static void
+init_and_make_win (void ** win_info_ptr, enum tui_win_type win_type,
+                 int height, int width, int origin_x, int origin_y, int box_it)
+{
+  void *opaque_win_info = *win_info_ptr;
+  struct tui_gen_win_info * generic;
+
+  if (opaque_win_info == NULL)
+    {
+      if (tui_win_is_auxillary (win_type))
+	opaque_win_info = (void *) tui_alloc_generic_win_info ();
+      else
+	opaque_win_info = (void *) tui_alloc_win_info (win_type);
+    }
+  if (tui_win_is_auxillary (win_type))
+    generic = (struct tui_gen_win_info *) opaque_win_info;
+  else
+    generic = &((struct tui_win_info *) opaque_win_info)->generic;
+
+  if (opaque_win_info != NULL)
+    {
+      init_gen_win_info (generic, win_type, height, width, origin_x, origin_y);
+      if (!tui_win_is_auxillary (win_type))
+	{
+	  if (generic->type == CMD_WIN)
+	    ((struct tui_win_info *) opaque_win_info)->can_highlight = FALSE;
+	  else
+	    ((struct tui_win_info *) opaque_win_info)->can_highlight = TRUE;
+	}
+      tui_make_window (generic, box_it);
+    }
+  *win_info_ptr = opaque_win_info;
+}
+
+
+static void
+make_source_or_disasm_window (struct tui_win_info * * win_info_ptr, enum tui_win_type type,
+                             int height, int origin_y)
+{
+  struct tui_gen_win_info * execution_info = (struct tui_gen_win_info *) NULL;
+
+  /*
+     ** Create the exeuction info window.
+   */
+  if (type == SRC_WIN)
+    execution_info = tui_source_exec_info_win_ptr ();
+  else
+    execution_info = tui_disassem_exec_info_win_ptr ();
+  init_and_make_win ((void **) & execution_info,
+		   EXEC_INFO_WIN,
+		   height,
+		   3,
+		   0,
+		   origin_y,
+		   DONT_BOX_WINDOW);
+  /*
+     ** Now create the source window.
+   */
+  init_and_make_win ((void **) win_info_ptr,
+		   type,
+		   height,
+		   tui_term_width () - execution_info->width,
+		   execution_info->width,
+		   origin_y,
+		   BOX_WINDOW);
+
+  (*win_info_ptr)->detail.source_info.execution_info = execution_info;
+}
+
+
+/* Show the Source/Command or the Disassem layout.   */
+static void
+show_source_or_disasm_and_command (enum tui_layout_type layout_type)
+{
+  if (tui_current_layout () != layout_type)
+    {
+      struct tui_win_info * *win_info_ptr;
+      int src_height, cmd_height;
+      struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
+
+      if (TUI_CMD_WIN != NULL)
+	cmd_height = TUI_CMD_WIN->generic.height;
+      else
+	cmd_height = tui_term_height () / 3;
+      src_height = tui_term_height () - cmd_height;
+
+
+      if (layout_type == SRC_COMMAND)
+	win_info_ptr = &TUI_SRC_WIN;
+      else
+	win_info_ptr = &TUI_DISASM_WIN;
+
+      if ((*win_info_ptr) == NULL)
+	{
+	  if (layout_type == SRC_COMMAND)
+	    make_source_window (win_info_ptr, src_height - 1, 0);
+	  else
+	    make_disasm_window (win_info_ptr, src_height - 1, 0);
+	  init_and_make_win ((void **) & locator,
+			   LOCATOR_WIN,
+			   2 /* 1 */ ,
+			   tui_term_width (),
+			   0,
+			   src_height - 1,
+			   DONT_BOX_WINDOW);
+	}
+      else
+	{
+	  init_gen_win_info (locator,
+			   LOCATOR_WIN,
+			   2 /* 1 */ ,
+			   tui_term_width (),
+			   0,
+			   src_height - 1);
+	  (*win_info_ptr)->detail.source_info.has_locator = TRUE;
+	  init_gen_win_info (
+			    &(*win_info_ptr)->generic,
+			    (*win_info_ptr)->generic.type,
+			    src_height - 1,
+			    (*win_info_ptr)->generic.width,
+		      (*win_info_ptr)->detail.source_info.execution_info->width,
+			    0);
+	  init_gen_win_info ((*win_info_ptr)->detail.source_info.execution_info,
+			   EXEC_INFO_WIN,
+			   src_height - 1,
+			   3,
+			   0,
+			   0);
+	  (*win_info_ptr)->can_highlight = TRUE;
+	  tui_make_visible (&(*win_info_ptr)->generic);
+	  tui_make_visible ((*win_info_ptr)->detail.source_info.execution_info);
+	}
+      if ((*win_info_ptr) != NULL)
+	{
+	  (*win_info_ptr)->detail.source_info.has_locator = TRUE;
+	  tui_make_visible (locator);
+	  tui_show_locator_content ();
+	  tui_show_source_content (*win_info_ptr);
+
+	  if (TUI_CMD_WIN == NULL)
+	    {
+	      make_command_window (&TUI_CMD_WIN, cmd_height, src_height);
+	      tui_refresh_win (&TUI_CMD_WIN->generic);
+	    }
+	  else
+	    {
+	      init_gen_win_info (&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 (layout_type);
+    }
+}
diff --git a/gdb/tui/tuiLayout.h b/gdb/tui/tui-layout.h
index f6b0ed79c68..5df1f0be9f1 100644
--- a/gdb/tui/tuiLayout.h
+++ b/gdb/tui/tui-layout.h
@@ -1,5 +1,8 @@
 /* TUI layout window management.
-   Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+
+   Copyright 1998, 1999, 2000, 2001, 2002, 2004 Free Software
+   Foundation, Inc.
+
    Contributed by Hewlett-Packard Company.
 
    This file is part of GDB.
@@ -22,9 +25,14 @@
 #ifndef TUI_LAYOUT_H
 #define TUI_LAYOUT_H
 
-extern void tuiAddWinToLayout (TuiWinType);
-extern int tuiDefaultWinHeight (TuiWinType, TuiLayoutType);
-extern int tuiDefaultWinViewportHeight (TuiWinType, TuiLayoutType);
-extern TuiStatus tuiSetLayout (TuiLayoutType, TuiRegisterDisplayType);
+#include "tui/tui.h"
+#include "tui/tui-data.h"
+
+extern void tui_add_win_to_layout (enum tui_win_type);
+extern int tui_default_win_height (enum tui_win_type, enum tui_layout_type);
+extern int tui_default_win_viewport_height (enum tui_win_type,
+					    enum tui_layout_type);
+extern enum tui_status tui_set_layout (enum tui_layout_type,
+				       enum tui_register_display_type);
 
 #endif /*TUI_LAYOUT_H */
diff --git a/gdb/tui/tui-main.c b/gdb/tui/tui-main.c
new file mode 100644
index 00000000000..920d83884f0
--- /dev/null
+++ b/gdb/tui/tui-main.c
@@ -0,0 +1,37 @@
+/* Main function for TUI gdb.
+
+   Copyright 2002, 2004 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "main.h"
+#include "gdb_string.h"
+#include "interps.h"
+
+int
+main (int argc, char **argv)
+{
+  struct captured_main_args args;
+  memset (&args, 0, sizeof args);
+  args.argc = argc;
+  args.argv = argv;
+  args.use_windows = 0;
+  args.interpreter_p = INTERP_TUI;
+  return gdb_main (&args);
+}
diff --git a/gdb/tui/tui-out.c b/gdb/tui/tui-out.c
index e1be56a6b00..1c2af689044 100644
--- a/gdb/tui/tui-out.c
+++ b/gdb/tui/tui-out.c
@@ -119,7 +119,7 @@ tui_table_begin (struct ui_out *uiout, int nbrofcols,
   if (nr_rows == 0)
     data->suppress_output = 1;
   else
-    /* Only the table suppresses the output and, fortunatly, a table
+    /* Only the table suppresses the output and, fortunately, a table
        is not a recursive data structure. */
     gdb_assert (data->suppress_output == 0);
 }
diff --git a/gdb/tui/tui-regs.c b/gdb/tui/tui-regs.c
new file mode 100644
index 00000000000..c0eab97513c
--- /dev/null
+++ b/gdb/tui/tui-regs.c
@@ -0,0 +1,745 @@
+/* TUI display registers in window.
+
+   Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
+   Foundation, Inc.
+
+   Contributed by Hewlett-Packard Company.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "tui/tui.h"
+#include "tui/tui-data.h"
+#include "symtab.h"
+#include "gdbtypes.h"
+#include "gdbcmd.h"
+#include "frame.h"
+#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"
+#include "tui/tui-wingeneral.h"
+#include "tui/tui-file.h"
+#include "reggroups.h"
+
+#include "gdb_curses.h"
+
+
+/*****************************************
+** STATIC LOCAL FUNCTIONS FORWARD DECLS    **
+******************************************/
+static void
+tui_display_register (struct tui_data_element *data,
+                      struct tui_gen_win_info *win_info);
+
+static enum tui_status
+tui_show_register_group (struct gdbarch *gdbarch, struct reggroup *group,
+                         struct frame_info *frame, int refresh_values_only);
+
+static enum tui_status
+tui_get_register (struct gdbarch *gdbarch, struct frame_info *frame,
+                  struct tui_data_element *data, int regnum, int *changedp);
+static void tui_register_format
+  (struct gdbarch *, struct frame_info *, struct tui_data_element*, int);
+static void tui_scroll_regs_forward_command (char *, int);
+static void tui_scroll_regs_backward_command (char *, int);
+
+
+
+/*****************************************
+** PUBLIC FUNCTIONS                     **
+******************************************/
+
+/* Answer the number of the last line in the regs display.  If there
+   are no registers (-1) is returned.  */
+int
+tui_last_regs_line_no (void)
+{
+  int num_lines = (-1);
+
+  if (TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
+    {
+      num_lines = (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)
+	num_lines++;
+    }
+  return num_lines;
+}
+
+
+/* Answer the line number that the register element at element_no is
+   on.  If element_no is greater than the number of register elements
+   there are, -1 is returned.  */
+int
+tui_line_from_reg_element_no (int element_no)
+{
+  if (element_no < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
+    {
+      int i, line = (-1);
+
+      i = 1;
+      while (line == (-1))
+	{
+	  if (element_no <
+	      (TUI_DATA_WIN->detail.data_display_info.regs_column_count * i))
+	    line = i - 1;
+	  else
+	    i++;
+	}
+
+      return line;
+    }
+  else
+    return (-1);
+}
+
+
+/* Answer the index of the first element in line_no.  If line_no is past
+   the register area (-1) is returned.  */
+int
+tui_first_reg_element_no_inline (int line_no)
+{
+  if ((line_no * TUI_DATA_WIN->detail.data_display_info.regs_column_count)
+      <= TUI_DATA_WIN->detail.data_display_info.regs_content_count)
+    return ((line_no + 1) *
+	    TUI_DATA_WIN->detail.data_display_info.regs_column_count) -
+      TUI_DATA_WIN->detail.data_display_info.regs_column_count;
+  else
+    return (-1);
+}
+
+
+/* Answer the index of the last element in line_no.  If line_no is
+   past the register area (-1) is returned.  */
+int
+tui_last_reg_element_no_in_line (int line_no)
+{
+  if ((line_no * TUI_DATA_WIN->detail.data_display_info.regs_column_count) <=
+      TUI_DATA_WIN->detail.data_display_info.regs_content_count)
+    return ((line_no + 1) *
+	    TUI_DATA_WIN->detail.data_display_info.regs_column_count) - 1;
+  else
+    return (-1);
+}
+
+/* Show the registers of the given group in the data window
+   and refresh the window.  */
+void
+tui_show_registers (struct reggroup *group)
+{
+  enum tui_status ret = TUI_FAILURE;
+  struct tui_data_info *display_info = &TUI_DATA_WIN->detail.data_display_info;
+
+  if (group == 0)
+    group = general_reggroup;
+
+  /* Say that registers should be displayed, even if there is a problem.  */
+  display_info->display_regs = TRUE;
+
+  if (target_has_registers && target_has_stack && target_has_memory)
+    {
+      ret = tui_show_register_group (current_gdbarch, group,
+                                     get_current_frame (),
+                                     group == display_info->current_group);
+    }
+  if (ret == TUI_FAILURE)
+    {
+      display_info->current_group = 0;
+      tui_erase_data_content (NO_REGS_STRING);
+    }
+  else
+    {
+      int i;
+
+      /* Clear all notation of changed values */
+      for (i = 0; i < display_info->regs_content_count; i++)
+	{
+	  struct tui_gen_win_info *data_item_win;
+          struct tui_win_element *win;
+
+	  data_item_win = &display_info->regs_content[i]
+            ->which_element.data_window;
+          win = (struct tui_win_element *) data_item_win->content[0];
+          win->which_element.data.highlight = FALSE;
+	}
+      display_info->current_group = group;
+      tui_display_all_data ();
+    }
+}
+
+
+/* Set the data window to display the registers of the register group
+   using the given frame.  Values are refreshed only when refresh_values_only
+   is TRUE.  */
+
+static enum tui_status
+tui_show_register_group (struct gdbarch *gdbarch, struct reggroup *group,
+                         struct frame_info *frame, int refresh_values_only)
+{
+  enum tui_status ret = TUI_FAILURE;
+  int nr_regs;
+  int allocated_here = FALSE;
+  int regnum, pos;
+  char title[80];
+  struct tui_data_info *display_info = &TUI_DATA_WIN->detail.data_display_info;
+
+  /* Make a new title showing which group we display.  */
+  snprintf (title, sizeof (title) - 1, "Register group: %s",
+            reggroup_name (group));
+  xfree (TUI_DATA_WIN->generic.title);
+  TUI_DATA_WIN->generic.title = xstrdup (title);
+
+  /* See how many registers must be displayed.  */
+  nr_regs = 0;
+  for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
+    {
+      /* Must be in the group and have a name.  */
+      if (gdbarch_register_reggroup_p (gdbarch, regnum, group)
+          && gdbarch_register_name (gdbarch, regnum) != 0)
+        nr_regs++;
+    }
+
+  if (display_info->regs_content_count > 0 && !refresh_values_only)
+    {
+      tui_free_data_content (display_info->regs_content,
+                             display_info->regs_content_count);
+      display_info->regs_content_count = 0;
+    }
+
+  if (display_info->regs_content_count <= 0)
+    {
+      display_info->regs_content = tui_alloc_content (nr_regs, DATA_WIN);
+      allocated_here = TRUE;
+      refresh_values_only = FALSE;
+    }
+
+  if (display_info->regs_content != (tui_win_content) NULL)
+    {
+      if (!refresh_values_only || allocated_here)
+	{
+	  TUI_DATA_WIN->generic.content = (void*) NULL;
+	  TUI_DATA_WIN->generic.content_size = 0;
+	  tui_add_content_elements (&TUI_DATA_WIN->generic, nr_regs);
+	  display_info->regs_content
+            = (tui_win_content) TUI_DATA_WIN->generic.content;
+	  display_info->regs_content_count = nr_regs;
+	}
+
+      /* Now set the register names and values */
+      pos = 0;
+      for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
+        {
+	  struct tui_gen_win_info *data_item_win;
+          struct tui_data_element *data;
+          const char *name;
+
+          if (!gdbarch_register_reggroup_p (gdbarch, regnum, group))
+            continue;
+
+          name = gdbarch_register_name (gdbarch, regnum);
+          if (name == 0)
+            continue;
+
+	  data_item_win =
+            &display_info->regs_content[pos]->which_element.data_window;
+          data =
+            &((struct tui_win_element *) data_item_win->content[0])->which_element.data;
+          if (data)
+            {
+              if (!refresh_values_only)
+                {
+                  data->item_no = regnum;
+                  data->name = name;
+                  data->highlight = FALSE;
+                }
+              if (data->value == (void*) NULL)
+                data->value = (void*) xmalloc (MAX_REGISTER_SIZE);
+
+              tui_get_register (gdbarch, frame, data, regnum, 0);
+            }
+          pos++;
+	}
+
+      TUI_DATA_WIN->generic.content_size =
+	display_info->regs_content_count + display_info->data_content_count;
+      ret = TUI_SUCCESS;
+    }
+
+  return ret;
+}
+
+/* Function to display the registers in the content from
+   'start_element_no' until the end of the register content or the end
+   of the display height.  No checking for displaying past the end of
+   the registers is done here.  */
+void
+tui_display_registers_from (int start_element_no)
+{
+  struct tui_data_info *display_info = &TUI_DATA_WIN->detail.data_display_info;
+
+  if (display_info->regs_content != (tui_win_content) NULL &&
+      display_info->regs_content_count > 0)
+    {
+      int i = start_element_no;
+      int j, value_chars_wide, item_win_width, cur_y;
+
+      int max_len = 0;
+      for (i = 0; i < display_info->regs_content_count; i++)
+        {
+          struct tui_data_element *data;
+          struct tui_gen_win_info *data_item_win;
+          char *p;
+          int len;
+
+          data_item_win = &display_info->regs_content[i]->which_element.data_window;
+          data = &((struct tui_win_element *)
+                   data_item_win->content[0])->which_element.data;
+          len = 0;
+          p = data->content;
+          if (p != 0)
+            while (*p)
+              {
+                if (*p++ == '\t')
+                  len = 8 * ((len / 8) + 1);
+                else
+                  len++;
+              }
+
+          if (len > max_len)
+            max_len = len;
+        }
+      item_win_width = max_len + 1;
+      i = start_element_no;
+
+      display_info->regs_column_count =
+        (TUI_DATA_WIN->generic.width - 2) / item_win_width;
+      if (display_info->regs_column_count == 0)
+        display_info->regs_column_count = 1;
+      item_win_width =
+        (TUI_DATA_WIN->generic.width - 2) / display_info->regs_column_count;
+
+      /*
+         ** Now create each data "sub" window, and write the display into it.
+       */
+      cur_y = 1;
+      while (i < display_info->regs_content_count &&
+	     cur_y <= TUI_DATA_WIN->generic.viewport_height)
+	{
+	  for (j = 0;
+	       (j < display_info->regs_column_count &&
+		i < display_info->regs_content_count); j++)
+	    {
+	      struct tui_gen_win_info * data_item_win;
+	      struct tui_data_element * data_element_ptr;
+
+	      /* create the window if necessary */
+	      data_item_win = &display_info->regs_content[i]
+                ->which_element.data_window;
+	      data_element_ptr = &((struct tui_win_element *)
+				 data_item_win->content[0])->which_element.data;
+              if (data_item_win->handle != (WINDOW*) NULL
+                  && (data_item_win->height != 1
+                      || data_item_win->width != item_win_width
+                      || data_item_win->origin.x != (item_win_width * j) + 1
+                      || data_item_win->origin.y != cur_y))
+                {
+                  tui_delete_win (data_item_win->handle);
+                  data_item_win->handle = 0;
+                }
+                  
+	      if (data_item_win->handle == (WINDOW *) NULL)
+		{
+		  data_item_win->height = 1;
+		  data_item_win->width = item_win_width;
+		  data_item_win->origin.x = (item_win_width * j) + 1;
+		  data_item_win->origin.y = cur_y;
+		  tui_make_window (data_item_win, DONT_BOX_WINDOW);
+                  scrollok (data_item_win->handle, FALSE);
+		}
+              touchwin (data_item_win->handle);
+
+	      /* Get the printable representation of the register
+                 and display it.  */
+              tui_display_register (data_element_ptr, data_item_win);
+	      i++;		/* next register */
+	    }
+	  cur_y++;		/* next row; */
+	}
+    }
+}
+
+
+/* Function to display the registers in the content from
+   'start_element_no' on 'start_line_no' until the end of the register
+   content or the end of the display height.  This function checks
+   that we won't display off the end of the register display.  */
+void
+tui_display_reg_element_at_line (int start_element_no, int start_line_no)
+{
+  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)
+    {
+      int element_no = start_element_no;
+
+      if (start_element_no != 0 && start_line_no != 0)
+	{
+	  int last_line_no, first_line_on_last_page;
+
+	  last_line_no = tui_last_regs_line_no ();
+	  first_line_on_last_page = last_line_no - (TUI_DATA_WIN->generic.height - 2);
+	  if (first_line_on_last_page < 0)
+	    first_line_on_last_page = 0;
+	  /*
+	     ** If there is no other data displayed except registers,
+	     ** and the element_no causes us to scroll past the end of the
+	     ** registers, adjust what element to really start the display at.
+	   */
+	  if (TUI_DATA_WIN->detail.data_display_info.data_content_count <= 0 &&
+	      start_line_no > first_line_on_last_page)
+	    element_no = tui_first_reg_element_no_inline (first_line_on_last_page);
+	}
+      tui_display_registers_from (element_no);
+    }
+}
+
+
+
+/* Function to display the registers starting at line line_no in the
+   data window.  Answers the line number that the display actually
+   started from.  If nothing is displayed (-1) is returned.  */
+int
+tui_display_registers_from_line (int line_no, int force_display)
+{
+  if (TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
+    {
+      int line, element_no;
+
+      if (line_no < 0)
+	line = 0;
+      else if (force_display)
+	{			/*
+				   ** If we must display regs (force_display is true), then make
+				   ** sure that we don't display off the end of the registers.
+				 */
+	  if (line_no >= tui_last_regs_line_no ())
+	    {
+	      if ((line = tui_line_from_reg_element_no (
+		 TUI_DATA_WIN->detail.data_display_info.regs_content_count - 1)) < 0)
+		line = 0;
+	    }
+	  else
+	    line = line_no;
+	}
+      else
+	line = line_no;
+
+      element_no = tui_first_reg_element_no_inline (line);
+      if (element_no < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
+	tui_display_reg_element_at_line (element_no, line);
+      else
+	line = (-1);
+
+      return line;
+    }
+
+  return (-1);			/* nothing was displayed */
+}
+
+
+/* This function check all displayed registers for changes in values,
+   given a particular frame.  If the values have changed, they are
+   updated with the new value and highlighted.  */
+void
+tui_check_register_values (struct frame_info *frame)
+{
+  if (TUI_DATA_WIN != NULL && TUI_DATA_WIN->generic.is_visible)
+    {
+      struct tui_data_info *display_info
+        = &TUI_DATA_WIN->detail.data_display_info;
+
+      if (display_info->regs_content_count <= 0 && display_info->display_regs)
+	tui_show_registers (display_info->current_group);
+      else
+	{
+	  int i, j;
+
+	  for (i = 0; (i < display_info->regs_content_count); i++)
+	    {
+	      struct tui_data_element *data;
+	      struct tui_gen_win_info *data_item_win_ptr;
+	      int was_hilighted;
+
+	      data_item_win_ptr = &display_info->regs_content[i]->
+                which_element.data_window;
+	      data = &((struct tui_win_element *)
+                       data_item_win_ptr->content[0])->which_element.data;
+	      was_hilighted = data->highlight;
+
+              tui_get_register (current_gdbarch, frame, data,
+                                data->item_no, &data->highlight);
+
+	      if (data->highlight || was_hilighted)
+		{
+                  tui_display_register (data, data_item_win_ptr);
+		}
+	    }
+	}
+    }
+}
+
+/* Display a register in a window.  If hilite is TRUE,
+   then the value will be displayed in reverse video  */
+static void
+tui_display_register (struct tui_data_element *data,
+                      struct tui_gen_win_info *win_info)
+{
+  if (win_info->handle != (WINDOW *) NULL)
+    {
+      int i;
+
+      if (data->highlight)
+	wstandout (win_info->handle);
+      
+      wmove (win_info->handle, 0, 0);
+      for (i = 1; i < win_info->width; i++)
+        waddch (win_info->handle, ' ');
+      wmove (win_info->handle, 0, 0);
+      if (data->content)
+        waddstr (win_info->handle, data->content);
+
+      if (data->highlight)
+	wstandend (win_info->handle);
+      tui_refresh_win (win_info);
+    }
+}
+
+static void
+tui_reg_next_command (char *arg, int from_tty)
+{
+  if (TUI_DATA_WIN != 0)
+    {
+      struct reggroup *group
+        = TUI_DATA_WIN->detail.data_display_info.current_group;
+
+      group = reggroup_next (current_gdbarch, group);
+      if (group == 0)
+        group = reggroup_next (current_gdbarch, 0);
+
+      if (group)
+        tui_show_registers (group);
+    }
+}
+
+static void
+tui_reg_float_command (char *arg, int from_tty)
+{
+  tui_show_registers (float_reggroup);
+}
+
+static void
+tui_reg_general_command (char *arg, int from_tty)
+{
+  tui_show_registers (general_reggroup);
+}
+
+static void
+tui_reg_system_command (char *arg, int from_tty)
+{
+  tui_show_registers (system_reggroup);
+}
+
+static struct cmd_list_element *tuireglist;
+
+static void
+tui_reg_command (char *args, int from_tty)
+{
+  printf_unfiltered ("\"tui reg\" must be followed by the name of a "
+                     "tui reg command.\n");
+  help_list (tuireglist, "tui reg ", -1, gdb_stdout);
+}
+
+void
+_initialize_tui_regs (void)
+{
+  struct cmd_list_element **tuicmd;
+
+  tuicmd = tui_get_cmd_list ();
+
+  add_prefix_cmd ("reg", class_tui, tui_reg_command,
+                  "TUI commands to control the register window.",
+                  &tuireglist, "tui reg ", 0,
+                  tuicmd);
+
+  add_cmd ("float", class_tui, tui_reg_float_command,
+           "Display only floating point registers\n",
+           &tuireglist);
+  add_cmd ("general", class_tui, tui_reg_general_command,
+           "Display only general registers\n",
+           &tuireglist);
+  add_cmd ("system", class_tui, tui_reg_system_command,
+           "Display only system registers\n",
+           &tuireglist);
+  add_cmd ("next", class_tui, tui_reg_next_command,
+           "Display next register group\n",
+           &tuireglist);
+
+  if (xdb_commands)
+    {
+      add_com ("fr", class_tui, tui_reg_float_command,
+	       "Display only floating point registers\n");
+      add_com ("gr", class_tui, tui_reg_general_command,
+	       "Display only general registers\n");
+      add_com ("sr", class_tui, tui_reg_system_command,
+	       "Display only special registers\n");
+      add_com ("+r", class_tui, tui_scroll_regs_forward_command,
+	       "Scroll the registers window forward\n");
+      add_com ("-r", class_tui, tui_scroll_regs_backward_command,
+	       "Scroll the register window backward\n");
+    }
+}
+
+
+/*****************************************
+** STATIC LOCAL FUNCTIONS                 **
+******************************************/
+
+extern int pagination_enabled;
+
+static void
+tui_restore_gdbout (void *ui)
+{
+  ui_file_delete (gdb_stdout);
+  gdb_stdout = (struct ui_file*) ui;
+  pagination_enabled = 1;
+}
+
+/* Get the register from the frame and make a printable representation
+   of it in the data element.  */
+static void
+tui_register_format (struct gdbarch *gdbarch, struct frame_info *frame,
+                     struct tui_data_element *data_element, int regnum)
+{
+  struct ui_file *stream;
+  struct ui_file *old_stdout;
+  const char *name;
+  struct cleanup *cleanups;
+  char *p, *s;
+  int pos;
+  struct type *type = gdbarch_register_type (gdbarch, regnum);
+
+  name = gdbarch_register_name (gdbarch, regnum);
+  if (name == 0)
+    {
+      return;
+    }
+  
+  pagination_enabled = 0;
+  old_stdout = gdb_stdout;
+  stream = tui_sfileopen (256);
+  gdb_stdout = stream;
+  cleanups = make_cleanup (tui_restore_gdbout, (void*) old_stdout);
+  if (TYPE_VECTOR (type) != 0 && 0)
+    {
+      char buf[MAX_REGISTER_SIZE];
+      int len;
+
+      len = register_size (current_gdbarch, regnum);
+      fprintf_filtered (stream, "%-14s ", name);
+      get_frame_register (frame, regnum, buf);
+      print_scalar_formatted (buf, type, 'f', len, stream);
+    }
+  else
+    {
+      gdbarch_print_registers_info (current_gdbarch, stream,
+                                    frame, regnum, 1);
+    }
+
+  /* Save formatted output in the buffer.  */
+  p = tui_file_get_strbuf (stream);
+
+  /* Remove the possible \n.  */
+  s = strrchr (p, '\n');
+  if (s && s[1] == 0)
+    *s = 0;
+
+  xfree (data_element->content);
+  data_element->content = xstrdup (p);
+  do_cleanups (cleanups);
+}
+
+/* Get the register value from the given frame and format it for
+   the display.  When changep is set, check if the new register value
+   has changed with respect to the previous call.  */
+static enum tui_status
+tui_get_register (struct gdbarch *gdbarch, struct frame_info *frame,
+                  struct tui_data_element *data, int regnum, int *changedp)
+{
+  enum tui_status ret = TUI_FAILURE;
+
+  if (changedp)
+    *changedp = FALSE;
+  if (target_has_registers)
+    {
+      char buf[MAX_REGISTER_SIZE];
+
+      get_frame_register (frame, regnum, buf);
+      /* NOTE: cagney/2003-03-13: This is bogus.  It is refering to
+         the register cache and not the frame which could have pulled
+         the register value off the stack.  */
+      if (register_cached (regnum) >= 0)
+        {
+          if (changedp)
+            {
+              int size = register_size (gdbarch, regnum);
+              char *old = (char*) data->value;
+              int i;
+
+              for (i = 0; i < size; i++)
+                if (buf[i] != old[i])
+                  {
+                    *changedp = TRUE;
+                    old[i] = buf[i];
+                  }
+            }
+
+          /* Reformat the data content if the value changed.  */
+          if (changedp == 0 || *changedp == TRUE)
+            tui_register_format (gdbarch, frame, data, regnum);
+          ret = TUI_SUCCESS;
+        }
+    }
+  return ret;
+}
+
+static void
+tui_scroll_regs_forward_command (char *arg, int from_tty)
+{
+  tui_scroll (FORWARD_SCROLL, TUI_DATA_WIN, 1);
+}
+
+
+static void
+tui_scroll_regs_backward_command (char *arg, int from_tty)
+{
+  tui_scroll (BACKWARD_SCROLL, TUI_DATA_WIN, 1);
+}
diff --git a/gdb/tui/tui-regs.h b/gdb/tui/tui-regs.h
new file mode 100644
index 00000000000..01e2fba1b6d
--- /dev/null
+++ b/gdb/tui/tui-regs.h
@@ -0,0 +1,39 @@
+/* TUI display registers in window.
+
+   Copyright 1998, 1999, 2000, 2001, 2004 Free Software Foundation,
+   Inc.
+
+   Contributed by Hewlett-Packard Company.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#ifndef TUI_REGS_H
+#define TUI_REGS_H
+
+#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 (struct reggroup *group);
+extern void tui_display_registers_from (int);
+extern int tui_display_registers_from_line (int, int);
+extern int tui_last_regs_line_no (void);
+extern int tui_first_reg_element_inline (int);
+extern int tui_line_from_reg_element_no (int);
+extern int tui_first_reg_element_no_inline (int lineno);
+
+#endif
diff --git a/gdb/tui/tui-source.c b/gdb/tui/tui-source.c
new file mode 100644
index 00000000000..d5154b11da1
--- /dev/null
+++ b/gdb/tui/tui-source.c
@@ -0,0 +1,352 @@
+/* TUI display source window.
+
+   Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
+   Foundation, Inc.
+
+   Contributed by Hewlett-Packard Company.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include <ctype.h>
+#include "symtab.h"
+#include "frame.h"
+#include "breakpoint.h"
+#include "source.h"
+#include "symtab.h"
+
+#include "tui/tui.h"
+#include "tui/tui-data.h"
+#include "tui/tui-stack.h"
+#include "tui/tui-winsource.h"
+#include "tui/tui-source.h"
+
+#include "gdb_string.h"
+#include "gdb_curses.h"
+
+/* Function to display source in the source window.  */
+enum tui_status
+tui_set_source_content (struct symtab *s, int line_no, int noerror)
+{
+  enum tui_status ret = TUI_FAILURE;
+
+  if (s != (struct symtab *) NULL && s->filename != (char *) NULL)
+    {
+      FILE *stream;
+      int i, desc, c, line_width, nlines;
+      char *src_line = 0;
+
+      if ((ret = tui_alloc_source_buffer (TUI_SRC_WIN)) == TUI_SUCCESS)
+	{
+	  line_width = TUI_SRC_WIN->generic.width - 1;
+	  /* Take hilite (window border) into account, when calculating
+	     the number of lines  */
+	  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, line_no);
+		  print_sys_errmsg (name, errno);
+		}
+	      ret = TUI_FAILURE;
+	    }
+	  else
+	    {
+	      if (s->line_charpos == 0)
+		find_source_lines (s, desc);
+
+	      if (line_no < 1 || line_no > s->nlines)
+		{
+		  close (desc);
+		  printf_unfiltered (
+			  "Line number %d out of range; %s has %d lines.\n",
+				      line_no, s->filename, s->nlines);
+		}
+	      else if (lseek (desc, s->line_charpos[line_no - 1], 0) < 0)
+		{
+		  close (desc);
+		  perror_with_name (s->filename);
+		}
+	      else
+		{
+		  int offset, cur_line_no, cur_line, cur_len, threshold;
+		  struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
+                  struct tui_source_info * src = &TUI_SRC_WIN->detail.source_info;
+
+                  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);
+                  src->filename = xstrdup (s->filename);
+
+		  /* Determine the threshold for the length of the line
+                     and the offset to start the display.  */
+		  offset = src->horizontal_offset;
+		  threshold = (line_width - 1) + offset;
+		  stream = fdopen (desc, FOPEN_RT);
+		  clearerr (stream);
+		  cur_line = 0;
+		  cur_line_no = src->start_line_or_addr.line_no = line_no;
+		  if (offset > 0)
+		    src_line = (char *) xmalloc (
+					   (threshold + 1) * sizeof (char));
+		  while (cur_line < nlines)
+		    {
+		      struct tui_win_element * element = (struct tui_win_element *)
+		      TUI_SRC_WIN->generic.content[cur_line];
+
+		      /* get the first character in the line */
+		      c = fgetc (stream);
+
+		      if (offset == 0)
+			src_line = ((struct tui_win_element *)
+				   TUI_SRC_WIN->generic.content[
+					cur_line])->which_element.source.line;
+		      /* Init the line with the line number */
+		      sprintf (src_line, "%-6d", cur_line_no);
+		      cur_len = strlen (src_line);
+		      i = cur_len -
+			((cur_len / tui_default_tab_len ()) * tui_default_tab_len ());
+		      while (i < tui_default_tab_len ())
+			{
+			  src_line[cur_len] = ' ';
+			  i++;
+			  cur_len++;
+			}
+		      src_line[cur_len] = (char) 0;
+
+		      /* Set whether element is the execution point and
+		         whether there is a break point on it.  */
+		      element->which_element.source.line_or_addr.line_no =
+			cur_line_no;
+		      element->which_element.source.is_exec_point =
+			(strcmp (((struct tui_win_element *)
+			locator->content[0])->which_element.locator.file_name,
+				 s->filename) == 0
+			 && cur_line_no == ((struct tui_win_element *)
+			 locator->content[0])->which_element.locator.line_no);
+		      if (c != EOF)
+			{
+			  i = strlen (src_line) - 1;
+			  do
+			    {
+			      if ((c != '\n') &&
+				  (c != '\r') && (++i < threshold))
+				{
+				  if (c < 040 && c != '\t')
+				    {
+				      src_line[i++] = '^';
+				      src_line[i] = c + 0100;
+				    }
+				  else if (c == 0177)
+				    {
+				      src_line[i++] = '^';
+				      src_line[i] = '?';
+				    }
+				  else
+				    {	/* Store the charcter in the line
+					   buffer.  If it is a tab, then
+					   translate to the correct number of
+					   chars so we don't overwrite our
+					   buffer.  */
+				      if (c == '\t')
+					{
+					  int j, max_tab_len = tui_default_tab_len ();
+
+					  for (j = i - (
+					       (i / max_tab_len) * max_tab_len);
+					       ((j < max_tab_len) &&
+						i < threshold);
+					       i++, j++)
+					    src_line[i] = ' ';
+					  i--;
+					}
+				      else
+					src_line[i] = c;
+				    }
+				  src_line[i + 1] = 0;
+				}
+			      else
+				{	/* If we have not reached EOL, then eat
+                                           chars until we do  */
+				  while (c != EOF && c != '\n' && c != '\r')
+				    c = fgetc (stream);
+				}
+			    }
+			  while (c != EOF && c != '\n' && c != '\r' &&
+				 i < threshold && (c = fgetc (stream)));
+			}
+		      /* Now copy the line taking the offset into account */
+		      if (strlen (src_line) > offset)
+			strcpy (((struct tui_win_element *) TUI_SRC_WIN->generic.content[
+					cur_line])->which_element.source.line,
+				&src_line[offset]);
+		      else
+			((struct tui_win_element *)
+			 TUI_SRC_WIN->generic.content[
+			  cur_line])->which_element.source.line[0] = (char) 0;
+		      cur_line++;
+		      cur_line_no++;
+		    }
+		  if (offset > 0)
+		    xfree (src_line);
+		  fclose (stream);
+		  TUI_SRC_WIN->generic.content_size = nlines;
+		  ret = TUI_SUCCESS;
+		}
+	    }
+	}
+    }
+  return ret;
+}
+
+
+/* elz: this function sets the contents of the source window to empty
+   except for a line in the middle with a warning message about the
+   source not being available. This function is called by
+   tui_erase_source_contents(), which in turn is invoked when the
+   source files cannot be accessed.  */
+
+void
+tui_set_source_content_nil (struct tui_win_info * win_info, char *warning_string)
+{
+  int line_width;
+  int n_lines;
+  int curr_line = 0;
+
+  line_width = win_info->generic.width - 1;
+  n_lines = win_info->generic.height - 2;
+
+  /* set to empty each line in the window, except for the one
+     which contains the message */
+  while (curr_line < win_info->generic.content_size)
+    {
+      /* set the information related to each displayed line
+         to null: i.e. the line number is 0, there is no bp,
+         it is not where the program is stopped */
+
+      struct tui_win_element * element =
+      (struct tui_win_element *) win_info->generic.content[curr_line];
+      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->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.
+         Note: the 'weird' arithmetic with the line width and height
+         comes from the function tui_erase_source_content(). We need
+         to keep the screen and the window's actual contents in synch.  */
+
+      if (curr_line == (n_lines / 2 + 1))
+	{
+	  int i;
+	  int xpos;
+	  int warning_length = strlen (warning_string);
+	  char *src_line;
+
+	  src_line = element->which_element.source.line;
+
+	  if (warning_length >= ((line_width - 1) / 2))
+	    xpos = 1;
+	  else
+	    xpos = (line_width - 1) / 2 - warning_length;
+
+	  for (i = 0; i < xpos; i++)
+	    src_line[i] = ' ';
+
+	  sprintf (src_line + i, "%s", warning_string);
+
+	  for (i = xpos + warning_length; i < line_width; i++)
+	    src_line[i] = ' ';
+
+	  src_line[i] = '\n';
+
+	}			/* end if */
+
+      curr_line++;
+
+    }				/* end while */
+}
+
+
+/* Function to display source in the source window.  This function
+   initializes the horizontal scroll to 0.  */
+void
+tui_show_symtab_source (struct symtab *s, union tui_line_or_address line, int noerror)
+{
+  TUI_SRC_WIN->detail.source_info.horizontal_offset = 0;
+  tui_update_source_window_as_is (TUI_SRC_WIN, s, line, noerror);
+}
+
+
+/* Answer whether the source is currently displayed in the source
+   window.  */
+int
+tui_source_is_displayed (char *fname)
+{
+  return (TUI_SRC_WIN->generic.content_in_use &&
+	  (strcmp (((struct tui_win_element *) (tui_locator_win_info_ptr ())->
+		  content[0])->which_element.locator.file_name, fname) == 0));
+}
+
+
+/* Scroll the source forward or backward vertically.  */
+void
+tui_vertical_source_scroll (enum tui_scroll_direction scroll_direction,
+			    int num_to_scroll)
+{
+  if (TUI_SRC_WIN->generic.content != NULL)
+    {
+      union tui_line_or_address l;
+      struct symtab *s;
+      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)
+	s = find_pc_symtab (get_frame_pc (deprecated_selected_frame));
+      else
+	s = cursal.symtab;
+
+      if (scroll_direction == FORWARD_SCROLL)
+	{
+	  l.line_no = content[0]->which_element.source.line_or_addr.line_no +
+	    num_to_scroll;
+	  if (l.line_no > s->nlines)
+	    /*line = s->nlines - win_info->generic.content_size + 1; */
+	    /*elz: fix for dts 23398 */
+	    l.line_no = content[0]->which_element.source.line_or_addr.line_no;
+	}
+      else
+	{
+	  l.line_no = content[0]->which_element.source.line_or_addr.line_no -
+	    num_to_scroll;
+	  if (l.line_no <= 0)
+	    l.line_no = 1;
+	}
+
+      print_source_lines (s, l.line_no, l.line_no + 1, 0);
+    }
+}
diff --git a/gdb/tui/tui-source.h b/gdb/tui/tui-source.h
new file mode 100644
index 00000000000..3b61ca4374d
--- /dev/null
+++ b/gdb/tui/tui-source.h
@@ -0,0 +1,40 @@
+/* TUI display source window.
+
+   Copyright 1998, 1999, 2000, 2001, 2002, 2004 Free Software
+   Foundation, Inc.
+
+   Contributed by Hewlett-Packard Company.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#ifndef TUI_SOURCE_H
+#define TUI_SOURCE_H
+
+#include "tui/tui-data.h"
+
+struct symtab;
+struct tui_win_info;
+
+extern void tui_set_source_content_nil (struct tui_win_info *, char *);
+
+extern enum tui_status tui_set_source_content (struct symtab *, int, int);
+extern void tui_show_symtab_source (struct symtab *, union tui_line_or_address, int);
+extern int tui_source_is_displayed (char *);
+extern void tui_vertical_source_scroll (enum tui_scroll_direction, int);
+
+#endif
diff --git a/gdb/tui/tuiStack.c b/gdb/tui/tui-stack.c
index a6ad07af1c3..0ee538988f4 100644
--- a/gdb/tui/tuiStack.c
+++ b/gdb/tui/tui-stack.c
@@ -1,7 +1,7 @@
 /* TUI display locator.
 
-   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.
 
@@ -30,22 +30,16 @@
 #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"
+#include "tui/tui-wingeneral.h"
+#include "tui/tui-source.h"
+#include "tui/tui-winsource.h"
+#include "tui/tui-file.h"
 
-#include "tui.h"
-#include "tuiData.h"
-#include "tuiStack.h"
-#include "tuiGeneralWin.h"
-#include "tuiSource.h"
-#include "tuiSourceWin.h"
-#include "tui-file.h"
-
-#ifdef HAVE_NCURSES_H       
-#include <ncurses.h>
-#else
-#ifdef HAVE_CURSES_H
-#include <curses.h>
-#endif
-#endif
+#include "gdb_curses.h"
 
 /* Get a printable name for the function at the address.
    The symbol name is demangled if demangling is turned on.
@@ -66,7 +60,7 @@ static void tui_update_command (char *, int);
    can on this single line: target name, process number, current
    function, current line, current PC, SingleKey mode.  */
 static char*
-tui_make_status_line (TuiLocatorElement* loc)
+tui_make_status_line (struct tui_locator_element* loc)
 {
   char* string;
   char line_buf[50], *pname;
@@ -94,13 +88,13 @@ tui_make_status_line (TuiLocatorElement* loc)
   if (pid_width > MAX_PID_WIDTH)
     pid_width = MAX_PID_WIDTH;
 
-  status_size = termWidth ();  
+  status_size = tui_term_width ();
   string = (char *) xmalloc (status_size + 1);
   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 +116,7 @@ tui_make_status_line (TuiLocatorElement* 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 +146,7 @@ tui_make_status_line (TuiLocatorElement* 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 +168,7 @@ tui_make_status_line (TuiLocatorElement* 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, " ");
@@ -244,33 +238,30 @@ tui_get_function_from_frame (struct frame_info *fi)
   return name;
 }
 
-/*
-   ** tuiShowLocatorContent()
- */
 void
-tuiShowLocatorContent (void)
+tui_show_locator_content (void)
 {
   char *string;
-  TuiGenWinInfoPtr locator;
+  struct tui_gen_win_info * locator;
 
-  locator = locatorWinInfoPtr ();
+  locator = tui_locator_win_info_ptr ();
 
-  if (m_genWinPtrNotNull (locator) && locator->handle != (WINDOW *) NULL)
+  if (locator != NULL && locator->handle != (WINDOW *) NULL)
     {
-      TuiWinElementPtr element;
+      struct tui_win_element * element;
 
-      element = (TuiWinElementPtr) locator->content[0];
+      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);
       wclrtoeol (locator->handle);
       wstandend (locator->handle);
-      tuiRefreshWin (locator);
+      tui_refresh_win (locator);
       wmove (locator->handle, 0, 0);
       xfree (string);
-      locator->contentInUse = TRUE;
+      locator->content_in_use = TRUE;
     }
 }
 
@@ -279,18 +270,18 @@ tuiShowLocatorContent (void)
 static void
 tui_set_locator_filename (const char *filename)
 {
-  TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
-  TuiLocatorElementPtr element;
+  struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
+  struct tui_locator_element * element;
 
-  if (locator->content[0] == (Opaque) NULL)
+  if (locator->content[0] == NULL)
     {
       tui_set_locator_info (filename, NULL, 0, 0);
       return;
     }
 
-  element = &((TuiWinElementPtr) 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.  */
@@ -298,69 +289,69 @@ static void
 tui_set_locator_info (const char *filename, const char *procname, int lineno,
                       CORE_ADDR addr)
 {
-  TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
-  TuiLocatorElementPtr element;
+  struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
+  struct tui_locator_element * element;
 
   /* Allocate the locator content if necessary.  */
-  if (locator->contentSize <= 0)
+  if (locator->content_size <= 0)
     {
-      locator->content = (OpaquePtr) allocContent (1, locator->type);
-      locator->contentSize = 1;
+      locator->content = (void **) tui_alloc_content (1, locator->type);
+      locator->content_size = 1;
     }
 
-  element = &((TuiWinElementPtr) 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);
 }
 
 /* Update only the filename portion of the locator.  */
 void
-tuiUpdateLocatorFilename (const char *filename)
+tui_update_locator_filename (const char *filename)
 {
   tui_set_locator_filename (filename);
-  tuiShowLocatorContent ();
+  tui_show_locator_content ();
 }
 
 /* Function to print the frame information for the TUI.  */
 void
-tuiShowFrameInfo (struct frame_info *fi)
+tui_show_frame_info (struct frame_info *fi)
 {
-  TuiWinInfoPtr winInfo;
-  register int i;
+  struct tui_win_info * win_info;
+  int i;
 
   if (fi)
     {
-      register int startLine, i;
+      int start_line, i;
       CORE_ADDR low;
-      TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
-      int sourceAlreadyDisplayed;
+      struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
+      int source_already_displayed;
       struct symtab_and_line sal;
 
       find_frame_sal (fi, &sal);
 
-      sourceAlreadyDisplayed = sal.symtab != 0
-        && tuiSourceIsDisplayed (sal.symtab->filename);
+      source_already_displayed = sal.symtab != 0
+        && tui_source_is_displayed (sal.symtab->filename);
       tui_set_locator_info (sal.symtab == 0 ? "??" : sal.symtab->filename,
                             tui_get_function_from_frame (fi),
                             sal.line,
                             get_frame_pc (fi));
-      tuiShowLocatorContent ();
-      startLine = 0;
-      for (i = 0; i < (sourceWindows ())->count; i++)
+      tui_show_locator_content ();
+      start_line = 0;
+      for (i = 0; i < (tui_source_windows ())->count; i++)
 	{
-	  TuiWhichElement *item;
-	  winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[i];
+	  union tui_which_element *item;
+	  win_info = (struct tui_win_info *) (tui_source_windows ())->list[i];
 
-	  item = &((TuiWinElementPtr) 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
 	    {
@@ -368,56 +359,57 @@ tuiShowFrameInfo (struct frame_info *fi)
 					    &low, (CORE_ADDR) NULL) == 0)
 		error ("No function contains program counter for selected frame.\n");
 	      else
-		low = tuiGetLowDisassemblyAddress (low, get_frame_pc (fi));
+		low = tui_get_low_disassembly_address (low, get_frame_pc (fi));
 	    }
 
-	  if (winInfo == srcWin)
+	  if (win_info == TUI_SRC_WIN)
 	    {
-	      TuiLineOrAddress l;
-	      l.lineNo = startLine;
-	      if (!(sourceAlreadyDisplayed
-		    && tuiLineIsDisplayed (item->locator.lineNo, winInfo, TRUE)))
-		tuiUpdateSourceWindow (winInfo, sal.symtab, l, TRUE);
+	      union tui_line_or_address l;
+	      l.line_no = start_line;
+	      if (!(source_already_displayed
+		    && 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;
-		  tuiSetIsExecPointAt (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)
 		{
-		  TuiLineOrAddress a;
+		  union tui_line_or_address a;
 		  a.addr = low;
-		  if (!tuiAddrIsDisplayed (item->locator.addr, winInfo, TRUE))
-		    tuiUpdateSourceWindow (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;
-		      tuiSetIsExecPointAt (a, winInfo);
+		      tui_set_is_exec_point_at (a, win_info);
 		    }
 		}
 	    }
-	  tuiUpdateExecInfo (winInfo);
+	  tui_update_exec_info (win_info);
 	}
     }
   else
     {
       tui_set_locator_info (NULL, NULL, 0, (CORE_ADDR) 0);
-      tuiShowLocatorContent ();
-      for (i = 0; i < (sourceWindows ())->count; i++)
+      tui_show_locator_content ();
+      for (i = 0; i < (tui_source_windows ())->count; i++)
 	{
-	  winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[i];
-	  tuiClearSourceContent (winInfo, EMPTY_SOURCE_PROMPT);
-	  tuiUpdateExecInfo (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);
 	}
     }
 }
 
-/* Function to initialize gdb commands, for tui window stack manipulation.  */
+/* Function to initialize gdb commands, for tui window stack
+   manipulation.  */
 void
-_initialize_tuiStack (void)
+_initialize_tui_stack (void)
 {
   add_com ("update", class_tui, tui_update_command,
            "Update the source window and locator to display the current "
diff --git a/gdb/tui/tuiStack.h b/gdb/tui/tui-stack.h
index 14be4974bed..65725b3fd2f 100644
--- a/gdb/tui/tuiStack.h
+++ b/gdb/tui/tui-stack.h
@@ -1,5 +1,8 @@
 /* TUI display locator.
-   Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+
+   Copyright 1998, 1999, 2000, 2001, 2002, 2004 Free Software
+   Foundation, Inc.
+
    Contributed by Hewlett-Packard Company.
 
    This file is part of GDB.
@@ -19,15 +22,13 @@
    Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
-#ifndef _TUI_STACK_H
-#define _TUI_STACK_H
-/*
-   ** This header file supports
- */
+#ifndef TUI_STACK_H
+#define TUI_STACK_H
+
+struct frame_info;
 
-extern void tuiUpdateLocatorFilename (const char *);
-extern void tuiShowLocatorContent (void);
-extern void tuiShowFrameInfo (struct frame_info *);
+extern void tui_update_locator_filename (const char *);
+extern void tui_show_locator_content (void);
+extern void tui_show_frame_info (struct frame_info *);
 
 #endif
-/*_TUI_STACK_H*/
diff --git a/gdb/tui/tui-win.c b/gdb/tui/tui-win.c
new file mode 100644
index 00000000000..1c67baa8b01
--- /dev/null
+++ b/gdb/tui/tui-win.c
@@ -0,0 +1,1520 @@
+/* TUI window generic functions.
+
+   Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
+   Foundation, Inc.
+
+   Contributed by Hewlett-Packard Company.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+/* This module contains procedures for handling tui window functions
+   like resize, scrolling, scrolling, changing focus, etc.
+
+   Author: Susan B. Macchia  */
+
+#include "defs.h"
+#include "command.h"
+#include "symtab.h"
+#include "breakpoint.h"
+#include "frame.h"
+#include "cli/cli-cmds.h"
+#include "top.h"
+#include "source.h"
+
+#include "tui/tui.h"
+#include "tui/tui-data.h"
+#include "tui/tui-wingeneral.h"
+#include "tui/tui-stack.h"
+#include "tui/tui-regs.h"
+#include "tui/tui-disasm.h"
+#include "tui/tui-source.h"
+#include "tui/tui-winsource.h"
+#include "tui/tui-windata.h"
+
+#include "gdb_curses.h"
+
+#include "gdb_string.h"
+#include <ctype.h>
+#include "readline/readline.h"
+
+/*******************************
+** Static Local Decls
+********************************/
+static void make_visible_with_new_height (struct tui_win_info *);
+static void make_invisible_and_set_new_height (struct tui_win_info *, int);
+static enum tui_status tui_adjust_win_heights (struct tui_win_info *, int);
+static int new_height_ok (struct tui_win_info *, int);
+static void tui_set_tab_width_command (char *, int);
+static void tui_refresh_all_command (char *, int);
+static void tui_set_win_height_command (char *, int);
+static void tui_xdb_set_win_height_command (char *, int);
+static void tui_all_windows_info (char *, int);
+static void tui_set_focus_command (char *, int);
+static void tui_scroll_forward_command (char *, int);
+static void tui_scroll_backward_command (char *, int);
+static void tui_scroll_left_command (char *, int);
+static void tui_scroll_right_command (char *, int);
+static void parse_scrolling_args (char *, struct tui_win_info * *, int *);
+
+
+/***************************************
+** DEFINITIONS
+***************************************/
+#define WIN_HEIGHT_USAGE      "Usage: winheight <win_name> [+ | -] <#lines>\n"
+#define XDBWIN_HEIGHT_USAGE   "Usage: w <#lines>\n"
+#define FOCUS_USAGE           "Usage: focus {<win> | next | prev}\n"
+
+/***************************************
+** PUBLIC FUNCTIONS
+***************************************/
+
+#ifndef ACS_LRCORNER
+#  define ACS_LRCORNER '+'
+#endif
+#ifndef ACS_LLCORNER
+#  define ACS_LLCORNER '+'
+#endif
+#ifndef ACS_ULCORNER
+#  define ACS_ULCORNER '+'
+#endif
+#ifndef ACS_URCORNER
+#  define ACS_URCORNER '+'
+#endif
+#ifndef ACS_HLINE
+#  define ACS_HLINE '-'
+#endif
+#ifndef ACS_VLINE
+#  define ACS_VLINE '|'
+#endif
+
+/* Possible values for tui-border-kind variable.  */
+static const char *tui_border_kind_enums[] = {
+  "space",
+  "ascii",
+  "acs",
+  NULL
+};
+
+/* Possible values for tui-border-mode and tui-active-border-mode.  */
+static const char *tui_border_mode_enums[] = {
+  "normal",
+  "standout",
+  "reverse",
+  "half",
+  "half-standout",
+  "bold",
+  "bold-standout",
+  NULL
+};
+
+struct tui_translate
+{
+  const char *name;
+  int value;
+};
+
+/* Translation table for border-mode variables.
+   The list of values must be terminated by a NULL.
+   After the NULL value, an entry defines the default.  */
+struct tui_translate tui_border_mode_translate[] = {
+  { "normal",		A_NORMAL },
+  { "standout",		A_STANDOUT },
+  { "reverse",		A_REVERSE },
+  { "half",		A_DIM },
+  { "half-standout",	A_DIM | A_STANDOUT },
+  { "bold",		A_BOLD },
+  { "bold-standout",	A_BOLD | A_STANDOUT },
+  { 0, 0 },
+  { "normal",		A_NORMAL }
+};
+
+/* Translation tables for border-kind, one for each border
+   character (see wborder, border curses operations).
+   -1 is used to indicate the ACS because ACS characters
+   are determined at run time by curses (depends on terminal).  */
+struct tui_translate tui_border_kind_translate_vline[] = {
+  { "space",    ' ' },
+  { "ascii",    '|' },
+  { "acs",      -1 },
+  { 0, 0 },
+  { "ascii",    '|' }
+};
+
+struct tui_translate tui_border_kind_translate_hline[] = {
+  { "space",    ' ' },
+  { "ascii",    '-' },
+  { "acs",      -1 },
+  { 0, 0 },
+  { "ascii",    '-' }
+};
+
+struct tui_translate tui_border_kind_translate_ulcorner[] = {
+  { "space",    ' ' },
+  { "ascii",    '+' },
+  { "acs",      -1 },
+  { 0, 0 },
+  { "ascii",    '+' }
+};
+
+struct tui_translate tui_border_kind_translate_urcorner[] = {
+  { "space",    ' ' },
+  { "ascii",    '+' },
+  { "acs",      -1 },
+  { 0, 0 },
+  { "ascii",    '+' }
+};
+
+struct tui_translate tui_border_kind_translate_llcorner[] = {
+  { "space",    ' ' },
+  { "ascii",    '+' },
+  { "acs",      -1 },
+  { 0, 0 },
+  { "ascii",    '+' }
+};
+
+struct tui_translate tui_border_kind_translate_lrcorner[] = {
+  { "space",    ' ' },
+  { "ascii",    '+' },
+  { "acs",      -1 },
+  { 0, 0 },
+  { "ascii",    '+' }
+};
+
+
+/* Tui configuration variables controlled with set/show command.  */
+const char *tui_active_border_mode = "bold-standout";
+const char *tui_border_mode = "normal";
+const char *tui_border_kind = "acs";
+
+/* Tui internal configuration variables.  These variables are
+   updated by tui_update_variables to reflect the tui configuration
+   variables.  */
+chtype tui_border_vline;
+chtype tui_border_hline;
+chtype tui_border_ulcorner;
+chtype tui_border_urcorner;
+chtype tui_border_llcorner;
+chtype tui_border_lrcorner;
+
+int tui_border_attrs;
+int tui_active_border_attrs;
+
+/* Identify the item in the translation table.
+   When the item is not recognized, use the default entry.  */
+static struct tui_translate *
+translate (const char *name, struct tui_translate *table)
+{
+  while (table->name)
+    {
+      if (name && strcmp (table->name, name) == 0)
+        return table;
+      table++;
+    }
+
+  /* Not found, return default entry.  */
+  table++;
+  return table;
+}
+
+/* Update the tui internal configuration according to gdb settings.
+   Returns 1 if the configuration has changed and the screen should
+   be redrawn.  */
+int
+tui_update_variables (void)
+{
+  int need_redraw = 0;
+  struct tui_translate *entry;
+
+  entry = translate (tui_border_mode, tui_border_mode_translate);
+  if (tui_border_attrs != entry->value)
+    {
+      tui_border_attrs = entry->value;
+      need_redraw = 1;
+    }
+  entry = translate (tui_active_border_mode, tui_border_mode_translate);
+  if (tui_active_border_attrs != entry->value)
+    {
+      tui_active_border_attrs = entry->value;
+      need_redraw = 1;
+    }
+
+  /* If one corner changes, all characters are changed.
+     Only check the first one.  The ACS characters are determined at
+     run time by curses terminal management.  */
+  entry = translate (tui_border_kind, tui_border_kind_translate_lrcorner);
+  if (tui_border_lrcorner != (chtype) entry->value)
+    {
+      tui_border_lrcorner = (entry->value < 0) ? ACS_LRCORNER : entry->value;
+      need_redraw = 1;
+    }
+  entry = translate (tui_border_kind, tui_border_kind_translate_llcorner);
+  tui_border_llcorner = (entry->value < 0) ? ACS_LLCORNER : entry->value;
+
+  entry = translate (tui_border_kind, tui_border_kind_translate_ulcorner);
+  tui_border_ulcorner = (entry->value < 0) ? ACS_ULCORNER : entry->value;
+
+  entry = translate (tui_border_kind, tui_border_kind_translate_urcorner);
+  tui_border_urcorner = (entry->value < 0) ? ACS_URCORNER : entry->value;
+
+  entry = translate (tui_border_kind, tui_border_kind_translate_hline);
+  tui_border_hline = (entry->value < 0) ? ACS_HLINE : entry->value;
+
+  entry = translate (tui_border_kind, tui_border_kind_translate_vline);
+  tui_border_vline = (entry->value < 0) ? ACS_VLINE : entry->value;
+
+  return need_redraw;
+}
+
+static void
+set_tui_cmd (char *args, int from_tty)
+{
+}
+
+static void
+show_tui_cmd (char *args, int from_tty)
+{
+}
+
+static struct cmd_list_element *tuilist;
+
+static void
+tui_command (char *args, int from_tty)
+{
+  printf_unfiltered ("\"tui\" must be followed by the name of a "
+                     "tui command.\n");
+  help_list (tuilist, "tui ", -1, gdb_stdout);
+}
+
+struct cmd_list_element **
+tui_get_cmd_list ()
+{
+  if (tuilist == 0)
+    add_prefix_cmd ("tui", class_tui, tui_command,
+                    "Text User Interface commands.",
+                    &tuilist, "tui ", 0, &cmdlist);
+  return &tuilist;
+}
+
+/* Function to initialize gdb commands, for tui window manipulation.  */
+void
+_initialize_tui_win (void)
+{
+  struct cmd_list_element *c;
+  static struct cmd_list_element *tui_setlist;
+  static struct cmd_list_element *tui_showlist;
+
+  /* Define the classes of commands.
+     They will appear in the help list in the reverse of this order.  */
+  add_prefix_cmd ("tui", class_tui, set_tui_cmd,
+                  "TUI configuration variables",
+		  &tui_setlist, "set tui ",
+		  0/*allow-unknown*/, &setlist);
+  add_prefix_cmd ("tui", class_tui, show_tui_cmd,
+                  "TUI configuration variables",
+		  &tui_showlist, "show tui ",
+		  0/*allow-unknown*/, &showlist);
+
+  add_com ("refresh", class_tui, tui_refresh_all_command,
+           "Refresh the terminal display.\n");
+  if (xdb_commands)
+    add_com_alias ("U", "refresh", class_tui, 0);
+  add_com ("tabset", class_tui, tui_set_tab_width_command,
+           "Set the width (in characters) of tab stops.\n\
+Usage: tabset <n>\n");
+  add_com ("winheight", class_tui, tui_set_win_height_command,
+           "Set the height of a specified window.\n\
+Usage: winheight <win_name> [+ | -] <#lines>\n\
+Window names are:\n\
+src  : the source window\n\
+cmd  : the command window\n\
+asm  : the disassembly window\n\
+regs : the register display\n");
+  add_com_alias ("wh", "winheight", class_tui, 0);
+  add_info ("win", tui_all_windows_info,
+            "List of all displayed windows.\n");
+  add_com ("focus", class_tui, tui_set_focus_command,
+           "Set focus to named window or next/prev window.\n\
+Usage: focus {<win> | next | prev}\n\
+Valid Window names are:\n\
+src  : the source window\n\
+asm  : the disassembly window\n\
+regs : the register display\n\
+cmd  : the command window\n");
+  add_com_alias ("fs", "focus", class_tui, 0);
+  add_com ("+", class_tui, tui_scroll_forward_command,
+           "Scroll window forward.\nUsage: + [win] [n]\n");
+  add_com ("-", class_tui, tui_scroll_backward_command,
+           "Scroll window backward.\nUsage: - [win] [n]\n");
+  add_com ("<", class_tui, tui_scroll_left_command,
+           "Scroll window forward.\nUsage: < [win] [n]\n");
+  add_com (">", class_tui, tui_scroll_right_command,
+           "Scroll window backward.\nUsage: > [win] [n]\n");
+  if (xdb_commands)
+    add_com ("w", class_xdb, tui_xdb_set_win_height_command,
+             "XDB compatibility command for setting the height of a command window.\n\
+Usage: w <#lines>\n");
+
+  /* Define the tui control variables.  */
+  c = add_set_enum_cmd
+    ("border-kind", no_class,
+     tui_border_kind_enums, &tui_border_kind,
+     "Set the kind of border for TUI windows.\n"
+     "This variable controls the border of TUI windows:\n"
+     "space           use a white space\n"
+     "ascii           use ascii characters + - | for the border\n"
+     "acs             use the Alternate Character Set\n",
+     &tui_setlist);
+  add_show_from_set (c, &tui_showlist);
+
+  c = add_set_enum_cmd
+    ("border-mode", no_class,
+     tui_border_mode_enums, &tui_border_mode,
+     "Set the attribute mode to use for the TUI window borders.\n"
+     "This variable controls the attributes to use for the window borders:\n"
+     "normal          normal display\n"
+     "standout        use highlight mode of terminal\n"
+     "reverse         use reverse video mode\n"
+     "half            use half bright\n"
+     "half-standout   use half bright and standout mode\n"
+     "bold            use extra bright or bold\n"
+     "bold-standout   use extra bright or bold with standout mode\n",
+     &tui_setlist);
+  add_show_from_set (c, &tui_showlist);
+
+  c = add_set_enum_cmd
+    ("active-border-mode", no_class,
+     tui_border_mode_enums, &tui_active_border_mode,
+     "Set the attribute mode to use for the active TUI window border.\n"
+     "This variable controls the attributes to use for the active window border:\n"
+     "normal          normal display\n"
+     "standout        use highlight mode of terminal\n"
+     "reverse         use reverse video mode\n"
+     "half            use half bright\n"
+     "half-standout   use half bright and standout mode\n"
+     "bold            use extra bright or bold\n"
+     "bold-standout   use extra bright or bold with standout mode\n",
+     &tui_setlist);
+  add_show_from_set (c, &tui_showlist);
+}
+
+/* Update gdb's knowledge of the terminal size.  */
+void
+tui_update_gdb_sizes (void)
+{
+  char cmd[50];
+  int screenheight, screenwidth;
+
+  rl_get_screen_size (&screenheight, &screenwidth);
+  /* Set to TUI command window dimension or use readline values.  */
+  sprintf (cmd, "set width %d",
+           tui_active ? TUI_CMD_WIN->generic.width : screenwidth);
+  execute_command (cmd, 0);
+  sprintf (cmd, "set height %d",
+           tui_active ? TUI_CMD_WIN->generic.height : screenheight);
+  execute_command (cmd, 0);
+}
+
+
+/* Set the logical focus to win_info.    */
+void
+tui_set_win_focus_to (struct tui_win_info * win_info)
+{
+  if (win_info != NULL)
+    {
+      struct tui_win_info * win_with_focus = tui_win_with_focus ();
+
+      if (win_with_focus != NULL
+	  && win_with_focus->generic.type != CMD_WIN)
+	tui_unhighlight_win (win_with_focus);
+      tui_set_win_with_focus (win_info);
+      if (win_info->generic.type != CMD_WIN)
+	tui_highlight_win (win_info);
+    }
+}
+
+
+void
+tui_scroll_forward (struct tui_win_info * win_to_scroll, int num_to_scroll)
+{
+  if (win_to_scroll != TUI_CMD_WIN)
+    {
+      int _num_to_scroll = num_to_scroll;
+
+      if (num_to_scroll == 0)
+	_num_to_scroll = win_to_scroll->generic.height - 3;
+      /*
+         ** If we are scrolling the source or disassembly window, do a
+         ** "psuedo" scroll since not all of the source is in memory,
+         ** only what is in the viewport.  If win_to_scroll is the
+         ** command window do nothing since the term should handle it.
+       */
+      if (win_to_scroll == TUI_SRC_WIN)
+	tui_vertical_source_scroll (FORWARD_SCROLL, _num_to_scroll);
+      else if (win_to_scroll == TUI_DISASM_WIN)
+	tui_vertical_disassem_scroll (FORWARD_SCROLL, _num_to_scroll);
+      else if (win_to_scroll == TUI_DATA_WIN)
+	tui_vertical_data_scroll (FORWARD_SCROLL, _num_to_scroll);
+    }
+}
+
+void
+tui_scroll_backward (struct tui_win_info * win_to_scroll, int num_to_scroll)
+{
+  if (win_to_scroll != TUI_CMD_WIN)
+    {
+      int _num_to_scroll = num_to_scroll;
+
+      if (num_to_scroll == 0)
+	_num_to_scroll = win_to_scroll->generic.height - 3;
+      /*
+         ** If we are scrolling the source or disassembly window, do a
+         ** "psuedo" scroll since not all of the source is in memory,
+         ** only what is in the viewport.  If win_to_scroll is the
+         ** command window do nothing since the term should handle it.
+       */
+      if (win_to_scroll == TUI_SRC_WIN)
+	tui_vertical_source_scroll (BACKWARD_SCROLL, _num_to_scroll);
+      else if (win_to_scroll == TUI_DISASM_WIN)
+	tui_vertical_disassem_scroll (BACKWARD_SCROLL, _num_to_scroll);
+      else if (win_to_scroll == TUI_DATA_WIN)
+	tui_vertical_data_scroll (BACKWARD_SCROLL, _num_to_scroll);
+    }
+}
+
+
+void
+tui_scroll_left (struct tui_win_info * win_to_scroll, int num_to_scroll)
+{
+  if (win_to_scroll != TUI_CMD_WIN)
+    {
+      int _num_to_scroll = num_to_scroll;
+
+      if (_num_to_scroll == 0)
+	_num_to_scroll = 1;
+      /*
+         ** If we are scrolling the source or disassembly window, do a
+         ** "psuedo" scroll since not all of the source is in memory,
+         ** only what is in the viewport. If win_to_scroll is the
+         ** command window do nothing since the term should handle it.
+       */
+      if (win_to_scroll == TUI_SRC_WIN || win_to_scroll == TUI_DISASM_WIN)
+	tui_horizontal_source_scroll (win_to_scroll, LEFT_SCROLL, _num_to_scroll);
+    }
+}
+
+
+void
+tui_scroll_right (struct tui_win_info * win_to_scroll, int num_to_scroll)
+{
+  if (win_to_scroll != TUI_CMD_WIN)
+    {
+      int _num_to_scroll = num_to_scroll;
+
+      if (_num_to_scroll == 0)
+	_num_to_scroll = 1;
+      /*
+         ** If we are scrolling the source or disassembly window, do a
+         ** "psuedo" scroll since not all of the source is in memory,
+         ** only what is in the viewport. If win_to_scroll is the
+         ** command window do nothing since the term should handle it.
+       */
+      if (win_to_scroll == TUI_SRC_WIN || win_to_scroll == TUI_DISASM_WIN)
+	tui_horizontal_source_scroll (win_to_scroll, RIGHT_SCROLL, _num_to_scroll);
+    }
+}
+
+
+/* Scroll a window.  Arguments are passed through a va_list.    */
+void
+tui_scroll (enum tui_scroll_direction direction,
+	    struct tui_win_info * win_to_scroll,
+	    int num_to_scroll)
+{
+  switch (direction)
+    {
+    case FORWARD_SCROLL:
+      tui_scroll_forward (win_to_scroll, num_to_scroll);
+      break;
+    case BACKWARD_SCROLL:
+      tui_scroll_backward (win_to_scroll, num_to_scroll);
+      break;
+    case LEFT_SCROLL:
+      tui_scroll_left (win_to_scroll, num_to_scroll);
+      break;
+    case RIGHT_SCROLL:
+      tui_scroll_right (win_to_scroll, num_to_scroll);
+      break;
+    default:
+      break;
+    }
+}
+
+
+void
+tui_refresh_all_win (void)
+{
+  enum tui_win_type type;
+
+  clearok (curscr, TRUE);
+  tui_refresh_all (tui_win_list);
+  for (type = SRC_WIN; type < MAX_MAJOR_WINDOWS; type++)
+    {
+      if (tui_win_list[type] && tui_win_list[type]->generic.is_visible)
+	{
+	  switch (type)
+	    {
+	    case SRC_WIN:
+	    case DISASSEM_WIN:
+	      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 ();
+	      break;
+	    default:
+	      break;
+	    }
+	}
+    }
+  tui_show_locator_content ();
+}
+
+
+/* Resize all the windows based on the the terminal size.  This
+   function gets called from within the readline sinwinch handler.  */
+void
+tui_resize_all (void)
+{
+  int height_diff, width_diff;
+  int screenheight, screenwidth;
+
+  rl_get_screen_size (&screenheight, &screenwidth);
+  width_diff = screenwidth - tui_term_width ();
+  height_diff = screenheight - tui_term_height ();
+  if (height_diff || width_diff)
+    {
+      enum tui_layout_type cur_layout = tui_current_layout ();
+      struct tui_win_info * win_with_focus = tui_win_with_focus ();
+      struct tui_win_info *first_win;
+      struct tui_win_info *second_win;
+      struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
+      enum tui_win_type win_type;
+      int new_height, split_diff, cmd_split_diff, num_wins_displayed = 2;
+
+#ifdef HAVE_RESIZE_TERM
+      resize_term (screenheight, screenwidth);
+#endif      
+      /* turn keypad off while we resize */
+      if (win_with_focus != 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);
+      if (cur_layout == SRC_DISASSEM_COMMAND ||
+	cur_layout == SRC_DATA_COMMAND || cur_layout == DISASSEM_DATA_COMMAND)
+	num_wins_displayed++;
+      split_diff = height_diff / num_wins_displayed;
+      cmd_split_diff = split_diff;
+      if (height_diff % num_wins_displayed)
+	{
+	  if (height_diff < 0)
+	    cmd_split_diff--;
+	  else
+	    cmd_split_diff++;
+	}
+      /* now adjust each window */
+      clear ();
+      refresh ();
+      switch (cur_layout)
+	{
+	case SRC_COMMAND:
+	case DISASSEM_COMMAND:
+	  first_win = (struct tui_win_info *) (tui_source_windows ())->list[0];
+	  first_win->generic.width += width_diff;
+	  locator->width += width_diff;
+	  /* check for invalid heights */
+	  if (height_diff == 0)
+	    new_height = first_win->generic.height;
+	  else if ((first_win->generic.height + split_diff) >=
+		   (screenheight - MIN_CMD_WIN_HEIGHT - 1))
+	    new_height = screenheight - MIN_CMD_WIN_HEIGHT - 1;
+	  else if ((first_win->generic.height + split_diff) <= 0)
+	    new_height = MIN_WIN_HEIGHT;
+	  else
+	    new_height = first_win->generic.height + split_diff;
+
+	  make_invisible_and_set_new_height (first_win, new_height);
+	  TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
+	  TUI_CMD_WIN->generic.width += width_diff;
+	  new_height = screenheight - TUI_CMD_WIN->generic.origin.y;
+	  make_invisible_and_set_new_height (TUI_CMD_WIN, new_height);
+	  make_visible_with_new_height (first_win);
+	  make_visible_with_new_height (TUI_CMD_WIN);
+	  if (first_win->generic.content_size <= 0)
+	    tui_erase_source_content (first_win, EMPTY_SOURCE_PROMPT);
+	  break;
+	default:
+	  if (cur_layout == SRC_DISASSEM_COMMAND)
+	    {
+	      first_win = TUI_SRC_WIN;
+	      first_win->generic.width += width_diff;
+	      second_win = TUI_DISASM_WIN;
+	      second_win->generic.width += width_diff;
+	    }
+	  else
+	    {
+	      first_win = TUI_DATA_WIN;
+	      first_win->generic.width += width_diff;
+	      second_win = (struct tui_win_info *) (tui_source_windows ())->list[0];
+	      second_win->generic.width += width_diff;
+	    }
+	  /* Change the first window's height/width */
+	  /* check for invalid heights */
+	  if (height_diff == 0)
+	    new_height = first_win->generic.height;
+	  else if ((first_win->generic.height +
+		    second_win->generic.height + (split_diff * 2)) >=
+		   (screenheight - MIN_CMD_WIN_HEIGHT - 1))
+	    new_height = (screenheight - MIN_CMD_WIN_HEIGHT - 1) / 2;
+	  else if ((first_win->generic.height + split_diff) <= 0)
+	    new_height = MIN_WIN_HEIGHT;
+	  else
+	    new_height = first_win->generic.height + split_diff;
+	  make_invisible_and_set_new_height (first_win, new_height);
+
+	  locator->width += width_diff;
+
+	  /* Change the second window's height/width */
+	  /* check for invalid heights */
+	  if (height_diff == 0)
+	    new_height = second_win->generic.height;
+	  else if ((first_win->generic.height +
+		    second_win->generic.height + (split_diff * 2)) >=
+		   (screenheight - MIN_CMD_WIN_HEIGHT - 1))
+	    {
+	      new_height = screenheight - MIN_CMD_WIN_HEIGHT - 1;
+	      if (new_height % 2)
+		new_height = (new_height / 2) + 1;
+	      else
+		new_height /= 2;
+	    }
+	  else if ((second_win->generic.height + split_diff) <= 0)
+	    new_height = MIN_WIN_HEIGHT;
+	  else
+	    new_height = second_win->generic.height + split_diff;
+	  second_win->generic.origin.y = first_win->generic.height - 1;
+	  make_invisible_and_set_new_height (second_win, new_height);
+
+	  /* Change the command window's height/width */
+	  TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
+	  make_invisible_and_set_new_height (
+			     TUI_CMD_WIN, TUI_CMD_WIN->generic.height + cmd_split_diff);
+	  make_visible_with_new_height (first_win);
+	  make_visible_with_new_height (second_win);
+	  make_visible_with_new_height (TUI_CMD_WIN);
+	  if (first_win->generic.content_size <= 0)
+	    tui_erase_source_content (first_win, EMPTY_SOURCE_PROMPT);
+	  if (second_win->generic.content_size <= 0)
+	    tui_erase_source_content (second_win, EMPTY_SOURCE_PROMPT);
+	  break;
+	}
+      /*
+         ** Now remove all invisible windows, and their content so that they get
+         ** created again when called for with the new size
+       */
+      for (win_type = SRC_WIN; (win_type < MAX_MAJOR_WINDOWS); win_type++)
+	{
+	  if (win_type != CMD_WIN && (tui_win_list[win_type] != NULL)
+	      && !tui_win_list[win_type]->generic.is_visible)
+	    {
+	      tui_free_window (tui_win_list[win_type]);
+	      tui_win_list[win_type] = (struct tui_win_info *) NULL;
+	    }
+	}
+      tui_set_win_resized_to (TRUE);
+      /* turn keypad back on, unless focus is in the command window */
+      if (win_with_focus != TUI_CMD_WIN)
+	keypad (TUI_CMD_WIN->generic.handle, TRUE);
+    }
+}
+
+
+/* SIGWINCH signal handler for the tui.  This signal handler is always
+   called, even when the readline package clears signals because it is
+   set as the old_sigwinch() (TUI only).  */
+void
+tui_sigwinch_handler (int signal)
+{
+  /*
+     ** Say that a resize was done so that the readline can do it
+     ** later when appropriate.
+   */
+  tui_set_win_resized_to (TRUE);
+}
+
+
+
+/*************************
+** STATIC LOCAL FUNCTIONS
+**************************/
+
+
+static void
+tui_scroll_forward_command (char *arg, int from_tty)
+{
+  int num_to_scroll = 1;
+  struct tui_win_info * win_to_scroll;
+
+  /* Make sure the curses mode is enabled.  */
+  tui_enable ();
+  if (arg == (char *) NULL)
+    parse_scrolling_args (arg, &win_to_scroll, (int *) NULL);
+  else
+    parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
+  tui_scroll (FORWARD_SCROLL, win_to_scroll, num_to_scroll);
+}
+
+
+static void
+tui_scroll_backward_command (char *arg, int from_tty)
+{
+  int num_to_scroll = 1;
+  struct tui_win_info * win_to_scroll;
+
+  /* Make sure the curses mode is enabled.  */
+  tui_enable ();
+  if (arg == (char *) NULL)
+    parse_scrolling_args (arg, &win_to_scroll, (int *) NULL);
+  else
+    parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
+  tui_scroll (BACKWARD_SCROLL, win_to_scroll, num_to_scroll);
+}
+
+
+static void
+tui_scroll_left_command (char *arg, int from_tty)
+{
+  int num_to_scroll;
+  struct tui_win_info * win_to_scroll;
+
+  /* Make sure the curses mode is enabled.  */
+  tui_enable ();
+  parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
+  tui_scroll (LEFT_SCROLL, win_to_scroll, num_to_scroll);
+}
+
+
+static void
+tui_scroll_right_command (char *arg, int from_tty)
+{
+  int num_to_scroll;
+  struct tui_win_info * win_to_scroll;
+
+  /* Make sure the curses mode is enabled.  */
+  tui_enable ();
+  parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
+  tui_scroll (RIGHT_SCROLL, win_to_scroll, num_to_scroll);
+}
+
+
+/* Set focus to the window named by 'arg'.  */
+static void
+tui_set_focus (char *arg, int from_tty)
+{
+  if (arg != (char *) NULL)
+    {
+      char *buf_ptr = (char *) xstrdup (arg);
+      int i;
+      struct tui_win_info * win_info = (struct tui_win_info *) NULL;
+
+      for (i = 0; (i < strlen (buf_ptr)); i++)
+	buf_ptr[i] = toupper (arg[i]);
+
+      if (subset_compare (buf_ptr, "NEXT"))
+	win_info = tui_next_win (tui_win_with_focus ());
+      else if (subset_compare (buf_ptr, "PREV"))
+	win_info = tui_prev_win (tui_win_with_focus ());
+      else
+	win_info = tui_partial_win_by_name (buf_ptr);
+
+      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 (win_info);
+	  keypad (TUI_CMD_WIN->generic.handle, (win_info != TUI_CMD_WIN));
+	}
+
+      if (TUI_DATA_WIN && TUI_DATA_WIN->generic.is_visible)
+	tui_refresh_data_win ();
+      xfree (buf_ptr);
+      printf_filtered ("Focus set to %s window.\n",
+		       tui_win_name ((struct tui_gen_win_info *) tui_win_with_focus ()));
+    }
+  else
+    warning ("Incorrect Number of Arguments.\n%s", FOCUS_USAGE);
+}
+
+static void
+tui_set_focus_command (char *arg, int from_tty)
+{
+  /* Make sure the curses mode is enabled.  */
+  tui_enable ();
+  tui_set_focus (arg, from_tty);
+}
+
+
+static void
+tui_all_windows_info (char *arg, int from_tty)
+{
+  enum tui_win_type type;
+  struct tui_win_info * win_with_focus = tui_win_with_focus ();
+
+  for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
+    if (tui_win_list[type] && tui_win_list[type]->generic.is_visible)
+      {
+	if (win_with_focus == tui_win_list[type])
+	  printf_filtered ("        %s\t(%d lines)  <has focus>\n",
+			   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 (&tui_win_list[type]->generic),
+			   tui_win_list[type]->generic.height);
+      }
+}
+
+
+static void
+tui_refresh_all_command (char *arg, int from_tty)
+{
+  /* Make sure the curses mode is enabled.  */
+  tui_enable ();
+
+  tui_refresh_all_win ();
+}
+
+
+/* Set the height of the specified window.   */
+static void
+tui_set_tab_width_command (char *arg, int from_tty)
+{
+  /* Make sure the curses mode is enabled.  */
+  tui_enable ();
+  if (arg != (char *) NULL)
+    {
+      int ts;
+
+      ts = atoi (arg);
+      if (ts > 0)
+	tui_set_default_tab_len (ts);
+      else
+	warning ("Tab widths greater than 0 must be specified.\n");
+    }
+}
+
+
+/* Set the height of the specified window.   */
+static void
+tui_set_win_height (char *arg, int from_tty)
+{
+  /* Make sure the curses mode is enabled.  */
+  tui_enable ();
+  if (arg != (char *) NULL)
+    {
+      char *buf = xstrdup (arg);
+      char *buf_ptr = buf;
+      char *wname = (char *) NULL;
+      int new_height, i;
+      struct tui_win_info * win_info;
+
+      wname = buf_ptr;
+      buf_ptr = strchr (buf_ptr, ' ');
+      if (buf_ptr != (char *) NULL)
+	{
+	  *buf_ptr = (char) 0;
+
+	  /*
+	     ** Validate the window name
+	   */
+	  for (i = 0; i < strlen (wname); i++)
+	    wname[i] = toupper (wname[i]);
+	  win_info = tui_partial_win_by_name (wname);
+
+	  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
+	    {
+	      /* Process the size */
+	      while (*(++buf_ptr) == ' ')
+		;
+
+	      if (*buf_ptr != (char) 0)
+		{
+		  int negate = FALSE;
+		  int fixed_size = TRUE;
+		  int input_no;;
+
+		  if (*buf_ptr == '+' || *buf_ptr == '-')
+		    {
+		      if (*buf_ptr == '-')
+			negate = TRUE;
+		      fixed_size = FALSE;
+		      buf_ptr++;
+		    }
+		  input_no = atoi (buf_ptr);
+		  if (input_no > 0)
+		    {
+		      if (negate)
+			input_no *= (-1);
+		      if (fixed_size)
+			new_height = input_no;
+		      else
+			new_height = win_info->generic.height + input_no;
+		      /*
+		         ** Now change the window's height, and adjust all
+		         ** other windows around it
+		       */
+		      if (tui_adjust_win_heights (win_info,
+						new_height) == TUI_FAILURE)
+			warning ("Invalid window height specified.\n%s",
+				 WIN_HEIGHT_USAGE);
+		      else
+                        tui_update_gdb_sizes ();
+		    }
+		  else
+		    warning ("Invalid window height specified.\n%s",
+			     WIN_HEIGHT_USAGE);
+		}
+	    }
+	}
+      else
+	printf_filtered (WIN_HEIGHT_USAGE);
+
+      if (buf != (char *) NULL)
+	xfree (buf);
+    }
+  else
+    printf_filtered (WIN_HEIGHT_USAGE);
+}
+
+/* Set the height of the specified window, with va_list.    */
+static void
+tui_set_win_height_command (char *arg, int from_tty)
+{
+  /* Make sure the curses mode is enabled.  */
+  tui_enable ();
+  tui_set_win_height (arg, from_tty);
+}
+
+
+/* XDB Compatibility command for setting the window height.  This will
+   increase or decrease the command window by the specified amount.  */
+static void
+tui_xdb_set_win_height (char *arg, int from_tty)
+{
+  /* Make sure the curses mode is enabled.  */
+  tui_enable ();
+  if (arg != (char *) NULL)
+    {
+      int input_no = atoi (arg);
+
+      if (input_no > 0)
+	{			/* Add 1 for the locator */
+	  int new_height = tui_term_height () - (input_no + 1);
+
+	  if (!new_height_ok (tui_win_list[CMD_WIN], new_height) ||
+	      tui_adjust_win_heights (tui_win_list[CMD_WIN],
+				    new_height) == TUI_FAILURE)
+	    warning ("Invalid window height specified.\n%s",
+		     XDBWIN_HEIGHT_USAGE);
+	}
+      else
+	warning ("Invalid window height specified.\n%s",
+		 XDBWIN_HEIGHT_USAGE);
+    }
+  else
+    warning ("Invalid window height specified.\n%s", XDBWIN_HEIGHT_USAGE);
+}
+
+/* Set the height of the specified window, with va_list.  */
+static void
+tui_xdb_set_win_height_command (char *arg, int from_tty)
+{
+  tui_xdb_set_win_height (arg, from_tty);
+}
+
+
+/* Function to adjust all window heights around the primary.   */
+static enum tui_status
+tui_adjust_win_heights (struct tui_win_info * primary_win_info, int new_height)
+{
+  enum tui_status status = TUI_FAILURE;
+
+  if (new_height_ok (primary_win_info, new_height))
+    {
+      status = TUI_SUCCESS;
+      if (new_height != primary_win_info->generic.height)
+	{
+	  int diff;
+	  struct tui_win_info * win_info;
+	  struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
+	  enum tui_layout_type cur_layout = tui_current_layout ();
+
+	  diff = (new_height - primary_win_info->generic.height) * (-1);
+	  if (cur_layout == SRC_COMMAND || cur_layout == DISASSEM_COMMAND)
+	    {
+	      struct tui_win_info * src_win_info;
+
+	      make_invisible_and_set_new_height (primary_win_info, new_height);
+	      if (primary_win_info->generic.type == CMD_WIN)
+		{
+		  win_info = (struct tui_win_info *) (tui_source_windows ())->list[0];
+		  src_win_info = win_info;
+		}
+	      else
+		{
+		  win_info = tui_win_list[CMD_WIN];
+		  src_win_info = primary_win_info;
+		}
+	      make_invisible_and_set_new_height (win_info,
+					     win_info->generic.height + diff);
+	      TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
+	      make_visible_with_new_height (win_info);
+	      make_visible_with_new_height (primary_win_info);
+	      if (src_win_info->generic.content_size <= 0)
+		tui_erase_source_content (src_win_info, EMPTY_SOURCE_PROMPT);
+	    }
+	  else
+	    {
+	      struct tui_win_info *first_win;
+	      struct tui_win_info *second_win;
+
+	      if (cur_layout == SRC_DISASSEM_COMMAND)
+		{
+		  first_win = TUI_SRC_WIN;
+		  second_win = TUI_DISASM_WIN;
+		}
+	      else
+		{
+		  first_win = TUI_DATA_WIN;
+		  second_win = (struct tui_win_info *) (tui_source_windows ())->list[0];
+		}
+	      if (primary_win_info == TUI_CMD_WIN)
+		{		/*
+				   ** Split the change in height accross the 1st & 2nd windows
+				   ** adjusting them as well.
+				 */
+		  int first_split_diff = diff / 2;	/* subtract the locator */
+		  int second_split_diff = first_split_diff;
+
+		  if (diff % 2)
+		    {
+		      if (first_win->generic.height >
+			  second_win->generic.height)
+			if (diff < 0)
+			  first_split_diff--;
+			else
+			  first_split_diff++;
+		      else
+			{
+			  if (diff < 0)
+			    second_split_diff--;
+			  else
+			    second_split_diff++;
+			}
+		    }
+		  /* make sure that the minimum hieghts are honored */
+		  while ((first_win->generic.height + first_split_diff) < 3)
+		    {
+		      first_split_diff++;
+		      second_split_diff--;
+		    }
+		  while ((second_win->generic.height + second_split_diff) < 3)
+		    {
+		      second_split_diff++;
+		      first_split_diff--;
+		    }
+		  make_invisible_and_set_new_height (
+						  first_win,
+				 first_win->generic.height + first_split_diff);
+		  second_win->generic.origin.y = first_win->generic.height - 1;
+		  make_invisible_and_set_new_height (
+		    second_win, second_win->generic.height + second_split_diff);
+		  TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
+		  make_invisible_and_set_new_height (TUI_CMD_WIN, new_height);
+		}
+	      else
+		{
+		  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 ((TUI_CMD_WIN->generic.height + diff) < 1)
+			{
+			  int i;
+			  for (i = TUI_CMD_WIN->generic.height + diff;
+			       (i < 1); i++)
+			    if (primary_win_info == first_win)
+			      second_win->generic.height--;
+			    else
+			      first_win->generic.height--;
+			}
+		    }
+		  if (primary_win_info == first_win)
+		    make_invisible_and_set_new_height (first_win, new_height);
+		  else
+		    make_invisible_and_set_new_height (
+						    first_win,
+						  first_win->generic.height);
+		  second_win->generic.origin.y = first_win->generic.height - 1;
+		  if (primary_win_info == second_win)
+		    make_invisible_and_set_new_height (second_win, new_height);
+		  else
+		    make_invisible_and_set_new_height (
+				      second_win, second_win->generic.height);
+		  TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
+		  if ((TUI_CMD_WIN->generic.height + diff) < 1)
+		    make_invisible_and_set_new_height (TUI_CMD_WIN, 1);
+		  else
+		    make_invisible_and_set_new_height (
+				     TUI_CMD_WIN, TUI_CMD_WIN->generic.height + diff);
+		}
+	      make_visible_with_new_height (TUI_CMD_WIN);
+	      make_visible_with_new_height (second_win);
+	      make_visible_with_new_height (first_win);
+	      if (first_win->generic.content_size <= 0)
+		tui_erase_source_content (first_win, EMPTY_SOURCE_PROMPT);
+	      if (second_win->generic.content_size <= 0)
+		tui_erase_source_content (second_win, EMPTY_SOURCE_PROMPT);
+	    }
+	}
+    }
+
+  return status;
+}
+
+
+/* Function make the target window (and auxillary windows associated
+   with the targer) invisible, and set the new height and location.  */
+static void
+make_invisible_and_set_new_height (struct tui_win_info * win_info, int height)
+{
+  int i;
+  struct tui_gen_win_info * gen_win_info;
+
+  tui_make_invisible (&win_info->generic);
+  win_info->generic.height = height;
+  if (height > 1)
+    win_info->generic.viewport_height = height - 1;
+  else
+    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 win_info */
+  switch (win_info->generic.type)
+    {
+    case SRC_WIN:
+    case DISASSEM_WIN:
+      gen_win_info = win_info->detail.source_info.execution_info;
+      tui_make_invisible (gen_win_info);
+      gen_win_info->height = height;
+      gen_win_info->origin.y = win_info->generic.origin.y;
+      if (height > 1)
+	gen_win_info->viewport_height = height - 1;
+      else
+	gen_win_info->viewport_height = height;
+      if (win_info != TUI_CMD_WIN)
+	gen_win_info->viewport_height--;
+
+      if (tui_win_has_locator (win_info))
+	{
+	  gen_win_info = tui_locator_win_info_ptr ();
+	  tui_make_invisible (gen_win_info);
+	  gen_win_info->origin.y = win_info->generic.origin.y + height;
+	}
+      break;
+    case DATA_WIN:
+      /* delete all data item windows */
+      for (i = 0; i < win_info->generic.content_size; i++)
+	{
+	  gen_win_info = (struct tui_gen_win_info *) & ((struct tui_win_element *)
+		      win_info->generic.content[i])->which_element.data_window;
+	  tui_delete_win (gen_win_info->handle);
+	  gen_win_info->handle = (WINDOW *) NULL;
+	}
+      break;
+    default:
+      break;
+    }
+}
+
+
+/* Function to make the windows with new heights visible.  This means
+   re-creating the windows' content since the window had to be
+   destroyed to be made invisible.  */
+static void
+make_visible_with_new_height (struct tui_win_info * win_info)
+{
+  struct symtab *s;
+
+  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 (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 line_or_addr;
+	  struct symtab_and_line cursal
+	    = get_current_source_symtab_and_line ();
+
+	  if (win_info->generic.type == SRC_WIN)
+	    line_or_addr.line_no =
+	      win_info->detail.source_info.start_line_or_addr.line_no;
+	  else
+	    line_or_addr.addr =
+	      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, line_or_addr, TRUE);
+	}
+      else if (deprecated_selected_frame != (struct frame_info *) NULL)
+	{
+	  union tui_line_or_address line;
+	  struct symtab_and_line cursal = get_current_source_symtab_and_line ();
+
+
+	  s = find_pc_symtab (get_frame_pc (deprecated_selected_frame));
+	  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 (win_info, s, line, TRUE);
+	}
+      if (tui_win_has_locator (win_info))
+	{
+	  tui_make_visible (tui_locator_win_info_ptr ());
+	  tui_show_locator_content ();
+	}
+      break;
+    case DATA_WIN:
+      tui_display_all_data ();
+      break;
+    case CMD_WIN:
+      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;
+    }
+}
+
+
+static int
+new_height_ok (struct tui_win_info * primary_win_info, int new_height)
+{
+  int ok = (new_height < tui_term_height ());
+
+  if (ok)
+    {
+      int diff;
+      enum tui_layout_type cur_layout = tui_current_layout ();
+
+      diff = (new_height - primary_win_info->generic.height) * (-1);
+      if (cur_layout == SRC_COMMAND || cur_layout == DISASSEM_COMMAND)
+	{
+	  ok = ((primary_win_info->generic.type == CMD_WIN &&
+		 new_height <= (tui_term_height () - 4) &&
+		 new_height >= MIN_CMD_WIN_HEIGHT) ||
+		(primary_win_info->generic.type != CMD_WIN &&
+		 new_height <= (tui_term_height () - 2) &&
+		 new_height >= MIN_WIN_HEIGHT));
+	  if (ok)
+	    {			/* check the total height */
+	      struct tui_win_info * win_info;
+
+	      if (primary_win_info == TUI_CMD_WIN)
+		win_info = (struct tui_win_info *) (tui_source_windows ())->list[0];
+	      else
+		win_info = TUI_CMD_WIN;
+	      ok = ((new_height +
+		     (win_info->generic.height + diff)) <= tui_term_height ());
+	    }
+	}
+      else
+	{
+	  int cur_total_height, total_height, min_height = 0;
+	  struct tui_win_info *first_win;
+	  struct tui_win_info *second_win;
+
+	  if (cur_layout == SRC_DISASSEM_COMMAND)
+	    {
+	      first_win = TUI_SRC_WIN;
+	      second_win = TUI_DISASM_WIN;
+	    }
+	  else
+	    {
+	      first_win = TUI_DATA_WIN;
+	      second_win = (struct tui_win_info *) (tui_source_windows ())->list[0];
+	    }
+	  /*
+	     ** We could simply add all the heights to obtain the same result
+	     ** but below is more explicit since we subtract 1 for the
+	     ** line that the first and second windows share, and add one
+	     ** for the locator.
+	   */
+	  total_height = cur_total_height =
+	    (first_win->generic.height + second_win->generic.height - 1)
+	    + TUI_CMD_WIN->generic.height + 1 /*locator */ ;
+	  if (primary_win_info == TUI_CMD_WIN)
+	    {
+	      /* locator included since first & second win share a line */
+	      ok = ((first_win->generic.height +
+		     second_win->generic.height + diff) >=
+		    (MIN_WIN_HEIGHT * 2) &&
+		    new_height >= MIN_CMD_WIN_HEIGHT);
+	      if (ok)
+		{
+		  total_height = new_height + (first_win->generic.height +
+					  second_win->generic.height + diff);
+		  min_height = MIN_CMD_WIN_HEIGHT;
+		}
+	    }
+	  else
+	    {
+	      min_height = MIN_WIN_HEIGHT;
+	      /*
+	         ** First see if we can increase/decrease the command
+	         ** window.  And make sure that the command window is
+	         ** at least 1 line
+	       */
+	      ok = ((TUI_CMD_WIN->generic.height + diff) > 0);
+	      if (!ok)
+		{		/*
+				   ** Looks like we have to increase/decrease one of
+				   ** the other windows
+				 */
+		  if (primary_win_info == first_win)
+		    ok = (second_win->generic.height + diff) >= min_height;
+		  else
+		    ok = (first_win->generic.height + diff) >= min_height;
+		}
+	      if (ok)
+		{
+		  if (primary_win_info == first_win)
+		    total_height = new_height +
+		      second_win->generic.height +
+		      TUI_CMD_WIN->generic.height + diff;
+		  else
+		    total_height = new_height +
+		      first_win->generic.height +
+		      TUI_CMD_WIN->generic.height + diff;
+		}
+	    }
+	  /*
+	     ** Now make sure that the proposed total height doesn't exceed
+	     ** the old total height.
+	   */
+	  if (ok)
+	    ok = (new_height >= min_height && total_height <= cur_total_height);
+	}
+    }
+
+  return ok;
+}
+
+
+static void
+parse_scrolling_args (char *arg, struct tui_win_info * * win_to_scroll,
+		      int *num_to_scroll)
+{
+  if (num_to_scroll)
+    *num_to_scroll = 0;
+  *win_to_scroll = tui_win_with_focus ();
+
+  /*
+     ** First set up the default window to scroll, in case there is no
+     ** window name arg
+   */
+  if (arg != (char *) NULL)
+    {
+      char *buf, *buf_ptr;
+
+      /* process the number of lines to scroll */
+      buf = buf_ptr = xstrdup (arg);
+      if (isdigit (*buf_ptr))
+	{
+	  char *num_str;
+
+	  num_str = buf_ptr;
+	  buf_ptr = strchr (buf_ptr, ' ');
+	  if (buf_ptr != (char *) NULL)
+	    {
+	      *buf_ptr = (char) 0;
+	      if (num_to_scroll)
+		*num_to_scroll = atoi (num_str);
+	      buf_ptr++;
+	    }
+	  else if (num_to_scroll)
+	    *num_to_scroll = atoi (num_str);
+	}
+
+      /* process the window name if one is specified */
+      if (buf_ptr != (char *) NULL)
+	{
+	  char *wname;
+	  int i;
+
+	  if (*buf_ptr == ' ')
+	    while (*(++buf_ptr) == ' ')
+	      ;
+
+	  if (*buf_ptr != (char) 0)
+	    wname = buf_ptr;
+	  else
+	    wname = "?";
+	  
+	  /* Validate the window name */
+	  for (i = 0; i < strlen (wname); i++)
+	    wname[i] = toupper (wname[i]);
+	  *win_to_scroll = tui_partial_win_by_name (wname);
+
+	  if (*win_to_scroll == (struct tui_win_info *) NULL ||
+	      !(*win_to_scroll)->generic.is_visible)
+	    warning ("Invalid window specified. \n\
+The window name specified must be valid and visible.\n");
+	  else if (*win_to_scroll == TUI_CMD_WIN)
+	    *win_to_scroll = (struct tui_win_info *) (tui_source_windows ())->list[0];
+	}
+      xfree (buf);
+    }
+}
diff --git a/gdb/tui/tuiWin.h b/gdb/tui/tui-win.h
index bc260804888..1e9b86f441c 100644
--- a/gdb/tui/tuiWin.h
+++ b/gdb/tui/tui-win.h
@@ -1,5 +1,8 @@
 /* TUI window generic functions.
-   Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+
+   Copyright 1998, 1999, 2000, 2001, 2002, 2004 Free Software
+   Foundation, Inc.
+
    Contributed by Hewlett-Packard Company.
 
    This file is part of GDB.
@@ -19,27 +22,22 @@
    Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
-#ifndef _TUI_WIN_H
-#define _TUI_WIN_H
+#ifndef TUI_WIN_H
+#define TUI_WIN_H
 
-/*****************************************
-** TYPE DEFINITIONS                        **
-******************************************/
+#include "tui/tui-data.h"
 
+struct tui_win_info;
 
-
-/*****************************************
-** PUBLIC FUNCTION EXTERNAL DECLS        **
-******************************************/
-extern void tuiScrollForward (TuiWinInfoPtr, int);
-extern void tuiScrollBackward (TuiWinInfoPtr, int);
-extern void tuiScrollLeft (TuiWinInfoPtr, int);
-extern void tuiScrollRight (TuiWinInfoPtr, int);
-extern void tui_scroll (TuiScrollDirection, TuiWinInfoPtr, int);
-extern void tuiSetWinFocusTo (TuiWinInfoPtr);
-extern void tuiResizeAll (void);
-extern void tuiRefreshAll (void);
-extern void tuiSigwinchHandler (int);
+extern void tui_scroll_forward (struct tui_win_info *, int);
+extern void tui_scroll_backward (struct tui_win_info *, int);
+extern void tui_scroll_left (struct tui_win_info *, int);
+extern void tui_scroll_right (struct tui_win_info *, int);
+extern void tui_scroll (enum tui_scroll_direction, struct tui_win_info *, int);
+extern void tui_set_win_focus_to (struct tui_win_info *);
+extern void tui_resize_all (void);
+extern void tui_refresh_all_win (void);
+extern void tui_sigwinch_handler (int);
 
 extern chtype tui_border_ulcorner;
 extern chtype tui_border_urcorner;
@@ -50,10 +48,12 @@ extern chtype tui_border_hline;
 extern int tui_border_attrs;
 extern int tui_active_border_attrs;
 
-extern int tui_update_variables ();
+extern int tui_update_variables (void);
 
 /* Update gdb's knowledge of the terminal size.  */
 extern void tui_update_gdb_sizes (void);
 
+/* Create or get the TUI command list.  */
+struct cmd_list_element **tui_get_cmd_list ();
+
 #endif
-/*_TUI_WIN_H*/
diff --git a/gdb/tui/tui-windata.c b/gdb/tui/tui-windata.c
new file mode 100644
index 00000000000..3c98cf60d68
--- /dev/null
+++ b/gdb/tui/tui-windata.c
@@ -0,0 +1,304 @@
+/* Data/register window display.
+
+   Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
+   Foundation, Inc.
+
+   Contributed by Hewlett-Packard Company.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "tui/tui.h"
+#include "tui/tui-data.h"
+#include "tui/tui-wingeneral.h"
+#include "tui/tui-regs.h"
+
+#include "gdb_string.h"
+#include "gdb_curses.h"
+
+
+/*****************************************
+** STATIC LOCAL FUNCTIONS FORWARD DECLS    **
+******************************************/
+
+
+
+/*****************************************
+** PUBLIC FUNCTIONS                        **
+******************************************/
+
+
+/* Answer the index first element displayed.  If none are displayed,
+   then return (-1).  */
+int
+tui_first_data_item_displayed (void)
+{
+  int element_no = (-1);
+  int i;
+
+  for (i = 0; (i < TUI_DATA_WIN->generic.content_size && element_no < 0); i++)
+    {
+      struct tui_gen_win_info * data_item_win;
+
+      data_item_win = &((tui_win_content)
+		      TUI_DATA_WIN->generic.content)[i]->which_element.data_window;
+      if (data_item_win->handle != (WINDOW *) NULL && data_item_win->is_visible)
+	element_no = i;
+    }
+
+  return element_no;
+}
+
+
+/* Answer the index of the first element in line_no.  If line_no is
+   past the data area (-1) is returned.  */
+int
+tui_first_data_element_no_in_line (int line_no)
+{
+  int first_element_no = (-1);
+
+  /*
+     ** First see if there is a register on line_no, and if so, set the
+     ** first element number
+   */
+  if ((first_element_no = tui_first_reg_element_no_inline (line_no)) == -1)
+    {				/*
+				   ** Looking at the general data, the 1st element on line_no
+				 */
+    }
+
+  return first_element_no;
+}
+
+
+/* Function to delete all the item windows in the data window.  This
+   is usually done when the data window is scrolled.  */
+void
+tui_delete_data_content_windows (void)
+{
+  int i;
+  struct tui_gen_win_info * data_item_win_ptr;
+
+  for (i = 0; (i < TUI_DATA_WIN->generic.content_size); i++)
+    {
+      data_item_win_ptr = &((tui_win_content)
+		      TUI_DATA_WIN->generic.content)[i]->which_element.data_window;
+      tui_delete_win (data_item_win_ptr->handle);
+      data_item_win_ptr->handle = (WINDOW *) NULL;
+      data_item_win_ptr->is_visible = FALSE;
+    }
+}
+
+
+void
+tui_erase_data_content (char *prompt)
+{
+  werase (TUI_DATA_WIN->generic.handle);
+  tui_check_and_display_highlight_if_needed (TUI_DATA_WIN);
+  if (prompt != (char *) NULL)
+    {
+      int half_width = (TUI_DATA_WIN->generic.width - 2) / 2;
+      int x_pos;
+
+      if (strlen (prompt) >= half_width)
+	x_pos = 1;
+      else
+	x_pos = half_width - strlen (prompt);
+      mvwaddstr (TUI_DATA_WIN->generic.handle,
+		 (TUI_DATA_WIN->generic.height / 2),
+		 x_pos,
+		 prompt);
+    }
+  wrefresh (TUI_DATA_WIN->generic.handle);
+}
+
+
+/* This function displays the data that is in the data window's
+   content.  It does not set the content.  */
+void
+tui_display_all_data (void)
+{
+  if (TUI_DATA_WIN->generic.content_size <= 0)
+    tui_erase_data_content (NO_DATA_STRING);
+  else
+    {
+      tui_erase_data_content ((char *) NULL);
+      tui_delete_data_content_windows ();
+      tui_check_and_display_highlight_if_needed (TUI_DATA_WIN);
+      tui_display_registers_from (0);
+      /*
+         ** Then display the other data
+       */
+      if (TUI_DATA_WIN->detail.data_display_info.data_content !=
+	  (tui_win_content) NULL &&
+	  TUI_DATA_WIN->detail.data_display_info.data_content_count > 0)
+	{
+	}
+    }
+}
+
+
+/* Function to display the data starting at line, line_no, in the data
+   window.  */
+void
+tui_display_data_from_line (int line_no)
+{
+  int _line_no = line_no;
+
+  if (line_no < 0)
+    _line_no = 0;
+
+  tui_check_and_display_highlight_if_needed (TUI_DATA_WIN);
+
+  /* there is no general data, force regs to display (if there are any) */
+  if (TUI_DATA_WIN->detail.data_display_info.data_content_count <= 0)
+    tui_display_registers_from_line (_line_no, TRUE);
+  else
+    {
+      int element_no, start_line_no;
+      int regs_last_line = tui_last_regs_line_no ();
+
+
+      /* display regs if we can */
+      if (tui_display_registers_from_line (_line_no, FALSE) < 0)
+	{			/*
+				   ** _line_no is past the regs display, so calc where the
+				   ** start data element is
+				 */
+	  if (regs_last_line < _line_no)
+	    {			/* figure out how many lines each element is to obtain
+				   the start element_no */
+	    }
+	}
+      else
+	{			/*
+				   ** calculate the starting element of the data display, given
+				   ** regs_last_line and how many lines each element is, up to
+				   ** _line_no
+				 */
+	}
+      /* Now display the data , starting at element_no */
+    }
+}
+
+
+/* Display data starting at element element_no.   */
+void
+tui_display_data_from (int element_no, int reuse_windows)
+{
+  int first_line = (-1);
+
+  if (element_no < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
+    first_line = tui_line_from_reg_element_no (element_no);
+  else
+    {				/* calculate the first_line from the element number */
+    }
+
+  if (first_line >= 0)
+    {
+      tui_erase_data_content ((char *) NULL);
+      if (!reuse_windows)
+	tui_delete_data_content_windows ();
+      tui_display_data_from_line (first_line);
+    }
+}
+
+
+/* Function to redisplay the contents of the data window.  */
+void
+tui_refresh_data_win (void)
+{
+  tui_erase_data_content ((char *) NULL);
+  if (TUI_DATA_WIN->generic.content_size > 0)
+    {
+      int first_element = tui_first_data_item_displayed ();
+
+      if (first_element >= 0)	/* re-use existing windows */
+	tui_display_data_from (first_element, TRUE);
+    }
+}
+
+
+/* Function to check the data values and hilite any that have changed.  */
+void
+tui_check_data_values (struct frame_info *frame)
+{
+  tui_check_register_values (frame);
+
+  /* Now check any other data values that there are */
+  if (TUI_DATA_WIN != NULL && TUI_DATA_WIN->generic.is_visible)
+    {
+      int i;
+
+      for (i = 0; TUI_DATA_WIN->detail.data_display_info.data_content_count; i++)
+	{
+#ifdef LATER
+	  tui_data_element_ptr data_element_ptr;
+	  struct tui_gen_win_info * data_item_win_ptr;
+	  Opaque new_value;
+
+	  data_item_ptr = &TUI_DATA_WIN->detail.data_display_info.
+	    data_content[i]->which_element.data_window;
+	  data_element_ptr = &((tui_win_content)
+			     data_item_win_ptr->content)[0]->which_element.data;
+	  if value
+	    has changed (data_element_ptr, frame, &new_value)
+	    {
+	      data_element_ptr->value = new_value;
+	      update the display with the new value, hiliting it.
+	    }
+#endif
+	}
+    }
+}
+
+
+/* Scroll the data window vertically forward or backward.   */
+void
+tui_vertical_data_scroll (enum tui_scroll_direction scroll_direction, int num_to_scroll)
+{
+  int first_element_no;
+  int first_line = (-1);
+
+  first_element_no = tui_first_data_item_displayed ();
+  if (first_element_no < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
+    first_line = tui_line_from_reg_element_no (first_element_no);
+  else
+    {				/* calculate the first line from the element number which is in
+				   ** the general data content
+				 */
+    }
+
+  if (first_line >= 0)
+    {
+      int last_element_no, last_line;
+
+      if (scroll_direction == FORWARD_SCROLL)
+	first_line += num_to_scroll;
+      else
+	first_line -= num_to_scroll;
+      tui_erase_data_content ((char *) NULL);
+      tui_delete_data_content_windows ();
+      tui_display_data_from_line (first_line);
+    }
+}
+
+
+/*****************************************
+** STATIC LOCAL FUNCTIONS               **
+******************************************/
diff --git a/gdb/tui/tuiDisassem.h b/gdb/tui/tui-windata.h
index 67284259bf0..10123a3fad9 100644
--- a/gdb/tui/tuiDisassem.h
+++ b/gdb/tui/tui-windata.h
@@ -1,5 +1,8 @@
-/* Disassembly display.
-   Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+/* Data/register window display.
+
+   Copyright 1998, 1999, 2000, 2001, 2004 Free Software Foundation,
+   Inc.
+
    Contributed by Hewlett-Packard Company.
 
    This file is part of GDB.
@@ -19,23 +22,20 @@
    Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
-#ifndef _TUI_DISASSEM_H
-#define _TUI_DISASSEM_H
-
-/*****************************************
-** TYPE DEFINITIONS                        **
-******************************************/
-
+#ifndef TUI_WINDATA_H
+#define TUI_WINDATA_H
 
+#include "tui/tui-data.h"
 
-/*****************************************
-** PUBLIC FUNCTION EXTERNAL DECLS        **
-******************************************/
-extern TuiStatus tuiSetDisassemContent (CORE_ADDR);
-extern void tuiShowDisassem (CORE_ADDR);
-extern void tuiShowDisassemAndUpdateSource (CORE_ADDR);
-extern void tuiVerticalDisassemScroll (TuiScrollDirection, int);
-extern CORE_ADDR tuiGetBeginAsmAddress (void);
+extern void tui_erase_data_content (char *);
+extern void tui_display_all_data (void);
+extern void tui_check_data_values (struct frame_info *);
+extern void tui_display_data_from_line (int);
+extern int tui_first_data_item_displayed (void);
+extern int tui_first_data_element_no_in_line (int);
+extern void tui_delete_data_content_windows (void);
+extern void tui_refresh_data_win (void);
+extern void tui_display_data_from (int, int);
+extern void tui_vertical_data_scroll (enum tui_scroll_direction, int);
 
 #endif
-/*_TUI_DISASSEM_H*/
diff --git a/gdb/tui/tui-wingeneral.c b/gdb/tui/tui-wingeneral.c
new file mode 100644
index 00000000000..3dc62d5d508
--- /dev/null
+++ b/gdb/tui/tui-wingeneral.c
@@ -0,0 +1,276 @@
+/* General window behavior.
+
+   Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
+   Inc.
+
+   Contributed by Hewlett-Packard Company.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "tui/tui.h"
+#include "tui/tui-data.h"
+#include "tui/tui-wingeneral.h"
+#include "tui/tui-win.h"
+
+#include "gdb_curses.h"
+
+/***********************
+** PUBLIC FUNCTIONS
+***********************/
+
+/* Refresh the window.   */
+void
+tui_refresh_win (struct tui_gen_win_info * win_info)
+{
+  if (win_info->type == DATA_WIN && win_info->content_size > 0)
+    {
+      int i;
+
+      for (i = 0; (i < win_info->content_size); i++)
+	{
+	  struct tui_gen_win_info * data_item_win_ptr;
+
+	  data_item_win_ptr = &((tui_win_content)
+			     win_info->content)[i]->which_element.data_window;
+	  if (data_item_win_ptr != NULL
+	      && data_item_win_ptr->handle != (WINDOW *) NULL)
+	    wrefresh (data_item_win_ptr->handle);
+	}
+    }
+  else if (win_info->type == CMD_WIN)
+    {
+      /* Do nothing */
+    }
+  else
+    {
+      if (win_info->handle != (WINDOW *) NULL)
+	wrefresh (win_info->handle);
+    }
+
+  return;
+}
+
+
+/* Function to delete the curses window, checking for NULL.   */
+void
+tui_delete_win (WINDOW * window)
+{
+  if (window != (WINDOW *) NULL)
+    delwin (window);
+
+  return;
+}
+
+
+/* Draw a border arround the window.  */
+void
+box_win (struct tui_gen_win_info * win_info, int highlight_flag)
+{
+  if (win_info && win_info->handle)
+    {
+      WINDOW *win;
+      int attrs;
+
+      win = win_info->handle;
+      if (highlight_flag == HILITE)
+        attrs = tui_active_border_attrs;
+      else
+        attrs = tui_border_attrs;
+
+      wattron (win, attrs);
+      wborder (win, tui_border_vline, tui_border_vline,
+               tui_border_hline, tui_border_hline,
+               tui_border_ulcorner, tui_border_urcorner,
+               tui_border_llcorner, tui_border_lrcorner);
+      if (win_info->title)
+        mvwaddstr (win, 0, 3, win_info->title);
+      wattroff (win, attrs);
+    }
+}
+
+
+void
+tui_unhighlight_win (struct tui_win_info * win_info)
+{
+  if (win_info != NULL && win_info->generic.handle != (WINDOW *) NULL)
+    {
+      box_win ((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 * win_info)
+{
+  if (win_info != NULL
+      && win_info->can_highlight
+      && win_info->generic.handle != (WINDOW *) NULL)
+    {
+      box_win ((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 * win_info)
+{
+  if (win_info != NULL && win_info->generic.type != CMD_WIN)
+    {
+      if (win_info->is_highlighted)
+	tui_highlight_win (win_info);
+      else
+	tui_unhighlight_win (win_info);
+
+    }
+  return;
+}
+
+
+void
+tui_make_window (struct tui_gen_win_info * win_info, int box_it)
+{
+  WINDOW *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 (box_it == BOX_WINDOW)
+	box_win (win_info, NO_HILITE);
+      win_info->is_visible = TRUE;
+      scrollok (handle, TRUE);
+    }
+}
+
+
+/* We can't really make windows visible, or invisible.  So we have to
+   delete the entire window when making it visible, and create it
+   again when making it visible.  */
+static void
+make_visible (struct tui_gen_win_info *win_info, int visible)
+{
+  /* Don't tear down/recreate command window */
+  if (win_info->type == CMD_WIN)
+    return;
+
+  if (visible)
+    {
+      if (!win_info->is_visible)
+	{
+	  tui_make_window (win_info,
+			   (win_info->type != CMD_WIN
+			    && !tui_win_is_auxillary (win_info->type)));
+	  win_info->is_visible = TRUE;
+	}
+    }
+  else if (!visible &&
+	   win_info->is_visible && win_info->handle != (WINDOW *) NULL)
+    {
+      win_info->is_visible = FALSE;
+      tui_delete_win (win_info->handle);
+      win_info->handle = (WINDOW *) NULL;
+    }
+
+  return;
+}
+
+void
+tui_make_visible (struct tui_gen_win_info *win_info)
+{
+  make_visible (win_info, 1);
+}
+
+void
+tui_make_invisible (struct tui_gen_win_info *win_info)
+{
+  make_visible (win_info, 0);
+}
+
+
+/* Makes all windows invisible (except the command and locator windows).   */
+static void
+make_all_visible (int visible)
+{
+  int i;
+
+  for (i = 0; i < MAX_MAJOR_WINDOWS; i++)
+    {
+      if (tui_win_list[i] != NULL
+	  && ((tui_win_list[i])->generic.type) != CMD_WIN)
+	{
+	  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 *) tui_win_list[i], visible);
+	}
+    }
+
+  return;
+}
+
+void
+tui_make_all_visible (void)
+{
+  make_all_visible (1);
+}
+
+void
+tui_make_all_invisible (void)
+{
+  make_all_visible (0);
+}
+
+/* Function to refresh all the windows currently displayed.  */
+
+void
+tui_refresh_all (struct tui_win_info * * list)
+{
+  enum tui_win_type type;
+  struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
+
+  for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
+    {
+      if (list[type] && list[type]->generic.is_visible)
+	{
+	  if (type == SRC_WIN || type == DISASSEM_WIN)
+	    {
+	      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->is_visible)
+    {
+      touchwin (locator->handle);
+      tui_refresh_win (locator);
+    }
+}
+
+
+/*********************************
+** Local Static Functions
+*********************************/
diff --git a/gdb/tui/tui-wingeneral.h b/gdb/tui/tui-wingeneral.h
new file mode 100644
index 00000000000..306d79402c0
--- /dev/null
+++ b/gdb/tui/tui-wingeneral.h
@@ -0,0 +1,45 @@
+/* General window behavior.
+
+   Copyright 1998, 1999, 2000, 2001, 2002, 2004 Free Software
+   Foundation, Inc.
+
+   Contributed by Hewlett-Packard Company.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#ifndef TUI_WINGENERAL_H
+#define TUI_WINGENERAL_H
+
+struct tui_win_info;
+struct tui_gen_win_info;
+
+extern void tui_unhighlight_win (struct tui_win_info *);
+extern void tui_make_visible (struct tui_gen_win_info *);
+extern void tui_make_invisible (struct tui_gen_win_info *);
+extern void tui_make_all_visible (void);
+extern void tui_make_all_invisible (void);
+extern void tui_make_window (struct tui_gen_win_info *, int);
+extern struct tui_win_info *tui_copy_win (struct tui_win_info *);
+extern void tui_box_win (struct tui_gen_win_info *, int);
+extern void tui_highlight_win (struct tui_win_info *);
+extern void tui_check_and_display_highlight_if_needed (struct tui_win_info *);
+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 *);
+
+#endif
diff --git a/gdb/tui/tui-winsource.c b/gdb/tui/tui-winsource.c
new file mode 100644
index 00000000000..de19d25c239
--- /dev/null
+++ b/gdb/tui/tui-winsource.c
@@ -0,0 +1,654 @@
+/* TUI display source/assembly window.
+
+   Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
+   Foundation, Inc.
+
+   Contributed by Hewlett-Packard Company.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include <ctype.h>
+#include "symtab.h"
+#include "frame.h"
+#include "breakpoint.h"
+#include "value.h"
+#include "source.h"
+
+#include "tui/tui.h"
+#include "tui/tui-data.h"
+#include "tui/tui-stack.h"
+#include "tui/tui-win.h"
+#include "tui/tui-wingeneral.h"
+#include "tui/tui-winsource.h"
+#include "tui/tui-source.h"
+#include "tui/tui-disasm.h"
+
+#include "gdb_string.h"
+#include "gdb_curses.h"
+
+/* Function to display the "main" routine.  */
+void
+tui_display_main (void)
+{
+  if ((tui_source_windows ())->count > 0)
+    {
+      CORE_ADDR addr;
+
+      addr = tui_get_begin_asm_address ();
+      if (addr != (CORE_ADDR) 0)
+	{
+	  struct symtab_and_line sal;
+
+	  tui_update_source_windows_with_addr (addr);
+	  sal = find_pc_line (addr, 0);
+          if (sal.symtab)
+             tui_update_locator_filename (sal.symtab->filename);
+          else
+             tui_update_locator_filename ("??");
+	}
+    }
+}
+
+
+
+/* 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 * win_info, struct symtab *s,
+			  union tui_line_or_address line_or_addr, int noerror)
+{
+  win_info->detail.source_info.horizontal_offset = 0;
+  tui_update_source_window_as_is (win_info, s, line_or_addr, noerror);
+
+  return;
+}
+
+
+/* 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 * win_info, struct symtab *s,
+				union tui_line_or_address line_or_addr, int noerror)
+{
+  enum tui_status ret;
+
+  if (win_info->generic.type == SRC_WIN)
+    ret = tui_set_source_content (s, line_or_addr.line_no, noerror);
+  else
+    ret = tui_set_disassem_content (line_or_addr.addr);
+
+  if (ret == TUI_FAILURE)
+    {
+      tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
+      tui_clear_exec_info_content (win_info);
+    }
+  else
+    {
+      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 = line_or_addr.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 () == TUI_DISASM_WIN &&
+	      tui_current_layout () != SRC_DISASSEM_COMMAND)
+	    tui_set_win_focus_to (TUI_SRC_WIN);
+	}
+    }
+
+
+  return;
+}
+
+
+/* Function to ensure that the source and/or disassemly windows
+   reflect the input address.  */
+void
+tui_update_source_windows_with_addr (CORE_ADDR addr)
+{
+  if (addr != 0)
+    {
+      struct symtab_and_line sal;
+      union tui_line_or_address l;
+      
+      switch (tui_current_layout ())
+	{
+	case DISASSEM_COMMAND:
+	case DISASSEM_DATA_COMMAND:
+	  tui_show_disassem (addr);
+	  break;
+	case SRC_DISASSEM_COMMAND:
+	  tui_show_disassem_and_update_source (addr);
+	  break;
+	default:
+	  sal = find_pc_line (addr, 0);
+	  l.line_no = sal.line;
+	  tui_show_symtab_source (sal.symtab, l, FALSE);
+	  break;
+	}
+    }
+  else
+    {
+      int i;
+
+      for (i = 0; i < (tui_source_windows ())->count; i++)
+	{
+	  struct tui_win_info * win_info = (struct tui_win_info *) (tui_source_windows ())->list[i];
+
+	  tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
+	  tui_clear_exec_info_content (win_info);
+	}
+    }
+}
+
+/* Function to ensure that the source and/or disassemly windows
+   reflect the input address.  */
+void
+tui_update_source_windows_with_line (struct symtab *s, int line)
+{
+  CORE_ADDR pc;
+  union tui_line_or_address l;
+  
+  switch (tui_current_layout ())
+    {
+    case DISASSEM_COMMAND:
+    case DISASSEM_DATA_COMMAND:
+      find_line_pc (s, line, &pc);
+      tui_update_source_windows_with_addr (pc);
+      break;
+    default:
+      l.line_no = line;
+      tui_show_symtab_source (s, l, FALSE);
+      if (tui_current_layout () == SRC_DISASSEM_COMMAND)
+	{
+	  find_line_pc (s, line, &pc);
+	  tui_show_disassem (pc);
+	}
+      break;
+    }
+
+  return;
+}
+
+void
+tui_clear_source_content (struct tui_win_info * win_info, int display_prompt)
+{
+  if (win_info != NULL)
+    {
+      int i;
+
+      win_info->generic.content_in_use = FALSE;
+      tui_erase_source_content (win_info, display_prompt);
+      for (i = 0; i < win_info->generic.content_size; i++)
+	{
+	  struct tui_win_element * element =
+	  (struct tui_win_element *) win_info->generic.content[i];
+	  element->which_element.source.has_break = FALSE;
+	  element->which_element.source.is_exec_point = FALSE;
+	}
+    }
+}
+
+
+void
+tui_erase_source_content (struct tui_win_info * win_info, int display_prompt)
+{
+  int x_pos;
+  int half_width = (win_info->generic.width - 2) / 2;
+
+  if (win_info->generic.handle != (WINDOW *) NULL)
+    {
+      werase (win_info->generic.handle);
+      tui_check_and_display_highlight_if_needed (win_info);
+      if (display_prompt == EMPTY_SOURCE_PROMPT)
+	{
+	  char *no_src_str;
+
+	  if (win_info->generic.type == SRC_WIN)
+	    no_src_str = NO_SRC_STRING;
+	  else
+	    no_src_str = NO_DISASSEM_STRING;
+	  if (strlen (no_src_str) >= half_width)
+	    x_pos = 1;
+	  else
+	    x_pos = half_width - strlen (no_src_str);
+	  mvwaddstr (win_info->generic.handle,
+		     (win_info->generic.height / 2),
+		     x_pos,
+		     no_src_str);
+
+	  /* elz: added this function call to set the real contents of
+	     the window to what is on the  screen, so that later calls
+	     to refresh, do display
+	     the correct stuff, and not the old image */
+
+	  tui_set_source_content_nil (win_info, no_src_str);
+	}
+      tui_refresh_win (&win_info->generic);
+    }
+}
+
+
+/* Redraw the complete line of a source or disassembly window.  */
+static void
+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 *) win_info->generic.content[lineno - 1];
+  if (line->which_element.source.is_exec_point)
+    wattron (win_info->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 (win_info->generic.handle, y, x);
+  while (x + 1 < win_info->generic.width)
+    {
+      waddch (win_info->generic.handle, ' ');
+      getyx (win_info->generic.handle, y, x);
+    }
+}
+
+void
+tui_show_source_content (struct tui_win_info * win_info)
+{
+  if (win_info->generic.content_size > 0)
+    {
+      int lineno;
+
+      for (lineno = 1; lineno <= win_info->generic.content_size; lineno++)
+        tui_show_source_line (win_info, lineno);
+    }
+  else
+    tui_erase_source_content (win_info, 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 * win_info,
+			      enum tui_scroll_direction direction,
+			      int num_to_scroll)
+{
+  if (win_info->generic.content != NULL)
+    {
+      int offset;
+      struct symtab *s;
+      struct symtab_and_line cursal = get_current_source_symtab_and_line ();
+
+      if (cursal.symtab == (struct symtab *) NULL)
+	s = find_pc_symtab (get_frame_pc (deprecated_selected_frame));
+      else
+	s = cursal.symtab;
+
+      if (direction == LEFT_SCROLL)
+	offset = win_info->detail.source_info.horizontal_offset + num_to_scroll;
+      else
+	{
+	  if ((offset =
+	     win_info->detail.source_info.horizontal_offset - num_to_scroll) < 0)
+	    offset = 0;
+	}
+      win_info->detail.source_info.horizontal_offset = offset;
+      tui_update_source_window_as_is (win_info, s,
+				      ((struct tui_win_element *)
+				       win_info->generic.content[0])->which_element.source.line_or_addr,
+				      FALSE);
+    }
+
+  return;
+}
+
+
+/* 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 * win_info)
+{
+  int changed = 0;
+  int i;
+  tui_win_content content = (tui_win_content) win_info->generic.content;
+
+  i = 0;
+  while (i < win_info->generic.content_size)
+    {
+      int new_state;
+
+      if (content[i]->which_element.source.line_or_addr.addr == l.addr)
+        new_state = TRUE;
+      else
+	new_state = FALSE;
+      if (new_state != content[i]->which_element.source.is_exec_point)
+        {
+          changed++;
+          content[i]->which_element.source.is_exec_point = new_state;
+          tui_show_source_line (win_info, i + 1);
+        }
+      i++;
+    }
+  if (changed)
+    tui_refresh_win (&win_info->generic);
+}
+
+/* Update the execution windows to show the active breakpoints.
+   This is called whenever a breakpoint is inserted, removed or
+   has its state changed.  */
+void
+tui_update_all_breakpoint_info (void)
+{
+  struct tui_list *list = tui_source_windows ();
+  int i;
+
+  for (i = 0; i < list->count; i++)
+    {
+      struct tui_win_info * win = (struct tui_win_info *) list->list[i];
+
+      if (tui_update_breakpoint_info (win, FALSE))
+        {
+          tui_update_exec_info (win);
+        }
+    }
+}
+
+
+/* Scan the source window and the breakpoints to update the
+   has_break information for each line.
+   Returns 1 if something changed and the execution window
+   must be refreshed.  */
+int
+tui_update_breakpoint_info (struct tui_win_info * win, int current_only)
+{
+  int i;
+  int need_refresh = 0;
+  struct tui_source_info * src = &win->detail.source_info;
+
+  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])->which_element.source;
+      if (current_only && !line->is_exec_point)
+         continue;
+
+      /* Scan each breakpoint to see if the current line has something to
+         do with it.  Identify enable/disabled breakpoints as well as
+         those that we already hit.  */
+      mode = 0;
+      for (bp = breakpoint_chain;
+           bp != (struct breakpoint *) NULL;
+           bp = bp->next)
+        {
+          if ((win == TUI_SRC_WIN
+               && bp->source_file
+               && (strcmp (src->filename, bp->source_file) == 0)
+               && 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;
+              else
+                mode |= TUI_BP_ENABLED;
+              if (bp->hit_count)
+                mode |= TUI_BP_HIT;
+              if (bp->cond)
+                mode |= TUI_BP_CONDITIONAL;
+              if (bp->type == bp_hardware_breakpoint)
+                mode |= TUI_BP_HARDWARE;
+            }
+        }
+      if (line->has_break != mode)
+        {
+          line->has_break = mode;
+          need_refresh = 1;
+        }
+    }
+  return need_refresh;
+}
+
+
+/* Function to initialize the content of the execution info window,
+   based upon the input window which is either the source or
+   disassembly window.  */
+enum tui_status
+tui_set_exec_info_content (struct tui_win_info * win_info)
+{
+  enum tui_status ret = TUI_SUCCESS;
+
+  if (win_info->detail.source_info.execution_info != (struct tui_gen_win_info *) NULL)
+    {
+      struct tui_gen_win_info * exec_info_ptr = win_info->detail.source_info.execution_info;
+
+      if (exec_info_ptr->content == NULL)
+	exec_info_ptr->content =
+	  (void **) tui_alloc_content (win_info->generic.height,
+					 exec_info_ptr->type);
+      if (exec_info_ptr->content != NULL)
+	{
+	  int i;
+
+          tui_update_breakpoint_info (win_info, 1);
+	  for (i = 0; i < win_info->generic.content_size; i++)
+	    {
+	      struct tui_win_element * element;
+	      struct tui_win_element * src_element;
+              int mode;
+
+	      element = (struct tui_win_element *) exec_info_ptr->content[i];
+	      src_element = (struct tui_win_element *) win_info->generic.content[i];
+
+              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 = src_element->which_element.source.has_break;
+              if (mode & TUI_BP_HIT)
+                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->which_element.simple_string[TUI_BP_HIT_POS] =
+                  (mode & TUI_BP_HARDWARE) ? 'h' : 'b';
+
+              if (mode & TUI_BP_ENABLED)
+                element->which_element.simple_string[TUI_BP_BREAK_POS] = '+';
+              else if (mode & TUI_BP_DISABLED)
+                element->which_element.simple_string[TUI_BP_BREAK_POS] = '-';
+
+              if (src_element->which_element.source.is_exec_point)
+                element->which_element.simple_string[TUI_EXEC_POS] = '>';
+	    }
+	  exec_info_ptr->content_size = win_info->generic.content_size;
+	}
+      else
+	ret = TUI_FAILURE;
+    }
+
+  return ret;
+}
+
+
+void
+tui_show_exec_info_content (struct tui_win_info * win_info)
+{
+  struct tui_gen_win_info * exec_info = win_info->detail.source_info.execution_info;
+  int cur_line;
+
+  werase (exec_info->handle);
+  tui_refresh_win (exec_info);
+  for (cur_line = 1; (cur_line <= exec_info->content_size); cur_line++)
+    mvwaddstr (exec_info->handle,
+	       cur_line,
+	       0,
+	       ((struct tui_win_element *)
+		exec_info->content[cur_line - 1])->which_element.simple_string);
+  tui_refresh_win (exec_info);
+  exec_info->content_in_use = TRUE;
+}
+
+
+void
+tui_erase_exec_info_content (struct tui_win_info * win_info)
+{
+  struct tui_gen_win_info * exec_info = win_info->detail.source_info.execution_info;
+
+  werase (exec_info->handle);
+  tui_refresh_win (exec_info);
+}
+
+void
+tui_clear_exec_info_content (struct tui_win_info * win_info)
+{
+  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 * win_info)
+{
+  tui_set_exec_info_content (win_info);
+  tui_show_exec_info_content (win_info);
+}
+
+enum tui_status
+tui_alloc_source_buffer (struct tui_win_info *win_info)
+{
+  char *src_line_buf;
+  int i, line_width, max_lines;
+  enum tui_status ret = TUI_FAILURE;
+
+  max_lines = win_info->generic.height;	/* less the highlight box */
+  line_width = win_info->generic.width - 1;
+  /*
+     ** Allocate the buffer for the source lines.  Do this only once since they
+     ** will be re-used for all source displays.  The only other time this will
+     ** be done is when a window's size changes.
+   */
+  if (win_info->generic.content == NULL)
+    {
+      src_line_buf = (char *) xmalloc ((max_lines * line_width) * sizeof (char));
+      if (src_line_buf == (char *) NULL)
+	fputs_unfiltered (
+	   "Unable to Allocate Memory for Source or Disassembly Display.\n",
+			   gdb_stderr);
+      else
+	{
+	  /* allocate the content list */
+	  if ((win_info->generic.content =
+	  (void **) tui_alloc_content (max_lines, SRC_WIN)) == NULL)
+	    {
+	      xfree (src_line_buf);
+	      src_line_buf = (char *) NULL;
+	      fputs_unfiltered (
+				 "Unable to Allocate Memory for Source or Disassembly Display.\n",
+				 gdb_stderr);
+	    }
+	}
+      for (i = 0; i < max_lines; i++)
+	((struct tui_win_element *)
+	 win_info->generic.content[i])->which_element.source.line =
+	  src_line_buf + (line_width * i);
+      ret = TUI_SUCCESS;
+    }
+  else
+    ret = TUI_SUCCESS;
+
+  return ret;
+}
+
+
+/* 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 * win_info,
+		       int check_threshold)
+{
+  int is_displayed = FALSE;
+  int i, threshold;
+
+  if (check_threshold)
+    threshold = SCROLL_THRESHOLD;
+  else
+    threshold = 0;
+  i = 0;
+  while (i < win_info->generic.content_size - threshold && !is_displayed)
+    {
+      is_displayed = (((struct tui_win_element *)
+		      win_info->generic.content[i])->which_element.source.line_or_addr.line_no
+		     == (int) line);
+      i++;
+    }
+
+  return is_displayed;
+}
+
+
+/* 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 * win_info,
+		    int check_threshold)
+{
+  int is_displayed = FALSE;
+  int i, threshold;
+
+  if (check_threshold)
+    threshold = SCROLL_THRESHOLD;
+  else
+    threshold = 0;
+  i = 0;
+  while (i < win_info->generic.content_size - threshold && !is_displayed)
+    {
+      is_displayed = (((struct tui_win_element *)
+		      win_info->generic.content[i])->which_element.source.line_or_addr.addr
+		     == addr);
+      i++;
+    }
+
+  return is_displayed;
+}
+
+
+/*****************************************
+** STATIC LOCAL FUNCTIONS               **
+******************************************/
diff --git a/gdb/tui/tui-winsource.h b/gdb/tui/tui-winsource.h
new file mode 100644
index 00000000000..e64589ba5f2
--- /dev/null
+++ b/gdb/tui/tui-winsource.h
@@ -0,0 +1,73 @@
+/* TUI display source/assembly window.
+
+   Copyright 1998, 1999, 2000, 2001, 2002, 2004 Free Software
+   Foundation, Inc.
+
+   Contributed by Hewlett-Packard Company.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#ifndef TUI_SOURCEWIN_H
+#define TUI_SOURCEWIN_H
+
+#include "tui/tui-data.h"
+
+struct tui_win_info;
+
+/* Update the execution windows to show the active breakpoints.  This
+   is called whenever a breakpoint is inserted, removed or has its
+   state changed.  */
+extern void tui_update_all_breakpoint_info (void);
+
+/* Scan the source window and the breakpoints to update the hasBreak
+   information for each line.  Returns 1 if something changed and the
+   execution window must be refreshed.  */
+extern int tui_update_breakpoint_info (struct tui_win_info * win,
+				       int current_only);
+
+/* Function to display the "main" routine.  */
+extern void tui_display_main (void);
+extern void tui_update_source_window (struct tui_win_info *, struct symtab *,
+				      union tui_line_or_address, int);
+extern void tui_update_source_window_as_is (struct tui_win_info *,
+					    struct symtab *,
+					    union tui_line_or_address, int);
+extern void tui_update_source_windows_with_addr (CORE_ADDR);
+extern void tui_update_source_windows_with_line (struct symtab *, int);
+extern void tui_clear_source_content (struct tui_win_info *, int);
+extern void tui_erase_source_content (struct tui_win_info *, int);
+extern void tui_show_source_content (struct tui_win_info *);
+extern void tui_horizontal_source_scroll (struct tui_win_info *,
+					  enum tui_scroll_direction, int);
+extern enum tui_status tui_set_exec_info_content (struct tui_win_info *);
+extern void tui_show_exec_info_content (struct tui_win_info *);
+extern void tui_erase_exec_info_content (struct tui_win_info *);
+extern void tui_clear_exec_info_content (struct tui_win_info *);
+extern void tui_update_exec_info (struct tui_win_info *);
+
+extern void tui_set_is_exec_point_at (union tui_line_or_address,
+				      struct tui_win_info *);
+extern enum tui_status tui_alloc_source_buffer (struct tui_win_info *);
+extern int tui_line_is_displayed (int, struct tui_win_info *, int);
+extern int tui_addr_is_displayed (CORE_ADDR, struct tui_win_info *, int);
+
+
+/* Constant definitions. */
+#define        SCROLL_THRESHOLD            2	/* threshold for lazy scroll */
+
+#endif
diff --git a/gdb/tui/tui.c b/gdb/tui/tui.c
index 601a5795e2d..d6f344f43d5 100644
--- a/gdb/tui/tui.c
+++ b/gdb/tui/tui.c
@@ -1,7 +1,7 @@
 /* General functions for the WDB TUI.
 
-   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.
 
@@ -22,10 +22,28 @@
    Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
+#include "defs.h"
+#include "gdbcmd.h"
+#include "tui/tui.h"
+#include "tui/tui-hooks.h"
+#include "tui/tui-data.h"
+#include "tui/tui-layout.h"
+#include "tui/tui-io.h"
+#include "tui/tui-regs.h"
+#include "tui/tui-stack.h"
+#include "tui/tui-win.h"
+#include "tui/tui-winsource.h"
+#include "tui/tui-windata.h"
+#include "target.h"
+#include "frame.h"
+#include "breakpoint.h"
+#include "inferior.h"
+#include "symtab.h"
+#include "source.h"
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <ctype.h>
-#include <malloc.h>
 #ifdef HAVE_TERM_H
 #include <term.h>
 #endif
@@ -35,38 +53,19 @@
 #include <termio.h>
 #endif
 #include <setjmp.h>
-#include "defs.h"
-#include "gdbcmd.h"
-#include "tui.h"
-#include "tuiData.h"
-#include "tuiLayout.h"
-#include "tuiIO.h"
-#include "tuiRegs.h"
-#include "tuiStack.h"
-#include "tuiWin.h"
-#include "tuiSourceWin.h"
-#include "tuiDataWin.h"
-#include "readline/readline.h"
-#include "target.h"
-#include "frame.h"
-#include "breakpoint.h"
-#include "inferior.h"
-#include "symtab.h"
-#include "source.h"
 
-#ifdef HAVE_NCURSES_H       
-#include <ncurses.h>
-#else
-#ifdef HAVE_CURSES_H
-#include <curses.h>
-#endif
-#endif
+#include "gdb_curses.h"
+
+/* This redefines CTRL if it is not already defined, so it must come
+   after terminal state releated include files like <term.h> and
+   "gdb_ncurses.h".  */
+#include "readline/readline.h"
 
 /* Tells whether the TUI is active or not.  */
 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
 {
@@ -137,10 +136,10 @@ tui_rl_change_windows (int notused1, int notused2)
 
   if (tui_active)
     {
-      TuiLayoutType new_layout;
-      TuiRegisterDisplayType regs_type = TUI_UNDEFINED_REGS;
+      enum tui_layout_type new_layout;
+      enum tui_register_display_type regs_type = TUI_UNDEFINED_REGS;
 
-      new_layout = currentLayout ();
+      new_layout = tui_current_layout ();
 
       /* Select a new layout to have a rolling layout behavior
 	 with always two windows (except when undefined).  */
@@ -170,7 +169,7 @@ tui_rl_change_windows (int notused1, int notused2)
 	  new_layout = SRC_COMMAND;
 	  break;
 	}
-      tuiSetLayout (new_layout, regs_type);
+      tui_set_layout (new_layout, regs_type);
     }
   return 0;
 }
@@ -185,10 +184,10 @@ tui_rl_delete_other_windows (int notused1, int notused2)
 
   if (tui_active)
     {
-      TuiLayoutType new_layout;
-      TuiRegisterDisplayType regs_type = TUI_UNDEFINED_REGS;
+      enum tui_layout_type new_layout;
+      enum tui_register_display_type regs_type = TUI_UNDEFINED_REGS;
 
-      new_layout = currentLayout ();
+      new_layout = tui_current_layout ();
 
       /* Kill one window.  */
       switch (new_layout)
@@ -205,7 +204,7 @@ tui_rl_delete_other_windows (int notused1, int notused2)
 	  new_layout = DISASSEM_COMMAND;
 	  break;
 	}
-      tuiSetLayout (new_layout, regs_type);
+      tui_set_layout (new_layout, regs_type);
     }
   return 0;
 }
@@ -215,18 +214,18 @@ tui_rl_delete_other_windows (int notused1, int notused2)
 static int
 tui_rl_other_window (int count, int key)
 {
-  TuiWinInfoPtr winInfo;
+  struct tui_win_info * win_info;
 
   if (!tui_active)
     tui_rl_switch_mode (0/*notused*/, 0/*notused*/);
 
-  winInfo = tuiNextWin (tuiWinWithFocus ());
-  if (winInfo)
+  win_info = tui_next_win (tui_win_with_focus ());
+  if (win_info)
     {
-      tuiSetWinFocusTo (winInfo);
-      if (dataWin && dataWin->generic.isVisible)
-        tuiRefreshDataWin ();
-      keypad (cmdWin->generic.handle, (winInfo != cmdWin));
+      tui_set_win_focus_to (win_info);
+      if (TUI_DATA_WIN && TUI_DATA_WIN->generic.is_visible)
+        tui_refresh_data_win ();
+      keypad (TUI_CMD_WIN->generic.handle, (win_info != TUI_CMD_WIN));
     }
   return 0;
 }
@@ -261,7 +260,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 +272,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;
 }
 
@@ -283,11 +282,11 @@ tui_rl_next_keymap (int notused1, int notused2)
    the command window is cleaner.  It will be displayed if
    we temporarily leave the SingleKey mode.  */
 static int
-tui_rl_startup_hook ()
+tui_rl_startup_hook (void)
 {
   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,15 +296,15 @@ 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);
-  tuiShowLocatorContent ();
+  tui_show_locator_content ();
 }
 
 /* Initialize readline and configure the keymap for the switching
    key shortcut.  */
 void
-tui_initialize_readline ()
+tui_initialize_readline (void)
 {
   int i;
   Keymap tui_ctlx_keymap;
@@ -384,15 +383,15 @@ tui_enable (void)
       nl();
       keypad (w, TRUE);
       rl_initialize ();
-      setTermHeightTo (LINES);
-      setTermWidthTo (COLS);
+      tui_set_term_height_to (LINES);
+      tui_set_term_width_to (COLS);
       def_prog_mode ();
 
-      tuiShowFrameInfo (0);
-      tuiSetLayout (SRC_COMMAND, TUI_UNDEFINED_REGS);
-      tuiSetWinFocusTo (srcWin);
-      keypad (cmdWin->generic.handle, TRUE);
-      wrefresh (cmdWin->generic.handle);
+      tui_show_frame_info (0);
+      tui_set_layout (SRC_COMMAND, TUI_UNDEFINED_REGS);
+      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
@@ -413,11 +412,11 @@ tui_enable (void)
 
   tui_active = 1;
   if (deprecated_selected_frame)
-     tuiShowFrameInfo (deprecated_selected_frame);
+     tui_show_frame_info (deprecated_selected_frame);
 
   /* Restore TUI keymap.  */
   tui_set_key_mode (tui_current_key_mode);
-  tuiRefreshAll ();
+  tui_refresh_all_win ();
 
   /* Update gdb's knowledge of its terminal.  */
   target_terminal_save_ours ();
@@ -456,26 +455,15 @@ tui_disable (void)
   tui_update_gdb_sizes ();
 }
 
-/* Wrapper on top of free() to ensure that input address
-   is greater than 0x0.  */
 void
-tuiFree (char *ptr)
+strcat_to_buf (char *buf, int buflen, const char *item_to_add)
 {
-  if (ptr != (char *) NULL)
+  if (item_to_add != (char *) NULL && buf != (char *) NULL)
     {
-      xfree (ptr);
-    }
-}
-
-void
-strcat_to_buf (char *buf, int buflen, const char *itemToAdd)
-{
-  if (itemToAdd != (char *) NULL && buf != (char *) NULL)
-    {
-      if ((strlen (buf) + strlen (itemToAdd)) <= buflen)
-	strcat (buf, itemToAdd);
+      if ((strlen (buf) + strlen (item_to_add)) <= buflen)
+	strcat (buf, item_to_add);
       else
-	strncat (buf, itemToAdd, (buflen - strlen (buf)));
+	strncat (buf, item_to_add, (buflen - strlen (buf)));
     }
 }
 
@@ -489,7 +477,7 @@ strcat_to_buf (char *buf, int buflen, const char *itemToAdd)
 #define CHK(val, dft)   (val<=0 ? dft : val)
 
 static void
-_tuiReset (void)
+tui_reset (void)
 {
   struct termio mode;
 
@@ -555,7 +543,7 @@ _tuiReset (void)
 #endif /* USG */
 
   return;
-}				/* _tuiReset */
+}
 #endif
 
 void
@@ -563,40 +551,40 @@ tui_show_source (const char *file, int line)
 {
   struct symtab_and_line cursal = get_current_source_symtab_and_line ();
   /* make sure that the source window is displayed */
-  tuiAddWinToLayout (SRC_WIN);
+  tui_add_win_to_layout (SRC_WIN);
 
-  tuiUpdateSourceWindowsWithLine (cursal.symtab, line);
-  tuiUpdateLocatorFilename (file);
+  tui_update_source_windows_with_line (cursal.symtab, line);
+  tui_update_locator_filename (file);
 }
 
 void
 tui_show_assembly (CORE_ADDR addr)
 {
-  tuiAddWinToLayout (DISASSEM_WIN);
-  tuiUpdateSourceWindowsWithAddr (addr);
+  tui_add_win_to_layout (DISASSEM_WIN);
+  tui_update_source_windows_with_addr (addr);
 }
 
 int
-tui_is_window_visible (TuiWinType type)
+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 c627b865170..d7b741c68a5 100644
--- a/gdb/tui/tui.h
+++ b/gdb/tui/tui.h
@@ -1,5 +1,8 @@
 /* External/Public TUI Header File.
-   Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+
+   Copyright 1998, 1999, 2000, 2001, 2004 Free Software Foundation,
+   Inc.
+
    Contributed by Hewlett-Packard Company.
 
    This file is part of GDB.
@@ -22,76 +25,40 @@
 #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;
 
-/* Opaque data type */
-typedef char *Opaque;
-typedef
-Opaque (*OpaqueFuncPtr) (va_list);
-     typedef char **OpaqueList;
-     typedef OpaqueList OpaquePtr;
-
-/* Generic function pointer */
-     typedef void (*TuiVoidFuncPtr) (va_list);
-     typedef int (*TuiIntFuncPtr) (va_list);
-/*
-   typedef Opaque (*TuiOpaqueFuncPtr) (va_list);
- */
-     typedef OpaqueFuncPtr TuiOpaqueFuncPtr;
-
 extern void strcat_to_buf (char *, int, const char *);
 
-/* Types of error returns */
-     typedef enum
-       {
-	 TUI_SUCCESS,
-	 TUI_FAILURE
-       }
-TuiStatus, *TuiStatusPtr;
+/* Types of error returns.  */
+enum tui_status
+{
+  TUI_SUCCESS,
+  TUI_FAILURE
+};
 
 /* Types of windows */
-     typedef enum
-       {
-	 SRC_WIN = 0,
-	 DISASSEM_WIN,
-	 DATA_WIN,
-	 CMD_WIN,
-	 /* This must ALWAYS be AFTER the major windows last */
-	 MAX_MAJOR_WINDOWS,
-	 /* auxillary windows */
-	 LOCATOR_WIN,
-	 EXEC_INFO_WIN,
-	 DATA_ITEM_WIN,
-	 /* This must ALWAYS be next to last */
-	 MAX_WINDOWS,
-	 UNDEFINED_WIN		/* LAST */
-       }
-TuiWinType, *TuiWinTypePtr;
-
-/* This is a point definition */
-     typedef struct _TuiPoint
-       {
-	 int x, y;
-       }
-TuiPoint, *TuiPointPtr;
+enum tui_win_type
+{
+  SRC_WIN = 0,
+  DISASSEM_WIN,
+  DATA_WIN,
+  CMD_WIN,
+  /* This must ALWAYS be AFTER the major windows last.  */
+  MAX_MAJOR_WINDOWS,
+  /* Auxillary windows.  */
+  LOCATOR_WIN,
+  EXEC_INFO_WIN,
+  DATA_ITEM_WIN,
+  /* This must ALWAYS be next to last.  */
+  MAX_WINDOWS,
+  UNDEFINED_WIN		/* LAST */
+};
 
 /* GENERAL TUI FUNCTIONS */
 /* tui.c */
-extern void tuiFree (char *);
-extern CORE_ADDR tuiGetLowDisassemblyAddress (CORE_ADDR, CORE_ADDR);
+extern CORE_ADDR tui_get_low_disassembly_address (CORE_ADDR, CORE_ADDR);
 extern void tui_show_assembly (CORE_ADDR addr);
-extern int tui_is_window_visible (TuiWinType type);
+extern int tui_is_window_visible (enum tui_win_type type);
 extern int tui_get_command_dimension (int *width, int *height);
 
 /* Initialize readline and configure the keymap for the switching
@@ -107,13 +74,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;
@@ -121,23 +88,13 @@ extern enum tui_key_mode tui_current_key_mode;
 /* Change the TUI key mode by installing the appropriate readline keymap.  */
 extern void tui_set_key_mode (enum tui_key_mode mode);
 
-extern void tui_initialize_io (void);
-
-extern void tui_initialize_readline (void);
-
 extern int tui_active;
 
-extern void tui_install_hooks (void);
-extern void tui_remove_hooks (void);
-
 extern void tui_show_source (const char *file, int line);
 
 extern struct ui_out *tui_out_new (struct ui_file *stream);
 
-/* tuiLayout.c */
-extern TuiStatus tui_set_layout (const char *);
+/* tui-layout.c */
+extern enum tui_status tui_set_layout_for_display_command (const char *name);
 
-/* tuiSourceWin.c */
-extern void tuiUpdateAllExecInfos (void);
-
-#endif /* TUI_H */
+#endif
diff --git a/gdb/tui/tuiData.c b/gdb/tui/tuiData.c
deleted file mode 100644
index 5acc33cc67d..00000000000
--- a/gdb/tui/tuiData.c
+++ /dev/null
@@ -1,1055 +0,0 @@
-/* TUI data manipulation routines.
-
-   Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
-   Inc.
-
-   Contributed by Hewlett-Packard Company.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#include "defs.h"
-#include "symtab.h"
-#include "tui.h"
-#include "tuiData.h"
-#include "tuiGeneralWin.h"
-
-#ifdef HAVE_NCURSES_H       
-#include <ncurses.h>
-#else
-#ifdef HAVE_CURSES_H
-#include <curses.h>
-#endif
-#endif
-
-/****************************
-** GLOBAL DECLARATIONS
-****************************/
-TuiWinInfoPtr winList[MAX_MAJOR_WINDOWS];
-
-/***************************
-** Private data
-****************************/
-static TuiLayoutType _currentLayout = UNDEFINED_LAYOUT;
-static int _termHeight, _termWidth;
-static TuiGenWinInfo _locator;
-static TuiGenWinInfo _execInfo[2];
-static TuiWinInfoPtr _srcWinList[2];
-static TuiList _sourceWindows =
-{(OpaqueList) _srcWinList, 0};
-static int _defaultTabLen = DEFAULT_TAB_LEN;
-static TuiWinInfoPtr _winWithFocus = (TuiWinInfoPtr) NULL;
-static TuiLayoutDef _layoutDef =
-{SRC_WIN,			/* displayMode */
- FALSE,				/* split */
- TUI_UNDEFINED_REGS,		/* regsDisplayType */
- TUI_SFLOAT_REGS};		/* floatRegsDisplayType */
-static int _winResized = FALSE;
-
-
-/*********************************
-** Static function forward decls
-**********************************/
-static void freeContent (TuiWinContent, int, TuiWinType);
-static void freeContentElements (TuiWinContent, int, TuiWinType);
-
-
-
-/*********************************
-** PUBLIC FUNCTIONS
-**********************************/
-
-/******************************************
-** ACCESSORS & MUTATORS FOR PRIVATE DATA
-******************************************/
-
-/*
-   ** tuiWinResized().
-   **        Answer a whether the terminal window has been resized or not
- */
-int
-tuiWinResized (void)
-{
-  return _winResized;
-}				/* tuiWinResized */
-
-
-/*
-   ** tuiSetWinResized().
-   **        Set a whether the terminal window has been resized or not
- */
-void
-tuiSetWinResizedTo (int resized)
-{
-  _winResized = resized;
-
-  return;
-}				/* tuiSetWinResizedTo */
-
-
-/*
-   ** tuiLayoutDef().
-   **        Answer a pointer to the current layout definition
- */
-TuiLayoutDefPtr
-tuiLayoutDef (void)
-{
-  return &_layoutDef;
-}				/* tuiLayoutDef */
-
-
-/*
-   ** tuiWinWithFocus().
-   **        Answer the window with the logical focus
- */
-TuiWinInfoPtr
-tuiWinWithFocus (void)
-{
-  return _winWithFocus;
-}				/* tuiWinWithFocus */
-
-
-/*
-   ** tuiSetWinWithFocus().
-   **        Set the window that has the logical focus
- */
-void
-tuiSetWinWithFocus (TuiWinInfoPtr winInfo)
-{
-  _winWithFocus = winInfo;
-
-  return;
-}				/* tuiSetWinWithFocus */
-
-
-/*
-   ** tuiDefaultTabLen().
-   **        Answer the length in chars, of tabs
- */
-int
-tuiDefaultTabLen (void)
-{
-  return _defaultTabLen;
-}				/* tuiDefaultTabLen */
-
-
-/*
-   ** tuiSetDefaultTabLen().
-   **        Set the length in chars, of tabs
- */
-void
-tuiSetDefaultTabLen (int len)
-{
-  _defaultTabLen = len;
-
-  return;
-}				/* tuiSetDefaultTabLen */
-
-
-/*
-   ** currentSourceWin()
-   **        Accessor for the current source window.  Usually there is only
-   **        one source window (either source or disassembly), but both can
-   **        be displayed at the same time.
- */
-TuiListPtr
-sourceWindows (void)
-{
-  return &_sourceWindows;
-}				/* currentSourceWindows */
-
-
-/*
-   ** clearSourceWindows()
-   **        Clear the list of source windows.  Usually there is only one
-   **        source window (either source or disassembly), but both can be
-   **        displayed at the same time.
- */
-void
-clearSourceWindows (void)
-{
-  _sourceWindows.list[0] = (Opaque) NULL;
-  _sourceWindows.list[1] = (Opaque) NULL;
-  _sourceWindows.count = 0;
-
-  return;
-}				/* currentSourceWindows */
-
-
-/*
-   ** clearSourceWindowsDetail()
-   **        Clear the pertinant detail in the source windows.
- */
-void
-clearSourceWindowsDetail (void)
-{
-  int i;
-
-  for (i = 0; i < (sourceWindows ())->count; i++)
-    clearWinDetail ((TuiWinInfoPtr) (sourceWindows ())->list[i]);
-
-  return;
-}				/* currentSourceWindows */
-
-
-/*
-   ** addSourceWindowToList().
-   **       Add a window to the list of source windows.  Usually there is
-   **       only one source window (either source or disassembly), but
-   **       both can be displayed at the same time.
- */
-void
-addToSourceWindows (TuiWinInfoPtr winInfo)
-{
-  if (_sourceWindows.count < 2)
-    _sourceWindows.list[_sourceWindows.count++] = (Opaque) winInfo;
-
-  return;
-}				/* addToSourceWindows */
-
-
-/*
-   ** clearWinDetail()
-   **        Clear the pertinant detail in the windows.
- */
-void
-clearWinDetail (TuiWinInfoPtr winInfo)
-{
-  if (m_winPtrNotNull (winInfo))
-    {
-      switch (winInfo->generic.type)
-	{
-	case SRC_WIN:
-	case DISASSEM_WIN:
-	  winInfo->detail.sourceInfo.startLineOrAddr.addr = 0;
-	  winInfo->detail.sourceInfo.horizontalOffset = 0;
-	  break;
-	case CMD_WIN:
-	  winInfo->detail.commandInfo.curLine =
-	    winInfo->detail.commandInfo.curch = 0;
-	  break;
-	case DATA_WIN:
-	  winInfo->detail.dataDisplayInfo.dataContent =
-	    (TuiWinContent) NULL;
-	  winInfo->detail.dataDisplayInfo.dataContentCount = 0;
-	  winInfo->detail.dataDisplayInfo.regsContent =
-	    (TuiWinContent) NULL;
-	  winInfo->detail.dataDisplayInfo.regsContentCount = 0;
-	  winInfo->detail.dataDisplayInfo.regsDisplayType =
-	    TUI_UNDEFINED_REGS;
-	  winInfo->detail.dataDisplayInfo.regsColumnCount = 1;
-	  winInfo->detail.dataDisplayInfo.displayRegs = FALSE;
-	  break;
-	default:
-	  break;
-	}
-    }
-
-  return;
-}				/* clearWinDetail */
-
-
-/*
-   ** sourceExecInfoPtr().
-   **        Accessor for the source execution info ptr.
- */
-TuiGenWinInfoPtr
-sourceExecInfoWinPtr (void)
-{
-  return &_execInfo[0];
-}				/* sourceExecInfoWinPtr */
-
-
-/*
-   ** disassemExecInfoPtr().
-   **        Accessor for the disassem execution info ptr.
- */
-TuiGenWinInfoPtr
-disassemExecInfoWinPtr (void)
-{
-  return &_execInfo[1];
-}				/* disassemExecInfoWinPtr */
-
-
-/*
-   ** locatorWinInfoPtr().
-   **        Accessor for the locator win info.  Answers a pointer to the
-   **        static locator win info struct.
- */
-TuiGenWinInfoPtr
-locatorWinInfoPtr (void)
-{
-  return &_locator;
-}				/* locatorWinInfoPtr */
-
-
-/*
-   ** termHeight().
-   **        Accessor for the termHeight
- */
-int
-termHeight (void)
-{
-  return _termHeight;
-}				/* termHeight */
-
-
-/*
-   ** setTermHeightTo().
-   **        Mutator for the term height
- */
-void
-setTermHeightTo (int h)
-{
-  _termHeight = h;
-
-  return;
-}				/* setTermHeightTo */
-
-
-/*
-   ** termWidth().
-   **        Accessor for the termWidth
- */
-int
-termWidth (void)
-{
-  return _termWidth;
-}				/* termWidth */
-
-
-/*
-   ** setTermWidth().
-   **        Mutator for the termWidth
- */
-void
-setTermWidthTo (int w)
-{
-  _termWidth = w;
-
-  return;
-}				/* setTermWidthTo */
-
-
-/*
-   ** currentLayout().
-   **        Accessor for the current layout
- */
-TuiLayoutType
-currentLayout (void)
-{
-  return _currentLayout;
-}				/* currentLayout */
-
-
-/*
-   ** setCurrentLayoutTo().
-   **        Mutator for the current layout
- */
-void
-setCurrentLayoutTo (TuiLayoutType newLayout)
-{
-  _currentLayout = newLayout;
-
-  return;
-}				/* setCurrentLayoutTo */
-
-
-/*
-   ** setGenWinOrigin().
-   **        Set the origin of the window
- */
-void
-setGenWinOrigin (TuiGenWinInfoPtr winInfo, int x, int y)
-{
-  winInfo->origin.x = x;
-  winInfo->origin.y = y;
-
-  return;
-}				/* setGenWinOrigin */
-
-
-/*****************************
-** OTHER PUBLIC FUNCTIONS
-*****************************/
-
-
-/*
-   ** tuiNextWin().
-   **        Answer the next window in the list, cycling back to the top
-   **        if necessary
- */
-TuiWinInfoPtr
-tuiNextWin (TuiWinInfoPtr curWin)
-{
-  TuiWinType type = curWin->generic.type;
-  TuiWinInfoPtr nextWin = (TuiWinInfoPtr) NULL;
-
-  if (curWin->generic.type == CMD_WIN)
-    type = SRC_WIN;
-  else
-    type = curWin->generic.type + 1;
-  while (type != curWin->generic.type && m_winPtrIsNull (nextWin))
-    {
-      if (winList[type] && winList[type]->generic.isVisible)
-	nextWin = winList[type];
-      else
-	{
-	  if (type == CMD_WIN)
-	    type = SRC_WIN;
-	  else
-	    type++;
-	}
-    }
-
-  return nextWin;
-}				/* tuiNextWin */
-
-
-/*
-   ** tuiPrevWin().
-   **        Answer the prev window in the list, cycling back to the bottom
-   **        if necessary
- */
-TuiWinInfoPtr
-tuiPrevWin (TuiWinInfoPtr curWin)
-{
-  TuiWinType type = curWin->generic.type;
-  TuiWinInfoPtr prev = (TuiWinInfoPtr) NULL;
-
-  if (curWin->generic.type == SRC_WIN)
-    type = CMD_WIN;
-  else
-    type = curWin->generic.type - 1;
-  while (type != curWin->generic.type && m_winPtrIsNull (prev))
-    {
-      if (winList[type]->generic.isVisible)
-	prev = winList[type];
-      else
-	{
-	  if (type == SRC_WIN)
-	    type = CMD_WIN;
-	  else
-	    type--;
-	}
-    }
-
-  return prev;
-}
-
-
-/*
-   **  partialWinByName().
-   **      Answer the window represented by name
- */
-TuiWinInfoPtr
-partialWinByName (char *name)
-{
-  TuiWinInfoPtr winInfo = (TuiWinInfoPtr) NULL;
-
-  if (name != (char *) NULL)
-    {
-      int i = 0;
-
-      while (i < MAX_MAJOR_WINDOWS && m_winPtrIsNull (winInfo))
-	{
-          if (winList[i] != 0)
-            {
-              char *curName = winName (&winList[i]->generic);
-              if (strlen (name) <= strlen (curName) &&
-                  strncmp (name, curName, strlen (name)) == 0)
-                winInfo = winList[i];
-            }
-	  i++;
-	}
-    }
-
-  return winInfo;
-}				/* partialWinByName */
-
-
-/*
-   ** winName().
-   **      Answer the name of the window
- */
-char *
-winName (TuiGenWinInfoPtr winInfo)
-{
-  char *name = (char *) NULL;
-
-  switch (winInfo->type)
-    {
-    case SRC_WIN:
-      name = SRC_NAME;
-      break;
-    case CMD_WIN:
-      name = CMD_NAME;
-      break;
-    case DISASSEM_WIN:
-      name = DISASSEM_NAME;
-      break;
-    case DATA_WIN:
-      name = DATA_NAME;
-      break;
-    default:
-      name = "";
-      break;
-    }
-
-  return name;
-}				/* winName */
-
-
-/*
-   ** initializeStaticData
- */
-void
-initializeStaticData (void)
-{
-  initGenericPart (sourceExecInfoWinPtr ());
-  initGenericPart (disassemExecInfoWinPtr ());
-  initGenericPart (locatorWinInfoPtr ());
-
-  return;
-}				/* initializeStaticData */
-
-
-/*
-   ** allocGenericWinInfo().
- */
-TuiGenWinInfoPtr
-allocGenericWinInfo (void)
-{
-  TuiGenWinInfoPtr win;
-
-  if ((win = (TuiGenWinInfoPtr) xmalloc (
-		     sizeof (TuiGenWinInfoPtr))) != (TuiGenWinInfoPtr) NULL)
-    initGenericPart (win);
-
-  return win;
-}				/* allocGenericWinInfo */
-
-
-/*
-   ** initGenericPart().
- */
-void
-initGenericPart (TuiGenWinInfoPtr win)
-{
-  win->width =
-    win->height =
-    win->origin.x =
-    win->origin.y =
-    win->viewportHeight =
-    win->contentSize =
-    win->lastVisibleLine = 0;
-  win->handle = (WINDOW *) NULL;
-  win->content = (OpaquePtr) NULL;
-  win->contentInUse =
-    win->isVisible = FALSE;
-  win->title = 0;
-}
-
-
-/*
-   ** initContentElement().
- */
-void
-initContentElement (TuiWinElementPtr element, TuiWinType type)
-{
-  element->highlight = FALSE;
-  switch (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;
-      break;
-    case DATA_WIN:
-      initGenericPart (&element->whichElement.dataWindow);
-      element->whichElement.dataWindow.type = DATA_ITEM_WIN;
-      ((TuiGenWinInfoPtr) & element->whichElement.dataWindow)->content =
-	(OpaquePtr) allocContent (1, DATA_ITEM_WIN);
-      ((TuiGenWinInfoPtr)
-       & element->whichElement.dataWindow)->contentSize = 1;
-      break;
-    case CMD_WIN:
-      element->whichElement.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 = (Opaque) NULL;
-      element->whichElement.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;
-      break;
-    case EXEC_INFO_WIN:
-      memset(element->whichElement.simpleString, ' ',
-             sizeof(element->whichElement.simpleString));
-      break;
-    default:
-      break;
-    }
-  return;
-}				/* initContentElement */
-
-/*
-   ** initWinInfo().
- */
-void
-initWinInfo (TuiWinInfoPtr winInfo)
-{
-  initGenericPart (&winInfo->generic);
-  winInfo->canHighlight =
-    winInfo->isHighlighted = FALSE;
-  switch (winInfo->generic.type)
-    {
-    case SRC_WIN:
-    case DISASSEM_WIN:
-      winInfo->detail.sourceInfo.executionInfo = (TuiGenWinInfoPtr) NULL;
-      winInfo->detail.sourceInfo.hasLocator = FALSE;
-      winInfo->detail.sourceInfo.horizontalOffset = 0;
-      winInfo->detail.sourceInfo.startLineOrAddr.addr = 0;
-      winInfo->detail.sourceInfo.filename = 0;
-      break;
-    case DATA_WIN:
-      winInfo->detail.dataDisplayInfo.dataContent = (TuiWinContent) NULL;
-      winInfo->detail.dataDisplayInfo.dataContentCount = 0;
-      winInfo->detail.dataDisplayInfo.regsContent = (TuiWinContent) NULL;
-      winInfo->detail.dataDisplayInfo.regsContentCount = 0;
-      winInfo->detail.dataDisplayInfo.regsDisplayType =
-	TUI_UNDEFINED_REGS;
-      winInfo->detail.dataDisplayInfo.regsColumnCount = 1;
-      winInfo->detail.dataDisplayInfo.displayRegs = FALSE;
-      break;
-    case CMD_WIN:
-      winInfo->detail.commandInfo.curLine = 0;
-      winInfo->detail.commandInfo.curch = 0;
-      break;
-    default:
-      winInfo->detail.opaque = (Opaque) NULL;
-      break;
-    }
-
-  return;
-}				/* initWinInfo */
-
-
-/*
-   ** allocWinInfo().
- */
-TuiWinInfoPtr
-allocWinInfo (TuiWinType type)
-{
-  TuiWinInfoPtr winInfo = (TuiWinInfoPtr) NULL;
-
-  winInfo = (TuiWinInfoPtr) xmalloc (sizeof (TuiWinInfo));
-  if (m_winPtrNotNull (winInfo))
-    {
-      winInfo->generic.type = type;
-      initWinInfo (winInfo);
-    }
-
-  return winInfo;
-}				/* allocWinInfo */
-
-
-/*
-   ** allocContent().
-   **        Allocates the content and elements in a block.
- */
-TuiWinContent
-allocContent (int numElements, TuiWinType type)
-{
-  TuiWinContent content = (TuiWinContent) NULL;
-  char *elementBlockPtr = (char *) NULL;
-  int i;
-
-  if ((content = (TuiWinContent)
-  xmalloc (sizeof (TuiWinElementPtr) * numElements)) != (TuiWinContent) NULL)
-    {				/*
-				   ** All windows, except the data window, can allocate the elements
-				   ** in a chunk.  The data window cannot because items can be
-				   ** added/removed from the data display by the user at any time.
-				 */
-      if (type != DATA_WIN)
-	{
-	  if ((elementBlockPtr = (char *)
-	   xmalloc (sizeof (TuiWinElement) * numElements)) != (char *) NULL)
-	    {
-	      for (i = 0; i < numElements; i++)
-		{
-		  content[i] = (TuiWinElementPtr) elementBlockPtr;
-		  initContentElement (content[i], type);
-		  elementBlockPtr += sizeof (TuiWinElement);
-		}
-	    }
-	  else
-	    {
-	      tuiFree ((char *) content);
-	      content = (TuiWinContent) NULL;
-	    }
-	}
-    }
-
-  return content;
-}				/* allocContent */
-
-
-/*
-   ** addContentElements().
-   **        Adds the input number of elements to the windows's content.  If
-   **        no content has been allocated yet, allocContent() is called to
-   **        do this.  The index of the first element added is returned,
-   **        unless there is a memory allocation error, in which case, (-1)
-   **        is returned.
- */
-int
-addContentElements (TuiGenWinInfoPtr winInfo, int numElements)
-{
-  TuiWinElementPtr elementPtr;
-  int i, indexStart;
-
-  if (winInfo->content == (OpaquePtr) NULL)
-    {
-      winInfo->content = (OpaquePtr) allocContent (numElements, winInfo->type);
-      indexStart = 0;
-    }
-  else
-    indexStart = winInfo->contentSize;
-  if (winInfo->content != (OpaquePtr) NULL)
-    {
-      for (i = indexStart; (i < numElements + indexStart); i++)
-	{
-	  if ((elementPtr = (TuiWinElementPtr)
-	       xmalloc (sizeof (TuiWinElement))) != (TuiWinElementPtr) NULL)
-	    {
-	      winInfo->content[i] = (Opaque) elementPtr;
-	      initContentElement (elementPtr, winInfo->type);
-	      winInfo->contentSize++;
-	    }
-	  else			/* things must be really hosed now! We ran out of memory!? */
-	    return (-1);
-	}
-    }
-
-  return indexStart;
-}				/* addContentElements */
-
-
-/* Delete all curses windows associated with winInfo, leaving everything
-   else intact.  */
-void
-tuiDelWindow (TuiWinInfoPtr winInfo)
-{
-  TuiGenWinInfoPtr genericWin;
-
-  switch (winInfo->generic.type)
-    {
-    case SRC_WIN:
-    case DISASSEM_WIN:
-      genericWin = locatorWinInfoPtr ();
-      if (genericWin != (TuiGenWinInfoPtr) NULL)
-	{
-	  tuiDelwin (genericWin->handle);
-	  genericWin->handle = (WINDOW *) NULL;
-	  genericWin->isVisible = FALSE;
-	}
-      if (winInfo->detail.sourceInfo.filename)
-        {
-          xfree (winInfo->detail.sourceInfo.filename);
-          winInfo->detail.sourceInfo.filename = 0;
-        }
-      genericWin = winInfo->detail.sourceInfo.executionInfo;
-      if (genericWin != (TuiGenWinInfoPtr) NULL)
-	{
-	  tuiDelwin (genericWin->handle);
-	  genericWin->handle = (WINDOW *) NULL;
-	  genericWin->isVisible = FALSE;
-	}
-      break;
-    case DATA_WIN:
-      if (winInfo->generic.content != (OpaquePtr) NULL)
-	{
-	  tuiDelDataWindows (winInfo->detail.dataDisplayInfo.regsContent,
-                             winInfo->detail.dataDisplayInfo.regsContentCount);
-	  tuiDelDataWindows (winInfo->detail.dataDisplayInfo.dataContent,
-                             winInfo->detail.dataDisplayInfo.dataContentCount);
-	}
-      break;
-    default:
-      break;
-    }
-  if (winInfo->generic.handle != (WINDOW *) NULL)
-    {
-      tuiDelwin (winInfo->generic.handle);
-      winInfo->generic.handle = (WINDOW *) NULL;
-      winInfo->generic.isVisible = FALSE;
-    }
-}
-
-
-/*
-   **  freeWindow().
- */
-void
-freeWindow (TuiWinInfoPtr winInfo)
-{
-  TuiGenWinInfoPtr genericWin;
-
-  switch (winInfo->generic.type)
-    {
-    case SRC_WIN:
-    case DISASSEM_WIN:
-      genericWin = locatorWinInfoPtr ();
-      if (genericWin != (TuiGenWinInfoPtr) NULL)
-	{
-	  tuiDelwin (genericWin->handle);
-	  genericWin->handle = (WINDOW *) NULL;
-	}
-      freeWinContent (genericWin);
-      if (winInfo->detail.sourceInfo.filename)
-        {
-          xfree (winInfo->detail.sourceInfo.filename);
-          winInfo->detail.sourceInfo.filename = 0;
-        }
-      genericWin = winInfo->detail.sourceInfo.executionInfo;
-      if (genericWin != (TuiGenWinInfoPtr) NULL)
-	{
-	  tuiDelwin (genericWin->handle);
-	  genericWin->handle = (WINDOW *) NULL;
-	  freeWinContent (genericWin);
-	}
-      break;
-    case DATA_WIN:
-      if (winInfo->generic.content != (OpaquePtr) NULL)
-	{
-	  freeDataContent (
-			    winInfo->detail.dataDisplayInfo.regsContent,
-			  winInfo->detail.dataDisplayInfo.regsContentCount);
-	  winInfo->detail.dataDisplayInfo.regsContent =
-	    (TuiWinContent) NULL;
-	  winInfo->detail.dataDisplayInfo.regsContentCount = 0;
-	  freeDataContent (
-			    winInfo->detail.dataDisplayInfo.dataContent,
-			  winInfo->detail.dataDisplayInfo.dataContentCount);
-	  winInfo->detail.dataDisplayInfo.dataContent =
-	    (TuiWinContent) NULL;
-	  winInfo->detail.dataDisplayInfo.dataContentCount = 0;
-	  winInfo->detail.dataDisplayInfo.regsDisplayType =
-	    TUI_UNDEFINED_REGS;
-	  winInfo->detail.dataDisplayInfo.regsColumnCount = 1;
-	  winInfo->detail.dataDisplayInfo.displayRegs = FALSE;
-	  winInfo->generic.content = (OpaquePtr) NULL;
-	  winInfo->generic.contentSize = 0;
-	}
-      break;
-    default:
-      break;
-    }
-  if (winInfo->generic.handle != (WINDOW *) NULL)
-    {
-      tuiDelwin (winInfo->generic.handle);
-      winInfo->generic.handle = (WINDOW *) NULL;
-      freeWinContent (&winInfo->generic);
-    }
-  if (winInfo->generic.title)
-    xfree (winInfo->generic.title);
-  xfree (winInfo);
-}
-
-
-/*
-   ** freeAllSourceWinsContent().
- */
-void
-freeAllSourceWinsContent (void)
-{
-  int i;
-
-  for (i = 0; i < (sourceWindows ())->count; i++)
-    {
-      TuiWinInfoPtr winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[i];
-
-      if (m_winPtrNotNull (winInfo))
-	{
-	  freeWinContent (&(winInfo->generic));
-	  freeWinContent (winInfo->detail.sourceInfo.executionInfo);
-	}
-    }
-
-  return;
-}				/* freeAllSourceWinsContent */
-
-
-/*
-   ** freeWinContent().
- */
-void
-freeWinContent (TuiGenWinInfoPtr winInfo)
-{
-  if (winInfo->content != (OpaquePtr) NULL)
-    {
-      freeContent ((TuiWinContent) winInfo->content,
-		   winInfo->contentSize,
-		   winInfo->type);
-      winInfo->content = (OpaquePtr) NULL;
-    }
-  winInfo->contentSize = 0;
-
-  return;
-}				/* freeWinContent */
-
-
-void
-tuiDelDataWindows (TuiWinContent content, int contentSize)
-{
-  int i;
-
-  /*
-     ** Remember that data window content elements are of type TuiGenWinInfoPtr,
-     ** each of which whose single element is a data element.
-   */
-  for (i = 0; i < contentSize; i++)
-    {
-      TuiGenWinInfoPtr genericWin = &content[i]->whichElement.dataWindow;
-
-      if (genericWin != (TuiGenWinInfoPtr) NULL)
-	{
-	  tuiDelwin (genericWin->handle);
-	  genericWin->handle = (WINDOW *) NULL;
-	  genericWin->isVisible = FALSE;
-	}
-    }
-
-  return;
-}				/* tuiDelDataWindows */
-
-
-void
-freeDataContent (TuiWinContent content, int contentSize)
-{
-  int i;
-
-  /*
-     ** Remember that data window content elements are of type TuiGenWinInfoPtr,
-     ** each of which whose single element is a data element.
-   */
-  for (i = 0; i < contentSize; i++)
-    {
-      TuiGenWinInfoPtr genericWin = &content[i]->whichElement.dataWindow;
-
-      if (genericWin != (TuiGenWinInfoPtr) NULL)
-	{
-	  tuiDelwin (genericWin->handle);
-	  genericWin->handle = (WINDOW *) NULL;
-	  freeWinContent (genericWin);
-	}
-    }
-  freeContent (content,
-	       contentSize,
-	       DATA_WIN);
-
-  return;
-}				/* freeDataContent */
-
-
-/**********************************
-** LOCAL STATIC FUNCTIONS        **
-**********************************/
-
-
-/*
-   ** freeContent().
- */
-static void
-freeContent (TuiWinContent content, int contentSize, TuiWinType winType)
-{
-  if (content != (TuiWinContent) NULL)
-    {
-      freeContentElements (content, contentSize, winType);
-      tuiFree ((char *) content);
-    }
-
-  return;
-}				/* freeContent */
-
-
-/*
-   ** freeContentElements().
- */
-static void
-freeContentElements (TuiWinContent content, int contentSize, TuiWinType type)
-{
-  if (content != (TuiWinContent) NULL)
-    {
-      int i;
-
-      if (type == SRC_WIN || type == DISASSEM_WIN)
-	{
-	  /* free whole source block */
-	  if (content[0]->whichElement.source.line != (char *) NULL)
-	    tuiFree (content[0]->whichElement.source.line);
-	}
-      else
-	{
-	  for (i = 0; i < contentSize; i++)
-	    {
-	      TuiWinElementPtr element;
-
-	      element = content[i];
-	      if (element != (TuiWinElementPtr) NULL)
-		{
-		  switch (type)
-		    {
-		    case DATA_WIN:
-		      tuiFree ((char *) element);
-		      break;
-		    case DATA_ITEM_WIN:
-		      /*
-		         ** Note that data elements are not allocated
-		         ** in a single block, but individually, as needed.
-		       */
-		      if (element->whichElement.data.type != TUI_REGISTER)
-			tuiFree ((char *)
-				 element->whichElement.data.name);
-		      tuiFree ((char *) element->whichElement.data.value);
-		      tuiFree ((char *) element);
-		      break;
-		    case CMD_WIN:
-		      tuiFree ((char *) element->whichElement.command.line);
-		      break;
-		    default:
-		      break;
-		    }
-		}
-	    }
-	}
-      if (type != DATA_WIN && type != DATA_ITEM_WIN)
-	tuiFree ((char *) content[0]);	/* free the element block */
-    }
-
-  return;
-}				/* freeContentElements */
diff --git a/gdb/tui/tuiData.h b/gdb/tui/tuiData.h
deleted file mode 100644
index 6fcf875b457..00000000000
--- a/gdb/tui/tuiData.h
+++ /dev/null
@@ -1,383 +0,0 @@
-/* TUI data manipulation routines.
-   Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
-   Contributed by Hewlett-Packard Company.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#ifndef TUI_DATA_H
-#define TUI_DATA_H
-
-#if defined (HAVE_NCURSES_H)
-#include <ncurses.h>
-#elif defined (HAVE_CURSES_H)
-#include <curses.h>
-#endif
-
-/* Generic window information */
-     typedef struct _TuiGenWinInfo
-       {
-	 WINDOW *handle;	/* window handle */
-	 TuiWinType type;	/* type of window */
-	 int width;		/* window width */
-	 int height;		/* window height */
-	 TuiPoint origin;	/* origin of window */
-	 OpaquePtr 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.  */
-       }
-TuiGenWinInfo, *TuiGenWinInfoPtr;
-
-/* Constant definitions */
-#define DEFAULT_TAB_LEN                8
-#define NO_SRC_STRING                  "[ No Source Available ]"
-#define NO_DISASSEM_STRING             "[ No Assembly Available ]"
-#define NO_REGS_STRING                 "[ Register Values Unavailable ]"
-#define NO_DATA_STRING                 "[ No Data Values Displayed ]"
-#define MAX_CONTENT_COUNT              100
-#define SRC_NAME                       "SRC"
-#define CMD_NAME                       "CMD"
-#define DATA_NAME                      "REGS"
-#define DISASSEM_NAME                  "ASM"
-#define TUI_NULL_STR                   ""
-#define DEFAULT_HISTORY_COUNT          25
-#define BOX_WINDOW                     TRUE
-#define DONT_BOX_WINDOW                FALSE
-#define HILITE                         TRUE
-#define NO_HILITE                      FALSE
-#define WITH_LOCATOR                   TRUE
-#define NO_LOCATOR                     FALSE
-#define EMPTY_SOURCE_PROMPT            TRUE
-#define NO_EMPTY_SOURCE_PROMPT         FALSE
-#define UNDEFINED_ITEM                 -1
-#define MIN_WIN_HEIGHT                 3
-#define MIN_CMD_WIN_HEIGHT             3
-
-/* Strings to display in the TUI status line.  */
-#define PROC_PREFIX                    "In: "
-#define LINE_PREFIX                    "Line: "
-#define PC_PREFIX                      "PC: "
-#define SINGLE_KEY                     "(SingleKey)"
-
-/* Minimum/Maximum length of some fields displayed in the TUI status line.  */
-#define MIN_LINE_WIDTH     4 /* Use at least 4 digits for line numbers.  */
-#define MIN_PROC_WIDTH    12
-#define MAX_TARGET_WIDTH  10
-#define MAX_PID_WIDTH     14
-
-#define TUI_FLOAT_REGS_NAME                  "$FREGS"
-#define TUI_FLOAT_REGS_NAME_LOWER            "$fregs"
-#define TUI_GENERAL_REGS_NAME                "$GREGS"
-#define TUI_GENERAL_REGS_NAME_LOWER          "$gregs"
-#define TUI_SPECIAL_REGS_NAME                "$SREGS"
-#define TUI_SPECIAL_REGS_NAME_LOWER          "$sregs"
-#define TUI_GENERAL_SPECIAL_REGS_NAME        "$REGS"
-#define TUI_GENERAL_SPECIAL_REGS_NAME_LOWER  "$regs"
-
-/* Scroll direction enum */
-typedef enum
-  {
-    FORWARD_SCROLL,
-    BACKWARD_SCROLL,
-    LEFT_SCROLL,
-    RIGHT_SCROLL
-  }
-TuiScrollDirection, *TuiScrollDirectionPtr;
-
-
-/* General list struct */
-typedef struct _TuiList
-  {
-    OpaqueList list;
-    int count;
-  }
-TuiList, *TuiListPtr;
-
-
-/* The kinds of layouts available */
-typedef enum
-  {
-    SRC_COMMAND,
-    DISASSEM_COMMAND,
-    SRC_DISASSEM_COMMAND,
-    SRC_DATA_COMMAND,
-    DISASSEM_DATA_COMMAND,
-    UNDEFINED_LAYOUT
-  }
-TuiLayoutType, *TuiLayoutTypePtr;
-
-/* Basic data types that can be displayed in the data window. */
-typedef enum _TuiDataType
-  {
-    TUI_REGISTER,
-    TUI_SCALAR,
-    TUI_COMPLEX,
-    TUI_STRUCT
-  }
-TuiDataType, TuiDataTypePtr;
-
-/* Types of register displays */
-typedef enum _TuiRegisterDisplayType
-  {
-    TUI_UNDEFINED_REGS,
-    TUI_GENERAL_REGS,
-    TUI_SFLOAT_REGS,
-    TUI_DFLOAT_REGS,
-    TUI_SPECIAL_REGS,
-    TUI_GENERAL_AND_SPECIAL_REGS
-  }
-TuiRegisterDisplayType, *TuiRegisterDisplayTypePtr;
-
-/* Structure describing source line or line address */
-typedef union _TuiLineOrAddress
-  {
-    int lineNo;
-    CORE_ADDR addr;
-  }
-TuiLineOrAddress, *TuiLineOrAddressPtr;
-
-/* Current Layout definition */
-typedef struct _TuiLayoutDef
-  {
-    TuiWinType displayMode;
-    int split;
-    TuiRegisterDisplayType regsDisplayType;
-    TuiRegisterDisplayType floatRegsDisplayType;
-  }
-TuiLayoutDef, *TuiLayoutDefPtr;
-
-/* Elements in the Source/Disassembly Window */
-typedef struct _TuiSourceElement
-  {
-    char *line;
-    TuiLineOrAddress lineOrAddr;
-    int isExecPoint;
-    int hasBreak;
-  }
-TuiSourceElement, *TuiSourceElementPtr;
-
-
-/* Elements in the data display window content */
-typedef struct _TuiDataElement
-  {
-    const char *name;
-    int itemNo;			/* the register number, or data display number */
-    TuiDataType type;
-    Opaque value;
-    int highlight;
-  }
-TuiDataElement, *TuiDataElementPtr;
-
-
-/* Elements in the command window content */
-typedef struct _TuiCommandElement
-  {
-    char *line;
-  }
-TuiCommandElement, *TuiCommandElementPtr;
-
-
-#define MAX_LOCATOR_ELEMENT_LEN        100
-
-/* Elements in the locator window content */
-typedef struct _TuiLocatorElement
-  {
-    char fileName[MAX_LOCATOR_ELEMENT_LEN];
-    char procName[MAX_LOCATOR_ELEMENT_LEN];
-    int lineNo;
-    CORE_ADDR addr;
-  }
-TuiLocatorElement, *TuiLocatorElementPtr;
-
-/* Flags to tell what kind of breakpoint is at current line.  */
-#define TUI_BP_ENABLED      0x01
-#define TUI_BP_DISABLED     0x02
-#define TUI_BP_HIT          0x04
-#define TUI_BP_CONDITIONAL  0x08
-#define TUI_BP_HARDWARE     0x10
-
-/* Position of breakpoint markers in the exec info string.  */
-#define TUI_BP_HIT_POS      0
-#define TUI_BP_BREAK_POS    1
-#define TUI_EXEC_POS        2
-#define TUI_EXECINFO_SIZE   4
-
-typedef char TuiExecInfoContent[TUI_EXECINFO_SIZE];
-
-/* An content element in a window */
-typedef union
-  {
-    TuiSourceElement source;	/* the source elements */
-    TuiGenWinInfo dataWindow;	/* data display elements */
-    TuiDataElement data;	/* elements of dataWindow */
-    TuiCommandElement command;	/* command elements */
-    TuiLocatorElement locator;	/* locator elements */
-    TuiExecInfoContent simpleString;	/* simple char based elements */
-  }
-TuiWhichElement, *TuiWhichElementPtr;
-
-typedef struct _TuiWinElement
-  {
-    int highlight;
-    TuiWhichElement whichElement;
-  }
-TuiWinElement, *TuiWinElementPtr;
-
-
-/* This describes the content of the window. */
-typedef TuiWinElementPtr *TuiWinContent;
-
-
-/* This struct defines the specific information about a data display window */
-typedef struct _TuiDataInfo
-  {
-    TuiWinContent dataContent;	/* start of data display content */
-    int dataContentCount;
-    TuiWinContent regsContent;	/* start of regs display content */
-    int regsContentCount;
-    TuiRegisterDisplayType regsDisplayType;
-    int regsColumnCount;
-    int displayRegs;		/* Should regs be displayed at all? */
-  }
-TuiDataInfo, *TuiDataInfoPtr;
-
-
-typedef struct _TuiSourceInfo
-  {
-    int hasLocator;		/* Does locator belongs to this window? */
-    TuiGenWinInfoPtr executionInfo;	/* execution information window */
-    int horizontalOffset;	/* used for horizontal scroll */
-    TuiLineOrAddress startLineOrAddr;
-    char* filename;
-  }
-TuiSourceInfo, *TuiSourceInfoPtr;
-
-
-typedef struct _TuiCommandInfo
-  {
-    int curLine;		/* The current line position */
-    int curch;			/* The current cursor position */
-    int start_line;
-  }
-TuiCommandInfo, *TuiCommandInfoPtr;
-
-
-/* This defines information about each logical window */
-typedef struct _TuiWinInfo
-  {
-    TuiGenWinInfo generic;	/* general window information */
-    union
-      {
-	TuiSourceInfo sourceInfo;
-	TuiDataInfo dataDisplayInfo;
-	TuiCommandInfo commandInfo;
-	Opaque opaque;
-      }
-    detail;
-    int canHighlight;		/* Can this window ever be highlighted? */
-    int isHighlighted;		/* Is this window highlighted? */
-  }
-TuiWinInfo, *TuiWinInfoPtr;
-
-/* MACROS (prefixed with m_) */
-
-/* Testing macros */
-#define        m_genWinPtrIsNull(winInfo) \
-                ((winInfo) == (TuiGenWinInfoPtr)NULL)
-#define        m_genWinPtrNotNull(winInfo) \
-                ((winInfo) != (TuiGenWinInfoPtr)NULL)
-#define        m_winPtrIsNull(winInfo) \
-                ((winInfo) == (TuiWinInfoPtr)NULL)
-#define        m_winPtrNotNull(winInfo) \
-                ((winInfo) != (TuiWinInfoPtr)NULL)
-
-#define        m_winIsSourceType(type) \
-                (type == SRC_WIN || type == DISASSEM_WIN)
-#define        m_winIsAuxillary(winType) \
-                (winType > MAX_MAJOR_WINDOWS)
-#define        m_hasLocator(winInfo) \
-                ( ((winInfo) != (TuiWinInfoPtr)NULL) ? \
-                    (winInfo->detail.sourceInfo.hasLocator) : \
-                    FALSE )
-
-#define     m_setWinHighlightOn(winInfo) \
-                if ((winInfo) != (TuiWinInfoPtr)NULL) \
-                              (winInfo)->isHighlighted = TRUE
-#define     m_setWinHighlightOff(winInfo) \
-                if ((winInfo) != (TuiWinInfoPtr)NULL) \
-                              (winInfo)->isHighlighted = FALSE
-
-
-/* Global Data */
-extern TuiWinInfoPtr winList[MAX_MAJOR_WINDOWS];
-
-/* Macros */
-#define srcWin            winList[SRC_WIN]
-#define disassemWin       winList[DISASSEM_WIN]
-#define dataWin           winList[DATA_WIN]
-#define cmdWin            winList[CMD_WIN]
-
-/* Data Manipulation Functions */
-extern void initializeStaticData (void);
-extern TuiGenWinInfoPtr allocGenericWinInfo (void);
-extern TuiWinInfoPtr allocWinInfo (TuiWinType);
-extern void initGenericPart (TuiGenWinInfoPtr);
-extern void initWinInfo (TuiWinInfoPtr);
-extern TuiWinContent allocContent (int, TuiWinType);
-extern int addContentElements (TuiGenWinInfoPtr, int);
-extern void initContentElement (TuiWinElementPtr, TuiWinType);
-extern void freeWindow (TuiWinInfoPtr);
-extern void freeWinContent (TuiGenWinInfoPtr);
-extern void freeDataContent (TuiWinContent, int);
-extern void freeAllSourceWinsContent (void);
-extern void tuiDelWindow (TuiWinInfoPtr);
-extern void tuiDelDataWindows (TuiWinContent, int);
-extern TuiWinInfoPtr partialWinByName (char *);
-extern char *winName (TuiGenWinInfoPtr);
-extern TuiLayoutType currentLayout (void);
-extern void setCurrentLayoutTo (TuiLayoutType);
-extern int termHeight (void);
-extern void setTermHeightTo (int);
-extern int termWidth (void);
-extern void setTermWidthTo (int);
-extern void setGenWinOrigin (TuiGenWinInfoPtr, int, int);
-extern TuiGenWinInfoPtr locatorWinInfoPtr (void);
-extern TuiGenWinInfoPtr sourceExecInfoWinPtr (void);
-extern TuiGenWinInfoPtr disassemExecInfoWinPtr (void);
-extern TuiListPtr sourceWindows (void);
-extern void clearSourceWindows (void);
-extern void clearSourceWindowsDetail (void);
-extern void clearWinDetail (TuiWinInfoPtr winInfo);
-extern void tuiAddToSourceWindows (TuiWinInfoPtr);
-extern int tuiDefaultTabLen (void);
-extern void tuiSetDefaultTabLen (int);
-extern TuiWinInfoPtr tuiWinWithFocus (void);
-extern void tuiSetWinWithFocus (TuiWinInfoPtr);
-extern TuiLayoutDefPtr tuiLayoutDef (void);
-extern int tuiWinResized (void);
-extern void tuiSetWinResizedTo (int);
-
-extern TuiWinInfoPtr tuiNextWin (TuiWinInfoPtr);
-extern TuiWinInfoPtr tuiPrevWin (TuiWinInfoPtr);
-
-extern void addToSourceWindows (TuiWinInfoPtr winInfo);
-
-#endif /* TUI_DATA_H */
diff --git a/gdb/tui/tuiDataWin.c b/gdb/tui/tuiDataWin.c
deleted file mode 100644
index f3bedd2d6b9..00000000000
--- a/gdb/tui/tuiDataWin.c
+++ /dev/null
@@ -1,349 +0,0 @@
-/* Data/register window display.
-
-   Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
-   Inc.
-
-   Contributed by Hewlett-Packard Company.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#include "defs.h"
-#include "tui.h"
-#include "tuiData.h"
-#include "tuiGeneralWin.h"
-#include "tuiRegs.h"
-
-#ifdef HAVE_NCURSES_H       
-#include <ncurses.h>
-#else
-#ifdef HAVE_CURSES_H
-#include <curses.h>
-#endif
-#endif
-
-
-/*****************************************
-** STATIC LOCAL FUNCTIONS FORWARD DECLS    **
-******************************************/
-
-
-
-/*****************************************
-** PUBLIC FUNCTIONS                        **
-******************************************/
-
-
-/*
-   ** tuiFirstDataItemDisplayed()
-   **    Answer the index first element displayed.
-   **    If none are displayed, then return (-1).
- */
-int
-tuiFirstDataItemDisplayed (void)
-{
-  int elementNo = (-1);
-  int i;
-
-  for (i = 0; (i < dataWin->generic.contentSize && elementNo < 0); i++)
-    {
-      TuiGenWinInfoPtr dataItemWin;
-
-      dataItemWin = &((TuiWinContent)
-		      dataWin->generic.content)[i]->whichElement.dataWindow;
-      if (dataItemWin->handle != (WINDOW *) NULL && dataItemWin->isVisible)
-	elementNo = i;
-    }
-
-  return elementNo;
-}				/* tuiFirstDataItemDisplayed */
-
-
-/*
-   ** tuiFirstDataElementNoInLine()
-   **        Answer the index of the first element in lineNo.  If lineNo is
-   **        past the data area (-1) is returned.
- */
-int
-tuiFirstDataElementNoInLine (int lineNo)
-{
-  int firstElementNo = (-1);
-
-  /*
-     ** First see if there is a register on lineNo, and if so, set the
-     ** first element number
-   */
-  if ((firstElementNo = tuiFirstRegElementNoInLine (lineNo)) == -1)
-    {				/*
-				   ** Looking at the general data, the 1st element on lineNo
-				 */
-    }
-
-  return firstElementNo;
-}				/* tuiFirstDataElementNoInLine */
-
-
-/*
-   ** tuiDeleteDataContentWindows()
-   **        Function to delete all the item windows in the data window.
-   **        This is usually done when the data window is scrolled.
- */
-void
-tuiDeleteDataContentWindows (void)
-{
-  int i;
-  TuiGenWinInfoPtr dataItemWinPtr;
-
-  for (i = 0; (i < dataWin->generic.contentSize); i++)
-    {
-      dataItemWinPtr = &((TuiWinContent)
-		      dataWin->generic.content)[i]->whichElement.dataWindow;
-      tuiDelwin (dataItemWinPtr->handle);
-      dataItemWinPtr->handle = (WINDOW *) NULL;
-      dataItemWinPtr->isVisible = FALSE;
-    }
-
-  return;
-}				/* tuiDeleteDataContentWindows */
-
-
-void
-tuiEraseDataContent (char *prompt)
-{
-  werase (dataWin->generic.handle);
-  checkAndDisplayHighlightIfNeeded (dataWin);
-  if (prompt != (char *) NULL)
-    {
-      int halfWidth = (dataWin->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),
-		 xPos,
-		 prompt);
-    }
-  wrefresh (dataWin->generic.handle);
-
-  return;
-}				/* tuiEraseDataContent */
-
-
-/*
-   ** tuiDisplayAllData().
-   **        This function displays the data that is in the data window's
-   **        content.  It does not set the content.
- */
-void
-tuiDisplayAllData (void)
-{
-  if (dataWin->generic.contentSize <= 0)
-    tuiEraseDataContent (NO_DATA_STRING);
-  else
-    {
-      tuiEraseDataContent ((char *) NULL);
-      tuiDeleteDataContentWindows ();
-      checkAndDisplayHighlightIfNeeded (dataWin);
-      tuiDisplayRegistersFrom (0);
-      /*
-         ** Then display the other data
-       */
-      if (dataWin->detail.dataDisplayInfo.dataContent !=
-	  (TuiWinContent) NULL &&
-	  dataWin->detail.dataDisplayInfo.dataContentCount > 0)
-	{
-	}
-    }
-  return;
-}				/* tuiDisplayAllData */
-
-
-/*
-   ** tuiDisplayDataFromLine()
-   **        Function to display the data starting at line, lineNo, in the
-   **        data window.
- */
-void
-tuiDisplayDataFromLine (int lineNo)
-{
-  int _lineNo = lineNo;
-
-  if (lineNo < 0)
-    _lineNo = 0;
-
-  checkAndDisplayHighlightIfNeeded (dataWin);
-
-  /* there is no general data, force regs to display (if there are any) */
-  if (dataWin->detail.dataDisplayInfo.dataContentCount <= 0)
-    tuiDisplayRegistersFromLine (_lineNo, TRUE);
-  else
-    {
-      int elementNo, startLineNo;
-      int regsLastLine = tuiLastRegsLineNo ();
-
-
-      /* display regs if we can */
-      if (tuiDisplayRegistersFromLine (_lineNo, FALSE) < 0)
-	{			/*
-				   ** _lineNo is past the regs display, so calc where the
-				   ** start data element is
-				 */
-	  if (regsLastLine < _lineNo)
-	    {			/* figure out how many lines each element is to obtain
-				   the start elementNo */
-	    }
-	}
-      else
-	{			/*
-				   ** calculate the starting element of the data display, given
-				   ** regsLastLine and how many lines each element is, up to
-				   ** _lineNo
-				 */
-	}
-      /* Now display the data , starting at elementNo */
-    }
-
-  return;
-}				/* tuiDisplayDataFromLine */
-
-
-/*
-   ** tuiDisplayDataFrom()
-   **        Display data starting at element elementNo
- */
-void
-tuiDisplayDataFrom (int elementNo, int reuseWindows)
-{
-  int firstLine = (-1);
-
-  if (elementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
-    firstLine = tuiLineFromRegElementNo (elementNo);
-  else
-    {				/* calculate the firstLine from the element number */
-    }
-
-  if (firstLine >= 0)
-    {
-      tuiEraseDataContent ((char *) NULL);
-      if (!reuseWindows)
-	tuiDeleteDataContentWindows ();
-      tuiDisplayDataFromLine (firstLine);
-    }
-
-  return;
-}				/* tuiDisplayDataFrom */
-
-
-/*
-   ** tuiRefreshDataWin()
-   **        Function to redisplay the contents of the data window.
- */
-void
-tuiRefreshDataWin (void)
-{
-  tuiEraseDataContent ((char *) NULL);
-  if (dataWin->generic.contentSize > 0)
-    {
-      int firstElement = tuiFirstDataItemDisplayed ();
-
-      if (firstElement >= 0)	/* re-use existing windows */
-	tuiDisplayDataFrom (firstElement, TRUE);
-    }
-
-  return;
-}				/* tuiRefreshDataWin */
-
-
-/*
-   ** tuiCheckDataValues().
-   **        Function to check the data values and hilite any that have changed
- */
-void
-tuiCheckDataValues (struct frame_info *frame)
-{
-  tuiCheckRegisterValues (frame);
-
-  /* Now check any other data values that there are */
-  if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
-    {
-      int i;
-
-      for (i = 0; dataWin->detail.dataDisplayInfo.dataContentCount; i++)
-	{
-#ifdef LATER
-	  TuiDataElementPtr dataElementPtr;
-	  TuiGenWinInfoPtr dataItemWinPtr;
-	  Opaque newValue;
-
-	  dataItemPtr = &dataWin->detail.dataDisplayInfo.
-	    dataContent[i]->whichElement.dataWindow;
-	  dataElementPtr = &((TuiWinContent)
-			     dataItemWinPtr->content)[0]->whichElement.data;
-	  if value
-	    has changed (dataElementPtr, frame, &newValue)
-	    {
-	      dataElementPtr->value = newValue;
-	      update the display with the new value, hiliting it.
-	    }
-#endif
-	}
-    }
-}				/* tuiCheckDataValues */
-
-
-/*
-   ** tuiVerticalDataScroll()
-   **        Scroll the data window vertically forward or backward.
- */
-void
-tuiVerticalDataScroll (TuiScrollDirection scrollDirection, int numToScroll)
-{
-  int firstElementNo;
-  int firstLine = (-1);
-
-  firstElementNo = tuiFirstDataItemDisplayed ();
-  if (firstElementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
-    firstLine = tuiLineFromRegElementNo (firstElementNo);
-  else
-    {				/* calculate the first line from the element number which is in
-				   ** the general data content
-				 */
-    }
-
-  if (firstLine >= 0)
-    {
-      int lastElementNo, lastLine;
-
-      if (scrollDirection == FORWARD_SCROLL)
-	firstLine += numToScroll;
-      else
-	firstLine -= numToScroll;
-      tuiEraseDataContent ((char *) NULL);
-      tuiDeleteDataContentWindows ();
-      tuiDisplayDataFromLine (firstLine);
-    }
-
-  return;
-}				/* tuiVerticalDataScroll */
-
-
-/*****************************************
-** STATIC LOCAL FUNCTIONS               **
-******************************************/
diff --git a/gdb/tui/tuiDataWin.h b/gdb/tui/tuiDataWin.h
deleted file mode 100644
index 0b1e700f1bb..00000000000
--- a/gdb/tui/tuiDataWin.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/* Data/register window display.
-   Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
-   Contributed by Hewlett-Packard Company.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#ifndef _TUI_DATAWIN_H
-#define _TUI_DATAWIN_H
-
-
-/*****************************************
-** TYPE DEFINITIONS                        **
-******************************************/
-
-
-
-/*****************************************
-** PUBLIC FUNCTION EXTERNAL DECLS        **
-******************************************/
-extern void tuiEraseDataContent (char *);
-extern void tuiDisplayAllData (void);
-extern void tuiCheckDataValues (struct frame_info *);
-extern void tuiDisplayDataFromLine (int);
-extern int tuiFirstDataItemDisplayed (void);
-extern int tuiFirstDataElementNoInLine (int);
-extern void tuiDeleteDataContentWindows (void);
-extern void tuiRefreshDataWin (void);
-extern void tuiDisplayDataFrom (int, int);
-extern void tuiVerticalDataScroll (TuiScrollDirection, int);
-
-#endif
-/*_TUI_DATAWIN_H*/
diff --git a/gdb/tui/tuiGeneralWin.c b/gdb/tui/tuiGeneralWin.c
deleted file mode 100644
index 42faf756284..00000000000
--- a/gdb/tui/tuiGeneralWin.c
+++ /dev/null
@@ -1,285 +0,0 @@
-/* General window behavior.
-
-   Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
-   Inc.
-
-   Contributed by Hewlett-Packard Company.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#include "defs.h"
-#include "tui.h"
-#include "tuiData.h"
-#include "tuiGeneralWin.h"
-#include "tuiWin.h"
-
-#ifdef HAVE_NCURSES_H       
-#include <ncurses.h>
-#else
-#ifdef HAVE_CURSES_H
-#include <curses.h>
-#endif
-#endif
-
-/***********************
-** PUBLIC FUNCTIONS
-***********************/
-/*
-   ** tuiRefreshWin()
-   **        Refresh the window
- */
-void
-tuiRefreshWin (TuiGenWinInfoPtr winInfo)
-{
-  if (winInfo->type == DATA_WIN && winInfo->contentSize > 0)
-    {
-      int i;
-
-      for (i = 0; (i < winInfo->contentSize); i++)
-	{
-	  TuiGenWinInfoPtr dataItemWinPtr;
-
-	  dataItemWinPtr = &((TuiWinContent)
-			     winInfo->content)[i]->whichElement.dataWindow;
-	  if (m_genWinPtrNotNull (dataItemWinPtr) &&
-	      dataItemWinPtr->handle != (WINDOW *) NULL)
-	    wrefresh (dataItemWinPtr->handle);
-	}
-    }
-  else if (winInfo->type == CMD_WIN)
-    {
-      /* Do nothing */
-    }
-  else
-    {
-      if (winInfo->handle != (WINDOW *) NULL)
-	wrefresh (winInfo->handle);
-    }
-
-  return;
-}				/* tuiRefreshWin */
-
-
-/*
-   ** tuiDelwin()
-   **        Function to delete the curses window, checking for null
- */
-void
-tuiDelwin (WINDOW * window)
-{
-  if (window != (WINDOW *) NULL)
-    delwin (window);
-
-  return;
-}				/* tuiDelwin */
-
-
-/* Draw a border arround the window.  */
-void
-boxWin (TuiGenWinInfoPtr winInfo, int highlightFlag)
-{
-  if (winInfo && winInfo->handle)
-    {
-      WINDOW *win;
-      int attrs;
-
-      win = winInfo->handle;
-      if (highlightFlag == HILITE)
-        attrs = tui_active_border_attrs;
-      else
-        attrs = tui_border_attrs;
-
-      wattron (win, attrs);
-      wborder (win, tui_border_vline, tui_border_vline,
-               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);
-      wattroff (win, attrs);
-    }
-}
-
-
-/*
-   ** unhighlightWin().
- */
-void
-unhighlightWin (TuiWinInfoPtr winInfo)
-{
-  if (m_winPtrNotNull (winInfo) && winInfo->generic.handle != (WINDOW *) NULL)
-    {
-      boxWin ((TuiGenWinInfoPtr) winInfo, NO_HILITE);
-      wrefresh (winInfo->generic.handle);
-      m_setWinHighlightOff (winInfo);
-    }
-}				/* unhighlightWin */
-
-
-/*
-   ** highlightWin().
- */
-void
-highlightWin (TuiWinInfoPtr winInfo)
-{
-  if (m_winPtrNotNull (winInfo) &&
-      winInfo->canHighlight && winInfo->generic.handle != (WINDOW *) NULL)
-    {
-      boxWin ((TuiGenWinInfoPtr) winInfo, HILITE);
-      wrefresh (winInfo->generic.handle);
-      m_setWinHighlightOn (winInfo);
-    }
-}				/* highlightWin */
-
-
-/*
-   ** checkAndDisplayHighlightIfNecessay
- */
-void
-checkAndDisplayHighlightIfNeeded (TuiWinInfoPtr winInfo)
-{
-  if (m_winPtrNotNull (winInfo) && winInfo->generic.type != CMD_WIN)
-    {
-      if (winInfo->isHighlighted)
-	highlightWin (winInfo);
-      else
-	unhighlightWin (winInfo);
-
-    }
-  return;
-}				/* checkAndDisplayHighlightIfNeeded */
-
-
-/*
-   ** makeWindow().
- */
-void
-makeWindow (TuiGenWinInfoPtr winInfo, int boxIt)
-{
-  WINDOW *handle;
-
-  handle = newwin (winInfo->height,
-		   winInfo->width,
-		   winInfo->origin.y,
-		   winInfo->origin.x);
-  winInfo->handle = handle;
-  if (handle != (WINDOW *) NULL)
-    {
-      if (boxIt == BOX_WINDOW)
-	boxWin (winInfo, NO_HILITE);
-      winInfo->isVisible = TRUE;
-      scrollok (handle, TRUE);
-    }
-}
-
-
-/*
-   ** makeVisible().
-   **        We can't really make windows visible, or invisible.  So we
-   **        have to delete the entire window when making it visible,
-   **        and create it again when making it visible.
- */
-void
-makeVisible (TuiGenWinInfoPtr winInfo, int visible)
-{
-  /* Don't tear down/recreate command window */
-  if (winInfo->type == CMD_WIN)
-    return;
-
-  if (visible)
-    {
-      if (!winInfo->isVisible)
-	{
-	  makeWindow (
-		       winInfo,
-	   (winInfo->type != CMD_WIN && !m_winIsAuxillary (winInfo->type)));
-	  winInfo->isVisible = TRUE;
-	}
-    }
-  else if (!visible &&
-	   winInfo->isVisible && winInfo->handle != (WINDOW *) NULL)
-    {
-      winInfo->isVisible = FALSE;
-      tuiDelwin (winInfo->handle);
-      winInfo->handle = (WINDOW *) NULL;
-    }
-
-  return;
-}				/* makeVisible */
-
-
-/*
-   ** makeAllVisible().
-   **        Makes all windows invisible (except the command and locator windows)
- */
-void
-makeAllVisible (int visible)
-{
-  int i;
-
-  for (i = 0; i < MAX_MAJOR_WINDOWS; i++)
-    {
-      if (m_winPtrNotNull (winList[i]) &&
-	  ((winList[i])->generic.type) != CMD_WIN)
-	{
-	  if (m_winIsSourceType ((winList[i])->generic.type))
-	    makeVisible ((winList[i])->detail.sourceInfo.executionInfo,
-			 visible);
-	  makeVisible ((TuiGenWinInfoPtr) winList[i], visible);
-	}
-    }
-
-  return;
-}				/* makeAllVisible */
-
-/*
-   ** refreshAll().
-   **        Function to refresh all the windows currently displayed
- */
-void
-refreshAll (TuiWinInfoPtr * list)
-{
-  TuiWinType type;
-  TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
-
-  for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
-    {
-      if (list[type] && list[type]->generic.isVisible)
-	{
-	  if (type == SRC_WIN || type == DISASSEM_WIN)
-	    {
-	      touchwin (list[type]->detail.sourceInfo.executionInfo->handle);
-	      tuiRefreshWin (list[type]->detail.sourceInfo.executionInfo);
-	    }
-	  touchwin (list[type]->generic.handle);
-	  tuiRefreshWin (&list[type]->generic);
-	}
-    }
-  if (locator->isVisible)
-    {
-      touchwin (locator->handle);
-      tuiRefreshWin (locator);
-    }
-
-  return;
-}				/* refreshAll */
-
-
-/*********************************
-** Local Static Functions
-*********************************/
diff --git a/gdb/tui/tuiGeneralWin.h b/gdb/tui/tuiGeneralWin.h
deleted file mode 100644
index 42d1ce46add..00000000000
--- a/gdb/tui/tuiGeneralWin.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/* General window behavior.
-   Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
-   Contributed by Hewlett-Packard Company.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#ifndef TUI_GENERAL_WIN_H
-#define TUI_GENERAL_WIN_H
-
-/*
-   ** Functions
- */
-extern void unhighlightWin (TuiWinInfoPtr);
-extern void makeVisible (TuiGenWinInfoPtr, int);
-extern void makeAllVisible (int);
-extern void makeWindow (TuiGenWinInfoPtr, int);
-extern TuiWinInfoPtr copyWin (TuiWinInfoPtr);
-extern void boxWin (TuiGenWinInfoPtr, int);
-extern void highlightWin (TuiWinInfoPtr);
-extern void checkAndDisplayHighlightIfNeeded (TuiWinInfoPtr);
-extern void refreshAll (TuiWinInfoPtr *);
-extern void tuiDelwin (WINDOW * window);
-extern void tuiRefreshWin (TuiGenWinInfoPtr);
-
-/*
-   ** Macros
- */
-#define    m_beVisible(winInfo)   makeVisible((TuiGenWinInfoPtr)(winInfo), TRUE)
-#define    m_beInvisible(winInfo) \
-                            makeVisible((TuiGenWinInfoPtr)(winInfo), FALSE)
-#define    m_allBeVisible()       makeAllVisible(TRUE)
-#define m_allBeInvisible()        makeAllVisible(FALSE)
-
-#endif /*TUI_GENERAL_WIN_H */
diff --git a/gdb/tui/tuiLayout.c b/gdb/tui/tuiLayout.c
deleted file mode 100644
index b79bfcb8c28..00000000000
--- a/gdb/tui/tuiLayout.c
+++ /dev/null
@@ -1,1148 +0,0 @@
-/* TUI layout window management.
-
-   Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
-   Inc.
-
-   Contributed by Hewlett-Packard Company.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#include "defs.h"
-#include "command.h"
-#include "symtab.h"
-#include "frame.h"
-#include "source.h"
-#include <ctype.h>
-
-#include "tui.h"
-#include "tuiData.h"
-#include "tuiDataWin.h"
-#include "tuiGeneralWin.h"
-#include "tuiStack.h"
-#include "tuiRegs.h"
-#include "tuiWin.h"
-#include "tuiSourceWin.h"
-#include "tuiDisassem.h"
-
-#ifdef HAVE_NCURSES_H       
-#include <ncurses.h>
-#else
-#ifdef HAVE_CURSES_H
-#include <curses.h>
-#endif
-#endif
-
-/*******************************
-** Static Local Decls
-********************************/
-static void showLayout (TuiLayoutType);
-static void _initGenWinInfo (TuiGenWinInfoPtr, TuiWinType, int, int, int, int);
-static void _initAndMakeWin (Opaque *, TuiWinType, int, int, int, int, int);
-static void _showSourceOrDisassemAndCommand (TuiLayoutType);
-static void _makeSourceOrDisassemWindow (TuiWinInfoPtr *, TuiWinType, int, int);
-static void _makeCommandWindow (TuiWinInfoPtr *, int, int);
-static void _makeSourceWindow (TuiWinInfoPtr *, int, int);
-static void _makeDisassemWindow (TuiWinInfoPtr *, int, int);
-static void _makeDataWindow (TuiWinInfoPtr *, int, int);
-static void _showSourceCommand (void);
-static void _showDisassemCommand (void);
-static void _showSourceDisassemCommand (void);
-static void _showData (TuiLayoutType);
-static TuiLayoutType _nextLayout (void);
-static TuiLayoutType _prevLayout (void);
-static void _tuiLayout_command (char *, int);
-static void _tuiToggleLayout_command (char *, int);
-static void _tuiToggleSplitLayout_command (char *, int);
-static CORE_ADDR _extractDisplayStartAddr (void);
-static void _tuiHandleXDBLayout (TuiLayoutDefPtr);
-
-
-/***************************************
-** DEFINITIONS
-***************************************/
-
-#define LAYOUT_USAGE     "Usage: layout prev | next | <layout_name> \n"
-
-/* Show the screen layout defined.  */
-static void
-showLayout (TuiLayoutType layout)
-{
-  TuiLayoutType curLayout = currentLayout ();
-
-  if (layout != curLayout)
-    {
-      /*
-         ** Since the new layout may cause changes in window size, we
-         ** should free the content and reallocate on next display of
-         ** source/asm
-       */
-      freeAllSourceWinsContent ();
-      clearSourceWindows ();
-      if (layout == SRC_DATA_COMMAND || layout == DISASSEM_DATA_COMMAND)
-	{
-	  _showData (layout);
-	  refreshAll (winList);
-	}
-      else
-	{
-	  /* First make the current layout be invisible */
-	  m_allBeInvisible ();
-	  m_beInvisible (locatorWinInfoPtr ());
-
-	  switch (layout)
-	    {
-	      /* Now show the new layout */
-	    case SRC_COMMAND:
-	      _showSourceCommand ();
-	      addToSourceWindows (srcWin);
-	      break;
-	    case DISASSEM_COMMAND:
-	      _showDisassemCommand ();
-	      addToSourceWindows (disassemWin);
-	      break;
-	    case SRC_DISASSEM_COMMAND:
-	      _showSourceDisassemCommand ();
-	      addToSourceWindows (srcWin);
-	      addToSourceWindows (disassemWin);
-	      break;
-	    default:
-	      break;
-	    }
-	}
-    }
-}
-
-
-/*
-   ** tuiSetLayout()
-   **    Function to set the layout to SRC_COMMAND, DISASSEM_COMMAND,
-   **    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.
- */
-TuiStatus
-tuiSetLayout (TuiLayoutType layoutType,
-              TuiRegisterDisplayType regsDisplayType)
-{
-  TuiStatus status = TUI_SUCCESS;
-
-  if (layoutType != UNDEFINED_LAYOUT || regsDisplayType != TUI_UNDEFINED_REGS)
-    {
-      TuiLayoutType curLayout = currentLayout (), newLayout = UNDEFINED_LAYOUT;
-      int regsPopulate = FALSE;
-      CORE_ADDR addr = _extractDisplayStartAddr ();
-      TuiWinInfoPtr newWinWithFocus = (TuiWinInfoPtr) NULL, winWithFocus = tuiWinWithFocus ();
-      TuiLayoutDefPtr layoutDef = tuiLayoutDef ();
-
-
-      if (layoutType == UNDEFINED_LAYOUT &&
-	  regsDisplayType != TUI_UNDEFINED_REGS)
-	{
-	  if (curLayout == SRC_DISASSEM_COMMAND)
-	    newLayout = DISASSEM_DATA_COMMAND;
-	  else if (curLayout == SRC_COMMAND || curLayout == SRC_DATA_COMMAND)
-	    newLayout = SRC_DATA_COMMAND;
-	  else if (curLayout == DISASSEM_COMMAND ||
-		   curLayout == DISASSEM_DATA_COMMAND)
-	    newLayout = DISASSEM_DATA_COMMAND;
-	}
-      else
-	newLayout = layoutType;
-
-      regsPopulate = (newLayout == SRC_DATA_COMMAND ||
-		      newLayout == DISASSEM_DATA_COMMAND ||
-		      regsDisplayType != TUI_UNDEFINED_REGS);
-      if (newLayout != curLayout || regsDisplayType != TUI_UNDEFINED_REGS)
-	{
-	  if (newLayout != curLayout)
-	    {
-	      showLayout (newLayout);
-	      /*
-	         ** Now determine where focus should be
-	       */
-	      if (winWithFocus != cmdWin)
-		{
-		  switch (newLayout)
-		    {
-		    case SRC_COMMAND:
-		      tuiSetWinFocusTo (srcWin);
-		      layoutDef->displayMode = SRC_WIN;
-		      layoutDef->split = FALSE;
-		      break;
-		    case DISASSEM_COMMAND:
-		      /* the previous layout was not showing
-		         ** code. this can happen if there is no
-		         ** source available:
-		         ** 1. if the source file is in another dir OR
-		         ** 2. if target was compiled without -g
-		         ** We still want to show the assembly though!
-		       */
-		      addr = tuiGetBeginAsmAddress ();
-		      tuiSetWinFocusTo (disassemWin);
-		      layoutDef->displayMode = DISASSEM_WIN;
-		      layoutDef->split = FALSE;
-		      break;
-		    case SRC_DISASSEM_COMMAND:
-		      /* the previous layout was not showing
-		         ** code. this can happen if there is no
-		         ** source available:
-		         ** 1. if the source file is in another dir OR
-		         ** 2. if target was compiled without -g
-		         ** We still want to show the assembly though!
-		       */
-		      addr = tuiGetBeginAsmAddress ();
-		      if (winWithFocus == srcWin)
-			tuiSetWinFocusTo (srcWin);
-		      else
-			tuiSetWinFocusTo (disassemWin);
-		      layoutDef->split = TRUE;
-		      break;
-		    case SRC_DATA_COMMAND:
-		      if (winWithFocus != dataWin)
-			tuiSetWinFocusTo (srcWin);
-		      else
-			tuiSetWinFocusTo (dataWin);
-		      layoutDef->displayMode = SRC_WIN;
-		      layoutDef->split = FALSE;
-		      break;
-		    case DISASSEM_DATA_COMMAND:
-		      /* the previous layout was not showing
-		         ** code. this can happen if there is no
-		         ** source available:
-		         ** 1. if the source file is in another dir OR
-		         ** 2. if target was compiled without -g
-		         ** We still want to show the assembly though!
-		       */
-		      addr = tuiGetBeginAsmAddress ();
-		      if (winWithFocus != dataWin)
-			tuiSetWinFocusTo (disassemWin);
-		      else
-			tuiSetWinFocusTo (dataWin);
-		      layoutDef->displayMode = DISASSEM_WIN;
-		      layoutDef->split = FALSE;
-		      break;
-		    default:
-		      break;
-		    }
-		}
-	      if (newWinWithFocus != (TuiWinInfoPtr) NULL)
-		tuiSetWinFocusTo (newWinWithFocus);
-	      /*
-	         ** Now update the window content
-	       */
-	      if (!regsPopulate &&
-		  (newLayout == SRC_DATA_COMMAND ||
-		   newLayout == DISASSEM_DATA_COMMAND))
-		tuiDisplayAllData ();
-
-	      tuiUpdateSourceWindowsWithAddr (addr);
-	    }
-	  if (regsPopulate)
-	    {
-	      layoutDef->regsDisplayType =
-		(regsDisplayType == TUI_UNDEFINED_REGS ?
-		 TUI_GENERAL_REGS : regsDisplayType);
-	      tuiShowRegisters (layoutDef->regsDisplayType);
-	    }
-	}
-    }
-  else
-    status = TUI_FAILURE;
-
-  return status;
-}
-
-/*
-   ** tuiAddWinToLayout().
-   **        Add the specified window to the layout in a logical way.
-   **        This means setting up the most logical layout given the
-   **        window to be added.
- */
-void
-tuiAddWinToLayout (TuiWinType type)
-{
-  TuiLayoutType curLayout = currentLayout ();
-
-  switch (type)
-    {
-    case SRC_WIN:
-      if (curLayout != SRC_COMMAND &&
-	  curLayout != SRC_DISASSEM_COMMAND &&
-	  curLayout != SRC_DATA_COMMAND)
-	{
-	  clearSourceWindowsDetail ();
-	  if (curLayout == DISASSEM_DATA_COMMAND)
-	    showLayout (SRC_DATA_COMMAND);
-	  else
-	    showLayout (SRC_COMMAND);
-	}
-      break;
-    case DISASSEM_WIN:
-      if (curLayout != DISASSEM_COMMAND &&
-	  curLayout != SRC_DISASSEM_COMMAND &&
-	  curLayout != DISASSEM_DATA_COMMAND)
-	{
-	  clearSourceWindowsDetail ();
-	  if (curLayout == SRC_DATA_COMMAND)
-	    showLayout (DISASSEM_DATA_COMMAND);
-	  else
-	    showLayout (DISASSEM_COMMAND);
-	}
-      break;
-    case DATA_WIN:
-      if (curLayout != SRC_DATA_COMMAND &&
-	  curLayout != DISASSEM_DATA_COMMAND)
-	{
-	  if (curLayout == DISASSEM_COMMAND)
-	    showLayout (DISASSEM_DATA_COMMAND);
-	  else
-	    showLayout (SRC_DATA_COMMAND);
-	}
-      break;
-    default:
-      break;
-    }
-
-  return;
-}				/* tuiAddWinToLayout */
-
-
-/*
-   ** tuiDefaultWinHeight().
-   **        Answer the height of a window.  If it hasn't been created yet,
-   **        answer what the height of a window would be based upon its
-   **        type and the layout.
- */
-int
-tuiDefaultWinHeight (TuiWinType type, TuiLayoutType layout)
-{
-  int h;
-
-  if (winList[type] != (TuiWinInfoPtr) NULL)
-    h = winList[type]->generic.height;
-  else
-    {
-      switch (layout)
-	{
-	case SRC_COMMAND:
-	case DISASSEM_COMMAND:
-	  if (m_winPtrIsNull (cmdWin))
-	    h = termHeight () / 2;
-	  else
-	    h = termHeight () - cmdWin->generic.height;
-	  break;
-	case SRC_DISASSEM_COMMAND:
-	case SRC_DATA_COMMAND:
-	case DISASSEM_DATA_COMMAND:
-	  if (m_winPtrIsNull (cmdWin))
-	    h = termHeight () / 3;
-	  else
-	    h = (termHeight () - cmdWin->generic.height) / 2;
-	  break;
-	default:
-	  h = 0;
-	  break;
-	}
-    }
-
-  return h;
-}				/* tuiDefaultWinHeight */
-
-
-/*
-   ** tuiDefaultWinViewportHeight().
-   **        Answer the height of a window.  If it hasn't been created yet,
-   **        answer what the height of a window would be based upon its
-   **        type and the layout.
- */
-int
-tuiDefaultWinViewportHeight (TuiWinType type, TuiLayoutType layout)
-{
-  int h;
-
-  h = tuiDefaultWinHeight (type, layout);
-
-  if (winList[type] == cmdWin)
-    h -= 1;
-  else
-    h -= 2;
-
-  return h;
-}				/* tuiDefaultWinViewportHeight */
-
-
-/*
-   ** _initialize_tuiLayout().
-   **        Function to initialize gdb commands, for tui window layout
-   **        manipulation.
- */
-void
-_initialize_tuiLayout (void)
-{
-  add_com ("layout", class_tui, _tuiLayout_command,
-           "Change the layout of windows.\n\
-Usage: layout prev | next | <layout_name> \n\
-Layout names are:\n\
-   src   : Displays source and command windows.\n\
-   asm   : Displays disassembly and command windows.\n\
-   split : Displays source, disassembly and command windows.\n\
-   regs  : Displays register window. If existing layout\n\
-           is source/command or assembly/command, the \n\
-           register window is displayed. If the\n\
-           source/assembly/command (split) is displayed, \n\
-           the register window is displayed with \n\
-           the window that has current logical focus.\n");
-  if (xdb_commands)
-    {
-      add_com ("td", class_tui, _tuiToggleLayout_command,
-               "Toggle between Source/Command and Disassembly/Command layouts.\n");
-      add_com ("ts", class_tui, _tuiToggleSplitLayout_command,
-               "Toggle between Source/Command or Disassembly/Command and \n\
-Source/Disassembly/Command layouts.\n");
-    }
-}
-
-
-/*************************
-** STATIC LOCAL FUNCTIONS
-**************************/
-
-
-/*
-   ** _tuiSetLayoutTo()
-   **    Function to set the layout to SRC, ASM, SPLIT, NEXT, PREV, DATA, REGS,
-   **        $REGS, $GREGS, $FREGS, $SREGS.
- */
-TuiStatus
-tui_set_layout (const char *layoutName)
-{
-  TuiStatus status = TUI_SUCCESS;
-
-  if (layoutName != (char *) NULL)
-    {
-      register int i;
-      register char *bufPtr;
-      TuiLayoutType newLayout = UNDEFINED_LAYOUT;
-      TuiRegisterDisplayType dpyType = TUI_UNDEFINED_REGS;
-      TuiLayoutType curLayout = currentLayout ();
-
-      bufPtr = (char *) xstrdup (layoutName);
-      for (i = 0; (i < strlen (layoutName)); i++)
-	bufPtr[i] = toupper (bufPtr[i]);
-
-      /* First check for ambiguous input */
-      if (strlen (bufPtr) <= 1 && (*bufPtr == 'S' || *bufPtr == '$'))
-	{
-	  warning ("Ambiguous command input.\n");
-	  status = TUI_FAILURE;
-	}
-      else
-	{
-	  if (subset_compare (bufPtr, "SRC"))
-	    newLayout = SRC_COMMAND;
-	  else if (subset_compare (bufPtr, "ASM"))
-	    newLayout = DISASSEM_COMMAND;
-	  else if (subset_compare (bufPtr, "SPLIT"))
-	    newLayout = SRC_DISASSEM_COMMAND;
-	  else if (subset_compare (bufPtr, "REGS") ||
-		   subset_compare (bufPtr, TUI_GENERAL_SPECIAL_REGS_NAME) ||
-		   subset_compare (bufPtr, TUI_GENERAL_REGS_NAME) ||
-		   subset_compare (bufPtr, TUI_FLOAT_REGS_NAME) ||
-		   subset_compare (bufPtr, TUI_SPECIAL_REGS_NAME))
-	    {
-	      if (curLayout == SRC_COMMAND || curLayout == SRC_DATA_COMMAND)
-		newLayout = SRC_DATA_COMMAND;
-	      else
-		newLayout = DISASSEM_DATA_COMMAND;
-
-/* could ifdef out the following code. when compile with -z, there are null 
-   pointer references that cause a core dump if 'layout regs' is the first 
-   layout command issued by the user. HP has asked us to hook up this code 
-   - edie epstein
- */
-	      if (subset_compare (bufPtr, TUI_FLOAT_REGS_NAME))
-		{
-		  if (dataWin->detail.dataDisplayInfo.regsDisplayType !=
-		      TUI_SFLOAT_REGS &&
-		      dataWin->detail.dataDisplayInfo.regsDisplayType !=
-		      TUI_DFLOAT_REGS)
-		    dpyType = TUI_SFLOAT_REGS;
-		  else
-		    dpyType =
-		      dataWin->detail.dataDisplayInfo.regsDisplayType;
-		}
-	      else if (subset_compare (bufPtr,
-				      TUI_GENERAL_SPECIAL_REGS_NAME))
-		dpyType = TUI_GENERAL_AND_SPECIAL_REGS;
-	      else if (subset_compare (bufPtr, TUI_GENERAL_REGS_NAME))
-		dpyType = TUI_GENERAL_REGS;
-	      else if (subset_compare (bufPtr, TUI_SPECIAL_REGS_NAME))
-		dpyType = TUI_SPECIAL_REGS;
-	      else if (dataWin)
-		{
-		  if (dataWin->detail.dataDisplayInfo.regsDisplayType !=
-		      TUI_UNDEFINED_REGS)
-		    dpyType =
-		      dataWin->detail.dataDisplayInfo.regsDisplayType;
-		  else
-		    dpyType = TUI_GENERAL_REGS;
-		}
-
-/* end of potential ifdef 
- */
-
-/* if ifdefed out code above, then assume that the user wishes to display the 
-   general purpose registers 
- */
-
-/*              dpyType = TUI_GENERAL_REGS; 
- */
-	    }
-	  else if (subset_compare (bufPtr, "NEXT"))
-	    newLayout = _nextLayout ();
-	  else if (subset_compare (bufPtr, "PREV"))
-	    newLayout = _prevLayout ();
-	  else
-	    status = TUI_FAILURE;
-	  xfree (bufPtr);
-
-	  tuiSetLayout (newLayout, dpyType);
-	}
-    }
-  else
-    status = TUI_FAILURE;
-
-  return status;
-}
-
-
-static CORE_ADDR
-_extractDisplayStartAddr (void)
-{
-  TuiLayoutType curLayout = currentLayout ();
-  CORE_ADDR addr;
-  CORE_ADDR pc;
-  struct symtab_and_line cursal = get_current_source_symtab_and_line ();
-
-  switch (curLayout)
-    {
-    case SRC_COMMAND:
-    case SRC_DATA_COMMAND:
-      find_line_pc (cursal.symtab,
-		    srcWin->detail.sourceInfo.startLineOrAddr.lineNo,
-		    &pc);
-      addr = pc;
-      break;
-    case DISASSEM_COMMAND:
-    case SRC_DISASSEM_COMMAND:
-    case DISASSEM_DATA_COMMAND:
-      addr = disassemWin->detail.sourceInfo.startLineOrAddr.addr;
-      break;
-    default:
-      addr = 0;
-      break;
-    }
-
-  return addr;
-}				/* _extractDisplayStartAddr */
-
-
-static void
-_tuiHandleXDBLayout (TuiLayoutDefPtr layoutDef)
-{
-  if (layoutDef->split)
-    {
-      tuiSetLayout (SRC_DISASSEM_COMMAND, TUI_UNDEFINED_REGS);
-      tuiSetWinFocusTo (winList[layoutDef->displayMode]);
-    }
-  else
-    {
-      if (layoutDef->displayMode == SRC_WIN)
-	tuiSetLayout (SRC_COMMAND, TUI_UNDEFINED_REGS);
-      else
-	tuiSetLayout (DISASSEM_DATA_COMMAND, layoutDef->regsDisplayType);
-    }
-
-
-  return;
-}				/* _tuiHandleXDBLayout */
-
-
-static void
-_tuiToggleLayout_command (char *arg, int fromTTY)
-{
-  TuiLayoutDefPtr layoutDef = tuiLayoutDef ();
-
-  /* Make sure the curses mode is enabled.  */
-  tui_enable ();
-  if (layoutDef->displayMode == SRC_WIN)
-    layoutDef->displayMode = DISASSEM_WIN;
-  else
-    layoutDef->displayMode = SRC_WIN;
-
-  if (!layoutDef->split)
-    _tuiHandleXDBLayout (layoutDef);
-
-}
-
-
-static void
-_tuiToggleSplitLayout_command (char *arg, int fromTTY)
-{
-  TuiLayoutDefPtr layoutDef = tuiLayoutDef ();
-
-  /* Make sure the curses mode is enabled.  */
-  tui_enable ();
-  layoutDef->split = (!layoutDef->split);
-  _tuiHandleXDBLayout (layoutDef);
-
-}
-
-
-static void
-_tuiLayout_command (char *arg, int fromTTY)
-{
-  /* Make sure the curses mode is enabled.  */
-  tui_enable ();
-
-  /* Switch to the selected layout.  */
-  if (tui_set_layout (arg) != TUI_SUCCESS)
-    warning ("Invalid layout specified.\n%s", LAYOUT_USAGE);
-
-}
-
-/*
-   ** _nextLayout().
-   **        Answer the previous layout to cycle to.
- */
-static TuiLayoutType
-_nextLayout (void)
-{
-  TuiLayoutType newLayout;
-
-  newLayout = currentLayout ();
-  if (newLayout == UNDEFINED_LAYOUT)
-    newLayout = SRC_COMMAND;
-  else
-    {
-      newLayout++;
-      if (newLayout == UNDEFINED_LAYOUT)
-	newLayout = SRC_COMMAND;
-    }
-
-  return newLayout;
-}				/* _nextLayout */
-
-
-/*
-   ** _prevLayout().
-   **        Answer the next layout to cycle to.
- */
-static TuiLayoutType
-_prevLayout (void)
-{
-  TuiLayoutType newLayout;
-
-  newLayout = currentLayout ();
-  if (newLayout == SRC_COMMAND)
-    newLayout = DISASSEM_DATA_COMMAND;
-  else
-    {
-      newLayout--;
-      if (newLayout == UNDEFINED_LAYOUT)
-	newLayout = DISASSEM_DATA_COMMAND;
-    }
-
-  return newLayout;
-}				/* _prevLayout */
-
-
-
-/*
-   ** _makeCommandWindow().
- */
-static void
-_makeCommandWindow (TuiWinInfoPtr * winInfoPtr, int height, int originY)
-{
-  _initAndMakeWin ((Opaque *) winInfoPtr,
-		   CMD_WIN,
-		   height,
-		   termWidth (),
-		   0,
-		   originY,
-		   DONT_BOX_WINDOW);
-
-  (*winInfoPtr)->canHighlight = FALSE;
-
-  return;
-}				/* _makeCommandWindow */
-
-
-/*
-   ** _makeSourceWindow().
- */
-static void
-_makeSourceWindow (TuiWinInfoPtr * winInfoPtr, int height, int originY)
-{
-  _makeSourceOrDisassemWindow (winInfoPtr, SRC_WIN, height, originY);
-
-  return;
-}				/* _makeSourceWindow */
-
-
-/*
-   ** _makeDisassemWindow().
- */
-static void
-_makeDisassemWindow (TuiWinInfoPtr * winInfoPtr, int height, int originY)
-{
-  _makeSourceOrDisassemWindow (winInfoPtr, DISASSEM_WIN, height, originY);
-
-  return;
-}				/* _makeDisassemWindow */
-
-
-/*
-   ** _makeDataWindow().
- */
-static void
-_makeDataWindow (TuiWinInfoPtr * winInfoPtr, int height, int originY)
-{
-  _initAndMakeWin ((Opaque *) winInfoPtr,
-		   DATA_WIN,
-		   height,
-		   termWidth (),
-		   0,
-		   originY,
-		   BOX_WINDOW);
-
-  return;
-}				/* _makeDataWindow */
-
-
-
-/*
-   **    _showSourceCommand().
-   **        Show the Source/Command layout
- */
-static void
-_showSourceCommand (void)
-{
-  _showSourceOrDisassemAndCommand (SRC_COMMAND);
-
-  return;
-}				/* _showSourceCommand */
-
-
-/*
-   **    _showDisassemCommand().
-   **        Show the Dissassem/Command layout
- */
-static void
-_showDisassemCommand (void)
-{
-  _showSourceOrDisassemAndCommand (DISASSEM_COMMAND);
-
-  return;
-}				/* _showDisassemCommand */
-
-
-/*
-   **    _showSourceDisassemCommand().
-   **        Show the Source/Disassem/Command layout
- */
-static void
-_showSourceDisassemCommand (void)
-{
-  if (currentLayout () != SRC_DISASSEM_COMMAND)
-    {
-      int cmdHeight, srcHeight, asmHeight;
-
-      if (m_winPtrNotNull (cmdWin))
-	cmdHeight = cmdWin->generic.height;
-      else
-	cmdHeight = termHeight () / 3;
-
-      srcHeight = (termHeight () - cmdHeight) / 2;
-      asmHeight = termHeight () - (srcHeight + cmdHeight);
-
-      if (m_winPtrIsNull (srcWin))
-	_makeSourceWindow (&srcWin, srcHeight, 0);
-      else
-	{
-	  _initGenWinInfo (&srcWin->generic,
-			   srcWin->generic.type,
-			   srcHeight,
-			   srcWin->generic.width,
-			   srcWin->detail.sourceInfo.executionInfo->width,
-			   0);
-	  srcWin->canHighlight = TRUE;
-	  _initGenWinInfo (srcWin->detail.sourceInfo.executionInfo,
-			   EXEC_INFO_WIN,
-			   srcHeight,
-			   3,
-			   0,
-			   0);
-	  m_beVisible (srcWin);
-	  m_beVisible (srcWin->detail.sourceInfo.executionInfo);
-	  srcWin->detail.sourceInfo.hasLocator = FALSE;;
-	}
-      if (m_winPtrNotNull (srcWin))
-	{
-	  TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
-
-	  tuiShowSourceContent (srcWin);
-	  if (m_winPtrIsNull (disassemWin))
-	    {
-	      _makeDisassemWindow (&disassemWin, asmHeight, srcHeight - 1);
-	      _initAndMakeWin ((Opaque *) & locator,
-			       LOCATOR_WIN,
-			       2 /* 1 */ ,
-			       termWidth (),
-			       0,
-			       (srcHeight + asmHeight) - 1,
-			       DONT_BOX_WINDOW);
-	    }
-	  else
-	    {
-	      _initGenWinInfo (locator,
-			       LOCATOR_WIN,
-			       2 /* 1 */ ,
-			       termWidth (),
-			       0,
-			       (srcHeight + asmHeight) - 1);
-	      disassemWin->detail.sourceInfo.hasLocator = TRUE;
-	      _initGenWinInfo (
-				&disassemWin->generic,
-				disassemWin->generic.type,
-				asmHeight,
-				disassemWin->generic.width,
-			disassemWin->detail.sourceInfo.executionInfo->width,
-				srcHeight - 1);
-	      _initGenWinInfo (disassemWin->detail.sourceInfo.executionInfo,
-			       EXEC_INFO_WIN,
-			       asmHeight,
-			       3,
-			       0,
-			       srcHeight - 1);
-	      disassemWin->canHighlight = TRUE;
-	      m_beVisible (disassemWin);
-	      m_beVisible (disassemWin->detail.sourceInfo.executionInfo);
-	    }
-	  if (m_winPtrNotNull (disassemWin))
-	    {
-	      srcWin->detail.sourceInfo.hasLocator = FALSE;
-	      disassemWin->detail.sourceInfo.hasLocator = TRUE;
-	      m_beVisible (locator);
-	      tuiShowLocatorContent ();
-	      tuiShowSourceContent (disassemWin);
-
-	      if (m_winPtrIsNull (cmdWin))
-		_makeCommandWindow (&cmdWin,
-				    cmdHeight,
-				    termHeight () - cmdHeight);
-	      else
-		{
-		  _initGenWinInfo (&cmdWin->generic,
-				   cmdWin->generic.type,
-				   cmdWin->generic.height,
-				   cmdWin->generic.width,
-				   0,
-				   cmdWin->generic.origin.y);
-		  cmdWin->canHighlight = FALSE;
-		  m_beVisible (cmdWin);
-		}
-	      if (m_winPtrNotNull (cmdWin))
-		tuiRefreshWin (&cmdWin->generic);
-	    }
-	}
-      setCurrentLayoutTo (SRC_DISASSEM_COMMAND);
-    }
-
-  return;
-}				/* _showSourceDisassemCommand */
-
-
-/*
-   **    _showData().
-   **        Show the Source/Data/Command or the Dissassembly/Data/Command layout
- */
-static void
-_showData (TuiLayoutType newLayout)
-{
-  int totalHeight = (termHeight () - cmdWin->generic.height);
-  int srcHeight, dataHeight;
-  TuiWinType winType;
-  TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
-
-
-  dataHeight = totalHeight / 2;
-  srcHeight = totalHeight - dataHeight;
-  m_allBeInvisible ();
-  m_beInvisible (locator);
-  _makeDataWindow (&dataWin, dataHeight, 0);
-  dataWin->canHighlight = TRUE;
-  if (newLayout == SRC_DATA_COMMAND)
-    winType = SRC_WIN;
-  else
-    winType = DISASSEM_WIN;
-  if (m_winPtrIsNull (winList[winType]))
-    {
-      if (winType == SRC_WIN)
-	_makeSourceWindow (&winList[winType], srcHeight, dataHeight - 1);
-      else
-	_makeDisassemWindow (&winList[winType], srcHeight, dataHeight - 1);
-      _initAndMakeWin ((Opaque *) & locator,
-		       LOCATOR_WIN,
-		       2 /* 1 */ ,
-		       termWidth (),
-		       0,
-		       totalHeight - 1,
-		       DONT_BOX_WINDOW);
-    }
-  else
-    {
-      _initGenWinInfo (&winList[winType]->generic,
-		       winList[winType]->generic.type,
-		       srcHeight,
-		       winList[winType]->generic.width,
-		   winList[winType]->detail.sourceInfo.executionInfo->width,
-		       dataHeight - 1);
-      _initGenWinInfo (winList[winType]->detail.sourceInfo.executionInfo,
-		       EXEC_INFO_WIN,
-		       srcHeight,
-		       3,
-		       0,
-		       dataHeight - 1);
-      m_beVisible (winList[winType]);
-      m_beVisible (winList[winType]->detail.sourceInfo.executionInfo);
-      _initGenWinInfo (locator,
-		       LOCATOR_WIN,
-		       2 /* 1 */ ,
-		       termWidth (),
-		       0,
-		       totalHeight - 1);
-    }
-  winList[winType]->detail.sourceInfo.hasLocator = TRUE;
-  m_beVisible (locator);
-  tuiShowLocatorContent ();
-  addToSourceWindows (winList[winType]);
-  setCurrentLayoutTo (newLayout);
-
-  return;
-}				/* _showData */
-
-/*
-   ** _initGenWinInfo().
- */
-static void
-_initGenWinInfo (TuiGenWinInfoPtr winInfo, TuiWinType type,
-                 int height, int width, int originX, int originY)
-{
-  int h = height;
-
-  winInfo->type = type;
-  winInfo->width = width;
-  winInfo->height = h;
-  if (h > 1)
-    {
-      winInfo->viewportHeight = h - 1;
-      if (winInfo->type != CMD_WIN)
-	winInfo->viewportHeight--;
-    }
-  else
-    winInfo->viewportHeight = 1;
-  winInfo->origin.x = originX;
-  winInfo->origin.y = originY;
-
-  return;
-}				/* _initGenWinInfo */
-
-/*
-   ** _initAndMakeWin().
- */
-static void
-_initAndMakeWin (Opaque * winInfoPtr, TuiWinType winType,
-                 int height, int width, int originX, int originY, int boxIt)
-{
-  Opaque opaqueWinInfo = *winInfoPtr;
-  TuiGenWinInfoPtr generic;
-
-  if (opaqueWinInfo == (Opaque) NULL)
-    {
-      if (m_winIsAuxillary (winType))
-	opaqueWinInfo = (Opaque) allocGenericWinInfo ();
-      else
-	opaqueWinInfo = (Opaque) allocWinInfo (winType);
-    }
-  if (m_winIsAuxillary (winType))
-    generic = (TuiGenWinInfoPtr) opaqueWinInfo;
-  else
-    generic = &((TuiWinInfoPtr) opaqueWinInfo)->generic;
-
-  if (opaqueWinInfo != (Opaque) NULL)
-    {
-      _initGenWinInfo (generic, winType, height, width, originX, originY);
-      if (!m_winIsAuxillary (winType))
-	{
-	  if (generic->type == CMD_WIN)
-	    ((TuiWinInfoPtr) opaqueWinInfo)->canHighlight = FALSE;
-	  else
-	    ((TuiWinInfoPtr) opaqueWinInfo)->canHighlight = TRUE;
-	}
-      makeWindow (generic, boxIt);
-    }
-  *winInfoPtr = opaqueWinInfo;
-}
-
-
-/*
-   ** _makeSourceOrDisassemWindow().
- */
-static void
-_makeSourceOrDisassemWindow (TuiWinInfoPtr * winInfoPtr, TuiWinType type,
-                             int height, int originY)
-{
-  TuiGenWinInfoPtr executionInfo = (TuiGenWinInfoPtr) NULL;
-
-  /*
-     ** Create the exeuction info window.
-   */
-  if (type == SRC_WIN)
-    executionInfo = sourceExecInfoWinPtr ();
-  else
-    executionInfo = disassemExecInfoWinPtr ();
-  _initAndMakeWin ((Opaque *) & executionInfo,
-		   EXEC_INFO_WIN,
-		   height,
-		   3,
-		   0,
-		   originY,
-		   DONT_BOX_WINDOW);
-  /*
-     ** Now create the source window.
-   */
-  _initAndMakeWin ((Opaque *) winInfoPtr,
-		   type,
-		   height,
-		   termWidth () - executionInfo->width,
-		   executionInfo->width,
-		   originY,
-		   BOX_WINDOW);
-
-  (*winInfoPtr)->detail.sourceInfo.executionInfo = executionInfo;
-
-  return;
-}				/* _makeSourceOrDisassemWindow */
-
-
-/*
-   **    _showSourceOrDisassemAndCommand().
-   **        Show the Source/Command or the Disassem layout
- */
-static void
-_showSourceOrDisassemAndCommand (TuiLayoutType layoutType)
-{
-  if (currentLayout () != layoutType)
-    {
-      TuiWinInfoPtr *winInfoPtr;
-      int srcHeight, cmdHeight;
-      TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
-
-      if (m_winPtrNotNull (cmdWin))
-	cmdHeight = cmdWin->generic.height;
-      else
-	cmdHeight = termHeight () / 3;
-      srcHeight = termHeight () - cmdHeight;
-
-
-      if (layoutType == SRC_COMMAND)
-	winInfoPtr = &srcWin;
-      else
-	winInfoPtr = &disassemWin;
-
-      if (m_winPtrIsNull (*winInfoPtr))
-	{
-	  if (layoutType == SRC_COMMAND)
-	    _makeSourceWindow (winInfoPtr, srcHeight - 1, 0);
-	  else
-	    _makeDisassemWindow (winInfoPtr, srcHeight - 1, 0);
-	  _initAndMakeWin ((Opaque *) & locator,
-			   LOCATOR_WIN,
-			   2 /* 1 */ ,
-			   termWidth (),
-			   0,
-			   srcHeight - 1,
-			   DONT_BOX_WINDOW);
-	}
-      else
-	{
-	  _initGenWinInfo (locator,
-			   LOCATOR_WIN,
-			   2 /* 1 */ ,
-			   termWidth (),
-			   0,
-			   srcHeight - 1);
-	  (*winInfoPtr)->detail.sourceInfo.hasLocator = TRUE;
-	  _initGenWinInfo (
-			    &(*winInfoPtr)->generic,
-			    (*winInfoPtr)->generic.type,
-			    srcHeight - 1,
-			    (*winInfoPtr)->generic.width,
-		      (*winInfoPtr)->detail.sourceInfo.executionInfo->width,
-			    0);
-	  _initGenWinInfo ((*winInfoPtr)->detail.sourceInfo.executionInfo,
-			   EXEC_INFO_WIN,
-			   srcHeight - 1,
-			   3,
-			   0,
-			   0);
-	  (*winInfoPtr)->canHighlight = TRUE;
-	  m_beVisible (*winInfoPtr);
-	  m_beVisible ((*winInfoPtr)->detail.sourceInfo.executionInfo);
-	}
-      if (m_winPtrNotNull (*winInfoPtr))
-	{
-	  (*winInfoPtr)->detail.sourceInfo.hasLocator = TRUE;
-	  m_beVisible (locator);
-	  tuiShowLocatorContent ();
-	  tuiShowSourceContent (*winInfoPtr);
-
-	  if (m_winPtrIsNull (cmdWin))
-	    {
-	      _makeCommandWindow (&cmdWin, cmdHeight, srcHeight);
-	      tuiRefreshWin (&cmdWin->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;
-	      m_beVisible (cmdWin);
-	    }
-	}
-      setCurrentLayoutTo (layoutType);
-    }
-
-  return;
-}				/* _showSourceOrDisassemAndCommand */
diff --git a/gdb/tui/tuiRegs.c b/gdb/tui/tuiRegs.c
deleted file mode 100644
index 9f0b1a4d845..00000000000
--- a/gdb/tui/tuiRegs.c
+++ /dev/null
@@ -1,1047 +0,0 @@
-/* TUI display registers in window.
-
-   Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
-   Inc.
-
-   Contributed by Hewlett-Packard Company.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#include "defs.h"
-#include "tui.h"
-#include "tuiData.h"
-#include "symtab.h"
-#include "gdbtypes.h"
-#include "gdbcmd.h"
-#include "frame.h"
-#include "regcache.h"
-#include "inferior.h"
-#include "target.h"
-#include "tuiLayout.h"
-#include "tuiWin.h"
-#include "tuiDataWin.h"
-#include "tuiGeneralWin.h"
-#include "tui-file.h"
-
-#ifdef HAVE_NCURSES_H       
-#include <ncurses.h>
-#else
-#ifdef HAVE_CURSES_H
-#include <curses.h>
-#endif
-#endif
-
-/*****************************************
-** LOCAL DEFINITIONS                    **
-******************************************/
-#define DOUBLE_FLOAT_LABEL_WIDTH    6
-#define DOUBLE_FLOAT_LABEL_FMT      "%6.6s: "
-#define DOUBLE_FLOAT_VALUE_WIDTH    30	/*min of 16 but may be in sci notation */
-
-#define SINGLE_FLOAT_LABEL_WIDTH    6
-#define SINGLE_FLOAT_LABEL_FMT      "%6.6s: "
-#define SINGLE_FLOAT_VALUE_WIDTH    25	/* min of 8 but may be in sci notation */
-
-#define SINGLE_LABEL_WIDTH    16
-#define SINGLE_LABEL_FMT      "%10.10s: "
-#define SINGLE_VALUE_WIDTH    20 /* minimum of 8 but may be in sci notation */
-
-/* In the code HP gave Cygnus, this was actually a function call to a
-   PA-specific function, which was supposed to determine whether the
-   target was a 64-bit or 32-bit processor.  However, the 64-bit
-   support wasn't complete, so we didn't merge that in, so we leave
-   this here as a stub.  */
-#define IS_64BIT 0
-
-/*****************************************
-** STATIC DATA                          **
-******************************************/
-
-
-/*****************************************
-** STATIC LOCAL FUNCTIONS FORWARD DECLS    **
-******************************************/
-static TuiStatus _tuiSetRegsContent
-  (int, int, struct frame_info *, TuiRegisterDisplayType, int);
-static const char *_tuiRegisterName (int);
-static TuiStatus _tuiGetRegisterRawValue (int, char *, struct frame_info *);
-static void _tuiSetRegisterElement
-  (int, struct frame_info *, TuiDataElementPtr, int);
-static void _tuiDisplayRegister (int, TuiGenWinInfoPtr, enum precision_type);
-static void _tuiRegisterFormat
-  (char *, int, int, TuiDataElementPtr, enum precision_type);
-static TuiStatus _tuiSetGeneralRegsContent (int);
-static TuiStatus _tuiSetSpecialRegsContent (int);
-static TuiStatus _tuiSetGeneralAndSpecialRegsContent (int);
-static TuiStatus _tuiSetFloatRegsContent (TuiRegisterDisplayType, int);
-static int _tuiRegValueHasChanged
-  (TuiDataElementPtr, struct frame_info *, char *);
-static void _tuiShowFloat_command (char *, int);
-static void _tuiShowGeneral_command (char *, int);
-static void _tuiShowSpecial_command (char *, int);
-static void _tui_vShowRegisters_commandSupport (TuiRegisterDisplayType);
-static void _tuiToggleFloatRegs_command (char *, int);
-static void _tuiScrollRegsForward_command (char *, int);
-static void _tuiScrollRegsBackward_command (char *, int);
-
-
-
-/*****************************************
-** PUBLIC FUNCTIONS                     **
-******************************************/
-
-/*
-   ** tuiLastRegsLineNo()
-   **        Answer the number of the last line in the regs display.
-   **        If there are no registers (-1) is returned.
- */
-int
-tuiLastRegsLineNo (void)
-{
-  register int numLines = (-1);
-
-  if (dataWin->detail.dataDisplayInfo.regsContentCount > 0)
-    {
-      numLines = (dataWin->detail.dataDisplayInfo.regsContentCount /
-		  dataWin->detail.dataDisplayInfo.regsColumnCount);
-      if (dataWin->detail.dataDisplayInfo.regsContentCount %
-	  dataWin->detail.dataDisplayInfo.regsColumnCount)
-	numLines++;
-    }
-  return numLines;
-}				/* tuiLastRegsLineNo */
-
-
-/*
-   ** tuiLineFromRegElementNo()
-   **        Answer the line number that the register element at elementNo is
-   **        on.  If elementNo is greater than the number of register elements
-   **        there are, -1 is returned.
- */
-int
-tuiLineFromRegElementNo (int elementNo)
-{
-  if (elementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
-    {
-      int i, line = (-1);
-
-      i = 1;
-      while (line == (-1))
-	{
-	  if (elementNo <
-	      (dataWin->detail.dataDisplayInfo.regsColumnCount * i))
-	    line = i - 1;
-	  else
-	    i++;
-	}
-
-      return line;
-    }
-  else
-    return (-1);
-}				/* tuiLineFromRegElementNo */
-
-
-/*
-   ** tuiFirstRegElementNoInLine()
-   **        Answer the index of the first element in lineNo.  If lineNo is
-   **        past the register area (-1) is returned.
- */
-int
-tuiFirstRegElementNoInLine (int lineNo)
-{
-  if ((lineNo * dataWin->detail.dataDisplayInfo.regsColumnCount)
-      <= dataWin->detail.dataDisplayInfo.regsContentCount)
-    return ((lineNo + 1) *
-	    dataWin->detail.dataDisplayInfo.regsColumnCount) -
-      dataWin->detail.dataDisplayInfo.regsColumnCount;
-  else
-    return (-1);
-}				/* tuiFirstRegElementNoInLine */
-
-
-/*
-   ** tuiLastRegElementNoInLine()
-   **        Answer the index of the last element in lineNo.  If lineNo is past
-   **        the register area (-1) is returned.
- */
-int
-tuiLastRegElementNoInLine (int lineNo)
-{
-  if ((lineNo * dataWin->detail.dataDisplayInfo.regsColumnCount) <=
-      dataWin->detail.dataDisplayInfo.regsContentCount)
-    return ((lineNo + 1) *
-	    dataWin->detail.dataDisplayInfo.regsColumnCount) - 1;
-  else
-    return (-1);
-}				/* tuiLastRegElementNoInLine */
-
-
-/*
-   ** tuiCalculateRegsColumnCount
-   **        Calculate the number of columns that should be used to display
-   **        the registers.
- */
-int
-tuiCalculateRegsColumnCount (TuiRegisterDisplayType dpyType)
-{
-  int colCount, colWidth;
-
-  if (IS_64BIT || dpyType == TUI_DFLOAT_REGS)
-    colWidth = DOUBLE_FLOAT_VALUE_WIDTH + DOUBLE_FLOAT_LABEL_WIDTH;
-  else
-    {
-      if (dpyType == TUI_SFLOAT_REGS)
-	colWidth = SINGLE_FLOAT_VALUE_WIDTH + SINGLE_FLOAT_LABEL_WIDTH;
-      else
-	colWidth = SINGLE_VALUE_WIDTH + SINGLE_LABEL_WIDTH;
-    }
-  colCount = (dataWin->generic.width - 2) / colWidth;
-
-  return colCount;
-}				/* tuiCalulateRegsColumnCount */
-
-
-/*
-   ** tuiShowRegisters().
-   **        Show the registers int the data window as indicated by dpyType.
-   **        If there is any other registers being displayed, then they are
-   **        cleared.  What registers are displayed is dependent upon dpyType.
- */
-void
-tuiShowRegisters (TuiRegisterDisplayType dpyType)
-{
-  TuiStatus ret = TUI_FAILURE;
-  int refreshValuesOnly = FALSE;
-
-  /* Say that registers should be displayed, even if there is a problem */
-  dataWin->detail.dataDisplayInfo.displayRegs = TRUE;
-
-  if (target_has_registers)
-    {
-      refreshValuesOnly =
-	(dpyType == dataWin->detail.dataDisplayInfo.regsDisplayType);
-      switch (dpyType)
-	{
-	case TUI_GENERAL_REGS:
-	  ret = _tuiSetGeneralRegsContent (refreshValuesOnly);
-	  break;
-	case TUI_SFLOAT_REGS:
-	case TUI_DFLOAT_REGS:
-	  ret = _tuiSetFloatRegsContent (dpyType, refreshValuesOnly);
-	  break;
-
-/* could ifdef out */
-
-	case TUI_SPECIAL_REGS:
-	  ret = _tuiSetSpecialRegsContent (refreshValuesOnly);
-	  break;
-	case TUI_GENERAL_AND_SPECIAL_REGS:
-	  ret = _tuiSetGeneralAndSpecialRegsContent (refreshValuesOnly);
-	  break;
-
-/* end of potential if def */
-
-	default:
-	  break;
-	}
-    }
-  if (ret == TUI_FAILURE)
-    {
-      dataWin->detail.dataDisplayInfo.regsDisplayType = TUI_UNDEFINED_REGS;
-      tuiEraseDataContent (NO_REGS_STRING);
-    }
-  else
-    {
-      int i;
-
-      /* Clear all notation of changed values */
-      for (i = 0; (i < dataWin->detail.dataDisplayInfo.regsContentCount); i++)
-	{
-	  TuiGenWinInfoPtr dataItemWin;
-
-	  dataItemWin = &dataWin->detail.dataDisplayInfo.
-	    regsContent[i]->whichElement.dataWindow;
-	  (&((TuiWinElementPtr)
-	     dataItemWin->content[0])->whichElement.data)->highlight = FALSE;
-	}
-      dataWin->detail.dataDisplayInfo.regsDisplayType = dpyType;
-      tuiDisplayAllData ();
-    }
-  (tuiLayoutDef ())->regsDisplayType = dpyType;
-
-  return;
-}				/* tuiShowRegisters */
-
-
-/*
-   ** tuiDisplayRegistersFrom().
-   **        Function to display the registers in the content from
-   **        'startElementNo' until the end of the register content or the
-   **        end of the display height.  No checking for displaying past
-   **        the end of the registers is done here.
- */
-void
-tuiDisplayRegistersFrom (int startElementNo)
-{
-  if (dataWin->detail.dataDisplayInfo.regsContent != (TuiWinContent) NULL &&
-      dataWin->detail.dataDisplayInfo.regsContentCount > 0)
-    {
-      register int i = startElementNo;
-      int j, valueCharsWide, itemWinWidth, curY, labelWidth;
-      enum precision_type precision;
-
-      precision = (dataWin->detail.dataDisplayInfo.regsDisplayType
-		   == TUI_DFLOAT_REGS) ?
-	double_precision : unspecified_precision;
-      if (IS_64BIT ||
-	  dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_DFLOAT_REGS)
-	{
-	  valueCharsWide = DOUBLE_FLOAT_VALUE_WIDTH;
-	  labelWidth = DOUBLE_FLOAT_LABEL_WIDTH;
-	}
-      else
-	{
-	  if (dataWin->detail.dataDisplayInfo.regsDisplayType ==
-	      TUI_SFLOAT_REGS)
-	    {
-	      valueCharsWide = SINGLE_FLOAT_VALUE_WIDTH;
-	      labelWidth = SINGLE_FLOAT_LABEL_WIDTH;
-	    }
-	  else
-	    {
-	      valueCharsWide = SINGLE_VALUE_WIDTH;
-	      labelWidth = SINGLE_LABEL_WIDTH;
-	    }
-	}
-      itemWinWidth = valueCharsWide + labelWidth;
-      /*
-         ** Now create each data "sub" window, and write the display into it.
-       */
-      curY = 1;
-      while (i < dataWin->detail.dataDisplayInfo.regsContentCount &&
-	     curY <= dataWin->generic.viewportHeight)
-	{
-	  for (j = 0;
-	       (j < dataWin->detail.dataDisplayInfo.regsColumnCount &&
-		i < dataWin->detail.dataDisplayInfo.regsContentCount); j++)
-	    {
-	      TuiGenWinInfoPtr dataItemWin;
-	      TuiDataElementPtr dataElementPtr;
-
-	      /* create the window if necessary */
-	      dataItemWin = &dataWin->detail.dataDisplayInfo.
-		regsContent[i]->whichElement.dataWindow;
-	      dataElementPtr = &((TuiWinElementPtr)
-				 dataItemWin->content[0])->whichElement.data;
-	      if (dataItemWin->handle == (WINDOW *) NULL)
-		{
-		  dataItemWin->height = 1;
-		  dataItemWin->width = (precision == double_precision) ?
-		    itemWinWidth + 2 : itemWinWidth + 1;
-		  dataItemWin->origin.x = (itemWinWidth * j) + 1;
-		  dataItemWin->origin.y = curY;
-		  makeWindow (dataItemWin, DONT_BOX_WINDOW);
-                  scrollok (dataItemWin->handle, FALSE);
-		}
-              touchwin (dataItemWin->handle);
-
-	      /*
-	         ** Get the printable representation of the register
-	         ** and display it
-	       */
-	      _tuiDisplayRegister (
-			    dataElementPtr->itemNo, dataItemWin, precision);
-	      i++;		/* next register */
-	    }
-	  curY++;		/* next row; */
-	}
-    }
-
-  return;
-}				/* tuiDisplayRegistersFrom */
-
-
-/*
-   ** tuiDisplayRegElementAtLine().
-   **        Function to display the registers in the content from
-   **        'startElementNo' on 'startLineNo' until the end of the
-   **        register content or the end of the display height.
-   **        This function checks that we won't display off the end
-   **        of the register display.
- */
-void
-tuiDisplayRegElementAtLine (int startElementNo, int startLineNo)
-{
-  if (dataWin->detail.dataDisplayInfo.regsContent != (TuiWinContent) NULL &&
-      dataWin->detail.dataDisplayInfo.regsContentCount > 0)
-    {
-      register int elementNo = startElementNo;
-
-      if (startElementNo != 0 && startLineNo != 0)
-	{
-	  register int lastLineNo, firstLineOnLastPage;
-
-	  lastLineNo = tuiLastRegsLineNo ();
-	  firstLineOnLastPage = lastLineNo - (dataWin->generic.height - 2);
-	  if (firstLineOnLastPage < 0)
-	    firstLineOnLastPage = 0;
-	  /*
-	     ** If there is no other data displayed except registers,
-	     ** 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 &&
-	      startLineNo > firstLineOnLastPage)
-	    elementNo = tuiFirstRegElementNoInLine (firstLineOnLastPage);
-	}
-      tuiDisplayRegistersFrom (elementNo);
-    }
-
-  return;
-}				/* tuiDisplayRegElementAtLine */
-
-
-
-/*
-   ** tuiDisplayRegistersFromLine().
-   **        Function to display the registers starting at line lineNo in
-   **        the data window.  Answers the line number that the display
-   **        actually started from.  If nothing is displayed (-1) is returned.
- */
-int
-tuiDisplayRegistersFromLine (int lineNo, int forceDisplay)
-{
-  if (dataWin->detail.dataDisplayInfo.regsContentCount > 0)
-    {
-      int line, elementNo;
-
-      if (lineNo < 0)
-	line = 0;
-      else if (forceDisplay)
-	{			/*
-				   ** If we must display regs (forceDisplay is true), then make
-				   ** sure that we don't display off the end of the registers.
-				 */
-	  if (lineNo >= tuiLastRegsLineNo ())
-	    {
-	      if ((line = tuiLineFromRegElementNo (
-		 dataWin->detail.dataDisplayInfo.regsContentCount - 1)) < 0)
-		line = 0;
-	    }
-	  else
-	    line = lineNo;
-	}
-      else
-	line = lineNo;
-
-      elementNo = tuiFirstRegElementNoInLine (line);
-      if (elementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
-	tuiDisplayRegElementAtLine (elementNo, line);
-      else
-	line = (-1);
-
-      return line;
-    }
-
-  return (-1);			/* nothing was displayed */
-}				/* tuiDisplayRegistersFromLine */
-
-
-/*
-   ** tuiCheckRegisterValues()
-   **        This function check all displayed registers for changes in
-   **        values, given a particular frame.  If the values have changed,
-   **        they are updated with the new value and highlighted.
- */
-void
-tuiCheckRegisterValues (struct frame_info *frame)
-{
-  if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
-    {
-      if (dataWin->detail.dataDisplayInfo.regsContentCount <= 0 &&
-	  dataWin->detail.dataDisplayInfo.displayRegs)
-	tuiShowRegisters ((tuiLayoutDef ())->regsDisplayType);
-      else
-	{
-	  int i, j;
-	  char rawBuf[MAX_REGISTER_SIZE];
-
-	  for (i = 0;
-	       (i < dataWin->detail.dataDisplayInfo.regsContentCount); i++)
-	    {
-	      TuiDataElementPtr dataElementPtr;
-	      TuiGenWinInfoPtr dataItemWinPtr;
-	      int wasHilighted;
-
-	      dataItemWinPtr = &dataWin->detail.dataDisplayInfo.
-		regsContent[i]->whichElement.dataWindow;
-	      dataElementPtr = &((TuiWinElementPtr)
-			     dataItemWinPtr->content[0])->whichElement.data;
-	      wasHilighted = dataElementPtr->highlight;
-	      dataElementPtr->highlight =
-		_tuiRegValueHasChanged (dataElementPtr, frame, &rawBuf[0]);
-	      if (dataElementPtr->highlight)
-		{
-                  int size;
-
-                  size = REGISTER_RAW_SIZE (dataElementPtr->itemNo);
-		  for (j = 0; j < size; j++)
-		    ((char *) dataElementPtr->value)[j] = rawBuf[j];
-		  _tuiDisplayRegister (
-					dataElementPtr->itemNo,
-					dataItemWinPtr,
-			((dataWin->detail.dataDisplayInfo.regsDisplayType ==
-			  TUI_DFLOAT_REGS) ?
-			 double_precision : unspecified_precision));
-		}
-	      else if (wasHilighted)
-		{
-		  dataElementPtr->highlight = FALSE;
-		  _tuiDisplayRegister (
-					dataElementPtr->itemNo,
-					dataItemWinPtr,
-			((dataWin->detail.dataDisplayInfo.regsDisplayType ==
-			  TUI_DFLOAT_REGS) ?
-			 double_precision : unspecified_precision));
-		}
-	    }
-	}
-    }
-  return;
-}				/* tuiCheckRegisterValues */
-
-
-/*
-   ** tuiToggleFloatRegs().
- */
-void
-tuiToggleFloatRegs (void)
-{
-  TuiLayoutDefPtr layoutDef = tuiLayoutDef ();
-
-  if (layoutDef->floatRegsDisplayType == TUI_SFLOAT_REGS)
-    layoutDef->floatRegsDisplayType = TUI_DFLOAT_REGS;
-  else
-    layoutDef->floatRegsDisplayType = TUI_SFLOAT_REGS;
-
-  if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible &&
-      (dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_SFLOAT_REGS ||
-       dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_DFLOAT_REGS))
-    tuiShowRegisters (layoutDef->floatRegsDisplayType);
-
-  return;
-}				/* tuiToggleFloatRegs */
-
-
-void
-_initialize_tuiRegs (void)
-{
-  if (xdb_commands)
-    {
-      add_com ("fr", class_tui, _tuiShowFloat_command,
-	       "Display only floating point registers\n");
-      add_com ("gr", class_tui, _tuiShowGeneral_command,
-	       "Display only general registers\n");
-      add_com ("sr", class_tui, _tuiShowSpecial_command,
-	       "Display only special registers\n");
-      add_com ("+r", class_tui, _tuiScrollRegsForward_command,
-	       "Scroll the registers window forward\n");
-      add_com ("-r", class_tui, _tuiScrollRegsBackward_command,
-	       "Scroll the register window backward\n");
-      add_com ("tf", class_tui, _tuiToggleFloatRegs_command,
-	       "Toggle between single and double precision floating point registers.\n");
-      add_cmd (TUI_FLOAT_REGS_NAME_LOWER,
-	       class_tui,
-	       _tuiToggleFloatRegs_command,
-	       "Toggle between single and double precision floating point \
-registers.\n",
-	       &togglelist);
-    }
-}
-
-
-/*****************************************
-** STATIC LOCAL FUNCTIONS                 **
-******************************************/
-
-
-/*
-   ** _tuiRegisterName().
-   **        Return the register name.
- */
-static const char *
-_tuiRegisterName (int regNum)
-{
-  return REGISTER_NAME (regNum);
-}
-extern int pagination_enabled;
-
-static void
-tui_restore_gdbout (void *ui)
-{
-  ui_file_delete (gdb_stdout);
-  gdb_stdout = (struct ui_file*) ui;
-  pagination_enabled = 1;
-}
-
-/*
-   ** _tuiRegisterFormat
-   **        Function to format the register name and value into a buffer,
-   **        suitable for printing or display
- */
-static void
-_tuiRegisterFormat (char *buf, int bufLen, int regNum,
-                    TuiDataElementPtr dataElement,
-                    enum precision_type precision)
-{
-  struct ui_file *stream;
-  struct ui_file *old_stdout;
-  const char *name;
-  struct cleanup *cleanups;
-  char *p;
-  int pos;
-
-  name = REGISTER_NAME (regNum);
-  if (name == 0)
-    {
-      strcpy (buf, "");
-      return;
-    }
-  
-  pagination_enabled = 0;
-  old_stdout = gdb_stdout;
-  stream = tui_sfileopen (bufLen);
-  gdb_stdout = stream;
-  cleanups = make_cleanup (tui_restore_gdbout, (void*) old_stdout);
-  gdbarch_print_registers_info (current_gdbarch, stream, deprecated_selected_frame,
-                                regNum, 1);
-
-  /* Save formatted output in the buffer.  */
-  p = tui_file_get_strbuf (stream);
-  pos = 0;
-  while (*p && *p == *name++ && bufLen)
-    {
-      *buf++ = *p++;
-      bufLen--;
-      pos++;
-    }
-  while (*p == ' ')
-    p++;
-  while (pos < 8 && bufLen)
-    {
-      *buf++ = ' ';
-      bufLen--;
-      pos++;
-    }
-  strncpy (buf, p, bufLen);
-
-  /* Remove the possible \n.  */
-  p = strchr (buf, '\n');
-  if (p)
-    *p = 0;
-
-  do_cleanups (cleanups);
-}
-
-
-#define NUM_GENERAL_REGS    32
-/*
-   ** _tuiSetGeneralRegsContent().
-   **      Set the content of the data window to consist of the general registers.
- */
-static TuiStatus
-_tuiSetGeneralRegsContent (int refreshValuesOnly)
-{
-  return (_tuiSetRegsContent (0,
-			      NUM_GENERAL_REGS - 1,
-			      deprecated_selected_frame,
-			      TUI_GENERAL_REGS,
-			      refreshValuesOnly));
-
-}				/* _tuiSetGeneralRegsContent */
-
-
-#ifndef PCOQ_HEAD_REGNUM
-#define START_SPECIAL_REGS  0
-#else
-#define START_SPECIAL_REGS    PCOQ_HEAD_REGNUM
-#endif
-
-/*
-   ** _tuiSetSpecialRegsContent().
-   **      Set the content of the data window to consist of the special registers.
- */
-static TuiStatus
-_tuiSetSpecialRegsContent (int refreshValuesOnly)
-{
-  TuiStatus ret = TUI_FAILURE;
-  int endRegNum;
-
-  endRegNum = FP0_REGNUM - 1;
-  ret = _tuiSetRegsContent (START_SPECIAL_REGS,
-			    endRegNum,
-			    deprecated_selected_frame,
-			    TUI_SPECIAL_REGS,
-			    refreshValuesOnly);
-
-  return ret;
-}				/* _tuiSetSpecialRegsContent */
-
-
-/*
-   ** _tuiSetGeneralAndSpecialRegsContent().
-   **      Set the content of the data window to consist of the special registers.
- */
-static TuiStatus
-_tuiSetGeneralAndSpecialRegsContent (int refreshValuesOnly)
-{
-  TuiStatus ret = TUI_FAILURE;
-  int endRegNum = (-1);
-
-  endRegNum = FP0_REGNUM - 1;
-  ret = _tuiSetRegsContent (
-	 0, endRegNum, deprecated_selected_frame, TUI_SPECIAL_REGS, refreshValuesOnly);
-
-  return ret;
-}				/* _tuiSetGeneralAndSpecialRegsContent */
-
-/*
-   ** _tuiSetFloatRegsContent().
-   **        Set the content of the data window to consist of the float registers.
- */
-static TuiStatus
-_tuiSetFloatRegsContent (TuiRegisterDisplayType dpyType, int refreshValuesOnly)
-{
-  TuiStatus ret = TUI_FAILURE;
-  int startRegNum;
-
-  startRegNum = FP0_REGNUM;
-  ret = _tuiSetRegsContent (startRegNum,
-			    NUM_REGS - 1,
-			    deprecated_selected_frame,
-			    dpyType,
-			    refreshValuesOnly);
-
-  return ret;
-}				/* _tuiSetFloatRegsContent */
-
-
-/*
-   ** _tuiRegValueHasChanged().
-   **        Answer TRUE if the register's value has changed, FALSE otherwise.
-   **        If TRUE, newValue is filled in with the new value.
- */
-static int
-_tuiRegValueHasChanged (TuiDataElementPtr dataElement,
-                        struct frame_info *frame,
-                        char *newValue)
-{
-  int hasChanged = FALSE;
-
-  if (dataElement->itemNo != UNDEFINED_ITEM &&
-      _tuiRegisterName (dataElement->itemNo) != (char *) NULL)
-    {
-      char rawBuf[MAX_REGISTER_SIZE];
-      int i;
-
-      if (_tuiGetRegisterRawValue (
-			 dataElement->itemNo, rawBuf, frame) == TUI_SUCCESS)
-	{
-          int size = REGISTER_RAW_SIZE (dataElement->itemNo);
-          
-	  for (i = 0; (i < size && !hasChanged); i++)
-	    hasChanged = (((char *) dataElement->value)[i] != rawBuf[i]);
-	  if (hasChanged && newValue != (char *) NULL)
-	    {
-	      for (i = 0; i < size; i++)
-		newValue[i] = rawBuf[i];
-	    }
-	}
-    }
-  return hasChanged;
-}				/* _tuiRegValueHasChanged */
-
-
-
-/*
-   ** _tuiGetRegisterRawValue().
-   **        Get the register raw value.  The raw value is returned in regValue.
- */
-static TuiStatus
-_tuiGetRegisterRawValue (int regNum, char *regValue, struct frame_info *frame)
-{
-  TuiStatus ret = TUI_FAILURE;
-
-  if (target_has_registers)
-    {
-      frame_read_register (frame, regNum, regValue);
-      /* NOTE: cagney/2003-03-13: This is bogus.  It is refering to
-         the register cache and not the frame which could have pulled
-         the register value off the stack.  */
-      if (register_cached (regNum) >= 0)
-	ret = TUI_SUCCESS;
-    }
-  return ret;
-}				/* _tuiGetRegisterRawValue */
-
-
-
-/*
-   ** _tuiSetRegisterElement().
-   **       Function to initialize a data element with the input and
-   **       the register value.
- */
-static void
-_tuiSetRegisterElement (int regNum, struct frame_info *frame,
-                        TuiDataElementPtr dataElement,
-                        int refreshValueOnly)
-{
-  if (dataElement != (TuiDataElementPtr) NULL)
-    {
-      if (!refreshValueOnly)
-	{
-	  dataElement->itemNo = regNum;
-	  dataElement->name = _tuiRegisterName (regNum);
-	  dataElement->highlight = FALSE;
-	}
-      if (dataElement->value == (Opaque) NULL)
-	dataElement->value = (Opaque) xmalloc (MAX_REGISTER_SIZE);
-      if (dataElement->value != (Opaque) NULL)
-	_tuiGetRegisterRawValue (regNum, dataElement->value, frame);
-    }
-
-  return;
-}				/* _tuiSetRegisterElement */
-
-
-/*
-   ** _tuiSetRegsContent().
-   **        Set the content of the data window to consist of the registers
-   **        numbered from startRegNum to endRegNum.  Note that if
-   **        refreshValuesOnly is TRUE, startRegNum and endRegNum are ignored.
- */
-static TuiStatus
-_tuiSetRegsContent (int startRegNum, int endRegNum,
-                    struct frame_info *frame,
-                    TuiRegisterDisplayType dpyType,
-                    int refreshValuesOnly)
-{
-  TuiStatus ret = TUI_FAILURE;
-  int numRegs = endRegNum - startRegNum + 1;
-  int allocatedHere = FALSE;
-
-  if (dataWin->detail.dataDisplayInfo.regsContentCount > 0 &&
-      !refreshValuesOnly)
-    {
-      freeDataContent (dataWin->detail.dataDisplayInfo.regsContent,
-		       dataWin->detail.dataDisplayInfo.regsContentCount);
-      dataWin->detail.dataDisplayInfo.regsContentCount = 0;
-    }
-  if (dataWin->detail.dataDisplayInfo.regsContentCount <= 0)
-    {
-      dataWin->detail.dataDisplayInfo.regsContent =
-	allocContent (numRegs, DATA_WIN);
-      allocatedHere = TRUE;
-    }
-
-  if (dataWin->detail.dataDisplayInfo.regsContent != (TuiWinContent) NULL)
-    {
-      int i;
-
-      if (!refreshValuesOnly || allocatedHere)
-	{
-	  dataWin->generic.content = (OpaquePtr) NULL;
-	  dataWin->generic.contentSize = 0;
-	  addContentElements (&dataWin->generic, numRegs);
-	  dataWin->detail.dataDisplayInfo.regsContent =
-	    (TuiWinContent) dataWin->generic.content;
-	  dataWin->detail.dataDisplayInfo.regsContentCount = numRegs;
-	}
-      /*
-         ** Now set the register names and values
-       */
-      for (i = startRegNum; (i <= endRegNum); i++)
-	{
-	  TuiGenWinInfoPtr dataItemWin;
-
-	  dataItemWin = &dataWin->detail.dataDisplayInfo.
-	    regsContent[i - startRegNum]->whichElement.dataWindow;
-	  _tuiSetRegisterElement (
-				   i,
-				   frame,
-	   &((TuiWinElementPtr) dataItemWin->content[0])->whichElement.data,
-				   !allocatedHere && refreshValuesOnly);
-	}
-      dataWin->detail.dataDisplayInfo.regsColumnCount =
-	tuiCalculateRegsColumnCount (dpyType);
-#ifdef LATER
-      if (dataWin->detail.dataDisplayInfo.dataContentCount > 0)
-	{
-	  /* delete all the windows? */
-	  /* realloc content equal to dataContentCount + regsContentCount */
-	  /* append dataWin->detail.dataDisplayInfo.dataContent to content */
-	}
-#endif
-      dataWin->generic.contentSize =
-	dataWin->detail.dataDisplayInfo.regsContentCount +
-	dataWin->detail.dataDisplayInfo.dataContentCount;
-      ret = TUI_SUCCESS;
-    }
-
-  return ret;
-}				/* _tuiSetRegsContent */
-
-
-/*
-   ** _tuiDisplayRegister().
-   **        Function to display a register in a window.  If hilite is TRUE,
-   **        than the value will be displayed in reverse video
- */
-static void
-_tuiDisplayRegister (int regNum,
-                     TuiGenWinInfoPtr winInfo,		/* the data item window */
-                     enum precision_type precision)
-{
-  if (winInfo->handle != (WINDOW *) NULL)
-    {
-      int i;
-      char buf[40];
-      int valueCharsWide, labelWidth;
-      TuiDataElementPtr dataElementPtr = &((TuiWinContent)
-				    winInfo->content)[0]->whichElement.data;
-
-      if (IS_64BIT ||
-	  dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_DFLOAT_REGS)
-	{
-	  valueCharsWide = DOUBLE_FLOAT_VALUE_WIDTH;
-	  labelWidth = DOUBLE_FLOAT_LABEL_WIDTH;
-	}
-      else
-	{
-	  if (dataWin->detail.dataDisplayInfo.regsDisplayType ==
-	      TUI_SFLOAT_REGS)
-	    {
-	      valueCharsWide = SINGLE_FLOAT_VALUE_WIDTH;
-	      labelWidth = SINGLE_FLOAT_LABEL_WIDTH;
-	    }
-	  else
-	    {
-	      valueCharsWide = SINGLE_VALUE_WIDTH;
-	      labelWidth = SINGLE_LABEL_WIDTH;
-	    }
-	}
-
-      buf[0] = (char) 0;
-      _tuiRegisterFormat (buf,
-			  valueCharsWide + labelWidth,
-			  regNum,
-			  dataElementPtr,
-			  precision);
-
-      if (dataElementPtr->highlight)
-	wstandout (winInfo->handle);
-
-      wmove (winInfo->handle, 0, 0);
-      for (i = 1; i < winInfo->width; i++)
-        waddch (winInfo->handle, ' ');
-      wmove (winInfo->handle, 0, 0);
-      waddstr (winInfo->handle, buf);
-
-      if (dataElementPtr->highlight)
-	wstandend (winInfo->handle);
-      tuiRefreshWin (winInfo);
-    }
-  return;
-}				/* _tuiDisplayRegister */
-
-
-static void
-_tui_vShowRegisters_commandSupport (TuiRegisterDisplayType dpyType)
-{
-
-  if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
-    {				/* Data window already displayed, show the registers */
-      if (dataWin->detail.dataDisplayInfo.regsDisplayType != dpyType)
-	tuiShowRegisters (dpyType);
-    }
-  else
-    (tuiLayoutDef ())->regsDisplayType = dpyType;
-
-  return;
-}				/* _tui_vShowRegisters_commandSupport */
-
-
-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 ((tuiLayoutDef ())->floatRegsDisplayType);
-
-  return;
-}				/* _tuiShowFloat_command */
-
-
-static void
-_tuiShowGeneral_command (char *arg, int fromTTY)
-{
-  _tui_vShowRegisters_commandSupport (TUI_GENERAL_REGS);
-}
-
-
-static void
-_tuiShowSpecial_command (char *arg, int fromTTY)
-{
-  _tui_vShowRegisters_commandSupport (TUI_SPECIAL_REGS);
-}
-
-
-static void
-_tuiToggleFloatRegs_command (char *arg, int fromTTY)
-{
-  if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
-    tuiToggleFloatRegs ();
-  else
-    {
-      TuiLayoutDefPtr layoutDef = tuiLayoutDef ();
-
-      if (layoutDef->floatRegsDisplayType == TUI_SFLOAT_REGS)
-	layoutDef->floatRegsDisplayType = TUI_DFLOAT_REGS;
-      else
-	layoutDef->floatRegsDisplayType = TUI_SFLOAT_REGS;
-    }
-
-
-  return;
-}				/* _tuiToggleFloatRegs_command */
-
-
-static void
-_tuiScrollRegsForward_command (char *arg, int fromTTY)
-{
-  tui_scroll (FORWARD_SCROLL, dataWin, 1);
-}
-
-
-static void
-_tuiScrollRegsBackward_command (char *arg, int fromTTY)
-{
-  tui_scroll (BACKWARD_SCROLL, dataWin, 1);
-}
diff --git a/gdb/tui/tuiRegs.h b/gdb/tui/tuiRegs.h
deleted file mode 100644
index 8fbfbbf471a..00000000000
--- a/gdb/tui/tuiRegs.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/* TUI display registers in window.
-   Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
-   Contributed by Hewlett-Packard Company.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#ifndef _TUI_REGS_H
-#define _TUI_REGS_H
-
-/*****************************************
-** TYPE DEFINITIONS                        **
-******************************************/
-
-
-
-/*****************************************
-** PUBLIC FUNCTION EXTERNAL DECLS        **
-******************************************/
-extern void tuiCheckRegisterValues (struct frame_info *);
-extern void tuiShowRegisters (TuiRegisterDisplayType);
-extern void tuiDisplayRegistersFrom (int);
-extern int tuiDisplayRegistersFromLine (int, int);
-extern int tuiLastRegsLineNo (void);
-extern int tuiFirstRegElementInLine (int);
-extern int tuiLastRegElementInLine (int);
-extern int tuiLineFromRegElementNo (int);
-extern void tuiToggleFloatRegs (void);
-extern int tuiCalculateRegsColumnCount (TuiRegisterDisplayType);
-extern int tuiFirstRegElementNoInLine (int lineno);
-
-#endif
-/*_TUI_REGS_H*/
diff --git a/gdb/tui/tuiSource.c b/gdb/tui/tuiSource.c
deleted file mode 100644
index 6428130d780..00000000000
--- a/gdb/tui/tuiSource.c
+++ /dev/null
@@ -1,356 +0,0 @@
-/* TUI display source window.
-
-   Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
-   Inc.
-
-   Contributed by Hewlett-Packard Company.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#include "defs.h"
-#include <ctype.h>
-#include "symtab.h"
-#include "frame.h"
-#include "breakpoint.h"
-#include "source.h"
-#include "symtab.h"
-
-#include "tui.h"
-#include "tuiData.h"
-#include "tuiStack.h"
-#include "tuiSourceWin.h"
-#include "tuiSource.h"
-
-#ifdef HAVE_NCURSES_H       
-#include <ncurses.h>
-#else
-#ifdef HAVE_CURSES_H
-#include <curses.h>
-#endif
-#endif
-
-/* Function to display source in the source window.  */
-TuiStatus
-tuiSetSourceContent (struct symtab *s, int lineNo, int noerror)
-{
-  TuiStatus ret = TUI_FAILURE;
-
-  if (s != (struct symtab *) NULL && s->filename != (char *) NULL)
-    {
-      register FILE *stream;
-      register int i, desc, c, lineWidth, nlines;
-      register char *srcLine = 0;
-
-      if ((ret = tuiAllocSourceBuffer (srcWin)) == TUI_SUCCESS)
-	{
-	  lineWidth = srcWin->generic.width - 1;
-	  /* Take hilite (window border) into account, when calculating
-	     the number of lines  */
-	  nlines = (lineNo + (srcWin->generic.height - 2)) - lineNo;
-	  desc = open_source_file (s);
-	  if (desc < 0)
-	    {
-	      if (!noerror)
-		{
-		  char *name = alloca (strlen (s->filename) + 100);
-		  sprintf (name, "%s:%d", s->filename, lineNo);
-		  print_sys_errmsg (name, errno);
-		}
-	      ret = TUI_FAILURE;
-	    }
-	  else
-	    {
-	      if (s->line_charpos == 0)
-		find_source_lines (s, desc);
-
-	      if (lineNo < 1 || lineNo > s->nlines)
-		{
-		  close (desc);
-		  printf_unfiltered (
-			  "Line number %d out of range; %s has %d lines.\n",
-				      lineNo, s->filename, s->nlines);
-		}
-	      else if (lseek (desc, s->line_charpos[lineNo - 1], 0) < 0)
-		{
-		  close (desc);
-		  perror_with_name (s->filename);
-		}
-	      else
-		{
-		  register int offset, curLineNo, curLine, curLen, threshold;
-		  TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
-                  TuiSourceInfoPtr src = &srcWin->detail.sourceInfo;
-
-                  if (srcWin->generic.title)
-                    xfree (srcWin->generic.title);
-                  srcWin->generic.title = xstrdup (s->filename);
-
-                  if (src->filename)
-                    xfree (src->filename);
-                  src->filename = xstrdup (s->filename);
-
-		  /* Determine the threshold for the length of the line
-                     and the offset to start the display.  */
-		  offset = src->horizontalOffset;
-		  threshold = (lineWidth - 1) + offset;
-		  stream = fdopen (desc, FOPEN_RT);
-		  clearerr (stream);
-		  curLine = 0;
-		  curLineNo = src->startLineOrAddr.lineNo = lineNo;
-		  if (offset > 0)
-		    srcLine = (char *) xmalloc (
-					   (threshold + 1) * sizeof (char));
-		  while (curLine < nlines)
-		    {
-		      TuiWinElementPtr element = (TuiWinElementPtr)
-		      srcWin->generic.content[curLine];
-
-		      /* get the first character in the line */
-		      c = fgetc (stream);
-
-		      if (offset == 0)
-			srcLine = ((TuiWinElementPtr)
-				   srcWin->generic.content[
-					curLine])->whichElement.source.line;
-		      /* Init the line with the line number */
-		      sprintf (srcLine, "%-6d", curLineNo);
-		      curLen = strlen (srcLine);
-		      i = curLen -
-			((curLen / tuiDefaultTabLen ()) * tuiDefaultTabLen ());
-		      while (i < tuiDefaultTabLen ())
-			{
-			  srcLine[curLen] = ' ';
-			  i++;
-			  curLen++;
-			}
-		      srcLine[curLen] = (char) 0;
-
-		      /* Set whether element is the execution point and
-		         whether there is a break point on it.  */
-		      element->whichElement.source.lineOrAddr.lineNo =
-			curLineNo;
-		      element->whichElement.source.isExecPoint =
-			(strcmp (((TuiWinElementPtr)
-			locator->content[0])->whichElement.locator.fileName,
-				 s->filename) == 0
-			 && curLineNo == ((TuiWinElementPtr)
-			 locator->content[0])->whichElement.locator.lineNo);
-		      if (c != EOF)
-			{
-			  i = strlen (srcLine) - 1;
-			  do
-			    {
-			      if ((c != '\n') &&
-				  (c != '\r') && (++i < threshold))
-				{
-				  if (c < 040 && c != '\t')
-				    {
-				      srcLine[i++] = '^';
-				      srcLine[i] = c + 0100;
-				    }
-				  else if (c == 0177)
-				    {
-				      srcLine[i++] = '^';
-				      srcLine[i] = '?';
-				    }
-				  else
-				    {	/* Store the charcter in the line
-					   buffer.  If it is a tab, then
-					   translate to the correct number of
-					   chars so we don't overwrite our
-					   buffer.  */
-				      if (c == '\t')
-					{
-					  int j, maxTabLen = tuiDefaultTabLen ();
-
-					  for (j = i - (
-					       (i / maxTabLen) * maxTabLen);
-					       ((j < maxTabLen) &&
-						i < threshold);
-					       i++, j++)
-					    srcLine[i] = ' ';
-					  i--;
-					}
-				      else
-					srcLine[i] = c;
-				    }
-				  srcLine[i + 1] = 0;
-				}
-			      else
-				{	/* If we have not reached EOL, then eat
-                                           chars until we do  */
-				  while (c != EOF && c != '\n' && c != '\r')
-				    c = fgetc (stream);
-				}
-			    }
-			  while (c != EOF && c != '\n' && c != '\r' &&
-				 i < threshold && (c = fgetc (stream)));
-			}
-		      /* Now copy the line taking the offset into account */
-		      if (strlen (srcLine) > offset)
-			strcpy (((TuiWinElementPtr) srcWin->generic.content[
-					curLine])->whichElement.source.line,
-				&srcLine[offset]);
-		      else
-			((TuiWinElementPtr)
-			 srcWin->generic.content[
-			  curLine])->whichElement.source.line[0] = (char) 0;
-		      curLine++;
-		      curLineNo++;
-		    }
-		  if (offset > 0)
-		    tuiFree (srcLine);
-		  fclose (stream);
-		  srcWin->generic.contentSize = nlines;
-		  ret = TUI_SUCCESS;
-		}
-	    }
-	}
-    }
-  return ret;
-}
-
-
-/* elz: this function sets the contents of the source window to empty
-   except for a line in the middle with a warning message about the
-   source not being available. This function is called by
-   tuiEraseSourceContents, which in turn is invoked when the source files
-   cannot be accessed */
-
-void
-tuiSetSourceContentNil (TuiWinInfoPtr winInfo, char *warning_string)
-{
-  int lineWidth;
-  int nLines;
-  int curr_line = 0;
-
-  lineWidth = winInfo->generic.width - 1;
-  nLines = winInfo->generic.height - 2;
-
-  /* set to empty each line in the window, except for the one
-     which contains the message */
-  while (curr_line < winInfo->generic.contentSize)
-    {
-      /* set the information related to each displayed line
-         to null: i.e. the line number is 0, there is no bp,
-         it is not where the program is stopped */
-
-      TuiWinElementPtr element =
-      (TuiWinElementPtr) winInfo->generic.content[curr_line];
-      element->whichElement.source.lineOrAddr.lineNo = 0;
-      element->whichElement.source.isExecPoint = FALSE;
-      element->whichElement.source.hasBreak = FALSE;
-
-      /* set the contents of the line to blank */
-      element->whichElement.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.
-         Note: the 'weird' arithmetic with the line width and height comes from
-         the function tuiEraseSourceContent. We need to keep the screen and the
-         window's actual contents in synch */
-
-      if (curr_line == (nLines / 2 + 1))
-	{
-	  int i;
-	  int xpos;
-	  int warning_length = strlen (warning_string);
-	  char *srcLine;
-
-	  srcLine = element->whichElement.source.line;
-
-	  if (warning_length >= ((lineWidth - 1) / 2))
-	    xpos = 1;
-	  else
-	    xpos = (lineWidth - 1) / 2 - warning_length;
-
-	  for (i = 0; i < xpos; i++)
-	    srcLine[i] = ' ';
-
-	  sprintf (srcLine + i, "%s", warning_string);
-
-	  for (i = xpos + warning_length; i < lineWidth; i++)
-	    srcLine[i] = ' ';
-
-	  srcLine[i] = '\n';
-
-	}			/* end if */
-
-      curr_line++;
-
-    }				/* end while */
-}
-
-
-/* Function to display source in the source window.  This function
-   initializes the horizontal scroll to 0.  */
-void
-tuiShowSource (struct symtab *s, TuiLineOrAddress line, int noerror)
-{
-  srcWin->detail.sourceInfo.horizontalOffset = 0;
-  tuiUpdateSourceWindowAsIs(srcWin, s, line, noerror);
-}
-
-
-/* Answer whether the source is currently displayed in the source window.  */
-int
-tuiSourceIsDisplayed (char *fname)
-{
-  return (srcWin->generic.contentInUse &&
-	  (strcmp (((TuiWinElementPtr) (locatorWinInfoPtr ())->
-		  content[0])->whichElement.locator.fileName, fname) == 0));
-}
-
-
-/* Scroll the source forward or backward vertically.  */
-void
-tuiVerticalSourceScroll (TuiScrollDirection scrollDirection,
-                         int numToScroll)
-{
-  if (srcWin->generic.content != (OpaquePtr) NULL)
-    {
-      TuiLineOrAddress l;
-      struct symtab *s;
-      TuiWinContent content = (TuiWinContent) srcWin->generic.content;
-      struct symtab_and_line cursal = get_current_source_symtab_and_line ();
-
-      if (cursal.symtab == (struct symtab *) NULL)
-	s = find_pc_symtab (get_frame_pc (deprecated_selected_frame));
-      else
-	s = cursal.symtab;
-
-      if (scrollDirection == FORWARD_SCROLL)
-	{
-	  l.lineNo = content[0]->whichElement.source.lineOrAddr.lineNo +
-	    numToScroll;
-	  if (l.lineNo > s->nlines)
-	    /*line = s->nlines - winInfo->generic.contentSize + 1; */
-	    /*elz: fix for dts 23398 */
-	    l.lineNo = content[0]->whichElement.source.lineOrAddr.lineNo;
-	}
-      else
-	{
-	  l.lineNo = content[0]->whichElement.source.lineOrAddr.lineNo -
-	    numToScroll;
-	  if (l.lineNo <= 0)
-	    l.lineNo = 1;
-	}
-
-      print_source_lines (s, l.lineNo, l.lineNo + 1, 0);
-    }
-}
diff --git a/gdb/tui/tuiSourceWin.c b/gdb/tui/tuiSourceWin.c
deleted file mode 100644
index cf5a0793f65..00000000000
--- a/gdb/tui/tuiSourceWin.c
+++ /dev/null
@@ -1,715 +0,0 @@
-/* TUI display source/assembly window.
-
-   Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
-   Inc.
-
-   Contributed by Hewlett-Packard Company.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#include "defs.h"
-#include <ctype.h>
-#include "symtab.h"
-#include "frame.h"
-#include "breakpoint.h"
-#include "value.h"
-#include "source.h"
-
-#include "tui.h"
-#include "tuiData.h"
-#include "tuiStack.h"
-#include "tuiWin.h"
-#include "tuiGeneralWin.h"
-#include "tuiSourceWin.h"
-#include "tuiSource.h"
-#include "tuiDisassem.h"
-
-#ifdef HAVE_NCURSES_H       
-#include <ncurses.h>
-#else
-#ifdef HAVE_CURSES_H
-#include <curses.h>
-#endif
-#endif
-
-/* Function to display the "main" routine.  */
-void
-tui_display_main (void)
-{
-  if ((sourceWindows ())->count > 0)
-    {
-      CORE_ADDR addr;
-
-      addr = tuiGetBeginAsmAddress ();
-      if (addr != (CORE_ADDR) 0)
-	{
-	  struct symtab_and_line sal;
-
-	  tuiUpdateSourceWindowsWithAddr (addr);
-	  sal = find_pc_line (addr, 0);
-          if (sal.symtab)
-             tuiUpdateLocatorFilename (sal.symtab->filename);
-          else
-             tuiUpdateLocatorFilename ("??");
-	}
-    }
-}
-
-
-
-/*
-   ** tuiUpdateSourceWindow().
-   **    Function to display source in the source window.  This function
-   **    initializes the horizontal scroll to 0.
- */
-void
-tuiUpdateSourceWindow (TuiWinInfoPtr winInfo, struct symtab *s,
-                       TuiLineOrAddress lineOrAddr, int noerror)
-{
-  winInfo->detail.sourceInfo.horizontalOffset = 0;
-  tuiUpdateSourceWindowAsIs (winInfo, s, lineOrAddr, noerror);
-
-  return;
-}				/* tuiUpdateSourceWindow */
-
-
-/*
-   ** tuiUpdateSourceWindowAsIs().
-   **        Function to display source in the source/asm window.  This
-   **        function shows the source as specified by the horizontal offset.
- */
-void
-tuiUpdateSourceWindowAsIs (TuiWinInfoPtr winInfo, struct symtab *s,
-                           TuiLineOrAddress lineOrAddr, int noerror)
-{
-  TuiStatus ret;
-
-  if (winInfo->generic.type == SRC_WIN)
-    ret = tuiSetSourceContent (s, lineOrAddr.lineNo, noerror);
-  else
-    ret = tuiSetDisassemContent (lineOrAddr.addr);
-
-  if (ret == TUI_FAILURE)
-    {
-      tuiClearSourceContent (winInfo, EMPTY_SOURCE_PROMPT);
-      tuiClearExecInfoContent (winInfo);
-    }
-  else
-    {
-      tui_update_breakpoint_info (winInfo, 0);
-      tuiShowSourceContent (winInfo);
-      tuiUpdateExecInfo (winInfo);
-      if (winInfo->generic.type == SRC_WIN)
-	{
-	  struct symtab_and_line sal;
-	  
-	  sal.line = lineOrAddr.lineNo +
-	    (winInfo->generic.contentSize - 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 (tuiWinWithFocus () == disassemWin &&
-	      currentLayout () != SRC_DISASSEM_COMMAND)
-	    tuiSetWinFocusTo (srcWin);
-	}
-    }
-
-
-  return;
-}				/* tuiUpdateSourceWindowAsIs */
-
-
-/*
-   ** tuiUpdateSourceWindowsWithAddr().
-   **        Function to ensure that the source and/or disassemly windows
-   **        reflect the input address.
- */
-void
-tuiUpdateSourceWindowsWithAddr (CORE_ADDR addr)
-{
-  if (addr != 0)
-    {
-      struct symtab_and_line sal;
-      TuiLineOrAddress l;
-      
-      switch (currentLayout ())
-	{
-	case DISASSEM_COMMAND:
-	case DISASSEM_DATA_COMMAND:
-	  tuiShowDisassem (addr);
-	  break;
-	case SRC_DISASSEM_COMMAND:
-	  tuiShowDisassemAndUpdateSource (addr);
-	  break;
-	default:
-	  sal = find_pc_line (addr, 0);
-	  l.lineNo = sal.line;
-	  tuiShowSource (sal.symtab, l, FALSE);
-	  break;
-	}
-    }
-  else
-    {
-      int i;
-
-      for (i = 0; i < (sourceWindows ())->count; i++)
-	{
-	  TuiWinInfoPtr winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[i];
-
-	  tuiClearSourceContent (winInfo, EMPTY_SOURCE_PROMPT);
-	  tuiClearExecInfoContent (winInfo);
-	}
-    }
-
-  return;
-}				/* tuiUpdateSourceWindowsWithAddr */
-
-/*
-   ** tuiUpdateSourceWindowsWithLine().
-   **        Function to ensure that the source and/or disassemly windows
-   **        reflect the input address.
- */
-void
-tuiUpdateSourceWindowsWithLine (struct symtab *s, int line)
-{
-  CORE_ADDR pc;
-  TuiLineOrAddress l;
-  
-  switch (currentLayout ())
-    {
-    case DISASSEM_COMMAND:
-    case DISASSEM_DATA_COMMAND:
-      find_line_pc (s, line, &pc);
-      tuiUpdateSourceWindowsWithAddr (pc);
-      break;
-    default:
-      l.lineNo = line;
-      tuiShowSource (s, l, FALSE);
-      if (currentLayout () == SRC_DISASSEM_COMMAND)
-	{
-	  find_line_pc (s, line, &pc);
-	  tuiShowDisassem (pc);
-	}
-      break;
-    }
-
-  return;
-}				/* tuiUpdateSourceWindowsWithLine */
-
-/*
-   ** tuiClearSourceContent().
- */
-void
-tuiClearSourceContent (TuiWinInfoPtr winInfo, int displayPrompt)
-{
-  if (m_winPtrNotNull (winInfo))
-    {
-      register int i;
-
-      winInfo->generic.contentInUse = FALSE;
-      tuiEraseSourceContent (winInfo, displayPrompt);
-      for (i = 0; i < winInfo->generic.contentSize; i++)
-	{
-	  TuiWinElementPtr element =
-	  (TuiWinElementPtr) winInfo->generic.content[i];
-	  element->whichElement.source.hasBreak = FALSE;
-	  element->whichElement.source.isExecPoint = FALSE;
-	}
-    }
-
-  return;
-}				/* tuiClearSourceContent */
-
-
-/*
-   ** tuiEraseSourceContent().
- */
-void
-tuiEraseSourceContent (TuiWinInfoPtr winInfo, int displayPrompt)
-{
-  int xPos;
-  int halfWidth = (winInfo->generic.width - 2) / 2;
-
-  if (winInfo->generic.handle != (WINDOW *) NULL)
-    {
-      werase (winInfo->generic.handle);
-      checkAndDisplayHighlightIfNeeded (winInfo);
-      if (displayPrompt == EMPTY_SOURCE_PROMPT)
-	{
-	  char *noSrcStr;
-
-	  if (winInfo->generic.type == SRC_WIN)
-	    noSrcStr = NO_SRC_STRING;
-	  else
-	    noSrcStr = NO_DISASSEM_STRING;
-	  if (strlen (noSrcStr) >= halfWidth)
-	    xPos = 1;
-	  else
-	    xPos = halfWidth - strlen (noSrcStr);
-	  mvwaddstr (winInfo->generic.handle,
-		     (winInfo->generic.height / 2),
-		     xPos,
-		     noSrcStr);
-
-	  /* elz: added this function call to set the real contents of
-	     the window to what is on the  screen, so that later calls
-	     to refresh, do display
-	     the correct stuff, and not the old image */
-
-	  tuiSetSourceContentNil (winInfo, noSrcStr);
-	}
-      tuiRefreshWin (&winInfo->generic);
-    }
-  return;
-}				/* tuiEraseSourceContent */
-
-
-/* Redraw the complete line of a source or disassembly window.  */
-static void
-tui_show_source_line (TuiWinInfoPtr winInfo, int lineno)
-{
-  TuiWinElementPtr line;
-  int x, y;
-
-  line = (TuiWinElementPtr) winInfo->generic.content[lineno - 1];
-  if (line->whichElement.source.isExecPoint)
-    wattron (winInfo->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);
-
-  /* Clear to end of line but stop before the border.  */
-  getyx (winInfo->generic.handle, y, x);
-  while (x + 1 < winInfo->generic.width)
-    {
-      waddch (winInfo->generic.handle, ' ');
-      getyx (winInfo->generic.handle, y, x);
-    }
-}
-
-/*
-   ** tuiShowSourceContent().
- */
-void
-tuiShowSourceContent (TuiWinInfoPtr winInfo)
-{
-  if (winInfo->generic.contentSize > 0)
-    {
-      int lineno;
-
-      for (lineno = 1; lineno <= winInfo->generic.contentSize; lineno++)
-        tui_show_source_line (winInfo, lineno);
-    }
-  else
-    tuiEraseSourceContent (winInfo, TRUE);
-
-  checkAndDisplayHighlightIfNeeded (winInfo);
-  tuiRefreshWin (&winInfo->generic);
-  winInfo->generic.contentInUse = TRUE;
-}
-
-
-/*
-   ** tuiHorizontalSourceScroll().
-   **      Scroll the source forward or backward horizontally
- */
-void
-tuiHorizontalSourceScroll (TuiWinInfoPtr winInfo,
-                           TuiScrollDirection direction,
-                           int numToScroll)
-{
-  if (winInfo->generic.content != (OpaquePtr) NULL)
-    {
-      int offset;
-      struct symtab *s;
-      struct symtab_and_line cursal = get_current_source_symtab_and_line ();
-
-      if (cursal.symtab == (struct symtab *) NULL)
-	s = find_pc_symtab (get_frame_pc (deprecated_selected_frame));
-      else
-	s = cursal.symtab;
-
-      if (direction == LEFT_SCROLL)
-	offset = winInfo->detail.sourceInfo.horizontalOffset + numToScroll;
-      else
-	{
-	  if ((offset =
-	     winInfo->detail.sourceInfo.horizontalOffset - numToScroll) < 0)
-	    offset = 0;
-	}
-      winInfo->detail.sourceInfo.horizontalOffset = offset;
-      tuiUpdateSourceWindowAsIs (
-				  winInfo,
-				  s,
-				  ((TuiWinElementPtr)
-				   winInfo->generic.content[0])->whichElement.source.lineOrAddr,
-				  FALSE);
-    }
-
-  return;
-}				/* tuiHorizontalSourceScroll */
-
-
-/* Set or clear the hasBreak flag in the line whose line is lineNo.  */
-void
-tuiSetIsExecPointAt (TuiLineOrAddress l, TuiWinInfoPtr winInfo)
-{
-  int changed = 0;
-  int i;
-  TuiWinContent content = (TuiWinContent) winInfo->generic.content;
-
-  i = 0;
-  while (i < winInfo->generic.contentSize)
-    {
-      int newState;
-
-      if (content[i]->whichElement.source.lineOrAddr.addr == l.addr)
-        newState = TRUE;
-      else
-	newState = FALSE;
-      if (newState != content[i]->whichElement.source.isExecPoint)
-        {
-          changed++;
-          content[i]->whichElement.source.isExecPoint = newState;
-          tui_show_source_line (winInfo, i + 1);
-        }
-      i++;
-    }
-  if (changed)
-    tuiRefreshWin (&winInfo->generic);
-}
-
-/* Update the execution windows to show the active breakpoints.
-   This is called whenever a breakpoint is inserted, removed or
-   has its state changed.  */
-void
-tui_update_all_breakpoint_info ()
-{
-  TuiList* list = sourceWindows ();
-  int i;
-
-  for (i = 0; i < list->count; i++)
-    {
-      TuiWinInfoPtr win = (TuiWinInfoPtr) list->list[i];
-
-      if (tui_update_breakpoint_info (win, FALSE))
-        {
-          tuiUpdateExecInfo (win);
-        }
-    }
-}
-
-
-/* Scan the source window and the breakpoints to update the
-   hasBreak information for each line.
-   Returns 1 if something changed and the execution window
-   must be refreshed.  */
-int
-tui_update_breakpoint_info (TuiWinInfoPtr win, int current_only)
-{
-  int i;
-  int need_refresh = 0;
-  TuiSourceInfoPtr src = &win->detail.sourceInfo;
-
-  for (i = 0; i < win->generic.contentSize; i++)
-    {
-      struct breakpoint *bp;
-      extern struct breakpoint *breakpoint_chain;
-      int mode;
-      TuiSourceElement* line;
-
-      line = &((TuiWinElementPtr) win->generic.content[i])->whichElement.source;
-      if (current_only && !line->isExecPoint)
-         continue;
-
-      /* Scan each breakpoint to see if the current line has something to
-         do with it.  Identify enable/disabled breakpoints as well as
-         those that we already hit.  */
-      mode = 0;
-      for (bp = breakpoint_chain;
-           bp != (struct breakpoint *) NULL;
-           bp = bp->next)
-        {
-          if ((win == srcWin
-               && bp->source_file
-               && (strcmp (src->filename, bp->source_file) == 0)
-               && bp->line_number == line->lineOrAddr.lineNo)
-              || (win == disassemWin
-                  && bp->address == line->lineOrAddr.addr))
-            {
-              if (bp->enable_state == bp_disabled)
-                mode |= TUI_BP_DISABLED;
-              else
-                mode |= TUI_BP_ENABLED;
-              if (bp->hit_count)
-                mode |= TUI_BP_HIT;
-              if (bp->cond)
-                mode |= TUI_BP_CONDITIONAL;
-              if (bp->type == bp_hardware_breakpoint)
-                mode |= TUI_BP_HARDWARE;
-            }
-        }
-      if (line->hasBreak != mode)
-        {
-          line->hasBreak = mode;
-          need_refresh = 1;
-        }
-    }
-  return need_refresh;
-}
-
-
-/*
-   ** tuiSetExecInfoContent().
-   **      Function to initialize the content of the execution info window,
-   **      based upon the input window which is either the source or
-   **      disassembly window.
- */
-TuiStatus
-tuiSetExecInfoContent (TuiWinInfoPtr winInfo)
-{
-  TuiStatus ret = TUI_SUCCESS;
-
-  if (winInfo->detail.sourceInfo.executionInfo != (TuiGenWinInfoPtr) NULL)
-    {
-      TuiGenWinInfoPtr execInfoPtr = winInfo->detail.sourceInfo.executionInfo;
-
-      if (execInfoPtr->content == (OpaquePtr) NULL)
-	execInfoPtr->content =
-	  (OpaquePtr) allocContent (winInfo->generic.height,
-				    execInfoPtr->type);
-      if (execInfoPtr->content != (OpaquePtr) NULL)
-	{
-	  int i;
-
-          tui_update_breakpoint_info (winInfo, 1);
-	  for (i = 0; i < winInfo->generic.contentSize; i++)
-	    {
-	      TuiWinElementPtr element;
-	      TuiWinElementPtr srcElement;
-              int mode;
-
-	      element = (TuiWinElementPtr) execInfoPtr->content[i];
-	      srcElement = (TuiWinElementPtr) winInfo->generic.content[i];
-
-              memset(element->whichElement.simpleString, ' ',
-                     sizeof(element->whichElement.simpleString));
-              element->whichElement.simpleString[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;
-              if (mode & TUI_BP_HIT)
-                element->whichElement.simpleString[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] =
-                  (mode & TUI_BP_HARDWARE) ? 'h' : 'b';
-
-              if (mode & TUI_BP_ENABLED)
-                element->whichElement.simpleString[TUI_BP_BREAK_POS] = '+';
-              else if (mode & TUI_BP_DISABLED)
-                element->whichElement.simpleString[TUI_BP_BREAK_POS] = '-';
-
-              if (srcElement->whichElement.source.isExecPoint)
-                element->whichElement.simpleString[TUI_EXEC_POS] = '>';
-	    }
-	  execInfoPtr->contentSize = winInfo->generic.contentSize;
-	}
-      else
-	ret = TUI_FAILURE;
-    }
-
-  return ret;
-}
-
-
-/*
-   ** tuiShowExecInfoContent().
- */
-void
-tuiShowExecInfoContent (TuiWinInfoPtr winInfo)
-{
-  TuiGenWinInfoPtr execInfo = winInfo->detail.sourceInfo.executionInfo;
-  int curLine;
-
-  werase (execInfo->handle);
-  tuiRefreshWin (execInfo);
-  for (curLine = 1; (curLine <= execInfo->contentSize); curLine++)
-    mvwaddstr (execInfo->handle,
-	       curLine,
-	       0,
-	       ((TuiWinElementPtr)
-		execInfo->content[curLine - 1])->whichElement.simpleString);
-  tuiRefreshWin (execInfo);
-  execInfo->contentInUse = TRUE;
-
-  return;
-}				/* tuiShowExecInfoContent */
-
-
-/*
-   ** tuiEraseExecInfoContent().
- */
-void
-tuiEraseExecInfoContent (TuiWinInfoPtr winInfo)
-{
-  TuiGenWinInfoPtr execInfo = winInfo->detail.sourceInfo.executionInfo;
-
-  werase (execInfo->handle);
-  tuiRefreshWin (execInfo);
-
-  return;
-}				/* tuiEraseExecInfoContent */
-
-/*
-   ** tuiClearExecInfoContent().
- */
-void
-tuiClearExecInfoContent (TuiWinInfoPtr winInfo)
-{
-  winInfo->detail.sourceInfo.executionInfo->contentInUse = FALSE;
-  tuiEraseExecInfoContent (winInfo);
-
-  return;
-}				/* tuiClearExecInfoContent */
-
-/*
-   ** tuiUpdateExecInfo().
-   **        Function to update the execution info window
- */
-void
-tuiUpdateExecInfo (TuiWinInfoPtr winInfo)
-{
-  tuiSetExecInfoContent (winInfo);
-  tuiShowExecInfoContent (winInfo);
-}				/* tuiUpdateExecInfo */
-
-TuiStatus
-tuiAllocSourceBuffer (TuiWinInfoPtr winInfo)
-{
-  register char *srcLineBuf;
-  register int i, lineWidth, maxLines;
-  TuiStatus ret = TUI_FAILURE;
-
-  maxLines = winInfo->generic.height;	/* less the highlight box */
-  lineWidth = winInfo->generic.width - 1;
-  /*
-     ** Allocate the buffer for the source lines.  Do this only once since they
-     ** will be re-used for all source displays.  The only other time this will
-     ** be done is when a window's size changes.
-   */
-  if (winInfo->generic.content == (OpaquePtr) NULL)
-    {
-      srcLineBuf = (char *) xmalloc ((maxLines * lineWidth) * sizeof (char));
-      if (srcLineBuf == (char *) NULL)
-	fputs_unfiltered (
-	   "Unable to Allocate Memory for Source or Disassembly Display.\n",
-			   gdb_stderr);
-      else
-	{
-	  /* allocate the content list */
-	  if ((winInfo->generic.content =
-	  (OpaquePtr) allocContent (maxLines, SRC_WIN)) == (OpaquePtr) NULL)
-	    {
-	      tuiFree (srcLineBuf);
-	      srcLineBuf = (char *) NULL;
-	      fputs_unfiltered (
-				 "Unable to Allocate Memory for Source or Disassembly Display.\n",
-				 gdb_stderr);
-	    }
-	}
-      for (i = 0; i < maxLines; i++)
-	((TuiWinElementPtr)
-	 winInfo->generic.content[i])->whichElement.source.line =
-	  srcLineBuf + (lineWidth * i);
-      ret = TUI_SUCCESS;
-    }
-  else
-    ret = TUI_SUCCESS;
-
-  return ret;
-}				/* tuiAllocSourceBuffer */
-
-
-/*
-   ** tuiLineIsDisplayed().
-   **      Answer whether the a particular line number or address is displayed
-   **      in the current source window.
- */
-int
-tuiLineIsDisplayed (int line, TuiWinInfoPtr winInfo,
-                    int checkThreshold)
-{
-  int isDisplayed = FALSE;
-  int i, threshold;
-
-  if (checkThreshold)
-    threshold = SCROLL_THRESHOLD;
-  else
-    threshold = 0;
-  i = 0;
-  while (i < winInfo->generic.contentSize - threshold && !isDisplayed)
-    {
-      isDisplayed = (((TuiWinElementPtr)
-		      winInfo->generic.content[i])->whichElement.source.lineOrAddr.lineNo
-		     == (int) line);
-      i++;
-    }
-
-  return isDisplayed;
-}				/* tuiLineIsDisplayed */
-
-
-/*
-   ** tuiLineIsDisplayed().
-   **      Answer whether the a particular line number or address is displayed
-   **      in the current source window.
- */
-int
-tuiAddrIsDisplayed (CORE_ADDR addr, TuiWinInfoPtr winInfo,
-		    int checkThreshold)
-{
-  int isDisplayed = FALSE;
-  int i, threshold;
-
-  if (checkThreshold)
-    threshold = SCROLL_THRESHOLD;
-  else
-    threshold = 0;
-  i = 0;
-  while (i < winInfo->generic.contentSize - threshold && !isDisplayed)
-    {
-      isDisplayed = (((TuiWinElementPtr)
-		      winInfo->generic.content[i])->whichElement.source.lineOrAddr.addr
-		     == addr);
-      i++;
-    }
-
-  return isDisplayed;
-}
-
-
-/*****************************************
-** STATIC LOCAL FUNCTIONS               **
-******************************************/
diff --git a/gdb/tui/tuiSourceWin.h b/gdb/tui/tuiSourceWin.h
deleted file mode 100644
index cb00449ed2d..00000000000
--- a/gdb/tui/tuiSourceWin.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/* TUI display source/assembly window.
-   Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
-   Contributed by Hewlett-Packard Company.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#ifndef _TUI_SOURCEWIN_H
-#define _TUI_SOURCEWIN_H
-
-/* Update the execution windows to show the active breakpoints.
-   This is called whenever a breakpoint is inserted, removed or
-   has its state changed.  */
-extern void tui_update_all_breakpoint_info (void);
-
-/* Scan the source window and the breakpoints to update the
-   hasBreak information for each line.
-   Returns 1 if something changed and the execution window
-   must be refreshed.  */
-extern int tui_update_breakpoint_info (TuiWinInfoPtr win, int current_only);
-
-/* Function to display the "main" routine.  */
-extern void tui_display_main (void);
-extern void tuiUpdateSourceWindow (TuiWinInfoPtr, struct symtab *, TuiLineOrAddress,
-				   int);
-extern void tuiUpdateSourceWindowAsIs (TuiWinInfoPtr, struct symtab *, TuiLineOrAddress,
-				       int);
-extern void tuiUpdateSourceWindowsWithAddr (CORE_ADDR);
-extern void tuiUpdateSourceWindowsWithLine (struct symtab *, int);
-extern void tuiClearSourceContent (TuiWinInfoPtr, int);
-extern void tuiEraseSourceContent (TuiWinInfoPtr, int);
-extern void tuiSetSourceContentNil (TuiWinInfoPtr, char *);
-extern void tuiShowSourceContent (TuiWinInfoPtr);
-extern void tuiHorizontalSourceScroll (TuiWinInfoPtr, TuiScrollDirection,
-				       int);
-extern TuiStatus tuiSetExecInfoContent (TuiWinInfoPtr);
-extern void tuiShowExecInfoContent (TuiWinInfoPtr);
-extern void tuiEraseExecInfoContent (TuiWinInfoPtr);
-extern void tuiClearExecInfoContent (TuiWinInfoPtr);
-extern void tuiUpdateExecInfo (TuiWinInfoPtr);
-
-extern void tuiSetIsExecPointAt (TuiLineOrAddress, TuiWinInfoPtr);
-extern TuiStatus tuiAllocSourceBuffer (TuiWinInfoPtr);
-extern int tuiLineIsDisplayed (int, TuiWinInfoPtr, int);
-extern int tuiAddrIsDisplayed (CORE_ADDR, TuiWinInfoPtr, int);
-
-
-/*
-   ** Constant definitions
- */
-#define        SCROLL_THRESHOLD            2	/* threshold for lazy scroll */
-
-#endif
-/*_TUI_SOURCEWIN_H */
diff --git a/gdb/tui/tuiWin.c b/gdb/tui/tuiWin.c
deleted file mode 100644
index ecd4920601b..00000000000
--- a/gdb/tui/tuiWin.c
+++ /dev/null
@@ -1,1615 +0,0 @@
-/* TUI window generic functions.
-
-   Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
-   Inc.
-
-   Contributed by Hewlett-Packard Company.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-/* This module contains procedures for handling tui window functions
-   like resize, scrolling, scrolling, changing focus, etc.
-
-   Author: Susan B. Macchia  */
-
-#include "defs.h"
-#include "command.h"
-#include "symtab.h"
-#include "breakpoint.h"
-#include "frame.h"
-#include "cli/cli-cmds.h"
-#include "top.h"
-#include "source.h"
-
-#include "tui.h"
-#include "tuiData.h"
-#include "tuiGeneralWin.h"
-#include "tuiStack.h"
-#include "tuiRegs.h"
-#include "tuiDisassem.h"
-#include "tuiSource.h"
-#include "tuiSourceWin.h"
-#include "tuiDataWin.h"
-
-#ifdef HAVE_NCURSES_H       
-#include <ncurses.h>
-#else
-#ifdef HAVE_CURSES_H
-#include <curses.h>
-#endif
-#endif
-
-#include <string.h>
-#include <ctype.h>
-#include <readline/readline.h>
-
-/*******************************
-** Static Local Decls
-********************************/
-static void _makeVisibleWithNewHeight (TuiWinInfoPtr);
-static void _makeInvisibleAndSetNewHeight (TuiWinInfoPtr, int);
-static TuiStatus _tuiAdjustWinHeights (TuiWinInfoPtr, int);
-static int _newHeightOk (TuiWinInfoPtr, int);
-static void _tuiSetTabWidth_command (char *, int);
-static void _tuiRefreshAll_command (char *, int);
-static void _tuiSetWinHeight_command (char *, int);
-static void _tuiXDBsetWinHeight_command (char *, int);
-static void _tuiAllWindowsInfo (char *, int);
-static void _tuiSetFocus_command (char *, int);
-static void _tuiScrollForward_command (char *, int);
-static void _tuiScrollBackward_command (char *, int);
-static void _tuiScrollLeft_command (char *, int);
-static void _tuiScrollRight_command (char *, int);
-static void _parseScrollingArgs (char *, TuiWinInfoPtr *, int *);
-
-
-/***************************************
-** DEFINITIONS
-***************************************/
-#define WIN_HEIGHT_USAGE      "Usage: winheight <win_name> [+ | -] <#lines>\n"
-#define XDBWIN_HEIGHT_USAGE   "Usage: w <#lines>\n"
-#define FOCUS_USAGE           "Usage: focus {<win> | next | prev}\n"
-
-/***************************************
-** PUBLIC FUNCTIONS
-***************************************/
-
-#ifndef ACS_LRCORNER
-#  define ACS_LRCORNER '+'
-#endif
-#ifndef ACS_LLCORNER
-#  define ACS_LLCORNER '+'
-#endif
-#ifndef ACS_ULCORNER
-#  define ACS_ULCORNER '+'
-#endif
-#ifndef ACS_URCORNER
-#  define ACS_URCORNER '+'
-#endif
-#ifndef ACS_HLINE
-#  define ACS_HLINE '-'
-#endif
-#ifndef ACS_VLINE
-#  define ACS_VLINE '|'
-#endif
-
-/* Possible values for tui-border-kind variable.  */
-static const char *tui_border_kind_enums[] = {
-  "space",
-  "ascii",
-  "acs",
-  NULL
-};
-
-/* Possible values for tui-border-mode and tui-active-border-mode.  */
-static const char *tui_border_mode_enums[] = {
-  "normal",
-  "standout",
-  "reverse",
-  "half",
-  "half-standout",
-  "bold",
-  "bold-standout",
-  NULL
-};
-
-struct tui_translate
-{
-  const char *name;
-  int value;
-};
-
-/* Translation table for border-mode variables.
-   The list of values must be terminated by a NULL.
-   After the NULL value, an entry defines the default.  */
-struct tui_translate tui_border_mode_translate[] = {
-  { "normal",		A_NORMAL },
-  { "standout",		A_STANDOUT },
-  { "reverse",		A_REVERSE },
-  { "half",		A_DIM },
-  { "half-standout",	A_DIM | A_STANDOUT },
-  { "bold",		A_BOLD },
-  { "bold-standout",	A_BOLD | A_STANDOUT },
-  { 0, 0 },
-  { "normal",		A_NORMAL }
-};
-
-/* Translation tables for border-kind, one for each border
-   character (see wborder, border curses operations).
-   -1 is used to indicate the ACS because ACS characters
-   are determined at run time by curses (depends on terminal).  */
-struct tui_translate tui_border_kind_translate_vline[] = {
-  { "space",    ' ' },
-  { "ascii",    '|' },
-  { "acs",      -1 },
-  { 0, 0 },
-  { "ascii",    '|' }
-};
-
-struct tui_translate tui_border_kind_translate_hline[] = {
-  { "space",    ' ' },
-  { "ascii",    '-' },
-  { "acs",      -1 },
-  { 0, 0 },
-  { "ascii",    '-' }
-};
-
-struct tui_translate tui_border_kind_translate_ulcorner[] = {
-  { "space",    ' ' },
-  { "ascii",    '+' },
-  { "acs",      -1 },
-  { 0, 0 },
-  { "ascii",    '+' }
-};
-
-struct tui_translate tui_border_kind_translate_urcorner[] = {
-  { "space",    ' ' },
-  { "ascii",    '+' },
-  { "acs",      -1 },
-  { 0, 0 },
-  { "ascii",    '+' }
-};
-
-struct tui_translate tui_border_kind_translate_llcorner[] = {
-  { "space",    ' ' },
-  { "ascii",    '+' },
-  { "acs",      -1 },
-  { 0, 0 },
-  { "ascii",    '+' }
-};
-
-struct tui_translate tui_border_kind_translate_lrcorner[] = {
-  { "space",    ' ' },
-  { "ascii",    '+' },
-  { "acs",      -1 },
-  { 0, 0 },
-  { "ascii",    '+' }
-};
-
-
-/* Tui configuration variables controlled with set/show command.  */
-const char *tui_active_border_mode = "bold-standout";
-const char *tui_border_mode = "normal";
-const char *tui_border_kind = "acs";
-
-/* Tui internal configuration variables.  These variables are
-   updated by tui_update_variables to reflect the tui configuration
-   variables.  */
-chtype tui_border_vline;
-chtype tui_border_hline;
-chtype tui_border_ulcorner;
-chtype tui_border_urcorner;
-chtype tui_border_llcorner;
-chtype tui_border_lrcorner;
-
-int tui_border_attrs;
-int tui_active_border_attrs;
-
-/* Identify the item in the translation table.
-   When the item is not recognized, use the default entry.  */
-static struct tui_translate *
-translate (const char *name, struct tui_translate *table)
-{
-  while (table->name)
-    {
-      if (name && strcmp (table->name, name) == 0)
-        return table;
-      table++;
-    }
-
-  /* Not found, return default entry.  */
-  table++;
-  return table;
-}
-
-/* Update the tui internal configuration according to gdb settings.
-   Returns 1 if the configuration has changed and the screen should
-   be redrawn.  */
-int
-tui_update_variables ()
-{
-  int need_redraw = 0;
-  struct tui_translate *entry;
-
-  entry = translate (tui_border_mode, tui_border_mode_translate);
-  if (tui_border_attrs != entry->value)
-    {
-      tui_border_attrs = entry->value;
-      need_redraw = 1;
-    }
-  entry = translate (tui_active_border_mode, tui_border_mode_translate);
-  if (tui_active_border_attrs != entry->value)
-    {
-      tui_active_border_attrs = entry->value;
-      need_redraw = 1;
-    }
-
-  /* If one corner changes, all characters are changed.
-     Only check the first one.  The ACS characters are determined at
-     run time by curses terminal management.  */
-  entry = translate (tui_border_kind, tui_border_kind_translate_lrcorner);
-  if (tui_border_lrcorner != (chtype) entry->value)
-    {
-      tui_border_lrcorner = (entry->value < 0) ? ACS_LRCORNER : entry->value;
-      need_redraw = 1;
-    }
-  entry = translate (tui_border_kind, tui_border_kind_translate_llcorner);
-  tui_border_llcorner = (entry->value < 0) ? ACS_LLCORNER : entry->value;
-
-  entry = translate (tui_border_kind, tui_border_kind_translate_ulcorner);
-  tui_border_ulcorner = (entry->value < 0) ? ACS_ULCORNER : entry->value;
-
-  entry = translate (tui_border_kind, tui_border_kind_translate_urcorner);
-  tui_border_urcorner = (entry->value < 0) ? ACS_URCORNER : entry->value;
-
-  entry = translate (tui_border_kind, tui_border_kind_translate_hline);
-  tui_border_hline = (entry->value < 0) ? ACS_HLINE : entry->value;
-
-  entry = translate (tui_border_kind, tui_border_kind_translate_vline);
-  tui_border_vline = (entry->value < 0) ? ACS_VLINE : entry->value;
-
-  return need_redraw;
-}
-
-static void
-set_tui_cmd (char *args, int from_tty)
-{
-}
-
-static void
-show_tui_cmd (char *args, int from_tty)
-{
-}
-
-/*
-   ** _initialize_tuiWin().
-   **        Function to initialize gdb commands, for tui window manipulation.
- */
-void
-_initialize_tuiWin (void)
-{
-  struct cmd_list_element *c;
-  static struct cmd_list_element *tui_setlist;
-  static struct cmd_list_element *tui_showlist;
-
-  /* Define the classes of commands.
-     They will appear in the help list in the reverse of this order.  */
-  add_cmd ("tui", class_tui, NULL,
-	   "Text User Interface commands.",
-	   &cmdlist);
-
-  add_prefix_cmd ("tui", class_tui, set_tui_cmd,
-                  "TUI configuration variables",
-		  &tui_setlist, "set tui ",
-		  0/*allow-unknown*/, &setlist);
-  add_prefix_cmd ("tui", class_tui, show_tui_cmd,
-                  "TUI configuration variables",
-		  &tui_showlist, "show tui ",
-		  0/*allow-unknown*/, &showlist);
-
-  add_com ("refresh", class_tui, _tuiRefreshAll_command,
-           "Refresh the terminal display.\n");
-  if (xdb_commands)
-    add_com_alias ("U", "refresh", class_tui, 0);
-  add_com ("tabset", class_tui, _tuiSetTabWidth_command,
-           "Set the width (in characters) of tab stops.\n\
-Usage: tabset <n>\n");
-  add_com ("winheight", class_tui, _tuiSetWinHeight_command,
-           "Set the height of a specified window.\n\
-Usage: winheight <win_name> [+ | -] <#lines>\n\
-Window names are:\n\
-src  : the source window\n\
-cmd  : the command window\n\
-asm  : the disassembly window\n\
-regs : the register display\n");
-  add_com_alias ("wh", "winheight", class_tui, 0);
-  add_info ("win", _tuiAllWindowsInfo,
-            "List of all displayed windows.\n");
-  add_com ("focus", class_tui, _tuiSetFocus_command,
-           "Set focus to named window or next/prev window.\n\
-Usage: focus {<win> | next | prev}\n\
-Valid Window names are:\n\
-src  : the source window\n\
-asm  : the disassembly window\n\
-regs : the register display\n\
-cmd  : the command window\n");
-  add_com_alias ("fs", "focus", class_tui, 0);
-  add_com ("+", class_tui, _tuiScrollForward_command,
-           "Scroll window forward.\nUsage: + [win] [n]\n");
-  add_com ("-", class_tui, _tuiScrollBackward_command,
-           "Scroll window backward.\nUsage: - [win] [n]\n");
-  add_com ("<", class_tui, _tuiScrollLeft_command,
-           "Scroll window forward.\nUsage: < [win] [n]\n");
-  add_com (">", class_tui, _tuiScrollRight_command,
-           "Scroll window backward.\nUsage: > [win] [n]\n");
-  if (xdb_commands)
-    add_com ("w", class_xdb, _tuiXDBsetWinHeight_command,
-             "XDB compatibility command for setting the height of a command window.\n\
-Usage: w <#lines>\n");
-
-  /* Define the tui control variables.  */
-  c = add_set_enum_cmd
-    ("border-kind", no_class,
-     tui_border_kind_enums, &tui_border_kind,
-     "Set the kind of border for TUI windows.\n"
-     "This variable controls the border of TUI windows:\n"
-     "space           use a white space\n"
-     "ascii           use ascii characters + - | for the border\n"
-     "acs             use the Alternate Character Set\n",
-     &tui_setlist);
-  add_show_from_set (c, &tui_showlist);
-
-  c = add_set_enum_cmd
-    ("border-mode", no_class,
-     tui_border_mode_enums, &tui_border_mode,
-     "Set the attribute mode to use for the TUI window borders.\n"
-     "This variable controls the attributes to use for the window borders:\n"
-     "normal          normal display\n"
-     "standout        use highlight mode of terminal\n"
-     "reverse         use reverse video mode\n"
-     "half            use half bright\n"
-     "half-standout   use half bright and standout mode\n"
-     "bold            use extra bright or bold\n"
-     "bold-standout   use extra bright or bold with standout mode\n",
-     &tui_setlist);
-  add_show_from_set (c, &tui_showlist);
-
-  c = add_set_enum_cmd
-    ("active-border-mode", no_class,
-     tui_border_mode_enums, &tui_active_border_mode,
-     "Set the attribute mode to use for the active TUI window border.\n"
-     "This variable controls the attributes to use for the active window border:\n"
-     "normal          normal display\n"
-     "standout        use highlight mode of terminal\n"
-     "reverse         use reverse video mode\n"
-     "half            use half bright\n"
-     "half-standout   use half bright and standout mode\n"
-     "bold            use extra bright or bold\n"
-     "bold-standout   use extra bright or bold with standout mode\n",
-     &tui_setlist);
-  add_show_from_set (c, &tui_showlist);
-}
-
-/* Update gdb's knowledge of the terminal size.  */
-void
-tui_update_gdb_sizes ()
-{
-  char cmd[50];
-  int screenheight, screenwidth;
-
-  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);
-  execute_command (cmd, 0);
-  sprintf (cmd, "set height %d",
-           tui_active ? cmdWin->generic.height : screenheight);
-  execute_command (cmd, 0);
-}
-
-
-/*
-   ** tuiSetWinFocusTo
-   **        Set the logical focus to winInfo
- */
-void
-tuiSetWinFocusTo (TuiWinInfoPtr winInfo)
-{
-  if (m_winPtrNotNull (winInfo))
-    {
-      TuiWinInfoPtr winWithFocus = tuiWinWithFocus ();
-
-      if (m_winPtrNotNull (winWithFocus) &&
-	  winWithFocus->generic.type != CMD_WIN)
-	unhighlightWin (winWithFocus);
-      tuiSetWinWithFocus (winInfo);
-      if (winInfo->generic.type != CMD_WIN)
-	highlightWin (winInfo);
-    }
-
-  return;
-}				/* tuiSetWinFocusTo */
-
-
-/*
-   ** tuiScrollForward().
- */
-void
-tuiScrollForward (TuiWinInfoPtr winToScroll, int numToScroll)
-{
-  if (winToScroll != cmdWin)
-    {
-      int _numToScroll = numToScroll;
-
-      if (numToScroll == 0)
-	_numToScroll = winToScroll->generic.height - 3;
-      /*
-         ** If we are scrolling the source or disassembly window, do a
-         ** "psuedo" scroll since not all of the source is in memory,
-         ** only what is in the viewport.  If winToScroll is the
-         ** command window do nothing since the term should handle it.
-       */
-      if (winToScroll == srcWin)
-	tuiVerticalSourceScroll (FORWARD_SCROLL, _numToScroll);
-      else if (winToScroll == disassemWin)
-	tuiVerticalDisassemScroll (FORWARD_SCROLL, _numToScroll);
-      else if (winToScroll == dataWin)
-	tuiVerticalDataScroll (FORWARD_SCROLL, _numToScroll);
-    }
-
-  return;
-}				/* tuiScrollForward */
-
-
-/*
-   ** tuiScrollBackward().
- */
-void
-tuiScrollBackward (TuiWinInfoPtr winToScroll, int numToScroll)
-{
-  if (winToScroll != cmdWin)
-    {
-      int _numToScroll = numToScroll;
-
-      if (numToScroll == 0)
-	_numToScroll = winToScroll->generic.height - 3;
-      /*
-         ** If we are scrolling the source or disassembly window, do a
-         ** "psuedo" scroll since not all of the source is in memory,
-         ** only what is in the viewport.  If winToScroll is the
-         ** command window do nothing since the term should handle it.
-       */
-      if (winToScroll == srcWin)
-	tuiVerticalSourceScroll (BACKWARD_SCROLL, _numToScroll);
-      else if (winToScroll == disassemWin)
-	tuiVerticalDisassemScroll (BACKWARD_SCROLL, _numToScroll);
-      else if (winToScroll == dataWin)
-	tuiVerticalDataScroll (BACKWARD_SCROLL, _numToScroll);
-    }
-  return;
-}				/* tuiScrollBackward */
-
-
-/*
-   ** tuiScrollLeft().
- */
-void
-tuiScrollLeft (TuiWinInfoPtr winToScroll, int numToScroll)
-{
-  if (winToScroll != cmdWin)
-    {
-      int _numToScroll = numToScroll;
-
-      if (_numToScroll == 0)
-	_numToScroll = 1;
-      /*
-         ** If we are scrolling the source or disassembly window, do a
-         ** "psuedo" scroll since not all of the source is in memory,
-         ** 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)
-	tuiHorizontalSourceScroll (winToScroll, LEFT_SCROLL, _numToScroll);
-    }
-  return;
-}				/* tuiScrollLeft */
-
-
-/*
-   ** tuiScrollRight().
- */
-void
-tuiScrollRight (TuiWinInfoPtr winToScroll, int numToScroll)
-{
-  if (winToScroll != cmdWin)
-    {
-      int _numToScroll = numToScroll;
-
-      if (_numToScroll == 0)
-	_numToScroll = 1;
-      /*
-         ** If we are scrolling the source or disassembly window, do a
-         ** "psuedo" scroll since not all of the source is in memory,
-         ** 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)
-	tuiHorizontalSourceScroll (winToScroll, RIGHT_SCROLL, _numToScroll);
-    }
-  return;
-}				/* tuiScrollRight */
-
-
-/*
-   ** tui_scroll().
-   **    Scroll a window.  Arguments are passed through a va_list.
- */
-void
-tui_scroll (TuiScrollDirection direction,
-	    TuiWinInfoPtr winToScroll,
-	    int numToScroll)
-{
-  switch (direction)
-    {
-    case FORWARD_SCROLL:
-      tuiScrollForward (winToScroll, numToScroll);
-      break;
-    case BACKWARD_SCROLL:
-      tuiScrollBackward (winToScroll, numToScroll);
-      break;
-    case LEFT_SCROLL:
-      tuiScrollLeft (winToScroll, numToScroll);
-      break;
-    case RIGHT_SCROLL:
-      tuiScrollRight (winToScroll, numToScroll);
-      break;
-    default:
-      break;
-    }
-}
-
-
-/*
-   ** tuiRefreshAll().
- */
-void
-tuiRefreshAll (void)
-{
-  TuiWinType type;
-
-  clearok (curscr, TRUE);
-  refreshAll (winList);
-  for (type = SRC_WIN; type < MAX_MAJOR_WINDOWS; type++)
-    {
-      if (winList[type] && winList[type]->generic.isVisible)
-	{
-	  switch (type)
-	    {
-	    case SRC_WIN:
-	    case DISASSEM_WIN:
-	      tuiShowSourceContent (winList[type]);
-	      checkAndDisplayHighlightIfNeeded (winList[type]);
-	      tuiEraseExecInfoContent (winList[type]);
-	      tuiUpdateExecInfo (winList[type]);
-	      break;
-	    case DATA_WIN:
-	      tuiRefreshDataWin ();
-	      break;
-	    default:
-	      break;
-	    }
-	}
-    }
-  tuiShowLocatorContent ();
-}
-
-
-/*
-   ** tuiResizeAll().
-   **      Resize all the windows based on the the terminal size.  This
-   **      function gets called from within the readline sinwinch handler.
- */
-void
-tuiResizeAll (void)
-{
-  int heightDiff, widthDiff;
-  int screenheight, screenwidth;
-
-  rl_get_screen_size (&screenheight, &screenwidth);
-  widthDiff = screenwidth - termWidth ();
-  heightDiff = screenheight - termHeight ();
-  if (heightDiff || widthDiff)
-    {
-      TuiLayoutType curLayout = currentLayout ();
-      TuiWinInfoPtr winWithFocus = tuiWinWithFocus ();
-      TuiWinInfoPtr firstWin, secondWin;
-      TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
-      TuiWinType winType;
-      int newHeight, splitDiff, cmdSplitDiff, numWinsDisplayed = 2;
-
-      /* turn keypad off while we resize */
-      if (winWithFocus != cmdWin)
-	keypad (cmdWin->generic.handle, FALSE);
-      tui_update_gdb_sizes ();
-      setTermHeightTo (screenheight);
-      setTermWidthTo (screenwidth);
-      if (curLayout == SRC_DISASSEM_COMMAND ||
-	curLayout == SRC_DATA_COMMAND || curLayout == DISASSEM_DATA_COMMAND)
-	numWinsDisplayed++;
-      splitDiff = heightDiff / numWinsDisplayed;
-      cmdSplitDiff = splitDiff;
-      if (heightDiff % numWinsDisplayed)
-	{
-	  if (heightDiff < 0)
-	    cmdSplitDiff--;
-	  else
-	    cmdSplitDiff++;
-	}
-      /* now adjust each window */
-      clear ();
-      refresh ();
-      switch (curLayout)
-	{
-	case SRC_COMMAND:
-	case DISASSEM_COMMAND:
-	  firstWin = (TuiWinInfoPtr) (sourceWindows ())->list[0];
-	  firstWin->generic.width += widthDiff;
-	  locator->width += widthDiff;
-	  /* check for invalid heights */
-	  if (heightDiff == 0)
-	    newHeight = firstWin->generic.height;
-	  else if ((firstWin->generic.height + splitDiff) >=
-		   (screenheight - MIN_CMD_WIN_HEIGHT - 1))
-	    newHeight = screenheight - MIN_CMD_WIN_HEIGHT - 1;
-	  else if ((firstWin->generic.height + splitDiff) <= 0)
-	    newHeight = MIN_WIN_HEIGHT;
-	  else
-	    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);
-	  _makeVisibleWithNewHeight (firstWin);
-	  _makeVisibleWithNewHeight (cmdWin);
-	  if (firstWin->generic.contentSize <= 0)
-	    tuiEraseSourceContent (firstWin, EMPTY_SOURCE_PROMPT);
-	  break;
-	default:
-	  if (curLayout == SRC_DISASSEM_COMMAND)
-	    {
-	      firstWin = srcWin;
-	      firstWin->generic.width += widthDiff;
-	      secondWin = disassemWin;
-	      secondWin->generic.width += widthDiff;
-	    }
-	  else
-	    {
-	      firstWin = dataWin;
-	      firstWin->generic.width += widthDiff;
-	      secondWin = (TuiWinInfoPtr) (sourceWindows ())->list[0];
-	      secondWin->generic.width += widthDiff;
-	    }
-	  /* Change the first window's height/width */
-	  /* check for invalid heights */
-	  if (heightDiff == 0)
-	    newHeight = firstWin->generic.height;
-	  else if ((firstWin->generic.height +
-		    secondWin->generic.height + (splitDiff * 2)) >=
-		   (screenheight - MIN_CMD_WIN_HEIGHT - 1))
-	    newHeight = (screenheight - MIN_CMD_WIN_HEIGHT - 1) / 2;
-	  else if ((firstWin->generic.height + splitDiff) <= 0)
-	    newHeight = MIN_WIN_HEIGHT;
-	  else
-	    newHeight = firstWin->generic.height + splitDiff;
-	  _makeInvisibleAndSetNewHeight (firstWin, newHeight);
-
-	  if (firstWin == dataWin && widthDiff != 0)
-	    firstWin->detail.dataDisplayInfo.regsColumnCount =
-	      tuiCalculateRegsColumnCount (
-			  firstWin->detail.dataDisplayInfo.regsDisplayType);
-	  locator->width += widthDiff;
-
-	  /* Change the second window's height/width */
-	  /* check for invalid heights */
-	  if (heightDiff == 0)
-	    newHeight = secondWin->generic.height;
-	  else if ((firstWin->generic.height +
-		    secondWin->generic.height + (splitDiff * 2)) >=
-		   (screenheight - MIN_CMD_WIN_HEIGHT - 1))
-	    {
-	      newHeight = screenheight - MIN_CMD_WIN_HEIGHT - 1;
-	      if (newHeight % 2)
-		newHeight = (newHeight / 2) + 1;
-	      else
-		newHeight /= 2;
-	    }
-	  else if ((secondWin->generic.height + splitDiff) <= 0)
-	    newHeight = MIN_WIN_HEIGHT;
-	  else
-	    newHeight = secondWin->generic.height + splitDiff;
-	  secondWin->generic.origin.y = firstWin->generic.height - 1;
-	  _makeInvisibleAndSetNewHeight (secondWin, newHeight);
-
-	  /* Change the command window's height/width */
-	  cmdWin->generic.origin.y = locator->origin.y + 1;
-	  _makeInvisibleAndSetNewHeight (
-			     cmdWin, cmdWin->generic.height + cmdSplitDiff);
-	  _makeVisibleWithNewHeight (firstWin);
-	  _makeVisibleWithNewHeight (secondWin);
-	  _makeVisibleWithNewHeight (cmdWin);
-	  if (firstWin->generic.contentSize <= 0)
-	    tuiEraseSourceContent (firstWin, EMPTY_SOURCE_PROMPT);
-	  if (secondWin->generic.contentSize <= 0)
-	    tuiEraseSourceContent (secondWin, EMPTY_SOURCE_PROMPT);
-	  break;
-	}
-      /*
-         ** Now remove all invisible windows, and their content so that they get
-         ** created again when called for with the new size
-       */
-      for (winType = SRC_WIN; (winType < MAX_MAJOR_WINDOWS); winType++)
-	{
-	  if (winType != CMD_WIN && m_winPtrNotNull (winList[winType]) &&
-	      !winList[winType]->generic.isVisible)
-	    {
-	      freeWindow (winList[winType]);
-	      winList[winType] = (TuiWinInfoPtr) NULL;
-	    }
-	}
-      tuiSetWinResizedTo (TRUE);
-      /* turn keypad back on, unless focus is in the command window */
-      if (winWithFocus != cmdWin)
-	keypad (cmdWin->generic.handle, TRUE);
-    }
-  return;
-}				/* tuiResizeAll */
-
-
-/*
-   ** tuiSigwinchHandler()
-   **    SIGWINCH signal handler for the tui.  This signal handler is
-   **    always called, even when the readline package clears signals
-   **    because it is set as the old_sigwinch() (TUI only)
- */
-void
-tuiSigwinchHandler (int signal)
-{
-  /*
-     ** Say that a resize was done so that the readline can do it
-     ** later when appropriate.
-   */
-  tuiSetWinResizedTo (TRUE);
-
-  return;
-}				/* tuiSigwinchHandler */
-
-
-
-/*************************
-** STATIC LOCAL FUNCTIONS
-**************************/
-
-
-/*
-   ** _tuiScrollForward_command().
- */
-static void
-_tuiScrollForward_command (char *arg, int fromTTY)
-{
-  int numToScroll = 1;
-  TuiWinInfoPtr winToScroll;
-
-  /* Make sure the curses mode is enabled.  */
-  tui_enable ();
-  if (arg == (char *) NULL)
-    _parseScrollingArgs (arg, &winToScroll, (int *) NULL);
-  else
-    _parseScrollingArgs (arg, &winToScroll, &numToScroll);
-  tui_scroll (FORWARD_SCROLL, winToScroll, numToScroll);
-}
-
-
-/*
-   ** _tuiScrollBackward_command().
- */
-static void
-_tuiScrollBackward_command (char *arg, int fromTTY)
-{
-  int numToScroll = 1;
-  TuiWinInfoPtr winToScroll;
-
-  /* Make sure the curses mode is enabled.  */
-  tui_enable ();
-  if (arg == (char *) NULL)
-    _parseScrollingArgs (arg, &winToScroll, (int *) NULL);
-  else
-    _parseScrollingArgs (arg, &winToScroll, &numToScroll);
-  tui_scroll (BACKWARD_SCROLL, winToScroll, numToScroll);
-}
-
-
-/*
-   ** _tuiScrollLeft_command().
- */
-static void
-_tuiScrollLeft_command (char *arg, int fromTTY)
-{
-  int numToScroll;
-  TuiWinInfoPtr winToScroll;
-
-  /* Make sure the curses mode is enabled.  */
-  tui_enable ();
-  _parseScrollingArgs (arg, &winToScroll, &numToScroll);
-  tui_scroll (LEFT_SCROLL, winToScroll, numToScroll);
-}
-
-
-/*
-   ** _tuiScrollRight_command().
- */
-static void
-_tuiScrollRight_command (char *arg, int fromTTY)
-{
-  int numToScroll;
-  TuiWinInfoPtr winToScroll;
-
-  /* Make sure the curses mode is enabled.  */
-  tui_enable ();
-  _parseScrollingArgs (arg, &winToScroll, &numToScroll);
-  tui_scroll (RIGHT_SCROLL, winToScroll, numToScroll);
-}
-
-
-/*
-   ** _tuiSetFocus().
-   **     Set focus to the window named by 'arg'
- */
-static void
-_tuiSetFocus (char *arg, int fromTTY)
-{
-  if (arg != (char *) NULL)
-    {
-      char *bufPtr = (char *) xstrdup (arg);
-      int i;
-      TuiWinInfoPtr winInfo = (TuiWinInfoPtr) NULL;
-
-      for (i = 0; (i < strlen (bufPtr)); i++)
-	bufPtr[i] = toupper (arg[i]);
-
-      if (subset_compare (bufPtr, "NEXT"))
-	winInfo = tuiNextWin (tuiWinWithFocus ());
-      else if (subset_compare (bufPtr, "PREV"))
-	winInfo = tuiPrevWin (tuiWinWithFocus ());
-      else
-	winInfo = partialWinByName (bufPtr);
-
-      if (winInfo == (TuiWinInfoPtr) NULL || !winInfo->generic.isVisible)
-	warning ("Invalid window specified. \n\
-The window name specified must be valid and visible.\n");
-      else
-	{
-	  tuiSetWinFocusTo (winInfo);
-	  keypad (cmdWin->generic.handle, (winInfo != cmdWin));
-	}
-
-      if (dataWin && dataWin->generic.isVisible)
-	tuiRefreshDataWin ();
-      tuiFree (bufPtr);
-      printf_filtered ("Focus set to %s window.\n",
-		       winName ((TuiGenWinInfoPtr) tuiWinWithFocus ()));
-    }
-  else
-    warning ("Incorrect Number of Arguments.\n%s", FOCUS_USAGE);
-
-  return;
-}				/* _tuiSetFocus */
-
-/*
-   ** _tuiSetFocus_command()
- */
-static void
-_tuiSetFocus_command (char *arg, int fromTTY)
-{
-  /* Make sure the curses mode is enabled.  */
-  tui_enable ();
-  _tuiSetFocus (arg, fromTTY);
-}
-
-
-/*
-   ** _tuiAllWindowsInfo().
- */
-static void
-_tuiAllWindowsInfo (char *arg, int fromTTY)
-{
-  TuiWinType type;
-  TuiWinInfoPtr winWithFocus = tuiWinWithFocus ();
-
-  for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
-    if (winList[type] && winList[type]->generic.isVisible)
-      {
-	if (winWithFocus == winList[type])
-	  printf_filtered ("        %s\t(%d lines)  <has focus>\n",
-			   winName (&winList[type]->generic),
-			   winList[type]->generic.height);
-	else
-	  printf_filtered ("        %s\t(%d lines)\n",
-			   winName (&winList[type]->generic),
-			   winList[type]->generic.height);
-      }
-
-  return;
-}				/* _tuiAllWindowsInfo */
-
-
-/*
-   ** _tuiRefreshAll_command().
- */
-static void
-_tuiRefreshAll_command (char *arg, int fromTTY)
-{
-  /* Make sure the curses mode is enabled.  */
-  tui_enable ();
-
-  tuiRefreshAll ();
-}
-
-
-/*
-   ** _tuiSetWinTabWidth_command().
-   **        Set the height of the specified window.
- */
-static void
-_tuiSetTabWidth_command (char *arg, int fromTTY)
-{
-  /* Make sure the curses mode is enabled.  */
-  tui_enable ();
-  if (arg != (char *) NULL)
-    {
-      int ts;
-
-      ts = atoi (arg);
-      if (ts > 0)
-	tuiSetDefaultTabLen (ts);
-      else
-	warning ("Tab widths greater than 0 must be specified.\n");
-    }
-
-  return;
-}				/* _tuiSetTabWidth_command */
-
-
-/*
-   ** _tuiSetWinHeight().
-   **        Set the height of the specified window.
- */
-static void
-_tuiSetWinHeight (char *arg, int fromTTY)
-{
-  /* Make sure the curses mode is enabled.  */
-  tui_enable ();
-  if (arg != (char *) NULL)
-    {
-      char *buf = xstrdup (arg);
-      char *bufPtr = buf;
-      char *wname = (char *) NULL;
-      int newHeight, i;
-      TuiWinInfoPtr winInfo;
-
-      wname = bufPtr;
-      bufPtr = strchr (bufPtr, ' ');
-      if (bufPtr != (char *) NULL)
-	{
-	  *bufPtr = (char) 0;
-
-	  /*
-	     ** Validate the window name
-	   */
-	  for (i = 0; i < strlen (wname); i++)
-	    wname[i] = toupper (wname[i]);
-	  winInfo = partialWinByName (wname);
-
-	  if (winInfo == (TuiWinInfoPtr) NULL || !winInfo->generic.isVisible)
-	    warning ("Invalid window specified. \n\
-The window name specified must be valid and visible.\n");
-	  else
-	    {
-	      /* Process the size */
-	      while (*(++bufPtr) == ' ')
-		;
-
-	      if (*bufPtr != (char) 0)
-		{
-		  int negate = FALSE;
-		  int fixedSize = TRUE;
-		  int inputNo;;
-
-		  if (*bufPtr == '+' || *bufPtr == '-')
-		    {
-		      if (*bufPtr == '-')
-			negate = TRUE;
-		      fixedSize = FALSE;
-		      bufPtr++;
-		    }
-		  inputNo = atoi (bufPtr);
-		  if (inputNo > 0)
-		    {
-		      if (negate)
-			inputNo *= (-1);
-		      if (fixedSize)
-			newHeight = inputNo;
-		      else
-			newHeight = winInfo->generic.height + inputNo;
-		      /*
-		         ** Now change the window's height, and adjust all
-		         ** other windows around it
-		       */
-		      if (_tuiAdjustWinHeights (winInfo,
-						newHeight) == TUI_FAILURE)
-			warning ("Invalid window height specified.\n%s",
-				 WIN_HEIGHT_USAGE);
-		      else
-                        tui_update_gdb_sizes ();
-		    }
-		  else
-		    warning ("Invalid window height specified.\n%s",
-			     WIN_HEIGHT_USAGE);
-		}
-	    }
-	}
-      else
-	printf_filtered (WIN_HEIGHT_USAGE);
-
-      if (buf != (char *) NULL)
-	tuiFree (buf);
-    }
-  else
-    printf_filtered (WIN_HEIGHT_USAGE);
-
-  return;
-}				/* _tuiSetWinHeight */
-
-/*
-   ** _tuiSetWinHeight_command().
-   **        Set the height of the specified window, with va_list.
- */
-static void
-_tuiSetWinHeight_command (char *arg, int fromTTY)
-{
-  /* Make sure the curses mode is enabled.  */
-  tui_enable ();
-  _tuiSetWinHeight (arg, fromTTY);
-}
-
-
-/*
-   ** _tuiXDBsetWinHeight().
-   **        XDB Compatibility command for setting the window height.  This will
-   **        increase or decrease the command window by the specified amount.
- */
-static void
-_tuiXDBsetWinHeight (char *arg, int fromTTY)
-{
-  /* Make sure the curses mode is enabled.  */
-  tui_enable ();
-  if (arg != (char *) NULL)
-    {
-      int inputNo = atoi (arg);
-
-      if (inputNo > 0)
-	{			/* Add 1 for the locator */
-	  int newHeight = termHeight () - (inputNo + 1);
-
-	  if (!_newHeightOk (winList[CMD_WIN], newHeight) ||
-	      _tuiAdjustWinHeights (winList[CMD_WIN],
-				    newHeight) == TUI_FAILURE)
-	    warning ("Invalid window height specified.\n%s",
-		     XDBWIN_HEIGHT_USAGE);
-	}
-      else
-	warning ("Invalid window height specified.\n%s",
-		 XDBWIN_HEIGHT_USAGE);
-    }
-  else
-    warning ("Invalid window height specified.\n%s", XDBWIN_HEIGHT_USAGE);
-
-  return;
-}				/* _tuiXDBsetWinHeight */
-
-/*
-   ** _tuiSetWinHeight_command().
-   **        Set the height of the specified window, with va_list.
- */
-static void
-_tuiXDBsetWinHeight_command (char *arg, int fromTTY)
-{
-  _tuiXDBsetWinHeight (arg, fromTTY);
-}
-
-
-/*
-   ** _tuiAdjustWinHeights().
-   **        Function to adjust all window heights around the primary
- */
-static TuiStatus
-_tuiAdjustWinHeights (TuiWinInfoPtr primaryWinInfo, int newHeight)
-{
-  TuiStatus status = TUI_FAILURE;
-
-  if (_newHeightOk (primaryWinInfo, newHeight))
-    {
-      status = TUI_SUCCESS;
-      if (newHeight != primaryWinInfo->generic.height)
-	{
-	  int diff;
-	  TuiWinInfoPtr winInfo;
-	  TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
-	  TuiLayoutType curLayout = currentLayout ();
-
-	  diff = (newHeight - primaryWinInfo->generic.height) * (-1);
-	  if (curLayout == SRC_COMMAND || curLayout == DISASSEM_COMMAND)
-	    {
-	      TuiWinInfoPtr srcWinInfo;
-
-	      _makeInvisibleAndSetNewHeight (primaryWinInfo, newHeight);
-	      if (primaryWinInfo->generic.type == CMD_WIN)
-		{
-		  winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[0];
-		  srcWinInfo = winInfo;
-		}
-	      else
-		{
-		  winInfo = winList[CMD_WIN];
-		  srcWinInfo = primaryWinInfo;
-		}
-	      _makeInvisibleAndSetNewHeight (winInfo,
-					     winInfo->generic.height + diff);
-	      cmdWin->generic.origin.y = locator->origin.y + 1;
-	      _makeVisibleWithNewHeight (winInfo);
-	      _makeVisibleWithNewHeight (primaryWinInfo);
-	      if (srcWinInfo->generic.contentSize <= 0)
-		tuiEraseSourceContent (srcWinInfo, EMPTY_SOURCE_PROMPT);
-	    }
-	  else
-	    {
-	      TuiWinInfoPtr firstWin, secondWin;
-
-	      if (curLayout == SRC_DISASSEM_COMMAND)
-		{
-		  firstWin = srcWin;
-		  secondWin = disassemWin;
-		}
-	      else
-		{
-		  firstWin = dataWin;
-		  secondWin = (TuiWinInfoPtr) (sourceWindows ())->list[0];
-		}
-	      if (primaryWinInfo == cmdWin)
-		{		/*
-				   ** Split the change in height accross the 1st & 2nd windows
-				   ** adjusting them as well.
-				 */
-		  int firstSplitDiff = diff / 2;	/* subtract the locator */
-		  int secondSplitDiff = firstSplitDiff;
-
-		  if (diff % 2)
-		    {
-		      if (firstWin->generic.height >
-			  secondWin->generic.height)
-			if (diff < 0)
-			  firstSplitDiff--;
-			else
-			  firstSplitDiff++;
-		      else
-			{
-			  if (diff < 0)
-			    secondSplitDiff--;
-			  else
-			    secondSplitDiff++;
-			}
-		    }
-		  /* make sure that the minimum hieghts are honored */
-		  while ((firstWin->generic.height + firstSplitDiff) < 3)
-		    {
-		      firstSplitDiff++;
-		      secondSplitDiff--;
-		    }
-		  while ((secondWin->generic.height + secondSplitDiff) < 3)
-		    {
-		      secondSplitDiff++;
-		      firstSplitDiff--;
-		    }
-		  _makeInvisibleAndSetNewHeight (
-						  firstWin,
-				 firstWin->generic.height + firstSplitDiff);
-		  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);
-		}
-	      else
-		{
-		  if ((cmdWin->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)
-			{
-			  int i;
-			  for (i = cmdWin->generic.height + diff;
-			       (i < 1); i++)
-			    if (primaryWinInfo == firstWin)
-			      secondWin->generic.height--;
-			    else
-			      firstWin->generic.height--;
-			}
-		    }
-		  if (primaryWinInfo == firstWin)
-		    _makeInvisibleAndSetNewHeight (firstWin, newHeight);
-		  else
-		    _makeInvisibleAndSetNewHeight (
-						    firstWin,
-						  firstWin->generic.height);
-		  secondWin->generic.origin.y = firstWin->generic.height - 1;
-		  if (primaryWinInfo == secondWin)
-		    _makeInvisibleAndSetNewHeight (secondWin, newHeight);
-		  else
-		    _makeInvisibleAndSetNewHeight (
-				      secondWin, secondWin->generic.height);
-		  cmdWin->generic.origin.y = locator->origin.y + 1;
-		  if ((cmdWin->generic.height + diff) < 1)
-		    _makeInvisibleAndSetNewHeight (cmdWin, 1);
-		  else
-		    _makeInvisibleAndSetNewHeight (
-				     cmdWin, cmdWin->generic.height + diff);
-		}
-	      _makeVisibleWithNewHeight (cmdWin);
-	      _makeVisibleWithNewHeight (secondWin);
-	      _makeVisibleWithNewHeight (firstWin);
-	      if (firstWin->generic.contentSize <= 0)
-		tuiEraseSourceContent (firstWin, EMPTY_SOURCE_PROMPT);
-	      if (secondWin->generic.contentSize <= 0)
-		tuiEraseSourceContent (secondWin, EMPTY_SOURCE_PROMPT);
-	    }
-	}
-    }
-
-  return status;
-}				/* _tuiAdjustWinHeights */
-
-
-/*
-   ** _makeInvisibleAndSetNewHeight().
-   **        Function make the target window (and auxillary windows associated
-   **        with the targer) invisible, and set the new height and location.
- */
-static void
-_makeInvisibleAndSetNewHeight (TuiWinInfoPtr winInfo, int height)
-{
-  int i;
-  TuiGenWinInfoPtr genWinInfo;
-
-
-  m_beInvisible (&winInfo->generic);
-  winInfo->generic.height = height;
-  if (height > 1)
-    winInfo->generic.viewportHeight = height - 1;
-  else
-    winInfo->generic.viewportHeight = height;
-  if (winInfo != cmdWin)
-    winInfo->generic.viewportHeight--;
-
-  /* Now deal with the auxillary windows associated with winInfo */
-  switch (winInfo->generic.type)
-    {
-    case SRC_WIN:
-    case DISASSEM_WIN:
-      genWinInfo = winInfo->detail.sourceInfo.executionInfo;
-      m_beInvisible (genWinInfo);
-      genWinInfo->height = height;
-      genWinInfo->origin.y = winInfo->generic.origin.y;
-      if (height > 1)
-	genWinInfo->viewportHeight = height - 1;
-      else
-	genWinInfo->viewportHeight = height;
-      if (winInfo != cmdWin)
-	genWinInfo->viewportHeight--;
-
-      if (m_hasLocator (winInfo))
-	{
-	  genWinInfo = locatorWinInfoPtr ();
-	  m_beInvisible (genWinInfo);
-	  genWinInfo->origin.y = winInfo->generic.origin.y + height;
-	}
-      break;
-    case DATA_WIN:
-      /* delete all data item windows */
-      for (i = 0; i < winInfo->generic.contentSize; i++)
-	{
-	  genWinInfo = (TuiGenWinInfoPtr) & ((TuiWinElementPtr)
-		      winInfo->generic.content[i])->whichElement.dataWindow;
-	  tuiDelwin (genWinInfo->handle);
-	  genWinInfo->handle = (WINDOW *) NULL;
-	}
-      break;
-    default:
-      break;
-    }
-}
-
-
-/*
-   ** _makeVisibleWithNewHeight().
-   **        Function to make the windows with new heights visible.
-   **        This means re-creating the windows' content since the window
-   **        had to be destroyed to be made invisible.
- */
-static void
-_makeVisibleWithNewHeight (TuiWinInfoPtr winInfo)
-{
-  struct symtab *s;
-
-  m_beVisible (&winInfo->generic);
-  checkAndDisplayHighlightIfNeeded (winInfo);
-  switch (winInfo->generic.type)
-    {
-    case SRC_WIN:
-    case DISASSEM_WIN:
-      freeWinContent (winInfo->detail.sourceInfo.executionInfo);
-      m_beVisible (winInfo->detail.sourceInfo.executionInfo);
-      if (winInfo->generic.content != (OpaquePtr) NULL)
-	{
-	  TuiLineOrAddress 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;
-	  else
-	    lineOrAddr.addr =
-	      winInfo->detail.sourceInfo.startLineOrAddr.addr;
-	  freeWinContent (&winInfo->generic);
-	  tuiUpdateSourceWindow (winInfo,
-				 cursal.symtab, lineOrAddr, TRUE);
-	}
-      else if (deprecated_selected_frame != (struct frame_info *) NULL)
-	{
-	  TuiLineOrAddress line;
-	  struct symtab_and_line cursal = get_current_source_symtab_and_line ();
-
-
-	  s = find_pc_symtab (get_frame_pc (deprecated_selected_frame));
-	  if (winInfo->generic.type == SRC_WIN)
-	    line.lineNo = cursal.line;
-	  else
-	    {
-	      find_line_pc (s, cursal.line, &line.addr);
-	    }
-	  tuiUpdateSourceWindow (winInfo, s, line, TRUE);
-	}
-      if (m_hasLocator (winInfo))
-	{
-	  m_beVisible (locatorWinInfoPtr ());
-	  tuiShowLocatorContent ();
-	}
-      break;
-    case DATA_WIN:
-      tuiDisplayAllData ();
-      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);
-      break;
-    default:
-      break;
-    }
-
-  return;
-}				/* _makeVisibleWithNewHeight */
-
-
-static int
-_newHeightOk (TuiWinInfoPtr primaryWinInfo, int newHeight)
-{
-  int ok = (newHeight < termHeight ());
-
-  if (ok)
-    {
-      int diff;
-      TuiLayoutType curLayout = currentLayout ();
-
-      diff = (newHeight - primaryWinInfo->generic.height) * (-1);
-      if (curLayout == SRC_COMMAND || curLayout == DISASSEM_COMMAND)
-	{
-	  ok = ((primaryWinInfo->generic.type == CMD_WIN &&
-		 newHeight <= (termHeight () - 4) &&
-		 newHeight >= MIN_CMD_WIN_HEIGHT) ||
-		(primaryWinInfo->generic.type != CMD_WIN &&
-		 newHeight <= (termHeight () - 2) &&
-		 newHeight >= MIN_WIN_HEIGHT));
-	  if (ok)
-	    {			/* check the total height */
-	      TuiWinInfoPtr winInfo;
-
-	      if (primaryWinInfo == cmdWin)
-		winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[0];
-	      else
-		winInfo = cmdWin;
-	      ok = ((newHeight +
-		     (winInfo->generic.height + diff)) <= termHeight ());
-	    }
-	}
-      else
-	{
-	  int curTotalHeight, totalHeight, minHeight = 0;
-	  TuiWinInfoPtr firstWin, secondWin;
-
-	  if (curLayout == SRC_DISASSEM_COMMAND)
-	    {
-	      firstWin = srcWin;
-	      secondWin = disassemWin;
-	    }
-	  else
-	    {
-	      firstWin = dataWin;
-	      secondWin = (TuiWinInfoPtr) (sourceWindows ())->list[0];
-	    }
-	  /*
-	     ** We could simply add all the heights to obtain the same result
-	     ** but below is more explicit since we subtract 1 for the
-	     ** line that the first and second windows share, and add one
-	     ** for the locator.
-	   */
-	  totalHeight = curTotalHeight =
-	    (firstWin->generic.height + secondWin->generic.height - 1)
-	    + cmdWin->generic.height + 1 /*locator */ ;
-	  if (primaryWinInfo == cmdWin)
-	    {
-	      /* locator included since first & second win share a line */
-	      ok = ((firstWin->generic.height +
-		     secondWin->generic.height + diff) >=
-		    (MIN_WIN_HEIGHT * 2) &&
-		    newHeight >= MIN_CMD_WIN_HEIGHT);
-	      if (ok)
-		{
-		  totalHeight = newHeight + (firstWin->generic.height +
-					  secondWin->generic.height + diff);
-		  minHeight = MIN_CMD_WIN_HEIGHT;
-		}
-	    }
-	  else
-	    {
-	      minHeight = MIN_WIN_HEIGHT;
-	      /*
-	         ** First see if we can increase/decrease the command
-	         ** window.  And make sure that the command window is
-	         ** at least 1 line
-	       */
-	      ok = ((cmdWin->generic.height + diff) > 0);
-	      if (!ok)
-		{		/*
-				   ** Looks like we have to increase/decrease one of
-				   ** the other windows
-				 */
-		  if (primaryWinInfo == firstWin)
-		    ok = (secondWin->generic.height + diff) >= minHeight;
-		  else
-		    ok = (firstWin->generic.height + diff) >= minHeight;
-		}
-	      if (ok)
-		{
-		  if (primaryWinInfo == firstWin)
-		    totalHeight = newHeight +
-		      secondWin->generic.height +
-		      cmdWin->generic.height + diff;
-		  else
-		    totalHeight = newHeight +
-		      firstWin->generic.height +
-		      cmdWin->generic.height + diff;
-		}
-	    }
-	  /*
-	     ** Now make sure that the proposed total height doesn't exceed
-	     ** the old total height.
-	   */
-	  if (ok)
-	    ok = (newHeight >= minHeight && totalHeight <= curTotalHeight);
-	}
-    }
-
-  return ok;
-}				/* _newHeightOk */
-
-
-/*
-   ** _parseScrollingArgs().
- */
-static void
-_parseScrollingArgs (char *arg, TuiWinInfoPtr * winToScroll, int *numToScroll)
-{
-  if (numToScroll)
-    *numToScroll = 0;
-  *winToScroll = tuiWinWithFocus ();
-
-  /*
-     ** First set up the default window to scroll, in case there is no
-     ** window name arg
-   */
-  if (arg != (char *) NULL)
-    {
-      char *buf, *bufPtr;
-
-      /* process the number of lines to scroll */
-      buf = bufPtr = xstrdup (arg);
-      if (isdigit (*bufPtr))
-	{
-	  char *numStr;
-
-	  numStr = bufPtr;
-	  bufPtr = strchr (bufPtr, ' ');
-	  if (bufPtr != (char *) NULL)
-	    {
-	      *bufPtr = (char) 0;
-	      if (numToScroll)
-		*numToScroll = atoi (numStr);
-	      bufPtr++;
-	    }
-	  else if (numToScroll)
-	    *numToScroll = atoi (numStr);
-	}
-
-      /* process the window name if one is specified */
-      if (bufPtr != (char *) NULL)
-	{
-	  char *wname;
-	  int i;
-
-	  if (*bufPtr == ' ')
-	    while (*(++bufPtr) == ' ')
-	      ;
-
-	  if (*bufPtr != (char) 0)
-	    wname = bufPtr;
-	  else
-	    wname = "?";
-	  
-	  /* Validate the window name */
-	  for (i = 0; i < strlen (wname); i++)
-	    wname[i] = toupper (wname[i]);
-	  *winToScroll = partialWinByName (wname);
-
-	  if (*winToScroll == (TuiWinInfoPtr) NULL ||
-	      !(*winToScroll)->generic.isVisible)
-	    warning ("Invalid window specified. \n\
-The window name specified must be valid and visible.\n");
-	  else if (*winToScroll == cmdWin)
-	    *winToScroll = (TuiWinInfoPtr) (sourceWindows ())->list[0];
-	}
-      tuiFree (buf);
-    }
-
-  return;
-}				/* _parseScrollingArgs */