2004-01-18 Andrew Cagney <cagney@redhat.com>

	* tui/tui-command.c: Rename tui/tuiCommand.c.
	* tui/tui-command.h: Rename tui/tuiCommand.h.
	* tui/tui-data.c: Rename tui/tuiData.c.
	* tui/tui-data.h: Rename tui/tuiData.h.
	* tui/tui-disasm.c: Rename tui/tuiDisassem.c.
	* tui/tui-disasm.h: Rename tui/tuiDisassem.h.
	* tui/tui-io.c: Rename tui/tuiIO.c.
	* tui/tui-io.h: Rename tui/tuiIO.h.
	* tui/tui-layout.c: Rename tui/tuiLayout.c.
	* tui/tui-layout.h: Rename tui/tuiLayout.h.
	* tui/tui-regs.c: Rename tui/tuiRegs.c.
	* tui/tui-regs.h: Rename tui/tuiRegs.h.
	* tui/tui-source.c: Rename tui/tuiSource.c.
	* tui/tui-source.h: Rename tui/tuiSource.h.
	* tui/tui-stack.c: Rename tui/tuiStack.c.
	* tui/tui-stack.h: Rename tui/tuiStack.h.
	* tui/tui-win.c: Rename tui/tuiWin.c.
	* tui/tui-win.h: Rename tui/tuiWin.h.
	* tui/tui-windata.c: Rename tui/tuiDataWin.c.
	* tui/tui-windata.h: Rename tui/tuiDataWin.h.
	* tui/tui-wingeneral.c: Rename tui/tuiGeneralWin.c.
	* tui/tui-wingeneral.h: Rename tui/tuiGeneralWin.h.
	* tui/tui-winsource.c: Rename tui/tuiSourceWin.c.
	* tui/tui-winsource.h: Rename tui/tuiSourceWin.h.
	* tui/tui-file.c: Update includes.
	* tui/tui-hooks.c: Update includes.
	* tui/tui-interp.c: Update includes.
	* tui/tui.c: Update includes.
	* Makefile.in: Update all tui/ dependencies.
	(SUBDIR_TUI_OBS, SUBDIR_TUI_SRCS): Update file names.

1 files changed, 1055 insertions, 0 deletions

diff --git a/gdb/tui/tui-data.c b/gdb/tui/tui-data.c
new file mode 100644
index 0000000..c6f4fb5
--- /dev/null
+++ b/gdb/tui/tui-data.c
@@ -0,0 +1,1055 @@
+/* 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/tui.h"
+#include "tui/tui-data.h"
+#include "tui/tui-wingeneral.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 */