/* TUI data manipulation routines.
- Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
- Inc.
+ Copyright (C) 1998-2019 Free Software Foundation, Inc.
Contributed by Hewlett-Packard Company.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "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
+#include "gdb_curses.h"
/****************************
** GLOBAL DECLARATIONS
****************************/
-TuiWinInfoPtr winList[MAX_MAJOR_WINDOWS];
+struct tui_win_info *tui_win_list[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 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 std::vector<tui_win_info *> source_windows;
+static struct tui_win_info *win_with_focus = NULL;
+static struct tui_layout_def layout_def = {
+ SRC_WIN, /* DISPLAY_MODE */
+ FALSE}; /* SPLIT */
+
+static int win_resized = FALSE;
/*********************************
** Static function forward decls
**********************************/
-static void freeContent (TuiWinContent, int, TuiWinType);
-static void freeContentElements (TuiWinContent, int, TuiWinType);
+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_auxillary (enum tui_win_type win_type)
+{
+ return (win_type > MAX_MAJOR_WINDOWS);
+}
+
+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. */
+/* Answer a whether the terminal window has been resized or not. */
int
tui_win_resized (void)
{
- return _winResized;
+ return win_resized;
}
-/* Set a whether the terminal window has been resized or not. */
+/* Set a whether the terminal window has been resized or not. */
void
tui_set_win_resized_to (int resized)
{
- _winResized = resized;
+ win_resized = resized;
}
-/* Answer a pointer to the current layout definition. */
-TuiLayoutDefPtr
+/* Answer a pointer to the current layout definition. */
+struct tui_layout_def *
tui_layout_def (void)
{
- return &_layoutDef;
+ return &layout_def;
}
-/* Answer the window with the logical focus. */
-TuiWinInfoPtr
+/* Answer the window with the logical focus. */
+struct tui_win_info *
tui_win_with_focus (void)
{
- return _winWithFocus;
+ return win_with_focus;
}
-/* Set the window that has the logical focus. */
+/* Set the window that has the logical focus. */
void
-tui_set_win_with_focus (TuiWinInfoPtr winInfo)
+tui_set_win_with_focus (struct tui_win_info *win_info)
{
- _winWithFocus = winInfo;
+ win_with_focus = win_info;
}
-/* Answer the length in chars, of tabs. */
-int
-tui_default_tab_len (void)
-{
- return _defaultTabLen;
-}
-
-
-/* Set the length in chars, of tabs. */
-void
-tui_set_default_tab_len (int len)
-{
- _defaultTabLen = len;
-}
-
-
-/*
- ** 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
-tui_source_windows (void)
+/* 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. */
+std::vector<tui_win_info *> &
+tui_source_windows ()
{
- return &_sourceWindows;
+ return source_windows;
}
window (either source or disassembly), but both can be displayed at
the same time. */
void
-tui_clear_source_windows (void)
+tui_clear_source_windows ()
{
- _sourceWindows.list[0] = (Opaque) NULL;
- _sourceWindows.list[1] = (Opaque) NULL;
- _sourceWindows.count = 0;
+ source_windows.clear ();
}
-/* Clear the pertinant detail in the source windows. */
+/* Clear the pertinant detail in the source windows. */
void
-tui_clear_source_windows_detail (void)
+tui_clear_source_windows_detail ()
{
- int i;
-
- for (i = 0; i < (tui_source_windows ())->count; i++)
- tui_clear_win_detail ((TuiWinInfoPtr) (tui_source_windows ())->list[i]);
+ for (tui_win_info *win : tui_source_windows ())
+ win->clear_detail ();
}
one source window (either source or disassembly), but both can be
displayed at the same time. */
void
-tui_add_to_source_windows (TuiWinInfoPtr winInfo)
+tui_add_to_source_windows (struct tui_win_info *win_info)
{
- if (_sourceWindows.count < 2)
- _sourceWindows.list[_sourceWindows.count++] = (Opaque) winInfo;
+ if (source_windows.size () < 2)
+ source_windows.push_back (win_info);
}
+/* See tui-data.h. */
-/* Clear the pertinant detail in the windows. */
void
-tui_clear_win_detail (TuiWinInfoPtr winInfo)
+tui_source_window_base::clear_detail ()
{
- 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;
- }
- }
+ gdbarch = NULL;
+ start_line_or_addr.loa = LOA_ADDRESS;
+ start_line_or_addr.u.addr = 0;
+ horizontal_offset = 0;
+}
+
+/* See tui-data.h. */
+
+void
+tui_cmd_window::clear_detail ()
+{
+ wmove (generic.handle, 0, 0);
+}
- return;
-} /* clearWinDetail */
+/* See tui-data.h. */
+void
+tui_data_window::clear_detail ()
+{
+ data_content = NULL;
+ data_content_count = 0;
+ regs_content = NULL;
+ regs_content_count = 0;
+ regs_column_count = 1;
+ display_regs = false;
+}
-/*
- ** sourceExecInfoPtr().
- ** Accessor for the source execution info ptr.
- */
-TuiGenWinInfoPtr
+/* Accessor for the source execution info ptr. */
+struct tui_gen_win_info *
tui_source_exec_info_win_ptr (void)
{
- return &_execInfo[0];
-} /* sourceExecInfoWinPtr */
+ return &exec_info[0];
+}
-/*
- ** disassemExecInfoPtr().
- ** Accessor for the disassem execution info ptr.
- */
-TuiGenWinInfoPtr
+/* Accessor for the disassem execution info ptr. */
+struct tui_gen_win_info *
tui_disassem_exec_info_win_ptr (void)
{
- return &_execInfo[1];
-} /* disassemExecInfoWinPtr */
+ return &exec_info[1];
+}
/* Accessor for the locator win info. Answers a pointer to the static
locator win info struct. */
-TuiGenWinInfoPtr
+struct tui_gen_win_info *
tui_locator_win_info_ptr (void)
{
return &_locator;
-} /* locatorWinInfoPtr */
+}
-/* Accessor for the termHeight. */
+/* Accessor for the term_height. */
int
tui_term_height (void)
{
- return _termHeight;
+ return term_height;
}
-/* Mutator for the term height. */
+/* Mutator for the term height. */
void
tui_set_term_height_to (int h)
{
- _termHeight = h;
+ term_height = h;
}
-/* Accessor for the termWidth. */
+/* Accessor for the term_width. */
int
tui_term_width (void)
{
- return _termWidth;
+ return term_width;
}
-/* Mutator for the termWidth. */
+/* Mutator for the term_width. */
void
tui_set_term_width_to (int w)
{
- _termWidth = w;
+ term_width = w;
}
-/* Accessor for the current layout. */
-TuiLayoutType
+/* Accessor for the current layout. */
+enum tui_layout_type
tui_current_layout (void)
{
- return _currentLayout;
+ return current_layout;
}
/* Mutator for the current layout. */
void
-tui_set_current_layout_to (TuiLayoutType newLayout)
+tui_set_current_layout_to (enum tui_layout_type new_layout)
{
- _currentLayout = newLayout;
+ current_layout = new_layout;
}
-/*
- ** 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
*****************************/
/* Answer the next window in the list, cycling back to the top if
necessary. */
-TuiWinInfoPtr
-tui_next_win (TuiWinInfoPtr curWin)
+struct tui_win_info *
+tui_next_win (struct tui_win_info *cur_win)
{
- TuiWinType type = curWin->generic.type;
- TuiWinInfoPtr nextWin = (TuiWinInfoPtr) NULL;
+ int type = cur_win->generic.type;
+ struct tui_win_info *next_win = NULL;
- if (curWin->generic.type == CMD_WIN)
+ if (cur_win->generic.type == CMD_WIN)
type = SRC_WIN;
else
- type = curWin->generic.type + 1;
- while (type != curWin->generic.type && m_winPtrIsNull (nextWin))
+ type = cur_win->generic.type + 1;
+ while (type != cur_win->generic.type && (next_win == NULL))
{
- if (winList[type] && winList[type]->generic.isVisible)
- nextWin = winList[type];
+ if (tui_win_list[type]
+ && tui_win_list[type]->generic.is_visible)
+ next_win = tui_win_list[type];
else
{
if (type == CMD_WIN)
}
}
- return nextWin;
-} /* tuiNextWin */
+ return next_win;
+}
/* Answer the prev window in the list, cycling back to the bottom if
necessary. */
-TuiWinInfoPtr
-tui_prev_win (TuiWinInfoPtr curWin)
+struct tui_win_info *
+tui_prev_win (struct tui_win_info *cur_win)
{
- TuiWinType type = curWin->generic.type;
- TuiWinInfoPtr prev = (TuiWinInfoPtr) NULL;
+ int type = cur_win->generic.type;
+ struct tui_win_info *prev = NULL;
- if (curWin->generic.type == SRC_WIN)
+ if (cur_win->generic.type == SRC_WIN)
type = CMD_WIN;
else
- type = curWin->generic.type - 1;
- while (type != curWin->generic.type && m_winPtrIsNull (prev))
+ type = cur_win->generic.type - 1;
+ while (type != cur_win->generic.type && (prev == NULL))
{
- if (winList[type]->generic.isVisible)
- prev = winList[type];
+ if (tui_win_list[type]
+ && tui_win_list[type]->generic.is_visible)
+ prev = tui_win_list[type];
else
{
if (type == SRC_WIN)
}
-/* Answer the window represented by name. */
-TuiWinInfoPtr
-tui_partial_win_by_name (char *name)
+/* Answer the window represented by name. */
+struct tui_win_info *
+tui_partial_win_by_name (const char *name)
{
- TuiWinInfoPtr winInfo = (TuiWinInfoPtr) NULL;
+ struct tui_win_info *win_info = NULL;
- if (name != (char *) NULL)
+ if (name != NULL)
{
int i = 0;
- while (i < MAX_MAJOR_WINDOWS && m_winPtrIsNull (winInfo))
+ while (i < MAX_MAJOR_WINDOWS && win_info == NULL)
{
- if (winList[i] != 0)
+ if (tui_win_list[i] != 0)
{
- char *curName = tui_win_name (&winList[i]->generic);
- if (strlen (name) <= strlen (curName) &&
- strncmp (name, curName, strlen (name)) == 0)
- winInfo = winList[i];
+ const char *cur_name =
+ tui_win_name (&tui_win_list[i]->generic);
+
+ if (strlen (name) <= strlen (cur_name)
+ && startswith (cur_name, name))
+ win_info = tui_win_list[i];
}
i++;
}
}
- return winInfo;
-} /* partialWinByName */
+ return win_info;
+}
-/*
- ** winName().
- ** Answer the name of the window
- */
-char *
-tui_win_name (TuiGenWinInfoPtr winInfo)
+/* Answer the name of the window. */
+const char *
+tui_win_name (const struct tui_gen_win_info *win_info)
{
- char *name = (char *) NULL;
+ const char *name = NULL;
- switch (winInfo->type)
+ switch (win_info->type)
{
case SRC_WIN:
name = SRC_NAME;
}
return name;
-} /* winName */
+}
void
}
-TuiGenWinInfoPtr
+struct tui_gen_win_info *
tui_alloc_generic_win_info (void)
{
- TuiGenWinInfoPtr win;
+ struct tui_gen_win_info *win = XNEW (struct tui_gen_win_info);
- if ((win = (TuiGenWinInfoPtr) xmalloc (
- sizeof (TuiGenWinInfoPtr))) != (TuiGenWinInfoPtr) NULL)
- tui_init_generic_part (win);
+ tui_init_generic_part (win);
return win;
-} /* allocGenericWinInfo */
+}
-/*
- ** initGenericPart().
- */
void
-tui_init_generic_part (TuiGenWinInfoPtr win)
+tui_init_generic_part (struct tui_gen_win_info *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->viewport_height =
+ win->content_size =
+ win->last_visible_line = 0;
+ win->handle = NULL;
+ win->content = NULL;
+ win->content_in_use =
+ win->is_visible = FALSE;
win->title = 0;
}
-/*
- ** initContentElement().
+/* init_content_element().
*/
-void
-initContentElement (TuiWinElementPtr element, TuiWinType type)
+static 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->whichElement.source.line = (char *) NULL;
- element->whichElement.source.lineOrAddr.lineNo = 0;
- element->whichElement.source.isExecPoint = FALSE;
- element->whichElement.source.hasBreak = FALSE;
+ element->which_element.source.line = NULL;
+ element->which_element.source.line_or_addr.loa = LOA_LINE;
+ element->which_element.source.line_or_addr.u.line_no = 0;
+ element->which_element.source.is_exec_point = FALSE;
+ element->which_element.source.has_break = FALSE;
break;
case DATA_WIN:
- tui_init_generic_part (&element->whichElement.dataWindow);
- element->whichElement.dataWindow.type = DATA_ITEM_WIN;
- ((TuiGenWinInfoPtr) & element->whichElement.dataWindow)->content =
- (OpaquePtr) tui_alloc_content (1, DATA_ITEM_WIN);
- ((TuiGenWinInfoPtr)
- & element->whichElement.dataWindow)->contentSize = 1;
+ tui_init_generic_part (&element->which_element.data_window);
+ element->which_element.data_window.type = DATA_ITEM_WIN;
+ element->which_element.data_window.content =
+ tui_alloc_content (1, DATA_ITEM_WIN);
+ element->which_element.data_window.content_size = 1;
break;
case CMD_WIN:
- element->whichElement.command.line = (char *) NULL;
+ element->which_element.command.line = 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;
+ element->which_element.data.name = 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 = NULL;
break;
case LOCATOR_WIN:
- element->whichElement.locator.fileName[0] =
- element->whichElement.locator.procName[0] = (char) 0;
- element->whichElement.locator.lineNo = 0;
- element->whichElement.locator.addr = 0;
+ element->which_element.locator.full_name[0] =
+ element->which_element.locator.proc_name[0] = (char) 0;
+ element->which_element.locator.line_no = 0;
+ element->which_element.locator.addr = 0;
break;
case EXEC_INFO_WIN:
- memset(element->whichElement.simpleString, ' ',
- sizeof(element->whichElement.simpleString));
+ memset(element->which_element.simple_string, ' ',
+ sizeof(element->which_element.simple_string));
break;
default:
break;
}
- return;
-} /* initContentElement */
+}
-/*
- ** initWinInfo().
- */
-void
-initWinInfo (TuiWinInfoPtr winInfo)
+tui_win_info::tui_win_info (enum tui_win_type type)
+{
+ generic.type = type;
+ tui_init_generic_part (&generic);
+}
+
+tui_source_window_base::tui_source_window_base (enum tui_win_type type)
+ : tui_win_info (type)
{
- tui_init_generic_part (&winInfo->generic);
- winInfo->canHighlight =
- winInfo->isHighlighted = FALSE;
- switch (winInfo->generic.type)
+ gdb_assert (type == SRC_WIN || type == DISASSEM_WIN);
+ start_line_or_addr.loa = LOA_ADDRESS;
+ start_line_or_addr.u.addr = 0;
+}
+
+struct tui_win_info *
+tui_alloc_win_info (enum tui_win_type type)
+{
+ switch (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 */
+ return new tui_source_window ();
+ case DISASSEM_WIN:
+ return new tui_disasm_window ();
-TuiWinInfoPtr
-tui_alloc_win_info (TuiWinType type)
-{
- TuiWinInfoPtr winInfo = (TuiWinInfoPtr) NULL;
+ case DATA_WIN:
+ return new tui_data_window ();
- winInfo = (TuiWinInfoPtr) xmalloc (sizeof (TuiWinInfo));
- if (m_winPtrNotNull (winInfo))
- {
- winInfo->generic.type = type;
- initWinInfo (winInfo);
+ case CMD_WIN:
+ return new tui_cmd_window ();
}
- return winInfo;
-} /* allocWinInfo */
+ gdb_assert_not_reached (_("Unhandled window type"));
+}
-/*
- ** allocContent().
- ** Allocates the content and elements in a block.
- */
-TuiWinContent
-tui_alloc_content (int numElements, TuiWinType type)
+/* Allocates the content and elements in a block. */
+tui_win_content
+tui_alloc_content (int num_elements, enum tui_win_type type)
{
- TuiWinContent content = (TuiWinContent) NULL;
- char *elementBlockPtr = (char *) NULL;
+ tui_win_content content;
+ struct tui_win_element *element_block_ptr;
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)
+ content = XNEWVEC (struct tui_win_element *, num_elements);
+
+ /*
+ * 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)
+ {
+ element_block_ptr = XNEWVEC (struct tui_win_element, num_elements);
+ for (i = 0; i < num_elements; i++)
{
- 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;
- }
+ content[i] = element_block_ptr;
+ init_content_element (content[i], type);
+ element_block_ptr++;
}
}
return content;
-} /* allocContent */
+}
/* Adds the input number of elements to the windows's content. If no
- content has been allocated yet, allocContent() is called to do
+ 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 (TuiGenWinInfoPtr winInfo, int numElements)
+tui_add_content_elements (struct tui_gen_win_info *win_info,
+ int num_elements)
{
- TuiWinElementPtr elementPtr;
- int i, indexStart;
+ struct tui_win_element *element_ptr;
+ int i, index_start;
- if (winInfo->content == (OpaquePtr) NULL)
+ if (win_info->content == NULL)
{
- winInfo->content = (OpaquePtr) tui_alloc_content (numElements, winInfo->type);
- indexStart = 0;
+ win_info->content = tui_alloc_content (num_elements, win_info->type);
+ index_start = 0;
}
else
- indexStart = winInfo->contentSize;
- if (winInfo->content != (OpaquePtr) NULL)
+ index_start = win_info->content_size;
+ if (win_info->content != NULL)
{
- for (i = indexStart; (i < numElements + indexStart); i++)
+ for (i = index_start; (i < num_elements + index_start); 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);
+ element_ptr = XNEW (struct tui_win_element);
+ win_info->content[i] = element_ptr;
+ init_content_element (element_ptr, win_info->type);
+ win_info->content_size++;
}
}
- return indexStart;
-} /* addContentElements */
-
+ return index_start;
+}
-/* Delete all curses windows associated with winInfo, leaving everything
- else intact. */
-void
-tuiDelWindow (TuiWinInfoPtr winInfo)
+tui_source_window_base::~tui_source_window_base ()
{
- TuiGenWinInfoPtr genericWin;
-
- switch (winInfo->generic.type)
+ xfree (fullname);
+ struct tui_gen_win_info *generic_win = execution_info;
+ if (generic_win != NULL)
{
- case SRC_WIN:
- case DISASSEM_WIN:
- genericWin = tui_locator_win_info_ptr ();
- if (genericWin != (TuiGenWinInfoPtr) NULL)
- {
- tui_delete_win (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)
- {
- tui_delete_win (genericWin->handle);
- genericWin->handle = (WINDOW *) NULL;
- genericWin->isVisible = FALSE;
- }
- break;
- case DATA_WIN:
- if (winInfo->generic.content != (OpaquePtr) NULL)
- {
- tui_del_data_windows (winInfo->detail.dataDisplayInfo.regsContent,
- winInfo->detail.dataDisplayInfo.regsContentCount);
- tui_del_data_windows (winInfo->detail.dataDisplayInfo.dataContent,
- winInfo->detail.dataDisplayInfo.dataContentCount);
- }
- break;
- default:
- break;
+ tui_delete_win (generic_win->handle);
+ generic_win->handle = NULL;
+ tui_free_win_content (generic_win);
}
- if (winInfo->generic.handle != (WINDOW *) NULL)
- {
- tui_delete_win (winInfo->generic.handle);
- winInfo->generic.handle = (WINDOW *) NULL;
- winInfo->generic.isVisible = FALSE;
- }
-}
+}
-
-void
-tui_free_window (TuiWinInfoPtr winInfo)
+tui_data_window::~tui_data_window ()
{
- TuiGenWinInfoPtr genericWin;
-
- switch (winInfo->generic.type)
+ if (generic.content != NULL)
{
- case SRC_WIN:
- case DISASSEM_WIN:
- genericWin = tui_locator_win_info_ptr ();
- if (genericWin != (TuiGenWinInfoPtr) NULL)
- {
- tui_delete_win (genericWin->handle);
- genericWin->handle = (WINDOW *) NULL;
- }
- tui_free_win_content (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)
- {
- tui_delete_win (genericWin->handle);
- genericWin->handle = (WINDOW *) NULL;
- tui_free_win_content (genericWin);
- }
- break;
- case DATA_WIN:
- if (winInfo->generic.content != (OpaquePtr) NULL)
- {
- tui_free_data_content (winInfo->detail.dataDisplayInfo.regsContent,
- winInfo->detail.dataDisplayInfo.regsContentCount);
- winInfo->detail.dataDisplayInfo.regsContent =
- (TuiWinContent) NULL;
- winInfo->detail.dataDisplayInfo.regsContentCount = 0;
- tui_free_data_content (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)
- {
- tui_delete_win (winInfo->generic.handle);
- winInfo->generic.handle = (WINDOW *) NULL;
- tui_free_win_content (&winInfo->generic);
+ tui_free_data_content (regs_content, regs_content_count);
+ regs_content = NULL;
+ regs_content_count = 0;
+ tui_free_data_content (data_content, data_content_count);
+ data_content = NULL;
+ data_content_count = 0;
+ regs_column_count = 1;
+ display_regs = false;
+ generic.content = NULL;
+ generic.content_size = 0;
}
- if (winInfo->generic.title)
- xfree (winInfo->generic.title);
- xfree (winInfo);
-}
-
+}
-void
-tui_free_all_source_wins_content (void)
+tui_win_info::~tui_win_info ()
{
- int i;
-
- for (i = 0; i < (tui_source_windows ())->count; i++)
+ if (generic.handle != NULL)
{
- TuiWinInfoPtr winInfo = (TuiWinInfoPtr) (tui_source_windows ())->list[i];
-
- if (m_winPtrNotNull (winInfo))
- {
- tui_free_win_content (&(winInfo->generic));
- tui_free_win_content (winInfo->detail.sourceInfo.executionInfo);
- }
+ tui_delete_win (generic.handle);
+ generic.handle = NULL;
+ tui_free_win_content (&generic);
}
+ if (generic.title)
+ xfree (generic.title);
}
void
-tui_free_win_content (TuiGenWinInfoPtr winInfo)
+tui_free_all_source_wins_content ()
{
- if (winInfo->content != (OpaquePtr) NULL)
+ for (tui_win_info *win_info : tui_source_windows ())
{
- freeContent ((TuiWinContent) winInfo->content,
- winInfo->contentSize,
- winInfo->type);
- winInfo->content = (OpaquePtr) NULL;
+ tui_free_win_content (&(win_info->generic));
+ tui_source_window_base *base = (tui_source_window_base *) win_info;
+ tui_free_win_content (base->execution_info);
}
- winInfo->contentSize = 0;
-
- return;
-} /* freeWinContent */
+}
void
-tui_del_data_windows (TuiWinContent content, int contentSize)
+tui_free_win_content (struct tui_gen_win_info *win_info)
{
- 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++)
+ if (win_info->content != NULL)
{
- TuiGenWinInfoPtr genericWin = &content[i]->whichElement.dataWindow;
-
- if (genericWin != (TuiGenWinInfoPtr) NULL)
- {
- tui_delete_win (genericWin->handle);
- genericWin->handle = (WINDOW *) NULL;
- genericWin->isVisible = FALSE;
- }
+ free_content (win_info->content,
+ win_info->content_size,
+ win_info->type);
+ win_info->content = NULL;
}
+ win_info->content_size = 0;
}
void
-tui_free_data_content (TuiWinContent content, int contentSize)
+tui_free_data_content (tui_win_content content,
+ int content_size)
{
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++)
+ /* 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++)
{
- TuiGenWinInfoPtr genericWin = &content[i]->whichElement.dataWindow;
+ struct tui_gen_win_info *generic_win
+ = &content[i]->which_element.data_window;
- if (genericWin != (TuiGenWinInfoPtr) NULL)
+ if (generic_win != NULL)
{
- tui_delete_win (genericWin->handle);
- genericWin->handle = (WINDOW *) NULL;
- tui_free_win_content (genericWin);
+ tui_delete_win (generic_win->handle);
+ generic_win->handle = NULL;
+ tui_free_win_content (generic_win);
}
}
- freeContent (content,
- contentSize,
- DATA_WIN);
-
- return;
-} /* freeDataContent */
+ free_content (content,
+ content_size,
+ DATA_WIN);
+}
/**********************************
**********************************/
-/*
- ** freeContent().
- */
static void
-freeContent (TuiWinContent content, int contentSize, TuiWinType winType)
+free_content (tui_win_content content,
+ int content_size,
+ enum tui_win_type win_type)
{
- if (content != (TuiWinContent) NULL)
+ if (content != NULL)
{
- freeContentElements (content, contentSize, winType);
- tuiFree ((char *) content);
+ free_content_elements (content, content_size, win_type);
+ xfree (content);
}
-
- return;
-} /* freeContent */
+}
-/*
- ** freeContentElements().
+/* free_content_elements().
*/
static void
-freeContentElements (TuiWinContent content, int contentSize, TuiWinType type)
+free_content_elements (tui_win_content content,
+ int content_size,
+ enum tui_win_type type)
{
- if (content != (TuiWinContent) NULL)
+ if (content != NULL)
{
int i;
- if (type == SRC_WIN || type == DISASSEM_WIN)
+ if (type == DISASSEM_WIN)
{
- /* free whole source block */
- if (content[0]->whichElement.source.line != (char *) NULL)
- tuiFree (content[0]->whichElement.source.line);
+ /* Free whole source block. */
+ xfree (content[0]->which_element.source.line);
}
else
{
- for (i = 0; i < contentSize; i++)
+ for (i = 0; i < content_size; i++)
{
- TuiWinElementPtr element;
+ struct tui_win_element *element;
element = content[i];
- if (element != (TuiWinElementPtr) NULL)
+ if (element != NULL)
{
switch (type)
{
+ case SRC_WIN:
+ xfree (element->which_element.source.line);
+ break;
case DATA_WIN:
- tuiFree ((char *) element);
+ xfree (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);
+ /* 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:
- tuiFree ((char *) element->whichElement.command.line);
+ xfree (element->which_element.command.line);
break;
default:
break;
}
}
if (type != DATA_WIN && type != DATA_ITEM_WIN)
- tuiFree ((char *) content[0]); /* free the element block */
+ xfree (content[0]); /* Free the element block. */
}
-
- return;
-} /* freeContentElements */
+}
projects / deliverable / binutils-gdb.git / blobdiff