// State returns the current state of the debugger. func (d *Debugger) State() (*api.DebuggerState, error) { if d.process.Exited() { return nil, proc.ProcessExitedError{Pid: d.ProcessPid()} } var ( state *api.DebuggerState goroutine *api.Goroutine ) if d.process.SelectedGoroutine != nil { goroutine = api.ConvertGoroutine(d.process.SelectedGoroutine) } state = &api.DebuggerState{ SelectedGoroutine: goroutine, Exited: d.process.Exited(), } for i := range d.process.Threads { th := api.ConvertThread(d.process.Threads[i]) state.Threads = append(state.Threads, th) if i == d.process.CurrentThread.ID { state.CurrentThread = th } } return state, nil }
func (c *RPCClient) Continue() <-chan *api.DebuggerState { ch := make(chan *api.DebuggerState) c.haltMu.Lock() c.haltReq = false c.haltMu.Unlock() go func() { for { c.haltMu.Lock() if c.haltReq { c.haltMu.Unlock() close(ch) return } c.haltMu.Unlock() state := new(api.DebuggerState) err := c.call("Command", &api.DebuggerCommand{Name: api.Continue}, state) if err != nil { state.Err = err } if state.Exited { // Error types apparently cannot be marshalled by Go correctly. Must reset error here. state.Err = fmt.Errorf("Process %d has exited with status %d", c.ProcessPid(), state.ExitStatus) } ch <- state if err != nil || state.Exited { close(ch) return } isbreakpoint := false istracepoint := true for i := range state.Threads { if state.Threads[i].Breakpoint != nil { isbreakpoint = true istracepoint = istracepoint && state.Threads[i].Breakpoint.Tracepoint } } if !isbreakpoint || !istracepoint { close(ch) return } } }() return ch }
func (c *RPCClient) Continue() <-chan *api.DebuggerState { ch := make(chan *api.DebuggerState) go func() { for { state := new(api.DebuggerState) err := c.call("Command", &api.DebuggerCommand{Name: api.Continue}, state) if err != nil { state.Err = err } if state.Exited { // Error types apparantly cannot be marshalled by Go correctly. Must reset error here. state.Err = fmt.Errorf("Process %d has exited with status %d", c.ProcessPid(), state.ExitStatus) } ch <- state if err != nil || state.Exited || state.Breakpoint == nil || !state.Breakpoint.Tracepoint { close(ch) return } } }() return ch }
func (d *Debugger) collectBreakpointInformation(state *api.DebuggerState) error { if state == nil || state.Breakpoint == nil { return nil } bp := state.Breakpoint bpi := &api.BreakpointInfo{} state.BreakpointInfo = bpi if bp.Goroutine { g, err := d.process.CurrentThread.GetG() if err != nil { return err } bpi.Goroutine = api.ConvertGoroutine(g) } if bp.Stacktrace > 0 { rawlocs, err := d.process.CurrentThread.Stacktrace(bp.Stacktrace) if err != nil { return err } bpi.Stacktrace, err = d.convertStacktrace(rawlocs, false) if err != nil { return err } } s, err := d.process.CurrentThread.Scope() if err != nil { return err } if len(bp.Variables) > 0 { bpi.Variables = make([]api.Variable, len(bp.Variables)) } for i := range bp.Variables { v, err := s.EvalVariable(bp.Variables[i]) if err != nil { return err } bpi.Variables[i] = api.ConvertVar(v) } vars, err := functionArguments(s) if err == nil { bpi.Arguments = vars } return nil }