[RFC] Remove the token from *stopped async output.

[Vladimir Prus <vladimir at codesourcery dot com>]

Since nobody complained about my proposal to remove token from the *stopped
async output (http://sourceware.org/ml/gdb/2008-03/msg00239.html), the
below patch removes it.

The code patch will go in as soon as other dependencies are in.
Eli, what do you think about the doc patch?

- Volodya

	[gdb/doc]
	* doc/gdb.texinfo (GDB/MI Output Syntax): Clarify that async
	output does not necessary include any tokens.

	[gdb]
	* mi/mi-main.c (last_async_command): Rename to current_token.
	(previous_async_command): Remove.
	(mi_cmd_gdb_exit): Adjust.
	(mi_cmd_exec_interrupt): Don't dance with previous_async_command.
	(mi_cmd_target_select): Adjust.
	(mi_cmd_execute): Don't set previous_async_command.  Free token
	here even in async mode.
	(mi_execute_async_cli_command): Adjust.
	(mi_exec_async_cli_cmd_continuation): Adjust.  Do not free the
	token.
	(mi_load_progress): Adjust.

	[gdb/testsuite]
	* gdb.mi/mi-syn-frame.exp: Adjust for token disappearance.
	* gdb.mi/mi2-syn-frame.exp: Likewise.
	* lib/mi-support.exp: Likewise.
---
 gdb/doc/gdb.texinfo                    |   11 +++--
 gdb/mi/mi-main.c                       |   74 ++++++++------------------------
 gdb/testsuite/gdb.mi/mi-syn-frame.exp  |    4 +-
 gdb/testsuite/gdb.mi/mi2-syn-frame.exp |    4 +-
 gdb/testsuite/lib/mi-support.exp       |    8 ++--
 5 files changed, 33 insertions(+), 68 deletions(-)

diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
index 294557c..fbaafd7 100644
--- a/gdb/doc/gdb.texinfo
+++ b/gdb/doc/gdb.texinfo
@@ -17886,10 +17886,13 @@ Notes:
 All output sequences end in a single line containing a period.
 
 @item
-The @code{@var{token}} is from the corresponding request.  If an execution
-command is interrupted by the @samp{-exec-interrupt} command, the
-@var{token} associated with the @samp{*stopped} message is the one of the
-original execution command, not the one of the interrupt command.
+The @code{@var{token}} is from the corresponding request.  Note that
+for all async output, while the token is allowed by the grammar and
+may be output by future versions of @value{GDBN} for select async
+output messages, it is generally omitted.  Frontends should treat
+all async output as reporting general changes in the state of the
+target and there should be no need to associate async output to any
+prior command.
 
 @item
 @cindex status output in @sc{gdb/mi}
diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c
index cfc9b2b..177d0ec 100644
--- a/gdb/mi/mi-main.c
+++ b/gdb/mi/mi-main.c
@@ -93,9 +93,7 @@ static struct mi_timestamp *current_command_ts;
 
 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);
@@ -124,8 +122,8 @@ enum mi_cmd_result
 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.  */
@@ -222,14 +220,9 @@ mi_cmd_exec_interrupt (char *args, int from_tty)
     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);
@@ -679,8 +672,8 @@ mi_cmd_target_select (char *args, int from_tty)
   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);
@@ -1191,25 +1184,8 @@ mi_cmd_execute (struct mi_parse *parse)
   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;
@@ -1223,19 +1199,14 @@ mi_cmd_execute (struct mi_parse *parse)
 	      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, &current_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)
@@ -1309,8 +1280,8 @@ mi_execute_async_cli_command (char *mi, char *args, int from_tty)
       /* 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);
@@ -1321,8 +1292,8 @@ mi_execute_async_cli_command (char *mi, char *args, int from_tty)
          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
@@ -1348,8 +1319,6 @@ mi_execute_async_cli_command (char *mi, char *args, int from_tty)
       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);
@@ -1365,18 +1334,11 @@ void
 mi_exec_async_cli_cmd_continuation (struct continuation_arg *arg, int error)
 {
   /* 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
@@ -1428,8 +1390,8 @@ mi_load_progress (const char *section_name,
       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);
@@ -1447,8 +1409,8 @@ mi_load_progress (const char *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);
diff --git a/gdb/testsuite/gdb.mi/mi-syn-frame.exp b/gdb/testsuite/gdb.mi/mi-syn-frame.exp
index aa68cea..ed89965 100644
--- a/gdb/testsuite/gdb.mi/mi-syn-frame.exp
+++ b/gdb/testsuite/gdb.mi/mi-syn-frame.exp
@@ -62,7 +62,7 @@ mi_gdb_test "403-exec-continue" \
 
 # Presently, the *stopped notification for this case does not include
 # any information.  This can be considered a bug.
-mi_gdb_test "" "403\\*stopped" "finished exec continue"
+mi_gdb_test "" "\\*stopped" "finished exec continue"
 
 mi_gdb_test "404-stack-list-frames 0 0" \
   "404\\^done,stack=\\\[frame=\{level=\"0\",addr=\"$hex\",func=\"main\",file=\".*mi-syn-frame.c\",fullname=\"${fullname_syntax}${srcfile}\",line=\"$decimal\"\}.*\\\]" \
@@ -91,7 +91,7 @@ mi_gdb_test "407-stack-list-frames" \
 
 mi_gdb_test "408-exec-continue" "408\\^running"
 
-mi_gdb_test "" "408\\*stopped.*" "finished exec continue"
+mi_gdb_test "" ".*\\*stopped.*" "finished exec continue"
 
 mi_gdb_test "409-stack-list-frames 0 0" \
   "409\\^done,stack=\\\[frame=\{level=\"0\",addr=\"$hex\",func=\"main\",file=\".*mi-syn-frame.c\",fullname=\"${fullname_syntax}${srcfile}\",line=\"$decimal\"\}.*\\\]" \
diff --git a/gdb/testsuite/gdb.mi/mi2-syn-frame.exp b/gdb/testsuite/gdb.mi/mi2-syn-frame.exp
index db767a8..9c1daab 100644
--- a/gdb/testsuite/gdb.mi/mi2-syn-frame.exp
+++ b/gdb/testsuite/gdb.mi/mi2-syn-frame.exp
@@ -60,7 +60,7 @@ mi_gdb_test "402-stack-list-frames" "402\\^done,stack=\\\[frame=\{level=\"0\",ad
 
 send_gdb "403-exec-continue\n"
 gdb_expect {
-  -re "403\\^running\[\r\n\]+${my_mi_gdb_prompt}403\\\*stopped\[\r\n\]+${my_mi_gdb_prompt}$" {
+  -re "403\\^running\[\r\n\]+${my_mi_gdb_prompt}.*\\\*stopped\[\r\n\]+${my_mi_gdb_prompt}$" {
     pass "403-exec-continue"
   }
   timeout {
@@ -95,7 +95,7 @@ mi_gdb_test "407-stack-list-frames" \
 
 send_gdb "408-exec-continue\n"
 gdb_expect {
-  -re "408\\^running\[\r\n\]+${my_mi_gdb_prompt}408\\\*stopped\[\r\n\]+${my_mi_gdb_prompt}$" {
+  -re "408\\^running\[\r\n\]+${my_mi_gdb_prompt}.*\\\*stopped\[\r\n\]+${my_mi_gdb_prompt}$" {
     pass "408-exec-continue"
   }
   timeout {
diff --git a/gdb/testsuite/lib/mi-support.exp b/gdb/testsuite/lib/mi-support.exp
index 317ba49..5926f16 100644
--- a/gdb/testsuite/lib/mi-support.exp
+++ b/gdb/testsuite/lib/mi-support.exp
@@ -947,7 +947,7 @@ proc mi_expect_stop { reason func args file line extra test } {
     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)"}
@@ -970,13 +970,13 @@ proc mi_expect_stop { reason func args file line extra test } {
         set r "reason=\"$reason\","
     }
 
-    verbose -log "mi_expect_stop: expecting: .*220\\*stopped,${r}${bn}${after_reason}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}${bn}${after_reason}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}${bn}${after_reason}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}${bn}${after_reason}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}${bn}${after_reason}thread-id=\"$decimal\",frame=\{addr=\"$hex\",func=\".*\",args=\[\\\[\{\].*\[\\\]\}\],file=\".*\",fullname=\"${fullname_syntax}.*\",line=\"\[0-9\]*\"\}.*\r\n$mi_gdb_prompt$" {
+	-re ".*\\*stopped,${r}${bn}${after_reason}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
 	}
-- 
1.5.3.5