/**
* create a stepper object relative to the active frame in this thread.
*/
public CorStepper CreateStepper()
{
ICorDebugStepper s = null;
m_th.CreateStepper(out s);
return(new CorStepper(s));
}
internal SourceStepper(RuntimeThread thread, ICorDebugStepper comStepper)
{
_thread = thread;
_comStepper = comStepper;
_comStepper.SetRangeIL(1);
_comStepper.SetUnmappedStopMask(CorDebugUnmappedStop.STOP_NONE);
}
internal SourceStepper GetStepper(ICorDebugStepper pStepper)
{
SourceStepper stepper;
_steppers.TryGetValue(pStepper, out stepper);
return(stepper);
}
internal SourceStepper(RuntimeThread thread, ICorDebugStepper comStepper)
{
_thread = thread;
_comStepper = comStepper;
_comStepper.SetRangeIL(1);
_comStepper.SetUnmappedStopMask(CorDebugUnmappedStop.STOP_NONE);
}
public StepCompleteDebugCallbackEventArgs(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugStepper pStepper, CorDebugStepReason reason)
: base(pAppDomain)
{
AppDomain = pAppDomain;
Thread = pThread;
Stepper = pStepper;
Reason = reason;
}
protected internal virtual void OnStepComplete(CorDebugStepReason reason)
{
this.corStepper = null;
if (StepComplete != null)
{
StepComplete(this, new StepperEventArgs(this, reason));
}
}
internal Stepper GetStepper(ICorDebugStepper corStepper)
{
foreach(Stepper stepper in this.Steppers) {
if (stepper.IsCorStepper(corStepper)) {
return stepper;
}
}
throw new DebuggerException("Stepper is not in collection");
}
int ICorDebugThread.CreateStepper(out ICorDebugStepper ppStepper)
{
Debug.Assert(!IsVirtualThread);
ICorDebugFrame frame;
((ICorDebugThread)this).GetActiveFrame(out frame);
ppStepper = new CorDebugStepper((CorDebugFrame)frame);
return(Utility.COM_HResults.S_OK);
}
public Stepper(Function function)
{
this.function = function;
corStepper = function.CorILFrame.CreateStepper();
JustMyCode = true;
function.Thread.Steppers.Add(this);
}
public CorStepper CreateStepper()
{
ICorDebugStepper istepper = null;
try
{
m_frame.CreateStepper(out istepper);
}
catch { }
return(istepper == null ? null : new CorStepper(istepper));
}
//
// IEnumerator interface
//
#region IEnumerator Members
public bool MoveNext()
{
var a = new ICorDebugStepper[1];
uint c = 0;
int r = m_enum.Next((uint) a.Length, a, out c);
if (r == 0 && c == 1) // S_OK && we got 1 new element
m_step = new CorStepper(a[0]);
else
m_step = null;
return m_step != null;
}
void ICorDebugManagedCallback.StepComplete(
ICorDebugAppDomain appDomain,
ICorDebugThread thread,
ICorDebugStepper stepper,
CorDebugStepReason stepReason)
{
if (DebugOutput)
{
Console.WriteLine("info: StepComplete");
}
appDomain.Continue(0);
}
public void StepComplete(
ICorDebugAppDomain appDomain,
ICorDebugThread thread,
ICorDebugStepper step,
CorDebugStepReason reason)
{
m_delegate.OnStepComplete(
new StepCompleteEventArgs(
new DebuggedAppDomain(appDomain),
new DebuggedThread(thread),
new Stepper(step),
reason));
}
private Stepper(StackFrame stackFrame, StepperOperation operation, int[] stepRanges, string name, bool justMyCode)
{
this.stackFrame = stackFrame;
this.operation = operation;
this.stepRanges = stepRanges;
this.name = name;
this.corStepper = stackFrame.CorILFrame.CreateStepper();
this.ignore = false;
this.StackFrame.Process.Steppers.Add(this);
if (justMyCode) {
corStepper.SetUnmappedStopMask(CorDebugUnmappedStop.STOP_NONE);
((ICorDebugStepper2)corStepper).SetJMC(1);
}
}
//
// IEnumerator interface
//
public bool MoveNext()
{
ICorDebugStepper[] a = new ICorDebugStepper[1];
uint c = 0;
int r = m_enum.Next((uint)a.Length, a, out c);
if (r == 0 && c == 1) // S_OK && we got 1 new element
{
m_step = new CorStepper(a[0]);
}
else
{
m_step = null;
}
return(m_step != null);
}
private Stepper(StackFrame stackFrame, StepperOperation operation, int[] stepRanges, string name, bool justMyCode)
{
this.stackFrame = stackFrame;
this.operation = operation;
this.stepRanges = stepRanges;
this.name = name;
this.corStepper = stackFrame.CorILFrame.CreateStepper();
this.ignore = false;
this.StackFrame.Thread.Steppers.Add(this);
if (justMyCode)
{
corStepper.SetUnmappedStopMask(CorDebugUnmappedStop.STOP_NONE);
corStepper.CastTo <ICorDebugStepper2>().SetJMC(1);
}
}
internal Stepper GetStepper(ICorDebugStepper corStepper)
{
foreach(Stepper stepper in this.Steppers) {
if (stepper.IsCorStepper(corStepper)) {
return stepper;
}
}
throw new DebuggerException("Stepper is not in collection");
}
public void StepComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugStepper pStepper, CorDebugStepReason reason)
{
try
{
_EnterCallback();
_UpdateActiveThread(pThread);
bool _isspecial;
lock (dbgproc)
{
_isspecial = _IsSourceAtSpecialPosition_unlocked();
}
if (_isspecial)
{
dbgproc._StepDirect(false, false);
return; // Don't fire this callback event; fire the next one.
}
lock (dbgproc)
{
#if DEBUG
if (!dbgproc.IsStepping)
{
dbgproc.dout.WriteLine("DEBUG: StepComplete: (!dbgproc.IsStepping)");
}
#endif
dbgproc.IsStepping = false;
{
//dbgproc.dout.WriteLine("0: -");
dbgproc.ShowCurrentLine_unlocked();
}
}
_CallbackEvent("StepComplete");
}
catch (Exception e)
{
_CallbackException(e);
}
}
public void StepComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugStepper pStepper, CorDebugStepReason reason)
{
EnterCallback("StepComplete (" + reason.ToString() + ")", pThread);
Thread thread = process.GetThread(pThread);
Stepper stepper = process.GetStepper(pStepper);
StackFrame currentStackFrame = thread.MostRecentStackFrame;
process.TraceMessage(" - stopped at {0} because of {1}", currentStackFrame.MethodInfo.FullName, stepper.ToString());
process.Steppers.Remove(stepper);
stepper.OnStepComplete(reason);
if (stepper.Ignore) {
// The stepper is ignored
process.TraceMessage(" - ignored");
} else if (thread.CurrentStepIn != null &&
thread.CurrentStepIn.StackFrame.Equals(currentStackFrame) &&
thread.CurrentStepIn.IsInStepRanges((int)currentStackFrame.IP)) {
Stepper.StepIn(currentStackFrame, thread.CurrentStepIn.StepRanges, "finishing step in");
process.TraceMessage(" - finishing step in");
} else if (currentStackFrame.IsNonUserCode) {
if (process.Options.EnableJustMyCode) {
currentStackFrame.MarkAsNonUserCode();
process.TraceMessage(" - method {0} marked as non user code", currentStackFrame.MethodInfo.FullName);
Stepper.StepIn(currentStackFrame, new int[] {0, int.MaxValue}, "seeking user code");
process.TraceMessage(" - seeking user code");
} else {
Stepper.StepOut(currentStackFrame, "stepping out of non-user code");
process.TraceMessage(" - stepping out of non-user code");
}
} else {
// User-code method
RequestPause(thread).Break = true;
process.TraceMessage(" - pausing in user code");
}
ExitCallback();
}
public void StepComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugStepper pStepper, CorDebugStepReason reason)
{
ManagedCallback managedCallback = GetProcessCallbackInterface(pAppDomain);
if (managedCallback != null)
{
managedCallback.StepComplete(pAppDomain, pThread, pStepper, reason);
}
}
public void StepComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugStepper pStepper, CorDebugStepReason reason)
{
pAppDomain.Continue(0);
}
public void StepComplete(ICorDebugAppDomain appDomain,
ICorDebugThread thd,
ICorDebugStepper stepper,
CorDebugStepReason reason)
{
}
public virtual void StepComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugStepper pStepper, CorDebugStepReason reason)
{
pAppDomain.Continue(0);
}
int ICorDebugNativeFrame.CreateStepper(out ICorDebugStepper ppStepper)
{
return ((ICorDebugFrame)this).CreateStepper(out ppStepper);
}
internal CorStepper(ICorDebugStepper stepper)
: base(stepper)
{
m_step = stepper;
}
int ICorDebugInternalFrame.CreateStepper(out ICorDebugStepper ppStepper)
{
return(ICorDebugFrame.CreateStepper(out ppStepper));
}
internal SourceStepper GetStepper(ICorDebugStepper pStepper)
{
SourceStepper stepper;
_steppers.TryGetValue(pStepper, out stepper);
return stepper;
}
int ICorDebugNativeFrame.CreateStepper(out ICorDebugStepper ppStepper)
{
return(((ICorDebugFrame)this).CreateStepper(out ppStepper));
}
int ICorDebugFrame.CreateStepper(out ICorDebugStepper ppStepper)
{
ppStepper = new CorDebugStepper(this);
return(COM_HResults.S_OK);
}
public void StepComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugStepper pStepper, CorDebugStepReason reason)
{
Log("Step completed. ({0})", reason);
var domain = GetProcessWrapper(pAppDomain).GetAppDomain(pAppDomain);
var thread = domain.GetThread(pThread);
var stepper = domain.GetStepper(pStepper);
var eventArgs = new StepperEventArgs(domain, thread, stepper);
if (thread.CurrentFrame.IsUserCode)
{
domain.DispatchStepCompletedEvent(eventArgs);
}
else
{
Log("Non-user code detected. Stepping out.");
thread.CurrentFrame.CreateStepper().StepOut();
eventArgs.Continue = true;
}
FinalizeEvent(eventArgs);
}
int ICorDebugInternalFrame.CreateStepper( out ICorDebugStepper ppStepper )
{
return this.ICorDebugFrame.CreateStepper( out ppStepper );
}
internal CorStepper (ICorDebugStepper stepper)
:base(stepper)
{
m_step = stepper;
}
internal bool IsCorStepper(ICorDebugStepper corStepper)
{
return(this.corStepper == corStepper);
}
internal Stepper(ICorDebugStepper step)
{
m_step = step;
}
public void StepComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugStepper pStepper, CorDebugStepReason reason)
{
Console.WriteLine("StepComplete");
pAppDomain.Continue(0);
}
public void StepComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugStepper pStepper, CorDebugStepReason reason)
{
ManagedCallback managedCallback = GetProcessCallbackInterface("StepComplete", pAppDomain);
if (managedCallback != null) {
managedCallback.StepComplete(pAppDomain, pThread, pStepper, reason);
}
}
public void StepComplete([In, MarshalAs(UnmanagedType.Interface)] ICorDebugAppDomain pAppDomain, [In, MarshalAs(UnmanagedType.Interface)] ICorDebugThread pThread, [In, MarshalAs(UnmanagedType.Interface)] ICorDebugStepper pStepper, [In] CorDebugStepReason reason)
{
throw new NotImplementedException();
}
protected internal virtual void OnStepComplete(CorDebugStepReason reason) {
this.corStepper = null;
if (StepComplete != null) {
StepComplete(this, new StepperEventArgs(this, reason));
}
}
public void StepComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugStepper pStepper, CorDebugStepReason reason)
{
EnterCallback(PausedReason.StepComplete, "StepComplete (" + reason.ToString() + ")", pThread);
Thread thread = process.Threads[pThread];
Stepper stepper = process.GetStepper(pStepper);
StackFrame currentStackFrame = process.SelectedThread.MostRecentStackFrame;
process.TraceMessage(" - stopped at {0} because of {1}", currentStackFrame.MethodInfo.FullName, stepper.ToString());
process.Steppers.Remove(stepper);
stepper.OnStepComplete(reason);
if (stepper.Ignore)
{
// The stepper is ignored
process.TraceMessage(" - ignored");
}
else if (thread.CurrentStepIn != null &&
thread.CurrentStepIn.StackFrame.Equals(currentStackFrame) &&
thread.CurrentStepIn.IsInStepRanges((int)currentStackFrame.IP))
{
Stepper.StepIn(currentStackFrame, thread.CurrentStepIn.StepRanges, "finishing step in");
process.TraceMessage(" - finishing step in");
}
else if (currentStackFrame.MethodInfo.StepOver)
{
if (process.Options.EnableJustMyCode)
{
currentStackFrame.MethodInfo.MarkAsNonUserCode();
process.TraceMessage(" - method {0} marked as non user code", currentStackFrame.MethodInfo.FullName);
Stepper.StepIn(currentStackFrame, new int[] { 0, int.MaxValue }, "seeking user code");
process.TraceMessage(" - seeking user code");
}
else
{
Stepper.StepOut(currentStackFrame, "stepping out of non-user code");
process.TraceMessage(" - stepping out of non-user code");
}
}
else
{
// User-code method
pauseOnNextExit = true;
process.TraceMessage(" - pausing in user code");
}
ExitCallback();
}
internal bool IsCorStepper(ICorDebugStepper corStepper)
{
return this.corStepper == corStepper;
}
public StepCompleteDebugCallbackEventArgs(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugStepper pStepper, CorDebugStepReason reason)
: base(pAppDomain) {
this.AppDomain = pAppDomain;
this.Thread = pThread;
this.Stepper = pStepper;
this.Reason = reason;
}
int ICorDebugFrame.CreateStepper (out ICorDebugStepper ppStepper)
{
ppStepper = new CorDebugStepper(this);
return Utility.COM_HResults.S_OK;
}
public virtual void StepComplete(
ICorDebugAppDomain appDomain,
ICorDebugThread thread,
ICorDebugStepper stepper,
CorDebugStepReason reason)
{
this.DefaultHandler(appDomain);
}
public void StepComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugStepper pStepper, CorDebugStepReason reason)
{
EnterCallback(PausedReason.StepComplete, "StepComplete (" + reason.ToString() + ")", pThread);
Thread thread = process.GetThread(pThread);
Stepper stepper = thread.GetStepper(pStepper);
process.TraceMessage(" - stepper info: " + stepper.ToString());
thread.Steppers.Remove(stepper);
stepper.OnStepComplete();
if (stepper.PauseWhenComplete)
{
if (process.SelectedThread.LastFunction.HasSymbols)
{
ExitCallback_Paused();
}
else
{
// This can only happen when JMC is disabled (ie NET1.1 or StepOut)
if (stepper.Operation == Stepper.StepperOperation.StepOut)
{
// Create new stepper and keep going
process.TraceMessage(" - stepping out of code without symbols at " + process.SelectedThread.LastFunction.ToString());
new Stepper(process.SelectedThread.LastFunction, "Stepper out of code without symbols").StepOut();
ExitCallback_Continue();
}
else
{
// NET1.1: There is extra step over stepper, just keep going
process.TraceMessage(" - leaving code without symbols");
ExitCallback_Continue();
}
}
}
else
{
ExitCallback_Continue();
}
}
void ICorDebugManagedCallback.StepComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugStepper pStepper, CorDebugStepReason reason)
{
var ev = new CorEventArgs(new CorAppDomain(pAppDomain, p_options));
GetOwner(ev.Controller).DispatchEvent(ev);
FinishEvent(ev);
}
int ICorDebugThread.CreateStepper(out ICorDebugStepper ppStepper)
{
Debug.Assert(!IsVirtualThread);
ICorDebugFrame frame;
((ICorDebugThread)this).GetActiveFrame(out frame);
ppStepper = new CorDebugStepper((CorDebugFrame)frame);
return Utility.COM_HResults.S_OK;
}
public void StepComplete(ICorDebugAppDomain appDomain,
ICorDebugThread thd,
ICorDebugStepper stepper,
CorDebugStepReason reason)
{
}
public void StepComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugStepper pStepper, CorDebugStepReason reason)
{
Log("Step completed. ({0})", reason);
var domain = GetProcessWrapper(pAppDomain).GetAppDomain(pAppDomain);
var thread = domain.GetThread(pThread);
var stepper = domain.GetStepper(pStepper);
var eventArgs = new StepperEventArgs(domain, thread, stepper);
if (thread.CurrentFrame.IsUserCode)
{
domain.DispatchStepCompletedEvent(eventArgs);
}
else
{
Log("Non-user code detected. Stepping out.");
thread.CurrentFrame.CreateStepper().StepOut();
eventArgs.Continue = true;
}
FinalizeEvent(eventArgs);
}
void ICorDebugManagedCallback.StepComplete(ICorDebugAppDomain appDomain,
ICorDebugThread thread,
ICorDebugStepper stepper,
CorDebugStepReason stepReason)
{
HandleEvent(ManagedCallbackType.OnStepComplete,
new CorStepCompleteEventArgs(appDomain == null ? null : new CorAppDomain(appDomain),
thread == null ? null : new CorThread(thread),
stepper == null ? null : new CorStepper(stepper),
stepReason,
ManagedCallbackType.OnStepComplete));
}
public void StepComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugStepper pStepper, CorDebugStepReason reason)
{
throw new NotImplementedException();
}