static int do_timings = 0;
-/* The token of the last asynchronous command. */
-static char *last_async_command;
-static char *previous_async_command;
+static char *current_token;
extern void _initialize_mi_main (void);
static enum mi_cmd_result mi_cmd_execute (struct mi_parse *parse);
mi_cmd_gdb_exit (char *command, char **argv, int argc)
{
/* We have to print everything right here because we never return. */
- if (last_async_command)
- fputs_unfiltered (last_async_command, raw_stdout);
+ if (current_token)
+ fputs_unfiltered (current_token, raw_stdout);
fputs_unfiltered ("^exit\n", raw_stdout);
mi_out_put (uiout, raw_stdout);
/* FIXME: The function called is not yet a formal libgdb function. */
error ("mi_cmd_exec_interrupt: Inferior not executing.");
interrupt_target_command (args, from_tty);
- if (last_async_command)
- fputs_unfiltered (last_async_command, raw_stdout);
+ if (current_token)
+ fputs_unfiltered (current_token, raw_stdout);
fputs_unfiltered ("^done", raw_stdout);
- xfree (last_async_command);
- if (previous_async_command)
- last_async_command = xstrdup (previous_async_command);
- xfree (previous_async_command);
- previous_async_command = NULL;
mi_out_put (uiout, raw_stdout);
mi_out_rewind (uiout);
fputs_unfiltered ("\n", raw_stdout);
do_cleanups (old_cleanups);
/* Issue the completion message here. */
- if (last_async_command)
- fputs_unfiltered (last_async_command, raw_stdout);
+ if (current_token)
+ fputs_unfiltered (current_token, raw_stdout);
fputs_unfiltered ("^connected", raw_stdout);
mi_out_put (uiout, raw_stdout);
mi_out_rewind (uiout);
if (parse->cmd->argv_func != NULL
|| parse->cmd->args_func != NULL)
{
- /* FIXME: We need to save the token because the command executed
- may be asynchronous and need to print the token again.
- In the future we can pass the token down to the func
- and get rid of the last_async_command. */
- /* The problem here is to keep the token around when we launch
- the target, and we want to interrupt it later on. The
- interrupt command will have its own token, but when the
- target stops, we must display the token corresponding to the
- last execution command given. So we have another string where
- we copy the token (previous_async_command), if this was
- indeed the token of an execution command, and when we stop we
- print that one. This is possible because the interrupt
- command, when over, will copy that token back into the
- default token string (last_async_command). */
-
if (target_executing)
{
- if (!previous_async_command)
- previous_async_command = xstrdup (last_async_command);
if (strcmp (parse->command, "exec-interrupt"))
{
struct ui_file *stb;
error_stream (stb);
}
}
- last_async_command = xstrdup (parse->token);
- cleanup = make_cleanup (free_current_contents, &last_async_command);
+ current_token = xstrdup (parse->token);
+ cleanup = make_cleanup (free_current_contents, ¤t_token);
/* FIXME: DELETE THIS! */
if (parse->cmd->args_func != NULL)
r = parse->cmd->args_func (parse->args, 0 /*from_tty */ );
else
r = parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
- if (target_can_async_p () && target_executing)
- /* last_async_command will be freed by continuation that
- all execution command set. */
- discard_cleanups (cleanup);
- else
- do_cleanups (cleanup);
+ do_cleanups (cleanup);
return r;
}
else if (parse->cmd->cli.cmd != 0)
/* NOTE: For synchronous targets asynchronous behavour is faked by
printing out the GDB prompt before we even try to execute the
command. */
- if (last_async_command)
- fputs_unfiltered (last_async_command, raw_stdout);
+ if (current_token)
+ fputs_unfiltered (current_token, raw_stdout);
fputs_unfiltered ("^running\n", raw_stdout);
fputs_unfiltered ("(gdb) \n", raw_stdout);
gdb_flush (raw_stdout);
calling execute_command is wrong. It should only be printed
once gdb has confirmed that it really has managed to send a
run command to the target. */
- if (last_async_command)
- fputs_unfiltered (last_async_command, raw_stdout);
+ if (current_token)
+ fputs_unfiltered (current_token, raw_stdout);
fputs_unfiltered ("^running\n", raw_stdout);
/* Ideally, we should be intalling continuation only when
do_cleanups (old_cleanups);
/* If the target was doing the operation synchronously we fake
the stopped message. */
- if (last_async_command)
- fputs_unfiltered (last_async_command, raw_stdout);
fputs_unfiltered ("*stopped", raw_stdout);
mi_out_put (uiout, raw_stdout);
mi_out_rewind (uiout);
mi_exec_async_cli_cmd_continuation (struct continuation_arg *arg, int error_p)
{
/* Assume 'error' means that target is stopped, too. */
- if (last_async_command)
- fputs_unfiltered (last_async_command, raw_stdout);
fputs_unfiltered ("*stopped", raw_stdout);
mi_out_put (uiout, raw_stdout);
fputs_unfiltered ("\n", raw_stdout);
fputs_unfiltered ("(gdb) \n", raw_stdout);
gdb_flush (raw_stdout);
- if (last_async_command)
- {
- free (last_async_command);
- last_async_command = NULL;
- }
}
void
xfree (previous_sect_name);
previous_sect_name = xstrdup (section_name);
- if (last_async_command)
- fputs_unfiltered (last_async_command, raw_stdout);
+ if (current_token)
+ fputs_unfiltered (current_token, raw_stdout);
fputs_unfiltered ("+download", raw_stdout);
cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
ui_out_field_string (uiout, "section", section_name);
struct cleanup *cleanup_tuple;
last_update.tv_sec = time_now.tv_sec;
last_update.tv_usec = time_now.tv_usec;
- if (last_async_command)
- fputs_unfiltered (last_async_command, raw_stdout);
+ if (current_token)
+ fputs_unfiltered (current_token, raw_stdout);
fputs_unfiltered ("+download", raw_stdout);
cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
ui_out_field_string (uiout, "section", section_name);
if { $reason == "exited-normally" } {
gdb_expect {
- -re "220\\*stopped,reason=\"exited-normally\"\r\n$mi_gdb_prompt$" {
+ -re "\\*stopped,reason=\"exited-normally\"\r\n$mi_gdb_prompt$" {
pass "$test"
}
-re ".*$mi_gdb_prompt$" {fail "continue to end (2)"}
set a $after_reason
- verbose -log "mi_expect_stop: expecting: .*220\\*stopped,${r}${a}${bn}thread-id=\"$decimal\",frame=\{addr=\"$hex\",func=\"$func\",args=$args,file=\".*$file\",fullname=\"${fullname_syntax}$file\",line=\"$line\"\}$after_stopped\r\n$mi_gdb_prompt$"
+ verbose -log "mi_expect_stop: expecting: .*\\*stopped,${r}${a}${bn}thread-id=\"$decimal\",frame=\{addr=\"$hex\",func=\"$func\",args=$args,file=\".*$file\",fullname=\"${fullname_syntax}$file\",line=\"$line\"\}$after_stopped\r\n$mi_gdb_prompt$"
gdb_expect {
- -re ".*220\\*stopped,${r}${a}${bn}thread-id=\"$decimal\",frame=\{addr=\"$hex\",func=\"$func\",args=$args,file=\".*$file\",fullname=\"${fullname_syntax}$file\",line=\"($line)\"\}$after_stopped\r\n$mi_gdb_prompt$" {
+ -re ".*\\*stopped,${r}${a}${bn}thread-id=\"$decimal\",frame=\{addr=\"$hex\",func=\"$func\",args=$args,file=\".*$file\",fullname=\"${fullname_syntax}$file\",line=\"($line)\"\}$after_stopped\r\n$mi_gdb_prompt$" {
pass "$test"
return $expect_out(2,string)
}
- -re ".*220\\*stopped,${r}${a}${bn}thread-id=\"$decimal\",frame=\{addr=\"$hex\",func=\".*\",args=\[\\\[\{\].*\[\\\]\}\],file=\".*\",fullname=\"${fullname_syntax}.*\",line=\"\[0-9\]*\"\}.*\r\n$mi_gdb_prompt$" {
+ -re ".*\\*stopped,${r}${a}${bn}thread-id=\"$decimal\",frame=\{addr=\"$hex\",func=\".*\",args=\[\\\[\{\].*\[\\\]\}\],file=\".*\",fullname=\"${fullname_syntax}.*\",line=\"\[0-9\]*\"\}.*\r\n$mi_gdb_prompt$" {
fail "$test (stopped at wrong place)"
return -1
}
projects / binutils-gdb.git / commitdiff