...
1
2
3
4
5 package gob
6
7 import (
8 "bufio"
9 "errors"
10 "io"
11 "reflect"
12 "sync"
13 )
14
15
16
17
18 const tooBig = 1 << 30
19
20
21
22
23
24
25
26 type Decoder struct {
27 mutex sync.Mutex
28 r io.Reader
29 buf decBuffer
30 wireType map[typeId]*wireType
31 decoderCache map[reflect.Type]map[typeId]**decEngine
32 ignorerCache map[typeId]**decEngine
33 freeList *decoderState
34 countBuf []byte
35 err error
36 }
37
38
39
40
41 func NewDecoder(r io.Reader) *Decoder {
42 dec := new(Decoder)
43
44 if _, ok := r.(io.ByteReader); !ok {
45 r = bufio.NewReader(r)
46 }
47 dec.r = r
48 dec.wireType = make(map[typeId]*wireType)
49 dec.decoderCache = make(map[reflect.Type]map[typeId]**decEngine)
50 dec.ignorerCache = make(map[typeId]**decEngine)
51 dec.countBuf = make([]byte, 9)
52
53 return dec
54 }
55
56
57 func (dec *Decoder) recvType(id typeId) {
58
59 if id < firstUserId || dec.wireType[id] != nil {
60 dec.err = errors.New("gob: duplicate type received")
61 return
62 }
63
64
65 wire := new(wireType)
66 dec.decodeValue(tWireType, reflect.ValueOf(wire))
67 if dec.err != nil {
68 return
69 }
70
71 dec.wireType[id] = wire
72 }
73
74 var errBadCount = errors.New("invalid message length")
75
76
77
78 func (dec *Decoder) recvMessage() bool {
79
80 nbytes, _, err := decodeUintReader(dec.r, dec.countBuf)
81 if err != nil {
82 dec.err = err
83 return false
84 }
85 if nbytes >= tooBig {
86 dec.err = errBadCount
87 return false
88 }
89 dec.readMessage(int(nbytes))
90 return dec.err == nil
91 }
92
93
94 func (dec *Decoder) readMessage(nbytes int) {
95 if dec.buf.Len() != 0 {
96
97 panic("non-empty decoder buffer")
98 }
99
100 dec.buf.Size(nbytes)
101 _, dec.err = io.ReadFull(dec.r, dec.buf.Bytes())
102 if dec.err == io.EOF {
103 dec.err = io.ErrUnexpectedEOF
104 }
105 }
106
107
108 func toInt(x uint64) int64 {
109 i := int64(x >> 1)
110 if x&1 != 0 {
111 i = ^i
112 }
113 return i
114 }
115
116 func (dec *Decoder) nextInt() int64 {
117 n, _, err := decodeUintReader(&dec.buf, dec.countBuf)
118 if err != nil {
119 dec.err = err
120 }
121 return toInt(n)
122 }
123
124 func (dec *Decoder) nextUint() uint64 {
125 n, _, err := decodeUintReader(&dec.buf, dec.countBuf)
126 if err != nil {
127 dec.err = err
128 }
129 return n
130 }
131
132
133
134
135
136
137
138
139 func (dec *Decoder) decodeTypeSequence(isInterface bool) typeId {
140 for dec.err == nil {
141 if dec.buf.Len() == 0 {
142 if !dec.recvMessage() {
143 break
144 }
145 }
146
147 id := typeId(dec.nextInt())
148 if id >= 0 {
149
150 return id
151 }
152
153 dec.recvType(-id)
154
155
156
157
158 if dec.buf.Len() > 0 {
159 if !isInterface {
160 dec.err = errors.New("extra data in buffer")
161 break
162 }
163 dec.nextUint()
164 }
165 }
166 return -1
167 }
168
169
170
171
172
173
174
175
176 func (dec *Decoder) Decode(e interface{}) error {
177 if e == nil {
178 return dec.DecodeValue(reflect.Value{})
179 }
180 value := reflect.ValueOf(e)
181
182
183 if value.Type().Kind() != reflect.Ptr {
184 dec.err = errors.New("gob: attempt to decode into a non-pointer")
185 return dec.err
186 }
187 return dec.DecodeValue(value)
188 }
189
190
191
192
193
194
195
196 func (dec *Decoder) DecodeValue(v reflect.Value) error {
197 if v.IsValid() {
198 if v.Kind() == reflect.Ptr && !v.IsNil() {
199
200 } else if !v.CanSet() {
201 return errors.New("gob: DecodeValue of unassignable value")
202 }
203 }
204
205 dec.mutex.Lock()
206 defer dec.mutex.Unlock()
207
208 dec.buf.Reset()
209 dec.err = nil
210 id := dec.decodeTypeSequence(false)
211 if dec.err == nil {
212 dec.decodeValue(id, v)
213 }
214 return dec.err
215 }
216
217
218
219
220 var debugFunc func(io.Reader)
221
View as plain text