Debugger made less static

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

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Pads/BreakPointsPad.cs

@@ -22,6 +22,8 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 {
 	public class BreakPointsPad : AbstractPadContent
 	{
+		WindowsDebugger debugger;
+
 		ListView  breakpointsList;
 		
 		ColumnHeader name     = new ColumnHeader();
@@ -40,6 +42,8 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 		
 		void InitializeComponents()
 		{
+			debugger = (WindowsDebugger)DebuggerService.CurrentDebugger;
+
 			breakpointsList = new ListView();
 			breakpointsList.FullRowSelect = true;
 			breakpointsList.AutoArrange = true;
@@ -55,11 +59,11 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			name.Width = 300;
 			path.Width = 400;
 			
-			NDebugger.DebuggingResumed += new DebuggerEventHandler(debuggerService_OnDebuggingResumed);
-			NDebugger.Instance.BreakpointAdded += new DebuggerLibrary.BreakpointEventHandler(AddBreakpoint);
-			NDebugger.Instance.BreakpointStateChanged += new DebuggerLibrary.BreakpointEventHandler(RefreshBreakpoint);
-			NDebugger.Instance.BreakpointRemoved += new DebuggerLibrary.BreakpointEventHandler(RemoveBreakpoint);
-			NDebugger.Instance.BreakpointHit += new DebuggerLibrary.BreakpointEventHandler(Breakpoints_OnBreakpointHit);
+			debugger.DebuggingResumed += new DebuggerEventHandler(debuggerService_OnDebuggingResumed);
+			debugger.BreakpointAdded += new DebuggerLibrary.BreakpointEventHandler(AddBreakpoint);
+			debugger.BreakpointStateChanged += new DebuggerLibrary.BreakpointEventHandler(RefreshBreakpoint);
+			debugger.BreakpointRemoved += new DebuggerLibrary.BreakpointEventHandler(RemoveBreakpoint);
+			debugger.BreakpointHit += new DebuggerLibrary.BreakpointEventHandler(Breakpoints_OnBreakpointHit);
 			
 			RedrawContent();
 		}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Pads/CallStackPad.cs

@@ -22,12 +22,10 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 {
 	public class CallStackPad : AbstractPadContent
 	{
+		WindowsDebugger debugger;
+
 		ListView  callStackList;
 		
-		//
-		//WindowsDebugger DebuggerService = (WindowsDebugger)((DebuggerService)ServiceManager.Services.GetService(typeof(DebuggerService))).CurrentDebugger;
-        WindowsDebugger debugger;
-		
 		ColumnHeader name     = new ColumnHeader();
 		ColumnHeader language = new ColumnHeader();
 		
@@ -45,6 +43,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 		void InitializeComponents()
 		{
             debugger = (WindowsDebugger)DebuggerService.CurrentDebugger;
+
 			callStackList = new ListView();
 			callStackList.FullRowSelect = true;
 			callStackList.AutoArrange = true;
@@ -58,8 +57,8 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			name.Width = 300;
 			language.Width = 400;
 			
-			NDebugger.IsDebuggingChanged += new DebuggerEventHandler(DebuggerStateChanged);
-			NDebugger.IsProcessRunningChanged += new DebuggerEventHandler(DebuggerStateChanged);
+			debugger.IsDebuggingChanged += new DebuggerEventHandler(DebuggerStateChanged);
+			debugger.IsProcessRunningChanged += new DebuggerEventHandler(DebuggerStateChanged);
 
 			RedrawContent();
 		}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Pads/ExceptionHistoryPad.cs

@@ -22,12 +22,10 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 {
 	public class ExceptionHistoryPad : AbstractPadContent
 	{
+		WindowsDebugger debugger;
+
 		ListView  exceptionHistoryList;
 		
-		//
-		//WindowsDebugger DebuggerService = (WindowsDebugger)((DebuggerService)ServiceManager.Services.GetService(typeof(DebuggerService))).CurrentDebugger;
-        WindowsDebugger debugger;
-		
 		ColumnHeader time      = new ColumnHeader();
 		ColumnHeader exception = new ColumnHeader();
 		ColumnHeader location  = new ColumnHeader();
@@ -45,7 +43,8 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 				
 		void InitializeComponents()
 		{
-            debugger = (WindowsDebugger)DebuggerService.CurrentDebugger;
+			debugger = (WindowsDebugger)DebuggerService.CurrentDebugger;
+
 			exceptionHistoryList = new ListView();
 			exceptionHistoryList.FullRowSelect = true;
 			exceptionHistoryList.AutoArrange = true;
@@ -60,8 +59,8 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			location.Width = 400;
 			time.Width = 80;
 			
-			NDebugger.IsDebuggingChanged += new DebuggerEventHandler(DebuggerStateChanged);
-			NDebugger.IsProcessRunningChanged += new DebuggerEventHandler(DebuggerStateChanged);
+			debugger.IsDebuggingChanged += new DebuggerEventHandler(DebuggerStateChanged);
+			debugger.IsProcessRunningChanged += new DebuggerEventHandler(DebuggerStateChanged);
 
 			RedrawContent();
 		}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Pads/LoadedModulesPad.cs

@@ -21,6 +21,8 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 {
 	public class LoadedModulesPad : AbstractPadContent
 	{
+		WindowsDebugger debugger;
+
 		ListView  loadedModulesList;
 		
 		ColumnHeader name        = new ColumnHeader();
@@ -46,6 +48,8 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 		
 		void InitializeComponents()
 		{
+			debugger = (WindowsDebugger)DebuggerService.CurrentDebugger;
+
 			loadedModulesList = new ListView();
 			loadedModulesList.FullRowSelect = true;
 			loadedModulesList.AutoArrange = true;
@@ -64,8 +68,8 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			timestamp.Width = 0;//80;
 			information.Width = 130;
 
-			NDebugger.Instance.ModuleLoaded += new DebuggerLibrary.ModuleEventHandler(AddModule);
-			NDebugger.Instance.ModuleUnloaded += new DebuggerLibrary.ModuleEventHandler(RemoveModule);
+			debugger.ModuleLoaded += new DebuggerLibrary.ModuleEventHandler(AddModule);
+			debugger.ModuleUnloaded += new DebuggerLibrary.ModuleEventHandler(RemoveModule);
 
 			RedrawContent();
 		}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Pads/LocalVarPad.cs

@@ -22,9 +22,9 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 {
 	public class LocalVarPad : AbstractPadContent
 	{
-		TreeListView localVarList;
+		WindowsDebugger debugger;
 
-		//ClassBrowserIconsService iconsService;
+		TreeListView localVarList;
 		
 		ColumnHeader name = new ColumnHeader();
 		ColumnHeader val  = new ColumnHeader();
@@ -43,6 +43,8 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 		
 		void InitializeComponents()
 		{
+			debugger = (WindowsDebugger)DebuggerService.CurrentDebugger;
+
 			ImageList imageList = new ImageList();
 			imageList.Images.Add(IconService.GetBitmap("Icons.16x16.Class"));
 			imageList.Images.Add(IconService.GetBitmap("Icons.16x16.Field"));
@@ -63,7 +65,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 
 			localVarList.BeforeExpand += new TreeListViewCancelEventHandler(localVarList_BeforeExpand);
 			
-			NDebugger.DebuggingPaused += new DebuggingPausedEventHandler(debuggerService_OnDebuggingPaused);
+			debugger.DebuggingPaused += new DebuggingPausedEventHandler(debuggerService_OnDebuggingPaused);
 
 			RedrawContent();
 		}
@@ -74,7 +76,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			val.Text  = "Value";
 			type.Text = "Type";
 
-            if (NDebugger.IsDebugging && NDebugger.IsProcessRunning == false) {
+            if (debugger.IsDebugging && debugger.IsProcessRunning == false) {
                 debuggerService_OnDebuggingPaused(this, new DebuggingPausedEventArgs(PausedReason.StepComplete));
             }
 		}
@@ -84,7 +86,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			localVarList.BeginUpdate();
 			localVarList.Items.Clear();
 
-			AddVariables(localVarList.Items, NDebugger.LocalVariables);
+			AddVariables(localVarList.Items, debugger.LocalVariables);
 
 			localVarList.EndUpdate();
 		}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Pads/RunningThreadsPad.cs

@@ -22,12 +22,10 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 {
 	public class RunningThreadsPad : AbstractPadContent
 	{
+		WindowsDebugger debugger;
+
 		ListView  runningThreadsList;
 		
-		//
-		//WindowsDebugger DebuggerService = (WindowsDebugger)((DebuggerService)ServiceManager.Services.GetService(typeof(DebuggerService))).CurrentDebugger;
-        WindowsDebugger debugger;
-		
 		ColumnHeader id          = new ColumnHeader();
 		ColumnHeader name        = new ColumnHeader();
 		ColumnHeader location    = new ColumnHeader();
@@ -47,7 +45,8 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			
 		void InitializeComponents()
 		{
-            debugger = (WindowsDebugger)DebuggerService.CurrentDebugger;
+			debugger = (WindowsDebugger)DebuggerService.CurrentDebugger;
+
 			runningThreadsList = new ListView();
 			runningThreadsList.FullRowSelect = true;
 			runningThreadsList.AutoArrange = true;
@@ -65,10 +64,10 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			breaked.Width = 80;
 		
 			
-			NDebugger.Instance.ThreadStarted += new ThreadEventHandler(AddThread);
-			NDebugger.Instance.ThreadStateChanged += new ThreadEventHandler(RefreshThread);
-			NDebugger.Instance.ThreadExited += new ThreadEventHandler(RemoveThread);
-			NDebugger.IsProcessRunningChanged += new DebuggerEventHandler(DebuggerStateChanged);
+			debugger.ThreadStarted += new ThreadEventHandler(AddThread);
+			debugger.ThreadStateChanged += new ThreadEventHandler(RefreshThread);
+			debugger.ThreadExited += new ThreadEventHandler(RemoveThread);
+			debugger.IsProcessRunningChanged += new DebuggerEventHandler(DebuggerStateChanged);
 	
 			RedrawContent();
 		}

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

@@ -34,7 +34,7 @@ using ICSharpCode.SharpDevelop.Services;
 
 namespace ICSharpCode.SharpDevelop.Services
 {	
-	public class WindowsDebugger:IDebugger //, IService
+	public class WindowsDebugger:NDebugger, IDebugger //, IService
 	{
 		public event EventHandler DebugStopped; // FIX: unused
 
@@ -88,15 +88,6 @@ namespace ICSharpCode.SharpDevelop.Services
 		
 		public void InitializeService()
 		{
-			NDebugger.DebuggerTraceMessage    += new MessageEventHandler(DebuggerTraceMessage);
-			NDebugger.LogMessage              += new MessageEventHandler(LogMessage);
-			NDebugger.DebuggingStarted        += new DebuggerEventHandler(DebuggingStarted);
-			NDebugger.DebuggingPaused         += new DebuggingPausedEventHandler(DebuggingPaused);
-			NDebugger.DebuggingResumed        += new DebuggerEventHandler(DebuggingResumed);
-			NDebugger.DebuggingStopped        += new DebuggerEventHandler(DebuggingStopped);
-			NDebugger.IsProcessRunningChanged += new DebuggerEventHandler(DebuggerStateChanged);
-			NDebugger.Instance.BreakpointStateChanged += new DebuggerLibrary.BreakpointEventHandler(RestoreSharpdevelopBreakpoint);
-
 			DebuggerService.BreakPointAdded   += new EventHandler(RestoreNDebuggerBreakpoints);
 			DebuggerService.BreakPointRemoved += new EventHandler(RestoreNDebuggerBreakpoints);
 			DebuggerService.BreakPointChanged += new EventHandler(RestoreNDebuggerBreakpoints);
@@ -108,13 +99,6 @@ namespace ICSharpCode.SharpDevelop.Services
 
 		public void UnloadService()
 		{
-			NDebugger.DebuggerTraceMessage   -= new MessageEventHandler(DebuggerTraceMessage);
-			NDebugger.LogMessage             -= new MessageEventHandler(LogMessage);
-			NDebugger.DebuggingStarted       -= new DebuggerEventHandler(DebuggingStarted);
-			NDebugger.DebuggingPaused        -= new DebuggingPausedEventHandler(DebuggingPaused);
-			NDebugger.IsProcessRunningChanged -= new DebuggerEventHandler(DebuggerStateChanged);
-			NDebugger.Instance.BreakpointStateChanged -= new DebuggerLibrary.BreakpointEventHandler(RestoreSharpdevelopBreakpoint);
-
 			DebuggerService.BreakPointAdded   -= new EventHandler(RestoreNDebuggerBreakpoints);
 			DebuggerService.BreakPointRemoved -= new EventHandler(RestoreNDebuggerBreakpoints);
 			DebuggerService.BreakPointChanged -= new EventHandler(RestoreNDebuggerBreakpoints);
@@ -126,17 +110,6 @@ namespace ICSharpCode.SharpDevelop.Services
 		#endregion		
 		
 		#region ICSharpCode.SharpDevelop.Services.IDebugger interface implementation
-		public bool IsDebugging { 
-			get { 
-				return NDebugger.IsDebugging; 
-			} 
-		}
-		
-		public bool IsProcessRunning { 
-			get { 
-				return NDebugger.IsProcessRunning; 
-			} 
-		}
 		
 		public bool SupportsStartStop { 
 			get { 
@@ -150,45 +123,11 @@ namespace ICSharpCode.SharpDevelop.Services
 			} 
 		}
 		
-		public void StartWithoutDebugging(System.Diagnostics.ProcessStartInfo psi)
-		{
-			NDebugger.StartWithoutDebugging(psi);
-		}
-		
-		public void Start(string fileName, string workingDirectory, string arguments)
-		{
-			NDebugger.Start(fileName, workingDirectory, arguments);
-		}
-		
 		public void Stop()
 		{
-			NDebugger.Terminate();
-		}
-		
-		public void Break()
-		{
-			NDebugger.Break();
-		}
-		
-		public void StepInto()
-		{
-			NDebugger.StepInto();
-		}
-		
-		public void StepOver()
-		{
-			NDebugger.StepOver();
-		}
-		
-		public void StepOut()
-		{
-			NDebugger.StepOut();
-		}
-		
-		public void Continue()
-		{
-			NDebugger.Continue();
+			this.Terminate();
 		}
+
 		#endregion
 		
 
@@ -204,36 +143,44 @@ namespace ICSharpCode.SharpDevelop.Services
 			}
 		}
 
-		public void RestoreSharpdevelopBreakpoint(object sender, BreakpointEventArgs e)
+		protected override void OnBreakpointStateChanged(object sender, BreakpointEventArgs e)
 		{
-			ICSharpCode.Core.Breakpoint sdBreakpoint = e.Breakpoint.Tag as ICSharpCode.Core.Breakpoint;
+			RestoreSharpdevelopBreakpoint(e.Breakpoint);
+		}
+
+		public void RestoreSharpdevelopBreakpoint(DebuggerLibrary.Breakpoint breakpoint)
+		{
+			ICSharpCode.Core.Breakpoint sdBreakpoint = breakpoint.Tag as ICSharpCode.Core.Breakpoint;
 			if (sdBreakpoint != null) {
-				sdBreakpoint.IsEnabled  = e.Breakpoint.Enabled;
-				sdBreakpoint.FileName   = e.Breakpoint.SourcecodeSegment.SourceFullFilename;
-				sdBreakpoint.LineNumber = e.Breakpoint.SourcecodeSegment.StartLine;
+				sdBreakpoint.IsEnabled  = breakpoint.Enabled;
+				sdBreakpoint.FileName   = breakpoint.SourcecodeSegment.SourceFullFilename;
+				sdBreakpoint.LineNumber = breakpoint.SourcecodeSegment.StartLine;
 			}
 		}
 		
 		// Output messages that report status of debugger
-		void DebuggerTraceMessage(object sender, MessageEventArgs e)
+		protected override void OnDebuggerTraceMessage(string message)
 		{
+			base.OnDebuggerTraceMessage(message);
 			if (messageViewCategoryDebuggerLog != null) {
-				messageViewCategoryDebuggerLog.AppendText(e.Message + "\n");
-				System.Console.WriteLine(e.Message);
+				messageViewCategoryDebuggerLog.AppendText(message + "\n");
+				System.Console.WriteLine(message);
 			}
 		}
-		
+
 		// Output messages form debuged program that are caused by System.Diagnostics.Trace.WriteLine(), etc...
-		void LogMessage(object sender, MessageEventArgs e)
+		protected override void OnLogMessage(string message)
 		{
-			DebuggerTraceMessage(this, e);
+			base.OnLogMessage(message);
+			OnDebuggerTraceMessage(message);
 			if (messageViewCategoryDebug != null) {
-				messageViewCategoryDebug.AppendText(e.Message + "\n");
+				messageViewCategoryDebug.AppendText(message + "\n");
 			}
 		}
 		
-		void DebuggingStarted(object sender, DebuggerEventArgs e)
+		protected override void OnDebuggingStarted()
 		{
+			base.OnDebuggingStarted();
 			// Initialize 
 			/*PadDescriptor cmv = (CompilerMessageView)WorkbenchSingleton.Workbench.GetPad(typeof(CompilerMessageView));
 			if (messageViewCategoryDebug == null) {	
@@ -247,11 +194,12 @@ namespace ICSharpCode.SharpDevelop.Services
 			messageViewCategoryDebuggerLog.ClearText();*/
 		}
 
-		void DebuggingPaused(object sender, DebuggingPausedEventArgs e)
+		protected override void OnDebuggingPaused(PausedReason reason)
 		{
-			if (e.Reason == PausedReason.Exception) {
-				exceptionHistory.Add(NDebugger.CurrentThread.CurrentException);
-				if (NDebugger.CurrentThread.CurrentException.ExceptionType != ExceptionType.DEBUG_EXCEPTION_UNHANDLED && (NDebugger.CatchHandledExceptions == false)) {
+			base.OnDebuggingPaused(reason);
+			if (reason == PausedReason.Exception) {
+				exceptionHistory.Add(CurrentThread.CurrentException);
+				if (CurrentThread.CurrentException.ExceptionType != ExceptionType.DEBUG_EXCEPTION_UNHANDLED && (CatchHandledExceptions == false)) {
 					// Ignore the exception
 					Continue();
 					return;
@@ -261,10 +209,10 @@ namespace ICSharpCode.SharpDevelop.Services
 				//MessageBox.Show("Exception was thrown in debugee:\n" + NDebugger.CurrentThread.CurrentException.ToString());
 				ExceptionForm form = new ExceptionForm();
 				form.label.Text = "Exception " + 
-				                  NDebugger.CurrentThread.CurrentException.Type +
+				                  CurrentThread.CurrentException.Type +
                                   " was thrown in debugee:\n" +
-				                  NDebugger.CurrentThread.CurrentException.Message;
-				form.pictureBox.Image = ResourceService.GetBitmap((NDebugger.CurrentThread.CurrentException.ExceptionType != ExceptionType.DEBUG_EXCEPTION_UNHANDLED)?"Icons.32x32.Warning":"Icons.32x32.Error");
+				                  CurrentThread.CurrentException.Message;
+				form.pictureBox.Image = ResourceService.GetBitmap((CurrentThread.CurrentException.ExceptionType != ExceptionType.DEBUG_EXCEPTION_UNHANDLED)?"Icons.32x32.Warning":"Icons.32x32.Error");
 				form.ShowDialog(ICSharpCode.SharpDevelop.Gui.WorkbenchSingleton.MainForm);
 				switch (form.result) {
 					case ExceptionForm.Result.Break: 
@@ -280,20 +228,22 @@ namespace ICSharpCode.SharpDevelop.Services
 			}
 			
 			try {
-				SelectThread(NDebugger.CurrentThread);
+				SelectThread(CurrentThread);
 			} catch (CurrentThreadNotAviableException) {}
 			JumpToCurrentLine();
 		}
 		
-		void DebuggingResumed(object sender, DebuggerEventArgs e)
+		protected override void OnDebuggingResumed()
 		{
+			base.OnDebuggingResumed();
 			selectedThread = null;
 			selectedFunction = null;
 			DebuggerService.RemoveCurrentLineMarker();
 		}
 		
-		void DebuggingStopped(object sender, DebuggerEventArgs e)
+		protected override void OnDebuggingStopped()
 		{
+			base.OnDebuggingStopped();
 			exceptionHistory.Clear();
 			//DebuggerService.Stop();//TODO: delete
 		}
@@ -337,8 +287,9 @@ namespace ICSharpCode.SharpDevelop.Services
 			}
 		}
 		
-		public void DebuggerStateChanged(object sender, DebuggerEventArgs e)
+		protected override void OnIsProcessRunningChanged()
 		{
+			base.OnIsProcessRunningChanged();
 			UpdateToolbars();
 		}
 		
@@ -355,8 +306,8 @@ namespace ICSharpCode.SharpDevelop.Services
 		/// </summary>
 		public string GetValueAsString(string variableName)
 		{
-			if (!NDebugger.IsDebugging || NDebugger.IsProcessRunning) return null;
-			VariableCollection collection = NDebugger.LocalVariables;
+			if (!IsDebugging || IsProcessRunning) return null;
+			VariableCollection collection = LocalVariables;
 			if (collection == null)
 				return null;
 			foreach (Variable v in collection) {

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

@@ -20,28 +20,28 @@ namespace DebuggerLibrary
 		public event BreakpointEventHandler BreakpointStateChanged;
 		public event BreakpointEventHandler BreakpointHit;
 
-		protected void OnBreakpointAdded(Breakpoint breakpoint)
+		protected virtual void OnBreakpointAdded(Breakpoint breakpoint)
 		{
 			if (BreakpointAdded != null) {
 				BreakpointAdded(this, new BreakpointEventArgs(breakpoint));
 			}
 		}
 
-		protected void OnBreakpointRemoved(Breakpoint breakpoint)
+		protected virtual void OnBreakpointRemoved(Breakpoint breakpoint)
 		{
 			if (BreakpointRemoved != null) {
 				BreakpointRemoved(this, new BreakpointEventArgs(breakpoint));
 			}
 		}
 
-		protected void OnBreakpointStateChanged(object sender, BreakpointEventArgs e)
+		protected virtual void OnBreakpointStateChanged(object sender, BreakpointEventArgs e)
 		{
 			if (BreakpointStateChanged != null) {
 				BreakpointStateChanged(this, new BreakpointEventArgs(e.Breakpoint));
 			}
 		}
 
-		protected void OnBreakpointHit(object sender, BreakpointEventArgs e)
+		protected virtual void OnBreakpointHit(object sender, BreakpointEventArgs e)
 		{
 			if (BreakpointHit != null) {
 				BreakpointHit(this, new BreakpointEventArgs(e.Breakpoint));

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

@@ -17,7 +17,8 @@ using DebuggerInterop.Core;
 namespace DebuggerLibrary
 {
 	class ManagedCallback
-	{		
+	{
+		NDebugger debugger = NDebugger.Instance;
 		bool handlingCallback = false;
 		public event CorDebugEvalEventHandler CorDebugEvalCompleted;
 
@@ -31,28 +32,28 @@ namespace DebuggerLibrary
 		void EnterCallback(string name)
 		{
 			handlingCallback = true;
-			NDebugger.IsProcessRunning = false;
-			NDebugger.CurrentThread = null;
-			NDebugger.TraceMessage("Callback: " + name);
+			debugger.IsProcessRunning = false;
+			debugger.CurrentThread = null;
+			debugger.TraceMessage("Callback: " + name);
 		}
 		
 		void ExitCallback_Continue(ICorDebugAppDomain pAppDomain)
 		{
-			NDebugger.Continue(pAppDomain);
+			debugger.Continue(pAppDomain);
 			handlingCallback = false;
 		}
 		
 		void ExitCallback_Continue()
 		{
-			NDebugger.Continue();
+			debugger.Continue();
 			handlingCallback = false;
 		}
 		
 		void ExitCallback_Paused(PausedReason reason)
 		{
 			if (reason != PausedReason.EvalComplete) {
-				NDebugger.OnDebuggingPaused(reason);
-				NDebugger.OnIsProcessRunningChanged();
+				debugger.OnDebuggingPaused(reason);
+				debugger.OnIsProcessRunningChanged();
 			}
 			handlingCallback = false;
 		}
@@ -64,11 +65,11 @@ namespace DebuggerLibrary
 		{
 			EnterCallback("StepComplete");
 
-			NDebugger.CurrentThread = NDebugger.Instance.GetThread(pThread);
+			debugger.CurrentThread = debugger.GetThread(pThread);
 
-			if (NDebugger.CurrentThread.CurrentFunction.Module.SymbolsLoaded == false) {
-				NDebugger.TraceMessage(" - stepping out of code without symbols");
-				NDebugger.StepOut();
+			if (debugger.CurrentThread.CurrentFunction.Module.SymbolsLoaded == false) {
+				debugger.TraceMessage(" - stepping out of code without symbols");
+				debugger.StepOut();
 				return;
 			}
 			
@@ -78,12 +79,12 @@ namespace DebuggerLibrary
 		public void Breakpoint(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, IntPtr pBreakpoint)
 		{
 			EnterCallback("Breakpoint");
-			
-			NDebugger.CurrentThread = NDebugger.Instance.GetThread(pThread);
+
+			debugger.CurrentThread = debugger.GetThread(pThread);
 			
 			ExitCallback_Paused(PausedReason.Breakpoint);
 			
-			foreach (Breakpoint b in NDebugger.Instance.Breakpoints) {
+			foreach (Breakpoint b in debugger.Breakpoints) {
 				if (b.Equals(pBreakpoint)) {
 					b.OnBreakpointHit();
 				}
@@ -101,7 +102,7 @@ namespace DebuggerLibrary
 		{
 			EnterCallback("Break");
 
-			NDebugger.CurrentThread = NDebugger.Instance.GetThread(pThread);
+			debugger.CurrentThread = debugger.GetThread(pThread);
 
 			ExitCallback_Paused(PausedReason.Break);
 		}
@@ -149,8 +150,8 @@ namespace DebuggerLibrary
 		public void LogMessage(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, int lLevel, string pLogSwitchName, string pMessage)
 		{
 			EnterCallback("LogMessage");
-			
-			NDebugger.OnLogMessage(pMessage);
+
+			debugger.OnLogMessage(pMessage);
 
 			ExitCallback_Continue(pAppDomain);
 		}
@@ -220,7 +221,7 @@ namespace DebuggerLibrary
 		{
 			EnterCallback("LoadModule");
 
-			NDebugger.Instance.AddModule(pModule);
+			debugger.AddModule(pModule);
 
 			ExitCallback_Continue(pAppDomain);
 		}
@@ -236,7 +237,7 @@ namespace DebuggerLibrary
 			if (pThread != null)
 			{
 				EnterCallback("NameChange: pThread");
-				Thread thread = NDebugger.Instance.GetThread(pThread);
+				Thread thread = debugger.GetThread(pThread);
 				thread.HasBeenLoaded = true;
 				thread.OnThreadStateChanged();
 				ExitCallback_Continue();
@@ -247,11 +248,11 @@ namespace DebuggerLibrary
 		public void CreateThread(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread)
 		{
 			EnterCallback("CreateThread");
-			
-			NDebugger.Instance.AddThread(pThread);
 
-			if (NDebugger.MainThread == null) {
-				NDebugger.MainThread = NDebugger.Instance.GetThread(pThread);
+			debugger.AddThread(pThread);
+
+			if (debugger.MainThread == null) {
+				debugger.MainThread = debugger.GetThread(pThread);
 			}
 
 			ExitCallback_Continue(pAppDomain);
@@ -279,7 +280,7 @@ namespace DebuggerLibrary
 		{
 			EnterCallback("UnloadModule");
 
-			NDebugger.Instance.RemoveModule(pModule);
+			debugger.RemoveModule(pModule);
 
 			ExitCallback_Continue(pAppDomain);
 		}
@@ -294,16 +295,16 @@ namespace DebuggerLibrary
 		public void ExitThread(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread)
 		{
 			EnterCallback("ExitThread");
-			
-			Thread thread = NDebugger.Instance.GetThread(pThread);
 
-			if (NDebugger.CurrentThread == thread)
-				NDebugger.CurrentThread = null;
-			
-			if (NDebugger.MainThread == thread)
-				NDebugger.MainThread = null;
-			
-			NDebugger.Instance.RemoveThread(thread);
+			Thread thread = debugger.GetThread(pThread);
+
+			if (debugger.CurrentThread == thread)
+				debugger.CurrentThread = null;
+
+			if (debugger.MainThread == thread)
+				debugger.MainThread = null;
+
+			debugger.RemoveThread(thread);
 
 			ExitCallback_Continue(pAppDomain);
 		}
@@ -319,7 +320,7 @@ namespace DebuggerLibrary
 		{
 			EnterCallback("ExitProcess");
 
-			NDebugger.Instance.ResetEnvironment();
+			debugger.ResetEnvironment();
 
 		}
 
@@ -357,8 +358,8 @@ namespace DebuggerLibrary
 			//	return;
 			//}
 
-			NDebugger.CurrentThread = NDebugger.Instance.GetThread(pThread);
-			NDebugger.CurrentThread.CurrentExceptionType = (ExceptionType)dwEventType;
+			debugger.CurrentThread = debugger.GetThread(pThread);
+			debugger.CurrentThread.CurrentExceptionType = (ExceptionType)dwEventType;
 
 			ExitCallback_Paused(PausedReason.Exception);
 		}

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

@@ -15,10 +15,13 @@ namespace DebuggerLibrary
 {
 	public partial class NDebugger
 	{
-		static NDebugger instance = new NDebugger();
+		static NDebugger instance = null;
 
 		public static NDebugger Instance {
 			get {
+				if (instance == null) {
+					throw new System.Exception("Create instance of NDebugger first");
+				}
 				return instance;
 			}
 			set {
@@ -26,21 +29,21 @@ namespace DebuggerLibrary
 			}
 		}
 
-		static ICorDebug                  corDebug;
-		static ManagedCallback            managedCallback;
-		static ManagedCallbackProxy       managedCallbackProxy;
+		ICorDebug                  corDebug;
+		ManagedCallback            managedCallback;
+		ManagedCallbackProxy       managedCallbackProxy;
 
-		static Process                    mainProcess;
+		Process                    mainProcess;
 		
-		public static bool CatchHandledExceptions = false;
+		public bool CatchHandledExceptions = false;
 
-		static internal ICorDebug CorDebug {
+		internal ICorDebug CorDebug {
 			get {
 				return corDebug;
 			}
 		}
 
-		static internal Process CurrentProcess {
+		internal Process CurrentProcess {
 			get {
 				return mainProcess;
 			}
@@ -61,7 +64,7 @@ namespace DebuggerLibrary
 			}
 		}
 
-        internal static ManagedCallback ManagedCallback {
+        internal ManagedCallback ManagedCallback {
 			get {
 				return managedCallback;
 			}
@@ -69,8 +72,14 @@ namespace DebuggerLibrary
 
 		#region Basic functions
 
-		private NDebugger()
+		public NDebugger()
 		{
+			if (instance != null) {
+				throw new System.Exception("You can create only one instance of NDebugger at the moment.");
+			} else {
+				instance = this;
+			}
+
 			InitDebugger();
 			ResetEnvironment();
 
@@ -82,7 +91,7 @@ namespace DebuggerLibrary
 			//corDebug.Terminate();
 		}
 
-		static internal void InitDebugger()
+		internal void InitDebugger()
 		{
             int size;
             NativeMethods.GetCORVersion(null, 0, out size);
@@ -118,29 +127,31 @@ namespace DebuggerLibrary
 
 		#region Public events
 
-		static public event DebuggerEventHandler DebuggingStarted;
+		public event DebuggerEventHandler DebuggingStarted;
 
-		static internal void OnDebuggingStarted()
+		protected internal virtual void OnDebuggingStarted()
 		{
 			TraceMessage ("Debugger event: OnDebuggingStarted()");
-			if (DebuggingStarted != null)
+			if (DebuggingStarted != null) {
 				DebuggingStarted(null, new DebuggerEventArgs());
+			}
 		}
 
 
-		static public event DebuggingPausedEventHandler DebuggingPaused;
+		public event DebuggingPausedEventHandler DebuggingPaused;
 
-		static internal void OnDebuggingPaused(PausedReason reason)
+		protected internal virtual void OnDebuggingPaused(PausedReason reason)
 		{
 			TraceMessage ("Debugger event: OnDebuggingPaused(" + reason.ToString() + ")");
-			if (DebuggingPaused != null)
+			if (DebuggingPaused != null) {
 				DebuggingPaused(null, new DebuggingPausedEventArgs(reason));
+			}
 		}
 
 
-		static public event DebuggingIsResumingEventHandler DebuggingIsResuming;
+		public event DebuggingIsResumingEventHandler DebuggingIsResuming;
 
-		static internal void OnDebuggingIsResuming(ref bool abort)
+		protected internal virtual void OnDebuggingIsResuming(ref bool abort)
 		{
 			if (DebuggingIsResuming != null) {
 				TraceMessage ("Debugger event: OnDebuggingIsResuming(" + abort.ToString() + ")");
@@ -156,66 +167,77 @@ namespace DebuggerLibrary
 		}
 
 
-		static public event DebuggerEventHandler DebuggingResumed;
+		public event DebuggerEventHandler DebuggingResumed;
 
-		static internal void OnDebuggingResumed()
+		protected internal virtual void OnDebuggingResumed()
 		{
 			TraceMessage ("Debugger event: OnDebuggingResumed()");
-			if (DebuggingResumed != null)
+			if (DebuggingResumed != null) {
 				DebuggingResumed(null, new DebuggerEventArgs());
+			}
 		}
 
 
-		static public event DebuggerEventHandler DebuggingStopped;
+		public event DebuggerEventHandler DebuggingStopped;
 
-		static internal void OnDebuggingStopped()
+		protected internal virtual void OnDebuggingStopped()
 		{
 			TraceMessage ("Debugger event: OnDebuggingStopped()");
-			if (DebuggingStopped != null)
+			if (DebuggingStopped != null) {
 				DebuggingStopped(null, new DebuggerEventArgs());
+			}
 		}
 
 
-		static public event DebuggerEventHandler IsProcessRunningChanged;
+		public event DebuggerEventHandler IsProcessRunningChanged;
 
-		static internal void OnIsProcessRunningChanged()
+		protected internal virtual void OnIsProcessRunningChanged()
 		{
 			TraceMessage ("Debugger event: OnIsProcessRunningChanged()");
-			if (IsProcessRunningChanged != null)
+			if (IsProcessRunningChanged != null) {
 				IsProcessRunningChanged(null, new DebuggerEventArgs());
+			}
 		}
 
 		
-		static public event DebuggerEventHandler IsDebuggingChanged;
+		public event DebuggerEventHandler IsDebuggingChanged;
 
-		static internal void OnIsDebuggingChanged()
+		protected internal virtual void OnIsDebuggingChanged()
 		{
 			TraceMessage ("Debugger event: OnIsDebuggingChanged()");
-			if (IsDebuggingChanged != null)
+			if (IsDebuggingChanged != null) {
 				IsDebuggingChanged(null, new DebuggerEventArgs());
+			}
 		}
 
 		/// <summary>
 		/// Fired when System.Diagnostics.Trace.WriteLine() is called in debuged process
 		/// </summary>
-		static public event MessageEventHandler LogMessage;
+		public event MessageEventHandler LogMessage;
 
-		static internal void OnLogMessage(string message)
+		protected internal virtual void OnLogMessage(string message)
 		{
 			TraceMessage ("Debugger event: OnLogMessage(\"" + message + "\")");
-			if (LogMessage != null)
+			if (LogMessage != null) {
 				LogMessage(null, new MessageEventArgs(message));
+			}
 		}
 
 		/// <summary>
 		/// Internal: Used to debug the debugger library.
 		/// </summary>
-		static public event MessageEventHandler DebuggerTraceMessage;
+		public event MessageEventHandler DebuggerTraceMessage;
 
-		static internal void TraceMessage(string message)
+		protected internal virtual void OnDebuggerTraceMessage(string message)
 		{
-			if (DebuggerTraceMessage != null)
+			if (DebuggerTraceMessage != null) {
 				DebuggerTraceMessage(null, new MessageEventArgs(message));
+			}
+		}
+
+		internal void TraceMessage(string message)
+		{
+			OnDebuggerTraceMessage(message);
 		}
 
 
@@ -223,14 +245,14 @@ namespace DebuggerLibrary
 
 		#region Execution control
 
-		static internal void Continue(ICorDebugAppDomain pAppDomain)
+		internal void Continue(ICorDebugAppDomain pAppDomain)
 		{
 			ICorDebugProcess outProcess;
 			pAppDomain.GetProcess(out outProcess);
 			outProcess.Continue(0);
 		}
 
-		static public void StartWithoutDebugging(System.Diagnostics.ProcessStartInfo psi)
+		public void StartWithoutDebugging(System.Diagnostics.ProcessStartInfo psi)
 		{		
 			System.Diagnostics.Process process;
 			process = new System.Diagnostics.Process();
@@ -238,7 +260,7 @@ namespace DebuggerLibrary
 			process.Start();
 		}
 		
-		static public void Start(string filename, string workingDirectory, string arguments)		
+		public void Start(string filename, string workingDirectory, string arguments)		
 		{
 			CurrentProcess = Process.CreateProcess(filename, workingDirectory, arguments);
 		}
@@ -274,7 +296,7 @@ namespace DebuggerLibrary
 		}
 
 
-		static public bool IsProcessRunning { 
+		public bool IsProcessRunning { 
 			get {
 				if (!IsDebugging) return false;
 				return CurrentProcess.IsProcessRunning;
@@ -285,13 +307,13 @@ namespace DebuggerLibrary
 			}
 		}
 
-		static public bool IsDebugging {
+		public bool IsDebugging {
 			get {
 				return (CurrentProcess != null);
 			}
 		}
 
-		static public Thread CurrentThread {
+		public Thread CurrentThread {
 			get {
 				if (!IsDebugging) return null;
 				return CurrentProcess.CurrentThread;
@@ -301,7 +323,7 @@ namespace DebuggerLibrary
 			}
 		}
 
-		static public Thread MainThread {
+		public Thread MainThread {
 			get {
 				if (!IsDebugging) return null;
 				return CurrentProcess.MainThread;
@@ -311,46 +333,46 @@ namespace DebuggerLibrary
 			}
 		}
 
-		static public SourcecodeSegment NextStatement { 
+		public SourcecodeSegment NextStatement { 
 			get {
 				if (!IsDebugging) return null;
 				return CurrentProcess.NextStatement;
 			}
 		}
 
-		static public VariableCollection LocalVariables { 
+		public VariableCollection LocalVariables { 
 			get {
 				if (!IsDebugging) return null;
 				return CurrentProcess.LocalVariables;
 			}
 		}
 
-		static public void Break()
+		public void Break()
 		{
 			CurrentProcess.Break();
 		}
 
-		static public void StepInto()
+		public void StepInto()
 		{
 			CurrentProcess.StepInto();
 		}
 
-		static public void StepOver()
+		public void StepOver()
 		{
 			CurrentProcess.StepOver();
 		}
 
-		static public void StepOut()
+		public void StepOut()
 		{
 			CurrentProcess.StepOut();
 		}
 
-		static public void Continue()
+		public void Continue()
 		{
 			CurrentProcess.Continue();
 		}
 
-		static public void Terminate()
+		public void Terminate()
 		{
 			CurrentProcess.Terminate();
 		}

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

@@ -144,7 +144,7 @@ namespace DebuggerLibrary
 			corFrame.CreateStepper(out stepper);
 			stepper.StepOut();
 
-			NDebugger.Continue();
+			NDebugger.Instance.Continue();
 		}
 
 		private unsafe void Step(bool stepIn)
@@ -167,9 +167,9 @@ namespace DebuggerLibrary
 
 			fixed (int* ranges = nextSt.StepRanges) {
 				stepper.StepRange(stepIn?1:0, (IntPtr)ranges, (uint)nextSt.StepRanges.Length / 2);
-			}  
+			}
 
-			NDebugger.Continue();
+			NDebugger.Instance.Continue();
 		}
 		
 		/// <summary>

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

@@ -43,8 +43,8 @@ namespace DebuggerLibrary
 				if (mainThread == null) {
 					mainThread = value;
 				}
-				if (NDebugger.ManagedCallback.HandlingCallback == false) {
-					NDebugger.OnDebuggingPaused(PausedReason.CurrentThreadChanged);
+				if (NDebugger.Instance.ManagedCallback.HandlingCallback == false) {
+					NDebugger.Instance.OnDebuggingPaused(PausedReason.CurrentThreadChanged);
 				}
 			}
 		}
@@ -93,7 +93,7 @@ namespace DebuggerLibrary
 
 		static public unsafe Process StartInternal(string filename, string workingDirectory, string arguments)
 		{
-			NDebugger.TraceMessage("Executing " + filename);
+			NDebugger.Instance.TraceMessage("Executing " + filename);
 
 			_SECURITY_ATTRIBUTES secAttr = new _SECURITY_ATTRIBUTES();
 			secAttr.bInheritHandle = 0;
@@ -108,7 +108,7 @@ namespace DebuggerLibrary
 
 			fixed (uint* pprocessStartupInfo = processStartupInfo)
 				fixed (uint* pprocessInfo = processInfo)
-					NDebugger.CorDebug.CreateProcess(
+					NDebugger.Instance.CorDebug.CreateProcess(
 						filename,   // lpApplicationName
 						arguments,                       // lpCommandLine
 						ref secAttr,                       // lpProcessAttributes
@@ -136,8 +136,8 @@ namespace DebuggerLibrary
             corProcess.Stop(5000); // TODO: Hardcoded value
 
 			isProcessRunning = false;
-			NDebugger.OnDebuggingPaused(PausedReason.Break);
-			NDebugger.OnIsProcessRunningChanged();
+			NDebugger.Instance.OnDebuggingPaused(PausedReason.Break);
+			NDebugger.Instance.OnIsProcessRunningChanged();
 		}
 
 		public void StepInto()
@@ -175,13 +175,13 @@ namespace DebuggerLibrary
 			}
 
 			bool abort = false;
-			NDebugger.OnDebuggingIsResuming(ref abort);
+			NDebugger.Instance.OnDebuggingIsResuming(ref abort);
 			if (abort == true) return;
 
 			isProcessRunning = true;
-			if (NDebugger.ManagedCallback.HandlingCallback == false) {
-				NDebugger.OnDebuggingResumed();
-				NDebugger.OnIsProcessRunningChanged();
+			if (NDebugger.Instance.ManagedCallback.HandlingCallback == false) {
+				NDebugger.Instance.OnDebuggingResumed();
+				NDebugger.Instance.OnIsProcessRunningChanged();
 			}
 
 			corProcess.Continue(0);

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

@@ -62,7 +62,7 @@ namespace DebuggerLibrary
 
 		public bool Suspended {
 			get	{
-				if (NDebugger.IsProcessRunning) return lastSuspendedState;
+				if (NDebugger.Instance.IsProcessRunning) return lastSuspendedState;
 
 				CorDebugThreadState state;
 				corThread.GetDebugState(out state);
@@ -77,7 +77,7 @@ namespace DebuggerLibrary
 		public ThreadPriority Priority {
 			get {
 				if (!HasBeenLoaded) return lastPriority;
-				if (NDebugger.IsProcessRunning) return lastPriority;
+				if (NDebugger.Instance.IsProcessRunning) return lastPriority;
 
 				Variable runTimeVar = RuntimeVariable;
 				if (runTimeVar is NullRefVariable) return ThreadPriority.Normal;
@@ -90,7 +90,7 @@ namespace DebuggerLibrary
 		public Variable RuntimeVariable {
 			get {
 				if (!HasBeenLoaded) throw new UnableToGetPropertyException(this, "runtimeVariable", "Thread has not started jet");
-				if (NDebugger.IsProcessRunning) throw new UnableToGetPropertyException(this, "runtimeVariable", "Process is running");
+				if (NDebugger.Instance.IsProcessRunning) throw new UnableToGetPropertyException(this, "runtimeVariable", "Process is running");
 				ICorDebugValue corValue;
 				corThread.GetObject(out corValue);
 				return VariableFactory.CreateVariable(corValue, "Thread" + ID);
@@ -101,7 +101,7 @@ namespace DebuggerLibrary
 		public string Name {
 			get	{
 				if (!HasBeenLoaded) return lastName;
-				if (NDebugger.IsProcessRunning) return lastName;
+				if (NDebugger.Instance.IsProcessRunning) return lastName;
 				Variable runtimeVar  = RuntimeVariable;
 				if (runtimeVar is NullRefVariable) return lastName;
 				Variable runtimeName = runtimeVar.SubVariables["m_Name"];
@@ -137,8 +137,8 @@ namespace DebuggerLibrary
 			get {
 				List<Function> callstack = new List<Function>();
 
-				if (!NDebugger.IsDebugging)     return callstack;
-				if (NDebugger.IsProcessRunning) return callstack;
+				if (!NDebugger.Instance.IsDebugging) return callstack;
+				if (NDebugger.Instance.IsProcessRunning) return callstack;
 
 				ICorDebugChainEnum corChainEnum;
 				corThread.EnumerateChains(out corChainEnum);
@@ -177,7 +177,7 @@ namespace DebuggerLibrary
 		
 		public Function CurrentFunction {
 			get {
-				if (NDebugger.IsProcessRunning) throw new CurrentFunctionNotAviableException();
+				if (NDebugger.Instance.IsProcessRunning) throw new CurrentFunctionNotAviableException();
 				ICorDebugFrame corFrame;
 				corThread.GetActiveFrame(out corFrame);
 				if (corFrame == null) {

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

@@ -32,7 +32,7 @@ namespace DebuggerLibrary
 		{
 			this.corFunction = corFunction;
 			this.args = args;
-			NDebugger.ManagedCallback.CorDebugEvalCompleted += new CorDebugEvalEventHandler(CorDebugEvalCompleted);
+			NDebugger.Instance.ManagedCallback.CorDebugEvalCompleted += new CorDebugEvalEventHandler(CorDebugEvalCompleted);
 		}
 		
 		/// <summary>
@@ -53,15 +53,15 @@ namespace DebuggerLibrary
 		/// </summary>
 		public void AsyncPerformEval()
 		{
-			if (NDebugger.IsProcessRunning) {
+			if (NDebugger.Instance.IsProcessRunning) {
 				throw new DebuggerException("Debugger must be paused");
 			}
 
-			NDebugger.CurrentThread.CorThread.CreateEval(out corEval);
+			NDebugger.Instance.CurrentThread.CorThread.CreateEval(out corEval);
 			
 			corEval.CallFunction(corFunction, (uint)args.Length, args);
-			
-			NDebugger.Continue();
+
+			NDebugger.Instance.Continue();
 		}
 		
 		public ICorDebugValue GetResult()

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

@@ -32,7 +32,7 @@ namespace DebuggerLibrary
 		
 		static public void PerformNextEval()
 		{
-			if (NDebugger.IsProcessRunning) {
+			if (NDebugger.Instance.IsProcessRunning) {
 				return;
 			}
 			if (waitingEvals.Count == 0) {