1
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
2
// Use of this source code is governed by a MIT license found in the LICENSE file.
16
const msgBadDesc = "unrecognized descriptor byte"
19
decDefMaxDepth = 1024 // maximum depth
20
decDefChanCap = 64 // should be large, as cap cannot be expanded
21
decScratchByteArrayLen = (8 + 2 + 2 + 1) * 8 // around cacheLineSize ie ~64, depending on Decoder size
23
// MARKER: massage decScratchByteArrayLen to ensure xxxDecDriver structs fit within cacheLine*N
25
// decFailNonEmptyIntf configures whether we error
26
// when decoding naked into a non-empty interface.
28
// Typically, we cannot decode non-nil stream value into
29
// nil interface with methods (e.g. io.Reader).
30
// However, in some scenarios, this should be allowed:
35
// Consequently, we should relax this. Put it behind a const flag for now.
36
decFailNonEmptyIntf = false
38
// decUseTransient says that we should not use the transient optimization.
40
// There's potential for GC corruption or memory overwrites if transient isn't
41
// used carefully, so this flag helps turn it off quickly if needed.
43
// Use it everywhere needed so we can completely remove unused code blocks.
44
decUseTransient = true
48
errNeedMapOrArrayDecodeToStruct = errors.New("only encoded map or array can decode into struct")49
errCannotDecodeIntoNil = errors.New("cannot decode into nil")51
errExpandSliceCannotChange = errors.New("expand slice: cannot change")53
errDecoderNotInitialized = errors.New("Decoder not initialized")55
errDecUnreadByteNothingToRead = errors.New("cannot unread - nothing has been read")56
errDecUnreadByteLastByteNotRead = errors.New("cannot unread - last byte has not been read")57
errDecUnreadByteUnknown = errors.New("cannot unread - reason unknown")58
errMaxDepthExceeded = errors.New("maximum decoding depth exceeded")61
// decByteState tracks where the []byte returned by the last call
62
// to DecodeBytes or DecodeStringAsByte came from
63
type decByteState uint8
66
decByteStateNone decByteState = iota
67
decByteStateZerocopy // view into []byte that we are decoding from
68
decByteStateReuseBuf // view into transient buffer used internally by decDriver
69
// decByteStateNewAlloc
72
type decNotDecodeableReason uint8
75
decNotDecodeableReasonUnknown decNotDecodeableReason = iota
76
decNotDecodeableReasonBadKind
77
decNotDecodeableReasonNonAddrValue
78
decNotDecodeableReasonNilReference
81
type decDriver interface {82
// this will check if the next token is a break.
85
// TryNil tries to decode as nil.
86
// If a nil is in the stream, it consumes it and returns true.
88
// Note: if TryNil returns true, that must be handled.
91
// ContainerType returns one of: Bytes, String, Nil, Slice or Map.
93
// Return unSet if not known.
95
// Note: Implementations MUST fully consume sentinel container types, specifically Nil.
96
ContainerType() (vt valueType)
98
// DecodeNaked will decode primitives (number, bool, string, []byte) and RawExt.
99
// For maps and arrays, it will not do the decoding in-band, but will signal
100
// the decoder, so that is done later, by setting the fauxUnion.valueType field.
102
// Note: Numbers are decoded as int64, uint64, float64 only (no smaller sized number types).
103
// for extensions, DecodeNaked must read the tag and the []byte if it exists.
104
// if the []byte is not read, then kInterfaceNaked will treat it as a Handle
105
// that stores the subsequent value in-band, and complete reading the RawExt.
107
// extensions should also use readx to decode them, for efficiency.
108
// kInterface will extract the detached byte slice if it has to pass it outside its realm.
111
DecodeInt64() (i int64)
112
DecodeUint64() (ui uint64)
114
DecodeFloat64() (f float64)
115
DecodeBool() (b bool)
117
// DecodeStringAsBytes returns the bytes representing a string.
118
// It will return a view into scratch buffer or input []byte (if applicable).
120
// Note: This can also decode symbols, if supported.
122
// Users should consume it right away and not store it for later use.
123
DecodeStringAsBytes() (v []byte)
125
// DecodeBytes returns the bytes representing a binary value.
126
// It will return a view into scratch buffer or input []byte (if applicable).
128
// All implementations must honor the contract below:
129
// if ZeroCopy and applicable, return a view into input []byte we are decoding from
130
// else if in == nil, return a view into scratch buffer
131
// else append decoded value to in[:0] and return that
132
// (this can be simulated by passing []byte{} as in parameter)134
// Implementations must also update Decoder.decByteState on each call to
135
// DecodeBytes or DecodeStringAsBytes. Some callers may check that and work appropriately.
137
// Note: DecodeBytes may decode past the length of the passed byte slice, up to the cap.
138
// Consequently, it is ok to pass a zero-len slice to DecodeBytes, as the returned
139
// byte slice will have the appropriate length.
140
DecodeBytes(in []byte) (out []byte)
141
// DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut []byte)
143
// DecodeExt will decode into a *RawExt or into an extension.
144
DecodeExt(v interface{}, basetype reflect.Type, xtag uint64, ext Ext)145
// decodeExt(verifyTag bool, tag byte) (xtag byte, xbs []byte)
147
DecodeTime() (t time.Time)
149
// ReadArrayStart will return the length of the array.
150
// If the format doesn't prefix the length, it returns containerLenUnknown.
151
// If the expected array was a nil in the stream, it returns containerLenNil.
154
// ReadMapStart will return the length of the array.
155
// If the format doesn't prefix the length, it returns containerLenUnknown.
156
// If the expected array was a nil in the stream, it returns containerLenNil.
163
// nextValueBytes will return the bytes representing the next value in the stream.
165
// if start is nil, then treat it as a request to discard the next set of bytes,
166
// and the return response does not matter.
167
// Typically, this means that the returned []byte is nil/empty/undefined.
169
// Optimize for decoding from a []byte, where the nextValueBytes will just be a sub-slice
170
// of the input slice. Callers that need to use this to not be a view into the input bytes
171
// should handle it appropriately.
172
nextValueBytes(start []byte) []byte
174
// descBd will describe the token descriptor that signifies what type was decoded
180
decNegintPosintFloatNumber
183
type decDriverContainerTracker interface {191
type decNegintPosintFloatNumber interface {192
decInteger() (ui uint64, neg, ok bool)
193
decFloat() (f float64, ok bool)
196
type decDriverNoopNumberHelper struct{}198
func (x decDriverNoopNumberHelper) decInteger() (ui uint64, neg, ok bool) {199
panic("decInteger unsupported")201
func (x decDriverNoopNumberHelper) decFloat() (f float64, ok bool) { panic("decFloat unsupported") }203
type decDriverNoopContainerReader struct{}205
// func (x decDriverNoopContainerReader) ReadArrayStart() (v int) { panic("ReadArrayStart unsupported") }206
// func (x decDriverNoopContainerReader) ReadMapStart() (v int) { panic("ReadMapStart unsupported") }207
func (x decDriverNoopContainerReader) ReadArrayEnd() {}208
func (x decDriverNoopContainerReader) ReadMapEnd() {}209
func (x decDriverNoopContainerReader) CheckBreak() (v bool) { return }211
// DecodeOptions captures configuration options during decode.
212
type DecodeOptions struct {213
// MapType specifies type to use during schema-less decoding of a map in the stream.
214
// If nil (unset), we default to map[string]interface{} iff json handle and MapKeyAsString=true,215
// else map[interface{}]interface{}.218
// SliceType specifies type to use during schema-less decoding of an array in the stream.
219
// If nil (unset), we default to []interface{} for all formats.220
SliceType reflect.Type
222
// MaxInitLen defines the maxinum initial length that we "make" a collection
223
// (string, slice, map, chan). If 0 or negative, we default to a sensible value
224
// based on the size of an element in the collection.
226
// For example, when decoding, a stream may say that it has 2^64 elements.
227
// We should not auto-matically provision a slice of that size, to prevent Out-Of-Memory crash.
228
// Instead, we provision up to MaxInitLen, fill that up, and start appending after that.
231
// ReaderBufferSize is the size of the buffer used when reading.
233
// if > 0, we use a smart buffer internally for performance purposes.
236
// MaxDepth defines the maximum depth when decoding nested
237
// maps and slices. If 0 or negative, we default to a suitably large number (currently 1024).
240
// If ErrorIfNoField, return an error when decoding a map
241
// from a codec stream into a struct, and no matching struct field is found.
244
// If ErrorIfNoArrayExpand, return an error when decoding a slice/array that cannot be expanded.
245
// For example, the stream contains an array of 8 items, but you are decoding into a [4]T array,
246
// or you are decoding into a slice of length 4 which is non-addressable (and so cannot be set).
247
ErrorIfNoArrayExpand bool
249
// If SignedInteger, use the int64 during schema-less decoding of unsigned values (not uint64).
252
// MapValueReset controls how we decode into a map value.
254
// By default, we MAY retrieve the mapping for a key, and then decode into that.
255
// However, especially with big maps, that retrieval may be expensive and unnecessary
256
// if the stream already contains all that is necessary to recreate the value.
258
// If true, we will never retrieve the previous mapping,
259
// but rather decode into a new value and set that in the map.
261
// If false, we will retrieve the previous mapping if necessary e.g.
262
// the previous mapping is a pointer, or is a struct or array with pre-set state,
263
// or is an interface.
266
// SliceElementReset: on decoding a slice, reset the element to a zero value first.
268
// concern: if the slice already contained some garbage, we will decode into that garbage.
269
SliceElementReset bool
271
// InterfaceReset controls how we decode into an interface.
273
// By default, when we see a field that is an interface{...},274
// or a map with interface{...} value, we will attempt decoding into the275
// "contained" value.
277
// However, this prevents us from reading a string into an interface{}278
// that formerly contained a number.
280
// If true, we will decode into a new "blank" value, and set that in the interface.
281
// If false, we will decode into whatever is contained in the interface.
284
// InternString controls interning of strings during decoding.
286
// Some handles, e.g. json, typically will read map keys as strings.
287
// If the set of keys are finite, it may help reduce allocation to
288
// look them up from a map (than to allocate them afresh).
290
// Note: Handles will be smart when using the intern functionality.
291
// Every string should not be interned.
292
// An excellent use-case for interning is struct field names,
293
// or map keys where key type is string.
296
// PreferArrayOverSlice controls whether to decode to an array or a slice.
298
// This only impacts decoding into a nil interface{}.300
// Consequently, it has no effect on codecgen.
302
// *Note*: This only applies if using go1.5 and above,
303
// as it requires reflect.ArrayOf support which was absent before go1.5.
304
PreferArrayOverSlice bool
306
// DeleteOnNilMapValue controls how to decode a nil value in the stream.
308
// If true, we will delete the mapping of the key.
309
// Else, just set the mapping to the zero value of the type.
311
// Deprecated: This does NOTHING and is left behind for compiling compatibility.
312
// This change is necessitated because 'nil' in a stream now consistently
313
// means the zero value (ie reset the value to its zero state).
314
DeleteOnNilMapValue bool
316
// RawToString controls how raw bytes in a stream are decoded into a nil interface{}.317
// By default, they are decoded as []byte, but can be decoded as string (if configured).
320
// ZeroCopy controls whether decoded values of []byte or string type
321
// point into the input []byte parameter passed to a NewDecoderBytes/ResetBytes(...) call.
323
// To illustrate, if ZeroCopy and decoding from a []byte (not io.Writer),
324
// then a []byte or string in the output result may just be a slice of (point into)
327
// This optimization prevents unnecessary copying.
329
// However, it is made optional, as the caller MUST ensure that the input parameter []byte is
330
// not modified after the Decode() happens, as any changes are mirrored in the decoded result.
333
// PreferPointerForStructOrArray controls whether a struct or array
334
// is stored in a nil interface{}, or a pointer to it.336
// This mostly impacts when we decode registered extensions.
337
PreferPointerForStructOrArray bool
339
// ValidateUnicode controls will cause decoding to fail if an expected unicode
340
// string is well-formed but include invalid codepoints.
342
// This could have a performance impact.
346
// ----------------------------------------
348
func (d *Decoder) rawExt(f *codecFnInfo, rv reflect.Value) {349
d.d.DecodeExt(rv2i(rv), f.ti.rt, 0, nil)
352
func (d *Decoder) ext(f *codecFnInfo, rv reflect.Value) {353
d.d.DecodeExt(rv2i(rv), f.ti.rt, f.xfTag, f.xfFn)
356
func (d *Decoder) selferUnmarshal(f *codecFnInfo, rv reflect.Value) {357
rv2i(rv).(Selfer).CodecDecodeSelf(d)
360
func (d *Decoder) binaryUnmarshal(f *codecFnInfo, rv reflect.Value) {361
bm := rv2i(rv).(encoding.BinaryUnmarshaler)
362
xbs := d.d.DecodeBytes(nil)
363
fnerr := bm.UnmarshalBinary(xbs)
367
func (d *Decoder) textUnmarshal(f *codecFnInfo, rv reflect.Value) {368
tm := rv2i(rv).(encoding.TextUnmarshaler)
369
fnerr := tm.UnmarshalText(d.d.DecodeStringAsBytes())
373
func (d *Decoder) jsonUnmarshal(f *codecFnInfo, rv reflect.Value) {374
d.jsonUnmarshalV(rv2i(rv).(jsonUnmarshaler))
377
func (d *Decoder) jsonUnmarshalV(tm jsonUnmarshaler) {378
// grab the bytes to be read, as UnmarshalJSON needs the full JSON so as to unmarshal it itself.
381
bs0 = d.blist.get(256)
383
bs := d.d.nextValueBytes(bs0)
384
fnerr := tm.UnmarshalJSON(bs)
387
if !byteSliceSameData(bs0, bs) {394
func (d *Decoder) kErr(f *codecFnInfo, rv reflect.Value) {395
d.errorf("no decoding function defined for kind %v", rv.Kind())398
func (d *Decoder) raw(f *codecFnInfo, rv reflect.Value) {399
rvSetBytes(rv, d.rawBytes())
402
func (d *Decoder) kString(f *codecFnInfo, rv reflect.Value) {403
rvSetString(rv, d.stringZC(d.d.DecodeStringAsBytes()))
406
func (d *Decoder) kBool(f *codecFnInfo, rv reflect.Value) {407
rvSetBool(rv, d.d.DecodeBool())
410
func (d *Decoder) kTime(f *codecFnInfo, rv reflect.Value) {411
rvSetTime(rv, d.d.DecodeTime())
414
func (d *Decoder) kFloat32(f *codecFnInfo, rv reflect.Value) {415
rvSetFloat32(rv, d.decodeFloat32())
418
func (d *Decoder) kFloat64(f *codecFnInfo, rv reflect.Value) {419
rvSetFloat64(rv, d.d.DecodeFloat64())
422
func (d *Decoder) kComplex64(f *codecFnInfo, rv reflect.Value) {423
rvSetComplex64(rv, complex(d.decodeFloat32(), 0))
426
func (d *Decoder) kComplex128(f *codecFnInfo, rv reflect.Value) {427
rvSetComplex128(rv, complex(d.d.DecodeFloat64(), 0))
430
func (d *Decoder) kInt(f *codecFnInfo, rv reflect.Value) {431
rvSetInt(rv, int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize)))
434
func (d *Decoder) kInt8(f *codecFnInfo, rv reflect.Value) {435
rvSetInt8(rv, int8(chkOvf.IntV(d.d.DecodeInt64(), 8)))
438
func (d *Decoder) kInt16(f *codecFnInfo, rv reflect.Value) {439
rvSetInt16(rv, int16(chkOvf.IntV(d.d.DecodeInt64(), 16)))
442
func (d *Decoder) kInt32(f *codecFnInfo, rv reflect.Value) {443
rvSetInt32(rv, int32(chkOvf.IntV(d.d.DecodeInt64(), 32)))
446
func (d *Decoder) kInt64(f *codecFnInfo, rv reflect.Value) {447
rvSetInt64(rv, d.d.DecodeInt64())
450
func (d *Decoder) kUint(f *codecFnInfo, rv reflect.Value) {451
rvSetUint(rv, uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize)))
454
func (d *Decoder) kUintptr(f *codecFnInfo, rv reflect.Value) {455
rvSetUintptr(rv, uintptr(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize)))
458
func (d *Decoder) kUint8(f *codecFnInfo, rv reflect.Value) {459
rvSetUint8(rv, uint8(chkOvf.UintV(d.d.DecodeUint64(), 8)))
462
func (d *Decoder) kUint16(f *codecFnInfo, rv reflect.Value) {463
rvSetUint16(rv, uint16(chkOvf.UintV(d.d.DecodeUint64(), 16)))
466
func (d *Decoder) kUint32(f *codecFnInfo, rv reflect.Value) {467
rvSetUint32(rv, uint32(chkOvf.UintV(d.d.DecodeUint64(), 32)))
470
func (d *Decoder) kUint64(f *codecFnInfo, rv reflect.Value) {471
rvSetUint64(rv, d.d.DecodeUint64())
474
func (d *Decoder) kInterfaceNaked(f *codecFnInfo) (rvn reflect.Value) {476
// use some hieristics to decode it appropriately
477
// based on the detected next value in the stream.
481
// We cannot decode non-nil stream value into nil interface with methods (e.g. io.Reader).
482
// Howver, it is possible that the user has ways to pass in a type for a given interface
487
// Consequently, we should relax this. Put it behind a const flag for now.
488
if decFailNonEmptyIntf && f.ti.numMeth > 0 {489
d.errorf("cannot decode non-nil codec value into nil %v (%v methods)", f.ti.rt, f.ti.numMeth)495
if d.jsms { // if json, default to a map type with string keys496
mtid = mapStrIntfTypId // for json performance
498
mtid = mapIntfIntfTypId
501
if mtid == mapStrIntfTypId {502
var v2 map[string]interface{}504
rvn = rv4iptr(&v2).Elem()
505
} else if mtid == mapIntfIntfTypId {506
var v2 map[interface{}]interface{}508
rvn = rv4iptr(&v2).Elem()
510
rvn = reflect.New(d.h.MapType)
514
rvn = rvZeroAddrK(d.h.MapType, reflect.Map)
515
d.decodeValue(rvn, nil)
518
if d.stid == 0 || d.stid == intfSliceTypId {521
rvn = rv4iptr(&v2).Elem()
523
rvn = reflect.New(d.h.SliceType)
527
rvn = rvZeroAddrK(d.h.SliceType, reflect.Slice)
528
d.decodeValue(rvn, nil)
530
if reflectArrayOfSupported && d.h.PreferArrayOverSlice {531
rvn = rvGetArray4Slice(rvn)
534
tag, bytes := n.u, n.l // calling decode below might taint the values
535
bfn := d.h.getExtForTag(tag)
536
var re = RawExt{Tag: tag}538
// it is one of the InterfaceExt ones: json and cbor.
539
// most likely cbor, as json decoding never reveals valueTypeExt (no tagging support)
542
rvn = rv4iptr(&re).Elem()
544
if bfn.ext == SelfExt {545
rvn = rvZeroAddrK(bfn.rt, bfn.rt.Kind())
546
d.decodeValue(rvn, d.h.fnNoExt(bfn.rt))
548
rvn = reflect.New(bfn.rt)
549
d.interfaceExtConvertAndDecode(rv2i(rvn), bfn.ext)
554
// one of the BytesExt ones: binc, msgpack, simple
556
re.setData(bytes, false)
557
rvn = rv4iptr(&re).Elem()
559
rvn = reflect.New(bfn.rt)
560
if bfn.ext == SelfExt {561
d.sideDecode(rv2i(rvn), bfn.rt, bytes)
563
bfn.ext.ReadExt(rv2i(rvn), bytes)
568
// if struct/array, directly store pointer into the interface
569
if d.h.PreferPointerForStructOrArray && rvn.CanAddr() {570
if rk := rvn.Kind(); rk == reflect.Array || rk == reflect.Struct {575
// rvn = reflect.Zero(f.ti.rt)
585
case valueTypeString, valueTypeSymbol:
592
halt.errorf("kInterfaceNaked: unexpected valueType: %d", n.v)597
func (d *Decoder) kInterface(f *codecFnInfo, rv reflect.Value) {598
// Note: A consequence of how kInterface works, is that
599
// if an interface already contains something, we try
600
// to decode into what was there before.
601
// We do not replace with a generic value (as got from decodeNaked).
603
// every interface passed here MUST be settable.
605
// ensure you call rvSetIntf(...) before returning.
607
isnilrv := rvIsNil(rv)
609
var rvn reflect.Value
611
if d.h.InterfaceReset {612
// check if mapping to a type: if so, initialize it and move on
613
rvn = d.h.intf2impl(f.ti.rtid)
615
rvn = d.kInterfaceNaked(f)
619
decSetNonNilRV2Zero4Intf(rv)
624
// check if mapping to a type: if so, initialize it and move on
625
rvn = d.h.intf2impl(f.ti.rtid)
627
rvn = d.kInterfaceNaked(f)
634
// now we have a non-nil interface value, meaning it contains a type
638
// rvn is now a non-interface type
640
canDecode, _ := isDecodeable(rvn)
642
// Note: interface{} is settable, but underlying type may not be.643
// Consequently, we MAY have to allocate a value (containing the underlying value),
644
// decode into it, and reset the interface to that new value.
647
rvn2 := d.oneShotAddrRV(rvn.Type(), rvn.Kind())
648
rvSetDirect(rvn2, rvn)
652
d.decodeValue(rvn, nil)
656
func decStructFieldKeyNotString(dd decDriver, keyType valueType, b *[decScratchByteArrayLen]byte) (rvkencname []byte) {657
if keyType == valueTypeInt {658
rvkencname = strconv.AppendInt(b[:0], dd.DecodeInt64(), 10)
659
} else if keyType == valueTypeUint {660
rvkencname = strconv.AppendUint(b[:0], dd.DecodeUint64(), 10)
661
} else if keyType == valueTypeFloat {662
rvkencname = strconv.AppendFloat(b[:0], dd.DecodeFloat64(), 'f', -1, 64)
664
halt.errorf("invalid struct key type: %v", keyType)669
func (d *Decoder) kStructField(si *structFieldInfo, rv reflect.Value) {671
if rv = si.path.field(rv); rv.IsValid() {672
decSetNonNilRV2Zero(rv)
676
d.decodeValueNoCheckNil(si.path.fieldAlloc(rv), nil)
679
func (d *Decoder) kStruct(f *codecFnInfo, rv reflect.Value) {680
ctyp := d.d.ContainerType()
682
var mf MissingFielder
683
if ti.flagMissingFielder {684
mf = rv2i(rv).(MissingFielder)
685
} else if ti.flagMissingFielderPtr {686
mf = rv2i(rvAddr(rv, ti.ptr)).(MissingFielder)
688
if ctyp == valueTypeMap {689
containerLen := d.mapStart(d.d.ReadMapStart())
690
if containerLen == 0 {694
hasLen := containerLen >= 0
697
var namearr2 [16]byte
700
var rvkencname []byte
701
for j := 0; d.containerNext(j, containerLen, hasLen); j++ {703
if ti.keyType == valueTypeString {704
rvkencname = d.d.DecodeStringAsBytes()
706
rvkencname = decStructFieldKeyNotString(d.d, ti.keyType, &d.b)
709
if si := ti.siForEncName(rvkencname); si != nil {710
d.kStructField(si, rv)
711
} else if mf != nil {712
// store rvkencname in new []byte, as it previously shares Decoder.b, which is used in decode
713
name2 = append(name2[:0], rvkencname...)
716
if !mf.CodecMissingField(name2, f) && d.h.ErrorIfNoField {717
d.errorf("no matching struct field when decoding stream map with key: %s ", stringView(name2))720
d.structFieldNotFound(-1, stringView(rvkencname))
724
} else if ctyp == valueTypeArray {725
containerLen := d.arrayStart(d.d.ReadArrayStart())
726
if containerLen == 0 {730
// Not much gain from doing it two ways for array.
731
// Arrays are not used as much for structs.
732
tisfi := ti.sfi.source()
733
hasLen := containerLen >= 0
735
// iterate all the items in the stream
736
// if mapped elem-wise to a field, handle it
737
// if more stream items than can be mapped, error it
738
for j := 0; d.containerNext(j, containerLen, hasLen); j++ {741
d.kStructField(tisfi[j], rv)
743
d.structFieldNotFound(j, "")
749
d.onerror(errNeedMapOrArrayDecodeToStruct)
753
func (d *Decoder) kSlice(f *codecFnInfo, rv reflect.Value) {754
// A slice can be set from a map or array in stream.
755
// This way, the order can be kept (as order is lost with map).
757
// Note: rv is a slice type here - guaranteed
760
rvCanset := rv.CanSet()
762
ctyp := d.d.ContainerType()
763
if ctyp == valueTypeBytes || ctyp == valueTypeString {764
// you can only decode bytes or string in the stream into a slice or array of bytes
765
if !(ti.rtid == uint8SliceTypId || ti.elemkind == uint8(reflect.Uint8)) {766
d.errorf("bytes/string in stream must decode into slice/array of bytes, not %v", ti.rt)768
rvbs := rvGetBytes(rv)
770
// not addressable byte slice, so do not decode into it past the length
771
rvbs = rvbs[:len(rvbs):len(rvbs)]
773
bs2 := d.decodeBytesInto(rvbs)
774
// if !(len(bs2) == len(rvbs) && byteSliceSameData(rvbs, bs2)) {775
if !(len(bs2) > 0 && len(bs2) == len(rvbs) && &bs2[0] == &rvbs[0]) {778
} else if len(rvbs) > 0 && len(bs2) > 0 {785
slh, containerLenS := d.decSliceHelperStart() // only expects valueType(Array|Map) - never Nil
787
// an array can never return a nil slice. so no need to check f.array here.
788
if containerLenS == 0 {791
rvSetDirect(rv, rvSliceZeroCap(ti.rt))
800
rtelem0Mut := !scalarBitset.isset(ti.elemkind)
803
for k := reflect.Kind(ti.elemkind); k == reflect.Ptr; k = rtelem.Kind() {804
rtelem = rtelem.Elem()
812
var rv9 reflect.Value
814
rvlen := rvLenSlice(rv)
815
rvcap := rvCapSlice(rv)
816
hasLen := containerLenS > 0
818
if containerLenS > rvcap {819
oldRvlenGtZero := rvlen > 0
820
rvlen1 := decInferLen(containerLenS, d.h.MaxInitLen, int(ti.elemsize))
822
} else if rvlen1 <= rvcap {825
rvSetSliceLen(rv, rvlen)
827
} else if rvCanset { // rvlen1 > rvcap829
rv, rvCanset = rvMakeSlice(rv, f.ti, rvlen, rvlen)
831
rvChanged = !rvCanset
832
} else { // rvlen1 > rvcap && !canSet833
d.errorf("cannot decode into non-settable slice")835
if rvChanged && oldRvlenGtZero && rtelem0Mut {836
rvCopySlice(rv, rv0, rtelem) // only copy up to length NOT cap i.e. rv0.Slice(0, rvcap)
838
} else if containerLenS != rvlen {840
rvlen = containerLenS
841
rvSetSliceLen(rv, rvlen)
846
// consider creating new element once, and just decoding into it.
847
var elemReset = d.h.SliceElementReset
851
for ; d.containerNext(j, containerLenS, hasLen); j++ {853
if rvIsNil(rv) { // means hasLen = false855
rvlen = decInferLen(containerLenS, d.h.MaxInitLen, int(ti.elemsize))
856
rv, rvCanset = rvMakeSlice(rv, f.ti, rvlen, rvlen)
858
rvChanged = !rvCanset
860
d.errorf("cannot decode into non-settable slice")867
// if indefinite, etc, then expand the slice if necessary
869
slh.ElemContainerState(j)
871
// expand the slice up to the cap.
872
// Note that we did, so we have to reset it later.
877
rvSetSliceLen(rv, rvlen)
878
} else if rvChanged {879
rv = rvSlice(rv, rvlen)
881
d.onerror(errExpandSliceCannotChange)
884
if !(rvCanset || rvChanged) {885
d.onerror(errExpandSliceCannotChange)
887
rv, rvcap, rvCanset = rvGrowSlice(rv, f.ti, rvcap, 1)
889
rvChanged = !rvCanset
892
slh.ElemContainerState(j)
894
rv9 = rvSliceIndex(rv, j, f.ti)
898
d.decodeValue(rv9, fn)
903
} else if rvChanged {907
} else if j == 0 && rvIsNil(rv) {909
rv = rvSliceZeroCap(ti.rt)
916
if rvChanged { // infers rvCanset=true, so it can be reset921
func (d *Decoder) kArray(f *codecFnInfo, rv reflect.Value) {922
// An array can be set from a map or array in stream.
924
ctyp := d.d.ContainerType()
925
if handleBytesWithinKArray && (ctyp == valueTypeBytes || ctyp == valueTypeString) {926
// you can only decode bytes or string in the stream into a slice or array of bytes
927
if f.ti.elemkind != uint8(reflect.Uint8) {928
d.errorf("bytes/string in stream can decode into array of bytes, but not %v", f.ti.rt)930
rvbs := rvGetArrayBytes(rv, nil)
931
bs2 := d.decodeBytesInto(rvbs)
932
if !byteSliceSameData(rvbs, bs2) && len(rvbs) > 0 && len(bs2) > 0 {938
slh, containerLenS := d.decSliceHelperStart() // only expects valueType(Array|Map) - never Nil
940
// an array can never return a nil slice. so no need to check f.array here.
941
if containerLenS == 0 {947
for k := reflect.Kind(f.ti.elemkind); k == reflect.Ptr; k = rtelem.Kind() {948
rtelem = rtelem.Elem()
953
var rv9 reflect.Value
955
rvlen := rv.Len() // same as cap
956
hasLen := containerLenS > 0
957
if hasLen && containerLenS > rvlen {958
d.errorf("cannot decode into array with length: %v, less than container length: %v", rvlen, containerLenS)961
// consider creating new element once, and just decoding into it.
962
var elemReset = d.h.SliceElementReset
964
for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {965
// note that you cannot expand the array if indefinite and we go past array length
967
slh.arrayCannotExpand(hasLen, rvlen, j, containerLenS)
971
slh.ElemContainerState(j)
972
rv9 = rvArrayIndex(rv, j, f.ti)
980
d.decodeValue(rv9, fn)
985
func (d *Decoder) kChan(f *codecFnInfo, rv reflect.Value) {986
// A slice can be set from a map or array in stream.
987
// This way, the order can be kept (as order is lost with map).
990
if ti.chandir&uint8(reflect.SendDir) == 0 {991
d.errorf("receive-only channel cannot be decoded")993
ctyp := d.d.ContainerType()
994
if ctyp == valueTypeBytes || ctyp == valueTypeString {995
// you can only decode bytes or string in the stream into a slice or array of bytes
996
if !(ti.rtid == uint8SliceTypId || ti.elemkind == uint8(reflect.Uint8)) {997
d.errorf("bytes/string in stream must decode into slice/array of bytes, not %v", ti.rt)999
bs2 := d.d.DecodeBytes(nil)
1001
ch, ok := irv.(chan<- byte)
1003
ch = irv.(chan byte)
1005
for _, b := range bs2 {1011
var rvCanset = rv.CanSet()
1013
// only expects valueType(Array|Map - nil handled above)
1014
slh, containerLenS := d.decSliceHelperStart()
1016
// an array can never return a nil slice. so no need to check f.array here.
1017
if containerLenS == 0 {1018
if rvCanset && rvIsNil(rv) {1019
rvSetDirect(rv, reflect.MakeChan(ti.rt, 0))
1026
useTransient := decUseTransient && ti.elemkind != byte(reflect.Ptr) && ti.tielem.flagCanTransient
1028
for k := reflect.Kind(ti.elemkind); k == reflect.Ptr; k = rtelem.Kind() {1029
rtelem = rtelem.Elem()
1036
var rv9 reflect.Value
1038
var rvlen int // = rv.Len()
1039
hasLen := containerLenS > 0
1041
for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {1045
rvlen = decInferLen(containerLenS, d.h.MaxInitLen, int(ti.elemsize))
1047
rvlen = decDefChanCap
1050
rv = reflect.MakeChan(ti.rt, rvlen)
1053
d.errorf("cannot decode into non-settable chan")1060
slh.ElemContainerState(j)
1063
} else if decUseTransient && useTransient {1064
rv9 = d.perType.TransientAddrK(ti.elem, reflect.Kind(ti.elemkind))
1066
rv9 = rvZeroAddrK(ti.elem, reflect.Kind(ti.elemkind))
1069
d.decodeValueNoCheckNil(rv9, fn)
1075
if rvChanged { // infers rvCanset=true, so it can be reset1076
rvSetDirect(rv0, rv)
1081
func (d *Decoder) kMap(f *codecFnInfo, rv reflect.Value) {1082
containerLen := d.mapStart(d.d.ReadMapStart())
1085
rvlen := decInferLen(containerLen, d.h.MaxInitLen, int(ti.keysize+ti.elemsize))
1086
rvSetDirect(rv, makeMapReflect(ti.rt, rvlen))
1089
if containerLen == 0 {1094
ktype, vtype := ti.key, ti.elem
1095
ktypeId := rt2id(ktype)
1096
vtypeKind := reflect.Kind(ti.elemkind)
1097
ktypeKind := reflect.Kind(ti.keykind)
1098
kfast := mapKeyFastKindFor(ktypeKind)
1099
visindirect := mapStoresElemIndirect(uintptr(ti.elemsize))
1100
visref := refBitset.isset(ti.elemkind)
1102
vtypePtr := vtypeKind == reflect.Ptr
1103
ktypePtr := ktypeKind == reflect.Ptr
1105
vTransient := decUseTransient && !vtypePtr && ti.tielem.flagCanTransient
1106
kTransient := decUseTransient && !ktypePtr && ti.tikey.flagCanTransient
1108
var vtypeElem reflect.Type
1110
var keyFn, valFn *codecFn
1111
var ktypeLo, vtypeLo = ktype, vtype
1113
if ktypeKind == reflect.Ptr {1114
for ktypeLo = ktype.Elem(); ktypeLo.Kind() == reflect.Ptr; ktypeLo = ktypeLo.Elem() {1119
vtypeElem = vtype.Elem()
1120
for vtypeLo = vtypeElem; vtypeLo.Kind() == reflect.Ptr; vtypeLo = vtypeLo.Elem() {1124
rvkMut := !scalarBitset.isset(ti.keykind) // if ktype is immutable, then re-use the same rvk.
1125
rvvMut := !scalarBitset.isset(ti.elemkind)
1126
rvvCanNil := isnilBitset.isset(ti.elemkind)
1129
// rvkn: if non-mutable, on each iteration of loop, set rvk to this
1131
// rvvn: if non-mutable, on each iteration of loop, set rvv to this
1132
// if mutable, may be used as a temporary value for local-scoped operations
1133
// rvva: if mutable, used as transient value for use for key lookup
1134
// rvvz: zero value of map value type, used to do a map set when nil is found in stream
1135
var rvk, rvkn, rvv, rvvn, rvva, rvvz reflect.Value
1137
// we do a doMapGet if kind is mutable, and InterfaceReset=true if interface
1138
var doMapGet, doMapSet bool
1140
if !d.h.MapValueReset {1141
if rvvMut && (vtypeKind != reflect.Interface || !d.h.InterfaceReset) {1143
rvva = mapAddrLoopvarRV(vtype, vtypeKind)
1147
ktypeIsString := ktypeId == stringTypId
1148
ktypeIsIntf := ktypeId == intfTypId
1150
hasLen := containerLen > 0
1152
// kstrbs is used locally for the key bytes, so we can reduce allocation.
1153
// When we read keys, we copy to this local bytes array, and use a stringView for lookup.
1154
// We only convert it into a true string if we have to do a set on the map.
1156
// Since kstr2bs will usually escape to the heap, declaring a [64]byte array may be wasteful.
1157
// It is only valuable if we are sure that it is declared on the stack.
1158
// var kstrarr [64]byte // most keys are less than 32 bytes, and even more less than 64
1159
// var kstrbs = kstrarr[:0]
1166
fnRvk2 := func() (s string) {1168
if len(kstr2bs) < 2 {1169
return string(kstr2bs)
1171
return d.mapKeyString(&callFnRvk, &kstrbs, &kstr2bs)
1174
// Use a possibly transient (map) value (and key), to reduce allocation
1176
for j := 0; d.containerNext(j, containerLen, hasLen); j++ {1179
// if vtypekind is a scalar and thus value will be decoded using TransientAddrK,
1180
// then it is ok to use TransientAddr2K for the map key.
1181
if decUseTransient && vTransient && kTransient {1182
rvk = d.perType.TransientAddr2K(ktype, ktypeKind)
1184
rvk = rvZeroAddrK(ktype, ktypeKind)
1190
if decUseTransient && vTransient {1191
rvvn = d.perType.TransientAddrK(vtype, vtypeKind)
1193
rvvn = rvZeroAddrK(vtype, vtypeKind)
1196
if !ktypeIsString && keyFn == nil {1197
keyFn = d.h.fn(ktypeLo)
1200
valFn = d.h.fn(vtypeLo)
1210
kstr2bs = d.d.DecodeStringAsBytes()
1211
rvSetString(rvk, fnRvk2())
1213
d.decByteState = decByteStateNone
1214
d.decodeValue(rvk, keyFn)
1215
// special case if interface wrapping a byte slice
1217
if rvk2 := rvk.Elem(); rvk2.IsValid() && rvk2.Type() == uint8SliceTyp {1218
kstr2bs = rvGetBytes(rvk2)
1219
rvSetIntf(rvk, rv4istr(fnRvk2()))
1221
// NOTE: consider failing early if map/slice/func
1228
// since a map, we have to set zero value if needed
1229
if !rvvz.IsValid() {1230
rvvz = rvZeroK(vtype, vtypeKind)
1233
s = d.string(kstr2bs)
1236
} else { // ktypeIsIntf1237
rvSetIntf(rvk, rv4istr(s))
1240
mapSet(rv, rvk, rvvz, kfast, visindirect, visref)
1244
// there is non-nil content in the stream to decode ...
1245
// consequently, it's ok to just directly create new value to the pointer (if vtypePtr)
1247
// set doMapSet to false iff u do a get, and the return value is a non-nil pointer
1252
} else if !doMapGet {1255
rvv = mapGet(rv, rvk, rvva, kfast, visindirect, visref)
1256
if !rvv.IsValid() || (rvvCanNil && rvIsNil(rvv)) {1260
case reflect.Ptr, reflect.Map: // ok to decode directly into map
1262
case reflect.Interface:
1263
// if an interface{}, just decode into it iff a non-nil ptr/map, else allocate afresh1265
if k := rvvn.Kind(); (k == reflect.Ptr || k == reflect.Map) && !rvIsNil(rvvn) {1266
d.decodeValueNoCheckNil(rvvn, nil) // valFn is incorrect here
1269
// make addressable (so we can set the interface)
1270
rvvn = rvZeroAddrK(vtype, vtypeKind)
1271
rvSetIntf(rvvn, rvv)
1274
// make addressable (so you can set the slice/array elements, etc)
1275
if decUseTransient && vTransient {1276
rvvn = d.perType.TransientAddrK(vtype, vtypeKind)
1278
rvvn = rvZeroAddrK(vtype, vtypeKind)
1280
rvSetDirect(rvvn, rvv)
1284
goto DECODE_VALUE_NO_CHECK_NIL
1288
rvv = reflect.New(vtypeElem) // non-nil in stream, so allocate value
1289
} else if decUseTransient && vTransient {1290
rvv = d.perType.TransientAddrK(vtype, vtypeKind)
1292
rvv = rvZeroAddrK(vtype, vtypeKind)
1295
DECODE_VALUE_NO_CHECK_NIL:
1296
d.decodeValueNoCheckNil(rvv, valFn)
1300
s = d.string(kstr2bs)
1303
} else { // ktypeIsIntf1304
rvSetIntf(rvk, rv4istr(s))
1307
mapSet(rv, rvk, rvv, kfast, visindirect, visref)
1314
// Decoder reads and decodes an object from an input stream in a supported format.
1316
// Decoder is NOT safe for concurrent use i.e. a Decoder cannot be used
1317
// concurrently in multiple goroutines.
1319
// However, as Decoder could be allocation heavy to initialize, a Reset method is provided
1320
// so its state can be reused to decode new input streams repeatedly.
1321
// This is the idiomatic way to use.
1322
type Decoder struct {1327
// cache the mapTypeId and sliceTypeId for faster comparisons
1335
// ---- cpu cache line boundary?
1338
// ---- cpu cache line boundary?
1346
// used for interning strings
1349
// ---- cpu cache line boundary?
1350
// ---- writable fields during execution --- *try* to keep in sep cache line
1354
// Extensions can call Decode() within a current Decode() call.
1355
// We need to know when the top level Decode() call returns,
1356
// so we can decide whether to Release() or not.
1357
calls uint16 // what depth in mustDecode are we in now.
1363
// b is an always-available scratch buffer used by Decoder and decDrivers.
1364
// By being always-available, it can be used for one-off things without
1365
// having to get from freelist, use, and return back to freelist.
1366
b [decScratchByteArrayLen]byte
1369
// NewDecoder returns a Decoder for decoding a stream of bytes from an io.Reader.
1371
// For efficiency, Users are encouraged to configure ReaderBufferSize on the handle
1372
// OR pass in a memory buffered reader (eg bufio.Reader, bytes.Buffer).
1373
func NewDecoder(r io.Reader, h Handle) *Decoder {1374
d := h.newDecDriver().decoder()
1381
// NewDecoderBytes returns a Decoder which efficiently decodes directly
1382
// from a byte slice with zero copying.
1383
func NewDecoderBytes(in []byte, h Handle) *Decoder {1384
d := h.newDecDriver().decoder()
1391
// NewDecoderString returns a Decoder which efficiently decodes directly
1392
// from a string with zero copying.
1394
// It is a convenience function that calls NewDecoderBytes with a
1395
// []byte view into the string.
1397
// This can be an efficient zero-copy if using default mode i.e. without codec.safe tag.
1398
func NewDecoderString(s string, h Handle) *Decoder {1399
return NewDecoderBytes(bytesView(s), h)
1402
func (d *Decoder) HandleName() string {1406
func (d *Decoder) r() *decRd {1410
func (d *Decoder) init(h Handle) {1412
d.cbreak = d.js || d.cbor
1414
d.err = errDecoderNotInitialized
1415
d.h = h.getBasicHandle()
1418
if d.h.InternString && d.is == nil {1421
// NOTE: do not initialize d.n here. It is lazily initialized in d.naked()
1424
func (d *Decoder) resetCommon() {1428
d.decByteState = decByteStateNone
1431
// reset all things which were cached from the Handle, but could change
1432
d.maxdepth = decDefMaxDepth
1433
if d.h.MaxDepth > 0 {1434
d.maxdepth = d.h.MaxDepth
1440
if d.h.MapType != nil {1441
d.mtid = rt2id(d.h.MapType)
1442
d.mtr = fastpathAvIndex(d.mtid) != -1
1444
if d.h.SliceType != nil {1445
d.stid = rt2id(d.h.SliceType)
1446
d.str = fastpathAvIndex(d.stid) != -1
1450
// Reset the Decoder with a new Reader to decode from,
1451
// clearing all state from last run(s).
1452
func (d *Decoder) Reset(r io.Reader) {1458
d.ri = new(ioDecReader)
1460
d.ri.reset(r, d.h.ReaderBufferSize, &d.blist)
1465
// ResetBytes resets the Decoder with a new []byte to decode from,
1466
// clearing all state from last run(s).
1467
func (d *Decoder) ResetBytes(in []byte) {1477
// ResetString resets the Decoder with a new string to decode from,
1478
// clearing all state from last run(s).
1480
// It is a convenience function that calls ResetBytes with a
1481
// []byte view into the string.
1483
// This can be an efficient zero-copy if using default mode i.e. without codec.safe tag.
1484
func (d *Decoder) ResetString(s string) {1485
d.ResetBytes(bytesView(s))
1488
func (d *Decoder) naked() *fauxUnion {1492
// Decode decodes the stream from reader and stores the result in the
1493
// value pointed to by v. v cannot be a nil pointer. v can also be
1494
// a reflect.Value of a pointer.
1496
// Note that a pointer to a nil interface is not a nil pointer.
1497
// If you do not know what type of stream it is, pass in a pointer to a nil interface.
1498
// We will decode and store a value in that nil interface.
1502
// // Decoding into a non-nil typed value
1504
// err = codec.NewDecoder(r, handle).Decode(&f)
1506
// // Decoding into nil interface
1508
// dec := codec.NewDecoder(r, handle)
1509
// err = dec.Decode(&v)
1511
// When decoding into a nil interface{}, we will decode into an appropriate value based1512
// on the contents of the stream:
1513
// - Numbers are decoded as float64, int64 or uint64.
1514
// - Other values are decoded appropriately depending on the type:
1515
// bool, string, []byte, time.Time, etc
1516
// - Extensions are decoded as RawExt (if no ext function registered for the tag)
1518
// Configurations exist on the Handle to override defaults
1519
// (e.g. for MapType, SliceType and how to decode raw bytes).
1521
// When decoding into a non-nil interface{} value, the mode of encoding is based on the1522
// type of the value. When a value is seen:
1523
// - If an extension is registered for it, call that extension function
1524
// - If it implements BinaryUnmarshaler, call its UnmarshalBinary(data []byte) error
1525
// - Else decode it based on its reflect.Kind
1527
// There are some special rules when decoding into containers (slice/array/map/struct).
1528
// Decode will typically use the stream contents to UPDATE the container i.e. the values
1529
// in these containers will not be zero'ed before decoding.
1530
// - A map can be decoded from a stream map, by updating matching keys.
1531
// - A slice can be decoded from a stream array,
1532
// by updating the first n elements, where n is length of the stream.
1533
// - A slice can be decoded from a stream map, by decoding as if
1534
// it contains a sequence of key-value pairs.
1535
// - A struct can be decoded from a stream map, by updating matching fields.
1536
// - A struct can be decoded from a stream array,
1537
// by updating fields as they occur in the struct (by index).
1539
// This in-place update maintains consistency in the decoding philosophy (i.e. we ALWAYS update
1540
// in place by default). However, the consequence of this is that values in slices or maps
1541
// which are not zero'ed before hand, will have part of the prior values in place after decode
1542
// if the stream doesn't contain an update for those parts.
1544
// This in-place update can be disabled by configuring the MapValueReset and SliceElementReset
1545
// decode options available on every handle.
1547
// Furthermore, when decoding a stream map or array with length of 0 into a nil map or slice,
1548
// we reset the destination map or slice to a zero-length value.
1550
// However, when decoding a stream nil, we reset the destination container
1551
// to its "zero" value (e.g. nil for slice/map, etc).
1553
// Note: we allow nil values in the stream anywhere except for map keys.
1554
// A nil value in the encoded stream where a map key is expected is treated as an error.
1555
func (d *Decoder) Decode(v interface{}) (err error) {1556
// tried to use closure, as runtime optimizes defer with no params.
1557
// This seemed to be causing weird issues (like circular reference found, unexpected panic, etc).
1558
// Also, see https://github.com/golang/go/issues/14939#issuecomment-417836139
1561
if x := recover(); x != nil {1562
panicValToErr(d, x, &d.err)
1572
// MustDecode is like Decode, but panics if unable to Decode.
1574
// Note: This provides insight to the code location that triggered the error.
1575
func (d *Decoder) MustDecode(v interface{}) {1578
halt.onerror(errNoFormatHandle)
1581
// Top-level: v is a pointer and not nil.
1587
// Release is a no-op.
1589
// Deprecated: Pooled resources are not used with a Decoder.
1590
// This method is kept for compatibility reasons only.
1591
func (d *Decoder) Release() {1594
func (d *Decoder) swallow() {1595
d.d.nextValueBytes(nil)
1598
func (d *Decoder) swallowErr() (err error) {1601
if x := recover(); x != nil {1602
panicValToErr(d, x, &err)
1610
func setZero(iv interface{}) {1618
// var canDecode bool
1619
switch v := iv.(type) {1659
decSetNonNilRV2Zero(v)
1661
if !fastpathDecodeSetZeroTypeSwitch(iv) {1662
decSetNonNilRV2Zero(rv)
1667
// decSetNonNilRV2Zero will set the non-nil value to its zero value.
1668
func decSetNonNilRV2Zero(v reflect.Value) {1669
// If not decodeable (settable), we do not touch it.
1670
// We considered empty'ing it if not decodeable e.g.
1671
// - if chan, drain it
1672
// - if map, clear it
1673
// - if slice or array, zero all elements up to len
1675
// However, we decided instead that we either will set the
1676
// whole value to the zero value, or leave AS IS.
1679
if k == reflect.Interface {1680
decSetNonNilRV2Zero4Intf(v)
1681
} else if k == reflect.Ptr {1682
decSetNonNilRV2Zero4Ptr(v)
1683
} else if v.CanSet() {1688
func decSetNonNilRV2Zero4Ptr(v reflect.Value) {1691
rvSetZero(ve) // we can have a pointer to an interface
1692
} else if v.CanSet() {1697
func decSetNonNilRV2Zero4Intf(v reflect.Value) {1700
rvSetDirectZero(ve) // interfaces always have element as a non-interface
1701
} else if v.CanSet() {1706
func (d *Decoder) decode(iv interface{}) {1707
// a switch with only concrete types can be optimized.
1708
// consequently, we deal with nil and interfaces outside the switch.
1711
d.onerror(errCannotDecodeIntoNil)
1714
switch v := iv.(type) {1718
if x, _ := isDecodeable(v); !x {1719
d.haltAsNotDecodeable(v)
1721
d.decodeValue(v, nil)
1723
*v = d.stringZC(d.d.DecodeStringAsBytes())
1725
*v = d.d.DecodeBool()
1727
*v = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
1729
*v = int8(chkOvf.IntV(d.d.DecodeInt64(), 8))
1731
*v = int16(chkOvf.IntV(d.d.DecodeInt64(), 16))
1733
*v = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
1735
*v = d.d.DecodeInt64()
1737
*v = uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
1739
*v = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
1741
*v = uint16(chkOvf.UintV(d.d.DecodeUint64(), 16))
1743
*v = uint32(chkOvf.UintV(d.d.DecodeUint64(), 32))
1745
*v = d.d.DecodeUint64()
1747
*v = d.decodeFloat32()
1749
*v = d.d.DecodeFloat64()
1751
*v = complex(d.decodeFloat32(), 0)
1753
*v = complex(d.d.DecodeFloat64(), 0)
1755
*v = d.decodeBytesInto(*v)
1757
// not addressable byte slice, so do not decode into it past the length
1758
b := d.decodeBytesInto(v[:len(v):len(v)])
1759
if !(len(b) > 0 && len(b) == len(v) && &b[0] == &v[0]) { // not same slice1763
*v = d.d.DecodeTime()
1768
d.decodeValue(rv4iptr(v), nil)
1771
// we can't check non-predefined types, as they might be a Selfer or extension.
1772
if skipFastpathTypeSwitchInDirectCall || !fastpathDecodeTypeSwitch(iv, d) {1773
v := reflect.ValueOf(iv)
1774
if x, _ := isDecodeable(v); !x {1775
d.haltAsNotDecodeable(v)
1777
d.decodeValue(v, nil)
1782
// decodeValue MUST be called by the actual value we want to decode into,
1783
// not its addr or a reference to it.
1785
// This way, we know if it is itself a pointer, and can handle nil in
1786
// the stream effectively.
1788
// Note that decodeValue will handle nil in the stream early, so that the
1789
// subsequent calls i.e. kXXX methods, etc do not have to handle it themselves.
1790
func (d *Decoder) decodeValue(rv reflect.Value, fn *codecFn) {1792
decSetNonNilRV2Zero(rv)
1795
d.decodeValueNoCheckNil(rv, fn)
1798
func (d *Decoder) decodeValueNoCheckNil(rv reflect.Value, fn *codecFn) {1799
// If stream is not containing a nil value, then we can deref to the base
1800
// non-pointer value, and decode into that.
1801
var rvp reflect.Value
1804
if rv.Kind() == reflect.Ptr {1807
rvSetDirect(rv, reflect.New(rv.Type().Elem()))
1815
fn = d.h.fn(rv.Type())
1820
} else if rv.CanAddr() {1821
rv = rvAddr(rv, fn.i.ti.ptr)
1822
} else if fn.i.addrDf {1823
d.errorf("cannot decode into a non-pointer value")1829
func (d *Decoder) structFieldNotFound(index int, rvkencname string) {1830
// Note: rvkencname is used only if there is an error, to pass into d.errorf.
1831
// Consequently, it is ok to pass in a stringView
1832
// Since rvkencname may be a stringView, do NOT pass it to another function.
1833
if d.h.ErrorIfNoField {1835
d.errorf("no matching struct field found when decoding stream array at index %v", index)1836
} else if rvkencname != "" {1837
d.errorf("no matching struct field found when decoding stream map with key " + rvkencname)1843
func (d *Decoder) arrayCannotExpand(sliceLen, streamLen int) {1844
if d.h.ErrorIfNoArrayExpand {1845
d.errorf("cannot expand array len during decode from %v to %v", sliceLen, streamLen)1849
func (d *Decoder) haltAsNotDecodeable(rv reflect.Value) {1851
d.onerror(errCannotDecodeIntoNil)
1853
// check if an interface can be retrieved, before grabbing an interface
1854
if !rv.CanInterface() {1855
d.errorf("cannot decode into a value without an interface: %v", rv)1857
d.errorf("cannot decode into value of kind: %v, %#v", rv.Kind(), rv2i(rv))1860
func (d *Decoder) depthIncr() {1862
if d.depth >= d.maxdepth {1863
d.onerror(errMaxDepthExceeded)
1867
func (d *Decoder) depthDecr() {1871
// Possibly get an interned version of a string, iff InternString=true and decoding a map key.
1873
// This should mostly be used for map keys, where the key type is string.
1874
// This is because keys of a map/struct are typically reused across many objects.
1875
func (d *Decoder) string(v []byte) (s string) {1876
if d.is == nil || d.c != containerMapKey || len(v) < 2 || len(v) > internMaxStrLen {1879
return d.is.string(v)
1882
func (d *Decoder) zerocopy() bool {1883
return d.bytes && d.h.ZeroCopy
1886
// decodeBytesInto is a convenience delegate function to decDriver.DecodeBytes.
1887
// It ensures that `in` is not a nil byte, before calling decDriver.DecodeBytes,
1888
// as decDriver.DecodeBytes treats a nil as a hint to use its internal scratch buffer.
1889
func (d *Decoder) decodeBytesInto(in []byte) (v []byte) {1893
return d.d.DecodeBytes(in)
1896
func (d *Decoder) rawBytes() (v []byte) {1897
// ensure that this is not a view into the bytes
1898
// i.e. if necessary, make new copy always.
1899
v = d.d.nextValueBytes([]byte{})1900
if d.bytes && !d.h.ZeroCopy {1901
vv := make([]byte, len(v))
1902
copy(vv, v) // using copy here triggers make+copy optimization eliding memclr
1908
func (d *Decoder) wrapErr(v error, err *error) {1909
*err = wrapCodecErr(v, d.hh.Name(), d.NumBytesRead(), false)
1912
// NumBytesRead returns the number of bytes read
1913
func (d *Decoder) NumBytesRead() int {1914
return int(d.r().numread())
1917
// decodeFloat32 will delegate to an appropriate DecodeFloat32 implementation (if exists),
1918
// else if will call DecodeFloat64 and ensure the value doesn't overflow.
1920
// Note that we return float64 to reduce unnecessary conversions
1921
func (d *Decoder) decodeFloat32() float32 {1923
return d.jsondriver().DecodeFloat32() // custom implementation for 32-bit
1925
return float32(chkOvf.Float32V(d.d.DecodeFloat64()))
1928
// ---- container tracking
1929
// Note: We update the .c after calling the callback.
1930
// This way, the callback can know what the last status was.
1932
// MARKER: do not call mapEnd if mapStart returns containerLenNil.
1934
// MARKER: optimize decoding since all formats do not truly support all decDriver'ish operations.
1935
// - Read(Map|Array)Start is only supported by all formats.
1936
// - CheckBreak is only supported by json and cbor.
1937
// - Read(Map|Array)End is only supported by json.
1938
// - Read(Map|Array)Elem(Kay|Value) is only supported by json.
1939
// Honor these in the code, to reduce the number of interface calls (even if empty).
1941
func (d *Decoder) checkBreak() (v bool) {1942
// MARKER: jsonDecDriver.CheckBreak() cannot be inlined (over budget inlining cost).
1943
// Consequently, there's no benefit in incurring the cost of this wrapping function.
1944
// It is faster to just call the interface method directly.
1947
// return d.jsondriver().CheckBreak()
1950
// return d.cbordriver().CheckBreak()
1954
v = d.d.CheckBreak()
1959
func (d *Decoder) containerNext(j, containerLen int, hasLen bool) bool {1960
// MARKER: keep in sync with gen-helper.go.tmpl
1962
// return (hasLen && j < containerLen) || !(hasLen || slh.d.checkBreak())
1964
return j < containerLen
1966
return !d.checkBreak()
1969
func (d *Decoder) mapStart(v int) int {1970
if v != containerLenNil {1972
d.c = containerMapStart
1977
func (d *Decoder) mapElemKey() {1979
d.jsondriver().ReadMapElemKey()
1981
d.c = containerMapKey
1984
func (d *Decoder) mapElemValue() {1986
d.jsondriver().ReadMapElemValue()
1988
d.c = containerMapValue
1991
func (d *Decoder) mapEnd() {1993
d.jsondriver().ReadMapEnd()
2000
func (d *Decoder) arrayStart(v int) int {2001
if v != containerLenNil {2003
d.c = containerArrayStart
2008
func (d *Decoder) arrayElem() {2010
d.jsondriver().ReadArrayElem()
2012
d.c = containerArrayElem
2015
func (d *Decoder) arrayEnd() {2017
d.jsondriver().ReadArrayEnd()
2019
// d.d.ReadArrayEnd()
2024
func (d *Decoder) interfaceExtConvertAndDecode(v interface{}, ext InterfaceExt) {2025
// var v interface{} = ext.ConvertExt(rv)2027
// ext.UpdateExt(rv, v)
2029
// assume v is a pointer:
2030
// - if struct|array, pass as is to ConvertExt
2031
// - else make it non-addressable and pass to ConvertExt
2032
// - make return value from ConvertExt addressable
2034
// - return the interface for passing into UpdateExt.
2035
// - interface should be a pointer if struct|array, else a value
2038
rv := reflect.ValueOf(v)
2041
if rvk == reflect.Struct || rvk == reflect.Array {2042
s = ext.ConvertExt(v)
2044
s = ext.ConvertExt(rv2i(rv2))
2046
rv = reflect.ValueOf(s)
2048
// We cannot use isDecodeable here, as the value converted may be nil,
2049
// or it may not be nil but is not addressable and thus we cannot extend it, etc.
2050
// Instead, we just ensure that the value is addressable.
2054
rv2 = d.oneShotAddrRV(rv.Type(), rvk)
2055
if rvk == reflect.Interface {2058
rvSetDirect(rv2, rv)
2063
d.decodeValue(rv, nil)
2064
ext.UpdateExt(v, rv2i(rv))
2067
func (d *Decoder) sideDecode(v interface{}, basetype reflect.Type, bs []byte) {2068
// NewDecoderBytes(bs, d.hh).decodeValue(baseRV(v), d.h.fnNoExt(basetype))
2070
defer func(rb bytesDecReader, bytes bool,
2071
c containerState, dbs decByteState, depth int16, r decReader, state interface{}) {2075
d.decByteState = dbs
2078
d.d.restoreState(state)
2079
}(d.rb, d.bytes, d.c, d.decByteState, d.depth, d.decReader, d.d.captureState())
2082
d.rb = bytesDecReader{bs[:len(bs):len(bs)], 0}2087
d.decByteState = decByteStateNone
2090
// must call using fnNoExt
2091
d.decodeValue(baseRV(v), d.h.fnNoExt(basetype))
2094
func (d *Decoder) fauxUnionReadRawBytes(asString bool) {2095
if asString || d.h.RawToString {2096
d.n.v = valueTypeString
2097
// fauxUnion is only used within DecodeNaked calls; consequently, we should try to intern.
2098
d.n.s = d.stringZC(d.d.DecodeBytes(nil))
2100
d.n.v = valueTypeBytes
2101
d.n.l = d.d.DecodeBytes([]byte{})2105
func (d *Decoder) oneShotAddrRV(rvt reflect.Type, rvk reflect.Kind) reflect.Value {2106
if decUseTransient &&
2107
(numBoolStrSliceBitset.isset(byte(rvk)) ||
2108
((rvk == reflect.Struct || rvk == reflect.Array) &&
2109
d.h.getTypeInfo(rt2id(rvt), rvt).flagCanTransient)) {2110
return d.perType.TransientAddrK(rvt, rvk)
2112
return rvZeroAddrK(rvt, rvk)
2115
// --------------------------------------------------
2117
// decSliceHelper assists when decoding into a slice, from a map or an array in the stream.
2118
// A slice can be set from a map or array in stream. This supports the MapBySlice interface.
2120
// Note: if IsNil, do not call ElemContainerState.
2121
type decSliceHelper struct {2128
func (d *Decoder) decSliceHelperStart() (x decSliceHelper, clen int) {2129
x.ct = d.d.ContainerType()
2134
case valueTypeArray:
2136
clen = d.arrayStart(d.d.ReadArrayStart())
2138
clen = d.mapStart(d.d.ReadMapStart())
2141
d.errorf("only encoded map or array can be decoded into a slice (%d)", x.ct)2146
func (x decSliceHelper) End() {2155
func (x decSliceHelper) ElemContainerState(index int) {2156
// Note: if isnil, clen=0, so we never call into ElemContainerState
2160
} else if index&1 == 0 { // index%2 == 0 {2167
func (x decSliceHelper) arrayCannotExpand(hasLen bool, lenv, j, containerLenS int) {2168
x.d.arrayCannotExpand(lenv, j+1)
2169
// drain completely and return
2170
x.ElemContainerState(j)
2173
for ; x.d.containerNext(j, containerLenS, hasLen); j++ {2174
x.ElemContainerState(j)
2180
// decNextValueBytesHelper helps with NextValueBytes calls.
2183
// - each Handle's decDriver will implement a high level nextValueBytes,
2184
// which will track the current cursor, delegate to a nextValueBytesR
2185
// method, and then potentially call bytesRdV at the end.
2187
// See simple.go for typical usage model.
2188
type decNextValueBytesHelper struct {2192
func (x decNextValueBytesHelper) append1(v *[]byte, b byte) {2193
if *v != nil && !x.d.bytes {2198
func (x decNextValueBytesHelper) appendN(v *[]byte, b ...byte) {2199
if *v != nil && !x.d.bytes {2200
*v = append(*v, b...)
2204
func (x decNextValueBytesHelper) appendS(v *[]byte, b string) {2205
if *v != nil && !x.d.bytes {2206
*v = append(*v, b...)
2210
func (x decNextValueBytesHelper) bytesRdV(v *[]byte, startpos uint) {2212
*v = x.d.rb.b[startpos:x.d.rb.c]
2216
// decNegintPosintFloatNumberHelper is used for formats that are binary
2217
// and have distinct ways of storing positive integers vs negative integers
2218
// vs floats, which are uniquely identified by the byte descriptor.
2220
// Currently, these formats are binc, cbor and simple.
2221
type decNegintPosintFloatNumberHelper struct {2225
func (x decNegintPosintFloatNumberHelper) uint64(ui uint64, neg, ok bool) uint64 {2229
return x.uint64TryFloat(ok)
2232
func (x decNegintPosintFloatNumberHelper) uint64TryFloat(ok bool) (ui uint64) {2233
if ok { // neg = true2234
x.d.errorf("assigning negative signed value to unsigned type")2236
f, ok := x.d.d.decFloat()
2237
if ok && f >= 0 && noFrac64(math.Float64bits(f)) {2240
x.d.errorf("invalid number loading uint64, with descriptor: %v", x.d.d.descBd())2245
func decNegintPosintFloatNumberHelperInt64v(ui uint64, neg, incrIfNeg bool) (i int64) {2246
if neg && incrIfNeg {2249
i = chkOvf.SignedIntV(ui)
2256
func (x decNegintPosintFloatNumberHelper) int64(ui uint64, neg, ok bool) (i int64) {2258
return decNegintPosintFloatNumberHelperInt64v(ui, neg, x.d.cbor)
2260
// return x.int64TryFloat()
2262
// func (x decNegintPosintFloatNumberHelper) int64TryFloat() (i int64) {2263
f, ok := x.d.d.decFloat()
2264
if ok && noFrac64(math.Float64bits(f)) {2267
x.d.errorf("invalid number loading uint64, with descriptor: %v", x.d.d.descBd())2272
func (x decNegintPosintFloatNumberHelper) float64(f float64, ok bool) float64 {2276
return x.float64TryInteger()
2279
func (x decNegintPosintFloatNumberHelper) float64TryInteger() float64 {2280
ui, neg, ok := x.d.d.decInteger()
2282
x.d.errorf("invalid descriptor for float: %v", x.d.d.descBd())2284
return float64(decNegintPosintFloatNumberHelperInt64v(ui, neg, x.d.cbor))
2287
// isDecodeable checks if value can be decoded into
2289
// decode can take any reflect.Value that is a inherently addressable i.e.
2290
// - non-nil chan (we will SEND to it)
2291
// - non-nil slice (we will set its elements)
2292
// - non-nil map (we will put into it)
2293
// - non-nil pointer (we can "update" it)
2296
// - array: if canAddr=true
2297
// - any other value pointer: if canAddr=true
2298
func isDecodeable(rv reflect.Value) (canDecode bool, reason decNotDecodeableReason) {2300
case reflect.Ptr, reflect.Slice, reflect.Chan, reflect.Map:
2301
canDecode = !rvIsNil(rv)
2302
reason = decNotDecodeableReasonNilReference
2303
case reflect.Func, reflect.Interface, reflect.Invalid, reflect.UnsafePointer:
2304
reason = decNotDecodeableReasonBadKind
2306
canDecode = rv.CanAddr()
2307
reason = decNotDecodeableReasonNonAddrValue
2312
func decByteSlice(r *decRd, clen, maxInitLen int, bs []byte) (bsOut []byte) {2314
bsOut = zeroByteSlice
2315
} else if cap(bs) >= clen {2321
len3 := decInferLen(clen-len2, maxInitLen, 1)
2323
bsOut = make([]byte, len2+len3)
2325
r.readb(bsOut[len2:])
2332
// decInferLen will infer a sensible length, given the following:
2333
// - clen: length wanted.
2334
// - maxlen: max length to be returned.
2335
// if <= 0, it is unset, and we infer it based on the unit size
2336
// - unit: number of bytes for each element of the collection
2337
func decInferLen(clen, maxlen, unit int) int {2338
// anecdotal testing showed increase in allocation with map length of 16.
2339
// We saw same typical alloc from 0-8, then a 20% increase at 16.
2340
// Thus, we set it to 8.
2343
maxMem = 256 * 1024 // 256Kb Memory
2346
// handle when maxlen is not set i.e. <= 0
2349
// maxlen<=0, clen<0: use default
2350
// maxlen> 0, clen<0: use default
2351
// maxlen<=0, clen>0: infer maxlen, and cap on it
2352
// maxlen> 0, clen>0: cap at maxlen
2354
if clen == 0 || clen == containerLenNil {2358
// if unspecified, return 64 for bytes, ... 8 for uint64, ... and everything else
2360
if clen > minLenIfUnset {2363
return minLenIfUnset
2369
maxlen = maxMem / unit