void NotifyTargetEvent(MD.Thread thread, MD.TargetEventArgs args)
{
if (args.Frame != null)
{
activeThread = args.Frame.Thread;
}
try {
if (args.Type == MD.TargetEventType.TargetStopped && ((int)args.Data) != 0)
{
DispatchEvent(delegate {
controller.OnDebuggerOutput(false, string.Format("Thread {0:x} received signal {1}.\n", args.Frame.Thread.ID, args.Data));
});
}
DL.TargetEventType type;
switch (args.Type)
{
case MD.TargetEventType.Exception: type = DL.TargetEventType.ExceptionThrown; break;
case MD.TargetEventType.TargetHitBreakpoint: type = DL.TargetEventType.TargetHitBreakpoint; break;
case MD.TargetEventType.TargetInterrupted: type = DL.TargetEventType.TargetInterrupted; break;
case MD.TargetEventType.TargetSignaled: type = DL.TargetEventType.TargetSignaled; break;
case MD.TargetEventType.TargetStopped: type = DL.TargetEventType.TargetStopped; break;
case MD.TargetEventType.UnhandledException: type = DL.TargetEventType.UnhandledException; break;
default:
return;
}
OnCleanFrameData();
DL.TargetEventArgs targetArgs = new DL.TargetEventArgs(type);
if (args.Type != MD.TargetEventType.TargetExited)
{
ML.TargetObject exception = null;
if (args.Type == MD.TargetEventType.UnhandledException || args.Type == MD.TargetEventType.Exception)
{
exception = args.Frame.ExceptionObject;
}
targetArgs.Backtrace = CreateBacktrace(thread, exception);
targetArgs.Thread = CreateThreadInfo(activeThread);
}
running = false;
DispatchEvent(delegate {
controller.OnTargetEvent(targetArgs);
});
} catch (Exception e) {
Console.WriteLine("*** DS.OnTargetEvent2, exception : {0}", e.ToString());
}
}
private void OnTargetEvent(MD.Thread thread, MD.TargetEventArgs args)
{
try {
if (!running)
{
LogEvent(args);
return;
}
bool notifyToClient = args.IsStopped || args.Type == MD.TargetEventType.UnhandledException || args.Type == MD.TargetEventType.Exception || args.Type == MD.TargetEventType.TargetInterrupted;
LogEvent(args);
bool isStop = args.Type != MD.TargetEventType.FrameChanged &&
args.Type != MD.TargetEventType.TargetExited &&
args.Type != MD.TargetEventType.TargetRunning;
if (isStop)
{
lock (debugger) {
if (stoppedWorkQueue.Count > 0)
{
// Execute queued work in another thread with a small delay
// since it is not safe to execute it here
System.Threading.ThreadPool.QueueUserWorkItem(delegate {
System.Threading.Thread.Sleep(50);
bool resume = false;
lock (debugger) {
foreach (ST.WaitCallback cb in stoppedWorkQueue)
{
cb(null);
}
stoppedWorkQueue.Clear();
}
if (resume)
{
guiManager.Continue(process.MainThread);
}
else if (notifyToClient)
{
NotifyTargetEvent(thread, args);
}
});
return;
}
}
}
if (notifyToClient)
{
NotifyTargetEvent(thread, args);
}
} catch (Exception e) {
Console.WriteLine("*** DS.OnTargetEvent1, exception : {0}", e.ToString());
}
}
void LogEvent(MD.TargetEventArgs args)
{
Console.WriteLine("Server OnTargetEvent: {0} stopped:{1} data:{2} queue:{3} thread:{4} running:{5}", args.Type, args.IsStopped, args.Data, stoppedWorkQueue.Count, args.Frame != null ? args.Frame.Thread : null, running);
}
void OperationCompleted(SingleSteppingEngine caller, TargetEventArgs result, ThreadingModel model)
{
if (!ThreadManager.InBackgroundThread)
throw new InternalError ();
foreach (Process process in process_hash.Values) {
process.OperationCompleted (caller, result, model);
}
lock (this) {
current_operation = null;
stopped_event.Set ();
}
}
protected virtual void OnTargetEvent(Thread thread, TargetEventArgs args)
{
if ((args.Type != TargetEventType.TargetSignaled) &&
(args.Type != TargetEventType.TargetExited) &&
(args.Type != TargetEventType.TargetInterrupted))
CurrentThread = thread;
Style.TargetEvent (thread, args);
}
internal void OnTargetEvent(SingleSteppingEngine sse, TargetEventArgs args)
{
Debugger.OnTargetEvent (sse.Client, args);
}
void IOperationHost.OperationCompleted(SingleSteppingEngine caller, TargetEventArgs result, ThreadingModel model)
{
Process.OperationCompleted (caller, result, model);
}
public abstract void TargetEvent(Thread thread, TargetEventArgs args);
void IOperationHost.OperationCompleted(SingleSteppingEngine sse, TargetEventArgs args, ThreadingModel model)
{
}
void IOperationHost.SendResult(SingleSteppingEngine sse, TargetEventArgs args)
{
Process.Debugger.OnTargetEvent(sse.Client, args);
}
void IOperationHost.OperationCompleted(SingleSteppingEngine caller, TargetEventArgs result, ThreadingModel model)
{
Process.OperationCompleted(caller, result, model);
}
internal void OnTargetEvent(SingleSteppingEngine sse, TargetEventArgs args)
{
Debugger.OnTargetEvent(sse.Client, args);
}
void IOperationHost.SendResult(SingleSteppingEngine sse, TargetEventArgs args)
{
Debugger.OnTargetEvent(sse.Thread, args);
}
protected override void OnTargetEvent(Mono.Debugger.Thread thread, TargetEventArgs args)
{
switch (args.Type) {
case TargetEventType.TargetStopped: {
eventData newEvent = new eventData();
newEvent.eventType = "TargetStopped";
newEvent.arg1 = thread.ID;
newEvent.arg3 = "";
newEvent.arg2 = (int)args.Data;
eventList.Add(newEvent);
break;
}
case TargetEventType.TargetRunning: {
eventData newEvent = new eventData();
newEvent.eventType = "TargetRunning";
newEvent.arg1 = thread.ID;
newEvent.arg2 = 0;
newEvent.arg3 = "";
eventList.Add(newEvent);
break;
}
case TargetEventType.TargetInterrupted: {
eventData newEvent = new eventData();
newEvent.eventType = "TargetInterrupted";
newEvent.arg1 = thread.ID;
newEvent.arg2 = 0;
newEvent.arg3 = "";
eventList.Add(newEvent);
break;
}
case TargetEventType.FrameChanged: {
eventData newEvent = new eventData();
newEvent.eventType = "FrameChanged";
newEvent.arg1 = thread.ID;
newEvent.arg2 = 0;
newEvent.arg3 = "";
eventList.Add(newEvent);
break;
}
case TargetEventType.TargetHitBreakpoint: {
eventData newEvent = new eventData();
newEvent.eventType = "TargetHitBreakpoint";
newEvent.arg1 = thread.ID;
newEvent.arg2 = (int)args.Data;
newEvent.arg3 = "";
eventList.Add(newEvent);
break;
}
case TargetEventType.TargetSignaled: {
eventData newEvent = new eventData();
newEvent.eventType = "TargetSignaled";
newEvent.arg1 = thread.ID;
newEvent.arg2 = (int)args.Data;
newEvent.arg3 = "";
eventList.Add(newEvent);
break;
}
case TargetEventType.TargetExited: {
eventData newEvent = new eventData();
newEvent.eventType = "TargetExited";
newEvent.arg1 = thread.ID;
newEvent.arg2 = (int)args.Data;
newEvent.arg3 = "";
eventList.Add(newEvent);
break;
}
case TargetEventType.Exception: {
eventData newEvent = new eventData();
newEvent.eventType = "Exception";
newEvent.arg1 = thread.ID;
newEvent.arg2 = 0;
newEvent.arg3 = "";
eventList.Add(newEvent);
break;
}
case TargetEventType.UnhandledException: {
eventData newEvent = new eventData();
newEvent.eventType = "UnhandledException";
newEvent.arg1 = thread.ID;
newEvent.arg2 = 0;
newEvent.arg3 = "";
eventList.Add(newEvent);
break;
}
}
base.OnTargetEvent(thread,args);
}
void IOperationHost.SendResult(SingleSteppingEngine sse, TargetEventArgs args)
{
Debugger.OnTargetEvent (sse.Thread, args);
}
internal override void Completed(SingleSteppingEngine sse, TargetEventArgs args)
{
Host.OperationCompleted (sse, args, ThreadingModel);
if (args != null)
Host.SendResult (sse, args);
}
public override void TargetEvent(Thread thread, TargetEventArgs args)
{
if (args.Frame != null)
TargetEvent (thread, args.Frame, args);
switch (args.Type) {
case TargetEventType.TargetExited:
if ((int) args.Data != 0)
interpreter.Print ("{0} exited with exit code {1}.",
thread.Name, (int) args.Data);
break;
case TargetEventType.TargetSignaled:
interpreter.Print ("{0} died with fatal signal {1}.",
thread.Name, (int) args.Data);
break;
}
}
internal virtual void Completed(SingleSteppingEngine sse, TargetEventArgs args)
{
if ((args != null) && ((args.Type == TargetEventType.TargetExited) || (args.Type == TargetEventType.TargetSignaled))) {
if ((sse.Thread.ThreadFlags & Thread.Flags.StopOnExit) == 0) {
Host.SendResult (sse, args);
return;
}
}
if (!IsCompleted) {
IsCompleted = true;
if (args != null)
Host.SendResult (sse, args);
Host.OperationCompleted (sse, args, ThreadingModel);
}
}
protected void TargetEvent(Thread target, StackFrame frame,
TargetEventArgs args)
{
switch (args.Type) {
case TargetEventType.TargetStopped: {
if ((int) args.Data != 0)
interpreter.Print ("{0} received signal {1} at {2}.",
target.Name, (int) args.Data, frame);
else if (!interpreter.IsInteractive)
break;
else
interpreter.Print ("{0} stopped at {1}.", target.Name, frame);
if (interpreter.IsScript)
break;
AssemblerLine insn;
try {
insn = target.DisassembleInstruction (
frame.Method, frame.TargetAddress);
} catch {
insn = null;
}
interpreter.Style.TargetStopped (interpreter, frame, insn);
break;
}
case TargetEventType.TargetHitBreakpoint: {
if (!interpreter.IsInteractive)
break;
interpreter.Print ("{0} hit breakpoint {1} at {2}.",
target.Name, (int) args.Data, frame);
if (interpreter.IsScript)
break;
AssemblerLine insn;
try {
insn = target.DisassembleInstruction (
frame.Method, frame.TargetAddress);
} catch {
insn = null;
}
interpreter.Style.TargetStopped (interpreter, frame, insn);
break;
}
case TargetEventType.Exception:
case TargetEventType.UnhandledException: {
interpreter.Print ("{0} caught {2}exception at {1}.", target.Name, frame,
args.Type == TargetEventType.Exception ?
"" : "unhandled ");
if (interpreter.IsScript)
break;
AssemblerLine insn;
try {
insn = target.DisassembleInstruction (
frame.Method, frame.TargetAddress);
} catch {
insn = null;
}
interpreter.Style.UnhandledException (interpreter, frame, insn);
break;
}
}
}
public override void TargetEvent(Thread thread, TargetEventArgs args)
{
if (TargetEventEvent != null)
TargetEventEvent (thread, args);
base.TargetEvent (thread, args);
}
void IOperationHost.SendResult(SingleSteppingEngine sse, TargetEventArgs args)
{
Process.Debugger.OnTargetEvent (sse.Client, args);
}
private void target_event(object sender, TargetEventArgs args)
{
switch (args.Type) {
case TargetEventType.TargetExited:
case TargetEventType.TargetSignaled:
KillApplication (null);
break;
case TargetEventType.TargetStopped:
case TargetEventType.TargetRunning:
ChangeState (null);
break;
case TargetEventType.TargetHitBreakpoint:
default:
break;
}
}
internal void OperationCompleted(SingleSteppingEngine caller, TargetEventArgs result, ThreadingModel model)
{
if (!ThreadManager.InBackgroundThread && Inferior.HasThreadEvents)
throw new InternalError ();
if (current_state == ProcessState.Stopping)
return;
else if (current_state != ProcessState.Running)
throw new InternalError ();
if ((result != null) && (caller != main_thread) &&
((result.Type == TargetEventType.TargetExited) || (result.Type == TargetEventType.TargetSignaled)))
return;
current_state = ProcessState.Stopping;
SuspendUserThreads (model, caller);
lock (this) {
current_state = ProcessState.Stopped;
current_operation.Completed ();
current_operation = null;
stopped_event.Set ();
}
}
bool BreakEventCheck(MD.TargetEventArgs args)
{
MD.StackFrame frame = args.Frame;
if (!(args.Data is int))
{
return(true);
}
int eventHandle = (int)args.Data;
DL.BreakEvent be;
if (!events.TryGetValue(eventHandle, out be))
{
return(true);
}
// Check hit count
if (be.HitCount > 0)
{
be.HitCount--;
DispatchEvent(delegate {
NotifyBreakEventUpdate(eventHandle, be.HitCount, null);
});
return(false);
}
MdbEvaluationContext ctx = new MdbEvaluationContext(frame.Thread, frame, null, SessionOptions.EvaluationOptions);
DL.Breakpoint bp = be as DL.Breakpoint;
if (bp != null && !string.IsNullOrEmpty(bp.ConditionExpression))
{
ML.TargetObject val = EvaluateExp(ctx, bp.ConditionExpression);
if (val == null)
{
return(false);
}
if (bp.BreakIfConditionChanges)
{
string current = evaluator.TargetObjectToExpression(ctx, val).Value;
string last;
bool found = lastConditionValue.TryGetValue(eventHandle, out last);
lastConditionValue [eventHandle] = current;
if (!found || last == current)
{
return(false);
}
}
else
{
ML.TargetFundamentalObject fob = val as ML.TargetFundamentalObject;
if (fob == null)
{
return(false);
}
object ob = fob.GetObject(frame.Thread);
if (!(ob is bool) || !(bool)ob)
{
return(false);
}
}
}
switch (be.HitAction)
{
case HitAction.Break:
return(true);
case HitAction.CustomAction:
return(controller.OnCustomBreakpointAction(be.CustomActionId, eventHandle));
case HitAction.PrintExpression:
if (string.IsNullOrEmpty(be.TraceExpression) || frame == null)
{
return(false);
}
ML.TargetObject val = EvaluateExp(ctx, be.TraceExpression);
if (val != null)
{
string str = evaluator.TargetObjectToString(ctx, val);
DispatchEvent(delegate {
NotifyBreakEventUpdate(eventHandle, -1, str);
});
}
return(false);
}
return(false);
}
public void target_event(Thread thread, TargetEventArgs args)
{
if (((thread.ThreadFlags & Thread.Flags.Daemon) != 0) &&
((args.Type == TargetEventType.TargetExited) ||
(args.Type == TargetEventType.TargetSignaled)))
return;
interpreter.OnTargetEvent (thread, args);
}
internal void OnTargetEvent(Thread thread, TargetEventArgs args)
{
try {
if (TargetEvent != null)
TargetEvent (thread, args);
} catch (Exception ex) {
Error ("{0} caught exception while sending {1}:\n{2}",
thread, args, ex);
}
}
