diff options
Diffstat (limited to 'vendor/github.com/golang/protobuf/proto/decode.go')
-rw-r--r-- | vendor/github.com/golang/protobuf/proto/decode.go | 428 |
1 files changed, 428 insertions, 0 deletions
diff --git a/vendor/github.com/golang/protobuf/proto/decode.go b/vendor/github.com/golang/protobuf/proto/decode.go new file mode 100644 index 0000000..d9aa3c4 --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/decode.go | |||
@@ -0,0 +1,428 @@ | |||
1 | // Go support for Protocol Buffers - Google's data interchange format | ||
2 | // | ||
3 | // Copyright 2010 The Go Authors. All rights reserved. | ||
4 | // https://github.com/golang/protobuf | ||
5 | // | ||
6 | // Redistribution and use in source and binary forms, with or without | ||
7 | // modification, are permitted provided that the following conditions are | ||
8 | // met: | ||
9 | // | ||
10 | // * Redistributions of source code must retain the above copyright | ||
11 | // notice, this list of conditions and the following disclaimer. | ||
12 | // * Redistributions in binary form must reproduce the above | ||
13 | // copyright notice, this list of conditions and the following disclaimer | ||
14 | // in the documentation and/or other materials provided with the | ||
15 | // distribution. | ||
16 | // * Neither the name of Google Inc. nor the names of its | ||
17 | // contributors may be used to endorse or promote products derived from | ||
18 | // this software without specific prior written permission. | ||
19 | // | ||
20 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
21 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
22 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
23 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | ||
24 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
25 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | ||
26 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | ||
27 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | ||
28 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
29 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | ||
30 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
31 | |||
32 | package proto | ||
33 | |||
34 | /* | ||
35 | * Routines for decoding protocol buffer data to construct in-memory representations. | ||
36 | */ | ||
37 | |||
38 | import ( | ||
39 | "errors" | ||
40 | "fmt" | ||
41 | "io" | ||
42 | ) | ||
43 | |||
44 | // errOverflow is returned when an integer is too large to be represented. | ||
45 | var errOverflow = errors.New("proto: integer overflow") | ||
46 | |||
47 | // ErrInternalBadWireType is returned by generated code when an incorrect | ||
48 | // wire type is encountered. It does not get returned to user code. | ||
49 | var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof") | ||
50 | |||
51 | // DecodeVarint reads a varint-encoded integer from the slice. | ||
52 | // It returns the integer and the number of bytes consumed, or | ||
53 | // zero if there is not enough. | ||
54 | // This is the format for the | ||
55 | // int32, int64, uint32, uint64, bool, and enum | ||
56 | // protocol buffer types. | ||
57 | func DecodeVarint(buf []byte) (x uint64, n int) { | ||
58 | for shift := uint(0); shift < 64; shift += 7 { | ||
59 | if n >= len(buf) { | ||
60 | return 0, 0 | ||
61 | } | ||
62 | b := uint64(buf[n]) | ||
63 | n++ | ||
64 | x |= (b & 0x7F) << shift | ||
65 | if (b & 0x80) == 0 { | ||
66 | return x, n | ||
67 | } | ||
68 | } | ||
69 | |||
70 | // The number is too large to represent in a 64-bit value. | ||
71 | return 0, 0 | ||
72 | } | ||
73 | |||
74 | func (p *Buffer) decodeVarintSlow() (x uint64, err error) { | ||
75 | i := p.index | ||
76 | l := len(p.buf) | ||
77 | |||
78 | for shift := uint(0); shift < 64; shift += 7 { | ||
79 | if i >= l { | ||
80 | err = io.ErrUnexpectedEOF | ||
81 | return | ||
82 | } | ||
83 | b := p.buf[i] | ||
84 | i++ | ||
85 | x |= (uint64(b) & 0x7F) << shift | ||
86 | if b < 0x80 { | ||
87 | p.index = i | ||
88 | return | ||
89 | } | ||
90 | } | ||
91 | |||
92 | // The number is too large to represent in a 64-bit value. | ||
93 | err = errOverflow | ||
94 | return | ||
95 | } | ||
96 | |||
97 | // DecodeVarint reads a varint-encoded integer from the Buffer. | ||
98 | // This is the format for the | ||
99 | // int32, int64, uint32, uint64, bool, and enum | ||
100 | // protocol buffer types. | ||
101 | func (p *Buffer) DecodeVarint() (x uint64, err error) { | ||
102 | i := p.index | ||
103 | buf := p.buf | ||
104 | |||
105 | if i >= len(buf) { | ||
106 | return 0, io.ErrUnexpectedEOF | ||
107 | } else if buf[i] < 0x80 { | ||
108 | p.index++ | ||
109 | return uint64(buf[i]), nil | ||
110 | } else if len(buf)-i < 10 { | ||
111 | return p.decodeVarintSlow() | ||
112 | } | ||
113 | |||
114 | var b uint64 | ||
115 | // we already checked the first byte | ||
116 | x = uint64(buf[i]) - 0x80 | ||
117 | i++ | ||
118 | |||
119 | b = uint64(buf[i]) | ||
120 | i++ | ||
121 | x += b << 7 | ||
122 | if b&0x80 == 0 { | ||
123 | goto done | ||
124 | } | ||
125 | x -= 0x80 << 7 | ||
126 | |||
127 | b = uint64(buf[i]) | ||
128 | i++ | ||
129 | x += b << 14 | ||
130 | if b&0x80 == 0 { | ||
131 | goto done | ||
132 | } | ||
133 | x -= 0x80 << 14 | ||
134 | |||
135 | b = uint64(buf[i]) | ||
136 | i++ | ||
137 | x += b << 21 | ||
138 | if b&0x80 == 0 { | ||
139 | goto done | ||
140 | } | ||
141 | x -= 0x80 << 21 | ||
142 | |||
143 | b = uint64(buf[i]) | ||
144 | i++ | ||
145 | x += b << 28 | ||
146 | if b&0x80 == 0 { | ||
147 | goto done | ||
148 | } | ||
149 | x -= 0x80 << 28 | ||
150 | |||
151 | b = uint64(buf[i]) | ||
152 | i++ | ||
153 | x += b << 35 | ||
154 | if b&0x80 == 0 { | ||
155 | goto done | ||
156 | } | ||
157 | x -= 0x80 << 35 | ||
158 | |||
159 | b = uint64(buf[i]) | ||
160 | i++ | ||
161 | x += b << 42 | ||
162 | if b&0x80 == 0 { | ||
163 | goto done | ||
164 | } | ||
165 | x -= 0x80 << 42 | ||
166 | |||
167 | b = uint64(buf[i]) | ||
168 | i++ | ||
169 | x += b << 49 | ||
170 | if b&0x80 == 0 { | ||
171 | goto done | ||
172 | } | ||
173 | x -= 0x80 << 49 | ||
174 | |||
175 | b = uint64(buf[i]) | ||
176 | i++ | ||
177 | x += b << 56 | ||
178 | if b&0x80 == 0 { | ||
179 | goto done | ||
180 | } | ||
181 | x -= 0x80 << 56 | ||
182 | |||
183 | b = uint64(buf[i]) | ||
184 | i++ | ||
185 | x += b << 63 | ||
186 | if b&0x80 == 0 { | ||
187 | goto done | ||
188 | } | ||
189 | // x -= 0x80 << 63 // Always zero. | ||
190 | |||
191 | return 0, errOverflow | ||
192 | |||
193 | done: | ||
194 | p.index = i | ||
195 | return x, nil | ||
196 | } | ||
197 | |||
198 | // DecodeFixed64 reads a 64-bit integer from the Buffer. | ||
199 | // This is the format for the | ||
200 | // fixed64, sfixed64, and double protocol buffer types. | ||
201 | func (p *Buffer) DecodeFixed64() (x uint64, err error) { | ||
202 | // x, err already 0 | ||
203 | i := p.index + 8 | ||
204 | if i < 0 || i > len(p.buf) { | ||
205 | err = io.ErrUnexpectedEOF | ||
206 | return | ||
207 | } | ||
208 | p.index = i | ||
209 | |||
210 | x = uint64(p.buf[i-8]) | ||
211 | x |= uint64(p.buf[i-7]) << 8 | ||
212 | x |= uint64(p.buf[i-6]) << 16 | ||
213 | x |= uint64(p.buf[i-5]) << 24 | ||
214 | x |= uint64(p.buf[i-4]) << 32 | ||
215 | x |= uint64(p.buf[i-3]) << 40 | ||
216 | x |= uint64(p.buf[i-2]) << 48 | ||
217 | x |= uint64(p.buf[i-1]) << 56 | ||
218 | return | ||
219 | } | ||
220 | |||
221 | // DecodeFixed32 reads a 32-bit integer from the Buffer. | ||
222 | // This is the format for the | ||
223 | // fixed32, sfixed32, and float protocol buffer types. | ||
224 | func (p *Buffer) DecodeFixed32() (x uint64, err error) { | ||
225 | // x, err already 0 | ||
226 | i := p.index + 4 | ||
227 | if i < 0 || i > len(p.buf) { | ||
228 | err = io.ErrUnexpectedEOF | ||
229 | return | ||
230 | } | ||
231 | p.index = i | ||
232 | |||
233 | x = uint64(p.buf[i-4]) | ||
234 | x |= uint64(p.buf[i-3]) << 8 | ||
235 | x |= uint64(p.buf[i-2]) << 16 | ||
236 | x |= uint64(p.buf[i-1]) << 24 | ||
237 | return | ||
238 | } | ||
239 | |||
240 | // DecodeZigzag64 reads a zigzag-encoded 64-bit integer | ||
241 | // from the Buffer. | ||
242 | // This is the format used for the sint64 protocol buffer type. | ||
243 | func (p *Buffer) DecodeZigzag64() (x uint64, err error) { | ||
244 | x, err = p.DecodeVarint() | ||
245 | if err != nil { | ||
246 | return | ||
247 | } | ||
248 | x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63) | ||
249 | return | ||
250 | } | ||
251 | |||
252 | // DecodeZigzag32 reads a zigzag-encoded 32-bit integer | ||
253 | // from the Buffer. | ||
254 | // This is the format used for the sint32 protocol buffer type. | ||
255 | func (p *Buffer) DecodeZigzag32() (x uint64, err error) { | ||
256 | x, err = p.DecodeVarint() | ||
257 | if err != nil { | ||
258 | return | ||
259 | } | ||
260 | x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31)) | ||
261 | return | ||
262 | } | ||
263 | |||
264 | // DecodeRawBytes reads a count-delimited byte buffer from the Buffer. | ||
265 | // This is the format used for the bytes protocol buffer | ||
266 | // type and for embedded messages. | ||
267 | func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) { | ||
268 | n, err := p.DecodeVarint() | ||
269 | if err != nil { | ||
270 | return nil, err | ||
271 | } | ||
272 | |||
273 | nb := int(n) | ||
274 | if nb < 0 { | ||
275 | return nil, fmt.Errorf("proto: bad byte length %d", nb) | ||
276 | } | ||
277 | end := p.index + nb | ||
278 | if end < p.index || end > len(p.buf) { | ||
279 | return nil, io.ErrUnexpectedEOF | ||
280 | } | ||
281 | |||
282 | if !alloc { | ||
283 | // todo: check if can get more uses of alloc=false | ||
284 | buf = p.buf[p.index:end] | ||
285 | p.index += nb | ||
286 | return | ||
287 | } | ||
288 | |||
289 | buf = make([]byte, nb) | ||
290 | copy(buf, p.buf[p.index:]) | ||
291 | p.index += nb | ||
292 | return | ||
293 | } | ||
294 | |||
295 | // DecodeStringBytes reads an encoded string from the Buffer. | ||
296 | // This is the format used for the proto2 string type. | ||
297 | func (p *Buffer) DecodeStringBytes() (s string, err error) { | ||
298 | buf, err := p.DecodeRawBytes(false) | ||
299 | if err != nil { | ||
300 | return | ||
301 | } | ||
302 | return string(buf), nil | ||
303 | } | ||
304 | |||
305 | // Unmarshaler is the interface representing objects that can | ||
306 | // unmarshal themselves. The argument points to data that may be | ||
307 | // overwritten, so implementations should not keep references to the | ||
308 | // buffer. | ||
309 | // Unmarshal implementations should not clear the receiver. | ||
310 | // Any unmarshaled data should be merged into the receiver. | ||
311 | // Callers of Unmarshal that do not want to retain existing data | ||
312 | // should Reset the receiver before calling Unmarshal. | ||
313 | type Unmarshaler interface { | ||
314 | Unmarshal([]byte) error | ||
315 | } | ||
316 | |||
317 | // newUnmarshaler is the interface representing objects that can | ||
318 | // unmarshal themselves. The semantics are identical to Unmarshaler. | ||
319 | // | ||
320 | // This exists to support protoc-gen-go generated messages. | ||
321 | // The proto package will stop type-asserting to this interface in the future. | ||
322 | // | ||
323 | // DO NOT DEPEND ON THIS. | ||
324 | type newUnmarshaler interface { | ||
325 | XXX_Unmarshal([]byte) error | ||
326 | } | ||
327 | |||
328 | // Unmarshal parses the protocol buffer representation in buf and places the | ||
329 | // decoded result in pb. If the struct underlying pb does not match | ||
330 | // the data in buf, the results can be unpredictable. | ||
331 | // | ||
332 | // Unmarshal resets pb before starting to unmarshal, so any | ||
333 | // existing data in pb is always removed. Use UnmarshalMerge | ||
334 | // to preserve and append to existing data. | ||
335 | func Unmarshal(buf []byte, pb Message) error { | ||
336 | pb.Reset() | ||
337 | if u, ok := pb.(newUnmarshaler); ok { | ||
338 | return u.XXX_Unmarshal(buf) | ||
339 | } | ||
340 | if u, ok := pb.(Unmarshaler); ok { | ||
341 | return u.Unmarshal(buf) | ||
342 | } | ||
343 | return NewBuffer(buf).Unmarshal(pb) | ||
344 | } | ||
345 | |||
346 | // UnmarshalMerge parses the protocol buffer representation in buf and | ||
347 | // writes the decoded result to pb. If the struct underlying pb does not match | ||
348 | // the data in buf, the results can be unpredictable. | ||
349 | // | ||
350 | // UnmarshalMerge merges into existing data in pb. | ||
351 | // Most code should use Unmarshal instead. | ||
352 | func UnmarshalMerge(buf []byte, pb Message) error { | ||
353 | if u, ok := pb.(newUnmarshaler); ok { | ||
354 | return u.XXX_Unmarshal(buf) | ||
355 | } | ||
356 | if u, ok := pb.(Unmarshaler); ok { | ||
357 | // NOTE: The history of proto have unfortunately been inconsistent | ||
358 | // whether Unmarshaler should or should not implicitly clear itself. | ||
359 | // Some implementations do, most do not. | ||
360 | // Thus, calling this here may or may not do what people want. | ||
361 | // | ||
362 | // See https://github.com/golang/protobuf/issues/424 | ||
363 | return u.Unmarshal(buf) | ||
364 | } | ||
365 | return NewBuffer(buf).Unmarshal(pb) | ||
366 | } | ||
367 | |||
368 | // DecodeMessage reads a count-delimited message from the Buffer. | ||
369 | func (p *Buffer) DecodeMessage(pb Message) error { | ||
370 | enc, err := p.DecodeRawBytes(false) | ||
371 | if err != nil { | ||
372 | return err | ||
373 | } | ||
374 | return NewBuffer(enc).Unmarshal(pb) | ||
375 | } | ||
376 | |||
377 | // DecodeGroup reads a tag-delimited group from the Buffer. | ||
378 | // StartGroup tag is already consumed. This function consumes | ||
379 | // EndGroup tag. | ||
380 | func (p *Buffer) DecodeGroup(pb Message) error { | ||
381 | b := p.buf[p.index:] | ||
382 | x, y := findEndGroup(b) | ||
383 | if x < 0 { | ||
384 | return io.ErrUnexpectedEOF | ||
385 | } | ||
386 | err := Unmarshal(b[:x], pb) | ||
387 | p.index += y | ||
388 | return err | ||
389 | } | ||
390 | |||
391 | // Unmarshal parses the protocol buffer representation in the | ||
392 | // Buffer and places the decoded result in pb. If the struct | ||
393 | // underlying pb does not match the data in the buffer, the results can be | ||
394 | // unpredictable. | ||
395 | // | ||
396 | // Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal. | ||
397 | func (p *Buffer) Unmarshal(pb Message) error { | ||
398 | // If the object can unmarshal itself, let it. | ||
399 | if u, ok := pb.(newUnmarshaler); ok { | ||
400 | err := u.XXX_Unmarshal(p.buf[p.index:]) | ||
401 | p.index = len(p.buf) | ||
402 | return err | ||
403 | } | ||
404 | if u, ok := pb.(Unmarshaler); ok { | ||
405 | // NOTE: The history of proto have unfortunately been inconsistent | ||
406 | // whether Unmarshaler should or should not implicitly clear itself. | ||
407 | // Some implementations do, most do not. | ||
408 | // Thus, calling this here may or may not do what people want. | ||
409 | // | ||
410 | // See https://github.com/golang/protobuf/issues/424 | ||
411 | err := u.Unmarshal(p.buf[p.index:]) | ||
412 | p.index = len(p.buf) | ||
413 | return err | ||
414 | } | ||
415 | |||
416 | // Slow workaround for messages that aren't Unmarshalers. | ||
417 | // This includes some hand-coded .pb.go files and | ||
418 | // bootstrap protos. | ||
419 | // TODO: fix all of those and then add Unmarshal to | ||
420 | // the Message interface. Then: | ||
421 | // The cast above and code below can be deleted. | ||
422 | // The old unmarshaler can be deleted. | ||
423 | // Clients can call Unmarshal directly (can already do that, actually). | ||
424 | var info InternalMessageInfo | ||
425 | err := info.Unmarshal(pb, p.buf[p.index:]) | ||
426 | p.index = len(p.buf) | ||
427 | return err | ||
428 | } | ||