/* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
- Copyright (C) 2002-2016 Free Software Foundation, Inc.
+ Copyright (C) 2002-2017 Free Software Foundation, Inc.
This file is part of GDB.
#include "tracepoint.h"
#include "cli-out.h"
#include "thread-fsm.h"
+#include "cli/cli-interp.h"
/* These are the interpreter setup, etc. functions for the MI
interpreter. */
static void mi_execute_command_wrapper (const char *cmd);
static void mi_execute_command_input_handler (char *cmd);
-static void mi_command_loop (void *data);
/* These are hooks that we put in place while doing interpreter_exec
so we can report interesting things that happened "behind the MI's
static int report_initial_inferior (struct inferior *inf, void *closure);
+/* Display the MI prompt. */
+
+static void
+display_mi_prompt (struct mi_interp *mi)
+{
+ struct ui *ui = current_ui;
+
+ fputs_unfiltered ("(gdb) \n", mi->raw_stdout);
+ gdb_flush (mi->raw_stdout);
+ ui->prompt_state = PROMPTED;
+}
+
/* Returns the INTERP's data cast as mi_interp if INTERP is an MI, and
returns NULL otherwise. */
static struct mi_interp *
as_mi_interp (struct interp *interp)
{
- if (ui_out_is_mi_like_p (interp_ui_out (interp)))
- return (struct mi_interp *) interp_data (interp);
+ if (interp_ui_out (interp)->is_mi_like_p ())
+ return (struct mi_interp *) interp;
return NULL;
}
-static void *
-mi_interpreter_init (struct interp *interp, int top_level)
+void
+mi_interp::init (bool top_level)
{
- struct mi_interp *mi = XNEW (struct mi_interp);
+ mi_interp *mi = this;
const char *name;
int mi_version;
- /* Assign the output channel created at startup to its own global,
- so that we can create a console channel that encapsulates and
- prefixes all gdb_output-type bits coming from the rest of the
- debugger. */
-
- raw_stdout = gdb_stdout;
+ /* Store the current output channel, so that we can create a console
+ channel that encapsulates and prefixes all gdb_output-type bits
+ coming from the rest of the debugger. */
+ mi->raw_stdout = gdb_stdout;
/* Create MI console channels, each with a different prefix so they
can be distinguished. */
- mi->out = mi_console_file_new (raw_stdout, "~", '"');
- mi->err = mi_console_file_new (raw_stdout, "&", '"');
+ mi->out = new mi_console_file (mi->raw_stdout, "~", '"');
+ mi->err = new mi_console_file (mi->raw_stdout, "&", '"');
mi->log = mi->err;
- mi->targ = mi_console_file_new (raw_stdout, "@", '"');
- mi->event_channel = mi_console_file_new (raw_stdout, "=", 0);
+ mi->targ = new mi_console_file (mi->raw_stdout, "@", '"');
+ mi->event_channel = new mi_console_file (mi->raw_stdout, "=", 0);
- name = interp_name (interp);
+ name = interp_name (this);
/* INTERP_MI selects the most recent released version. "mi2" was
released as part of GDB 6.0. */
if (strcmp (name, INTERP_MI) == 0)
up-front. */
iterate_over_inferiors (report_initial_inferior, mi);
}
-
- return mi;
}
-static int
-mi_interpreter_resume (void *data)
+void
+mi_interp::resume ()
{
- struct mi_interp *mi = (struct mi_interp *) data;
+ struct mi_interp *mi = this;
struct ui *ui = current_ui;
/* As per hack note in mi_interpreter_init, swap in the output
ui->call_readline = gdb_readline_no_editing_callback;
ui->input_handler = mi_execute_command_input_handler;
- /* FIXME: This is a total hack for now. PB's use of the MI
- implicitly relies on a bug in the async support which allows
- asynchronous commands to leak through the commmand loop. The bug
- involves (but is not limited to) the fact that sync_execution was
- erroneously initialized to 0. Duplicate by initializing it thus
- here... */
- sync_execution = 0;
gdb_stdout = mi->out;
/* Route error and log output through the MI. */
clear_interpreter_hooks ();
deprecated_show_load_progress = mi_load_progress;
-
- return 1;
}
-static int
-mi_interpreter_suspend (void *data)
+void
+mi_interp::suspend ()
{
gdb_disable_readline ();
- return 1;
}
-static struct gdb_exception
-mi_interpreter_exec (void *data, const char *command)
+gdb_exception
+mi_interp::exec (const char *command)
{
mi_execute_command_wrapper (command);
return exception_none;
{
struct ui *ui = current_ui;
- mi_execute_command (cmd, stdin == ui->instream);
+ mi_execute_command (cmd, ui->instream == ui->stdin_stream);
}
/* Observer for the synchronous_command_done notification. */
/* If MI is sync, then output the MI prompt now, indicating we're
ready for further input. */
if (!mi_async_p ())
- {
- fputs_unfiltered ("(gdb) \n", raw_stdout);
- gdb_flush (raw_stdout);
- }
+ display_mi_prompt (mi);
}
/* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
static void
mi_execute_command_input_handler (char *cmd)
{
+ struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
+ struct ui *ui = current_ui;
+
+ ui->prompt_state = PROMPT_NEEDED;
+
mi_execute_command_wrapper (cmd);
/* Print a prompt, indicating we're ready for further input, unless
to go back to the event loop and will output the prompt in the
'synchronous_command_done' observer when the target next
stops. */
- if (!sync_execution)
- {
- fputs_unfiltered ("(gdb) \n", raw_stdout);
- gdb_flush (raw_stdout);
- }
+ if (ui->prompt_state == PROMPT_NEEDED)
+ display_mi_prompt (mi);
}
-static void
-mi_command_loop (void *data)
+void
+mi_interp::pre_command_loop ()
{
+ struct mi_interp *mi = this;
+
/* Turn off 8 bit strings in quoted output. Any character with the
high bit set is printed using C's octal format. */
sevenbit_strings = 1;
/* Tell the world that we're alive. */
- fputs_unfiltered ("(gdb) \n", raw_stdout);
- gdb_flush (raw_stdout);
-
- start_event_loop ();
+ display_mi_prompt (mi);
}
static void
mi_new_thread (struct thread_info *t)
{
struct inferior *inf = find_inferior_ptid (t->ptid);
- struct switch_thru_all_uis state;
gdb_assert (inf);
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
struct cleanup *old_chain;
static void
mi_thread_exit (struct thread_info *t, int silent)
{
- struct switch_thru_all_uis state;
-
if (silent)
return;
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
struct cleanup *old_chain;
mi_record_changed (struct inferior *inferior, int started, const char *method,
const char *format)
{
- struct switch_thru_all_uis state;
-
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
struct cleanup *old_chain;
static void
mi_inferior_added (struct inferior *inf)
{
- struct switch_thru_all_uis state;
-
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct interp *interp;
struct mi_interp *mi;
static void
mi_inferior_appeared (struct inferior *inf)
{
- struct switch_thru_all_uis state;
-
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
struct cleanup *old_chain;
static void
mi_inferior_exit (struct inferior *inf)
{
- struct switch_thru_all_uis state;
-
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
struct cleanup *old_chain;
static void
mi_inferior_removed (struct inferior *inf)
{
- struct switch_thru_all_uis state;
-
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
struct cleanup *old_chain;
static void
mi_on_signal_received (enum gdb_signal siggnal)
{
- struct switch_thru_all_uis state;
-
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = find_mi_interp ();
static void
mi_on_end_stepping_range (void)
{
- struct switch_thru_all_uis state;
-
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = find_mi_interp ();
static void
mi_on_signal_exited (enum gdb_signal siggnal)
{
- struct switch_thru_all_uis state;
-
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = find_mi_interp ();
static void
mi_on_exited (int exitstatus)
{
- struct switch_thru_all_uis state;
-
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = find_mi_interp ();
static void
mi_on_no_history (void)
{
- struct switch_thru_all_uis state;
-
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = find_mi_interp ();
using cli interpreter, be sure to use MI uiout for output,
not the current one. */
struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
+ struct mi_interp *mi = (struct mi_interp *) top_level_interpreter ();
if (print_frame)
{
struct thread_info *tp;
int core;
+ struct interp *console_interp;
tp = inferior_thread ();
enum async_reply_reason reason;
reason = thread_fsm_async_reply_reason (tp->thread_fsm);
- ui_out_field_string (mi_uiout, "reason",
- async_reason_lookup (reason));
+ mi_uiout->field_string ("reason", async_reason_lookup (reason));
}
print_stop_event (mi_uiout);
- /* Breakpoint hits should always be mirrored to the console.
- Deciding what to mirror to the console wrt to breakpoints and
- random stops gets messy real fast. E.g., say "s" trips on a
- breakpoint. We'd clearly want to mirror the event to the
- console in this case. But what about more complicated cases
- like "s&; thread n; s&", and one of those steps spawning a
- new thread, and that thread hitting a breakpoint? It's
- impossible in general to track whether the thread had any
- relation to the commands that had been executed. So we just
- simplify and always mirror breakpoints and random events to
- the console.
-
- OTOH, we should print the source line to the console when
- stepping or other similar commands, iff the step was started
- by a console command, but not if it was started with
- -exec-step or similar. */
- if ((bpstat_what (tp->control.stop_bpstat).main_action
- == BPSTAT_WHAT_STOP_NOISY)
- || !(tp->thread_fsm != NULL
- && thread_fsm_finished_p (tp->thread_fsm))
- || (tp->control.command_interp != NULL
- && tp->control.command_interp != top_level_interpreter ()))
- {
- struct mi_interp *mi
- = (struct mi_interp *) top_level_interpreter_data ();
+ console_interp = interp_lookup (current_ui, INTERP_CONSOLE);
+ if (should_print_stop_to_console (console_interp, tp))
+ print_stop_event (mi->cli_uiout);
- print_stop_event (mi->cli_uiout);
- }
-
- tp = inferior_thread ();
- ui_out_field_int (mi_uiout, "thread-id", tp->global_num);
+ mi_uiout->field_int ("thread-id", tp->global_num);
if (non_stop)
{
struct cleanup *back_to = make_cleanup_ui_out_list_begin_end
(mi_uiout, "stopped-threads");
- ui_out_field_int (mi_uiout, NULL, tp->global_num);
+ mi_uiout->field_int (NULL, tp->global_num);
do_cleanups (back_to);
}
else
- ui_out_field_string (mi_uiout, "stopped-threads", "all");
+ mi_uiout->field_string ("stopped-threads", "all");
core = target_core_of_thread (inferior_ptid);
if (core != -1)
- ui_out_field_int (mi_uiout, "core", core);
+ mi_uiout->field_int ("core", core);
}
- fputs_unfiltered ("*stopped", raw_stdout);
- mi_out_put (mi_uiout, raw_stdout);
+ fputs_unfiltered ("*stopped", mi->raw_stdout);
+ mi_out_put (mi_uiout, mi->raw_stdout);
mi_out_rewind (mi_uiout);
- mi_print_timing_maybe ();
- fputs_unfiltered ("\n", raw_stdout);
- gdb_flush (raw_stdout);
+ mi_print_timing_maybe (mi->raw_stdout);
+ fputs_unfiltered ("\n", mi->raw_stdout);
+ gdb_flush (mi->raw_stdout);
}
static void
mi_on_normal_stop (struct bpstats *bs, int print_frame)
{
- struct switch_thru_all_uis state;
-
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
if (as_mi_interp (top_level_interpreter ()) == NULL)
continue;
0,
0,
0,
+ 0,
};
/* Emit notification on changing a traceframe. */
static void
mi_traceframe_changed (int tfnum, int tpnum)
{
- struct switch_thru_all_uis state;
-
if (mi_suppress_notification.traceframe)
return;
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
struct cleanup *old_chain;
static void
mi_tsv_created (const struct trace_state_variable *tsv)
{
- struct switch_thru_all_uis state;
-
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
struct cleanup *old_chain;
static void
mi_tsv_deleted (const struct trace_state_variable *tsv)
{
- struct switch_thru_all_uis state;
-
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
struct cleanup *old_chain;
static void
mi_tsv_modified (const struct trace_state_variable *tsv)
{
- struct switch_thru_all_uis state;
-
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
struct ui_out *mi_uiout;
fprintf_unfiltered (mi->event_channel,
"tsv-modified");
- ui_out_redirect (mi_uiout, mi->event_channel);
+ mi_uiout->redirect (mi->event_channel);
- ui_out_field_string (mi_uiout, "name", tsv->name);
- ui_out_field_string (mi_uiout, "initial",
+ mi_uiout->field_string ("name", tsv->name);
+ mi_uiout->field_string ("initial",
plongest (tsv->initial_value));
if (tsv->value_known)
- ui_out_field_string (mi_uiout, "current", plongest (tsv->value));
+ mi_uiout->field_string ("current", plongest (tsv->value));
- ui_out_redirect (mi_uiout, NULL);
+ mi_uiout->redirect (NULL);
gdb_flush (mi->event_channel);
static void
mi_breakpoint_created (struct breakpoint *b)
{
- struct switch_thru_all_uis state;
-
if (mi_suppress_notification.breakpoint)
return;
if (b->number <= 0)
return;
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
struct ui_out *mi_uiout;
/* We want the output from gdb_breakpoint_query to go to
mi->event_channel. One approach would be to just call
gdb_breakpoint_query, and then use mi_out_put to send the current
- content of mi_outout into mi->event_channel. However, that will
+ content of mi_uiout into mi->event_channel. However, that will
break if anything is output to mi_uiout prior to calling the
breakpoint_created notifications. So, we use
ui_out_redirect. */
- ui_out_redirect (mi_uiout, mi->event_channel);
+ mi_uiout->redirect (mi->event_channel);
TRY
{
gdb_breakpoint_query (mi_uiout, b->number, NULL);
}
END_CATCH
- ui_out_redirect (mi_uiout, NULL);
+ mi_uiout->redirect (NULL);
gdb_flush (mi->event_channel);
static void
mi_breakpoint_deleted (struct breakpoint *b)
{
- struct switch_thru_all_uis state;
-
if (mi_suppress_notification.breakpoint)
return;
if (b->number <= 0)
return;
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
struct cleanup *old_chain;
static void
mi_breakpoint_modified (struct breakpoint *b)
{
- struct switch_thru_all_uis state;
-
if (mi_suppress_notification.breakpoint)
return;
if (b->number <= 0)
return;
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
struct cleanup *old_chain;
/* We want the output from gdb_breakpoint_query to go to
mi->event_channel. One approach would be to just call
gdb_breakpoint_query, and then use mi_out_put to send the current
- content of mi_outout into mi->event_channel. However, that will
+ content of mi_uiout into mi->event_channel. However, that will
break if anything is output to mi_uiout prior to calling the
breakpoint_created notifications. So, we use
ui_out_redirect. */
- ui_out_redirect (mi->mi_uiout, mi->event_channel);
+ mi->mi_uiout->redirect (mi->event_channel);
TRY
{
gdb_breakpoint_query (mi->mi_uiout, b->number, NULL);
}
END_CATCH
- ui_out_redirect (mi->mi_uiout, NULL);
+ mi->mi_uiout->redirect (NULL);
gdb_flush (mi->event_channel);
mi_output_running_pid (struct thread_info *info, void *arg)
{
ptid_t *ptid = (ptid_t *) arg;
- struct switch_thru_all_uis state;
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
continue;
if (ptid_get_pid (*ptid) == ptid_get_pid (info->ptid))
- fprintf_unfiltered (raw_stdout,
+ fprintf_unfiltered (mi->raw_stdout,
"*running,thread-id=\"%d\"\n",
info->global_num);
}
}
static void
-mi_on_resume_1 (ptid_t ptid)
+mi_on_resume_1 (struct mi_interp *mi, ptid_t ptid)
{
/* To cater for older frontends, emit ^running, but do it only once
per each command. We do it here, since at this point we know
In future (MI3), we'll be outputting "^done" here. */
if (!running_result_record_printed && mi_proceeded)
{
- fprintf_unfiltered (raw_stdout, "%s^running\n",
+ fprintf_unfiltered (mi->raw_stdout, "%s^running\n",
current_token ? current_token : "");
}
if (ptid_get_pid (ptid) == -1)
- fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
+ fprintf_unfiltered (mi->raw_stdout, "*running,thread-id=\"all\"\n");
else if (ptid_is_pid (ptid))
{
int count = 0;
iterate_over_inferiors (mi_inferior_count, &count);
if (count == 1)
- fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
+ fprintf_unfiltered (mi->raw_stdout, "*running,thread-id=\"all\"\n");
else
iterate_over_threads (mi_output_running_pid, &ptid);
}
struct thread_info *ti = find_thread_ptid (ptid);
gdb_assert (ti);
- fprintf_unfiltered (raw_stdout, "*running,thread-id=\"%d\"\n",
+ fprintf_unfiltered (mi->raw_stdout, "*running,thread-id=\"%d\"\n",
ti->global_num);
}
if (!running_result_record_printed && mi_proceeded)
{
running_result_record_printed = 1;
- /* This is what gdb used to do historically -- printing prompt even if
- it cannot actually accept any input. This will be surely removed
- for MI3, and may be removed even earlier. SYNC_EXECUTION is
- checked here because we only need to emit a prompt if a
- synchronous command was issued when the target is async. */
- if (!target_can_async_p () || sync_execution)
- fputs_unfiltered ("(gdb) \n", raw_stdout);
+ /* This is what gdb used to do historically -- printing prompt
+ even if it cannot actually accept any input. This will be
+ surely removed for MI3, and may be removed even earlier. */
+ if (current_ui->prompt_state == PROMPT_BLOCKED)
+ fputs_unfiltered ("(gdb) \n", mi->raw_stdout);
}
- gdb_flush (raw_stdout);
+ gdb_flush (mi->raw_stdout);
}
static void
mi_on_resume (ptid_t ptid)
{
struct thread_info *tp = NULL;
- struct switch_thru_all_uis state;
if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
tp = inferior_thread ();
if (tp->control.in_infcall)
return;
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
struct cleanup *old_chain;
old_chain = make_cleanup_restore_target_terminal ();
target_terminal_ours_for_output ();
- mi_on_resume_1 (ptid);
+ mi_on_resume_1 (mi, ptid);
do_cleanups (old_chain);
}
}
+/* See mi-interp.h. */
+
+void
+mi_output_solib_attribs (ui_out *uiout, struct so_list *solib)
+{
+ struct gdbarch *gdbarch = target_gdbarch ();
+
+ uiout->field_string ("id", solib->so_original_name);
+ uiout->field_string ("target-name", solib->so_original_name);
+ uiout->field_string ("host-name", solib->so_name);
+ uiout->field_int ("symbols-loaded", solib->symbols_loaded);
+ if (!gdbarch_has_global_solist (target_gdbarch ()))
+ uiout->field_fmt ("thread-group", "i%d", current_inferior ()->num);
+
+ struct cleanup *cleanup
+ = make_cleanup_ui_out_list_begin_end (uiout, "ranges");
+ struct cleanup *tuple_clean_up
+ = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
+ if (solib->addr_high != 0)
+ {
+ uiout->field_core_addr ("from", gdbarch, solib->addr_low);
+ uiout->field_core_addr ("to", gdbarch, solib->addr_high);
+ }
+ do_cleanups (tuple_clean_up);
+ do_cleanups (cleanup);
+}
+
static void
mi_solib_loaded (struct so_list *solib)
{
- struct switch_thru_all_uis state;
-
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
struct ui_out *uiout;
fprintf_unfiltered (mi->event_channel, "library-loaded");
- ui_out_redirect (uiout, mi->event_channel);
+ uiout->redirect (mi->event_channel);
- ui_out_field_string (uiout, "id", solib->so_original_name);
- ui_out_field_string (uiout, "target-name", solib->so_original_name);
- ui_out_field_string (uiout, "host-name", solib->so_name);
- ui_out_field_int (uiout, "symbols-loaded", solib->symbols_loaded);
- if (!gdbarch_has_global_solist (target_gdbarch ()))
- {
- ui_out_field_fmt (uiout, "thread-group", "i%d",
- current_inferior ()->num);
- }
+ mi_output_solib_attribs (uiout, solib);
- ui_out_redirect (uiout, NULL);
+ uiout->redirect (NULL);
gdb_flush (mi->event_channel);
static void
mi_solib_unloaded (struct so_list *solib)
{
- struct switch_thru_all_uis state;
-
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
struct ui_out *uiout;
fprintf_unfiltered (mi->event_channel, "library-unloaded");
- ui_out_redirect (uiout, mi->event_channel);
+ uiout->redirect (mi->event_channel);
- ui_out_field_string (uiout, "id", solib->so_original_name);
- ui_out_field_string (uiout, "target-name", solib->so_original_name);
- ui_out_field_string (uiout, "host-name", solib->so_name);
+ uiout->field_string ("id", solib->so_original_name);
+ uiout->field_string ("target-name", solib->so_original_name);
+ uiout->field_string ("host-name", solib->so_name);
if (!gdbarch_has_global_solist (target_gdbarch ()))
{
- ui_out_field_fmt (uiout, "thread-group", "i%d",
- current_inferior ()->num);
+ uiout->field_fmt ("thread-group", "i%d", current_inferior ()->num);
}
- ui_out_redirect (uiout, NULL);
+ uiout->redirect (NULL);
gdb_flush (mi->event_channel);
static void
mi_command_param_changed (const char *param, const char *value)
{
- struct switch_thru_all_uis state;
-
if (mi_suppress_notification.cmd_param_changed)
return;
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
struct ui_out *mi_uiout;
fprintf_unfiltered (mi->event_channel, "cmd-param-changed");
- ui_out_redirect (mi_uiout, mi->event_channel);
+ mi_uiout->redirect (mi->event_channel);
- ui_out_field_string (mi_uiout, "param", param);
- ui_out_field_string (mi_uiout, "value", value);
+ mi_uiout->field_string ("param", param);
+ mi_uiout->field_string ("value", value);
- ui_out_redirect (mi_uiout, NULL);
+ mi_uiout->redirect (NULL);
gdb_flush (mi->event_channel);
mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr,
ssize_t len, const bfd_byte *myaddr)
{
- struct switch_thru_all_uis state;
-
if (mi_suppress_notification.memory)
return;
- SWITCH_THRU_ALL_UIS (state)
+ SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
struct ui_out *mi_uiout;
fprintf_unfiltered (mi->event_channel, "memory-changed");
- ui_out_redirect (mi_uiout, mi->event_channel);
+ mi_uiout->redirect (mi->event_channel);
- ui_out_field_fmt (mi_uiout, "thread-group", "i%d", inferior->num);
- ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch (), memaddr);
- ui_out_field_fmt (mi_uiout, "len", "%s", hex_string (len));
+ mi_uiout->field_fmt ("thread-group", "i%d", inferior->num);
+ mi_uiout->field_core_addr ("addr", target_gdbarch (), memaddr);
+ mi_uiout->field_fmt ("len", "%s", hex_string (len));
/* Append 'type=code' into notification if MEMADDR falls in the range of
sections contain code. */
sec->the_bfd_section);
if (flags & SEC_CODE)
- ui_out_field_string (mi_uiout, "type", "code");
+ mi_uiout->field_string ("type", "code");
}
- ui_out_redirect (mi_uiout, NULL);
+ mi_uiout->redirect (NULL);
gdb_flush (mi->event_channel);
}
}
+/* Emit an event when the selection context (inferior, thread, frame)
+ changed. */
+
+static void
+mi_user_selected_context_changed (user_selected_what selection)
+{
+ struct thread_info *tp;
+
+ /* Don't send an event if we're responding to an MI command. */
+ if (mi_suppress_notification.user_selected_context)
+ return;
+
+ tp = find_thread_ptid (inferior_ptid);
+
+ SWITCH_THRU_ALL_UIS ()
+ {
+ struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
+ struct ui_out *mi_uiout;
+ struct cleanup *old_chain;
+
+ if (mi == NULL)
+ continue;
+
+ mi_uiout = interp_ui_out (top_level_interpreter ());
+
+ mi_uiout->redirect (mi->event_channel);
+
+ old_chain = make_cleanup_ui_out_redirect_pop (mi_uiout);
+
+ make_cleanup_restore_target_terminal ();
+ target_terminal_ours_for_output ();
+
+ if (selection & USER_SELECTED_INFERIOR)
+ print_selected_inferior (mi->cli_uiout);
+
+ if (tp != NULL
+ && (selection & (USER_SELECTED_THREAD | USER_SELECTED_FRAME)))
+ {
+ print_selected_thread_frame (mi->cli_uiout, selection);
+
+ fprintf_unfiltered (mi->event_channel,
+ "thread-selected,id=\"%d\"",
+ tp->global_num);
+
+ if (tp->state != THREAD_RUNNING)
+ {
+ if (has_stack_frames ())
+ print_stack_frame_to_uiout (mi_uiout, get_selected_frame (NULL),
+ 1, SRC_AND_LOC, 1);
+ }
+ }
+
+ gdb_flush (mi->event_channel);
+ do_cleanups (old_chain);
+ }
+}
+
static int
report_initial_inferior (struct inferior *inf, void *closure)
{
return 0;
}
-static struct ui_out *
-mi_ui_out (struct interp *interp)
+ui_out *
+mi_interp::interp_ui_out ()
{
- struct mi_interp *mi = (struct mi_interp *) interp_data (interp);
-
- return mi->mi_uiout;
+ return this->mi_uiout;
}
-/* Save the original value of raw_stdout here when logging, so we can
- restore correctly when done. */
-
-static struct ui_file *saved_raw_stdout;
-
/* Do MI-specific logging actions; save raw_stdout, and change all
the consoles to use the supplied ui-file(s). */
-static int
-mi_set_logging (struct interp *interp, int start_log,
- struct ui_file *out, struct ui_file *logfile)
+void
+mi_interp::set_logging (ui_file_up logfile, bool logging_redirect)
{
- struct mi_interp *mi = (struct mi_interp *) interp_data (interp);
-
- if (!mi)
- return 0;
+ struct mi_interp *mi = this;
- if (start_log)
+ if (logfile != NULL)
{
- /* The tee created already is based on gdb_stdout, which for MI
- is a console and so we end up in an infinite loop of console
- writing to ui_file writing to console etc. So discard the
- existing tee (it hasn't been used yet, and MI won't ever use
- it), and create one based on raw_stdout instead. */
- if (logfile)
- {
- ui_file_delete (out);
- out = tee_file_new (raw_stdout, 0, logfile, 0);
- }
+ mi->saved_raw_stdout = mi->raw_stdout;
+ mi->raw_stdout = make_logging_output (mi->raw_stdout,
+ std::move (logfile),
+ logging_redirect);
- saved_raw_stdout = raw_stdout;
- raw_stdout = out;
}
else
{
- raw_stdout = saved_raw_stdout;
- saved_raw_stdout = NULL;
+ delete mi->raw_stdout;
+ mi->raw_stdout = mi->saved_raw_stdout;
+ mi->saved_raw_stdout = NULL;
}
- mi_console_set_raw (mi->out, raw_stdout);
- mi_console_set_raw (mi->err, raw_stdout);
- mi_console_set_raw (mi->log, raw_stdout);
- mi_console_set_raw (mi->targ, raw_stdout);
- mi_console_set_raw (mi->event_channel, raw_stdout);
-
- return 1;
+ mi->out->set_raw (mi->raw_stdout);
+ mi->err->set_raw (mi->raw_stdout);
+ mi->log->set_raw (mi->raw_stdout);
+ mi->targ->set_raw (mi->raw_stdout);
+ mi->event_channel->set_raw (mi->raw_stdout);
}
-/* The MI interpreter's vtable. */
-
-static const struct interp_procs mi_interp_procs =
-{
- mi_interpreter_init, /* init_proc */
- mi_interpreter_resume, /* resume_proc */
- mi_interpreter_suspend, /* suspend_proc */
- mi_interpreter_exec, /* exec_proc */
- mi_ui_out, /* ui_out_proc */
- mi_set_logging, /* set_logging_proc */
- mi_command_loop /* command_loop_proc */
-};
-
/* Factory for MI interpreters. */
static struct interp *
mi_interp_factory (const char *name)
{
- return interp_new (name, &mi_interp_procs, NULL);
+ return new mi_interp (name);
}
extern initialize_file_ftype _initialize_mi_interp; /* -Wmissing-prototypes */
observer_attach_command_param_changed (mi_command_param_changed);
observer_attach_memory_changed (mi_memory_changed);
observer_attach_sync_execution_done (mi_on_sync_execution_done);
+ observer_attach_user_selected_context_changed
+ (mi_user_selected_context_changed);
}