added

vendor/github.com/glycerine/zygomys/zygo/callgo.go

@@ -0,0 +1,209 @@
+package zygo
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+)
+
+// call Go methods
+
+// Using reflection, invoke a Go method on a struct or interface.
+// args[0] is a hash with an an attached GoStruct
+// args[1] is a hash representing a method call on that struct.
+// The returned Sexp is a hash that represents the result of that call.
+func CallGoMethodFunction(env *Zlisp, name string, args []Sexp) (Sexp, error) {
+	Q("_method user func running!\n")
+
+	// protect against bad calls/bad reflection
+	var wasPanic bool
+	var recovered interface{}
+	tr := make([]byte, 16384)
+	trace := &tr
+	sx, err := func() (Sexp, error) {
+		defer func() {
+			recovered = recover()
+			if recovered != nil {
+				wasPanic = true
+				nbyte := runtime.Stack(*trace, false)
+				*trace = (*trace)[:nbyte]
+			}
+		}()
+
+		narg := len(args)
+		if narg < 2 {
+			return SexpNull, WrongNargs
+		}
+		obj, isHash := args[0].(*SexpHash)
+		if !isHash {
+			return SexpNull, fmt.Errorf("_method error: first argument must be a hash or defmap (a record) with an attached GoObject")
+		}
+
+		var methodname string
+		switch m := args[1].(type) {
+		case *SexpSymbol:
+			methodname = m.name
+		case *SexpStr:
+			methodname = m.S
+		default:
+			return SexpNull, fmt.Errorf("_method error: second argument must be a method name in symbol or string form (got %T)", args[1])
+		}
+
+		// get the method list, verify the method exists and get its type
+		if obj.NumMethod == -1 {
+			err := obj.SetMethodList(env)
+			if err != nil {
+				return SexpNull, fmt.Errorf("could not get method list for object: %s", err)
+			}
+		}
+
+		var method reflect.Method
+		found := false
+		for _, me := range obj.GoMethods {
+			if me.Name == methodname {
+				method = me
+				found = true
+				break
+			}
+		}
+		if !found {
+			return SexpNull, fmt.Errorf("no such method '%s' on %s. choices are: %s",
+				methodname, obj.TypeName,
+				(obj.GoMethSx).SexpString(nil))
+		}
+		// INVAR: var method holds our call target
+
+		// try always expecting this to be already done... test crashes
+		//P("in CallGoMethod '%s' obj.GoShadowStructVa = '%#v'", methodname, obj.GoShadowStructVa)
+		if obj.GoShadowStructVa.Kind() == reflect.Invalid {
+			// ready the struct... but only because there isn't already a shadow struct there!!
+			if !obj.ShadowSet {
+				_, err := ToGoFunction(env, "togo", []Sexp{obj})
+				if err != nil {
+					return SexpNull, fmt.Errorf("error converting object to Go struct: '%s'", err)
+				}
+			}
+		}
+		inputVa := []reflect.Value{(obj.GoShadowStructVa)}
+
+		// prep args.
+		needed := method.Type.NumIn() - 1 // one for the receiver
+		avail := narg - 2
+		if needed != avail {
+			// TODO: support varargs eventually
+			return SexpNull, fmt.Errorf("method %s needs %d arguments, but we have %d", method.Name, needed, avail)
+		}
+
+		var va reflect.Value
+		for i := 2; i < narg; i++ {
+			typ := method.Type.In(i - 1)
+			pdepth := PointerDepth(typ)
+			// we only handle 0 and 1 for now
+			Q("pdepth = %v\n", pdepth)
+			switch pdepth {
+			case 0:
+				va = reflect.New(typ)
+			case 1:
+				// handle the common single pointer to struct case
+				va = reflect.New(typ.Elem())
+			default:
+				return SexpNull, fmt.Errorf("error converting %d-th argument to "+
+					"Go: we don't handle double pointers", i-2)
+			}
+			Q("converting to go '%#v' into -> %#v\n", args[i], va.Interface())
+			iface, err := SexpToGoStructs(args[i], va.Interface(), env, nil)
+			if err != nil {
+				return SexpNull, fmt.Errorf("error converting %d-th "+
+					"argument to Go: '%s'", i-2, err)
+			}
+			switch pdepth {
+			case 0:
+				inputVa = append(inputVa, reflect.ValueOf(iface).Elem())
+			case 1:
+				inputVa = append(inputVa, reflect.ValueOf(iface))
+			}
+			Q("\n allocated new %T/val=%#v /i=%#v\n", va, va, va.Interface())
+		}
+
+		//P("_method: about to .Call by reflection!\n")
+
+		out := method.Func.Call(inputVa)
+
+		var iout []interface{}
+		for _, o := range out {
+			iout = append(iout, o.Interface())
+		}
+		Q("done with _method call, iout = %#v\n", iout)
+		Q("done with _method call, iout[0] = %#v\n", iout[0])
+
+		nout := len(out)
+		r := make([]Sexp, 0)
+		for i := 0; i < nout; i++ {
+			f := out[i].Interface()
+			switch e := f.(type) {
+			case nil:
+				r = append(r, SexpNull)
+			case int64:
+				r = append(r, &SexpInt{Val: e})
+			case int:
+				r = append(r, &SexpInt{Val: int64(e)})
+			case error:
+				r = append(r, &SexpError{e})
+			case string:
+				r = append(r, &SexpStr{S: e})
+			case float64:
+				r = append(r, &SexpFloat{Val: e})
+			case []byte:
+				r = append(r, &SexpRaw{Val: e})
+			case rune:
+				r = append(r, &SexpChar{Val: e})
+			default:
+				// go through the type registry
+				found := false
+				for hashName, factory := range GoStructRegistry.Registry {
+					st, err := factory.Factory(env, nil)
+					if err != nil {
+						return SexpNull, fmt.Errorf("MakeHash '%s' problem on Factory call: %s",
+							hashName, err)
+					}
+					Q("got st from Factory, checking if types match")
+					if reflect.ValueOf(st).Type() == out[i].Type() {
+						Q("types match")
+						retHash, err := MakeHash([]Sexp{}, factory.RegisteredName, env)
+						if err != nil {
+							return SexpNull, fmt.Errorf("MakeHash '%s' problem: %s",
+								hashName, err)
+						}
+
+						Q("filling from shadow")
+						err = retHash.FillHashFromShadow(env, f)
+						if err != nil {
+							return SexpNull, err
+						}
+						r = append(r, retHash)
+						found = true
+						break
+					}
+				}
+				if !found {
+					r = append(r, &SexpReflect{Val: out[i]})
+				}
+			}
+		}
+		return env.NewSexpArray(r), nil
+	}()
+	if wasPanic {
+		return SexpNull, fmt.Errorf("\n recovered from panic "+
+			"during CallGo. panic on = '%v'\n"+
+			"stack trace:\n%s\n", recovered, string(*trace))
+	}
+	return sx, err
+}
+
+// detect if inteface is holding anything
+func NilOrHoldsNil(iface interface{}) bool {
+	if iface == nil {
+		return true
+	}
+	return reflect.ValueOf(iface).IsNil()
+}