/* Function to set the disassembly window's content.
Disassemble count lines starting at pc.
Return address of the count'th instruction after pc. */
static CORE_ADDR
tui_disassemble (struct tui_asm_line* asm_lines, CORE_ADDR pc, int count)
{
struct ui_file *gdb_dis_out;
/* now init the ui_file structure */
gdb_dis_out = tui_sfileopen (256);
/* Now construct each line */
for (; count > 0; count--, asm_lines++)
{
if (asm_lines->addr_string)
xfree (asm_lines->addr_string);
if (asm_lines->insn)
xfree (asm_lines->insn);
print_address (pc, gdb_dis_out);
asm_lines->addr = pc;
asm_lines->addr_string = xstrdup (tui_file_get_strbuf (gdb_dis_out));
ui_file_rewind (gdb_dis_out);
pc = pc + gdb_print_insn (pc, gdb_dis_out);
asm_lines->insn = xstrdup (tui_file_get_strbuf (gdb_dis_out));
/* reset the buffer to empty */
ui_file_rewind (gdb_dis_out);
}
ui_file_delete (gdb_dis_out);
return pc;
}
static char *
tui_register_format (struct frame_info *frame, int regnum)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
struct ui_file *stream;
struct ui_file *old_stdout;
struct cleanup *cleanups;
char *p, *s;
char *ret;
pagination_enabled = 0;
old_stdout = gdb_stdout;
stream = tui_sfileopen (256);
gdb_stdout = stream;
cleanups = make_cleanup (tui_restore_gdbout, (void*) old_stdout);
gdbarch_print_registers_info (gdbarch, stream, frame, regnum, 1);
/* Save formatted output in the buffer. */
p = tui_file_get_strbuf (stream);
/* Remove the possible \n. */
s = strrchr (p, '\n');
if (s && s[1] == 0)
*s = 0;
ret = xstrdup (p);
do_cleanups (cleanups);
return ret;
}
/* Get a printable name for the function at the address. The symbol
name is demangled if demangling is turned on. Returns a pointer to
a static area holding the result. */
static char*
tui_get_function_from_frame (struct frame_info *fi)
{
static char name[256];
struct ui_file *stream = tui_sfileopen (256);
char *p;
print_address_symbolic (get_frame_pc (fi), stream, demangle, "");
p = tui_file_get_strbuf (stream);
/* Use simple heuristics to isolate the function name. The symbol
can be demangled and we can have function parameters. Remove
them because the status line is too short to display them. */
if (*p == '<')
p++;
strncpy (name, p, sizeof (name));
p = strchr (name, '(');
if (!p)
p = strchr (name, '>');
if (p)
*p = 0;
p = strchr (name, '+');
if (p)
*p = 0;
ui_file_delete (stream);
return name;
}
/* Get the register from the frame and make a printable representation
of it in the data element. */
static void
tui_register_format (struct gdbarch *gdbarch, struct frame_info *frame,
struct tui_data_element *data_element, int regnum)
{
struct ui_file *stream;
struct ui_file *old_stdout;
const char *name;
struct cleanup *cleanups;
char *p, *s;
int pos;
struct type *type = gdbarch_register_type (gdbarch, regnum);
name = gdbarch_register_name (gdbarch, regnum);
if (name == 0)
{
return;
}
pagination_enabled = 0;
old_stdout = gdb_stdout;
stream = tui_sfileopen (256);
gdb_stdout = stream;
cleanups = make_cleanup (tui_restore_gdbout, (void*) old_stdout);
if (TYPE_VECTOR (type) != 0 && 0)
{
gdb_byte buf[MAX_REGISTER_SIZE];
int len;
len = register_size (current_gdbarch, regnum);
fprintf_filtered (stream, "%-14s ", name);
get_frame_register (frame, regnum, buf);
print_scalar_formatted (buf, type, 'f', len, stream);
}
else
{
gdbarch_print_registers_info (current_gdbarch, stream,
frame, regnum, 1);
}
/* Save formatted output in the buffer. */
p = tui_file_get_strbuf (stream);
/* Remove the possible \n. */
s = strrchr (p, '\n');
if (s && s[1] == 0)
*s = 0;
xfree (data_element->content);
data_element->content = xstrdup (p);
do_cleanups (cleanups);
}
/* Create the status line to display as much information as we can on
this single line: target name, process number, current function,
current line, current PC, SingleKey mode. */
static char*
tui_make_status_line (struct tui_locator_element *loc)
{
char *string;
char line_buf[50], *pname;
char *buf;
int status_size;
int i, proc_width;
const char *pid_name;
const char *pc_buf;
int target_width;
int pid_width;
int line_width;
int pc_width;
struct ui_file *pc_out;
if (ptid_equal (inferior_ptid, null_ptid))
pid_name = "No process";
else
pid_name = target_pid_to_str (inferior_ptid);
target_width = strlen (target_shortname);
if (target_width > MAX_TARGET_WIDTH)
target_width = MAX_TARGET_WIDTH;
pid_width = strlen (pid_name);
if (pid_width > MAX_PID_WIDTH)
pid_width = MAX_PID_WIDTH;
status_size = tui_term_width ();
string = (char *) xmalloc (status_size + 1);
buf = (char*) alloca (status_size + 1);
/* Translate line number and obtain its size. */
if (loc->line_no > 0)
sprintf (line_buf, "%d", loc->line_no);
else
strcpy (line_buf, "??");
line_width = strlen (line_buf);
if (line_width < MIN_LINE_WIDTH)
line_width = MIN_LINE_WIDTH;
/* Translate PC address. */
pc_out = tui_sfileopen (128);
deprecated_print_address_numeric (loc->addr, 1, pc_out);
pc_buf = tui_file_get_strbuf (pc_out);
pc_width = strlen (pc_buf);
/* First determine the amount of proc name width we have available.
The +1 are for a space separator between fields.
The -1 are to take into account the \0 counted by sizeof. */
proc_width = (status_size
- (target_width + 1)
- (pid_width + 1)
- (sizeof (PROC_PREFIX) - 1 + 1)
- (sizeof (LINE_PREFIX) - 1 + line_width + 1)
- (sizeof (PC_PREFIX) - 1 + pc_width + 1)
- (tui_current_key_mode == TUI_SINGLE_KEY_MODE
? (sizeof (SINGLE_KEY) - 1 + 1)
: 0));
/* If there is no room to print the function name, try by removing
some fields. */
if (proc_width < MIN_PROC_WIDTH)
{
proc_width += target_width + 1;
target_width = 0;
if (proc_width < MIN_PROC_WIDTH)
{
proc_width += pid_width + 1;
pid_width = 0;
if (proc_width <= MIN_PROC_WIDTH)
{
proc_width += pc_width + sizeof (PC_PREFIX) - 1 + 1;
pc_width = 0;
if (proc_width < 0)
{
proc_width += line_width + sizeof (LINE_PREFIX) - 1 + 1;
line_width = 0;
if (proc_width < 0)
proc_width = 0;
}
}
}
}
/* Now convert elements to string form. */
pname = loc->proc_name;
/* Now create the locator line from the string version of the
elements. We could use sprintf() here but that wouldn't ensure
that we don't overrun the size of the allocated buffer.
strcat_to_buf() will. */
*string = (char) 0;
if (target_width > 0)
{
sprintf (buf, "%*.*s ",
-target_width, target_width, target_shortname);
strcat_to_buf (string, status_size, buf);
}
if (pid_width > 0)
{
sprintf (buf, "%*.*s ",
-pid_width, pid_width, pid_name);
strcat_to_buf (string, status_size, buf);
}
/* Show whether we are in SingleKey mode. */
if (tui_current_key_mode == TUI_SINGLE_KEY_MODE)
{
strcat_to_buf (string, status_size, SINGLE_KEY);
strcat_to_buf (string, status_size, " ");
}
/* Procedure/class name. */
if (proc_width > 0)
{
if (strlen (pname) > proc_width)
sprintf (buf, "%s%*.*s* ", PROC_PREFIX,
1 - proc_width, proc_width - 1, pname);
else
sprintf (buf, "%s%*.*s ", PROC_PREFIX,
-proc_width, proc_width, pname);
strcat_to_buf (string, status_size, buf);
}
if (line_width > 0)
{
sprintf (buf, "%s%*.*s ", LINE_PREFIX,
-line_width, line_width, line_buf);
strcat_to_buf (string, status_size, buf);
}
if (pc_width > 0)
{
strcat_to_buf (string, status_size, PC_PREFIX);
strcat_to_buf (string, status_size, pc_buf);
}
for (i = strlen (string); i < status_size; i++)
string[i] = ' ';
string[status_size] = (char) 0;
ui_file_delete (pc_out);
return string;
}