object plain coding

objects are now encodable and decodable.

But the interface changed.

The Object interface is a plain.Encoder

there is a function objects.PlainDecode(r io.Reader) (Object, error)
for decoding (in order to dispatch the respective object decoder
after an object header.

Inside, this uses the following pattern (note upper/lower case)

type object struct {...}
func (o *object) plainEncode(w io.Writer) error // called by full objects
func (o *object) plainDecode(r io.Reader) error //

// implements plain decode, but privately to the package.
type hdr struct { *object }
func (h hdr) PlainDecode(r io.Reader) error

example concrete object:
type Array struct { object .... }
func (a *Array) PlainEncode(w io.Writer) error // implements plain.Encoder
// implements plain decoding, but only after the header.
func (a *Array) plainDecode(r io.Reader) error

Author: scott-cotton

memory/model.go

@@ -52,8 +52,8 @@ func NewModel(index indexing.T) *Model {
 	z.class = Zero
 	z.parent = zz
 	z.root = zz
-	z.obj = z
-	res.AddPointsTo(z, z)
+	z.obj = zz
+	res.AddAddressOf(zz, zz)
 	return res
 }
 

objects/array.go

@@ -19,6 +19,7 @@ import (
 
 	"github.com/go-air/pal/internal/plain"
 	"github.com/go-air/pal/memory"
+	"github.com/go-air/pal/typeset"
 )
 
 type Array struct {
@@ -27,6 +28,10 @@ type Array struct {
 	n        int64
 }
 
+func newArray(loc memory.Loc, ty typeset.Type) *Array {
+	return &Array{object: object{kind: karray, loc: loc, typ: ty}}
+}
+
 func (a *Array) Len() int64 {
 	return a.n
 }
@@ -37,22 +42,17 @@ func (a *Array) At(i int) memory.Loc {
 }
 
 func (a *Array) PlainEncode(w io.Writer) error {
-	var err error
-	err = plain.Put(w, "a ")
-	if err != nil {
-		return err
-	}
-	return plain.EncodeJoin(w, " ", &a.object, plain.Uint(a.elemSize), plain.Uint(a.n))
+	return plain.EncodeJoin(w, " ", hdr{&a.object}, plain.Uint(a.elemSize), plain.Uint(a.n))
 }
 
-func (a *Array) PlainDecode(r io.Reader) error {
+func (a *Array) plainDecode(r io.Reader) error {
 	var err error
-	err = plain.Expect(r, "a ")
+	err = plain.Expect(r, " ")
 	if err != nil {
 		return err
 	}
 	esz, n := plain.Uint(a.elemSize), plain.Uint(a.n)
-	err = plain.DecodeJoin(r, " ", &a.object, &esz, &n)
+	err = plain.DecodeJoin(r, " ", &esz, &n)
 	if err != nil {
 		return err
 	}

objects/array_test.go

@@ -16,25 +16,21 @@ package objects
 
 import (
 	"testing"
-
-	"github.com/go-air/pal/internal/plain"
 )
 
-func clobArray(c plain.Coder) {
-	a := c.(*Array)
+func clobArray(o Object) {
+	a := o.(*Array)
 	a.loc = 0
 	a.typ = 0
 	a.n = 0
 	a.elemSize = 0
 }
 
 func TestArray(t *testing.T) {
-	a := &Array{}
-	a.loc = 3
-	a.typ = 7
+	a := newArray(3, 7)
 	a.n = 17
 	a.elemSize = 5
-	if err := plain.TestRoundTripClobber(a, clobArray, false); err != nil {
+	if err := testRoundTrip(a, clobArray, false); err != nil {
 		t.Error(err)
 	}
 }

objects/builder.go

@@ -186,9 +186,10 @@ func (b *Builder) Pointer(gtype *types.Pointer) *Pointer {
 // which may or may not be declared.  `declName` must be empty
 // iff the associated function is not declared.
 func (b *Builder) Func(sig *types.Signature, declName string, opaque memory.Attrs) *Func {
-	fn := &Func{declName: declName}
-	fn.typ = b.ts.FromGoType(sig)
-	_, fn.loc = b.Type(fn.typ).WithPointer()
+	typ := b.ts.FromGoType(sig)
+	_, obj := b.Type(typ).WithPointer()
+	fn := newFunc(obj, typ)
+	fn.declName = declName
 
 	b.mmod.AddAddressOf(fn.loc, fn.loc)
 
@@ -199,7 +200,6 @@ func (b *Builder) Func(sig *types.Signature, declName string, opaque memory.Attr
 	b.Class(memory.Local) // for all params and returns
 
 	recv := sig.Recv()
-	var obj memory.Loc
 
 	if recv != nil {
 		b.mgp.Type(b.ts.FromGoType(recv.Type()))
@@ -273,19 +273,15 @@ func (b *Builder) walkObj(m memory.Loc) {
 		switch ty {
 		case typeset.Pointer:
 			if b.omap[m] == nil {
-				ptr := &Pointer{}
-				ptr.loc = m
-				ptr.typ = ty
+				ptr := newPointer(m, ty)
 				b.omap[m] = ptr
 			}
 		}
 	case typeset.Array:
 		var arr *Array
 		obj := b.omap[m]
 		if obj == nil {
-			arr = &Array{}
-			arr.loc = m
-			arr.typ = ty
+			arr = newArray(m, ty)
 			arr.n = int64(b.ts.ArrayLen(ty))
 			arr.elemSize = int64(b.ts.Lsize(b.ts.Elem(ty)))
 			b.omap[m] = arr
@@ -302,9 +298,7 @@ func (b *Builder) walkObj(m memory.Loc) {
 		var strukt *Struct
 		obj := b.omap[m]
 		if obj == nil {
-			strukt = &Struct{}
-			strukt.loc = m
-			strukt.typ = ty
+			strukt = newStruct(m, ty)
 			b.omap[m] = strukt
 		} else {
 			strukt = obj.(*Struct)
@@ -322,9 +316,7 @@ func (b *Builder) walkObj(m memory.Loc) {
 		var ch *Chan
 		obj := b.omap[m]
 		if obj == nil {
-			ch = &Chan{}
-			ch.loc = m
-			ch.typ = ty
+			ch = newChan(m, ty)
 			ch.slot = b.Type(b.ts.Elem(ty)).Gen()
 			b.mmod.AddAddressOf(ch.loc, ch.slot)
 			b.omap[m] = ch
@@ -336,9 +328,7 @@ func (b *Builder) walkObj(m memory.Loc) {
 		var ma *Map
 		obj := b.omap[m]
 		if obj == nil {
-			ma = &Map{}
-			ma.loc = m
-			ma.typ = ty
+			ma = newMap(m, ty)
 			ma.key = b.Type(b.ts.Key(ty)).Gen()
 			ma.elem = b.Type(b.ts.Elem(ty)).Gen()
 			b.mmod.AddAddressOf(ma.loc, ma.key)
@@ -353,9 +343,7 @@ func (b *Builder) walkObj(m memory.Loc) {
 		var slice *Slice
 		obj := b.omap[m]
 		if obj == nil {
-			slice = &Slice{}
-			slice.loc = m
-			slice.typ = b.mmod.Type(m)
+			slice = newSlice(m, ty)
 			slice.Len = b.indexing.Zero()
 			slice.Cap = b.indexing.Zero()
 			b.AddAddressOf(slice.loc, b.mmod.Zero())
@@ -371,9 +359,7 @@ func (b *Builder) walkObj(m memory.Loc) {
 		var tuple *Tuple
 		obj := b.omap[m]
 		if obj == nil {
-			tuple = &Tuple{}
-			tuple.loc = m
-			tuple.typ = ty
+			tuple = newTuple(m, ty)
 			b.omap[m] = tuple
 		} else {
 			tuple = obj.(*Tuple)

objects/chan.go

@@ -19,6 +19,7 @@ import (
 
 	"github.com/go-air/pal/internal/plain"
 	"github.com/go-air/pal/memory"
+	"github.com/go-air/pal/typeset"
 )
 
 // Chan object
@@ -31,6 +32,10 @@ type Chan struct {
 	slot memory.Loc
 }
 
+func newChan(loc memory.Loc, ty typeset.Type) *Chan {
+	return &Chan{object: object{kind: kchan, loc: loc, typ: ty}}
+}
+
 // Recv retrieves the data from the c and loads
 // it into dst.
 func (c *Chan) Recv(dst memory.Loc, mm *memory.Model) {
@@ -45,27 +50,15 @@ func (c *Chan) Send(src memory.Loc, mm *memory.Model) {
 }
 
 func (c *Chan) PlainEncode(w io.Writer) error {
-	var err error
-	err = plain.Put(w, "c ")
-	if err != nil {
-		return err
-	}
-	if err = c.object.PlainEncode(w); err != nil {
-		return err
-	}
-	return c.slot.PlainEncode(w)
+	return plain.EncodeJoin(w, " ", hdr{&c.object}, c.slot)
 }
 
-func (c *Chan) PlainDecode(r io.Reader) error {
+func (c *Chan) plainDecode(r io.Reader) error {
 	var err error
-	err = plain.Expect(r, "c ")
+	err = plain.Expect(r, " ")
 	if err != nil {
 		return err
 	}
-	p := &c.object
-	if err = p.PlainDecode(r); err != nil {
-		return err
-	}
 	ps := &c.slot
 	return ps.PlainDecode(r)
 }

objects/func.go

@@ -34,6 +34,10 @@ type Func struct {
 	variadic bool
 }
 
+func newFunc(loc memory.Loc, typ typeset.Type) *Func {
+	return &Func{object: object{kind: kfunc, loc: loc, typ: typ}}
+}
+
 func (f *Func) Declared() bool {
 	return f.declName != ""
 }
@@ -67,11 +71,8 @@ func (f *Func) NumResults() int {
 }
 
 func (f *Func) PlainEncode(w io.Writer) error {
-	err := plain.Put(w, "f ")
-	if err != nil {
-		return err
-	}
-	err = plain.EncodeJoin(w, " ", f.fnobj, f.recv, plain.Uint(len(f.params)))
+	err := plain.EncodeJoin(w, " ", hdr{&f.object},
+		f.fnobj, f.recv, plain.Uint(len(f.params)))
 	if f.variadic {
 		err = plain.Put(w, "*")
 	} else {
@@ -112,8 +113,8 @@ func (f *Func) PlainEncode(w io.Writer) error {
 	return nil
 }
 
-func (f *Func) PlainDecode(r io.Reader) error {
-	err := plain.Expect(r, "f ")
+func (f *Func) plainDecode(r io.Reader) error {
+	err := plain.Expect(r, " ")
 	if err != nil {
 		return err
 	}
@@ -133,7 +134,7 @@ func (f *Func) PlainDecode(r io.Reader) error {
 	case '.':
 		f.variadic = false
 	default:
-		return fmt.Errorf("unexpected '%c'", buf[0])
+		return fmt.Errorf("unexpected modifier '%c'", buf[0])
 	}
 	f.params = make([]memory.Loc, n)
 	for i := plain.Uint(0); i < n; i++ {
@@ -149,7 +150,7 @@ func (f *Func) PlainDecode(r io.Reader) error {
 	}
 	err = plain.Expect(r, " ")
 	if err != nil {
-		return err
+		return fmt.Errorf("unexpected space 2: %w\n", err)
 	}
 	err = (&n).PlainDecode(r)
 	if err != nil {

objects/func_test.go

@@ -20,12 +20,11 @@ import (
 	"testing"
 
 	"github.com/go-air/pal/indexing"
-	"github.com/go-air/pal/internal/plain"
 	"github.com/go-air/pal/memory"
 )
 
-func clobber(c plain.Coder) {
-	f := c.(*Func)
+func fclob(o Object) {
+	f := o.(*Func)
 	f.declName = ""
 	f.fnobj = 0
 	f.recv = 0
@@ -43,7 +42,7 @@ func TestFuncPlain(t *testing.T) {
 	sig := types.NewSignature(nil, parms, ress, false)
 	b := NewBuilder("pkg", indexing.ConstVals())
 	f := b.Func(sig, "declName", memory.IsOpaque)
-	err := plain.TestRoundTripClobber(f, clobber, true)
+	err := testRoundTrip(f, fclob, true)
 	if err != nil {
 		t.Error(err)
 	}

objects/interface.go

@@ -29,6 +29,6 @@ func (i *Interface) PlainEncode(w io.Writer) error {
 	return nil
 }
 
-func (i *Interface) PlainDecode(r io.Reader) error {
+func (i *Interface) plainDecode(r io.Reader) error {
 	return nil
 }

objects/map.go

@@ -19,6 +19,7 @@ import (
 
 	"github.com/go-air/pal/internal/plain"
 	"github.com/go-air/pal/memory"
+	"github.com/go-air/pal/typeset"
 )
 
 type Map struct {
@@ -27,6 +28,10 @@ type Map struct {
 	elem memory.Loc
 }
 
+func newMap(loc memory.Loc, typ typeset.Type) *Map {
+	return &Map{object: object{kind: kmap, loc: loc, typ: typ}}
+}
+
 func (m *Map) Key() memory.Loc {
 	return m.key
 }
@@ -46,26 +51,12 @@ func (m *Map) Lookup(dst memory.Loc, mm *memory.Model) {
 }
 
 func (m *Map) PlainEncode(w io.Writer) error {
-	var err error
-	err = plain.Put(w, "m")
-	if err != nil {
-		return err
-	}
-	err = m.object.PlainEncode(w)
-	if err != nil {
-		return err
-	}
-	return plain.EncodeJoin(w, " ", m.key, m.elem)
+	return plain.EncodeJoin(w, " ", hdr{&m.object}, m.key, m.elem)
 }
 
-func (m *Map) PlainDecode(r io.Reader) error {
+func (m *Map) plainDecode(r io.Reader) error {
 	var err error
-	err = plain.Expect(r, "m")
-	if err != nil {
-		return err
-	}
-	pobj := &m.object
-	err = pobj.PlainDecode(r)
+	err = plain.Expect(r, " ")
 	if err != nil {
 		return err
 	}