#include "tui/tui-wingeneral.h"
#include "gdb_string.h"
-
-#ifdef HAVE_NCURSES_H
-#include <ncurses.h>
-#else
-#ifdef HAVE_CURSES_H
-#include <curses.h>
-#endif
-#endif
+#include "gdb_curses.h"
/****************************
** GLOBAL DECLARATIONS
/***************************
** Private data
****************************/
-static enum tui_layout_type _currentLayout = UNDEFINED_LAYOUT;
-static int _termHeight, _termWidth;
+static enum tui_layout_type current_layout = UNDEFINED_LAYOUT;
+static int term_height, term_width;
static struct tui_gen_win_info _locator;
-static struct tui_gen_win_info _execInfo[2];
-static struct tui_win_info * _srcWinList[2];
-static struct tui_list _sourceWindows = {(void **) _srcWinList, 0};
-static int _defaultTabLen = DEFAULT_TAB_LEN;
-static struct tui_win_info * _winWithFocus = (struct tui_win_info *) NULL;
-static struct tui_layout_def _layoutDef =
-{SRC_WIN, /* displayMode */
- FALSE, /* split */
- TUI_UNDEFINED_REGS, /* regsDisplayType */
- TUI_SFLOAT_REGS}; /* floatRegsDisplayType */
-static int _winResized = FALSE;
+static struct tui_gen_win_info exec_info[2];
+static struct tui_win_info * src_win_list[2];
+static struct tui_list source_windows = {(void **) src_win_list, 0};
+static int default_tab_len = DEFAULT_TAB_LEN;
+static struct tui_win_info * win_with_focus = (struct tui_win_info *) NULL;
+static struct tui_layout_def layout_def =
+{SRC_WIN, /* DISPLAY_MODE */
+ FALSE, /* SPLIT */
+ TUI_UNDEFINED_REGS, /* REGS_DISPLAY_TYPE */
+ TUI_SFLOAT_REGS}; /* FLOAT_REGS_DISPLAY_TYPE */
+static int win_resized = FALSE;
/*********************************
** Static function forward decls
**********************************/
-static void freeContent (tui_win_content, int, enum tui_win_type);
-static void freeContentElements (tui_win_content, int, enum tui_win_type);
+static void free_content (tui_win_content, int, enum tui_win_type);
+static void free_content_elements (tui_win_content, int, enum tui_win_type);
int
tui_win_resized (void)
{
- return _winResized;
+ return win_resized;
}
void
tui_set_win_resized_to (int resized)
{
- _winResized = resized;
+ win_resized = resized;
}
struct tui_layout_def *
tui_layout_def (void)
{
- return &_layoutDef;
+ return &layout_def;
}
struct tui_win_info *
tui_win_with_focus (void)
{
- return _winWithFocus;
+ return win_with_focus;
}
void
tui_set_win_with_focus (struct tui_win_info * win_info)
{
- _winWithFocus = win_info;
+ win_with_focus = win_info;
}
int
tui_default_tab_len (void)
{
- return _defaultTabLen;
+ return default_tab_len;
}
void
tui_set_default_tab_len (int len)
{
- _defaultTabLen = len;
+ default_tab_len = len;
}
-/*
- ** currentSourceWin()
- ** Accessor for the current source window. Usually there is only
- ** one source window (either source or disassembly), but both can
- ** be displayed at the same time.
- */
+/* Accessor for the current source window. Usually there is only one
+ source window (either source or disassembly), but both can be
+ displayed at the same time. */
struct tui_list *
tui_source_windows (void)
{
- return &_sourceWindows;
+ return &source_windows;
}
void
tui_clear_source_windows (void)
{
- _sourceWindows.list[0] = NULL;
- _sourceWindows.list[1] = NULL;
- _sourceWindows.count = 0;
+ source_windows.list[0] = NULL;
+ source_windows.list[1] = NULL;
+ source_windows.count = 0;
}
void
tui_add_to_source_windows (struct tui_win_info * win_info)
{
- if (_sourceWindows.count < 2)
- _sourceWindows.list[_sourceWindows.count++] = (void *) win_info;
+ if (source_windows.count < 2)
+ source_windows.list[source_windows.count++] = (void *) win_info;
}
break;
}
}
-
- return;
-} /* clearWinDetail */
+}
-/*
- ** sourceExecInfoPtr().
- ** Accessor for the source execution info ptr.
- */
+/* Accessor for the source execution info ptr. */
struct tui_gen_win_info *
tui_source_exec_info_win_ptr (void)
{
- return &_execInfo[0];
-} /* sourceExecInfoWinPtr */
+ return &exec_info[0];
+}
-/*
- ** disassemExecInfoPtr().
- ** Accessor for the disassem execution info ptr.
- */
+/* Accessor for the disassem execution info ptr. */
struct tui_gen_win_info *
tui_disassem_exec_info_win_ptr (void)
{
- return &_execInfo[1];
-} /* disassemExecInfoWinPtr */
+ return &exec_info[1];
+}
/* Accessor for the locator win info. Answers a pointer to the static
}
-/* Accessor for the termHeight. */
+/* Accessor for the term_height. */
int
tui_term_height (void)
{
- return _termHeight;
+ return term_height;
}
void
tui_set_term_height_to (int h)
{
- _termHeight = h;
+ term_height = h;
}
-/* Accessor for the termWidth. */
+/* Accessor for the term_width. */
int
tui_term_width (void)
{
- return _termWidth;
+ return term_width;
}
-/* Mutator for the termWidth. */
+/* Mutator for the term_width. */
void
tui_set_term_width_to (int w)
{
- _termWidth = w;
+ term_width = w;
}
enum tui_layout_type
tui_current_layout (void)
{
- return _currentLayout;
+ return current_layout;
}
/* Mutator for the current layout. */
void
-tui_set_current_layout_to (enum tui_layout_type newLayout)
+tui_set_current_layout_to (enum tui_layout_type new_layout)
{
- _currentLayout = newLayout;
+ current_layout = new_layout;
}
-/*
- ** setGenWinOrigin().
- ** Set the origin of the window
- */
+/* Set the origin of the window. */
void
-setGenWinOrigin (struct tui_gen_win_info * win_info, int x, int y)
+set_gen_win_origin (struct tui_gen_win_info * win_info, int x, int y)
{
win_info->origin.x = x;
win_info->origin.y = y;
-
- return;
-} /* setGenWinOrigin */
+}
/*****************************
/* Answer the next window in the list, cycling back to the top if
necessary. */
struct tui_win_info *
-tui_next_win (struct tui_win_info * curWin)
+tui_next_win (struct tui_win_info * cur_win)
{
- enum tui_win_type type = curWin->generic.type;
- struct tui_win_info * nextWin = (struct tui_win_info *) NULL;
+ enum tui_win_type type = cur_win->generic.type;
+ struct tui_win_info * next_win = (struct tui_win_info *) NULL;
- if (curWin->generic.type == CMD_WIN)
+ if (cur_win->generic.type == CMD_WIN)
type = SRC_WIN;
else
- type = curWin->generic.type + 1;
- while (type != curWin->generic.type && (nextWin == NULL))
+ type = cur_win->generic.type + 1;
+ while (type != cur_win->generic.type && (next_win == NULL))
{
if (tui_win_list[type] && tui_win_list[type]->generic.is_visible)
- nextWin = tui_win_list[type];
+ next_win = tui_win_list[type];
else
{
if (type == CMD_WIN)
}
}
- return nextWin;
-} /* tuiNextWin */
+ return next_win;
+}
/* Answer the prev window in the list, cycling back to the bottom if
necessary. */
struct tui_win_info *
-tui_prev_win (struct tui_win_info * curWin)
+tui_prev_win (struct tui_win_info * cur_win)
{
- enum tui_win_type type = curWin->generic.type;
+ enum tui_win_type type = cur_win->generic.type;
struct tui_win_info * prev = (struct tui_win_info *) NULL;
- if (curWin->generic.type == SRC_WIN)
+ if (cur_win->generic.type == SRC_WIN)
type = CMD_WIN;
else
- type = curWin->generic.type - 1;
- while (type != curWin->generic.type && (prev == NULL))
+ type = cur_win->generic.type - 1;
+ while (type != cur_win->generic.type && (prev == NULL))
{
if (tui_win_list[type]->generic.is_visible)
prev = tui_win_list[type];
{
if (tui_win_list[i] != 0)
{
- char *curName = tui_win_name (&tui_win_list[i]->generic);
- if (strlen (name) <= strlen (curName) &&
- strncmp (name, curName, strlen (name)) == 0)
+ char *cur_name = tui_win_name (&tui_win_list[i]->generic);
+ if (strlen (name) <= strlen (cur_name) &&
+ strncmp (name, cur_name, strlen (name)) == 0)
win_info = tui_win_list[i];
}
i++;
}
return win_info;
-} /* partialWinByName */
+}
-/*
- ** winName().
- ** Answer the name of the window
- */
+/* Answer the name of the window. */
char *
tui_win_name (struct tui_gen_win_info * win_info)
{
}
return name;
-} /* winName */
+}
void
tui_init_generic_part (win);
return win;
-} /* allocGenericWinInfo */
+}
-/*
- ** initGenericPart().
- */
void
tui_init_generic_part (struct tui_gen_win_info * win)
{
/*
- ** initContentElement().
+ ** init_content_element().
*/
void
-initContentElement (struct tui_win_element * element, enum tui_win_type type)
+init_content_element (struct tui_win_element * element, enum tui_win_type type)
{
element->highlight = FALSE;
switch (type)
default:
break;
}
- return;
-} /* initContentElement */
+}
-/*
- ** initWinInfo().
- */
void
-initWinInfo (struct tui_win_info * win_info)
+init_win_info (struct tui_win_info * win_info)
{
tui_init_generic_part (&win_info->generic);
win_info->can_highlight =
win_info->detail.opaque = NULL;
break;
}
-
- return;
-} /* initWinInfo */
+}
struct tui_win_info *
if ((win_info != NULL))
{
win_info->generic.type = type;
- initWinInfo (win_info);
+ init_win_info (win_info);
}
return win_info;
-} /* allocWinInfo */
+}
-/*
- ** allocContent().
- ** Allocates the content and elements in a block.
- */
+/* Allocates the content and elements in a block. */
tui_win_content
-tui_alloc_content (int numElements, enum tui_win_type type)
+tui_alloc_content (int num_elements, enum tui_win_type type)
{
tui_win_content content = (tui_win_content) NULL;
- char *elementBlockPtr = (char *) NULL;
+ char *element_block_ptr = (char *) NULL;
int i;
if ((content = (tui_win_content)
- xmalloc (sizeof (struct tui_win_element *) * numElements)) != (tui_win_content) NULL)
+ xmalloc (sizeof (struct tui_win_element *) * num_elements)) != (tui_win_content) NULL)
{ /*
** All windows, except the data window, can allocate the elements
** in a chunk. The data window cannot because items can be
*/
if (type != DATA_WIN)
{
- if ((elementBlockPtr = (char *)
- xmalloc (sizeof (struct tui_win_element) * numElements)) != (char *) NULL)
+ if ((element_block_ptr = (char *)
+ xmalloc (sizeof (struct tui_win_element) * num_elements)) != (char *) NULL)
{
- for (i = 0; i < numElements; i++)
+ for (i = 0; i < num_elements; i++)
{
- content[i] = (struct tui_win_element *) elementBlockPtr;
- initContentElement (content[i], type);
- elementBlockPtr += sizeof (struct tui_win_element);
+ content[i] = (struct tui_win_element *) element_block_ptr;
+ init_content_element (content[i], type);
+ element_block_ptr += sizeof (struct tui_win_element);
}
}
else
}
return content;
-} /* allocContent */
+}
/* Adds the input number of elements to the windows's content. If no
- content has been allocated yet, allocContent() is called to do
+ content has been allocated yet, alloc_content() is called to do
this. The index of the first element added is returned, unless
there is a memory allocation error, in which case, (-1) is
returned. */
int
-tui_add_content_elements (struct tui_gen_win_info * win_info, int numElements)
+tui_add_content_elements (struct tui_gen_win_info * win_info, int num_elements)
{
- struct tui_win_element * elementPtr;
- int i, indexStart;
+ struct tui_win_element * element_ptr;
+ int i, index_start;
if (win_info->content == NULL)
{
- win_info->content = (void **) tui_alloc_content (numElements, win_info->type);
- indexStart = 0;
+ win_info->content = (void **) tui_alloc_content (num_elements, win_info->type);
+ index_start = 0;
}
else
- indexStart = win_info->content_size;
+ index_start = win_info->content_size;
if (win_info->content != NULL)
{
- for (i = indexStart; (i < numElements + indexStart); i++)
+ for (i = index_start; (i < num_elements + index_start); i++)
{
- if ((elementPtr = (struct tui_win_element *)
+ if ((element_ptr = (struct tui_win_element *)
xmalloc (sizeof (struct tui_win_element))) != (struct tui_win_element *) NULL)
{
- win_info->content[i] = (void *) elementPtr;
- initContentElement (elementPtr, win_info->type);
+ win_info->content[i] = (void *) element_ptr;
+ init_content_element (element_ptr, win_info->type);
win_info->content_size++;
}
else /* things must be really hosed now! We ran out of memory!? */
}
}
- return indexStart;
-} /* addContentElements */
+ return index_start;
+}
/* Delete all curses windows associated with win_info, leaving everything
else intact. */
void
-tuiDelWindow (struct tui_win_info * win_info)
+tui_del_window (struct tui_win_info * win_info)
{
- struct tui_gen_win_info * genericWin;
+ struct tui_gen_win_info * generic_win;
switch (win_info->generic.type)
{
case SRC_WIN:
case DISASSEM_WIN:
- genericWin = tui_locator_win_info_ptr ();
- if (genericWin != (struct tui_gen_win_info *) NULL)
+ generic_win = tui_locator_win_info_ptr ();
+ if (generic_win != (struct tui_gen_win_info *) NULL)
{
- tui_delete_win (genericWin->handle);
- genericWin->handle = (WINDOW *) NULL;
- genericWin->is_visible = FALSE;
+ tui_delete_win (generic_win->handle);
+ generic_win->handle = (WINDOW *) NULL;
+ generic_win->is_visible = FALSE;
}
if (win_info->detail.source_info.filename)
{
xfree (win_info->detail.source_info.filename);
win_info->detail.source_info.filename = 0;
}
- genericWin = win_info->detail.source_info.execution_info;
- if (genericWin != (struct tui_gen_win_info *) NULL)
+ generic_win = win_info->detail.source_info.execution_info;
+ if (generic_win != (struct tui_gen_win_info *) NULL)
{
- tui_delete_win (genericWin->handle);
- genericWin->handle = (WINDOW *) NULL;
- genericWin->is_visible = FALSE;
+ tui_delete_win (generic_win->handle);
+ generic_win->handle = (WINDOW *) NULL;
+ generic_win->is_visible = FALSE;
}
break;
case DATA_WIN:
void
tui_free_window (struct tui_win_info * win_info)
{
- struct tui_gen_win_info * genericWin;
+ struct tui_gen_win_info * generic_win;
switch (win_info->generic.type)
{
case SRC_WIN:
case DISASSEM_WIN:
- genericWin = tui_locator_win_info_ptr ();
- if (genericWin != (struct tui_gen_win_info *) NULL)
+ generic_win = tui_locator_win_info_ptr ();
+ if (generic_win != (struct tui_gen_win_info *) NULL)
{
- tui_delete_win (genericWin->handle);
- genericWin->handle = (WINDOW *) NULL;
+ tui_delete_win (generic_win->handle);
+ generic_win->handle = (WINDOW *) NULL;
}
- tui_free_win_content (genericWin);
+ tui_free_win_content (generic_win);
if (win_info->detail.source_info.filename)
{
xfree (win_info->detail.source_info.filename);
win_info->detail.source_info.filename = 0;
}
- genericWin = win_info->detail.source_info.execution_info;
- if (genericWin != (struct tui_gen_win_info *) NULL)
+ generic_win = win_info->detail.source_info.execution_info;
+ if (generic_win != (struct tui_gen_win_info *) NULL)
{
- tui_delete_win (genericWin->handle);
- genericWin->handle = (WINDOW *) NULL;
- tui_free_win_content (genericWin);
+ tui_delete_win (generic_win->handle);
+ generic_win->handle = (WINDOW *) NULL;
+ tui_free_win_content (generic_win);
}
break;
case DATA_WIN:
{
if (win_info->content != NULL)
{
- freeContent ((tui_win_content) win_info->content,
+ free_content ((tui_win_content) win_info->content,
win_info->content_size,
win_info->type);
win_info->content = NULL;
}
win_info->content_size = 0;
-
- return;
-} /* freeWinContent */
+}
void
-tui_del_data_windows (tui_win_content content, int contentSize)
+tui_del_data_windows (tui_win_content content, int content_size)
{
int i;
** Remember that data window content elements are of type struct tui_gen_win_info *,
** each of which whose single element is a data element.
*/
- for (i = 0; i < contentSize; i++)
+ for (i = 0; i < content_size; i++)
{
- struct tui_gen_win_info * genericWin = &content[i]->which_element.data_window;
+ struct tui_gen_win_info * generic_win = &content[i]->which_element.data_window;
- if (genericWin != (struct tui_gen_win_info *) NULL)
+ if (generic_win != (struct tui_gen_win_info *) NULL)
{
- tui_delete_win (genericWin->handle);
- genericWin->handle = (WINDOW *) NULL;
- genericWin->is_visible = FALSE;
+ tui_delete_win (generic_win->handle);
+ generic_win->handle = (WINDOW *) NULL;
+ generic_win->is_visible = FALSE;
}
}
}
void
-tui_free_data_content (tui_win_content content, int contentSize)
+tui_free_data_content (tui_win_content content, int content_size)
{
int i;
** Remember that data window content elements are of type struct tui_gen_win_info *,
** each of which whose single element is a data element.
*/
- for (i = 0; i < contentSize; i++)
+ for (i = 0; i < content_size; i++)
{
- struct tui_gen_win_info * genericWin = &content[i]->which_element.data_window;
+ struct tui_gen_win_info * generic_win = &content[i]->which_element.data_window;
- if (genericWin != (struct tui_gen_win_info *) NULL)
+ if (generic_win != (struct tui_gen_win_info *) NULL)
{
- tui_delete_win (genericWin->handle);
- genericWin->handle = (WINDOW *) NULL;
- tui_free_win_content (genericWin);
+ tui_delete_win (generic_win->handle);
+ generic_win->handle = (WINDOW *) NULL;
+ tui_free_win_content (generic_win);
}
}
- freeContent (content,
- contentSize,
+ free_content (content,
+ content_size,
DATA_WIN);
-
- return;
-} /* freeDataContent */
+}
/**********************************
**********************************/
-/*
- ** freeContent().
- */
static void
-freeContent (tui_win_content content, int contentSize, enum tui_win_type winType)
+free_content (tui_win_content content, int content_size, enum tui_win_type win_type)
{
if (content != (tui_win_content) NULL)
{
- freeContentElements (content, contentSize, winType);
+ free_content_elements (content, content_size, win_type);
xfree (content);
}
-
- return;
-} /* freeContent */
+}
/*
- ** freeContentElements().
+ ** free_content_elements().
*/
static void
-freeContentElements (tui_win_content content, int contentSize, enum tui_win_type type)
+free_content_elements (tui_win_content content, int content_size, enum tui_win_type type)
{
if (content != (tui_win_content) NULL)
{
}
else
{
- for (i = 0; i < contentSize; i++)
+ for (i = 0; i < content_size; i++)
{
struct tui_win_element * element;
if (type != DATA_WIN && type != DATA_ITEM_WIN)
xfree (content[0]); /* free the element block */
}
-
- return;
-} /* freeContentElements */
+}
projects / deliverable / binutils-gdb.git / blobdiff