From patchwork Wed Feb 3 16:43:40 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Pedro Alves X-Patchwork-Id: 10726 Received: (qmail 75237 invoked by alias); 3 Feb 2016 16:52:54 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 75165 invoked by uid 89); 3 Feb 2016 16:52:53 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.3 required=5.0 tests=BAYES_00, RP_MATCHES_RCVD, SPF_HELO_PASS autolearn=ham version=3.3.2 spammy=107, 4007, 3927, 392, 7 X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-GCM-SHA384 encrypted) ESMTPS; Wed, 03 Feb 2016 16:52:47 +0000 Received: from int-mx11.intmail.prod.int.phx2.redhat.com (int-mx11.intmail.prod.int.phx2.redhat.com [10.5.11.24]) by mx1.redhat.com (Postfix) with ESMTPS id 20263383AB2 for ; Wed, 3 Feb 2016 16:44:04 +0000 (UTC) Received: from brno.lan (ovpn01.gateway.prod.ext.phx2.redhat.com [10.5.9.1]) by int-mx11.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id u13GhwPN022971 for ; Wed, 3 Feb 2016 11:44:03 -0500 From: Pedro Alves To: gdb-patches@sourceware.org Subject: [PATCH 05/23] Make the interpreters be per UI Date: Wed, 3 Feb 2016 16:43:40 +0000 Message-Id: <1454517838-7784-6-git-send-email-palves@redhat.com> In-Reply-To: <1454517838-7784-1-git-send-email-palves@redhat.com> References: <1454517838-7784-1-git-send-email-palves@redhat.com> Make each UI have its own interpreter list, top level interpreter, current interpreter, etc. The "interpreter_async" global is not really specific to an struct interp (it crosses interpreter-exec ...), so I moved it to "struct ui" directly, while the other globals were left hidden in interps.c, opaque to the rest of GDB. --- gdb/breakpoint.c | 2 +- gdb/cli/cli-script.c | 16 +++--- gdb/compile/compile.c | 14 ++--- gdb/guile/guile.c | 14 ++--- gdb/guile/scm-ports.c | 6 +- gdb/inf-loop.c | 2 +- gdb/infcall.c | 6 +- gdb/infrun.c | 4 +- gdb/interps.c | 149 +++++++++++++++++++++++++++++++------------------- gdb/interps.h | 9 --- gdb/main.c | 2 +- gdb/python/python.c | 12 ++-- gdb/top.c | 6 +- gdb/top.h | 15 +++++ 14 files changed, 150 insertions(+), 107 deletions(-) diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c index afd9065..1fad0d1 100644 --- a/gdb/breakpoint.c +++ b/gdb/breakpoint.c @@ -4720,7 +4720,7 @@ bpstat_do_actions_1 (bpstat *bsp) if (breakpoint_proceeded) { - if (interpreter_async) + if (current_ui->async) /* If we are in async mode, then the target might be still running, not stopped at any breakpoint, so nothing for us to do here -- just return to the event loop. */ diff --git a/gdb/cli/cli-script.c b/gdb/cli/cli-script.c index 7302330..5fc01b3 100644 --- a/gdb/cli/cli-script.c +++ b/gdb/cli/cli-script.c @@ -379,8 +379,8 @@ execute_user_command (struct cmd_list_element *c, char *args) not confused with Insight. */ in_user_command = 1; - make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + make_cleanup_restore_integer (¤t_ui->async); + current_ui->async = 0; command_nest_depth++; while (cmdlines) @@ -661,8 +661,8 @@ while_command (char *arg, int from_tty) if (command == NULL) return; - old_chain = make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + old_chain = make_cleanup_restore_integer (¤t_ui->async); + current_ui->async = 0; execute_control_command_untraced (command); free_command_lines (&command); @@ -685,8 +685,8 @@ if_command (char *arg, int from_tty) if (command == NULL) return; - old_chain = make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + old_chain = make_cleanup_restore_integer (¤t_ui->async); + current_ui->async = 0; execute_control_command_untraced (command); free_command_lines (&command); @@ -1688,8 +1688,8 @@ script_from_file (FILE *stream, const char *file) source_line_number = 0; source_file_name = file; - make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + make_cleanup_restore_integer (¤t_ui->async); + current_ui->async = 0; { diff --git a/gdb/compile/compile.c b/gdb/compile/compile.c index 77b4137..0c4a738 100644 --- a/gdb/compile/compile.c +++ b/gdb/compile/compile.c @@ -18,7 +18,7 @@ along with this program. If not, see . */ #include "defs.h" -#include "interps.h" +#include "top.h" #include "ui-out.h" #include "command.h" #include "cli/cli-script.h" @@ -91,8 +91,8 @@ compile_file_command (char *arg, int from_tty) char *buffer; struct cleanup *cleanup; - cleanup = make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + cleanup = make_cleanup_restore_integer (¤t_ui->async); + current_ui->async = 0; /* Check the user did not just after command. */ if (arg == NULL) @@ -133,8 +133,8 @@ compile_code_command (char *arg, int from_tty) struct cleanup *cleanup; enum compile_i_scope_types scope = COMPILE_I_SIMPLE_SCOPE; - cleanup = make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + cleanup = make_cleanup_restore_integer (¤t_ui->async); + current_ui->async = 0; if (arg != NULL && check_raw_argument (&arg)) { @@ -187,8 +187,8 @@ compile_print_command (char *arg_param, int from_tty) enum compile_i_scope_types scope = COMPILE_I_PRINT_ADDRESS_SCOPE; struct format_data fmt; - cleanup = make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + cleanup = make_cleanup_restore_integer (¤t_ui->async); + current_ui->async = 0; /* Passing &FMT as SCOPE_DATA is safe as do_module_cleanup will not touch the stale pointer if compile_object_run has already quit. */ diff --git a/gdb/guile/guile.c b/gdb/guile/guile.c index 7352b57..86964eb 100644 --- a/gdb/guile/guile.c +++ b/gdb/guile/guile.c @@ -27,7 +27,7 @@ #include "cli/cli-utils.h" #include "command.h" #include "gdbcmd.h" -#include "interps.h" +#include "top.h" #include "extension-priv.h" #include "utils.h" #include "version.h" @@ -166,8 +166,8 @@ guile_repl_command (char *arg, int from_tty) { struct cleanup *cleanup; - cleanup = make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + cleanup = make_cleanup_restore_integer (¤t_ui->async); + current_ui->async = 0; arg = skip_spaces (arg); @@ -199,8 +199,8 @@ guile_command (char *arg, int from_tty) { struct cleanup *cleanup; - cleanup = make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + cleanup = make_cleanup_restore_integer (¤t_ui->async); + current_ui->async = 0; arg = skip_spaces (arg); @@ -329,8 +329,8 @@ gdbscm_execute_gdb_command (SCM command_scm, SCM rest) { struct cleanup *inner_cleanups; - inner_cleanups = make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + inner_cleanups = make_cleanup_restore_integer (¤t_ui->async); + current_ui->async = 0; prevent_dont_repeat (); if (to_string) diff --git a/gdb/guile/scm-ports.c b/gdb/guile/scm-ports.c index a7d61af..b4e8ce6 100644 --- a/gdb/guile/scm-ports.c +++ b/gdb/guile/scm-ports.c @@ -23,7 +23,7 @@ #include "defs.h" #include "gdb_select.h" -#include "interps.h" +#include "top.h" #include "target.h" #include "guile-internal.h" @@ -515,8 +515,8 @@ ioscm_with_output_to_port_worker (SCM port, SCM thunk, enum oport oport, cleanups = set_batch_flag_and_make_cleanup_restore_page_info (); - make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + make_cleanup_restore_integer (¤t_ui->async); + current_ui->async = 0; port_file = ioscm_file_port_new (port); diff --git a/gdb/inf-loop.c b/gdb/inf-loop.c index 2591ae9..d006df8 100644 --- a/gdb/inf-loop.c +++ b/gdb/inf-loop.c @@ -61,7 +61,7 @@ inferior_event_handler (enum inferior_event_type event_type, /* When running a command list (from a user command, say), these are only run when the command list is all done. */ - if (interpreter_async) + if (current_ui->async) { check_frame_language_change (); diff --git a/gdb/infcall.c b/gdb/infcall.c index 77cd931..11f5aba 100644 --- a/gdb/infcall.c +++ b/gdb/infcall.c @@ -560,13 +560,13 @@ run_inferior_call (struct call_thread_fsm *sm, ptid_t call_thread_ptid = call_thread->ptid; int saved_sync_execution = sync_execution; int was_running = call_thread->state == THREAD_RUNNING; - int saved_interpreter_async = interpreter_async; + int saved_ui_async = current_ui->async; /* Infcalls run synchronously, in the foreground. */ sync_execution = 1; /* So that we don't print the prompt prematurely in fetch_inferior_event. */ - interpreter_async = 0; + current_ui->async = 0; call_thread->control.in_infcall = 1; @@ -601,7 +601,7 @@ run_inferior_call (struct call_thread_fsm *sm, again here. In other cases, stdin will be re-enabled by inferior_event_handler, when an exception is thrown. */ sync_execution = saved_sync_execution; - interpreter_async = saved_interpreter_async; + current_ui->async = saved_ui_async; /* At this point the current thread may have changed. Refresh CALL_THREAD as it could be invalid if its thread has exited. */ diff --git a/gdb/infrun.c b/gdb/infrun.c index 15210c9..7f0c3c9 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -3790,7 +3790,7 @@ wait_for_inferior (void) static void reinstall_readline_callback_handler_cleanup (void *arg) { - if (!interpreter_async) + if (!current_ui->async) { /* We're not going back to the top level event loop yet. Don't install the readline callback, as it'd prep the terminal, @@ -3977,7 +3977,7 @@ fetch_inferior_event (void *client_data) /* If the inferior was in sync execution mode, and now isn't, restore the prompt (a synchronous execution command has finished, and we're ready for input). */ - if (interpreter_async && was_sync && !sync_execution) + if (current_ui->async && was_sync && !sync_execution) observer_notify_sync_execution_done (); if (cmd_done diff --git a/gdb/interps.c b/gdb/interps.c index b188d08..945b830 100644 --- a/gdb/interps.c +++ b/gdb/interps.c @@ -39,11 +39,29 @@ #include "top.h" /* For command_loop. */ #include "continuations.h" -/* True if the current interpreter in is async mode. See interps.h - for more details. This starts out disabled, until all the explicit - command line arguments (e.g., `gdb -ex "start" -ex "next"') are - processed. */ -int interpreter_async = 0; +/* Each UI has its own independent set of interpreters. */ + +struct ui_interp_info +{ + /* Each top level has its own independent set of interpreters. */ + struct interp *interp_list; + struct interp *current_interpreter; + struct interp *top_level_interpreter_ptr; + + /* The interpreter that is active while `interp_exec' is active, NULL + at all other times. */ + struct interp *command_interpreter; +}; + +static struct ui_interp_info * +get_current_interp_info (void) +{ + struct ui *ui = current_ui; + + if (ui->interp_info == NULL) + ui->interp_info = XCNEW (struct ui_interp_info); + return ui->interp_info; +} struct interp { @@ -71,12 +89,6 @@ struct interp void _initialize_interpreter (void); -/* Variables local to this file: */ - -static struct interp *interp_list = NULL; -static struct interp *current_interpreter = NULL; -static struct interp *top_level_interpreter_ptr = NULL; - /* interp_new - This allocates space for a new interpreter, fills the fields from the inputs, and returns a pointer to the interpreter. */ @@ -104,10 +116,12 @@ interp_new (const char *name, const struct interp_procs *procs) void interp_add (struct interp *interp) { + struct ui_interp_info *ui_interp = get_current_interp_info (); + gdb_assert (interp_lookup (interp->name) == NULL); - interp->next = interp_list; - interp_list = interp; + interp->next = ui_interp->interp_list; + ui_interp->interp_list = interp; } /* This sets the current interpreter to be INTERP. If INTERP has not @@ -127,24 +141,24 @@ interp_add (struct interp *interp) int interp_set (struct interp *interp, int top_level) { - struct interp *old_interp = current_interpreter; + struct ui_interp_info *ui_interp = get_current_interp_info (); + struct interp *old_interp = ui_interp->current_interpreter; int first_time = 0; char buffer[64]; /* If we already have an interpreter, then trying to set top level interpreter is kinda pointless. */ - gdb_assert (!top_level || !current_interpreter); - gdb_assert (!top_level || !top_level_interpreter_ptr); + gdb_assert (!top_level || !ui_interp->current_interpreter); + gdb_assert (!top_level || !ui_interp->top_level_interpreter_ptr); - if (current_interpreter != NULL) + if (old_interp != NULL) { ui_out_flush (current_uiout); - if (current_interpreter->procs->suspend_proc - && !current_interpreter->procs->suspend_proc (current_interpreter-> - data)) + if (old_interp->procs->suspend_proc + && !old_interp->procs->suspend_proc (old_interp->data)) { error (_("Could not suspend interpreter \"%s\"."), - current_interpreter->name); + old_interp->name); } } else @@ -152,18 +166,18 @@ interp_set (struct interp *interp, int top_level) first_time = 1; } - current_interpreter = interp; + ui_interp->current_interpreter = interp; if (top_level) - top_level_interpreter_ptr = interp; + ui_interp->top_level_interpreter_ptr = interp; /* We use interpreter_p for the "set interpreter" variable, so we need to make sure we have a malloc'ed copy for the set command to free. */ if (interpreter_p != NULL - && strcmp (current_interpreter->name, interpreter_p) != 0) + && strcmp (interp->name, interpreter_p) != 0) { xfree (interpreter_p); - interpreter_p = xstrdup (current_interpreter->name); + interpreter_p = xstrdup (interp->name); } /* Run the init proc. If it fails, try to restore the old interp. */ @@ -209,12 +223,15 @@ interp_set (struct interp *interp, int top_level) struct interp * interp_lookup (const char *name) { + struct ui_interp_info *ui_interp = get_current_interp_info (); struct interp *interp; if (name == NULL || strlen (name) == 0) return NULL; - for (interp = interp_list; interp != NULL; interp = interp->next) + for (interp = ui_interp->interp_list; + interp != NULL; + interp = interp->next) { if (strcmp (interp->name, name) == 0) return interp; @@ -228,34 +245,37 @@ interp_lookup (const char *name) struct ui_out * interp_ui_out (struct interp *interp) { - if (interp != NULL) - return interp->procs->ui_out_proc (interp); + struct ui_interp_info *ui_interp = get_current_interp_info (); - return current_interpreter->procs->ui_out_proc (current_interpreter); + if (interp == NULL) + interp = ui_interp->current_interpreter; + return interp->procs->ui_out_proc (interp); } int current_interp_set_logging (int start_log, struct ui_file *out, struct ui_file *logfile) { - if (current_interpreter == NULL - || current_interpreter->procs->set_logging_proc == NULL) + struct ui_interp_info *ui_interp = get_current_interp_info (); + struct interp *interp = ui_interp->current_interpreter; + + if (interp == NULL + || interp->procs->set_logging_proc == NULL) return 0; - return current_interpreter->procs->set_logging_proc (current_interpreter, - start_log, out, - logfile); + return interp->procs->set_logging_proc (interp, start_log, out, logfile); } /* Temporarily overrides the current interpreter. */ struct interp * interp_set_temp (const char *name) { + struct ui_interp_info *ui_interp = get_current_interp_info (); struct interp *interp = interp_lookup (name); - struct interp *old_interp = current_interpreter; + struct interp *old_interp = ui_interp->current_interpreter; if (interp) - current_interpreter = interp; + ui_interp->current_interpreter = interp; return old_interp; } @@ -279,16 +299,15 @@ interp_name (struct interp *interp) int current_interp_named_p (const char *interp_name) { - if (current_interpreter) - return (strcmp (current_interpreter->name, interp_name) == 0); + struct ui_interp_info *ui_interp = get_current_interp_info (); + struct interp *interp = ui_interp->current_interpreter; + + if (interp != NULL) + return (strcmp (interp->name, interp_name) == 0); return 0; } -/* The interpreter that is active while `interp_exec' is active, NULL - at all other times. */ -static struct interp *command_interpreter; - /* The interpreter that was active when a command was executed. Normally that'd always be CURRENT_INTERPRETER, except that MI's -interpreter-exec command doesn't actually flip the current @@ -302,28 +321,35 @@ static struct interp *command_interpreter; struct interp * command_interp (void) { - if (command_interpreter != NULL) - return command_interpreter; + struct ui_interp_info *ui_interp = get_current_interp_info (); + + if (ui_interp->command_interpreter != NULL) + return ui_interp->command_interpreter; else - return current_interpreter; + return ui_interp->current_interpreter; } /* Run the current command interpreter's main loop. */ void current_interp_command_loop (void) { - gdb_assert (current_interpreter != NULL); + struct ui_interp_info *ui_interp = get_current_interp_info (); + struct interp *interp = ui_interp->current_interpreter; + + gdb_assert (ui_interp->current_interpreter != NULL); - current_interpreter->procs->command_loop_proc (current_interpreter->data); + interp->procs->command_loop_proc (interp->data); } int interp_quiet_p (struct interp *interp) { + struct ui_interp_info *ui_interp = get_current_interp_info (); + if (interp != NULL) return interp->quiet_p; else - return current_interpreter->quiet_p; + return ui_interp->current_interpreter->quiet_p; } static int @@ -341,18 +367,20 @@ interp_set_quiet (struct interp *interp, int quiet) struct gdb_exception interp_exec (struct interp *interp, const char *command_str) { + struct ui_interp_info *ui_interp = get_current_interp_info (); + struct gdb_exception ex; struct interp *save_command_interp; gdb_assert (interp->procs->exec_proc != NULL); /* See `command_interp' for why we do this. */ - save_command_interp = command_interpreter; - command_interpreter = interp; + save_command_interp = ui_interp->command_interpreter; + ui_interp->command_interpreter = interp; ex = interp->procs->exec_proc (interp->data, command_str); - command_interpreter = save_command_interp; + ui_interp->command_interpreter = save_command_interp; return ex; } @@ -379,6 +407,7 @@ clear_interpreter_hooks (void) static void interpreter_exec_cmd (char *args, int from_tty) { + struct ui_interp_info *ui_interp = get_current_interp_info (); struct interp *old_interp, *interp_to_use; char **prules = NULL; char **trule = NULL; @@ -400,7 +429,7 @@ interpreter_exec_cmd (char *args, int from_tty) if (nrules < 2) error (_("usage: interpreter-exec [ ... ]")); - old_interp = current_interpreter; + old_interp = ui_interp->current_interpreter; interp_to_use = interp_lookup (prules[0]); if (interp_to_use == NULL) @@ -438,12 +467,15 @@ static VEC (char_ptr) * interpreter_completer (struct cmd_list_element *ignore, const char *text, const char *word) { + struct ui_interp_info *ui_interp = get_current_interp_info (); int textlen; VEC (char_ptr) *matches = NULL; struct interp *interp; textlen = strlen (text); - for (interp = interp_list; interp != NULL; interp = interp->next) + for (interp = ui_interp->interp_list; + interp != NULL; + interp = interp->next) { if (strncmp (interp->name, text, textlen) == 0) { @@ -474,14 +506,19 @@ interpreter_completer (struct cmd_list_element *ignore, struct interp * top_level_interpreter (void) { - return top_level_interpreter_ptr; + struct ui_interp_info *ui_interp = get_current_interp_info (); + + return ui_interp->top_level_interpreter_ptr; } void * top_level_interpreter_data (void) { - gdb_assert (top_level_interpreter_ptr); - return top_level_interpreter_ptr->data; + struct interp *interp; + + interp = top_level_interpreter (); + gdb_assert (interp != NULL); + return interp->data; } /* This just adds the "interpreter-exec" command. */ diff --git a/gdb/interps.h b/gdb/interps.h index 19cd1c2..f0badc5 100644 --- a/gdb/interps.h +++ b/gdb/interps.h @@ -93,15 +93,6 @@ extern struct interp *top_level_interpreter (void); extern struct interp *command_interp (void); -/* True if the current interpreter is in async mode, false if in sync - mode. If in sync mode, running a synchronous execution command - (with execute_command, e.g, "next") will not return until the - command is finished. If in async mode, then running a synchronous - command returns right after resuming the target. Waiting for the - command's completion is later done on the top event loop (using - continuations). */ -extern int interpreter_async; - extern void clear_interpreter_hooks (void); /* well-known interpreters */ diff --git a/gdb/main.c b/gdb/main.c index 44d1a90..72d0369 100644 --- a/gdb/main.c +++ b/gdb/main.c @@ -309,7 +309,7 @@ captured_command_loop (void *data) { /* Top-level execution commands can be run in the background from here on. */ - interpreter_async = 1; + current_ui->async = 1; current_interp_command_loop (); /* FIXME: cagney/1999-11-05: A correct command_loop() implementaton diff --git a/gdb/python/python.c b/gdb/python/python.c index 7202105..a164e37 100644 --- a/gdb/python/python.c +++ b/gdb/python/python.c @@ -331,8 +331,8 @@ python_interactive_command (char *arg, int from_tty) struct cleanup *cleanup; int err; - cleanup = make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + cleanup = make_cleanup_restore_integer (¤t_ui->async); + current_ui->async = 0; arg = skip_spaces (arg); @@ -476,8 +476,8 @@ python_command (char *arg, int from_tty) cleanup = ensure_python_env (get_current_arch (), current_language); - make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + make_cleanup_restore_integer (¤t_ui->async); + current_ui->async = 0; arg = skip_spaces (arg); if (arg && *arg) @@ -659,8 +659,8 @@ execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw) char *copy = xstrdup (arg); struct cleanup *cleanup = make_cleanup (xfree, copy); - make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + make_cleanup_restore_integer (¤t_ui->async); + current_ui->async = 0; prevent_dont_repeat (); if (to_string) diff --git a/gdb/top.c b/gdb/top.c index 26aee8a..3ecaaeb 100644 --- a/gdb/top.c +++ b/gdb/top.c @@ -392,7 +392,7 @@ maybe_wait_sync_command_done (int was_sync) command's list, running command hooks or similars), and we just ran a synchronous command that started the target, wait for that command to end. */ - if (!interpreter_async && !was_sync && sync_execution) + if (!current_ui->async && !was_sync && sync_execution) wait_sync_command_done (); } @@ -510,8 +510,8 @@ execute_command_to_string (char *p, int from_tty) restoration callbacks. */ cleanup = set_batch_flag_and_make_cleanup_restore_page_info (); - make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + make_cleanup_restore_integer (¤t_ui->async); + current_ui->async = 0; str_file = mem_fileopen (); diff --git a/gdb/top.h b/gdb/top.h index 8beaa4a..2daa03b 100644 --- a/gdb/top.h +++ b/gdb/top.h @@ -23,6 +23,8 @@ #include "buffer.h" #include "event-loop.h" +struct tl_interp_info; + /* All about a user interface instance. Each user interface has its own I/O files/streams, readline state, its own top level interpreter (for the main UI, this is the interpreter specified @@ -50,6 +52,19 @@ struct ui processing. */ void (*input_handler) (char *); + /* Each UI has its own independent set of interpreters. */ + struct ui_interp_info *interp_info; + + /* True if the UI is in async mode, false if in sync mode. If in + sync mode, a synchronous execution command (e.g, "next") does not + return until the command is finished. If in async mode, then + running a synchronous command returns right after resuming the + target. Waiting for the command's completion is later done on + the top event loop. For the main UI, this starts out disabled, + until all the explicit command line arguments (e.g., `gdb -ex + "start" -ex "next"') are processed. */ + int async; + /* The fields below that start with "m_" are "private". They're meant to be accessed through wrapper macros that make them look like globals. */