bool OnStep(StepEventRequest stepReq) {
debuggerThread.VerifyAccess();
if (stepReq == null)
return false;
bool b = toStepper.TryGetValue(stepReq, out var info);
Debug.Assert(b);
if (!b)
return false;
toStepper.Remove(stepReq);
stepReq.Disable();
return info.OnStep(new StepCompleteEventArgs(stepReq, false, false));
}
private void HandleStep(StepEvent stepEvent)
{
if (currentStepRequest != null)
{
currentStepRequest.Enabled = false;
currentStepRequest = null;
}
_engine.Callback.StepCompleted(_mainThread);
logger.Trace("Stepping: {0}:{1}", stepEvent.Method.Name, stepEvent.Location);
isStepping = false;
}
internal void CancelStepper(StepEventRequest stepReq)
{
debuggerThread.VerifyAccess();
if (stepReq != null)
{
try {
using (TempBreak())
stepReq.Disable();
}
catch {
}
}
}
internal void Step(AD7Thread thread, enum_STEPKIND sk, enum_STEPUNIT stepUnit)
{
DebugHelper.TraceEnteringMethod();
if (!_isStepping)
{
if (currentStepRequest == null)
{
currentStepRequest = _vm.CreateStepRequest(thread.ThreadMirror);
}
else
{
currentStepRequest.Disable();
}
_isStepping = true;
if (stepUnit == enum_STEPUNIT.STEP_LINE || stepUnit == enum_STEPUNIT.STEP_STATEMENT)
{
switch (sk)
{
case enum_STEPKIND.STEP_INTO:
currentStepRequest.Depth = StepDepth.Into;
break;
case enum_STEPKIND.STEP_OUT:
currentStepRequest.Depth = StepDepth.Out;
break;
case enum_STEPKIND.STEP_OVER:
currentStepRequest.Depth = StepDepth.Over;
break;
default:
return;
}
}
else if (stepUnit == enum_STEPUNIT.STEP_INSTRUCTION)
{
//TODO: by techcap
}
else
{
throw new NotImplementedException();
}
currentStepRequest.Size = StepSize.Line;
currentStepRequest.Enable();
}
ResumeVM();
}
private void HandleStep(StepEvent stepEvent)
{
DebugHelper.TraceEnteringMethod();
if (currentStepRequest != null)
{
currentStepRequest.Enabled = false;
currentStepRequest = null;
}
_engine.Callback.StepCompleted(GetThread(stepEvent));
logger.Trace("Stepping: {0}:{1}", stepEvent.Method.Name, stepEvent.Location);
_isStepping = false;
}
internal void CancelStepper(StepEventRequest stepReq) {
debuggerThread.VerifyAccess();
if (stepReq != null) {
try {
using (TempBreak())
stepReq.Disable();
}
catch {
}
if (toStepper.TryGetValue(stepReq, out var info)) {
toStepper.Remove(stepReq);
info.OnStep(new StepCompleteEventArgs(stepReq, false, true));
}
}
}
void SaveStepper(StepEventRequest newMonoStepper, object tag, bool callRunCore)
{
engine.VerifyMonoDebugThread();
if (newMonoStepper != null)
{
stepData = new StepData(tag, newMonoStepper);
if (callRunCore)
{
engine.RunCore();
}
}
else
{
// This should rarely if ever happen so the string doesn't need to be localized
RaiseStepComplete(thread, tag, "Could not step");
}
}
protected override void OnNextLine()
{
ThreadPool.QueueUserWorkItem(delegate {
Adaptor.CancelAsyncOperations(); // This call can block, so it has to run in background thread to avoid keeping the main session lock
var req = vm.CreateStepRequest(current_thread);
req.Depth = StepDepth.Over;
req.Size = StepSize.Line;
if (assemblyFilters != null && assemblyFilters.Count > 0)
{
req.AssemblyFilter = assemblyFilters;
}
req.Enabled = true;
currentStepRequest = req;
OnResumed();
vm.Resume();
DequeueEventsForFirstThread();
});
}
internal void Step(MonoThread thread, enum_STEPKIND sk)
{
if (isStepping)
{
return;
}
if (currentStepRequest == null)
{
currentStepRequest = _vm.CreateStepRequest(thread.ThreadMirror);
}
else
{
currentStepRequest.Disable();
}
isStepping = true;
switch (sk)
{
case enum_STEPKIND.STEP_INTO:
currentStepRequest.Depth = StepDepth.Into;
break;
case enum_STEPKIND.STEP_OUT:
currentStepRequest.Depth = StepDepth.Out;
break;
case enum_STEPKIND.STEP_OVER:
currentStepRequest.Depth = StepDepth.Over;
break;
default:
return;
}
currentStepRequest.Size = StepSize.Line;
currentStepRequest.Enable();
_vm.Resume();
}
public StepCompleteEventArgs(StepEventRequest stepEventRequest, bool forciblyCanceled)
{
StepEventRequest = stepEventRequest;
ForciblyCanceled = forciblyCanceled;
}
void HandleEvent(Event e, bool dequeuing)
{
if (dequeuing && exited)
{
return;
}
bool resume = true;
ObjectMirror exception = null;
TargetEventType etype = TargetEventType.TargetStopped;
#if DEBUG_EVENT_QUEUEING
if (!(e is TypeLoadEvent))
{
Console.WriteLine("pp event: " + e);
}
#endif
OnHandleEvent(e);
if (e is AssemblyLoadEvent)
{
AssemblyLoadEvent ae = (AssemblyLoadEvent)e;
bool isExternal = !UpdateAssemblyFilters(ae.Assembly) && userAssemblyNames != null;
string flagExt = isExternal? " [External]" : "";
OnDebuggerOutput(false, string.Format("Loaded assembly: {0}{1}\n", ae.Assembly.Location, flagExt));
}
if (e is AssemblyUnloadEvent)
{
AssemblyUnloadEvent aue = (AssemblyUnloadEvent)e;
// Mark affected breakpoints as pending again
List <KeyValuePair <EventRequest, BreakInfo> > affectedBreakpoints = new List <KeyValuePair <EventRequest, BreakInfo> > (
breakpoints.Where(x => (x.Value.Location.Method.DeclaringType.Assembly.Location.Equals(aue.Assembly.Location, StringComparison.OrdinalIgnoreCase)))
);
foreach (KeyValuePair <EventRequest, BreakInfo> breakpoint in affectedBreakpoints)
{
OnDebuggerOutput(false, string.Format("Re-pending breakpoint at {0}:{1}\n",
Path.GetFileName(breakpoint.Value.Location.SourceFile),
breakpoint.Value.Location.LineNumber));
breakpoints.Remove(breakpoint.Key);
pending_bes.Add(breakpoint.Value.BreakEvent);
}
// Remove affected types from the loaded types list
List <string> affectedTypes = new List <string>();
foreach (var pair in types)
{
try {
if (!pair.Value.Assembly.Location.Equals(aue.Assembly.Location, StringComparison.OrdinalIgnoreCase))
{
continue;
}
} catch {
}
affectedTypes.Add(pair.Key);
}
foreach (string typename in affectedTypes)
{
types.Remove(typename);
}
foreach (var pair in source_to_type)
{
pair.Value.RemoveAll(delegate(TypeMirror mirror){
try {
return(mirror.Assembly.Location.Equals(aue.Assembly.Location, StringComparison.OrdinalIgnoreCase));
} catch {
}
return(true);
});
}
OnDebuggerOutput(false, string.Format("Unloaded assembly: {0}\n", aue.Assembly.Location));
}
if (e is VMStartEvent)
{
//HACK: 2.6.1 VM doesn't emit type load event, so work around it
var t = vm.RootDomain.Corlib.GetType("System.Exception", false, false);
if (t != null)
{
ResolveBreakpoints(t);
}
OnVMStartEvent((VMStartEvent)e);
}
if (e is TypeLoadEvent)
{
var t = ((TypeLoadEvent)e).Type;
string typeName = t.FullName;
// if (types.ContainsKey(typeName)) {
// if (typeName != "System.Exception")
// LoggingService.LogError("Type '" + typeName + "' loaded more than once", null);
// }
ResolveBreakpoints(t);
}
if (e is BreakpointEvent)
{
BreakpointEvent be = (BreakpointEvent)e;
if (!HandleBreakpoint(e.Thread, be.Request))
{
etype = TargetEventType.TargetHitBreakpoint;
resume = false;
}
}
if (e is ExceptionEvent)
{
etype = TargetEventType.ExceptionThrown;
var ev = (ExceptionEvent)e;
exception = ev.Exception;
if (ev.Request != unhandledExceptionRequest || exception.Type.FullName != "System.Threading.ThreadAbortException")
{
resume = false;
}
}
if (e is StepEvent)
{
etype = TargetEventType.TargetStopped;
resume = false;
}
if (e is ThreadStartEvent)
{
ThreadStartEvent ts = (ThreadStartEvent)e;
OnDebuggerOutput(false, string.Format("Thread started: {0}\n", ts.Thread.Name));
}
if (resume)
{
vm.Resume();
}
else
{
if (currentStepRequest != null)
{
currentStepRequest.Enabled = false;
currentStepRequest = null;
}
current_thread = recent_thread = e.Thread;
TargetEventArgs args = new TargetEventArgs(etype);
args.Process = OnGetProcesses() [0];
args.Thread = GetThread(args.Process, current_thread);
args.Backtrace = GetThreadBacktrace(current_thread);
if (exception != null)
{
activeExceptionsByThread [current_thread.Id] = exception;
}
OnTargetEvent(args);
}
}
public StepData(object tag, StepEventRequest monoStepper)
{
Tag = tag;
MonoStepper = monoStepper;
}
