193 lines
6.1 KiB
Go
193 lines
6.1 KiB
Go
package tape
|
|
|
|
import "io"
|
|
import "math"
|
|
import "bufio"
|
|
|
|
// Decodable is any type that can decode itself from a decoder.
|
|
type Decodable interface {
|
|
// Decode reads data from decoder, replacing the data of the object. It
|
|
// returns the amount of bytes written, and an error if the write
|
|
// stopped early.
|
|
Decode(decoder *Decoder) (n int, err error)
|
|
}
|
|
|
|
// Decoder decodes data from an [io.Reader].
|
|
type Decoder struct {
|
|
bufio.Reader
|
|
}
|
|
|
|
// NewDecoder creates a new decoder that reads from reader.
|
|
func NewDecoder(reader io.Reader) *Decoder {
|
|
decoder := &Decoder { }
|
|
decoder.Reader.Reset(reader)
|
|
return decoder
|
|
}
|
|
|
|
// ReadFull calls [io.ReadFull] on the reader.
|
|
func (this *Decoder) ReadFull(buffer []byte) (n int, err error) {
|
|
return io.ReadFull(this, buffer)
|
|
}
|
|
|
|
// ReadInt8 decodes an 8-bit signed integer from the input reader.
|
|
func (this *Decoder) ReadInt8() (value int8, n int, err error) {
|
|
uncasted, n, err := this.ReadUint8()
|
|
return int8(uncasted), n, err
|
|
}
|
|
|
|
// ReadUint8 decodes an 8-bit unsigned integer from the input reader.
|
|
func (this *Decoder) ReadUint8() (value uint8, n int, err error) {
|
|
buffer := [1]byte { }
|
|
n, err = this.ReadFull(buffer[:])
|
|
return uint8(buffer[0]), n, err
|
|
}
|
|
|
|
// ReadInt16 decodes an 16-bit signed integer from the input reader.
|
|
func (this *Decoder) ReadInt16() (value int16, n int, err error) {
|
|
uncasted, n, err := this.ReadUint16()
|
|
return int16(uncasted), n, err
|
|
}
|
|
|
|
// ReadUint16 decodes an 16-bit unsigned integer from the input reader.
|
|
func (this *Decoder) ReadUint16() (value uint16, n int, err error) {
|
|
buffer := [2]byte { }
|
|
n, err = this.ReadFull(buffer[:])
|
|
return uint16(buffer[0]) << 8 |
|
|
uint16(buffer[1]), n, err
|
|
}
|
|
|
|
// ReadInt32 decodes an 32-bit signed integer from the input reader.
|
|
func (this *Decoder) ReadInt32() (value int32, n int, err error) {
|
|
uncasted, n, err := this.ReadUint32()
|
|
return int32(uncasted), n, err
|
|
}
|
|
|
|
// ReadUint32 decodes an 32-bit unsigned integer from the input reader.
|
|
func (this *Decoder) ReadUint32() (value uint32, n int, err error) {
|
|
buffer := [4]byte { }
|
|
n, err = this.ReadFull(buffer[:])
|
|
return uint32(buffer[0]) << 24 |
|
|
uint32(buffer[1]) << 16 |
|
|
uint32(buffer[2]) << 8 |
|
|
uint32(buffer[3]), n, err
|
|
}
|
|
|
|
// ReadInt64 decodes an 64-bit signed integer from the input reader.
|
|
func (this *Decoder) ReadInt64() (value int64, n int, err error) {
|
|
uncasted, n, err := this.ReadUint64()
|
|
return int64(uncasted), n, err
|
|
}
|
|
|
|
// ReadUint64 decodes an 64-bit unsigned integer from the input reader.
|
|
func (this *Decoder) ReadUint64() (value uint64, n int, err error) {
|
|
buffer := [8]byte { }
|
|
n, err = this.ReadFull(buffer[:])
|
|
return uint64(buffer[0]) << 56 |
|
|
uint64(buffer[1]) << 48 |
|
|
uint64(buffer[2]) << 40 |
|
|
uint64(buffer[3]) << 32 |
|
|
uint64(buffer[4]) << 24 |
|
|
uint64(buffer[5]) << 16 |
|
|
uint64(buffer[6]) << 8 |
|
|
uint64(buffer[7]), n, err
|
|
}
|
|
|
|
// ReadIntN decodes an N-byte signed integer from the input reader.
|
|
func (this *Decoder) ReadIntN(bytes int) (value int64, n int, err error) {
|
|
uncasted, n, err := this.ReadUintN(bytes)
|
|
return int64(uncasted), n, err
|
|
}
|
|
|
|
// ReadUintN decodes an N-byte unsigned integer from the input reader.
|
|
func (this *Decoder) ReadUintN(bytes int) (value uint64, n int, err error) {
|
|
// TODO: don't make multiple read calls (without allocating)
|
|
buffer := [1]byte { }
|
|
for bytesLeft := bytes; bytesLeft > 0; bytesLeft -- {
|
|
nn, err := this.ReadFull(buffer[:])
|
|
n += nn; if err != nil { return 0, n, err }
|
|
value |= uint64(buffer[0]) << ((bytesLeft - 1) * 8)
|
|
}
|
|
// *read* integers too big, but don't return them.
|
|
if bytes > 8 { value = 0 }
|
|
return value, n, nil
|
|
}
|
|
|
|
// ReadFloat16 decodes a 16-bit floating point value from the input reader.
|
|
func (this *Decoder) ReadFloat16() (value float32, n int, err error) {
|
|
bits, nn, err := this.ReadUint16()
|
|
n += nn; if err != nil { return 0, n, err }
|
|
return math.Float32frombits(f16bitsToF32bits(bits)), n, nil
|
|
}
|
|
|
|
// ReadFloat32 decldes a 32-bit floating point value from the input reader.
|
|
func (this *Decoder) ReadFloat32() (value float32, n int, err error) {
|
|
bits, nn, err := this.ReadUint32()
|
|
n += nn; if err != nil { return 0, n, err }
|
|
return math.Float32frombits(bits), n, nil
|
|
}
|
|
|
|
// ReadFloat64 decldes a 64-bit floating point value from the input reader.
|
|
func (this *Decoder) ReadFloat64() (value float64, n int, err error) {
|
|
bits, nn, err := this.ReadUint64()
|
|
n += nn; if err != nil { return 0, n, err }
|
|
return math.Float64frombits(bits), n, nil
|
|
}
|
|
|
|
// ReadTag decodes a [Tag] from the input reader.
|
|
func (this *Decoder) ReadTag() (value Tag, n int, err error) {
|
|
uncasted, nn, err := this.ReadUint8()
|
|
n += nn; if err != nil { return 0, n, err }
|
|
return Tag(uncasted), n, nil
|
|
}
|
|
|
|
// f16bitsToF32bits returns uint32 (float32 bits) converted from specified uint16.
|
|
// Taken from https://github.com/x448/float16/blob/v0.8.4/float16
|
|
//
|
|
// MIT License
|
|
//
|
|
// Copyright (c) 2019 Montgomery Edwards⁴⁴⁸ and Faye Amacker
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in all
|
|
// copies or substantial portions of the Software.
|
|
func f16bitsToF32bits(in uint16) uint32 {
|
|
// All 65536 conversions with this were confirmed to be correct
|
|
// by Montgomery Edwards⁴⁴⁸ (github.com/x448).
|
|
|
|
sign := uint32(in&0x8000) << 16 // sign for 32-bit
|
|
exp := uint32(in&0x7c00) >> 10 // exponenent for 16-bit
|
|
coef := uint32(in&0x03ff) << 13 // significand for 32-bit
|
|
|
|
if exp == 0x1f {
|
|
if coef == 0 {
|
|
// infinity
|
|
return sign | 0x7f800000 | coef
|
|
}
|
|
// NaN
|
|
return sign | 0x7fc00000 | coef
|
|
}
|
|
|
|
if exp == 0 {
|
|
if coef == 0 {
|
|
// zero
|
|
return sign
|
|
}
|
|
|
|
// normalize subnormal numbers
|
|
exp++
|
|
for coef&0x7f800000 == 0 {
|
|
coef <<= 1
|
|
exp--
|
|
}
|
|
coef &= 0x007fffff
|
|
}
|
|
|
|
return sign | ((exp + (0x7f - 0xf)) << 23) | coef
|
|
}
|