#include "linespec.h"
#include "extension.h"
#include "gdbcmd.h"
+#include "observer.h"
#include <ctype.h>
-#include "gdb_sys_time.h"
-
-#if defined HAVE_SYS_RESOURCE_H
-#include <sys/resource.h>
-#endif
-
-#ifdef HAVE_GETRUSAGE
-struct rusage rusage;
-#endif
+#include "run-time-clock.h"
+#include <chrono>
enum
{
}
else
{
- struct cleanup *back_to = make_cleanup_restore_integer (&sched_multi);
+ scoped_restore save_multi = make_scoped_restore (&sched_multi);
if (current_context->all)
{
same. */
continue_1 (1);
}
- do_cleanups (back_to);
}
}
{
enum gdb_rc rc;
char *mi_error_message;
+ ptid_t previous_ptid = inferior_ptid;
if (argc != 1)
error (_("-thread-select: USAGE: threadnum."));
rc = gdb_thread_select (current_uiout, argv[0], &mi_error_message);
+ /* If thread switch did not succeed don't notify or print. */
if (rc == GDB_RC_FAIL)
{
make_cleanup (xfree, mi_error_message);
error ("%s", mi_error_message);
}
+
+ print_selected_thread_frame (current_uiout,
+ USER_SELECTED_THREAD | USER_SELECTED_FRAME);
+
+ /* Notify if the thread has effectively changed. */
+ if (!ptid_equal (inferior_ptid, previous_ptid))
+ {
+ observer_notify_user_selected_context_changed (USER_SELECTED_THREAD
+ | USER_SELECTED_FRAME);
+ }
}
void
struct cleanup *back_to
= make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
- ui_out_field_fmt (uiout, "id", "i%d", inferior->num);
- ui_out_field_string (uiout, "type", "process");
+ uiout->field_fmt ("id", "i%d", inferior->num);
+ uiout->field_string ("type", "process");
if (inferior->has_exit_code)
- ui_out_field_string (uiout, "exit-code",
+ uiout->field_string ("exit-code",
int_string (inferior->exit_code, 8, 0, 0, 1));
if (inferior->pid != 0)
- ui_out_field_int (uiout, "pid", inferior->pid);
+ uiout->field_int ("pid", inferior->pid);
if (inferior->pspace->pspace_exec_filename != NULL)
{
- ui_out_field_string (uiout, "executable",
+ uiout->field_string ("executable",
inferior->pspace->pspace_exec_filename);
}
e = unique (b, e);
for (; b != e; ++b)
- ui_out_field_int (uiout, NULL, *b);
+ uiout->field_int (NULL, *b);
do_cleanups (back_to_2);
}
make_cleanup (xfree, cores);
for (p = strtok (p, ","); p; p = strtok (NULL, ","))
- ui_out_field_string (uiout, NULL, p);
+ uiout->field_string (NULL, p);
do_cleanups (back_to);
}
back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
- ui_out_field_fmt (uiout, "id", "%s", pid);
- ui_out_field_string (uiout, "type", "process");
+ uiout->field_fmt ("id", "%s", pid);
+ uiout->field_string ("type", "process");
if (cmd)
- ui_out_field_string (uiout, "description", cmd);
+ uiout->field_string ("description", cmd);
if (user)
- ui_out_field_string (uiout, "user", user);
+ uiout->field_string ("user", user);
if (cores)
output_cores (uiout, "cores", cores);
const char *tid = get_osdata_column (child, "tid");
const char *tcore = get_osdata_column (child, "core");
- ui_out_field_string (uiout, "id", tid);
+ uiout->field_string ("id", tid);
if (tcore)
- ui_out_field_string (uiout, "core", tcore);
+ uiout->field_string ("core", tcore);
do_cleanups (back_to_2);
}
{
if (gdbarch_register_name (gdbarch, regnum) == NULL
|| *(gdbarch_register_name (gdbarch, regnum)) == '\0')
- ui_out_field_string (uiout, NULL, "");
+ uiout->field_string (NULL, "");
else
- ui_out_field_string (uiout, NULL,
- gdbarch_register_name (gdbarch, regnum));
+ uiout->field_string (NULL, gdbarch_register_name (gdbarch, regnum));
}
}
if (gdbarch_register_name (gdbarch, regnum) == NULL
|| *(gdbarch_register_name (gdbarch, regnum)) == '\0')
- ui_out_field_string (uiout, NULL, "");
+ uiout->field_string (NULL, "");
else
- ui_out_field_string (uiout, NULL,
- gdbarch_register_name (gdbarch, regnum));
+ uiout->field_string (NULL, gdbarch_register_name (gdbarch, regnum));
}
do_cleanups (cleanup);
}
error (_("-data-list-changed-registers: "
"Unable to read register contents."));
else if (changed)
- ui_out_field_int (uiout, NULL, regnum);
+ uiout->field_int (NULL, regnum);
}
}
error (_("-data-list-changed-registers: "
"Unable to read register contents."));
else if (changed)
- ui_out_field_int (uiout, NULL, regnum);
+ uiout->field_int (NULL, regnum);
}
else
error (_("bad register number"));
return;
tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
- ui_out_field_int (uiout, "number", regnum);
+ uiout->field_int ("number", regnum);
if (format == 'N')
format = 0;
get_formatted_print_options (&opts, format);
opts.deref_ref = 1;
val_print (value_type (val),
- value_contents_for_printing (val),
value_embedded_offset (val), 0,
stb, 0, val, &opts, current_language);
- ui_out_field_stream (uiout, "value", stb);
+ uiout->field_stream ("value", stb);
do_cleanups (tuple_cleanup);
}
void
mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
{
- struct expression *expr;
struct cleanup *old_chain;
struct value *val;
struct ui_file *stb;
error (_("-data-evaluate-expression: "
"Usage: -data-evaluate-expression expression"));
- expr = parse_expression (argv[0]);
-
- make_cleanup (free_current_contents, &expr);
+ expression_up expr = parse_expression (argv[0]);
- val = evaluate_expression (expr);
+ val = evaluate_expression (expr.get ());
/* Print the result of the expression evaluation. */
get_user_print_options (&opts);
opts.deref_ref = 0;
common_val_print (val, stb, 0, &opts, current_language);
- ui_out_field_stream (uiout, "value", stb);
+ uiout->field_stream ("value", stb);
do_cleanups (old_chain);
}
{
struct gdbarch *gdbarch = get_current_arch ();
struct ui_out *uiout = current_uiout;
- struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
CORE_ADDR addr;
long total_bytes, nr_cols, nr_rows;
char word_format;
long word_size;
char word_asize;
char aschar;
- gdb_byte *mbuf;
int nr_bytes;
long offset = 0;
int oind = 0;
/* Create a buffer and read it in. */
total_bytes = word_size * nr_rows * nr_cols;
- mbuf = XCNEWVEC (gdb_byte, total_bytes);
- make_cleanup (xfree, mbuf);
+
+ std::unique_ptr<gdb_byte[]> mbuf (new gdb_byte[total_bytes]);
/* Dispatch memory reads to the topmost target, not the flattened
current_target. */
nr_bytes = target_read (current_target.beneath,
- TARGET_OBJECT_MEMORY, NULL, mbuf,
+ TARGET_OBJECT_MEMORY, NULL, mbuf.get (),
addr, total_bytes);
if (nr_bytes <= 0)
error (_("Unable to read memory."));
/* Output the header information. */
- ui_out_field_core_addr (uiout, "addr", gdbarch, 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",
- gdbarch, addr + word_size * nr_cols);
- ui_out_field_core_addr (uiout, "prev-row",
- gdbarch, addr - word_size * nr_cols);
- ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
- ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
+ uiout->field_core_addr ("addr", gdbarch, addr);
+ uiout->field_int ("nr-bytes", nr_bytes);
+ uiout->field_int ("total-bytes", total_bytes);
+ uiout->field_core_addr ("next-row", gdbarch, addr + word_size * nr_cols);
+ uiout->field_core_addr ("prev-row", gdbarch, addr - word_size * nr_cols);
+ uiout->field_core_addr ("next-page", gdbarch, addr + total_bytes);
+ uiout->field_core_addr ("prev-page", gdbarch, addr - total_bytes);
/* Build the result as a two dimentional table. */
{
struct value_print_options opts;
cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
- ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
+ uiout->field_core_addr ("addr", gdbarch, 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");
{
if (col_byte + word_size > nr_bytes)
{
- ui_out_field_string (uiout, NULL, "N/A");
+ uiout->field_string (NULL, "N/A");
}
else
{
ui_file_rewind (stream);
- print_scalar_formatted (mbuf + col_byte, word_type, &opts,
+ print_scalar_formatted (&mbuf[col_byte], word_type, &opts,
word_asize, stream);
- ui_out_field_stream (uiout, NULL, stream);
+ uiout->field_stream (NULL, stream);
}
}
do_cleanups (cleanup_list_data);
else
fputc_unfiltered (mbuf[byte], stream);
}
- ui_out_field_stream (uiout, "ascii", stream);
+ uiout->field_stream ("ascii", stream);
}
do_cleanups (cleanup_tuple);
}
do_cleanups (cleanup_stream);
}
- do_cleanups (cleanups);
}
void
int i;
int alloc_len;
- ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin);
- ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin
- - addr);
- ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end);
+ uiout->field_core_addr ("begin", gdbarch, read_result->begin);
+ uiout->field_core_addr ("offset", gdbarch, read_result->begin - addr);
+ uiout->field_core_addr ("end", gdbarch, read_result->end);
alloc_len = (read_result->end - read_result->begin) * 2 * unit_size + 1;
data = (char *) xmalloc (alloc_len);
{
sprintf (p, "%02x", read_result->data[i]);
}
- ui_out_field_string (uiout, "contents", data);
+ uiout->field_string ("contents", data);
xfree (data);
do_cleanups (t);
}
struct ui_out *uiout = current_uiout;
cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
- ui_out_field_string (uiout, NULL, "frozen-varobjs");
- ui_out_field_string (uiout, NULL, "pending-breakpoints");
- ui_out_field_string (uiout, NULL, "thread-info");
- ui_out_field_string (uiout, NULL, "data-read-memory-bytes");
- ui_out_field_string (uiout, NULL, "breakpoint-notifications");
- ui_out_field_string (uiout, NULL, "ada-task-info");
- ui_out_field_string (uiout, NULL, "language-option");
- ui_out_field_string (uiout, NULL, "info-gdb-mi-command");
- ui_out_field_string (uiout, NULL, "undefined-command-error-code");
- ui_out_field_string (uiout, NULL, "exec-run-start-option");
+ uiout->field_string (NULL, "frozen-varobjs");
+ uiout->field_string (NULL, "pending-breakpoints");
+ uiout->field_string (NULL, "thread-info");
+ uiout->field_string (NULL, "data-read-memory-bytes");
+ uiout->field_string (NULL, "breakpoint-notifications");
+ uiout->field_string (NULL, "ada-task-info");
+ uiout->field_string (NULL, "language-option");
+ uiout->field_string (NULL, "info-gdb-mi-command");
+ uiout->field_string (NULL, "undefined-command-error-code");
+ uiout->field_string (NULL, "exec-run-start-option");
if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON)))
- ui_out_field_string (uiout, NULL, "python");
+ uiout->field_string (NULL, "python");
do_cleanups (cleanup);
return;
cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
if (mi_async_p ())
- ui_out_field_string (uiout, NULL, "async");
+ uiout->field_string (NULL, "async");
if (target_can_execute_reverse)
- ui_out_field_string (uiout, NULL, "reverse");
+ uiout->field_string (NULL, "reverse");
do_cleanups (cleanup);
return;
}
inf = add_inferior_with_spaces ();
- ui_out_field_fmt (current_uiout, "inferior", "i%d", inf->num);
+ current_uiout->field_fmt ("inferior", "i%d", inf->num);
}
/* Callback used to find the first inferior other than the current
fputs_unfiltered ("\n", mi->raw_stdout);
}
+/* Determine whether the parsed command already notifies the
+ user_selected_context_changed observer. */
+
+static int
+command_notifies_uscc_observer (struct mi_parse *command)
+{
+ if (command->op == CLI_COMMAND)
+ {
+ /* CLI commands "thread" and "inferior" already send it. */
+ return (strncmp (command->command, "thread ", 7) == 0
+ || strncmp (command->command, "inferior ", 9) == 0);
+ }
+ else /* MI_COMMAND */
+ {
+ if (strcmp (command->command, "interpreter-exec") == 0
+ && command->argc > 1)
+ {
+ /* "thread" and "inferior" again, but through -interpreter-exec. */
+ return (strncmp (command->argv[1], "thread ", 7) == 0
+ || strncmp (command->argv[1], "inferior ", 9) == 0);
+ }
+
+ else
+ /* -thread-select already sends it. */
+ return strcmp (command->command, "thread-select") == 0;
+ }
+}
+
void
mi_execute_command (const char *cmd, int from_tty)
{
if (command != NULL)
{
ptid_t previous_ptid = inferior_ptid;
+ struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
command->token = token;
+ if (command->cmd != NULL && command->cmd->suppress_notification != NULL)
+ {
+ make_cleanup_restore_integer (command->cmd->suppress_notification);
+ *command->cmd->suppress_notification = 1;
+ }
+
if (do_timings)
{
- command->cmd_start = XNEW (struct mi_timestamp);
+ command->cmd_start = new mi_timestamp ();
timestamp (command->cmd_start);
}
if (/* The notifications are only output when the top-level
interpreter (specified on the command line) is MI. */
- ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
+ interp_ui_out (top_level_interpreter ())->is_mi_like_p ()
/* Don't try report anything if there are no threads --
the program is dead. */
&& thread_count () != 0
- /* -thread-select explicitly changes thread. If frontend uses that
- internally, we don't want to emit =thread-selected, since
- =thread-selected is supposed to indicate user's intentions. */
- && strcmp (command->command, "thread-select") != 0)
+ /* If the command already reports the thread change, no need to do it
+ again. */
+ && !command_notifies_uscc_observer (command))
{
struct mi_interp *mi
= (struct mi_interp *) top_level_interpreter_data ();
if (report_change)
{
- struct thread_info *ti = inferior_thread ();
- struct cleanup *old_chain;
-
- old_chain = make_cleanup_restore_target_terminal ();
- target_terminal_ours_for_output ();
-
- fprintf_unfiltered (mi->event_channel,
- "thread-selected,id=\"%d\"",
- ti->global_num);
- gdb_flush (mi->event_channel);
-
- do_cleanups (old_chain);
+ observer_notify_user_selected_context_changed
+ (USER_SELECTED_THREAD | USER_SELECTED_FRAME);
}
}
mi_parse_free (command);
+
+ do_cleanups (cleanup);
}
}
current_context = parse;
- if (parse->cmd->suppress_notification != NULL)
- {
- make_cleanup_restore_integer (parse->cmd->suppress_notification);
- *parse->cmd->suppress_notification = 1;
- }
-
if (parse->cmd->argv_func != NULL)
{
parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
unsigned long total_sent,
unsigned long grand_total)
{
- struct timeval time_now, delta, update_threshold;
- static struct timeval last_update;
+ using namespace std::chrono;
+ static steady_clock::time_point last_update;
static char *previous_sect_name = NULL;
int new_section;
struct ui_out *saved_uiout;
uiout = current_uiout;
- update_threshold.tv_sec = 0;
- update_threshold.tv_usec = 500000;
- gettimeofday (&time_now, NULL);
-
- delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
- delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
-
- if (delta.tv_usec < 0)
- {
- delta.tv_sec -= 1;
- delta.tv_usec += 1000000L;
- }
-
new_section = (previous_sect_name ?
strcmp (previous_sect_name, section_name) : 1);
if (new_section)
fputs_unfiltered (current_token, mi->raw_stdout);
fputs_unfiltered ("+download", mi->raw_stdout);
cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
- ui_out_field_string (uiout, "section", section_name);
- ui_out_field_int (uiout, "section-size", total_section);
- ui_out_field_int (uiout, "total-size", grand_total);
+ uiout->field_string ("section", section_name);
+ uiout->field_int ("section-size", total_section);
+ uiout->field_int ("total-size", grand_total);
do_cleanups (cleanup_tuple);
mi_out_put (uiout, mi->raw_stdout);
fputs_unfiltered ("\n", mi->raw_stdout);
gdb_flush (mi->raw_stdout);
}
- if (delta.tv_sec >= update_threshold.tv_sec &&
- delta.tv_usec >= update_threshold.tv_usec)
+ steady_clock::time_point time_now = steady_clock::now ();
+ if (time_now - last_update > milliseconds (500))
{
struct cleanup *cleanup_tuple;
- last_update.tv_sec = time_now.tv_sec;
- last_update.tv_usec = time_now.tv_usec;
+ last_update = time_now;
if (current_token)
fputs_unfiltered (current_token, mi->raw_stdout);
fputs_unfiltered ("+download", mi->raw_stdout);
cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
- ui_out_field_string (uiout, "section", section_name);
- ui_out_field_int (uiout, "section-sent", sent_so_far);
- ui_out_field_int (uiout, "section-size", total_section);
- ui_out_field_int (uiout, "total-sent", total_sent);
- ui_out_field_int (uiout, "total-size", grand_total);
+ uiout->field_string ("section", section_name);
+ uiout->field_int ("section-sent", sent_so_far);
+ uiout->field_int ("section-size", total_section);
+ uiout->field_int ("total-sent", total_sent);
+ uiout->field_int ("total-size", grand_total);
do_cleanups (cleanup_tuple);
mi_out_put (uiout, mi->raw_stdout);
fputs_unfiltered ("\n", mi->raw_stdout);
static void
timestamp (struct mi_timestamp *tv)
{
- gettimeofday (&tv->wallclock, NULL);
-#ifdef HAVE_GETRUSAGE
- getrusage (RUSAGE_SELF, &rusage);
- tv->utime.tv_sec = rusage.ru_utime.tv_sec;
- tv->utime.tv_usec = rusage.ru_utime.tv_usec;
- tv->stime.tv_sec = rusage.ru_stime.tv_sec;
- tv->stime.tv_usec = rusage.ru_stime.tv_usec;
-#else
- {
- long usec = get_run_time ();
+ using namespace std::chrono;
- tv->utime.tv_sec = usec/1000000L;
- tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
- tv->stime.tv_sec = 0;
- tv->stime.tv_usec = 0;
- }
-#endif
+ tv->wallclock = steady_clock::now ();
+ run_time_clock::now (tv->utime, tv->stime);
}
static void
print_diff_now (file, current_command_ts);
}
-static long
-timeval_diff (struct timeval start, struct timeval end)
-{
- return ((end.tv_sec - start.tv_sec) * 1000000L)
- + (end.tv_usec - start.tv_usec);
-}
-
static void
print_diff (struct ui_file *file, struct mi_timestamp *start,
struct mi_timestamp *end)
{
+ using namespace std::chrono;
+
+ duration<double> wallclock = end->wallclock - start->wallclock;
+ duration<double> utime = end->utime - start->utime;
+ duration<double> stime = end->stime - start->stime;
+
fprintf_unfiltered
(file,
",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
- timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
- timeval_diff (start->utime, end->utime) / 1000000.0,
- timeval_diff (start->stime, end->stime) / 1000000.0);
+ wallclock.count (), utime.count (), stime.count ());
}
void
break;
}
}
+
+ if (argc - oind != 1)
+ error (_("Exactly one argument required "
+ "(file in which to save trace data)"));
+
filename = argv[oind];
if (generate_ctf)
/* Print EXPRESSION according to VALUES. */
static void
-print_variable_or_computed (char *expression, enum print_values values)
+print_variable_or_computed (const char *expression, enum print_values values)
{
- struct expression *expr;
struct cleanup *old_chain;
struct value *val;
struct ui_file *stb;
stb = mem_fileopen ();
old_chain = make_cleanup_ui_file_delete (stb);
- expr = parse_expression (expression);
-
- make_cleanup (free_current_contents, &expr);
+ expression_up expr = parse_expression (expression);
if (values == PRINT_SIMPLE_VALUES)
- val = evaluate_type (expr);
+ val = evaluate_type (expr.get ());
else
- val = evaluate_expression (expr);
+ val = evaluate_expression (expr.get ());
if (values != PRINT_NO_VALUES)
make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
- ui_out_field_string (uiout, "name", expression);
+ uiout->field_string ("name", expression);
switch (values)
{
case PRINT_SIMPLE_VALUES:
type = check_typedef (value_type (val));
type_print (value_type (val), "", stb, -1);
- ui_out_field_stream (uiout, "type", stb);
+ uiout->field_stream ("type", stb);
if (TYPE_CODE (type) != TYPE_CODE_ARRAY
&& TYPE_CODE (type) != TYPE_CODE_STRUCT
&& TYPE_CODE (type) != TYPE_CODE_UNION)
get_no_prettyformat_print_options (&opts);
opts.deref_ref = 1;
common_val_print (val, stb, 0, &opts, current_language);
- ui_out_field_stream (uiout, "value", stb);
+ uiout->field_stream ("value", stb);
}
break;
case PRINT_ALL_VALUES:
get_no_prettyformat_print_options (&opts);
opts.deref_ref = 1;
common_val_print (val, stb, 0, &opts, current_language);
- ui_out_field_stream (uiout, "value", stb);
+ uiout->field_stream ("value", stb);
}
break;
}
old_chain = make_cleanup_restore_current_thread ();
select_frame (get_current_frame ());
- encode_actions_and_make_cleanup (tloc, &tracepoint_list,
- &stepping_list);
+ encode_actions (tloc, &tracepoint_list, &stepping_list);
if (stepping_frame)
clist = &stepping_list;
/* Explicitly wholly collected variables. */
{
struct cleanup *list_cleanup;
- char *p;
int i;
list_cleanup = make_cleanup_ui_out_list_begin_end (uiout,
"explicit-variables");
- for (i = 0; VEC_iterate (char_ptr, clist->wholly_collected, i, p); i++)
- print_variable_or_computed (p, var_print_values);
+
+ const std::vector<std::string> &wholly_collected
+ = clist->wholly_collected ();
+ for (size_t i = 0; i < wholly_collected.size (); i++)
+ {
+ const std::string &str = wholly_collected[i];
+ print_variable_or_computed (str.c_str (), var_print_values);
+ }
+
do_cleanups (list_cleanup);
}
list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout,
"computed-expressions");
- for (i = 0; VEC_iterate (char_ptr, clist->computed, i, p); i++)
- print_variable_or_computed (p, comp_print_values);
+
+ const std::vector<std::string> &computed = clist->computed ();
+ for (size_t i = 0; i < computed.size (); i++)
+ {
+ const std::string &str = computed[i];
+ print_variable_or_computed (str.c_str (), comp_print_values);
+ }
+
do_cleanups (list_cleanup);
}
tsvname = (char *) xrealloc (tsvname, strlen (tsv->name) + 2);
tsvname[0] = '$';
strcpy (tsvname + 1, tsv->name);
- ui_out_field_string (uiout, "name", tsvname);
+ uiout->field_string ("name", tsvname);
tsv->value_known = target_get_trace_state_variable_value (tsv->number,
&tsv->value);
- ui_out_field_int (uiout, "current", tsv->value);
+ uiout->field_int ("current", tsv->value);
}
else
{
- ui_out_field_skip (uiout, "name");
- ui_out_field_skip (uiout, "current");
+ uiout->field_skip ("name");
+ uiout->field_skip ("current");
}
do_cleanups (cleanup_child);
cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
- ui_out_field_core_addr (uiout, "address", gdbarch, r->start);
- ui_out_field_int (uiout, "length", r->length);
+ uiout->field_core_addr ("address", gdbarch, r->start);
+ uiout->field_int ("length", r->length);
data = (gdb_byte *) xmalloc (r->length);
make_cleanup (xfree, data);
for (m = 0, p = data_str; m < r->length; ++m, p += 2)
sprintf (p, "%02x", data[m]);
- ui_out_field_string (uiout, "contents", data_str);
+ uiout->field_string ("contents", data_str);
}
else
- ui_out_field_skip (uiout, "contents");
+ uiout->field_skip ("contents");
}
do_cleanups (cleanup_child);
}