private void mnuDebug_StepOver_Click(object sender, EventArgs e) { mTraceback = OnTracebackReceived; StartScript(); ExecuteStep(); }
internal string Create(TracebackDelegate traceFunc) { string result = String.Empty; try { m_pe = new PythonEngine(); m_Engine = m_pe.engine; m_Scope = m_pe.scope; var pc = Microsoft.Scripting.Hosting.Providers.HostingHelpers.GetLanguageContext(m_Engine) as PythonContext; PythonDictionary hooks = (PythonDictionary)pc.SystemState.Get__dict__()["path_hooks"]; hooks.Clear(); if (traceFunc != null) { m_Engine.SetTrace(traceFunc); } result = "Created"; } catch (Exception ex) { result = ex.Message; } return(result); }
internal string Create(TracebackDelegate traceFunc) { string result = String.Empty; try { // none of this adds to the python path but I am leaving it here because there HAS to be a way to do this //Environment.SetEnvironmentVariable("IRONPYTHONPATH", Misc.CurrentScriptDirectory()); m_Engine = Python.CreateEngine(); //m_Engine.GetService<ExceptionOperations>().FormatException(exception); //ICollection<string> paths = m_Engine.GetSearchPaths(); //paths.Add(Misc.CurrentScriptDirectory()); //m_Engine.SetSearchPaths(paths); // m_Source = m_Engine.CreateScriptSourceFromString(m_Text); m_Scope = GetRazorScope(m_Engine); if (traceFunc != null) { m_Engine.SetTrace(traceFunc); } result = "Created"; } catch (Exception ex) { result = ex.Message; } return(result); }
private void mnuDebug_StepOut_Click(object sender, EventArgs e) { mTraceback = null; StartScript(); ExecuteStep(); }
public void SetTrace(TracebackDelegate func) { foreach (var ext in Extensions) { if (ext.Engine != null) { ext.Engine._engine.SetTrace(func); } } }
internal PythonTracebackListener(PythonContext pythonContext, object traceObject) { _pythonContext = pythonContext; if (traceObject != null) { _traceObject = traceObject; _traceDispatch = (TracebackDelegate)Converter.ConvertToDelegate(traceObject, typeof(TracebackDelegate)); } }
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; } } }
// not enabled because we don't yet support tracing built-in functions. Doing so is a little // difficult because it's hard to flip tracing on/off for them w/o a perf overhead in the // non-profiling case. public static void setprofile(CodeContext /*!*/ context, TracebackDelegate o) { PythonContext pyContext = PythonContext.GetContext(context); pyContext.EnsureDebugContext(); if (o == null) { pyContext.UnregisterTracebackHandler(); } else { pyContext.RegisterTracebackHandler(); } // Register the trace func with the listener pyContext.TracebackListener.SetProfile(o); }
internal string Create(TracebackDelegate traceFunc) { string result = ""; try { m_Engine = Python.CreateEngine(); m_Source = m_Engine.CreateScriptSourceFromString(m_Text); m_Scope = GetRazorScope(m_Engine); if (traceFunc != null) { m_Engine.SetTrace(traceFunc); } result = "Created"; } catch (Exception ex) { result = ex.Message; } return(result); }
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, new TraceBack(null, pyFrame)); 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; } } }
/// <summary> /// Enables call tracing for the current thread in this ScriptEngine. /// /// TracebackDelegate will be called back for each function entry, exit, exception, and line change. /// </summary> public static void SetTrace(this ScriptEngine /*!*/ engine, TracebackDelegate traceFunc) { SysModule.settrace(GetPythonContext(engine).SharedContext, traceFunc); }
/// <summary> /// Enables call tracing for the current thread for the Python engine in this ScriptRuntime. /// /// TracebackDelegate will be called back for each function entry, exit, exception, and line change. /// </summary> public static void SetTrace(this ScriptRuntime /*!*/ runtime, TracebackDelegate traceFunc) { SetTrace(GetEngine(runtime), traceFunc); }
/// <summary> /// Enables call tracing for the current thread for the Python engine in this ScriptRuntime. /// /// TracebackDelegate will be called back for each function entry, exit, exception, and line change. /// </summary> public static void SetTrace(this ScriptRuntime/*!*/ runtime, TracebackDelegate traceFunc) { SetTrace(GetEngine(runtime), traceFunc); }
public void Setf_trace(object value) { _traceObject = value; _trace = (TracebackDelegate)Converter.ConvertToDelegate(value, typeof(TracebackDelegate)); }
private void StepOutExecuted(object sender, ExecutedRoutedEventArgs e) { _traceback = null; ExecuteStep(); }
/// <summary> /// Enables call tracing for the current thread in this ScriptEngine. /// /// TracebackDelegate will be called back for each function entry, exit, exception, and line change. /// </summary> public static void SetTrace(this ScriptEngine/*!*/ engine, TracebackDelegate traceFunc) { SysModule.settrace(GetPythonContext(engine).SharedContext, traceFunc); }
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); } } } }
private void StepInExecuted(object sender, ExecutedRoutedEventArgs e) { _traceback = this.OnTracebackReceived; ExecuteStep(); }
private void StepInExecuted(object sender, ExecutedRoutedEventArgs e) { _traceback = this.OnTracebackReceived; ExecuteStep(); }
private void StepOutExecuted(object sender, ExecutedRoutedEventArgs e) { _traceback = null; ExecuteStep(); }
internal static void SetTrace(object function, TracebackDelegate traceDispatch) { _globalTraceDispatch = traceDispatch; _globalTraceObject = function; }
public void Deletef_trace() { f_trace = null; }
private void DispatchTrace(List<FunctionStack> thread, TraceEventKind kind, object payload, TracebackDelegate traceDispatch, object traceDispatchObject, TraceBackFrame toFrame) { object args = null; // Prepare the event string traceEvent = String.Empty; switch (kind) { case TraceEventKind.FrameEnter: traceEvent = "call"; break; case TraceEventKind.TracePoint: traceEvent = "line"; break; case TraceEventKind.Exception: traceEvent = "exception"; throw new NotImplementedException(); case TraceEventKind.FrameExit: traceEvent = "return"; args = payload; break; } bool traceDispatchThrew = true; InTraceBack = true; try { TracebackDelegate dlg = traceDispatch(toFrame, traceEvent, args); traceDispatchThrew = false; toFrame.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; } } }
internal void SetProfile(TracebackDelegate traceDispatch) { _globalTraceDispatch = traceDispatch; _profile = true; }
internal static void SetTrace(object function, TracebackDelegate traceDispatch) { _globalTraceDispatch = traceDispatch; _globalTraceObject = function; }
public void Setf_trace(object value) { _traceObject = value; _trace = (TracebackDelegate)Converter.ConvertToDelegate(value, typeof(TracebackDelegate)); }
internal void SetProfile(TracebackDelegate traceDispatch) { _globalTraceDispatch = traceDispatch; _profile = true; }