1 // Copyright 2009 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
5 //go:generate go run decgen.go -output dec_helpers.go
19 errBadUint
= errors
.New("gob: encoded unsigned integer out of range")
20 errBadType
= errors
.New("gob: unknown type id or corrupted data")
21 errRange
= errors
.New("gob: bad data: field numbers out of bounds")
24 type decHelper
func(state
*decoderState
, v reflect
.Value
, length
int, ovfl error
) bool
26 // decoderState is the execution state of an instance of the decoder. A new state
27 // is created for nested objects.
28 type decoderState
struct {
30 // The buffer is stored with an extra indirection because it may be replaced
31 // if we load a type during decode (when reading an interface value).
33 fieldnum
int // the last field number read.
34 next
*decoderState
// for free list
37 // decBuffer is an extremely simple, fast implementation of a read-only byte buffer.
38 // It is initialized by calling Size and then copying the data into the slice returned by Bytes().
39 type decBuffer
struct {
41 offset
int // Read offset.
44 func (d
*decBuffer
) Read(p
[]byte) (int, error
) {
45 n
:= copy(p
, d
.data
[d
.offset
:])
46 if n
== 0 && len(p
) != 0 {
53 func (d
*decBuffer
) Drop(n
int) {
60 // Size grows the buffer to exactly n bytes, so d.Bytes() will
61 // return a slice of length n. Existing data is first discarded.
62 func (d
*decBuffer
) Size(n
int) {
65 d
.data
= make([]byte, n
)
71 func (d
*decBuffer
) ReadByte() (byte, error
) {
72 if d
.offset
>= len(d
.data
) {
80 func (d
*decBuffer
) Len() int {
81 return len(d
.data
) - d
.offset
84 func (d
*decBuffer
) Bytes() []byte {
85 return d
.data
[d
.offset
:]
88 func (d
*decBuffer
) Reset() {
93 // We pass the bytes.Buffer separately for easier testing of the infrastructure
94 // without requiring a full Decoder.
95 func (dec
*Decoder
) newDecoderState(buf
*decBuffer
) *decoderState
{
101 dec
.freeList
= d
.next
107 func (dec
*Decoder
) freeDecoderState(d
*decoderState
) {
108 d
.next
= dec
.freeList
112 func overflow(name
string) error
{
113 return errors
.New(`value for "` + name
+ `" out of range`)
116 // decodeUintReader reads an encoded unsigned integer from an io.Reader.
117 // Used only by the Decoder to read the message length.
118 func decodeUintReader(r io
.Reader
, buf
[]byte) (x
uint64, width
int, err error
) {
120 n
, err
:= io
.ReadFull(r
, buf
[0:width
])
126 return uint64(b
), width
, nil
133 width
, err
= io
.ReadFull(r
, buf
[0:n
])
136 err
= io
.ErrUnexpectedEOF
140 // Could check that the high byte is zero but it's not worth it.
141 for _
, b
:= range buf
[0:width
] {
144 width
++ // +1 for length byte
148 // decodeUint reads an encoded unsigned integer from state.r.
149 // Does not check for overflow.
150 func (state
*decoderState
) decodeUint() (x
uint64) {
151 b
, err
:= state
.b
.ReadByte()
162 buf
:= state
.b
.Bytes()
164 errorf("invalid uint data length %d: exceeds input size %d", n
, len(buf
))
166 // Don't need to check error; it's safe to loop regardless.
167 // Could check that the high byte is zero but it's not worth it.
168 for _
, b
:= range buf
[0:n
] {
175 // decodeInt reads an encoded signed integer from state.r.
176 // Does not check for overflow.
177 func (state
*decoderState
) decodeInt() int64 {
178 x
:= state
.decodeUint()
180 return ^int64(x
>> 1)
185 // getLength decodes the next uint and makes sure it is a possible
186 // size for a data item that follows, which means it must fit in a
187 // non-negative int and fit in the buffer.
188 func (state
*decoderState
) getLength() (int, bool) {
189 n
:= int(state
.decodeUint())
190 if n
< 0 || state
.b
.Len() < n || tooBig
<= n
{
196 // decOp is the signature of a decoding operator for a given type.
197 type decOp
func(i
*decInstr
, state
*decoderState
, v reflect
.Value
)
199 // The 'instructions' of the decoding machine
200 type decInstr
struct {
202 field
int // field number of the wire type
203 index
[]int // field access indices for destination type
204 ovfl error
// error message for overflow/underflow (for arrays, of the elements)
207 // ignoreUint discards a uint value with no destination.
208 func ignoreUint(i
*decInstr
, state
*decoderState
, v reflect
.Value
) {
212 // ignoreTwoUints discards a uint value with no destination. It's used to skip
214 func ignoreTwoUints(i
*decInstr
, state
*decoderState
, v reflect
.Value
) {
219 // Since the encoder writes no zeros, if we arrive at a decoder we have
220 // a value to extract and store. The field number has already been read
221 // (it's how we knew to call this decoder).
222 // Each decoder is responsible for handling any indirections associated
223 // with the data structure. If any pointer so reached is nil, allocation must
226 // decAlloc takes a value and returns a settable value that can
227 // be assigned to. If the value is a pointer, decAlloc guarantees it points to storage.
228 // The callers to the individual decoders are expected to have used decAlloc.
229 // The individual decoders don't need to it.
230 func decAlloc(v reflect
.Value
) reflect
.Value
{
231 for v
.Kind() == reflect
.Pointer
{
233 v
.Set(reflect
.New(v
.Type().Elem()))
240 // decBool decodes a uint and stores it as a boolean in value.
241 func decBool(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
242 value
.SetBool(state
.decodeUint() != 0)
245 // decInt8 decodes an integer and stores it as an int8 in value.
246 func decInt8(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
247 v
:= state
.decodeInt()
248 if v
< math
.MinInt8 || math
.MaxInt8
< v
{
254 // decUint8 decodes an unsigned integer and stores it as a uint8 in value.
255 func decUint8(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
256 v
:= state
.decodeUint()
257 if math
.MaxUint8
< v
{
263 // decInt16 decodes an integer and stores it as an int16 in value.
264 func decInt16(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
265 v
:= state
.decodeInt()
266 if v
< math
.MinInt16 || math
.MaxInt16
< v
{
272 // decUint16 decodes an unsigned integer and stores it as a uint16 in value.
273 func decUint16(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
274 v
:= state
.decodeUint()
275 if math
.MaxUint16
< v
{
281 // decInt32 decodes an integer and stores it as an int32 in value.
282 func decInt32(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
283 v
:= state
.decodeInt()
284 if v
< math
.MinInt32 || math
.MaxInt32
< v
{
290 // decUint32 decodes an unsigned integer and stores it as a uint32 in value.
291 func decUint32(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
292 v
:= state
.decodeUint()
293 if math
.MaxUint32
< v
{
299 // decInt64 decodes an integer and stores it as an int64 in value.
300 func decInt64(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
301 v
:= state
.decodeInt()
305 // decUint64 decodes an unsigned integer and stores it as a uint64 in value.
306 func decUint64(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
307 v
:= state
.decodeUint()
311 // Floating-point numbers are transmitted as uint64s holding the bits
312 // of the underlying representation. They are sent byte-reversed, with
313 // the exponent end coming out first, so integer floating point numbers
314 // (for example) transmit more compactly. This routine does the
316 func float64FromBits(u
uint64) float64 {
317 v
:= bits
.ReverseBytes64(u
)
318 return math
.Float64frombits(v
)
321 // float32FromBits decodes an unsigned integer, treats it as a 32-bit floating-point
322 // number, and returns it. It's a helper function for float32 and complex64.
323 // It returns a float64 because that's what reflection needs, but its return
324 // value is known to be accurately representable in a float32.
325 func float32FromBits(u
uint64, ovfl error
) float64 {
326 v
:= float64FromBits(u
)
331 // +Inf is OK in both 32- and 64-bit floats. Underflow is always OK.
332 if math
.MaxFloat32
< av
&& av
<= math
.MaxFloat64
{
338 // decFloat32 decodes an unsigned integer, treats it as a 32-bit floating-point
339 // number, and stores it in value.
340 func decFloat32(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
341 value
.SetFloat(float32FromBits(state
.decodeUint(), i
.ovfl
))
344 // decFloat64 decodes an unsigned integer, treats it as a 64-bit floating-point
345 // number, and stores it in value.
346 func decFloat64(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
347 value
.SetFloat(float64FromBits(state
.decodeUint()))
350 // decComplex64 decodes a pair of unsigned integers, treats them as a
351 // pair of floating point numbers, and stores them as a complex64 in value.
352 // The real part comes first.
353 func decComplex64(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
354 real
:= float32FromBits(state
.decodeUint(), i
.ovfl
)
355 imag
:= float32FromBits(state
.decodeUint(), i
.ovfl
)
356 value
.SetComplex(complex(real
, imag
))
359 // decComplex128 decodes a pair of unsigned integers, treats them as a
360 // pair of floating point numbers, and stores them as a complex128 in value.
361 // The real part comes first.
362 func decComplex128(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
363 real
:= float64FromBits(state
.decodeUint())
364 imag
:= float64FromBits(state
.decodeUint())
365 value
.SetComplex(complex(real
, imag
))
368 // decUint8Slice decodes a byte slice and stores in value a slice header
369 // describing the data.
370 // uint8 slices are encoded as an unsigned count followed by the raw bytes.
371 func decUint8Slice(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
372 n
, ok
:= state
.getLength()
374 errorf("bad %s slice length: %d", value
.Type(), n
)
377 value
.Set(reflect
.MakeSlice(value
.Type(), n
, n
))
381 if _
, err
:= state
.b
.Read(value
.Bytes()); err
!= nil {
382 errorf("error decoding []byte: %s", err
)
386 // decString decodes byte array and stores in value a string header
387 // describing the data.
388 // Strings are encoded as an unsigned count followed by the raw bytes.
389 func decString(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
390 n
, ok
:= state
.getLength()
392 errorf("bad %s slice length: %d", value
.Type(), n
)
395 data
:= state
.b
.Bytes()
397 errorf("invalid string length %d: exceeds input size %d", n
, len(data
))
399 s
:= string(data
[:n
])
404 // ignoreUint8Array skips over the data for a byte slice value with no destination.
405 func ignoreUint8Array(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
406 n
, ok
:= state
.getLength()
408 errorf("slice length too large")
412 errorf("invalid slice length %d: exceeds input size %d", n
, bn
)
419 // The encoder engine is an array of instructions indexed by field number of the incoming
420 // decoder. It is executed with random access according to field number.
421 type decEngine
struct {
423 numInstr
int // the number of active instructions
426 // decodeSingle decodes a top-level value that is not a struct and stores it in value.
427 // Such values are preceded by a zero, making them have the memory layout of a
428 // struct field (although with an illegal field number).
429 func (dec
*Decoder
) decodeSingle(engine
*decEngine
, value reflect
.Value
) {
430 state
:= dec
.newDecoderState(&dec
.buf
)
431 defer dec
.freeDecoderState(state
)
432 state
.fieldnum
= singletonField
433 if state
.decodeUint() != 0 {
434 errorf("decode: corrupted data: non-zero delta for singleton")
436 instr
:= &engine
.instr
[singletonField
]
437 instr
.op(instr
, state
, value
)
440 // decodeStruct decodes a top-level struct and stores it in value.
441 // Indir is for the value, not the type. At the time of the call it may
442 // differ from ut.indir, which was computed when the engine was built.
443 // This state cannot arise for decodeSingle, which is called directly
444 // from the user's value, not from the innards of an engine.
445 func (dec
*Decoder
) decodeStruct(engine
*decEngine
, value reflect
.Value
) {
446 state
:= dec
.newDecoderState(&dec
.buf
)
447 defer dec
.freeDecoderState(state
)
449 for state
.b
.Len() > 0 {
450 delta
:= int(state
.decodeUint())
452 errorf("decode: corrupted data: negative delta")
454 if delta
== 0 { // struct terminator is zero delta fieldnum
457 fieldnum
:= state
.fieldnum
+ delta
458 if fieldnum
>= len(engine
.instr
) {
462 instr
:= &engine
.instr
[fieldnum
]
463 var field reflect
.Value
464 if instr
.index
!= nil {
465 // Otherwise the field is unknown to us and instr.op is an ignore op.
466 field
= value
.FieldByIndex(instr
.index
)
467 if field
.Kind() == reflect
.Pointer
{
468 field
= decAlloc(field
)
471 instr
.op(instr
, state
, field
)
472 state
.fieldnum
= fieldnum
476 var noValue reflect
.Value
478 // ignoreStruct discards the data for a struct with no destination.
479 func (dec
*Decoder
) ignoreStruct(engine
*decEngine
) {
480 state
:= dec
.newDecoderState(&dec
.buf
)
481 defer dec
.freeDecoderState(state
)
483 for state
.b
.Len() > 0 {
484 delta
:= int(state
.decodeUint())
486 errorf("ignore decode: corrupted data: negative delta")
488 if delta
== 0 { // struct terminator is zero delta fieldnum
491 fieldnum
:= state
.fieldnum
+ delta
492 if fieldnum
>= len(engine
.instr
) {
495 instr
:= &engine
.instr
[fieldnum
]
496 instr
.op(instr
, state
, noValue
)
497 state
.fieldnum
= fieldnum
501 // ignoreSingle discards the data for a top-level non-struct value with no
502 // destination. It's used when calling Decode with a nil value.
503 func (dec
*Decoder
) ignoreSingle(engine
*decEngine
) {
504 state
:= dec
.newDecoderState(&dec
.buf
)
505 defer dec
.freeDecoderState(state
)
506 state
.fieldnum
= singletonField
507 delta
:= int(state
.decodeUint())
509 errorf("decode: corrupted data: non-zero delta for singleton")
511 instr
:= &engine
.instr
[singletonField
]
512 instr
.op(instr
, state
, noValue
)
515 // decodeArrayHelper does the work for decoding arrays and slices.
516 func (dec
*Decoder
) decodeArrayHelper(state
*decoderState
, value reflect
.Value
, elemOp decOp
, length
int, ovfl error
, helper decHelper
) {
517 if helper
!= nil && helper(state
, value
, length
, ovfl
) {
520 instr
:= &decInstr
{elemOp
, 0, nil, ovfl
}
521 isPtr
:= value
.Type().Elem().Kind() == reflect
.Pointer
522 for i
:= 0; i
< length
; i
++ {
523 if state
.b
.Len() == 0 {
524 errorf("decoding array or slice: length exceeds input size (%d elements)", length
)
530 elemOp(instr
, state
, v
)
534 // decodeArray decodes an array and stores it in value.
535 // The length is an unsigned integer preceding the elements. Even though the length is redundant
536 // (it's part of the type), it's a useful check and is included in the encoding.
537 func (dec
*Decoder
) decodeArray(state
*decoderState
, value reflect
.Value
, elemOp decOp
, length
int, ovfl error
, helper decHelper
) {
538 if n
:= state
.decodeUint(); n
!= uint64(length
) {
539 errorf("length mismatch in decodeArray")
541 dec
.decodeArrayHelper(state
, value
, elemOp
, length
, ovfl
, helper
)
544 // decodeIntoValue is a helper for map decoding.
545 func decodeIntoValue(state
*decoderState
, op decOp
, isPtr
bool, value reflect
.Value
, instr
*decInstr
) reflect
.Value
{
555 // decodeMap decodes a map and stores it in value.
556 // Maps are encoded as a length followed by key:value pairs.
557 // Because the internals of maps are not visible to us, we must
558 // use reflection rather than pointer magic.
559 func (dec
*Decoder
) decodeMap(mtyp reflect
.Type
, state
*decoderState
, value reflect
.Value
, keyOp
, elemOp decOp
, ovfl error
) {
560 n
:= int(state
.decodeUint())
562 value
.Set(reflect
.MakeMapWithSize(mtyp
, n
))
564 keyIsPtr
:= mtyp
.Key().Kind() == reflect
.Pointer
565 elemIsPtr
:= mtyp
.Elem().Kind() == reflect
.Pointer
566 keyInstr
:= &decInstr
{keyOp
, 0, nil, ovfl
}
567 elemInstr
:= &decInstr
{elemOp
, 0, nil, ovfl
}
568 keyP
:= reflect
.New(mtyp
.Key())
569 keyZ
:= reflect
.Zero(mtyp
.Key())
570 elemP
:= reflect
.New(mtyp
.Elem())
571 elemZ
:= reflect
.Zero(mtyp
.Elem())
572 for i
:= 0; i
< n
; i
++ {
573 key
:= decodeIntoValue(state
, keyOp
, keyIsPtr
, keyP
.Elem(), keyInstr
)
574 elem
:= decodeIntoValue(state
, elemOp
, elemIsPtr
, elemP
.Elem(), elemInstr
)
575 value
.SetMapIndex(key
, elem
)
576 keyP
.Elem().Set(keyZ
)
577 elemP
.Elem().Set(elemZ
)
581 // ignoreArrayHelper does the work for discarding arrays and slices.
582 func (dec
*Decoder
) ignoreArrayHelper(state
*decoderState
, elemOp decOp
, length
int) {
583 instr
:= &decInstr
{elemOp
, 0, nil, errors
.New("no error")}
584 for i
:= 0; i
< length
; i
++ {
585 if state
.b
.Len() == 0 {
586 errorf("decoding array or slice: length exceeds input size (%d elements)", length
)
588 elemOp(instr
, state
, noValue
)
592 // ignoreArray discards the data for an array value with no destination.
593 func (dec
*Decoder
) ignoreArray(state
*decoderState
, elemOp decOp
, length
int) {
594 if n
:= state
.decodeUint(); n
!= uint64(length
) {
595 errorf("length mismatch in ignoreArray")
597 dec
.ignoreArrayHelper(state
, elemOp
, length
)
600 // ignoreMap discards the data for a map value with no destination.
601 func (dec
*Decoder
) ignoreMap(state
*decoderState
, keyOp
, elemOp decOp
) {
602 n
:= int(state
.decodeUint())
603 keyInstr
:= &decInstr
{keyOp
, 0, nil, errors
.New("no error")}
604 elemInstr
:= &decInstr
{elemOp
, 0, nil, errors
.New("no error")}
605 for i
:= 0; i
< n
; i
++ {
606 keyOp(keyInstr
, state
, noValue
)
607 elemOp(elemInstr
, state
, noValue
)
611 // decodeSlice decodes a slice and stores it in value.
612 // Slices are encoded as an unsigned length followed by the elements.
613 func (dec
*Decoder
) decodeSlice(state
*decoderState
, value reflect
.Value
, elemOp decOp
, ovfl error
, helper decHelper
) {
614 u
:= state
.decodeUint()
616 size
:= uint64(typ
.Elem().Size())
619 // Take care with overflow in this calculation.
620 if n
< 0 ||
uint64(n
) != u || nBytes
> tooBig ||
(size
> 0 && nBytes
/size
!= u
) {
621 // We don't check n against buffer length here because if it's a slice
622 // of interfaces, there will be buffer reloads.
623 errorf("%s slice too big: %d elements of %d bytes", typ
.Elem(), u
, size
)
626 value
.Set(reflect
.MakeSlice(typ
, n
, n
))
630 dec
.decodeArrayHelper(state
, value
, elemOp
, n
, ovfl
, helper
)
633 // ignoreSlice skips over the data for a slice value with no destination.
634 func (dec
*Decoder
) ignoreSlice(state
*decoderState
, elemOp decOp
) {
635 dec
.ignoreArrayHelper(state
, elemOp
, int(state
.decodeUint()))
638 // decodeInterface decodes an interface value and stores it in value.
639 // Interfaces are encoded as the name of a concrete type followed by a value.
640 // If the name is empty, the value is nil and no value is sent.
641 func (dec
*Decoder
) decodeInterface(ityp reflect
.Type
, state
*decoderState
, value reflect
.Value
) {
642 // Read the name of the concrete type.
643 nr
:= state
.decodeUint()
644 if nr
> 1<<31 { // zero is permissible for anonymous types
645 errorf("invalid type name length %d", nr
)
647 if nr
> uint64(state
.b
.Len()) {
648 errorf("invalid type name length %d: exceeds input size", nr
)
651 name
:= state
.b
.Bytes()[:n
]
653 // Allocate the destination interface value.
655 // Copy the nil interface value to the target.
656 value
.Set(reflect
.Zero(value
.Type()))
659 if len(name
) > 1024 {
660 errorf("name too long (%d bytes): %.20q...", len(name
), name
)
662 // The concrete type must be registered.
663 typi
, ok
:= nameToConcreteType
.Load(string(name
))
665 errorf("name not registered for interface: %q", name
)
667 typ
:= typi
.(reflect
.Type
)
669 // Read the type id of the concrete value.
670 concreteId
:= dec
.decodeTypeSequence(true)
674 // Byte count of value is next; we don't care what it is (it's there
675 // in case we want to ignore the value by skipping it completely).
677 // Read the concrete value.
679 dec
.decodeValue(concreteId
, v
)
683 // Assign the concrete value to the interface.
684 // Tread carefully; it might not satisfy the interface.
685 if !typ
.AssignableTo(ityp
) {
686 errorf("%s is not assignable to type %s", typ
, ityp
)
688 // Copy the interface value to the target.
692 // ignoreInterface discards the data for an interface value with no destination.
693 func (dec
*Decoder
) ignoreInterface(state
*decoderState
) {
694 // Read the name of the concrete type.
695 n
, ok
:= state
.getLength()
697 errorf("bad interface encoding: name too large for buffer")
701 errorf("invalid interface value length %d: exceeds input size %d", n
, bn
)
704 id
:= dec
.decodeTypeSequence(true)
708 // At this point, the decoder buffer contains a delimited value. Just toss it.
709 n
, ok
= state
.getLength()
711 errorf("bad interface encoding: data length too large for buffer")
716 // decodeGobDecoder decodes something implementing the GobDecoder interface.
717 // The data is encoded as a byte slice.
718 func (dec
*Decoder
) decodeGobDecoder(ut
*userTypeInfo
, state
*decoderState
, value reflect
.Value
) {
719 // Read the bytes for the value.
720 n
, ok
:= state
.getLength()
722 errorf("GobDecoder: length too large for buffer")
726 errorf("GobDecoder: invalid data length %d: exceeds input size %d", n
, len(b
))
731 // We know it's one of these.
732 switch ut
.externalDec
{
734 err
= value
.Interface().(GobDecoder
).GobDecode(b
)
736 err
= value
.Interface().(encoding
.BinaryUnmarshaler
).UnmarshalBinary(b
)
738 err
= value
.Interface().(encoding
.TextUnmarshaler
).UnmarshalText(b
)
745 // ignoreGobDecoder discards the data for a GobDecoder value with no destination.
746 func (dec
*Decoder
) ignoreGobDecoder(state
*decoderState
) {
747 // Read the bytes for the value.
748 n
, ok
:= state
.getLength()
750 errorf("GobDecoder: length too large for buffer")
754 errorf("GobDecoder: invalid data length %d: exceeds input size %d", n
, bn
)
759 // Index by Go types.
760 var decOpTable
= [...]decOp
{
761 reflect
.Bool
: decBool
,
762 reflect
.Int8
: decInt8
,
763 reflect
.Int16
: decInt16
,
764 reflect
.Int32
: decInt32
,
765 reflect
.Int64
: decInt64
,
766 reflect
.Uint8
: decUint8
,
767 reflect
.Uint16
: decUint16
,
768 reflect
.Uint32
: decUint32
,
769 reflect
.Uint64
: decUint64
,
770 reflect
.Float32
: decFloat32
,
771 reflect
.Float64
: decFloat64
,
772 reflect
.Complex64
: decComplex64
,
773 reflect
.Complex128
: decComplex128
,
774 reflect
.String
: decString
,
777 // Indexed by gob types. tComplex will be added during type.init().
778 var decIgnoreOpMap
= map[typeId
]decOp
{
783 tBytes
: ignoreUint8Array
,
784 tString
: ignoreUint8Array
,
785 tComplex
: ignoreTwoUints
,
788 // decOpFor returns the decoding op for the base type under rt and
789 // the indirection count to reach it.
790 func (dec
*Decoder
) decOpFor(wireId typeId
, rt reflect
.Type
, name
string, inProgress
map[reflect
.Type
]*decOp
) *decOp
{
792 // If the type implements GobEncoder, we handle it without further processing.
793 if ut
.externalDec
!= 0 {
794 return dec
.gobDecodeOpFor(ut
)
797 // If this type is already in progress, it's a recursive type (e.g. map[string]*T).
798 // Return the pointer to the op we're already building.
799 if opPtr
:= inProgress
[rt
]; opPtr
!= nil {
805 if int(k
) < len(decOpTable
) {
811 switch t
:= typ
; t
.Kind() {
813 name
= "element of " + name
814 elemId
:= dec
.wireType
[wireId
].ArrayT
.Elem
815 elemOp
:= dec
.decOpFor(elemId
, t
.Elem(), name
, inProgress
)
816 ovfl
:= overflow(name
)
817 helper
:= decArrayHelper
[t
.Elem().Kind()]
818 op
= func(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
819 state
.dec
.decodeArray(state
, value
, *elemOp
, t
.Len(), ovfl
, helper
)
823 keyId
:= dec
.wireType
[wireId
].MapT
.Key
824 elemId
:= dec
.wireType
[wireId
].MapT
.Elem
825 keyOp
:= dec
.decOpFor(keyId
, t
.Key(), "key of "+name
, inProgress
)
826 elemOp
:= dec
.decOpFor(elemId
, t
.Elem(), "element of "+name
, inProgress
)
827 ovfl
:= overflow(name
)
828 op
= func(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
829 state
.dec
.decodeMap(t
, state
, value
, *keyOp
, *elemOp
, ovfl
)
833 name
= "element of " + name
834 if t
.Elem().Kind() == reflect
.Uint8
{
839 if tt
, ok
:= builtinIdToType
[wireId
]; ok
{
840 elemId
= tt
.(*sliceType
).Elem
842 elemId
= dec
.wireType
[wireId
].SliceT
.Elem
844 elemOp
:= dec
.decOpFor(elemId
, t
.Elem(), name
, inProgress
)
845 ovfl
:= overflow(name
)
846 helper
:= decSliceHelper
[t
.Elem().Kind()]
847 op
= func(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
848 state
.dec
.decodeSlice(state
, value
, *elemOp
, ovfl
, helper
)
852 // Generate a closure that calls out to the engine for the nested type.
854 enginePtr
, err
:= dec
.getDecEnginePtr(wireId
, ut
)
858 op
= func(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
859 // indirect through enginePtr to delay evaluation for recursive structs.
860 dec
.decodeStruct(*enginePtr
, value
)
862 case reflect
.Interface
:
863 op
= func(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
864 state
.dec
.decodeInterface(t
, state
, value
)
869 errorf("decode can't handle type %s", rt
)
874 // decIgnoreOpFor returns the decoding op for a field that has no destination.
875 func (dec
*Decoder
) decIgnoreOpFor(wireId typeId
, inProgress
map[typeId
]*decOp
) *decOp
{
876 // If this type is already in progress, it's a recursive type (e.g. map[string]*T).
877 // Return the pointer to the op we're already building.
878 if opPtr
:= inProgress
[wireId
]; opPtr
!= nil {
881 op
, ok
:= decIgnoreOpMap
[wireId
]
883 inProgress
[wireId
] = &op
884 if wireId
== tInterface
{
885 // Special case because it's a method: the ignored item might
886 // define types and we need to record their state in the decoder.
887 op
= func(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
888 state
.dec
.ignoreInterface(state
)
893 wire
:= dec
.wireType
[wireId
]
896 errorf("bad data: undefined type %s", wireId
.string())
897 case wire
.ArrayT
!= nil:
898 elemId
:= wire
.ArrayT
.Elem
899 elemOp
:= dec
.decIgnoreOpFor(elemId
, inProgress
)
900 op
= func(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
901 state
.dec
.ignoreArray(state
, *elemOp
, wire
.ArrayT
.Len
)
904 case wire
.MapT
!= nil:
905 keyId
:= dec
.wireType
[wireId
].MapT
.Key
906 elemId
:= dec
.wireType
[wireId
].MapT
.Elem
907 keyOp
:= dec
.decIgnoreOpFor(keyId
, inProgress
)
908 elemOp
:= dec
.decIgnoreOpFor(elemId
, inProgress
)
909 op
= func(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
910 state
.dec
.ignoreMap(state
, *keyOp
, *elemOp
)
913 case wire
.SliceT
!= nil:
914 elemId
:= wire
.SliceT
.Elem
915 elemOp
:= dec
.decIgnoreOpFor(elemId
, inProgress
)
916 op
= func(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
917 state
.dec
.ignoreSlice(state
, *elemOp
)
920 case wire
.StructT
!= nil:
921 // Generate a closure that calls out to the engine for the nested type.
922 enginePtr
, err
:= dec
.getIgnoreEnginePtr(wireId
)
926 op
= func(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
927 // indirect through enginePtr to delay evaluation for recursive structs
928 state
.dec
.ignoreStruct(*enginePtr
)
931 case wire
.GobEncoderT
!= nil, wire
.BinaryMarshalerT
!= nil, wire
.TextMarshalerT
!= nil:
932 op
= func(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
933 state
.dec
.ignoreGobDecoder(state
)
938 errorf("bad data: ignore can't handle type %s", wireId
.string())
943 // gobDecodeOpFor returns the op for a type that is known to implement
945 func (dec
*Decoder
) gobDecodeOpFor(ut
*userTypeInfo
) *decOp
{
947 if ut
.decIndir
== -1 {
948 rcvrType
= reflect
.PointerTo(rcvrType
)
949 } else if ut
.decIndir
> 0 {
950 for i
:= int8(0); i
< ut
.decIndir
; i
++ {
951 rcvrType
= rcvrType
.Elem()
955 op
= func(i
*decInstr
, state
*decoderState
, value reflect
.Value
) {
956 // We now have the base type. We need its address if the receiver is a pointer.
957 if value
.Kind() != reflect
.Pointer
&& rcvrType
.Kind() == reflect
.Pointer
{
960 state
.dec
.decodeGobDecoder(ut
, state
, value
)
965 // compatibleType asks: Are these two gob Types compatible?
966 // Answers the question for basic types, arrays, maps and slices, plus
967 // GobEncoder/Decoder pairs.
968 // Structs are considered ok; fields will be checked later.
969 func (dec
*Decoder
) compatibleType(fr reflect
.Type
, fw typeId
, inProgress
map[reflect
.Type
]typeId
) bool {
970 if rhs
, ok
:= inProgress
[fr
]; ok
{
975 wire
, ok
:= dec
.wireType
[fw
]
976 // If wire was encoded with an encoding method, fr must have that method.
977 // And if not, it must not.
978 // At most one of the booleans in ut is set.
979 // We could possibly relax this constraint in the future in order to
980 // choose the decoding method using the data in the wireType.
981 // The parentheses look odd but are correct.
982 if (ut
.externalDec
== xGob
) != (ok
&& wire
.GobEncoderT
!= nil) ||
983 (ut
.externalDec
== xBinary
) != (ok
&& wire
.BinaryMarshalerT
!= nil) ||
984 (ut
.externalDec
== xText
) != (ok
&& wire
.TextMarshalerT
!= nil) {
987 if ut
.externalDec
!= 0 { // This test trumps all others.
990 switch t
:= ut
.base
; t
.Kind() {
992 // chan, etc: cannot handle.
996 case reflect
.Int
, reflect
.Int8
, reflect
.Int16
, reflect
.Int32
, reflect
.Int64
:
998 case reflect
.Uint
, reflect
.Uint8
, reflect
.Uint16
, reflect
.Uint32
, reflect
.Uint64
, reflect
.Uintptr
:
1000 case reflect
.Float32
, reflect
.Float64
:
1002 case reflect
.Complex64
, reflect
.Complex128
:
1003 return fw
== tComplex
1004 case reflect
.String
:
1005 return fw
== tString
1006 case reflect
.Interface
:
1007 return fw
== tInterface
1009 if !ok || wire
.ArrayT
== nil {
1012 array
:= wire
.ArrayT
1013 return t
.Len() == array
.Len
&& dec
.compatibleType(t
.Elem(), array
.Elem
, inProgress
)
1015 if !ok || wire
.MapT
== nil {
1018 MapType
:= wire
.MapT
1019 return dec
.compatibleType(t
.Key(), MapType
.Key
, inProgress
) && dec
.compatibleType(t
.Elem(), MapType
.Elem
, inProgress
)
1021 // Is it an array of bytes?
1022 if t
.Elem().Kind() == reflect
.Uint8
{
1025 // Extract and compare element types.
1027 if tt
, ok
:= builtinIdToType
[fw
]; ok
{
1028 sw
, _
= tt
.(*sliceType
)
1029 } else if wire
!= nil {
1032 elem
:= userType(t
.Elem()).base
1033 return sw
!= nil && dec
.compatibleType(elem
, sw
.Elem
, inProgress
)
1034 case reflect
.Struct
:
1039 // typeString returns a human-readable description of the type identified by remoteId.
1040 func (dec
*Decoder
) typeString(remoteId typeId
) string {
1042 defer typeLock
.Unlock()
1043 if t
:= idToType
[remoteId
]; t
!= nil {
1044 // globally known type.
1047 return dec
.wireType
[remoteId
].string()
1050 // compileSingle compiles the decoder engine for a non-struct top-level value, including
1052 func (dec
*Decoder
) compileSingle(remoteId typeId
, ut
*userTypeInfo
) (engine
*decEngine
, err error
) {
1054 engine
= new(decEngine
)
1055 engine
.instr
= make([]decInstr
, 1) // one item
1056 name
:= rt
.String() // best we can do
1057 if !dec
.compatibleType(rt
, remoteId
, make(map[reflect
.Type
]typeId
)) {
1058 remoteType
:= dec
.typeString(remoteId
)
1059 // Common confusing case: local interface type, remote concrete type.
1060 if ut
.base
.Kind() == reflect
.Interface
&& remoteId
!= tInterface
{
1061 return nil, errors
.New("gob: local interface type " + name
+ " can only be decoded from remote interface type; received concrete type " + remoteType
)
1063 return nil, errors
.New("gob: decoding into local type " + name
+ ", received remote type " + remoteType
)
1065 op
:= dec
.decOpFor(remoteId
, rt
, name
, make(map[reflect
.Type
]*decOp
))
1066 ovfl
:= errors
.New(`value for "` + name
+ `" out of range`)
1067 engine
.instr
[singletonField
] = decInstr
{*op
, singletonField
, nil, ovfl
}
1072 // compileIgnoreSingle compiles the decoder engine for a non-struct top-level value that will be discarded.
1073 func (dec
*Decoder
) compileIgnoreSingle(remoteId typeId
) *decEngine
{
1074 engine
:= new(decEngine
)
1075 engine
.instr
= make([]decInstr
, 1) // one item
1076 op
:= dec
.decIgnoreOpFor(remoteId
, make(map[typeId
]*decOp
))
1077 ovfl
:= overflow(dec
.typeString(remoteId
))
1078 engine
.instr
[0] = decInstr
{*op
, 0, nil, ovfl
}
1083 // compileDec compiles the decoder engine for a value. If the value is not a struct,
1084 // it calls out to compileSingle.
1085 func (dec
*Decoder
) compileDec(remoteId typeId
, ut
*userTypeInfo
) (engine
*decEngine
, err error
) {
1086 defer catchError(&err
)
1089 if srt
.Kind() != reflect
.Struct || ut
.externalDec
!= 0 {
1090 return dec
.compileSingle(remoteId
, ut
)
1092 var wireStruct
*structType
1093 // Builtin types can come from global pool; the rest must be defined by the decoder.
1094 // Also we know we're decoding a struct now, so the client must have sent one.
1095 if t
, ok
:= builtinIdToType
[remoteId
]; ok
{
1096 wireStruct
, _
= t
.(*structType
)
1098 wire
:= dec
.wireType
[remoteId
]
1102 wireStruct
= wire
.StructT
1104 if wireStruct
== nil {
1105 errorf("type mismatch in decoder: want struct type %s; got non-struct", rt
)
1107 engine
= new(decEngine
)
1108 engine
.instr
= make([]decInstr
, len(wireStruct
.Field
))
1109 seen
:= make(map[reflect
.Type
]*decOp
)
1110 // Loop over the fields of the wire type.
1111 for fieldnum
:= 0; fieldnum
< len(wireStruct
.Field
); fieldnum
++ {
1112 wireField
:= wireStruct
.Field
[fieldnum
]
1113 if wireField
.Name
== "" {
1114 errorf("empty name for remote field of type %s", wireStruct
.Name
)
1116 ovfl
:= overflow(wireField
.Name
)
1117 // Find the field of the local type with the same name.
1118 localField
, present
:= srt
.FieldByName(wireField
.Name
)
1119 // TODO(r): anonymous names
1120 if !present ||
!isExported(wireField
.Name
) {
1121 op
:= dec
.decIgnoreOpFor(wireField
.Id
, make(map[typeId
]*decOp
))
1122 engine
.instr
[fieldnum
] = decInstr
{*op
, fieldnum
, nil, ovfl
}
1125 if !dec
.compatibleType(localField
.Type
, wireField
.Id
, make(map[reflect
.Type
]typeId
)) {
1126 errorf("wrong type (%s) for received field %s.%s", localField
.Type
, wireStruct
.Name
, wireField
.Name
)
1128 op
:= dec
.decOpFor(wireField
.Id
, localField
.Type
, localField
.Name
, seen
)
1129 engine
.instr
[fieldnum
] = decInstr
{*op
, fieldnum
, localField
.Index
, ovfl
}
1135 // getDecEnginePtr returns the engine for the specified type.
1136 func (dec
*Decoder
) getDecEnginePtr(remoteId typeId
, ut
*userTypeInfo
) (enginePtr
**decEngine
, err error
) {
1138 decoderMap
, ok
:= dec
.decoderCache
[rt
]
1140 decoderMap
= make(map[typeId
]**decEngine
)
1141 dec
.decoderCache
[rt
] = decoderMap
1143 if enginePtr
, ok
= decoderMap
[remoteId
]; !ok
{
1144 // To handle recursive types, mark this engine as underway before compiling.
1145 enginePtr
= new(*decEngine
)
1146 decoderMap
[remoteId
] = enginePtr
1147 *enginePtr
, err
= dec
.compileDec(remoteId
, ut
)
1149 delete(decoderMap
, remoteId
)
1155 // emptyStruct is the type we compile into when ignoring a struct value.
1156 type emptyStruct
struct{}
1158 var emptyStructType
= reflect
.TypeOf(emptyStruct
{})
1160 // getIgnoreEnginePtr returns the engine for the specified type when the value is to be discarded.
1161 func (dec
*Decoder
) getIgnoreEnginePtr(wireId typeId
) (enginePtr
**decEngine
, err error
) {
1163 if enginePtr
, ok
= dec
.ignorerCache
[wireId
]; !ok
{
1164 // To handle recursive types, mark this engine as underway before compiling.
1165 enginePtr
= new(*decEngine
)
1166 dec
.ignorerCache
[wireId
] = enginePtr
1167 wire
:= dec
.wireType
[wireId
]
1168 if wire
!= nil && wire
.StructT
!= nil {
1169 *enginePtr
, err
= dec
.compileDec(wireId
, userType(emptyStructType
))
1171 *enginePtr
= dec
.compileIgnoreSingle(wireId
)
1174 delete(dec
.ignorerCache
, wireId
)
1180 // decodeValue decodes the data stream representing a value and stores it in value.
1181 func (dec
*Decoder
) decodeValue(wireId typeId
, value reflect
.Value
) {
1182 defer catchError(&dec
.err
)
1183 // If the value is nil, it means we should just ignore this item.
1184 if !value
.IsValid() {
1185 dec
.decodeIgnoredValue(wireId
)
1188 // Dereference down to the underlying type.
1189 ut
:= userType(value
.Type())
1191 var enginePtr
**decEngine
1192 enginePtr
, dec
.err
= dec
.getDecEnginePtr(wireId
, ut
)
1196 value
= decAlloc(value
)
1197 engine
:= *enginePtr
1198 if st
:= base
; st
.Kind() == reflect
.Struct
&& ut
.externalDec
== 0 {
1199 wt
:= dec
.wireType
[wireId
]
1200 if engine
.numInstr
== 0 && st
.NumField() > 0 &&
1201 wt
!= nil && len(wt
.StructT
.Field
) > 0 {
1203 errorf("type mismatch: no fields matched compiling decoder for %s", name
)
1205 dec
.decodeStruct(engine
, value
)
1207 dec
.decodeSingle(engine
, value
)
1211 // decodeIgnoredValue decodes the data stream representing a value of the specified type and discards it.
1212 func (dec
*Decoder
) decodeIgnoredValue(wireId typeId
) {
1213 var enginePtr
**decEngine
1214 enginePtr
, dec
.err
= dec
.getIgnoreEnginePtr(wireId
)
1218 wire
:= dec
.wireType
[wireId
]
1219 if wire
!= nil && wire
.StructT
!= nil {
1220 dec
.ignoreStruct(*enginePtr
)
1222 dec
.ignoreSingle(*enginePtr
)
1228 switch reflect
.TypeOf(int(0)).Bits() {
1236 panic("gob: unknown size of int/uint")
1238 decOpTable
[reflect
.Int
] = iop
1239 decOpTable
[reflect
.Uint
] = uop
1242 switch reflect
.TypeOf(uintptr(0)).Bits() {
1248 panic("gob: unknown size of uintptr")
1250 decOpTable
[reflect
.Uintptr
] = uop
1253 // Gob depends on being able to take the address
1254 // of zeroed Values it creates, so use this wrapper instead
1255 // of the standard reflect.Zero.
1256 // Each call allocates once.
1257 func allocValue(t reflect
.Type
) reflect
.Value
{
1258 return reflect
.New(t
).Elem()