public RuntimeValue[] GetStackFrameValueAll(uint pid, uint depth, uint cValues, StackValueKind kind) { WireProtocol.OutgoingMessage[] cmds = new WireProtocol.OutgoingMessage[cValues]; RuntimeValue[] vals = null; uint i; for (i = 0; i < cValues; i++) { cmds[i] = CreateMessage_GetValue_Stack(pid, depth, kind, i); } WireProtocol.IncomingMessage[] replies = SyncMessages(cmds); if (replies != null) { vals = new RuntimeValue[cValues]; for (i = 0; i < cValues; i++) { WireProtocol.Commands.Debugging_Value_Reply reply = replies[i].Payload as WireProtocol.Commands.Debugging_Value_Reply; if (reply != null) { vals[i] = RuntimeValue.Convert(this, reply.m_values); } } } return vals; }
internal Request(Engine parent, WireProtocol.OutgoingMessage req, int retries, int timeout, CommandEventHandler callback) { if (retries < 0) { throw new ArgumentException("Value cannot be negative", "retries"); } if (timeout < 1 || timeout > 60 * 60 * 1000) { throw new ArgumentException(String.Format("Value out of bounds: {0}", timeout), "timeout"); } m_parent = parent; m_req = req; m_retries = retries; m_timeoutRetry = new TimeSpan(timeout * TimeSpan.TicksPerMillisecond); m_timeoutWait = new TimeSpan((retries == 0 ? 1 : 2 * retries) * timeout * TimeSpan.TicksPerMillisecond); m_callback = callback; if (callback == null) { m_event = new ManualResetEvent(false); } }
public bool Reply(Converter converter, uint flags, object payload) { OutgoingMessage msgReply = new OutgoingMessage(this, converter, flags, payload); return(msgReply.Send()); }
public WireProtocol.Commands.Debugging_Resolve_Assembly[] ResolveAllAssemblies() { WireProtocol.Commands.Debugging_TypeSys_Assemblies.Reply assemblies = GetAssemblies(); WireProtocol.Commands.Debugging_Resolve_Assembly[] resolveAssemblies = null; if (assemblies == null || assemblies.m_data == null) { resolveAssemblies = new WireProtocol.Commands.Debugging_Resolve_Assembly[0]; } else { int cAssembly = assemblies.m_data.Length; WireProtocol.OutgoingMessage[] requests = new WireProtocol.OutgoingMessage[cAssembly]; int iAssembly; for (iAssembly = 0; iAssembly < cAssembly; iAssembly++) { WireProtocol.Commands.Debugging_Resolve_Assembly cmd = new WireProtocol.Commands.Debugging_Resolve_Assembly(); cmd.m_idx = assemblies.m_data[iAssembly]; requests[iAssembly] = CreateMessage(WireProtocol.Commands.c_Debugging_Resolve_Assembly, 0, cmd); } WireProtocol.IncomingMessage[] replies = SyncMessages(requests); resolveAssemblies = new WireProtocol.Commands.Debugging_Resolve_Assembly[cAssembly]; for (iAssembly = 0; iAssembly < cAssembly; iAssembly++) { resolveAssemblies[iAssembly] = requests[iAssembly].Payload as WireProtocol.Commands.Debugging_Resolve_Assembly; resolveAssemblies[iAssembly].m_reply = replies[iAssembly].Payload as WireProtocol.Commands.Debugging_Resolve_Assembly.Reply; } } return resolveAssemblies; }
static public bool ReplyBadPacket( IController ctrl, uint flags ) { //What is this for? Nack + Ping? What can the TinyCLR possibly do with this information? OutgoingMessage msg = new OutgoingMessage( ctrl, null, Commands.c_Monitor_Ping, Flags.c_NonCritical | Flags.c_NACK | flags, null ); return msg.Send(); }
public bool Reply( Converter converter, uint flags, object payload ) { OutgoingMessage msgReply = new OutgoingMessage( this, converter, flags, payload ); return msgReply.Send(); }
public async Task <bool> ReplyAsync(Converter converter, uint flags, object payload) { OutgoingMessage msgReply = new OutgoingMessage(this, converter, flags, payload); return(await msgReply.SendAsync().ConfigureAwait(false)); }
private IncomingMessage[ ] SyncMessages( OutgoingMessage[ ] messages ) { return SyncMessages( messages, 2, 1000 ); }
private IncomingMessage[ ] SyncMessages( OutgoingMessage[ ] messages, int retries, int timeout ) { int cMessage = messages.Length; IncomingMessage[ ] replies = new IncomingMessage[ cMessage ]; Request[ ] requests = new Request[ cMessage ]; for( int iMessage = 0; iMessage < cMessage; iMessage++ ) { replies[ iMessage ] = SyncRequest( messages[ iMessage ], retries, timeout ); } return replies; }
internal IncomingMessage SyncRequest( OutgoingMessage msg, int retries, int timeout ) { // Lock on m_ReqSyncLock object, so only one thread is active inside the block. lock( m_ReqSyncLock ) { Request req = AsyncRequest( msg, retries, timeout ); return req != null ? req.Wait( ) : null; } }
internal Request AsyncRequest( OutgoingMessage msg, int retries, int timeout ) { Request req = new Request( this, msg, retries, timeout, null ); lock( m_state.SyncObject ) { //Checking whether IsRunning and adding the request to m_requests //needs to be atomic to avoid adding a request after the Engine //has been stopped. if( !IsRunning ) { throw new ApplicationException( "Engine is not running or process has exited." ); } m_requests.Add( req ); req.SendAsync( ); } return req; }