void
mi_ui_out::open (const char *name, ui_out_type type)
{
ui_file *stream = m_streams.back ();
field_separator ();
m_suppress_field_separator = true;
if (name)
fprintf_unfiltered (stream, "%s=", name);
switch (type)
{
case ui_out_type_tuple:
fputc_unfiltered ('{', stream);
break;
case ui_out_type_list:
fputc_unfiltered ('[', stream);
break;
default:
internal_error (__FILE__, __LINE__, _("bad switch"));
}
}
static void
mi_open (struct ui_out *uiout,
const char *name,
enum ui_out_type type)
{
struct ui_out_data *data = ui_out_data (uiout);
field_separator (uiout);
data->suppress_field_separator = 1;
if (name)
fprintf_unfiltered (data->buffer, "%s=", name);
switch (type)
{
case ui_out_type_tuple:
fputc_unfiltered ('{', data->buffer);
break;
case ui_out_type_list:
if (data->mi_version == 0)
fputc_unfiltered ('{', data->buffer);
else
fputc_unfiltered ('[', data->buffer);
break;
default:
internal_error (__FILE__, __LINE__, "bad switch");
}
}
static char *
explicit_to_string_internal (int as_linespec,
const struct explicit_location *explicit_loc)
{
struct ui_file *buf;
char space, *result;
int need_space = 0;
struct cleanup *cleanup;
space = as_linespec ? ':' : ' ';
buf = mem_fileopen ();
cleanup = make_cleanup_ui_file_delete (buf);
if (explicit_loc->source_filename != NULL)
{
if (!as_linespec)
fputs_unfiltered ("-source ", buf);
fputs_unfiltered (explicit_loc->source_filename, buf);
need_space = 1;
}
if (explicit_loc->function_name != NULL)
{
if (need_space)
fputc_unfiltered (space, buf);
if (!as_linespec)
fputs_unfiltered ("-function ", buf);
fputs_unfiltered (explicit_loc->function_name, buf);
need_space = 1;
}
if (explicit_loc->label_name != NULL)
{
if (need_space)
fputc_unfiltered (space, buf);
if (!as_linespec)
fputs_unfiltered ("-label ", buf);
fputs_unfiltered (explicit_loc->label_name, buf);
need_space = 1;
}
if (explicit_loc->line_offset.sign != LINE_OFFSET_UNKNOWN)
{
if (need_space)
fputc_unfiltered (space, buf);
if (!as_linespec)
fputs_unfiltered ("-line ", buf);
fprintf_filtered (buf, "%s%d",
(explicit_loc->line_offset.sign == LINE_OFFSET_NONE ? ""
: (explicit_loc->line_offset.sign
== LINE_OFFSET_PLUS ? "+" : "-")),
explicit_loc->line_offset.offset);
}
result = ui_file_xstrdup (buf, NULL);
do_cleanups (cleanup);
return result;
}
void
mi_ui_out::field_separator ()
{
if (m_suppress_field_separator)
m_suppress_field_separator = false;
else
fputc_unfiltered (',', m_streams.back ());
}
static void
field_separator (struct ui_out *uiout)
{
struct ui_out_data *data = ui_out_data (uiout);
if (data->suppress_field_separator)
data->suppress_field_separator = 0;
else
fputc_unfiltered (',', data->buffer);
}
static void
mi_close (struct ui_out *uiout,
enum ui_out_type type)
{
mi_out_data *data = ui_out_data (uiout);
switch (type)
{
case ui_out_type_tuple:
fputc_unfiltered ('}', data->buffer);
break;
case ui_out_type_list:
fputc_unfiltered (']', data->buffer);
break;
default:
internal_error (__FILE__, __LINE__, "bad switch");
}
data->suppress_field_separator = 0;
}
void
mi_ui_out::close (ui_out_type type)
{
ui_file *stream = m_streams.back ();
switch (type)
{
case ui_out_type_tuple:
fputc_unfiltered ('}', stream);
break;
case ui_out_type_list:
fputc_unfiltered (']', stream);
break;
default:
internal_error (__FILE__, __LINE__, _("bad switch"));
}
m_suppress_field_separator = false;
}
static void
signal_catchpoint_print_recreate (struct breakpoint *b, struct ui_file *fp)
{
struct signal_catchpoint *c = (struct signal_catchpoint *) b;
fprintf_unfiltered (fp, "catch signal");
if (c->signals_to_be_caught)
{
int i;
gdb_signal_type iter;
for (i = 0;
VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter);
i++)
fprintf_unfiltered (fp, " %s", signal_to_name_or_int (iter));
}
else if (c->catch_all)
fprintf_unfiltered (fp, " all");
fputc_unfiltered ('\n', fp);
}
static void
serial_logchar (struct ui_file *stream, int ch_type, int ch, int timeout)
{
if (ch_type != serial_current_type)
{
fprintf_unfiltered (stream, "\n%c ", ch_type);
serial_current_type = ch_type;
}
if (serial_logbase != logbase_ascii)
fputc_unfiltered (' ', stream);
switch (ch)
{
case SERIAL_TIMEOUT:
fprintf_unfiltered (stream, "<Timeout: %d seconds>", timeout);
return;
case SERIAL_ERROR:
fprintf_unfiltered (stream, "<Error: %s>", safe_strerror (errno));
return;
case SERIAL_EOF:
fputs_unfiltered ("<Eof>", stream);
return;
case SERIAL_BREAK:
fputs_unfiltered ("<Break>", stream);
return;
default:
if (serial_logbase == logbase_hex)
fprintf_unfiltered (stream, "%02x", ch & 0xff);
else if (serial_logbase == logbase_octal)
fprintf_unfiltered (stream, "%03o", ch & 0xff);
else
switch (ch)
{
case '\\':
fputs_unfiltered ("\\\\", stream);
break;
case '\b':
fputs_unfiltered ("\\b", stream);
break;
case '\f':
fputs_unfiltered ("\\f", stream);
break;
case '\n':
fputs_unfiltered ("\\n", stream);
break;
case '\r':
fputs_unfiltered ("\\r", stream);
break;
case '\t':
fputs_unfiltered ("\\t", stream);
break;
case '\v':
fputs_unfiltered ("\\v", stream);
break;
default:
fprintf_unfiltered (stream,
isprint (ch) ? "%c" : "\\x%02x", ch & 0xFF);
break;
}
}
}
enum mi_cmd_result
mi_cmd_data_read_memory (char *command, char **argv, int argc)
{
struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
CORE_ADDR addr;
long total_bytes;
long nr_cols;
long nr_rows;
char word_format;
struct type *word_type;
long word_size;
char word_asize;
char aschar;
gdb_byte *mbuf;
int nr_bytes;
long offset = 0;
int optind = 0;
char *optarg;
enum opt
{
OFFSET_OPT
};
static struct mi_opt opts[] =
{
{"o", OFFSET_OPT, 1},
0
};
while (1)
{
int opt = mi_getopt ("mi_cmd_data_read_memory", argc, argv, opts,
&optind, &optarg);
if (opt < 0)
break;
switch ((enum opt) opt)
{
case OFFSET_OPT:
offset = atol (optarg);
break;
}
}
argv += optind;
argc -= optind;
if (argc < 5 || argc > 6)
{
mi_error_message = xstrprintf ("mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
return MI_CMD_ERROR;
}
/* Extract all the arguments. */
/* Start address of the memory dump. */
addr = parse_and_eval_address (argv[0]) + offset;
/* The format character to use when displaying a memory word. See
the ``x'' command. */
word_format = argv[1][0];
/* The size of the memory word. */
word_size = atol (argv[2]);
switch (word_size)
{
case 1:
word_type = builtin_type_int8;
word_asize = 'b';
break;
case 2:
word_type = builtin_type_int16;
word_asize = 'h';
break;
case 4:
word_type = builtin_type_int32;
word_asize = 'w';
break;
case 8:
word_type = builtin_type_int64;
word_asize = 'g';
break;
default:
word_type = builtin_type_int8;
word_asize = 'b';
}
/* The number of rows */
nr_rows = atol (argv[3]);
if (nr_rows <= 0)
{
mi_error_message = xstrprintf ("mi_cmd_data_read_memory: invalid number of rows.");
return MI_CMD_ERROR;
}
/* number of bytes per row. */
nr_cols = atol (argv[4]);
if (nr_cols <= 0)
{
mi_error_message = xstrprintf ("mi_cmd_data_read_memory: invalid number of columns.");
return MI_CMD_ERROR;
}
/* The un-printable character when printing ascii. */
if (argc == 6)
aschar = *argv[5];
else
aschar = 0;
/* create a buffer and read it in. */
total_bytes = word_size * nr_rows * nr_cols;
mbuf = xcalloc (total_bytes, 1);
make_cleanup (xfree, mbuf);
nr_bytes = target_read (¤t_target, TARGET_OBJECT_MEMORY, NULL,
mbuf, addr, total_bytes);
if (nr_bytes <= 0)
{
do_cleanups (cleanups);
mi_error_message = xstrdup ("Unable to read memory.");
return MI_CMD_ERROR;
}
/* output the header information. */
ui_out_field_core_addr (uiout, "addr", addr);
ui_out_field_int (uiout, "nr-bytes", nr_bytes);
ui_out_field_int (uiout, "total-bytes", total_bytes);
ui_out_field_core_addr (uiout, "next-row", addr + word_size * nr_cols);
ui_out_field_core_addr (uiout, "prev-row", addr - word_size * nr_cols);
ui_out_field_core_addr (uiout, "next-page", addr + total_bytes);
ui_out_field_core_addr (uiout, "prev-page", addr - total_bytes);
/* Build the result as a two dimentional table. */
{
struct ui_stream *stream = ui_out_stream_new (uiout);
struct cleanup *cleanup_list_memory;
int row;
int row_byte;
cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");
for (row = 0, row_byte = 0;
row < nr_rows;
row++, row_byte += nr_cols * word_size)
{
int col;
int col_byte;
struct cleanup *cleanup_tuple;
struct cleanup *cleanup_list_data;
cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
ui_out_field_core_addr (uiout, "addr", addr + row_byte);
/* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
for (col = 0, col_byte = row_byte;
col < nr_cols;
col++, col_byte += word_size)
{
if (col_byte + word_size > nr_bytes)
{
ui_out_field_string (uiout, NULL, "N/A");
}
else
{
ui_file_rewind (stream->stream);
print_scalar_formatted (mbuf + col_byte, word_type, word_format,
word_asize, stream->stream);
ui_out_field_stream (uiout, NULL, stream);
}
}
do_cleanups (cleanup_list_data);
if (aschar)
{
int byte;
ui_file_rewind (stream->stream);
for (byte = row_byte; byte < row_byte + word_size * nr_cols; byte++)
{
if (byte >= nr_bytes)
{
fputc_unfiltered ('X', stream->stream);
}
else if (mbuf[byte] < 32 || mbuf[byte] > 126)
{
fputc_unfiltered (aschar, stream->stream);
}
else
fputc_unfiltered (mbuf[byte], stream->stream);
}
ui_out_field_stream (uiout, "ascii", stream);
}
do_cleanups (cleanup_tuple);
}
ui_out_stream_delete (stream);
do_cleanups (cleanup_list_memory);
}
do_cleanups (cleanups);
return MI_CMD_DONE;
}