Source file src/pkg/gob/decoder.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	package gob
     6	
     7	import (
     8		"bufio"
     9		"bytes"
    10		"io"
    11		"os"
    12		"reflect"
    13		"sync"
    14	)
    15	
    16	// A Decoder manages the receipt of type and data information read from the
    17	// remote side of a connection.
    18	type Decoder struct {
    19		mutex        sync.Mutex                              // each item must be received atomically
    20		r            io.Reader                               // source of the data
    21		buf          bytes.Buffer                            // buffer for more efficient i/o from r
    22		wireType     map[typeId]*wireType                    // map from remote ID to local description
    23		decoderCache map[reflect.Type]map[typeId]**decEngine // cache of compiled engines
    24		ignorerCache map[typeId]**decEngine                  // ditto for ignored objects
    25		freeList     *decoderState                           // list of free decoderStates; avoids reallocation
    26		countBuf     []byte                                  // used for decoding integers while parsing messages
    27		tmp          []byte                                  // temporary storage for i/o; saves reallocating
    28		err          os.Error
    29	}
    30	
    31	// NewDecoder returns a new decoder that reads from the io.Reader.
    32	func NewDecoder(r io.Reader) *Decoder {
    33		dec := new(Decoder)
    34		dec.r = bufio.NewReader(r)
    35		dec.wireType = make(map[typeId]*wireType)
    36		dec.decoderCache = make(map[reflect.Type]map[typeId]**decEngine)
    37		dec.ignorerCache = make(map[typeId]**decEngine)
    38		dec.countBuf = make([]byte, 9) // counts may be uint64s (unlikely!), require 9 bytes
    39	
    40		return dec
    41	}
    42	
    43	// recvType loads the definition of a type.
    44	func (dec *Decoder) recvType(id typeId) {
    45		// Have we already seen this type?  That's an error
    46		if id < firstUserId || dec.wireType[id] != nil {
    47			dec.err = os.NewError("gob: duplicate type received")
    48			return
    49		}
    50	
    51		// Type:
    52		wire := new(wireType)
    53		dec.decodeValue(tWireType, reflect.ValueOf(wire))
    54		if dec.err != nil {
    55			return
    56		}
    57		// Remember we've seen this type.
    58		dec.wireType[id] = wire
    59	}
    60	
    61	// recvMessage reads the next count-delimited item from the input. It is the converse
    62	// of Encoder.writeMessage. It returns false on EOF or other error reading the message.
    63	func (dec *Decoder) recvMessage() bool {
    64		// Read a count.
    65		nbytes, _, err := decodeUintReader(dec.r, dec.countBuf)
    66		if err != nil {
    67			dec.err = err
    68			return false
    69		}
    70		dec.readMessage(int(nbytes))
    71		return dec.err == nil
    72	}
    73	
    74	// readMessage reads the next nbytes bytes from the input.
    75	func (dec *Decoder) readMessage(nbytes int) {
    76		// Allocate the buffer.
    77		if cap(dec.tmp) < nbytes {
    78			dec.tmp = make([]byte, nbytes+100) // room to grow
    79		}
    80		dec.tmp = dec.tmp[:nbytes]
    81	
    82		// Read the data
    83		_, dec.err = io.ReadFull(dec.r, dec.tmp)
    84		if dec.err != nil {
    85			if dec.err == os.EOF {
    86				dec.err = io.ErrUnexpectedEOF
    87			}
    88			return
    89		}
    90		dec.buf.Write(dec.tmp)
    91	}
    92	
    93	// toInt turns an encoded uint64 into an int, according to the marshaling rules.
    94	func toInt(x uint64) int64 {
    95		i := int64(x >> 1)
    96		if x&1 != 0 {
    97			i = ^i
    98		}
    99		return i
   100	}
   101	
   102	func (dec *Decoder) nextInt() int64 {
   103		n, _, err := decodeUintReader(&dec.buf, dec.countBuf)
   104		if err != nil {
   105			dec.err = err
   106		}
   107		return toInt(n)
   108	}
   109	
   110	func (dec *Decoder) nextUint() uint64 {
   111		n, _, err := decodeUintReader(&dec.buf, dec.countBuf)
   112		if err != nil {
   113			dec.err = err
   114		}
   115		return n
   116	}
   117	
   118	// decodeTypeSequence parses:
   119	// TypeSequence
   120	//	(TypeDefinition DelimitedTypeDefinition*)?
   121	// and returns the type id of the next value.  It returns -1 at
   122	// EOF.  Upon return, the remainder of dec.buf is the value to be
   123	// decoded.  If this is an interface value, it can be ignored by
   124	// simply resetting that buffer.
   125	func (dec *Decoder) decodeTypeSequence(isInterface bool) typeId {
   126		for dec.err == nil {
   127			if dec.buf.Len() == 0 {
   128				if !dec.recvMessage() {
   129					break
   130				}
   131			}
   132			// Receive a type id.
   133			id := typeId(dec.nextInt())
   134			if id >= 0 {
   135				// Value follows.
   136				return id
   137			}
   138			// Type definition for (-id) follows.
   139			dec.recvType(-id)
   140			// When decoding an interface, after a type there may be a
   141			// DelimitedValue still in the buffer.  Skip its count.
   142			// (Alternatively, the buffer is empty and the byte count
   143			// will be absorbed by recvMessage.)
   144			if dec.buf.Len() > 0 {
   145				if !isInterface {
   146					dec.err = os.NewError("extra data in buffer")
   147					break
   148				}
   149				dec.nextUint()
   150			}
   151		}
   152		return -1
   153	}
   154	
   155	// Decode reads the next value from the connection and stores
   156	// it in the data represented by the empty interface value.
   157	// If e is nil, the value will be discarded. Otherwise,
   158	// the value underlying e must be a pointer to the
   159	// correct type for the next data item received.
   160	func (dec *Decoder) Decode(e interface{}) os.Error {
   161		if e == nil {
   162			return dec.DecodeValue(reflect.Value{})
   163		}
   164		value := reflect.ValueOf(e)
   165		// If e represents a value as opposed to a pointer, the answer won't
   166		// get back to the caller.  Make sure it's a pointer.
   167		if value.Type().Kind() != reflect.Ptr {
   168			dec.err = os.NewError("gob: attempt to decode into a non-pointer")
   169			return dec.err
   170		}
   171		return dec.DecodeValue(value)
   172	}
   173	
   174	// DecodeValue reads the next value from the connection.
   175	// If v is the zero reflect.Value (v.Kind() == Invalid), DecodeValue discards the value.
   176	// Otherwise, it stores the value into v.  In that case, v must represent
   177	// a non-nil pointer to data or be an assignable reflect.Value (v.CanSet())
   178	func (dec *Decoder) DecodeValue(v reflect.Value) os.Error {
   179		if v.IsValid() {
   180			if v.Kind() == reflect.Ptr && !v.IsNil() {
   181				// That's okay, we'll store through the pointer.
   182			} else if !v.CanSet() {
   183				return os.NewError("gob: DecodeValue of unassignable value")
   184			}
   185		}
   186		// Make sure we're single-threaded through here.
   187		dec.mutex.Lock()
   188		defer dec.mutex.Unlock()
   189	
   190		dec.buf.Reset() // In case data lingers from previous invocation.
   191		dec.err = nil
   192		id := dec.decodeTypeSequence(false)
   193		if dec.err == nil {
   194			dec.decodeValue(id, v)
   195		}
   196		return dec.err
   197	}
   198	
   199	// If debug.go is compiled into the program , debugFunc prints a human-readable
   200	// representation of the gob data read from r by calling that file's Debug function.
   201	// Otherwise it is nil.
   202	var debugFunc func(io.Reader)
The Go Programming Language

Source file src/pkg/gob/decoder.go
