Add "executing" property to threads.

[deliverable/binutils-gdb.git] / gdb / inf-loop.c

diff --git a/gdb/inf-loop.c b/gdb/inf-loop.c
index 4889c6f11764bb075cffd4cdc9ea01595d582869..3f98bfcaa15d2e89d155186616e6f820e66a7e04 100644 (file)
--- a/gdb/inf-loop.c
+++ b/gdb/inf-loop.c
@@ -26,6 +26,7 @@
 #include "remote.h"
 #include "exceptions.h"
 #include "language.h"
+#include "gdbthread.h"
 
 static int fetch_inferior_event_wrapper (gdb_client_data client_data);
 
@@ -72,14 +73,6 @@ inferior_event_handler (enum inferior_event_type event_type,
       break;
 
     case INF_EXEC_COMPLETE:
-
-      /* This is the first thing to do -- so that continuations know that
-        the target is stopped.  For example, command_line_handler_continuation
-        will run breakpoint commands, and if we think that the target is
-        running, we'll refuse to execute most commands.  MI continuation
-        presently uses target_executing to either print or not print *stopped.  */
-      target_executing = 0;
-
       /* Unregister the inferior from the event loop. This is done so that
         when the inferior is not running we don't get distracted by
         spurious inferior output.  */
@@ -92,32 +85,37 @@ inferior_event_handler (enum inferior_event_type event_type,
       was_sync = sync_execution;
       async_enable_stdin ();
 
-      /* If there's an error doing breakpoint commands, we don't
-        want to throw -- continuation might still do something.  */
-      TRY_CATCH (e, RETURN_MASK_ALL)
-       {
-         bpstat_do_actions (&stop_bpstat);
-       }
       /* If we were doing a multi-step (eg: step n, next n), but it
         got interrupted by a breakpoint, still do the pending
         continuations.  The continuation itself is responsible for
-        distinguishing the cases.  */
+        distinguishing the cases.  The continuations are allowed to
+        touch the inferior memory, e.g. to remove breakpoints, so run
+        them before running breakpoint commands, which may resume the
+        target.  */
       do_all_intermediate_continuations (0);
 
+      /* Always finish the previous command before running any
+        breakpoint commands.  Any stop cancels the previous command.
+        E.g. a "finish" or "step-n" command interrupted by an
+        unrelated breakpoint is canceled.  */
       do_all_continuations (0);
 
-      if (current_language != expected_language)
+      if (current_language != expected_language
+         && language_mode == language_mode_auto)
+       language_info (1);      /* Print what changed.  */
+
+      /* Don't propagate breakpoint commands errors.  Either we're
+        stopping or some command resumes the inferior.  The user will
+        be informed.  */
+      TRY_CATCH (e, RETURN_MASK_ALL)
        {
-         if (language_mode == language_mode_auto)
-           {
-             language_info (1);        /* Print what changed.  */
-           }
+         bpstat_do_actions (&stop_bpstat);
        }
 
-      /* If the continuation did not start the target again,
-        prepare for interation with the user.  */
-      if (!target_executing)
-       {              
+      /* If no breakpoint command resumed the inferior, prepare for
+        interaction with the user.  */
+      if (!is_running (inferior_ptid))
+       {
          if (was_sync)
            {
              display_gdb_prompt (0);