parameter loading

gotypes/signature.go

@@ -0,0 +1,101 @@
+package gotypes
+
+import (
+	"errors"
+	"go/token"
+	"go/types"
+	"strconv"
+)
+
+type Signature struct {
+	sig     *types.Signature
+	params  *Tuple
+	results *Tuple
+}
+
+func NewSignature(sig *types.Signature) *Signature {
+	s := &Signature{
+		sig: sig,
+	}
+	s.init()
+	return s
+}
+
+func ParseSignature(expr string) (*Signature, error) {
+	tv, err := types.Eval(token.NewFileSet(), nil, token.NoPos, expr)
+	if err != nil {
+		return nil, err
+	}
+	if tv.Value != nil {
+		return nil, errors.New("signature expression should have nil value")
+	}
+	s, ok := tv.Type.(*types.Signature)
+	if !ok {
+		return nil, errors.New("provided type is not a function signature")
+	}
+	return NewSignature(s), nil
+}
+
+func (s *Signature) Params() *Tuple { return s.params }
+
+func (s *Signature) Results() *Tuple { return s.results }
+
+func (s *Signature) Bytes() int { return s.Params().Bytes() + s.Results().Bytes() }
+
+func (s *Signature) init() {
+	p := s.sig.Params()
+	r := s.sig.Results()
+
+	// Compute offsets of parameters and return values.
+	vs := tuplevars(p)
+	vs = append(vs, tuplevars(r)...)
+	vs = append(vs, types.NewParam(token.NoPos, nil, "sentinel", types.Typ[types.Uint64]))
+	offsets := Sizes.Offsetsof(vs)
+
+	// Build components for them.
+	s.params = newTuple(p, offsets, "arg")
+	s.results = newTuple(r, offsets[p.Len():], "ret")
+}
+
+type Tuple struct {
+	components []Component
+	byname     map[string]Component
+	size       int
+}
+
+func newTuple(t *types.Tuple, offsets []int64, defaultprefix string) *Tuple {
+	tuple := &Tuple{
+		byname: map[string]Component{},
+		size:   int(offsets[t.Len()]),
+	}
+	for i := 0; i < t.Len(); i++ {
+		v := t.At(i)
+		name := v.Name()
+		if name == "" {
+			name = defaultprefix
+			if i > 0 {
+				name += strconv.Itoa(i)
+			}
+		}
+		c := NewComponent(name, v.Type(), int(offsets[i]))
+		tuple.components = append(tuple.components, c)
+		if v.Name() != "" {
+			tuple.byname[v.Name()] = c
+		}
+	}
+	return tuple
+}
+
+func (t *Tuple) Lookup(name string) Component { return t.byname[name] }
+
+func (t *Tuple) At(i int) Component { return t.components[i] }
+
+func (t *Tuple) Bytes() int { return t.size }
+
+func tuplevars(t *types.Tuple) []*types.Var {
+	vs := make([]*types.Var, t.Len())
+	for i := 0; i < t.Len(); i++ {
+		vs[i] = t.At(i)
+	}
+	return vs
+}