#include "defs.h"
#include "gdbcmd.h"
#include "ui-out.h"
#include "event-loop.h"
#include "event-top.h"
#include "interps.h"
#include "completer.h"
#include "gdb_string.h"
#include "gdb-events.h"
#include "gdb_assert.h"
#include "top.h"
#include "exceptions.h"
struct interp
{
const char *name;
struct interp *next;
void *data;
int inited;
struct ui_out *interpreter_out;
const struct interp_procs *procs;
int quiet_p;
};
static void initialize_interps (void);
static void set_interpreter_cmd (char *args, int from_tty,
struct cmd_list_element *c);
static void list_interpreter_cmd (char *args, int from_tty);
static char **interpreter_completer (char *text, char *word);
void _initialize_interpreter (void);
static struct interp *interp_list = NULL;
static struct interp *current_interpreter = NULL;
static int interpreter_initialized = 0;
struct interp *
interp_new (const char *name, void *data, struct ui_out *uiout,
const struct interp_procs *procs)
{
struct interp *new_interp;
new_interp = XMALLOC (struct interp);
new_interp->name = xstrdup (name);
new_interp->data = data;
new_interp->interpreter_out = uiout;
new_interp->quiet_p = 0;
new_interp->procs = procs;
new_interp->inited = 0;
return new_interp;
}
void
interp_add (struct interp *interp)
{
if (!interpreter_initialized)
initialize_interps ();
gdb_assert (interp_lookup (interp->name) == NULL);
interp->next = interp_list;
interp_list = interp;
}
struct interp *
interp_set (struct interp *interp)
{
struct interp *old_interp = current_interpreter;
int first_time = 0;
char buffer[64];
if (current_interpreter != NULL)
{
#if 0
do_all_continuations ();
#endif
ui_out_flush (uiout);
if (current_interpreter->procs->suspend_proc
&& !current_interpreter->procs->suspend_proc (current_interpreter->
data))
{
error (_("Could not suspend interpreter \"%s\"."),
current_interpreter->name);
}
}
else
{
first_time = 1;
}
current_interpreter = interp;
if (interpreter_p != NULL
&& strcmp (current_interpreter->name, interpreter_p) != 0)
{
xfree (interpreter_p);
interpreter_p = xstrdup (current_interpreter->name);
}
uiout = interp->interpreter_out;
if (!interp->inited)
{
if (interp->procs->init_proc != NULL)
{
interp->data = interp->procs->init_proc ();
}
interp->inited = 1;
}
#if 0
clear_interpreter_hooks ();
#endif
if (interp->procs->resume_proc != NULL
&& (!interp->procs->resume_proc (interp->data)))
{
if (old_interp == NULL || !interp_set (old_interp))
internal_error (__FILE__, __LINE__,
_("Failed to initialize new interp \"%s\" %s"),
interp->name, "and could not restore old interp!\n");
return NULL;
}
if (!first_time)
{
if (!interp_quiet_p (interp))
{
sprintf (buffer, "Switching to interpreter \"%.24s\".\n",
interp->name);
ui_out_text (uiout, buffer);
}
display_gdb_prompt (NULL);
}
if (old_interp == NULL)
return current_interpreter;
else
return old_interp;
}
struct interp *
interp_lookup (const char *name)
{
struct interp *interp;
if (name == NULL || strlen (name) == 0)
return NULL;
for (interp = interp_list; interp != NULL; interp = interp->next)
{
if (strcmp (interp->name, name) == 0)
return interp;
}
return NULL;
}
struct interp *
current_interp (void)
{
return current_interpreter;
}
struct ui_out *
interp_ui_out (struct interp *interp)
{
if (interp != NULL)
return interp->interpreter_out;
return current_interpreter->interpreter_out;
}
int
current_interp_named_p (const char *interp_name)
{
if (current_interpreter)
return (strcmp (current_interpreter->name, interp_name) == 0);
return 0;
}
int
current_interp_display_prompt_p (void)
{
if (current_interpreter == NULL
|| current_interpreter->procs->prompt_proc_p == NULL)
return 0;
else
return current_interpreter->procs->prompt_proc_p (current_interpreter->
data);
}
void
current_interp_command_loop (void)
{
if (deprecated_command_loop_hook != NULL)
deprecated_command_loop_hook ();
else if (current_interpreter != NULL
&& current_interpreter->procs->command_loop_proc != NULL)
current_interpreter->procs->command_loop_proc (current_interpreter->data);
else
cli_command_loop (NULL);
}
int
interp_quiet_p (struct interp *interp)
{
if (interp != NULL)
return interp->quiet_p;
else
return current_interpreter->quiet_p;
}
int
interp_set_quiet (struct interp *interp, int quiet)
{
int old_val = interp->quiet_p;
interp->quiet_p = quiet;
return old_val;
}
int
interp_exec_p (struct interp *interp)
{
return interp->procs->exec_proc != NULL;
}
struct gdb_exception
interp_exec (struct interp *interp, const char *command_str)
{
if (interp->procs->exec_proc != NULL)
{
return interp->procs->exec_proc (interp->data, command_str);
}
return exception_none;
}
int
interp_complete (struct interp *interp,
char *word, char *command_buffer, int cursor)
{
if (interp->procs->complete_proc != NULL)
{
return interp->procs->complete_proc (interp->data, word, command_buffer, cursor);
}
return 0;
}
void
clear_interpreter_hooks (void)
{
deprecated_init_ui_hook = 0;
deprecated_print_frame_info_listing_hook = 0;
deprecated_query_hook = 0;
deprecated_warning_hook = 0;
deprecated_create_breakpoint_hook = 0;
deprecated_delete_breakpoint_hook = 0;
deprecated_modify_breakpoint_hook = 0;
deprecated_interactive_hook = 0;
deprecated_registers_changed_hook = 0;
deprecated_readline_begin_hook = 0;
deprecated_readline_hook = 0;
deprecated_readline_end_hook = 0;
deprecated_register_changed_hook = 0;
deprecated_memory_changed_hook = 0;
deprecated_context_hook = 0;
deprecated_target_wait_hook = 0;
deprecated_call_command_hook = 0;
deprecated_error_hook = 0;
deprecated_error_begin_hook = 0;
deprecated_command_loop_hook = 0;
clear_gdb_event_hooks ();
}
static void
initialize_interps (void)
{
interpreter_initialized = 1;
}
static void
interpreter_exec_cmd (char *args, int from_tty)
{
struct interp *old_interp, *interp_to_use;
char **prules = NULL;
char **trule = NULL;
unsigned int nrules;
unsigned int i;
int old_quiet, use_quiet;
prules = buildargv (args);
if (prules == NULL)
{
error (_("unable to parse arguments"));
}
nrules = 0;
if (prules != NULL)
{
for (trule = prules; *trule != NULL; trule++)
{
nrules++;
}
}
if (nrules < 2)
error (_("usage: interpreter-exec <interpreter> [ <command> ... ]"));
interp_to_use = interp_lookup (prules[0]);
if (interp_to_use == NULL)
error (_("Could not find interpreter \"%s\"."), prules[0]);
use_quiet = interp_set_quiet (interp_to_use, 1);
old_interp = interp_set (interp_to_use);
if (old_interp == NULL)
error (_("Could not switch to interpreter \"%s\"."), prules[0]);
old_quiet = interp_set_quiet (old_interp, 1);
for (i = 1; i < nrules; i++)
{
struct gdb_exception e = interp_exec (interp_to_use, prules[i]);
if (e.reason < 0)
{
interp_set (old_interp);
interp_set_quiet (interp_to_use, old_quiet);
error (_("error in command: \"%s\"."), prules[i]);
break;
}
}
interp_set (old_interp);
interp_set_quiet (interp_to_use, use_quiet);
interp_set_quiet (old_interp, old_quiet);
}
static char **
interpreter_completer (char *text, char *word)
{
int alloced = 0;
int textlen;
int num_matches;
char **matches;
struct interp *interp;
for (interp = interp_list; interp != NULL; interp = interp->next)
++alloced;
matches = (char **) xmalloc (alloced * sizeof (char *));
num_matches = 0;
textlen = strlen (text);
for (interp = interp_list; interp != NULL; interp = interp->next)
{
if (strncmp (interp->name, text, textlen) == 0)
{
matches[num_matches] =
(char *) xmalloc (strlen (word) + strlen (interp->name) + 1);
if (word == text)
strcpy (matches[num_matches], interp->name);
else if (word > text)
{
strcpy (matches[num_matches], interp->name + (word - text));
}
else
{
strncpy (matches[num_matches], word, text - word);
matches[num_matches][text - word] = '\0';
strcat (matches[num_matches], interp->name);
}
++num_matches;
}
}
if (num_matches == 0)
{
xfree (matches);
matches = NULL;
}
else if (num_matches < alloced)
{
matches = (char **) xrealloc ((char *) matches, ((num_matches + 1)
* sizeof (char *)));
matches[num_matches] = NULL;
}
return matches;
}
void
list_interpreter_cmd (char *args, int from_tty)
{
struct interp *interp_ptr;
struct cleanup *list_cleanup;
list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "interpreters");
for (interp_ptr = interp_list; interp_ptr != NULL;
interp_ptr = interp_ptr->next)
{
ui_out_text (uiout, " * ");
ui_out_field_string (uiout, "interpreter", interp_ptr->name);
ui_out_text (uiout, "\n");
}
do_cleanups (list_cleanup);
}
static void
set_interpreter_cmd (char *args, int from_tty, struct cmd_list_element * c)
{
struct interp *interp_ptr;
dont_repeat ();
if (cmd_type (c) != set_cmd)
return;
interp_ptr = interp_lookup (interpreter_p);
if (interp_ptr != NULL)
{
if (interp_ptr == current_interpreter)
return;
if (!interp_set (interp_ptr))
error ("\nCould not switch to interpreter \"%s\", %s%s\".\n",
interp_ptr->name, "reverting to interpreter \"",
current_interpreter->name);
}
else
{
char *bad_name = interpreter_p;
interpreter_p = xstrdup (current_interpreter->name);
error ("Could not find interpreter \"%s\".", bad_name);
}
}
void
_initialize_interpreter (void)
{
struct cmd_list_element *c;
add_setshow_string_cmd ("interpreter", class_support,
&interpreter_p, _("\
Set the interpreter for gdb."), _("\
Show the interpreter for gdb."), NULL,
set_interpreter_cmd, NULL,
&setlist, &showlist);
add_cmd ("interpreters", class_support,
list_interpreter_cmd,
"List the interpreters currently available in gdb.",
&infolist);
c = add_cmd ("interpreter-exec", class_support,
interpreter_exec_cmd, _("\
Execute a command in an interpreter. It takes two arguments:\n\
The first argument is the name of the interpreter to use.\n\
The second argument is the command to execute.\n"), &cmdlist);
set_cmd_completer (c, interpreter_completer);
}