+2004-02-07 Andrew Cagney <cagney@redhat.com>
+
+ * tui/tui-command.c: Change variable and function names to lower
+ case.
+ * tui/tui-data.c, tui/tui-disasm.c: Ditto.
+ * tui/tui-hooks.c, tui/tui-io.c, tui/tui-layout.c: Ditto.
+ * tui/tui-regs.c, 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 Elena Zannoni <ezannoni@redhat.com>
* buildsym.c (free_pending_blocks, finish_block)
return ch;
else
{
- unsigned int c = 0, chCopy = ch;
+ unsigned int c = 0, ch_copy = ch;
register int i;
char *term;
term[i] = toupper (term[i]);
if ((strcmp (term, "XTERM") == 0) && key_is_start_sequence (ch))
{
- unsigned int pageCh = 0, tmpChar;
+ unsigned int page_ch = 0;
+ unsigned int tmp_char;
- tmpChar = 0;
- while (!key_is_end_sequence (tmpChar))
+ tmp_char = 0;
+ while (!key_is_end_sequence (tmp_char))
{
- tmpChar = (int) wgetch (w);
- if (tmpChar == ERR)
+ tmp_char = (int) wgetch (w);
+ if (tmp_char == ERR)
{
return ch;
}
- if (!tmpChar)
+ if (!tmp_char)
break;
- if (tmpChar == 53)
- pageCh = KEY_PPAGE;
- else if (tmpChar == 54)
- pageCh = KEY_NPAGE;
+ if (tmp_char == 53)
+ page_ch = KEY_PPAGE;
+ else if (tmp_char == 54)
+ page_ch = KEY_NPAGE;
else
{
return 0;
}
}
- chCopy = pageCh;
+ ch_copy = page_ch;
}
- switch (chCopy)
+ switch (ch_copy)
{
case KEY_NPAGE:
tui_scroll_forward (win_info, 0);
tui_refresh_all_win ();
break;
default:
- c = chCopy;
+ c = ch_copy;
break;
}
return c;
/***************************
** 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 */
+}
static CORE_ADDR
tui_find_disassembly_address (CORE_ADDR pc, int from)
{
- register CORE_ADDR newLow;
- int maxLines;
+ register CORE_ADDR new_low;
+ int max_lines;
int i;
struct tui_asm_line* lines;
- maxLines = (from > 0) ? from : - from;
- if (maxLines <= 1)
+ max_lines = (from > 0) ? from : - from;
+ if (max_lines <= 1)
return pc;
lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line)
- * maxLines);
- memset (lines, 0, sizeof (struct tui_asm_line) * maxLines);
+ * max_lines);
+ memset (lines, 0, sizeof (struct tui_asm_line) * max_lines);
- newLow = pc;
+ new_low = pc;
if (from > 0)
{
- tui_disassemble (lines, pc, maxLines);
- newLow = lines[maxLines - 1].addr;
+ tui_disassemble (lines, pc, max_lines);
+ new_low = lines[max_lines - 1].addr;
}
else
{
/* Find backward an address which is a symbol
and for which disassembling from that address will fill
completely the window. */
- pos = maxLines - 1;
+ pos = max_lines - 1;
do {
- newLow -= 1 * maxLines;
- msymbol = lookup_minimal_symbol_by_pc_section (newLow, 0);
+ new_low -= 1 * max_lines;
+ msymbol = lookup_minimal_symbol_by_pc_section (new_low, 0);
if (msymbol)
- newLow = SYMBOL_VALUE_ADDRESS (msymbol);
+ new_low = SYMBOL_VALUE_ADDRESS (msymbol);
else
- newLow += 1 * maxLines;
+ new_low += 1 * max_lines;
- tui_disassemble (lines, newLow, maxLines);
+ tui_disassemble (lines, new_low, max_lines);
last_addr = lines[pos].addr;
} while (last_addr > pc && msymbol);
CORE_ADDR next_addr;
pos++;
- if (pos >= maxLines)
+ if (pos >= max_lines)
pos = 0;
next_addr = tui_disassemble (&lines[pos], last_addr, 1);
last_addr = next_addr;
} while (last_addr <= pc);
pos++;
- if (pos >= maxLines)
+ if (pos >= max_lines)
pos = 0;
- newLow = lines[pos].addr;
+ new_low = lines[pos].addr;
}
- for (i = 0; i < maxLines; i++)
+ for (i = 0; i < max_lines; i++)
{
xfree (lines[i].addr_string);
xfree (lines[i].insn);
}
- return newLow;
+ return new_low;
}
/* Function to set the disassembly window's content. */
enum tui_status ret = TUI_FAILURE;
register int i;
int offset = TUI_DISASM_WIN->detail.source_info.horizontal_offset;
- register int lineWidth, maxLines;
+ register int line_width, max_lines;
CORE_ADDR cur_pc;
struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
int tab_len = tui_default_tab_len ();
cur_pc = (CORE_ADDR)
(((struct tui_win_element *) locator->content[0])->which_element.locator.addr);
- maxLines = TUI_DISASM_WIN->generic.height - 2; /* account for hilite */
+ max_lines = TUI_DISASM_WIN->generic.height - 2; /* account for hilite */
/* Get temporary table that will hold all strings (addr & insn). */
lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line)
- * maxLines);
- memset (lines, 0, sizeof (struct tui_asm_line) * maxLines);
+ * max_lines);
+ memset (lines, 0, sizeof (struct tui_asm_line) * max_lines);
- lineWidth = TUI_DISASM_WIN->generic.width - 1;
+ line_width = TUI_DISASM_WIN->generic.width - 1;
- tui_disassemble (lines, pc, maxLines);
+ tui_disassemble (lines, pc, max_lines);
/* See what is the maximum length of an address and of a line. */
addr_size = 0;
max_size = 0;
- for (i = 0; i < maxLines; i++)
+ for (i = 0; i < max_lines; i++)
{
size_t len = strlen (lines[i].addr_string);
if (len > addr_size)
insn_pos = (1 + (addr_size / tab_len)) * tab_len;
/* Now construct each line */
- for (i = 0; i < maxLines; i++)
+ for (i = 0; i < max_lines; i++)
{
struct tui_win_element * element;
struct tui_source_element* src;
- int curLen;
+ int cur_len;
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);
+ cur_len = strlen (line);
/* Add spaces to make the instructions start on the same column */
- while (curLen < insn_pos)
+ while (cur_len < insn_pos)
{
strcat (line, " ");
- curLen++;
+ cur_len++;
}
strcat (line, lines[i].insn);
/* Function to display the disassembly window with disassembled code. */
void
-tui_show_disassem (CORE_ADDR startAddr)
+tui_show_disassem (CORE_ADDR start_addr)
{
- struct symtab *s = find_pc_symtab (startAddr);
- struct tui_win_info * winWithFocus = tui_win_with_focus ();
+ struct symtab *s = find_pc_symtab (start_addr);
+ struct tui_win_info * win_with_focus = tui_win_with_focus ();
union tui_line_or_address val;
- val.addr = startAddr;
+ val.addr = start_addr;
tui_add_win_to_layout (DISASSEM_WIN);
tui_update_source_window (TUI_DISASM_WIN, s, val, FALSE);
/*
** if the focus was in the src win, put it in the asm win, if the
** source view isn't split
*/
- if (tui_current_layout () != SRC_DISASSEM_COMMAND && winWithFocus == TUI_SRC_WIN)
+ if (tui_current_layout () != SRC_DISASSEM_COMMAND && win_with_focus == TUI_SRC_WIN)
tui_set_win_focus_to (TUI_DISASM_WIN);
return;
/* Function to display the disassembly window. */
void
-tui_show_disassem_and_update_source (CORE_ADDR startAddr)
+tui_show_disassem_and_update_source (CORE_ADDR start_addr)
{
struct symtab_and_line sal;
- tui_show_disassem (startAddr);
+ tui_show_disassem (start_addr);
if (tui_current_layout () == SRC_DISASSEM_COMMAND)
{
union tui_line_or_address val;
** Update what is in the source window if it is displayed too,
** note that it follows what is in the disassembly window and visa-versa
*/
- sal = find_pc_line (startAddr, 0);
+ sal = find_pc_line (start_addr, 0);
val.line_no = sal.line;
tui_update_source_window (TUI_SRC_WIN, sal.symtab, val, TRUE);
if (sal.symtab)
/* Scroll the disassembly forward or backward vertically. */
void
-tui_vertical_disassem_scroll (enum tui_scroll_direction scrollDirection,
- int numToScroll)
+tui_vertical_disassem_scroll (enum tui_scroll_direction scroll_direction,
+ int num_to_scroll)
{
if (TUI_DISASM_WIN->generic.content != NULL)
{
tui_win_content content;
struct symtab *s;
union tui_line_or_address val;
- int maxLines, dir;
+ int max_lines, dir;
struct symtab_and_line cursal = get_current_source_symtab_and_line ();
content = (tui_win_content) TUI_DISASM_WIN->generic.content;
s = cursal.symtab;
/* account for hilite */
- maxLines = TUI_DISASM_WIN->generic.height - 2;
+ max_lines = TUI_DISASM_WIN->generic.height - 2;
pc = content[0]->which_element.source.line_or_addr.addr;
- dir = (scrollDirection == FORWARD_SCROLL) ? maxLines : - maxLines;
+ dir = (scroll_direction == FORWARD_SCROLL) ? max_lines : - max_lines;
val.addr = tui_find_disassembly_address (pc, dir);
tui_update_source_window_as_is (TUI_DISASM_WIN, s, val, FALSE);
{
tui_refreshing_registers = 1;
#if 0
- tuiCheckDataValues (fi);
+ tui_check_data_values (fi);
#endif
tui_refreshing_registers = 0;
}
This may be the main gdb prompt or a secondary prompt. */
static char *tui_rl_saved_prompt;
-static unsigned int _tuiHandleResizeDuringIO (unsigned int);
+static unsigned int tui_handle_resize_during_io (unsigned int);
static void
tui_putc (char c)
#endif
ch = wgetch (w);
- ch = _tuiHandleResizeDuringIO (ch);
+ ch = tui_handle_resize_during_io (ch);
/* The \n must be echoed because it will not be printed by readline. */
if (ch == '\n')
if (ch == '\n' || ch == '\r' || ch == '\f')
TUI_CMD_WIN->detail.command_info.curch = 0;
-#if 0
- else
- tuiIncrCommandCharCountBy (1);
-#endif
if (ch == KEY_BACKSPACE)
return '\b';
/* Cleanup when a resize has occured.
Returns the character that must be processed. */
static unsigned int
-_tuiHandleResizeDuringIO (unsigned int originalCh)
+tui_handle_resize_during_io (unsigned int original_ch)
{
if (tui_win_resized ())
{
return '\n';
}
else
- return originalCh;
+ return original_ch;
}
/*******************************
** Static Local Decls
********************************/
-static void showLayout (enum tui_layout_type);
-static void _initGenWinInfo (struct tui_gen_win_info *, enum tui_win_type, int, int, int, int);
-static void _initAndMakeWin (void **, enum tui_win_type, int, int, int, int, int);
-static void _showSourceOrDisassemAndCommand (enum tui_layout_type);
-static void _makeSourceOrDisassemWindow (struct tui_win_info * *, enum tui_win_type, int, int);
-static void _makeCommandWindow (struct tui_win_info * *, int, int);
-static void _makeSourceWindow (struct tui_win_info * *, int, int);
-static void _makeDisassemWindow (struct tui_win_info * *, int, int);
-static void _makeDataWindow (struct tui_win_info * *, int, int);
-static void _showSourceCommand (void);
-static void _showDisassemCommand (void);
-static void _showSourceDisassemCommand (void);
-static void _showData (enum tui_layout_type);
-static enum tui_layout_type _nextLayout (void);
-static enum tui_layout_type _prevLayout (void);
-static void _tuiLayout_command (char *, int);
-static void _tuiToggleLayout_command (char *, int);
-static void _tuiToggleSplitLayout_command (char *, int);
-static CORE_ADDR _extractDisplayStartAddr (void);
-static void _tuiHandleXDBLayout (struct tui_layout_def *);
+static void show_layout (enum tui_layout_type);
+static void init_gen_win_info (struct tui_gen_win_info *, enum tui_win_type, int, int, int, int);
+static void init_and_make_win (void **, enum tui_win_type, int, int, int, int, int);
+static void show_source_or_disasm_and_command (enum tui_layout_type);
+static void make_source_or_disasm_window (struct tui_win_info * *, enum tui_win_type, int, int);
+static void make_command_window (struct tui_win_info * *, int, int);
+static void make_source_window (struct tui_win_info * *, int, int);
+static void make_disasm_window (struct tui_win_info * *, int, int);
+static void make_data_window (struct tui_win_info * *, int, int);
+static void show_source_command (void);
+static void show_disasm_command (void);
+static void show_source_disasm_command (void);
+static void show_data (enum tui_layout_type);
+static enum tui_layout_type next_layout (void);
+static enum tui_layout_type prev_layout (void);
+static void tui_layout_command (char *, int);
+static void tui_toggle_layout_command (char *, int);
+static void tui_toggle_split_layout_command (char *, int);
+static CORE_ADDR extract_display_start_addr (void);
+static void tui_handle_xdb_layout (struct tui_layout_def *);
/***************************************
/* Show the screen layout defined. */
static void
-showLayout (enum tui_layout_type layout)
+show_layout (enum tui_layout_type layout)
{
- enum tui_layout_type curLayout = tui_current_layout ();
+ enum tui_layout_type cur_layout = tui_current_layout ();
- if (layout != curLayout)
+ if (layout != cur_layout)
{
/*
** Since the new layout may cause changes in window size, we
tui_clear_source_windows ();
if (layout == SRC_DATA_COMMAND || layout == DISASSEM_DATA_COMMAND)
{
- _showData (layout);
+ show_data (layout);
tui_refresh_all (tui_win_list);
}
else
{
/* Now show the new layout */
case SRC_COMMAND:
- _showSourceCommand ();
+ show_source_command ();
tui_add_to_source_windows (TUI_SRC_WIN);
break;
case DISASSEM_COMMAND:
- _showDisassemCommand ();
+ show_disasm_command ();
tui_add_to_source_windows (TUI_DISASM_WIN);
break;
case SRC_DISASSEM_COMMAND:
- _showSourceDisassemCommand ();
+ show_source_disasm_command ();
tui_add_to_source_windows (TUI_SRC_WIN);
tui_add_to_source_windows (TUI_DISASM_WIN);
break;
UNDEFINED_LAYOUT, then the data window is populated according to
regs_display_type. */
enum tui_status
-tui_set_layout (enum tui_layout_type layoutType,
+tui_set_layout (enum tui_layout_type layout_type,
enum tui_register_display_type regs_display_type)
{
enum tui_status status = TUI_SUCCESS;
- if (layoutType != UNDEFINED_LAYOUT || regs_display_type != TUI_UNDEFINED_REGS)
+ if (layout_type != UNDEFINED_LAYOUT || regs_display_type != TUI_UNDEFINED_REGS)
{
- enum tui_layout_type curLayout = tui_current_layout (), newLayout = UNDEFINED_LAYOUT;
- int regsPopulate = FALSE;
- CORE_ADDR addr = _extractDisplayStartAddr ();
- struct tui_win_info * newWinWithFocus = (struct tui_win_info *) NULL;
- struct tui_win_info * winWithFocus = tui_win_with_focus ();
- struct tui_layout_def * layoutDef = tui_layout_def ();
+ enum tui_layout_type cur_layout = tui_current_layout (), new_layout = UNDEFINED_LAYOUT;
+ int regs_populate = FALSE;
+ CORE_ADDR addr = extract_display_start_addr ();
+ struct tui_win_info * new_win_with_focus = (struct tui_win_info *) NULL;
+ struct tui_win_info * win_with_focus = tui_win_with_focus ();
+ struct tui_layout_def * layout_def = tui_layout_def ();
- if (layoutType == UNDEFINED_LAYOUT &&
+ if (layout_type == UNDEFINED_LAYOUT &&
regs_display_type != TUI_UNDEFINED_REGS)
{
- if (curLayout == SRC_DISASSEM_COMMAND)
- newLayout = DISASSEM_DATA_COMMAND;
- else if (curLayout == SRC_COMMAND || curLayout == SRC_DATA_COMMAND)
- newLayout = SRC_DATA_COMMAND;
- else if (curLayout == DISASSEM_COMMAND ||
- curLayout == DISASSEM_DATA_COMMAND)
- newLayout = DISASSEM_DATA_COMMAND;
+ if (cur_layout == SRC_DISASSEM_COMMAND)
+ new_layout = DISASSEM_DATA_COMMAND;
+ else if (cur_layout == SRC_COMMAND || cur_layout == SRC_DATA_COMMAND)
+ new_layout = SRC_DATA_COMMAND;
+ else if (cur_layout == DISASSEM_COMMAND ||
+ cur_layout == DISASSEM_DATA_COMMAND)
+ new_layout = DISASSEM_DATA_COMMAND;
}
else
- newLayout = layoutType;
+ new_layout = layout_type;
- regsPopulate = (newLayout == SRC_DATA_COMMAND ||
- newLayout == DISASSEM_DATA_COMMAND ||
+ regs_populate = (new_layout == SRC_DATA_COMMAND ||
+ new_layout == DISASSEM_DATA_COMMAND ||
regs_display_type != TUI_UNDEFINED_REGS);
- if (newLayout != curLayout || regs_display_type != TUI_UNDEFINED_REGS)
+ if (new_layout != cur_layout || regs_display_type != TUI_UNDEFINED_REGS)
{
- if (newLayout != curLayout)
+ if (new_layout != cur_layout)
{
- showLayout (newLayout);
+ show_layout (new_layout);
/*
** Now determine where focus should be
*/
- if (winWithFocus != TUI_CMD_WIN)
+ if (win_with_focus != TUI_CMD_WIN)
{
- switch (newLayout)
+ switch (new_layout)
{
case SRC_COMMAND:
tui_set_win_focus_to (TUI_SRC_WIN);
- layoutDef->display_mode = SRC_WIN;
- layoutDef->split = FALSE;
+ layout_def->display_mode = SRC_WIN;
+ layout_def->split = FALSE;
break;
case DISASSEM_COMMAND:
/* the previous layout was not showing
*/
addr = tui_get_begin_asm_address ();
tui_set_win_focus_to (TUI_DISASM_WIN);
- layoutDef->display_mode = DISASSEM_WIN;
- layoutDef->split = FALSE;
+ layout_def->display_mode = DISASSEM_WIN;
+ layout_def->split = FALSE;
break;
case SRC_DISASSEM_COMMAND:
/* the previous layout was not showing
** We still want to show the assembly though!
*/
addr = tui_get_begin_asm_address ();
- if (winWithFocus == TUI_SRC_WIN)
+ if (win_with_focus == TUI_SRC_WIN)
tui_set_win_focus_to (TUI_SRC_WIN);
else
tui_set_win_focus_to (TUI_DISASM_WIN);
- layoutDef->split = TRUE;
+ layout_def->split = TRUE;
break;
case SRC_DATA_COMMAND:
- if (winWithFocus != TUI_DATA_WIN)
+ if (win_with_focus != TUI_DATA_WIN)
tui_set_win_focus_to (TUI_SRC_WIN);
else
tui_set_win_focus_to (TUI_DATA_WIN);
- layoutDef->display_mode = SRC_WIN;
- layoutDef->split = FALSE;
+ layout_def->display_mode = SRC_WIN;
+ layout_def->split = FALSE;
break;
case DISASSEM_DATA_COMMAND:
/* the previous layout was not showing
** We still want to show the assembly though!
*/
addr = tui_get_begin_asm_address ();
- if (winWithFocus != TUI_DATA_WIN)
+ if (win_with_focus != TUI_DATA_WIN)
tui_set_win_focus_to (TUI_DISASM_WIN);
else
tui_set_win_focus_to (TUI_DATA_WIN);
- layoutDef->display_mode = DISASSEM_WIN;
- layoutDef->split = FALSE;
+ layout_def->display_mode = DISASSEM_WIN;
+ layout_def->split = FALSE;
break;
default:
break;
}
}
- if (newWinWithFocus != (struct tui_win_info *) NULL)
- tui_set_win_focus_to (newWinWithFocus);
+ if (new_win_with_focus != (struct tui_win_info *) NULL)
+ tui_set_win_focus_to (new_win_with_focus);
/*
** Now update the window content
*/
- if (!regsPopulate &&
- (newLayout == SRC_DATA_COMMAND ||
- newLayout == DISASSEM_DATA_COMMAND))
+ if (!regs_populate &&
+ (new_layout == SRC_DATA_COMMAND ||
+ new_layout == DISASSEM_DATA_COMMAND))
tui_display_all_data ();
tui_update_source_windows_with_addr (addr);
}
- if (regsPopulate)
+ if (regs_populate)
{
- layoutDef->regs_display_type =
+ layout_def->regs_display_type =
(regs_display_type == TUI_UNDEFINED_REGS ?
TUI_GENERAL_REGS : regs_display_type);
- tui_show_registers (layoutDef->regs_display_type);
+ tui_show_registers (layout_def->regs_display_type);
}
}
}
void
tui_add_win_to_layout (enum tui_win_type type)
{
- enum tui_layout_type curLayout = tui_current_layout ();
+ enum tui_layout_type cur_layout = tui_current_layout ();
switch (type)
{
case SRC_WIN:
- if (curLayout != SRC_COMMAND &&
- curLayout != SRC_DISASSEM_COMMAND &&
- curLayout != SRC_DATA_COMMAND)
+ if (cur_layout != SRC_COMMAND &&
+ cur_layout != SRC_DISASSEM_COMMAND &&
+ cur_layout != SRC_DATA_COMMAND)
{
tui_clear_source_windows_detail ();
- if (curLayout == DISASSEM_DATA_COMMAND)
- showLayout (SRC_DATA_COMMAND);
+ if (cur_layout == DISASSEM_DATA_COMMAND)
+ show_layout (SRC_DATA_COMMAND);
else
- showLayout (SRC_COMMAND);
+ show_layout (SRC_COMMAND);
}
break;
case DISASSEM_WIN:
- if (curLayout != DISASSEM_COMMAND &&
- curLayout != SRC_DISASSEM_COMMAND &&
- curLayout != DISASSEM_DATA_COMMAND)
+ if (cur_layout != DISASSEM_COMMAND &&
+ cur_layout != SRC_DISASSEM_COMMAND &&
+ cur_layout != DISASSEM_DATA_COMMAND)
{
tui_clear_source_windows_detail ();
- if (curLayout == SRC_DATA_COMMAND)
- showLayout (DISASSEM_DATA_COMMAND);
+ if (cur_layout == SRC_DATA_COMMAND)
+ show_layout (DISASSEM_DATA_COMMAND);
else
- showLayout (DISASSEM_COMMAND);
+ show_layout (DISASSEM_COMMAND);
}
break;
case DATA_WIN:
- if (curLayout != SRC_DATA_COMMAND &&
- curLayout != DISASSEM_DATA_COMMAND)
+ if (cur_layout != SRC_DATA_COMMAND &&
+ cur_layout != DISASSEM_DATA_COMMAND)
{
- if (curLayout == DISASSEM_COMMAND)
- showLayout (DISASSEM_DATA_COMMAND);
+ if (cur_layout == DISASSEM_COMMAND)
+ show_layout (DISASSEM_DATA_COMMAND);
else
- showLayout (SRC_DATA_COMMAND);
+ show_layout (SRC_DATA_COMMAND);
}
break;
default:
break;
}
-
- return;
-} /* tuiAddWinToLayout */
+}
-/*
- ** tuiDefaultWinHeight().
- ** Answer the height of a window. If it hasn't been created yet,
- ** answer what the height of a window would be based upon its
- ** type and the layout.
- */
+/* Answer the height of a window. If it hasn't been created yet,
+ answer what the height of a window would be based upon its type and
+ the layout. */
int
-tuiDefaultWinHeight (enum tui_win_type type, enum tui_layout_type layout)
+tui_default_win_height (enum tui_win_type type, enum tui_layout_type layout)
{
int h;
}
return h;
-} /* tuiDefaultWinHeight */
+}
/* Answer the height of a window. If it hasn't been created yet,
{
int h;
- h = tuiDefaultWinHeight (type, layout);
+ h = tui_default_win_height (type, layout);
if (tui_win_list[type] == TUI_CMD_WIN)
h -= 1;
h -= 2;
return h;
-} /* tuiDefaultWinViewportHeight */
+}
-/*
- ** _initialize_tuiLayout().
- ** Function to initialize gdb commands, for tui window layout
- ** manipulation.
- */
+/* Function to initialize gdb commands, for tui window layout
+ manipulation. */
void
-_initialize_tuiLayout (void)
+_initialize_tui_layout (void)
{
- add_com ("layout", class_tui, _tuiLayout_command,
+ add_com ("layout", class_tui, tui_layout_command,
"Change the layout of windows.\n\
Usage: layout prev | next | <layout_name> \n\
Layout names are:\n\
the window that has current logical focus.\n");
if (xdb_commands)
{
- add_com ("td", class_tui, _tuiToggleLayout_command,
+ add_com ("td", class_tui, tui_toggle_layout_command,
"Toggle between Source/Command and Disassembly/Command layouts.\n");
- add_com ("ts", class_tui, _tuiToggleSplitLayout_command,
+ add_com ("ts", class_tui, tui_toggle_split_layout_command,
"Toggle between Source/Command or Disassembly/Command and \n\
Source/Disassembly/Command layouts.\n");
}
**************************/
-/*
- ** _tuiSetLayoutTo()
- ** Function to set the layout to SRC, ASM, SPLIT, NEXT, PREV, DATA, REGS,
- ** $REGS, $GREGS, $FREGS, $SREGS.
- */
+/* Function to set the layout to SRC, ASM, SPLIT, NEXT, PREV, DATA,
+ REGS, $REGS, $GREGS, $FREGS, $SREGS. */
enum tui_status
-tui_set_layout_for_display_command (const char *layoutName)
+tui_set_layout_for_display_command (const char *layout_name)
{
enum tui_status status = TUI_SUCCESS;
- if (layoutName != (char *) NULL)
+ if (layout_name != (char *) NULL)
{
register int i;
- register char *bufPtr;
- enum tui_layout_type newLayout = UNDEFINED_LAYOUT;
- enum tui_register_display_type dpyType = TUI_UNDEFINED_REGS;
- enum tui_layout_type curLayout = tui_current_layout ();
+ register char *buf_ptr;
+ enum tui_layout_type new_layout = UNDEFINED_LAYOUT;
+ enum tui_register_display_type dpy_type = TUI_UNDEFINED_REGS;
+ enum tui_layout_type cur_layout = tui_current_layout ();
- bufPtr = (char *) xstrdup (layoutName);
- for (i = 0; (i < strlen (layoutName)); i++)
- bufPtr[i] = toupper (bufPtr[i]);
+ buf_ptr = (char *) xstrdup (layout_name);
+ for (i = 0; (i < strlen (layout_name)); i++)
+ buf_ptr[i] = toupper (buf_ptr[i]);
/* First check for ambiguous input */
- if (strlen (bufPtr) <= 1 && (*bufPtr == 'S' || *bufPtr == '$'))
+ if (strlen (buf_ptr) <= 1 && (*buf_ptr == 'S' || *buf_ptr == '$'))
{
warning ("Ambiguous command input.\n");
status = TUI_FAILURE;
}
else
{
- if (subset_compare (bufPtr, "SRC"))
- newLayout = SRC_COMMAND;
- else if (subset_compare (bufPtr, "ASM"))
- newLayout = DISASSEM_COMMAND;
- else if (subset_compare (bufPtr, "SPLIT"))
- newLayout = SRC_DISASSEM_COMMAND;
- else if (subset_compare (bufPtr, "REGS") ||
- subset_compare (bufPtr, TUI_GENERAL_SPECIAL_REGS_NAME) ||
- subset_compare (bufPtr, TUI_GENERAL_REGS_NAME) ||
- subset_compare (bufPtr, TUI_FLOAT_REGS_NAME) ||
- subset_compare (bufPtr, TUI_SPECIAL_REGS_NAME))
+ if (subset_compare (buf_ptr, "SRC"))
+ new_layout = SRC_COMMAND;
+ else if (subset_compare (buf_ptr, "ASM"))
+ new_layout = DISASSEM_COMMAND;
+ else if (subset_compare (buf_ptr, "SPLIT"))
+ new_layout = SRC_DISASSEM_COMMAND;
+ else if (subset_compare (buf_ptr, "REGS") ||
+ subset_compare (buf_ptr, TUI_GENERAL_SPECIAL_REGS_NAME) ||
+ subset_compare (buf_ptr, TUI_GENERAL_REGS_NAME) ||
+ subset_compare (buf_ptr, TUI_FLOAT_REGS_NAME) ||
+ subset_compare (buf_ptr, TUI_SPECIAL_REGS_NAME))
{
- if (curLayout == SRC_COMMAND || curLayout == SRC_DATA_COMMAND)
- newLayout = SRC_DATA_COMMAND;
+ if (cur_layout == SRC_COMMAND || cur_layout == SRC_DATA_COMMAND)
+ new_layout = SRC_DATA_COMMAND;
else
- newLayout = DISASSEM_DATA_COMMAND;
+ new_layout = DISASSEM_DATA_COMMAND;
/* could ifdef out the following code. when compile with -z, there are null
pointer references that cause a core dump if 'layout regs' is the first
layout command issued by the user. HP has asked us to hook up this code
- edie epstein
*/
- if (subset_compare (bufPtr, TUI_FLOAT_REGS_NAME))
+ if (subset_compare (buf_ptr, TUI_FLOAT_REGS_NAME))
{
if (TUI_DATA_WIN->detail.data_display_info.regs_display_type !=
TUI_SFLOAT_REGS &&
TUI_DATA_WIN->detail.data_display_info.regs_display_type !=
TUI_DFLOAT_REGS)
- dpyType = TUI_SFLOAT_REGS;
+ dpy_type = TUI_SFLOAT_REGS;
else
- dpyType =
+ dpy_type =
TUI_DATA_WIN->detail.data_display_info.regs_display_type;
}
- else if (subset_compare (bufPtr,
+ else if (subset_compare (buf_ptr,
TUI_GENERAL_SPECIAL_REGS_NAME))
- dpyType = TUI_GENERAL_AND_SPECIAL_REGS;
- else if (subset_compare (bufPtr, TUI_GENERAL_REGS_NAME))
- dpyType = TUI_GENERAL_REGS;
- else if (subset_compare (bufPtr, TUI_SPECIAL_REGS_NAME))
- dpyType = TUI_SPECIAL_REGS;
+ dpy_type = TUI_GENERAL_AND_SPECIAL_REGS;
+ else if (subset_compare (buf_ptr, TUI_GENERAL_REGS_NAME))
+ dpy_type = TUI_GENERAL_REGS;
+ else if (subset_compare (buf_ptr, TUI_SPECIAL_REGS_NAME))
+ dpy_type = TUI_SPECIAL_REGS;
else if (TUI_DATA_WIN)
{
if (TUI_DATA_WIN->detail.data_display_info.regs_display_type !=
TUI_UNDEFINED_REGS)
- dpyType =
+ dpy_type =
TUI_DATA_WIN->detail.data_display_info.regs_display_type;
else
- dpyType = TUI_GENERAL_REGS;
+ dpy_type = TUI_GENERAL_REGS;
}
/* end of potential ifdef
general purpose registers
*/
-/* dpyType = TUI_GENERAL_REGS;
+/* dpy_type = TUI_GENERAL_REGS;
*/
}
- else if (subset_compare (bufPtr, "NEXT"))
- newLayout = _nextLayout ();
- else if (subset_compare (bufPtr, "PREV"))
- newLayout = _prevLayout ();
+ else if (subset_compare (buf_ptr, "NEXT"))
+ new_layout = next_layout ();
+ else if (subset_compare (buf_ptr, "PREV"))
+ new_layout = prev_layout ();
else
status = TUI_FAILURE;
- xfree (bufPtr);
+ xfree (buf_ptr);
- tui_set_layout (newLayout, dpyType);
+ tui_set_layout (new_layout, dpy_type);
}
}
else
static CORE_ADDR
-_extractDisplayStartAddr (void)
+extract_display_start_addr (void)
{
- enum tui_layout_type curLayout = tui_current_layout ();
+ enum tui_layout_type cur_layout = tui_current_layout ();
CORE_ADDR addr;
CORE_ADDR pc;
struct symtab_and_line cursal = get_current_source_symtab_and_line ();
- switch (curLayout)
+ switch (cur_layout)
{
case SRC_COMMAND:
case SRC_DATA_COMMAND:
}
return addr;
-} /* _extractDisplayStartAddr */
+}
static void
-_tuiHandleXDBLayout (struct tui_layout_def * layoutDef)
+tui_handle_xdb_layout (struct tui_layout_def * layout_def)
{
- if (layoutDef->split)
+ if (layout_def->split)
{
tui_set_layout (SRC_DISASSEM_COMMAND, TUI_UNDEFINED_REGS);
- tui_set_win_focus_to (tui_win_list[layoutDef->display_mode]);
+ tui_set_win_focus_to (tui_win_list[layout_def->display_mode]);
}
else
{
- if (layoutDef->display_mode == SRC_WIN)
+ if (layout_def->display_mode == SRC_WIN)
tui_set_layout (SRC_COMMAND, TUI_UNDEFINED_REGS);
else
- tui_set_layout (DISASSEM_DATA_COMMAND, layoutDef->regs_display_type);
+ tui_set_layout (DISASSEM_DATA_COMMAND, layout_def->regs_display_type);
}
-
-
- return;
-} /* _tuiHandleXDBLayout */
+}
static void
-_tuiToggleLayout_command (char *arg, int fromTTY)
+tui_toggle_layout_command (char *arg, int from_tty)
{
- struct tui_layout_def * layoutDef = tui_layout_def ();
+ struct tui_layout_def * layout_def = tui_layout_def ();
/* Make sure the curses mode is enabled. */
tui_enable ();
- if (layoutDef->display_mode == SRC_WIN)
- layoutDef->display_mode = DISASSEM_WIN;
+ if (layout_def->display_mode == SRC_WIN)
+ layout_def->display_mode = DISASSEM_WIN;
else
- layoutDef->display_mode = SRC_WIN;
-
- if (!layoutDef->split)
- _tuiHandleXDBLayout (layoutDef);
+ layout_def->display_mode = SRC_WIN;
+ if (!layout_def->split)
+ tui_handle_xdb_layout (layout_def);
}
static void
-_tuiToggleSplitLayout_command (char *arg, int fromTTY)
+tui_toggle_split_layout_command (char *arg, int from_tty)
{
- struct tui_layout_def * layoutDef = tui_layout_def ();
+ struct tui_layout_def * layout_def = tui_layout_def ();
/* Make sure the curses mode is enabled. */
tui_enable ();
- layoutDef->split = (!layoutDef->split);
- _tuiHandleXDBLayout (layoutDef);
-
+ layout_def->split = (!layout_def->split);
+ tui_handle_xdb_layout (layout_def);
}
static void
-_tuiLayout_command (char *arg, int fromTTY)
+tui_layout_command (char *arg, int from_tty)
{
/* Make sure the curses mode is enabled. */
tui_enable ();
}
-/*
- ** _nextLayout().
- ** Answer the previous layout to cycle to.
- */
+/* Answer the previous layout to cycle to. */
static enum tui_layout_type
-_nextLayout (void)
+next_layout (void)
{
- enum tui_layout_type newLayout;
+ enum tui_layout_type new_layout;
- newLayout = tui_current_layout ();
- if (newLayout == UNDEFINED_LAYOUT)
- newLayout = SRC_COMMAND;
+ new_layout = tui_current_layout ();
+ if (new_layout == UNDEFINED_LAYOUT)
+ new_layout = SRC_COMMAND;
else
{
- newLayout++;
- if (newLayout == UNDEFINED_LAYOUT)
- newLayout = SRC_COMMAND;
+ new_layout++;
+ if (new_layout == UNDEFINED_LAYOUT)
+ new_layout = SRC_COMMAND;
}
- return newLayout;
-} /* _nextLayout */
+ return new_layout;
+}
-/*
- ** _prevLayout().
- ** Answer the next layout to cycle to.
- */
+/* Answer the next layout to cycle to. */
static enum tui_layout_type
-_prevLayout (void)
+prev_layout (void)
{
- enum tui_layout_type newLayout;
+ enum tui_layout_type new_layout;
- newLayout = tui_current_layout ();
- if (newLayout == SRC_COMMAND)
- newLayout = DISASSEM_DATA_COMMAND;
+ new_layout = tui_current_layout ();
+ if (new_layout == SRC_COMMAND)
+ new_layout = DISASSEM_DATA_COMMAND;
else
{
- newLayout--;
- if (newLayout == UNDEFINED_LAYOUT)
- newLayout = DISASSEM_DATA_COMMAND;
+ new_layout--;
+ if (new_layout == UNDEFINED_LAYOUT)
+ new_layout = DISASSEM_DATA_COMMAND;
}
- return newLayout;
-} /* _prevLayout */
+ return new_layout;
+}
-/*
- ** _makeCommandWindow().
- */
static void
-_makeCommandWindow (struct tui_win_info * * winInfoPtr, int height, int originY)
+make_command_window (struct tui_win_info * * win_info_ptr, int height, int origin_y)
{
- _initAndMakeWin ((void **) winInfoPtr,
+ init_and_make_win ((void **) win_info_ptr,
CMD_WIN,
height,
tui_term_width (),
0,
- originY,
+ origin_y,
DONT_BOX_WINDOW);
- (*winInfoPtr)->can_highlight = FALSE;
-
- return;
-} /* _makeCommandWindow */
+ (*win_info_ptr)->can_highlight = FALSE;
+}
/*
- ** _makeSourceWindow().
+ ** make_source_window().
*/
static void
-_makeSourceWindow (struct tui_win_info * * winInfoPtr, int height, int originY)
+make_source_window (struct tui_win_info * * win_info_ptr, int height, int origin_y)
{
- _makeSourceOrDisassemWindow (winInfoPtr, SRC_WIN, height, originY);
+ make_source_or_disasm_window (win_info_ptr, SRC_WIN, height, origin_y);
return;
-} /* _makeSourceWindow */
+} /* make_source_window */
/*
- ** _makeDisassemWindow().
+ ** make_disasm_window().
*/
static void
-_makeDisassemWindow (struct tui_win_info * * winInfoPtr, int height, int originY)
+make_disasm_window (struct tui_win_info * * win_info_ptr, int height, int origin_y)
{
- _makeSourceOrDisassemWindow (winInfoPtr, DISASSEM_WIN, height, originY);
+ make_source_or_disasm_window (win_info_ptr, DISASSEM_WIN, height, origin_y);
return;
-} /* _makeDisassemWindow */
+} /* make_disasm_window */
-/*
- ** _makeDataWindow().
- */
static void
-_makeDataWindow (struct tui_win_info * * winInfoPtr, int height, int originY)
+make_data_window (struct tui_win_info * * win_info_ptr, int height, int origin_y)
{
- _initAndMakeWin ((void **) winInfoPtr,
+ init_and_make_win ((void **) win_info_ptr,
DATA_WIN,
height,
tui_term_width (),
0,
- originY,
+ origin_y,
BOX_WINDOW);
-
- return;
-} /* _makeDataWindow */
+}
-/*
- ** _showSourceCommand().
- ** Show the Source/Command layout
- */
+/* Show the Source/Command layout. */
static void
-_showSourceCommand (void)
+show_source_command (void)
{
- _showSourceOrDisassemAndCommand (SRC_COMMAND);
-
- return;
-} /* _showSourceCommand */
+ show_source_or_disasm_and_command (SRC_COMMAND);
+}
-/*
- ** _showDisassemCommand().
- ** Show the Dissassem/Command layout
- */
+/* Show the Dissassem/Command layout. */
static void
-_showDisassemCommand (void)
+show_disasm_command (void)
{
- _showSourceOrDisassemAndCommand (DISASSEM_COMMAND);
-
- return;
-} /* _showDisassemCommand */
+ show_source_or_disasm_and_command (DISASSEM_COMMAND);
+}
-/*
- ** _showSourceDisassemCommand().
- ** Show the Source/Disassem/Command layout
- */
+/* Show the Source/Disassem/Command layout. */
static void
-_showSourceDisassemCommand (void)
+show_source_disasm_command (void)
{
if (tui_current_layout () != SRC_DISASSEM_COMMAND)
{
- int cmdHeight, srcHeight, asmHeight;
+ int cmd_height, src_height, asm_height;
if (TUI_CMD_WIN != NULL)
- cmdHeight = TUI_CMD_WIN->generic.height;
+ cmd_height = TUI_CMD_WIN->generic.height;
else
- cmdHeight = tui_term_height () / 3;
+ cmd_height = tui_term_height () / 3;
- srcHeight = (tui_term_height () - cmdHeight) / 2;
- asmHeight = tui_term_height () - (srcHeight + cmdHeight);
+ src_height = (tui_term_height () - cmd_height) / 2;
+ asm_height = tui_term_height () - (src_height + cmd_height);
if (TUI_SRC_WIN == NULL)
- _makeSourceWindow (&TUI_SRC_WIN, srcHeight, 0);
+ make_source_window (&TUI_SRC_WIN, src_height, 0);
else
{
- _initGenWinInfo (&TUI_SRC_WIN->generic,
+ init_gen_win_info (&TUI_SRC_WIN->generic,
TUI_SRC_WIN->generic.type,
- srcHeight,
+ src_height,
TUI_SRC_WIN->generic.width,
TUI_SRC_WIN->detail.source_info.execution_info->width,
0);
TUI_SRC_WIN->can_highlight = TRUE;
- _initGenWinInfo (TUI_SRC_WIN->detail.source_info.execution_info,
+ init_gen_win_info (TUI_SRC_WIN->detail.source_info.execution_info,
EXEC_INFO_WIN,
- srcHeight,
+ src_height,
3,
0,
0);
tui_show_source_content (TUI_SRC_WIN);
if (TUI_DISASM_WIN == NULL)
{
- _makeDisassemWindow (&TUI_DISASM_WIN, asmHeight, srcHeight - 1);
- _initAndMakeWin ((void **) & locator,
+ make_disasm_window (&TUI_DISASM_WIN, asm_height, src_height - 1);
+ init_and_make_win ((void **) & locator,
LOCATOR_WIN,
2 /* 1 */ ,
tui_term_width (),
0,
- (srcHeight + asmHeight) - 1,
+ (src_height + asm_height) - 1,
DONT_BOX_WINDOW);
}
else
{
- _initGenWinInfo (locator,
+ init_gen_win_info (locator,
LOCATOR_WIN,
2 /* 1 */ ,
tui_term_width (),
0,
- (srcHeight + asmHeight) - 1);
+ (src_height + asm_height) - 1);
TUI_DISASM_WIN->detail.source_info.has_locator = TRUE;
- _initGenWinInfo (
+ init_gen_win_info (
&TUI_DISASM_WIN->generic,
TUI_DISASM_WIN->generic.type,
- asmHeight,
+ asm_height,
TUI_DISASM_WIN->generic.width,
TUI_DISASM_WIN->detail.source_info.execution_info->width,
- srcHeight - 1);
- _initGenWinInfo (TUI_DISASM_WIN->detail.source_info.execution_info,
+ src_height - 1);
+ init_gen_win_info (TUI_DISASM_WIN->detail.source_info.execution_info,
EXEC_INFO_WIN,
- asmHeight,
+ asm_height,
3,
0,
- srcHeight - 1);
+ src_height - 1);
TUI_DISASM_WIN->can_highlight = TRUE;
tui_make_visible (&TUI_DISASM_WIN->generic);
tui_make_visible (TUI_DISASM_WIN->detail.source_info.execution_info);
tui_show_source_content (TUI_DISASM_WIN);
if (TUI_CMD_WIN == NULL)
- _makeCommandWindow (&TUI_CMD_WIN,
- cmdHeight,
- tui_term_height () - cmdHeight);
+ make_command_window (&TUI_CMD_WIN,
+ cmd_height,
+ tui_term_height () - cmd_height);
else
{
- _initGenWinInfo (&TUI_CMD_WIN->generic,
+ init_gen_win_info (&TUI_CMD_WIN->generic,
TUI_CMD_WIN->generic.type,
TUI_CMD_WIN->generic.height,
TUI_CMD_WIN->generic.width,
}
tui_set_current_layout_to (SRC_DISASSEM_COMMAND);
}
-
- return;
-} /* _showSourceDisassemCommand */
+}
-/*
- ** _showData().
- ** Show the Source/Data/Command or the Dissassembly/Data/Command layout
- */
+/* Show the Source/Data/Command or the Dissassembly/Data/Command
+ layout. */
static void
-_showData (enum tui_layout_type newLayout)
+show_data (enum tui_layout_type new_layout)
{
- int totalHeight = (tui_term_height () - TUI_CMD_WIN->generic.height);
- int srcHeight, dataHeight;
- enum tui_win_type winType;
+ int total_height = (tui_term_height () - TUI_CMD_WIN->generic.height);
+ int src_height, data_height;
+ enum tui_win_type win_type;
struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
- dataHeight = totalHeight / 2;
- srcHeight = totalHeight - dataHeight;
+ data_height = total_height / 2;
+ src_height = total_height - data_height;
tui_make_all_invisible ();
tui_make_invisible (locator);
- _makeDataWindow (&TUI_DATA_WIN, dataHeight, 0);
+ make_data_window (&TUI_DATA_WIN, data_height, 0);
TUI_DATA_WIN->can_highlight = TRUE;
- if (newLayout == SRC_DATA_COMMAND)
- winType = SRC_WIN;
+ if (new_layout == SRC_DATA_COMMAND)
+ win_type = SRC_WIN;
else
- winType = DISASSEM_WIN;
- if (tui_win_list[winType] == NULL)
+ win_type = DISASSEM_WIN;
+ if (tui_win_list[win_type] == NULL)
{
- if (winType == SRC_WIN)
- _makeSourceWindow (&tui_win_list[winType], srcHeight, dataHeight - 1);
+ if (win_type == SRC_WIN)
+ make_source_window (&tui_win_list[win_type], src_height, data_height - 1);
else
- _makeDisassemWindow (&tui_win_list[winType], srcHeight, dataHeight - 1);
- _initAndMakeWin ((void **) & locator,
+ make_disasm_window (&tui_win_list[win_type], src_height, data_height - 1);
+ init_and_make_win ((void **) & locator,
LOCATOR_WIN,
2 /* 1 */ ,
tui_term_width (),
0,
- totalHeight - 1,
+ total_height - 1,
DONT_BOX_WINDOW);
}
else
{
- _initGenWinInfo (&tui_win_list[winType]->generic,
- tui_win_list[winType]->generic.type,
- srcHeight,
- tui_win_list[winType]->generic.width,
- tui_win_list[winType]->detail.source_info.execution_info->width,
- dataHeight - 1);
- _initGenWinInfo (tui_win_list[winType]->detail.source_info.execution_info,
+ init_gen_win_info (&tui_win_list[win_type]->generic,
+ tui_win_list[win_type]->generic.type,
+ src_height,
+ tui_win_list[win_type]->generic.width,
+ tui_win_list[win_type]->detail.source_info.execution_info->width,
+ data_height - 1);
+ init_gen_win_info (tui_win_list[win_type]->detail.source_info.execution_info,
EXEC_INFO_WIN,
- srcHeight,
+ src_height,
3,
0,
- dataHeight - 1);
- tui_make_visible (&tui_win_list[winType]->generic);
- tui_make_visible (tui_win_list[winType]->detail.source_info.execution_info);
- _initGenWinInfo (locator,
+ data_height - 1);
+ tui_make_visible (&tui_win_list[win_type]->generic);
+ tui_make_visible (tui_win_list[win_type]->detail.source_info.execution_info);
+ init_gen_win_info (locator,
LOCATOR_WIN,
2 /* 1 */ ,
tui_term_width (),
0,
- totalHeight - 1);
+ total_height - 1);
}
- tui_win_list[winType]->detail.source_info.has_locator = TRUE;
+ tui_win_list[win_type]->detail.source_info.has_locator = TRUE;
tui_make_visible (locator);
tui_show_locator_content ();
- tui_add_to_source_windows (tui_win_list[winType]);
- tui_set_current_layout_to (newLayout);
-
- return;
-} /* _showData */
+ tui_add_to_source_windows (tui_win_list[win_type]);
+ tui_set_current_layout_to (new_layout);
+}
/*
- ** _initGenWinInfo().
+ ** init_gen_win_info().
*/
static void
-_initGenWinInfo (struct tui_gen_win_info * winInfo, enum tui_win_type type,
- int height, int width, int originX, int originY)
+init_gen_win_info (struct tui_gen_win_info * win_info, enum tui_win_type type,
+ int height, int width, int origin_x, int origin_y)
{
int h = height;
- winInfo->type = type;
- winInfo->width = width;
- winInfo->height = h;
+ win_info->type = type;
+ win_info->width = width;
+ win_info->height = h;
if (h > 1)
{
- winInfo->viewport_height = h - 1;
- if (winInfo->type != CMD_WIN)
- winInfo->viewport_height--;
+ win_info->viewport_height = h - 1;
+ if (win_info->type != CMD_WIN)
+ win_info->viewport_height--;
}
else
- winInfo->viewport_height = 1;
- winInfo->origin.x = originX;
- winInfo->origin.y = originY;
+ win_info->viewport_height = 1;
+ win_info->origin.x = origin_x;
+ win_info->origin.y = origin_y;
return;
-} /* _initGenWinInfo */
+} /* init_gen_win_info */
/*
- ** _initAndMakeWin().
+ ** init_and_make_win().
*/
static void
-_initAndMakeWin (void ** winInfoPtr, enum tui_win_type winType,
- int height, int width, int originX, int originY, int boxIt)
+init_and_make_win (void ** win_info_ptr, enum tui_win_type win_type,
+ int height, int width, int origin_x, int origin_y, int box_it)
{
- void *opaqueWinInfo = *winInfoPtr;
+ void *opaque_win_info = *win_info_ptr;
struct tui_gen_win_info * generic;
- if (opaqueWinInfo == NULL)
+ if (opaque_win_info == NULL)
{
- if (tui_win_is_auxillary (winType))
- opaqueWinInfo = (void *) tui_alloc_generic_win_info ();
+ if (tui_win_is_auxillary (win_type))
+ opaque_win_info = (void *) tui_alloc_generic_win_info ();
else
- opaqueWinInfo = (void *) tui_alloc_win_info (winType);
+ opaque_win_info = (void *) tui_alloc_win_info (win_type);
}
- if (tui_win_is_auxillary (winType))
- generic = (struct tui_gen_win_info *) opaqueWinInfo;
+ if (tui_win_is_auxillary (win_type))
+ generic = (struct tui_gen_win_info *) opaque_win_info;
else
- generic = &((struct tui_win_info *) opaqueWinInfo)->generic;
+ generic = &((struct tui_win_info *) opaque_win_info)->generic;
- if (opaqueWinInfo != NULL)
+ if (opaque_win_info != NULL)
{
- _initGenWinInfo (generic, winType, height, width, originX, originY);
- if (!tui_win_is_auxillary (winType))
+ init_gen_win_info (generic, win_type, height, width, origin_x, origin_y);
+ if (!tui_win_is_auxillary (win_type))
{
if (generic->type == CMD_WIN)
- ((struct tui_win_info *) opaqueWinInfo)->can_highlight = FALSE;
+ ((struct tui_win_info *) opaque_win_info)->can_highlight = FALSE;
else
- ((struct tui_win_info *) opaqueWinInfo)->can_highlight = TRUE;
+ ((struct tui_win_info *) opaque_win_info)->can_highlight = TRUE;
}
- tui_make_window (generic, boxIt);
+ tui_make_window (generic, box_it);
}
- *winInfoPtr = opaqueWinInfo;
+ *win_info_ptr = opaque_win_info;
}
-/*
- ** _makeSourceOrDisassemWindow().
- */
static void
-_makeSourceOrDisassemWindow (struct tui_win_info * * winInfoPtr, enum tui_win_type type,
- int height, int originY)
+make_source_or_disasm_window (struct tui_win_info * * win_info_ptr, enum tui_win_type type,
+ int height, int origin_y)
{
struct tui_gen_win_info * execution_info = (struct tui_gen_win_info *) NULL;
execution_info = tui_source_exec_info_win_ptr ();
else
execution_info = tui_disassem_exec_info_win_ptr ();
- _initAndMakeWin ((void **) & execution_info,
+ init_and_make_win ((void **) & execution_info,
EXEC_INFO_WIN,
height,
3,
0,
- originY,
+ origin_y,
DONT_BOX_WINDOW);
/*
** Now create the source window.
*/
- _initAndMakeWin ((void **) winInfoPtr,
+ init_and_make_win ((void **) win_info_ptr,
type,
height,
tui_term_width () - execution_info->width,
execution_info->width,
- originY,
+ origin_y,
BOX_WINDOW);
- (*winInfoPtr)->detail.source_info.execution_info = execution_info;
-
- return;
-} /* _makeSourceOrDisassemWindow */
+ (*win_info_ptr)->detail.source_info.execution_info = execution_info;
+}
-/*
- ** _showSourceOrDisassemAndCommand().
- ** Show the Source/Command or the Disassem layout
- */
+/* Show the Source/Command or the Disassem layout. */
static void
-_showSourceOrDisassemAndCommand (enum tui_layout_type layoutType)
+show_source_or_disasm_and_command (enum tui_layout_type layout_type)
{
- if (tui_current_layout () != layoutType)
+ if (tui_current_layout () != layout_type)
{
- struct tui_win_info * *winInfoPtr;
- int srcHeight, cmdHeight;
+ struct tui_win_info * *win_info_ptr;
+ int src_height, cmd_height;
struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
if (TUI_CMD_WIN != NULL)
- cmdHeight = TUI_CMD_WIN->generic.height;
+ cmd_height = TUI_CMD_WIN->generic.height;
else
- cmdHeight = tui_term_height () / 3;
- srcHeight = tui_term_height () - cmdHeight;
+ cmd_height = tui_term_height () / 3;
+ src_height = tui_term_height () - cmd_height;
- if (layoutType == SRC_COMMAND)
- winInfoPtr = &TUI_SRC_WIN;
+ if (layout_type == SRC_COMMAND)
+ win_info_ptr = &TUI_SRC_WIN;
else
- winInfoPtr = &TUI_DISASM_WIN;
+ win_info_ptr = &TUI_DISASM_WIN;
- if ((*winInfoPtr) == NULL)
+ if ((*win_info_ptr) == NULL)
{
- if (layoutType == SRC_COMMAND)
- _makeSourceWindow (winInfoPtr, srcHeight - 1, 0);
+ if (layout_type == SRC_COMMAND)
+ make_source_window (win_info_ptr, src_height - 1, 0);
else
- _makeDisassemWindow (winInfoPtr, srcHeight - 1, 0);
- _initAndMakeWin ((void **) & locator,
+ make_disasm_window (win_info_ptr, src_height - 1, 0);
+ init_and_make_win ((void **) & locator,
LOCATOR_WIN,
2 /* 1 */ ,
tui_term_width (),
0,
- srcHeight - 1,
+ src_height - 1,
DONT_BOX_WINDOW);
}
else
{
- _initGenWinInfo (locator,
+ init_gen_win_info (locator,
LOCATOR_WIN,
2 /* 1 */ ,
tui_term_width (),
0,
- srcHeight - 1);
- (*winInfoPtr)->detail.source_info.has_locator = TRUE;
- _initGenWinInfo (
- &(*winInfoPtr)->generic,
- (*winInfoPtr)->generic.type,
- srcHeight - 1,
- (*winInfoPtr)->generic.width,
- (*winInfoPtr)->detail.source_info.execution_info->width,
+ src_height - 1);
+ (*win_info_ptr)->detail.source_info.has_locator = TRUE;
+ init_gen_win_info (
+ &(*win_info_ptr)->generic,
+ (*win_info_ptr)->generic.type,
+ src_height - 1,
+ (*win_info_ptr)->generic.width,
+ (*win_info_ptr)->detail.source_info.execution_info->width,
0);
- _initGenWinInfo ((*winInfoPtr)->detail.source_info.execution_info,
+ init_gen_win_info ((*win_info_ptr)->detail.source_info.execution_info,
EXEC_INFO_WIN,
- srcHeight - 1,
+ src_height - 1,
3,
0,
0);
- (*winInfoPtr)->can_highlight = TRUE;
- tui_make_visible (&(*winInfoPtr)->generic);
- tui_make_visible ((*winInfoPtr)->detail.source_info.execution_info);
+ (*win_info_ptr)->can_highlight = TRUE;
+ tui_make_visible (&(*win_info_ptr)->generic);
+ tui_make_visible ((*win_info_ptr)->detail.source_info.execution_info);
}
- if ((*winInfoPtr) != NULL)
+ if ((*win_info_ptr) != NULL)
{
- (*winInfoPtr)->detail.source_info.has_locator = TRUE;
+ (*win_info_ptr)->detail.source_info.has_locator = TRUE;
tui_make_visible (locator);
tui_show_locator_content ();
- tui_show_source_content (*winInfoPtr);
+ tui_show_source_content (*win_info_ptr);
if (TUI_CMD_WIN == NULL)
{
- _makeCommandWindow (&TUI_CMD_WIN, cmdHeight, srcHeight);
+ make_command_window (&TUI_CMD_WIN, cmd_height, src_height);
tui_refresh_win (&TUI_CMD_WIN->generic);
}
else
{
- _initGenWinInfo (&TUI_CMD_WIN->generic,
+ init_gen_win_info (&TUI_CMD_WIN->generic,
TUI_CMD_WIN->generic.type,
TUI_CMD_WIN->generic.height,
TUI_CMD_WIN->generic.width,
tui_make_visible (&TUI_CMD_WIN->generic);
}
}
- tui_set_current_layout_to (layoutType);
+ tui_set_current_layout_to (layout_type);
}
-
- return;
-} /* _showSourceOrDisassemAndCommand */
+}
/*****************************************
** STATIC LOCAL FUNCTIONS FORWARD DECLS **
******************************************/
-static enum tui_status _tuiSetRegsContent
+static enum tui_status tui_set_regs_content
(int, int, struct frame_info *, enum tui_register_display_type, int);
-static const char *_tuiRegisterName (int);
-static enum tui_status _tuiGetRegisterRawValue (int, char *, struct frame_info *);
-static void _tuiSetRegisterElement
+static const char *tui_register_name (int);
+static enum tui_status tui_get_register_raw_value (int, char *, struct frame_info *);
+static void tui_set_register_element
(int, struct frame_info *, struct tui_data_element *, int);
-static void _tuiDisplayRegister (int, struct tui_gen_win_info *, enum precision_type);
-static void _tuiRegisterFormat
+static void tui_display_register (int, struct tui_gen_win_info *, enum precision_type);
+static void tui_register_format
(char *, int, int, struct tui_data_element *, enum precision_type);
-static enum tui_status _tuiSetGeneralRegsContent (int);
-static enum tui_status _tuiSetSpecialRegsContent (int);
-static enum tui_status _tuiSetGeneralAndSpecialRegsContent (int);
-static enum tui_status _tuiSetFloatRegsContent (enum tui_register_display_type, int);
-static int _tuiRegValueHasChanged
+static enum tui_status tui_set_general_regs_content (int);
+static enum tui_status tui_set_special_regs_content (int);
+static enum tui_status tui_set_general_and_special_regs_content (int);
+static enum tui_status tui_set_float_regs_content (enum tui_register_display_type, int);
+static int tui_reg_value_has_changed
(struct tui_data_element *, struct frame_info *, char *);
-static void _tuiShowFloat_command (char *, int);
-static void _tuiShowGeneral_command (char *, int);
-static void _tuiShowSpecial_command (char *, int);
-static void _tui_vShowRegisters_commandSupport (enum tui_register_display_type);
-static void _tuiToggleFloatRegs_command (char *, int);
-static void _tuiScrollRegsForward_command (char *, int);
-static void _tuiScrollRegsBackward_command (char *, int);
+static void tui_show_float_command (char *, int);
+static void tui_show_general_command (char *, int);
+static void tui_show_special_command (char *, int);
+static void tui_v_show_registers_command_support (enum tui_register_display_type);
+static void _tui_toggle_float_regs_command (char *, int);
+static void tui_scroll_regs_forward_command (char *, int);
+static void tui_scroll_regs_backward_command (char *, int);
int
tui_last_regs_line_no (void)
{
- register int numLines = (-1);
+ register int num_lines = (-1);
if (TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
{
- numLines = (TUI_DATA_WIN->detail.data_display_info.regs_content_count /
+ num_lines = (TUI_DATA_WIN->detail.data_display_info.regs_content_count /
TUI_DATA_WIN->detail.data_display_info.regs_column_count);
if (TUI_DATA_WIN->detail.data_display_info.regs_content_count %
TUI_DATA_WIN->detail.data_display_info.regs_column_count)
- numLines++;
+ num_lines++;
}
- return numLines;
+ return num_lines;
}
-/* Answer the line number that the register element at elementNo is
- on. If elementNo is greater than the number of register elements
+/* Answer the line number that the register element at element_no is
+ on. If element_no is greater than the number of register elements
there are, -1 is returned. */
int
-tui_line_from_reg_element_no (int elementNo)
+tui_line_from_reg_element_no (int element_no)
{
- if (elementNo < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
+ if (element_no < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
{
int i, line = (-1);
i = 1;
while (line == (-1))
{
- if (elementNo <
+ if (element_no <
(TUI_DATA_WIN->detail.data_display_info.regs_column_count * i))
line = i - 1;
else
}
-/* Answer the index of the first element in lineNo. If lineNo is past
+/* Answer the index of the first element in line_no. If line_no is past
the register area (-1) is returned. */
int
-tui_first_reg_element_no_inline (int lineNo)
+tui_first_reg_element_no_inline (int line_no)
{
- if ((lineNo * TUI_DATA_WIN->detail.data_display_info.regs_column_count)
+ if ((line_no * TUI_DATA_WIN->detail.data_display_info.regs_column_count)
<= TUI_DATA_WIN->detail.data_display_info.regs_content_count)
- return ((lineNo + 1) *
+ return ((line_no + 1) *
TUI_DATA_WIN->detail.data_display_info.regs_column_count) -
TUI_DATA_WIN->detail.data_display_info.regs_column_count;
else
}
-/*
- ** tuiLastRegElementNoInLine()
- ** Answer the index of the last element in lineNo. If lineNo is past
- ** the register area (-1) is returned.
- */
+/* Answer the index of the last element in line_no. If line_no is
+ past the register area (-1) is returned. */
int
-tuiLastRegElementNoInLine (int lineNo)
+tui_last_reg_element_no_in_line (int line_no)
{
- if ((lineNo * TUI_DATA_WIN->detail.data_display_info.regs_column_count) <=
+ if ((line_no * TUI_DATA_WIN->detail.data_display_info.regs_column_count) <=
TUI_DATA_WIN->detail.data_display_info.regs_content_count)
- return ((lineNo + 1) *
+ return ((line_no + 1) *
TUI_DATA_WIN->detail.data_display_info.regs_column_count) - 1;
else
return (-1);
-} /* tuiLastRegElementNoInLine */
+}
/* Calculate the number of columns that should be used to display the
registers. */
int
-tui_calculate_regs_column_count (enum tui_register_display_type dpyType)
+tui_calculate_regs_column_count (enum tui_register_display_type dpy_type)
{
- int colCount, colWidth;
+ int col_count, col_width;
- if (IS_64BIT || dpyType == TUI_DFLOAT_REGS)
- colWidth = DOUBLE_FLOAT_VALUE_WIDTH + DOUBLE_FLOAT_LABEL_WIDTH;
+ if (IS_64BIT || dpy_type == TUI_DFLOAT_REGS)
+ col_width = DOUBLE_FLOAT_VALUE_WIDTH + DOUBLE_FLOAT_LABEL_WIDTH;
else
{
- if (dpyType == TUI_SFLOAT_REGS)
- colWidth = SINGLE_FLOAT_VALUE_WIDTH + SINGLE_FLOAT_LABEL_WIDTH;
+ if (dpy_type == TUI_SFLOAT_REGS)
+ col_width = SINGLE_FLOAT_VALUE_WIDTH + SINGLE_FLOAT_LABEL_WIDTH;
else
- colWidth = SINGLE_VALUE_WIDTH + SINGLE_LABEL_WIDTH;
+ col_width = SINGLE_VALUE_WIDTH + SINGLE_LABEL_WIDTH;
}
- colCount = (TUI_DATA_WIN->generic.width - 2) / colWidth;
+ col_count = (TUI_DATA_WIN->generic.width - 2) / col_width;
- return colCount;
-} /* tuiCalulateRegs_column_count */
+ return col_count;
+}
-/* Show the registers int the data window as indicated by dpyType. If
+/* Show the registers int the data window as indicated by dpy_type. If
there is any other registers being displayed, then they are
- cleared. What registers are displayed is dependent upon dpyType. */
+ cleared. What registers are displayed is dependent upon dpy_type. */
void
-tui_show_registers (enum tui_register_display_type dpyType)
+tui_show_registers (enum tui_register_display_type dpy_type)
{
enum tui_status ret = TUI_FAILURE;
- int refreshValuesOnly = FALSE;
+ int refresh_values_only = FALSE;
/* Say that registers should be displayed, even if there is a problem */
TUI_DATA_WIN->detail.data_display_info.display_regs = TRUE;
if (target_has_registers)
{
- refreshValuesOnly =
- (dpyType == TUI_DATA_WIN->detail.data_display_info.regs_display_type);
- switch (dpyType)
+ refresh_values_only =
+ (dpy_type == TUI_DATA_WIN->detail.data_display_info.regs_display_type);
+ switch (dpy_type)
{
case TUI_GENERAL_REGS:
- ret = _tuiSetGeneralRegsContent (refreshValuesOnly);
+ ret = tui_set_general_regs_content (refresh_values_only);
break;
case TUI_SFLOAT_REGS:
case TUI_DFLOAT_REGS:
- ret = _tuiSetFloatRegsContent (dpyType, refreshValuesOnly);
+ ret = tui_set_float_regs_content (dpy_type, refresh_values_only);
break;
/* could ifdef out */
case TUI_SPECIAL_REGS:
- ret = _tuiSetSpecialRegsContent (refreshValuesOnly);
+ ret = tui_set_special_regs_content (refresh_values_only);
break;
case TUI_GENERAL_AND_SPECIAL_REGS:
- ret = _tuiSetGeneralAndSpecialRegsContent (refreshValuesOnly);
+ ret = tui_set_general_and_special_regs_content (refresh_values_only);
break;
/* end of potential if def */
/* Clear all notation of changed values */
for (i = 0; (i < TUI_DATA_WIN->detail.data_display_info.regs_content_count); i++)
{
- struct tui_gen_win_info * dataItemWin;
+ struct tui_gen_win_info * data_item_win;
- dataItemWin = &TUI_DATA_WIN->detail.data_display_info.
+ data_item_win = &TUI_DATA_WIN->detail.data_display_info.
regs_content[i]->which_element.data_window;
(&((struct tui_win_element *)
- dataItemWin->content[0])->which_element.data)->highlight = FALSE;
+ data_item_win->content[0])->which_element.data)->highlight = FALSE;
}
- TUI_DATA_WIN->detail.data_display_info.regs_display_type = dpyType;
+ TUI_DATA_WIN->detail.data_display_info.regs_display_type = dpy_type;
tui_display_all_data ();
}
- (tui_layout_def ())->regs_display_type = dpyType;
+ (tui_layout_def ())->regs_display_type = dpy_type;
return;
}
/* Function to display the registers in the content from
- 'startElementNo' until the end of the register content or the end
+ 'start_element_no' until the end of the register content or the end
of the display height. No checking for displaying past the end of
the registers is done here. */
void
-tui_display_registers_from (int startElementNo)
+tui_display_registers_from (int start_element_no)
{
if (TUI_DATA_WIN->detail.data_display_info.regs_content != (tui_win_content) NULL &&
TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
{
- register int i = startElementNo;
- int j, valueCharsWide, itemWinWidth, curY, labelWidth;
+ register int i = start_element_no;
+ int j, value_chars_wide, item_win_width, cur_y, label_width;
enum precision_type precision;
precision = (TUI_DATA_WIN->detail.data_display_info.regs_display_type
if (IS_64BIT ||
TUI_DATA_WIN->detail.data_display_info.regs_display_type == TUI_DFLOAT_REGS)
{
- valueCharsWide = DOUBLE_FLOAT_VALUE_WIDTH;
- labelWidth = DOUBLE_FLOAT_LABEL_WIDTH;
+ value_chars_wide = DOUBLE_FLOAT_VALUE_WIDTH;
+ label_width = DOUBLE_FLOAT_LABEL_WIDTH;
}
else
{
if (TUI_DATA_WIN->detail.data_display_info.regs_display_type ==
TUI_SFLOAT_REGS)
{
- valueCharsWide = SINGLE_FLOAT_VALUE_WIDTH;
- labelWidth = SINGLE_FLOAT_LABEL_WIDTH;
+ value_chars_wide = SINGLE_FLOAT_VALUE_WIDTH;
+ label_width = SINGLE_FLOAT_LABEL_WIDTH;
}
else
{
- valueCharsWide = SINGLE_VALUE_WIDTH;
- labelWidth = SINGLE_LABEL_WIDTH;
+ value_chars_wide = SINGLE_VALUE_WIDTH;
+ label_width = SINGLE_LABEL_WIDTH;
}
}
- itemWinWidth = valueCharsWide + labelWidth;
+ item_win_width = value_chars_wide + label_width;
/*
** Now create each data "sub" window, and write the display into it.
*/
- curY = 1;
+ cur_y = 1;
while (i < TUI_DATA_WIN->detail.data_display_info.regs_content_count &&
- curY <= TUI_DATA_WIN->generic.viewport_height)
+ cur_y <= TUI_DATA_WIN->generic.viewport_height)
{
for (j = 0;
(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;
+ struct tui_gen_win_info * data_item_win;
+ struct tui_data_element * data_element_ptr;
/* create the window if necessary */
- dataItemWin = &TUI_DATA_WIN->detail.data_display_info.
+ data_item_win = &TUI_DATA_WIN->detail.data_display_info.
regs_content[i]->which_element.data_window;
- dataElementPtr = &((struct tui_win_element *)
- dataItemWin->content[0])->which_element.data;
- if (dataItemWin->handle == (WINDOW *) NULL)
+ data_element_ptr = &((struct tui_win_element *)
+ data_item_win->content[0])->which_element.data;
+ if (data_item_win->handle == (WINDOW *) NULL)
{
- dataItemWin->height = 1;
- dataItemWin->width = (precision == double_precision) ?
- itemWinWidth + 2 : itemWinWidth + 1;
- dataItemWin->origin.x = (itemWinWidth * j) + 1;
- dataItemWin->origin.y = curY;
- tui_make_window (dataItemWin, DONT_BOX_WINDOW);
- scrollok (dataItemWin->handle, FALSE);
+ data_item_win->height = 1;
+ data_item_win->width = (precision == double_precision) ?
+ item_win_width + 2 : item_win_width + 1;
+ data_item_win->origin.x = (item_win_width * j) + 1;
+ data_item_win->origin.y = cur_y;
+ tui_make_window (data_item_win, DONT_BOX_WINDOW);
+ scrollok (data_item_win->handle, FALSE);
}
- touchwin (dataItemWin->handle);
+ touchwin (data_item_win->handle);
/*
** Get the printable representation of the register
** and display it
*/
- _tuiDisplayRegister (
- dataElementPtr->item_no, dataItemWin, precision);
+ tui_display_register (
+ data_element_ptr->item_no, data_item_win, precision);
i++; /* next register */
}
- curY++; /* next row; */
+ cur_y++; /* next row; */
}
}
}
-/*
- ** tuiDisplayRegElementAtLine().
- ** Function to display the registers in the content from
- ** 'startElementNo' on 'startLineNo' until the end of the
- ** register content or the end of the display height.
- ** This function checks that we won't display off the end
- ** of the register display.
- */
+/* Function to display the registers in the content from
+ 'start_element_no' on 'start_line_no' until the end of the register
+ content or the end of the display height. This function checks
+ that we won't display off the end of the register display. */
void
-tuiDisplayRegElementAtLine (int startElementNo, int startLineNo)
+tui_display_reg_element_at_line (int start_element_no, int start_line_no)
{
if (TUI_DATA_WIN->detail.data_display_info.regs_content != (tui_win_content) NULL &&
TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
{
- register int elementNo = startElementNo;
+ register int element_no = start_element_no;
- if (startElementNo != 0 && startLineNo != 0)
+ if (start_element_no != 0 && start_line_no != 0)
{
- register int lastLineNo, firstLineOnLastPage;
+ register int last_line_no, first_line_on_last_page;
- lastLineNo = tui_last_regs_line_no ();
- firstLineOnLastPage = lastLineNo - (TUI_DATA_WIN->generic.height - 2);
- if (firstLineOnLastPage < 0)
- firstLineOnLastPage = 0;
+ last_line_no = tui_last_regs_line_no ();
+ first_line_on_last_page = last_line_no - (TUI_DATA_WIN->generic.height - 2);
+ if (first_line_on_last_page < 0)
+ first_line_on_last_page = 0;
/*
** If there is no other data displayed except registers,
- ** and the elementNo causes us to scroll past the end of the
+ ** and the element_no causes us to scroll past the end of the
** registers, adjust what element to really start the display at.
*/
if (TUI_DATA_WIN->detail.data_display_info.data_content_count <= 0 &&
- startLineNo > firstLineOnLastPage)
- elementNo = tui_first_reg_element_no_inline (firstLineOnLastPage);
+ start_line_no > first_line_on_last_page)
+ element_no = tui_first_reg_element_no_inline (first_line_on_last_page);
}
- tui_display_registers_from (elementNo);
+ tui_display_registers_from (element_no);
}
-
- return;
-} /* tuiDisplayRegElementAtLine */
+}
-/* Function to display the registers starting at line lineNo in the
+/* Function to display the registers starting at line line_no in the
data window. Answers the line number that the display actually
started from. If nothing is displayed (-1) is returned. */
int
-tui_display_registers_from_line (int lineNo, int forceDisplay)
+tui_display_registers_from_line (int line_no, int force_display)
{
if (TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
{
- int line, elementNo;
+ int line, element_no;
- if (lineNo < 0)
+ if (line_no < 0)
line = 0;
- else if (forceDisplay)
+ else if (force_display)
{ /*
- ** If we must display regs (forceDisplay is true), then make
+ ** If we must display regs (force_display is true), then make
** sure that we don't display off the end of the registers.
*/
- if (lineNo >= tui_last_regs_line_no ())
+ if (line_no >= tui_last_regs_line_no ())
{
if ((line = tui_line_from_reg_element_no (
TUI_DATA_WIN->detail.data_display_info.regs_content_count - 1)) < 0)
line = 0;
}
else
- line = lineNo;
+ line = line_no;
}
else
- line = lineNo;
+ line = line_no;
- elementNo = tui_first_reg_element_no_inline (line);
- if (elementNo < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
- tuiDisplayRegElementAtLine (elementNo, line);
+ element_no = tui_first_reg_element_no_inline (line);
+ if (element_no < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
+ tui_display_reg_element_at_line (element_no, line);
else
line = (-1);
else
{
int i, j;
- char rawBuf[MAX_REGISTER_SIZE];
+ char raw_buf[MAX_REGISTER_SIZE];
for (i = 0;
(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;
+ struct tui_data_element * data_element_ptr;
+ struct tui_gen_win_info * data_item_win_ptr;
+ int was_hilighted;
- dataItemWinPtr = &TUI_DATA_WIN->detail.data_display_info.
+ data_item_win_ptr = &TUI_DATA_WIN->detail.data_display_info.
regs_content[i]->which_element.data_window;
- dataElementPtr = &((struct tui_win_element *)
- dataItemWinPtr->content[0])->which_element.data;
- wasHilighted = dataElementPtr->highlight;
- dataElementPtr->highlight =
- _tuiRegValueHasChanged (dataElementPtr, frame, &rawBuf[0]);
- if (dataElementPtr->highlight)
+ data_element_ptr = &((struct tui_win_element *)
+ data_item_win_ptr->content[0])->which_element.data;
+ was_hilighted = data_element_ptr->highlight;
+ data_element_ptr->highlight =
+ tui_reg_value_has_changed (data_element_ptr, frame, &raw_buf[0]);
+ if (data_element_ptr->highlight)
{
int size;
- size = DEPRECATED_REGISTER_RAW_SIZE (dataElementPtr->item_no);
+ size = DEPRECATED_REGISTER_RAW_SIZE (data_element_ptr->item_no);
for (j = 0; j < size; j++)
- ((char *) dataElementPtr->value)[j] = rawBuf[j];
- _tuiDisplayRegister (
- dataElementPtr->item_no,
- dataItemWinPtr,
+ ((char *) data_element_ptr->value)[j] = raw_buf[j];
+ tui_display_register (
+ data_element_ptr->item_no,
+ data_item_win_ptr,
((TUI_DATA_WIN->detail.data_display_info.regs_display_type ==
TUI_DFLOAT_REGS) ?
double_precision : unspecified_precision));
}
- else if (wasHilighted)
+ else if (was_hilighted)
{
- dataElementPtr->highlight = FALSE;
- _tuiDisplayRegister (
- dataElementPtr->item_no,
- dataItemWinPtr,
+ data_element_ptr->highlight = FALSE;
+ tui_display_register (
+ data_element_ptr->item_no,
+ data_item_win_ptr,
((TUI_DATA_WIN->detail.data_display_info.regs_display_type ==
TUI_DFLOAT_REGS) ?
double_precision : unspecified_precision));
/*
- ** tuiToggleFloatRegs().
+ ** tui_toggle_float_regs().
*/
void
-tuiToggleFloatRegs (void)
+tui_toggle_float_regs (void)
{
- struct tui_layout_def * layoutDef = tui_layout_def ();
+ struct tui_layout_def * layout_def = tui_layout_def ();
- if (layoutDef->float_regs_display_type == TUI_SFLOAT_REGS)
- layoutDef->float_regs_display_type = TUI_DFLOAT_REGS;
+ if (layout_def->float_regs_display_type == TUI_SFLOAT_REGS)
+ layout_def->float_regs_display_type = TUI_DFLOAT_REGS;
else
- layoutDef->float_regs_display_type = TUI_SFLOAT_REGS;
+ layout_def->float_regs_display_type = TUI_SFLOAT_REGS;
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);
+ tui_show_registers (layout_def->float_regs_display_type);
return;
-} /* tuiToggleFloatRegs */
+} /* tui_toggle_float_regs */
void
-_initialize_tuiRegs (void)
+_initialize_tui_regs (void)
{
if (xdb_commands)
{
- add_com ("fr", class_tui, _tuiShowFloat_command,
+ add_com ("fr", class_tui, tui_show_float_command,
"Display only floating point registers\n");
- add_com ("gr", class_tui, _tuiShowGeneral_command,
+ add_com ("gr", class_tui, tui_show_general_command,
"Display only general registers\n");
- add_com ("sr", class_tui, _tuiShowSpecial_command,
+ add_com ("sr", class_tui, tui_show_special_command,
"Display only special registers\n");
- add_com ("+r", class_tui, _tuiScrollRegsForward_command,
+ add_com ("+r", class_tui, tui_scroll_regs_forward_command,
"Scroll the registers window forward\n");
- add_com ("-r", class_tui, _tuiScrollRegsBackward_command,
+ add_com ("-r", class_tui, tui_scroll_regs_backward_command,
"Scroll the register window backward\n");
- add_com ("tf", class_tui, _tuiToggleFloatRegs_command,
+ add_com ("tf", class_tui, _tui_toggle_float_regs_command,
"Toggle between single and double precision floating point registers.\n");
add_cmd (TUI_FLOAT_REGS_NAME_LOWER,
class_tui,
- _tuiToggleFloatRegs_command,
+ _tui_toggle_float_regs_command,
"Toggle between single and double precision floating point \
registers.\n",
&togglelist);
/*
- ** _tuiRegisterName().
+ ** tui_register_name().
** Return the register name.
*/
static const char *
-_tuiRegisterName (int regNum)
+tui_register_name (int reg_num)
{
- return REGISTER_NAME (regNum);
+ return REGISTER_NAME (reg_num);
}
extern int pagination_enabled;
}
/*
- ** _tuiRegisterFormat
+ ** tui_register_format
** Function to format the register name and value into a buffer,
** suitable for printing or display
*/
static void
-_tuiRegisterFormat (char *buf, int bufLen, int regNum,
- struct tui_data_element * dataElement,
+tui_register_format (char *buf, int buf_len, int reg_num,
+ struct tui_data_element * data_element,
enum precision_type precision)
{
struct ui_file *stream;
char *p;
int pos;
- name = REGISTER_NAME (regNum);
+ name = REGISTER_NAME (reg_num);
if (name == 0)
{
strcpy (buf, "");
pagination_enabled = 0;
old_stdout = gdb_stdout;
- stream = tui_sfileopen (bufLen);
+ stream = tui_sfileopen (buf_len);
gdb_stdout = stream;
cleanups = make_cleanup (tui_restore_gdbout, (void*) old_stdout);
gdbarch_print_registers_info (current_gdbarch, stream, deprecated_selected_frame,
- regNum, 1);
+ reg_num, 1);
/* Save formatted output in the buffer. */
p = tui_file_get_strbuf (stream);
pos = 0;
- while (*p && *p == *name++ && bufLen)
+ while (*p && *p == *name++ && buf_len)
{
*buf++ = *p++;
- bufLen--;
+ buf_len--;
pos++;
}
while (*p == ' ')
p++;
- while (pos < 8 && bufLen)
+ while (pos < 8 && buf_len)
{
*buf++ = ' ';
- bufLen--;
+ buf_len--;
pos++;
}
- strncpy (buf, p, bufLen);
+ strncpy (buf, p, buf_len);
/* Remove the possible \n. */
p = strchr (buf, '\n');
#define NUM_GENERAL_REGS 32
-/*
- ** _tuiSetGeneralRegsContent().
- ** Set the content of the data window to consist of the general registers.
- */
+/* Set the content of the data window to consist of the general
+ registers. */
static enum tui_status
-_tuiSetGeneralRegsContent (int refreshValuesOnly)
+tui_set_general_regs_content (int refresh_values_only)
{
- return (_tuiSetRegsContent (0,
+ return (tui_set_regs_content (0,
NUM_GENERAL_REGS - 1,
deprecated_selected_frame,
TUI_GENERAL_REGS,
- refreshValuesOnly));
+ refresh_values_only));
-} /* _tuiSetGeneralRegsContent */
+}
#ifndef PCOQ_HEAD_REGNUM
#define START_SPECIAL_REGS PCOQ_HEAD_REGNUM
#endif
-/*
- ** _tuiSetSpecialRegsContent().
- ** Set the content of the data window to consist of the special registers.
- */
+/* Set the content of the data window to consist of the special
+ registers. */
static enum tui_status
-_tuiSetSpecialRegsContent (int refreshValuesOnly)
+tui_set_special_regs_content (int refresh_values_only)
{
enum tui_status ret = TUI_FAILURE;
- int endRegNum;
+ int end_reg_num;
- endRegNum = FP0_REGNUM - 1;
- ret = _tuiSetRegsContent (START_SPECIAL_REGS,
- endRegNum,
+ end_reg_num = FP0_REGNUM - 1;
+ ret = tui_set_regs_content (START_SPECIAL_REGS,
+ end_reg_num,
deprecated_selected_frame,
TUI_SPECIAL_REGS,
- refreshValuesOnly);
+ refresh_values_only);
return ret;
-} /* _tuiSetSpecialRegsContent */
+}
-/*
- ** _tuiSetGeneralAndSpecialRegsContent().
- ** Set the content of the data window to consist of the special registers.
- */
+/* Set the content of the data window to consist of the special
+ registers. */
static enum tui_status
-_tuiSetGeneralAndSpecialRegsContent (int refreshValuesOnly)
+tui_set_general_and_special_regs_content (int refresh_values_only)
{
enum tui_status ret = TUI_FAILURE;
- int endRegNum = (-1);
+ int end_reg_num = (-1);
- endRegNum = FP0_REGNUM - 1;
- ret = _tuiSetRegsContent (
- 0, endRegNum, deprecated_selected_frame, TUI_SPECIAL_REGS, refreshValuesOnly);
+ end_reg_num = FP0_REGNUM - 1;
+ ret = tui_set_regs_content (
+ 0, end_reg_num, deprecated_selected_frame, TUI_SPECIAL_REGS, refresh_values_only);
return ret;
-} /* _tuiSetGeneralAndSpecialRegsContent */
+}
-/*
- ** _tuiSetFloatRegsContent().
- ** Set the content of the data window to consist of the float registers.
- */
+/* Set the content of the data window to consist of the float
+ registers. */
static enum tui_status
-_tuiSetFloatRegsContent (enum tui_register_display_type dpyType, int refreshValuesOnly)
+tui_set_float_regs_content (enum tui_register_display_type dpy_type,
+ int refresh_values_only)
{
enum tui_status ret = TUI_FAILURE;
- int startRegNum;
+ int start_reg_num;
- startRegNum = FP0_REGNUM;
- ret = _tuiSetRegsContent (startRegNum,
+ start_reg_num = FP0_REGNUM;
+ ret = tui_set_regs_content (start_reg_num,
NUM_REGS - 1,
deprecated_selected_frame,
- dpyType,
- refreshValuesOnly);
+ dpy_type,
+ refresh_values_only);
return ret;
-} /* _tuiSetFloatRegsContent */
+}
-/*
- ** _tuiRegValueHasChanged().
- ** Answer TRUE if the register's value has changed, FALSE otherwise.
- ** If TRUE, newValue is filled in with the new value.
- */
+/* Answer TRUE if the register's value has changed, FALSE otherwise.
+ If TRUE, new_value is filled in with the new value. */
static int
-_tuiRegValueHasChanged (struct tui_data_element * dataElement,
- struct frame_info *frame,
- char *newValue)
+tui_reg_value_has_changed (struct tui_data_element * data_element,
+ struct frame_info *frame, char *new_value)
{
- int hasChanged = FALSE;
+ int has_changed = FALSE;
- if (dataElement->item_no != UNDEFINED_ITEM &&
- _tuiRegisterName (dataElement->item_no) != (char *) NULL)
+ if (data_element->item_no != UNDEFINED_ITEM &&
+ tui_register_name (data_element->item_no) != (char *) NULL)
{
- char rawBuf[MAX_REGISTER_SIZE];
+ char raw_buf[MAX_REGISTER_SIZE];
int i;
- if (_tuiGetRegisterRawValue (
- dataElement->item_no, rawBuf, frame) == TUI_SUCCESS)
+ if (tui_get_register_raw_value (data_element->item_no, raw_buf, frame) == TUI_SUCCESS)
{
- int size = DEPRECATED_REGISTER_RAW_SIZE (dataElement->item_no);
+ int size = DEPRECATED_REGISTER_RAW_SIZE (data_element->item_no);
- for (i = 0; (i < size && !hasChanged); i++)
- hasChanged = (((char *) dataElement->value)[i] != rawBuf[i]);
- if (hasChanged && newValue != (char *) NULL)
+ for (i = 0; (i < size && !has_changed); i++)
+ has_changed = (((char *) data_element->value)[i] != raw_buf[i]);
+ if (has_changed && new_value != (char *) NULL)
{
for (i = 0; i < size; i++)
- newValue[i] = rawBuf[i];
+ new_value[i] = raw_buf[i];
}
}
}
- return hasChanged;
-} /* _tuiRegValueHasChanged */
+ return has_changed;
+}
-/*
- ** _tuiGetRegisterRawValue().
- ** Get the register raw value. The raw value is returned in regValue.
- */
+/* Get the register raw value. The raw value is returned in reg_value. */
static enum tui_status
-_tuiGetRegisterRawValue (int regNum, char *regValue, struct frame_info *frame)
+tui_get_register_raw_value (int reg_num, char *reg_value, struct frame_info *frame)
{
enum tui_status ret = TUI_FAILURE;
if (target_has_registers)
{
- get_frame_register (frame, regNum, regValue);
+ get_frame_register (frame, reg_num, reg_value);
/* NOTE: cagney/2003-03-13: This is bogus. It is refering to
the register cache and not the frame which could have pulled
the register value off the stack. */
- if (register_cached (regNum) >= 0)
+ if (register_cached (reg_num) >= 0)
ret = TUI_SUCCESS;
}
return ret;
-} /* _tuiGetRegisterRawValue */
+}
-/*
- ** _tuiSetRegisterElement().
- ** Function to initialize a data element with the input and
- ** the register value.
- */
+/* Function to initialize a data element with the input and the
+ register value. */
static void
-_tuiSetRegisterElement (int regNum, struct frame_info *frame,
- struct tui_data_element * dataElement,
- int refreshValueOnly)
+tui_set_register_element (int reg_num, struct frame_info *frame,
+ struct tui_data_element * data_element,
+ int refresh_value_only)
{
- if (dataElement != (struct tui_data_element *) NULL)
+ if (data_element != (struct tui_data_element *) NULL)
{
- if (!refreshValueOnly)
+ if (!refresh_value_only)
{
- dataElement->item_no = regNum;
- dataElement->name = _tuiRegisterName (regNum);
- dataElement->highlight = FALSE;
+ data_element->item_no = reg_num;
+ data_element->name = tui_register_name (reg_num);
+ data_element->highlight = FALSE;
}
- if (dataElement->value == NULL)
- dataElement->value = xmalloc (MAX_REGISTER_SIZE);
- if (dataElement->value != NULL)
- _tuiGetRegisterRawValue (regNum, dataElement->value, frame);
+ if (data_element->value == NULL)
+ data_element->value = xmalloc (MAX_REGISTER_SIZE);
+ if (data_element->value != NULL)
+ tui_get_register_raw_value (reg_num, data_element->value, frame);
}
-
- return;
-} /* _tuiSetRegisterElement */
+}
-/*
- ** _tuiSetRegsContent().
- ** Set the content of the data window to consist of the registers
- ** numbered from startRegNum to endRegNum. Note that if
- ** refreshValuesOnly is TRUE, startRegNum and endRegNum are ignored.
- */
+/* Set the content of the data window to consist of the registers
+ numbered from start_reg_num to end_reg_num. Note that if
+ refresh_values_only is TRUE, start_reg_num and end_reg_num are
+ ignored. */
static enum tui_status
-_tuiSetRegsContent (int startRegNum, int endRegNum,
+tui_set_regs_content (int start_reg_num, int end_reg_num,
struct frame_info *frame,
- enum tui_register_display_type dpyType,
- int refreshValuesOnly)
+ enum tui_register_display_type dpy_type,
+ int refresh_values_only)
{
enum tui_status ret = TUI_FAILURE;
- int numRegs = endRegNum - startRegNum + 1;
- int allocatedHere = FALSE;
+ int num_regs = end_reg_num - start_reg_num + 1;
+ int allocated_here = FALSE;
if (TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0 &&
- !refreshValuesOnly)
+ !refresh_values_only)
{
tui_free_data_content (TUI_DATA_WIN->detail.data_display_info.regs_content,
TUI_DATA_WIN->detail.data_display_info.regs_content_count);
if (TUI_DATA_WIN->detail.data_display_info.regs_content_count <= 0)
{
TUI_DATA_WIN->detail.data_display_info.regs_content =
- tui_alloc_content (numRegs, DATA_WIN);
- allocatedHere = TRUE;
+ tui_alloc_content (num_regs, DATA_WIN);
+ allocated_here = TRUE;
}
if (TUI_DATA_WIN->detail.data_display_info.regs_content != (tui_win_content) NULL)
{
int i;
- if (!refreshValuesOnly || allocatedHere)
+ if (!refresh_values_only || allocated_here)
{
TUI_DATA_WIN->generic.content = NULL;
TUI_DATA_WIN->generic.content_size = 0;
- tui_add_content_elements (&TUI_DATA_WIN->generic, numRegs);
+ tui_add_content_elements (&TUI_DATA_WIN->generic, num_regs);
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;
+ TUI_DATA_WIN->detail.data_display_info.regs_content_count = num_regs;
}
/*
** Now set the register names and values
*/
- for (i = startRegNum; (i <= endRegNum); i++)
+ for (i = start_reg_num; (i <= end_reg_num); i++)
{
- struct tui_gen_win_info * dataItemWin;
+ struct tui_gen_win_info * data_item_win;
- dataItemWin = &TUI_DATA_WIN->detail.data_display_info.
- regs_content[i - startRegNum]->which_element.data_window;
- _tuiSetRegisterElement (
+ data_item_win = &TUI_DATA_WIN->detail.data_display_info.
+ regs_content[i - start_reg_num]->which_element.data_window;
+ tui_set_register_element (
i,
frame,
- &((struct tui_win_element *) dataItemWin->content[0])->which_element.data,
- !allocatedHere && refreshValuesOnly);
+ &((struct tui_win_element *) data_item_win->content[0])->which_element.data,
+ !allocated_here && refresh_values_only);
}
TUI_DATA_WIN->detail.data_display_info.regs_column_count =
- tui_calculate_regs_column_count (dpyType);
+ tui_calculate_regs_column_count (dpy_type);
#ifdef LATER
if (TUI_DATA_WIN->detail.data_display_info.data_content_count > 0)
{
/* delete all the windows? */
/* realloc content equal to data_content_count + regs_content_count */
- /* append TUI_DATA_WIN->detail.data_display_info.dataContent to content */
+ /* append TUI_DATA_WIN->detail.data_display_info.data_content to content */
}
#endif
TUI_DATA_WIN->generic.content_size =
}
return ret;
-} /* _tuiSetRegsContent */
+}
-/*
- ** _tuiDisplayRegister().
- ** Function to display a register in a window. If hilite is TRUE,
- ** than the value will be displayed in reverse video
- */
+/* Function to display a register in a window. If hilite is TRUE,
+ than the value will be displayed in reverse video. */
static void
-_tuiDisplayRegister (int regNum,
- struct tui_gen_win_info * winInfo, /* the data item window */
+tui_display_register (int reg_num,
+ struct tui_gen_win_info * win_info, /* the data item window */
enum precision_type precision)
{
- if (winInfo->handle != (WINDOW *) NULL)
+ if (win_info->handle != (WINDOW *) NULL)
{
int i;
char buf[40];
- int valueCharsWide, labelWidth;
- struct tui_data_element * dataElementPtr = &((tui_win_content)
- winInfo->content)[0]->which_element.data;
+ int value_chars_wide, label_width;
+ struct tui_data_element * data_element_ptr = &((tui_win_content)
+ win_info->content)[0]->which_element.data;
if (IS_64BIT ||
TUI_DATA_WIN->detail.data_display_info.regs_display_type == TUI_DFLOAT_REGS)
{
- valueCharsWide = DOUBLE_FLOAT_VALUE_WIDTH;
- labelWidth = DOUBLE_FLOAT_LABEL_WIDTH;
+ value_chars_wide = DOUBLE_FLOAT_VALUE_WIDTH;
+ label_width = DOUBLE_FLOAT_LABEL_WIDTH;
}
else
{
if (TUI_DATA_WIN->detail.data_display_info.regs_display_type ==
TUI_SFLOAT_REGS)
{
- valueCharsWide = SINGLE_FLOAT_VALUE_WIDTH;
- labelWidth = SINGLE_FLOAT_LABEL_WIDTH;
+ value_chars_wide = SINGLE_FLOAT_VALUE_WIDTH;
+ label_width = SINGLE_FLOAT_LABEL_WIDTH;
}
else
{
- valueCharsWide = SINGLE_VALUE_WIDTH;
- labelWidth = SINGLE_LABEL_WIDTH;
+ value_chars_wide = SINGLE_VALUE_WIDTH;
+ label_width = SINGLE_LABEL_WIDTH;
}
}
buf[0] = (char) 0;
- _tuiRegisterFormat (buf,
- valueCharsWide + labelWidth,
- regNum,
- dataElementPtr,
+ tui_register_format (buf,
+ value_chars_wide + label_width,
+ reg_num,
+ data_element_ptr,
precision);
- if (dataElementPtr->highlight)
- wstandout (winInfo->handle);
+ if (data_element_ptr->highlight)
+ wstandout (win_info->handle);
- wmove (winInfo->handle, 0, 0);
- for (i = 1; i < winInfo->width; i++)
- waddch (winInfo->handle, ' ');
- wmove (winInfo->handle, 0, 0);
- waddstr (winInfo->handle, buf);
+ wmove (win_info->handle, 0, 0);
+ for (i = 1; i < win_info->width; i++)
+ waddch (win_info->handle, ' ');
+ wmove (win_info->handle, 0, 0);
+ waddstr (win_info->handle, buf);
- if (dataElementPtr->highlight)
- wstandend (winInfo->handle);
- tui_refresh_win (winInfo);
+ if (data_element_ptr->highlight)
+ wstandend (win_info->handle);
+ tui_refresh_win (win_info);
}
- return;
-} /* _tuiDisplayRegister */
+}
static void
-_tui_vShowRegisters_commandSupport (enum tui_register_display_type dpyType)
+tui_v_show_registers_command_support (enum tui_register_display_type dpy_type)
{
if (TUI_DATA_WIN != NULL && TUI_DATA_WIN->generic.is_visible)
{ /* Data window already displayed, show the registers */
- if (TUI_DATA_WIN->detail.data_display_info.regs_display_type != dpyType)
- tui_show_registers (dpyType);
+ if (TUI_DATA_WIN->detail.data_display_info.regs_display_type != dpy_type)
+ tui_show_registers (dpy_type);
}
else
- (tui_layout_def ())->regs_display_type = dpyType;
+ (tui_layout_def ())->regs_display_type = dpy_type;
return;
-} /* _tui_vShowRegisters_commandSupport */
+}
static void
-_tuiShowFloat_command (char *arg, int fromTTY)
+tui_show_float_command (char *arg, int from_tty)
{
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 */
+ tui_v_show_registers_command_support ((tui_layout_def ())->float_regs_display_type);
+}
static void
-_tuiShowGeneral_command (char *arg, int fromTTY)
+tui_show_general_command (char *arg, int from_tty)
{
- _tui_vShowRegisters_commandSupport (TUI_GENERAL_REGS);
+ tui_v_show_registers_command_support (TUI_GENERAL_REGS);
}
static void
-_tuiShowSpecial_command (char *arg, int fromTTY)
+tui_show_special_command (char *arg, int from_tty)
{
- _tui_vShowRegisters_commandSupport (TUI_SPECIAL_REGS);
+ tui_v_show_registers_command_support (TUI_SPECIAL_REGS);
}
static void
-_tuiToggleFloatRegs_command (char *arg, int fromTTY)
+_tui_toggle_float_regs_command (char *arg, int from_tty)
{
if (TUI_DATA_WIN != NULL && TUI_DATA_WIN->generic.is_visible)
- tuiToggleFloatRegs ();
+ tui_toggle_float_regs ();
else
{
- struct tui_layout_def * layoutDef = tui_layout_def ();
+ struct tui_layout_def * layout_def = tui_layout_def ();
- if (layoutDef->float_regs_display_type == TUI_SFLOAT_REGS)
- layoutDef->float_regs_display_type = TUI_DFLOAT_REGS;
+ if (layout_def->float_regs_display_type == TUI_SFLOAT_REGS)
+ layout_def->float_regs_display_type = TUI_DFLOAT_REGS;
else
- layoutDef->float_regs_display_type = TUI_SFLOAT_REGS;
+ layout_def->float_regs_display_type = TUI_SFLOAT_REGS;
}
-
-
- return;
-} /* _tuiToggleFloatRegs_command */
+}
static void
-_tuiScrollRegsForward_command (char *arg, int fromTTY)
+tui_scroll_regs_forward_command (char *arg, int from_tty)
{
tui_scroll (FORWARD_SCROLL, TUI_DATA_WIN, 1);
}
static void
-_tuiScrollRegsBackward_command (char *arg, int fromTTY)
+tui_scroll_regs_backward_command (char *arg, int from_tty)
{
tui_scroll (BACKWARD_SCROLL, TUI_DATA_WIN, 1);
}
if (s != (struct symtab *) NULL && s->filename != (char *) NULL)
{
register FILE *stream;
- register int i, desc, c, lineWidth, nlines;
- register char *srcLine = 0;
+ register int i, desc, c, line_width, nlines;
+ register char *src_line = 0;
if ((ret = tui_alloc_source_buffer (TUI_SRC_WIN)) == TUI_SUCCESS)
{
- lineWidth = TUI_SRC_WIN->generic.width - 1;
+ line_width = TUI_SRC_WIN->generic.width - 1;
/* Take hilite (window border) into account, when calculating
the number of lines */
nlines = (line_no + (TUI_SRC_WIN->generic.height - 2)) - line_no;
}
else
{
- register int offset, curLineNo, curLine, curLen, threshold;
+ register int offset, cur_line_no, cur_line, cur_len, threshold;
struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
struct tui_source_info * src = &TUI_SRC_WIN->detail.source_info;
/* Determine the threshold for the length of the line
and the offset to start the display. */
offset = src->horizontal_offset;
- threshold = (lineWidth - 1) + offset;
+ threshold = (line_width - 1) + offset;
stream = fdopen (desc, FOPEN_RT);
clearerr (stream);
- curLine = 0;
- curLineNo = src->start_line_or_addr.line_no = line_no;
+ cur_line = 0;
+ cur_line_no = src->start_line_or_addr.line_no = line_no;
if (offset > 0)
- srcLine = (char *) xmalloc (
+ src_line = (char *) xmalloc (
(threshold + 1) * sizeof (char));
- while (curLine < nlines)
+ while (cur_line < nlines)
{
struct tui_win_element * element = (struct tui_win_element *)
- TUI_SRC_WIN->generic.content[curLine];
+ TUI_SRC_WIN->generic.content[cur_line];
/* get the first character in the line */
c = fgetc (stream);
if (offset == 0)
- srcLine = ((struct tui_win_element *)
+ src_line = ((struct tui_win_element *)
TUI_SRC_WIN->generic.content[
- curLine])->which_element.source.line;
+ cur_line])->which_element.source.line;
/* Init the line with the line number */
- sprintf (srcLine, "%-6d", curLineNo);
- curLen = strlen (srcLine);
- i = curLen -
- ((curLen / tui_default_tab_len ()) * tui_default_tab_len ());
+ sprintf (src_line, "%-6d", cur_line_no);
+ cur_len = strlen (src_line);
+ i = cur_len -
+ ((cur_len / tui_default_tab_len ()) * tui_default_tab_len ());
while (i < tui_default_tab_len ())
{
- srcLine[curLen] = ' ';
+ src_line[cur_len] = ' ';
i++;
- curLen++;
+ cur_len++;
}
- srcLine[curLen] = (char) 0;
+ src_line[cur_len] = (char) 0;
/* Set whether element is the execution point and
whether there is a break point on it. */
element->which_element.source.line_or_addr.line_no =
- curLineNo;
+ cur_line_no;
element->which_element.source.is_exec_point =
(strcmp (((struct tui_win_element *)
locator->content[0])->which_element.locator.file_name,
s->filename) == 0
- && curLineNo == ((struct tui_win_element *)
+ && cur_line_no == ((struct tui_win_element *)
locator->content[0])->which_element.locator.line_no);
if (c != EOF)
{
- i = strlen (srcLine) - 1;
+ i = strlen (src_line) - 1;
do
{
if ((c != '\n') &&
{
if (c < 040 && c != '\t')
{
- srcLine[i++] = '^';
- srcLine[i] = c + 0100;
+ src_line[i++] = '^';
+ src_line[i] = c + 0100;
}
else if (c == 0177)
{
- srcLine[i++] = '^';
- srcLine[i] = '?';
+ src_line[i++] = '^';
+ src_line[i] = '?';
}
else
{ /* Store the charcter in the line
buffer. */
if (c == '\t')
{
- int j, maxTabLen = tui_default_tab_len ();
+ int j, max_tab_len = tui_default_tab_len ();
for (j = i - (
- (i / maxTabLen) * maxTabLen);
- ((j < maxTabLen) &&
+ (i / max_tab_len) * max_tab_len);
+ ((j < max_tab_len) &&
i < threshold);
i++, j++)
- srcLine[i] = ' ';
+ src_line[i] = ' ';
i--;
}
else
- srcLine[i] = c;
+ src_line[i] = c;
}
- srcLine[i + 1] = 0;
+ src_line[i + 1] = 0;
}
else
{ /* If we have not reached EOL, then eat
i < threshold && (c = fgetc (stream)));
}
/* Now copy the line taking the offset into account */
- if (strlen (srcLine) > offset)
+ if (strlen (src_line) > offset)
strcpy (((struct tui_win_element *) TUI_SRC_WIN->generic.content[
- curLine])->which_element.source.line,
- &srcLine[offset]);
+ cur_line])->which_element.source.line,
+ &src_line[offset]);
else
((struct tui_win_element *)
TUI_SRC_WIN->generic.content[
- curLine])->which_element.source.line[0] = (char) 0;
- curLine++;
- curLineNo++;
+ cur_line])->which_element.source.line[0] = (char) 0;
+ cur_line++;
+ cur_line_no++;
}
if (offset > 0)
- xfree (srcLine);
+ xfree (src_line);
fclose (stream);
TUI_SRC_WIN->generic.content_size = nlines;
ret = TUI_SUCCESS;
/* elz: this function sets the contents of the source window to empty
except for a line in the middle with a warning message about the
source not being available. This function is called by
- tuiEraseSourceContents, which in turn is invoked when the source
- files cannot be accessed. */
+ tui_erase_source_contents(), which in turn is invoked when the
+ source files cannot be accessed. */
void
-tui_set_source_content_nil (struct tui_win_info * winInfo, char *warning_string)
+tui_set_source_content_nil (struct tui_win_info * win_info, char *warning_string)
{
- int lineWidth;
- int nLines;
+ int line_width;
+ int n_lines;
int curr_line = 0;
- lineWidth = winInfo->generic.width - 1;
- nLines = winInfo->generic.height - 2;
+ line_width = win_info->generic.width - 1;
+ n_lines = win_info->generic.height - 2;
/* set to empty each line in the window, except for the one
which contains the message */
- while (curr_line < winInfo->generic.content_size)
+ while (curr_line < win_info->generic.content_size)
{
/* set the information related to each displayed line
to null: i.e. the line number is 0, there is no bp,
it is not where the program is stopped */
struct tui_win_element * element =
- (struct tui_win_element *) winInfo->generic.content[curr_line];
+ (struct tui_win_element *) win_info->generic.content[curr_line];
element->which_element.source.line_or_addr.line_no = 0;
element->which_element.source.is_exec_point = FALSE;
element->which_element.source.has_break = FALSE;
/* set the contents of the line to blank */
element->which_element.source.line[0] = (char) 0;
- /* if the current line is in the middle of the screen, then we want to
- display the 'no source available' message in it.
- Note: the 'weird' arithmetic with the line width and height comes from
- the function tuiEraseSourceContent. We need to keep the screen and the
- window's actual contents in synch */
+ /* if the current line is in the middle of the screen, then we
+ want to display the 'no source available' message in it.
+ Note: the 'weird' arithmetic with the line width and height
+ comes from the function tui_erase_source_content(). We need
+ to keep the screen and the window's actual contents in synch. */
- if (curr_line == (nLines / 2 + 1))
+ if (curr_line == (n_lines / 2 + 1))
{
int i;
int xpos;
int warning_length = strlen (warning_string);
- char *srcLine;
+ char *src_line;
- srcLine = element->which_element.source.line;
+ src_line = element->which_element.source.line;
- if (warning_length >= ((lineWidth - 1) / 2))
+ if (warning_length >= ((line_width - 1) / 2))
xpos = 1;
else
- xpos = (lineWidth - 1) / 2 - warning_length;
+ xpos = (line_width - 1) / 2 - warning_length;
for (i = 0; i < xpos; i++)
- srcLine[i] = ' ';
+ src_line[i] = ' ';
- sprintf (srcLine + i, "%s", warning_string);
+ sprintf (src_line + i, "%s", warning_string);
- for (i = xpos + warning_length; i < lineWidth; i++)
- srcLine[i] = ' ';
+ for (i = xpos + warning_length; i < line_width; i++)
+ src_line[i] = ' ';
- srcLine[i] = '\n';
+ src_line[i] = '\n';
} /* end if */
/* Scroll the source forward or backward vertically. */
void
-tui_vertical_source_scroll (enum tui_scroll_direction scrollDirection,
- int numToScroll)
+tui_vertical_source_scroll (enum tui_scroll_direction scroll_direction,
+ int num_to_scroll)
{
if (TUI_SRC_WIN->generic.content != NULL)
{
else
s = cursal.symtab;
- if (scrollDirection == FORWARD_SCROLL)
+ if (scroll_direction == FORWARD_SCROLL)
{
l.line_no = content[0]->which_element.source.line_or_addr.line_no +
- numToScroll;
+ num_to_scroll;
if (l.line_no > s->nlines)
- /*line = s->nlines - winInfo->generic.content_size + 1; */
+ /*line = s->nlines - win_info->generic.content_size + 1; */
/*elz: fix for dts 23398 */
l.line_no = content[0]->which_element.source.line_or_addr.line_no;
}
else
{
l.line_no = content[0]->which_element.source.line_or_addr.line_no -
- numToScroll;
+ num_to_scroll;
if (l.line_no <= 0)
l.line_no = 1;
}
return name;
}
-/* tuiShowLocatorContent(). */
void
tui_show_locator_content (void)
{
register int start_line, i;
CORE_ADDR low;
struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
- int sourceAlreadyDisplayed;
+ int source_already_displayed;
struct symtab_and_line sal;
find_frame_sal (fi, &sal);
- sourceAlreadyDisplayed = sal.symtab != 0
+ source_already_displayed = sal.symtab != 0
&& tui_source_is_displayed (sal.symtab->filename);
tui_set_locator_info (sal.symtab == 0 ? "??" : sal.symtab->filename,
tui_get_function_from_frame (fi),
{
union tui_line_or_address l;
l.line_no = start_line;
- if (!(sourceAlreadyDisplayed
+ if (!(source_already_displayed
&& tui_line_is_displayed (item->locator.line_no, win_info, TRUE)))
tui_update_source_window (win_info, sal.symtab, l, TRUE);
else
}
}
-/* Function to initialize gdb commands, for tui window stack manipulation. */
+/* Function to initialize gdb commands, for tui window stack
+ manipulation. */
void
-_initialize_tuiStack (void)
+_initialize_tui_stack (void)
{
add_com ("update", class_tui, tui_update_command,
"Update the source window and locator to display the current "
/*******************************
** Static Local Decls
********************************/
-static void _makeVisibleWithNewHeight (struct tui_win_info *);
-static void _makeInvisibleAndSetNewHeight (struct tui_win_info *, int);
-static enum tui_status _tuiAdjustWinHeights (struct tui_win_info *, int);
-static int _newHeightOk (struct tui_win_info *, int);
-static void _tuiSetTabWidth_command (char *, int);
-static void _tuiRefreshAll_command (char *, int);
-static void _tuiSetWinHeight_command (char *, int);
-static void _tuiXDBsetWinHeight_command (char *, int);
-static void _tuiAllWindowsInfo (char *, int);
-static void _tuiSetFocus_command (char *, int);
-static void _tuiScrollForward_command (char *, int);
-static void _tuiScrollBackward_command (char *, int);
-static void _tuiScrollLeft_command (char *, int);
-static void _tuiScrollRight_command (char *, int);
-static void _parseScrollingArgs (char *, struct tui_win_info * *, int *);
+static void make_visible_with_new_height (struct tui_win_info *);
+static void make_invisible_and_set_new_height (struct tui_win_info *, int);
+static enum tui_status tui_adjust_win_heights (struct tui_win_info *, int);
+static int new_height_ok (struct tui_win_info *, int);
+static void tui_set_tab_width_command (char *, int);
+static void tui_refresh_all_command (char *, int);
+static void tui_set_win_height_command (char *, int);
+static void tui_xdb_set_win_height_command (char *, int);
+static void tui_all_windows_info (char *, int);
+static void tui_set_focus_command (char *, int);
+static void tui_scroll_forward_command (char *, int);
+static void tui_scroll_backward_command (char *, int);
+static void tui_scroll_left_command (char *, int);
+static void tui_scroll_right_command (char *, int);
+static void parse_scrolling_args (char *, struct tui_win_info * *, int *);
/***************************************
{
}
-/*
- ** _initialize_tuiWin().
- ** Function to initialize gdb commands, for tui window manipulation.
- */
+/* Function to initialize gdb commands, for tui window manipulation. */
void
-_initialize_tuiWin (void)
+_initialize_tui_win (void)
{
struct cmd_list_element *c;
static struct cmd_list_element *tui_setlist;
&tui_showlist, "show tui ",
0/*allow-unknown*/, &showlist);
- add_com ("refresh", class_tui, _tuiRefreshAll_command,
+ add_com ("refresh", class_tui, tui_refresh_all_command,
"Refresh the terminal display.\n");
if (xdb_commands)
add_com_alias ("U", "refresh", class_tui, 0);
- add_com ("tabset", class_tui, _tuiSetTabWidth_command,
+ add_com ("tabset", class_tui, tui_set_tab_width_command,
"Set the width (in characters) of tab stops.\n\
Usage: tabset <n>\n");
- add_com ("winheight", class_tui, _tuiSetWinHeight_command,
+ add_com ("winheight", class_tui, tui_set_win_height_command,
"Set the height of a specified window.\n\
Usage: winheight <win_name> [+ | -] <#lines>\n\
Window names are:\n\
asm : the disassembly window\n\
regs : the register display\n");
add_com_alias ("wh", "winheight", class_tui, 0);
- add_info ("win", _tuiAllWindowsInfo,
+ add_info ("win", tui_all_windows_info,
"List of all displayed windows.\n");
- add_com ("focus", class_tui, _tuiSetFocus_command,
+ add_com ("focus", class_tui, tui_set_focus_command,
"Set focus to named window or next/prev window.\n\
Usage: focus {<win> | next | prev}\n\
Valid Window names are:\n\
regs : the register display\n\
cmd : the command window\n");
add_com_alias ("fs", "focus", class_tui, 0);
- add_com ("+", class_tui, _tuiScrollForward_command,
+ add_com ("+", class_tui, tui_scroll_forward_command,
"Scroll window forward.\nUsage: + [win] [n]\n");
- add_com ("-", class_tui, _tuiScrollBackward_command,
+ add_com ("-", class_tui, tui_scroll_backward_command,
"Scroll window backward.\nUsage: - [win] [n]\n");
- add_com ("<", class_tui, _tuiScrollLeft_command,
+ add_com ("<", class_tui, tui_scroll_left_command,
"Scroll window forward.\nUsage: < [win] [n]\n");
- add_com (">", class_tui, _tuiScrollRight_command,
+ add_com (">", class_tui, tui_scroll_right_command,
"Scroll window backward.\nUsage: > [win] [n]\n");
if (xdb_commands)
- add_com ("w", class_xdb, _tuiXDBsetWinHeight_command,
+ add_com ("w", class_xdb, tui_xdb_set_win_height_command,
"XDB compatibility command for setting the height of a command window.\n\
Usage: w <#lines>\n");
{
if (win_info != NULL)
{
- struct tui_win_info * winWithFocus = tui_win_with_focus ();
+ struct tui_win_info * win_with_focus = tui_win_with_focus ();
- if (winWithFocus != NULL
- && winWithFocus->generic.type != CMD_WIN)
- tui_unhighlight_win (winWithFocus);
+ if (win_with_focus != NULL
+ && win_with_focus->generic.type != CMD_WIN)
+ tui_unhighlight_win (win_with_focus);
tui_set_win_with_focus (win_info);
if (win_info->generic.type != CMD_WIN)
tui_highlight_win (win_info);
}
-
- return;
-} /* tuiSetWinFocusTo */
+}
void
-tui_scroll_forward (struct tui_win_info * winToScroll, int numToScroll)
+tui_scroll_forward (struct tui_win_info * win_to_scroll, int num_to_scroll)
{
- if (winToScroll != TUI_CMD_WIN)
+ if (win_to_scroll != TUI_CMD_WIN)
{
- int _numToScroll = numToScroll;
+ int _num_to_scroll = num_to_scroll;
- if (numToScroll == 0)
- _numToScroll = winToScroll->generic.height - 3;
+ if (num_to_scroll == 0)
+ _num_to_scroll = win_to_scroll->generic.height - 3;
/*
** If we are scrolling the source or disassembly window, do a
** "psuedo" scroll since not all of the source is in memory,
- ** only what is in the viewport. If winToScroll is the
+ ** only what is in the viewport. If win_to_scroll is the
** command window do nothing since the term should handle it.
*/
- if (winToScroll == TUI_SRC_WIN)
- tui_vertical_source_scroll (FORWARD_SCROLL, _numToScroll);
- else if (winToScroll == TUI_DISASM_WIN)
- tui_vertical_disassem_scroll (FORWARD_SCROLL, _numToScroll);
- else if (winToScroll == TUI_DATA_WIN)
- tui_vertical_data_scroll (FORWARD_SCROLL, _numToScroll);
+ if (win_to_scroll == TUI_SRC_WIN)
+ tui_vertical_source_scroll (FORWARD_SCROLL, _num_to_scroll);
+ else if (win_to_scroll == TUI_DISASM_WIN)
+ tui_vertical_disassem_scroll (FORWARD_SCROLL, _num_to_scroll);
+ else if (win_to_scroll == TUI_DATA_WIN)
+ tui_vertical_data_scroll (FORWARD_SCROLL, _num_to_scroll);
}
}
void
-tui_scroll_backward (struct tui_win_info * winToScroll, int numToScroll)
+tui_scroll_backward (struct tui_win_info * win_to_scroll, int num_to_scroll)
{
- if (winToScroll != TUI_CMD_WIN)
+ if (win_to_scroll != TUI_CMD_WIN)
{
- int _numToScroll = numToScroll;
+ int _num_to_scroll = num_to_scroll;
- if (numToScroll == 0)
- _numToScroll = winToScroll->generic.height - 3;
+ if (num_to_scroll == 0)
+ _num_to_scroll = win_to_scroll->generic.height - 3;
/*
** If we are scrolling the source or disassembly window, do a
** "psuedo" scroll since not all of the source is in memory,
- ** only what is in the viewport. If winToScroll is the
+ ** only what is in the viewport. If win_to_scroll is the
** command window do nothing since the term should handle it.
*/
- if (winToScroll == TUI_SRC_WIN)
- tui_vertical_source_scroll (BACKWARD_SCROLL, _numToScroll);
- else if (winToScroll == TUI_DISASM_WIN)
- tui_vertical_disassem_scroll (BACKWARD_SCROLL, _numToScroll);
- else if (winToScroll == TUI_DATA_WIN)
- tui_vertical_data_scroll (BACKWARD_SCROLL, _numToScroll);
+ if (win_to_scroll == TUI_SRC_WIN)
+ tui_vertical_source_scroll (BACKWARD_SCROLL, _num_to_scroll);
+ else if (win_to_scroll == TUI_DISASM_WIN)
+ tui_vertical_disassem_scroll (BACKWARD_SCROLL, _num_to_scroll);
+ else if (win_to_scroll == TUI_DATA_WIN)
+ tui_vertical_data_scroll (BACKWARD_SCROLL, _num_to_scroll);
}
}
void
-tui_scroll_left (struct tui_win_info * winToScroll, int numToScroll)
+tui_scroll_left (struct tui_win_info * win_to_scroll, int num_to_scroll)
{
- if (winToScroll != TUI_CMD_WIN)
+ if (win_to_scroll != TUI_CMD_WIN)
{
- int _numToScroll = numToScroll;
+ int _num_to_scroll = num_to_scroll;
- if (_numToScroll == 0)
- _numToScroll = 1;
+ if (_num_to_scroll == 0)
+ _num_to_scroll = 1;
/*
** If we are scrolling the source or disassembly window, do a
** "psuedo" scroll since not all of the source is in memory,
- ** only what is in the viewport. If winToScroll is the
+ ** only what is in the viewport. If win_to_scroll is the
** command window do nothing since the term should handle it.
*/
- if (winToScroll == TUI_SRC_WIN || winToScroll == TUI_DISASM_WIN)
- tui_horizontal_source_scroll (winToScroll, LEFT_SCROLL, _numToScroll);
+ if (win_to_scroll == TUI_SRC_WIN || win_to_scroll == TUI_DISASM_WIN)
+ tui_horizontal_source_scroll (win_to_scroll, LEFT_SCROLL, _num_to_scroll);
}
}
void
-tui_scroll_right (struct tui_win_info * winToScroll, int numToScroll)
+tui_scroll_right (struct tui_win_info * win_to_scroll, int num_to_scroll)
{
- if (winToScroll != TUI_CMD_WIN)
+ if (win_to_scroll != TUI_CMD_WIN)
{
- int _numToScroll = numToScroll;
+ int _num_to_scroll = num_to_scroll;
- if (_numToScroll == 0)
- _numToScroll = 1;
+ if (_num_to_scroll == 0)
+ _num_to_scroll = 1;
/*
** If we are scrolling the source or disassembly window, do a
** "psuedo" scroll since not all of the source is in memory,
- ** only what is in the viewport. If winToScroll is the
+ ** only what is in the viewport. If win_to_scroll is the
** command window do nothing since the term should handle it.
*/
- if (winToScroll == TUI_SRC_WIN || winToScroll == TUI_DISASM_WIN)
- tui_horizontal_source_scroll (winToScroll, RIGHT_SCROLL, _numToScroll);
+ if (win_to_scroll == TUI_SRC_WIN || win_to_scroll == TUI_DISASM_WIN)
+ tui_horizontal_source_scroll (win_to_scroll, RIGHT_SCROLL, _num_to_scroll);
}
}
/* Scroll a window. Arguments are passed through a va_list. */
void
tui_scroll (enum tui_scroll_direction direction,
- struct tui_win_info * winToScroll,
- int numToScroll)
+ struct tui_win_info * win_to_scroll,
+ int num_to_scroll)
{
switch (direction)
{
case FORWARD_SCROLL:
- tui_scroll_forward (winToScroll, numToScroll);
+ tui_scroll_forward (win_to_scroll, num_to_scroll);
break;
case BACKWARD_SCROLL:
- tui_scroll_backward (winToScroll, numToScroll);
+ tui_scroll_backward (win_to_scroll, num_to_scroll);
break;
case LEFT_SCROLL:
- tui_scroll_left (winToScroll, numToScroll);
+ tui_scroll_left (win_to_scroll, num_to_scroll);
break;
case RIGHT_SCROLL:
- tui_scroll_right (winToScroll, numToScroll);
+ tui_scroll_right (win_to_scroll, num_to_scroll);
break;
default:
break;
}
-/*
- ** tuiResizeAll().
- ** Resize all the windows based on the the terminal size. This
- ** function gets called from within the readline sinwinch handler.
- */
+/* Resize all the windows based on the the terminal size. This
+ function gets called from within the readline sinwinch handler. */
void
-tuiResizeAll (void)
+tui_resize_all (void)
{
- int heightDiff, widthDiff;
+ int height_diff, width_diff;
int screenheight, screenwidth;
rl_get_screen_size (&screenheight, &screenwidth);
- widthDiff = screenwidth - tui_term_width ();
- heightDiff = screenheight - tui_term_height ();
- if (heightDiff || widthDiff)
+ width_diff = screenwidth - tui_term_width ();
+ height_diff = screenheight - tui_term_height ();
+ if (height_diff || width_diff)
{
- enum tui_layout_type curLayout = tui_current_layout ();
- struct tui_win_info * winWithFocus = tui_win_with_focus ();
- struct tui_win_info *firstWin;
- struct tui_win_info *secondWin;
+ enum tui_layout_type cur_layout = tui_current_layout ();
+ struct tui_win_info * win_with_focus = tui_win_with_focus ();
+ struct tui_win_info *first_win;
+ struct tui_win_info *second_win;
struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
- enum tui_win_type winType;
- int newHeight, splitDiff, cmdSplitDiff, numWinsDisplayed = 2;
+ enum tui_win_type win_type;
+ int new_height, split_diff, cmd_split_diff, num_wins_displayed = 2;
/* turn keypad off while we resize */
- if (winWithFocus != TUI_CMD_WIN)
+ if (win_with_focus != TUI_CMD_WIN)
keypad (TUI_CMD_WIN->generic.handle, FALSE);
tui_update_gdb_sizes ();
tui_set_term_height_to (screenheight);
tui_set_term_width_to (screenwidth);
- if (curLayout == SRC_DISASSEM_COMMAND ||
- curLayout == SRC_DATA_COMMAND || curLayout == DISASSEM_DATA_COMMAND)
- numWinsDisplayed++;
- splitDiff = heightDiff / numWinsDisplayed;
- cmdSplitDiff = splitDiff;
- if (heightDiff % numWinsDisplayed)
+ if (cur_layout == SRC_DISASSEM_COMMAND ||
+ cur_layout == SRC_DATA_COMMAND || cur_layout == DISASSEM_DATA_COMMAND)
+ num_wins_displayed++;
+ split_diff = height_diff / num_wins_displayed;
+ cmd_split_diff = split_diff;
+ if (height_diff % num_wins_displayed)
{
- if (heightDiff < 0)
- cmdSplitDiff--;
+ if (height_diff < 0)
+ cmd_split_diff--;
else
- cmdSplitDiff++;
+ cmd_split_diff++;
}
/* now adjust each window */
clear ();
refresh ();
- switch (curLayout)
+ switch (cur_layout)
{
case SRC_COMMAND:
case DISASSEM_COMMAND:
- firstWin = (struct tui_win_info *) (tui_source_windows ())->list[0];
- firstWin->generic.width += widthDiff;
- locator->width += widthDiff;
+ first_win = (struct tui_win_info *) (tui_source_windows ())->list[0];
+ first_win->generic.width += width_diff;
+ locator->width += width_diff;
/* check for invalid heights */
- if (heightDiff == 0)
- newHeight = firstWin->generic.height;
- else if ((firstWin->generic.height + splitDiff) >=
+ if (height_diff == 0)
+ new_height = first_win->generic.height;
+ else if ((first_win->generic.height + split_diff) >=
(screenheight - MIN_CMD_WIN_HEIGHT - 1))
- newHeight = screenheight - MIN_CMD_WIN_HEIGHT - 1;
- else if ((firstWin->generic.height + splitDiff) <= 0)
- newHeight = MIN_WIN_HEIGHT;
+ new_height = screenheight - MIN_CMD_WIN_HEIGHT - 1;
+ else if ((first_win->generic.height + split_diff) <= 0)
+ new_height = MIN_WIN_HEIGHT;
else
- newHeight = firstWin->generic.height + splitDiff;
+ new_height = first_win->generic.height + split_diff;
- _makeInvisibleAndSetNewHeight (firstWin, newHeight);
+ make_invisible_and_set_new_height (first_win, new_height);
TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
- TUI_CMD_WIN->generic.width += widthDiff;
- newHeight = screenheight - TUI_CMD_WIN->generic.origin.y;
- _makeInvisibleAndSetNewHeight (TUI_CMD_WIN, newHeight);
- _makeVisibleWithNewHeight (firstWin);
- _makeVisibleWithNewHeight (TUI_CMD_WIN);
- if (firstWin->generic.content_size <= 0)
- tui_erase_source_content (firstWin, EMPTY_SOURCE_PROMPT);
+ TUI_CMD_WIN->generic.width += width_diff;
+ new_height = screenheight - TUI_CMD_WIN->generic.origin.y;
+ make_invisible_and_set_new_height (TUI_CMD_WIN, new_height);
+ make_visible_with_new_height (first_win);
+ make_visible_with_new_height (TUI_CMD_WIN);
+ if (first_win->generic.content_size <= 0)
+ tui_erase_source_content (first_win, EMPTY_SOURCE_PROMPT);
break;
default:
- if (curLayout == SRC_DISASSEM_COMMAND)
+ if (cur_layout == SRC_DISASSEM_COMMAND)
{
- firstWin = TUI_SRC_WIN;
- firstWin->generic.width += widthDiff;
- secondWin = TUI_DISASM_WIN;
- secondWin->generic.width += widthDiff;
+ first_win = TUI_SRC_WIN;
+ first_win->generic.width += width_diff;
+ second_win = TUI_DISASM_WIN;
+ second_win->generic.width += width_diff;
}
else
{
- firstWin = TUI_DATA_WIN;
- firstWin->generic.width += widthDiff;
- secondWin = (struct tui_win_info *) (tui_source_windows ())->list[0];
- secondWin->generic.width += widthDiff;
+ first_win = TUI_DATA_WIN;
+ first_win->generic.width += width_diff;
+ second_win = (struct tui_win_info *) (tui_source_windows ())->list[0];
+ second_win->generic.width += width_diff;
}
/* Change the first window's height/width */
/* check for invalid heights */
- if (heightDiff == 0)
- newHeight = firstWin->generic.height;
- else if ((firstWin->generic.height +
- secondWin->generic.height + (splitDiff * 2)) >=
+ if (height_diff == 0)
+ new_height = first_win->generic.height;
+ else if ((first_win->generic.height +
+ second_win->generic.height + (split_diff * 2)) >=
(screenheight - MIN_CMD_WIN_HEIGHT - 1))
- newHeight = (screenheight - MIN_CMD_WIN_HEIGHT - 1) / 2;
- else if ((firstWin->generic.height + splitDiff) <= 0)
- newHeight = MIN_WIN_HEIGHT;
+ new_height = (screenheight - MIN_CMD_WIN_HEIGHT - 1) / 2;
+ else if ((first_win->generic.height + split_diff) <= 0)
+ new_height = MIN_WIN_HEIGHT;
else
- newHeight = firstWin->generic.height + splitDiff;
- _makeInvisibleAndSetNewHeight (firstWin, newHeight);
+ new_height = first_win->generic.height + split_diff;
+ make_invisible_and_set_new_height (first_win, new_height);
- if (firstWin == TUI_DATA_WIN && widthDiff != 0)
- firstWin->detail.data_display_info.regs_column_count =
+ if (first_win == TUI_DATA_WIN && width_diff != 0)
+ first_win->detail.data_display_info.regs_column_count =
tui_calculate_regs_column_count (
- firstWin->detail.data_display_info.regs_display_type);
- locator->width += widthDiff;
+ first_win->detail.data_display_info.regs_display_type);
+ locator->width += width_diff;
/* Change the second window's height/width */
/* check for invalid heights */
- if (heightDiff == 0)
- newHeight = secondWin->generic.height;
- else if ((firstWin->generic.height +
- secondWin->generic.height + (splitDiff * 2)) >=
+ if (height_diff == 0)
+ new_height = second_win->generic.height;
+ else if ((first_win->generic.height +
+ second_win->generic.height + (split_diff * 2)) >=
(screenheight - MIN_CMD_WIN_HEIGHT - 1))
{
- newHeight = screenheight - MIN_CMD_WIN_HEIGHT - 1;
- if (newHeight % 2)
- newHeight = (newHeight / 2) + 1;
+ new_height = screenheight - MIN_CMD_WIN_HEIGHT - 1;
+ if (new_height % 2)
+ new_height = (new_height / 2) + 1;
else
- newHeight /= 2;
+ new_height /= 2;
}
- else if ((secondWin->generic.height + splitDiff) <= 0)
- newHeight = MIN_WIN_HEIGHT;
+ else if ((second_win->generic.height + split_diff) <= 0)
+ new_height = MIN_WIN_HEIGHT;
else
- newHeight = secondWin->generic.height + splitDiff;
- secondWin->generic.origin.y = firstWin->generic.height - 1;
- _makeInvisibleAndSetNewHeight (secondWin, newHeight);
+ new_height = second_win->generic.height + split_diff;
+ second_win->generic.origin.y = first_win->generic.height - 1;
+ make_invisible_and_set_new_height (second_win, new_height);
/* Change the command window's height/width */
TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
- _makeInvisibleAndSetNewHeight (
- TUI_CMD_WIN, TUI_CMD_WIN->generic.height + cmdSplitDiff);
- _makeVisibleWithNewHeight (firstWin);
- _makeVisibleWithNewHeight (secondWin);
- _makeVisibleWithNewHeight (TUI_CMD_WIN);
- if (firstWin->generic.content_size <= 0)
- tui_erase_source_content (firstWin, EMPTY_SOURCE_PROMPT);
- if (secondWin->generic.content_size <= 0)
- tui_erase_source_content (secondWin, EMPTY_SOURCE_PROMPT);
+ make_invisible_and_set_new_height (
+ TUI_CMD_WIN, TUI_CMD_WIN->generic.height + cmd_split_diff);
+ make_visible_with_new_height (first_win);
+ make_visible_with_new_height (second_win);
+ make_visible_with_new_height (TUI_CMD_WIN);
+ if (first_win->generic.content_size <= 0)
+ tui_erase_source_content (first_win, EMPTY_SOURCE_PROMPT);
+ if (second_win->generic.content_size <= 0)
+ tui_erase_source_content (second_win, EMPTY_SOURCE_PROMPT);
break;
}
/*
** Now remove all invisible windows, and their content so that they get
** created again when called for with the new size
*/
- for (winType = SRC_WIN; (winType < MAX_MAJOR_WINDOWS); winType++)
+ for (win_type = SRC_WIN; (win_type < MAX_MAJOR_WINDOWS); win_type++)
{
- if (winType != CMD_WIN && (tui_win_list[winType] != NULL)
- && !tui_win_list[winType]->generic.is_visible)
+ if (win_type != CMD_WIN && (tui_win_list[win_type] != NULL)
+ && !tui_win_list[win_type]->generic.is_visible)
{
- tui_free_window (tui_win_list[winType]);
- tui_win_list[winType] = (struct tui_win_info *) NULL;
+ tui_free_window (tui_win_list[win_type]);
+ tui_win_list[win_type] = (struct tui_win_info *) NULL;
}
}
tui_set_win_resized_to (TRUE);
/* turn keypad back on, unless focus is in the command window */
- if (winWithFocus != TUI_CMD_WIN)
+ if (win_with_focus != TUI_CMD_WIN)
keypad (TUI_CMD_WIN->generic.handle, TRUE);
}
- return;
-} /* tuiResizeAll */
+}
-/*
- ** tuiSigwinchHandler()
- ** SIGWINCH signal handler for the tui. This signal handler is
- ** always called, even when the readline package clears signals
- ** because it is set as the old_sigwinch() (TUI only)
- */
+/* SIGWINCH signal handler for the tui. This signal handler is always
+ called, even when the readline package clears signals because it is
+ set as the old_sigwinch() (TUI only). */
void
-tuiSigwinchHandler (int signal)
+tui_sigwinch_handler (int signal)
{
/*
** Say that a resize was done so that the readline can do it
** later when appropriate.
*/
tui_set_win_resized_to (TRUE);
-
- return;
-} /* tuiSigwinchHandler */
+}
**************************/
-/*
- ** _tuiScrollForward_command().
- */
static void
-_tuiScrollForward_command (char *arg, int fromTTY)
+tui_scroll_forward_command (char *arg, int from_tty)
{
- int numToScroll = 1;
- struct tui_win_info * winToScroll;
+ int num_to_scroll = 1;
+ struct tui_win_info * win_to_scroll;
/* Make sure the curses mode is enabled. */
tui_enable ();
if (arg == (char *) NULL)
- _parseScrollingArgs (arg, &winToScroll, (int *) NULL);
+ parse_scrolling_args (arg, &win_to_scroll, (int *) NULL);
else
- _parseScrollingArgs (arg, &winToScroll, &numToScroll);
- tui_scroll (FORWARD_SCROLL, winToScroll, numToScroll);
+ parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
+ tui_scroll (FORWARD_SCROLL, win_to_scroll, num_to_scroll);
}
-/*
- ** _tuiScrollBackward_command().
- */
static void
-_tuiScrollBackward_command (char *arg, int fromTTY)
+tui_scroll_backward_command (char *arg, int from_tty)
{
- int numToScroll = 1;
- struct tui_win_info * winToScroll;
+ int num_to_scroll = 1;
+ struct tui_win_info * win_to_scroll;
/* Make sure the curses mode is enabled. */
tui_enable ();
if (arg == (char *) NULL)
- _parseScrollingArgs (arg, &winToScroll, (int *) NULL);
+ parse_scrolling_args (arg, &win_to_scroll, (int *) NULL);
else
- _parseScrollingArgs (arg, &winToScroll, &numToScroll);
- tui_scroll (BACKWARD_SCROLL, winToScroll, numToScroll);
+ parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
+ tui_scroll (BACKWARD_SCROLL, win_to_scroll, num_to_scroll);
}
-/*
- ** _tuiScrollLeft_command().
- */
static void
-_tuiScrollLeft_command (char *arg, int fromTTY)
+tui_scroll_left_command (char *arg, int from_tty)
{
- int numToScroll;
- struct tui_win_info * winToScroll;
+ int num_to_scroll;
+ struct tui_win_info * win_to_scroll;
/* Make sure the curses mode is enabled. */
tui_enable ();
- _parseScrollingArgs (arg, &winToScroll, &numToScroll);
- tui_scroll (LEFT_SCROLL, winToScroll, numToScroll);
+ parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
+ tui_scroll (LEFT_SCROLL, win_to_scroll, num_to_scroll);
}
-/*
- ** _tuiScrollRight_command().
- */
static void
-_tuiScrollRight_command (char *arg, int fromTTY)
+tui_scroll_right_command (char *arg, int from_tty)
{
- int numToScroll;
- struct tui_win_info * winToScroll;
+ int num_to_scroll;
+ struct tui_win_info * win_to_scroll;
/* Make sure the curses mode is enabled. */
tui_enable ();
- _parseScrollingArgs (arg, &winToScroll, &numToScroll);
- tui_scroll (RIGHT_SCROLL, winToScroll, numToScroll);
+ parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
+ tui_scroll (RIGHT_SCROLL, win_to_scroll, num_to_scroll);
}
-/*
- ** _tuiSetFocus().
- ** Set focus to the window named by 'arg'
- */
+/* Set focus to the window named by 'arg'. */
static void
-_tuiSetFocus (char *arg, int fromTTY)
+tui_set_focus (char *arg, int from_tty)
{
if (arg != (char *) NULL)
{
- char *bufPtr = (char *) xstrdup (arg);
+ char *buf_ptr = (char *) xstrdup (arg);
int i;
struct tui_win_info * win_info = (struct tui_win_info *) NULL;
- for (i = 0; (i < strlen (bufPtr)); i++)
- bufPtr[i] = toupper (arg[i]);
+ for (i = 0; (i < strlen (buf_ptr)); i++)
+ buf_ptr[i] = toupper (arg[i]);
- if (subset_compare (bufPtr, "NEXT"))
+ if (subset_compare (buf_ptr, "NEXT"))
win_info = tui_next_win (tui_win_with_focus ());
- else if (subset_compare (bufPtr, "PREV"))
+ else if (subset_compare (buf_ptr, "PREV"))
win_info = tui_prev_win (tui_win_with_focus ());
else
- win_info = tui_partial_win_by_name (bufPtr);
+ win_info = tui_partial_win_by_name (buf_ptr);
if (win_info == (struct tui_win_info *) NULL || !win_info->generic.is_visible)
warning ("Invalid window specified. \n\
if (TUI_DATA_WIN && TUI_DATA_WIN->generic.is_visible)
tui_refresh_data_win ();
- xfree (bufPtr);
+ xfree (buf_ptr);
printf_filtered ("Focus set to %s window.\n",
tui_win_name ((struct tui_gen_win_info *) tui_win_with_focus ()));
}
else
warning ("Incorrect Number of Arguments.\n%s", FOCUS_USAGE);
+}
- return;
-} /* _tuiSetFocus */
-
-/*
- ** _tuiSetFocus_command()
- */
static void
-_tuiSetFocus_command (char *arg, int fromTTY)
+tui_set_focus_command (char *arg, int from_tty)
{
/* Make sure the curses mode is enabled. */
tui_enable ();
- _tuiSetFocus (arg, fromTTY);
+ tui_set_focus (arg, from_tty);
}
-/*
- ** _tuiAllWindowsInfo().
- */
static void
-_tuiAllWindowsInfo (char *arg, int fromTTY)
+tui_all_windows_info (char *arg, int from_tty)
{
enum tui_win_type type;
- struct tui_win_info * winWithFocus = tui_win_with_focus ();
+ struct tui_win_info * win_with_focus = tui_win_with_focus ();
for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
if (tui_win_list[type] && tui_win_list[type]->generic.is_visible)
{
- if (winWithFocus == tui_win_list[type])
+ if (win_with_focus == tui_win_list[type])
printf_filtered (" %s\t(%d lines) <has focus>\n",
tui_win_name (&tui_win_list[type]->generic),
tui_win_list[type]->generic.height);
tui_win_name (&tui_win_list[type]->generic),
tui_win_list[type]->generic.height);
}
-
- return;
-} /* _tuiAllWindowsInfo */
+}
-/*
- ** _tuiRefreshAll_command().
- */
static void
-_tuiRefreshAll_command (char *arg, int fromTTY)
+tui_refresh_all_command (char *arg, int from_tty)
{
/* Make sure the curses mode is enabled. */
tui_enable ();
}
-/*
- ** _tuiSetWinTabWidth_command().
- ** Set the height of the specified window.
- */
+/* Set the height of the specified window. */
static void
-_tuiSetTabWidth_command (char *arg, int fromTTY)
+tui_set_tab_width_command (char *arg, int from_tty)
{
/* Make sure the curses mode is enabled. */
tui_enable ();
else
warning ("Tab widths greater than 0 must be specified.\n");
}
-
- return;
-} /* _tuiSetTabWidth_command */
+}
-/*
- ** _tuiSetWinHeight().
- ** Set the height of the specified window.
- */
+/* Set the height of the specified window. */
static void
-_tuiSetWinHeight (char *arg, int fromTTY)
+tui_set_win_height (char *arg, int from_tty)
{
/* Make sure the curses mode is enabled. */
tui_enable ();
if (arg != (char *) NULL)
{
char *buf = xstrdup (arg);
- char *bufPtr = buf;
+ char *buf_ptr = buf;
char *wname = (char *) NULL;
- int newHeight, i;
+ int new_height, i;
struct tui_win_info * win_info;
- wname = bufPtr;
- bufPtr = strchr (bufPtr, ' ');
- if (bufPtr != (char *) NULL)
+ wname = buf_ptr;
+ buf_ptr = strchr (buf_ptr, ' ');
+ if (buf_ptr != (char *) NULL)
{
- *bufPtr = (char) 0;
+ *buf_ptr = (char) 0;
/*
** Validate the window name
else
{
/* Process the size */
- while (*(++bufPtr) == ' ')
+ while (*(++buf_ptr) == ' ')
;
- if (*bufPtr != (char) 0)
+ if (*buf_ptr != (char) 0)
{
int negate = FALSE;
- int fixedSize = TRUE;
- int inputNo;;
+ int fixed_size = TRUE;
+ int input_no;;
- if (*bufPtr == '+' || *bufPtr == '-')
+ if (*buf_ptr == '+' || *buf_ptr == '-')
{
- if (*bufPtr == '-')
+ if (*buf_ptr == '-')
negate = TRUE;
- fixedSize = FALSE;
- bufPtr++;
+ fixed_size = FALSE;
+ buf_ptr++;
}
- inputNo = atoi (bufPtr);
- if (inputNo > 0)
+ input_no = atoi (buf_ptr);
+ if (input_no > 0)
{
if (negate)
- inputNo *= (-1);
- if (fixedSize)
- newHeight = inputNo;
+ input_no *= (-1);
+ if (fixed_size)
+ new_height = input_no;
else
- newHeight = win_info->generic.height + inputNo;
+ new_height = win_info->generic.height + input_no;
/*
** Now change the window's height, and adjust all
** other windows around it
*/
- if (_tuiAdjustWinHeights (win_info,
- newHeight) == TUI_FAILURE)
+ if (tui_adjust_win_heights (win_info,
+ new_height) == TUI_FAILURE)
warning ("Invalid window height specified.\n%s",
WIN_HEIGHT_USAGE);
else
}
else
printf_filtered (WIN_HEIGHT_USAGE);
+}
- return;
-} /* _tuiSetWinHeight */
-
-/*
- ** _tuiSetWinHeight_command().
- ** Set the height of the specified window, with va_list.
- */
+/* Set the height of the specified window, with va_list. */
static void
-_tuiSetWinHeight_command (char *arg, int fromTTY)
+tui_set_win_height_command (char *arg, int from_tty)
{
/* Make sure the curses mode is enabled. */
tui_enable ();
- _tuiSetWinHeight (arg, fromTTY);
+ tui_set_win_height (arg, from_tty);
}
-/*
- ** _tuiXDBsetWinHeight().
- ** XDB Compatibility command for setting the window height. This will
- ** increase or decrease the command window by the specified amount.
- */
+/* XDB Compatibility command for setting the window height. This will
+ increase or decrease the command window by the specified amount. */
static void
-_tuiXDBsetWinHeight (char *arg, int fromTTY)
+tui_xdb_set_win_height (char *arg, int from_tty)
{
/* Make sure the curses mode is enabled. */
tui_enable ();
if (arg != (char *) NULL)
{
- int inputNo = atoi (arg);
+ int input_no = atoi (arg);
- if (inputNo > 0)
+ if (input_no > 0)
{ /* Add 1 for the locator */
- int newHeight = tui_term_height () - (inputNo + 1);
+ int new_height = tui_term_height () - (input_no + 1);
- if (!_newHeightOk (tui_win_list[CMD_WIN], newHeight) ||
- _tuiAdjustWinHeights (tui_win_list[CMD_WIN],
- newHeight) == TUI_FAILURE)
+ if (!new_height_ok (tui_win_list[CMD_WIN], new_height) ||
+ tui_adjust_win_heights (tui_win_list[CMD_WIN],
+ new_height) == TUI_FAILURE)
warning ("Invalid window height specified.\n%s",
XDBWIN_HEIGHT_USAGE);
}
}
else
warning ("Invalid window height specified.\n%s", XDBWIN_HEIGHT_USAGE);
+}
- return;
-} /* _tuiXDBsetWinHeight */
-
-/*
- ** _tuiSetWinHeight_command().
- ** Set the height of the specified window, with va_list.
- */
+/* Set the height of the specified window, with va_list. */
static void
-_tuiXDBsetWinHeight_command (char *arg, int fromTTY)
+tui_xdb_set_win_height_command (char *arg, int from_tty)
{
- _tuiXDBsetWinHeight (arg, fromTTY);
+ tui_xdb_set_win_height (arg, from_tty);
}
-/*
- ** _tuiAdjustWinHeights().
- ** Function to adjust all window heights around the primary
- */
+/* Function to adjust all window heights around the primary. */
static enum tui_status
-_tuiAdjustWinHeights (struct tui_win_info * primaryWinInfo, int newHeight)
+tui_adjust_win_heights (struct tui_win_info * primary_win_info, int new_height)
{
enum tui_status status = TUI_FAILURE;
- if (_newHeightOk (primaryWinInfo, newHeight))
+ if (new_height_ok (primary_win_info, new_height))
{
status = TUI_SUCCESS;
- if (newHeight != primaryWinInfo->generic.height)
+ if (new_height != primary_win_info->generic.height)
{
int diff;
struct tui_win_info * win_info;
struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
- enum tui_layout_type 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)
+ diff = (new_height - primary_win_info->generic.height) * (-1);
+ if (cur_layout == SRC_COMMAND || cur_layout == DISASSEM_COMMAND)
{
- struct tui_win_info * srcWinInfo;
+ struct tui_win_info * src_win_info;
- _makeInvisibleAndSetNewHeight (primaryWinInfo, newHeight);
- if (primaryWinInfo->generic.type == CMD_WIN)
+ make_invisible_and_set_new_height (primary_win_info, new_height);
+ if (primary_win_info->generic.type == CMD_WIN)
{
win_info = (struct tui_win_info *) (tui_source_windows ())->list[0];
- srcWinInfo = win_info;
+ src_win_info = win_info;
}
else
{
win_info = tui_win_list[CMD_WIN];
- srcWinInfo = primaryWinInfo;
+ src_win_info = primary_win_info;
}
- _makeInvisibleAndSetNewHeight (win_info,
+ make_invisible_and_set_new_height (win_info,
win_info->generic.height + diff);
TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
- _makeVisibleWithNewHeight (win_info);
- _makeVisibleWithNewHeight (primaryWinInfo);
- if (srcWinInfo->generic.content_size <= 0)
- tui_erase_source_content (srcWinInfo, EMPTY_SOURCE_PROMPT);
+ make_visible_with_new_height (win_info);
+ make_visible_with_new_height (primary_win_info);
+ if (src_win_info->generic.content_size <= 0)
+ tui_erase_source_content (src_win_info, EMPTY_SOURCE_PROMPT);
}
else
{
- struct tui_win_info *firstWin;
- struct tui_win_info *secondWin;
+ struct tui_win_info *first_win;
+ struct tui_win_info *second_win;
- if (curLayout == SRC_DISASSEM_COMMAND)
+ if (cur_layout == SRC_DISASSEM_COMMAND)
{
- firstWin = TUI_SRC_WIN;
- secondWin = TUI_DISASM_WIN;
+ first_win = TUI_SRC_WIN;
+ second_win = TUI_DISASM_WIN;
}
else
{
- firstWin = TUI_DATA_WIN;
- secondWin = (struct tui_win_info *) (tui_source_windows ())->list[0];
+ first_win = TUI_DATA_WIN;
+ second_win = (struct tui_win_info *) (tui_source_windows ())->list[0];
}
- if (primaryWinInfo == TUI_CMD_WIN)
+ if (primary_win_info == TUI_CMD_WIN)
{ /*
** Split the change in height accross the 1st & 2nd windows
** adjusting them as well.
*/
- int firstSplitDiff = diff / 2; /* subtract the locator */
- int secondSplitDiff = firstSplitDiff;
+ int first_split_diff = diff / 2; /* subtract the locator */
+ int second_split_diff = first_split_diff;
if (diff % 2)
{
- if (firstWin->generic.height >
- secondWin->generic.height)
+ if (first_win->generic.height >
+ second_win->generic.height)
if (diff < 0)
- firstSplitDiff--;
+ first_split_diff--;
else
- firstSplitDiff++;
+ first_split_diff++;
else
{
if (diff < 0)
- secondSplitDiff--;
+ second_split_diff--;
else
- secondSplitDiff++;
+ second_split_diff++;
}
}
/* make sure that the minimum hieghts are honored */
- while ((firstWin->generic.height + firstSplitDiff) < 3)
+ while ((first_win->generic.height + first_split_diff) < 3)
{
- firstSplitDiff++;
- secondSplitDiff--;
+ first_split_diff++;
+ second_split_diff--;
}
- while ((secondWin->generic.height + secondSplitDiff) < 3)
+ while ((second_win->generic.height + second_split_diff) < 3)
{
- secondSplitDiff++;
- firstSplitDiff--;
+ second_split_diff++;
+ first_split_diff--;
}
- _makeInvisibleAndSetNewHeight (
- firstWin,
- firstWin->generic.height + firstSplitDiff);
- secondWin->generic.origin.y = firstWin->generic.height - 1;
- _makeInvisibleAndSetNewHeight (
- secondWin, secondWin->generic.height + secondSplitDiff);
+ make_invisible_and_set_new_height (
+ first_win,
+ first_win->generic.height + first_split_diff);
+ second_win->generic.origin.y = first_win->generic.height - 1;
+ make_invisible_and_set_new_height (
+ second_win, second_win->generic.height + second_split_diff);
TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
- _makeInvisibleAndSetNewHeight (TUI_CMD_WIN, newHeight);
+ make_invisible_and_set_new_height (TUI_CMD_WIN, new_height);
}
else
{
int i;
for (i = TUI_CMD_WIN->generic.height + diff;
(i < 1); i++)
- if (primaryWinInfo == firstWin)
- secondWin->generic.height--;
+ if (primary_win_info == first_win)
+ second_win->generic.height--;
else
- firstWin->generic.height--;
+ first_win->generic.height--;
}
}
- if (primaryWinInfo == firstWin)
- _makeInvisibleAndSetNewHeight (firstWin, newHeight);
+ if (primary_win_info == first_win)
+ make_invisible_and_set_new_height (first_win, new_height);
else
- _makeInvisibleAndSetNewHeight (
- firstWin,
- firstWin->generic.height);
- secondWin->generic.origin.y = firstWin->generic.height - 1;
- if (primaryWinInfo == secondWin)
- _makeInvisibleAndSetNewHeight (secondWin, newHeight);
+ make_invisible_and_set_new_height (
+ first_win,
+ first_win->generic.height);
+ second_win->generic.origin.y = first_win->generic.height - 1;
+ if (primary_win_info == second_win)
+ make_invisible_and_set_new_height (second_win, new_height);
else
- _makeInvisibleAndSetNewHeight (
- secondWin, secondWin->generic.height);
+ make_invisible_and_set_new_height (
+ second_win, second_win->generic.height);
TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
if ((TUI_CMD_WIN->generic.height + diff) < 1)
- _makeInvisibleAndSetNewHeight (TUI_CMD_WIN, 1);
+ make_invisible_and_set_new_height (TUI_CMD_WIN, 1);
else
- _makeInvisibleAndSetNewHeight (
+ make_invisible_and_set_new_height (
TUI_CMD_WIN, TUI_CMD_WIN->generic.height + diff);
}
- _makeVisibleWithNewHeight (TUI_CMD_WIN);
- _makeVisibleWithNewHeight (secondWin);
- _makeVisibleWithNewHeight (firstWin);
- if (firstWin->generic.content_size <= 0)
- tui_erase_source_content (firstWin, EMPTY_SOURCE_PROMPT);
- if (secondWin->generic.content_size <= 0)
- tui_erase_source_content (secondWin, EMPTY_SOURCE_PROMPT);
+ make_visible_with_new_height (TUI_CMD_WIN);
+ make_visible_with_new_height (second_win);
+ make_visible_with_new_height (first_win);
+ if (first_win->generic.content_size <= 0)
+ tui_erase_source_content (first_win, EMPTY_SOURCE_PROMPT);
+ if (second_win->generic.content_size <= 0)
+ tui_erase_source_content (second_win, EMPTY_SOURCE_PROMPT);
}
}
}
return status;
-} /* _tuiAdjustWinHeights */
+}
-/*
- ** _makeInvisibleAndSetNewHeight().
- ** Function make the target window (and auxillary windows associated
- ** with the targer) invisible, and set the new height and location.
- */
+/* Function make the target window (and auxillary windows associated
+ with the targer) invisible, and set the new height and location. */
static void
-_makeInvisibleAndSetNewHeight (struct tui_win_info * win_info, int height)
+make_invisible_and_set_new_height (struct tui_win_info * win_info, int height)
{
int i;
- struct tui_gen_win_info * genWinInfo;
+ struct tui_gen_win_info * gen_win_info;
tui_make_invisible (&win_info->generic);
win_info->generic.height = height;
{
case SRC_WIN:
case DISASSEM_WIN:
- genWinInfo = win_info->detail.source_info.execution_info;
- tui_make_invisible (genWinInfo);
- genWinInfo->height = height;
- genWinInfo->origin.y = win_info->generic.origin.y;
+ gen_win_info = win_info->detail.source_info.execution_info;
+ tui_make_invisible (gen_win_info);
+ gen_win_info->height = height;
+ gen_win_info->origin.y = win_info->generic.origin.y;
if (height > 1)
- genWinInfo->viewport_height = height - 1;
+ gen_win_info->viewport_height = height - 1;
else
- genWinInfo->viewport_height = height;
+ gen_win_info->viewport_height = height;
if (win_info != TUI_CMD_WIN)
- genWinInfo->viewport_height--;
+ gen_win_info->viewport_height--;
if (tui_win_has_locator (win_info))
{
- genWinInfo = tui_locator_win_info_ptr ();
- tui_make_invisible (genWinInfo);
- genWinInfo->origin.y = win_info->generic.origin.y + height;
+ gen_win_info = tui_locator_win_info_ptr ();
+ tui_make_invisible (gen_win_info);
+ gen_win_info->origin.y = win_info->generic.origin.y + height;
}
break;
case DATA_WIN:
/* delete all data item windows */
for (i = 0; i < win_info->generic.content_size; i++)
{
- genWinInfo = (struct tui_gen_win_info *) & ((struct tui_win_element *)
+ gen_win_info = (struct tui_gen_win_info *) & ((struct tui_win_element *)
win_info->generic.content[i])->which_element.data_window;
- tui_delete_win (genWinInfo->handle);
- genWinInfo->handle = (WINDOW *) NULL;
+ tui_delete_win (gen_win_info->handle);
+ gen_win_info->handle = (WINDOW *) NULL;
}
break;
default:
}
-/*
- ** _makeVisibleWithNewHeight().
- ** Function to make the windows with new heights visible.
- ** This means re-creating the windows' content since the window
- ** had to be destroyed to be made invisible.
- */
+/* Function to make the windows with new heights visible. This means
+ re-creating the windows' content since the window had to be
+ destroyed to be made invisible. */
static void
-_makeVisibleWithNewHeight (struct tui_win_info * win_info)
+make_visible_with_new_height (struct tui_win_info * win_info)
{
struct symtab *s;
tui_make_visible (win_info->detail.source_info.execution_info);
if (win_info->generic.content != NULL)
{
- union tui_line_or_address lineOrAddr;
+ union tui_line_or_address line_or_addr;
struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
if (win_info->generic.type == SRC_WIN)
- lineOrAddr.line_no =
+ line_or_addr.line_no =
win_info->detail.source_info.start_line_or_addr.line_no;
else
- lineOrAddr.addr =
+ line_or_addr.addr =
win_info->detail.source_info.start_line_or_addr.addr;
tui_free_win_content (&win_info->generic);
- tui_update_source_window (win_info, cursal.symtab, lineOrAddr, TRUE);
+ tui_update_source_window (win_info, cursal.symtab, line_or_addr, TRUE);
}
else if (deprecated_selected_frame != (struct frame_info *) NULL)
{
default:
break;
}
-
- return;
-} /* _makeVisibleWithNewHeight */
+}
static int
-_newHeightOk (struct tui_win_info * primaryWinInfo, int newHeight)
+new_height_ok (struct tui_win_info * primary_win_info, int new_height)
{
- int ok = (newHeight < tui_term_height ());
+ int ok = (new_height < tui_term_height ());
if (ok)
{
int diff;
enum tui_layout_type cur_layout = tui_current_layout ();
- diff = (newHeight - primaryWinInfo->generic.height) * (-1);
+ diff = (new_height - primary_win_info->generic.height) * (-1);
if (cur_layout == SRC_COMMAND || cur_layout == DISASSEM_COMMAND)
{
- ok = ((primaryWinInfo->generic.type == CMD_WIN &&
- newHeight <= (tui_term_height () - 4) &&
- newHeight >= MIN_CMD_WIN_HEIGHT) ||
- (primaryWinInfo->generic.type != CMD_WIN &&
- newHeight <= (tui_term_height () - 2) &&
- newHeight >= MIN_WIN_HEIGHT));
+ ok = ((primary_win_info->generic.type == CMD_WIN &&
+ new_height <= (tui_term_height () - 4) &&
+ new_height >= MIN_CMD_WIN_HEIGHT) ||
+ (primary_win_info->generic.type != CMD_WIN &&
+ new_height <= (tui_term_height () - 2) &&
+ new_height >= MIN_WIN_HEIGHT));
if (ok)
{ /* check the total height */
struct tui_win_info * win_info;
- if (primaryWinInfo == TUI_CMD_WIN)
+ if (primary_win_info == TUI_CMD_WIN)
win_info = (struct tui_win_info *) (tui_source_windows ())->list[0];
else
win_info = TUI_CMD_WIN;
- ok = ((newHeight +
+ ok = ((new_height +
(win_info->generic.height + diff)) <= tui_term_height ());
}
}
else
{
- int curTotalHeight, totalHeight, minHeight = 0;
- struct tui_win_info *firstWin;
- struct tui_win_info *secondWin;
+ int cur_total_height, total_height, min_height = 0;
+ struct tui_win_info *first_win;
+ struct tui_win_info *second_win;
if (cur_layout == SRC_DISASSEM_COMMAND)
{
- firstWin = TUI_SRC_WIN;
- secondWin = TUI_DISASM_WIN;
+ first_win = TUI_SRC_WIN;
+ second_win = TUI_DISASM_WIN;
}
else
{
- firstWin = TUI_DATA_WIN;
- secondWin = (struct tui_win_info *) (tui_source_windows ())->list[0];
+ first_win = TUI_DATA_WIN;
+ second_win = (struct tui_win_info *) (tui_source_windows ())->list[0];
}
/*
** We could simply add all the heights to obtain the same result
** line that the first and second windows share, and add one
** for the locator.
*/
- totalHeight = curTotalHeight =
- (firstWin->generic.height + secondWin->generic.height - 1)
+ total_height = cur_total_height =
+ (first_win->generic.height + second_win->generic.height - 1)
+ TUI_CMD_WIN->generic.height + 1 /*locator */ ;
- if (primaryWinInfo == TUI_CMD_WIN)
+ if (primary_win_info == TUI_CMD_WIN)
{
/* locator included since first & second win share a line */
- ok = ((firstWin->generic.height +
- secondWin->generic.height + diff) >=
+ ok = ((first_win->generic.height +
+ second_win->generic.height + diff) >=
(MIN_WIN_HEIGHT * 2) &&
- newHeight >= MIN_CMD_WIN_HEIGHT);
+ new_height >= MIN_CMD_WIN_HEIGHT);
if (ok)
{
- totalHeight = newHeight + (firstWin->generic.height +
- secondWin->generic.height + diff);
- minHeight = MIN_CMD_WIN_HEIGHT;
+ total_height = new_height + (first_win->generic.height +
+ second_win->generic.height + diff);
+ min_height = MIN_CMD_WIN_HEIGHT;
}
}
else
{
- minHeight = MIN_WIN_HEIGHT;
+ min_height = MIN_WIN_HEIGHT;
/*
** First see if we can increase/decrease the command
** window. And make sure that the command window is
** Looks like we have to increase/decrease one of
** the other windows
*/
- if (primaryWinInfo == firstWin)
- ok = (secondWin->generic.height + diff) >= minHeight;
+ if (primary_win_info == first_win)
+ ok = (second_win->generic.height + diff) >= min_height;
else
- ok = (firstWin->generic.height + diff) >= minHeight;
+ ok = (first_win->generic.height + diff) >= min_height;
}
if (ok)
{
- if (primaryWinInfo == firstWin)
- totalHeight = newHeight +
- secondWin->generic.height +
+ if (primary_win_info == first_win)
+ total_height = new_height +
+ second_win->generic.height +
TUI_CMD_WIN->generic.height + diff;
else
- totalHeight = newHeight +
- firstWin->generic.height +
+ total_height = new_height +
+ first_win->generic.height +
TUI_CMD_WIN->generic.height + diff;
}
}
** the old total height.
*/
if (ok)
- ok = (newHeight >= minHeight && totalHeight <= curTotalHeight);
+ ok = (new_height >= min_height && total_height <= cur_total_height);
}
}
return ok;
-} /* _newHeightOk */
+}
-/*
- ** _parseScrollingArgs().
- */
static void
-_parseScrollingArgs (char *arg, struct tui_win_info * * winToScroll, int *numToScroll)
+parse_scrolling_args (char *arg, struct tui_win_info * * win_to_scroll,
+ int *num_to_scroll)
{
- if (numToScroll)
- *numToScroll = 0;
- *winToScroll = tui_win_with_focus ();
+ if (num_to_scroll)
+ *num_to_scroll = 0;
+ *win_to_scroll = tui_win_with_focus ();
/*
** First set up the default window to scroll, in case there is no
*/
if (arg != (char *) NULL)
{
- char *buf, *bufPtr;
+ char *buf, *buf_ptr;
/* process the number of lines to scroll */
- buf = bufPtr = xstrdup (arg);
- if (isdigit (*bufPtr))
+ buf = buf_ptr = xstrdup (arg);
+ if (isdigit (*buf_ptr))
{
- char *numStr;
+ char *num_str;
- numStr = bufPtr;
- bufPtr = strchr (bufPtr, ' ');
- if (bufPtr != (char *) NULL)
+ num_str = buf_ptr;
+ buf_ptr = strchr (buf_ptr, ' ');
+ if (buf_ptr != (char *) NULL)
{
- *bufPtr = (char) 0;
- if (numToScroll)
- *numToScroll = atoi (numStr);
- bufPtr++;
+ *buf_ptr = (char) 0;
+ if (num_to_scroll)
+ *num_to_scroll = atoi (num_str);
+ buf_ptr++;
}
- else if (numToScroll)
- *numToScroll = atoi (numStr);
+ else if (num_to_scroll)
+ *num_to_scroll = atoi (num_str);
}
/* process the window name if one is specified */
- if (bufPtr != (char *) NULL)
+ if (buf_ptr != (char *) NULL)
{
char *wname;
int i;
- if (*bufPtr == ' ')
- while (*(++bufPtr) == ' ')
+ if (*buf_ptr == ' ')
+ while (*(++buf_ptr) == ' ')
;
- if (*bufPtr != (char) 0)
- wname = bufPtr;
+ if (*buf_ptr != (char) 0)
+ wname = buf_ptr;
else
wname = "?";
/* Validate the window name */
for (i = 0; i < strlen (wname); i++)
wname[i] = toupper (wname[i]);
- *winToScroll = tui_partial_win_by_name (wname);
+ *win_to_scroll = tui_partial_win_by_name (wname);
- if (*winToScroll == (struct tui_win_info *) NULL ||
- !(*winToScroll)->generic.is_visible)
+ if (*win_to_scroll == (struct tui_win_info *) NULL ||
+ !(*win_to_scroll)->generic.is_visible)
warning ("Invalid window specified. \n\
The window name specified must be valid and visible.\n");
- else if (*winToScroll == TUI_CMD_WIN)
- *winToScroll = (struct tui_win_info *) (tui_source_windows ())->list[0];
+ else if (*win_to_scroll == TUI_CMD_WIN)
+ *win_to_scroll = (struct tui_win_info *) (tui_source_windows ())->list[0];
}
xfree (buf);
}
-
- return;
-} /* _parseScrollingArgs */
+}
******************************************/
-/*
- ** tuiFirstDataItemDisplayed()
- ** Answer the index first element displayed.
- ** If none are displayed, then return (-1).
- */
+/* Answer the index first element displayed. If none are displayed,
+ then return (-1). */
int
-tuiFirstDataItemDisplayed (void)
+tui_first_data_item_displayed (void)
{
- int elementNo = (-1);
+ int element_no = (-1);
int i;
- for (i = 0; (i < TUI_DATA_WIN->generic.content_size && elementNo < 0); i++)
+ for (i = 0; (i < TUI_DATA_WIN->generic.content_size && element_no < 0); i++)
{
- struct tui_gen_win_info * dataItemWin;
+ struct tui_gen_win_info * data_item_win;
- dataItemWin = &((tui_win_content)
+ data_item_win = &((tui_win_content)
TUI_DATA_WIN->generic.content)[i]->which_element.data_window;
- if (dataItemWin->handle != (WINDOW *) NULL && dataItemWin->is_visible)
- elementNo = i;
+ if (data_item_win->handle != (WINDOW *) NULL && data_item_win->is_visible)
+ element_no = i;
}
- return elementNo;
-} /* tuiFirstDataItemDisplayed */
+ return element_no;
+}
-/*
- ** tuiFirstDataElementNoInLine()
- ** Answer the index of the first element in lineNo. If lineNo is
- ** past the data area (-1) is returned.
- */
+/* Answer the index of the first element in line_no. If line_no is
+ past the data area (-1) is returned. */
int
-tuiFirstDataElementNoInLine (int lineNo)
+tui_first_data_element_no_in_line (int line_no)
{
- int firstElementNo = (-1);
+ int first_element_no = (-1);
/*
- ** First see if there is a register on lineNo, and if so, set the
+ ** First see if there is a register on line_no, and if so, set the
** first element number
*/
- if ((firstElementNo = tui_first_reg_element_no_inline (lineNo)) == -1)
+ if ((first_element_no = tui_first_reg_element_no_inline (line_no)) == -1)
{ /*
- ** Looking at the general data, the 1st element on lineNo
+ ** Looking at the general data, the 1st element on line_no
*/
}
- return firstElementNo;
-} /* tuiFirstDataElementNoInLine */
+ return first_element_no;
+}
-/*
- ** tuiDeleteDataContentWindows()
- ** Function to delete all the item windows in the data window.
- ** This is usually done when the data window is scrolled.
- */
+/* Function to delete all the item windows in the data window. This
+ is usually done when the data window is scrolled. */
void
-tuiDeleteDataContentWindows (void)
+tui_delete_data_content_windows (void)
{
int i;
- struct tui_gen_win_info * dataItemWinPtr;
+ struct tui_gen_win_info * data_item_win_ptr;
for (i = 0; (i < TUI_DATA_WIN->generic.content_size); i++)
{
- dataItemWinPtr = &((tui_win_content)
+ data_item_win_ptr = &((tui_win_content)
TUI_DATA_WIN->generic.content)[i]->which_element.data_window;
- tui_delete_win (dataItemWinPtr->handle);
- dataItemWinPtr->handle = (WINDOW *) NULL;
- dataItemWinPtr->is_visible = FALSE;
+ tui_delete_win (data_item_win_ptr->handle);
+ data_item_win_ptr->handle = (WINDOW *) NULL;
+ data_item_win_ptr->is_visible = FALSE;
}
-
- return;
-} /* tuiDeleteDataContentWindows */
+}
void
tui_check_and_display_highlight_if_needed (TUI_DATA_WIN);
if (prompt != (char *) NULL)
{
- int halfWidth = (TUI_DATA_WIN->generic.width - 2) / 2;
- int xPos;
+ int half_width = (TUI_DATA_WIN->generic.width - 2) / 2;
+ int x_pos;
- if (strlen (prompt) >= halfWidth)
- xPos = 1;
+ if (strlen (prompt) >= half_width)
+ x_pos = 1;
else
- xPos = halfWidth - strlen (prompt);
+ x_pos = half_width - strlen (prompt);
mvwaddstr (TUI_DATA_WIN->generic.handle,
(TUI_DATA_WIN->generic.height / 2),
- xPos,
+ x_pos,
prompt);
}
wrefresh (TUI_DATA_WIN->generic.handle);
else
{
tui_erase_data_content ((char *) NULL);
- tuiDeleteDataContentWindows ();
+ tui_delete_data_content_windows ();
tui_check_and_display_highlight_if_needed (TUI_DATA_WIN);
tui_display_registers_from (0);
/*
}
-/*
- ** tuiDisplayDataFromLine()
- ** Function to display the data starting at line, lineNo, in the
- ** data window.
- */
+/* Function to display the data starting at line, line_no, in the data
+ window. */
void
-tuiDisplayDataFromLine (int lineNo)
+tui_display_data_from_line (int line_no)
{
- int _lineNo = lineNo;
+ int _line_no = line_no;
- if (lineNo < 0)
- _lineNo = 0;
+ if (line_no < 0)
+ _line_no = 0;
tui_check_and_display_highlight_if_needed (TUI_DATA_WIN);
/* there is no general data, force regs to display (if there are any) */
if (TUI_DATA_WIN->detail.data_display_info.data_content_count <= 0)
- tui_display_registers_from_line (_lineNo, TRUE);
+ tui_display_registers_from_line (_line_no, TRUE);
else
{
- int elementNo, startLineNo;
- int regsLastLine = tui_last_regs_line_no ();
+ int element_no, start_line_no;
+ int regs_last_line = tui_last_regs_line_no ();
/* display regs if we can */
- if (tui_display_registers_from_line (_lineNo, FALSE) < 0)
+ if (tui_display_registers_from_line (_line_no, FALSE) < 0)
{ /*
- ** _lineNo is past the regs display, so calc where the
+ ** _line_no is past the regs display, so calc where the
** start data element is
*/
- if (regsLastLine < _lineNo)
+ if (regs_last_line < _line_no)
{ /* figure out how many lines each element is to obtain
- the start elementNo */
+ the start element_no */
}
}
else
{ /*
** calculate the starting element of the data display, given
- ** regsLastLine and how many lines each element is, up to
- ** _lineNo
+ ** regs_last_line and how many lines each element is, up to
+ ** _line_no
*/
}
- /* Now display the data , starting at elementNo */
+ /* Now display the data , starting at element_no */
}
-
- return;
-} /* tuiDisplayDataFromLine */
+}
-/*
- ** tuiDisplayDataFrom()
- ** Display data starting at element elementNo
- */
+/* Display data starting at element element_no. */
void
-tuiDisplayDataFrom (int elementNo, int reuseWindows)
+tui_display_data_from (int element_no, int reuse_windows)
{
- int firstLine = (-1);
+ int first_line = (-1);
- if (elementNo < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
- firstLine = tui_line_from_reg_element_no (elementNo);
+ if (element_no < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
+ first_line = tui_line_from_reg_element_no (element_no);
else
- { /* calculate the firstLine from the element number */
+ { /* calculate the first_line from the element number */
}
- if (firstLine >= 0)
+ if (first_line >= 0)
{
tui_erase_data_content ((char *) NULL);
- if (!reuseWindows)
- tuiDeleteDataContentWindows ();
- tuiDisplayDataFromLine (firstLine);
+ if (!reuse_windows)
+ tui_delete_data_content_windows ();
+ tui_display_data_from_line (first_line);
}
-
- return;
-} /* tuiDisplayDataFrom */
+}
/* Function to redisplay the contents of the data window. */
tui_erase_data_content ((char *) NULL);
if (TUI_DATA_WIN->generic.content_size > 0)
{
- int firstElement = tuiFirstDataItemDisplayed ();
+ int first_element = tui_first_data_item_displayed ();
- if (firstElement >= 0) /* re-use existing windows */
- tuiDisplayDataFrom (firstElement, TRUE);
+ if (first_element >= 0) /* re-use existing windows */
+ tui_display_data_from (first_element, TRUE);
}
}
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;
+ tui_data_element_ptr data_element_ptr;
+ struct tui_gen_win_info * data_item_win_ptr;
+ Opaque new_value;
- dataItemPtr = &TUI_DATA_WIN->detail.data_display_info.
+ data_item_ptr = &TUI_DATA_WIN->detail.data_display_info.
data_content[i]->which_element.data_window;
- dataElementPtr = &((tui_win_content)
- dataItemWinPtr->content)[0]->which_element.data;
+ data_element_ptr = &((tui_win_content)
+ data_item_win_ptr->content)[0]->which_element.data;
if value
- has changed (dataElementPtr, frame, &newValue)
+ has changed (data_element_ptr, frame, &new_value)
{
- dataElementPtr->value = newValue;
+ data_element_ptr->value = new_value;
update the display with the new value, hiliting it.
}
#endif
/* Scroll the data window vertically forward or backward. */
void
-tui_vertical_data_scroll (enum tui_scroll_direction scrollDirection, int numToScroll)
+tui_vertical_data_scroll (enum tui_scroll_direction scroll_direction, int num_to_scroll)
{
- int firstElementNo;
- int firstLine = (-1);
+ int first_element_no;
+ int first_line = (-1);
- firstElementNo = tuiFirstDataItemDisplayed ();
- if (firstElementNo < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
- firstLine = tui_line_from_reg_element_no (firstElementNo);
+ first_element_no = tui_first_data_item_displayed ();
+ if (first_element_no < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
+ first_line = tui_line_from_reg_element_no (first_element_no);
else
{ /* calculate the first line from the element number which is in
** the general data content
*/
}
- if (firstLine >= 0)
+ if (first_line >= 0)
{
- int lastElementNo, lastLine;
+ int last_element_no, last_line;
- if (scrollDirection == FORWARD_SCROLL)
- firstLine += numToScroll;
+ if (scroll_direction == FORWARD_SCROLL)
+ first_line += num_to_scroll;
else
- firstLine -= numToScroll;
+ first_line -= num_to_scroll;
tui_erase_data_content ((char *) NULL);
- tuiDeleteDataContentWindows ();
- tuiDisplayDataFromLine (firstLine);
+ tui_delete_data_content_windows ();
+ tui_display_data_from_line (first_line);
}
-
- return;
-} /* tuiVerticalDataScroll */
+}
/*****************************************
for (i = 0; (i < win_info->content_size); i++)
{
- struct tui_gen_win_info * dataItemWinPtr;
+ struct tui_gen_win_info * data_item_win_ptr;
- dataItemWinPtr = &((tui_win_content)
+ data_item_win_ptr = &((tui_win_content)
win_info->content)[i]->which_element.data_window;
- if (dataItemWinPtr != NULL
- && dataItemWinPtr->handle != (WINDOW *) NULL)
- wrefresh (dataItemWinPtr->handle);
+ if (data_item_win_ptr != NULL
+ && data_item_win_ptr->handle != (WINDOW *) NULL)
+ wrefresh (data_item_win_ptr->handle);
}
}
else if (win_info->type == CMD_WIN)
/* Draw a border arround the window. */
void
-boxWin (struct tui_gen_win_info * win_info, int highlightFlag)
+box_win (struct tui_gen_win_info * win_info, int highlight_flag)
{
if (win_info && win_info->handle)
{
int attrs;
win = win_info->handle;
- if (highlightFlag == HILITE)
+ if (highlight_flag == HILITE)
attrs = tui_active_border_attrs;
else
attrs = tui_border_attrs;
{
if (win_info != NULL && win_info->generic.handle != (WINDOW *) NULL)
{
- boxWin ((struct tui_gen_win_info *) win_info, NO_HILITE);
+ box_win ((struct tui_gen_win_info *) win_info, NO_HILITE);
wrefresh (win_info->generic.handle);
tui_set_win_highlight (win_info, 0);
}
&& win_info->can_highlight
&& win_info->generic.handle != (WINDOW *) NULL)
{
- boxWin ((struct tui_gen_win_info *) win_info, HILITE);
+ box_win ((struct tui_gen_win_info *) win_info, HILITE);
wrefresh (win_info->generic.handle);
tui_set_win_highlight (win_info, 1);
}
void
-tui_make_window (struct tui_gen_win_info * win_info, int boxIt)
+tui_make_window (struct tui_gen_win_info * win_info, int box_it)
{
WINDOW *handle;
win_info->handle = handle;
if (handle != (WINDOW *) NULL)
{
- if (boxIt == BOX_WINDOW)
- boxWin (win_info, NO_HILITE);
+ if (box_it == BOX_WINDOW)
+ box_win (win_info, NO_HILITE);
win_info->is_visible = TRUE;
scrollok (handle, TRUE);
}
touchwin (locator->handle);
tui_refresh_win (locator);
}
-
- return;
-} /* refreshAll */
+}
/*********************************
initializes the horizontal scroll to 0. */
void
tui_update_source_window (struct tui_win_info * win_info, struct symtab *s,
- union tui_line_or_address lineOrAddr, int noerror)
+ union tui_line_or_address line_or_addr, int noerror)
{
win_info->detail.source_info.horizontal_offset = 0;
- tui_update_source_window_as_is (win_info, s, lineOrAddr, noerror);
+ tui_update_source_window_as_is (win_info, s, line_or_addr, noerror);
return;
}
shows the source as specified by the horizontal offset. */
void
tui_update_source_window_as_is (struct tui_win_info * win_info, struct symtab *s,
- union tui_line_or_address lineOrAddr, int noerror)
+ union tui_line_or_address line_or_addr, int noerror)
{
enum tui_status ret;
if (win_info->generic.type == SRC_WIN)
- ret = tui_set_source_content (s, lineOrAddr.line_no, noerror);
+ ret = tui_set_source_content (s, line_or_addr.line_no, noerror);
else
- ret = tui_set_disassem_content (lineOrAddr.addr);
+ ret = tui_set_disassem_content (line_or_addr.addr);
if (ret == TUI_FAILURE)
{
{
struct symtab_and_line sal;
- sal.line = lineOrAddr.line_no +
+ sal.line = line_or_addr.line_no +
(win_info->generic.content_size - 2);
sal.symtab = s;
set_current_source_symtab_and_line (&sal);
tui_clear_exec_info_content (win_info);
}
}
-
- return;
-} /* tuiUpdateSourceWindowsWithAddr */
+}
/* Function to ensure that the source and/or disassemly windows
reflect the input address. */
}
void
-tui_clear_source_content (struct tui_win_info * win_info, int displayPrompt)
+tui_clear_source_content (struct tui_win_info * win_info, int display_prompt)
{
if (win_info != NULL)
{
register int i;
win_info->generic.content_in_use = FALSE;
- tui_erase_source_content (win_info, displayPrompt);
+ tui_erase_source_content (win_info, display_prompt);
for (i = 0; i < win_info->generic.content_size; i++)
{
struct tui_win_element * element =
element->which_element.source.is_exec_point = FALSE;
}
}
-
- return;
-} /* tuiClearSourceContent */
+}
void
-tui_erase_source_content (struct tui_win_info * win_info, int displayPrompt)
+tui_erase_source_content (struct tui_win_info * win_info, int display_prompt)
{
- int xPos;
- int halfWidth = (win_info->generic.width - 2) / 2;
+ int x_pos;
+ int half_width = (win_info->generic.width - 2) / 2;
if (win_info->generic.handle != (WINDOW *) NULL)
{
werase (win_info->generic.handle);
tui_check_and_display_highlight_if_needed (win_info);
- if (displayPrompt == EMPTY_SOURCE_PROMPT)
+ if (display_prompt == EMPTY_SOURCE_PROMPT)
{
- char *noSrcStr;
+ char *no_src_str;
if (win_info->generic.type == SRC_WIN)
- noSrcStr = NO_SRC_STRING;
+ no_src_str = NO_SRC_STRING;
else
- noSrcStr = NO_DISASSEM_STRING;
- if (strlen (noSrcStr) >= halfWidth)
- xPos = 1;
+ no_src_str = NO_DISASSEM_STRING;
+ if (strlen (no_src_str) >= half_width)
+ x_pos = 1;
else
- xPos = halfWidth - strlen (noSrcStr);
+ x_pos = half_width - strlen (no_src_str);
mvwaddstr (win_info->generic.handle,
(win_info->generic.height / 2),
- xPos,
- noSrcStr);
+ x_pos,
+ no_src_str);
/* elz: added this function call to set the real contents of
the window to what is on the screen, so that later calls
to refresh, do display
the correct stuff, and not the old image */
- tui_set_source_content_nil (win_info, noSrcStr);
+ tui_set_source_content_nil (win_info, no_src_str);
}
tui_refresh_win (&win_info->generic);
}
- return;
-} /* tuiEraseSourceContent */
+}
/* Redraw the complete line of a source or disassembly window. */
void
tui_horizontal_source_scroll (struct tui_win_info * win_info,
enum tui_scroll_direction direction,
- int numToScroll)
+ int num_to_scroll)
{
if (win_info->generic.content != NULL)
{
s = cursal.symtab;
if (direction == LEFT_SCROLL)
- offset = win_info->detail.source_info.horizontal_offset + numToScroll;
+ offset = win_info->detail.source_info.horizontal_offset + num_to_scroll;
else
{
if ((offset =
- win_info->detail.source_info.horizontal_offset - numToScroll) < 0)
+ win_info->detail.source_info.horizontal_offset - num_to_scroll) < 0)
offset = 0;
}
win_info->detail.source_info.horizontal_offset = offset;
}
return;
-} /* tuiHorizontalSourceScroll */
+}
/* Set or clear the has_break flag in the line whose line is line_no. */
i = 0;
while (i < win_info->generic.content_size)
{
- int newState;
+ int new_state;
if (content[i]->which_element.source.line_or_addr.addr == l.addr)
- newState = TRUE;
+ new_state = TRUE;
else
- newState = FALSE;
- if (newState != content[i]->which_element.source.is_exec_point)
+ new_state = FALSE;
+ if (new_state != content[i]->which_element.source.is_exec_point)
{
changed++;
- content[i]->which_element.source.is_exec_point = newState;
+ content[i]->which_element.source.is_exec_point = new_state;
tui_show_source_line (win_info, i + 1);
}
i++;
}
-/*
- ** tuiSetExecInfoContent().
- ** Function to initialize the content of the execution info window,
- ** based upon the input window which is either the source or
- ** disassembly window.
- */
+/* Function to initialize the content of the execution info window,
+ based upon the input window which is either the source or
+ disassembly window. */
enum tui_status
-tuiSetExecInfoContent (struct tui_win_info * win_info)
+tui_set_exec_info_content (struct tui_win_info * win_info)
{
enum tui_status ret = TUI_SUCCESS;
if (win_info->detail.source_info.execution_info != (struct tui_gen_win_info *) NULL)
{
- struct tui_gen_win_info * execInfoPtr = win_info->detail.source_info.execution_info;
+ struct tui_gen_win_info * exec_info_ptr = win_info->detail.source_info.execution_info;
- if (execInfoPtr->content == NULL)
- execInfoPtr->content =
+ if (exec_info_ptr->content == NULL)
+ exec_info_ptr->content =
(void **) tui_alloc_content (win_info->generic.height,
- execInfoPtr->type);
- if (execInfoPtr->content != NULL)
+ exec_info_ptr->type);
+ if (exec_info_ptr->content != NULL)
{
int i;
for (i = 0; i < win_info->generic.content_size; i++)
{
struct tui_win_element * element;
- struct tui_win_element * srcElement;
+ struct tui_win_element * src_element;
int mode;
- element = (struct tui_win_element *) execInfoPtr->content[i];
- srcElement = (struct tui_win_element *) win_info->generic.content[i];
+ element = (struct tui_win_element *) exec_info_ptr->content[i];
+ src_element = (struct tui_win_element *) win_info->generic.content[i];
memset(element->which_element.simple_string, ' ',
sizeof(element->which_element.simple_string));
/* Now update the exec info content based upon the state
of each line as indicated by the source content. */
- mode = srcElement->which_element.source.has_break;
+ mode = src_element->which_element.source.has_break;
if (mode & TUI_BP_HIT)
element->which_element.simple_string[TUI_BP_HIT_POS] =
(mode & TUI_BP_HARDWARE) ? 'H' : 'B';
else if (mode & TUI_BP_DISABLED)
element->which_element.simple_string[TUI_BP_BREAK_POS] = '-';
- if (srcElement->which_element.source.is_exec_point)
+ if (src_element->which_element.source.is_exec_point)
element->which_element.simple_string[TUI_EXEC_POS] = '>';
}
- execInfoPtr->content_size = win_info->generic.content_size;
+ exec_info_ptr->content_size = win_info->generic.content_size;
}
else
ret = TUI_FAILURE;
}
-/*
- ** tuiShowExecInfoContent().
- */
void
-tuiShowExecInfoContent (struct tui_win_info * win_info)
+tui_show_exec_info_content (struct tui_win_info * win_info)
{
- 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->content_size); curLine++)
- mvwaddstr (execInfo->handle,
- curLine,
+ struct tui_gen_win_info * exec_info = win_info->detail.source_info.execution_info;
+ int cur_line;
+
+ werase (exec_info->handle);
+ tui_refresh_win (exec_info);
+ for (cur_line = 1; (cur_line <= exec_info->content_size); cur_line++)
+ mvwaddstr (exec_info->handle,
+ cur_line,
0,
((struct tui_win_element *)
- execInfo->content[curLine - 1])->which_element.simple_string);
- tui_refresh_win (execInfo);
- execInfo->content_in_use = TRUE;
-
- return;
+ exec_info->content[cur_line - 1])->which_element.simple_string);
+ tui_refresh_win (exec_info);
+ exec_info->content_in_use = TRUE;
}
void
tui_erase_exec_info_content (struct tui_win_info * win_info)
{
- struct tui_gen_win_info * execInfo = win_info->detail.source_info.execution_info;
-
- werase (execInfo->handle);
- tui_refresh_win (execInfo);
+ struct tui_gen_win_info * exec_info = win_info->detail.source_info.execution_info;
- return;
+ werase (exec_info->handle);
+ tui_refresh_win (exec_info);
}
void
void
tui_update_exec_info (struct tui_win_info * win_info)
{
- tuiSetExecInfoContent (win_info);
- tuiShowExecInfoContent (win_info);
-} /* tuiUpdateExecInfo */
+ tui_set_exec_info_content (win_info);
+ tui_show_exec_info_content (win_info);
+}
enum tui_status
tui_alloc_source_buffer (struct tui_win_info *win_info)
{
- register char *srcLineBuf;
- register int i, lineWidth, maxLines;
+ register char *src_line_buf;
+ register int i, line_width, max_lines;
enum tui_status ret = TUI_FAILURE;
- maxLines = win_info->generic.height; /* less the highlight box */
- lineWidth = win_info->generic.width - 1;
+ max_lines = win_info->generic.height; /* less the highlight box */
+ line_width = win_info->generic.width - 1;
/*
** Allocate the buffer for the source lines. Do this only once since they
** will be re-used for all source displays. The only other time this will
*/
if (win_info->generic.content == NULL)
{
- srcLineBuf = (char *) xmalloc ((maxLines * lineWidth) * sizeof (char));
- if (srcLineBuf == (char *) NULL)
+ src_line_buf = (char *) xmalloc ((max_lines * line_width) * sizeof (char));
+ if (src_line_buf == (char *) NULL)
fputs_unfiltered (
"Unable to Allocate Memory for Source or Disassembly Display.\n",
gdb_stderr);
{
/* allocate the content list */
if ((win_info->generic.content =
- (void **) tui_alloc_content (maxLines, SRC_WIN)) == NULL)
+ (void **) tui_alloc_content (max_lines, SRC_WIN)) == NULL)
{
- xfree (srcLineBuf);
- srcLineBuf = (char *) NULL;
+ xfree (src_line_buf);
+ src_line_buf = (char *) NULL;
fputs_unfiltered (
"Unable to Allocate Memory for Source or Disassembly Display.\n",
gdb_stderr);
}
}
- for (i = 0; i < maxLines; i++)
+ for (i = 0; i < max_lines; i++)
((struct tui_win_element *)
win_info->generic.content[i])->which_element.source.line =
- srcLineBuf + (lineWidth * i);
+ src_line_buf + (line_width * i);
ret = TUI_SUCCESS;
}
else
ret = TUI_SUCCESS;
return ret;
-} /* tuiAllocSourceBuffer */
+}
/* Answer whether the a particular line number or address is displayed
in the current source window. */
int
tui_line_is_displayed (int line, struct tui_win_info * win_info,
- int checkThreshold)
+ int check_threshold)
{
- int isDisplayed = FALSE;
+ int is_displayed = FALSE;
int i, threshold;
- if (checkThreshold)
+ if (check_threshold)
threshold = SCROLL_THRESHOLD;
else
threshold = 0;
i = 0;
- while (i < win_info->generic.content_size - threshold && !isDisplayed)
+ while (i < win_info->generic.content_size - threshold && !is_displayed)
{
- isDisplayed = (((struct tui_win_element *)
+ is_displayed = (((struct tui_win_element *)
win_info->generic.content[i])->which_element.source.line_or_addr.line_no
== (int) line);
i++;
}
- return isDisplayed;
+ return is_displayed;
}
in the current source window. */
int
tui_addr_is_displayed (CORE_ADDR addr, struct tui_win_info * win_info,
- int checkThreshold)
+ int check_threshold)
{
- int isDisplayed = FALSE;
+ int is_displayed = FALSE;
int i, threshold;
- if (checkThreshold)
+ if (check_threshold)
threshold = SCROLL_THRESHOLD;
else
threshold = 0;
i = 0;
- while (i < win_info->generic.content_size - threshold && !isDisplayed)
+ while (i < win_info->generic.content_size - threshold && !is_displayed)
{
- isDisplayed = (((struct tui_win_element *)
+ is_displayed = (((struct tui_win_element *)
win_info->generic.content[i])->which_element.source.line_or_addr.addr
== addr);
i++;
}
- return isDisplayed;
+ return is_displayed;
}
static int
tui_rl_other_window (int count, int key)
{
- struct tui_win_info * winInfo;
+ struct tui_win_info * win_info;
if (!tui_active)
tui_rl_switch_mode (0/*notused*/, 0/*notused*/);
- winInfo = tui_next_win (tui_win_with_focus ());
- if (winInfo)
+ win_info = tui_next_win (tui_win_with_focus ());
+ if (win_info)
{
- tui_set_win_focus_to (winInfo);
+ tui_set_win_focus_to (win_info);
if (TUI_DATA_WIN && TUI_DATA_WIN->generic.is_visible)
tui_refresh_data_win ();
- keypad (TUI_CMD_WIN->generic.handle, (winInfo != TUI_CMD_WIN));
+ keypad (TUI_CMD_WIN->generic.handle, (win_info != TUI_CMD_WIN));
}
return 0;
}
}
void
-strcat_to_buf (char *buf, int buflen, const char *itemToAdd)
+strcat_to_buf (char *buf, int buflen, const char *item_to_add)
{
- if (itemToAdd != (char *) NULL && buf != (char *) NULL)
+ if (item_to_add != (char *) NULL && buf != (char *) NULL)
{
- if ((strlen (buf) + strlen (itemToAdd)) <= buflen)
- strcat (buf, itemToAdd);
+ if ((strlen (buf) + strlen (item_to_add)) <= buflen)
+ strcat (buf, item_to_add);
else
- strncat (buf, itemToAdd, (buflen - strlen (buf)));
+ strncat (buf, item_to_add, (buflen - strlen (buf)));
}
}
#define CHK(val, dft) (val<=0 ? dft : val)
static void
-_tuiReset (void)
+tui_reset (void)
{
struct termio mode;
#endif /* USG */
return;
-} /* _tuiReset */
+}
#endif
void
projects / deliverable / binutils-gdb.git / commitdiff
