Source file src/github.com/gogo/protobuf/proto/table_unmarshal.go

Documentation: github.com/gogo/protobuf/proto

     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  

View as plain text