Less pointers

Item, Raw, Blob are rather small structures, so an additional pointer
may hurt performance.

diff --git a/gyac/atom/dec.go b/gyac/atom/dec.go
index 653bcb4d4137ccfbf7e425c4eb0ac271b50c02c9db18208a6e719df0455b1922..6fccb3f6d32831cc937e764a19ceeb1f4a87a11e76a2dcaff0a5c7bc486ce3dc 100644 (file)
--- a/gyac/atom/dec.go
+++ b/gyac/atom/dec.go
@@ -225,7 +225,7 @@ func Decode(buf []byte) (t types.Type, v any, off int, err error) {
                        return
                }
                t = types.Raw
-               v = &Raw{T: Type(tag), V: buf[1 : 1+l]}
+               v = Raw{T: Type(tag), V: buf[1 : 1+l]}
 
        case TAI64, TAI64N, TAI64NA:
                var l int

diff --git a/gyac/atom/enc.go b/gyac/atom/enc.go
index df9ceeed1f2e76813570a5e84903c619c8f885bdcb75b445020ee2dcb8d52f3c..39c4af01ac08561e794effe943f5627f6cde004e45d4a178d41cbeacd99b218d 100644 (file)
--- a/gyac/atom/enc.go
+++ b/gyac/atom/enc.go
@@ -173,6 +173,6 @@ func TAI64Encode(buf, tai []byte) []byte {
        }
 }
 
-func RawEncode(buf []byte, raw *Raw) []byte {
+func RawEncode(buf []byte, raw Raw) []byte {
        return append(append(buf, byte(raw.T)), raw.V...)
 }

diff --git a/gyac/blob.go b/gyac/blob.go
index dc5029032242d7c2b3bf37803b7646dab266db91815f5324c3643b6dea520ed6..1566e21dd8ed73e684ef846bfdba95ab11ad53e54d051240296bdd75aacbf5b3 100644 (file)
--- a/gyac/blob.go
+++ b/gyac/blob.go
@@ -30,8 +30,8 @@ func (blob *Blob) String() string {
        return fmt.Sprintf("BLOB(%d, %d)", blob.ChunkLen, l)
 }
 
-func MakeBlob(chunkLen int, data []byte) *Blob {
-       blob := Blob{ChunkLen: chunkLen}
+func MakeBlob(chunkLen int, data []byte) (blob Blob) {
+       blob.ChunkLen = chunkLen
        n := len(data) / chunkLen
        for i := 0; i < n; i++ {
                blob.Chunks = append(blob.Chunks, data[i*chunkLen:(i+1)*chunkLen])
@@ -40,5 +40,5 @@ func MakeBlob(chunkLen int, data []byte) *Blob {
        if left > 0 {
                blob.Chunks = append(blob.Chunks, data[len(data)-left:])
        }
-       return &blob
+       return
 }

diff --git a/gyac/cmd/test-vector-anys/main.go b/gyac/cmd/test-vector-anys/main.go
index 2e5d03d06a55beb386478debf61968cbaba83fe8dee702594008ac7de5702711..ae4bad7a02a03451abb4f1aa74db87cb0e396fe05a9c67a49d8b55718ef392f9 100644 (file)
--- a/gyac/cmd/test-vector-anys/main.go
+++ b/gyac/cmd/test-vector-anys/main.go
@@ -87,7 +87,7 @@ func main() {
                        map[string]any{},
                        gyac.MakeBlob(123, []byte{}),
                        uuid.Nil,
-                       &atom.Raw{
+                       atom.Raw{
                                T: atom.TAI64,
                                V: []byte("\x00\x00\x00\x00\x00\x00\x00\x00"),
                        },
@@ -96,13 +96,13 @@ func main() {
                        time.Unix(1234567890, 0),
                        time.Unix(1234567890, 456*1000),
                        time.Unix(1234567890, 456789),
-                       &atom.Raw{
+                       atom.Raw{
                                T: atom.TAI64NA,
                                V: []byte("\x40\x00\x00\x00\x49\x96\x02\xF4\x00\x06\xF8\x55\x07\x5B\xCD\x15"),
                        },
                },
                "floats": []any{
-                       &atom.Raw{T: atom.Float32, V: []byte("\x01\x02\x03\x04")},
+                       atom.Raw{T: atom.Float32, V: []byte("\x01\x02\x03\x04")},
                },
                "uuid": uuid.MustParse("0e875e3f-d385-49eb-87b4-be42d641c367"),
        }

diff --git a/gyac/cmd/test-vector-manual/main.go b/gyac/cmd/test-vector-manual/main.go
index d9fdbb21d6581c5d2973a8009fe11e8e1afca3a50d787a7e1d2c0d3905a45b57..c34e17e2258c19a2f6c64123252fa1ac163b96e1572d97a570f0e1e03ad85958 100644 (file)
--- a/gyac/cmd/test-vector-manual/main.go
+++ b/gyac/cmd/test-vector-manual/main.go
@@ -158,7 +158,7 @@ func main() {
                                tai.FromTime(t)
                                buf = atom.TAI64Encode(buf, tai[:])
                        }
-                       buf = atom.RawEncode(buf, &atom.Raw{
+                       buf = atom.RawEncode(buf, atom.Raw{
                                T: atom.TAI64NA,
                                V: []byte("\x40\x00\x00\x00\x49\x96\x02\xF4\x00\x06\xF8\x55\x07\x5B\xCD\x15"),
                        })
@@ -167,7 +167,7 @@ func main() {
                {
                        buf = atom.StrEncode(buf, "floats")
                        buf = atom.ListEncode(buf)
-                       buf = atom.RawEncode(buf, &atom.Raw{
+                       buf = atom.RawEncode(buf, atom.Raw{
                                T: atom.Float32,
                                V: []byte("\x01\x02\x03\x04"),
                        })
@@ -189,7 +189,7 @@ func main() {
                                buf = atom.BinEncode(buf, []byte{})
                        }
                        buf = atom.UUIDEncode(buf, uuid.Nil)
-                       buf = atom.RawEncode(buf, &atom.Raw{
+                       buf = atom.RawEncode(buf, atom.Raw{
                                T: atom.TAI64,
                                V: []byte("\x00\x00\x00\x00\x00\x00\x00\x00"),
                        })

diff --git a/gyac/dec.go b/gyac/dec.go
index 244e5245d7205e5e859d36d8eea047dc3bbbc75807b50c4314c559f0c2653c77..a3561d8c3ed5e8acd04d2a925ef9fa9f2a504a18afddc0cd91dbdae668b86f72 100644 (file)
--- a/gyac/dec.go
+++ b/gyac/dec.go
@@ -41,13 +41,12 @@ func decode(
        buf []byte,
        allowContainers, expectEOC bool,
        recursionDepth int,
-) (item *Item, tail []byte, err error) {
+) (item Item, tail []byte, err error) {
        if recursionDepth > ParseMaxRecursionDepth {
                err = errors.New("deep recursion")
                return
        }
        var off int
-       item = &Item{}
        item.T, item.V, off, err = atom.Decode(buf)
        if err != nil {
                return
@@ -65,8 +64,8 @@ func decode(
                        err = atom.ErrUnknownType
                        return
                }
-               var sub *Item
-               var v []*Item
+               var sub Item
+               var v []Item
                for {
                        sub, buf, err = decode(buf, true, true, recursionDepth+1)
                        tail = buf
@@ -86,8 +85,8 @@ func decode(
                        err = atom.ErrUnknownType
                        return
                }
-               v := make(map[string]*Item)
-               var sub *Item
+               v := make(map[string]Item)
+               var sub Item
                var keyPrev string
                for {
                        sub, buf, err = decode(buf, false, true, recursionDepth+1)
@@ -132,8 +131,8 @@ func decode(
                        return
                }
                chunkLen := int(item.V.(uint64))
-               v := &Blob{ChunkLen: chunkLen}
-               var sub *Item
+               v := Blob{ChunkLen: chunkLen}
+               var sub Item
        BlobCycle:
                for {
                        sub, buf, err = decode(buf, false, true, recursionDepth+1)

diff --git a/gyac/enc.go b/gyac/enc.go
index 756ec97b504371eeaf0eee6400e4dd33d0fc1f568fb39f4585bc777b69ee8181..92de56a2b49457e79beace83a112f0ec7a58130f11b448f09e1a0d7e6dd0f931 100644 (file)
--- a/gyac/enc.go
+++ b/gyac/enc.go
@@ -25,7 +25,7 @@ import (
        "go.cypherpunks.su/yac/gyac/types"
 )
 
-func (item *Item) Encode(buf []byte) []byte {
+func (item Item) Encode(buf []byte) []byte {
        switch item.T {
        case types.NIL:
                return atom.NILEncode(buf)
@@ -41,12 +41,12 @@ func (item *Item) Encode(buf []byte) []byte {
                return atom.BigIntEncode(buf, item.V.(*big.Int))
        case types.List:
                buf = atom.ListEncode(buf)
-               for _, v := range item.V.([]*Item) {
+               for _, v := range item.V.([]Item) {
                        buf = v.Encode(buf)
                }
                buf = atom.EOCEncode(buf)
        case types.Map:
-               m := item.V.(map[string]*Item)
+               m := item.V.(map[string]Item)
                keys := make([]string, 0, len(m))
                for k := range m {
                        keys = append(keys, k)
@@ -59,7 +59,7 @@ func (item *Item) Encode(buf []byte) []byte {
                }
                buf = atom.EOCEncode(buf)
        case types.Blob:
-               blob := item.V.(*Blob)
+               blob := item.V.(Blob)
                buf = atom.BlobEncode(buf, blob.ChunkLen)
                for _, chunk := range blob.Chunks {
                        if len(chunk) == blob.ChunkLen {
@@ -83,7 +83,7 @@ func (item *Item) Encode(buf []byte) []byte {
        case types.Str:
                return atom.StrEncode(buf, item.V.(string))
        case types.Raw:
-               return atom.RawEncode(buf, item.V.(*atom.Raw))
+               return atom.RawEncode(buf, item.V.(atom.Raw))
        default:
                panic("unhandled type")
        }

diff --git a/gyac/fromgo.go b/gyac/fromgo.go
index 9b48623fd0d2bd2b733ebfb2038eae2ed9e4d185c6c5d64b2d9fd4f48f6e9c06..5ea9bae3e774e145b25986b1f9fb731eee634e97cf70129c1b478e6e51017038 100644 (file)
--- a/gyac/fromgo.go
+++ b/gyac/fromgo.go
@@ -44,17 +44,19 @@ func structTagRead(f reflect.StructField) (name string, omit bool) {
        return
 }
 
-func FromGo(v any) *Item {
+func FromGo(v any) Item {
        if v == nil {
-               return &Item{T: types.NIL}
+               return Item{T: types.NIL}
        }
        rv := reflect.ValueOf(v)
        if b, ok := v.([]byte); ok {
-               return &Item{T: types.Bin, V: b}
+               return Item{T: types.Bin, V: b}
        }
        switch v := v.(type) {
        case *Blob:
-               return &Item{T: types.Blob, V: v}
+               return Item{T: types.Blob, V: *v}
+       case Blob:
+               return Item{T: types.Blob, V: v}
        case time.Time:
                t := tai64n.Leapsecs.Add(v)
                var taiRaw []byte
@@ -67,20 +69,22 @@ func FromGo(v any) *Item {
                        tai.FromTime(t)
                        taiRaw = tai[:]
                }
-               return &Item{T: types.TAI64, V: taiRaw}
+               return Item{T: types.TAI64, V: taiRaw}
        case *atom.Raw:
-               return &Item{T: types.Raw, V: v}
+               return Item{T: types.Raw, V: *v}
+       case atom.Raw:
+               return Item{T: types.Raw, V: v}
        case *big.Int:
-               return &Item{T: types.BigInt, V: v}
+               return Item{T: types.BigInt, V: v}
        }
        switch reflect.TypeOf(v).Kind() {
        case reflect.Pointer:
                if rv.IsNil() {
-                       return &Item{T: types.NIL}
+                       return Item{T: types.NIL}
                }
                return FromGo(rv.Elem().Interface())
        case reflect.Slice:
-               var ret []*Item
+               var ret []Item
                if anys, ok := v.([]any); ok {
                        for _, v := range anys {
                                ret = append(ret, FromGo(v))
@@ -91,19 +95,19 @@ func FromGo(v any) *Item {
                                ret = append(ret, FromGo(rv.Index(i).Interface()))
                        }
                }
-               return &Item{T: types.List, V: ret}
+               return Item{T: types.List, V: ret}
        case reflect.Map:
-               ret := make(map[string]*Item, rv.Len())
+               ret := make(map[string]Item, rv.Len())
                iter := rv.MapRange()
                for iter.Next() {
                        ret[iter.Key().String()] = FromGo(iter.Value().Interface())
                }
-               return &Item{T: types.Map, V: ret}
+               return Item{T: types.Map, V: ret}
        }
        {
                t := rv.Type()
                if t.Kind() == reflect.Struct {
-                       ret := make(map[string]*Item)
+                       ret := make(map[string]Item)
                        for _, f := range reflect.VisibleFields(t) {
                                fv := rv.FieldByIndex(f.Index)
                                name, omit := structTagRead(f)
@@ -113,11 +117,11 @@ func FromGo(v any) *Item {
                                case types.NIL:
                                        empty = true
                                case types.List:
-                                       if len(item.V.([]*Item)) == 0 {
+                                       if len(item.V.([]Item)) == 0 {
                                                empty = true
                                        }
                                case types.Map:
-                                       if len(item.V.(map[string]*Item)) == 0 {
+                                       if len(item.V.(map[string]Item)) == 0 {
                                                empty = true
                                        }
                                }
@@ -125,51 +129,51 @@ func FromGo(v any) *Item {
                                        ret[name] = item
                                }
                        }
-                       return &Item{T: types.Map, V: ret}
+                       return Item{T: types.Map, V: ret}
                }
        }
        switch v := v.(type) {
        case bool:
-               return &Item{T: types.Bool, V: v}
+               return Item{T: types.Bool, V: v}
        case uuid.UUID:
-               return &Item{T: types.UUID, V: v}
+               return Item{T: types.UUID, V: v}
        case uint:
-               return &Item{T: types.UInt, V: uint64(v)}
+               return Item{T: types.UInt, V: uint64(v)}
        case uint8:
-               return &Item{T: types.UInt, V: uint64(v)}
+               return Item{T: types.UInt, V: uint64(v)}
        case uint16:
-               return &Item{T: types.UInt, V: uint64(v)}
+               return Item{T: types.UInt, V: uint64(v)}
        case uint32:
-               return &Item{T: types.UInt, V: uint64(v)}
+               return Item{T: types.UInt, V: uint64(v)}
        case uint64:
-               return &Item{T: types.UInt, V: v}
+               return Item{T: types.UInt, V: v}
        case int:
                if v >= 0 {
-                       return &Item{T: types.UInt, V: uint64(v)}
+                       return Item{T: types.UInt, V: uint64(v)}
                }
-               return &Item{T: types.Int, V: int64(v)}
+               return Item{T: types.Int, V: int64(v)}
        case int8:
                if v >= 0 {
-                       return &Item{T: types.UInt, V: uint64(v)}
+                       return Item{T: types.UInt, V: uint64(v)}
                }
-               return &Item{T: types.Int, V: int64(v)}
+               return Item{T: types.Int, V: int64(v)}
        case int16:
                if v >= 0 {
-                       return &Item{T: types.UInt, V: uint64(v)}
+                       return Item{T: types.UInt, V: uint64(v)}
                }
-               return &Item{T: types.Int, V: int64(v)}
+               return Item{T: types.Int, V: int64(v)}
        case int32:
                if v >= 0 {
-                       return &Item{T: types.UInt, V: uint64(v)}
+                       return Item{T: types.UInt, V: uint64(v)}
                }
-               return &Item{T: types.Int, V: int64(v)}
+               return Item{T: types.Int, V: int64(v)}
        case int64:
                if v >= 0 {
-                       return &Item{T: types.UInt, V: uint64(v)}
+                       return Item{T: types.UInt, V: uint64(v)}
                }
-               return &Item{T: types.Int, V: v}
+               return Item{T: types.Int, V: v}
        case string:
-               return &Item{T: types.Str, V: v}
+               return Item{T: types.Str, V: v}
        default:
                panic(fmt.Errorf("unhandled type: %+v", v))
        }

diff --git a/gyac/fuzz_test.go b/gyac/fuzz_test.go
index 795ab88c2eab083d43fddbd5360ec4d6cbc3325aba81b00b087b6e2a21c6e85f..103e4dac9e5b32a924ca21fc13f8b13b80fe896929667b342d7d76dc88f8b8ea 100644 (file)
--- a/gyac/fuzz_test.go
+++ b/gyac/fuzz_test.go
@@ -6,7 +6,7 @@ import (
 )
 
 func FuzzItemDecode(f *testing.F) {
-       var item *Item
+       var item Item
        var err error
        var tail []byte
        f.Fuzz(func(t *testing.T, b []byte) {

diff --git a/gyac/mapstruct/dec.go b/gyac/mapstruct/dec.go
index fadf76895be34a15f83911debf199c3e0ad9de3b0e81a2a45c7bc56d291e2165..bcba9ffcd96fd75ad3a91a51c6074231056b6597807c5d8f5f7f84fb0537adb0 100644 (file)
--- a/gyac/mapstruct/dec.go
+++ b/gyac/mapstruct/dec.go
@@ -23,7 +23,7 @@ import (
 )
 
 func Decode(dst any, raw []byte) (tail []byte, err error) {
-       var item *gyac.Item
+       var item gyac.Item
        item, tail, err = gyac.Decode(raw)
        if err != nil {
                return

diff --git a/gyac/togo.go b/gyac/togo.go
index ec10fa7d2934e60f29921ae952c1eaf4bbfb809b08a9a5a3c38a07a61fbaf2dc..4dc62f9cb0fbf5297d26bd4c9df83c19b6ee4a7cc7f920664f38b6980f6707ca 100644 (file)
--- a/gyac/togo.go
+++ b/gyac/togo.go
@@ -25,7 +25,7 @@ import (
        "go.cypherpunks.su/yac/gyac/types"
 )
 
-func (item *Item) ToGo() any {
+func (item Item) ToGo() any {
        switch item.T {
        case types.NIL:
                return nil
@@ -39,18 +39,18 @@ func (item *Item) ToGo() any {
                return item.V.(int64)
        case types.List:
                var ret []any
-               for _, v := range item.V.([]*Item) {
+               for _, v := range item.V.([]Item) {
                        ret = append(ret, v.ToGo())
                }
                return ret
        case types.Map:
                ret := make(map[string]any)
-               for k, v := range item.V.(map[string]*Item) {
+               for k, v := range item.V.(map[string]Item) {
                        ret[k] = v.ToGo()
                }
                return ret
        case types.Blob:
-               return item.V.(*Blob)
+               return item.V.(Blob)
        case types.BigInt:
                return item.V.(*big.Int)
        case types.Float:
@@ -62,18 +62,18 @@ func (item *Item) ToGo() any {
                        tai := tai64n.TAI64(raw)
                        t, isLeap := tai64n.Leapsecs.Sub(tai.Time())
                        if isLeap {
-                               return &atom.Raw{T: atom.TAI64, V: raw}
+                               return atom.Raw{T: atom.TAI64, V: raw}
                        }
                        return t
                case tai64n.TAI64NSize:
                        tai := tai64n.TAI64N(raw)
                        t, isLeap := tai64n.Leapsecs.Sub(tai.Time())
                        if isLeap {
-                               return &atom.Raw{T: atom.TAI64N, V: raw}
+                               return atom.Raw{T: atom.TAI64N, V: raw}
                        }
                        return t
                case tai64n.TAI64NASize:
-                       return &atom.Raw{T: atom.TAI64NA, V: raw}
+                       return atom.Raw{T: atom.TAI64NA, V: raw}
                default:
                        panic("unexpected TAI size")
                }
@@ -82,7 +82,7 @@ func (item *Item) ToGo() any {
        case types.Str:
                return item.V.(string)
        case types.Raw:
-               return item.V.(*atom.Raw)
+               return item.V.(atom.Raw)
        default:
                panic(fmt.Errorf("unhandled type: %+v", item))
        }

diff --git a/gyac/yacpki/signed-data.go b/gyac/yacpki/signed-data.go
index 04bc6719a96719ec398171d84fc3f857cfa403f22badf3930aed9315349680d4..1e5bc680aa3b436f953b3b56da6540a35876bd43a140db5ca55497e724c0994f 100644 (file)
--- a/gyac/yacpki/signed-data.go
+++ b/gyac/yacpki/signed-data.go
@@ -45,7 +45,7 @@ type SignedData struct {
 }
 
 func SignedDataParse(data []byte) (sd *SignedData, tail []byte, err error) {
-       var item *gyac.Item
+       var item gyac.Item
        item, tail, err = gyac.Decode(data)
        if err != nil {
                return
@@ -54,7 +54,7 @@ func SignedDataParse(data []byte) (sd *SignedData, tail []byte, err error) {
        return
 }
 
-func SignedDataParseItem(item *gyac.Item) (sd *SignedData, err error) {
+func SignedDataParseItem(item gyac.Item) (sd *SignedData, err error) {
        if item.T != types.Map {
                err = errors.New("SignedDataParse: non-map")
                return