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, 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;
}
public TargetEventArgs(TargetEventType type, object data, StackFrame frame)
: this(type, data)
{
this.Frame = frame;
}
