X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fmi%2Fmi-interp.c;h=72d63d0a05f44a2d39fc99c5320a2cbb7c1f004f;hb=0e454242cc1527e49ad0ea795614ac94a083b68a;hp=d2e5b1cd1d68fe987ba347bc17655b163718f6d5;hpb=f38d3ad186f1820596743a04b7394b0749942501;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/mi/mi-interp.c b/gdb/mi/mi-interp.c index d2e5b1cd1d..72d63d0a05 100644 --- a/gdb/mi/mi-interp.c +++ b/gdb/mi/mi-interp.c @@ -38,13 +38,13 @@ #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 @@ -89,6 +89,18 @@ static void mi_on_sync_execution_done (void); 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. */ @@ -107,20 +119,18 @@ mi_interpreter_init (struct interp *interp, int top_level) 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 = mi_console_file_new (mi->raw_stdout, "~", '"'); + mi->err = mi_console_file_new (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 = mi_console_file_new (mi->raw_stdout, "@", '"'); + mi->event_channel = mi_console_file_new (mi->raw_stdout, "=", 0); name = interp_name (interp); /* INTERP_MI selects the most recent released version. "mi2" was @@ -159,20 +169,10 @@ mi_interpreter_resume (void *data) /* As per hack note in mi_interpreter_init, swap in the output channels... */ - gdb_setup_readline (); + gdb_setup_readline (0); - /* These overwrite some of the initialization done in - _intialize_event_loop. */ ui->call_readline = gdb_readline_no_editing_callback; ui->input_handler = mi_execute_command_input_handler; - async_command_editing_p = 0; - /* 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. */ @@ -286,7 +286,7 @@ mi_execute_command_wrapper (const char *cmd) { 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. */ @@ -303,10 +303,7 @@ mi_on_sync_execution_done (void) /* 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. */ @@ -314,6 +311,11 @@ mi_on_sync_execution_done (void) 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 @@ -321,36 +323,31 @@ mi_execute_command_input_handler (char *cmd) 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) +mi_interpreter_pre_command_loop (struct interp *self) { + struct mi_interp *mi = (struct mi_interp *) interp_data (self); + /* 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; @@ -373,12 +370,10 @@ mi_new_thread (struct thread_info *t) 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; @@ -403,9 +398,7 @@ static void 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; @@ -449,9 +442,7 @@ mi_record_changed (struct inferior *inferior, int started, const char *method, 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; @@ -482,9 +473,7 @@ mi_inferior_added (struct inferior *inf) 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; @@ -506,9 +495,7 @@ mi_inferior_appeared (struct inferior *inf) 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; @@ -535,9 +522,7 @@ mi_inferior_exit (struct inferior *inf) 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; @@ -586,9 +571,7 @@ find_mi_interp (void) 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 (); @@ -605,9 +588,7 @@ mi_on_signal_received (enum gdb_signal siggnal) 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 (); @@ -624,9 +605,7 @@ mi_on_end_stepping_range (void) 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 (); @@ -643,9 +622,7 @@ mi_on_signal_exited (enum gdb_signal siggnal) 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 (); @@ -662,9 +639,7 @@ mi_on_exited (int exitstatus) 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 (); @@ -683,11 +658,13 @@ mi_on_normal_stop_1 (struct bpstats *bs, int print_frame) 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_data (); if (print_frame) { struct thread_info *tp; int core; + struct interp *console_interp; tp = inferior_thread (); @@ -702,36 +679,10 @@ mi_on_normal_stop_1 (struct bpstats *bs, int print_frame) } 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 (); - - print_stop_event (mi->cli_uiout); - } + console_interp = interp_lookup (current_ui, INTERP_CONSOLE); + if (should_print_stop_to_console (console_interp, tp)) + print_stop_event (mi->cli_uiout); - tp = inferior_thread (); ui_out_field_int (mi_uiout, "thread-id", tp->global_num); if (non_stop) { @@ -749,20 +700,18 @@ mi_on_normal_stop_1 (struct bpstats *bs, int print_frame) ui_out_field_int (mi_uiout, "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; @@ -795,6 +744,7 @@ struct mi_suppress_notification mi_suppress_notification = 0, 0, 0, + 0, }; /* Emit notification on changing a traceframe. */ @@ -802,12 +752,10 @@ struct mi_suppress_notification mi_suppress_notification = 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; @@ -836,9 +784,7 @@ mi_traceframe_changed (int tfnum, int tpnum) 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; @@ -864,9 +810,7 @@ mi_tsv_created (const struct trace_state_variable *tsv) 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; @@ -894,9 +838,7 @@ mi_tsv_deleted (const struct trace_state_variable *tsv) 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; @@ -934,15 +876,13 @@ mi_tsv_modified (const struct trace_state_variable *tsv) 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; @@ -988,15 +928,13 @@ mi_breakpoint_created (struct breakpoint *b) 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; @@ -1021,15 +959,13 @@ mi_breakpoint_deleted (struct breakpoint *b) 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; @@ -1070,9 +1006,8 @@ static int 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 ()); @@ -1080,7 +1015,7 @@ mi_output_running_pid (struct thread_info *info, void *arg) 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); } @@ -1101,7 +1036,7 @@ mi_inferior_count (struct inferior *inf, void *arg) } 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 @@ -1113,12 +1048,12 @@ mi_on_resume_1 (ptid_t ptid) 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; @@ -1129,7 +1064,7 @@ mi_on_resume_1 (ptid_t ptid) 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); } @@ -1138,29 +1073,26 @@ mi_on_resume_1 (ptid_t 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 (); @@ -1171,7 +1103,7 @@ mi_on_resume (ptid_t ptid) 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; @@ -1182,7 +1114,7 @@ mi_on_resume (ptid_t ptid) 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); } @@ -1191,9 +1123,7 @@ mi_on_resume (ptid_t ptid) 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; @@ -1232,9 +1162,7 @@ mi_solib_loaded (struct so_list *solib) 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; @@ -1274,12 +1202,10 @@ mi_solib_unloaded (struct so_list *solib) 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; @@ -1314,12 +1240,10 @@ static void 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; @@ -1362,6 +1286,63 @@ mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr, } } +/* 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 ()); + + ui_out_redirect (mi_uiout, 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) { @@ -1392,11 +1373,6 @@ mi_ui_out (struct interp *interp) return mi->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). */ @@ -1419,23 +1395,23 @@ mi_set_logging (struct interp *interp, int start_log, if (logfile) { ui_file_delete (out); - out = tee_file_new (raw_stdout, 0, logfile, 0); + out = tee_file_new (mi->raw_stdout, 0, logfile, 0); } - saved_raw_stdout = raw_stdout; - raw_stdout = out; + mi->saved_raw_stdout = mi->raw_stdout; + mi->raw_stdout = out; } else { - raw_stdout = saved_raw_stdout; - saved_raw_stdout = NULL; + 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); + mi_console_set_raw (mi->out, mi->raw_stdout); + mi_console_set_raw (mi->err, mi->raw_stdout); + mi_console_set_raw (mi->log, mi->raw_stdout); + mi_console_set_raw (mi->targ, mi->raw_stdout); + mi_console_set_raw (mi->event_channel, mi->raw_stdout); return 1; } @@ -1450,7 +1426,7 @@ static const struct interp_procs mi_interp_procs = mi_interpreter_exec, /* exec_proc */ mi_ui_out, /* ui_out_proc */ mi_set_logging, /* set_logging_proc */ - mi_command_loop /* command_loop_proc */ + mi_interpreter_pre_command_loop /* pre_command_loop_proc */ }; /* Factory for MI interpreters. */ @@ -1499,4 +1475,6 @@ _initialize_mi_interp (void) 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); }