func Select(c *Context, s *Scope, line int) {
	if !shouldPause(c) {
		return
	}
	Line(c, s, line)
	if currentState != run {
		fmt.Println("< Evaluating channel expressions and RHS of send expressions. >")
	}
}
Select marks a select statement.
package godebug
import (
	"bufio"
	"fmt"
	"os"
	"reflect"
	"strings"
	"sync/atomic"
	"unicode"
	"unsafe"
	"github.com/mailgun/godebug/Godeps/_workspace/src/github.com/0xfaded/eval"
)
var buildMode = ""  
const (
	run int32 = iota
	next
	step
)
type contextManager interface {
	GetValue(key interface{}) (value interface{}, ok bool)
	SetValues(contextCall func(), keyVal ...interface{})
}
var (
	currentState     int32
	currentDepth     int
	debuggerDepth    int
	justLeft         bool  
	context          = getContextManager()
	goroutineKey     = 0
	currentGoroutine uint32
	ids              idPool
)
func EnterFunc(fn func()) (ctx *Context, proceed bool) {
	val, ok := context.GetValue(goroutineKey)
	if !ok {
		id := uint32(ids.Acquire())
		defer ids.Release(uint(id))
		context.SetValues(fn, goroutineKey, id)
		return nil, false
	}
	if val.(uint32) == atomic.LoadUint32(&currentGoroutine) && currentState != run {
		if justLeft {
			debuggerDepth++
			justLeft = false
		}
		currentDepth++
	}
	return &Context{goroutine: val.(uint32)}, true
}
func EnterFuncLit(fn func(*Context)) (ctx *Context, proceed bool) {
	val, ok := context.GetValue(goroutineKey)
	if !ok {
		id := uint32(ids.Acquire())
		defer ids.Release(uint(id))
		context.SetValues(func() {
			fn(&Context{goroutine: id})
		}, goroutineKey, id)
		return nil, false
	}
	if val.(uint32) == atomic.LoadUint32(&currentGoroutine) && currentState != run {
		if justLeft {
			debuggerDepth++
			justLeft = false
		}
		currentDepth++
	}
	return &Context{goroutine: val.(uint32)}, true
}
func EnterFuncWithRecovers(r chan chan interface{}, fn func(*Context)) (<-chan chan interface{}, chan interface{}) {
	var (
		quit      = make(chan struct{})
		recovers  = make(chan chan interface{})
		rr        = make(chan interface{})
		panicChan = make(chan interface{})
		ctx       *Context
		ok        bool
	)
	go func() {
		for {
			select {
			case <-quit:
				return
			case r <- rr:  
				recovers <- rr  
			}
		}
	}()
	Go(func() {
		didPanic := true
		defer func() {
			close(quit)
			close(recovers)
			if didPanic {
				panicChan <- recover()
			}
			close(panicChan)
		}()
		if ctx, ok = EnterFuncLit(fn); ok {
			defer ExitFunc(ctx)
			fn(ctx)
		}
		didPanic = false
	})
	return recovers, panicChan
}
func ExitFunc(ctx *Context) {
	if atomic.LoadUint32(&currentGoroutine) != ctx.goroutine {
		return
	}
	if currentState == run {
		return
	}
	if currentState == next && currentDepth == debuggerDepth {
		debuggerDepth--
		justLeft = true
	}
	currentDepth--
}
type Context struct {
	goroutine uint32
}
type caseSentinel int
func Case(c *Context, s *Scope, line int) interface{} {
	Line(c, s, line)
	return caseSentinel(0)
}
func Comm(c *Context, s *Scope, line int) chan struct{} {
	Line(c, s, line)
	return nil
}
func EndSelect(c *Context, s *Scope) chan struct{} {
	if shouldPause(c) {
		fmt.Println("< All channel expressions evaluated. Choosing case to proceed. >")
	}
	return nil
}