mirror of
https://github.com/wader/fq.git
synced 2024-12-24 13:52:02 +03:00
7c5215347d
Remove bitio.Buffer layer. bitio.Buffer was a kitchen sink layer with helpers now it's just a buffer and most functions have been moved to decode instead. bitio package now only have primitive types and functions simialar to standard library io and bytes packages. Make nearly eveything internally use bitio.Bit* interfaces so that slicing work correctly this will also make it possible to start experimenting with more complicated silcing helpers, ex things like: breplace(.header.bitrate; 123) to get a new buffer with bitrate changed.
269 lines
6.9 KiB
Go
269 lines
6.9 KiB
Go
package cbor
|
|
|
|
// https://en.wikipedia.org/wiki/CBOR
|
|
// https://www.rfc-editor.org/rfc/rfc8949.html
|
|
|
|
// TODO: streaming bytes test?
|
|
// TODO: decode some sematic tags
|
|
|
|
import (
|
|
"bytes"
|
|
"embed"
|
|
"math/big"
|
|
"strings"
|
|
|
|
"github.com/wader/fq/format"
|
|
"github.com/wader/fq/format/registry"
|
|
"github.com/wader/fq/internal/mathextra"
|
|
"github.com/wader/fq/pkg/bitio"
|
|
"github.com/wader/fq/pkg/decode"
|
|
"github.com/wader/fq/pkg/scalar"
|
|
)
|
|
|
|
//go:embed *.jq
|
|
var cborFS embed.FS
|
|
|
|
func init() {
|
|
registry.MustRegister(decode.Format{
|
|
Name: format.CBOR,
|
|
Description: "Concise Binary Object Representation",
|
|
DecodeFn: decodeCBOR,
|
|
Files: cborFS,
|
|
ToRepr: "_cbor_torepr",
|
|
})
|
|
}
|
|
|
|
type majorTypeEntry struct {
|
|
s scalar.S
|
|
d func(d *decode.D, shortCount uint64, count uint64) interface{}
|
|
}
|
|
|
|
type majorTypeEntries map[uint64]majorTypeEntry
|
|
|
|
func (mts majorTypeEntries) MapScalar(s scalar.S) (scalar.S, error) {
|
|
u := s.ActualU()
|
|
if fe, ok := mts[u]; ok {
|
|
s = fe.s
|
|
s.Actual = u
|
|
}
|
|
return s, nil
|
|
}
|
|
|
|
const (
|
|
shortCountVariable8Bit = 24
|
|
shortCountVariable16Bit = 25
|
|
shortCountVariable32Bit = 26
|
|
shortCountVariable64Bit = 27
|
|
shortCountIndefinite = 31
|
|
|
|
shortCountSpecialFalse = 20
|
|
shortCountSpecialTrue = 21
|
|
shortCountSpecialNull = 22
|
|
shortCountSpecialUndefined = 23
|
|
|
|
shortCountSpecialFloat16Bit = 25
|
|
shortCountSpecialFloat32Bit = 26
|
|
shortCountSpecialFloat64Bit = 27
|
|
)
|
|
|
|
var shortCountMap = scalar.UToSymStr{
|
|
shortCountVariable8Bit: "8bit",
|
|
shortCountVariable16Bit: "16bit",
|
|
shortCountVariable32Bit: "32bit",
|
|
shortCountVariable64Bit: "64bit",
|
|
shortCountIndefinite: "indefinite",
|
|
}
|
|
|
|
var tagMap = scalar.UToSymStr{
|
|
0: "date_time",
|
|
1: "epoch_date_time",
|
|
2: "unsigned_bignum",
|
|
3: "negative_bignum",
|
|
4: "decimal_fraction",
|
|
5: "bigfloat",
|
|
21: "base64url",
|
|
22: "base64",
|
|
23: "base16",
|
|
24: "encoded_cbor",
|
|
32: "uri",
|
|
33: "base64url",
|
|
34: "base64",
|
|
36: "mime_message",
|
|
55799: "self_described_cbor",
|
|
}
|
|
|
|
const (
|
|
majorTypePositiveInt = 0
|
|
majorTypeNegativeInt = 1
|
|
majorTypeBytes = 2
|
|
majorTypeUTF8 = 3
|
|
majorTypeArray = 4
|
|
majorTypeMap = 5
|
|
majorTypeSematic = 6
|
|
majorTypeSpecialFloat = 7
|
|
)
|
|
|
|
const (
|
|
breakMarker = 0xff
|
|
)
|
|
|
|
func decodeCBORValue(d *decode.D) interface{} {
|
|
majorTypeMap := majorTypeEntries{
|
|
majorTypePositiveInt: {s: scalar.S{Sym: "positive_int"}, d: func(d *decode.D, shortCount uint64, count uint64) interface{} {
|
|
d.FieldValueU("value", count)
|
|
return nil
|
|
}},
|
|
majorTypeNegativeInt: {s: scalar.S{Sym: "negative_int"}, d: func(d *decode.D, shortCount uint64, count uint64) interface{} {
|
|
n := new(big.Int)
|
|
n.SetUint64(count).Neg(n).Sub(n, mathextra.BigIntOne)
|
|
d.FieldValueBigInt("value", n)
|
|
return nil
|
|
}},
|
|
majorTypeBytes: {s: scalar.S{Sym: "bytes"}, d: func(d *decode.D, shortCount uint64, count uint64) interface{} {
|
|
if shortCount == shortCountIndefinite {
|
|
bb := &bytes.Buffer{}
|
|
d.FieldArray("items", func(d *decode.D) {
|
|
for d.PeekBits(8) != breakMarker {
|
|
d.FieldStruct("item", func(d *decode.D) {
|
|
v := decodeCBORValue(d)
|
|
switch v := v.(type) {
|
|
case []byte:
|
|
bb.Write(v)
|
|
default:
|
|
d.Fatalf("non-bytes in bytes stream %v", v)
|
|
}
|
|
})
|
|
}
|
|
})
|
|
d.FieldRootBitBuf("value", bitio.NewBitReader(bb.Bytes(), -1))
|
|
// nil, nested indefinite bytes is not allowed
|
|
return nil
|
|
}
|
|
|
|
buf := d.MustReadAllBits(d.FieldRawLen("value", int64(count)*8))
|
|
|
|
return buf
|
|
}},
|
|
majorTypeUTF8: {s: scalar.S{Sym: "utf8"}, d: func(d *decode.D, shortCount uint64, count uint64) interface{} {
|
|
if shortCount == shortCountIndefinite {
|
|
sb := &strings.Builder{}
|
|
d.FieldArray("items", func(d *decode.D) {
|
|
for d.PeekBits(8) != breakMarker {
|
|
d.FieldStruct("item", func(d *decode.D) {
|
|
v := decodeCBORValue(d)
|
|
switch v := v.(type) {
|
|
case string:
|
|
sb.WriteString(v)
|
|
default:
|
|
d.Fatalf("non-string in string stream %v", v)
|
|
}
|
|
})
|
|
}
|
|
})
|
|
d.FieldValueStr("value", sb.String())
|
|
// nil, nested indefinite string is not allowed
|
|
return nil
|
|
}
|
|
|
|
return d.FieldUTF8("value", int(count))
|
|
}},
|
|
majorTypeArray: {s: scalar.S{Sym: "array"}, d: func(d *decode.D, shortCount uint64, count uint64) interface{} {
|
|
d.FieldArray("elements", func(d *decode.D) {
|
|
for i := uint64(0); true; i++ {
|
|
if shortCount == shortCountIndefinite && d.PeekBits(8) == breakMarker {
|
|
break
|
|
} else if i >= count {
|
|
break
|
|
}
|
|
d.FieldStruct("element", func(d *decode.D) { decodeCBORValue(d) })
|
|
}
|
|
})
|
|
if shortCount == shortCountIndefinite {
|
|
d.FieldU8("break")
|
|
}
|
|
return nil
|
|
}},
|
|
majorTypeMap: {s: scalar.S{Sym: "map"}, d: func(d *decode.D, shortCount uint64, count uint64) interface{} {
|
|
d.FieldArray("pairs", func(d *decode.D) {
|
|
for i := uint64(0); true; i++ {
|
|
if shortCount == shortCountIndefinite && d.PeekBits(8) == breakMarker {
|
|
break
|
|
} else if i >= count {
|
|
break
|
|
}
|
|
d.FieldStruct("pair", func(d *decode.D) {
|
|
d.FieldStruct("key", func(d *decode.D) { decodeCBORValue(d) })
|
|
d.FieldStruct("value", func(d *decode.D) { decodeCBORValue(d) })
|
|
})
|
|
}
|
|
})
|
|
if shortCount == shortCountIndefinite {
|
|
d.FieldU8("break")
|
|
}
|
|
return nil
|
|
}},
|
|
majorTypeSematic: {s: scalar.S{Sym: "semantic"}, d: func(d *decode.D, shortCount uint64, count uint64) interface{} {
|
|
d.FieldValueU("tag", count, tagMap)
|
|
d.FieldStruct("value", func(d *decode.D) { decodeCBORValue(d) })
|
|
return nil
|
|
}},
|
|
majorTypeSpecialFloat: {s: scalar.S{Sym: "special_float"}, d: func(d *decode.D, shortCount uint64, count uint64) interface{} {
|
|
switch shortCount {
|
|
// TODO: 0-19
|
|
case shortCountSpecialFalse:
|
|
d.FieldValueBool("value", false)
|
|
case shortCountSpecialTrue:
|
|
d.FieldValueBool("value", true)
|
|
case shortCountSpecialNull:
|
|
d.FieldValueNil("value")
|
|
case shortCountSpecialUndefined:
|
|
// TODO: undefined
|
|
case 24:
|
|
// TODO: future
|
|
case shortCountSpecialFloat16Bit:
|
|
d.FieldF16("value")
|
|
case shortCountSpecialFloat32Bit:
|
|
d.FieldF32("value")
|
|
case shortCountSpecialFloat64Bit:
|
|
d.FieldF64("value")
|
|
case 28, 29, 30:
|
|
// TODO: future
|
|
}
|
|
return nil
|
|
}},
|
|
}
|
|
|
|
typ := d.FieldU3("major_type", majorTypeMap)
|
|
shortCount := d.FieldU5("short_count", shortCountMap)
|
|
count := shortCount
|
|
if typ != majorTypeSpecialFloat {
|
|
switch count {
|
|
// 0-23 value in shortCount
|
|
case shortCountVariable8Bit:
|
|
count = d.FieldU8("variable_count")
|
|
case shortCountVariable16Bit:
|
|
count = d.FieldU16("variable_count")
|
|
case shortCountVariable32Bit:
|
|
count = d.FieldU32("variable_count")
|
|
case shortCountVariable64Bit:
|
|
count = d.FieldU64("variable_count")
|
|
case 28, 29, 30:
|
|
d.Fatalf("incorrect shortCount %d", count)
|
|
}
|
|
}
|
|
|
|
if mt, ok := majorTypeMap[typ]; ok {
|
|
if mt.d != nil {
|
|
return mt.d(d, shortCount, count)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
panic("unreachable")
|
|
}
|
|
|
|
func decodeCBOR(d *decode.D, in interface{}) interface{} {
|
|
decodeCBORValue(d)
|
|
return nil
|
|
}
|