public AD7Thread(AD7Engine engine, DebuggedThread debuggedThread)//ThreadMirror threadMirror) { _engine = engine; ThreadMirror = debuggedThread.Thread; _debuggedThread = debuggedThread; }
public SoftEvaluationContext (SoftDebuggerSession session, StackFrame frame, DC.EvaluationOptions options): base (options) { Frame = frame; Thread = frame.Thread; string method = frame.Method.Name; if (frame.Method.DeclaringType != null) method = frame.Method.DeclaringType.FullName + "." + method; var location = new DC.SourceLocation (method, frame.FileName, frame.LineNumber); string language; if (frame.Method != null) { if (frame.IsNativeTransition) { language = "Transition"; } else { language = "Managed"; } } else { language = "Native"; } Evaluator = session.GetEvaluator (new DC.StackFrame (frame.ILOffset, location, language, session.IsExternalCode (frame), true)); Adapter = session.Adaptor; this.session = session; this.stackVersion = session.StackVersion; sourceAvailable = !string.IsNullOrEmpty (frame.FileName) && System.IO.File.Exists (frame.FileName); }
// name is a field name, local variable name, etc. // parent is a LiveStackFrame, ObjectMirror, ArrayMirror, etc. Parents are always non-null except for the LiveStackFrame parent. // key is an integral index, a FieldInfoMirror, LocalVariable, etc. // value is the object associated with the parent/key. It will be a Value or a primitive type (like char or int). public VariableItem(ThreadMirror thread, string name, VariableItem parent, object key, object value, int index) : base(NSObject.AllocAndInitInstance("VariableItem")) { Contract.Requires(thread != null); Contract.Requires(!string.IsNullOrEmpty(name)); Contract.Requires(parent != null || value is LiveStackFrame); Contract.Requires(key != null || value is LiveStackFrame); Contract.Requires(value != null); // null debugger values are PrimitiveValues with a null Value Contract.Requires(index >= 0); Parent = parent; Key = key; Value = value; m_index = index; m_actualName = name; m_actualValue = value; Details details = DoGetDetails(thread, name, parent, key, value); Value = details.Value; AttributedName = NSMutableAttributedString.Create(details.DisplayName).Retain(); AttributedType = NSAttributedString.Create(details.DisplayType).Retain(); AttributedValue = NSAttributedString.Create(details.DisplayValue).Retain(); NumberOfChildren = details.NumberOfChildren; }
private string DoGetRefCount(ThreadMirror thread) { string result = null; // Using InvokeMethod causes the VM to exit. Not sure what calling InvokeMethod // does, but if it is working it takes forever to finish. #if DOES_NOT_WORK ObjectMirror value = Object as ObjectMirror; if (value != null && value.Type.IsType("MObjc.NSObject")) { MethodMirror method = value.Type.FindMethod("retainCount", 0); if (method != null) { Value v = value.InvokeMethod(thread, method, new Value[0], InvokeOptions.DisableBreakpoints | InvokeOptions.SingleThreaded); // var invoker = new InvokeMethod(); // Value v = invoker.Invoke(thread, value, "retainCount"); PrimitiveValue p = v as PrimitiveValue; if (p != null) result = string.Format(" (retainCount = {0})", p.Value); } } #endif return result; }
internal StepEventRequest (VirtualMachine vm, ThreadMirror thread) : base (vm, EventType.Step) { if (thread == null) throw new ArgumentNullException ("thread"); CheckMirror (vm, thread); this.step_thread = thread; Depth = StepDepth.Into; Size = StepSize.Min; }
/* * FIXME: Decide on the way to request/handle debugging information: * - request the info in bulk for all frames/on demand for individual frames * - request the info from the runtime/request only the il offset, and compute * everything else based on this info using the method debug info. */ internal StackFrame(VirtualMachine vm, long id, ThreadMirror thread, MethodMirror method, int il_offset, StackFrameFlags flags) : base(vm, id) { this.thread = thread; this.method = method; this.il_offset = il_offset; this.flags = flags; }
public DebuggedThread(ThreadMirror thread, AD7Engine engine) { Thread = thread; Id = thread.TID; Name = ""; TargetId = thread.TID; AD7Thread ad7Thread = new AD7Thread(engine, this); Client = ad7Thread; }
public SoftDebuggerBacktrace (SoftDebuggerSession session, MDB.ThreadMirror thread): base (session.Adaptor) { this.session = session; this.thread = thread; stackVersion = session.StackVersion; if (thread != null) this.frames = thread.GetFrames (); else this.frames = new MDB.StackFrame[0]; }
public static void Set(ThreadMirror thread, VariableItem item, InstanceValue parent, FieldInfoMirror key, Value newValue) { if (key.IsStatic) { key.DeclaringType.SetValue(key, newValue); } else { var o = (ObjectMirror) parent.Instance; o.SetValue(key, newValue); } }
public SoftDebuggerBacktrace(SoftDebuggerSession session, MDB.ThreadMirror thread) : base(session.Adaptor) { this.session = session; this.thread = thread; stackVersion = session.StackVersion; if (thread != null) { this.frames = thread.GetFrames(); } else { this.frames = new MDB.StackFrame[0]; } }
// Like the above except exceptions are allowed to escape. public Value UnsafeInvoke(ThreadMirror thread, Value target, string name) { Contract.Requires(thread != null, "thread is null"); Contract.Requires(target != null, "target is null"); Contract.Requires(target is ObjectMirror || target is StructMirror, "target is a " + target.GetType().FullName); Contract.Requires(!name.IsNullOrWhiteSpace()); Value result; if (target is ObjectMirror) result = DoInvoke(thread, (ObjectMirror) target, name); else result = DoInvoke(thread, (StructMirror) target, name); return result; }
public void Write(System.IO.StreamWriter stream, ThreadMirror thread, int indent) { for (int i = 0; i < indent; ++i) { stream.Write('\t'); } string refCount = DoGetRefCount(thread); stream.WriteLine("{0}{1}\t\t\t\t{2}", Name, refCount, Type); foreach (Trace child in Children) { child.Write(stream, thread, indent + 1); } }
public static string GetThreadName(ThreadMirror thread) { string name = thread.Name; if (thread.Id == 1) // TODO: should we be using ThreadId here? name = "main"; else if (thread.Id == 2) name = "finalizer"; if (!string.IsNullOrEmpty(name)) name = string.Format("{0} ({1})", name, thread.Id); else name = thread.Id.ToString(); return name; }
public static void Set(ThreadMirror thread, VariableItem item, InstanceValue parent, int key, Value newValue) { FieldInfoMirror field = parent.Type.GetFields()[key]; Contract.Assert(!field.IsStatic); ObjectMirror o = parent.Instance as ObjectMirror; if (o != null) { o.SetValue(field, newValue); } else { var s = (StructMirror) parent.Instance; s.Fields[key] = newValue; SetValue.Invoke(thread, item.Parent, item.Parent.Parent.Value, item.Parent.Key, s); } }
public static VariableItem GetChild(ThreadMirror thread, VariableItem parentItem, LiveStackFrame parent, int index) { VariableItem child; IList<LocalVariable> locals = parent.GetVisibleVariables(); if (index < locals.Count) { LocalVariable local = locals[index]; string name = local.Name; if (string.IsNullOrEmpty(name)) name = "$" + local.Index; // temporary variable Value v = parent.GetValue(local); child = new VariableItem(thread, name, parentItem, local, v, index); } else { FieldInfoMirror[] fields = parent.Method.DeclaringType.GetAllFields().ToArray(); Contract.Assert(fields.Length > 0); object v = null; string name = "this"; if (parent.ThisPtr is ObjectMirror) { v = new InstanceValue((ObjectMirror) parent.ThisPtr, fields); } else if (parent.ThisPtr is StructMirror) { v = new InstanceValue((StructMirror) parent.ThisPtr, fields); } else if (parent.ThisPtr == null || parent.ThisPtr.IsNull()) { v = new TypeValue(parent.Method.DeclaringType); name = "statics"; } else { Contract.Assert(false, parent.ThisPtr.TypeName() + " is bogus"); } child = new VariableItem(thread, name, parentItem, index, v, index); } return child; }
public SoftEvaluationContext (SoftDebuggerSession session, StackFrame frame, DC.EvaluationOptions options): base (options) { Frame = frame; Thread = frame.Thread; string method = frame.Method.Name; if (frame.Method.DeclaringType != null) method = frame.Method.DeclaringType.FullName + "." + method; var location = new DC.SourceLocation (method, frame.FileName, frame.LineNumber); var lang = frame.Method != null? "Managed" : "Native"; Evaluator = session.GetResolver (new DC.StackFrame (frame.ILOffset, location, lang, session.IsExternalCode (frame), true)); Adapter = session.Adaptor; this.session = session; this.stackVersion = session.StackVersion; }
// Target should be a ObjectMirror or a StructMirror. Name should be the name of a // property (e.g. Count), field (eg Empty), or nullary method. Returns an error string. public static Value Evaluate(ThreadMirror thread, Value target, string name) { Contract.Requires(thread != null, "thread is null"); Contract.Requires(target != null, "target is null"); Contract.Requires(!string.IsNullOrEmpty(name), "name is null or empty"); Value result = null; // Try fields, if (target is ObjectMirror) result = DoGetField((ObjectMirror) target, name, thread); else if (target is StructMirror) result = DoGetField((StructMirror) target, name, thread); // properties. if (result == null) { if (target is ObjectMirror) result = DoEvaluateProperty(thread, (ObjectMirror) target, name); else if (target is StructMirror) result = DoEvaluateProperty(thread, (StructMirror) target, name); } // and methods. if (result == null) { if (target is ObjectMirror) result = DoEvaluateMethod(thread, (ObjectMirror) target, name); else if (target is StructMirror) result = DoEvaluateMethod(thread, (StructMirror) target, name); else Contract.Assert(false, "Expected an ObjectMirror or StructMirror but got a " + target.GetType().FullName); } if (result == null) result = target.VirtualMachine.RootDomain.CreateString(string.Empty); // usually ShouldEvaluate was false return result; }
private const int Timeout = 500; // TODO: might want to allow this to be set (especially when we get an immediate window) #endregion Fields #region Methods // Invokes a nullary method on an ObjectMirror or StructMirror. If the call // times out a StringMirror is returned with an error message. public Value Invoke(ThreadMirror thread, Value target, string name) { Contract.Requires(thread != null, "thread is null"); Contract.Requires(target != null, "target is null"); Contract.Requires(target is ObjectMirror || target is StructMirror, "target is a " + target.GetType().FullName); Contract.Requires(!name.IsNullOrWhiteSpace()); Value result; try { result = UnsafeInvoke(thread, target, name); } catch (Exception e) { result = thread.Domain.CreateString(e.Message); } return result; }
ThreadInfo GetThread (ProcessInfo process, ThreadMirror thread) { long tid = GetId (thread); foreach (var t in OnGetThreads (process.Id)) if (t.Id == tid) return t; return null; }
internal static void AbortInvoke (VirtualMachine vm, ThreadMirror thread, int id) { vm.conn.VM_AbortInvoke (thread.Id, id); }
// // Implementation of InvokeMultiple // internal static IInvokeAsyncResult BeginInvokeMultiple(VirtualMachine vm, ThreadMirror thread, MethodMirror[] methods, Value this_obj, IList <IList <Value> > arguments, InvokeOptions options, AsyncCallback callback, object state) { if (thread == null) { throw new ArgumentNullException("thread"); } if (methods == null) { throw new ArgumentNullException("methods"); } foreach (var m in methods) { if (m == null) { throw new ArgumentNullException("method"); } } if (arguments == null) { arguments = new List <IList <Value> > (); for (int i = 0; i < methods.Length; ++i) { arguments.Add(new Value [0]); } } else { // FIXME: Not needed for property evaluation throw new NotImplementedException(); } if (callback == null) { throw new ArgumentException("A callback argument is required for this method.", "callback"); } InvokeFlags f = InvokeFlags.NONE; if ((options & InvokeOptions.DisableBreakpoints) != 0) { f |= InvokeFlags.DISABLE_BREAKPOINTS; } if ((options & InvokeOptions.SingleThreaded) != 0) { f |= InvokeFlags.SINGLE_THREADED; } InvokeAsyncResult r = new InvokeAsyncResult { AsyncState = state, AsyncWaitHandle = new ManualResetEvent(false), VM = vm, Thread = thread, Callback = callback, NumPending = methods.Length, IsMultiple = true }; var mids = new long [methods.Length]; for (int i = 0; i < methods.Length; ++i) { mids [i] = methods [i].Id; } var args = new List <ValueImpl[]> (); for (int i = 0; i < methods.Length; ++i) { args.Add(vm.EncodeValues(arguments [i])); } thread.InvalidateFrames(); r.ID = vm.conn.VM_BeginInvokeMethods(thread.Id, mids, this_obj != null ? vm.EncodeValue(this_obj) : vm.EncodeValue(vm.CreateValue(null)), args, f, InvokeMultipleCB, r); return(r); }
public Task<InvokeResult> InvokeMethodAsyncWithResult (ThreadMirror thread, MethodMirror method, IList<Value> arguments, InvokeOptions options = InvokeOptions.None) { var tcs = new TaskCompletionSource<InvokeResult> (); BeginInvokeMethod (thread, method, arguments, options, iar => { try { tcs.SetResult (EndInvokeMethodInternalWithResult (iar)); } catch (OperationCanceledException) { tcs.TrySetCanceled (); } catch (Exception ex) { tcs.TrySetException (ex); } }, null); return tcs.Task; }
internal static IInvokeAsyncResult BeginInvokeMethod (VirtualMachine vm, ThreadMirror thread, MethodMirror method, Value this_obj, IList<Value> arguments, InvokeOptions options, AsyncCallback callback, object state) { if (thread == null) throw new ArgumentNullException ("thread"); if (method == null) throw new ArgumentNullException ("method"); if (arguments == null) arguments = new Value [0]; InvokeFlags f = InvokeFlags.NONE; if ((options & InvokeOptions.DisableBreakpoints) != 0) f |= InvokeFlags.DISABLE_BREAKPOINTS; if ((options & InvokeOptions.SingleThreaded) != 0) f |= InvokeFlags.SINGLE_THREADED; if ((options & InvokeOptions.ReturnOutThis) != 0) f |= InvokeFlags.OUT_THIS; if ((options & InvokeOptions.ReturnOutArgs) != 0) f |= InvokeFlags.OUT_ARGS; InvokeAsyncResult r = new InvokeAsyncResult { AsyncState = state, AsyncWaitHandle = new ManualResetEvent (false), VM = vm, Thread = thread, Callback = callback }; thread.InvalidateFrames (); r.ID = vm.conn.VM_BeginInvokeMethod (thread.Id, method.Id, this_obj != null ? vm.EncodeValue (this_obj) : vm.EncodeValue (vm.CreateValue (null)), vm.EncodeValues (arguments), f, InvokeCB, r); return r; }
public ObjectMirror GetExceptionObject (ThreadMirror thread) { ObjectMirror obj; if (activeExceptionsByThread.TryGetValue (thread.ThreadId, out obj)) return obj; else return null; }
public Value InvokeMethod (ThreadMirror thread, MethodMirror method, IList<Value> arguments, InvokeOptions options) { return InvokeMethod (vm, thread, method, this, arguments, options); }
internal void AddThreadToInvalidateList(ThreadMirror threadMirror) { lock (threadsToInvalidate) { threadsToInvalidate.Add(threadMirror); } }
public Task <InvokeResult> InvokeMethodAsyncWithResult(ThreadMirror thread, MethodMirror method, IList <Value> arguments, InvokeOptions options = InvokeOptions.None) { return(ObjectMirror.InvokeMethodAsyncWithResult(vm, thread, method, this, arguments, options)); }
public Value InvokeMethod(ThreadMirror thread, MethodMirror method, IList <Value> arguments, InvokeOptions options) { return(ObjectMirror.InvokeMethod(vm, thread, method, this, arguments, options)); }
public Value NewInstance(ThreadMirror thread, MethodMirror method, IList <Value> arguments, InvokeOptions options) { return(ObjectMirror.InvokeMethod(vm, thread, method, null, arguments, options)); }
public Value InvokeMethod(ThreadMirror thread, MethodMirror method, IList <Value> arguments) { return(ObjectMirror.InvokeMethod(vm, thread, method, null, arguments, InvokeOptions.None)); }
internal T GetObject <T> (long id, long domain_id, long type_id) where T : ObjectMirror { ObjectMirror obj = null; lock (objects_lock) { if (objects == null) { objects = new Dictionary <long, ObjectMirror> (); } objects.TryGetValue(id, out obj); } if (obj == null) { /* * Obtain the domain/type of the object to determine the type of * object we need to create. Do this outside the lock. */ if (domain_id == 0 || type_id == 0) { if (conn.Version.AtLeast(2, 5)) { var info = conn.Object_GetInfo(id); domain_id = info.domain_id; type_id = info.type_id; } else { if (domain_id == 0) { domain_id = conn.Object_GetDomain(id); } if (type_id == 0) { type_id = conn.Object_GetType(id); } } } AppDomainMirror d = GetDomain(domain_id); TypeMirror t = GetType(type_id); if (t.Assembly == d.Corlib && t.Namespace == "System.Threading" && t.Name == "Thread") { obj = new ThreadMirror(this, id, t, d); } else if (t.Assembly == d.Corlib && t.Namespace == "System" && t.Name == "String") { obj = new StringMirror(this, id, t, d); } else if (typeof(T) == typeof(ArrayMirror)) { obj = new ArrayMirror(this, id, t, d); } else { obj = new ObjectMirror(this, id, t, d); } // Publish lock (objects_lock) { ObjectMirror prev_obj; if (objects.TryGetValue(id, out prev_obj)) { obj = prev_obj; } else { objects [id] = obj; } } } return((T)obj); }
public StepEventRequest CreateStepRequest(ThreadMirror thread) { return(new StepEventRequest(this, thread)); }
public IAsyncResult BeginInvokeMethod(ThreadMirror thread, MethodMirror method, IList <Value> arguments, InvokeOptions options, AsyncCallback callback, object state) { return(ObjectMirror.BeginInvokeMethod(vm, thread, method, this, arguments, options, callback, state)); }
public Value NewInstance(ThreadMirror thread, MethodMirror method, IList <Value> arguments) { return(NewInstance(thread, method, arguments, InvokeOptions.None)); }
Backtrace GetThreadBacktrace (ThreadMirror thread) { return new Backtrace (new SoftDebuggerBacktrace (this, thread)); }
public SdbThreadMirror(MDS.ThreadMirror threadMirror) : base(threadMirror) { }
void HandleBreakEventSet (Event[] es, bool dequeuing) { if (dequeuing && exited) return; OnHandleBreakEventSet (es); bool resume = true; ObjectMirror exception = null; TargetEventType etype = TargetEventType.TargetStopped; BreakEvent breakEvent = null; if (es[0] is ExceptionEvent) { var bad = es.FirstOrDefault (ee => !(ee is ExceptionEvent)); if (bad != null) throw new Exception ("Catchpoint eventset had unexpected event type " + bad.GetType ()); var ev = (ExceptionEvent)es[0]; if (ev.Request == unhandledExceptionRequest) etype = TargetEventType.UnhandledException; else etype = TargetEventType.ExceptionThrown; exception = ev.Exception; if (ev.Request != unhandledExceptionRequest || exception.Type.FullName != "System.Threading.ThreadAbortException") resume = false; } else { //always need to evaluate all breakpoints, some might be tracepoints or conditional bps with counters foreach (Event e in es) { BreakpointEvent be = e as BreakpointEvent; if (be != null) { if (!HandleBreakpoint (e.Thread, be.Request)) { etype = TargetEventType.TargetHitBreakpoint; BreakInfo binfo; if (breakpoints.TryGetValue (be.Request, out binfo)) breakEvent = binfo.BreakEvent; resume = false; } } else if (e is StepEvent) { etype = TargetEventType.TargetStopped; resume = false; } else { throw new Exception ("Break eventset had unexpected event type " + e.GetType ()); } } } if (resume) { //all breakpoints were conditional and evaluated as false vm.Resume (); DequeueEventsForFirstThread (); } else { if (currentStepRequest != null) { currentStepRequest.Enabled = false; currentStepRequest = null; } current_thread = recent_thread = es[0].Thread; TargetEventArgs args = new TargetEventArgs (etype); args.Process = OnGetProcesses () [0]; args.Thread = GetThread (args.Process, current_thread); args.Backtrace = GetThreadBacktrace (current_thread); args.BreakEvent = breakEvent; if (exception != null) activeExceptionsByThread [current_thread.ThreadId] = exception; OnTargetEvent (args); } }
internal static Value InvokeMethod(VirtualMachine vm, ThreadMirror thread, MethodMirror method, Value this_obj, IList <Value> arguments, InvokeOptions options) { return(EndInvokeMethodInternal(BeginInvokeMethod(vm, thread, method, this_obj, arguments, options, null, null))); }
void DequeueEventsForFirstThread () { List<List<Event>> dequeuing; lock (queuedEventSets) { if (queuedEventSets.Count < 1) return; dequeuing = new List<List<Event>> (); var node = queuedEventSets.First; //making this the current thread means that all events from other threads will get queued current_thread = node.Value[0].Thread; while (node != null) { if (node.Value[0].Thread.Id == current_thread.Id) { var d = node; node = node.Next; dequeuing.Add (d.Value); queuedEventSets.Remove (d); } else { node = node.Next; } } } #if DEBUG_EVENT_QUEUEING foreach (var e in dequeuing) Console.WriteLine ("dq eventset({0}): {1}", e.Count, e[0]); #endif //firing this off in a thread prevents possible infinite recursion ThreadPool.QueueUserWorkItem (delegate { if (!exited) { foreach (var es in dequeuing) { try { HandleBreakEventSet (es.ToArray (), true); } catch (VMDisconnectedException ex) { if (!HandleException (ex)) OnDebuggerOutput (true, ex.ToString ()); break; } catch (Exception ex) { if (!HandleException (ex)) OnDebuggerOutput (true, ex.ToString ()); } } } }); }
// // Invoke the members of METHODS one-by-one, calling CALLBACK after each invoke was finished. The IAsyncResult will be marked as completed after all invokes have // finished. The callback will be called with a different IAsyncResult that represents one method invocation. // From protocol version 2.22. // public IAsyncResult BeginInvokeMultiple(ThreadMirror thread, MethodMirror[] methods, IList <IList <Value> > arguments, InvokeOptions options, AsyncCallback callback, object state) { return(BeginInvokeMultiple(vm, thread, methods, this, arguments, options, callback, state)); }
public IAsyncResult BeginInvokeMethod (VirtualMachine vm, ThreadMirror thread, MethodMirror method, IList<Value> arguments, InvokeOptions options, AsyncCallback callback, object state) { return BeginInvokeMethod (vm, thread, method, this, arguments, options, callback, state); }
internal static Task <TResult> InvokeMethodAsync <TResult> (VirtualMachine vm, ThreadMirror thread, MethodMirror method, Value this_obj, IList <Value> arguments, InvokeOptions options, Func <IAsyncResult, TResult> callback) { var tcs = new TaskCompletionSource <TResult> (); BeginInvokeMethod(vm, thread, method, this_obj, arguments, options, iar => { try { tcs.SetResult(callback(iar)); } catch (OperationCanceledException) { tcs.TrySetCanceled(); } catch (Exception ex) { tcs.TrySetException(ex); } }, null); return(tcs.Task); }
// // Invoke the members of METHODS one-by-one, calling CALLBACK after each invoke was finished. The IAsyncResult will be marked as completed after all invokes have // finished. The callback will be called with a different IAsyncResult that represents one method invocation. // From protocol version 2.22. // public IAsyncResult BeginInvokeMultiple (ThreadMirror thread, MethodMirror[] methods, IList<IList<Value>> arguments, InvokeOptions options, AsyncCallback callback, object state) { return BeginInvokeMultiple (vm, thread, methods, this, arguments, options, callback, state); }
internal static Task <InvokeResult> InvokeMethodAsyncWithResult(VirtualMachine vm, ThreadMirror thread, MethodMirror method, Value this_obj, IList <Value> arguments, InvokeOptions options) { return(InvokeMethodAsync(vm, thread, method, this_obj, arguments, options, EndInvokeMethodInternalWithResult)); }
internal static Value InvokeMethod (VirtualMachine vm, ThreadMirror thread, MethodMirror method, Value this_obj, IList<Value> arguments, InvokeOptions options) { return EndInvokeMethodInternal (BeginInvokeMethod (vm, thread, method, this_obj, arguments, options, null, null)); }
public Task <Value> InvokeMethodAsync(ThreadMirror thread, MethodMirror method, IList <Value> arguments, InvokeOptions options = InvokeOptions.None) { return(InvokeMethodAsync(vm, thread, method, this, arguments, options)); }
// // Implementation of InvokeMultiple // internal static IInvokeAsyncResult BeginInvokeMultiple (VirtualMachine vm, ThreadMirror thread, MethodMirror[] methods, Value this_obj, IList<IList<Value>> arguments, InvokeOptions options, AsyncCallback callback, object state) { if (thread == null) throw new ArgumentNullException ("thread"); if (methods == null) throw new ArgumentNullException ("methods"); foreach (var m in methods) if (m == null) throw new ArgumentNullException ("method"); if (arguments == null) { arguments = new List<IList<Value>> (); for (int i = 0; i < methods.Length; ++i) arguments.Add (new Value [0]); } else { // FIXME: Not needed for property evaluation throw new NotImplementedException (); } if (callback == null) throw new ArgumentException ("A callback argument is required for this method.", "callback"); InvokeFlags f = InvokeFlags.NONE; if ((options & InvokeOptions.DisableBreakpoints) != 0) f |= InvokeFlags.DISABLE_BREAKPOINTS; if ((options & InvokeOptions.SingleThreaded) != 0) f |= InvokeFlags.SINGLE_THREADED; InvokeAsyncResult r = new InvokeAsyncResult { AsyncState = state, AsyncWaitHandle = new ManualResetEvent (false), VM = vm, Thread = thread, Callback = callback, NumPending = methods.Length, IsMultiple = true }; var mids = new long [methods.Length]; for (int i = 0; i < methods.Length; ++i) mids [i] = methods [i].Id; var args = new List<ValueImpl[]> (); for (int i = 0; i < methods.Length; ++i) args.Add (vm.EncodeValues (arguments [i])); thread.InvalidateFrames (); r.ID = vm.conn.VM_BeginInvokeMethods (thread.Id, mids, this_obj != null ? vm.EncodeValue (this_obj) : vm.EncodeValue (vm.CreateValue (null)), args, f, InvokeMultipleCB, r); return r; }
internal static void AbortInvoke(VirtualMachine vm, ThreadMirror thread, int id) { vm.conn.VM_AbortInvoke(thread.Id, id); }