void AddBreakEvent(BreakEvent be)
{
object handle = null;
try {
handle = OnInsertBreakEvent(be, be.Enabled);
} catch (Exception ex) {
Breakpoint bp = be as Breakpoint;
if (bp != null)
{
OnDebuggerOutput(false, "Could not set breakpoint at location '" + bp.FileName + ":" + bp.Line + "' (" + ex.Message + ")\n");
}
else
{
OnDebuggerOutput(false, "Could not set catchpoint for exception '" + ((Catchpoint)be).ExceptionName + "' (" + ex.Message + ")\n");
}
HandleException(ex);
return;
}
lock (breakpoints) {
SetBreakEventHandle(be, handle);
Breakpoints.NotifyStatusChanged(be);
}
}
internal protected void NotifySourceFileUnloaded(string fullFilePath)
{
List <BreakEvent> toUpdate = new List <BreakEvent> ();
lock (breakpoints) {
// Make a copy of the breakpoints table since it can be modified while iterating
Dictionary <BreakEvent, BreakEventInfo> breakpointsCopy = new Dictionary <BreakEvent, BreakEventInfo> (breakpoints);
foreach (KeyValuePair <BreakEvent, BreakEventInfo> bps in breakpointsCopy)
{
Breakpoint bp = bps.Key as Breakpoint;
if (bp != null && bps.Value.Handle != null)
{
if (System.IO.Path.GetFullPath(bp.FileName) == fullFilePath)
{
toUpdate.Add(bp);
}
}
}
foreach (BreakEvent be in toUpdate)
{
SetBreakEventHandle(be, null);
Breakpoints.NotifyStatusChanged(be);
}
}
}
/// <summary>
/// This method can be used by subclasses to set the validity of a breakpoint.
/// </summary>
protected void SetBreakEventStatus(BreakEvent be, bool isValid)
{
lock (breakpoints) {
BreakEventInfo bi;
if (!breakpoints.TryGetValue(be, out bi))
{
bi = new BreakEventInfo(null);
}
if (bi.IsValid != isValid)
{
bi.IsValid = isValid;
breakpoints [be] = bi;
Breakpoints.NotifyStatusChanged(be);
}
}
}
void UpdateBreakEvent(BreakEvent be)
{
lock (breakpoints) {
object handle;
if (GetBreakpointHandle(be, out handle))
{
if (handle != null)
{
object newHandle = OnUpdateBreakEvent(handle, be);
if (newHandle != handle && (newHandle == null || !newHandle.Equals(handle)))
{
// Update the handle if it has changed, and notify the status change
SetBreakEventHandle(be, newHandle);
}
Breakpoints.NotifyStatusChanged(be);
}
else
{
// Try inserting the breakpoint again
try {
handle = OnInsertBreakEvent(be, be.Enabled);
if (handle != null)
{
// This time worked
SetBreakEventHandle(be, handle);
Breakpoints.NotifyStatusChanged(be);
}
} catch (Exception ex) {
Breakpoint bp = be as Breakpoint;
if (bp != null)
{
OnDebuggerOutput(false, "Could not set breakpoint at location '" + bp.FileName + ":" + bp.Line + " (" + ex.Message + ")\n");
}
else
{
OnDebuggerOutput(false, "Could not set catchpoint for exception '" + ((Catchpoint)be).ExceptionName + "' (" + ex.Message + ")\n");
}
HandleException(ex);
}
}
}
}
}
internal protected void OnTargetEvent(TargetEventArgs args)
{
currentProcesses = null;
if (args.Process != null)
{
args.Process.Attach(this);
}
if (args.Thread != null)
{
args.Thread.Attach(this);
activeThread = args.Thread;
}
if (args.Backtrace != null)
{
args.Backtrace.Attach(this);
}
switch (args.Type)
{
case TargetEventType.ExceptionThrown:
lock (slock) {
isRunning = false;
}
if (TargetExceptionThrown != null)
{
TargetExceptionThrown(this, args);
}
break;
case TargetEventType.TargetExited:
lock (slock) {
isRunning = false;
started = false;
foreach (BreakEvent bp in Breakpoints)
{
Breakpoints.NotifyStatusChanged(bp);
}
}
if (TargetExited != null)
{
TargetExited(this, args);
}
break;
case TargetEventType.TargetHitBreakpoint:
lock (slock) {
isRunning = false;
}
if (TargetHitBreakpoint != null)
{
TargetHitBreakpoint(this, args);
}
break;
case TargetEventType.TargetInterrupted:
lock (slock) {
isRunning = false;
}
if (TargetInterrupted != null)
{
TargetInterrupted(this, args);
}
break;
case TargetEventType.TargetSignaled:
lock (slock) {
isRunning = false;
}
if (TargetSignaled != null)
{
TargetSignaled(this, args);
}
break;
case TargetEventType.TargetStopped:
lock (slock) {
isRunning = false;
}
if (TargetStopped != null)
{
TargetStopped(this, args);
}
break;
case TargetEventType.UnhandledException:
lock (slock) {
isRunning = false;
}
if (TargetUnhandledException != null)
{
TargetUnhandledException(this, args);
}
break;
}
if (TargetEvent != null)
{
TargetEvent(this, args);
}
}
