summaryrefslogtreecommitdiff
path: root/lib/binstruct
diff options
context:
space:
mode:
Diffstat (limited to 'lib/binstruct')
-rw-r--r--lib/binstruct/binint/builtins.go129
-rw-r--r--lib/binstruct/binstruct_test.go3
-rw-r--r--lib/binstruct/size.go18
-rw-r--r--lib/binstruct/structs.go4
4 files changed, 91 insertions, 63 deletions
diff --git a/lib/binstruct/binint/builtins.go b/lib/binstruct/binint/builtins.go
index 01186bc..cfd0fc2 100644
--- a/lib/binstruct/binint/builtins.go
+++ b/lib/binstruct/binint/builtins.go
@@ -1,4 +1,4 @@
-// Copyright (C) 2022 Luke Shumaker <lukeshu@lukeshu.com>
+// Copyright (C) 2022-2023 Luke Shumaker <lukeshu@lukeshu.com>
//
// SPDX-License-Identifier: GPL-2.0-or-later
@@ -10,230 +10,249 @@ import (
"git.lukeshu.com/btrfs-progs-ng/lib/binstruct/binutil"
)
+const (
+ sizeof8 = 1
+ sizeof16 = 2
+ sizeof32 = 4
+ sizeof64 = 8
+)
+
// unsigned
type U8 uint8
-func (U8) BinaryStaticSize() int { return 1 }
+func (U8) BinaryStaticSize() int { return sizeof8 }
func (x U8) MarshalBinary() ([]byte, error) { return []byte{byte(x)}, nil }
func (x *U8) UnmarshalBinary(dat []byte) (int, error) {
- if err := binutil.NeedNBytes(dat, 1); err != nil {
+ if err := binutil.NeedNBytes(dat, sizeof8); err != nil {
return 0, err
}
*x = U8(dat[0])
- return 1, nil
+ return sizeof8, nil
}
// unsigned little endian
type U16le uint16
-func (U16le) BinaryStaticSize() int { return 2 }
+func (U16le) BinaryStaticSize() int { return sizeof16 }
func (x U16le) MarshalBinary() ([]byte, error) {
- var buf [2]byte
+ var buf [sizeof16]byte
binary.LittleEndian.PutUint16(buf[:], uint16(x))
return buf[:], nil
}
+
func (x *U16le) UnmarshalBinary(dat []byte) (int, error) {
- if err := binutil.NeedNBytes(dat, 2); err != nil {
+ if err := binutil.NeedNBytes(dat, sizeof16); err != nil {
return 0, err
}
*x = U16le(binary.LittleEndian.Uint16(dat))
- return 2, nil
+ return sizeof16, nil
}
type U32le uint32
-func (U32le) BinaryStaticSize() int { return 4 }
+func (U32le) BinaryStaticSize() int { return sizeof32 }
func (x U32le) MarshalBinary() ([]byte, error) {
- var buf [4]byte
+ var buf [sizeof32]byte
binary.LittleEndian.PutUint32(buf[:], uint32(x))
return buf[:], nil
}
+
func (x *U32le) UnmarshalBinary(dat []byte) (int, error) {
- if err := binutil.NeedNBytes(dat, 4); err != nil {
+ if err := binutil.NeedNBytes(dat, sizeof32); err != nil {
return 0, err
}
*x = U32le(binary.LittleEndian.Uint32(dat))
- return 4, nil
+ return sizeof32, nil
}
type U64le uint64
-func (U64le) BinaryStaticSize() int { return 8 }
+func (U64le) BinaryStaticSize() int { return sizeof64 }
func (x U64le) MarshalBinary() ([]byte, error) {
- var buf [8]byte
+ var buf [sizeof64]byte
binary.LittleEndian.PutUint64(buf[:], uint64(x))
return buf[:], nil
}
+
func (x *U64le) UnmarshalBinary(dat []byte) (int, error) {
- if err := binutil.NeedNBytes(dat, 8); err != nil {
+ if err := binutil.NeedNBytes(dat, sizeof64); err != nil {
return 0, err
}
*x = U64le(binary.LittleEndian.Uint64(dat))
- return 8, nil
+ return sizeof64, nil
}
// unsigned big endian
type U16be uint16
-func (U16be) BinaryStaticSize() int { return 2 }
+func (U16be) BinaryStaticSize() int { return sizeof16 }
func (x U16be) MarshalBinary() ([]byte, error) {
- var buf [2]byte
+ var buf [sizeof16]byte
binary.BigEndian.PutUint16(buf[:], uint16(x))
return buf[:], nil
}
+
func (x *U16be) UnmarshalBinary(dat []byte) (int, error) {
- if err := binutil.NeedNBytes(dat, 2); err != nil {
+ if err := binutil.NeedNBytes(dat, sizeof16); err != nil {
return 0, err
}
*x = U16be(binary.BigEndian.Uint16(dat))
- return 2, nil
+ return sizeof16, nil
}
type U32be uint32
-func (U32be) BinaryStaticSize() int { return 4 }
+func (U32be) BinaryStaticSize() int { return sizeof32 }
func (x U32be) MarshalBinary() ([]byte, error) {
- var buf [4]byte
+ var buf [sizeof32]byte
binary.BigEndian.PutUint32(buf[:], uint32(x))
return buf[:], nil
}
+
func (x *U32be) UnmarshalBinary(dat []byte) (int, error) {
- if err := binutil.NeedNBytes(dat, 4); err != nil {
+ if err := binutil.NeedNBytes(dat, sizeof32); err != nil {
return 0, err
}
*x = U32be(binary.BigEndian.Uint32(dat))
- return 4, nil
+ return sizeof32, nil
}
type U64be uint64
-func (U64be) BinaryStaticSize() int { return 8 }
+func (U64be) BinaryStaticSize() int { return sizeof64 }
func (x U64be) MarshalBinary() ([]byte, error) {
- var buf [8]byte
+ var buf [sizeof64]byte
binary.BigEndian.PutUint64(buf[:], uint64(x))
return buf[:], nil
}
+
func (x *U64be) UnmarshalBinary(dat []byte) (int, error) {
- if err := binutil.NeedNBytes(dat, 8); err != nil {
+ if err := binutil.NeedNBytes(dat, sizeof64); err != nil {
return 0, err
}
*x = U64be(binary.BigEndian.Uint64(dat))
- return 8, nil
+ return sizeof64, nil
}
// signed
type I8 int8
-func (I8) BinaryStaticSize() int { return 1 }
+func (I8) BinaryStaticSize() int { return sizeof8 }
func (x I8) MarshalBinary() ([]byte, error) { return []byte{byte(x)}, nil }
func (x *I8) UnmarshalBinary(dat []byte) (int, error) {
- if err := binutil.NeedNBytes(dat, 1); err != nil {
+ if err := binutil.NeedNBytes(dat, sizeof8); err != nil {
return 0, err
}
*x = I8(dat[0])
- return 1, nil
+ return sizeof8, nil
}
// signed little endian
type I16le int16
-func (I16le) BinaryStaticSize() int { return 2 }
+func (I16le) BinaryStaticSize() int { return sizeof16 }
func (x I16le) MarshalBinary() ([]byte, error) {
- var buf [2]byte
+ var buf [sizeof16]byte
binary.LittleEndian.PutUint16(buf[:], uint16(x))
return buf[:], nil
}
+
func (x *I16le) UnmarshalBinary(dat []byte) (int, error) {
- if err := binutil.NeedNBytes(dat, 2); err != nil {
+ if err := binutil.NeedNBytes(dat, sizeof16); err != nil {
return 0, err
}
*x = I16le(binary.LittleEndian.Uint16(dat))
- return 2, nil
+ return sizeof16, nil
}
type I32le int32
-func (I32le) BinaryStaticSize() int { return 4 }
+func (I32le) BinaryStaticSize() int { return sizeof32 }
func (x I32le) MarshalBinary() ([]byte, error) {
- var buf [4]byte
+ var buf [sizeof32]byte
binary.LittleEndian.PutUint32(buf[:], uint32(x))
return buf[:], nil
}
+
func (x *I32le) UnmarshalBinary(dat []byte) (int, error) {
- if err := binutil.NeedNBytes(dat, 4); err != nil {
+ if err := binutil.NeedNBytes(dat, sizeof32); err != nil {
return 0, err
}
*x = I32le(binary.LittleEndian.Uint32(dat))
- return 4, nil
+ return sizeof32, nil
}
type I64le int64
-func (I64le) BinaryStaticSize() int { return 8 }
+func (I64le) BinaryStaticSize() int { return sizeof64 }
func (x I64le) MarshalBinary() ([]byte, error) {
- var buf [8]byte
+ var buf [sizeof64]byte
binary.LittleEndian.PutUint64(buf[:], uint64(x))
return buf[:], nil
}
+
func (x *I64le) UnmarshalBinary(dat []byte) (int, error) {
- if err := binutil.NeedNBytes(dat, 8); err != nil {
+ if err := binutil.NeedNBytes(dat, sizeof64); err != nil {
return 0, err
}
*x = I64le(binary.LittleEndian.Uint64(dat))
- return 8, nil
+ return sizeof64, nil
}
// signed big endian
type I16be int16
-func (I16be) BinaryStaticSize() int { return 2 }
+func (I16be) BinaryStaticSize() int { return sizeof16 }
func (x I16be) MarshalBinary() ([]byte, error) {
- var buf [2]byte
+ var buf [sizeof16]byte
binary.BigEndian.PutUint16(buf[:], uint16(x))
return buf[:], nil
}
+
func (x *I16be) UnmarshalBinary(dat []byte) (int, error) {
- if err := binutil.NeedNBytes(dat, 2); err != nil {
+ if err := binutil.NeedNBytes(dat, sizeof16); err != nil {
return 0, err
}
*x = I16be(binary.BigEndian.Uint16(dat))
- return 2, nil
+ return sizeof16, nil
}
type I32be int32
-func (I32be) BinaryStaticSize() int { return 4 }
+func (I32be) BinaryStaticSize() int { return sizeof32 }
func (x I32be) MarshalBinary() ([]byte, error) {
- var buf [4]byte
+ var buf [sizeof32]byte
binary.BigEndian.PutUint32(buf[:], uint32(x))
return buf[:], nil
}
+
func (x *I32be) UnmarshalBinary(dat []byte) (int, error) {
- if err := binutil.NeedNBytes(dat, 4); err != nil {
+ if err := binutil.NeedNBytes(dat, sizeof32); err != nil {
return 0, err
}
*x = I32be(binary.BigEndian.Uint32(dat))
- return 4, nil
+ return sizeof32, nil
}
type I64be int64
-func (I64be) BinaryStaticSize() int { return 8 }
+func (I64be) BinaryStaticSize() int { return sizeof64 }
func (x I64be) MarshalBinary() ([]byte, error) {
- var buf [8]byte
+ var buf [sizeof64]byte
binary.BigEndian.PutUint64(buf[:], uint64(x))
return buf[:], nil
}
+
func (x *I64be) UnmarshalBinary(dat []byte) (int, error) {
- if err := binutil.NeedNBytes(dat, 8); err != nil {
+ if err := binutil.NeedNBytes(dat, sizeof64); err != nil {
return 0, err
}
*x = I64be(binary.BigEndian.Uint64(dat))
- return 8, nil
+ return sizeof64, nil
}
diff --git a/lib/binstruct/binstruct_test.go b/lib/binstruct/binstruct_test.go
index 105e790..8780acc 100644
--- a/lib/binstruct/binstruct_test.go
+++ b/lib/binstruct/binstruct_test.go
@@ -1,4 +1,4 @@
-// Copyright (C) 2022 Luke Shumaker <lukeshu@lukeshu.com>
+// Copyright (C) 2022-2023 Luke Shumaker <lukeshu@lukeshu.com>
//
// SPDX-License-Identifier: GPL-2.0-or-later
@@ -13,6 +13,7 @@ import (
)
func TestSmoke(t *testing.T) {
+ t.Parallel()
type UUID [16]byte
type PhysicalAddr int64
type DevItem struct {
diff --git a/lib/binstruct/size.go b/lib/binstruct/size.go
index 365da85..d6d70c6 100644
--- a/lib/binstruct/size.go
+++ b/lib/binstruct/size.go
@@ -1,4 +1,4 @@
-// Copyright (C) 2022 Luke Shumaker <lukeshu@lukeshu.com>
+// Copyright (C) 2022-2023 Luke Shumaker <lukeshu@lukeshu.com>
//
// SPDX-License-Identifier: GPL-2.0-or-later
@@ -28,8 +28,16 @@ var (
unmarshalerType = reflect.TypeOf((*Unmarshaler)(nil)).Elem()
)
+const (
+ sizeof8 = 1
+ sizeof16 = 2
+ sizeof32 = 4
+ sizeof64 = 8
+)
+
func staticSize(typ reflect.Type) (int, error) {
if typ.Implements(staticSizerType) {
+ //nolint:forcetypeassert // Already did a type check via reflection.
return reflect.New(typ).Elem().Interface().(StaticSizer).BinaryStaticSize(), nil
}
if typ.Implements(marshalerType) || typ.Implements(unmarshalerType) {
@@ -42,13 +50,13 @@ func staticSize(typ reflect.Type) (int, error) {
}
switch typ.Kind() {
case reflect.Uint8, reflect.Int8:
- return 1, nil
+ return sizeof8, nil
case reflect.Uint16, reflect.Int16:
- return 2, nil
+ return sizeof16, nil
case reflect.Uint32, reflect.Int32:
- return 4, nil
+ return sizeof32, nil
case reflect.Uint64, reflect.Int64:
- return 8, nil
+ return sizeof64, nil
case reflect.Ptr:
return staticSize(typ.Elem())
case reflect.Array:
diff --git a/lib/binstruct/structs.go b/lib/binstruct/structs.go
index 9bc556c..7eea600 100644
--- a/lib/binstruct/structs.go
+++ b/lib/binstruct/structs.go
@@ -1,4 +1,4 @@
-// Copyright (C) 2022 Luke Shumaker <lukeshu@lukeshu.com>
+// Copyright (C) 2022-2023 Luke Shumaker <lukeshu@lukeshu.com>
//
// SPDX-License-Identifier: GPL-2.0-or-later
@@ -120,7 +120,7 @@ func genStructHandler(structInfo reflect.Type) (structHandler, error) {
var curOffset, endOffset int
for i := 0; i < structInfo.NumField(); i++ {
- var fieldInfo reflect.StructField = structInfo.Field(i)
+ fieldInfo := structInfo.Field(i)
if fieldInfo.Anonymous && fieldInfo.Type != endType {
err := fmt.Errorf("binstruct does not support embedded fields")
generated by cgit v1.1-4-g5e80 at 2024-07-04 17:48:10 +0000