private void FireTargetEvent(TargetEventType type, ResultData curFrame, BreakEvent breakEvent = null) { UpdateHitCountData(); TargetEventArgs args = new TargetEventArgs(type); if (type != TargetEventType.TargetExited) { GdbCommandResult res = RunCommand("-stack-info-depth"); int fcount = int.Parse(res.GetValue("depth")); GdbBacktrace bt = new GdbBacktrace(this, activeThread, fcount, curFrame); args.Backtrace = new Backtrace(bt); args.Thread = GetThread(activeThread); args.BreakEvent = breakEvent; } if (_suppressEvents && type == TargetEventType.TargetStopped) { args.IsStopEvent = true; TargetStoppedWhenSuppressed?.Invoke(this, args); } else { OnTargetEvent(args); } }
public TargetEventArgs AssertTargetEvent(Thread thread, TargetEventType type) { DebuggerEvent e = AssertEvent(); if (e.Type != DebuggerEventType.TargetEvent) { Assert.Fail("Received event {0}, but expected {1}.", e, type); } if ((thread != null) && (e.Data != thread)) { Assert.Fail("Received event {0} while waiting for {1} in thread {2}.", e, type, thread); } TargetEventArgs args = (TargetEventArgs)e.Data2; if (args.Type != type) { Assert.Fail("Received event {0} while waiting for {1} in thread {2}.", e, type, thread); } return(args); }
void FireTargetEvent(TargetEventType type) { TargetEventArgs args = new TargetEventArgs(type); if (type != TargetEventType.TargetExited) { HxcppBacktrace bt = new HxcppBacktrace(this, lastResult.depth + 1, lastResult.threadId); args.Backtrace = new Backtrace(bt); args.Thread = GetThread(0); } OnTargetEvent(args); }
void FireTargetEvent(TargetEventType type, ResultData curFrame) { UpdateHitCountData(); TargetEventArgs args = new TargetEventArgs(type); if (type != TargetEventType.TargetExited) { GdbCommandResult res = RunCommand("-stack-info-depth"); int fcount = int.Parse(res.GetValue("depth")); GdbBacktrace bt = new GdbBacktrace(this, activeThread, fcount, curFrame); args.Backtrace = new Backtrace(bt); args.Thread = GetThread(activeThread); } OnTargetEvent(args); }
void FireTargetEvent(TargetEventType type) { TargetEventArgs args = new TargetEventArgs (type); if (type != TargetEventType.TargetExited) { HxcppBacktrace bt = new HxcppBacktrace (this, lastResult.depth + 1, lastResult.threadId); args.Backtrace = new Backtrace (bt); args.Thread = GetThread (0); } OnTargetEvent (args); }
void FireTargetEvent (TargetEventType type, ResultData curFrame) { UpdateHitCountData (); TargetEventArgs args = new TargetEventArgs (type); if (type != TargetEventType.TargetExited) { GdbCommandResult res = RunCommand ("-stack-info-depth"); int fcount = int.Parse (res.GetValue ("depth")); GdbBacktrace bt = new GdbBacktrace (this, activeThread, fcount, curFrame); args.Backtrace = new Backtrace (bt); args.Thread = GetThread (activeThread); } OnTargetEvent (args); }
public TargetEvent(TargetEventType targetEventType, float punt) : base(EventType.TARGET) { this.targetEventType = targetEventType; targetEventTypeString = targetEventType.ToString(); this.punt = punt; }
public TargetEventArgs(TargetEventType type) { this.type = type; }
public TargetEventArgs AssertTargetEvent(Thread thread, TargetEventType type) { DebuggerEvent e = AssertEvent (); if (e.Type != DebuggerEventType.TargetEvent) Assert.Fail ("Received event {0}, but expected {1}.", e, type); if ((thread != null) && (e.Data != thread)) Assert.Fail ("Received event {0} while waiting for {1} in thread {2}.", e, type, thread); TargetEventArgs args = (TargetEventArgs) e.Data2; if (args.Type != type) Assert.Fail ("Received event {0} while waiting for {1} in thread {2}.", e, type, thread); return args; }
public TargetEventArgs(TargetEventType type, StackFrame frame) : this(type, (object)null) { this.Frame = frame; }
public TargetEventArgs(TargetEventType type, object data) { this.Type = type; this.Data = data; }
public TargetEventArgs(TargetEventType type) { this.Type = type; }
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); } }
/// <summary> /// Initializes a new instance of the <see cref="WhatPumpkin.TargetEvent"/> class. /// </summary> /// <param name="target">Target.</param> public TargetEventArgs(UnityEngine.GameObject target, TargetEventType eventType) { _target = target; _targetEventType = eventType; }
private void HandleEvent(GdbEvent ev) { if (ev.Name != "stopped") { return; } CleanTempVariableObjects(); BreakEvent breakEvent = null; TargetEventType type = TargetEventType.TargetStopped; if (!string.IsNullOrEmpty(ev.Reason)) { switch (ev.Reason) { case "breakpoint-hit": type = TargetEventType.TargetHitBreakpoint; var breakPointNumber = ev.GetInt("bkptno"); if (!CheckBreakpoint(breakPointNumber)) { RunCommand("-exec-continue"); return; } breakEvent = breakpoints[breakPointNumber].BreakEvent; break; case "watchpoint-trigger": type = TargetEventType.TargetHitBreakpoint; var watchPointNumber = ev.GetObject("wpt").GetInt("number"); breakEvent = breakpoints[watchPointNumber].BreakEvent; break; case "signal-received": if (ev.GetValue("signal-name") == "SIGINT") { type = TargetEventType.TargetInterrupted; } else { type = TargetEventType.TargetSignaled; } break; case "exited": case "exited-signalled": case "exited-normally": type = TargetEventType.TargetExited; break; default: type = TargetEventType.TargetStopped; break; } } ResultData curFrame = ev.GetObject("frame"); FireTargetEvent(type, curFrame, breakEvent); }
public TargetEventArgs(TargetEventType type, StackFrame frame) : this(type, (object) null) { this.Frame = frame; }
public TargetEventArgs(TargetEventType type, object data, StackFrame frame) : this(type, data) { this.Frame = frame; }