Author: martin
Date: 2007-01-16 13:20:36 -0500 (Tue, 16 Jan 2007)
New Revision: 71159

Modified:
   trunk/debugger/ChangeLog
   trunk/debugger/backend/MonoThreadManager.cs
   trunk/debugger/backend/SingleSteppingEngine.cs
   trunk/debugger/backend/ThreadManager.cs
   trunk/debugger/classes/DebuggerConfiguration.cs
   trunk/debugger/classes/Thread.cs
Log:
2007-01-16  Martin Baulig  <[EMAIL PROTECTED]>

        * classes/Thread.cs (Thread.Flags): Added `AutoRun'.
        (Thread.AutoStop): New public method.

        * classes/DebuggerConfiguration.cs
        (DebuggerConfiguration.StayInThread): New public property.

        * backends/SingleSteppingEngine.cs: Correctly handle stop requests.



Modified: trunk/debugger/ChangeLog
===================================================================
--- trunk/debugger/ChangeLog    2007-01-16 17:46:05 UTC (rev 71158)
+++ trunk/debugger/ChangeLog    2007-01-16 18:20:36 UTC (rev 71159)
@@ -1,3 +1,13 @@
+2007-01-16  Martin Baulig  <[EMAIL PROTECTED]>
+
+       * classes/Thread.cs (Thread.Flags): Added `AutoRun'.
+       (Thread.AutoStop): New public method.
+
+       * classes/DebuggerConfiguration.cs
+       (DebuggerConfiguration.StayInThread): New public property.
+
+       * backends/SingleSteppingEngine.cs: Correctly handle stop requests.
+
 2007-01-03  Martin Baulig  <[EMAIL PROTECTED]>
 
        * classes/Thread.cs (Thread.Flags): New public enum.

Modified: trunk/debugger/backend/MonoThreadManager.cs
===================================================================
--- trunk/debugger/backend/MonoThreadManager.cs 2007-01-16 17:46:05 UTC (rev 
71158)
+++ trunk/debugger/backend/MonoThreadManager.cs 2007-01-16 18:20:36 UTC (rev 
71159)
@@ -141,7 +141,7 @@
                }
 
                internal bool HandleChildEvent (SingleSteppingEngine engine, 
Inferior inferior,
-                                               ref Inferior.ChildEvent cevent)
+                                               ref Inferior.ChildEvent cevent, 
out bool resume_target)
                {
                        if (cevent.Type == 
Inferior.ChildEventType.CHILD_NOTIFICATION) {
                                NotificationType type = (NotificationType) 
cevent.Argument;
@@ -197,6 +197,7 @@
                                                engine.ReachedManagedMain 
(data);
                                        else
                                                engine.ReachedManagedMain 
(TargetAddress.Null);
+                                       resume_target = false;
                                        return true;
                                }
 
@@ -208,18 +209,21 @@
                                        cevent = new Inferior.ChildEvent (
                                                
Inferior.ChildEventType.UNHANDLED_EXCEPTION,
                                                0, cevent.Data1, cevent.Data2);
+                                       resume_target = false;
                                        return false;
 
                                case NotificationType.HandleException:
                                        cevent = new Inferior.ChildEvent (
                                                
Inferior.ChildEventType.HANDLE_EXCEPTION,
                                                0, cevent.Data1, cevent.Data2);
+                                       resume_target = false;
                                        return false;
 
                                case NotificationType.ThrowException:
                                        cevent = new Inferior.ChildEvent (
                                                
Inferior.ChildEventType.THROW_EXCEPTION,
                                                0, cevent.Data1, cevent.Data2);
+                                       resume_target = false;
                                        return false;
 
                                case NotificationType.FinalizeManagedCode:
@@ -236,16 +240,17 @@
                                }
                                }
 
-                               inferior.Continue ();
+                               resume_target = true;
                                return true;
                        }
 
                        if ((cevent.Type == 
Inferior.ChildEventType.CHILD_STOPPED) &&
                            (cevent.Argument == 
inferior.MonoThreadAbortSignal)) {
-                               inferior.Continue ();
+                               resume_target = true;
                                return true;
                        }
 
+                       resume_target = false;
                        return false;
                }
        }

Modified: trunk/debugger/backend/SingleSteppingEngine.cs
===================================================================
--- trunk/debugger/backend/SingleSteppingEngine.cs      2007-01-16 17:46:05 UTC 
(rev 71158)
+++ trunk/debugger/backend/SingleSteppingEngine.cs      2007-01-16 18:20:36 UTC 
(rev 71159)
@@ -151,8 +151,8 @@
                                return;
 
                        Inferior.ChildEvent cevent = inferior.ProcessEvent 
(status);
-                       Report.Debug (DebugFlags.EventLoop, "{0} received event 
{1} ({2:x})",
-                                     this, cevent, status);
+                       Report.Debug (DebugFlags.EventLoop, "{0} received event 
{1} ({2:x}){3}",
+                                     this, cevent, status, stop_requested ? " 
- stop requested" : "");
                        if (has_thread_lock) {
                                Report.Debug (DebugFlags.EventLoop,
                                              "{0} received event {1} while 
being thread-locked ({2})",
@@ -179,8 +179,21 @@
                                              "{0} received event {1} ({2:x}) 
while running {3}",
                                              this, cevent, status, 
current_operation);
 
-                       if (manager.HandleChildEvent (this, inferior, ref 
cevent))
+                       bool resume_target;
+                       if (manager.HandleChildEvent (this, inferior, ref 
cevent, out resume_target)) {
+                               Report.Debug (DebugFlags.EventLoop,
+                                             "{0} done handling event: {1} {2} 
{3}", this, cevent, resume_target,
+                                             stop_requested);
+                               if (!resume_target)
+                                       return;
+                               if (stop_requested) {
+                                       stop_requested = false;
+                                       frame_changed (inferior.CurrentFrame, 
null);
+                                       OperationCompleted (new TargetEventArgs 
(TargetEventType.TargetStopped, 0, current_frame));
+                               }
+                               inferior.Continue ();
                                return;
+                       }
                        ProcessChildEvent (cevent);
                }
 
@@ -778,8 +791,8 @@
                public override void Stop ()
                {
                        lock (this) {
-                               Report.Debug (DebugFlags.EventLoop, "{0} 
interrupt: {1}",
-                                             this, engine_stopped);
+                               Report.Debug (DebugFlags.EventLoop, "{0} 
interrupt: {1} {2}",
+                                             this, engine_stopped, 
current_operation);
 
                                if (engine_stopped)
                                        return;
@@ -1371,8 +1384,12 @@
                                        return;
                                }
 
-                               if (manager.HandleChildEvent (this, inferior, 
ref cevent))
+                               bool resume_target;
+                               if (manager.HandleChildEvent (this, inferior, 
ref cevent, out resume_target)) {
+                                       if (resume_target)
+                                               inferior.Continue ();
                                        return;
+                               }
                                ProcessChildEvent (cevent);
                        }
                }
@@ -2019,6 +2036,9 @@
                        if (sse.ProcessServant.IsAttached)
                                return EventResult.Completed;
 
+                       Report.Debug (DebugFlags.SSE,
+                                     "{0} start #1: {1} {2} {3}", sse, cevent,
+                                     sse.ProcessServant.IsAttached, 
inferior.MainMethodAddress);
                        sse.PushOperation (new OperationRun (
                                sse, inferior.MainMethodAddress, true, Result));
                        return EventResult.Running;

Modified: trunk/debugger/backend/ThreadManager.cs
===================================================================
--- trunk/debugger/backend/ThreadManager.cs     2007-01-16 17:46:05 UTC (rev 
71158)
+++ trunk/debugger/backend/ThreadManager.cs     2007-01-16 18:20:36 UTC (rev 
71159)
@@ -152,10 +152,10 @@
                }
 
                internal bool HandleChildEvent (SingleSteppingEngine engine, 
Inferior inferior,
-                                               ref Inferior.ChildEvent cevent)
+                                               ref Inferior.ChildEvent cevent, 
out bool resume_target)
                {
                        if (cevent.Type == Inferior.ChildEventType.NONE) {
-                               inferior.Continue ();
+                               resume_target = true;
                                return true;
                        }
 
@@ -163,18 +163,19 @@
 
                        if (cevent.Type == 
Inferior.ChildEventType.CHILD_CREATED_THREAD) {
                                inferior.Process.ThreadCreated (inferior, (int) 
cevent.Argument, false);
-                               inferior.Continue ();
+                               resume_target = true;
                                return true;
                        }
 
                        if (cevent.Type == 
Inferior.ChildEventType.CHILD_FORKED) {
                                inferior.Process.ChildForked (inferior, (int) 
cevent.Argument);
-                               inferior.Continue ();
+                               resume_target = true;
                                return true;
                        }
 
                        if (cevent.Type == Inferior.ChildEventType.CHILD_EXECD) 
{
                                inferior.Process.ChildExecd (inferior);
+                               resume_target = false;
                                return true;
                        }
 
@@ -182,19 +183,22 @@
                            (cevent.Argument == inferior.SIGCHLD)) {
                                cevent = new Inferior.ChildEvent (
                                        Inferior.ChildEventType.CHILD_STOPPED, 
0, 0, 0);
+                               resume_target = false;
                                return false;
                        }
 
                        bool retval = false;
+                       resume_target = false;
                        if (inferior.Process.MonoManager != null)
                                retval = 
inferior.Process.MonoManager.HandleChildEvent (
-                                       engine, inferior, ref cevent);
+                                       engine, inferior, ref cevent, out 
resume_target);
 
                        if ((cevent.Type == 
Inferior.ChildEventType.CHILD_EXITED) ||
                             (cevent.Type == 
Inferior.ChildEventType.CHILD_SIGNALED)) {
                                thread_hash.Remove (engine.PID);
                                engine_hash.Remove (engine.ID);
                                engine.OnThreadExited (cevent);
+                               resume_target = false;
                                return true;
                        }
 

Modified: trunk/debugger/classes/DebuggerConfiguration.cs
===================================================================
--- trunk/debugger/classes/DebuggerConfiguration.cs     2007-01-16 17:46:05 UTC 
(rev 71158)
+++ trunk/debugger/classes/DebuggerConfiguration.cs     2007-01-16 18:20:36 UTC 
(rev 71159)
@@ -120,6 +120,7 @@
                        }
                }
 
+               bool stay_in_thread;
                bool load_native_symtabs;
                Hashtable module_groups;
 
@@ -207,5 +208,10 @@
                        get { return load_native_symtabs; }
                        set { load_native_symtabs = true; }
                }
+
+               public bool StayInThread {
+                       get { return stay_in_thread; }
+                       set { stay_in_thread = false; }
+               }
        }
 }

Modified: trunk/debugger/classes/Thread.cs
===================================================================
--- trunk/debugger/classes/Thread.cs    2007-01-16 17:46:05 UTC (rev 71158)
+++ trunk/debugger/classes/Thread.cs    2007-01-16 18:20:36 UTC (rev 71159)
@@ -25,13 +25,15 @@
                        None            = 0x0000,
                        Daemon          = 0x0001,
                        Immutable       = 0x0002,
-                       Background      = 0x0004
+                       Background      = 0x0004,
+                       AutoRun         = 0x0008
                }
 
                internal Thread (ThreadServant servant, int id)
                {
                        this.id = id;
                        this.servant = servant;
+                       this.is_running = true;
                        this.operation_completed_event = new 
ST.ManualResetEvent (false);
                }
 
@@ -386,7 +388,6 @@
                        lock (this) {
                                check_alive ();
                                is_running = true;
-                               flags |= Flags.Background;
                                operation_completed_event.Reset ();
                                ThreadCommandResult result = new 
ThreadCommandResult (this);
                                servant.Continue (until, new 
ThreadCommandResult (this));
@@ -404,6 +405,7 @@
                        lock (this) {
                                check_alive ();
                                is_running = true;
+                               flags |= Flags.Background;
                                operation_completed_event.Reset ();
                                ThreadCommandResult result = new 
ThreadCommandResult (this);
                                servant.Background (until, new 
ThreadCommandResult (this));
@@ -433,6 +435,15 @@
                        servant.Stop ();
                }
 
+               public void AutoStop ()
+               {
+                       check_alive ();
+                       servant.Stop ();
+                       Wait ();
+                       is_running = false;
+                       flags |= Flags.AutoRun;
+               }
+
                public void Wait ()
                {
                        Report.Debug (DebugFlags.Wait, "{0} waiting", this);

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to