blob: bb2622f28c399993a934b851781ecd07bdbb4db5 [file] [log] [blame]
Scott Bakere7144bc2019-10-01 14:16:47 -07001// Go support for Protocol Buffers - Google's data interchange format
2//
3// Copyright 2016 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
32package proto
33
34import (
35 "errors"
36 "fmt"
37 "io"
38 "math"
39 "reflect"
40 "strconv"
41 "strings"
42 "sync"
43 "sync/atomic"
44 "unicode/utf8"
45)
46
47// Unmarshal is the entry point from the generated .pb.go files.
48// This function is not intended to be used by non-generated code.
49// This function is not subject to any compatibility guarantee.
50// msg contains a pointer to a protocol buffer struct.
51// b is the data to be unmarshaled into the protocol buffer.
52// a is a pointer to a place to store cached unmarshal information.
53func (a *InternalMessageInfo) Unmarshal(msg Message, b []byte) error {
54 // Load the unmarshal information for this message type.
55 // The atomic load ensures memory consistency.
56 u := atomicLoadUnmarshalInfo(&a.unmarshal)
57 if u == nil {
58 // Slow path: find unmarshal info for msg, update a with it.
59 u = getUnmarshalInfo(reflect.TypeOf(msg).Elem())
60 atomicStoreUnmarshalInfo(&a.unmarshal, u)
61 }
62 // Then do the unmarshaling.
63 err := u.unmarshal(toPointer(&msg), b)
64 return err
65}
66
67type unmarshalInfo struct {
68 typ reflect.Type // type of the protobuf struct
69
70 // 0 = only typ field is initialized
71 // 1 = completely initialized
72 initialized int32
73 lock sync.Mutex // prevents double initialization
74 dense []unmarshalFieldInfo // fields indexed by tag #
75 sparse map[uint64]unmarshalFieldInfo // fields indexed by tag #
76 reqFields []string // names of required fields
77 reqMask uint64 // 1<<len(reqFields)-1
78 unrecognized field // offset of []byte to put unrecognized data (or invalidField if we should throw it away)
79 extensions field // offset of extensions field (of type proto.XXX_InternalExtensions), or invalidField if it does not exist
80 oldExtensions field // offset of old-form extensions field (of type map[int]Extension)
81 extensionRanges []ExtensionRange // if non-nil, implies extensions field is valid
82 isMessageSet bool // if true, implies extensions field is valid
83
84 bytesExtensions field // offset of XXX_extensions with type []byte
85}
86
87// An unmarshaler takes a stream of bytes and a pointer to a field of a message.
88// It decodes the field, stores it at f, and returns the unused bytes.
89// w is the wire encoding.
90// b is the data after the tag and wire encoding have been read.
91type unmarshaler func(b []byte, f pointer, w int) ([]byte, error)
92
93type unmarshalFieldInfo struct {
94 // location of the field in the proto message structure.
95 field field
96
97 // function to unmarshal the data for the field.
98 unmarshal unmarshaler
99
100 // if a required field, contains a single set bit at this field's index in the required field list.
101 reqMask uint64
102
103 name string // name of the field, for error reporting
104}
105
106var (
107 unmarshalInfoMap = map[reflect.Type]*unmarshalInfo{}
108 unmarshalInfoLock sync.Mutex
109)
110
111// getUnmarshalInfo returns the data structure which can be
112// subsequently used to unmarshal a message of the given type.
113// t is the type of the message (note: not pointer to message).
114func getUnmarshalInfo(t reflect.Type) *unmarshalInfo {
115 // It would be correct to return a new unmarshalInfo
116 // unconditionally. We would end up allocating one
117 // per occurrence of that type as a message or submessage.
118 // We use a cache here just to reduce memory usage.
119 unmarshalInfoLock.Lock()
120 defer unmarshalInfoLock.Unlock()
121 u := unmarshalInfoMap[t]
122 if u == nil {
123 u = &unmarshalInfo{typ: t}
124 // Note: we just set the type here. The rest of the fields
125 // will be initialized on first use.
126 unmarshalInfoMap[t] = u
127 }
128 return u
129}
130
131// unmarshal does the main work of unmarshaling a message.
132// u provides type information used to unmarshal the message.
133// m is a pointer to a protocol buffer message.
134// b is a byte stream to unmarshal into m.
135// This is top routine used when recursively unmarshaling submessages.
136func (u *unmarshalInfo) unmarshal(m pointer, b []byte) error {
137 if atomic.LoadInt32(&u.initialized) == 0 {
138 u.computeUnmarshalInfo()
139 }
140 if u.isMessageSet {
141 return unmarshalMessageSet(b, m.offset(u.extensions).toExtensions())
142 }
143 var reqMask uint64 // bitmask of required fields we've seen.
144 var errLater error
145 for len(b) > 0 {
146 // Read tag and wire type.
147 // Special case 1 and 2 byte varints.
148 var x uint64
149 if b[0] < 128 {
150 x = uint64(b[0])
151 b = b[1:]
152 } else if len(b) >= 2 && b[1] < 128 {
153 x = uint64(b[0]&0x7f) + uint64(b[1])<<7
154 b = b[2:]
155 } else {
156 var n int
157 x, n = decodeVarint(b)
158 if n == 0 {
159 return io.ErrUnexpectedEOF
160 }
161 b = b[n:]
162 }
163 tag := x >> 3
164 wire := int(x) & 7
165
166 // Dispatch on the tag to one of the unmarshal* functions below.
167 var f unmarshalFieldInfo
168 if tag < uint64(len(u.dense)) {
169 f = u.dense[tag]
170 } else {
171 f = u.sparse[tag]
172 }
173 if fn := f.unmarshal; fn != nil {
174 var err error
175 b, err = fn(b, m.offset(f.field), wire)
176 if err == nil {
177 reqMask |= f.reqMask
178 continue
179 }
180 if r, ok := err.(*RequiredNotSetError); ok {
181 // Remember this error, but keep parsing. We need to produce
182 // a full parse even if a required field is missing.
183 if errLater == nil {
184 errLater = r
185 }
186 reqMask |= f.reqMask
187 continue
188 }
189 if err != errInternalBadWireType {
190 if err == errInvalidUTF8 {
191 if errLater == nil {
192 fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name
193 errLater = &invalidUTF8Error{fullName}
194 }
195 continue
196 }
197 return err
198 }
199 // Fragments with bad wire type are treated as unknown fields.
200 }
201
202 // Unknown tag.
203 if !u.unrecognized.IsValid() {
204 // Don't keep unrecognized data; just skip it.
205 var err error
206 b, err = skipField(b, wire)
207 if err != nil {
208 return err
209 }
210 continue
211 }
212 // Keep unrecognized data around.
213 // maybe in extensions, maybe in the unrecognized field.
214 z := m.offset(u.unrecognized).toBytes()
215 var emap map[int32]Extension
216 var e Extension
217 for _, r := range u.extensionRanges {
218 if uint64(r.Start) <= tag && tag <= uint64(r.End) {
219 if u.extensions.IsValid() {
220 mp := m.offset(u.extensions).toExtensions()
221 emap = mp.extensionsWrite()
222 e = emap[int32(tag)]
223 z = &e.enc
224 break
225 }
226 if u.oldExtensions.IsValid() {
227 p := m.offset(u.oldExtensions).toOldExtensions()
228 emap = *p
229 if emap == nil {
230 emap = map[int32]Extension{}
231 *p = emap
232 }
233 e = emap[int32(tag)]
234 z = &e.enc
235 break
236 }
237 if u.bytesExtensions.IsValid() {
238 z = m.offset(u.bytesExtensions).toBytes()
239 break
240 }
241 panic("no extensions field available")
242 }
243 }
244 // Use wire type to skip data.
245 var err error
246 b0 := b
247 b, err = skipField(b, wire)
248 if err != nil {
249 return err
250 }
251 *z = encodeVarint(*z, tag<<3|uint64(wire))
252 *z = append(*z, b0[:len(b0)-len(b)]...)
253
254 if emap != nil {
255 emap[int32(tag)] = e
256 }
257 }
258 if reqMask != u.reqMask && errLater == nil {
259 // A required field of this message is missing.
260 for _, n := range u.reqFields {
261 if reqMask&1 == 0 {
262 errLater = &RequiredNotSetError{n}
263 }
264 reqMask >>= 1
265 }
266 }
267 return errLater
268}
269
270// computeUnmarshalInfo fills in u with information for use
271// in unmarshaling protocol buffers of type u.typ.
272func (u *unmarshalInfo) computeUnmarshalInfo() {
273 u.lock.Lock()
274 defer u.lock.Unlock()
275 if u.initialized != 0 {
276 return
277 }
278 t := u.typ
279 n := t.NumField()
280
281 // Set up the "not found" value for the unrecognized byte buffer.
282 // This is the default for proto3.
283 u.unrecognized = invalidField
284 u.extensions = invalidField
285 u.oldExtensions = invalidField
286 u.bytesExtensions = invalidField
287
288 // List of the generated type and offset for each oneof field.
289 type oneofField struct {
290 ityp reflect.Type // interface type of oneof field
291 field field // offset in containing message
292 }
293 var oneofFields []oneofField
294
295 for i := 0; i < n; i++ {
296 f := t.Field(i)
297 if f.Name == "XXX_unrecognized" {
298 // The byte slice used to hold unrecognized input is special.
299 if f.Type != reflect.TypeOf(([]byte)(nil)) {
300 panic("bad type for XXX_unrecognized field: " + f.Type.Name())
301 }
302 u.unrecognized = toField(&f)
303 continue
304 }
305 if f.Name == "XXX_InternalExtensions" {
306 // Ditto here.
307 if f.Type != reflect.TypeOf(XXX_InternalExtensions{}) {
308 panic("bad type for XXX_InternalExtensions field: " + f.Type.Name())
309 }
310 u.extensions = toField(&f)
311 if f.Tag.Get("protobuf_messageset") == "1" {
312 u.isMessageSet = true
313 }
314 continue
315 }
316 if f.Name == "XXX_extensions" {
317 // An older form of the extensions field.
318 if f.Type == reflect.TypeOf((map[int32]Extension)(nil)) {
319 u.oldExtensions = toField(&f)
320 continue
321 } else if f.Type == reflect.TypeOf(([]byte)(nil)) {
322 u.bytesExtensions = toField(&f)
323 continue
324 }
325 panic("bad type for XXX_extensions field: " + f.Type.Name())
326 }
327 if f.Name == "XXX_NoUnkeyedLiteral" || f.Name == "XXX_sizecache" {
328 continue
329 }
330
331 oneof := f.Tag.Get("protobuf_oneof")
332 if oneof != "" {
333 oneofFields = append(oneofFields, oneofField{f.Type, toField(&f)})
334 // The rest of oneof processing happens below.
335 continue
336 }
337
338 tags := f.Tag.Get("protobuf")
339 tagArray := strings.Split(tags, ",")
340 if len(tagArray) < 2 {
341 panic("protobuf tag not enough fields in " + t.Name() + "." + f.Name + ": " + tags)
342 }
343 tag, err := strconv.Atoi(tagArray[1])
344 if err != nil {
345 panic("protobuf tag field not an integer: " + tagArray[1])
346 }
347
348 name := ""
349 for _, tag := range tagArray[3:] {
350 if strings.HasPrefix(tag, "name=") {
351 name = tag[5:]
352 }
353 }
354
355 // Extract unmarshaling function from the field (its type and tags).
356 unmarshal := fieldUnmarshaler(&f)
357
358 // Required field?
359 var reqMask uint64
360 if tagArray[2] == "req" {
361 bit := len(u.reqFields)
362 u.reqFields = append(u.reqFields, name)
363 reqMask = uint64(1) << uint(bit)
364 // TODO: if we have more than 64 required fields, we end up
365 // not verifying that all required fields are present.
366 // Fix this, perhaps using a count of required fields?
367 }
368
369 // Store the info in the correct slot in the message.
370 u.setTag(tag, toField(&f), unmarshal, reqMask, name)
371 }
372
373 // Find any types associated with oneof fields.
374 // TODO: XXX_OneofFuncs returns more info than we need. Get rid of some of it?
375 fn := reflect.Zero(reflect.PtrTo(t)).MethodByName("XXX_OneofFuncs")
376 // gogo: len(oneofFields) > 0 is needed for embedded oneof messages, without a marshaler and unmarshaler
377 if fn.IsValid() && len(oneofFields) > 0 {
378 res := fn.Call(nil)[3] // last return value from XXX_OneofFuncs: []interface{}
379 for i := res.Len() - 1; i >= 0; i-- {
380 v := res.Index(i) // interface{}
381 tptr := reflect.ValueOf(v.Interface()).Type() // *Msg_X
382 typ := tptr.Elem() // Msg_X
383
384 f := typ.Field(0) // oneof implementers have one field
385 baseUnmarshal := fieldUnmarshaler(&f)
386 tags := strings.Split(f.Tag.Get("protobuf"), ",")
387 fieldNum, err := strconv.Atoi(tags[1])
388 if err != nil {
389 panic("protobuf tag field not an integer: " + tags[1])
390 }
391 var name string
392 for _, tag := range tags {
393 if strings.HasPrefix(tag, "name=") {
394 name = strings.TrimPrefix(tag, "name=")
395 break
396 }
397 }
398
399 // Find the oneof field that this struct implements.
400 // Might take O(n^2) to process all of the oneofs, but who cares.
401 for _, of := range oneofFields {
402 if tptr.Implements(of.ityp) {
403 // We have found the corresponding interface for this struct.
404 // That lets us know where this struct should be stored
405 // when we encounter it during unmarshaling.
406 unmarshal := makeUnmarshalOneof(typ, of.ityp, baseUnmarshal)
407 u.setTag(fieldNum, of.field, unmarshal, 0, name)
408 }
409 }
410 }
411 }
412
413 // Get extension ranges, if any.
414 fn = reflect.Zero(reflect.PtrTo(t)).MethodByName("ExtensionRangeArray")
415 if fn.IsValid() {
416 if !u.extensions.IsValid() && !u.oldExtensions.IsValid() && !u.bytesExtensions.IsValid() {
417 panic("a message with extensions, but no extensions field in " + t.Name())
418 }
419 u.extensionRanges = fn.Call(nil)[0].Interface().([]ExtensionRange)
420 }
421
422 // Explicitly disallow tag 0. This will ensure we flag an error
423 // when decoding a buffer of all zeros. Without this code, we
424 // would decode and skip an all-zero buffer of even length.
425 // [0 0] is [tag=0/wiretype=varint varint-encoded-0].
426 u.setTag(0, zeroField, func(b []byte, f pointer, w int) ([]byte, error) {
427 return nil, fmt.Errorf("proto: %s: illegal tag 0 (wire type %d)", t, w)
428 }, 0, "")
429
430 // Set mask for required field check.
431 u.reqMask = uint64(1)<<uint(len(u.reqFields)) - 1
432
433 atomic.StoreInt32(&u.initialized, 1)
434}
435
436// setTag stores the unmarshal information for the given tag.
437// tag = tag # for field
438// field/unmarshal = unmarshal info for that field.
439// reqMask = if required, bitmask for field position in required field list. 0 otherwise.
440// name = short name of the field.
441func (u *unmarshalInfo) setTag(tag int, field field, unmarshal unmarshaler, reqMask uint64, name string) {
442 i := unmarshalFieldInfo{field: field, unmarshal: unmarshal, reqMask: reqMask, name: name}
443 n := u.typ.NumField()
444 if tag >= 0 && (tag < 16 || tag < 2*n) { // TODO: what are the right numbers here?
445 for len(u.dense) <= tag {
446 u.dense = append(u.dense, unmarshalFieldInfo{})
447 }
448 u.dense[tag] = i
449 return
450 }
451 if u.sparse == nil {
452 u.sparse = map[uint64]unmarshalFieldInfo{}
453 }
454 u.sparse[uint64(tag)] = i
455}
456
457// fieldUnmarshaler returns an unmarshaler for the given field.
458func fieldUnmarshaler(f *reflect.StructField) unmarshaler {
459 if f.Type.Kind() == reflect.Map {
460 return makeUnmarshalMap(f)
461 }
462 return typeUnmarshaler(f.Type, f.Tag.Get("protobuf"))
463}
464
465// typeUnmarshaler returns an unmarshaler for the given field type / field tag pair.
466func typeUnmarshaler(t reflect.Type, tags string) unmarshaler {
467 tagArray := strings.Split(tags, ",")
468 encoding := tagArray[0]
469 name := "unknown"
470 ctype := false
471 isTime := false
472 isDuration := false
473 isWktPointer := false
474 proto3 := false
475 validateUTF8 := true
476 for _, tag := range tagArray[3:] {
477 if strings.HasPrefix(tag, "name=") {
478 name = tag[5:]
479 }
480 if tag == "proto3" {
481 proto3 = true
482 }
483 if strings.HasPrefix(tag, "customtype=") {
484 ctype = true
485 }
486 if tag == "stdtime" {
487 isTime = true
488 }
489 if tag == "stdduration" {
490 isDuration = true
491 }
492 if tag == "wktptr" {
493 isWktPointer = true
494 }
495 }
496 validateUTF8 = validateUTF8 && proto3
497
498 // Figure out packaging (pointer, slice, or both)
499 slice := false
500 pointer := false
501 if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
502 slice = true
503 t = t.Elem()
504 }
505 if t.Kind() == reflect.Ptr {
506 pointer = true
507 t = t.Elem()
508 }
509
510 if ctype {
511 if reflect.PtrTo(t).Implements(customType) {
512 if slice {
513 return makeUnmarshalCustomSlice(getUnmarshalInfo(t), name)
514 }
515 if pointer {
516 return makeUnmarshalCustomPtr(getUnmarshalInfo(t), name)
517 }
518 return makeUnmarshalCustom(getUnmarshalInfo(t), name)
519 } else {
520 panic(fmt.Sprintf("custom type: type: %v, does not implement the proto.custom interface", t))
521 }
522 }
523
524 if isTime {
525 if pointer {
526 if slice {
527 return makeUnmarshalTimePtrSlice(getUnmarshalInfo(t), name)
528 }
529 return makeUnmarshalTimePtr(getUnmarshalInfo(t), name)
530 }
531 if slice {
532 return makeUnmarshalTimeSlice(getUnmarshalInfo(t), name)
533 }
534 return makeUnmarshalTime(getUnmarshalInfo(t), name)
535 }
536
537 if isDuration {
538 if pointer {
539 if slice {
540 return makeUnmarshalDurationPtrSlice(getUnmarshalInfo(t), name)
541 }
542 return makeUnmarshalDurationPtr(getUnmarshalInfo(t), name)
543 }
544 if slice {
545 return makeUnmarshalDurationSlice(getUnmarshalInfo(t), name)
546 }
547 return makeUnmarshalDuration(getUnmarshalInfo(t), name)
548 }
549
550 if isWktPointer {
551 switch t.Kind() {
552 case reflect.Float64:
553 if pointer {
554 if slice {
555 return makeStdDoubleValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
556 }
557 return makeStdDoubleValuePtrUnmarshaler(getUnmarshalInfo(t), name)
558 }
559 if slice {
560 return makeStdDoubleValueSliceUnmarshaler(getUnmarshalInfo(t), name)
561 }
562 return makeStdDoubleValueUnmarshaler(getUnmarshalInfo(t), name)
563 case reflect.Float32:
564 if pointer {
565 if slice {
566 return makeStdFloatValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
567 }
568 return makeStdFloatValuePtrUnmarshaler(getUnmarshalInfo(t), name)
569 }
570 if slice {
571 return makeStdFloatValueSliceUnmarshaler(getUnmarshalInfo(t), name)
572 }
573 return makeStdFloatValueUnmarshaler(getUnmarshalInfo(t), name)
574 case reflect.Int64:
575 if pointer {
576 if slice {
577 return makeStdInt64ValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
578 }
579 return makeStdInt64ValuePtrUnmarshaler(getUnmarshalInfo(t), name)
580 }
581 if slice {
582 return makeStdInt64ValueSliceUnmarshaler(getUnmarshalInfo(t), name)
583 }
584 return makeStdInt64ValueUnmarshaler(getUnmarshalInfo(t), name)
585 case reflect.Uint64:
586 if pointer {
587 if slice {
588 return makeStdUInt64ValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
589 }
590 return makeStdUInt64ValuePtrUnmarshaler(getUnmarshalInfo(t), name)
591 }
592 if slice {
593 return makeStdUInt64ValueSliceUnmarshaler(getUnmarshalInfo(t), name)
594 }
595 return makeStdUInt64ValueUnmarshaler(getUnmarshalInfo(t), name)
596 case reflect.Int32:
597 if pointer {
598 if slice {
599 return makeStdInt32ValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
600 }
601 return makeStdInt32ValuePtrUnmarshaler(getUnmarshalInfo(t), name)
602 }
603 if slice {
604 return makeStdInt32ValueSliceUnmarshaler(getUnmarshalInfo(t), name)
605 }
606 return makeStdInt32ValueUnmarshaler(getUnmarshalInfo(t), name)
607 case reflect.Uint32:
608 if pointer {
609 if slice {
610 return makeStdUInt32ValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
611 }
612 return makeStdUInt32ValuePtrUnmarshaler(getUnmarshalInfo(t), name)
613 }
614 if slice {
615 return makeStdUInt32ValueSliceUnmarshaler(getUnmarshalInfo(t), name)
616 }
617 return makeStdUInt32ValueUnmarshaler(getUnmarshalInfo(t), name)
618 case reflect.Bool:
619 if pointer {
620 if slice {
621 return makeStdBoolValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
622 }
623 return makeStdBoolValuePtrUnmarshaler(getUnmarshalInfo(t), name)
624 }
625 if slice {
626 return makeStdBoolValueSliceUnmarshaler(getUnmarshalInfo(t), name)
627 }
628 return makeStdBoolValueUnmarshaler(getUnmarshalInfo(t), name)
629 case reflect.String:
630 if pointer {
631 if slice {
632 return makeStdStringValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
633 }
634 return makeStdStringValuePtrUnmarshaler(getUnmarshalInfo(t), name)
635 }
636 if slice {
637 return makeStdStringValueSliceUnmarshaler(getUnmarshalInfo(t), name)
638 }
639 return makeStdStringValueUnmarshaler(getUnmarshalInfo(t), name)
640 case uint8SliceType:
641 if pointer {
642 if slice {
643 return makeStdBytesValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
644 }
645 return makeStdBytesValuePtrUnmarshaler(getUnmarshalInfo(t), name)
646 }
647 if slice {
648 return makeStdBytesValueSliceUnmarshaler(getUnmarshalInfo(t), name)
649 }
650 return makeStdBytesValueUnmarshaler(getUnmarshalInfo(t), name)
651 default:
652 panic(fmt.Sprintf("unknown wktpointer type %#v", t))
653 }
654 }
655
656 // We'll never have both pointer and slice for basic types.
657 if pointer && slice && t.Kind() != reflect.Struct {
658 panic("both pointer and slice for basic type in " + t.Name())
659 }
660
661 switch t.Kind() {
662 case reflect.Bool:
663 if pointer {
664 return unmarshalBoolPtr
665 }
666 if slice {
667 return unmarshalBoolSlice
668 }
669 return unmarshalBoolValue
670 case reflect.Int32:
671 switch encoding {
672 case "fixed32":
673 if pointer {
674 return unmarshalFixedS32Ptr
675 }
676 if slice {
677 return unmarshalFixedS32Slice
678 }
679 return unmarshalFixedS32Value
680 case "varint":
681 // this could be int32 or enum
682 if pointer {
683 return unmarshalInt32Ptr
684 }
685 if slice {
686 return unmarshalInt32Slice
687 }
688 return unmarshalInt32Value
689 case "zigzag32":
690 if pointer {
691 return unmarshalSint32Ptr
692 }
693 if slice {
694 return unmarshalSint32Slice
695 }
696 return unmarshalSint32Value
697 }
698 case reflect.Int64:
699 switch encoding {
700 case "fixed64":
701 if pointer {
702 return unmarshalFixedS64Ptr
703 }
704 if slice {
705 return unmarshalFixedS64Slice
706 }
707 return unmarshalFixedS64Value
708 case "varint":
709 if pointer {
710 return unmarshalInt64Ptr
711 }
712 if slice {
713 return unmarshalInt64Slice
714 }
715 return unmarshalInt64Value
716 case "zigzag64":
717 if pointer {
718 return unmarshalSint64Ptr
719 }
720 if slice {
721 return unmarshalSint64Slice
722 }
723 return unmarshalSint64Value
724 }
725 case reflect.Uint32:
726 switch encoding {
727 case "fixed32":
728 if pointer {
729 return unmarshalFixed32Ptr
730 }
731 if slice {
732 return unmarshalFixed32Slice
733 }
734 return unmarshalFixed32Value
735 case "varint":
736 if pointer {
737 return unmarshalUint32Ptr
738 }
739 if slice {
740 return unmarshalUint32Slice
741 }
742 return unmarshalUint32Value
743 }
744 case reflect.Uint64:
745 switch encoding {
746 case "fixed64":
747 if pointer {
748 return unmarshalFixed64Ptr
749 }
750 if slice {
751 return unmarshalFixed64Slice
752 }
753 return unmarshalFixed64Value
754 case "varint":
755 if pointer {
756 return unmarshalUint64Ptr
757 }
758 if slice {
759 return unmarshalUint64Slice
760 }
761 return unmarshalUint64Value
762 }
763 case reflect.Float32:
764 if pointer {
765 return unmarshalFloat32Ptr
766 }
767 if slice {
768 return unmarshalFloat32Slice
769 }
770 return unmarshalFloat32Value
771 case reflect.Float64:
772 if pointer {
773 return unmarshalFloat64Ptr
774 }
775 if slice {
776 return unmarshalFloat64Slice
777 }
778 return unmarshalFloat64Value
779 case reflect.Map:
780 panic("map type in typeUnmarshaler in " + t.Name())
781 case reflect.Slice:
782 if pointer {
783 panic("bad pointer in slice case in " + t.Name())
784 }
785 if slice {
786 return unmarshalBytesSlice
787 }
788 return unmarshalBytesValue
789 case reflect.String:
790 if validateUTF8 {
791 if pointer {
792 return unmarshalUTF8StringPtr
793 }
794 if slice {
795 return unmarshalUTF8StringSlice
796 }
797 return unmarshalUTF8StringValue
798 }
799 if pointer {
800 return unmarshalStringPtr
801 }
802 if slice {
803 return unmarshalStringSlice
804 }
805 return unmarshalStringValue
806 case reflect.Struct:
807 // message or group field
808 if !pointer {
809 switch encoding {
810 case "bytes":
811 if slice {
812 return makeUnmarshalMessageSlice(getUnmarshalInfo(t), name)
813 }
814 return makeUnmarshalMessage(getUnmarshalInfo(t), name)
815 }
816 }
817 switch encoding {
818 case "bytes":
819 if slice {
820 return makeUnmarshalMessageSlicePtr(getUnmarshalInfo(t), name)
821 }
822 return makeUnmarshalMessagePtr(getUnmarshalInfo(t), name)
823 case "group":
824 if slice {
825 return makeUnmarshalGroupSlicePtr(getUnmarshalInfo(t), name)
826 }
827 return makeUnmarshalGroupPtr(getUnmarshalInfo(t), name)
828 }
829 }
830 panic(fmt.Sprintf("unmarshaler not found type:%s encoding:%s", t, encoding))
831}
832
833// Below are all the unmarshalers for individual fields of various types.
834
835func unmarshalInt64Value(b []byte, f pointer, w int) ([]byte, error) {
836 if w != WireVarint {
837 return b, errInternalBadWireType
838 }
839 x, n := decodeVarint(b)
840 if n == 0 {
841 return nil, io.ErrUnexpectedEOF
842 }
843 b = b[n:]
844 v := int64(x)
845 *f.toInt64() = v
846 return b, nil
847}
848
849func unmarshalInt64Ptr(b []byte, f pointer, w int) ([]byte, error) {
850 if w != WireVarint {
851 return b, errInternalBadWireType
852 }
853 x, n := decodeVarint(b)
854 if n == 0 {
855 return nil, io.ErrUnexpectedEOF
856 }
857 b = b[n:]
858 v := int64(x)
859 *f.toInt64Ptr() = &v
860 return b, nil
861}
862
863func unmarshalInt64Slice(b []byte, f pointer, w int) ([]byte, error) {
864 if w == WireBytes { // packed
865 x, n := decodeVarint(b)
866 if n == 0 {
867 return nil, io.ErrUnexpectedEOF
868 }
869 b = b[n:]
870 if x > uint64(len(b)) {
871 return nil, io.ErrUnexpectedEOF
872 }
873 res := b[x:]
874 b = b[:x]
875 for len(b) > 0 {
876 x, n = decodeVarint(b)
877 if n == 0 {
878 return nil, io.ErrUnexpectedEOF
879 }
880 b = b[n:]
881 v := int64(x)
882 s := f.toInt64Slice()
883 *s = append(*s, v)
884 }
885 return res, nil
886 }
887 if w != WireVarint {
888 return b, errInternalBadWireType
889 }
890 x, n := decodeVarint(b)
891 if n == 0 {
892 return nil, io.ErrUnexpectedEOF
893 }
894 b = b[n:]
895 v := int64(x)
896 s := f.toInt64Slice()
897 *s = append(*s, v)
898 return b, nil
899}
900
901func unmarshalSint64Value(b []byte, f pointer, w int) ([]byte, error) {
902 if w != WireVarint {
903 return b, errInternalBadWireType
904 }
905 x, n := decodeVarint(b)
906 if n == 0 {
907 return nil, io.ErrUnexpectedEOF
908 }
909 b = b[n:]
910 v := int64(x>>1) ^ int64(x)<<63>>63
911 *f.toInt64() = v
912 return b, nil
913}
914
915func unmarshalSint64Ptr(b []byte, f pointer, w int) ([]byte, error) {
916 if w != WireVarint {
917 return b, errInternalBadWireType
918 }
919 x, n := decodeVarint(b)
920 if n == 0 {
921 return nil, io.ErrUnexpectedEOF
922 }
923 b = b[n:]
924 v := int64(x>>1) ^ int64(x)<<63>>63
925 *f.toInt64Ptr() = &v
926 return b, nil
927}
928
929func unmarshalSint64Slice(b []byte, f pointer, w int) ([]byte, error) {
930 if w == WireBytes { // packed
931 x, n := decodeVarint(b)
932 if n == 0 {
933 return nil, io.ErrUnexpectedEOF
934 }
935 b = b[n:]
936 if x > uint64(len(b)) {
937 return nil, io.ErrUnexpectedEOF
938 }
939 res := b[x:]
940 b = b[:x]
941 for len(b) > 0 {
942 x, n = decodeVarint(b)
943 if n == 0 {
944 return nil, io.ErrUnexpectedEOF
945 }
946 b = b[n:]
947 v := int64(x>>1) ^ int64(x)<<63>>63
948 s := f.toInt64Slice()
949 *s = append(*s, v)
950 }
951 return res, nil
952 }
953 if w != WireVarint {
954 return b, errInternalBadWireType
955 }
956 x, n := decodeVarint(b)
957 if n == 0 {
958 return nil, io.ErrUnexpectedEOF
959 }
960 b = b[n:]
961 v := int64(x>>1) ^ int64(x)<<63>>63
962 s := f.toInt64Slice()
963 *s = append(*s, v)
964 return b, nil
965}
966
967func unmarshalUint64Value(b []byte, f pointer, w int) ([]byte, error) {
968 if w != WireVarint {
969 return b, errInternalBadWireType
970 }
971 x, n := decodeVarint(b)
972 if n == 0 {
973 return nil, io.ErrUnexpectedEOF
974 }
975 b = b[n:]
976 v := uint64(x)
977 *f.toUint64() = v
978 return b, nil
979}
980
981func unmarshalUint64Ptr(b []byte, f pointer, w int) ([]byte, error) {
982 if w != WireVarint {
983 return b, errInternalBadWireType
984 }
985 x, n := decodeVarint(b)
986 if n == 0 {
987 return nil, io.ErrUnexpectedEOF
988 }
989 b = b[n:]
990 v := uint64(x)
991 *f.toUint64Ptr() = &v
992 return b, nil
993}
994
995func unmarshalUint64Slice(b []byte, f pointer, w int) ([]byte, error) {
996 if w == WireBytes { // packed
997 x, n := decodeVarint(b)
998 if n == 0 {
999 return nil, io.ErrUnexpectedEOF
1000 }
1001 b = b[n:]
1002 if x > uint64(len(b)) {
1003 return nil, io.ErrUnexpectedEOF
1004 }
1005 res := b[x:]
1006 b = b[:x]
1007 for len(b) > 0 {
1008 x, n = decodeVarint(b)
1009 if n == 0 {
1010 return nil, io.ErrUnexpectedEOF
1011 }
1012 b = b[n:]
1013 v := uint64(x)
1014 s := f.toUint64Slice()
1015 *s = append(*s, v)
1016 }
1017 return res, nil
1018 }
1019 if w != WireVarint {
1020 return b, errInternalBadWireType
1021 }
1022 x, n := decodeVarint(b)
1023 if n == 0 {
1024 return nil, io.ErrUnexpectedEOF
1025 }
1026 b = b[n:]
1027 v := uint64(x)
1028 s := f.toUint64Slice()
1029 *s = append(*s, v)
1030 return b, nil
1031}
1032
1033func unmarshalInt32Value(b []byte, f pointer, w int) ([]byte, error) {
1034 if w != WireVarint {
1035 return b, errInternalBadWireType
1036 }
1037 x, n := decodeVarint(b)
1038 if n == 0 {
1039 return nil, io.ErrUnexpectedEOF
1040 }
1041 b = b[n:]
1042 v := int32(x)
1043 *f.toInt32() = v
1044 return b, nil
1045}
1046
1047func unmarshalInt32Ptr(b []byte, f pointer, w int) ([]byte, error) {
1048 if w != WireVarint {
1049 return b, errInternalBadWireType
1050 }
1051 x, n := decodeVarint(b)
1052 if n == 0 {
1053 return nil, io.ErrUnexpectedEOF
1054 }
1055 b = b[n:]
1056 v := int32(x)
1057 f.setInt32Ptr(v)
1058 return b, nil
1059}
1060
1061func unmarshalInt32Slice(b []byte, f pointer, w int) ([]byte, error) {
1062 if w == WireBytes { // packed
1063 x, n := decodeVarint(b)
1064 if n == 0 {
1065 return nil, io.ErrUnexpectedEOF
1066 }
1067 b = b[n:]
1068 if x > uint64(len(b)) {
1069 return nil, io.ErrUnexpectedEOF
1070 }
1071 res := b[x:]
1072 b = b[:x]
1073 for len(b) > 0 {
1074 x, n = decodeVarint(b)
1075 if n == 0 {
1076 return nil, io.ErrUnexpectedEOF
1077 }
1078 b = b[n:]
1079 v := int32(x)
1080 f.appendInt32Slice(v)
1081 }
1082 return res, nil
1083 }
1084 if w != WireVarint {
1085 return b, errInternalBadWireType
1086 }
1087 x, n := decodeVarint(b)
1088 if n == 0 {
1089 return nil, io.ErrUnexpectedEOF
1090 }
1091 b = b[n:]
1092 v := int32(x)
1093 f.appendInt32Slice(v)
1094 return b, nil
1095}
1096
1097func unmarshalSint32Value(b []byte, f pointer, w int) ([]byte, error) {
1098 if w != WireVarint {
1099 return b, errInternalBadWireType
1100 }
1101 x, n := decodeVarint(b)
1102 if n == 0 {
1103 return nil, io.ErrUnexpectedEOF
1104 }
1105 b = b[n:]
1106 v := int32(x>>1) ^ int32(x)<<31>>31
1107 *f.toInt32() = v
1108 return b, nil
1109}
1110
1111func unmarshalSint32Ptr(b []byte, f pointer, w int) ([]byte, error) {
1112 if w != WireVarint {
1113 return b, errInternalBadWireType
1114 }
1115 x, n := decodeVarint(b)
1116 if n == 0 {
1117 return nil, io.ErrUnexpectedEOF
1118 }
1119 b = b[n:]
1120 v := int32(x>>1) ^ int32(x)<<31>>31
1121 f.setInt32Ptr(v)
1122 return b, nil
1123}
1124
1125func unmarshalSint32Slice(b []byte, f pointer, w int) ([]byte, error) {
1126 if w == WireBytes { // packed
1127 x, n := decodeVarint(b)
1128 if n == 0 {
1129 return nil, io.ErrUnexpectedEOF
1130 }
1131 b = b[n:]
1132 if x > uint64(len(b)) {
1133 return nil, io.ErrUnexpectedEOF
1134 }
1135 res := b[x:]
1136 b = b[:x]
1137 for len(b) > 0 {
1138 x, n = decodeVarint(b)
1139 if n == 0 {
1140 return nil, io.ErrUnexpectedEOF
1141 }
1142 b = b[n:]
1143 v := int32(x>>1) ^ int32(x)<<31>>31
1144 f.appendInt32Slice(v)
1145 }
1146 return res, nil
1147 }
1148 if w != WireVarint {
1149 return b, errInternalBadWireType
1150 }
1151 x, n := decodeVarint(b)
1152 if n == 0 {
1153 return nil, io.ErrUnexpectedEOF
1154 }
1155 b = b[n:]
1156 v := int32(x>>1) ^ int32(x)<<31>>31
1157 f.appendInt32Slice(v)
1158 return b, nil
1159}
1160
1161func unmarshalUint32Value(b []byte, f pointer, w int) ([]byte, error) {
1162 if w != WireVarint {
1163 return b, errInternalBadWireType
1164 }
1165 x, n := decodeVarint(b)
1166 if n == 0 {
1167 return nil, io.ErrUnexpectedEOF
1168 }
1169 b = b[n:]
1170 v := uint32(x)
1171 *f.toUint32() = v
1172 return b, nil
1173}
1174
1175func unmarshalUint32Ptr(b []byte, f pointer, w int) ([]byte, error) {
1176 if w != WireVarint {
1177 return b, errInternalBadWireType
1178 }
1179 x, n := decodeVarint(b)
1180 if n == 0 {
1181 return nil, io.ErrUnexpectedEOF
1182 }
1183 b = b[n:]
1184 v := uint32(x)
1185 *f.toUint32Ptr() = &v
1186 return b, nil
1187}
1188
1189func unmarshalUint32Slice(b []byte, f pointer, w int) ([]byte, error) {
1190 if w == WireBytes { // packed
1191 x, n := decodeVarint(b)
1192 if n == 0 {
1193 return nil, io.ErrUnexpectedEOF
1194 }
1195 b = b[n:]
1196 if x > uint64(len(b)) {
1197 return nil, io.ErrUnexpectedEOF
1198 }
1199 res := b[x:]
1200 b = b[:x]
1201 for len(b) > 0 {
1202 x, n = decodeVarint(b)
1203 if n == 0 {
1204 return nil, io.ErrUnexpectedEOF
1205 }
1206 b = b[n:]
1207 v := uint32(x)
1208 s := f.toUint32Slice()
1209 *s = append(*s, v)
1210 }
1211 return res, nil
1212 }
1213 if w != WireVarint {
1214 return b, errInternalBadWireType
1215 }
1216 x, n := decodeVarint(b)
1217 if n == 0 {
1218 return nil, io.ErrUnexpectedEOF
1219 }
1220 b = b[n:]
1221 v := uint32(x)
1222 s := f.toUint32Slice()
1223 *s = append(*s, v)
1224 return b, nil
1225}
1226
1227func unmarshalFixed64Value(b []byte, f pointer, w int) ([]byte, error) {
1228 if w != WireFixed64 {
1229 return b, errInternalBadWireType
1230 }
1231 if len(b) < 8 {
1232 return nil, io.ErrUnexpectedEOF
1233 }
1234 v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
1235 *f.toUint64() = v
1236 return b[8:], nil
1237}
1238
1239func unmarshalFixed64Ptr(b []byte, f pointer, w int) ([]byte, error) {
1240 if w != WireFixed64 {
1241 return b, errInternalBadWireType
1242 }
1243 if len(b) < 8 {
1244 return nil, io.ErrUnexpectedEOF
1245 }
1246 v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
1247 *f.toUint64Ptr() = &v
1248 return b[8:], nil
1249}
1250
1251func unmarshalFixed64Slice(b []byte, f pointer, w int) ([]byte, error) {
1252 if w == WireBytes { // packed
1253 x, n := decodeVarint(b)
1254 if n == 0 {
1255 return nil, io.ErrUnexpectedEOF
1256 }
1257 b = b[n:]
1258 if x > uint64(len(b)) {
1259 return nil, io.ErrUnexpectedEOF
1260 }
1261 res := b[x:]
1262 b = b[:x]
1263 for len(b) > 0 {
1264 if len(b) < 8 {
1265 return nil, io.ErrUnexpectedEOF
1266 }
1267 v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
1268 s := f.toUint64Slice()
1269 *s = append(*s, v)
1270 b = b[8:]
1271 }
1272 return res, nil
1273 }
1274 if w != WireFixed64 {
1275 return b, errInternalBadWireType
1276 }
1277 if len(b) < 8 {
1278 return nil, io.ErrUnexpectedEOF
1279 }
1280 v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
1281 s := f.toUint64Slice()
1282 *s = append(*s, v)
1283 return b[8:], nil
1284}
1285
1286func unmarshalFixedS64Value(b []byte, f pointer, w int) ([]byte, error) {
1287 if w != WireFixed64 {
1288 return b, errInternalBadWireType
1289 }
1290 if len(b) < 8 {
1291 return nil, io.ErrUnexpectedEOF
1292 }
1293 v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
1294 *f.toInt64() = v
1295 return b[8:], nil
1296}
1297
1298func unmarshalFixedS64Ptr(b []byte, f pointer, w int) ([]byte, error) {
1299 if w != WireFixed64 {
1300 return b, errInternalBadWireType
1301 }
1302 if len(b) < 8 {
1303 return nil, io.ErrUnexpectedEOF
1304 }
1305 v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
1306 *f.toInt64Ptr() = &v
1307 return b[8:], nil
1308}
1309
1310func unmarshalFixedS64Slice(b []byte, f pointer, w int) ([]byte, error) {
1311 if w == WireBytes { // packed
1312 x, n := decodeVarint(b)
1313 if n == 0 {
1314 return nil, io.ErrUnexpectedEOF
1315 }
1316 b = b[n:]
1317 if x > uint64(len(b)) {
1318 return nil, io.ErrUnexpectedEOF
1319 }
1320 res := b[x:]
1321 b = b[:x]
1322 for len(b) > 0 {
1323 if len(b) < 8 {
1324 return nil, io.ErrUnexpectedEOF
1325 }
1326 v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
1327 s := f.toInt64Slice()
1328 *s = append(*s, v)
1329 b = b[8:]
1330 }
1331 return res, nil
1332 }
1333 if w != WireFixed64 {
1334 return b, errInternalBadWireType
1335 }
1336 if len(b) < 8 {
1337 return nil, io.ErrUnexpectedEOF
1338 }
1339 v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
1340 s := f.toInt64Slice()
1341 *s = append(*s, v)
1342 return b[8:], nil
1343}
1344
1345func unmarshalFixed32Value(b []byte, f pointer, w int) ([]byte, error) {
1346 if w != WireFixed32 {
1347 return b, errInternalBadWireType
1348 }
1349 if len(b) < 4 {
1350 return nil, io.ErrUnexpectedEOF
1351 }
1352 v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
1353 *f.toUint32() = v
1354 return b[4:], nil
1355}
1356
1357func unmarshalFixed32Ptr(b []byte, f pointer, w int) ([]byte, error) {
1358 if w != WireFixed32 {
1359 return b, errInternalBadWireType
1360 }
1361 if len(b) < 4 {
1362 return nil, io.ErrUnexpectedEOF
1363 }
1364 v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
1365 *f.toUint32Ptr() = &v
1366 return b[4:], nil
1367}
1368
1369func unmarshalFixed32Slice(b []byte, f pointer, w int) ([]byte, error) {
1370 if w == WireBytes { // packed
1371 x, n := decodeVarint(b)
1372 if n == 0 {
1373 return nil, io.ErrUnexpectedEOF
1374 }
1375 b = b[n:]
1376 if x > uint64(len(b)) {
1377 return nil, io.ErrUnexpectedEOF
1378 }
1379 res := b[x:]
1380 b = b[:x]
1381 for len(b) > 0 {
1382 if len(b) < 4 {
1383 return nil, io.ErrUnexpectedEOF
1384 }
1385 v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
1386 s := f.toUint32Slice()
1387 *s = append(*s, v)
1388 b = b[4:]
1389 }
1390 return res, nil
1391 }
1392 if w != WireFixed32 {
1393 return b, errInternalBadWireType
1394 }
1395 if len(b) < 4 {
1396 return nil, io.ErrUnexpectedEOF
1397 }
1398 v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
1399 s := f.toUint32Slice()
1400 *s = append(*s, v)
1401 return b[4:], nil
1402}
1403
1404func unmarshalFixedS32Value(b []byte, f pointer, w int) ([]byte, error) {
1405 if w != WireFixed32 {
1406 return b, errInternalBadWireType
1407 }
1408 if len(b) < 4 {
1409 return nil, io.ErrUnexpectedEOF
1410 }
1411 v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
1412 *f.toInt32() = v
1413 return b[4:], nil
1414}
1415
1416func unmarshalFixedS32Ptr(b []byte, f pointer, w int) ([]byte, error) {
1417 if w != WireFixed32 {
1418 return b, errInternalBadWireType
1419 }
1420 if len(b) < 4 {
1421 return nil, io.ErrUnexpectedEOF
1422 }
1423 v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
1424 f.setInt32Ptr(v)
1425 return b[4:], nil
1426}
1427
1428func unmarshalFixedS32Slice(b []byte, f pointer, w int) ([]byte, error) {
1429 if w == WireBytes { // packed
1430 x, n := decodeVarint(b)
1431 if n == 0 {
1432 return nil, io.ErrUnexpectedEOF
1433 }
1434 b = b[n:]
1435 if x > uint64(len(b)) {
1436 return nil, io.ErrUnexpectedEOF
1437 }
1438 res := b[x:]
1439 b = b[:x]
1440 for len(b) > 0 {
1441 if len(b) < 4 {
1442 return nil, io.ErrUnexpectedEOF
1443 }
1444 v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
1445 f.appendInt32Slice(v)
1446 b = b[4:]
1447 }
1448 return res, nil
1449 }
1450 if w != WireFixed32 {
1451 return b, errInternalBadWireType
1452 }
1453 if len(b) < 4 {
1454 return nil, io.ErrUnexpectedEOF
1455 }
1456 v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
1457 f.appendInt32Slice(v)
1458 return b[4:], nil
1459}
1460
1461func unmarshalBoolValue(b []byte, f pointer, w int) ([]byte, error) {
1462 if w != WireVarint {
1463 return b, errInternalBadWireType
1464 }
1465 // Note: any length varint is allowed, even though any sane
1466 // encoder will use one byte.
1467 // See https://github.com/golang/protobuf/issues/76
1468 x, n := decodeVarint(b)
1469 if n == 0 {
1470 return nil, io.ErrUnexpectedEOF
1471 }
1472 // TODO: check if x>1? Tests seem to indicate no.
1473 v := x != 0
1474 *f.toBool() = v
1475 return b[n:], nil
1476}
1477
1478func unmarshalBoolPtr(b []byte, f pointer, w int) ([]byte, error) {
1479 if w != WireVarint {
1480 return b, errInternalBadWireType
1481 }
1482 x, n := decodeVarint(b)
1483 if n == 0 {
1484 return nil, io.ErrUnexpectedEOF
1485 }
1486 v := x != 0
1487 *f.toBoolPtr() = &v
1488 return b[n:], nil
1489}
1490
1491func unmarshalBoolSlice(b []byte, f pointer, w int) ([]byte, error) {
1492 if w == WireBytes { // packed
1493 x, n := decodeVarint(b)
1494 if n == 0 {
1495 return nil, io.ErrUnexpectedEOF
1496 }
1497 b = b[n:]
1498 if x > uint64(len(b)) {
1499 return nil, io.ErrUnexpectedEOF
1500 }
1501 res := b[x:]
1502 b = b[:x]
1503 for len(b) > 0 {
1504 x, n = decodeVarint(b)
1505 if n == 0 {
1506 return nil, io.ErrUnexpectedEOF
1507 }
1508 v := x != 0
1509 s := f.toBoolSlice()
1510 *s = append(*s, v)
1511 b = b[n:]
1512 }
1513 return res, nil
1514 }
1515 if w != WireVarint {
1516 return b, errInternalBadWireType
1517 }
1518 x, n := decodeVarint(b)
1519 if n == 0 {
1520 return nil, io.ErrUnexpectedEOF
1521 }
1522 v := x != 0
1523 s := f.toBoolSlice()
1524 *s = append(*s, v)
1525 return b[n:], nil
1526}
1527
1528func unmarshalFloat64Value(b []byte, f pointer, w int) ([]byte, error) {
1529 if w != WireFixed64 {
1530 return b, errInternalBadWireType
1531 }
1532 if len(b) < 8 {
1533 return nil, io.ErrUnexpectedEOF
1534 }
1535 v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
1536 *f.toFloat64() = v
1537 return b[8:], nil
1538}
1539
1540func unmarshalFloat64Ptr(b []byte, f pointer, w int) ([]byte, error) {
1541 if w != WireFixed64 {
1542 return b, errInternalBadWireType
1543 }
1544 if len(b) < 8 {
1545 return nil, io.ErrUnexpectedEOF
1546 }
1547 v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
1548 *f.toFloat64Ptr() = &v
1549 return b[8:], nil
1550}
1551
1552func unmarshalFloat64Slice(b []byte, f pointer, w int) ([]byte, error) {
1553 if w == WireBytes { // packed
1554 x, n := decodeVarint(b)
1555 if n == 0 {
1556 return nil, io.ErrUnexpectedEOF
1557 }
1558 b = b[n:]
1559 if x > uint64(len(b)) {
1560 return nil, io.ErrUnexpectedEOF
1561 }
1562 res := b[x:]
1563 b = b[:x]
1564 for len(b) > 0 {
1565 if len(b) < 8 {
1566 return nil, io.ErrUnexpectedEOF
1567 }
1568 v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
1569 s := f.toFloat64Slice()
1570 *s = append(*s, v)
1571 b = b[8:]
1572 }
1573 return res, nil
1574 }
1575 if w != WireFixed64 {
1576 return b, errInternalBadWireType
1577 }
1578 if len(b) < 8 {
1579 return nil, io.ErrUnexpectedEOF
1580 }
1581 v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
1582 s := f.toFloat64Slice()
1583 *s = append(*s, v)
1584 return b[8:], nil
1585}
1586
1587func unmarshalFloat32Value(b []byte, f pointer, w int) ([]byte, error) {
1588 if w != WireFixed32 {
1589 return b, errInternalBadWireType
1590 }
1591 if len(b) < 4 {
1592 return nil, io.ErrUnexpectedEOF
1593 }
1594 v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
1595 *f.toFloat32() = v
1596 return b[4:], nil
1597}
1598
1599func unmarshalFloat32Ptr(b []byte, f pointer, w int) ([]byte, error) {
1600 if w != WireFixed32 {
1601 return b, errInternalBadWireType
1602 }
1603 if len(b) < 4 {
1604 return nil, io.ErrUnexpectedEOF
1605 }
1606 v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
1607 *f.toFloat32Ptr() = &v
1608 return b[4:], nil
1609}
1610
1611func unmarshalFloat32Slice(b []byte, f pointer, w int) ([]byte, error) {
1612 if w == WireBytes { // packed
1613 x, n := decodeVarint(b)
1614 if n == 0 {
1615 return nil, io.ErrUnexpectedEOF
1616 }
1617 b = b[n:]
1618 if x > uint64(len(b)) {
1619 return nil, io.ErrUnexpectedEOF
1620 }
1621 res := b[x:]
1622 b = b[:x]
1623 for len(b) > 0 {
1624 if len(b) < 4 {
1625 return nil, io.ErrUnexpectedEOF
1626 }
1627 v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
1628 s := f.toFloat32Slice()
1629 *s = append(*s, v)
1630 b = b[4:]
1631 }
1632 return res, nil
1633 }
1634 if w != WireFixed32 {
1635 return b, errInternalBadWireType
1636 }
1637 if len(b) < 4 {
1638 return nil, io.ErrUnexpectedEOF
1639 }
1640 v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
1641 s := f.toFloat32Slice()
1642 *s = append(*s, v)
1643 return b[4:], nil
1644}
1645
1646func unmarshalStringValue(b []byte, f pointer, w int) ([]byte, error) {
1647 if w != WireBytes {
1648 return b, errInternalBadWireType
1649 }
1650 x, n := decodeVarint(b)
1651 if n == 0 {
1652 return nil, io.ErrUnexpectedEOF
1653 }
1654 b = b[n:]
1655 if x > uint64(len(b)) {
1656 return nil, io.ErrUnexpectedEOF
1657 }
1658 v := string(b[:x])
1659 *f.toString() = v
1660 return b[x:], nil
1661}
1662
1663func unmarshalStringPtr(b []byte, f pointer, w int) ([]byte, error) {
1664 if w != WireBytes {
1665 return b, errInternalBadWireType
1666 }
1667 x, n := decodeVarint(b)
1668 if n == 0 {
1669 return nil, io.ErrUnexpectedEOF
1670 }
1671 b = b[n:]
1672 if x > uint64(len(b)) {
1673 return nil, io.ErrUnexpectedEOF
1674 }
1675 v := string(b[:x])
1676 *f.toStringPtr() = &v
1677 return b[x:], nil
1678}
1679
1680func unmarshalStringSlice(b []byte, f pointer, w int) ([]byte, error) {
1681 if w != WireBytes {
1682 return b, errInternalBadWireType
1683 }
1684 x, n := decodeVarint(b)
1685 if n == 0 {
1686 return nil, io.ErrUnexpectedEOF
1687 }
1688 b = b[n:]
1689 if x > uint64(len(b)) {
1690 return nil, io.ErrUnexpectedEOF
1691 }
1692 v := string(b[:x])
1693 s := f.toStringSlice()
1694 *s = append(*s, v)
1695 return b[x:], nil
1696}
1697
1698func unmarshalUTF8StringValue(b []byte, f pointer, w int) ([]byte, error) {
1699 if w != WireBytes {
1700 return b, errInternalBadWireType
1701 }
1702 x, n := decodeVarint(b)
1703 if n == 0 {
1704 return nil, io.ErrUnexpectedEOF
1705 }
1706 b = b[n:]
1707 if x > uint64(len(b)) {
1708 return nil, io.ErrUnexpectedEOF
1709 }
1710 v := string(b[:x])
1711 *f.toString() = v
1712 if !utf8.ValidString(v) {
1713 return b[x:], errInvalidUTF8
1714 }
1715 return b[x:], nil
1716}
1717
1718func unmarshalUTF8StringPtr(b []byte, f pointer, w int) ([]byte, error) {
1719 if w != WireBytes {
1720 return b, errInternalBadWireType
1721 }
1722 x, n := decodeVarint(b)
1723 if n == 0 {
1724 return nil, io.ErrUnexpectedEOF
1725 }
1726 b = b[n:]
1727 if x > uint64(len(b)) {
1728 return nil, io.ErrUnexpectedEOF
1729 }
1730 v := string(b[:x])
1731 *f.toStringPtr() = &v
1732 if !utf8.ValidString(v) {
1733 return b[x:], errInvalidUTF8
1734 }
1735 return b[x:], nil
1736}
1737
1738func unmarshalUTF8StringSlice(b []byte, f pointer, w int) ([]byte, error) {
1739 if w != WireBytes {
1740 return b, errInternalBadWireType
1741 }
1742 x, n := decodeVarint(b)
1743 if n == 0 {
1744 return nil, io.ErrUnexpectedEOF
1745 }
1746 b = b[n:]
1747 if x > uint64(len(b)) {
1748 return nil, io.ErrUnexpectedEOF
1749 }
1750 v := string(b[:x])
1751 s := f.toStringSlice()
1752 *s = append(*s, v)
1753 if !utf8.ValidString(v) {
1754 return b[x:], errInvalidUTF8
1755 }
1756 return b[x:], nil
1757}
1758
1759var emptyBuf [0]byte
1760
1761func unmarshalBytesValue(b []byte, f pointer, w int) ([]byte, error) {
1762 if w != WireBytes {
1763 return b, errInternalBadWireType
1764 }
1765 x, n := decodeVarint(b)
1766 if n == 0 {
1767 return nil, io.ErrUnexpectedEOF
1768 }
1769 b = b[n:]
1770 if x > uint64(len(b)) {
1771 return nil, io.ErrUnexpectedEOF
1772 }
1773 // The use of append here is a trick which avoids the zeroing
1774 // that would be required if we used a make/copy pair.
1775 // We append to emptyBuf instead of nil because we want
1776 // a non-nil result even when the length is 0.
1777 v := append(emptyBuf[:], b[:x]...)
1778 *f.toBytes() = v
1779 return b[x:], nil
1780}
1781
1782func unmarshalBytesSlice(b []byte, f pointer, w int) ([]byte, error) {
1783 if w != WireBytes {
1784 return b, errInternalBadWireType
1785 }
1786 x, n := decodeVarint(b)
1787 if n == 0 {
1788 return nil, io.ErrUnexpectedEOF
1789 }
1790 b = b[n:]
1791 if x > uint64(len(b)) {
1792 return nil, io.ErrUnexpectedEOF
1793 }
1794 v := append(emptyBuf[:], b[:x]...)
1795 s := f.toBytesSlice()
1796 *s = append(*s, v)
1797 return b[x:], nil
1798}
1799
1800func makeUnmarshalMessagePtr(sub *unmarshalInfo, name string) unmarshaler {
1801 return func(b []byte, f pointer, w int) ([]byte, error) {
1802 if w != WireBytes {
1803 return b, errInternalBadWireType
1804 }
1805 x, n := decodeVarint(b)
1806 if n == 0 {
1807 return nil, io.ErrUnexpectedEOF
1808 }
1809 b = b[n:]
1810 if x > uint64(len(b)) {
1811 return nil, io.ErrUnexpectedEOF
1812 }
1813 // First read the message field to see if something is there.
1814 // The semantics of multiple submessages are weird. Instead of
1815 // the last one winning (as it is for all other fields), multiple
1816 // submessages are merged.
1817 v := f.getPointer()
1818 if v.isNil() {
1819 v = valToPointer(reflect.New(sub.typ))
1820 f.setPointer(v)
1821 }
1822 err := sub.unmarshal(v, b[:x])
1823 if err != nil {
1824 if r, ok := err.(*RequiredNotSetError); ok {
1825 r.field = name + "." + r.field
1826 } else {
1827 return nil, err
1828 }
1829 }
1830 return b[x:], err
1831 }
1832}
1833
1834func makeUnmarshalMessageSlicePtr(sub *unmarshalInfo, name string) unmarshaler {
1835 return func(b []byte, f pointer, w int) ([]byte, error) {
1836 if w != WireBytes {
1837 return b, errInternalBadWireType
1838 }
1839 x, n := decodeVarint(b)
1840 if n == 0 {
1841 return nil, io.ErrUnexpectedEOF
1842 }
1843 b = b[n:]
1844 if x > uint64(len(b)) {
1845 return nil, io.ErrUnexpectedEOF
1846 }
1847 v := valToPointer(reflect.New(sub.typ))
1848 err := sub.unmarshal(v, b[:x])
1849 if err != nil {
1850 if r, ok := err.(*RequiredNotSetError); ok {
1851 r.field = name + "." + r.field
1852 } else {
1853 return nil, err
1854 }
1855 }
1856 f.appendPointer(v)
1857 return b[x:], err
1858 }
1859}
1860
1861func makeUnmarshalGroupPtr(sub *unmarshalInfo, name string) unmarshaler {
1862 return func(b []byte, f pointer, w int) ([]byte, error) {
1863 if w != WireStartGroup {
1864 return b, errInternalBadWireType
1865 }
1866 x, y := findEndGroup(b)
1867 if x < 0 {
1868 return nil, io.ErrUnexpectedEOF
1869 }
1870 v := f.getPointer()
1871 if v.isNil() {
1872 v = valToPointer(reflect.New(sub.typ))
1873 f.setPointer(v)
1874 }
1875 err := sub.unmarshal(v, b[:x])
1876 if err != nil {
1877 if r, ok := err.(*RequiredNotSetError); ok {
1878 r.field = name + "." + r.field
1879 } else {
1880 return nil, err
1881 }
1882 }
1883 return b[y:], err
1884 }
1885}
1886
1887func makeUnmarshalGroupSlicePtr(sub *unmarshalInfo, name string) unmarshaler {
1888 return func(b []byte, f pointer, w int) ([]byte, error) {
1889 if w != WireStartGroup {
1890 return b, errInternalBadWireType
1891 }
1892 x, y := findEndGroup(b)
1893 if x < 0 {
1894 return nil, io.ErrUnexpectedEOF
1895 }
1896 v := valToPointer(reflect.New(sub.typ))
1897 err := sub.unmarshal(v, b[:x])
1898 if err != nil {
1899 if r, ok := err.(*RequiredNotSetError); ok {
1900 r.field = name + "." + r.field
1901 } else {
1902 return nil, err
1903 }
1904 }
1905 f.appendPointer(v)
1906 return b[y:], err
1907 }
1908}
1909
1910func makeUnmarshalMap(f *reflect.StructField) unmarshaler {
1911 t := f.Type
1912 kt := t.Key()
1913 vt := t.Elem()
1914 tagArray := strings.Split(f.Tag.Get("protobuf"), ",")
1915 valTags := strings.Split(f.Tag.Get("protobuf_val"), ",")
1916 for _, t := range tagArray {
1917 if strings.HasPrefix(t, "customtype=") {
1918 valTags = append(valTags, t)
1919 }
1920 if t == "stdtime" {
1921 valTags = append(valTags, t)
1922 }
1923 if t == "stdduration" {
1924 valTags = append(valTags, t)
1925 }
1926 if t == "wktptr" {
1927 valTags = append(valTags, t)
1928 }
1929 }
1930 unmarshalKey := typeUnmarshaler(kt, f.Tag.Get("protobuf_key"))
1931 unmarshalVal := typeUnmarshaler(vt, strings.Join(valTags, ","))
1932 return func(b []byte, f pointer, w int) ([]byte, error) {
1933 // The map entry is a submessage. Figure out how big it is.
1934 if w != WireBytes {
1935 return nil, fmt.Errorf("proto: bad wiretype for map field: got %d want %d", w, WireBytes)
1936 }
1937 x, n := decodeVarint(b)
1938 if n == 0 {
1939 return nil, io.ErrUnexpectedEOF
1940 }
1941 b = b[n:]
1942 if x > uint64(len(b)) {
1943 return nil, io.ErrUnexpectedEOF
1944 }
1945 r := b[x:] // unused data to return
1946 b = b[:x] // data for map entry
1947
1948 // Note: we could use #keys * #values ~= 200 functions
1949 // to do map decoding without reflection. Probably not worth it.
1950 // Maps will be somewhat slow. Oh well.
1951
1952 // Read key and value from data.
1953 var nerr nonFatal
1954 k := reflect.New(kt)
1955 v := reflect.New(vt)
1956 for len(b) > 0 {
1957 x, n := decodeVarint(b)
1958 if n == 0 {
1959 return nil, io.ErrUnexpectedEOF
1960 }
1961 wire := int(x) & 7
1962 b = b[n:]
1963
1964 var err error
1965 switch x >> 3 {
1966 case 1:
1967 b, err = unmarshalKey(b, valToPointer(k), wire)
1968 case 2:
1969 b, err = unmarshalVal(b, valToPointer(v), wire)
1970 default:
1971 err = errInternalBadWireType // skip unknown tag
1972 }
1973
1974 if nerr.Merge(err) {
1975 continue
1976 }
1977 if err != errInternalBadWireType {
1978 return nil, err
1979 }
1980
1981 // Skip past unknown fields.
1982 b, err = skipField(b, wire)
1983 if err != nil {
1984 return nil, err
1985 }
1986 }
1987
1988 // Get map, allocate if needed.
1989 m := f.asPointerTo(t).Elem() // an addressable map[K]T
1990 if m.IsNil() {
1991 m.Set(reflect.MakeMap(t))
1992 }
1993
1994 // Insert into map.
1995 m.SetMapIndex(k.Elem(), v.Elem())
1996
1997 return r, nerr.E
1998 }
1999}
2000
2001// makeUnmarshalOneof makes an unmarshaler for oneof fields.
2002// for:
2003// message Msg {
2004// oneof F {
2005// int64 X = 1;
2006// float64 Y = 2;
2007// }
2008// }
2009// typ is the type of the concrete entry for a oneof case (e.g. Msg_X).
2010// ityp is the interface type of the oneof field (e.g. isMsg_F).
2011// unmarshal is the unmarshaler for the base type of the oneof case (e.g. int64).
2012// Note that this function will be called once for each case in the oneof.
2013func makeUnmarshalOneof(typ, ityp reflect.Type, unmarshal unmarshaler) unmarshaler {
2014 sf := typ.Field(0)
2015 field0 := toField(&sf)
2016 return func(b []byte, f pointer, w int) ([]byte, error) {
2017 // Allocate holder for value.
2018 v := reflect.New(typ)
2019
2020 // Unmarshal data into holder.
2021 // We unmarshal into the first field of the holder object.
2022 var err error
2023 var nerr nonFatal
2024 b, err = unmarshal(b, valToPointer(v).offset(field0), w)
2025 if !nerr.Merge(err) {
2026 return nil, err
2027 }
2028
2029 // Write pointer to holder into target field.
2030 f.asPointerTo(ityp).Elem().Set(v)
2031
2032 return b, nerr.E
2033 }
2034}
2035
2036// Error used by decode internally.
2037var errInternalBadWireType = errors.New("proto: internal error: bad wiretype")
2038
2039// skipField skips past a field of type wire and returns the remaining bytes.
2040func skipField(b []byte, wire int) ([]byte, error) {
2041 switch wire {
2042 case WireVarint:
2043 _, k := decodeVarint(b)
2044 if k == 0 {
2045 return b, io.ErrUnexpectedEOF
2046 }
2047 b = b[k:]
2048 case WireFixed32:
2049 if len(b) < 4 {
2050 return b, io.ErrUnexpectedEOF
2051 }
2052 b = b[4:]
2053 case WireFixed64:
2054 if len(b) < 8 {
2055 return b, io.ErrUnexpectedEOF
2056 }
2057 b = b[8:]
2058 case WireBytes:
2059 m, k := decodeVarint(b)
2060 if k == 0 || uint64(len(b)-k) < m {
2061 return b, io.ErrUnexpectedEOF
2062 }
2063 b = b[uint64(k)+m:]
2064 case WireStartGroup:
2065 _, i := findEndGroup(b)
2066 if i == -1 {
2067 return b, io.ErrUnexpectedEOF
2068 }
2069 b = b[i:]
2070 default:
2071 return b, fmt.Errorf("proto: can't skip unknown wire type %d", wire)
2072 }
2073 return b, nil
2074}
2075
2076// findEndGroup finds the index of the next EndGroup tag.
2077// Groups may be nested, so the "next" EndGroup tag is the first
2078// unpaired EndGroup.
2079// findEndGroup returns the indexes of the start and end of the EndGroup tag.
2080// Returns (-1,-1) if it can't find one.
2081func findEndGroup(b []byte) (int, int) {
2082 depth := 1
2083 i := 0
2084 for {
2085 x, n := decodeVarint(b[i:])
2086 if n == 0 {
2087 return -1, -1
2088 }
2089 j := i
2090 i += n
2091 switch x & 7 {
2092 case WireVarint:
2093 _, k := decodeVarint(b[i:])
2094 if k == 0 {
2095 return -1, -1
2096 }
2097 i += k
2098 case WireFixed32:
2099 if len(b)-4 < i {
2100 return -1, -1
2101 }
2102 i += 4
2103 case WireFixed64:
2104 if len(b)-8 < i {
2105 return -1, -1
2106 }
2107 i += 8
2108 case WireBytes:
2109 m, k := decodeVarint(b[i:])
2110 if k == 0 {
2111 return -1, -1
2112 }
2113 i += k
2114 if uint64(len(b)-i) < m {
2115 return -1, -1
2116 }
2117 i += int(m)
2118 case WireStartGroup:
2119 depth++
2120 case WireEndGroup:
2121 depth--
2122 if depth == 0 {
2123 return j, i
2124 }
2125 default:
2126 return -1, -1
2127 }
2128 }
2129}
2130
2131// encodeVarint appends a varint-encoded integer to b and returns the result.
2132func encodeVarint(b []byte, x uint64) []byte {
2133 for x >= 1<<7 {
2134 b = append(b, byte(x&0x7f|0x80))
2135 x >>= 7
2136 }
2137 return append(b, byte(x))
2138}
2139
2140// decodeVarint reads a varint-encoded integer from b.
2141// Returns the decoded integer and the number of bytes read.
2142// If there is an error, it returns 0,0.
2143func decodeVarint(b []byte) (uint64, int) {
2144 var x, y uint64
2145 if len(b) == 0 {
2146 goto bad
2147 }
2148 x = uint64(b[0])
2149 if x < 0x80 {
2150 return x, 1
2151 }
2152 x -= 0x80
2153
2154 if len(b) <= 1 {
2155 goto bad
2156 }
2157 y = uint64(b[1])
2158 x += y << 7
2159 if y < 0x80 {
2160 return x, 2
2161 }
2162 x -= 0x80 << 7
2163
2164 if len(b) <= 2 {
2165 goto bad
2166 }
2167 y = uint64(b[2])
2168 x += y << 14
2169 if y < 0x80 {
2170 return x, 3
2171 }
2172 x -= 0x80 << 14
2173
2174 if len(b) <= 3 {
2175 goto bad
2176 }
2177 y = uint64(b[3])
2178 x += y << 21
2179 if y < 0x80 {
2180 return x, 4
2181 }
2182 x -= 0x80 << 21
2183
2184 if len(b) <= 4 {
2185 goto bad
2186 }
2187 y = uint64(b[4])
2188 x += y << 28
2189 if y < 0x80 {
2190 return x, 5
2191 }
2192 x -= 0x80 << 28
2193
2194 if len(b) <= 5 {
2195 goto bad
2196 }
2197 y = uint64(b[5])
2198 x += y << 35
2199 if y < 0x80 {
2200 return x, 6
2201 }
2202 x -= 0x80 << 35
2203
2204 if len(b) <= 6 {
2205 goto bad
2206 }
2207 y = uint64(b[6])
2208 x += y << 42
2209 if y < 0x80 {
2210 return x, 7
2211 }
2212 x -= 0x80 << 42
2213
2214 if len(b) <= 7 {
2215 goto bad
2216 }
2217 y = uint64(b[7])
2218 x += y << 49
2219 if y < 0x80 {
2220 return x, 8
2221 }
2222 x -= 0x80 << 49
2223
2224 if len(b) <= 8 {
2225 goto bad
2226 }
2227 y = uint64(b[8])
2228 x += y << 56
2229 if y < 0x80 {
2230 return x, 9
2231 }
2232 x -= 0x80 << 56
2233
2234 if len(b) <= 9 {
2235 goto bad
2236 }
2237 y = uint64(b[9])
2238 x += y << 63
2239 if y < 2 {
2240 return x, 10
2241 }
2242
2243bad:
2244 return 0, 0
2245}