func makeEnv() *eval.SimpleEnv {
env := eval.MakeSimpleEnv()
env.Consts["constant1"] = reflect.ValueOf(constant1)
var1 := 1
env.Vars["var1"] = reflect.ValueOf(&var1)
env.Funcs["add"] = reflect.ValueOf(func(a, b int) int { return a + b })
fmtPkg := eval.MakeSimpleEnv()
fmtPkg.Funcs["Sprintf"] = reflect.ValueOf(fmt.Sprintf)
env.Pkgs["fmt"] = fmtPkg
return env
}
func main() {
simpleEnv := eval.MakeSimpleEnv()
v := 4
c := "CONSTANT"
simpleEnv.Vars["v"] = reflect.ValueOf(&v)
simpleEnv.Consts["c"] = reflect.ValueOf(c)
env := &CustomEnv{simpleEnv}
expectResult("v + 1", env, "6")
expectResult("c + \" value\"", env, "constant value")
}
// Create an eval.Env environment to use in evaluation.
// This is a bit ugly here, because we are rolling everything by hand, but
// we want some sort of environment to show off in demo'ing.
// The artifical environment we create here consists of
// fmt:
// fns: fmt.Println, fmt.Printf
// os:
// types: MyInt
// vars: Stdout, Args
// main:
// type Alice
// var alice, aliceptr
//
// (REPL also adds var results to main)
//
// See make_env in github.com/rocky/go-fish for an automated way to
// create more complete environment from a starting import.
func makeBogusEnv() *eval.SimpleEnv {
// A copule of things from the fmt package.
var fmt_funcs map[string]reflect.Value = make(map[string]reflect.Value)
fmt_funcs["Println"] = reflect.ValueOf(fmt.Println)
fmt_funcs["Printf"] = reflect.ValueOf(fmt.Printf)
// A simple type for demo
type MyInt int
// A stripped down package environment. See
// http://github.com/rocky/go-fish and repl_imports.go for a more
// complete environment.
pkgs := map[string]eval.Env{
"fmt": &eval.SimpleEnv{
Vars: make(map[string]reflect.Value),
Consts: make(map[string]reflect.Value),
Funcs: fmt_funcs,
Types: make(map[string]reflect.Type),
Pkgs: nil,
}, "os": &eval.SimpleEnv{
Vars: map[string]reflect.Value{
"Stdout": reflect.ValueOf(&os.Stdout),
"Args": reflect.ValueOf(&os.Args)},
Consts: make(map[string]reflect.Value),
Funcs: make(map[string]reflect.Value),
Types: map[string]reflect.Type{
"MyInt": reflect.TypeOf(*new(MyInt))},
Pkgs: nil,
},
}
mainEnv := eval.MakeSimpleEnv()
mainEnv.Pkgs = pkgs
// Some "alice" things for testing
type Alice struct {
Bob int
Secret string
}
type R rune
alice := Alice{1, "shhh"}
alicePtr := &alice
foo := 10
ints := []int{1, 2, 3, 4}
add := func(a, b int) int {
return a + b
}
sum := func(as ...int) int {
r := 0
for _, a := range as {
r += a
}
return r
}
mainEnv.Vars["alice"] = reflect.ValueOf(&alice)
mainEnv.Vars["alicePtr"] = reflect.ValueOf(&alicePtr)
mainEnv.Vars["foo"] = reflect.ValueOf(&foo)
mainEnv.Vars["ints"] = reflect.ValueOf(&ints)
mainEnv.Consts["bar"] = reflect.ValueOf(eval.NewConstInt64(5))
mainEnv.Funcs["add"] = reflect.ValueOf(add)
mainEnv.Funcs["sum"] = reflect.ValueOf(sum)
mainEnv.Types["Alice"] = reflect.TypeOf(Alice{})
mainEnv.Types["R"] = reflect.TypeOf(R(0))
var xi *XI = new(XI)
var yi *YI = new(YI)
var zi *ZI = new(ZI)
*xi = XI(X(0))
*yi = YI(Y(0))
*zi = ZI(Z(0))
mainEnv.Types["XI"] = reflect.TypeOf(xi).Elem()
mainEnv.Types["YI"] = reflect.TypeOf(yi).Elem()
mainEnv.Types["ZI"] = reflect.TypeOf(zi).Elem()
mainEnv.Types["X"] = reflect.TypeOf(X(0))
mainEnv.Types["Y"] = reflect.TypeOf(Y(0))
mainEnv.Types["Z"] = reflect.TypeOf(Z(0))
return mainEnv
}
