/* Manages interpreters for GDB, the GNU debugger.
|
/* Manages interpreters for GDB, the GNU debugger.
|
|
|
Copyright (C) 2000, 2002, 2003, 2007, 2008, 2009, 2010
|
Copyright (C) 2000, 2002, 2003, 2007, 2008, 2009, 2010
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
Written by Jim Ingham <jingham@apple.com> of Apple Computer, Inc.
|
Written by Jim Ingham <jingham@apple.com> of Apple Computer, Inc.
|
|
|
This file is part of GDB.
|
This file is part of GDB.
|
|
|
This program is free software; you can redistribute it and/or modify
|
This program is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
/* This is just a first cut at separating out the "interpreter"
|
/* This is just a first cut at separating out the "interpreter"
|
functions of gdb into self-contained modules. There are a couple
|
functions of gdb into self-contained modules. There are a couple
|
of open areas that need to be sorted out:
|
of open areas that need to be sorted out:
|
|
|
1) The interpreter explicitly contains a UI_OUT, and can insert itself
|
1) The interpreter explicitly contains a UI_OUT, and can insert itself
|
into the event loop, but it doesn't explicitly contain hooks for readline.
|
into the event loop, but it doesn't explicitly contain hooks for readline.
|
I did this because it seems to me many interpreters won't want to use
|
I did this because it seems to me many interpreters won't want to use
|
the readline command interface, and it is probably simpler to just let
|
the readline command interface, and it is probably simpler to just let
|
them take over the input in their resume proc. */
|
them take over the input in their resume proc. */
|
|
|
#include "defs.h"
|
#include "defs.h"
|
#include "gdbcmd.h"
|
#include "gdbcmd.h"
|
#include "ui-out.h"
|
#include "ui-out.h"
|
#include "event-loop.h"
|
#include "event-loop.h"
|
#include "event-top.h"
|
#include "event-top.h"
|
#include "interps.h"
|
#include "interps.h"
|
#include "completer.h"
|
#include "completer.h"
|
#include "gdb_string.h"
|
#include "gdb_string.h"
|
#include "gdb_assert.h"
|
#include "gdb_assert.h"
|
#include "top.h" /* For command_loop. */
|
#include "top.h" /* For command_loop. */
|
#include "exceptions.h"
|
#include "exceptions.h"
|
|
|
struct interp
|
struct interp
|
{
|
{
|
/* This is the name in "-i=" and set interpreter. */
|
/* This is the name in "-i=" and set interpreter. */
|
const char *name;
|
const char *name;
|
|
|
/* Interpreters are stored in a linked list, this is the next
|
/* Interpreters are stored in a linked list, this is the next
|
one... */
|
one... */
|
struct interp *next;
|
struct interp *next;
|
|
|
/* This is a cookie that an instance of the interpreter can use.
|
/* This is a cookie that an instance of the interpreter can use.
|
This is a bit confused right now as the exact initialization
|
This is a bit confused right now as the exact initialization
|
sequence for it, and how it relates to the interpreter's uiout
|
sequence for it, and how it relates to the interpreter's uiout
|
object is a bit confused. */
|
object is a bit confused. */
|
void *data;
|
void *data;
|
|
|
/* Has the init_proc been run? */
|
/* Has the init_proc been run? */
|
int inited;
|
int inited;
|
|
|
/* This is the ui_out used to collect results for this interpreter.
|
/* This is the ui_out used to collect results for this interpreter.
|
It can be a formatter for stdout, as is the case for the console
|
It can be a formatter for stdout, as is the case for the console
|
& mi outputs, or it might be a result formatter. */
|
& mi outputs, or it might be a result formatter. */
|
struct ui_out *interpreter_out;
|
struct ui_out *interpreter_out;
|
|
|
const struct interp_procs *procs;
|
const struct interp_procs *procs;
|
int quiet_p;
|
int quiet_p;
|
};
|
};
|
|
|
/* Functions local to this file. */
|
/* Functions local to this file. */
|
static void initialize_interps (void);
|
static void initialize_interps (void);
|
static char **interpreter_completer (struct cmd_list_element *cmd,
|
static char **interpreter_completer (struct cmd_list_element *cmd,
|
char *text, char *word);
|
char *text, char *word);
|
|
|
/* The magic initialization routine for this module. */
|
/* The magic initialization routine for this module. */
|
|
|
void _initialize_interpreter (void);
|
void _initialize_interpreter (void);
|
|
|
/* Variables local to this file: */
|
/* Variables local to this file: */
|
|
|
static struct interp *interp_list = NULL;
|
static struct interp *interp_list = NULL;
|
static struct interp *current_interpreter = NULL;
|
static struct interp *current_interpreter = NULL;
|
static struct interp *top_level_interpreter_ptr = NULL;
|
static struct interp *top_level_interpreter_ptr = NULL;
|
|
|
static int interpreter_initialized = 0;
|
static int interpreter_initialized = 0;
|
|
|
/* interp_new - This allocates space for a new interpreter,
|
/* interp_new - This allocates space for a new interpreter,
|
fills the fields from the inputs, and returns a pointer to the
|
fills the fields from the inputs, and returns a pointer to the
|
interpreter. */
|
interpreter. */
|
struct interp *
|
struct interp *
|
interp_new (const char *name, void *data, struct ui_out *uiout,
|
interp_new (const char *name, void *data, struct ui_out *uiout,
|
const struct interp_procs *procs)
|
const struct interp_procs *procs)
|
{
|
{
|
struct interp *new_interp;
|
struct interp *new_interp;
|
|
|
new_interp = XMALLOC (struct interp);
|
new_interp = XMALLOC (struct interp);
|
|
|
new_interp->name = xstrdup (name);
|
new_interp->name = xstrdup (name);
|
new_interp->data = data;
|
new_interp->data = data;
|
new_interp->interpreter_out = uiout;
|
new_interp->interpreter_out = uiout;
|
new_interp->quiet_p = 0;
|
new_interp->quiet_p = 0;
|
new_interp->procs = procs;
|
new_interp->procs = procs;
|
new_interp->inited = 0;
|
new_interp->inited = 0;
|
|
|
return new_interp;
|
return new_interp;
|
}
|
}
|
|
|
/* Add interpreter INTERP to the gdb interpreter list. The
|
/* Add interpreter INTERP to the gdb interpreter list. The
|
interpreter must not have previously been added. */
|
interpreter must not have previously been added. */
|
void
|
void
|
interp_add (struct interp *interp)
|
interp_add (struct interp *interp)
|
{
|
{
|
if (!interpreter_initialized)
|
if (!interpreter_initialized)
|
initialize_interps ();
|
initialize_interps ();
|
|
|
gdb_assert (interp_lookup (interp->name) == NULL);
|
gdb_assert (interp_lookup (interp->name) == NULL);
|
|
|
interp->next = interp_list;
|
interp->next = interp_list;
|
interp_list = interp;
|
interp_list = interp;
|
}
|
}
|
|
|
/* This sets the current interpreter to be INTERP. If INTERP has not
|
/* This sets the current interpreter to be INTERP. If INTERP has not
|
been initialized, then this will also run the init proc. If the
|
been initialized, then this will also run the init proc. If the
|
init proc is successful, return 1, if it fails, set the old
|
init proc is successful, return 1, if it fails, set the old
|
interpreter back in place and return 0. If we can't restore the
|
interpreter back in place and return 0. If we can't restore the
|
old interpreter, then raise an internal error, since we are in
|
old interpreter, then raise an internal error, since we are in
|
pretty bad shape at this point.
|
pretty bad shape at this point.
|
|
|
The TOP_LEVEL parameter tells if this new interpreter is
|
The TOP_LEVEL parameter tells if this new interpreter is
|
the top-level one. The top-level is what is requested
|
the top-level one. The top-level is what is requested
|
on the command line, and is responsible for reporting general
|
on the command line, and is responsible for reporting general
|
notification about target state changes. For example, if
|
notification about target state changes. For example, if
|
MI is the top-level interpreter, then it will always report
|
MI is the top-level interpreter, then it will always report
|
events such as target stops and new thread creation, even if they
|
events such as target stops and new thread creation, even if they
|
are caused by CLI commands. */
|
are caused by CLI commands. */
|
int
|
int
|
interp_set (struct interp *interp, int top_level)
|
interp_set (struct interp *interp, int top_level)
|
{
|
{
|
struct interp *old_interp = current_interpreter;
|
struct interp *old_interp = current_interpreter;
|
int first_time = 0;
|
int first_time = 0;
|
char buffer[64];
|
char buffer[64];
|
|
|
/* If we already have an interpreter, then trying to
|
/* If we already have an interpreter, then trying to
|
set top level interpreter is kinda pointless. */
|
set top level interpreter is kinda pointless. */
|
gdb_assert (!top_level || !current_interpreter);
|
gdb_assert (!top_level || !current_interpreter);
|
gdb_assert (!top_level || !top_level_interpreter_ptr);
|
gdb_assert (!top_level || !top_level_interpreter_ptr);
|
|
|
if (current_interpreter != NULL)
|
if (current_interpreter != NULL)
|
{
|
{
|
do_all_continuations ();
|
do_all_continuations ();
|
ui_out_flush (uiout);
|
ui_out_flush (uiout);
|
if (current_interpreter->procs->suspend_proc
|
if (current_interpreter->procs->suspend_proc
|
&& !current_interpreter->procs->suspend_proc (current_interpreter->
|
&& !current_interpreter->procs->suspend_proc (current_interpreter->
|
data))
|
data))
|
{
|
{
|
error (_("Could not suspend interpreter \"%s\"."),
|
error (_("Could not suspend interpreter \"%s\"."),
|
current_interpreter->name);
|
current_interpreter->name);
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
first_time = 1;
|
first_time = 1;
|
}
|
}
|
|
|
current_interpreter = interp;
|
current_interpreter = interp;
|
if (top_level)
|
if (top_level)
|
top_level_interpreter_ptr = interp;
|
top_level_interpreter_ptr = interp;
|
|
|
/* We use interpreter_p for the "set interpreter" variable, so we need
|
/* 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. */
|
to make sure we have a malloc'ed copy for the set command to free. */
|
if (interpreter_p != NULL
|
if (interpreter_p != NULL
|
&& strcmp (current_interpreter->name, interpreter_p) != 0)
|
&& strcmp (current_interpreter->name, interpreter_p) != 0)
|
{
|
{
|
xfree (interpreter_p);
|
xfree (interpreter_p);
|
|
|
interpreter_p = xstrdup (current_interpreter->name);
|
interpreter_p = xstrdup (current_interpreter->name);
|
}
|
}
|
|
|
uiout = interp->interpreter_out;
|
uiout = interp->interpreter_out;
|
|
|
/* Run the init proc. If it fails, try to restore the old interp. */
|
/* Run the init proc. If it fails, try to restore the old interp. */
|
|
|
if (!interp->inited)
|
if (!interp->inited)
|
{
|
{
|
if (interp->procs->init_proc != NULL)
|
if (interp->procs->init_proc != NULL)
|
{
|
{
|
interp->data = interp->procs->init_proc (top_level);
|
interp->data = interp->procs->init_proc (top_level);
|
}
|
}
|
interp->inited = 1;
|
interp->inited = 1;
|
}
|
}
|
|
|
/* Clear out any installed interpreter hooks/event handlers. */
|
/* Clear out any installed interpreter hooks/event handlers. */
|
clear_interpreter_hooks ();
|
clear_interpreter_hooks ();
|
|
|
if (interp->procs->resume_proc != NULL
|
if (interp->procs->resume_proc != NULL
|
&& (!interp->procs->resume_proc (interp->data)))
|
&& (!interp->procs->resume_proc (interp->data)))
|
{
|
{
|
if (old_interp == NULL || !interp_set (old_interp, 0))
|
if (old_interp == NULL || !interp_set (old_interp, 0))
|
internal_error (__FILE__, __LINE__,
|
internal_error (__FILE__, __LINE__,
|
_("Failed to initialize new interp \"%s\" %s"),
|
_("Failed to initialize new interp \"%s\" %s"),
|
interp->name, "and could not restore old interp!\n");
|
interp->name, "and could not restore old interp!\n");
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Finally, put up the new prompt to show that we are indeed here.
|
/* Finally, put up the new prompt to show that we are indeed here.
|
Also, display_gdb_prompt for the console does some readline magic
|
Also, display_gdb_prompt for the console does some readline magic
|
which is needed for the console interpreter, at least... */
|
which is needed for the console interpreter, at least... */
|
|
|
if (!first_time)
|
if (!first_time)
|
{
|
{
|
if (!interp_quiet_p (interp))
|
if (!interp_quiet_p (interp))
|
{
|
{
|
sprintf (buffer, "Switching to interpreter \"%.24s\".\n",
|
sprintf (buffer, "Switching to interpreter \"%.24s\".\n",
|
interp->name);
|
interp->name);
|
ui_out_text (uiout, buffer);
|
ui_out_text (uiout, buffer);
|
}
|
}
|
display_gdb_prompt (NULL);
|
display_gdb_prompt (NULL);
|
}
|
}
|
|
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* interp_lookup - Looks up the interpreter for NAME. If no such
|
/* interp_lookup - Looks up the interpreter for NAME. If no such
|
interpreter exists, return NULL, otherwise return a pointer to the
|
interpreter exists, return NULL, otherwise return a pointer to the
|
interpreter. */
|
interpreter. */
|
struct interp *
|
struct interp *
|
interp_lookup (const char *name)
|
interp_lookup (const char *name)
|
{
|
{
|
struct interp *interp;
|
struct interp *interp;
|
|
|
if (name == NULL || strlen (name) == 0)
|
if (name == NULL || strlen (name) == 0)
|
return NULL;
|
return NULL;
|
|
|
for (interp = interp_list; interp != NULL; interp = interp->next)
|
for (interp = interp_list; interp != NULL; interp = interp->next)
|
{
|
{
|
if (strcmp (interp->name, name) == 0)
|
if (strcmp (interp->name, name) == 0)
|
return interp;
|
return interp;
|
}
|
}
|
|
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Returns the current interpreter. */
|
/* Returns the current interpreter. */
|
|
|
struct ui_out *
|
struct ui_out *
|
interp_ui_out (struct interp *interp)
|
interp_ui_out (struct interp *interp)
|
{
|
{
|
if (interp != NULL)
|
if (interp != NULL)
|
return interp->interpreter_out;
|
return interp->interpreter_out;
|
|
|
return current_interpreter->interpreter_out;
|
return current_interpreter->interpreter_out;
|
}
|
}
|
|
|
/* Returns true if the current interp is the passed in name. */
|
/* Returns true if the current interp is the passed in name. */
|
int
|
int
|
current_interp_named_p (const char *interp_name)
|
current_interp_named_p (const char *interp_name)
|
{
|
{
|
if (current_interpreter)
|
if (current_interpreter)
|
return (strcmp (current_interpreter->name, interp_name) == 0);
|
return (strcmp (current_interpreter->name, interp_name) == 0);
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* This is called in display_gdb_prompt. If the proc returns a zero
|
/* This is called in display_gdb_prompt. If the proc returns a zero
|
value, display_gdb_prompt will return without displaying the
|
value, display_gdb_prompt will return without displaying the
|
prompt. */
|
prompt. */
|
int
|
int
|
current_interp_display_prompt_p (void)
|
current_interp_display_prompt_p (void)
|
{
|
{
|
if (current_interpreter == NULL
|
if (current_interpreter == NULL
|
|| current_interpreter->procs->prompt_proc_p == NULL)
|
|| current_interpreter->procs->prompt_proc_p == NULL)
|
return 0;
|
return 0;
|
else
|
else
|
return current_interpreter->procs->prompt_proc_p (current_interpreter->
|
return current_interpreter->procs->prompt_proc_p (current_interpreter->
|
data);
|
data);
|
}
|
}
|
|
|
/* Run the current command interpreter's main loop. */
|
/* Run the current command interpreter's main loop. */
|
void
|
void
|
current_interp_command_loop (void)
|
current_interp_command_loop (void)
|
{
|
{
|
/* Somewhat messy. For the moment prop up all the old ways of
|
/* Somewhat messy. For the moment prop up all the old ways of
|
selecting the command loop. `deprecated_command_loop_hook'
|
selecting the command loop. `deprecated_command_loop_hook'
|
should be deprecated. */
|
should be deprecated. */
|
if (deprecated_command_loop_hook != NULL)
|
if (deprecated_command_loop_hook != NULL)
|
deprecated_command_loop_hook ();
|
deprecated_command_loop_hook ();
|
else if (current_interpreter != NULL
|
else if (current_interpreter != NULL
|
&& current_interpreter->procs->command_loop_proc != NULL)
|
&& current_interpreter->procs->command_loop_proc != NULL)
|
current_interpreter->procs->command_loop_proc (current_interpreter->data);
|
current_interpreter->procs->command_loop_proc (current_interpreter->data);
|
else
|
else
|
cli_command_loop ();
|
cli_command_loop ();
|
}
|
}
|
|
|
int
|
int
|
interp_quiet_p (struct interp *interp)
|
interp_quiet_p (struct interp *interp)
|
{
|
{
|
if (interp != NULL)
|
if (interp != NULL)
|
return interp->quiet_p;
|
return interp->quiet_p;
|
else
|
else
|
return current_interpreter->quiet_p;
|
return current_interpreter->quiet_p;
|
}
|
}
|
|
|
static int
|
static int
|
interp_set_quiet (struct interp *interp, int quiet)
|
interp_set_quiet (struct interp *interp, int quiet)
|
{
|
{
|
int old_val = interp->quiet_p;
|
int old_val = interp->quiet_p;
|
interp->quiet_p = quiet;
|
interp->quiet_p = quiet;
|
return old_val;
|
return old_val;
|
}
|
}
|
|
|
/* interp_exec - This executes COMMAND_STR in the current
|
/* interp_exec - This executes COMMAND_STR in the current
|
interpreter. */
|
interpreter. */
|
int
|
int
|
interp_exec_p (struct interp *interp)
|
interp_exec_p (struct interp *interp)
|
{
|
{
|
return interp->procs->exec_proc != NULL;
|
return interp->procs->exec_proc != NULL;
|
}
|
}
|
|
|
struct gdb_exception
|
struct gdb_exception
|
interp_exec (struct interp *interp, const char *command_str)
|
interp_exec (struct interp *interp, const char *command_str)
|
{
|
{
|
if (interp->procs->exec_proc != NULL)
|
if (interp->procs->exec_proc != NULL)
|
{
|
{
|
return interp->procs->exec_proc (interp->data, command_str);
|
return interp->procs->exec_proc (interp->data, command_str);
|
}
|
}
|
return exception_none;
|
return exception_none;
|
}
|
}
|
|
|
/* A convenience routine that nulls out all the common command hooks.
|
/* A convenience routine that nulls out all the common command hooks.
|
Use it when removing your interpreter in its suspend proc. */
|
Use it when removing your interpreter in its suspend proc. */
|
void
|
void
|
clear_interpreter_hooks (void)
|
clear_interpreter_hooks (void)
|
{
|
{
|
deprecated_init_ui_hook = 0;
|
deprecated_init_ui_hook = 0;
|
deprecated_print_frame_info_listing_hook = 0;
|
deprecated_print_frame_info_listing_hook = 0;
|
/*print_frame_more_info_hook = 0; */
|
/*print_frame_more_info_hook = 0; */
|
deprecated_query_hook = 0;
|
deprecated_query_hook = 0;
|
deprecated_warning_hook = 0;
|
deprecated_warning_hook = 0;
|
deprecated_interactive_hook = 0;
|
deprecated_interactive_hook = 0;
|
deprecated_readline_begin_hook = 0;
|
deprecated_readline_begin_hook = 0;
|
deprecated_readline_hook = 0;
|
deprecated_readline_hook = 0;
|
deprecated_readline_end_hook = 0;
|
deprecated_readline_end_hook = 0;
|
deprecated_register_changed_hook = 0;
|
deprecated_register_changed_hook = 0;
|
deprecated_context_hook = 0;
|
deprecated_context_hook = 0;
|
deprecated_target_wait_hook = 0;
|
deprecated_target_wait_hook = 0;
|
deprecated_call_command_hook = 0;
|
deprecated_call_command_hook = 0;
|
deprecated_error_begin_hook = 0;
|
deprecated_error_begin_hook = 0;
|
deprecated_command_loop_hook = 0;
|
deprecated_command_loop_hook = 0;
|
}
|
}
|
|
|
/* This is a lazy init routine, called the first time the interpreter
|
/* This is a lazy init routine, called the first time the interpreter
|
module is used. I put it here just in case, but I haven't thought
|
module is used. I put it here just in case, but I haven't thought
|
of a use for it yet. I will probably bag it soon, since I don't
|
of a use for it yet. I will probably bag it soon, since I don't
|
think it will be necessary. */
|
think it will be necessary. */
|
static void
|
static void
|
initialize_interps (void)
|
initialize_interps (void)
|
{
|
{
|
interpreter_initialized = 1;
|
interpreter_initialized = 1;
|
/* Don't know if anything needs to be done here... */
|
/* Don't know if anything needs to be done here... */
|
}
|
}
|
|
|
static void
|
static void
|
interpreter_exec_cmd (char *args, int from_tty)
|
interpreter_exec_cmd (char *args, int from_tty)
|
{
|
{
|
struct interp *old_interp, *interp_to_use;
|
struct interp *old_interp, *interp_to_use;
|
char **prules = NULL;
|
char **prules = NULL;
|
char **trule = NULL;
|
char **trule = NULL;
|
unsigned int nrules;
|
unsigned int nrules;
|
unsigned int i;
|
unsigned int i;
|
int old_quiet, use_quiet;
|
int old_quiet, use_quiet;
|
|
|
if (args == NULL)
|
if (args == NULL)
|
error_no_arg (_("interpreter-exec command"));
|
error_no_arg (_("interpreter-exec command"));
|
|
|
prules = gdb_buildargv (args);
|
prules = gdb_buildargv (args);
|
make_cleanup_freeargv (prules);
|
make_cleanup_freeargv (prules);
|
|
|
nrules = 0;
|
nrules = 0;
|
for (trule = prules; *trule != NULL; trule++)
|
for (trule = prules; *trule != NULL; trule++)
|
nrules++;
|
nrules++;
|
|
|
if (nrules < 2)
|
if (nrules < 2)
|
error (_("usage: interpreter-exec <interpreter> [ <command> ... ]"));
|
error (_("usage: interpreter-exec <interpreter> [ <command> ... ]"));
|
|
|
old_interp = current_interpreter;
|
old_interp = current_interpreter;
|
|
|
interp_to_use = interp_lookup (prules[0]);
|
interp_to_use = interp_lookup (prules[0]);
|
if (interp_to_use == NULL)
|
if (interp_to_use == NULL)
|
error (_("Could not find interpreter \"%s\"."), prules[0]);
|
error (_("Could not find interpreter \"%s\"."), prules[0]);
|
|
|
/* Temporarily set interpreters quiet */
|
/* Temporarily set interpreters quiet */
|
old_quiet = interp_set_quiet (old_interp, 1);
|
old_quiet = interp_set_quiet (old_interp, 1);
|
use_quiet = interp_set_quiet (interp_to_use, 1);
|
use_quiet = interp_set_quiet (interp_to_use, 1);
|
|
|
if (!interp_set (interp_to_use, 0))
|
if (!interp_set (interp_to_use, 0))
|
error (_("Could not switch to interpreter \"%s\"."), prules[0]);
|
error (_("Could not switch to interpreter \"%s\"."), prules[0]);
|
|
|
for (i = 1; i < nrules; i++)
|
for (i = 1; i < nrules; i++)
|
{
|
{
|
struct gdb_exception e = interp_exec (interp_to_use, prules[i]);
|
struct gdb_exception e = interp_exec (interp_to_use, prules[i]);
|
if (e.reason < 0)
|
if (e.reason < 0)
|
{
|
{
|
interp_set (old_interp, 0);
|
interp_set (old_interp, 0);
|
interp_set_quiet (interp_to_use, use_quiet);
|
interp_set_quiet (interp_to_use, use_quiet);
|
interp_set_quiet (old_interp, old_quiet);
|
interp_set_quiet (old_interp, old_quiet);
|
error (_("error in command: \"%s\"."), prules[i]);
|
error (_("error in command: \"%s\"."), prules[i]);
|
}
|
}
|
}
|
}
|
|
|
interp_set (old_interp, 0);
|
interp_set (old_interp, 0);
|
interp_set_quiet (interp_to_use, use_quiet);
|
interp_set_quiet (interp_to_use, use_quiet);
|
interp_set_quiet (old_interp, old_quiet);
|
interp_set_quiet (old_interp, old_quiet);
|
}
|
}
|
|
|
/* List the possible interpreters which could complete the given text. */
|
/* List the possible interpreters which could complete the given text. */
|
static char **
|
static char **
|
interpreter_completer (struct cmd_list_element *ignore, char *text, char *word)
|
interpreter_completer (struct cmd_list_element *ignore, char *text, char *word)
|
{
|
{
|
int alloced = 0;
|
int alloced = 0;
|
int textlen;
|
int textlen;
|
int num_matches;
|
int num_matches;
|
char **matches;
|
char **matches;
|
struct interp *interp;
|
struct interp *interp;
|
|
|
/* We expect only a very limited number of interpreters, so just
|
/* We expect only a very limited number of interpreters, so just
|
allocate room for all of them plus one for the last that must be NULL
|
allocate room for all of them plus one for the last that must be NULL
|
to correctly end the list. */
|
to correctly end the list. */
|
for (interp = interp_list; interp != NULL; interp = interp->next)
|
for (interp = interp_list; interp != NULL; interp = interp->next)
|
++alloced;
|
++alloced;
|
matches = (char **) xcalloc (alloced + 1, sizeof (char *));
|
matches = (char **) xcalloc (alloced + 1, sizeof (char *));
|
|
|
num_matches = 0;
|
num_matches = 0;
|
textlen = strlen (text);
|
textlen = strlen (text);
|
for (interp = interp_list; interp != NULL; interp = interp->next)
|
for (interp = interp_list; interp != NULL; interp = interp->next)
|
{
|
{
|
if (strncmp (interp->name, text, textlen) == 0)
|
if (strncmp (interp->name, text, textlen) == 0)
|
{
|
{
|
matches[num_matches] =
|
matches[num_matches] =
|
(char *) xmalloc (strlen (word) + strlen (interp->name) + 1);
|
(char *) xmalloc (strlen (word) + strlen (interp->name) + 1);
|
if (word == text)
|
if (word == text)
|
strcpy (matches[num_matches], interp->name);
|
strcpy (matches[num_matches], interp->name);
|
else if (word > text)
|
else if (word > text)
|
{
|
{
|
/* Return some portion of interp->name */
|
/* Return some portion of interp->name */
|
strcpy (matches[num_matches], interp->name + (word - text));
|
strcpy (matches[num_matches], interp->name + (word - text));
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Return some of text plus interp->name */
|
/* Return some of text plus interp->name */
|
strncpy (matches[num_matches], word, text - word);
|
strncpy (matches[num_matches], word, text - word);
|
matches[num_matches][text - word] = '\0';
|
matches[num_matches][text - word] = '\0';
|
strcat (matches[num_matches], interp->name);
|
strcat (matches[num_matches], interp->name);
|
}
|
}
|
++num_matches;
|
++num_matches;
|
}
|
}
|
}
|
}
|
|
|
if (num_matches == 0)
|
if (num_matches == 0)
|
{
|
{
|
xfree (matches);
|
xfree (matches);
|
matches = NULL;
|
matches = NULL;
|
}
|
}
|
|
|
return matches;
|
return matches;
|
}
|
}
|
|
|
struct interp *
|
struct interp *
|
top_level_interpreter (void)
|
top_level_interpreter (void)
|
{
|
{
|
return top_level_interpreter_ptr;
|
return top_level_interpreter_ptr;
|
}
|
}
|
|
|
void *
|
void *
|
top_level_interpreter_data (void)
|
top_level_interpreter_data (void)
|
{
|
{
|
gdb_assert (top_level_interpreter_ptr);
|
gdb_assert (top_level_interpreter_ptr);
|
return top_level_interpreter_ptr->data;
|
return top_level_interpreter_ptr->data;
|
}
|
}
|
|
|
/* This just adds the "interpreter-exec" command. */
|
/* This just adds the "interpreter-exec" command. */
|
void
|
void
|
_initialize_interpreter (void)
|
_initialize_interpreter (void)
|
{
|
{
|
struct cmd_list_element *c;
|
struct cmd_list_element *c;
|
|
|
c = add_cmd ("interpreter-exec", class_support,
|
c = add_cmd ("interpreter-exec", class_support,
|
interpreter_exec_cmd, _("\
|
interpreter_exec_cmd, _("\
|
Execute a command in an interpreter. It takes two arguments:\n\
|
Execute a command in an interpreter. It takes two arguments:\n\
|
The first argument is the name of the interpreter to use.\n\
|
The first argument is the name of the interpreter to use.\n\
|
The second argument is the command to execute.\n"), &cmdlist);
|
The second argument is the command to execute.\n"), &cmdlist);
|
set_cmd_completer (c, interpreter_completer);
|
set_cmd_completer (c, interpreter_completer);
|
}
|
}
|
|
|
