podman

1
// 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

32
package proto
33

34
import (
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.
53
func (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

67
type 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.
91
type unmarshaler func(b []byte, f pointer, w int) ([]byte, error)
92

93
type 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

106
var (
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).
114
func 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.
136
func (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.
272
func (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
	// gogo: len(oneofFields) > 0 is needed for embedded oneof messages, without a marshaler and unmarshaler
375
	if len(oneofFields) > 0 {
376
		var oneofImplementers []interface{}
377
		switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
378
		case oneofFuncsIface:
379
			_, _, _, oneofImplementers = m.XXX_OneofFuncs()
380
		case oneofWrappersIface:
381
			oneofImplementers = m.XXX_OneofWrappers()
382
		}
383
		for _, v := range oneofImplementers {
384
			tptr := reflect.TypeOf(v) // *Msg_X
385
			typ := tptr.Elem()        // Msg_X
386

387
			f := typ.Field(0) // oneof implementers have one field
388
			baseUnmarshal := fieldUnmarshaler(&f)
389
			tags := strings.Split(f.Tag.Get("protobuf"), ",")
390
			fieldNum, err := strconv.Atoi(tags[1])
391
			if err != nil {
392
				panic("protobuf tag field not an integer: " + tags[1])
393
			}
394
			var name string
395
			for _, tag := range tags {
396
				if strings.HasPrefix(tag, "name=") {
397
					name = strings.TrimPrefix(tag, "name=")
398
					break
399
				}
400
			}
401

402
			// Find the oneof field that this struct implements.
403
			// Might take O(n^2) to process all of the oneofs, but who cares.
404
			for _, of := range oneofFields {
405
				if tptr.Implements(of.ityp) {
406
					// We have found the corresponding interface for this struct.
407
					// That lets us know where this struct should be stored
408
					// when we encounter it during unmarshaling.
409
					unmarshal := makeUnmarshalOneof(typ, of.ityp, baseUnmarshal)
410
					u.setTag(fieldNum, of.field, unmarshal, 0, name)
411
				}
412
			}
413

414
		}
415
	}
416

417
	// Get extension ranges, if any.
418
	fn := reflect.Zero(reflect.PtrTo(t)).MethodByName("ExtensionRangeArray")
419
	if fn.IsValid() {
420
		if !u.extensions.IsValid() && !u.oldExtensions.IsValid() && !u.bytesExtensions.IsValid() {
421
			panic("a message with extensions, but no extensions field in " + t.Name())
422
		}
423
		u.extensionRanges = fn.Call(nil)[0].Interface().([]ExtensionRange)
424
	}
425

426
	// Explicitly disallow tag 0. This will ensure we flag an error
427
	// when decoding a buffer of all zeros. Without this code, we
428
	// would decode and skip an all-zero buffer of even length.
429
	// [0 0] is [tag=0/wiretype=varint varint-encoded-0].
430
	u.setTag(0, zeroField, func(b []byte, f pointer, w int) ([]byte, error) {
431
		return nil, fmt.Errorf("proto: %s: illegal tag 0 (wire type %d)", t, w)
432
	}, 0, "")
433

434
	// Set mask for required field check.
435
	u.reqMask = uint64(1)<<uint(len(u.reqFields)) - 1
436

437
	atomic.StoreInt32(&u.initialized, 1)
438
}
439

440
// setTag stores the unmarshal information for the given tag.
441
// tag = tag # for field
442
// field/unmarshal = unmarshal info for that field.
443
// reqMask = if required, bitmask for field position in required field list. 0 otherwise.
444
// name = short name of the field.
445
func (u *unmarshalInfo) setTag(tag int, field field, unmarshal unmarshaler, reqMask uint64, name string) {
446
	i := unmarshalFieldInfo{field: field, unmarshal: unmarshal, reqMask: reqMask, name: name}
447
	n := u.typ.NumField()
448
	if tag >= 0 && (tag < 16 || tag < 2*n) { // TODO: what are the right numbers here?
449
		for len(u.dense) <= tag {
450
			u.dense = append(u.dense, unmarshalFieldInfo{})
451
		}
452
		u.dense[tag] = i
453
		return
454
	}
455
	if u.sparse == nil {
456
		u.sparse = map[uint64]unmarshalFieldInfo{}
457
	}
458
	u.sparse[uint64(tag)] = i
459
}
460

461
// fieldUnmarshaler returns an unmarshaler for the given field.
462
func fieldUnmarshaler(f *reflect.StructField) unmarshaler {
463
	if f.Type.Kind() == reflect.Map {
464
		return makeUnmarshalMap(f)
465
	}
466
	return typeUnmarshaler(f.Type, f.Tag.Get("protobuf"))
467
}
468

469
// typeUnmarshaler returns an unmarshaler for the given field type / field tag pair.
470
func typeUnmarshaler(t reflect.Type, tags string) unmarshaler {
471
	tagArray := strings.Split(tags, ",")
472
	encoding := tagArray[0]
473
	name := "unknown"
474
	ctype := false
475
	isTime := false
476
	isDuration := false
477
	isWktPointer := false
478
	proto3 := false
479
	validateUTF8 := true
480
	for _, tag := range tagArray[3:] {
481
		if strings.HasPrefix(tag, "name=") {
482
			name = tag[5:]
483
		}
484
		if tag == "proto3" {
485
			proto3 = true
486
		}
487
		if strings.HasPrefix(tag, "customtype=") {
488
			ctype = true
489
		}
490
		if tag == "stdtime" {
491
			isTime = true
492
		}
493
		if tag == "stdduration" {
494
			isDuration = true
495
		}
496
		if tag == "wktptr" {
497
			isWktPointer = true
498
		}
499
	}
500
	validateUTF8 = validateUTF8 && proto3
501

502
	// Figure out packaging (pointer, slice, or both)
503
	slice := false
504
	pointer := false
505
	if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
506
		slice = true
507
		t = t.Elem()
508
	}
509
	if t.Kind() == reflect.Ptr {
510
		pointer = true
511
		t = t.Elem()
512
	}
513

514
	if ctype {
515
		if reflect.PtrTo(t).Implements(customType) {
516
			if slice {
517
				return makeUnmarshalCustomSlice(getUnmarshalInfo(t), name)
518
			}
519
			if pointer {
520
				return makeUnmarshalCustomPtr(getUnmarshalInfo(t), name)
521
			}
522
			return makeUnmarshalCustom(getUnmarshalInfo(t), name)
523
		} else {
524
			panic(fmt.Sprintf("custom type: type: %v, does not implement the proto.custom interface", t))
525
		}
526
	}
527

528
	if isTime {
529
		if pointer {
530
			if slice {
531
				return makeUnmarshalTimePtrSlice(getUnmarshalInfo(t), name)
532
			}
533
			return makeUnmarshalTimePtr(getUnmarshalInfo(t), name)
534
		}
535
		if slice {
536
			return makeUnmarshalTimeSlice(getUnmarshalInfo(t), name)
537
		}
538
		return makeUnmarshalTime(getUnmarshalInfo(t), name)
539
	}
540

541
	if isDuration {
542
		if pointer {
543
			if slice {
544
				return makeUnmarshalDurationPtrSlice(getUnmarshalInfo(t), name)
545
			}
546
			return makeUnmarshalDurationPtr(getUnmarshalInfo(t), name)
547
		}
548
		if slice {
549
			return makeUnmarshalDurationSlice(getUnmarshalInfo(t), name)
550
		}
551
		return makeUnmarshalDuration(getUnmarshalInfo(t), name)
552
	}
553

554
	if isWktPointer {
555
		switch t.Kind() {
556
		case reflect.Float64:
557
			if pointer {
558
				if slice {
559
					return makeStdDoubleValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
560
				}
561
				return makeStdDoubleValuePtrUnmarshaler(getUnmarshalInfo(t), name)
562
			}
563
			if slice {
564
				return makeStdDoubleValueSliceUnmarshaler(getUnmarshalInfo(t), name)
565
			}
566
			return makeStdDoubleValueUnmarshaler(getUnmarshalInfo(t), name)
567
		case reflect.Float32:
568
			if pointer {
569
				if slice {
570
					return makeStdFloatValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
571
				}
572
				return makeStdFloatValuePtrUnmarshaler(getUnmarshalInfo(t), name)
573
			}
574
			if slice {
575
				return makeStdFloatValueSliceUnmarshaler(getUnmarshalInfo(t), name)
576
			}
577
			return makeStdFloatValueUnmarshaler(getUnmarshalInfo(t), name)
578
		case reflect.Int64:
579
			if pointer {
580
				if slice {
581
					return makeStdInt64ValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
582
				}
583
				return makeStdInt64ValuePtrUnmarshaler(getUnmarshalInfo(t), name)
584
			}
585
			if slice {
586
				return makeStdInt64ValueSliceUnmarshaler(getUnmarshalInfo(t), name)
587
			}
588
			return makeStdInt64ValueUnmarshaler(getUnmarshalInfo(t), name)
589
		case reflect.Uint64:
590
			if pointer {
591
				if slice {
592
					return makeStdUInt64ValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
593
				}
594
				return makeStdUInt64ValuePtrUnmarshaler(getUnmarshalInfo(t), name)
595
			}
596
			if slice {
597
				return makeStdUInt64ValueSliceUnmarshaler(getUnmarshalInfo(t), name)
598
			}
599
			return makeStdUInt64ValueUnmarshaler(getUnmarshalInfo(t), name)
600
		case reflect.Int32:
601
			if pointer {
602
				if slice {
603
					return makeStdInt32ValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
604
				}
605
				return makeStdInt32ValuePtrUnmarshaler(getUnmarshalInfo(t), name)
606
			}
607
			if slice {
608
				return makeStdInt32ValueSliceUnmarshaler(getUnmarshalInfo(t), name)
609
			}
610
			return makeStdInt32ValueUnmarshaler(getUnmarshalInfo(t), name)
611
		case reflect.Uint32:
612
			if pointer {
613
				if slice {
614
					return makeStdUInt32ValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
615
				}
616
				return makeStdUInt32ValuePtrUnmarshaler(getUnmarshalInfo(t), name)
617
			}
618
			if slice {
619
				return makeStdUInt32ValueSliceUnmarshaler(getUnmarshalInfo(t), name)
620
			}
621
			return makeStdUInt32ValueUnmarshaler(getUnmarshalInfo(t), name)
622
		case reflect.Bool:
623
			if pointer {
624
				if slice {
625
					return makeStdBoolValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
626
				}
627
				return makeStdBoolValuePtrUnmarshaler(getUnmarshalInfo(t), name)
628
			}
629
			if slice {
630
				return makeStdBoolValueSliceUnmarshaler(getUnmarshalInfo(t), name)
631
			}
632
			return makeStdBoolValueUnmarshaler(getUnmarshalInfo(t), name)
633
		case reflect.String:
634
			if pointer {
635
				if slice {
636
					return makeStdStringValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
637
				}
638
				return makeStdStringValuePtrUnmarshaler(getUnmarshalInfo(t), name)
639
			}
640
			if slice {
641
				return makeStdStringValueSliceUnmarshaler(getUnmarshalInfo(t), name)
642
			}
643
			return makeStdStringValueUnmarshaler(getUnmarshalInfo(t), name)
644
		case uint8SliceType:
645
			if pointer {
646
				if slice {
647
					return makeStdBytesValuePtrSliceUnmarshaler(getUnmarshalInfo(t), name)
648
				}
649
				return makeStdBytesValuePtrUnmarshaler(getUnmarshalInfo(t), name)
650
			}
651
			if slice {
652
				return makeStdBytesValueSliceUnmarshaler(getUnmarshalInfo(t), name)
653
			}
654
			return makeStdBytesValueUnmarshaler(getUnmarshalInfo(t), name)
655
		default:
656
			panic(fmt.Sprintf("unknown wktpointer type %#v", t))
657
		}
658
	}
659

660
	// We'll never have both pointer and slice for basic types.
661
	if pointer && slice && t.Kind() != reflect.Struct {
662
		panic("both pointer and slice for basic type in " + t.Name())
663
	}
664

665
	switch t.Kind() {
666
	case reflect.Bool:
667
		if pointer {
668
			return unmarshalBoolPtr
669
		}
670
		if slice {
671
			return unmarshalBoolSlice
672
		}
673
		return unmarshalBoolValue
674
	case reflect.Int32:
675
		switch encoding {
676
		case "fixed32":
677
			if pointer {
678
				return unmarshalFixedS32Ptr
679
			}
680
			if slice {
681
				return unmarshalFixedS32Slice
682
			}
683
			return unmarshalFixedS32Value
684
		case "varint":
685
			// this could be int32 or enum
686
			if pointer {
687
				return unmarshalInt32Ptr
688
			}
689
			if slice {
690
				return unmarshalInt32Slice
691
			}
692
			return unmarshalInt32Value
693
		case "zigzag32":
694
			if pointer {
695
				return unmarshalSint32Ptr
696
			}
697
			if slice {
698
				return unmarshalSint32Slice
699
			}
700
			return unmarshalSint32Value
701
		}
702
	case reflect.Int64:
703
		switch encoding {
704
		case "fixed64":
705
			if pointer {
706
				return unmarshalFixedS64Ptr
707
			}
708
			if slice {
709
				return unmarshalFixedS64Slice
710
			}
711
			return unmarshalFixedS64Value
712
		case "varint":
713
			if pointer {
714
				return unmarshalInt64Ptr
715
			}
716
			if slice {
717
				return unmarshalInt64Slice
718
			}
719
			return unmarshalInt64Value
720
		case "zigzag64":
721
			if pointer {
722
				return unmarshalSint64Ptr
723
			}
724
			if slice {
725
				return unmarshalSint64Slice
726
			}
727
			return unmarshalSint64Value
728
		}
729
	case reflect.Uint32:
730
		switch encoding {
731
		case "fixed32":
732
			if pointer {
733
				return unmarshalFixed32Ptr
734
			}
735
			if slice {
736
				return unmarshalFixed32Slice
737
			}
738
			return unmarshalFixed32Value
739
		case "varint":
740
			if pointer {
741
				return unmarshalUint32Ptr
742
			}
743
			if slice {
744
				return unmarshalUint32Slice
745
			}
746
			return unmarshalUint32Value
747
		}
748
	case reflect.Uint64:
749
		switch encoding {
750
		case "fixed64":
751
			if pointer {
752
				return unmarshalFixed64Ptr
753
			}
754
			if slice {
755
				return unmarshalFixed64Slice
756
			}
757
			return unmarshalFixed64Value
758
		case "varint":
759
			if pointer {
760
				return unmarshalUint64Ptr
761
			}
762
			if slice {
763
				return unmarshalUint64Slice
764
			}
765
			return unmarshalUint64Value
766
		}
767
	case reflect.Float32:
768
		if pointer {
769
			return unmarshalFloat32Ptr
770
		}
771
		if slice {
772
			return unmarshalFloat32Slice
773
		}
774
		return unmarshalFloat32Value
775
	case reflect.Float64:
776
		if pointer {
777
			return unmarshalFloat64Ptr
778
		}
779
		if slice {
780
			return unmarshalFloat64Slice
781
		}
782
		return unmarshalFloat64Value
783
	case reflect.Map:
784
		panic("map type in typeUnmarshaler in " + t.Name())
785
	case reflect.Slice:
786
		if pointer {
787
			panic("bad pointer in slice case in " + t.Name())
788
		}
789
		if slice {
790
			return unmarshalBytesSlice
791
		}
792
		return unmarshalBytesValue
793
	case reflect.String:
794
		if validateUTF8 {
795
			if pointer {
796
				return unmarshalUTF8StringPtr
797
			}
798
			if slice {
799
				return unmarshalUTF8StringSlice
800
			}
801
			return unmarshalUTF8StringValue
802
		}
803
		if pointer {
804
			return unmarshalStringPtr
805
		}
806
		if slice {
807
			return unmarshalStringSlice
808
		}
809
		return unmarshalStringValue
810
	case reflect.Struct:
811
		// message or group field
812
		if !pointer {
813
			switch encoding {
814
			case "bytes":
815
				if slice {
816
					return makeUnmarshalMessageSlice(getUnmarshalInfo(t), name)
817
				}
818
				return makeUnmarshalMessage(getUnmarshalInfo(t), name)
819
			}
820
		}
821
		switch encoding {
822
		case "bytes":
823
			if slice {
824
				return makeUnmarshalMessageSlicePtr(getUnmarshalInfo(t), name)
825
			}
826
			return makeUnmarshalMessagePtr(getUnmarshalInfo(t), name)
827
		case "group":
828
			if slice {
829
				return makeUnmarshalGroupSlicePtr(getUnmarshalInfo(t), name)
830
			}
831
			return makeUnmarshalGroupPtr(getUnmarshalInfo(t), name)
832
		}
833
	}
834
	panic(fmt.Sprintf("unmarshaler not found type:%s encoding:%s", t, encoding))
835
}
836

837
// Below are all the unmarshalers for individual fields of various types.
838

839
func unmarshalInt64Value(b []byte, f pointer, w int) ([]byte, error) {
840
	if w != WireVarint {
841
		return b, errInternalBadWireType
842
	}
843
	x, n := decodeVarint(b)
844
	if n == 0 {
845
		return nil, io.ErrUnexpectedEOF
846
	}
847
	b = b[n:]
848
	v := int64(x)
849
	*f.toInt64() = v
850
	return b, nil
851
}
852

853
func unmarshalInt64Ptr(b []byte, f pointer, w int) ([]byte, error) {
854
	if w != WireVarint {
855
		return b, errInternalBadWireType
856
	}
857
	x, n := decodeVarint(b)
858
	if n == 0 {
859
		return nil, io.ErrUnexpectedEOF
860
	}
861
	b = b[n:]
862
	v := int64(x)
863
	*f.toInt64Ptr() = &v
864
	return b, nil
865
}
866

867
func unmarshalInt64Slice(b []byte, f pointer, w int) ([]byte, error) {
868
	if w == WireBytes { // packed
869
		x, n := decodeVarint(b)
870
		if n == 0 {
871
			return nil, io.ErrUnexpectedEOF
872
		}
873
		b = b[n:]
874
		if x > uint64(len(b)) {
875
			return nil, io.ErrUnexpectedEOF
876
		}
877
		res := b[x:]
878
		b = b[:x]
879
		for len(b) > 0 {
880
			x, n = decodeVarint(b)
881
			if n == 0 {
882
				return nil, io.ErrUnexpectedEOF
883
			}
884
			b = b[n:]
885
			v := int64(x)
886
			s := f.toInt64Slice()
887
			*s = append(*s, v)
888
		}
889
		return res, nil
890
	}
891
	if w != WireVarint {
892
		return b, errInternalBadWireType
893
	}
894
	x, n := decodeVarint(b)
895
	if n == 0 {
896
		return nil, io.ErrUnexpectedEOF
897
	}
898
	b = b[n:]
899
	v := int64(x)
900
	s := f.toInt64Slice()
901
	*s = append(*s, v)
902
	return b, nil
903
}
904

905
func unmarshalSint64Value(b []byte, f pointer, w int) ([]byte, error) {
906
	if w != WireVarint {
907
		return b, errInternalBadWireType
908
	}
909
	x, n := decodeVarint(b)
910
	if n == 0 {
911
		return nil, io.ErrUnexpectedEOF
912
	}
913
	b = b[n:]
914
	v := int64(x>>1) ^ int64(x)<<63>>63
915
	*f.toInt64() = v
916
	return b, nil
917
}
918

919
func unmarshalSint64Ptr(b []byte, f pointer, w int) ([]byte, error) {
920
	if w != WireVarint {
921
		return b, errInternalBadWireType
922
	}
923
	x, n := decodeVarint(b)
924
	if n == 0 {
925
		return nil, io.ErrUnexpectedEOF
926
	}
927
	b = b[n:]
928
	v := int64(x>>1) ^ int64(x)<<63>>63
929
	*f.toInt64Ptr() = &v
930
	return b, nil
931
}
932

933
func unmarshalSint64Slice(b []byte, f pointer, w int) ([]byte, error) {
934
	if w == WireBytes { // packed
935
		x, n := decodeVarint(b)
936
		if n == 0 {
937
			return nil, io.ErrUnexpectedEOF
938
		}
939
		b = b[n:]
940
		if x > uint64(len(b)) {
941
			return nil, io.ErrUnexpectedEOF
942
		}
943
		res := b[x:]
944
		b = b[:x]
945
		for len(b) > 0 {
946
			x, n = decodeVarint(b)
947
			if n == 0 {
948
				return nil, io.ErrUnexpectedEOF
949
			}
950
			b = b[n:]
951
			v := int64(x>>1) ^ int64(x)<<63>>63
952
			s := f.toInt64Slice()
953
			*s = append(*s, v)
954
		}
955
		return res, nil
956
	}
957
	if w != WireVarint {
958
		return b, errInternalBadWireType
959
	}
960
	x, n := decodeVarint(b)
961
	if n == 0 {
962
		return nil, io.ErrUnexpectedEOF
963
	}
964
	b = b[n:]
965
	v := int64(x>>1) ^ int64(x)<<63>>63
966
	s := f.toInt64Slice()
967
	*s = append(*s, v)
968
	return b, nil
969
}
970

971
func unmarshalUint64Value(b []byte, f pointer, w int) ([]byte, error) {
972
	if w != WireVarint {
973
		return b, errInternalBadWireType
974
	}
975
	x, n := decodeVarint(b)
976
	if n == 0 {
977
		return nil, io.ErrUnexpectedEOF
978
	}
979
	b = b[n:]
980
	v := uint64(x)
981
	*f.toUint64() = v
982
	return b, nil
983
}
984

985
func unmarshalUint64Ptr(b []byte, f pointer, w int) ([]byte, error) {
986
	if w != WireVarint {
987
		return b, errInternalBadWireType
988
	}
989
	x, n := decodeVarint(b)
990
	if n == 0 {
991
		return nil, io.ErrUnexpectedEOF
992
	}
993
	b = b[n:]
994
	v := uint64(x)
995
	*f.toUint64Ptr() = &v
996
	return b, nil
997
}
998

999
func unmarshalUint64Slice(b []byte, f pointer, w int) ([]byte, error) {
1000
	if w == WireBytes { // packed
1001
		x, n := decodeVarint(b)
1002
		if n == 0 {
1003
			return nil, io.ErrUnexpectedEOF
1004
		}
1005
		b = b[n:]
1006
		if x > uint64(len(b)) {
1007
			return nil, io.ErrUnexpectedEOF
1008
		}
1009
		res := b[x:]
1010
		b = b[:x]
1011
		for len(b) > 0 {
1012
			x, n = decodeVarint(b)
1013
			if n == 0 {
1014
				return nil, io.ErrUnexpectedEOF
1015
			}
1016
			b = b[n:]
1017
			v := uint64(x)
1018
			s := f.toUint64Slice()
1019
			*s = append(*s, v)
1020
		}
1021
		return res, nil
1022
	}
1023
	if w != WireVarint {
1024
		return b, errInternalBadWireType
1025
	}
1026
	x, n := decodeVarint(b)
1027
	if n == 0 {
1028
		return nil, io.ErrUnexpectedEOF
1029
	}
1030
	b = b[n:]
1031
	v := uint64(x)
1032
	s := f.toUint64Slice()
1033
	*s = append(*s, v)
1034
	return b, nil
1035
}
1036

1037
func unmarshalInt32Value(b []byte, f pointer, w int) ([]byte, error) {
1038
	if w != WireVarint {
1039
		return b, errInternalBadWireType
1040
	}
1041
	x, n := decodeVarint(b)
1042
	if n == 0 {
1043
		return nil, io.ErrUnexpectedEOF
1044
	}
1045
	b = b[n:]
1046
	v := int32(x)
1047
	*f.toInt32() = v
1048
	return b, nil
1049
}
1050

1051
func unmarshalInt32Ptr(b []byte, f pointer, w int) ([]byte, error) {
1052
	if w != WireVarint {
1053
		return b, errInternalBadWireType
1054
	}
1055
	x, n := decodeVarint(b)
1056
	if n == 0 {
1057
		return nil, io.ErrUnexpectedEOF
1058
	}
1059
	b = b[n:]
1060
	v := int32(x)
1061
	f.setInt32Ptr(v)
1062
	return b, nil
1063
}
1064

1065
func unmarshalInt32Slice(b []byte, f pointer, w int) ([]byte, error) {
1066
	if w == WireBytes { // packed
1067
		x, n := decodeVarint(b)
1068
		if n == 0 {
1069
			return nil, io.ErrUnexpectedEOF
1070
		}
1071
		b = b[n:]
1072
		if x > uint64(len(b)) {
1073
			return nil, io.ErrUnexpectedEOF
1074
		}
1075
		res := b[x:]
1076
		b = b[:x]
1077
		for len(b) > 0 {
1078
			x, n = decodeVarint(b)
1079
			if n == 0 {
1080
				return nil, io.ErrUnexpectedEOF
1081
			}
1082
			b = b[n:]
1083
			v := int32(x)
1084
			f.appendInt32Slice(v)
1085
		}
1086
		return res, nil
1087
	}
1088
	if w != WireVarint {
1089
		return b, errInternalBadWireType
1090
	}
1091
	x, n := decodeVarint(b)
1092
	if n == 0 {
1093
		return nil, io.ErrUnexpectedEOF
1094
	}
1095
	b = b[n:]
1096
	v := int32(x)
1097
	f.appendInt32Slice(v)
1098
	return b, nil
1099
}
1100

1101
func unmarshalSint32Value(b []byte, f pointer, w int) ([]byte, error) {
1102
	if w != WireVarint {
1103
		return b, errInternalBadWireType
1104
	}
1105
	x, n := decodeVarint(b)
1106
	if n == 0 {
1107
		return nil, io.ErrUnexpectedEOF
1108
	}
1109
	b = b[n:]
1110
	v := int32(x>>1) ^ int32(x)<<31>>31
1111
	*f.toInt32() = v
1112
	return b, nil
1113
}
1114

1115
func unmarshalSint32Ptr(b []byte, f pointer, w int) ([]byte, error) {
1116
	if w != WireVarint {
1117
		return b, errInternalBadWireType
1118
	}
1119
	x, n := decodeVarint(b)
1120
	if n == 0 {
1121
		return nil, io.ErrUnexpectedEOF
1122
	}
1123
	b = b[n:]
1124
	v := int32(x>>1) ^ int32(x)<<31>>31
1125
	f.setInt32Ptr(v)
1126
	return b, nil
1127
}
1128

1129
func unmarshalSint32Slice(b []byte, f pointer, w int) ([]byte, error) {
1130
	if w == WireBytes { // packed
1131
		x, n := decodeVarint(b)
1132
		if n == 0 {
1133
			return nil, io.ErrUnexpectedEOF
1134
		}
1135
		b = b[n:]
1136
		if x > uint64(len(b)) {
1137
			return nil, io.ErrUnexpectedEOF
1138
		}
1139
		res := b[x:]
1140
		b = b[:x]
1141
		for len(b) > 0 {
1142
			x, n = decodeVarint(b)
1143
			if n == 0 {
1144
				return nil, io.ErrUnexpectedEOF
1145
			}
1146
			b = b[n:]
1147
			v := int32(x>>1) ^ int32(x)<<31>>31
1148
			f.appendInt32Slice(v)
1149
		}
1150
		return res, nil
1151
	}
1152
	if w != WireVarint {
1153
		return b, errInternalBadWireType
1154
	}
1155
	x, n := decodeVarint(b)
1156
	if n == 0 {
1157
		return nil, io.ErrUnexpectedEOF
1158
	}
1159
	b = b[n:]
1160
	v := int32(x>>1) ^ int32(x)<<31>>31
1161
	f.appendInt32Slice(v)
1162
	return b, nil
1163
}
1164

1165
func unmarshalUint32Value(b []byte, f pointer, w int) ([]byte, error) {
1166
	if w != WireVarint {
1167
		return b, errInternalBadWireType
1168
	}
1169
	x, n := decodeVarint(b)
1170
	if n == 0 {
1171
		return nil, io.ErrUnexpectedEOF
1172
	}
1173
	b = b[n:]
1174
	v := uint32(x)
1175
	*f.toUint32() = v
1176
	return b, nil
1177
}
1178

1179
func unmarshalUint32Ptr(b []byte, f pointer, w int) ([]byte, error) {
1180
	if w != WireVarint {
1181
		return b, errInternalBadWireType
1182
	}
1183
	x, n := decodeVarint(b)
1184
	if n == 0 {
1185
		return nil, io.ErrUnexpectedEOF
1186
	}
1187
	b = b[n:]
1188
	v := uint32(x)
1189
	*f.toUint32Ptr() = &v
1190
	return b, nil
1191
}
1192

1193
func unmarshalUint32Slice(b []byte, f pointer, w int) ([]byte, error) {
1194
	if w == WireBytes { // packed
1195
		x, n := decodeVarint(b)
1196
		if n == 0 {
1197
			return nil, io.ErrUnexpectedEOF
1198
		}
1199
		b = b[n:]
1200
		if x > uint64(len(b)) {
1201
			return nil, io.ErrUnexpectedEOF
1202
		}
1203
		res := b[x:]
1204
		b = b[:x]
1205
		for len(b) > 0 {
1206
			x, n = decodeVarint(b)
1207
			if n == 0 {
1208
				return nil, io.ErrUnexpectedEOF
1209
			}
1210
			b = b[n:]
1211
			v := uint32(x)
1212
			s := f.toUint32Slice()
1213
			*s = append(*s, v)
1214
		}
1215
		return res, nil
1216
	}
1217
	if w != WireVarint {
1218
		return b, errInternalBadWireType
1219
	}
1220
	x, n := decodeVarint(b)
1221
	if n == 0 {
1222
		return nil, io.ErrUnexpectedEOF
1223
	}
1224
	b = b[n:]
1225
	v := uint32(x)
1226
	s := f.toUint32Slice()
1227
	*s = append(*s, v)
1228
	return b, nil
1229
}
1230

1231
func unmarshalFixed64Value(b []byte, f pointer, w int) ([]byte, error) {
1232
	if w != WireFixed64 {
1233
		return b, errInternalBadWireType
1234
	}
1235
	if len(b) < 8 {
1236
		return nil, io.ErrUnexpectedEOF
1237
	}
1238
	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
1239
	*f.toUint64() = v
1240
	return b[8:], nil
1241
}
1242

1243
func unmarshalFixed64Ptr(b []byte, f pointer, w int) ([]byte, error) {
1244
	if w != WireFixed64 {
1245
		return b, errInternalBadWireType
1246
	}
1247
	if len(b) < 8 {
1248
		return nil, io.ErrUnexpectedEOF
1249
	}
1250
	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
1251
	*f.toUint64Ptr() = &v
1252
	return b[8:], nil
1253
}
1254

1255
func unmarshalFixed64Slice(b []byte, f pointer, w int) ([]byte, error) {
1256
	if w == WireBytes { // packed
1257
		x, n := decodeVarint(b)
1258
		if n == 0 {
1259
			return nil, io.ErrUnexpectedEOF
1260
		}
1261
		b = b[n:]
1262
		if x > uint64(len(b)) {
1263
			return nil, io.ErrUnexpectedEOF
1264
		}
1265
		res := b[x:]
1266
		b = b[:x]
1267
		for len(b) > 0 {
1268
			if len(b) < 8 {
1269
				return nil, io.ErrUnexpectedEOF
1270
			}
1271
			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
1272
			s := f.toUint64Slice()
1273
			*s = append(*s, v)
1274
			b = b[8:]
1275
		}
1276
		return res, nil
1277
	}
1278
	if w != WireFixed64 {
1279
		return b, errInternalBadWireType
1280
	}
1281
	if len(b) < 8 {
1282
		return nil, io.ErrUnexpectedEOF
1283
	}
1284
	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
1285
	s := f.toUint64Slice()
1286
	*s = append(*s, v)
1287
	return b[8:], nil
1288
}
1289

1290
func unmarshalFixedS64Value(b []byte, f pointer, w int) ([]byte, error) {
1291
	if w != WireFixed64 {
1292
		return b, errInternalBadWireType
1293
	}
1294
	if len(b) < 8 {
1295
		return nil, io.ErrUnexpectedEOF
1296
	}
1297
	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
1298
	*f.toInt64() = v
1299
	return b[8:], nil
1300
}
1301

1302
func unmarshalFixedS64Ptr(b []byte, f pointer, w int) ([]byte, error) {
1303
	if w != WireFixed64 {
1304
		return b, errInternalBadWireType
1305
	}
1306
	if len(b) < 8 {
1307
		return nil, io.ErrUnexpectedEOF
1308
	}
1309
	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
1310
	*f.toInt64Ptr() = &v
1311
	return b[8:], nil
1312
}
1313

1314
func unmarshalFixedS64Slice(b []byte, f pointer, w int) ([]byte, error) {
1315
	if w == WireBytes { // packed
1316
		x, n := decodeVarint(b)
1317
		if n == 0 {
1318
			return nil, io.ErrUnexpectedEOF
1319
		}
1320
		b = b[n:]
1321
		if x > uint64(len(b)) {
1322
			return nil, io.ErrUnexpectedEOF
1323
		}
1324
		res := b[x:]
1325
		b = b[:x]
1326
		for len(b) > 0 {
1327
			if len(b) < 8 {
1328
				return nil, io.ErrUnexpectedEOF
1329
			}
1330
			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
1331
			s := f.toInt64Slice()
1332
			*s = append(*s, v)
1333
			b = b[8:]
1334
		}
1335
		return res, nil
1336
	}
1337
	if w != WireFixed64 {
1338
		return b, errInternalBadWireType
1339
	}
1340
	if len(b) < 8 {
1341
		return nil, io.ErrUnexpectedEOF
1342
	}
1343
	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
1344
	s := f.toInt64Slice()
1345
	*s = append(*s, v)
1346
	return b[8:], nil
1347
}
1348

1349
func unmarshalFixed32Value(b []byte, f pointer, w int) ([]byte, error) {
1350
	if w != WireFixed32 {
1351
		return b, errInternalBadWireType
1352
	}
1353
	if len(b) < 4 {
1354
		return nil, io.ErrUnexpectedEOF
1355
	}
1356
	v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
1357
	*f.toUint32() = v
1358
	return b[4:], nil
1359
}
1360

1361
func unmarshalFixed32Ptr(b []byte, f pointer, w int) ([]byte, error) {
1362
	if w != WireFixed32 {
1363
		return b, errInternalBadWireType
1364
	}
1365
	if len(b) < 4 {
1366
		return nil, io.ErrUnexpectedEOF
1367
	}
1368
	v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
1369
	*f.toUint32Ptr() = &v
1370
	return b[4:], nil
1371
}
1372

1373
func unmarshalFixed32Slice(b []byte, f pointer, w int) ([]byte, error) {
1374
	if w == WireBytes { // packed
1375
		x, n := decodeVarint(b)
1376
		if n == 0 {
1377
			return nil, io.ErrUnexpectedEOF
1378
		}
1379
		b = b[n:]
1380
		if x > uint64(len(b)) {
1381
			return nil, io.ErrUnexpectedEOF
1382
		}
1383
		res := b[x:]
1384
		b = b[:x]
1385
		for len(b) > 0 {
1386
			if len(b) < 4 {
1387
				return nil, io.ErrUnexpectedEOF
1388
			}
1389
			v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
1390
			s := f.toUint32Slice()
1391
			*s = append(*s, v)
1392
			b = b[4:]
1393
		}
1394
		return res, nil
1395
	}
1396
	if w != WireFixed32 {
1397
		return b, errInternalBadWireType
1398
	}
1399
	if len(b) < 4 {
1400
		return nil, io.ErrUnexpectedEOF
1401
	}
1402
	v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
1403
	s := f.toUint32Slice()
1404
	*s = append(*s, v)
1405
	return b[4:], nil
1406
}
1407

1408
func unmarshalFixedS32Value(b []byte, f pointer, w int) ([]byte, error) {
1409
	if w != WireFixed32 {
1410
		return b, errInternalBadWireType
1411
	}
1412
	if len(b) < 4 {
1413
		return nil, io.ErrUnexpectedEOF
1414
	}
1415
	v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
1416
	*f.toInt32() = v
1417
	return b[4:], nil
1418
}
1419

1420
func unmarshalFixedS32Ptr(b []byte, f pointer, w int) ([]byte, error) {
1421
	if w != WireFixed32 {
1422
		return b, errInternalBadWireType
1423
	}
1424
	if len(b) < 4 {
1425
		return nil, io.ErrUnexpectedEOF
1426
	}
1427
	v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
1428
	f.setInt32Ptr(v)
1429
	return b[4:], nil
1430
}
1431

1432
func unmarshalFixedS32Slice(b []byte, f pointer, w int) ([]byte, error) {
1433
	if w == WireBytes { // packed
1434
		x, n := decodeVarint(b)
1435
		if n == 0 {
1436
			return nil, io.ErrUnexpectedEOF
1437
		}
1438
		b = b[n:]
1439
		if x > uint64(len(b)) {
1440
			return nil, io.ErrUnexpectedEOF
1441
		}
1442
		res := b[x:]
1443
		b = b[:x]
1444
		for len(b) > 0 {
1445
			if len(b) < 4 {
1446
				return nil, io.ErrUnexpectedEOF
1447
			}
1448
			v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
1449
			f.appendInt32Slice(v)
1450
			b = b[4:]
1451
		}
1452
		return res, nil
1453
	}
1454
	if w != WireFixed32 {
1455
		return b, errInternalBadWireType
1456
	}
1457
	if len(b) < 4 {
1458
		return nil, io.ErrUnexpectedEOF
1459
	}
1460
	v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
1461
	f.appendInt32Slice(v)
1462
	return b[4:], nil
1463
}
1464

1465
func unmarshalBoolValue(b []byte, f pointer, w int) ([]byte, error) {
1466
	if w != WireVarint {
1467
		return b, errInternalBadWireType
1468
	}
1469
	// Note: any length varint is allowed, even though any sane
1470
	// encoder will use one byte.
1471
	// See https://github.com/golang/protobuf/issues/76
1472
	x, n := decodeVarint(b)
1473
	if n == 0 {
1474
		return nil, io.ErrUnexpectedEOF
1475
	}
1476
	// TODO: check if x>1? Tests seem to indicate no.
1477
	v := x != 0
1478
	*f.toBool() = v
1479
	return b[n:], nil
1480
}
1481

1482
func unmarshalBoolPtr(b []byte, f pointer, w int) ([]byte, error) {
1483
	if w != WireVarint {
1484
		return b, errInternalBadWireType
1485
	}
1486
	x, n := decodeVarint(b)
1487
	if n == 0 {
1488
		return nil, io.ErrUnexpectedEOF
1489
	}
1490
	v := x != 0
1491
	*f.toBoolPtr() = &v
1492
	return b[n:], nil
1493
}
1494

1495
func unmarshalBoolSlice(b []byte, f pointer, w int) ([]byte, error) {
1496
	if w == WireBytes { // packed
1497
		x, n := decodeVarint(b)
1498
		if n == 0 {
1499
			return nil, io.ErrUnexpectedEOF
1500
		}
1501
		b = b[n:]
1502
		if x > uint64(len(b)) {
1503
			return nil, io.ErrUnexpectedEOF
1504
		}
1505
		res := b[x:]
1506
		b = b[:x]
1507
		for len(b) > 0 {
1508
			x, n = decodeVarint(b)
1509
			if n == 0 {
1510
				return nil, io.ErrUnexpectedEOF
1511
			}
1512
			v := x != 0
1513
			s := f.toBoolSlice()
1514
			*s = append(*s, v)
1515
			b = b[n:]
1516
		}
1517
		return res, nil
1518
	}
1519
	if w != WireVarint {
1520
		return b, errInternalBadWireType
1521
	}
1522
	x, n := decodeVarint(b)
1523
	if n == 0 {
1524
		return nil, io.ErrUnexpectedEOF
1525
	}
1526
	v := x != 0
1527
	s := f.toBoolSlice()
1528
	*s = append(*s, v)
1529
	return b[n:], nil
1530
}
1531

1532
func unmarshalFloat64Value(b []byte, f pointer, w int) ([]byte, error) {
1533
	if w != WireFixed64 {
1534
		return b, errInternalBadWireType
1535
	}
1536
	if len(b) < 8 {
1537
		return nil, io.ErrUnexpectedEOF
1538
	}
1539
	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)
1540
	*f.toFloat64() = v
1541
	return b[8:], nil
1542
}
1543

1544
func unmarshalFloat64Ptr(b []byte, f pointer, w int) ([]byte, error) {
1545
	if w != WireFixed64 {
1546
		return b, errInternalBadWireType
1547
	}
1548
	if len(b) < 8 {
1549
		return nil, io.ErrUnexpectedEOF
1550
	}
1551
	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)
1552
	*f.toFloat64Ptr() = &v
1553
	return b[8:], nil
1554
}
1555

1556
func unmarshalFloat64Slice(b []byte, f pointer, w int) ([]byte, error) {
1557
	if w == WireBytes { // packed
1558
		x, n := decodeVarint(b)
1559
		if n == 0 {
1560
			return nil, io.ErrUnexpectedEOF
1561
		}
1562
		b = b[n:]
1563
		if x > uint64(len(b)) {
1564
			return nil, io.ErrUnexpectedEOF
1565
		}
1566
		res := b[x:]
1567
		b = b[:x]
1568
		for len(b) > 0 {
1569
			if len(b) < 8 {
1570
				return nil, io.ErrUnexpectedEOF
1571
			}
1572
			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)
1573
			s := f.toFloat64Slice()
1574
			*s = append(*s, v)
1575
			b = b[8:]
1576
		}
1577
		return res, nil
1578
	}
1579
	if w != WireFixed64 {
1580
		return b, errInternalBadWireType
1581
	}
1582
	if len(b) < 8 {
1583
		return nil, io.ErrUnexpectedEOF
1584
	}
1585
	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)
1586
	s := f.toFloat64Slice()
1587
	*s = append(*s, v)
1588
	return b[8:], nil
1589
}
1590

1591
func unmarshalFloat32Value(b []byte, f pointer, w int) ([]byte, error) {
1592
	if w != WireFixed32 {
1593
		return b, errInternalBadWireType
1594
	}
1595
	if len(b) < 4 {
1596
		return nil, io.ErrUnexpectedEOF
1597
	}
1598
	v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
1599
	*f.toFloat32() = v
1600
	return b[4:], nil
1601
}
1602

1603
func unmarshalFloat32Ptr(b []byte, f pointer, w int) ([]byte, error) {
1604
	if w != WireFixed32 {
1605
		return b, errInternalBadWireType
1606
	}
1607
	if len(b) < 4 {
1608
		return nil, io.ErrUnexpectedEOF
1609
	}
1610
	v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
1611
	*f.toFloat32Ptr() = &v
1612
	return b[4:], nil
1613
}
1614

1615
func unmarshalFloat32Slice(b []byte, f pointer, w int) ([]byte, error) {
1616
	if w == WireBytes { // packed
1617
		x, n := decodeVarint(b)
1618
		if n == 0 {
1619
			return nil, io.ErrUnexpectedEOF
1620
		}
1621
		b = b[n:]
1622
		if x > uint64(len(b)) {
1623
			return nil, io.ErrUnexpectedEOF
1624
		}
1625
		res := b[x:]
1626
		b = b[:x]
1627
		for len(b) > 0 {
1628
			if len(b) < 4 {
1629
				return nil, io.ErrUnexpectedEOF
1630
			}
1631
			v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
1632
			s := f.toFloat32Slice()
1633
			*s = append(*s, v)
1634
			b = b[4:]
1635
		}
1636
		return res, nil
1637
	}
1638
	if w != WireFixed32 {
1639
		return b, errInternalBadWireType
1640
	}
1641
	if len(b) < 4 {
1642
		return nil, io.ErrUnexpectedEOF
1643
	}
1644
	v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
1645
	s := f.toFloat32Slice()
1646
	*s = append(*s, v)
1647
	return b[4:], nil
1648
}
1649

1650
func unmarshalStringValue(b []byte, f pointer, w int) ([]byte, error) {
1651
	if w != WireBytes {
1652
		return b, errInternalBadWireType
1653
	}
1654
	x, n := decodeVarint(b)
1655
	if n == 0 {
1656
		return nil, io.ErrUnexpectedEOF
1657
	}
1658
	b = b[n:]
1659
	if x > uint64(len(b)) {
1660
		return nil, io.ErrUnexpectedEOF
1661
	}
1662
	v := string(b[:x])
1663
	*f.toString() = v
1664
	return b[x:], nil
1665
}
1666

1667
func unmarshalStringPtr(b []byte, f pointer, w int) ([]byte, error) {
1668
	if w != WireBytes {
1669
		return b, errInternalBadWireType
1670
	}
1671
	x, n := decodeVarint(b)
1672
	if n == 0 {
1673
		return nil, io.ErrUnexpectedEOF
1674
	}
1675
	b = b[n:]
1676
	if x > uint64(len(b)) {
1677
		return nil, io.ErrUnexpectedEOF
1678
	}
1679
	v := string(b[:x])
1680
	*f.toStringPtr() = &v
1681
	return b[x:], nil
1682
}
1683

1684
func unmarshalStringSlice(b []byte, f pointer, w int) ([]byte, error) {
1685
	if w != WireBytes {
1686
		return b, errInternalBadWireType
1687
	}
1688
	x, n := decodeVarint(b)
1689
	if n == 0 {
1690
		return nil, io.ErrUnexpectedEOF
1691
	}
1692
	b = b[n:]
1693
	if x > uint64(len(b)) {
1694
		return nil, io.ErrUnexpectedEOF
1695
	}
1696
	v := string(b[:x])
1697
	s := f.toStringSlice()
1698
	*s = append(*s, v)
1699
	return b[x:], nil
1700
}
1701

1702
func unmarshalUTF8StringValue(b []byte, f pointer, w int) ([]byte, error) {
1703
	if w != WireBytes {
1704
		return b, errInternalBadWireType
1705
	}
1706
	x, n := decodeVarint(b)
1707
	if n == 0 {
1708
		return nil, io.ErrUnexpectedEOF
1709
	}
1710
	b = b[n:]
1711
	if x > uint64(len(b)) {
1712
		return nil, io.ErrUnexpectedEOF
1713
	}
1714
	v := string(b[:x])
1715
	*f.toString() = v
1716
	if !utf8.ValidString(v) {
1717
		return b[x:], errInvalidUTF8
1718
	}
1719
	return b[x:], nil
1720
}
1721

1722
func unmarshalUTF8StringPtr(b []byte, f pointer, w int) ([]byte, error) {
1723
	if w != WireBytes {
1724
		return b, errInternalBadWireType
1725
	}
1726
	x, n := decodeVarint(b)
1727
	if n == 0 {
1728
		return nil, io.ErrUnexpectedEOF
1729
	}
1730
	b = b[n:]
1731
	if x > uint64(len(b)) {
1732
		return nil, io.ErrUnexpectedEOF
1733
	}
1734
	v := string(b[:x])
1735
	*f.toStringPtr() = &v
1736
	if !utf8.ValidString(v) {
1737
		return b[x:], errInvalidUTF8
1738
	}
1739
	return b[x:], nil
1740
}
1741

1742
func unmarshalUTF8StringSlice(b []byte, f pointer, w int) ([]byte, error) {
1743
	if w != WireBytes {
1744
		return b, errInternalBadWireType
1745
	}
1746
	x, n := decodeVarint(b)
1747
	if n == 0 {
1748
		return nil, io.ErrUnexpectedEOF
1749
	}
1750
	b = b[n:]
1751
	if x > uint64(len(b)) {
1752
		return nil, io.ErrUnexpectedEOF
1753
	}
1754
	v := string(b[:x])
1755
	s := f.toStringSlice()
1756
	*s = append(*s, v)
1757
	if !utf8.ValidString(v) {
1758
		return b[x:], errInvalidUTF8
1759
	}
1760
	return b[x:], nil
1761
}
1762

1763
var emptyBuf [0]byte
1764

1765
func unmarshalBytesValue(b []byte, f pointer, w int) ([]byte, error) {
1766
	if w != WireBytes {
1767
		return b, errInternalBadWireType
1768
	}
1769
	x, n := decodeVarint(b)
1770
	if n == 0 {
1771
		return nil, io.ErrUnexpectedEOF
1772
	}
1773
	b = b[n:]
1774
	if x > uint64(len(b)) {
1775
		return nil, io.ErrUnexpectedEOF
1776
	}
1777
	// The use of append here is a trick which avoids the zeroing
1778
	// that would be required if we used a make/copy pair.
1779
	// We append to emptyBuf instead of nil because we want
1780
	// a non-nil result even when the length is 0.
1781
	v := append(emptyBuf[:], b[:x]...)
1782
	*f.toBytes() = v
1783
	return b[x:], nil
1784
}
1785

1786
func unmarshalBytesSlice(b []byte, f pointer, w int) ([]byte, error) {
1787
	if w != WireBytes {
1788
		return b, errInternalBadWireType
1789
	}
1790
	x, n := decodeVarint(b)
1791
	if n == 0 {
1792
		return nil, io.ErrUnexpectedEOF
1793
	}
1794
	b = b[n:]
1795
	if x > uint64(len(b)) {
1796
		return nil, io.ErrUnexpectedEOF
1797
	}
1798
	v := append(emptyBuf[:], b[:x]...)
1799
	s := f.toBytesSlice()
1800
	*s = append(*s, v)
1801
	return b[x:], nil
1802
}
1803

1804
func makeUnmarshalMessagePtr(sub *unmarshalInfo, name string) unmarshaler {
1805
	return func(b []byte, f pointer, w int) ([]byte, error) {
1806
		if w != WireBytes {
1807
			return b, errInternalBadWireType
1808
		}
1809
		x, n := decodeVarint(b)
1810
		if n == 0 {
1811
			return nil, io.ErrUnexpectedEOF
1812
		}
1813
		b = b[n:]
1814
		if x > uint64(len(b)) {
1815
			return nil, io.ErrUnexpectedEOF
1816
		}
1817
		// First read the message field to see if something is there.
1818
		// The semantics of multiple submessages are weird.  Instead of
1819
		// the last one winning (as it is for all other fields), multiple
1820
		// submessages are merged.
1821
		v := f.getPointer()
1822
		if v.isNil() {
1823
			v = valToPointer(reflect.New(sub.typ))
1824
			f.setPointer(v)
1825
		}
1826
		err := sub.unmarshal(v, b[:x])
1827
		if err != nil {
1828
			if r, ok := err.(*RequiredNotSetError); ok {
1829
				r.field = name + "." + r.field
1830
			} else {
1831
				return nil, err
1832
			}
1833
		}
1834
		return b[x:], err
1835
	}
1836
}
1837

1838
func makeUnmarshalMessageSlicePtr(sub *unmarshalInfo, name string) unmarshaler {
1839
	return func(b []byte, f pointer, w int) ([]byte, error) {
1840
		if w != WireBytes {
1841
			return b, errInternalBadWireType
1842
		}
1843
		x, n := decodeVarint(b)
1844
		if n == 0 {
1845
			return nil, io.ErrUnexpectedEOF
1846
		}
1847
		b = b[n:]
1848
		if x > uint64(len(b)) {
1849
			return nil, io.ErrUnexpectedEOF
1850
		}
1851
		v := valToPointer(reflect.New(sub.typ))
1852
		err := sub.unmarshal(v, b[:x])
1853
		if err != nil {
1854
			if r, ok := err.(*RequiredNotSetError); ok {
1855
				r.field = name + "." + r.field
1856
			} else {
1857
				return nil, err
1858
			}
1859
		}
1860
		f.appendPointer(v)
1861
		return b[x:], err
1862
	}
1863
}
1864

1865
func makeUnmarshalGroupPtr(sub *unmarshalInfo, name string) unmarshaler {
1866
	return func(b []byte, f pointer, w int) ([]byte, error) {
1867
		if w != WireStartGroup {
1868
			return b, errInternalBadWireType
1869
		}
1870
		x, y := findEndGroup(b)
1871
		if x < 0 {
1872
			return nil, io.ErrUnexpectedEOF
1873
		}
1874
		v := f.getPointer()
1875
		if v.isNil() {
1876
			v = valToPointer(reflect.New(sub.typ))
1877
			f.setPointer(v)
1878
		}
1879
		err := sub.unmarshal(v, b[:x])
1880
		if err != nil {
1881
			if r, ok := err.(*RequiredNotSetError); ok {
1882
				r.field = name + "." + r.field
1883
			} else {
1884
				return nil, err
1885
			}
1886
		}
1887
		return b[y:], err
1888
	}
1889
}
1890

1891
func makeUnmarshalGroupSlicePtr(sub *unmarshalInfo, name string) unmarshaler {
1892
	return func(b []byte, f pointer, w int) ([]byte, error) {
1893
		if w != WireStartGroup {
1894
			return b, errInternalBadWireType
1895
		}
1896
		x, y := findEndGroup(b)
1897
		if x < 0 {
1898
			return nil, io.ErrUnexpectedEOF
1899
		}
1900
		v := valToPointer(reflect.New(sub.typ))
1901
		err := sub.unmarshal(v, b[:x])
1902
		if err != nil {
1903
			if r, ok := err.(*RequiredNotSetError); ok {
1904
				r.field = name + "." + r.field
1905
			} else {
1906
				return nil, err
1907
			}
1908
		}
1909
		f.appendPointer(v)
1910
		return b[y:], err
1911
	}
1912
}
1913

1914
func makeUnmarshalMap(f *reflect.StructField) unmarshaler {
1915
	t := f.Type
1916
	kt := t.Key()
1917
	vt := t.Elem()
1918
	tagArray := strings.Split(f.Tag.Get("protobuf"), ",")
1919
	valTags := strings.Split(f.Tag.Get("protobuf_val"), ",")
1920
	for _, t := range tagArray {
1921
		if strings.HasPrefix(t, "customtype=") {
1922
			valTags = append(valTags, t)
1923
		}
1924
		if t == "stdtime" {
1925
			valTags = append(valTags, t)
1926
		}
1927
		if t == "stdduration" {
1928
			valTags = append(valTags, t)
1929
		}
1930
		if t == "wktptr" {
1931
			valTags = append(valTags, t)
1932
		}
1933
	}
1934
	unmarshalKey := typeUnmarshaler(kt, f.Tag.Get("protobuf_key"))
1935
	unmarshalVal := typeUnmarshaler(vt, strings.Join(valTags, ","))
1936
	return func(b []byte, f pointer, w int) ([]byte, error) {
1937
		// The map entry is a submessage. Figure out how big it is.
1938
		if w != WireBytes {
1939
			return nil, fmt.Errorf("proto: bad wiretype for map field: got %d want %d", w, WireBytes)
1940
		}
1941
		x, n := decodeVarint(b)
1942
		if n == 0 {
1943
			return nil, io.ErrUnexpectedEOF
1944
		}
1945
		b = b[n:]
1946
		if x > uint64(len(b)) {
1947
			return nil, io.ErrUnexpectedEOF
1948
		}
1949
		r := b[x:] // unused data to return
1950
		b = b[:x]  // data for map entry
1951

1952
		// Note: we could use #keys * #values ~= 200 functions
1953
		// to do map decoding without reflection. Probably not worth it.
1954
		// Maps will be somewhat slow. Oh well.
1955

1956
		// Read key and value from data.
1957
		var nerr nonFatal
1958
		k := reflect.New(kt)
1959
		v := reflect.New(vt)
1960
		for len(b) > 0 {
1961
			x, n := decodeVarint(b)
1962
			if n == 0 {
1963
				return nil, io.ErrUnexpectedEOF
1964
			}
1965
			wire := int(x) & 7
1966
			b = b[n:]
1967

1968
			var err error
1969
			switch x >> 3 {
1970
			case 1:
1971
				b, err = unmarshalKey(b, valToPointer(k), wire)
1972
			case 2:
1973
				b, err = unmarshalVal(b, valToPointer(v), wire)
1974
			default:
1975
				err = errInternalBadWireType // skip unknown tag
1976
			}
1977

1978
			if nerr.Merge(err) {
1979
				continue
1980
			}
1981
			if err != errInternalBadWireType {
1982
				return nil, err
1983
			}
1984

1985
			// Skip past unknown fields.
1986
			b, err = skipField(b, wire)
1987
			if err != nil {
1988
				return nil, err
1989
			}
1990
		}
1991

1992
		// Get map, allocate if needed.
1993
		m := f.asPointerTo(t).Elem() // an addressable map[K]T
1994
		if m.IsNil() {
1995
			m.Set(reflect.MakeMap(t))
1996
		}
1997

1998
		// Insert into map.
1999
		m.SetMapIndex(k.Elem(), v.Elem())
2000

2001
		return r, nerr.E
2002
	}
2003
}
2004

2005
// makeUnmarshalOneof makes an unmarshaler for oneof fields.
2006
// for:
2007
// message Msg {
2008
//   oneof F {
2009
//     int64 X = 1;
2010
//     float64 Y = 2;
2011
//   }
2012
// }
2013
// typ is the type of the concrete entry for a oneof case (e.g. Msg_X).
2014
// ityp is the interface type of the oneof field (e.g. isMsg_F).
2015
// unmarshal is the unmarshaler for the base type of the oneof case (e.g. int64).
2016
// Note that this function will be called once for each case in the oneof.
2017
func makeUnmarshalOneof(typ, ityp reflect.Type, unmarshal unmarshaler) unmarshaler {
2018
	sf := typ.Field(0)
2019
	field0 := toField(&sf)
2020
	return func(b []byte, f pointer, w int) ([]byte, error) {
2021
		// Allocate holder for value.
2022
		v := reflect.New(typ)
2023

2024
		// Unmarshal data into holder.
2025
		// We unmarshal into the first field of the holder object.
2026
		var err error
2027
		var nerr nonFatal
2028
		b, err = unmarshal(b, valToPointer(v).offset(field0), w)
2029
		if !nerr.Merge(err) {
2030
			return nil, err
2031
		}
2032

2033
		// Write pointer to holder into target field.
2034
		f.asPointerTo(ityp).Elem().Set(v)
2035

2036
		return b, nerr.E
2037
	}
2038
}
2039

2040
// Error used by decode internally.
2041
var errInternalBadWireType = errors.New("proto: internal error: bad wiretype")
2042

2043
// skipField skips past a field of type wire and returns the remaining bytes.
2044
func skipField(b []byte, wire int) ([]byte, error) {
2045
	switch wire {
2046
	case WireVarint:
2047
		_, k := decodeVarint(b)
2048
		if k == 0 {
2049
			return b, io.ErrUnexpectedEOF
2050
		}
2051
		b = b[k:]
2052
	case WireFixed32:
2053
		if len(b) < 4 {
2054
			return b, io.ErrUnexpectedEOF
2055
		}
2056
		b = b[4:]
2057
	case WireFixed64:
2058
		if len(b) < 8 {
2059
			return b, io.ErrUnexpectedEOF
2060
		}
2061
		b = b[8:]
2062
	case WireBytes:
2063
		m, k := decodeVarint(b)
2064
		if k == 0 || uint64(len(b)-k) < m {
2065
			return b, io.ErrUnexpectedEOF
2066
		}
2067
		b = b[uint64(k)+m:]
2068
	case WireStartGroup:
2069
		_, i := findEndGroup(b)
2070
		if i == -1 {
2071
			return b, io.ErrUnexpectedEOF
2072
		}
2073
		b = b[i:]
2074
	default:
2075
		return b, fmt.Errorf("proto: can't skip unknown wire type %d", wire)
2076
	}
2077
	return b, nil
2078
}
2079

2080
// findEndGroup finds the index of the next EndGroup tag.
2081
// Groups may be nested, so the "next" EndGroup tag is the first
2082
// unpaired EndGroup.
2083
// findEndGroup returns the indexes of the start and end of the EndGroup tag.
2084
// Returns (-1,-1) if it can't find one.
2085
func findEndGroup(b []byte) (int, int) {
2086
	depth := 1
2087
	i := 0
2088
	for {
2089
		x, n := decodeVarint(b[i:])
2090
		if n == 0 {
2091
			return -1, -1
2092
		}
2093
		j := i
2094
		i += n
2095
		switch x & 7 {
2096
		case WireVarint:
2097
			_, k := decodeVarint(b[i:])
2098
			if k == 0 {
2099
				return -1, -1
2100
			}
2101
			i += k
2102
		case WireFixed32:
2103
			if len(b)-4 < i {
2104
				return -1, -1
2105
			}
2106
			i += 4
2107
		case WireFixed64:
2108
			if len(b)-8 < i {
2109
				return -1, -1
2110
			}
2111
			i += 8
2112
		case WireBytes:
2113
			m, k := decodeVarint(b[i:])
2114
			if k == 0 {
2115
				return -1, -1
2116
			}
2117
			i += k
2118
			if uint64(len(b)-i) < m {
2119
				return -1, -1
2120
			}
2121
			i += int(m)
2122
		case WireStartGroup:
2123
			depth++
2124
		case WireEndGroup:
2125
			depth--
2126
			if depth == 0 {
2127
				return j, i
2128
			}
2129
		default:
2130
			return -1, -1
2131
		}
2132
	}
2133
}
2134

2135
// encodeVarint appends a varint-encoded integer to b and returns the result.
2136
func encodeVarint(b []byte, x uint64) []byte {
2137
	for x >= 1<<7 {
2138
		b = append(b, byte(x&0x7f|0x80))
2139
		x >>= 7
2140
	}
2141
	return append(b, byte(x))
2142
}
2143

2144
// decodeVarint reads a varint-encoded integer from b.
2145
// Returns the decoded integer and the number of bytes read.
2146
// If there is an error, it returns 0,0.
2147
func decodeVarint(b []byte) (uint64, int) {
2148
	var x, y uint64
2149
	if len(b) == 0 {
2150
		goto bad
2151
	}
2152
	x = uint64(b[0])
2153
	if x < 0x80 {
2154
		return x, 1
2155
	}
2156
	x -= 0x80
2157

2158
	if len(b) <= 1 {
2159
		goto bad
2160
	}
2161
	y = uint64(b[1])
2162
	x += y << 7
2163
	if y < 0x80 {
2164
		return x, 2
2165
	}
2166
	x -= 0x80 << 7
2167

2168
	if len(b) <= 2 {
2169
		goto bad
2170
	}
2171
	y = uint64(b[2])
2172
	x += y << 14
2173
	if y < 0x80 {
2174
		return x, 3
2175
	}
2176
	x -= 0x80 << 14
2177

2178
	if len(b) <= 3 {
2179
		goto bad
2180
	}
2181
	y = uint64(b[3])
2182
	x += y << 21
2183
	if y < 0x80 {
2184
		return x, 4
2185
	}
2186
	x -= 0x80 << 21
2187

2188
	if len(b) <= 4 {
2189
		goto bad
2190
	}
2191
	y = uint64(b[4])
2192
	x += y << 28
2193
	if y < 0x80 {
2194
		return x, 5
2195
	}
2196
	x -= 0x80 << 28
2197

2198
	if len(b) <= 5 {
2199
		goto bad
2200
	}
2201
	y = uint64(b[5])
2202
	x += y << 35
2203
	if y < 0x80 {
2204
		return x, 6
2205
	}
2206
	x -= 0x80 << 35
2207

2208
	if len(b) <= 6 {
2209
		goto bad
2210
	}
2211
	y = uint64(b[6])
2212
	x += y << 42
2213
	if y < 0x80 {
2214
		return x, 7
2215
	}
2216
	x -= 0x80 << 42
2217

2218
	if len(b) <= 7 {
2219
		goto bad
2220
	}
2221
	y = uint64(b[7])
2222
	x += y << 49
2223
	if y < 0x80 {
2224
		return x, 8
2225
	}
2226
	x -= 0x80 << 49
2227

2228
	if len(b) <= 8 {
2229
		goto bad
2230
	}
2231
	y = uint64(b[8])
2232
	x += y << 56
2233
	if y < 0x80 {
2234
		return x, 9
2235
	}
2236
	x -= 0x80 << 56
2237

2238
	if len(b) <= 9 {
2239
		goto bad
2240
	}
2241
	y = uint64(b[9])
2242
	x += y << 63
2243
	if y < 2 {
2244
		return x, 10
2245
	}
2246

2247
bad:
2248
	return 0, 0
2249
}
2250