123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311 |
- // Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
- // Use of this source code is governed by a MIT license found in the LICENSE file.
- package codec
- import (
- "math"
- "reflect"
- "time"
- )
- // Symbol management:
- // - symbols are stored in a symbol map during encoding and decoding.
- // - the symbols persist until the (En|De)coder ResetXXX method is called.
- const bincDoPrune = true
- // vd as low 4 bits (there are 16 slots)
- const (
- bincVdSpecial byte = iota
- bincVdPosInt
- bincVdNegInt
- bincVdFloat
- bincVdString
- bincVdByteArray
- bincVdArray
- bincVdMap
- bincVdTimestamp
- bincVdSmallInt
- _ // bincVdUnicodeOther
- bincVdSymbol
- _ // bincVdDecimal
- _ // open slot
- _ // open slot
- bincVdCustomExt = 0x0f
- )
- const (
- bincSpNil byte = iota
- bincSpFalse
- bincSpTrue
- bincSpNan
- bincSpPosInf
- bincSpNegInf
- bincSpZeroFloat
- bincSpZero
- bincSpNegOne
- )
- const (
- _ byte = iota // bincFlBin16
- bincFlBin32
- _ // bincFlBin32e
- bincFlBin64
- _ // bincFlBin64e
- // others not currently supported
- )
- const bincBdNil = 0 // bincVdSpecial<<4 | bincSpNil // staticcheck barfs on this (SA4016)
- var (
- bincdescSpecialVsNames = map[byte]string{
- bincSpNil: "nil",
- bincSpFalse: "false",
- bincSpTrue: "true",
- bincSpNan: "float",
- bincSpPosInf: "float",
- bincSpNegInf: "float",
- bincSpZeroFloat: "float",
- bincSpZero: "uint",
- bincSpNegOne: "int",
- }
- bincdescVdNames = map[byte]string{
- bincVdSpecial: "special",
- bincVdSmallInt: "uint",
- bincVdPosInt: "uint",
- bincVdFloat: "float",
- bincVdSymbol: "string",
- bincVdString: "string",
- bincVdByteArray: "bytes",
- bincVdTimestamp: "time",
- bincVdCustomExt: "ext",
- bincVdArray: "array",
- bincVdMap: "map",
- }
- )
- func bincdescbd(bd byte) (s string) {
- return bincdesc(bd>>4, bd&0x0f)
- }
- func bincdesc(vd, vs byte) (s string) {
- if vd == bincVdSpecial {
- s = bincdescSpecialVsNames[vs]
- } else {
- s = bincdescVdNames[vd]
- }
- if s == "" {
- s = "unknown"
- }
- return
- }
- type bincEncState struct {
- m map[string]uint16 // symbols
- }
- func (e bincEncState) captureState() interface{} { return e.m }
- func (e *bincEncState) resetState() { e.m = nil }
- func (e *bincEncState) reset() { e.resetState() }
- func (e *bincEncState) restoreState(v interface{}) { e.m = v.(map[string]uint16) }
- type bincEncDriver struct {
- noBuiltInTypes
- encDriverNoopContainerWriter
- h *BincHandle
- bincEncState
- e Encoder
- }
- func (e *bincEncDriver) encoder() *Encoder {
- return &e.e
- }
- func (e *bincEncDriver) EncodeNil() {
- e.e.encWr.writen1(bincBdNil)
- }
- func (e *bincEncDriver) EncodeTime(t time.Time) {
- if t.IsZero() {
- e.EncodeNil()
- } else {
- bs := bincEncodeTime(t)
- e.e.encWr.writen1(bincVdTimestamp<<4 | uint8(len(bs)))
- e.e.encWr.writeb(bs)
- }
- }
- func (e *bincEncDriver) EncodeBool(b bool) {
- if b {
- e.e.encWr.writen1(bincVdSpecial<<4 | bincSpTrue)
- } else {
- e.e.encWr.writen1(bincVdSpecial<<4 | bincSpFalse)
- }
- }
- func (e *bincEncDriver) encSpFloat(f float64) (done bool) {
- if f == 0 {
- e.e.encWr.writen1(bincVdSpecial<<4 | bincSpZeroFloat)
- } else if math.IsNaN(float64(f)) {
- e.e.encWr.writen1(bincVdSpecial<<4 | bincSpNan)
- } else if math.IsInf(float64(f), +1) {
- e.e.encWr.writen1(bincVdSpecial<<4 | bincSpPosInf)
- } else if math.IsInf(float64(f), -1) {
- e.e.encWr.writen1(bincVdSpecial<<4 | bincSpNegInf)
- } else {
- return
- }
- return true
- }
- func (e *bincEncDriver) EncodeFloat32(f float32) {
- if !e.encSpFloat(float64(f)) {
- e.e.encWr.writen1(bincVdFloat<<4 | bincFlBin32)
- bigen.writeUint32(e.e.w(), math.Float32bits(f))
- }
- }
- func (e *bincEncDriver) EncodeFloat64(f float64) {
- if e.encSpFloat(f) {
- return
- }
- b := bigen.PutUint64(math.Float64bits(f))
- if bincDoPrune {
- i := 7
- for ; i >= 0 && (b[i] == 0); i-- {
- }
- i++
- if i <= 6 {
- e.e.encWr.writen1(bincVdFloat<<4 | 0x8 | bincFlBin64)
- e.e.encWr.writen1(byte(i))
- e.e.encWr.writeb(b[:i])
- return
- }
- }
- e.e.encWr.writen1(bincVdFloat<<4 | bincFlBin64)
- e.e.encWr.writen8(b)
- }
- func (e *bincEncDriver) encIntegerPrune32(bd byte, pos bool, v uint64) {
- b := bigen.PutUint32(uint32(v))
- if bincDoPrune {
- i := byte(pruneSignExt(b[:], pos))
- e.e.encWr.writen1(bd | 3 - i)
- e.e.encWr.writeb(b[i:])
- } else {
- e.e.encWr.writen1(bd | 3)
- e.e.encWr.writen4(b)
- }
- }
- func (e *bincEncDriver) encIntegerPrune64(bd byte, pos bool, v uint64) {
- b := bigen.PutUint64(v)
- if bincDoPrune {
- i := byte(pruneSignExt(b[:], pos))
- e.e.encWr.writen1(bd | 7 - i)
- e.e.encWr.writeb(b[i:])
- } else {
- e.e.encWr.writen1(bd | 7)
- e.e.encWr.writen8(b)
- }
- }
- func (e *bincEncDriver) EncodeInt(v int64) {
- if v >= 0 {
- e.encUint(bincVdPosInt<<4, true, uint64(v))
- } else if v == -1 {
- e.e.encWr.writen1(bincVdSpecial<<4 | bincSpNegOne)
- } else {
- e.encUint(bincVdNegInt<<4, false, uint64(-v))
- }
- }
- func (e *bincEncDriver) EncodeUint(v uint64) {
- e.encUint(bincVdPosInt<<4, true, v)
- }
- func (e *bincEncDriver) encUint(bd byte, pos bool, v uint64) {
- if v == 0 {
- e.e.encWr.writen1(bincVdSpecial<<4 | bincSpZero)
- } else if pos && v >= 1 && v <= 16 {
- e.e.encWr.writen1(bincVdSmallInt<<4 | byte(v-1))
- } else if v <= math.MaxUint8 {
- e.e.encWr.writen2(bd|0x0, byte(v))
- } else if v <= math.MaxUint16 {
- e.e.encWr.writen1(bd | 0x01)
- bigen.writeUint16(e.e.w(), uint16(v))
- } else if v <= math.MaxUint32 {
- e.encIntegerPrune32(bd, pos, v)
- } else {
- e.encIntegerPrune64(bd, pos, v)
- }
- }
- func (e *bincEncDriver) EncodeExt(v interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
- var bs0, bs []byte
- if ext == SelfExt {
- bs0 = e.e.blist.get(1024)
- bs = bs0
- e.e.sideEncode(v, basetype, &bs)
- } else {
- bs = ext.WriteExt(v)
- }
- if bs == nil {
- e.EncodeNil()
- goto END
- }
- e.encodeExtPreamble(uint8(xtag), len(bs))
- e.e.encWr.writeb(bs)
- END:
- if ext == SelfExt {
- e.e.blist.put(bs)
- if !byteSliceSameData(bs0, bs) {
- e.e.blist.put(bs0)
- }
- }
- }
- func (e *bincEncDriver) EncodeRawExt(re *RawExt) {
- e.encodeExtPreamble(uint8(re.Tag), len(re.Data))
- e.e.encWr.writeb(re.Data)
- }
- func (e *bincEncDriver) encodeExtPreamble(xtag byte, length int) {
- e.encLen(bincVdCustomExt<<4, uint64(length))
- e.e.encWr.writen1(xtag)
- }
- func (e *bincEncDriver) WriteArrayStart(length int) {
- e.encLen(bincVdArray<<4, uint64(length))
- }
- func (e *bincEncDriver) WriteMapStart(length int) {
- e.encLen(bincVdMap<<4, uint64(length))
- }
- func (e *bincEncDriver) EncodeSymbol(v string) {
- //symbols only offer benefit when string length > 1.
- //This is because strings with length 1 take only 2 bytes to store
- //(bd with embedded length, and single byte for string val).
- l := len(v)
- if l == 0 {
- e.encBytesLen(cUTF8, 0)
- return
- } else if l == 1 {
- e.encBytesLen(cUTF8, 1)
- e.e.encWr.writen1(v[0])
- return
- }
- if e.m == nil {
- e.m = make(map[string]uint16, 16)
- }
- ui, ok := e.m[v]
- if ok {
- if ui <= math.MaxUint8 {
- e.e.encWr.writen2(bincVdSymbol<<4, byte(ui))
- } else {
- e.e.encWr.writen1(bincVdSymbol<<4 | 0x8)
- bigen.writeUint16(e.e.w(), ui)
- }
- } else {
- e.e.seq++
- ui = e.e.seq
- e.m[v] = ui
- var lenprec uint8
- if l <= math.MaxUint8 {
- // lenprec = 0
- } else if l <= math.MaxUint16 {
- lenprec = 1
- } else if int64(l) <= math.MaxUint32 {
- lenprec = 2
- } else {
- lenprec = 3
- }
- if ui <= math.MaxUint8 {
- e.e.encWr.writen2(bincVdSymbol<<4|0x0|0x4|lenprec, byte(ui))
- } else {
- e.e.encWr.writen1(bincVdSymbol<<4 | 0x8 | 0x4 | lenprec)
- bigen.writeUint16(e.e.w(), ui)
- }
- if lenprec == 0 {
- e.e.encWr.writen1(byte(l))
- } else if lenprec == 1 {
- bigen.writeUint16(e.e.w(), uint16(l))
- } else if lenprec == 2 {
- bigen.writeUint32(e.e.w(), uint32(l))
- } else {
- bigen.writeUint64(e.e.w(), uint64(l))
- }
- e.e.encWr.writestr(v)
- }
- }
- func (e *bincEncDriver) EncodeString(v string) {
- if e.h.StringToRaw {
- e.encLen(bincVdByteArray<<4, uint64(len(v)))
- if len(v) > 0 {
- e.e.encWr.writestr(v)
- }
- return
- }
- e.EncodeStringEnc(cUTF8, v)
- }
- func (e *bincEncDriver) EncodeStringEnc(c charEncoding, v string) {
- if e.e.c == containerMapKey && c == cUTF8 && (e.h.AsSymbols == 1) {
- e.EncodeSymbol(v)
- return
- }
- e.encLen(bincVdString<<4, uint64(len(v)))
- if len(v) > 0 {
- e.e.encWr.writestr(v)
- }
- }
- func (e *bincEncDriver) EncodeStringBytesRaw(v []byte) {
- if v == nil {
- e.EncodeNil()
- return
- }
- e.encLen(bincVdByteArray<<4, uint64(len(v)))
- if len(v) > 0 {
- e.e.encWr.writeb(v)
- }
- }
- func (e *bincEncDriver) encBytesLen(c charEncoding, length uint64) {
- // MARKER: we currently only support UTF-8 (string) and RAW (bytearray).
- // We should consider supporting bincUnicodeOther.
- if c == cRAW {
- e.encLen(bincVdByteArray<<4, length)
- } else {
- e.encLen(bincVdString<<4, length)
- }
- }
- func (e *bincEncDriver) encLen(bd byte, l uint64) {
- if l < 12 {
- e.e.encWr.writen1(bd | uint8(l+4))
- } else {
- e.encLenNumber(bd, l)
- }
- }
- func (e *bincEncDriver) encLenNumber(bd byte, v uint64) {
- if v <= math.MaxUint8 {
- e.e.encWr.writen2(bd, byte(v))
- } else if v <= math.MaxUint16 {
- e.e.encWr.writen1(bd | 0x01)
- bigen.writeUint16(e.e.w(), uint16(v))
- } else if v <= math.MaxUint32 {
- e.e.encWr.writen1(bd | 0x02)
- bigen.writeUint32(e.e.w(), uint32(v))
- } else {
- e.e.encWr.writen1(bd | 0x03)
- bigen.writeUint64(e.e.w(), uint64(v))
- }
- }
- //------------------------------------
- type bincDecState struct {
- bdRead bool
- bd byte
- vd byte
- vs byte
- _ bool
- // MARKER: consider using binary search here instead of a map (ie bincDecSymbol)
- s map[uint16][]byte
- }
- func (x bincDecState) captureState() interface{} { return x }
- func (x *bincDecState) resetState() { *x = bincDecState{} }
- func (x *bincDecState) reset() { x.resetState() }
- func (x *bincDecState) restoreState(v interface{}) { *x = v.(bincDecState) }
- type bincDecDriver struct {
- decDriverNoopContainerReader
- decDriverNoopNumberHelper
- noBuiltInTypes
- h *BincHandle
- bincDecState
- d Decoder
- }
- func (d *bincDecDriver) decoder() *Decoder {
- return &d.d
- }
- func (d *bincDecDriver) descBd() string {
- return sprintf("%v (%s)", d.bd, bincdescbd(d.bd))
- }
- func (d *bincDecDriver) readNextBd() {
- d.bd = d.d.decRd.readn1()
- d.vd = d.bd >> 4
- d.vs = d.bd & 0x0f
- d.bdRead = true
- }
- func (d *bincDecDriver) advanceNil() (null bool) {
- if !d.bdRead {
- d.readNextBd()
- }
- if d.bd == bincBdNil {
- d.bdRead = false
- return true // null = true
- }
- return
- }
- func (d *bincDecDriver) TryNil() bool {
- return d.advanceNil()
- }
- func (d *bincDecDriver) ContainerType() (vt valueType) {
- if !d.bdRead {
- d.readNextBd()
- }
- if d.bd == bincBdNil {
- d.bdRead = false
- return valueTypeNil
- } else if d.vd == bincVdByteArray {
- return valueTypeBytes
- } else if d.vd == bincVdString {
- return valueTypeString
- } else if d.vd == bincVdArray {
- return valueTypeArray
- } else if d.vd == bincVdMap {
- return valueTypeMap
- }
- return valueTypeUnset
- }
- func (d *bincDecDriver) DecodeTime() (t time.Time) {
- if d.advanceNil() {
- return
- }
- if d.vd != bincVdTimestamp {
- d.d.errorf("cannot decode time - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
- }
- t, err := bincDecodeTime(d.d.decRd.readx(uint(d.vs)))
- halt.onerror(err)
- d.bdRead = false
- return
- }
- func (d *bincDecDriver) decFloatPruned(maxlen uint8) {
- l := d.d.decRd.readn1()
- if l > maxlen {
- d.d.errorf("cannot read float - at most %v bytes used to represent float - received %v bytes", maxlen, l)
- }
- for i := l; i < maxlen; i++ {
- d.d.b[i] = 0
- }
- d.d.decRd.readb(d.d.b[0:l])
- }
- func (d *bincDecDriver) decFloatPre32() (b [4]byte) {
- if d.vs&0x8 == 0 {
- b = d.d.decRd.readn4()
- } else {
- d.decFloatPruned(4)
- copy(b[:], d.d.b[:])
- }
- return
- }
- func (d *bincDecDriver) decFloatPre64() (b [8]byte) {
- if d.vs&0x8 == 0 {
- b = d.d.decRd.readn8()
- } else {
- d.decFloatPruned(8)
- copy(b[:], d.d.b[:])
- }
- return
- }
- func (d *bincDecDriver) decFloatVal() (f float64) {
- switch d.vs & 0x7 {
- case bincFlBin32:
- f = float64(math.Float32frombits(bigen.Uint32(d.decFloatPre32())))
- case bincFlBin64:
- f = math.Float64frombits(bigen.Uint64(d.decFloatPre64()))
- default:
- // ok = false
- d.d.errorf("read float supports only float32/64 - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
- }
- return
- }
- func (d *bincDecDriver) decUint() (v uint64) {
- switch d.vs {
- case 0:
- v = uint64(d.d.decRd.readn1())
- case 1:
- v = uint64(bigen.Uint16(d.d.decRd.readn2()))
- case 2:
- v = uint64(bigen.Uint32(d.d.decRd.readn3()))
- case 3:
- v = uint64(bigen.Uint32(d.d.decRd.readn4()))
- case 4, 5, 6:
- var b [8]byte
- lim := 7 - d.vs
- bs := d.d.b[lim:8]
- d.d.decRd.readb(bs)
- copy(b[lim:], bs)
- v = bigen.Uint64(b)
- case 7:
- v = bigen.Uint64(d.d.decRd.readn8())
- default:
- d.d.errorf("unsigned integers with greater than 64 bits of precision not supported: d.vs: %v %x", d.vs, d.vs)
- }
- return
- }
- func (d *bincDecDriver) uintBytes() (bs []byte) {
- switch d.vs {
- case 0:
- bs = d.d.b[:1]
- bs[0] = d.d.decRd.readn1()
- case 1:
- bs = d.d.b[:2]
- d.d.decRd.readb(bs)
- case 2:
- bs = d.d.b[:3]
- d.d.decRd.readb(bs)
- case 3:
- bs = d.d.b[:4]
- d.d.decRd.readb(bs)
- case 4, 5, 6:
- lim := 7 - d.vs
- bs = d.d.b[lim:8]
- d.d.decRd.readb(bs)
- case 7:
- bs = d.d.b[:8]
- d.d.decRd.readb(bs)
- default:
- d.d.errorf("unsigned integers with greater than 64 bits of precision not supported: d.vs: %v %x", d.vs, d.vs)
- }
- return
- }
- func (d *bincDecDriver) decInteger() (ui uint64, neg, ok bool) {
- ok = true
- vd, vs := d.vd, d.vs
- if vd == bincVdPosInt {
- ui = d.decUint()
- } else if vd == bincVdNegInt {
- ui = d.decUint()
- neg = true
- } else if vd == bincVdSmallInt {
- ui = uint64(d.vs) + 1
- } else if vd == bincVdSpecial {
- if vs == bincSpZero {
- // i = 0
- } else if vs == bincSpNegOne {
- neg = true
- ui = 1
- } else {
- ok = false
- // d.d.errorf("integer decode has invalid special value %x-%x/%s", d.vd, d.vs, bincdesc(d.vd, d.vs))
- }
- } else {
- ok = false
- // d.d.errorf("integer can only be decoded from int/uint. d.bd: 0x%x, d.vd: 0x%x", d.bd, d.vd)
- }
- return
- }
- func (d *bincDecDriver) decFloat() (f float64, ok bool) {
- ok = true
- vd, vs := d.vd, d.vs
- if vd == bincVdSpecial {
- if vs == bincSpNan {
- f = math.NaN()
- } else if vs == bincSpPosInf {
- f = math.Inf(1)
- } else if vs == bincSpZeroFloat || vs == bincSpZero {
- } else if vs == bincSpNegInf {
- f = math.Inf(-1)
- } else {
- ok = false
- // d.d.errorf("float - invalid special value %x-%x/%s", d.vd, d.vs, bincdesc(d.vd, d.vs))
- }
- } else if vd == bincVdFloat {
- f = d.decFloatVal()
- } else {
- ok = false
- }
- return
- }
- func (d *bincDecDriver) DecodeInt64() (i int64) {
- if d.advanceNil() {
- return
- }
- i = decNegintPosintFloatNumberHelper{&d.d}.int64(d.decInteger())
- d.bdRead = false
- return
- }
- func (d *bincDecDriver) DecodeUint64() (ui uint64) {
- if d.advanceNil() {
- return
- }
- ui = decNegintPosintFloatNumberHelper{&d.d}.uint64(d.decInteger())
- d.bdRead = false
- return
- }
- func (d *bincDecDriver) DecodeFloat64() (f float64) {
- if d.advanceNil() {
- return
- }
- f = decNegintPosintFloatNumberHelper{&d.d}.float64(d.decFloat())
- d.bdRead = false
- return
- }
- func (d *bincDecDriver) DecodeBool() (b bool) {
- if d.advanceNil() {
- return
- }
- if d.bd == (bincVdSpecial | bincSpFalse) {
- // b = false
- } else if d.bd == (bincVdSpecial | bincSpTrue) {
- b = true
- } else {
- d.d.errorf("bool - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
- }
- d.bdRead = false
- return
- }
- func (d *bincDecDriver) ReadMapStart() (length int) {
- if d.advanceNil() {
- return containerLenNil
- }
- if d.vd != bincVdMap {
- d.d.errorf("map - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
- }
- length = d.decLen()
- d.bdRead = false
- return
- }
- func (d *bincDecDriver) ReadArrayStart() (length int) {
- if d.advanceNil() {
- return containerLenNil
- }
- if d.vd != bincVdArray {
- d.d.errorf("array - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
- }
- length = d.decLen()
- d.bdRead = false
- return
- }
- func (d *bincDecDriver) decLen() int {
- if d.vs > 3 {
- return int(d.vs - 4)
- }
- return int(d.decLenNumber())
- }
- func (d *bincDecDriver) decLenNumber() (v uint64) {
- if x := d.vs; x == 0 {
- v = uint64(d.d.decRd.readn1())
- } else if x == 1 {
- v = uint64(bigen.Uint16(d.d.decRd.readn2()))
- } else if x == 2 {
- v = uint64(bigen.Uint32(d.d.decRd.readn4()))
- } else {
- v = bigen.Uint64(d.d.decRd.readn8())
- }
- return
- }
- // func (d *bincDecDriver) decStringBytes(bs []byte, zerocopy bool) (bs2 []byte) {
- func (d *bincDecDriver) DecodeStringAsBytes() (bs2 []byte) {
- d.d.decByteState = decByteStateNone
- if d.advanceNil() {
- return
- }
- var slen = -1
- switch d.vd {
- case bincVdString, bincVdByteArray:
- slen = d.decLen()
- if d.d.bytes {
- d.d.decByteState = decByteStateZerocopy
- bs2 = d.d.decRd.rb.readx(uint(slen))
- } else {
- d.d.decByteState = decByteStateReuseBuf
- bs2 = decByteSlice(d.d.r(), slen, d.d.h.MaxInitLen, d.d.b[:])
- }
- case bincVdSymbol:
- // zerocopy doesn't apply for symbols,
- // as the values must be stored in a table for later use.
- var symbol uint16
- vs := d.vs
- if vs&0x8 == 0 {
- symbol = uint16(d.d.decRd.readn1())
- } else {
- symbol = uint16(bigen.Uint16(d.d.decRd.readn2()))
- }
- if d.s == nil {
- d.s = make(map[uint16][]byte, 16)
- }
- if vs&0x4 == 0 {
- bs2 = d.s[symbol]
- } else {
- switch vs & 0x3 {
- case 0:
- slen = int(d.d.decRd.readn1())
- case 1:
- slen = int(bigen.Uint16(d.d.decRd.readn2()))
- case 2:
- slen = int(bigen.Uint32(d.d.decRd.readn4()))
- case 3:
- slen = int(bigen.Uint64(d.d.decRd.readn8()))
- }
- // As we are using symbols, do not store any part of
- // the parameter bs in the map, as it might be a shared buffer.
- bs2 = decByteSlice(d.d.r(), slen, d.d.h.MaxInitLen, nil)
- d.s[symbol] = bs2
- }
- default:
- d.d.errorf("string/bytes - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
- }
- d.bdRead = false
- return
- }
- func (d *bincDecDriver) DecodeBytes(bs []byte) (bsOut []byte) {
- d.d.decByteState = decByteStateNone
- if d.advanceNil() {
- return
- }
- if d.vd == bincVdArray {
- if bs == nil {
- bs = d.d.b[:]
- d.d.decByteState = decByteStateReuseBuf
- }
- slen := d.ReadArrayStart()
- var changed bool
- if bs, changed = usableByteSlice(bs, slen); changed {
- d.d.decByteState = decByteStateNone
- }
- for i := 0; i < slen; i++ {
- bs[i] = uint8(chkOvf.UintV(d.DecodeUint64(), 8))
- }
- for i := len(bs); i < slen; i++ {
- bs = append(bs, uint8(chkOvf.UintV(d.DecodeUint64(), 8)))
- }
- return bs
- }
- var clen int
- if d.vd == bincVdString || d.vd == bincVdByteArray {
- clen = d.decLen()
- } else {
- d.d.errorf("bytes - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
- }
- d.bdRead = false
- if d.d.zerocopy() {
- d.d.decByteState = decByteStateZerocopy
- return d.d.decRd.rb.readx(uint(clen))
- }
- if bs == nil {
- bs = d.d.b[:]
- d.d.decByteState = decByteStateReuseBuf
- }
- return decByteSlice(d.d.r(), clen, d.d.h.MaxInitLen, bs)
- }
- func (d *bincDecDriver) DecodeExt(rv interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
- if xtag > 0xff {
- d.d.errorf("ext: tag must be <= 0xff; got: %v", xtag)
- }
- if d.advanceNil() {
- return
- }
- xbs, realxtag1, zerocopy := d.decodeExtV(ext != nil, uint8(xtag))
- realxtag := uint64(realxtag1)
- if ext == nil {
- re := rv.(*RawExt)
- re.Tag = realxtag
- re.setData(xbs, zerocopy)
- } else if ext == SelfExt {
- d.d.sideDecode(rv, basetype, xbs)
- } else {
- ext.ReadExt(rv, xbs)
- }
- }
- func (d *bincDecDriver) decodeExtV(verifyTag bool, tag byte) (xbs []byte, xtag byte, zerocopy bool) {
- if d.vd == bincVdCustomExt {
- l := d.decLen()
- xtag = d.d.decRd.readn1()
- if verifyTag && xtag != tag {
- d.d.errorf("wrong extension tag - got %b, expecting: %v", xtag, tag)
- }
- if d.d.bytes {
- xbs = d.d.decRd.rb.readx(uint(l))
- zerocopy = true
- } else {
- xbs = decByteSlice(d.d.r(), l, d.d.h.MaxInitLen, d.d.b[:])
- }
- } else if d.vd == bincVdByteArray {
- xbs = d.DecodeBytes(nil)
- } else {
- d.d.errorf("ext expects extensions or byte array - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
- }
- d.bdRead = false
- return
- }
- func (d *bincDecDriver) DecodeNaked() {
- if !d.bdRead {
- d.readNextBd()
- }
- n := d.d.naked()
- var decodeFurther bool
- switch d.vd {
- case bincVdSpecial:
- switch d.vs {
- case bincSpNil:
- n.v = valueTypeNil
- case bincSpFalse:
- n.v = valueTypeBool
- n.b = false
- case bincSpTrue:
- n.v = valueTypeBool
- n.b = true
- case bincSpNan:
- n.v = valueTypeFloat
- n.f = math.NaN()
- case bincSpPosInf:
- n.v = valueTypeFloat
- n.f = math.Inf(1)
- case bincSpNegInf:
- n.v = valueTypeFloat
- n.f = math.Inf(-1)
- case bincSpZeroFloat:
- n.v = valueTypeFloat
- n.f = float64(0)
- case bincSpZero:
- n.v = valueTypeUint
- n.u = uint64(0) // int8(0)
- case bincSpNegOne:
- n.v = valueTypeInt
- n.i = int64(-1) // int8(-1)
- default:
- d.d.errorf("cannot infer value - unrecognized special value %x-%x/%s", d.vd, d.vs, bincdesc(d.vd, d.vs))
- }
- case bincVdSmallInt:
- n.v = valueTypeUint
- n.u = uint64(int8(d.vs)) + 1 // int8(d.vs) + 1
- case bincVdPosInt:
- n.v = valueTypeUint
- n.u = d.decUint()
- case bincVdNegInt:
- n.v = valueTypeInt
- n.i = -(int64(d.decUint()))
- case bincVdFloat:
- n.v = valueTypeFloat
- n.f = d.decFloatVal()
- case bincVdString:
- n.v = valueTypeString
- n.s = d.d.stringZC(d.DecodeStringAsBytes())
- case bincVdByteArray:
- d.d.fauxUnionReadRawBytes(false)
- case bincVdSymbol:
- n.v = valueTypeSymbol
- n.s = d.d.stringZC(d.DecodeStringAsBytes())
- case bincVdTimestamp:
- n.v = valueTypeTime
- tt, err := bincDecodeTime(d.d.decRd.readx(uint(d.vs)))
- halt.onerror(err)
- n.t = tt
- case bincVdCustomExt:
- n.v = valueTypeExt
- l := d.decLen()
- n.u = uint64(d.d.decRd.readn1())
- if d.d.bytes {
- n.l = d.d.decRd.rb.readx(uint(l))
- } else {
- n.l = decByteSlice(d.d.r(), l, d.d.h.MaxInitLen, d.d.b[:])
- }
- case bincVdArray:
- n.v = valueTypeArray
- decodeFurther = true
- case bincVdMap:
- n.v = valueTypeMap
- decodeFurther = true
- default:
- d.d.errorf("cannot infer value - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
- }
- if !decodeFurther {
- d.bdRead = false
- }
- if n.v == valueTypeUint && d.h.SignedInteger {
- n.v = valueTypeInt
- n.i = int64(n.u)
- }
- }
- func (d *bincDecDriver) nextValueBytes(v0 []byte) (v []byte) {
- if !d.bdRead {
- d.readNextBd()
- }
- v = v0
- var h = decNextValueBytesHelper{d: &d.d}
- var cursor = d.d.rb.c - 1
- h.append1(&v, d.bd)
- v = d.nextValueBytesBdReadR(v)
- d.bdRead = false
- h.bytesRdV(&v, cursor)
- return
- }
- func (d *bincDecDriver) nextValueBytesR(v0 []byte) (v []byte) {
- d.readNextBd()
- v = v0
- var h = decNextValueBytesHelper{d: &d.d}
- h.append1(&v, d.bd)
- return d.nextValueBytesBdReadR(v)
- }
- func (d *bincDecDriver) nextValueBytesBdReadR(v0 []byte) (v []byte) {
- v = v0
- var h = decNextValueBytesHelper{d: &d.d}
- fnLen := func(vs byte) uint {
- switch vs {
- case 0:
- x := d.d.decRd.readn1()
- h.append1(&v, x)
- return uint(x)
- case 1:
- x := d.d.decRd.readn2()
- h.appendN(&v, x[:]...)
- return uint(bigen.Uint16(x))
- case 2:
- x := d.d.decRd.readn4()
- h.appendN(&v, x[:]...)
- return uint(bigen.Uint32(x))
- case 3:
- x := d.d.decRd.readn8()
- h.appendN(&v, x[:]...)
- return uint(bigen.Uint64(x))
- default:
- return uint(vs - 4)
- }
- }
- var clen uint
- switch d.vd {
- case bincVdSpecial:
- switch d.vs {
- case bincSpNil, bincSpFalse, bincSpTrue, bincSpNan, bincSpPosInf: // pass
- case bincSpNegInf, bincSpZeroFloat, bincSpZero, bincSpNegOne: // pass
- default:
- d.d.errorf("cannot infer value - unrecognized special value %x-%x/%s", d.vd, d.vs, bincdesc(d.vd, d.vs))
- }
- case bincVdSmallInt: // pass
- case bincVdPosInt, bincVdNegInt:
- bs := d.uintBytes()
- h.appendN(&v, bs...)
- case bincVdFloat:
- fn := func(xlen byte) {
- if d.vs&0x8 != 0 {
- xlen = d.d.decRd.readn1()
- h.append1(&v, xlen)
- if xlen > 8 {
- d.d.errorf("cannot read float - at most 8 bytes used to represent float - received %v bytes", xlen)
- }
- }
- d.d.decRd.readb(d.d.b[:xlen])
- h.appendN(&v, d.d.b[:xlen]...)
- }
- switch d.vs & 0x7 {
- case bincFlBin32:
- fn(4)
- case bincFlBin64:
- fn(8)
- default:
- d.d.errorf("read float supports only float32/64 - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
- }
- case bincVdString, bincVdByteArray:
- clen = fnLen(d.vs)
- h.appendN(&v, d.d.decRd.readx(clen)...)
- case bincVdSymbol:
- if d.vs&0x8 == 0 {
- h.append1(&v, d.d.decRd.readn1())
- } else {
- h.appendN(&v, d.d.decRd.rb.readx(2)...)
- }
- if d.vs&0x4 != 0 {
- clen = fnLen(d.vs & 0x3)
- h.appendN(&v, d.d.decRd.readx(clen)...)
- }
- case bincVdTimestamp:
- h.appendN(&v, d.d.decRd.readx(uint(d.vs))...)
- case bincVdCustomExt:
- clen = fnLen(d.vs)
- h.append1(&v, d.d.decRd.readn1()) // tag
- h.appendN(&v, d.d.decRd.readx(clen)...)
- case bincVdArray:
- clen = fnLen(d.vs)
- for i := uint(0); i < clen; i++ {
- v = d.nextValueBytesR(v)
- }
- case bincVdMap:
- clen = fnLen(d.vs)
- for i := uint(0); i < clen; i++ {
- v = d.nextValueBytesR(v)
- v = d.nextValueBytesR(v)
- }
- default:
- d.d.errorf("cannot infer value - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
- }
- return
- }
- //------------------------------------
- //BincHandle is a Handle for the Binc Schema-Free Encoding Format
- //defined at https://github.com/ugorji/binc .
- //
- //BincHandle currently supports all Binc features with the following EXCEPTIONS:
- // - only integers up to 64 bits of precision are supported.
- // big integers are unsupported.
- // - Only IEEE 754 binary32 and binary64 floats are supported (ie Go float32 and float64 types).
- // extended precision and decimal IEEE 754 floats are unsupported.
- // - Only UTF-8 strings supported.
- // Unicode_Other Binc types (UTF16, UTF32) are currently unsupported.
- //
- //Note that these EXCEPTIONS are temporary and full support is possible and may happen soon.
- type BincHandle struct {
- BasicHandle
- binaryEncodingType
- // noElemSeparators
- // AsSymbols defines what should be encoded as symbols.
- //
- // Encoding as symbols can reduce the encoded size significantly.
- //
- // However, during decoding, each string to be encoded as a symbol must
- // be checked to see if it has been seen before. Consequently, encoding time
- // will increase if using symbols, because string comparisons has a clear cost.
- //
- // Values:
- // - 0: default: library uses best judgement
- // - 1: use symbols
- // - 2: do not use symbols
- AsSymbols uint8
- // AsSymbols: may later on introduce more options ...
- // - m: map keys
- // - s: struct fields
- // - n: none
- // - a: all: same as m, s, ...
- // _ [7]uint64 // padding (cache-aligned)
- }
- // Name returns the name of the handle: binc
- func (h *BincHandle) Name() string { return "binc" }
- func (h *BincHandle) desc(bd byte) string { return bincdesc(bd>>4, bd&0x0f) }
- func (h *BincHandle) newEncDriver() encDriver {
- var e = &bincEncDriver{h: h}
- e.e.e = e
- e.e.init(h)
- e.reset()
- return e
- }
- func (h *BincHandle) newDecDriver() decDriver {
- d := &bincDecDriver{h: h}
- d.d.d = d
- d.d.init(h)
- d.reset()
- return d
- }
- // var timeDigits = [...]byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}
- // EncodeTime encodes a time.Time as a []byte, including
- // information on the instant in time and UTC offset.
- //
- // Format Description
- //
- // A timestamp is composed of 3 components:
- //
- // - secs: signed integer representing seconds since unix epoch
- // - nsces: unsigned integer representing fractional seconds as a
- // nanosecond offset within secs, in the range 0 <= nsecs < 1e9
- // - tz: signed integer representing timezone offset in minutes east of UTC,
- // and a dst (daylight savings time) flag
- //
- // When encoding a timestamp, the first byte is the descriptor, which
- // defines which components are encoded and how many bytes are used to
- // encode secs and nsecs components. *If secs/nsecs is 0 or tz is UTC, it
- // is not encoded in the byte array explicitly*.
- //
- // Descriptor 8 bits are of the form `A B C DDD EE`:
- // A: Is secs component encoded? 1 = true
- // B: Is nsecs component encoded? 1 = true
- // C: Is tz component encoded? 1 = true
- // DDD: Number of extra bytes for secs (range 0-7).
- // If A = 1, secs encoded in DDD+1 bytes.
- // If A = 0, secs is not encoded, and is assumed to be 0.
- // If A = 1, then we need at least 1 byte to encode secs.
- // DDD says the number of extra bytes beyond that 1.
- // E.g. if DDD=0, then secs is represented in 1 byte.
- // if DDD=2, then secs is represented in 3 bytes.
- // EE: Number of extra bytes for nsecs (range 0-3).
- // If B = 1, nsecs encoded in EE+1 bytes (similar to secs/DDD above)
- //
- // Following the descriptor bytes, subsequent bytes are:
- //
- // secs component encoded in `DDD + 1` bytes (if A == 1)
- // nsecs component encoded in `EE + 1` bytes (if B == 1)
- // tz component encoded in 2 bytes (if C == 1)
- //
- // secs and nsecs components are integers encoded in a BigEndian
- // 2-complement encoding format.
- //
- // tz component is encoded as 2 bytes (16 bits). Most significant bit 15 to
- // Least significant bit 0 are described below:
- //
- // Timezone offset has a range of -12:00 to +14:00 (ie -720 to +840 minutes).
- // Bit 15 = have\_dst: set to 1 if we set the dst flag.
- // Bit 14 = dst\_on: set to 1 if dst is in effect at the time, or 0 if not.
- // Bits 13..0 = timezone offset in minutes. It is a signed integer in Big Endian format.
- //
- func bincEncodeTime(t time.Time) []byte {
- // t := rv2i(rv).(time.Time)
- tsecs, tnsecs := t.Unix(), t.Nanosecond()
- var (
- bd byte
- bs [16]byte
- i int = 1
- )
- l := t.Location()
- if l == time.UTC {
- l = nil
- }
- if tsecs != 0 {
- bd = bd | 0x80
- btmp := bigen.PutUint64(uint64(tsecs))
- f := pruneSignExt(btmp[:], tsecs >= 0)
- bd = bd | (byte(7-f) << 2)
- copy(bs[i:], btmp[f:])
- i = i + (8 - f)
- }
- if tnsecs != 0 {
- bd = bd | 0x40
- btmp := bigen.PutUint32(uint32(tnsecs))
- f := pruneSignExt(btmp[:4], true)
- bd = bd | byte(3-f)
- copy(bs[i:], btmp[f:4])
- i = i + (4 - f)
- }
- if l != nil {
- bd = bd | 0x20
- // Note that Go Libs do not give access to dst flag.
- _, zoneOffset := t.Zone()
- // zoneName, zoneOffset := t.Zone()
- zoneOffset /= 60
- z := uint16(zoneOffset)
- btmp := bigen.PutUint16(z)
- // clear dst flags
- bs[i] = btmp[0] & 0x3f
- bs[i+1] = btmp[1]
- i = i + 2
- }
- bs[0] = bd
- return bs[0:i]
- }
- // bincDecodeTime decodes a []byte into a time.Time.
- func bincDecodeTime(bs []byte) (tt time.Time, err error) {
- bd := bs[0]
- var (
- tsec int64
- tnsec uint32
- tz uint16
- i byte = 1
- i2 byte
- n byte
- )
- if bd&(1<<7) != 0 {
- var btmp [8]byte
- n = ((bd >> 2) & 0x7) + 1
- i2 = i + n
- copy(btmp[8-n:], bs[i:i2])
- // if first bit of bs[i] is set, then fill btmp[0..8-n] with 0xff (ie sign extend it)
- if bs[i]&(1<<7) != 0 {
- copy(btmp[0:8-n], bsAll0xff)
- }
- i = i2
- tsec = int64(bigen.Uint64(btmp))
- }
- if bd&(1<<6) != 0 {
- var btmp [4]byte
- n = (bd & 0x3) + 1
- i2 = i + n
- copy(btmp[4-n:], bs[i:i2])
- i = i2
- tnsec = bigen.Uint32(btmp)
- }
- if bd&(1<<5) == 0 {
- tt = time.Unix(tsec, int64(tnsec)).UTC()
- return
- }
- // In stdlib time.Parse, when a date is parsed without a zone name, it uses "" as zone name.
- // However, we need name here, so it can be shown when time is printf.d.
- // Zone name is in form: UTC-08:00.
- // Note that Go Libs do not give access to dst flag, so we ignore dst bits
- tz = bigen.Uint16([2]byte{bs[i], bs[i+1]})
- // sign extend sign bit into top 2 MSB (which were dst bits):
- if tz&(1<<13) == 0 { // positive
- tz = tz & 0x3fff //clear 2 MSBs: dst bits
- } else { // negative
- tz = tz | 0xc000 //set 2 MSBs: dst bits
- }
- tzint := int16(tz)
- if tzint == 0 {
- tt = time.Unix(tsec, int64(tnsec)).UTC()
- } else {
- // For Go Time, do not use a descriptive timezone.
- // It's unnecessary, and makes it harder to do a reflect.DeepEqual.
- // The Offset already tells what the offset should be, if not on UTC and unknown zone name.
- // var zoneName = timeLocUTCName(tzint)
- tt = time.Unix(tsec, int64(tnsec)).In(time.FixedZone("", int(tzint)*60))
- }
- return
- }
- var _ decDriver = (*bincDecDriver)(nil)
- var _ encDriver = (*bincEncDriver)(nil)
|