func (n *node) Walk(in func(n *node) bool, out func(n *node)) {
	if in != nil && !in(n) {
		return
	}
	for _, child := range n.child {
		child.Walk(in, out)
	}
	if out != nil {
		out(n)
	}
}
Walk traverses AST n in depth first order, call cbin function
at node entry and cbout function at node exit.
package interp
import (
	"bufio"
	"fmt"
	"go/build"
	"go/scanner"
	"go/token"
	"os"
	"reflect"
	"strconv"
)
type node struct {
	child  []*node         
	anc    *node           
	start  *node           
	tnext  *node           
	fnext  *node           
	interp *Interpreter    
	frame  *frame          
	index  int             
	findex int             
	level  int             
	nleft  int             
	nright int             
	kind   nkind           
	pos    token.Pos       
	sym    *symbol         
	typ    *itype          
	recv   *receiver       
	types  []reflect.Type  
	action action          
	exec   bltn            
	gen    bltnGenerator   
	val    interface{}     
	rval   reflect.Value   
	ident  string          
}
type receiver struct {
	node  *node          
	val   reflect.Value  
	index []int          
}
type frame struct {
	anc       *frame             
	data      []reflect.Value    
	deferred  [][]reflect.Value  
	recovered interface{}        
}
type Exports map[string]map[string]reflect.Value
type imports map[string]map[string]*symbol
type opt struct {
	astDot  bool           
	cfgDot  bool           
	noRun   bool           
	context build.Context  
}
type Interpreter struct {
	Name string  
	opt
	frame    *frame             
	nindex   int                
	fset     *token.FileSet     
	universe *scope             
	scopes   map[string]*scope  
	binPkg   Exports            
	srcPkg   imports            
	rdir     map[string]bool    
}
const (
	mainID   = "main"
	selfPath = "github.com/containous/yaegi/interp"
)
var Symbols = Exports{
	selfPath: map[string]reflect.Value{
		"New": reflect.ValueOf(New),
		"Interpreter": reflect.ValueOf((*Interpreter)(nil)),
		"Options":     reflect.ValueOf((*Options)(nil)),
	},
}
func init() { Symbols[selfPath]["Symbols"] = reflect.ValueOf(Symbols) }
type _error struct {
	WError func() string
}
func (w _error) Error() string { return w.WError() }