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; }