Esempio n. 1
0
//makeEnv creates an environment to use in eval
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

}
Esempio n. 2
0
func writeImport(w io.Writer, pkg *ast.Package, pkgPath string) error {
	var files []*ast.File
	for _, f := range pkg.Files {
		if ast.FileExports(f) {
			files = append(files, f)
		}
	}
	env := eval.MakeSimpleEnv()
	env.Path = pkgPath
	for _, f := range files {
		for _, d := range f.Decls {
			if gen, ok := d.(*ast.GenDecl); ok {
				for _, s := range gen.Specs {
					if v, ok := s.(*ast.ValueSpec); ok {
						for _, i := range v.Names {
							if gen.Tok == token.VAR {
								env.Vars[i.Name] = reflect.Value{}
							} else {
								env.Consts[i.Name] = reflect.Value{}
							}
						}
					} else if t, ok := s.(*ast.TypeSpec); ok {
						env.Types[t.Name.Name] = nil
					}
				}
			} else if fun, ok := d.(*ast.FuncDecl); ok && fun.Recv == nil {
				env.Funcs[fun.Name.Name] = reflect.Value{}
			}
		}
	}
	return writePkg(w, env, pkg.Name)
}
Esempio n. 3
0
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")

}
Esempio n. 4
0
// 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
}
Esempio n. 5
0
File: main.go Progetto: 0xfaded/gack
func main() {
	gack.Repl(eval.MakeSimpleEnv(), nil)
}