Source file src/encoding/gob/decode.go

     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.
     4	
     5	//go:generate go run decgen.go -output dec_helpers.go
     6	
     7	package gob
     8	
     9	import (
    10		"encoding"
    11		"errors"
    12		"io"
    13		"math"
    14		"math/bits"
    15		"reflect"
    16	)
    17	
    18	var (
    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")
    22	)
    23	
    24	type decHelper func(state *decoderState, v reflect.Value, length int, ovfl error) bool
    25	
    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 {
    29		dec *Decoder
    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).
    32		b        *decBuffer
    33		fieldnum int           // the last field number read.
    34		next     *decoderState // for free list
    35	}
    36	
    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 {
    40		data   []byte
    41		offset int // Read offset.
    42	}
    43	
    44	func (d *decBuffer) Read(p []byte) (int, error) {
    45		n := copy(p, d.data[d.offset:])
    46		if n == 0 && len(p) != 0 {
    47			return 0, io.EOF
    48		}
    49		d.offset += n
    50		return n, nil
    51	}
    52	
    53	func (d *decBuffer) Drop(n int) {
    54		if n > d.Len() {
    55			panic("drop")
    56		}
    57		d.offset += n
    58	}
    59	
    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) {
    63		d.Reset()
    64		if cap(d.data) < n {
    65			d.data = make([]byte, n)
    66		} else {
    67			d.data = d.data[0:n]
    68		}
    69	}
    70	
    71	func (d *decBuffer) ReadByte() (byte, error) {
    72		if d.offset >= len(d.data) {
    73			return 0, io.EOF
    74		}
    75		c := d.data[d.offset]
    76		d.offset++
    77		return c, nil
    78	}
    79	
    80	func (d *decBuffer) Len() int {
    81		return len(d.data) - d.offset
    82	}
    83	
    84	func (d *decBuffer) Bytes() []byte {
    85		return d.data[d.offset:]
    86	}
    87	
    88	func (d *decBuffer) Reset() {
    89		d.data = d.data[0:0]
    90		d.offset = 0
    91	}
    92	
    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 {
    96		d := dec.freeList
    97		if d == nil {
    98			d = new(decoderState)
    99			d.dec = dec
   100		} else {
   101			dec.freeList = d.next
   102		}
   103		d.b = buf
   104		return d
   105	}
   106	
   107	func (dec *Decoder) freeDecoderState(d *decoderState) {
   108		d.next = dec.freeList
   109		dec.freeList = d
   110	}
   111	
   112	func overflow(name string) error {
   113		return errors.New(`value for "` + name + `" out of range`)
   114	}
   115	
   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) {
   119		width = 1
   120		n, err := io.ReadFull(r, buf[0:width])
   121		if n == 0 {
   122			return
   123		}
   124		b := buf[0]
   125		if b <= 0x7f {
   126			return uint64(b), width, nil
   127		}
   128		n = -int(int8(b))
   129		if n > uint64Size {
   130			err = errBadUint
   131			return
   132		}
   133		width, err = io.ReadFull(r, buf[0:n])
   134		if err != nil {
   135			if err == io.EOF {
   136				err = io.ErrUnexpectedEOF
   137			}
   138			return
   139		}
   140		// Could check that the high byte is zero but it's not worth it.
   141		for _, b := range buf[0:width] {
   142			x = x<<8 | uint64(b)
   143		}
   144		width++ // +1 for length byte
   145		return
   146	}
   147	
   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()
   152		if err != nil {
   153			error_(err)
   154		}
   155		if b <= 0x7f {
   156			return uint64(b)
   157		}
   158		n := -int(int8(b))
   159		if n > uint64Size {
   160			error_(errBadUint)
   161		}
   162		buf := state.b.Bytes()
   163		if len(buf) < n {
   164			errorf("invalid uint data length %d: exceeds input size %d", n, len(buf))
   165		}
   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] {
   169			x = x<<8 | uint64(b)
   170		}
   171		state.b.Drop(n)
   172		return x
   173	}
   174	
   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()
   179		if x&1 != 0 {
   180			return ^int64(x >> 1)
   181		}
   182		return int64(x >> 1)
   183	}
   184	
   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 {
   191			return 0, false
   192		}
   193		return n, true
   194	}
   195	
   196	// decOp is the signature of a decoding operator for a given type.
   197	type decOp func(i *decInstr, state *decoderState, v reflect.Value)
   198	
   199	// The 'instructions' of the decoding machine
   200	type decInstr struct {
   201		op    decOp
   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)
   205	}
   206	
   207	// ignoreUint discards a uint value with no destination.
   208	func ignoreUint(i *decInstr, state *decoderState, v reflect.Value) {
   209		state.decodeUint()
   210	}
   211	
   212	// ignoreTwoUints discards a uint value with no destination. It's used to skip
   213	// complex values.
   214	func ignoreTwoUints(i *decInstr, state *decoderState, v reflect.Value) {
   215		state.decodeUint()
   216		state.decodeUint()
   217	}
   218	
   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
   224	// be done.
   225	
   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.Ptr {
   232			if v.IsNil() {
   233				v.Set(reflect.New(v.Type().Elem()))
   234			}
   235			v = v.Elem()
   236		}
   237		return v
   238	}
   239	
   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)
   243	}
   244	
   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 {
   249			error_(i.ovfl)
   250		}
   251		value.SetInt(v)
   252	}
   253	
   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 {
   258			error_(i.ovfl)
   259		}
   260		value.SetUint(v)
   261	}
   262	
   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 {
   267			error_(i.ovfl)
   268		}
   269		value.SetInt(v)
   270	}
   271	
   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 {
   276			error_(i.ovfl)
   277		}
   278		value.SetUint(v)
   279	}
   280	
   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 {
   285			error_(i.ovfl)
   286		}
   287		value.SetInt(v)
   288	}
   289	
   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 {
   294			error_(i.ovfl)
   295		}
   296		value.SetUint(v)
   297	}
   298	
   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()
   302		value.SetInt(v)
   303	}
   304	
   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()
   308		value.SetUint(v)
   309	}
   310	
   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
   315	// unswizzling.
   316	func float64FromBits(u uint64) float64 {
   317		v := bits.ReverseBytes64(u)
   318		return math.Float64frombits(v)
   319	}
   320	
   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)
   327		av := v
   328		if av < 0 {
   329			av = -av
   330		}
   331		// +Inf is OK in both 32- and 64-bit floats. Underflow is always OK.
   332		if math.MaxFloat32 < av && av <= math.MaxFloat64 {
   333			error_(ovfl)
   334		}
   335		return v
   336	}
   337	
   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))
   342	}
   343	
   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()))
   348	}
   349	
   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))
   357	}
   358	
   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))
   366	}
   367	
   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()
   373		if !ok {
   374			errorf("bad %s slice length: %d", value.Type(), n)
   375		}
   376		if value.Cap() < n {
   377			value.Set(reflect.MakeSlice(value.Type(), n, n))
   378		} else {
   379			value.Set(value.Slice(0, n))
   380		}
   381		if _, err := state.b.Read(value.Bytes()); err != nil {
   382			errorf("error decoding []byte: %s", err)
   383		}
   384	}
   385	
   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()
   391		if !ok {
   392			errorf("bad %s slice length: %d", value.Type(), n)
   393		}
   394		// Read the data.
   395		data := state.b.Bytes()
   396		if len(data) < n {
   397			errorf("invalid string length %d: exceeds input size %d", n, len(data))
   398		}
   399		s := string(data[:n])
   400		state.b.Drop(n)
   401		value.SetString(s)
   402	}
   403	
   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()
   407		if !ok {
   408			errorf("slice length too large")
   409		}
   410		bn := state.b.Len()
   411		if bn < n {
   412			errorf("invalid slice length %d: exceeds input size %d", n, bn)
   413		}
   414		state.b.Drop(n)
   415	}
   416	
   417	// Execution engine
   418	
   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 {
   422		instr    []decInstr
   423		numInstr int // the number of active instructions
   424	}
   425	
   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")
   435		}
   436		instr := &engine.instr[singletonField]
   437		instr.op(instr, state, value)
   438	}
   439	
   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)
   448		state.fieldnum = -1
   449		for state.b.Len() > 0 {
   450			delta := int(state.decodeUint())
   451			if delta < 0 {
   452				errorf("decode: corrupted data: negative delta")
   453			}
   454			if delta == 0 { // struct terminator is zero delta fieldnum
   455				break
   456			}
   457			fieldnum := state.fieldnum + delta
   458			if fieldnum >= len(engine.instr) {
   459				error_(errRange)
   460				break
   461			}
   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.Ptr {
   468					field = decAlloc(field)
   469				}
   470			}
   471			instr.op(instr, state, field)
   472			state.fieldnum = fieldnum
   473		}
   474	}
   475	
   476	var noValue reflect.Value
   477	
   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)
   482		state.fieldnum = -1
   483		for state.b.Len() > 0 {
   484			delta := int(state.decodeUint())
   485			if delta < 0 {
   486				errorf("ignore decode: corrupted data: negative delta")
   487			}
   488			if delta == 0 { // struct terminator is zero delta fieldnum
   489				break
   490			}
   491			fieldnum := state.fieldnum + delta
   492			if fieldnum >= len(engine.instr) {
   493				error_(errRange)
   494			}
   495			instr := &engine.instr[fieldnum]
   496			instr.op(instr, state, noValue)
   497			state.fieldnum = fieldnum
   498		}
   499	}
   500	
   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())
   508		if delta != 0 {
   509			errorf("decode: corrupted data: non-zero delta for singleton")
   510		}
   511		instr := &engine.instr[singletonField]
   512		instr.op(instr, state, noValue)
   513	}
   514	
   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) {
   518			return
   519		}
   520		instr := &decInstr{elemOp, 0, nil, ovfl}
   521		isPtr := value.Type().Elem().Kind() == reflect.Ptr
   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)
   525			}
   526			v := value.Index(i)
   527			if isPtr {
   528				v = decAlloc(v)
   529			}
   530			elemOp(instr, state, v)
   531		}
   532	}
   533	
   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")
   540		}
   541		dec.decodeArrayHelper(state, value, elemOp, length, ovfl, helper)
   542	}
   543	
   544	// decodeIntoValue is a helper for map decoding.
   545	func decodeIntoValue(state *decoderState, op decOp, isPtr bool, value reflect.Value, instr *decInstr) reflect.Value {
   546		v := value
   547		if isPtr {
   548			v = decAlloc(value)
   549		}
   550	
   551		op(instr, state, v)
   552		return value
   553	}
   554	
   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())
   561		if value.IsNil() {
   562			value.Set(reflect.MakeMapWithSize(mtyp, n))
   563		}
   564		keyIsPtr := mtyp.Key().Kind() == reflect.Ptr
   565		elemIsPtr := mtyp.Elem().Kind() == reflect.Ptr
   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)
   578		}
   579	}
   580	
   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)
   587			}
   588			elemOp(instr, state, noValue)
   589		}
   590	}
   591	
   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")
   596		}
   597		dec.ignoreArrayHelper(state, elemOp, length)
   598	}
   599	
   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)
   608		}
   609	}
   610	
   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()
   615		typ := value.Type()
   616		size := uint64(typ.Elem().Size())
   617		nBytes := u * size
   618		n := int(u)
   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)
   624		}
   625		if value.Cap() < n {
   626			value.Set(reflect.MakeSlice(typ, n, n))
   627		} else {
   628			value.Set(value.Slice(0, n))
   629		}
   630		dec.decodeArrayHelper(state, value, elemOp, n, ovfl, helper)
   631	}
   632	
   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()))
   636	}
   637	
   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)
   646		}
   647		if nr > uint64(state.b.Len()) {
   648			errorf("invalid type name length %d: exceeds input size", nr)
   649		}
   650		n := int(nr)
   651		name := state.b.Bytes()[:n]
   652		state.b.Drop(n)
   653		// Allocate the destination interface value.
   654		if len(name) == 0 {
   655			// Copy the nil interface value to the target.
   656			value.Set(reflect.Zero(value.Type()))
   657			return
   658		}
   659		if len(name) > 1024 {
   660			errorf("name too long (%d bytes): %.20q...", len(name), name)
   661		}
   662		// The concrete type must be registered.
   663		typi, ok := nameToConcreteType.Load(string(name))
   664		if !ok {
   665			errorf("name not registered for interface: %q", name)
   666		}
   667		typ := typi.(reflect.Type)
   668	
   669		// Read the type id of the concrete value.
   670		concreteId := dec.decodeTypeSequence(true)
   671		if concreteId < 0 {
   672			error_(dec.err)
   673		}
   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).
   676		state.decodeUint()
   677		// Read the concrete value.
   678		v := allocValue(typ)
   679		dec.decodeValue(concreteId, v)
   680		if dec.err != nil {
   681			error_(dec.err)
   682		}
   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)
   687		}
   688		// Copy the interface value to the target.
   689		value.Set(v)
   690	}
   691	
   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()
   696		if !ok {
   697			errorf("bad interface encoding: name too large for buffer")
   698		}
   699		bn := state.b.Len()
   700		if bn < n {
   701			errorf("invalid interface value length %d: exceeds input size %d", n, bn)
   702		}
   703		state.b.Drop(n)
   704		id := dec.decodeTypeSequence(true)
   705		if id < 0 {
   706			error_(dec.err)
   707		}
   708		// At this point, the decoder buffer contains a delimited value. Just toss it.
   709		n, ok = state.getLength()
   710		if !ok {
   711			errorf("bad interface encoding: data length too large for buffer")
   712		}
   713		state.b.Drop(n)
   714	}
   715	
   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()
   721		if !ok {
   722			errorf("GobDecoder: length too large for buffer")
   723		}
   724		b := state.b.Bytes()
   725		if len(b) < n {
   726			errorf("GobDecoder: invalid data length %d: exceeds input size %d", n, len(b))
   727		}
   728		b = b[:n]
   729		state.b.Drop(n)
   730		var err error
   731		// We know it's one of these.
   732		switch ut.externalDec {
   733		case xGob:
   734			err = value.Interface().(GobDecoder).GobDecode(b)
   735		case xBinary:
   736			err = value.Interface().(encoding.BinaryUnmarshaler).UnmarshalBinary(b)
   737		case xText:
   738			err = value.Interface().(encoding.TextUnmarshaler).UnmarshalText(b)
   739		}
   740		if err != nil {
   741			error_(err)
   742		}
   743	}
   744	
   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()
   749		if !ok {
   750			errorf("GobDecoder: length too large for buffer")
   751		}
   752		bn := state.b.Len()
   753		if bn < n {
   754			errorf("GobDecoder: invalid data length %d: exceeds input size %d", n, bn)
   755		}
   756		state.b.Drop(n)
   757	}
   758	
   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,
   775	}
   776	
   777	// Indexed by gob types.  tComplex will be added during type.init().
   778	var decIgnoreOpMap = map[typeId]decOp{
   779		tBool:    ignoreUint,
   780		tInt:     ignoreUint,
   781		tUint:    ignoreUint,
   782		tFloat:   ignoreUint,
   783		tBytes:   ignoreUint8Array,
   784		tString:  ignoreUint8Array,
   785		tComplex: ignoreTwoUints,
   786	}
   787	
   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 {
   791		ut := userType(rt)
   792		// If the type implements GobEncoder, we handle it without further processing.
   793		if ut.externalDec != 0 {
   794			return dec.gobDecodeOpFor(ut)
   795		}
   796	
   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 {
   800			return opPtr
   801		}
   802		typ := ut.base
   803		var op decOp
   804		k := typ.Kind()
   805		if int(k) < len(decOpTable) {
   806			op = decOpTable[k]
   807		}
   808		if op == nil {
   809			inProgress[rt] = &op
   810			// Special cases
   811			switch t := typ; t.Kind() {
   812			case reflect.Array:
   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)
   820				}
   821	
   822			case reflect.Map:
   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)
   830				}
   831	
   832			case reflect.Slice:
   833				name = "element of " + name
   834				if t.Elem().Kind() == reflect.Uint8 {
   835					op = decUint8Slice
   836					break
   837				}
   838				var elemId typeId
   839				if tt, ok := builtinIdToType[wireId]; ok {
   840					elemId = tt.(*sliceType).Elem
   841				} else {
   842					elemId = dec.wireType[wireId].SliceT.Elem
   843				}
   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)
   849				}
   850	
   851			case reflect.Struct:
   852				// Generate a closure that calls out to the engine for the nested type.
   853				ut := userType(typ)
   854				enginePtr, err := dec.getDecEnginePtr(wireId, ut)
   855				if err != nil {
   856					error_(err)
   857				}
   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)
   861				}
   862			case reflect.Interface:
   863				op = func(i *decInstr, state *decoderState, value reflect.Value) {
   864					state.dec.decodeInterface(t, state, value)
   865				}
   866			}
   867		}
   868		if op == nil {
   869			errorf("decode can't handle type %s", rt)
   870		}
   871		return &op
   872	}
   873	
   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 {
   879			return opPtr
   880		}
   881		op, ok := decIgnoreOpMap[wireId]
   882		if !ok {
   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)
   889				}
   890				return &op
   891			}
   892			// Special cases
   893			wire := dec.wireType[wireId]
   894			switch {
   895			case wire == nil:
   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)
   902				}
   903	
   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)
   911				}
   912	
   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)
   918				}
   919	
   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)
   923				if err != nil {
   924					error_(err)
   925				}
   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)
   929				}
   930	
   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)
   934				}
   935			}
   936		}
   937		if op == nil {
   938			errorf("bad data: ignore can't handle type %s", wireId.string())
   939		}
   940		return &op
   941	}
   942	
   943	// gobDecodeOpFor returns the op for a type that is known to implement
   944	// GobDecoder.
   945	func (dec *Decoder) gobDecodeOpFor(ut *userTypeInfo) *decOp {
   946		rcvrType := ut.user
   947		if ut.decIndir == -1 {
   948			rcvrType = reflect.PtrTo(rcvrType)
   949		} else if ut.decIndir > 0 {
   950			for i := int8(0); i < ut.decIndir; i++ {
   951				rcvrType = rcvrType.Elem()
   952			}
   953		}
   954		var op decOp
   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.Ptr && rcvrType.Kind() == reflect.Ptr {
   958				value = value.Addr()
   959			}
   960			state.dec.decodeGobDecoder(ut, state, value)
   961		}
   962		return &op
   963	}
   964	
   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 {
   971			return rhs == fw
   972		}
   973		inProgress[fr] = fw
   974		ut := userType(fr)
   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) {
   985			return false
   986		}
   987		if ut.externalDec != 0 { // This test trumps all others.
   988			return true
   989		}
   990		switch t := ut.base; t.Kind() {
   991		default:
   992			// chan, etc: cannot handle.
   993			return false
   994		case reflect.Bool:
   995			return fw == tBool
   996		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   997			return fw == tInt
   998		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   999			return fw == tUint
  1000		case reflect.Float32, reflect.Float64:
  1001			return fw == tFloat
  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
  1008		case reflect.Array:
  1009			if !ok || wire.ArrayT == nil {
  1010				return false
  1011			}
  1012			array := wire.ArrayT
  1013			return t.Len() == array.Len && dec.compatibleType(t.Elem(), array.Elem, inProgress)
  1014		case reflect.Map:
  1015			if !ok || wire.MapT == nil {
  1016				return false
  1017			}
  1018			MapType := wire.MapT
  1019			return dec.compatibleType(t.Key(), MapType.Key, inProgress) && dec.compatibleType(t.Elem(), MapType.Elem, inProgress)
  1020		case reflect.Slice:
  1021			// Is it an array of bytes?
  1022			if t.Elem().Kind() == reflect.Uint8 {
  1023				return fw == tBytes
  1024			}
  1025			// Extract and compare element types.
  1026			var sw *sliceType
  1027			if tt, ok := builtinIdToType[fw]; ok {
  1028				sw, _ = tt.(*sliceType)
  1029			} else if wire != nil {
  1030				sw = wire.SliceT
  1031			}
  1032			elem := userType(t.Elem()).base
  1033			return sw != nil && dec.compatibleType(elem, sw.Elem, inProgress)
  1034		case reflect.Struct:
  1035			return true
  1036		}
  1037	}
  1038	
  1039	// typeString returns a human-readable description of the type identified by remoteId.
  1040	func (dec *Decoder) typeString(remoteId typeId) string {
  1041		typeLock.Lock()
  1042		defer typeLock.Unlock()
  1043		if t := idToType[remoteId]; t != nil {
  1044			// globally known type.
  1045			return t.string()
  1046		}
  1047		return dec.wireType[remoteId].string()
  1048	}
  1049	
  1050	// compileSingle compiles the decoder engine for a non-struct top-level value, including
  1051	// GobDecoders.
  1052	func (dec *Decoder) compileSingle(remoteId typeId, ut *userTypeInfo) (engine *decEngine, err error) {
  1053		rt := ut.user
  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)
  1062			}
  1063			return nil, errors.New("gob: decoding into local type " + name + ", received remote type " + remoteType)
  1064		}
  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}
  1068		engine.numInstr = 1
  1069		return
  1070	}
  1071	
  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}
  1079		engine.numInstr = 1
  1080		return engine
  1081	}
  1082	
  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)
  1087		rt := ut.base
  1088		srt := rt
  1089		if srt.Kind() != reflect.Struct || ut.externalDec != 0 {
  1090			return dec.compileSingle(remoteId, ut)
  1091		}
  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)
  1097		} else {
  1098			wire := dec.wireType[remoteId]
  1099			if wire == nil {
  1100				error_(errBadType)
  1101			}
  1102			wireStruct = wire.StructT
  1103		}
  1104		if wireStruct == nil {
  1105			errorf("type mismatch in decoder: want struct type %s; got non-struct", rt)
  1106		}
  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)
  1115			}
  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}
  1123				continue
  1124			}
  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)
  1127			}
  1128			op := dec.decOpFor(wireField.Id, localField.Type, localField.Name, seen)
  1129			engine.instr[fieldnum] = decInstr{*op, fieldnum, localField.Index, ovfl}
  1130			engine.numInstr++
  1131		}
  1132		return
  1133	}
  1134	
  1135	// getDecEnginePtr returns the engine for the specified type.
  1136	func (dec *Decoder) getDecEnginePtr(remoteId typeId, ut *userTypeInfo) (enginePtr **decEngine, err error) {
  1137		rt := ut.user
  1138		decoderMap, ok := dec.decoderCache[rt]
  1139		if !ok {
  1140			decoderMap = make(map[typeId]**decEngine)
  1141			dec.decoderCache[rt] = decoderMap
  1142		}
  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)
  1148			if err != nil {
  1149				delete(decoderMap, remoteId)
  1150			}
  1151		}
  1152		return
  1153	}
  1154	
  1155	// emptyStruct is the type we compile into when ignoring a struct value.
  1156	type emptyStruct struct{}
  1157	
  1158	var emptyStructType = reflect.TypeOf(emptyStruct{})
  1159	
  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) {
  1162		var ok bool
  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))
  1170			} else {
  1171				*enginePtr = dec.compileIgnoreSingle(wireId)
  1172			}
  1173			if err != nil {
  1174				delete(dec.ignorerCache, wireId)
  1175			}
  1176		}
  1177		return
  1178	}
  1179	
  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)
  1186			return
  1187		}
  1188		// Dereference down to the underlying type.
  1189		ut := userType(value.Type())
  1190		base := ut.base
  1191		var enginePtr **decEngine
  1192		enginePtr, dec.err = dec.getDecEnginePtr(wireId, ut)
  1193		if dec.err != nil {
  1194			return
  1195		}
  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 {
  1202				name := base.Name()
  1203				errorf("type mismatch: no fields matched compiling decoder for %s", name)
  1204			}
  1205			dec.decodeStruct(engine, value)
  1206		} else {
  1207			dec.decodeSingle(engine, value)
  1208		}
  1209	}
  1210	
  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)
  1215		if dec.err != nil {
  1216			return
  1217		}
  1218		wire := dec.wireType[wireId]
  1219		if wire != nil && wire.StructT != nil {
  1220			dec.ignoreStruct(*enginePtr)
  1221		} else {
  1222			dec.ignoreSingle(*enginePtr)
  1223		}
  1224	}
  1225	
  1226	func init() {
  1227		var iop, uop decOp
  1228		switch reflect.TypeOf(int(0)).Bits() {
  1229		case 32:
  1230			iop = decInt32
  1231			uop = decUint32
  1232		case 64:
  1233			iop = decInt64
  1234			uop = decUint64
  1235		default:
  1236			panic("gob: unknown size of int/uint")
  1237		}
  1238		decOpTable[reflect.Int] = iop
  1239		decOpTable[reflect.Uint] = uop
  1240	
  1241		// Finally uintptr
  1242		switch reflect.TypeOf(uintptr(0)).Bits() {
  1243		case 32:
  1244			uop = decUint32
  1245		case 64:
  1246			uop = decUint64
  1247		default:
  1248			panic("gob: unknown size of uintptr")
  1249		}
  1250		decOpTable[reflect.Uintptr] = uop
  1251	}
  1252	
  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()
  1259	}
  1260	

View as plain text