Moving functionality from NDebugger to Process - using ProcessEventArgs

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@1687 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Service/DynamicTreeDebuggerRow.cs

@@ -74,7 +74,7 @@ namespace ICSharpCode.SharpDevelop.Services
 			Update();
 		}
 		
-		void Update(object sender, DebuggerEventArgs e)
+		void Update(object sender, ProcessEventArgs e)
 		{
 			dirty = true;
 			Update();
@@ -166,7 +166,7 @@ namespace ICSharpCode.SharpDevelop.Services
 			if (Variable.Process.IsPaused) {
 				action();
 			} else {
-				EventHandler<DebuggerEventArgs> onDebuggingPaused = null;
+				EventHandler<ProcessEventArgs> onDebuggingPaused = null;
 				onDebuggingPaused = delegate {
 					action();
 					Variable.Process.DebuggingPaused -= onDebuggingPaused;

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Service/WindowsDebugger.cs

@@ -329,7 +329,7 @@ namespace ICSharpCode.SharpDevelop.Services
 			}
 		}
 		
-		void DebuggingPaused(object sender, DebuggerEventArgs e)
+		void DebuggingPaused(object sender, ProcessEventArgs e)
 		{
 			OnIsProcessRunningChanged(EventArgs.Empty);
 		}
@@ -357,12 +357,12 @@ namespace ICSharpCode.SharpDevelop.Services
 			}
 		}
 		
-		void DebuggeeStateChanged(object sender, DebuggerEventArgs e)
+		void DebuggeeStateChanged(object sender, ProcessEventArgs e)
 		{
 			JumpToCurrentLine();
 		}
 		
-		void DebuggingResumed(object sender, DebuggerEventArgs e)
+		void DebuggingResumed(object sender, ProcessEventArgs e)
 		{
 			if (!debugger.Evaluating) {
 				DebuggerService.RemoveCurrentLineMarker();

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Debugger/DebugeeState.cs

@@ -20,7 +20,7 @@ namespace Debugger
 		
 		public event EventHandler Expired;
 		
-		public event EventHandler<DebuggerEventArgs> Changed {
+		public event EventHandler<ProcessEventArgs> Changed {
 			add {
 				process.DebuggeeStateChanged += value;
 			}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Debugger/DebuggerEvents/MessageEventArgs.cs

@@ -10,7 +10,7 @@ using System;
 namespace Debugger 
 {	
 	[Serializable]
-	public class MessageEventArgs : DebuggerEventArgs
+	public class MessageEventArgs : ProcessEventArgs
 	{
 		int level;
 		string message;

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Debugger/ExceptionEventArgs.cs

@@ -9,7 +9,7 @@ using System;
 
 namespace Debugger
 {
-	public class ExceptionEventArgs: DebuggerEventArgs
+	public class ExceptionEventArgs: ProcessEventArgs
 	{
 		bool @continue;
 		Exception exception;

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Debugger/IMutable.cs

@@ -11,6 +11,6 @@ namespace Debugger
 {
 	public interface IMutable
 	{
-		event EventHandler<DebuggerEventArgs> Changed;
+		event EventHandler<ProcessEventArgs> Changed;
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Debugger/Internal/ManagedCallback.cs

@@ -46,16 +46,16 @@ namespace Debugger
 				// ExitProcess may be called at any time when debuggee is killed
 				name == "ExitProcess") {
 				
-				process.SelectedProcess = process.GetProcess(pProcess);
+				process = process.GetProcess(pProcess);
 				if (process.IsPaused && process.PauseSession.PausedReason == PausedReason.ForcedBreak) {
 					process.TraceMessage("Processing post-break callback");
 					// Continue the break, process is still breaked because of the callback
-					process.SelectedProcess.Continue();
+					process.Continue();
 					pauseProcessInsteadOfContinue = true;
 				} else {
 					pauseProcessInsteadOfContinue = false;
 				}
-				process.SelectedProcess.NotifyPaused(new PauseSession(pausedReason));
+				process.NotifyPaused(new PauseSession(pausedReason));
 			} else {
 				throw new DebuggerException("Invalid state at the start of callback");
 			}
@@ -69,9 +69,9 @@ namespace Debugger
 		void EnterCallback(PausedReason pausedReason, string name, ICorDebugThread pThread)
 		{
 			EnterCallback(pausedReason, name, pThread.Process);
-			process.SelectedProcess.SelectedThread = process.GetThread(pThread);
+			process.SelectedThread = process.GetThread(pThread);
 			// Remove expired functions from the callstack cache
-			process.SelectedProcess.SelectedThread.CheckExpirationOfFunctions();
+			process.SelectedThread.CheckExpirationOfFunctions();
 		}
 		
 		void ExitCallback_Continue()
@@ -79,7 +79,7 @@ namespace Debugger
 			if (pauseProcessInsteadOfContinue) {
 				ExitCallback_Paused();
 			} else {
-				process.SelectedProcess.Continue();
+				process.Continue();
 			}
 		}
 		

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Debugger/NDebugger.cs

@@ -44,7 +44,7 @@ namespace Debugger
 			}
 		}
 		
-        internal ManagedCallback ManagedCallback {
+		internal ManagedCallback ManagedCallback {
 			get {
 				return managedCallback;
 			}
@@ -116,17 +116,8 @@ namespace Debugger
 		
 		internal void TerminateDebugger()
 		{
-			ClearModules();
-			
 			ResetBreakpoints();
 			
-			ClearThreads();
-			
-			selectedProcess = null;
-			pausedHandle.Reset();
-			
-			pendingEvalsCollection.Clear();
-			
 			TraceMessage("Reset done");
 			
 			corDebug.Terminate();
@@ -142,20 +133,6 @@ namespace Debugger
 			noProcessesHandle.Set();
 		}
 		
-		
-		/// <summary>
-		/// Fired when System.Diagnostics.Trace.WriteLine() is called in debuged process
-		/// </summary>
-		public event EventHandler<MessageEventArgs> LogMessage;
-
-		protected internal virtual void OnLogMessage(MessageEventArgs arg)
-		{
-			TraceMessage ("Debugger event: OnLogMessage");
-			if (LogMessage != null) {
-				LogMessage(this, arg);
-			}
-		}
-
 		/// <summary>
 		/// Internal: Used to debug the debugger library.
 		/// </summary>
@@ -174,7 +151,6 @@ namespace Debugger
 			OnDebuggerTraceMessage(message);
 		}
 		
-
 		public void StartWithoutDebugging(System.Diagnostics.ProcessStartInfo psi)
 		{
 			System.Diagnostics.Process process;
@@ -189,25 +165,5 @@ namespace Debugger
 			Process process = Process.CreateProcess(this, filename, workingDirectory, arguments);
 			AddProcess(process);
 		}
-
-		public SourcecodeSegment NextStatement { 
-			get {
-				if (SelectedFunction == null || IsRunning) {
-					return null;
-				} else {
-					return SelectedFunction.NextStatement;
-				}
-			}
-		}
-		
-		public VariableCollection LocalVariables { 
-			get {
-				if (SelectedFunction == null || IsRunning) {
-					return VariableCollection.Empty;
-				} else {
-					return SelectedFunction.Variables;
-				}
-			}
-		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Debugger/Process-StateControl.cs

@@ -26,9 +26,9 @@ namespace Debugger
 		Process selectedProcess;
 		
 		public event EventHandler<ExceptionEventArgs> ExceptionThrown;
-		public event EventHandler<DebuggerEventArgs> DebuggingResumed;
+		public event EventHandler<ProcessEventArgs> DebuggingResumed;
-		public event EventHandler<DebuggerEventArgs> DebuggingPaused;
+		public event EventHandler<ProcessEventArgs> DebuggingPaused;
-		public event EventHandler<DebuggerEventArgs> DebuggeeStateChanged;
+		public event EventHandler<ProcessEventArgs> DebuggeeStateChanged;
 		
 		public bool PauseOnHandledException {
 			get {
@@ -50,7 +50,7 @@ namespace Debugger
 		{
 			TraceMessage ("Debugger event: OnDebuggingResumed()");
 			if (DebuggingResumed != null) {
-				DebuggingResumed(this, new DebuggerEventArgs(this));
+				DebuggingResumed(this, new ProcessEventArgs(this));
 			}
 		}
 		
@@ -58,7 +58,7 @@ namespace Debugger
 		{
 			TraceMessage ("Debugger event: OnDebuggingPaused (" + PausedReason.ToString() + ")");
 			if (DebuggingPaused != null) {
-				DebuggingPaused(this, new DebuggerEventArgs(this));
+				DebuggingPaused(this, new ProcessEventArgs(this));
 			}
 		}
 		
@@ -67,26 +67,7 @@ namespace Debugger
 		{
 			TraceMessage ("Debugger event: OnDebuggeeStateChanged (" + PausedReason.ToString() + ")");
 			if (DebuggeeStateChanged != null) {
-				DebuggeeStateChanged(this, new DebuggerEventArgs(this));
+				DebuggeeStateChanged(this, new ProcessEventArgs(this));
-			}
-		}
-		
-		public Process SelectedProcess {
-			get {
-				return selectedProcess;
-			}
-			set {
-				selectedProcess = value;
-			}
-		}
-		
-		public Thread SelectedThread {
-			get {
-				if (SelectedProcess == null) {
-					return null;
-				} else {
-					return SelectedProcess.SelectedThread;
-				}
 			}
 		}
 		
@@ -100,16 +81,6 @@ namespace Debugger
 			}
 		}
 		
-		public PauseSession PauseSession {
-			get {
-				if (SelectedProcess == null) {
-					return null;
-				} else {
-					return SelectedProcess.PauseSession;
-				}
-			}
-		}
-		
 		/// <summary>
 		/// Indentification of the state of the debugee. This value changes whenever the state of the debugee significatntly changes
 		/// </summary>
@@ -119,32 +90,6 @@ namespace Debugger
 			}
 		}
 		
-		public void AssertPaused()
-		{
-			if (!IsPaused) {
-				throw new DebuggerException("Debugger is not paused.");
-			}
-		}
-		
-		public void AssertRunning()
-		{
-			if (IsPaused) {
-				throw new DebuggerException("Debugger is not running.");
-			}
-		}
-		
-		public bool IsPaused {
-			get {
-				return (PauseSession != null);
-			}
-		}
-		
-		public bool IsRunning {
-			get {
-				return !IsPaused;
-			}
-		}
-		
 		/// <summary>
 		/// The reason why the debugger is paused.
 		/// Thows an DebuggerException if debugger is not paused.
@@ -159,7 +104,7 @@ namespace Debugger
 		internal void Pause(bool debuggeeStateChanged)
 		{
 			if (this.SelectedThread == null && this.Threads.Count > 0) {
-				this.SelectedProcess.SelectedThread = this.Threads[0];
+				this.SelectedThread = this.Threads[0];
 			}
 			
 			if (this.SelectedThread != null) {
@@ -221,15 +166,6 @@ namespace Debugger
 			}
 		}
 		
-		public void Break()
-		{
-			foreach(Process p in Processes) {
-				if (p.IsRunning) {
-					p.Break();
-				}
-			}
-		}
-
 		public void StepInto()
 		{
 			SelectedFunction.StepInto();
@@ -244,17 +180,5 @@ namespace Debugger
 		{
 			SelectedFunction.StepOut();
 		}
-
-		public void Continue()
-		{
-			SelectedProcess.Continue();
-		}
-
-		public void Terminate()
-		{
-			foreach(Process p in Processes) {
-				p.Terminate();
-			}
-		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Modules/ModuleEventArgs.cs

@@ -10,7 +10,7 @@ using System;
 namespace Debugger 
 {	
 	[Serializable]
-	public class ModuleEventArgs : DebuggerEventArgs
+	public class ModuleEventArgs : ProcessEventArgs
 	{
 		Module module;
 		

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Function.cs

@@ -343,7 +343,7 @@ namespace Debugger
 						} else {
 							// invalidates all frames and chains for the current thread
 							CorILFrame.SetIP((uint)ilOffset);
-							process.SelectedProcess.NotifyPaused(new PauseSession(PausedReason.SetIP));
+							process.NotifyPaused(new PauseSession(PausedReason.SetIP));
 							process.Pause(false);
 						}
 					} catch {

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Process.cs

@@ -38,7 +38,7 @@ namespace Debugger
 			if(!hasExpired) {
 				hasExpired = true;
 				if (Expired != null) {
-					Expired(this, new DebuggerEventArgs(debugger));
+					Expired(this, new ProcessEventArgs(this));
 				}
 			}
 		}
@@ -84,18 +84,6 @@ namespace Debugger
 			}
 		}
 		
-		public IList<Thread> Threads {
-			get {
-				List<Thread> threads = new List<Thread>();
-				foreach(Thread thread in debugger.Threads) {
-					if (thread.Process == this) {
-						threads.Add(thread);
-					}
-				}
-				return threads;
-			}
-		}
-		
 		static public Process CreateProcess(NDebugger debugger, string filename, string workingDirectory, string arguments)
 		{
 			return debugger.MTA2STA.Call<Process>(delegate{
@@ -145,9 +133,8 @@ namespace Debugger
 			corProcess.Stop(5000); // TODO: Hardcoded value
 			
 			pauseSession = new PauseSession(PausedReason.ForcedBreak);
-			debugger.SelectedProcess = this;
 			
-			debugger.Pause(true);
+			Pause(true);
 		}
 		
 		public void Continue()
@@ -156,8 +143,8 @@ namespace Debugger
 
 			pauseSession.NotifyHasExpired();
 			pauseSession = null;
-			debugger.OnDebuggingResumed();
+			OnDebuggingResumed();
-			debugger.pausedHandle.Reset();
+			pausedHandle.Reset();
 			
 			corProcess.Continue(0);
 		}
@@ -198,5 +185,58 @@ namespace Debugger
 				throw new DebuggerException("Process is not running.");
 			}
 		}
+		
+		
+		
+		/// <summary>
+		/// Fired when System.Diagnostics.Trace.WriteLine() is called in debuged process
+		/// </summary>
+		public event EventHandler<MessageEventArgs> LogMessage;
+		
+		protected internal virtual void OnLogMessage(MessageEventArgs arg)
+		{
+			TraceMessage ("Debugger event: OnLogMessage");
+			if (LogMessage != null) {
+				LogMessage(this, arg);
+			}
+		}
+		
+		/// <summary>
+		/// Internal: Used to debug the debugger library.
+		/// </summary>
+		public event EventHandler<MessageEventArgs> DebuggerTraceMessage;
+		
+		protected internal virtual void OnDebuggerTraceMessage(string message)
+		{
+			if (DebuggerTraceMessage != null) {
+				DebuggerTraceMessage(this, new MessageEventArgs(this, message));
+			}
+		}
+		
+		internal void TraceMessage(string message)
+		{
+			System.Diagnostics.Debug.WriteLine("Debugger:" + message);
+			OnDebuggerTraceMessage(message);
+		}
+		
+		public SourcecodeSegment NextStatement { 
+			get {
+				if (SelectedFunction == null || IsRunning) {
+					return null;
+				} else {
+					return SelectedFunction.NextStatement;
+				}
+			}
+		}
+		
+		public VariableCollection LocalVariables { 
+			get {
+				if (SelectedFunction == null || IsRunning) {
+					return VariableCollection.Empty;
+				} else {
+					return SelectedFunction.Variables;
+				}
+			}
+		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/StepperEventArgs.cs

@@ -10,7 +10,7 @@ using System;
 namespace Debugger
 {
 	[Serializable]
-	public class StepperEventArgs: DebuggerEventArgs
+	public class StepperEventArgs: ProcessEventArgs
 	{
 		Stepper stepper;
 		
@@ -20,7 +20,7 @@ namespace Debugger
 			}
 		}
 		
-		public StepperEventArgs(Stepper stepper): base(stepper.Debugger)
+		public StepperEventArgs(Stepper stepper): base(stepper.Process)
 		{
 			this.stepper = stepper;
 		}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Thread.cs

@@ -74,8 +74,6 @@ namespace Debugger
 			this.process = process;
 			this.corThread = corThread;
 			id = corThread.ID;
-			
-			this.process = process.GetProcess(corThread.Process);
 		}
 		
 		public bool Suspended {

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/ThreadEventArgs.cs

@@ -10,7 +10,7 @@ using System;
 namespace Debugger 
 {	
 	[Serializable]
-	public class ThreadEventArgs : DebuggerEventArgs
+	public class ThreadEventArgs : ProcessEventArgs
 	{
 		Thread thread;
 		

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ArrayValue.cs

@@ -118,7 +118,7 @@ namespace Debugger
 				elementName += indices[i].ToString() + ",";
 			elementName = elementName.TrimEnd(new char[] {','}) + "]";
 			
-			return new Variable(Debugger,
+			return new Variable(Process,
 			                    elementName,
 			                    Variable.Flags.Default,
 			                    new IExpirable[] {this.Variable},

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/Evals/EvalEventArgs.cs

@@ -10,7 +10,7 @@ using System;
 namespace Debugger 
 {	
 	[Serializable]
-	public class EvalEventArgs : DebuggerEventArgs
+	public class EvalEventArgs : ProcessEventArgs
 	{
 		Eval eval;
 		

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ValueEventArgs.cs

@@ -10,7 +10,7 @@ using System;
 namespace Debugger 
 {	
 	[Serializable]
-	public class ValueEventArgs : DebuggerEventArgs
+	public class ValueEventArgs : ProcessEventArgs
 	{
 		Value val;
 		
@@ -20,7 +20,7 @@ namespace Debugger
 			}
 		}
 		
-		public ValueEventArgs(Value val): base(val.Debugger)
+		public ValueEventArgs(Value val): base(val.Process)
 		{
 			this.val = val;
 		}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/Variable.cs

@@ -55,7 +55,7 @@ namespace Debugger
 		bool isExpired = false;
 		
 		public event EventHandler Expired;
-		public event EventHandler<DebuggerEventArgs> Changed;
+		public event EventHandler<ProcessEventArgs> Changed;
 		
 		public Process Process {
 			get {
@@ -161,7 +161,7 @@ namespace Debugger
 			foreach(IExpirable exp in expireDependencies) {
 				AddExpireDependency(exp);
 			}
-			AddExpireDependency(process.SelectedProcess);
+			AddExpireDependency(process);
 			
 			this.mutateDependencies = mutateDependencies;
 			if (!this.HasExpired) {
@@ -198,7 +198,7 @@ namespace Debugger
 			}
 		}
 		
-		void DependencyChanged(object sender, DebuggerEventArgs e)
+		void DependencyChanged(object sender, ProcessEventArgs e)
 		{
 			NotifyChange();
 		}
@@ -218,7 +218,7 @@ namespace Debugger
 			}
 		}
 		
-		protected virtual void OnChanged(DebuggerEventArgs e)
+		protected virtual void OnChanged(ProcessEventArgs e)
 		{
 			if (Changed != null) {
 				Changed(this, e);

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/VariableEventArgs.cs

@@ -9,7 +9,7 @@ using System;
 
 namespace Debugger
 {
-	public class VariableEventArgs: DebuggerEventArgs
+	public class VariableEventArgs: ProcessEventArgs
 	{
 		Variable variable;