tape/dynamic.go

@@ -63,73 +63,66 @@ func EncodeAny(encoder *Encoder, value any, tag Tag) (n int, err error) {
 // DecodeAny decodes data and places it into destination, which must be a
 // pointer to a supported type. See [EncodeAny] for a list of supported types.
 func DecodeAny(decoder *Decoder, destination any, tag Tag) (n int, err error) {
-	reflectDestination := reflect.ValueOf(destination)
+	return decodeAny(decoder, reflect.ValueOf(destination), tag)
-	if reflectDestination.Kind() != reflect.Pointer {
-		return n, fmt.Errorf("expected pointer destination, not %v", destination)
-	}
-	return decodeAny(decoder, reflectDestination.Elem(), tag)
 }
 
-// unknownSlicePlaceholder is inserted by skeletonValue and informs the program
-// that the destination for the slice needs to be generated based on the item
-// tag in the OTA.
-type unknownSlicePlaceholder struct { }
-var unknownSlicePlaceholderType = reflect.TypeOf(unknownSlicePlaceholder { })
-
-// decodeAny is internal to [DecodeAny]. It takes in an addressable
-// [reflect.Value] as the destination.
 func decodeAny(decoder *Decoder, destination reflect.Value, tag Tag) (n int, err error) {
 	errWrongDestinationType := func(expected string) error {
-		panic(fmt.Errorf(
+		return fmt.Errorf(
-		// return fmt.Errorf(
+			"expected &%s destination, not %v",
-			"expected %s destination, not %v",
+			expected, destination)
-			expected, destination))
+	}
+	
+	if destination.Kind() != reflect.Pointer {
+		return n, errWrongDestinationType("pointer")
 	}
 	
 	switch tag.WithoutCN() {
 	case SI:
 		// SI: (none)
-		err = setInt(destination, uint64(tag.CN()))
+		err = setIntPtr(destination, uint64(tag.CN()))
 		if err != nil { return n, err }
 	case LI:
 		// LI: <value: IntN>
-		nn, err := decodeAndSetInt(decoder, destination, tag.CN() + 1)
+		nn, err := decodeAndSetIntPtr(decoder, destination, tag.CN() - 1)
 		n += nn; if err != nil { return n, err }
 	case FP:
 		// FP: <value: FloatN>
-		nn, err := decodeAndSetFloat(decoder, destination, tag.CN() + 1)
+		nn, err := decodeAndSetFloatPtr(decoder, destination, tag.CN() - 1)
 		n += nn; if err != nil { return n, err }
 	case SBA:
 		// SBA: <data: U8>*
+		destination, err := asByteArrayPtr(destination)
+		if err != nil { return n, err }
 		buffer := make([]byte, tag.CN())
 		nn, err := decoder.Read(buffer)
 		n += nn; if err != nil { return n, err }
-		err = setByteArray(destination, buffer)
+		*destination = buffer
-		if err != nil { return n, err }
 	case LBA:
 		// LBA: <length: UN> <data: U8>*
-		length, nn, err := decoder.ReadUintN(tag.CN() + 1)
+		destination, err := asByteArrayPtr(destination)
+		if err != nil { return n, err }
+		length, nn, err := decoder.ReadUintN(tag.CN() - 1)
 		n += nn; if err != nil { return n, err }
 		buffer := make([]byte, length)
 		nn, err = decoder.Read(buffer)
 		n += nn; if err != nil { return n, err }
-		err = setByteArray(destination, buffer)
+		*destination = buffer
-		if err != nil { return n, err }
 	case OTA:
 		// OTA: <length: UN> <elementTag: tape.Tag> <values>*
-		length, nn, err := decoder.ReadUintN(tag.CN() + 1)
+		length, nn, err := decoder.ReadUintN(tag.CN() - 1)
 		n += nn; if err != nil { return n, err }
 		oneTag, nn, err := decoder.ReadTag()
 		n += nn; if err != nil { return n, err }
 		var slice reflect.Value
 		needSet := false
-		if destination.Kind() == reflect.Struct && destination.Type() == unknownSlicePlaceholderType {
+		elem := destination.Elem()
+		if elem.Kind() == reflect.Struct && elem.Type().Name() == "unknownSlicePlaceholder" {
 			needSet = true
 			slice, err = skeletonValueSlice(oneTag, int(length))
 			if err != nil { return n, err }
-			slice = slice.Elem()
 		} else {
-			slice = destination
+			slice = elem
 			if slice.Kind() != reflect.Slice {
 				return n, errWrongDestinationType("slice")
 			}
@@ -140,16 +133,16 @@ func decodeAny(decoder *Decoder, destination reflect.Value, tag Tag) (n int, err
 			n += nn; if err != nil { return n, err }
 		}
 		if needSet {
-			destination.Set(slice)
+			destination.Elem().Set(slice)
 		}
 	case KTV:
 		// KTV: <length: UN> (<key: U16> <tag: Tag> <value>)*
-		table := destination
+		table := destination.Elem()
 		var dummyMap map[uint16] any
 		if table.Type() != reflect.TypeOf(dummyMap) {
 			return n, errWrongDestinationType("map[uint16] any")
 		}
-		length, nn, err := decoder.ReadUintN(tag.CN() + 1)
+		length, nn, err := decoder.ReadUintN(tag.CN() - 1)
 		n += nn; if err != nil { return n, err }
 		table.Clear()
 		for _ = range length {
@@ -245,65 +238,58 @@ func encodeAnyMap(encoder *Encoder, value any, tag Tag) (n int, err error) {
 	return n, nil
 }
 
-// setInt expects a settable destination.
+func setIntPtr(destination reflect.Value, value uint64) error {
-func setInt(destination reflect.Value, value uint64) error {
+	elem := destination.Elem()
-	switch {
+	if !elem.CanInt() {
-	case destination.CanInt():
+		return fmt.Errorf("cannot assign integer to %T", elem.Interface())
-		destination.Set(reflect.ValueOf(int64(value)).Convert(destination.Type()))
-	case destination.CanUint():
-		destination.Set(reflect.ValueOf(value).Convert(destination.Type()))
-	default:
-		return fmt.Errorf("cannot assign integer to %T", destination.Interface())
 	}
+	elem.Set(reflect.ValueOf(value).Convert(elem.Type()))
 	return nil
 }
 
-// setInt expects a settable destination.
+func setFloatPtr(destination reflect.Value, value float64) error {
-func setFloat(destination reflect.Value, value float64) error {
+	elem := destination.Elem()
-	if !destination.CanFloat() {
+	if !elem.CanFloat() {
-		return fmt.Errorf("cannot assign float to %T", destination.Interface())
+		return fmt.Errorf("cannot assign float to %T", elem.Interface())
 	}
-	destination.Set(reflect.ValueOf(value).Convert(destination.Type()))
+	elem.Set(reflect.ValueOf(value).Convert(elem.Type()))
 	return nil
 }
 
-// setByteArrayexpects a settable destination.
+func decodeAndSetIntPtr(decoder *Decoder, destination reflect.Value, bytes int) (n int, err error) {
-func setByteArray(destination reflect.Value, value []byte) error {
-	typ := destination.Type()
-	if typ.Kind() != reflect.Slice {
-		return fmt.Errorf("cannot assign %T to ", value)
-	}
-	if typ.Elem() != reflect.TypeOf(byte(0)) {
-		return fmt.Errorf("cannot convert %T to *[]byte", value)
-	}
-	destination.Set(reflect.ValueOf(value))
-	return nil
-}
-
-// decodeAndSetInt expects a settable destination.
-func decodeAndSetInt(decoder *Decoder, destination reflect.Value, bytes int) (n int, err error) {
 	value, nn, err := decoder.ReadUintN(bytes)
 	n += nn; if err != nil { return n, err }
-	return n, setInt(destination, value)
+	return n, setIntPtr(destination, value)
 }
 
-// decodeAndSetInt expects a settable destination.
+func decodeAndSetFloatPtr(decoder *Decoder, destination reflect.Value, bytes int) (n int, err error) {
-func decodeAndSetFloat(decoder *Decoder, destination reflect.Value, bytes int) (n int, err error) {
 	switch bytes {
 	case 8:
 		value, nn, err := decoder.ReadFloat64()
 		n += nn; if err != nil { return n, err }
-		return n, setFloat(destination, float64(value))
+		return n, setFloatPtr(destination, float64(value))
 	case 4:
 		value, nn, err := decoder.ReadFloat32()
 		n += nn; if err != nil { return n, err }
-		return n, setFloat(destination, float64(value))
+		return n, setFloatPtr(destination, float64(value))
 	}
 	return n, fmt.Errorf("cannot decode float%d", bytes * 8)
 }
 
-// skeletonValue returns a pointer value. In order for it to be set, it must be
+func asByteArrayPtr(value reflect.Value) (*[]byte, error) {
-// dereferenced using Elem().
+	typ := value.Type()
+	if typ.Kind() != reflect.Pointer {
+		return nil, fmt.Errorf("cannot convert %T to pointer", value)
+	}
+	if typ.Elem().Kind() != reflect.Slice {
+		return nil, fmt.Errorf("cannot convert %T to slice pointer", value)
+	}
+	if typ.Elem().Elem() != reflect.TypeOf(byte(0)) {
+		return nil, fmt.Errorf("cannot convert %T to *[]byte", value)
+	}
+	return value.Convert(reflect.PtrTo(reflect.SliceOf(reflect.TypeOf(byte(0))))).Interface().(*[]byte), nil
+}
+
 func skeletonValue(tag Tag) (reflect.Value, error) {
 	switch tag.WithoutCN() {
 	case SI:
@@ -331,8 +317,6 @@ func skeletonValue(tag Tag) (reflect.Value, error) {
 	return reflect.Value { }, fmt.Errorf("unknown TN %d", tag.TN())
 }
 
-// skeletonValueSlice returns a pointer value. In order for it to be set, it
-// must be dereferenced using Elem().
 func skeletonValueSlice(tag Tag, length int) (reflect.Value, error) {
 	switch tag.WithoutCN() {
 	case SI:
@@ -359,3 +343,8 @@ func skeletonValueSlice(tag Tag, length int) (reflect.Value, error) {
 	}
 	return reflect.Value { }, fmt.Errorf("unknown TN %d", tag.TN())
 }
+
+// unknownSlicePlaceholder is inserted by skeletonValue and informs the program
+// that the destination for the slice needs to be generated based on the item
+// tag in the OTA.
+type unknownSlicePlaceholder struct { }