private void DispatchTrace(List <FunctionStack> thread, Debugging.TraceEventKind kind, object payload, TracebackDelegate traceDispatch, object traceDispatchObject, TraceBackFrame pyFrame)
{
object args = null;
// Prepare the event
string traceEvent = String.Empty;
switch (kind)
{
case Debugging.TraceEventKind.FrameEnter: traceEvent = "call"; break;
case Debugging.TraceEventKind.TracePoint: traceEvent = "line"; break;
case Debugging.TraceEventKind.Exception:
traceEvent = "exception";
object pyException = PythonExceptions.ToPython((Exception)payload);
object pyType = ((IPythonObject)pyException).PythonType;
args = PythonTuple.MakeTuple(pyType, pyException, null);
break;
case Debugging.TraceEventKind.FrameExit:
traceEvent = "return";
args = payload;
break;
}
bool traceDispatchThrew = true;
InTraceBack = true;
try {
TracebackDelegate dlg = traceDispatch(pyFrame, traceEvent, args);
traceDispatchThrew = false;
pyFrame.Setf_trace(dlg);
} finally {
InTraceBack = false;
if (traceDispatchThrew)
{
// We're matching CPython's behavior here. If the trace dispatch throws any exceptions
// we don't re-enable tracebacks. We need to leave the trace callback in place though
// so that we can pop our frames.
_globalTraceObject = _globalTraceDispatch = null;
_exceptionThrown = true;
}
}
}
public void OnTraceEvent(Debugging.TraceEventKind kind, string name, string sourceFileName, SourceSpan sourceSpan, Func <IDictionary <object, object> > scopeCallback, object payload, object customPayload)
{
if (kind == Debugging.TraceEventKind.ThreadExit || // We don't care about thread-exit events
#if PROFILER_SUPPORT
(_profile && kind == Debugging.TraceEventKind.TracePoint) || // Ignore code execute tracebacks when in profile mode
#endif
kind == Debugging.TraceEventKind.ExceptionUnwind) // and we always have a try/catch so we don't care about methods unwinding.
{
return;
}
TracebackDelegate traceDispatch = null;
object traceDispatchObject = null;
var thread = PythonOps.GetFunctionStack();
TraceBackFrame pyFrame;
if (InTraceBack)
{
return;
}
try {
if (kind == Debugging.TraceEventKind.FrameEnter)
{
traceDispatch = _globalTraceDispatch;
traceDispatchObject = _globalTraceObject;
var properties = (PythonDebuggingPayload)customPayload;
// push the new frame
pyFrame = new TraceBackFrame(
this,
properties.Code,
thread.Count == 0 ? null : thread[thread.Count - 1].Frame,
properties,
scopeCallback
);
thread.Add(new FunctionStack(pyFrame));
if (traceDispatchObject == null)
{
return;
}
pyFrame.Setf_trace(traceDispatchObject);
}
else
{
if (thread.Count == 0)
{
return;
}
pyFrame = thread[thread.Count - 1].Frame;
if (pyFrame == null)
{
// force creation of the Python frame
pyFrame = SysModule._getframeImpl(thread[thread.Count - 1].Context, 0);
}
traceDispatch = pyFrame.TraceDelegate;
traceDispatchObject = pyFrame.Getf_trace();
}
// Update the current line
if (kind != Debugging.TraceEventKind.FrameExit)
{
pyFrame._lineNo = sourceSpan.Start.Line;
}
if (traceDispatchObject != null && !_exceptionThrown)
{
DispatchTrace(thread, kind, payload, traceDispatch, traceDispatchObject, pyFrame);
}
} finally {
if (kind == Debugging.TraceEventKind.FrameExit && thread.Count > 0)
{
// don't pop frames we didn't push
if (thread[thread.Count - 1].Code == ((PythonDebuggingPayload)customPayload).Code)
{
thread.RemoveAt(thread.Count - 1);
}
}
}
}
