+2004-02-07 Andrew Cagney <cagney@redhat.com>
+
+ * tui/tui.h: Do not include <stdarg.h>, <string.h>, and
+ "ansidecl.h". Do not undef "reg" and "chtype". Fix case of
+ fields and variables.
+ * tui/tui-wingeneral.h (m_beVisible): Delete macro.
+ (m_beInvisible): Delete macro.
+ * tui/tui-data.h: Fix case case fields and variables.
+ (m_genWinPtrIsNull): Delete macro.
+ (tui_win_list): Rename winList.
+ (TUI_SRC_WIN): Rename srcWin.
+ (TUI_DISASM_WIN): Rename disassemWin.
+ (TUI_DATA_WIN): Rename dataWin.
+ (TUI_CMD_WIN): Rename cmdWin.
+ (m_genWinPtrNotNull): Delete macro.
+ (m_winPtrIsNull): Delete macro.
+ (m_winPtrNotNull): Delete macro.
+ (tui_win_is_source_type): Replace m_winIsSourceType
+ (tui_win_is_auxillary): Replace m_winIsAuzillary.
+ (tui_win_has_locator): Replace m_hasLocator.
+ (tui_set_win_highlight): Replace m_setWinHighlightOn and
+ m_setWinHighlightOff.
+ * tui/tui-data.c: Update references.
+ (tui_win_is_source_type, tui_set_win_highlight): New functions.
+ (tui_win_has_locator, tui_win_is_auxillary): New functions.
+ * tui/tui-command.c, tui/tui-disasm.c: Update references.
+ * tui/tui-io.c, tui/tui-layout.c, tui/tui-regs.c: Ditto.
+ * tui/tui-regs.h, tui/tui-source.c, tui/tui-stack.c: Ditto.
+ * tui/tui-win.c, tui/tui-windata.c, tui/tui-wingeneral.c: Ditto.
+ * tui/tui-winsource.c, tui/tui.c: Ditto.
+
2004-02-07 Mark Kettenis <kettenis@gnu.org>
* sparc-tdep.h (sparc_fetch_wcookie): New prototype.
unsigned int
tui_dispatch_ctrl_char (unsigned int ch)
{
- struct tui_win_info * winInfo = tui_win_with_focus ();
- WINDOW *w = cmdWin->generic.handle;
+ struct tui_win_info *win_info = tui_win_with_focus ();
+ WINDOW *w = TUI_CMD_WIN->generic.handle;
/*
** If the command window has the logical focus, or no-one does
** assume it is the command window; in this case, pass the
** character on through and do nothing here.
*/
- if (winInfo == (struct tui_win_info *) NULL || winInfo == cmdWin)
+ if (win_info == NULL || win_info == TUI_CMD_WIN)
return ch;
else
{
switch (chCopy)
{
case KEY_NPAGE:
- tui_scroll_forward (winInfo, 0);
+ tui_scroll_forward (win_info, 0);
break;
case KEY_PPAGE:
- tui_scroll_backward (winInfo, 0);
+ tui_scroll_backward (win_info, 0);
break;
case KEY_DOWN:
case KEY_SF:
- tui_scroll_forward (winInfo, 1);
+ tui_scroll_forward (win_info, 1);
break;
case KEY_UP:
case KEY_SR:
- tui_scroll_backward (winInfo, 1);
+ tui_scroll_backward (win_info, 1);
break;
case KEY_RIGHT:
- tui_scroll_left (winInfo, 1);
+ tui_scroll_left (win_info, 1);
break;
case KEY_LEFT:
- tui_scroll_right (winInfo, 1);
+ tui_scroll_right (win_info, 1);
break;
case '\f':
tui_refresh_all_win ();
/* TUI data manipulation routines.
- Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
- Inc.
+ Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
+ Foundation, Inc.
Contributed by Hewlett-Packard Company.
#include "tui/tui-data.h"
#include "tui/tui-wingeneral.h"
+#include "gdb_string.h"
+
#ifdef HAVE_NCURSES_H
#include <ncurses.h>
#else
/****************************
** GLOBAL DECLARATIONS
****************************/
-struct tui_win_info *(winList[MAX_MAJOR_WINDOWS]);
+struct tui_win_info *(tui_win_list[MAX_MAJOR_WINDOWS]);
/***************************
** Private data
** 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
******************************************/
/* Set the window that has the logical focus. */
void
-tui_set_win_with_focus (struct tui_win_info * winInfo)
+tui_set_win_with_focus (struct tui_win_info * win_info)
{
- _winWithFocus = winInfo;
+ _winWithFocus = win_info;
}
one source window (either source or disassembly), but both can be
displayed at the same time. */
void
-tui_add_to_source_windows (struct tui_win_info * winInfo)
+tui_add_to_source_windows (struct tui_win_info * win_info)
{
if (_sourceWindows.count < 2)
- _sourceWindows.list[_sourceWindows.count++] = (void *) winInfo;
+ _sourceWindows.list[_sourceWindows.count++] = (void *) win_info;
}
/* Clear the pertinant detail in the windows. */
void
-tui_clear_win_detail (struct tui_win_info * winInfo)
+tui_clear_win_detail (struct tui_win_info * win_info)
{
- if (m_winPtrNotNull (winInfo))
+ if (win_info != NULL)
{
- switch (winInfo->generic.type)
+ switch (win_info->generic.type)
{
case SRC_WIN:
case DISASSEM_WIN:
- winInfo->detail.sourceInfo.startLineOrAddr.addr = 0;
- winInfo->detail.sourceInfo.horizontalOffset = 0;
+ win_info->detail.source_info.start_line_or_addr.addr = 0;
+ win_info->detail.source_info.horizontal_offset = 0;
break;
case CMD_WIN:
- winInfo->detail.commandInfo.curLine =
- winInfo->detail.commandInfo.curch = 0;
+ win_info->detail.command_info.cur_line =
+ win_info->detail.command_info.curch = 0;
break;
case DATA_WIN:
- winInfo->detail.dataDisplayInfo.dataContent =
+ win_info->detail.data_display_info.data_content =
(tui_win_content) NULL;
- winInfo->detail.dataDisplayInfo.dataContentCount = 0;
- winInfo->detail.dataDisplayInfo.regsContent =
+ win_info->detail.data_display_info.data_content_count = 0;
+ win_info->detail.data_display_info.regs_content =
(tui_win_content) NULL;
- winInfo->detail.dataDisplayInfo.regsContentCount = 0;
- winInfo->detail.dataDisplayInfo.regsDisplayType =
+ win_info->detail.data_display_info.regs_content_count = 0;
+ win_info->detail.data_display_info.regs_display_type =
TUI_UNDEFINED_REGS;
- winInfo->detail.dataDisplayInfo.regsColumnCount = 1;
- winInfo->detail.dataDisplayInfo.displayRegs = FALSE;
+ win_info->detail.data_display_info.regs_column_count = 1;
+ win_info->detail.data_display_info.display_regs = FALSE;
break;
default:
break;
** Set the origin of the window
*/
void
-setGenWinOrigin (struct tui_gen_win_info * winInfo, int x, int y)
+setGenWinOrigin (struct tui_gen_win_info * win_info, int x, int y)
{
- winInfo->origin.x = x;
- winInfo->origin.y = y;
+ win_info->origin.x = x;
+ win_info->origin.y = y;
return;
} /* setGenWinOrigin */
type = SRC_WIN;
else
type = curWin->generic.type + 1;
- while (type != curWin->generic.type && m_winPtrIsNull (nextWin))
+ while (type != curWin->generic.type && (nextWin == NULL))
{
- if (winList[type] && winList[type]->generic.isVisible)
- nextWin = winList[type];
+ if (tui_win_list[type] && tui_win_list[type]->generic.is_visible)
+ nextWin = tui_win_list[type];
else
{
if (type == CMD_WIN)
type = CMD_WIN;
else
type = curWin->generic.type - 1;
- while (type != curWin->generic.type && m_winPtrIsNull (prev))
+ while (type != curWin->generic.type && (prev == NULL))
{
- if (winList[type]->generic.isVisible)
- prev = winList[type];
+ if (tui_win_list[type]->generic.is_visible)
+ prev = tui_win_list[type];
else
{
if (type == SRC_WIN)
struct tui_win_info *
tui_partial_win_by_name (char *name)
{
- struct tui_win_info * winInfo = (struct tui_win_info *) NULL;
+ struct tui_win_info * win_info = (struct tui_win_info *) NULL;
if (name != (char *) NULL)
{
int i = 0;
- while (i < MAX_MAJOR_WINDOWS && m_winPtrIsNull (winInfo))
+ while (i < MAX_MAJOR_WINDOWS && win_info == NULL)
{
- if (winList[i] != 0)
+ if (tui_win_list[i] != 0)
{
- char *curName = tui_win_name (&winList[i]->generic);
+ char *curName = tui_win_name (&tui_win_list[i]->generic);
if (strlen (name) <= strlen (curName) &&
strncmp (name, curName, strlen (name)) == 0)
- winInfo = winList[i];
+ win_info = tui_win_list[i];
}
i++;
}
}
- return winInfo;
+ return win_info;
} /* partialWinByName */
** Answer the name of the window
*/
char *
-tui_win_name (struct tui_gen_win_info * winInfo)
+tui_win_name (struct tui_gen_win_info * win_info)
{
char *name = (char *) NULL;
- switch (winInfo->type)
+ switch (win_info->type)
{
case SRC_WIN:
name = SRC_NAME;
win->height =
win->origin.x =
win->origin.y =
- win->viewportHeight =
- win->contentSize =
- win->lastVisibleLine = 0;
+ win->viewport_height =
+ win->content_size =
+ win->last_visible_line = 0;
win->handle = (WINDOW *) NULL;
win->content = NULL;
- win->contentInUse =
- win->isVisible = FALSE;
+ win->content_in_use =
+ win->is_visible = FALSE;
win->title = 0;
}
{
case SRC_WIN:
case DISASSEM_WIN:
- element->whichElement.source.line = (char *) NULL;
- element->whichElement.source.lineOrAddr.lineNo = 0;
- element->whichElement.source.isExecPoint = FALSE;
- element->whichElement.source.hasBreak = FALSE;
+ element->which_element.source.line = (char *) NULL;
+ element->which_element.source.line_or_addr.line_no = 0;
+ element->which_element.source.is_exec_point = FALSE;
+ element->which_element.source.has_break = FALSE;
break;
case DATA_WIN:
- tui_init_generic_part (&element->whichElement.dataWindow);
- element->whichElement.dataWindow.type = DATA_ITEM_WIN;
- ((struct tui_gen_win_info *) & element->whichElement.dataWindow)->content =
+ tui_init_generic_part (&element->which_element.data_window);
+ element->which_element.data_window.type = DATA_ITEM_WIN;
+ ((struct tui_gen_win_info *) & element->which_element.data_window)->content =
(void **) tui_alloc_content (1, DATA_ITEM_WIN);
((struct tui_gen_win_info *)
- & element->whichElement.dataWindow)->contentSize = 1;
+ & element->which_element.data_window)->content_size = 1;
break;
case CMD_WIN:
- element->whichElement.command.line = (char *) NULL;
+ element->which_element.command.line = (char *) NULL;
break;
case DATA_ITEM_WIN:
- element->whichElement.data.name = (char *) NULL;
- element->whichElement.data.type = TUI_REGISTER;
- element->whichElement.data.itemNo = UNDEFINED_ITEM;
- element->whichElement.data.value = NULL;
- element->whichElement.data.highlight = FALSE;
+ element->which_element.data.name = (char *) NULL;
+ element->which_element.data.type = TUI_REGISTER;
+ element->which_element.data.item_no = UNDEFINED_ITEM;
+ element->which_element.data.value = NULL;
+ element->which_element.data.highlight = FALSE;
break;
case LOCATOR_WIN:
- element->whichElement.locator.fileName[0] =
- element->whichElement.locator.procName[0] = (char) 0;
- element->whichElement.locator.lineNo = 0;
- element->whichElement.locator.addr = 0;
+ element->which_element.locator.file_name[0] =
+ element->which_element.locator.proc_name[0] = (char) 0;
+ element->which_element.locator.line_no = 0;
+ element->which_element.locator.addr = 0;
break;
case EXEC_INFO_WIN:
- memset(element->whichElement.simpleString, ' ',
- sizeof(element->whichElement.simpleString));
+ memset(element->which_element.simple_string, ' ',
+ sizeof(element->which_element.simple_string));
break;
default:
break;
** initWinInfo().
*/
void
-initWinInfo (struct tui_win_info * winInfo)
+initWinInfo (struct tui_win_info * win_info)
{
- tui_init_generic_part (&winInfo->generic);
- winInfo->canHighlight =
- winInfo->isHighlighted = FALSE;
- switch (winInfo->generic.type)
+ tui_init_generic_part (&win_info->generic);
+ win_info->can_highlight =
+ win_info->is_highlighted = FALSE;
+ switch (win_info->generic.type)
{
case SRC_WIN:
case DISASSEM_WIN:
- winInfo->detail.sourceInfo.executionInfo = (struct tui_gen_win_info *) NULL;
- winInfo->detail.sourceInfo.hasLocator = FALSE;
- winInfo->detail.sourceInfo.horizontalOffset = 0;
- winInfo->detail.sourceInfo.startLineOrAddr.addr = 0;
- winInfo->detail.sourceInfo.filename = 0;
+ win_info->detail.source_info.execution_info = (struct tui_gen_win_info *) NULL;
+ win_info->detail.source_info.has_locator = FALSE;
+ win_info->detail.source_info.horizontal_offset = 0;
+ win_info->detail.source_info.start_line_or_addr.addr = 0;
+ win_info->detail.source_info.filename = 0;
break;
case DATA_WIN:
- winInfo->detail.dataDisplayInfo.dataContent = (tui_win_content) NULL;
- winInfo->detail.dataDisplayInfo.dataContentCount = 0;
- winInfo->detail.dataDisplayInfo.regsContent = (tui_win_content) NULL;
- winInfo->detail.dataDisplayInfo.regsContentCount = 0;
- winInfo->detail.dataDisplayInfo.regsDisplayType =
+ win_info->detail.data_display_info.data_content = (tui_win_content) NULL;
+ win_info->detail.data_display_info.data_content_count = 0;
+ win_info->detail.data_display_info.regs_content = (tui_win_content) NULL;
+ win_info->detail.data_display_info.regs_content_count = 0;
+ win_info->detail.data_display_info.regs_display_type =
TUI_UNDEFINED_REGS;
- winInfo->detail.dataDisplayInfo.regsColumnCount = 1;
- winInfo->detail.dataDisplayInfo.displayRegs = FALSE;
+ win_info->detail.data_display_info.regs_column_count = 1;
+ win_info->detail.data_display_info.display_regs = FALSE;
break;
case CMD_WIN:
- winInfo->detail.commandInfo.curLine = 0;
- winInfo->detail.commandInfo.curch = 0;
+ win_info->detail.command_info.cur_line = 0;
+ win_info->detail.command_info.curch = 0;
break;
default:
- winInfo->detail.opaque = NULL;
+ win_info->detail.opaque = NULL;
break;
}
struct tui_win_info *
tui_alloc_win_info (enum tui_win_type type)
{
- struct tui_win_info * winInfo = (struct tui_win_info *) NULL;
+ struct tui_win_info * win_info = (struct tui_win_info *) NULL;
- winInfo = (struct tui_win_info *) xmalloc (sizeof (struct tui_win_info));
- if (m_winPtrNotNull (winInfo))
+ win_info = (struct tui_win_info *) xmalloc (sizeof (struct tui_win_info));
+ if ((win_info != NULL))
{
- winInfo->generic.type = type;
- initWinInfo (winInfo);
+ win_info->generic.type = type;
+ initWinInfo (win_info);
}
- return winInfo;
+ return win_info;
} /* allocWinInfo */
there is a memory allocation error, in which case, (-1) is
returned. */
int
-tui_add_content_elements (struct tui_gen_win_info * winInfo, int numElements)
+tui_add_content_elements (struct tui_gen_win_info * win_info, int numElements)
{
struct tui_win_element * elementPtr;
int i, indexStart;
- if (winInfo->content == NULL)
+ if (win_info->content == NULL)
{
- winInfo->content = (void **) tui_alloc_content (numElements, winInfo->type);
+ win_info->content = (void **) tui_alloc_content (numElements, win_info->type);
indexStart = 0;
}
else
- indexStart = winInfo->contentSize;
- if (winInfo->content != NULL)
+ indexStart = win_info->content_size;
+ if (win_info->content != NULL)
{
for (i = indexStart; (i < numElements + indexStart); i++)
{
if ((elementPtr = (struct tui_win_element *)
xmalloc (sizeof (struct tui_win_element))) != (struct tui_win_element *) NULL)
{
- winInfo->content[i] = (void *) elementPtr;
- initContentElement (elementPtr, winInfo->type);
- winInfo->contentSize++;
+ win_info->content[i] = (void *) elementPtr;
+ initContentElement (elementPtr, win_info->type);
+ win_info->content_size++;
}
else /* things must be really hosed now! We ran out of memory!? */
return (-1);
} /* addContentElements */
-/* Delete all curses windows associated with winInfo, leaving everything
+/* Delete all curses windows associated with win_info, leaving everything
else intact. */
void
-tuiDelWindow (struct tui_win_info * winInfo)
+tuiDelWindow (struct tui_win_info * win_info)
{
struct tui_gen_win_info * genericWin;
- switch (winInfo->generic.type)
+ switch (win_info->generic.type)
{
case SRC_WIN:
case DISASSEM_WIN:
{
tui_delete_win (genericWin->handle);
genericWin->handle = (WINDOW *) NULL;
- genericWin->isVisible = FALSE;
+ genericWin->is_visible = FALSE;
}
- if (winInfo->detail.sourceInfo.filename)
+ if (win_info->detail.source_info.filename)
{
- xfree (winInfo->detail.sourceInfo.filename);
- winInfo->detail.sourceInfo.filename = 0;
+ xfree (win_info->detail.source_info.filename);
+ win_info->detail.source_info.filename = 0;
}
- genericWin = winInfo->detail.sourceInfo.executionInfo;
+ genericWin = win_info->detail.source_info.execution_info;
if (genericWin != (struct tui_gen_win_info *) NULL)
{
tui_delete_win (genericWin->handle);
genericWin->handle = (WINDOW *) NULL;
- genericWin->isVisible = FALSE;
+ genericWin->is_visible = FALSE;
}
break;
case DATA_WIN:
- if (winInfo->generic.content != NULL)
+ if (win_info->generic.content != NULL)
{
- tui_del_data_windows (winInfo->detail.dataDisplayInfo.regsContent,
- winInfo->detail.dataDisplayInfo.regsContentCount);
- tui_del_data_windows (winInfo->detail.dataDisplayInfo.dataContent,
- winInfo->detail.dataDisplayInfo.dataContentCount);
+ tui_del_data_windows (win_info->detail.data_display_info.regs_content,
+ win_info->detail.data_display_info.regs_content_count);
+ tui_del_data_windows (win_info->detail.data_display_info.data_content,
+ win_info->detail.data_display_info.data_content_count);
}
break;
default:
break;
}
- if (winInfo->generic.handle != (WINDOW *) NULL)
+ if (win_info->generic.handle != (WINDOW *) NULL)
{
- tui_delete_win (winInfo->generic.handle);
- winInfo->generic.handle = (WINDOW *) NULL;
- winInfo->generic.isVisible = FALSE;
+ tui_delete_win (win_info->generic.handle);
+ win_info->generic.handle = (WINDOW *) NULL;
+ win_info->generic.is_visible = FALSE;
}
}
void
-tui_free_window (struct tui_win_info * winInfo)
+tui_free_window (struct tui_win_info * win_info)
{
struct tui_gen_win_info * genericWin;
- switch (winInfo->generic.type)
+ switch (win_info->generic.type)
{
case SRC_WIN:
case DISASSEM_WIN:
genericWin->handle = (WINDOW *) NULL;
}
tui_free_win_content (genericWin);
- if (winInfo->detail.sourceInfo.filename)
+ if (win_info->detail.source_info.filename)
{
- xfree (winInfo->detail.sourceInfo.filename);
- winInfo->detail.sourceInfo.filename = 0;
+ xfree (win_info->detail.source_info.filename);
+ win_info->detail.source_info.filename = 0;
}
- genericWin = winInfo->detail.sourceInfo.executionInfo;
+ genericWin = win_info->detail.source_info.execution_info;
if (genericWin != (struct tui_gen_win_info *) NULL)
{
tui_delete_win (genericWin->handle);
}
break;
case DATA_WIN:
- if (winInfo->generic.content != NULL)
+ if (win_info->generic.content != NULL)
{
- tui_free_data_content (winInfo->detail.dataDisplayInfo.regsContent,
- winInfo->detail.dataDisplayInfo.regsContentCount);
- winInfo->detail.dataDisplayInfo.regsContent =
+ tui_free_data_content (win_info->detail.data_display_info.regs_content,
+ win_info->detail.data_display_info.regs_content_count);
+ win_info->detail.data_display_info.regs_content =
(tui_win_content) NULL;
- winInfo->detail.dataDisplayInfo.regsContentCount = 0;
- tui_free_data_content (winInfo->detail.dataDisplayInfo.dataContent,
- winInfo->detail.dataDisplayInfo.dataContentCount);
- winInfo->detail.dataDisplayInfo.dataContent =
+ win_info->detail.data_display_info.regs_content_count = 0;
+ tui_free_data_content (win_info->detail.data_display_info.data_content,
+ win_info->detail.data_display_info.data_content_count);
+ win_info->detail.data_display_info.data_content =
(tui_win_content) NULL;
- winInfo->detail.dataDisplayInfo.dataContentCount = 0;
- winInfo->detail.dataDisplayInfo.regsDisplayType =
+ win_info->detail.data_display_info.data_content_count = 0;
+ win_info->detail.data_display_info.regs_display_type =
TUI_UNDEFINED_REGS;
- winInfo->detail.dataDisplayInfo.regsColumnCount = 1;
- winInfo->detail.dataDisplayInfo.displayRegs = FALSE;
- winInfo->generic.content = NULL;
- winInfo->generic.contentSize = 0;
+ win_info->detail.data_display_info.regs_column_count = 1;
+ win_info->detail.data_display_info.display_regs = FALSE;
+ win_info->generic.content = NULL;
+ win_info->generic.content_size = 0;
}
break;
default:
break;
}
- if (winInfo->generic.handle != (WINDOW *) NULL)
+ if (win_info->generic.handle != (WINDOW *) NULL)
{
- tui_delete_win (winInfo->generic.handle);
- winInfo->generic.handle = (WINDOW *) NULL;
- tui_free_win_content (&winInfo->generic);
+ tui_delete_win (win_info->generic.handle);
+ win_info->generic.handle = (WINDOW *) NULL;
+ tui_free_win_content (&win_info->generic);
}
- if (winInfo->generic.title)
- xfree (winInfo->generic.title);
- xfree (winInfo);
+ if (win_info->generic.title)
+ xfree (win_info->generic.title);
+ xfree (win_info);
}
for (i = 0; i < (tui_source_windows ())->count; i++)
{
- struct tui_win_info * winInfo = (struct tui_win_info *) (tui_source_windows ())->list[i];
+ struct tui_win_info * win_info = (struct tui_win_info *) (tui_source_windows ())->list[i];
- if (m_winPtrNotNull (winInfo))
+ if (win_info != NULL)
{
- tui_free_win_content (&(winInfo->generic));
- tui_free_win_content (winInfo->detail.sourceInfo.executionInfo);
+ tui_free_win_content (&(win_info->generic));
+ tui_free_win_content (win_info->detail.source_info.execution_info);
}
}
}
void
-tui_free_win_content (struct tui_gen_win_info * winInfo)
+tui_free_win_content (struct tui_gen_win_info * win_info)
{
- if (winInfo->content != NULL)
+ if (win_info->content != NULL)
{
- freeContent ((tui_win_content) winInfo->content,
- winInfo->contentSize,
- winInfo->type);
- winInfo->content = NULL;
+ freeContent ((tui_win_content) win_info->content,
+ win_info->content_size,
+ win_info->type);
+ win_info->content = NULL;
}
- winInfo->contentSize = 0;
+ win_info->content_size = 0;
return;
} /* freeWinContent */
*/
for (i = 0; i < contentSize; i++)
{
- struct tui_gen_win_info * genericWin = &content[i]->whichElement.dataWindow;
+ struct tui_gen_win_info * genericWin = &content[i]->which_element.data_window;
if (genericWin != (struct tui_gen_win_info *) NULL)
{
tui_delete_win (genericWin->handle);
genericWin->handle = (WINDOW *) NULL;
- genericWin->isVisible = FALSE;
+ genericWin->is_visible = FALSE;
}
}
}
*/
for (i = 0; i < contentSize; i++)
{
- struct tui_gen_win_info * genericWin = &content[i]->whichElement.dataWindow;
+ struct tui_gen_win_info * genericWin = &content[i]->which_element.data_window;
if (genericWin != (struct tui_gen_win_info *) NULL)
{
if (type == SRC_WIN || type == DISASSEM_WIN)
{
/* free whole source block */
- xfree (content[0]->whichElement.source.line);
+ xfree (content[0]->which_element.source.line);
}
else
{
** Note that data elements are not allocated
** in a single block, but individually, as needed.
*/
- if (element->whichElement.data.type != TUI_REGISTER)
- xfree ((void *)element->whichElement.data.name);
- xfree (element->whichElement.data.value);
+ if (element->which_element.data.type != TUI_REGISTER)
+ xfree ((void *)element->which_element.data.name);
+ xfree (element->which_element.data.value);
xfree (element);
break;
case CMD_WIN:
- xfree (element->whichElement.command.line);
+ xfree (element->which_element.command.line);
break;
default:
break;
int height; /* window height */
struct tui_point origin; /* origin of window */
void **content; /* content of window */
- int contentSize; /* Size of content (# of elements) */
- int contentInUse; /* Can it be used, or is it already used? */
- int viewportHeight; /* viewport height */
- int lastVisibleLine; /* index of last visible line */
- int isVisible; /* whether the window is visible or not */
- char* title; /* Window title to display. */
+ int content_size; /* Size of content (# of elements) */
+ int content_in_use; /* Can it be used, or is it already used? */
+ int viewport_height; /* viewport height */
+ int last_visible_line; /* index of last visible line */
+ int is_visible; /* whether the window is visible or not */
+ char *title; /* Window title to display. */
};
/* Constant definitions */
/* Structure describing source line or line address */
union tui_line_or_address
{
- int lineNo;
+ int line_no;
CORE_ADDR addr;
};
/* Current Layout definition */
struct tui_layout_def
{
- enum tui_win_type displayMode;
+ enum tui_win_type display_mode;
int split;
- enum tui_register_display_type regsDisplayType;
- enum tui_register_display_type floatRegsDisplayType;
+ enum tui_register_display_type regs_display_type;
+ enum tui_register_display_type float_regs_display_type;
};
/* Elements in the Source/Disassembly Window */
struct tui_source_element
{
char *line;
- union tui_line_or_address lineOrAddr;
- int isExecPoint;
- int hasBreak;
+ union tui_line_or_address line_or_addr;
+ int is_exec_point;
+ int has_break;
};
struct tui_data_element
{
const char *name;
- int itemNo; /* the register number, or data display number */
+ int item_no; /* the register number, or data display number */
enum tui_data_type type;
void *value;
int highlight;
/* Elements in the locator window content */
struct tui_locator_element
{
- char fileName[MAX_LOCATOR_ELEMENT_LEN];
- char procName[MAX_LOCATOR_ELEMENT_LEN];
- int lineNo;
+ char file_name[MAX_LOCATOR_ELEMENT_LEN];
+ char proc_name[MAX_LOCATOR_ELEMENT_LEN];
+ int line_no;
CORE_ADDR addr;
};
union tui_which_element
{
struct tui_source_element source; /* the source elements */
- struct tui_gen_win_info dataWindow; /* data display elements */
- struct tui_data_element data; /* elements of dataWindow */
+ struct tui_gen_win_info data_window; /* data display elements */
+ struct tui_data_element data; /* elements of data_window */
struct tui_command_element command; /* command elements */
struct tui_locator_element locator; /* locator elements */
- tui_exec_info_content simpleString; /* simple char based elements */
+ tui_exec_info_content simple_string; /* simple char based elements */
};
struct tui_win_element
{
int highlight;
- union tui_which_element whichElement;
+ union tui_which_element which_element;
};
/* This struct defines the specific information about a data display window */
struct tui_data_info
{
- tui_win_content dataContent; /* start of data display content */
- int dataContentCount;
- tui_win_content regsContent; /* start of regs display content */
- int regsContentCount;
- enum tui_register_display_type regsDisplayType;
- int regsColumnCount;
- int displayRegs; /* Should regs be displayed at all? */
+ tui_win_content data_content; /* start of data display content */
+ int data_content_count;
+ tui_win_content regs_content; /* start of regs display content */
+ int regs_content_count;
+ enum tui_register_display_type regs_display_type;
+ int regs_column_count;
+ int display_regs; /* Should regs be displayed at all? */
};
struct tui_source_info
{
- int hasLocator; /* Does locator belongs to this window? */
+ int has_locator; /* Does locator belongs to this window? */
/* Execution information window. */
- struct tui_gen_win_info *executionInfo;
- int horizontalOffset; /* used for horizontal scroll */
- union tui_line_or_address startLineOrAddr;
+ struct tui_gen_win_info *execution_info;
+ int horizontal_offset; /* used for horizontal scroll */
+ union tui_line_or_address start_line_or_addr;
char* filename;
};
struct tui_command_info
{
- int curLine; /* The current line position */
+ int cur_line; /* The current line position */
int curch; /* The current cursor position */
int start_line;
};
struct tui_gen_win_info generic; /* general window information */
union
{
- struct tui_source_info sourceInfo;
- struct tui_data_info dataDisplayInfo;
- struct tui_command_info commandInfo;
+ struct tui_source_info source_info;
+ struct tui_data_info data_display_info;
+ struct tui_command_info command_info;
void *opaque;
}
detail;
- int canHighlight; /* Can this window ever be highlighted? */
- int isHighlighted; /* Is this window highlighted? */
+ int can_highlight; /* Can this window ever be highlighted? */
+ int is_highlighted; /* Is this window highlighted? */
};
-/* MACROS (prefixed with m_) */
-
-/* Testing macros */
-#define m_genWinPtrIsNull(winInfo) \
- ((winInfo) == (struct tui_gen_win_info *)NULL)
-#define m_genWinPtrNotNull(winInfo) \
- ((winInfo) != (struct tui_gen_win_info *)NULL)
-#define m_winPtrIsNull(winInfo) \
- ((winInfo) == (struct tui_win_info *)NULL)
-#define m_winPtrNotNull(winInfo) \
- ((winInfo) != (struct tui_win_info *)NULL)
-
-#define m_winIsSourceType(type) \
- (type == SRC_WIN || type == DISASSEM_WIN)
-#define m_winIsAuxillary(winType) \
- (winType > MAX_MAJOR_WINDOWS)
-#define m_hasLocator(winInfo) \
- ( ((winInfo) != (struct tui_win_info *)NULL) ? \
- (winInfo->detail.sourceInfo.hasLocator) : \
- FALSE )
-
-#define m_setWinHighlightOn(winInfo) \
- if ((winInfo) != (struct tui_win_info *)NULL) \
- (winInfo)->isHighlighted = TRUE
-#define m_setWinHighlightOff(winInfo) \
- if ((winInfo) != (struct tui_win_info *)NULL) \
- (winInfo)->isHighlighted = FALSE
+extern int tui_win_is_source_type (enum tui_win_type win_type);
+extern int tui_win_is_auxillary (enum tui_win_type win_type);
+extern int tui_win_has_locator (struct tui_win_info *win_info);
+extern void tui_set_win_highlight (struct tui_win_info *win_info,
+ int highlight);
/* Global Data */
-extern struct tui_win_info *(winList[MAX_MAJOR_WINDOWS]);
+extern struct tui_win_info *(tui_win_list[MAX_MAJOR_WINDOWS]);
-/* Macros */
-#define srcWin winList[SRC_WIN]
-#define disassemWin winList[DISASSEM_WIN]
-#define dataWin winList[DATA_WIN]
-#define cmdWin winList[CMD_WIN]
+#define TUI_SRC_WIN tui_win_list[SRC_WIN]
+#define TUI_DISASM_WIN tui_win_list[DISASSEM_WIN]
+#define TUI_DATA_WIN tui_win_list[DATA_WIN]
+#define TUI_CMD_WIN tui_win_list[CMD_WIN]
/* Data Manipulation Functions */
extern void tui_initialize_static_data (void);
extern struct tui_list * tui_source_windows (void);
extern void tui_clear_source_windows (void);
extern void tui_clear_source_windows_detail (void);
-extern void tui_clear_win_detail (struct tui_win_info * winInfo);
+extern void tui_clear_win_detail (struct tui_win_info * win_info);
extern void tui_add_to_source_windows (struct tui_win_info *);
extern int tui_default_tab_len (void);
extern void tui_set_default_tab_len (int);
extern struct tui_win_info *tui_next_win (struct tui_win_info *);
extern struct tui_win_info *tui_prev_win (struct tui_win_info *);
-extern void tui_add_to_source_windows (struct tui_win_info * winInfo);
+extern void tui_add_to_source_windows (struct tui_win_info * win_info);
#endif /* TUI_DATA_H */
#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"
{
enum tui_status ret = TUI_FAILURE;
register int i;
- register int offset = disassemWin->detail.sourceInfo.horizontalOffset;
+ int offset = TUI_DISASM_WIN->detail.source_info.horizontal_offset;
register int lineWidth, maxLines;
CORE_ADDR cur_pc;
struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
if (pc == 0)
return TUI_FAILURE;
- ret = tui_alloc_source_buffer (disassemWin);
+ ret = tui_alloc_source_buffer (TUI_DISASM_WIN);
if (ret != TUI_SUCCESS)
return ret;
- disassemWin->detail.sourceInfo.startLineOrAddr.addr = pc;
+ TUI_DISASM_WIN->detail.source_info.start_line_or_addr.addr = pc;
cur_pc = (CORE_ADDR)
- (((struct tui_win_element *) locator->content[0])->whichElement.locator.addr);
+ (((struct tui_win_element *) locator->content[0])->which_element.locator.addr);
- maxLines = disassemWin->generic.height - 2; /* account for hilite */
+ maxLines = TUI_DISASM_WIN->generic.height - 2; /* account for hilite */
/* Get temporary table that will hold all strings (addr & insn). */
lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line)
* maxLines);
memset (lines, 0, sizeof (struct tui_asm_line) * maxLines);
- lineWidth = disassemWin->generic.width - 1;
+ lineWidth = TUI_DISASM_WIN->generic.width - 1;
tui_disassemble (lines, pc, maxLines);
struct tui_source_element* src;
int curLen;
- element = (struct tui_win_element *) disassemWin->generic.content[i];
- src = &element->whichElement.source;
+ element = (struct tui_win_element *) TUI_DISASM_WIN->generic.content[i];
+ src = &element->which_element.source;
strcpy (line, lines[i].addr_string);
curLen = strlen (line);
else
src->line[0] = '\0';
- src->lineOrAddr.addr = lines[i].addr;
- src->isExecPoint = lines[i].addr == cur_pc;
+ src->line_or_addr.addr = lines[i].addr;
+ src->is_exec_point = lines[i].addr == cur_pc;
/* See whether there is a breakpoint installed. */
- src->hasBreak = (!src->isExecPoint
+ src->has_break = (!src->is_exec_point
&& breakpoint_here_p (pc) != no_breakpoint_here);
xfree (lines[i].addr_string);
xfree (lines[i].insn);
}
- disassemWin->generic.contentSize = i;
+ TUI_DISASM_WIN->generic.content_size = i;
return TUI_SUCCESS;
}
val.addr = startAddr;
tui_add_win_to_layout (DISASSEM_WIN);
- tui_update_source_window (disassemWin, s, val, FALSE);
+ tui_update_source_window (TUI_DISASM_WIN, s, val, FALSE);
/*
** if the focus was in the src win, put it in the asm win, if the
** source view isn't split
*/
- if (tui_current_layout () != SRC_DISASSEM_COMMAND && winWithFocus == srcWin)
- tui_set_win_focus_to (disassemWin);
+ if (tui_current_layout () != SRC_DISASSEM_COMMAND && winWithFocus == TUI_SRC_WIN)
+ tui_set_win_focus_to (TUI_DISASM_WIN);
return;
}
** note that it follows what is in the disassembly window and visa-versa
*/
sal = find_pc_line (startAddr, 0);
- val.lineNo = sal.line;
- tui_update_source_window (srcWin, sal.symtab, val, TRUE);
+ val.line_no = sal.line;
+ tui_update_source_window (TUI_SRC_WIN, sal.symtab, val, TRUE);
if (sal.symtab)
{
set_current_source_symtab_and_line (&sal);
CORE_ADDR addr;
locator = tui_locator_win_info_ptr ();
- element = &((struct tui_win_element *) locator->content[0])->whichElement.locator;
+ element = &((struct tui_win_element *) locator->content[0])->which_element.locator;
if (element->addr == 0)
{
tui_vertical_disassem_scroll (enum tui_scroll_direction scrollDirection,
int numToScroll)
{
- if (disassemWin->generic.content != NULL)
+ if (TUI_DISASM_WIN->generic.content != NULL)
{
CORE_ADDR pc;
tui_win_content content;
int maxLines, dir;
struct symtab_and_line cursal = get_current_source_symtab_and_line ();
- content = (tui_win_content) disassemWin->generic.content;
+ content = (tui_win_content) TUI_DISASM_WIN->generic.content;
if (cursal.symtab == (struct symtab *) NULL)
s = find_pc_symtab (get_frame_pc (deprecated_selected_frame));
else
s = cursal.symtab;
/* account for hilite */
- maxLines = disassemWin->generic.height - 2;
- pc = content[0]->whichElement.source.lineOrAddr.addr;
+ maxLines = TUI_DISASM_WIN->generic.height - 2;
+ pc = content[0]->which_element.source.line_or_addr.addr;
dir = (scrollDirection == FORWARD_SCROLL) ? maxLines : - maxLines;
val.addr = tui_find_disassembly_address (pc, dir);
- tui_update_source_window_as_is (disassemWin, s, val, FALSE);
+ tui_update_source_window_as_is (TUI_DISASM_WIN, s, val, FALSE);
}
}
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
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);
/* 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;
}
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)
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);
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. */
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);
}
int ch;
WINDOW *w;
- w = cmdWin->generic.handle;
+ w = TUI_CMD_WIN->generic.handle;
#ifdef TUI_USE_PIPE_FOR_READLINE
/* Flush readline output. */
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. */
}
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 (ch == '\n' || ch == '\r' || ch == '\f')
- cmdWin->detail.commandInfo.curch = 0;
+ TUI_CMD_WIN->detail.command_info.curch = 0;
#if 0
else
tuiIncrCommandCharCountBy (1);
if (layout == SRC_DATA_COMMAND || layout == DISASSEM_DATA_COMMAND)
{
_showData (layout);
- tui_refresh_all (winList);
+ tui_refresh_all (tui_win_list);
}
else
{
/* Now show the new layout */
case SRC_COMMAND:
_showSourceCommand ();
- tui_add_to_source_windows (srcWin);
+ tui_add_to_source_windows (TUI_SRC_WIN);
break;
case DISASSEM_COMMAND:
_showDisassemCommand ();
- tui_add_to_source_windows (disassemWin);
+ tui_add_to_source_windows (TUI_DISASM_WIN);
break;
case SRC_DISASSEM_COMMAND:
_showSourceDisassemCommand ();
- tui_add_to_source_windows (srcWin);
- tui_add_to_source_windows (disassemWin);
+ tui_add_to_source_windows (TUI_SRC_WIN);
+ tui_add_to_source_windows (TUI_DISASM_WIN);
break;
default:
break;
SRC_DISASSEM_COMMAND, SRC_DATA_COMMAND, or DISASSEM_DATA_COMMAND.
If the layout is SRC_DATA_COMMAND, DISASSEM_DATA_COMMAND, or
UNDEFINED_LAYOUT, then the data window is populated according to
- regsDisplayType. */
+ regs_display_type. */
enum tui_status
tui_set_layout (enum tui_layout_type layoutType,
- enum tui_register_display_type regsDisplayType)
+ enum tui_register_display_type regs_display_type)
{
enum tui_status status = TUI_SUCCESS;
- if (layoutType != UNDEFINED_LAYOUT || regsDisplayType != TUI_UNDEFINED_REGS)
+ if (layoutType != UNDEFINED_LAYOUT || regs_display_type != TUI_UNDEFINED_REGS)
{
enum tui_layout_type curLayout = tui_current_layout (), newLayout = UNDEFINED_LAYOUT;
int regsPopulate = FALSE;
if (layoutType == UNDEFINED_LAYOUT &&
- regsDisplayType != TUI_UNDEFINED_REGS)
+ regs_display_type != TUI_UNDEFINED_REGS)
{
if (curLayout == SRC_DISASSEM_COMMAND)
newLayout = DISASSEM_DATA_COMMAND;
regsPopulate = (newLayout == SRC_DATA_COMMAND ||
newLayout == DISASSEM_DATA_COMMAND ||
- regsDisplayType != TUI_UNDEFINED_REGS);
- if (newLayout != curLayout || regsDisplayType != TUI_UNDEFINED_REGS)
+ regs_display_type != TUI_UNDEFINED_REGS);
+ if (newLayout != curLayout || regs_display_type != TUI_UNDEFINED_REGS)
{
if (newLayout != curLayout)
{
/*
** Now determine where focus should be
*/
- if (winWithFocus != cmdWin)
+ if (winWithFocus != TUI_CMD_WIN)
{
switch (newLayout)
{
case SRC_COMMAND:
- tui_set_win_focus_to (srcWin);
- layoutDef->displayMode = SRC_WIN;
+ tui_set_win_focus_to (TUI_SRC_WIN);
+ layoutDef->display_mode = SRC_WIN;
layoutDef->split = FALSE;
break;
case DISASSEM_COMMAND:
** We still want to show the assembly though!
*/
addr = tui_get_begin_asm_address ();
- tui_set_win_focus_to (disassemWin);
- layoutDef->displayMode = DISASSEM_WIN;
+ tui_set_win_focus_to (TUI_DISASM_WIN);
+ layoutDef->display_mode = DISASSEM_WIN;
layoutDef->split = FALSE;
break;
case SRC_DISASSEM_COMMAND:
** We still want to show the assembly though!
*/
addr = tui_get_begin_asm_address ();
- if (winWithFocus == srcWin)
- tui_set_win_focus_to (srcWin);
+ if (winWithFocus == TUI_SRC_WIN)
+ tui_set_win_focus_to (TUI_SRC_WIN);
else
- tui_set_win_focus_to (disassemWin);
+ tui_set_win_focus_to (TUI_DISASM_WIN);
layoutDef->split = TRUE;
break;
case SRC_DATA_COMMAND:
- if (winWithFocus != dataWin)
- tui_set_win_focus_to (srcWin);
+ if (winWithFocus != TUI_DATA_WIN)
+ tui_set_win_focus_to (TUI_SRC_WIN);
else
- tui_set_win_focus_to (dataWin);
- layoutDef->displayMode = SRC_WIN;
+ tui_set_win_focus_to (TUI_DATA_WIN);
+ layoutDef->display_mode = SRC_WIN;
layoutDef->split = FALSE;
break;
case DISASSEM_DATA_COMMAND:
** We still want to show the assembly though!
*/
addr = tui_get_begin_asm_address ();
- if (winWithFocus != dataWin)
- tui_set_win_focus_to (disassemWin);
+ if (winWithFocus != TUI_DATA_WIN)
+ tui_set_win_focus_to (TUI_DISASM_WIN);
else
- tui_set_win_focus_to (dataWin);
- layoutDef->displayMode = DISASSEM_WIN;
+ tui_set_win_focus_to (TUI_DATA_WIN);
+ layoutDef->display_mode = DISASSEM_WIN;
layoutDef->split = FALSE;
break;
default:
}
if (regsPopulate)
{
- layoutDef->regsDisplayType =
- (regsDisplayType == TUI_UNDEFINED_REGS ?
- TUI_GENERAL_REGS : regsDisplayType);
- tui_show_registers (layoutDef->regsDisplayType);
+ layoutDef->regs_display_type =
+ (regs_display_type == TUI_UNDEFINED_REGS ?
+ TUI_GENERAL_REGS : regs_display_type);
+ tui_show_registers (layoutDef->regs_display_type);
}
}
}
{
int h;
- if (winList[type] != (struct tui_win_info *) NULL)
- h = winList[type]->generic.height;
+ if (tui_win_list[type] != (struct tui_win_info *) NULL)
+ h = tui_win_list[type]->generic.height;
else
{
switch (layout)
{
case SRC_COMMAND:
case DISASSEM_COMMAND:
- if (m_winPtrIsNull (cmdWin))
+ if (TUI_CMD_WIN == NULL)
h = tui_term_height () / 2;
else
- h = tui_term_height () - cmdWin->generic.height;
+ h = tui_term_height () - TUI_CMD_WIN->generic.height;
break;
case SRC_DISASSEM_COMMAND:
case SRC_DATA_COMMAND:
case DISASSEM_DATA_COMMAND:
- if (m_winPtrIsNull (cmdWin))
+ if (TUI_CMD_WIN == NULL)
h = tui_term_height () / 3;
else
- h = (tui_term_height () - cmdWin->generic.height) / 2;
+ h = (tui_term_height () - TUI_CMD_WIN->generic.height) / 2;
break;
default:
h = 0;
h = tuiDefaultWinHeight (type, layout);
- if (winList[type] == cmdWin)
+ if (tui_win_list[type] == TUI_CMD_WIN)
h -= 1;
else
h -= 2;
*/
if (subset_compare (bufPtr, TUI_FLOAT_REGS_NAME))
{
- if (dataWin->detail.dataDisplayInfo.regsDisplayType !=
+ if (TUI_DATA_WIN->detail.data_display_info.regs_display_type !=
TUI_SFLOAT_REGS &&
- dataWin->detail.dataDisplayInfo.regsDisplayType !=
+ TUI_DATA_WIN->detail.data_display_info.regs_display_type !=
TUI_DFLOAT_REGS)
dpyType = TUI_SFLOAT_REGS;
else
dpyType =
- dataWin->detail.dataDisplayInfo.regsDisplayType;
+ TUI_DATA_WIN->detail.data_display_info.regs_display_type;
}
else if (subset_compare (bufPtr,
TUI_GENERAL_SPECIAL_REGS_NAME))
dpyType = TUI_GENERAL_REGS;
else if (subset_compare (bufPtr, TUI_SPECIAL_REGS_NAME))
dpyType = TUI_SPECIAL_REGS;
- else if (dataWin)
+ else if (TUI_DATA_WIN)
{
- if (dataWin->detail.dataDisplayInfo.regsDisplayType !=
+ if (TUI_DATA_WIN->detail.data_display_info.regs_display_type !=
TUI_UNDEFINED_REGS)
dpyType =
- dataWin->detail.dataDisplayInfo.regsDisplayType;
+ TUI_DATA_WIN->detail.data_display_info.regs_display_type;
else
dpyType = TUI_GENERAL_REGS;
}
case SRC_COMMAND:
case SRC_DATA_COMMAND:
find_line_pc (cursal.symtab,
- srcWin->detail.sourceInfo.startLineOrAddr.lineNo,
+ TUI_SRC_WIN->detail.source_info.start_line_or_addr.line_no,
&pc);
addr = pc;
break;
case DISASSEM_COMMAND:
case SRC_DISASSEM_COMMAND:
case DISASSEM_DATA_COMMAND:
- addr = disassemWin->detail.sourceInfo.startLineOrAddr.addr;
+ addr = TUI_DISASM_WIN->detail.source_info.start_line_or_addr.addr;
break;
default:
addr = 0;
if (layoutDef->split)
{
tui_set_layout (SRC_DISASSEM_COMMAND, TUI_UNDEFINED_REGS);
- tui_set_win_focus_to (winList[layoutDef->displayMode]);
+ tui_set_win_focus_to (tui_win_list[layoutDef->display_mode]);
}
else
{
- if (layoutDef->displayMode == SRC_WIN)
+ if (layoutDef->display_mode == SRC_WIN)
tui_set_layout (SRC_COMMAND, TUI_UNDEFINED_REGS);
else
- tui_set_layout (DISASSEM_DATA_COMMAND, layoutDef->regsDisplayType);
+ tui_set_layout (DISASSEM_DATA_COMMAND, layoutDef->regs_display_type);
}
/* Make sure the curses mode is enabled. */
tui_enable ();
- if (layoutDef->displayMode == SRC_WIN)
- layoutDef->displayMode = DISASSEM_WIN;
+ if (layoutDef->display_mode == SRC_WIN)
+ layoutDef->display_mode = DISASSEM_WIN;
else
- layoutDef->displayMode = SRC_WIN;
+ layoutDef->display_mode = SRC_WIN;
if (!layoutDef->split)
_tuiHandleXDBLayout (layoutDef);
originY,
DONT_BOX_WINDOW);
- (*winInfoPtr)->canHighlight = FALSE;
+ (*winInfoPtr)->can_highlight = FALSE;
return;
} /* _makeCommandWindow */
{
int cmdHeight, srcHeight, asmHeight;
- if (m_winPtrNotNull (cmdWin))
- cmdHeight = cmdWin->generic.height;
+ if (TUI_CMD_WIN != NULL)
+ cmdHeight = TUI_CMD_WIN->generic.height;
else
cmdHeight = tui_term_height () / 3;
srcHeight = (tui_term_height () - cmdHeight) / 2;
asmHeight = tui_term_height () - (srcHeight + cmdHeight);
- if (m_winPtrIsNull (srcWin))
- _makeSourceWindow (&srcWin, srcHeight, 0);
+ if (TUI_SRC_WIN == NULL)
+ _makeSourceWindow (&TUI_SRC_WIN, srcHeight, 0);
else
{
- _initGenWinInfo (&srcWin->generic,
- srcWin->generic.type,
+ _initGenWinInfo (&TUI_SRC_WIN->generic,
+ TUI_SRC_WIN->generic.type,
srcHeight,
- srcWin->generic.width,
- srcWin->detail.sourceInfo.executionInfo->width,
+ TUI_SRC_WIN->generic.width,
+ TUI_SRC_WIN->detail.source_info.execution_info->width,
0);
- srcWin->canHighlight = TRUE;
- _initGenWinInfo (srcWin->detail.sourceInfo.executionInfo,
+ TUI_SRC_WIN->can_highlight = TRUE;
+ _initGenWinInfo (TUI_SRC_WIN->detail.source_info.execution_info,
EXEC_INFO_WIN,
srcHeight,
3,
0,
0);
- tui_make_visible (&srcWin->generic);
- tui_make_visible (srcWin->detail.sourceInfo.executionInfo);
- srcWin->detail.sourceInfo.hasLocator = FALSE;;
+ tui_make_visible (&TUI_SRC_WIN->generic);
+ tui_make_visible (TUI_SRC_WIN->detail.source_info.execution_info);
+ TUI_SRC_WIN->detail.source_info.has_locator = FALSE;;
}
- if (m_winPtrNotNull (srcWin))
+ if (TUI_SRC_WIN != NULL)
{
struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
- tui_show_source_content (srcWin);
- if (m_winPtrIsNull (disassemWin))
+ tui_show_source_content (TUI_SRC_WIN);
+ if (TUI_DISASM_WIN == NULL)
{
- _makeDisassemWindow (&disassemWin, asmHeight, srcHeight - 1);
+ _makeDisassemWindow (&TUI_DISASM_WIN, asmHeight, srcHeight - 1);
_initAndMakeWin ((void **) & locator,
LOCATOR_WIN,
2 /* 1 */ ,
tui_term_width (),
0,
(srcHeight + asmHeight) - 1);
- disassemWin->detail.sourceInfo.hasLocator = TRUE;
+ TUI_DISASM_WIN->detail.source_info.has_locator = TRUE;
_initGenWinInfo (
- &disassemWin->generic,
- disassemWin->generic.type,
+ &TUI_DISASM_WIN->generic,
+ TUI_DISASM_WIN->generic.type,
asmHeight,
- disassemWin->generic.width,
- disassemWin->detail.sourceInfo.executionInfo->width,
+ TUI_DISASM_WIN->generic.width,
+ TUI_DISASM_WIN->detail.source_info.execution_info->width,
srcHeight - 1);
- _initGenWinInfo (disassemWin->detail.sourceInfo.executionInfo,
+ _initGenWinInfo (TUI_DISASM_WIN->detail.source_info.execution_info,
EXEC_INFO_WIN,
asmHeight,
3,
0,
srcHeight - 1);
- disassemWin->canHighlight = TRUE;
- tui_make_visible (&disassemWin->generic);
- tui_make_visible (disassemWin->detail.sourceInfo.executionInfo);
+ TUI_DISASM_WIN->can_highlight = TRUE;
+ tui_make_visible (&TUI_DISASM_WIN->generic);
+ tui_make_visible (TUI_DISASM_WIN->detail.source_info.execution_info);
}
- if (m_winPtrNotNull (disassemWin))
+ if (TUI_DISASM_WIN != NULL)
{
- srcWin->detail.sourceInfo.hasLocator = FALSE;
- disassemWin->detail.sourceInfo.hasLocator = TRUE;
+ TUI_SRC_WIN->detail.source_info.has_locator = FALSE;
+ TUI_DISASM_WIN->detail.source_info.has_locator = TRUE;
tui_make_visible (locator);
tui_show_locator_content ();
- tui_show_source_content (disassemWin);
+ tui_show_source_content (TUI_DISASM_WIN);
- if (m_winPtrIsNull (cmdWin))
- _makeCommandWindow (&cmdWin,
+ if (TUI_CMD_WIN == NULL)
+ _makeCommandWindow (&TUI_CMD_WIN,
cmdHeight,
tui_term_height () - cmdHeight);
else
{
- _initGenWinInfo (&cmdWin->generic,
- cmdWin->generic.type,
- cmdWin->generic.height,
- cmdWin->generic.width,
+ _initGenWinInfo (&TUI_CMD_WIN->generic,
+ TUI_CMD_WIN->generic.type,
+ TUI_CMD_WIN->generic.height,
+ TUI_CMD_WIN->generic.width,
0,
- cmdWin->generic.origin.y);
- cmdWin->canHighlight = FALSE;
- tui_make_visible (&cmdWin->generic);
+ TUI_CMD_WIN->generic.origin.y);
+ TUI_CMD_WIN->can_highlight = FALSE;
+ tui_make_visible (&TUI_CMD_WIN->generic);
}
- if (m_winPtrNotNull (cmdWin))
- tui_refresh_win (&cmdWin->generic);
+ if (TUI_CMD_WIN != NULL)
+ tui_refresh_win (&TUI_CMD_WIN->generic);
}
}
tui_set_current_layout_to (SRC_DISASSEM_COMMAND);
static void
_showData (enum tui_layout_type newLayout)
{
- int totalHeight = (tui_term_height () - cmdWin->generic.height);
+ int totalHeight = (tui_term_height () - TUI_CMD_WIN->generic.height);
int srcHeight, dataHeight;
enum tui_win_type winType;
struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
srcHeight = totalHeight - dataHeight;
tui_make_all_invisible ();
tui_make_invisible (locator);
- _makeDataWindow (&dataWin, dataHeight, 0);
- dataWin->canHighlight = TRUE;
+ _makeDataWindow (&TUI_DATA_WIN, dataHeight, 0);
+ TUI_DATA_WIN->can_highlight = TRUE;
if (newLayout == SRC_DATA_COMMAND)
winType = SRC_WIN;
else
winType = DISASSEM_WIN;
- if (m_winPtrIsNull (winList[winType]))
+ if (tui_win_list[winType] == NULL)
{
if (winType == SRC_WIN)
- _makeSourceWindow (&winList[winType], srcHeight, dataHeight - 1);
+ _makeSourceWindow (&tui_win_list[winType], srcHeight, dataHeight - 1);
else
- _makeDisassemWindow (&winList[winType], srcHeight, dataHeight - 1);
+ _makeDisassemWindow (&tui_win_list[winType], srcHeight, dataHeight - 1);
_initAndMakeWin ((void **) & locator,
LOCATOR_WIN,
2 /* 1 */ ,
}
else
{
- _initGenWinInfo (&winList[winType]->generic,
- winList[winType]->generic.type,
+ _initGenWinInfo (&tui_win_list[winType]->generic,
+ tui_win_list[winType]->generic.type,
srcHeight,
- winList[winType]->generic.width,
- winList[winType]->detail.sourceInfo.executionInfo->width,
+ tui_win_list[winType]->generic.width,
+ tui_win_list[winType]->detail.source_info.execution_info->width,
dataHeight - 1);
- _initGenWinInfo (winList[winType]->detail.sourceInfo.executionInfo,
+ _initGenWinInfo (tui_win_list[winType]->detail.source_info.execution_info,
EXEC_INFO_WIN,
srcHeight,
3,
0,
dataHeight - 1);
- tui_make_visible (&winList[winType]->generic);
- tui_make_visible (winList[winType]->detail.sourceInfo.executionInfo);
+ tui_make_visible (&tui_win_list[winType]->generic);
+ tui_make_visible (tui_win_list[winType]->detail.source_info.execution_info);
_initGenWinInfo (locator,
LOCATOR_WIN,
2 /* 1 */ ,
0,
totalHeight - 1);
}
- winList[winType]->detail.sourceInfo.hasLocator = TRUE;
+ tui_win_list[winType]->detail.source_info.has_locator = TRUE;
tui_make_visible (locator);
tui_show_locator_content ();
- tui_add_to_source_windows (winList[winType]);
+ tui_add_to_source_windows (tui_win_list[winType]);
tui_set_current_layout_to (newLayout);
return;
winInfo->height = h;
if (h > 1)
{
- winInfo->viewportHeight = h - 1;
+ winInfo->viewport_height = h - 1;
if (winInfo->type != CMD_WIN)
- winInfo->viewportHeight--;
+ winInfo->viewport_height--;
}
else
- winInfo->viewportHeight = 1;
+ winInfo->viewport_height = 1;
winInfo->origin.x = originX;
winInfo->origin.y = originY;
if (opaqueWinInfo == NULL)
{
- if (m_winIsAuxillary (winType))
+ if (tui_win_is_auxillary (winType))
opaqueWinInfo = (void *) tui_alloc_generic_win_info ();
else
opaqueWinInfo = (void *) tui_alloc_win_info (winType);
}
- if (m_winIsAuxillary (winType))
+ if (tui_win_is_auxillary (winType))
generic = (struct tui_gen_win_info *) opaqueWinInfo;
else
generic = &((struct tui_win_info *) opaqueWinInfo)->generic;
if (opaqueWinInfo != NULL)
{
_initGenWinInfo (generic, winType, height, width, originX, originY);
- if (!m_winIsAuxillary (winType))
+ if (!tui_win_is_auxillary (winType))
{
if (generic->type == CMD_WIN)
- ((struct tui_win_info *) opaqueWinInfo)->canHighlight = FALSE;
+ ((struct tui_win_info *) opaqueWinInfo)->can_highlight = FALSE;
else
- ((struct tui_win_info *) opaqueWinInfo)->canHighlight = TRUE;
+ ((struct tui_win_info *) opaqueWinInfo)->can_highlight = TRUE;
}
tui_make_window (generic, boxIt);
}
_makeSourceOrDisassemWindow (struct tui_win_info * * winInfoPtr, enum tui_win_type type,
int height, int originY)
{
- struct tui_gen_win_info * executionInfo = (struct tui_gen_win_info *) NULL;
+ struct tui_gen_win_info * execution_info = (struct tui_gen_win_info *) NULL;
/*
** Create the exeuction info window.
*/
if (type == SRC_WIN)
- executionInfo = tui_source_exec_info_win_ptr ();
+ execution_info = tui_source_exec_info_win_ptr ();
else
- executionInfo = tui_disassem_exec_info_win_ptr ();
- _initAndMakeWin ((void **) & executionInfo,
+ execution_info = tui_disassem_exec_info_win_ptr ();
+ _initAndMakeWin ((void **) & execution_info,
EXEC_INFO_WIN,
height,
3,
_initAndMakeWin ((void **) winInfoPtr,
type,
height,
- tui_term_width () - executionInfo->width,
- executionInfo->width,
+ tui_term_width () - execution_info->width,
+ execution_info->width,
originY,
BOX_WINDOW);
- (*winInfoPtr)->detail.sourceInfo.executionInfo = executionInfo;
+ (*winInfoPtr)->detail.source_info.execution_info = execution_info;
return;
} /* _makeSourceOrDisassemWindow */
int srcHeight, cmdHeight;
struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
- if (m_winPtrNotNull (cmdWin))
- cmdHeight = cmdWin->generic.height;
+ if (TUI_CMD_WIN != NULL)
+ cmdHeight = TUI_CMD_WIN->generic.height;
else
cmdHeight = tui_term_height () / 3;
srcHeight = tui_term_height () - cmdHeight;
if (layoutType == SRC_COMMAND)
- winInfoPtr = &srcWin;
+ winInfoPtr = &TUI_SRC_WIN;
else
- winInfoPtr = &disassemWin;
+ winInfoPtr = &TUI_DISASM_WIN;
- if (m_winPtrIsNull (*winInfoPtr))
+ if ((*winInfoPtr) == NULL)
{
if (layoutType == SRC_COMMAND)
_makeSourceWindow (winInfoPtr, srcHeight - 1, 0);
tui_term_width (),
0,
srcHeight - 1);
- (*winInfoPtr)->detail.sourceInfo.hasLocator = TRUE;
+ (*winInfoPtr)->detail.source_info.has_locator = TRUE;
_initGenWinInfo (
&(*winInfoPtr)->generic,
(*winInfoPtr)->generic.type,
srcHeight - 1,
(*winInfoPtr)->generic.width,
- (*winInfoPtr)->detail.sourceInfo.executionInfo->width,
+ (*winInfoPtr)->detail.source_info.execution_info->width,
0);
- _initGenWinInfo ((*winInfoPtr)->detail.sourceInfo.executionInfo,
+ _initGenWinInfo ((*winInfoPtr)->detail.source_info.execution_info,
EXEC_INFO_WIN,
srcHeight - 1,
3,
0,
0);
- (*winInfoPtr)->canHighlight = TRUE;
+ (*winInfoPtr)->can_highlight = TRUE;
tui_make_visible (&(*winInfoPtr)->generic);
- tui_make_visible ((*winInfoPtr)->detail.sourceInfo.executionInfo);
+ tui_make_visible ((*winInfoPtr)->detail.source_info.execution_info);
}
- if (m_winPtrNotNull (*winInfoPtr))
+ if ((*winInfoPtr) != NULL)
{
- (*winInfoPtr)->detail.sourceInfo.hasLocator = TRUE;
+ (*winInfoPtr)->detail.source_info.has_locator = TRUE;
tui_make_visible (locator);
tui_show_locator_content ();
tui_show_source_content (*winInfoPtr);
- if (m_winPtrIsNull (cmdWin))
+ if (TUI_CMD_WIN == NULL)
{
- _makeCommandWindow (&cmdWin, cmdHeight, srcHeight);
- tui_refresh_win (&cmdWin->generic);
+ _makeCommandWindow (&TUI_CMD_WIN, cmdHeight, srcHeight);
+ tui_refresh_win (&TUI_CMD_WIN->generic);
}
else
{
- _initGenWinInfo (&cmdWin->generic,
- cmdWin->generic.type,
- cmdWin->generic.height,
- cmdWin->generic.width,
- cmdWin->generic.origin.x,
- cmdWin->generic.origin.y);
- cmdWin->canHighlight = FALSE;
- tui_make_visible (&cmdWin->generic);
+ _initGenWinInfo (&TUI_CMD_WIN->generic,
+ TUI_CMD_WIN->generic.type,
+ TUI_CMD_WIN->generic.height,
+ TUI_CMD_WIN->generic.width,
+ TUI_CMD_WIN->generic.origin.x,
+ TUI_CMD_WIN->generic.origin.y);
+ TUI_CMD_WIN->can_highlight = FALSE;
+ tui_make_visible (&TUI_CMD_WIN->generic);
}
}
tui_set_current_layout_to (layoutType);
#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"
{
register int numLines = (-1);
- if (dataWin->detail.dataDisplayInfo.regsContentCount > 0)
+ if (TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
{
- numLines = (dataWin->detail.dataDisplayInfo.regsContentCount /
- dataWin->detail.dataDisplayInfo.regsColumnCount);
- if (dataWin->detail.dataDisplayInfo.regsContentCount %
- dataWin->detail.dataDisplayInfo.regsColumnCount)
+ numLines = (TUI_DATA_WIN->detail.data_display_info.regs_content_count /
+ TUI_DATA_WIN->detail.data_display_info.regs_column_count);
+ if (TUI_DATA_WIN->detail.data_display_info.regs_content_count %
+ TUI_DATA_WIN->detail.data_display_info.regs_column_count)
numLines++;
}
return numLines;
int
tui_line_from_reg_element_no (int elementNo)
{
- if (elementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
+ if (elementNo < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
{
int i, line = (-1);
while (line == (-1))
{
if (elementNo <
- (dataWin->detail.dataDisplayInfo.regsColumnCount * i))
+ (TUI_DATA_WIN->detail.data_display_info.regs_column_count * i))
line = i - 1;
else
i++;
int
tui_first_reg_element_no_inline (int lineNo)
{
- if ((lineNo * dataWin->detail.dataDisplayInfo.regsColumnCount)
- <= dataWin->detail.dataDisplayInfo.regsContentCount)
+ if ((lineNo * TUI_DATA_WIN->detail.data_display_info.regs_column_count)
+ <= TUI_DATA_WIN->detail.data_display_info.regs_content_count)
return ((lineNo + 1) *
- dataWin->detail.dataDisplayInfo.regsColumnCount) -
- dataWin->detail.dataDisplayInfo.regsColumnCount;
+ TUI_DATA_WIN->detail.data_display_info.regs_column_count) -
+ TUI_DATA_WIN->detail.data_display_info.regs_column_count;
else
return (-1);
}
int
tuiLastRegElementNoInLine (int lineNo)
{
- if ((lineNo * dataWin->detail.dataDisplayInfo.regsColumnCount) <=
- dataWin->detail.dataDisplayInfo.regsContentCount)
+ if ((lineNo * TUI_DATA_WIN->detail.data_display_info.regs_column_count) <=
+ TUI_DATA_WIN->detail.data_display_info.regs_content_count)
return ((lineNo + 1) *
- dataWin->detail.dataDisplayInfo.regsColumnCount) - 1;
+ TUI_DATA_WIN->detail.data_display_info.regs_column_count) - 1;
else
return (-1);
} /* tuiLastRegElementNoInLine */
else
colWidth = SINGLE_VALUE_WIDTH + SINGLE_LABEL_WIDTH;
}
- colCount = (dataWin->generic.width - 2) / colWidth;
+ colCount = (TUI_DATA_WIN->generic.width - 2) / colWidth;
return colCount;
-} /* tuiCalulateRegsColumnCount */
+} /* tuiCalulateRegs_column_count */
/* Show the registers int the data window as indicated by dpyType. If
int refreshValuesOnly = FALSE;
/* Say that registers should be displayed, even if there is a problem */
- dataWin->detail.dataDisplayInfo.displayRegs = TRUE;
+ TUI_DATA_WIN->detail.data_display_info.display_regs = TRUE;
if (target_has_registers)
{
refreshValuesOnly =
- (dpyType == dataWin->detail.dataDisplayInfo.regsDisplayType);
+ (dpyType == TUI_DATA_WIN->detail.data_display_info.regs_display_type);
switch (dpyType)
{
case TUI_GENERAL_REGS:
}
if (ret == TUI_FAILURE)
{
- dataWin->detail.dataDisplayInfo.regsDisplayType = TUI_UNDEFINED_REGS;
+ TUI_DATA_WIN->detail.data_display_info.regs_display_type = TUI_UNDEFINED_REGS;
tui_erase_data_content (NO_REGS_STRING);
}
else
int i;
/* Clear all notation of changed values */
- for (i = 0; (i < dataWin->detail.dataDisplayInfo.regsContentCount); i++)
+ for (i = 0; (i < TUI_DATA_WIN->detail.data_display_info.regs_content_count); i++)
{
struct tui_gen_win_info * dataItemWin;
- dataItemWin = &dataWin->detail.dataDisplayInfo.
- regsContent[i]->whichElement.dataWindow;
+ dataItemWin = &TUI_DATA_WIN->detail.data_display_info.
+ regs_content[i]->which_element.data_window;
(&((struct tui_win_element *)
- dataItemWin->content[0])->whichElement.data)->highlight = FALSE;
+ dataItemWin->content[0])->which_element.data)->highlight = FALSE;
}
- dataWin->detail.dataDisplayInfo.regsDisplayType = dpyType;
+ TUI_DATA_WIN->detail.data_display_info.regs_display_type = dpyType;
tui_display_all_data ();
}
- (tui_layout_def ())->regsDisplayType = dpyType;
+ (tui_layout_def ())->regs_display_type = dpyType;
return;
}
void
tui_display_registers_from (int startElementNo)
{
- if (dataWin->detail.dataDisplayInfo.regsContent != (tui_win_content) NULL &&
- dataWin->detail.dataDisplayInfo.regsContentCount > 0)
+ if (TUI_DATA_WIN->detail.data_display_info.regs_content != (tui_win_content) NULL &&
+ TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
{
register int i = startElementNo;
int j, valueCharsWide, itemWinWidth, curY, labelWidth;
enum precision_type precision;
- precision = (dataWin->detail.dataDisplayInfo.regsDisplayType
+ precision = (TUI_DATA_WIN->detail.data_display_info.regs_display_type
== TUI_DFLOAT_REGS) ?
double_precision : unspecified_precision;
if (IS_64BIT ||
- dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_DFLOAT_REGS)
+ TUI_DATA_WIN->detail.data_display_info.regs_display_type == TUI_DFLOAT_REGS)
{
valueCharsWide = DOUBLE_FLOAT_VALUE_WIDTH;
labelWidth = DOUBLE_FLOAT_LABEL_WIDTH;
}
else
{
- if (dataWin->detail.dataDisplayInfo.regsDisplayType ==
+ if (TUI_DATA_WIN->detail.data_display_info.regs_display_type ==
TUI_SFLOAT_REGS)
{
valueCharsWide = SINGLE_FLOAT_VALUE_WIDTH;
** Now create each data "sub" window, and write the display into it.
*/
curY = 1;
- while (i < dataWin->detail.dataDisplayInfo.regsContentCount &&
- curY <= dataWin->generic.viewportHeight)
+ while (i < TUI_DATA_WIN->detail.data_display_info.regs_content_count &&
+ curY <= TUI_DATA_WIN->generic.viewport_height)
{
for (j = 0;
- (j < dataWin->detail.dataDisplayInfo.regsColumnCount &&
- i < dataWin->detail.dataDisplayInfo.regsContentCount); j++)
+ (j < TUI_DATA_WIN->detail.data_display_info.regs_column_count &&
+ i < TUI_DATA_WIN->detail.data_display_info.regs_content_count); j++)
{
struct tui_gen_win_info * dataItemWin;
struct tui_data_element * dataElementPtr;
/* create the window if necessary */
- dataItemWin = &dataWin->detail.dataDisplayInfo.
- regsContent[i]->whichElement.dataWindow;
+ dataItemWin = &TUI_DATA_WIN->detail.data_display_info.
+ regs_content[i]->which_element.data_window;
dataElementPtr = &((struct tui_win_element *)
- dataItemWin->content[0])->whichElement.data;
+ dataItemWin->content[0])->which_element.data;
if (dataItemWin->handle == (WINDOW *) NULL)
{
dataItemWin->height = 1;
** and display it
*/
_tuiDisplayRegister (
- dataElementPtr->itemNo, dataItemWin, precision);
+ dataElementPtr->item_no, dataItemWin, precision);
i++; /* next register */
}
curY++; /* next row; */
void
tuiDisplayRegElementAtLine (int startElementNo, int startLineNo)
{
- if (dataWin->detail.dataDisplayInfo.regsContent != (tui_win_content) NULL &&
- dataWin->detail.dataDisplayInfo.regsContentCount > 0)
+ if (TUI_DATA_WIN->detail.data_display_info.regs_content != (tui_win_content) NULL &&
+ TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
{
register int elementNo = startElementNo;
register int lastLineNo, firstLineOnLastPage;
lastLineNo = tui_last_regs_line_no ();
- firstLineOnLastPage = lastLineNo - (dataWin->generic.height - 2);
+ firstLineOnLastPage = lastLineNo - (TUI_DATA_WIN->generic.height - 2);
if (firstLineOnLastPage < 0)
firstLineOnLastPage = 0;
/*
** and the elementNo causes us to scroll past the end of the
** registers, adjust what element to really start the display at.
*/
- if (dataWin->detail.dataDisplayInfo.dataContentCount <= 0 &&
+ if (TUI_DATA_WIN->detail.data_display_info.data_content_count <= 0 &&
startLineNo > firstLineOnLastPage)
elementNo = tui_first_reg_element_no_inline (firstLineOnLastPage);
}
int
tui_display_registers_from_line (int lineNo, int forceDisplay)
{
- if (dataWin->detail.dataDisplayInfo.regsContentCount > 0)
+ if (TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
{
int line, elementNo;
if (lineNo >= tui_last_regs_line_no ())
{
if ((line = tui_line_from_reg_element_no (
- dataWin->detail.dataDisplayInfo.regsContentCount - 1)) < 0)
+ TUI_DATA_WIN->detail.data_display_info.regs_content_count - 1)) < 0)
line = 0;
}
else
line = lineNo;
elementNo = tui_first_reg_element_no_inline (line);
- if (elementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
+ if (elementNo < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
tuiDisplayRegElementAtLine (elementNo, line);
else
line = (-1);
void
tui_check_register_values (struct frame_info *frame)
{
- if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
+ if (TUI_DATA_WIN != NULL && TUI_DATA_WIN->generic.is_visible)
{
- if (dataWin->detail.dataDisplayInfo.regsContentCount <= 0 &&
- dataWin->detail.dataDisplayInfo.displayRegs)
- tui_show_registers ((tui_layout_def ())->regsDisplayType);
+ if (TUI_DATA_WIN->detail.data_display_info.regs_content_count <= 0 &&
+ TUI_DATA_WIN->detail.data_display_info.display_regs)
+ tui_show_registers ((tui_layout_def ())->regs_display_type);
else
{
int i, j;
char rawBuf[MAX_REGISTER_SIZE];
for (i = 0;
- (i < dataWin->detail.dataDisplayInfo.regsContentCount); i++)
+ (i < TUI_DATA_WIN->detail.data_display_info.regs_content_count); i++)
{
struct tui_data_element * dataElementPtr;
struct tui_gen_win_info * dataItemWinPtr;
int wasHilighted;
- dataItemWinPtr = &dataWin->detail.dataDisplayInfo.
- regsContent[i]->whichElement.dataWindow;
+ dataItemWinPtr = &TUI_DATA_WIN->detail.data_display_info.
+ regs_content[i]->which_element.data_window;
dataElementPtr = &((struct tui_win_element *)
- dataItemWinPtr->content[0])->whichElement.data;
+ dataItemWinPtr->content[0])->which_element.data;
wasHilighted = dataElementPtr->highlight;
dataElementPtr->highlight =
_tuiRegValueHasChanged (dataElementPtr, frame, &rawBuf[0]);
{
int size;
- size = DEPRECATED_REGISTER_RAW_SIZE (dataElementPtr->itemNo);
+ size = DEPRECATED_REGISTER_RAW_SIZE (dataElementPtr->item_no);
for (j = 0; j < size; j++)
((char *) dataElementPtr->value)[j] = rawBuf[j];
_tuiDisplayRegister (
- dataElementPtr->itemNo,
+ dataElementPtr->item_no,
dataItemWinPtr,
- ((dataWin->detail.dataDisplayInfo.regsDisplayType ==
+ ((TUI_DATA_WIN->detail.data_display_info.regs_display_type ==
TUI_DFLOAT_REGS) ?
double_precision : unspecified_precision));
}
{
dataElementPtr->highlight = FALSE;
_tuiDisplayRegister (
- dataElementPtr->itemNo,
+ dataElementPtr->item_no,
dataItemWinPtr,
- ((dataWin->detail.dataDisplayInfo.regsDisplayType ==
+ ((TUI_DATA_WIN->detail.data_display_info.regs_display_type ==
TUI_DFLOAT_REGS) ?
double_precision : unspecified_precision));
}
{
struct tui_layout_def * layoutDef = tui_layout_def ();
- if (layoutDef->floatRegsDisplayType == TUI_SFLOAT_REGS)
- layoutDef->floatRegsDisplayType = TUI_DFLOAT_REGS;
+ if (layoutDef->float_regs_display_type == TUI_SFLOAT_REGS)
+ layoutDef->float_regs_display_type = TUI_DFLOAT_REGS;
else
- layoutDef->floatRegsDisplayType = TUI_SFLOAT_REGS;
+ layoutDef->float_regs_display_type = TUI_SFLOAT_REGS;
- if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible &&
- (dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_SFLOAT_REGS ||
- dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_DFLOAT_REGS))
- tui_show_registers (layoutDef->floatRegsDisplayType);
+ if (TUI_DATA_WIN != NULL && TUI_DATA_WIN->generic.is_visible &&
+ (TUI_DATA_WIN->detail.data_display_info.regs_display_type == TUI_SFLOAT_REGS ||
+ TUI_DATA_WIN->detail.data_display_info.regs_display_type == TUI_DFLOAT_REGS))
+ tui_show_registers (layoutDef->float_regs_display_type);
return;
} /* tuiToggleFloatRegs */
{
int hasChanged = FALSE;
- if (dataElement->itemNo != UNDEFINED_ITEM &&
- _tuiRegisterName (dataElement->itemNo) != (char *) NULL)
+ if (dataElement->item_no != UNDEFINED_ITEM &&
+ _tuiRegisterName (dataElement->item_no) != (char *) NULL)
{
char rawBuf[MAX_REGISTER_SIZE];
int i;
if (_tuiGetRegisterRawValue (
- dataElement->itemNo, rawBuf, frame) == TUI_SUCCESS)
+ dataElement->item_no, rawBuf, frame) == TUI_SUCCESS)
{
- int size = DEPRECATED_REGISTER_RAW_SIZE (dataElement->itemNo);
+ int size = DEPRECATED_REGISTER_RAW_SIZE (dataElement->item_no);
for (i = 0; (i < size && !hasChanged); i++)
hasChanged = (((char *) dataElement->value)[i] != rawBuf[i]);
{
if (!refreshValueOnly)
{
- dataElement->itemNo = regNum;
+ dataElement->item_no = regNum;
dataElement->name = _tuiRegisterName (regNum);
dataElement->highlight = FALSE;
}
int numRegs = endRegNum - startRegNum + 1;
int allocatedHere = FALSE;
- if (dataWin->detail.dataDisplayInfo.regsContentCount > 0 &&
+ if (TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0 &&
!refreshValuesOnly)
{
- tui_free_data_content (dataWin->detail.dataDisplayInfo.regsContent,
- dataWin->detail.dataDisplayInfo.regsContentCount);
- dataWin->detail.dataDisplayInfo.regsContentCount = 0;
+ tui_free_data_content (TUI_DATA_WIN->detail.data_display_info.regs_content,
+ TUI_DATA_WIN->detail.data_display_info.regs_content_count);
+ TUI_DATA_WIN->detail.data_display_info.regs_content_count = 0;
}
- if (dataWin->detail.dataDisplayInfo.regsContentCount <= 0)
+ if (TUI_DATA_WIN->detail.data_display_info.regs_content_count <= 0)
{
- dataWin->detail.dataDisplayInfo.regsContent =
+ TUI_DATA_WIN->detail.data_display_info.regs_content =
tui_alloc_content (numRegs, DATA_WIN);
allocatedHere = TRUE;
}
- if (dataWin->detail.dataDisplayInfo.regsContent != (tui_win_content) NULL)
+ if (TUI_DATA_WIN->detail.data_display_info.regs_content != (tui_win_content) NULL)
{
int i;
if (!refreshValuesOnly || allocatedHere)
{
- dataWin->generic.content = NULL;
- dataWin->generic.contentSize = 0;
- tui_add_content_elements (&dataWin->generic, numRegs);
- dataWin->detail.dataDisplayInfo.regsContent =
- (tui_win_content) dataWin->generic.content;
- dataWin->detail.dataDisplayInfo.regsContentCount = numRegs;
+ TUI_DATA_WIN->generic.content = NULL;
+ TUI_DATA_WIN->generic.content_size = 0;
+ tui_add_content_elements (&TUI_DATA_WIN->generic, numRegs);
+ TUI_DATA_WIN->detail.data_display_info.regs_content =
+ (tui_win_content) TUI_DATA_WIN->generic.content;
+ TUI_DATA_WIN->detail.data_display_info.regs_content_count = numRegs;
}
/*
** Now set the register names and values
{
struct tui_gen_win_info * dataItemWin;
- dataItemWin = &dataWin->detail.dataDisplayInfo.
- regsContent[i - startRegNum]->whichElement.dataWindow;
+ dataItemWin = &TUI_DATA_WIN->detail.data_display_info.
+ regs_content[i - startRegNum]->which_element.data_window;
_tuiSetRegisterElement (
i,
frame,
- &((struct tui_win_element *) dataItemWin->content[0])->whichElement.data,
+ &((struct tui_win_element *) dataItemWin->content[0])->which_element.data,
!allocatedHere && refreshValuesOnly);
}
- dataWin->detail.dataDisplayInfo.regsColumnCount =
+ TUI_DATA_WIN->detail.data_display_info.regs_column_count =
tui_calculate_regs_column_count (dpyType);
#ifdef LATER
- if (dataWin->detail.dataDisplayInfo.dataContentCount > 0)
+ if (TUI_DATA_WIN->detail.data_display_info.data_content_count > 0)
{
/* delete all the windows? */
- /* realloc content equal to dataContentCount + regsContentCount */
- /* append dataWin->detail.dataDisplayInfo.dataContent to content */
+ /* realloc content equal to data_content_count + regs_content_count */
+ /* append TUI_DATA_WIN->detail.data_display_info.dataContent to content */
}
#endif
- dataWin->generic.contentSize =
- dataWin->detail.dataDisplayInfo.regsContentCount +
- dataWin->detail.dataDisplayInfo.dataContentCount;
+ TUI_DATA_WIN->generic.content_size =
+ TUI_DATA_WIN->detail.data_display_info.regs_content_count +
+ TUI_DATA_WIN->detail.data_display_info.data_content_count;
ret = TUI_SUCCESS;
}
char buf[40];
int valueCharsWide, labelWidth;
struct tui_data_element * dataElementPtr = &((tui_win_content)
- winInfo->content)[0]->whichElement.data;
+ winInfo->content)[0]->which_element.data;
if (IS_64BIT ||
- dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_DFLOAT_REGS)
+ TUI_DATA_WIN->detail.data_display_info.regs_display_type == TUI_DFLOAT_REGS)
{
valueCharsWide = DOUBLE_FLOAT_VALUE_WIDTH;
labelWidth = DOUBLE_FLOAT_LABEL_WIDTH;
}
else
{
- if (dataWin->detail.dataDisplayInfo.regsDisplayType ==
+ if (TUI_DATA_WIN->detail.data_display_info.regs_display_type ==
TUI_SFLOAT_REGS)
{
valueCharsWide = SINGLE_FLOAT_VALUE_WIDTH;
_tui_vShowRegisters_commandSupport (enum tui_register_display_type dpyType)
{
- if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
+ if (TUI_DATA_WIN != NULL && TUI_DATA_WIN->generic.is_visible)
{ /* Data window already displayed, show the registers */
- if (dataWin->detail.dataDisplayInfo.regsDisplayType != dpyType)
+ if (TUI_DATA_WIN->detail.data_display_info.regs_display_type != dpyType)
tui_show_registers (dpyType);
}
else
- (tui_layout_def ())->regsDisplayType = dpyType;
+ (tui_layout_def ())->regs_display_type = dpyType;
return;
} /* _tui_vShowRegisters_commandSupport */
static void
_tuiShowFloat_command (char *arg, int fromTTY)
{
- if (m_winPtrIsNull (dataWin) || !dataWin->generic.isVisible ||
- (dataWin->detail.dataDisplayInfo.regsDisplayType != TUI_SFLOAT_REGS &&
- dataWin->detail.dataDisplayInfo.regsDisplayType != TUI_DFLOAT_REGS))
- _tui_vShowRegisters_commandSupport ((tui_layout_def ())->floatRegsDisplayType);
+ if (TUI_DATA_WIN == NULL || !TUI_DATA_WIN->generic.is_visible ||
+ (TUI_DATA_WIN->detail.data_display_info.regs_display_type != TUI_SFLOAT_REGS &&
+ TUI_DATA_WIN->detail.data_display_info.regs_display_type != TUI_DFLOAT_REGS))
+ _tui_vShowRegisters_commandSupport ((tui_layout_def ())->float_regs_display_type);
return;
} /* _tuiShowFloat_command */
static void
_tuiToggleFloatRegs_command (char *arg, int fromTTY)
{
- if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
+ if (TUI_DATA_WIN != NULL && TUI_DATA_WIN->generic.is_visible)
tuiToggleFloatRegs ();
else
{
struct tui_layout_def * layoutDef = tui_layout_def ();
- if (layoutDef->floatRegsDisplayType == TUI_SFLOAT_REGS)
- layoutDef->floatRegsDisplayType = TUI_DFLOAT_REGS;
+ if (layoutDef->float_regs_display_type == TUI_SFLOAT_REGS)
+ layoutDef->float_regs_display_type = TUI_DFLOAT_REGS;
else
- layoutDef->floatRegsDisplayType = TUI_SFLOAT_REGS;
+ layoutDef->float_regs_display_type = TUI_SFLOAT_REGS;
}
static void
_tuiScrollRegsForward_command (char *arg, int fromTTY)
{
- tui_scroll (FORWARD_SCROLL, dataWin, 1);
+ tui_scroll (FORWARD_SCROLL, TUI_DATA_WIN, 1);
}
static void
_tuiScrollRegsBackward_command (char *arg, int fromTTY)
{
- tui_scroll (BACKWARD_SCROLL, dataWin, 1);
+ tui_scroll (BACKWARD_SCROLL, TUI_DATA_WIN, 1);
}
#ifndef TUI_REGS_H
#define TUI_REGS_H
-#include "tui/tui-data.h" /* For TuiRegisterDisplayType. */
+#include "tui/tui-data.h" /* For struct tui_register_display_type. */
extern void tui_check_register_values (struct frame_info *);
extern void tui_show_registers (enum tui_register_display_type);
/* Function to display source in the source window. */
enum tui_status
-tui_set_source_content (struct symtab *s, int lineNo, int noerror)
+tui_set_source_content (struct symtab *s, int line_no, int noerror)
{
enum tui_status ret = TUI_FAILURE;
register int i, desc, c, lineWidth, nlines;
register char *srcLine = 0;
- if ((ret = tui_alloc_source_buffer (srcWin)) == TUI_SUCCESS)
+ if ((ret = tui_alloc_source_buffer (TUI_SRC_WIN)) == TUI_SUCCESS)
{
- lineWidth = srcWin->generic.width - 1;
+ lineWidth = TUI_SRC_WIN->generic.width - 1;
/* Take hilite (window border) into account, when calculating
the number of lines */
- nlines = (lineNo + (srcWin->generic.height - 2)) - lineNo;
+ nlines = (line_no + (TUI_SRC_WIN->generic.height - 2)) - line_no;
desc = open_source_file (s);
if (desc < 0)
{
if (!noerror)
{
char *name = alloca (strlen (s->filename) + 100);
- sprintf (name, "%s:%d", s->filename, lineNo);
+ sprintf (name, "%s:%d", s->filename, line_no);
print_sys_errmsg (name, errno);
}
ret = TUI_FAILURE;
if (s->line_charpos == 0)
find_source_lines (s, desc);
- if (lineNo < 1 || lineNo > s->nlines)
+ if (line_no < 1 || line_no > s->nlines)
{
close (desc);
printf_unfiltered (
"Line number %d out of range; %s has %d lines.\n",
- lineNo, s->filename, s->nlines);
+ line_no, s->filename, s->nlines);
}
- else if (lseek (desc, s->line_charpos[lineNo - 1], 0) < 0)
+ else if (lseek (desc, s->line_charpos[line_no - 1], 0) < 0)
{
close (desc);
perror_with_name (s->filename);
{
register int offset, curLineNo, curLine, curLen, threshold;
struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
- struct tui_source_info * src = &srcWin->detail.sourceInfo;
+ struct tui_source_info * src = &TUI_SRC_WIN->detail.source_info;
- if (srcWin->generic.title)
- xfree (srcWin->generic.title);
- srcWin->generic.title = xstrdup (s->filename);
+ if (TUI_SRC_WIN->generic.title)
+ xfree (TUI_SRC_WIN->generic.title);
+ TUI_SRC_WIN->generic.title = xstrdup (s->filename);
if (src->filename)
xfree (src->filename);
/* Determine the threshold for the length of the line
and the offset to start the display. */
- offset = src->horizontalOffset;
+ offset = src->horizontal_offset;
threshold = (lineWidth - 1) + offset;
stream = fdopen (desc, FOPEN_RT);
clearerr (stream);
curLine = 0;
- curLineNo = src->startLineOrAddr.lineNo = lineNo;
+ curLineNo = src->start_line_or_addr.line_no = line_no;
if (offset > 0)
srcLine = (char *) xmalloc (
(threshold + 1) * sizeof (char));
while (curLine < nlines)
{
struct tui_win_element * element = (struct tui_win_element *)
- srcWin->generic.content[curLine];
+ TUI_SRC_WIN->generic.content[curLine];
/* get the first character in the line */
c = fgetc (stream);
if (offset == 0)
srcLine = ((struct tui_win_element *)
- srcWin->generic.content[
- curLine])->whichElement.source.line;
+ TUI_SRC_WIN->generic.content[
+ curLine])->which_element.source.line;
/* Init the line with the line number */
sprintf (srcLine, "%-6d", curLineNo);
curLen = strlen (srcLine);
/* Set whether element is the execution point and
whether there is a break point on it. */
- element->whichElement.source.lineOrAddr.lineNo =
+ element->which_element.source.line_or_addr.line_no =
curLineNo;
- element->whichElement.source.isExecPoint =
+ element->which_element.source.is_exec_point =
(strcmp (((struct tui_win_element *)
- locator->content[0])->whichElement.locator.fileName,
+ locator->content[0])->which_element.locator.file_name,
s->filename) == 0
&& curLineNo == ((struct tui_win_element *)
- locator->content[0])->whichElement.locator.lineNo);
+ locator->content[0])->which_element.locator.line_no);
if (c != EOF)
{
i = strlen (srcLine) - 1;
}
/* Now copy the line taking the offset into account */
if (strlen (srcLine) > offset)
- strcpy (((struct tui_win_element *) srcWin->generic.content[
- curLine])->whichElement.source.line,
+ strcpy (((struct tui_win_element *) TUI_SRC_WIN->generic.content[
+ curLine])->which_element.source.line,
&srcLine[offset]);
else
((struct tui_win_element *)
- srcWin->generic.content[
- curLine])->whichElement.source.line[0] = (char) 0;
+ TUI_SRC_WIN->generic.content[
+ curLine])->which_element.source.line[0] = (char) 0;
curLine++;
curLineNo++;
}
if (offset > 0)
xfree (srcLine);
fclose (stream);
- srcWin->generic.contentSize = nlines;
+ TUI_SRC_WIN->generic.content_size = nlines;
ret = TUI_SUCCESS;
}
}
/* set to empty each line in the window, except for the one
which contains the message */
- while (curr_line < winInfo->generic.contentSize)
+ while (curr_line < winInfo->generic.content_size)
{
/* set the information related to each displayed line
to null: i.e. the line number is 0, there is no bp,
struct tui_win_element * element =
(struct tui_win_element *) winInfo->generic.content[curr_line];
- element->whichElement.source.lineOrAddr.lineNo = 0;
- element->whichElement.source.isExecPoint = FALSE;
- element->whichElement.source.hasBreak = FALSE;
+ element->which_element.source.line_or_addr.line_no = 0;
+ element->which_element.source.is_exec_point = FALSE;
+ element->which_element.source.has_break = FALSE;
/* set the contents of the line to blank */
- element->whichElement.source.line[0] = (char) 0;
+ element->which_element.source.line[0] = (char) 0;
/* if the current line is in the middle of the screen, then we want to
display the 'no source available' message in it.
int warning_length = strlen (warning_string);
char *srcLine;
- srcLine = element->whichElement.source.line;
+ srcLine = element->which_element.source.line;
if (warning_length >= ((lineWidth - 1) / 2))
xpos = 1;
void
tui_show_symtab_source (struct symtab *s, union tui_line_or_address line, int noerror)
{
- srcWin->detail.sourceInfo.horizontalOffset = 0;
- tui_update_source_window_as_is (srcWin, s, line, noerror);
+ TUI_SRC_WIN->detail.source_info.horizontal_offset = 0;
+ tui_update_source_window_as_is (TUI_SRC_WIN, s, line, noerror);
}
int
tui_source_is_displayed (char *fname)
{
- return (srcWin->generic.contentInUse &&
+ return (TUI_SRC_WIN->generic.content_in_use &&
(strcmp (((struct tui_win_element *) (tui_locator_win_info_ptr ())->
- content[0])->whichElement.locator.fileName, fname) == 0));
+ content[0])->which_element.locator.file_name, fname) == 0));
}
tui_vertical_source_scroll (enum tui_scroll_direction scrollDirection,
int numToScroll)
{
- if (srcWin->generic.content != NULL)
+ if (TUI_SRC_WIN->generic.content != NULL)
{
union tui_line_or_address l;
struct symtab *s;
- tui_win_content content = (tui_win_content) srcWin->generic.content;
+ tui_win_content content = (tui_win_content) TUI_SRC_WIN->generic.content;
struct symtab_and_line cursal = get_current_source_symtab_and_line ();
if (cursal.symtab == (struct symtab *) NULL)
if (scrollDirection == FORWARD_SCROLL)
{
- l.lineNo = content[0]->whichElement.source.lineOrAddr.lineNo +
+ l.line_no = content[0]->which_element.source.line_or_addr.line_no +
numToScroll;
- if (l.lineNo > s->nlines)
- /*line = s->nlines - winInfo->generic.contentSize + 1; */
+ if (l.line_no > s->nlines)
+ /*line = s->nlines - winInfo->generic.content_size + 1; */
/*elz: fix for dts 23398 */
- l.lineNo = content[0]->whichElement.source.lineOrAddr.lineNo;
+ l.line_no = content[0]->which_element.source.line_or_addr.line_no;
}
else
{
- l.lineNo = content[0]->whichElement.source.lineOrAddr.lineNo -
+ l.line_no = content[0]->which_element.source.line_or_addr.line_no -
numToScroll;
- if (l.lineNo <= 0)
- l.lineNo = 1;
+ if (l.line_no <= 0)
+ l.line_no = 1;
}
- print_source_lines (s, l.lineNo, l.lineNo + 1, 0);
+ print_source_lines (s, l.line_no, l.line_no + 1, 0);
}
}
#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"
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);
- (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));
}
/* 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
}
/* 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, " ");
locator = tui_locator_win_info_ptr ();
- if (m_genWinPtrNotNull (locator) && locator->handle != (WINDOW *) NULL)
+ if (locator != NULL && locator->handle != (WINDOW *) NULL)
{
struct tui_win_element * element;
element = (struct tui_win_element *) locator->content[0];
- string = tui_make_status_line (&element->whichElement.locator);
+ string = tui_make_status_line (&element->which_element.locator);
wmove (locator->handle, 0, 0);
wstandout (locator->handle);
waddstr (locator->handle, string);
tui_refresh_win (locator);
wmove (locator->handle, 0, 0);
xfree (string);
- locator->contentInUse = TRUE;
+ locator->content_in_use = TRUE;
}
}
return;
}
- element = &((struct tui_win_element *) locator->content[0])->whichElement.locator;
- element->fileName[0] = 0;
- strcat_to_buf (element->fileName, MAX_LOCATOR_ELEMENT_LEN, filename);
+ element = &((struct tui_win_element *) locator->content[0])->which_element.locator;
+ element->file_name[0] = 0;
+ strcat_to_buf (element->file_name, MAX_LOCATOR_ELEMENT_LEN, filename);
}
/* Update the locator, with the provided arguments. */
struct tui_locator_element * element;
/* Allocate the locator content if necessary. */
- if (locator->contentSize <= 0)
+ if (locator->content_size <= 0)
{
locator->content = (void **) tui_alloc_content (1, locator->type);
- locator->contentSize = 1;
+ locator->content_size = 1;
}
- element = &((struct tui_win_element *) locator->content[0])->whichElement.locator;
- element->procName[0] = (char) 0;
- strcat_to_buf (element->procName, MAX_LOCATOR_ELEMENT_LEN, procname);
- element->lineNo = lineno;
+ element = &((struct tui_win_element *) locator->content[0])->which_element.locator;
+ element->proc_name[0] = (char) 0;
+ strcat_to_buf (element->proc_name, MAX_LOCATOR_ELEMENT_LEN, procname);
+ element->line_no = lineno;
element->addr = addr;
tui_set_locator_filename (filename);
}
void
tui_show_frame_info (struct frame_info *fi)
{
- struct tui_win_info * winInfo;
+ struct tui_win_info * win_info;
register int i;
if (fi)
{
- register int startLine, i;
+ register int start_line, i;
CORE_ADDR low;
struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
int sourceAlreadyDisplayed;
sal.line,
get_frame_pc (fi));
tui_show_locator_content ();
- startLine = 0;
+ start_line = 0;
for (i = 0; i < (tui_source_windows ())->count; i++)
{
union tui_which_element *item;
- winInfo = (struct tui_win_info *) (tui_source_windows ())->list[i];
+ win_info = (struct tui_win_info *) (tui_source_windows ())->list[i];
- item = &((struct tui_win_element *) locator->content[0])->whichElement;
- if (winInfo == srcWin)
+ item = &((struct tui_win_element *) locator->content[0])->which_element;
+ if (win_info == TUI_SRC_WIN)
{
- startLine = (item->locator.lineNo -
- (winInfo->generic.viewportHeight / 2)) + 1;
- if (startLine <= 0)
- startLine = 1;
+ start_line = (item->locator.line_no -
+ (win_info->generic.viewport_height / 2)) + 1;
+ if (start_line <= 0)
+ start_line = 1;
}
else
{
low = tui_get_low_disassembly_address (low, get_frame_pc (fi));
}
- if (winInfo == srcWin)
+ if (win_info == TUI_SRC_WIN)
{
union tui_line_or_address l;
- l.lineNo = startLine;
+ l.line_no = start_line;
if (!(sourceAlreadyDisplayed
- && tui_line_is_displayed (item->locator.lineNo, winInfo, TRUE)))
- tui_update_source_window (winInfo, sal.symtab, l, TRUE);
+ && tui_line_is_displayed (item->locator.line_no, win_info, TRUE)))
+ tui_update_source_window (win_info, sal.symtab, l, TRUE);
else
{
- l.lineNo = item->locator.lineNo;
- tui_set_is_exec_point_at (l, winInfo);
+ l.line_no = item->locator.line_no;
+ tui_set_is_exec_point_at (l, win_info);
}
}
else
{
- if (winInfo == disassemWin)
+ if (win_info == TUI_DISASM_WIN)
{
union tui_line_or_address a;
a.addr = low;
- if (!tui_addr_is_displayed (item->locator.addr, winInfo, TRUE))
- tui_update_source_window (winInfo, sal.symtab, a, TRUE);
+ if (!tui_addr_is_displayed (item->locator.addr, win_info, TRUE))
+ tui_update_source_window (win_info, sal.symtab, a, TRUE);
else
{
a.addr = item->locator.addr;
- tui_set_is_exec_point_at (a, winInfo);
+ tui_set_is_exec_point_at (a, win_info);
}
}
}
- tui_update_exec_info (winInfo);
+ tui_update_exec_info (win_info);
}
}
else
tui_show_locator_content ();
for (i = 0; i < (tui_source_windows ())->count; i++)
{
- winInfo = (struct tui_win_info *) (tui_source_windows ())->list[i];
- tui_clear_source_content (winInfo, EMPTY_SOURCE_PROMPT);
- tui_update_exec_info (winInfo);
+ win_info = (struct tui_win_info *) (tui_source_windows ())->list[i];
+ tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
+ tui_update_exec_info (win_info);
}
}
}
rl_get_screen_size (&screenheight, &screenwidth);
/* Set to TUI command window dimension or use readline values. */
sprintf (cmd, "set width %d",
- tui_active ? cmdWin->generic.width : screenwidth);
+ tui_active ? TUI_CMD_WIN->generic.width : screenwidth);
execute_command (cmd, 0);
sprintf (cmd, "set height %d",
- tui_active ? cmdWin->generic.height : screenheight);
+ tui_active ? TUI_CMD_WIN->generic.height : screenheight);
execute_command (cmd, 0);
}
-/* Set the logical focus to winInfo. */
+/* Set the logical focus to win_info. */
void
-tui_set_win_focus_to (struct tui_win_info * winInfo)
+tui_set_win_focus_to (struct tui_win_info * win_info)
{
- if (m_winPtrNotNull (winInfo))
+ if (win_info != NULL)
{
struct tui_win_info * winWithFocus = tui_win_with_focus ();
- if (m_winPtrNotNull (winWithFocus) &&
- winWithFocus->generic.type != CMD_WIN)
+ if (winWithFocus != NULL
+ && winWithFocus->generic.type != CMD_WIN)
tui_unhighlight_win (winWithFocus);
- tui_set_win_with_focus (winInfo);
- if (winInfo->generic.type != CMD_WIN)
- tui_highlight_win (winInfo);
+ tui_set_win_with_focus (win_info);
+ if (win_info->generic.type != CMD_WIN)
+ tui_highlight_win (win_info);
}
return;
void
tui_scroll_forward (struct tui_win_info * winToScroll, int numToScroll)
{
- if (winToScroll != cmdWin)
+ if (winToScroll != TUI_CMD_WIN)
{
int _numToScroll = numToScroll;
** only what is in the viewport. If winToScroll is the
** command window do nothing since the term should handle it.
*/
- if (winToScroll == srcWin)
+ if (winToScroll == TUI_SRC_WIN)
tui_vertical_source_scroll (FORWARD_SCROLL, _numToScroll);
- else if (winToScroll == disassemWin)
+ else if (winToScroll == TUI_DISASM_WIN)
tui_vertical_disassem_scroll (FORWARD_SCROLL, _numToScroll);
- else if (winToScroll == dataWin)
+ else if (winToScroll == TUI_DATA_WIN)
tui_vertical_data_scroll (FORWARD_SCROLL, _numToScroll);
}
}
void
tui_scroll_backward (struct tui_win_info * winToScroll, int numToScroll)
{
- if (winToScroll != cmdWin)
+ if (winToScroll != TUI_CMD_WIN)
{
int _numToScroll = numToScroll;
** only what is in the viewport. If winToScroll is the
** command window do nothing since the term should handle it.
*/
- if (winToScroll == srcWin)
+ if (winToScroll == TUI_SRC_WIN)
tui_vertical_source_scroll (BACKWARD_SCROLL, _numToScroll);
- else if (winToScroll == disassemWin)
+ else if (winToScroll == TUI_DISASM_WIN)
tui_vertical_disassem_scroll (BACKWARD_SCROLL, _numToScroll);
- else if (winToScroll == dataWin)
+ else if (winToScroll == TUI_DATA_WIN)
tui_vertical_data_scroll (BACKWARD_SCROLL, _numToScroll);
}
}
void
tui_scroll_left (struct tui_win_info * winToScroll, int numToScroll)
{
- if (winToScroll != cmdWin)
+ if (winToScroll != TUI_CMD_WIN)
{
int _numToScroll = numToScroll;
** only what is in the viewport. If winToScroll is the
** command window do nothing since the term should handle it.
*/
- if (winToScroll == srcWin || winToScroll == disassemWin)
+ if (winToScroll == TUI_SRC_WIN || winToScroll == TUI_DISASM_WIN)
tui_horizontal_source_scroll (winToScroll, LEFT_SCROLL, _numToScroll);
}
}
void
tui_scroll_right (struct tui_win_info * winToScroll, int numToScroll)
{
- if (winToScroll != cmdWin)
+ if (winToScroll != TUI_CMD_WIN)
{
int _numToScroll = numToScroll;
** only what is in the viewport. If winToScroll is the
** command window do nothing since the term should handle it.
*/
- if (winToScroll == srcWin || winToScroll == disassemWin)
+ if (winToScroll == TUI_SRC_WIN || winToScroll == TUI_DISASM_WIN)
tui_horizontal_source_scroll (winToScroll, RIGHT_SCROLL, _numToScroll);
}
}
enum tui_win_type type;
clearok (curscr, TRUE);
- tui_refresh_all (winList);
+ tui_refresh_all (tui_win_list);
for (type = SRC_WIN; type < MAX_MAJOR_WINDOWS; type++)
{
- if (winList[type] && winList[type]->generic.isVisible)
+ if (tui_win_list[type] && tui_win_list[type]->generic.is_visible)
{
switch (type)
{
case SRC_WIN:
case DISASSEM_WIN:
- tui_show_source_content (winList[type]);
- tui_check_and_display_highlight_if_needed (winList[type]);
- tui_erase_exec_info_content (winList[type]);
- tui_update_exec_info (winList[type]);
+ tui_show_source_content (tui_win_list[type]);
+ tui_check_and_display_highlight_if_needed (tui_win_list[type]);
+ tui_erase_exec_info_content (tui_win_list[type]);
+ tui_update_exec_info (tui_win_list[type]);
break;
case DATA_WIN:
tui_refresh_data_win ();
int newHeight, splitDiff, cmdSplitDiff, numWinsDisplayed = 2;
/* turn keypad off while we resize */
- if (winWithFocus != cmdWin)
- keypad (cmdWin->generic.handle, FALSE);
+ if (winWithFocus != TUI_CMD_WIN)
+ keypad (TUI_CMD_WIN->generic.handle, FALSE);
tui_update_gdb_sizes ();
tui_set_term_height_to (screenheight);
tui_set_term_width_to (screenwidth);
newHeight = firstWin->generic.height + splitDiff;
_makeInvisibleAndSetNewHeight (firstWin, newHeight);
- cmdWin->generic.origin.y = locator->origin.y + 1;
- cmdWin->generic.width += widthDiff;
- newHeight = screenheight - cmdWin->generic.origin.y;
- _makeInvisibleAndSetNewHeight (cmdWin, newHeight);
+ TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
+ TUI_CMD_WIN->generic.width += widthDiff;
+ newHeight = screenheight - TUI_CMD_WIN->generic.origin.y;
+ _makeInvisibleAndSetNewHeight (TUI_CMD_WIN, newHeight);
_makeVisibleWithNewHeight (firstWin);
- _makeVisibleWithNewHeight (cmdWin);
- if (firstWin->generic.contentSize <= 0)
+ _makeVisibleWithNewHeight (TUI_CMD_WIN);
+ if (firstWin->generic.content_size <= 0)
tui_erase_source_content (firstWin, EMPTY_SOURCE_PROMPT);
break;
default:
if (curLayout == SRC_DISASSEM_COMMAND)
{
- firstWin = srcWin;
+ firstWin = TUI_SRC_WIN;
firstWin->generic.width += widthDiff;
- secondWin = disassemWin;
+ secondWin = TUI_DISASM_WIN;
secondWin->generic.width += widthDiff;
}
else
{
- firstWin = dataWin;
+ firstWin = TUI_DATA_WIN;
firstWin->generic.width += widthDiff;
secondWin = (struct tui_win_info *) (tui_source_windows ())->list[0];
secondWin->generic.width += widthDiff;
newHeight = firstWin->generic.height + splitDiff;
_makeInvisibleAndSetNewHeight (firstWin, newHeight);
- if (firstWin == dataWin && widthDiff != 0)
- firstWin->detail.dataDisplayInfo.regsColumnCount =
+ if (firstWin == TUI_DATA_WIN && widthDiff != 0)
+ firstWin->detail.data_display_info.regs_column_count =
tui_calculate_regs_column_count (
- firstWin->detail.dataDisplayInfo.regsDisplayType);
+ firstWin->detail.data_display_info.regs_display_type);
locator->width += widthDiff;
/* Change the second window's height/width */
_makeInvisibleAndSetNewHeight (secondWin, newHeight);
/* Change the command window's height/width */
- cmdWin->generic.origin.y = locator->origin.y + 1;
+ TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
_makeInvisibleAndSetNewHeight (
- cmdWin, cmdWin->generic.height + cmdSplitDiff);
+ TUI_CMD_WIN, TUI_CMD_WIN->generic.height + cmdSplitDiff);
_makeVisibleWithNewHeight (firstWin);
_makeVisibleWithNewHeight (secondWin);
- _makeVisibleWithNewHeight (cmdWin);
- if (firstWin->generic.contentSize <= 0)
+ _makeVisibleWithNewHeight (TUI_CMD_WIN);
+ if (firstWin->generic.content_size <= 0)
tui_erase_source_content (firstWin, EMPTY_SOURCE_PROMPT);
- if (secondWin->generic.contentSize <= 0)
+ if (secondWin->generic.content_size <= 0)
tui_erase_source_content (secondWin, EMPTY_SOURCE_PROMPT);
break;
}
*/
for (winType = SRC_WIN; (winType < MAX_MAJOR_WINDOWS); winType++)
{
- if (winType != CMD_WIN && m_winPtrNotNull (winList[winType]) &&
- !winList[winType]->generic.isVisible)
+ if (winType != CMD_WIN && (tui_win_list[winType] != NULL)
+ && !tui_win_list[winType]->generic.is_visible)
{
- tui_free_window (winList[winType]);
- winList[winType] = (struct tui_win_info *) NULL;
+ tui_free_window (tui_win_list[winType]);
+ tui_win_list[winType] = (struct tui_win_info *) NULL;
}
}
tui_set_win_resized_to (TRUE);
/* turn keypad back on, unless focus is in the command window */
- if (winWithFocus != cmdWin)
- keypad (cmdWin->generic.handle, TRUE);
+ if (winWithFocus != TUI_CMD_WIN)
+ keypad (TUI_CMD_WIN->generic.handle, TRUE);
}
return;
} /* tuiResizeAll */
{
char *bufPtr = (char *) xstrdup (arg);
int i;
- struct tui_win_info * winInfo = (struct tui_win_info *) NULL;
+ struct tui_win_info * win_info = (struct tui_win_info *) NULL;
for (i = 0; (i < strlen (bufPtr)); i++)
bufPtr[i] = toupper (arg[i]);
if (subset_compare (bufPtr, "NEXT"))
- winInfo = tui_next_win (tui_win_with_focus ());
+ win_info = tui_next_win (tui_win_with_focus ());
else if (subset_compare (bufPtr, "PREV"))
- winInfo = tui_prev_win (tui_win_with_focus ());
+ win_info = tui_prev_win (tui_win_with_focus ());
else
- winInfo = tui_partial_win_by_name (bufPtr);
+ win_info = tui_partial_win_by_name (bufPtr);
- if (winInfo == (struct tui_win_info *) NULL || !winInfo->generic.isVisible)
+ if (win_info == (struct tui_win_info *) NULL || !win_info->generic.is_visible)
warning ("Invalid window specified. \n\
The window name specified must be valid and visible.\n");
else
{
- tui_set_win_focus_to (winInfo);
- keypad (cmdWin->generic.handle, (winInfo != cmdWin));
+ tui_set_win_focus_to (win_info);
+ keypad (TUI_CMD_WIN->generic.handle, (win_info != TUI_CMD_WIN));
}
- if (dataWin && dataWin->generic.isVisible)
+ if (TUI_DATA_WIN && TUI_DATA_WIN->generic.is_visible)
tui_refresh_data_win ();
xfree (bufPtr);
printf_filtered ("Focus set to %s window.\n",
struct tui_win_info * winWithFocus = tui_win_with_focus ();
for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
- if (winList[type] && winList[type]->generic.isVisible)
+ if (tui_win_list[type] && tui_win_list[type]->generic.is_visible)
{
- if (winWithFocus == winList[type])
+ if (winWithFocus == tui_win_list[type])
printf_filtered (" %s\t(%d lines) <has focus>\n",
- tui_win_name (&winList[type]->generic),
- winList[type]->generic.height);
+ tui_win_name (&tui_win_list[type]->generic),
+ tui_win_list[type]->generic.height);
else
printf_filtered (" %s\t(%d lines)\n",
- tui_win_name (&winList[type]->generic),
- winList[type]->generic.height);
+ tui_win_name (&tui_win_list[type]->generic),
+ tui_win_list[type]->generic.height);
}
return;
char *bufPtr = buf;
char *wname = (char *) NULL;
int newHeight, i;
- struct tui_win_info * winInfo;
+ struct tui_win_info * win_info;
wname = bufPtr;
bufPtr = strchr (bufPtr, ' ');
*/
for (i = 0; i < strlen (wname); i++)
wname[i] = toupper (wname[i]);
- winInfo = tui_partial_win_by_name (wname);
+ win_info = tui_partial_win_by_name (wname);
- if (winInfo == (struct tui_win_info *) NULL || !winInfo->generic.isVisible)
+ if (win_info == (struct tui_win_info *) NULL || !win_info->generic.is_visible)
warning ("Invalid window specified. \n\
The window name specified must be valid and visible.\n");
else
if (fixedSize)
newHeight = inputNo;
else
- newHeight = winInfo->generic.height + inputNo;
+ newHeight = win_info->generic.height + inputNo;
/*
** Now change the window's height, and adjust all
** other windows around it
*/
- if (_tuiAdjustWinHeights (winInfo,
+ if (_tuiAdjustWinHeights (win_info,
newHeight) == TUI_FAILURE)
warning ("Invalid window height specified.\n%s",
WIN_HEIGHT_USAGE);
{ /* Add 1 for the locator */
int newHeight = tui_term_height () - (inputNo + 1);
- if (!_newHeightOk (winList[CMD_WIN], newHeight) ||
- _tuiAdjustWinHeights (winList[CMD_WIN],
+ if (!_newHeightOk (tui_win_list[CMD_WIN], newHeight) ||
+ _tuiAdjustWinHeights (tui_win_list[CMD_WIN],
newHeight) == TUI_FAILURE)
warning ("Invalid window height specified.\n%s",
XDBWIN_HEIGHT_USAGE);
if (newHeight != primaryWinInfo->generic.height)
{
int diff;
- struct tui_win_info * winInfo;
+ struct tui_win_info * win_info;
struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
enum tui_layout_type curLayout = tui_current_layout ();
_makeInvisibleAndSetNewHeight (primaryWinInfo, newHeight);
if (primaryWinInfo->generic.type == CMD_WIN)
{
- winInfo = (struct tui_win_info *) (tui_source_windows ())->list[0];
- srcWinInfo = winInfo;
+ win_info = (struct tui_win_info *) (tui_source_windows ())->list[0];
+ srcWinInfo = win_info;
}
else
{
- winInfo = winList[CMD_WIN];
+ win_info = tui_win_list[CMD_WIN];
srcWinInfo = primaryWinInfo;
}
- _makeInvisibleAndSetNewHeight (winInfo,
- winInfo->generic.height + diff);
- cmdWin->generic.origin.y = locator->origin.y + 1;
- _makeVisibleWithNewHeight (winInfo);
+ _makeInvisibleAndSetNewHeight (win_info,
+ win_info->generic.height + diff);
+ TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
+ _makeVisibleWithNewHeight (win_info);
_makeVisibleWithNewHeight (primaryWinInfo);
- if (srcWinInfo->generic.contentSize <= 0)
+ if (srcWinInfo->generic.content_size <= 0)
tui_erase_source_content (srcWinInfo, EMPTY_SOURCE_PROMPT);
}
else
if (curLayout == SRC_DISASSEM_COMMAND)
{
- firstWin = srcWin;
- secondWin = disassemWin;
+ firstWin = TUI_SRC_WIN;
+ secondWin = TUI_DISASM_WIN;
}
else
{
- firstWin = dataWin;
+ firstWin = TUI_DATA_WIN;
secondWin = (struct tui_win_info *) (tui_source_windows ())->list[0];
}
- if (primaryWinInfo == cmdWin)
+ if (primaryWinInfo == TUI_CMD_WIN)
{ /*
** Split the change in height accross the 1st & 2nd windows
** adjusting them as well.
secondWin->generic.origin.y = firstWin->generic.height - 1;
_makeInvisibleAndSetNewHeight (
secondWin, secondWin->generic.height + secondSplitDiff);
- cmdWin->generic.origin.y = locator->origin.y + 1;
- _makeInvisibleAndSetNewHeight (cmdWin, newHeight);
+ TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
+ _makeInvisibleAndSetNewHeight (TUI_CMD_WIN, newHeight);
}
else
{
- if ((cmdWin->generic.height + diff) < 1)
+ if ((TUI_CMD_WIN->generic.height + diff) < 1)
{ /*
** If there is no way to increase the command window
** take real estate from the 1st or 2nd window.
*/
- if ((cmdWin->generic.height + diff) < 1)
+ if ((TUI_CMD_WIN->generic.height + diff) < 1)
{
int i;
- for (i = cmdWin->generic.height + diff;
+ for (i = TUI_CMD_WIN->generic.height + diff;
(i < 1); i++)
if (primaryWinInfo == firstWin)
secondWin->generic.height--;
else
_makeInvisibleAndSetNewHeight (
secondWin, secondWin->generic.height);
- cmdWin->generic.origin.y = locator->origin.y + 1;
- if ((cmdWin->generic.height + diff) < 1)
- _makeInvisibleAndSetNewHeight (cmdWin, 1);
+ TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
+ if ((TUI_CMD_WIN->generic.height + diff) < 1)
+ _makeInvisibleAndSetNewHeight (TUI_CMD_WIN, 1);
else
_makeInvisibleAndSetNewHeight (
- cmdWin, cmdWin->generic.height + diff);
+ TUI_CMD_WIN, TUI_CMD_WIN->generic.height + diff);
}
- _makeVisibleWithNewHeight (cmdWin);
+ _makeVisibleWithNewHeight (TUI_CMD_WIN);
_makeVisibleWithNewHeight (secondWin);
_makeVisibleWithNewHeight (firstWin);
- if (firstWin->generic.contentSize <= 0)
+ if (firstWin->generic.content_size <= 0)
tui_erase_source_content (firstWin, EMPTY_SOURCE_PROMPT);
- if (secondWin->generic.contentSize <= 0)
+ if (secondWin->generic.content_size <= 0)
tui_erase_source_content (secondWin, EMPTY_SOURCE_PROMPT);
}
}
** with the targer) invisible, and set the new height and location.
*/
static void
-_makeInvisibleAndSetNewHeight (struct tui_win_info * winInfo, int height)
+_makeInvisibleAndSetNewHeight (struct tui_win_info * win_info, int height)
{
int i;
struct tui_gen_win_info * genWinInfo;
- tui_make_invisible (&winInfo->generic);
- winInfo->generic.height = height;
+ tui_make_invisible (&win_info->generic);
+ win_info->generic.height = height;
if (height > 1)
- winInfo->generic.viewportHeight = height - 1;
+ win_info->generic.viewport_height = height - 1;
else
- winInfo->generic.viewportHeight = height;
- if (winInfo != cmdWin)
- winInfo->generic.viewportHeight--;
+ win_info->generic.viewport_height = height;
+ if (win_info != TUI_CMD_WIN)
+ win_info->generic.viewport_height--;
- /* Now deal with the auxillary windows associated with winInfo */
- switch (winInfo->generic.type)
+ /* Now deal with the auxillary windows associated with win_info */
+ switch (win_info->generic.type)
{
case SRC_WIN:
case DISASSEM_WIN:
- genWinInfo = winInfo->detail.sourceInfo.executionInfo;
+ genWinInfo = win_info->detail.source_info.execution_info;
tui_make_invisible (genWinInfo);
genWinInfo->height = height;
- genWinInfo->origin.y = winInfo->generic.origin.y;
+ genWinInfo->origin.y = win_info->generic.origin.y;
if (height > 1)
- genWinInfo->viewportHeight = height - 1;
+ genWinInfo->viewport_height = height - 1;
else
- genWinInfo->viewportHeight = height;
- if (winInfo != cmdWin)
- genWinInfo->viewportHeight--;
+ genWinInfo->viewport_height = height;
+ if (win_info != TUI_CMD_WIN)
+ genWinInfo->viewport_height--;
- if (m_hasLocator (winInfo))
+ if (tui_win_has_locator (win_info))
{
genWinInfo = tui_locator_win_info_ptr ();
tui_make_invisible (genWinInfo);
- genWinInfo->origin.y = winInfo->generic.origin.y + height;
+ genWinInfo->origin.y = win_info->generic.origin.y + height;
}
break;
case DATA_WIN:
/* delete all data item windows */
- for (i = 0; i < winInfo->generic.contentSize; i++)
+ for (i = 0; i < win_info->generic.content_size; i++)
{
genWinInfo = (struct tui_gen_win_info *) & ((struct tui_win_element *)
- winInfo->generic.content[i])->whichElement.dataWindow;
+ win_info->generic.content[i])->which_element.data_window;
tui_delete_win (genWinInfo->handle);
genWinInfo->handle = (WINDOW *) NULL;
}
** had to be destroyed to be made invisible.
*/
static void
-_makeVisibleWithNewHeight (struct tui_win_info * winInfo)
+_makeVisibleWithNewHeight (struct tui_win_info * win_info)
{
struct symtab *s;
- tui_make_visible (&winInfo->generic);
- tui_check_and_display_highlight_if_needed (winInfo);
- switch (winInfo->generic.type)
+ tui_make_visible (&win_info->generic);
+ tui_check_and_display_highlight_if_needed (win_info);
+ switch (win_info->generic.type)
{
case SRC_WIN:
case DISASSEM_WIN:
- tui_free_win_content (winInfo->detail.sourceInfo.executionInfo);
- tui_make_visible (winInfo->detail.sourceInfo.executionInfo);
- if (winInfo->generic.content != NULL)
+ tui_free_win_content (win_info->detail.source_info.execution_info);
+ tui_make_visible (win_info->detail.source_info.execution_info);
+ if (win_info->generic.content != NULL)
{
union tui_line_or_address lineOrAddr;
struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
- if (winInfo->generic.type == SRC_WIN)
- lineOrAddr.lineNo =
- winInfo->detail.sourceInfo.startLineOrAddr.lineNo;
+ if (win_info->generic.type == SRC_WIN)
+ lineOrAddr.line_no =
+ win_info->detail.source_info.start_line_or_addr.line_no;
else
lineOrAddr.addr =
- winInfo->detail.sourceInfo.startLineOrAddr.addr;
- tui_free_win_content (&winInfo->generic);
- tui_update_source_window (winInfo, cursal.symtab, lineOrAddr, TRUE);
+ win_info->detail.source_info.start_line_or_addr.addr;
+ tui_free_win_content (&win_info->generic);
+ tui_update_source_window (win_info, cursal.symtab, lineOrAddr, TRUE);
}
else if (deprecated_selected_frame != (struct frame_info *) NULL)
{
s = find_pc_symtab (get_frame_pc (deprecated_selected_frame));
- if (winInfo->generic.type == SRC_WIN)
- line.lineNo = cursal.line;
+ if (win_info->generic.type == SRC_WIN)
+ line.line_no = cursal.line;
else
{
find_line_pc (s, cursal.line, &line.addr);
}
- tui_update_source_window (winInfo, s, line, TRUE);
+ tui_update_source_window (win_info, s, line, TRUE);
}
- if (m_hasLocator (winInfo))
+ if (tui_win_has_locator (win_info))
{
tui_make_visible (tui_locator_win_info_ptr ());
tui_show_locator_content ();
tui_display_all_data ();
break;
case CMD_WIN:
- winInfo->detail.commandInfo.curLine = 0;
- winInfo->detail.commandInfo.curch = 0;
- wmove (winInfo->generic.handle,
- winInfo->detail.commandInfo.curLine,
- winInfo->detail.commandInfo.curch);
+ win_info->detail.command_info.cur_line = 0;
+ win_info->detail.command_info.curch = 0;
+ wmove (win_info->generic.handle,
+ win_info->detail.command_info.cur_line,
+ win_info->detail.command_info.curch);
break;
default:
break;
if (ok)
{
int diff;
- enum tui_layout_type curLayout = tui_current_layout ();
+ enum tui_layout_type cur_layout = tui_current_layout ();
diff = (newHeight - primaryWinInfo->generic.height) * (-1);
- if (curLayout == SRC_COMMAND || curLayout == DISASSEM_COMMAND)
+ if (cur_layout == SRC_COMMAND || cur_layout == DISASSEM_COMMAND)
{
ok = ((primaryWinInfo->generic.type == CMD_WIN &&
newHeight <= (tui_term_height () - 4) &&
newHeight >= MIN_WIN_HEIGHT));
if (ok)
{ /* check the total height */
- struct tui_win_info * winInfo;
+ struct tui_win_info * win_info;
- if (primaryWinInfo == cmdWin)
- winInfo = (struct tui_win_info *) (tui_source_windows ())->list[0];
+ if (primaryWinInfo == TUI_CMD_WIN)
+ win_info = (struct tui_win_info *) (tui_source_windows ())->list[0];
else
- winInfo = cmdWin;
+ win_info = TUI_CMD_WIN;
ok = ((newHeight +
- (winInfo->generic.height + diff)) <= tui_term_height ());
+ (win_info->generic.height + diff)) <= tui_term_height ());
}
}
else
struct tui_win_info *firstWin;
struct tui_win_info *secondWin;
- if (curLayout == SRC_DISASSEM_COMMAND)
+ if (cur_layout == SRC_DISASSEM_COMMAND)
{
- firstWin = srcWin;
- secondWin = disassemWin;
+ firstWin = TUI_SRC_WIN;
+ secondWin = TUI_DISASM_WIN;
}
else
{
- firstWin = dataWin;
+ firstWin = TUI_DATA_WIN;
secondWin = (struct tui_win_info *) (tui_source_windows ())->list[0];
}
/*
*/
totalHeight = curTotalHeight =
(firstWin->generic.height + secondWin->generic.height - 1)
- + cmdWin->generic.height + 1 /*locator */ ;
- if (primaryWinInfo == cmdWin)
+ + TUI_CMD_WIN->generic.height + 1 /*locator */ ;
+ if (primaryWinInfo == TUI_CMD_WIN)
{
/* locator included since first & second win share a line */
ok = ((firstWin->generic.height +
** window. And make sure that the command window is
** at least 1 line
*/
- ok = ((cmdWin->generic.height + diff) > 0);
+ ok = ((TUI_CMD_WIN->generic.height + diff) > 0);
if (!ok)
{ /*
** Looks like we have to increase/decrease one of
if (primaryWinInfo == firstWin)
totalHeight = newHeight +
secondWin->generic.height +
- cmdWin->generic.height + diff;
+ TUI_CMD_WIN->generic.height + diff;
else
totalHeight = newHeight +
firstWin->generic.height +
- cmdWin->generic.height + diff;
+ TUI_CMD_WIN->generic.height + diff;
}
}
/*
*winToScroll = tui_partial_win_by_name (wname);
if (*winToScroll == (struct tui_win_info *) NULL ||
- !(*winToScroll)->generic.isVisible)
+ !(*winToScroll)->generic.is_visible)
warning ("Invalid window specified. \n\
The window name specified must be valid and visible.\n");
- else if (*winToScroll == cmdWin)
+ else if (*winToScroll == TUI_CMD_WIN)
*winToScroll = (struct tui_win_info *) (tui_source_windows ())->list[0];
}
xfree (buf);
int elementNo = (-1);
int i;
- for (i = 0; (i < dataWin->generic.contentSize && elementNo < 0); i++)
+ for (i = 0; (i < TUI_DATA_WIN->generic.content_size && elementNo < 0); i++)
{
struct tui_gen_win_info * dataItemWin;
dataItemWin = &((tui_win_content)
- dataWin->generic.content)[i]->whichElement.dataWindow;
- if (dataItemWin->handle != (WINDOW *) NULL && dataItemWin->isVisible)
+ TUI_DATA_WIN->generic.content)[i]->which_element.data_window;
+ if (dataItemWin->handle != (WINDOW *) NULL && dataItemWin->is_visible)
elementNo = i;
}
int i;
struct tui_gen_win_info * dataItemWinPtr;
- for (i = 0; (i < dataWin->generic.contentSize); i++)
+ for (i = 0; (i < TUI_DATA_WIN->generic.content_size); i++)
{
dataItemWinPtr = &((tui_win_content)
- dataWin->generic.content)[i]->whichElement.dataWindow;
+ TUI_DATA_WIN->generic.content)[i]->which_element.data_window;
tui_delete_win (dataItemWinPtr->handle);
dataItemWinPtr->handle = (WINDOW *) NULL;
- dataItemWinPtr->isVisible = FALSE;
+ dataItemWinPtr->is_visible = FALSE;
}
return;
void
tui_erase_data_content (char *prompt)
{
- werase (dataWin->generic.handle);
- tui_check_and_display_highlight_if_needed (dataWin);
+ werase (TUI_DATA_WIN->generic.handle);
+ tui_check_and_display_highlight_if_needed (TUI_DATA_WIN);
if (prompt != (char *) NULL)
{
- int halfWidth = (dataWin->generic.width - 2) / 2;
+ int halfWidth = (TUI_DATA_WIN->generic.width - 2) / 2;
int xPos;
if (strlen (prompt) >= halfWidth)
xPos = 1;
else
xPos = halfWidth - strlen (prompt);
- mvwaddstr (dataWin->generic.handle,
- (dataWin->generic.height / 2),
+ mvwaddstr (TUI_DATA_WIN->generic.handle,
+ (TUI_DATA_WIN->generic.height / 2),
xPos,
prompt);
}
- wrefresh (dataWin->generic.handle);
+ wrefresh (TUI_DATA_WIN->generic.handle);
}
void
tui_display_all_data (void)
{
- if (dataWin->generic.contentSize <= 0)
+ if (TUI_DATA_WIN->generic.content_size <= 0)
tui_erase_data_content (NO_DATA_STRING);
else
{
tui_erase_data_content ((char *) NULL);
tuiDeleteDataContentWindows ();
- tui_check_and_display_highlight_if_needed (dataWin);
+ tui_check_and_display_highlight_if_needed (TUI_DATA_WIN);
tui_display_registers_from (0);
/*
** Then display the other data
*/
- if (dataWin->detail.dataDisplayInfo.dataContent !=
+ if (TUI_DATA_WIN->detail.data_display_info.data_content !=
(tui_win_content) NULL &&
- dataWin->detail.dataDisplayInfo.dataContentCount > 0)
+ TUI_DATA_WIN->detail.data_display_info.data_content_count > 0)
{
}
}
if (lineNo < 0)
_lineNo = 0;
- tui_check_and_display_highlight_if_needed (dataWin);
+ tui_check_and_display_highlight_if_needed (TUI_DATA_WIN);
/* there is no general data, force regs to display (if there are any) */
- if (dataWin->detail.dataDisplayInfo.dataContentCount <= 0)
+ if (TUI_DATA_WIN->detail.data_display_info.data_content_count <= 0)
tui_display_registers_from_line (_lineNo, TRUE);
else
{
{
int firstLine = (-1);
- if (elementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
+ if (elementNo < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
firstLine = tui_line_from_reg_element_no (elementNo);
else
{ /* calculate the firstLine from the element number */
tui_refresh_data_win (void)
{
tui_erase_data_content ((char *) NULL);
- if (dataWin->generic.contentSize > 0)
+ if (TUI_DATA_WIN->generic.content_size > 0)
{
int firstElement = tuiFirstDataItemDisplayed ();
tui_check_register_values (frame);
/* Now check any other data values that there are */
- if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
+ if (TUI_DATA_WIN != NULL && TUI_DATA_WIN->generic.is_visible)
{
int i;
- for (i = 0; dataWin->detail.dataDisplayInfo.dataContentCount; i++)
+ for (i = 0; TUI_DATA_WIN->detail.data_display_info.data_content_count; i++)
{
#ifdef LATER
TuiDataElementPtr dataElementPtr;
struct tui_gen_win_info * dataItemWinPtr;
Opaque newValue;
- dataItemPtr = &dataWin->detail.dataDisplayInfo.
- dataContent[i]->whichElement.dataWindow;
+ dataItemPtr = &TUI_DATA_WIN->detail.data_display_info.
+ data_content[i]->which_element.data_window;
dataElementPtr = &((tui_win_content)
- dataItemWinPtr->content)[0]->whichElement.data;
+ dataItemWinPtr->content)[0]->which_element.data;
if value
has changed (dataElementPtr, frame, &newValue)
{
int firstLine = (-1);
firstElementNo = tuiFirstDataItemDisplayed ();
- if (firstElementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
+ if (firstElementNo < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
firstLine = tui_line_from_reg_element_no (firstElementNo);
else
{ /* calculate the first line from the element number which is in
/* Refresh the window. */
void
-tui_refresh_win (struct tui_gen_win_info * winInfo)
+tui_refresh_win (struct tui_gen_win_info * win_info)
{
- if (winInfo->type == DATA_WIN && winInfo->contentSize > 0)
+ if (win_info->type == DATA_WIN && win_info->content_size > 0)
{
int i;
- for (i = 0; (i < winInfo->contentSize); i++)
+ for (i = 0; (i < win_info->content_size); i++)
{
struct tui_gen_win_info * dataItemWinPtr;
dataItemWinPtr = &((tui_win_content)
- winInfo->content)[i]->whichElement.dataWindow;
- if (m_genWinPtrNotNull (dataItemWinPtr) &&
- dataItemWinPtr->handle != (WINDOW *) NULL)
+ win_info->content)[i]->which_element.data_window;
+ if (dataItemWinPtr != NULL
+ && dataItemWinPtr->handle != (WINDOW *) NULL)
wrefresh (dataItemWinPtr->handle);
}
}
- else if (winInfo->type == CMD_WIN)
+ else if (win_info->type == CMD_WIN)
{
/* Do nothing */
}
else
{
- if (winInfo->handle != (WINDOW *) NULL)
- wrefresh (winInfo->handle);
+ if (win_info->handle != (WINDOW *) NULL)
+ wrefresh (win_info->handle);
}
return;
/* Draw a border arround the window. */
void
-boxWin (struct tui_gen_win_info * winInfo, int highlightFlag)
+boxWin (struct tui_gen_win_info * win_info, int highlightFlag)
{
- if (winInfo && winInfo->handle)
+ if (win_info && win_info->handle)
{
WINDOW *win;
int attrs;
- win = winInfo->handle;
+ win = win_info->handle;
if (highlightFlag == HILITE)
attrs = tui_active_border_attrs;
else
tui_border_hline, tui_border_hline,
tui_border_ulcorner, tui_border_urcorner,
tui_border_llcorner, tui_border_lrcorner);
- if (winInfo->title)
- mvwaddstr (win, 0, 3, winInfo->title);
+ if (win_info->title)
+ mvwaddstr (win, 0, 3, win_info->title);
wattroff (win, attrs);
}
}
void
-tui_unhighlight_win (struct tui_win_info * winInfo)
+tui_unhighlight_win (struct tui_win_info * win_info)
{
- if (m_winPtrNotNull (winInfo) && winInfo->generic.handle != (WINDOW *) NULL)
+ if (win_info != NULL && win_info->generic.handle != (WINDOW *) NULL)
{
- boxWin ((struct tui_gen_win_info *) winInfo, NO_HILITE);
- wrefresh (winInfo->generic.handle);
- m_setWinHighlightOff (winInfo);
+ boxWin ((struct tui_gen_win_info *) win_info, NO_HILITE);
+ wrefresh (win_info->generic.handle);
+ tui_set_win_highlight (win_info, 0);
}
}
void
-tui_highlight_win (struct tui_win_info * winInfo)
+tui_highlight_win (struct tui_win_info * win_info)
{
- if (m_winPtrNotNull (winInfo) &&
- winInfo->canHighlight && winInfo->generic.handle != (WINDOW *) NULL)
+ if (win_info != NULL
+ && win_info->can_highlight
+ && win_info->generic.handle != (WINDOW *) NULL)
{
- boxWin ((struct tui_gen_win_info *) winInfo, HILITE);
- wrefresh (winInfo->generic.handle);
- m_setWinHighlightOn (winInfo);
+ boxWin ((struct tui_gen_win_info *) win_info, HILITE);
+ wrefresh (win_info->generic.handle);
+ tui_set_win_highlight (win_info, 1);
}
}
void
-tui_check_and_display_highlight_if_needed (struct tui_win_info * winInfo)
+tui_check_and_display_highlight_if_needed (struct tui_win_info * win_info)
{
- if (m_winPtrNotNull (winInfo) && winInfo->generic.type != CMD_WIN)
+ if (win_info != NULL && win_info->generic.type != CMD_WIN)
{
- if (winInfo->isHighlighted)
- tui_highlight_win (winInfo);
+ if (win_info->is_highlighted)
+ tui_highlight_win (win_info);
else
- tui_unhighlight_win (winInfo);
+ tui_unhighlight_win (win_info);
}
return;
void
-tui_make_window (struct tui_gen_win_info * winInfo, int boxIt)
+tui_make_window (struct tui_gen_win_info * win_info, int boxIt)
{
WINDOW *handle;
- handle = newwin (winInfo->height,
- winInfo->width,
- winInfo->origin.y,
- winInfo->origin.x);
- winInfo->handle = handle;
+ handle = newwin (win_info->height,
+ win_info->width,
+ win_info->origin.y,
+ win_info->origin.x);
+ win_info->handle = handle;
if (handle != (WINDOW *) NULL)
{
if (boxIt == BOX_WINDOW)
- boxWin (winInfo, NO_HILITE);
- winInfo->isVisible = TRUE;
+ boxWin (win_info, NO_HILITE);
+ win_info->is_visible = TRUE;
scrollok (handle, TRUE);
}
}
if (visible)
{
- if (!win_info->isVisible)
+ if (!win_info->is_visible)
{
tui_make_window (win_info,
(win_info->type != CMD_WIN
- && !m_winIsAuxillary (win_info->type)));
- win_info->isVisible = TRUE;
+ && !tui_win_is_auxillary (win_info->type)));
+ win_info->is_visible = TRUE;
}
}
else if (!visible &&
- win_info->isVisible && win_info->handle != (WINDOW *) NULL)
+ win_info->is_visible && win_info->handle != (WINDOW *) NULL)
{
- win_info->isVisible = FALSE;
+ win_info->is_visible = FALSE;
tui_delete_win (win_info->handle);
win_info->handle = (WINDOW *) NULL;
}
for (i = 0; i < MAX_MAJOR_WINDOWS; i++)
{
- if (m_winPtrNotNull (winList[i]) &&
- ((winList[i])->generic.type) != CMD_WIN)
+ if (tui_win_list[i] != NULL
+ && ((tui_win_list[i])->generic.type) != CMD_WIN)
{
- if (m_winIsSourceType ((winList[i])->generic.type))
- make_visible ((winList[i])->detail.sourceInfo.executionInfo,
+ if (tui_win_is_source_type ((tui_win_list[i])->generic.type))
+ make_visible ((tui_win_list[i])->detail.source_info.execution_info,
visible);
- make_visible ((struct tui_gen_win_info *) winList[i], visible);
+ make_visible ((struct tui_gen_win_info *) tui_win_list[i], visible);
}
}
for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
{
- if (list[type] && list[type]->generic.isVisible)
+ if (list[type] && list[type]->generic.is_visible)
{
if (type == SRC_WIN || type == DISASSEM_WIN)
{
- touchwin (list[type]->detail.sourceInfo.executionInfo->handle);
- tui_refresh_win (list[type]->detail.sourceInfo.executionInfo);
+ touchwin (list[type]->detail.source_info.execution_info->handle);
+ tui_refresh_win (list[type]->detail.source_info.execution_info);
}
touchwin (list[type]->generic.handle);
tui_refresh_win (&list[type]->generic);
}
}
- if (locator->isVisible)
+ if (locator->is_visible)
{
touchwin (locator->handle);
tui_refresh_win (locator);
extern void tui_delete_win (WINDOW * window);
extern void tui_refresh_win (struct tui_gen_win_info *);
-/*
- ** Macros
- */
-#define m_beVisible(winInfo) makeVisible((struct tui_gen_win_info *)(winInfo), TRUE)
-#define m_beInvisible(winInfo) \
- makeVisible((struct tui_gen_win_info *)(winInfo), FALSE)
-
#endif
/* Function to display source in the source window. This function
initializes the horizontal scroll to 0. */
void
-tui_update_source_window (struct tui_win_info * winInfo, struct symtab *s,
+tui_update_source_window (struct tui_win_info * win_info, struct symtab *s,
union tui_line_or_address lineOrAddr, int noerror)
{
- winInfo->detail.sourceInfo.horizontalOffset = 0;
- tui_update_source_window_as_is (winInfo, s, lineOrAddr, noerror);
+ win_info->detail.source_info.horizontal_offset = 0;
+ tui_update_source_window_as_is (win_info, s, lineOrAddr, noerror);
return;
}
/* Function to display source in the source/asm window. This function
shows the source as specified by the horizontal offset. */
void
-tui_update_source_window_as_is (struct tui_win_info * winInfo, struct symtab *s,
+tui_update_source_window_as_is (struct tui_win_info * win_info, struct symtab *s,
union tui_line_or_address lineOrAddr, int noerror)
{
enum tui_status ret;
- if (winInfo->generic.type == SRC_WIN)
- ret = tui_set_source_content (s, lineOrAddr.lineNo, noerror);
+ if (win_info->generic.type == SRC_WIN)
+ ret = tui_set_source_content (s, lineOrAddr.line_no, noerror);
else
ret = tui_set_disassem_content (lineOrAddr.addr);
if (ret == TUI_FAILURE)
{
- tui_clear_source_content (winInfo, EMPTY_SOURCE_PROMPT);
- tui_clear_exec_info_content (winInfo);
+ tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
+ tui_clear_exec_info_content (win_info);
}
else
{
- tui_update_breakpoint_info (winInfo, 0);
- tui_show_source_content (winInfo);
- tui_update_exec_info (winInfo);
- if (winInfo->generic.type == SRC_WIN)
+ tui_update_breakpoint_info (win_info, 0);
+ tui_show_source_content (win_info);
+ tui_update_exec_info (win_info);
+ if (win_info->generic.type == SRC_WIN)
{
struct symtab_and_line sal;
- sal.line = lineOrAddr.lineNo +
- (winInfo->generic.contentSize - 2);
+ sal.line = lineOrAddr.line_no +
+ (win_info->generic.content_size - 2);
sal.symtab = s;
set_current_source_symtab_and_line (&sal);
/*
** If the focus was in the asm win, put it in the src
** win if we don't have a split layout
*/
- if (tui_win_with_focus () == disassemWin &&
+ if (tui_win_with_focus () == TUI_DISASM_WIN &&
tui_current_layout () != SRC_DISASSEM_COMMAND)
- tui_set_win_focus_to (srcWin);
+ tui_set_win_focus_to (TUI_SRC_WIN);
}
}
break;
default:
sal = find_pc_line (addr, 0);
- l.lineNo = sal.line;
+ l.line_no = sal.line;
tui_show_symtab_source (sal.symtab, l, FALSE);
break;
}
for (i = 0; i < (tui_source_windows ())->count; i++)
{
- struct tui_win_info * winInfo = (struct tui_win_info *) (tui_source_windows ())->list[i];
+ struct tui_win_info * win_info = (struct tui_win_info *) (tui_source_windows ())->list[i];
- tui_clear_source_content (winInfo, EMPTY_SOURCE_PROMPT);
- tui_clear_exec_info_content (winInfo);
+ tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
+ tui_clear_exec_info_content (win_info);
}
}
tui_update_source_windows_with_addr (pc);
break;
default:
- l.lineNo = line;
+ l.line_no = line;
tui_show_symtab_source (s, l, FALSE);
if (tui_current_layout () == SRC_DISASSEM_COMMAND)
{
}
void
-tui_clear_source_content (struct tui_win_info * winInfo, int displayPrompt)
+tui_clear_source_content (struct tui_win_info * win_info, int displayPrompt)
{
- if (m_winPtrNotNull (winInfo))
+ if (win_info != NULL)
{
register int i;
- winInfo->generic.contentInUse = FALSE;
- tui_erase_source_content (winInfo, displayPrompt);
- for (i = 0; i < winInfo->generic.contentSize; i++)
+ win_info->generic.content_in_use = FALSE;
+ tui_erase_source_content (win_info, displayPrompt);
+ for (i = 0; i < win_info->generic.content_size; i++)
{
struct tui_win_element * element =
- (struct tui_win_element *) winInfo->generic.content[i];
- element->whichElement.source.hasBreak = FALSE;
- element->whichElement.source.isExecPoint = FALSE;
+ (struct tui_win_element *) win_info->generic.content[i];
+ element->which_element.source.has_break = FALSE;
+ element->which_element.source.is_exec_point = FALSE;
}
}
void
-tui_erase_source_content (struct tui_win_info * winInfo, int displayPrompt)
+tui_erase_source_content (struct tui_win_info * win_info, int displayPrompt)
{
int xPos;
- int halfWidth = (winInfo->generic.width - 2) / 2;
+ int halfWidth = (win_info->generic.width - 2) / 2;
- if (winInfo->generic.handle != (WINDOW *) NULL)
+ if (win_info->generic.handle != (WINDOW *) NULL)
{
- werase (winInfo->generic.handle);
- tui_check_and_display_highlight_if_needed (winInfo);
+ werase (win_info->generic.handle);
+ tui_check_and_display_highlight_if_needed (win_info);
if (displayPrompt == EMPTY_SOURCE_PROMPT)
{
char *noSrcStr;
- if (winInfo->generic.type == SRC_WIN)
+ if (win_info->generic.type == SRC_WIN)
noSrcStr = NO_SRC_STRING;
else
noSrcStr = NO_DISASSEM_STRING;
xPos = 1;
else
xPos = halfWidth - strlen (noSrcStr);
- mvwaddstr (winInfo->generic.handle,
- (winInfo->generic.height / 2),
+ mvwaddstr (win_info->generic.handle,
+ (win_info->generic.height / 2),
xPos,
noSrcStr);
to refresh, do display
the correct stuff, and not the old image */
- tui_set_source_content_nil (winInfo, noSrcStr);
+ tui_set_source_content_nil (win_info, noSrcStr);
}
- tui_refresh_win (&winInfo->generic);
+ tui_refresh_win (&win_info->generic);
}
return;
} /* tuiEraseSourceContent */
/* Redraw the complete line of a source or disassembly window. */
static void
-tui_show_source_line (struct tui_win_info * winInfo, int lineno)
+tui_show_source_line (struct tui_win_info * win_info, int lineno)
{
struct tui_win_element * line;
int x, y;
- line = (struct tui_win_element *) winInfo->generic.content[lineno - 1];
- if (line->whichElement.source.isExecPoint)
- wattron (winInfo->generic.handle, A_STANDOUT);
+ line = (struct tui_win_element *) win_info->generic.content[lineno - 1];
+ if (line->which_element.source.is_exec_point)
+ wattron (win_info->generic.handle, A_STANDOUT);
- mvwaddstr (winInfo->generic.handle, lineno, 1,
- line->whichElement.source.line);
- if (line->whichElement.source.isExecPoint)
- wattroff (winInfo->generic.handle, A_STANDOUT);
+ mvwaddstr (win_info->generic.handle, lineno, 1,
+ line->which_element.source.line);
+ if (line->which_element.source.is_exec_point)
+ wattroff (win_info->generic.handle, A_STANDOUT);
/* Clear to end of line but stop before the border. */
- getyx (winInfo->generic.handle, y, x);
- while (x + 1 < winInfo->generic.width)
+ getyx (win_info->generic.handle, y, x);
+ while (x + 1 < win_info->generic.width)
{
- waddch (winInfo->generic.handle, ' ');
- getyx (winInfo->generic.handle, y, x);
+ waddch (win_info->generic.handle, ' ');
+ getyx (win_info->generic.handle, y, x);
}
}
void
-tui_show_source_content (struct tui_win_info * winInfo)
+tui_show_source_content (struct tui_win_info * win_info)
{
- if (winInfo->generic.contentSize > 0)
+ if (win_info->generic.content_size > 0)
{
int lineno;
- for (lineno = 1; lineno <= winInfo->generic.contentSize; lineno++)
- tui_show_source_line (winInfo, lineno);
+ for (lineno = 1; lineno <= win_info->generic.content_size; lineno++)
+ tui_show_source_line (win_info, lineno);
}
else
- tui_erase_source_content (winInfo, TRUE);
+ tui_erase_source_content (win_info, TRUE);
- tui_check_and_display_highlight_if_needed (winInfo);
- tui_refresh_win (&winInfo->generic);
- winInfo->generic.contentInUse = TRUE;
+ tui_check_and_display_highlight_if_needed (win_info);
+ tui_refresh_win (&win_info->generic);
+ win_info->generic.content_in_use = TRUE;
}
/* Scroll the source forward or backward horizontally. */
void
-tui_horizontal_source_scroll (struct tui_win_info * winInfo,
+tui_horizontal_source_scroll (struct tui_win_info * win_info,
enum tui_scroll_direction direction,
int numToScroll)
{
- if (winInfo->generic.content != NULL)
+ if (win_info->generic.content != NULL)
{
int offset;
struct symtab *s;
s = cursal.symtab;
if (direction == LEFT_SCROLL)
- offset = winInfo->detail.sourceInfo.horizontalOffset + numToScroll;
+ offset = win_info->detail.source_info.horizontal_offset + numToScroll;
else
{
if ((offset =
- winInfo->detail.sourceInfo.horizontalOffset - numToScroll) < 0)
+ win_info->detail.source_info.horizontal_offset - numToScroll) < 0)
offset = 0;
}
- winInfo->detail.sourceInfo.horizontalOffset = offset;
- tui_update_source_window_as_is (winInfo, s,
+ win_info->detail.source_info.horizontal_offset = offset;
+ tui_update_source_window_as_is (win_info, s,
((struct tui_win_element *)
- winInfo->generic.content[0])->whichElement.source.lineOrAddr,
+ win_info->generic.content[0])->which_element.source.line_or_addr,
FALSE);
}
} /* tuiHorizontalSourceScroll */
-/* Set or clear the hasBreak flag in the line whose line is lineNo. */
+/* Set or clear the has_break flag in the line whose line is line_no. */
void
-tui_set_is_exec_point_at (union tui_line_or_address l, struct tui_win_info * winInfo)
+tui_set_is_exec_point_at (union tui_line_or_address l, struct tui_win_info * win_info)
{
int changed = 0;
int i;
- tui_win_content content = (tui_win_content) winInfo->generic.content;
+ tui_win_content content = (tui_win_content) win_info->generic.content;
i = 0;
- while (i < winInfo->generic.contentSize)
+ while (i < win_info->generic.content_size)
{
int newState;
- if (content[i]->whichElement.source.lineOrAddr.addr == l.addr)
+ if (content[i]->which_element.source.line_or_addr.addr == l.addr)
newState = TRUE;
else
newState = FALSE;
- if (newState != content[i]->whichElement.source.isExecPoint)
+ if (newState != content[i]->which_element.source.is_exec_point)
{
changed++;
- content[i]->whichElement.source.isExecPoint = newState;
- tui_show_source_line (winInfo, i + 1);
+ content[i]->which_element.source.is_exec_point = newState;
+ tui_show_source_line (win_info, i + 1);
}
i++;
}
if (changed)
- tui_refresh_win (&winInfo->generic);
+ tui_refresh_win (&win_info->generic);
}
/* Update the execution windows to show the active breakpoints.
/* Scan the source window and the breakpoints to update the
- hasBreak information for each line.
+ has_break information for each line.
Returns 1 if something changed and the execution window
must be refreshed. */
int
{
int i;
int need_refresh = 0;
- struct tui_source_info * src = &win->detail.sourceInfo;
+ struct tui_source_info * src = &win->detail.source_info;
- for (i = 0; i < win->generic.contentSize; i++)
+ for (i = 0; i < win->generic.content_size; i++)
{
struct breakpoint *bp;
extern struct breakpoint *breakpoint_chain;
int mode;
struct tui_source_element* line;
- line = &((struct tui_win_element *) win->generic.content[i])->whichElement.source;
- if (current_only && !line->isExecPoint)
+ line = &((struct tui_win_element *) win->generic.content[i])->which_element.source;
+ if (current_only && !line->is_exec_point)
continue;
/* Scan each breakpoint to see if the current line has something to
bp != (struct breakpoint *) NULL;
bp = bp->next)
{
- if ((win == srcWin
+ if ((win == TUI_SRC_WIN
&& bp->source_file
&& (strcmp (src->filename, bp->source_file) == 0)
- && bp->line_number == line->lineOrAddr.lineNo)
- || (win == disassemWin
- && bp->loc->address == line->lineOrAddr.addr))
+ && bp->line_number == line->line_or_addr.line_no)
+ || (win == TUI_DISASM_WIN
+ && bp->loc->address == line->line_or_addr.addr))
{
if (bp->enable_state == bp_disabled)
mode |= TUI_BP_DISABLED;
mode |= TUI_BP_HARDWARE;
}
}
- if (line->hasBreak != mode)
+ if (line->has_break != mode)
{
- line->hasBreak = mode;
+ line->has_break = mode;
need_refresh = 1;
}
}
** disassembly window.
*/
enum tui_status
-tuiSetExecInfoContent (struct tui_win_info * winInfo)
+tuiSetExecInfoContent (struct tui_win_info * win_info)
{
enum tui_status ret = TUI_SUCCESS;
- if (winInfo->detail.sourceInfo.executionInfo != (struct tui_gen_win_info *) NULL)
+ if (win_info->detail.source_info.execution_info != (struct tui_gen_win_info *) NULL)
{
- struct tui_gen_win_info * execInfoPtr = winInfo->detail.sourceInfo.executionInfo;
+ struct tui_gen_win_info * execInfoPtr = win_info->detail.source_info.execution_info;
if (execInfoPtr->content == NULL)
execInfoPtr->content =
- (void **) tui_alloc_content (winInfo->generic.height,
+ (void **) tui_alloc_content (win_info->generic.height,
execInfoPtr->type);
if (execInfoPtr->content != NULL)
{
int i;
- tui_update_breakpoint_info (winInfo, 1);
- for (i = 0; i < winInfo->generic.contentSize; i++)
+ tui_update_breakpoint_info (win_info, 1);
+ for (i = 0; i < win_info->generic.content_size; i++)
{
struct tui_win_element * element;
struct tui_win_element * srcElement;
int mode;
element = (struct tui_win_element *) execInfoPtr->content[i];
- srcElement = (struct tui_win_element *) winInfo->generic.content[i];
+ srcElement = (struct tui_win_element *) win_info->generic.content[i];
- memset(element->whichElement.simpleString, ' ',
- sizeof(element->whichElement.simpleString));
- element->whichElement.simpleString[TUI_EXECINFO_SIZE - 1] = 0;
+ memset(element->which_element.simple_string, ' ',
+ sizeof(element->which_element.simple_string));
+ element->which_element.simple_string[TUI_EXECINFO_SIZE - 1] = 0;
/* Now update the exec info content based upon the state
of each line as indicated by the source content. */
- mode = srcElement->whichElement.source.hasBreak;
+ mode = srcElement->which_element.source.has_break;
if (mode & TUI_BP_HIT)
- element->whichElement.simpleString[TUI_BP_HIT_POS] =
+ element->which_element.simple_string[TUI_BP_HIT_POS] =
(mode & TUI_BP_HARDWARE) ? 'H' : 'B';
else if (mode & (TUI_BP_ENABLED | TUI_BP_DISABLED))
- element->whichElement.simpleString[TUI_BP_HIT_POS] =
+ element->which_element.simple_string[TUI_BP_HIT_POS] =
(mode & TUI_BP_HARDWARE) ? 'h' : 'b';
if (mode & TUI_BP_ENABLED)
- element->whichElement.simpleString[TUI_BP_BREAK_POS] = '+';
+ element->which_element.simple_string[TUI_BP_BREAK_POS] = '+';
else if (mode & TUI_BP_DISABLED)
- element->whichElement.simpleString[TUI_BP_BREAK_POS] = '-';
+ element->which_element.simple_string[TUI_BP_BREAK_POS] = '-';
- if (srcElement->whichElement.source.isExecPoint)
- element->whichElement.simpleString[TUI_EXEC_POS] = '>';
+ if (srcElement->which_element.source.is_exec_point)
+ element->which_element.simple_string[TUI_EXEC_POS] = '>';
}
- execInfoPtr->contentSize = winInfo->generic.contentSize;
+ execInfoPtr->content_size = win_info->generic.content_size;
}
else
ret = TUI_FAILURE;
** tuiShowExecInfoContent().
*/
void
-tuiShowExecInfoContent (struct tui_win_info * winInfo)
+tuiShowExecInfoContent (struct tui_win_info * win_info)
{
- struct tui_gen_win_info * execInfo = winInfo->detail.sourceInfo.executionInfo;
+ struct tui_gen_win_info * execInfo = win_info->detail.source_info.execution_info;
int curLine;
werase (execInfo->handle);
tui_refresh_win (execInfo);
- for (curLine = 1; (curLine <= execInfo->contentSize); curLine++)
+ for (curLine = 1; (curLine <= execInfo->content_size); curLine++)
mvwaddstr (execInfo->handle,
curLine,
0,
((struct tui_win_element *)
- execInfo->content[curLine - 1])->whichElement.simpleString);
+ execInfo->content[curLine - 1])->which_element.simple_string);
tui_refresh_win (execInfo);
- execInfo->contentInUse = TRUE;
+ execInfo->content_in_use = TRUE;
return;
}
void
-tui_erase_exec_info_content (struct tui_win_info * winInfo)
+tui_erase_exec_info_content (struct tui_win_info * win_info)
{
- struct tui_gen_win_info * execInfo = winInfo->detail.sourceInfo.executionInfo;
+ struct tui_gen_win_info * execInfo = win_info->detail.source_info.execution_info;
werase (execInfo->handle);
tui_refresh_win (execInfo);
}
void
-tui_clear_exec_info_content (struct tui_win_info * winInfo)
+tui_clear_exec_info_content (struct tui_win_info * win_info)
{
- winInfo->detail.sourceInfo.executionInfo->contentInUse = FALSE;
- tui_erase_exec_info_content (winInfo);
+ win_info->detail.source_info.execution_info->content_in_use = FALSE;
+ tui_erase_exec_info_content (win_info);
return;
}
/* Function to update the execution info window. */
void
-tui_update_exec_info (struct tui_win_info * winInfo)
+tui_update_exec_info (struct tui_win_info * win_info)
{
- tuiSetExecInfoContent (winInfo);
- tuiShowExecInfoContent (winInfo);
+ tuiSetExecInfoContent (win_info);
+ tuiShowExecInfoContent (win_info);
} /* tuiUpdateExecInfo */
enum tui_status
-tui_alloc_source_buffer (struct tui_win_info *winInfo)
+tui_alloc_source_buffer (struct tui_win_info *win_info)
{
register char *srcLineBuf;
register int i, lineWidth, maxLines;
enum tui_status ret = TUI_FAILURE;
- maxLines = winInfo->generic.height; /* less the highlight box */
- lineWidth = winInfo->generic.width - 1;
+ maxLines = win_info->generic.height; /* less the highlight box */
+ lineWidth = win_info->generic.width - 1;
/*
** Allocate the buffer for the source lines. Do this only once since they
** will be re-used for all source displays. The only other time this will
** be done is when a window's size changes.
*/
- if (winInfo->generic.content == NULL)
+ if (win_info->generic.content == NULL)
{
srcLineBuf = (char *) xmalloc ((maxLines * lineWidth) * sizeof (char));
if (srcLineBuf == (char *) NULL)
else
{
/* allocate the content list */
- if ((winInfo->generic.content =
+ if ((win_info->generic.content =
(void **) tui_alloc_content (maxLines, SRC_WIN)) == NULL)
{
xfree (srcLineBuf);
}
for (i = 0; i < maxLines; i++)
((struct tui_win_element *)
- winInfo->generic.content[i])->whichElement.source.line =
+ win_info->generic.content[i])->which_element.source.line =
srcLineBuf + (lineWidth * i);
ret = TUI_SUCCESS;
}
/* Answer whether the a particular line number or address is displayed
in the current source window. */
int
-tui_line_is_displayed (int line, struct tui_win_info * winInfo,
+tui_line_is_displayed (int line, struct tui_win_info * win_info,
int checkThreshold)
{
int isDisplayed = FALSE;
else
threshold = 0;
i = 0;
- while (i < winInfo->generic.contentSize - threshold && !isDisplayed)
+ while (i < win_info->generic.content_size - threshold && !isDisplayed)
{
isDisplayed = (((struct tui_win_element *)
- winInfo->generic.content[i])->whichElement.source.lineOrAddr.lineNo
+ win_info->generic.content[i])->which_element.source.line_or_addr.line_no
== (int) line);
i++;
}
/* Answer whether the a particular line number or address is displayed
in the current source window. */
int
-tui_addr_is_displayed (CORE_ADDR addr, struct tui_win_info * winInfo,
+tui_addr_is_displayed (CORE_ADDR addr, struct tui_win_info * win_info,
int checkThreshold)
{
int isDisplayed = FALSE;
else
threshold = 0;
i = 0;
- while (i < winInfo->generic.contentSize - threshold && !isDisplayed)
+ while (i < win_info->generic.content_size - threshold && !isDisplayed)
{
isDisplayed = (((struct tui_win_element *)
- winInfo->generic.content[i])->whichElement.source.lineOrAddr.addr
+ win_info->generic.content[i])->which_element.source.line_or_addr.addr
== addr);
i++;
}
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
{
if (winInfo)
{
tui_set_win_focus_to (winInfo);
- if (dataWin && dataWin->generic.isVisible)
+ if (TUI_DATA_WIN && TUI_DATA_WIN->generic.is_visible)
tui_refresh_data_win ();
- keypad (cmdWin->generic.handle, (winInfo != cmdWin));
+ keypad (TUI_CMD_WIN->generic.handle, (winInfo != TUI_CMD_WIN));
}
return 0;
}
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);
}
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;
}
tui_rl_startup_hook ()
{
rl_already_prompted = 1;
- if (tui_current_key_mode != tui_command_mode)
- tui_set_key_mode (tui_single_key_mode);
+ if (tui_current_key_mode != TUI_COMMAND_MODE)
+ tui_set_key_mode (TUI_SINGLE_KEY_MODE);
tui_redisplay_readline ();
return 0;
}
tui_set_key_mode (enum tui_key_mode mode)
{
tui_current_key_mode = mode;
- rl_set_keymap (mode == tui_single_key_mode
+ rl_set_keymap (mode == TUI_SINGLE_KEY_MODE
? tui_keymap : tui_readline_standard_keymap);
tui_show_locator_content ();
}
tui_show_frame_info (0);
tui_set_layout (SRC_COMMAND, TUI_UNDEFINED_REGS);
- tui_set_win_focus_to (srcWin);
- keypad (cmdWin->generic.handle, TRUE);
- wrefresh (cmdWin->generic.handle);
+ tui_set_win_focus_to (TUI_SRC_WIN);
+ keypad (TUI_CMD_WIN->generic.handle, TRUE);
+ wrefresh (TUI_CMD_WIN->generic.handle);
tui_finish_init = 0;
}
else
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;
}
#ifndef TUI_H
#define TUI_H
-#include <stdarg.h>
-#include <string.h>
-#include "ansidecl.h"
-
-#if defined(reg)
-#undef reg
-#endif
-#if defined(chtype)
-#undef chtype
-#endif
-
struct ui_file;
extern void strcat_to_buf (char *, int, const char *);
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;
/* tui-winsource.c */
extern void tui_update_all_exec_infos (void);
-#endif /* TUI_H */
+#endif
+
projects / binutils-gdb.git / commitdiff