Source file src/pkg/cmd/vendor/github.com/google/pprof/profile/proto.go

     1	// Copyright 2014 Google Inc. All Rights Reserved.
     2	//
     3	// Licensed under the Apache License, Version 2.0 (the "License");
     4	// you may not use this file except in compliance with the License.
     5	// You may obtain a copy of the License at
     6	//
     7	//     http://www.apache.org/licenses/LICENSE-2.0
     8	//
     9	// Unless required by applicable law or agreed to in writing, software
    10	// distributed under the License is distributed on an "AS IS" BASIS,
    11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12	// See the License for the specific language governing permissions and
    13	// limitations under the License.
    14	
    15	// This file is a simple protocol buffer encoder and decoder.
    16	// The format is described at
    17	// https://developers.google.com/protocol-buffers/docs/encoding
    18	//
    19	// A protocol message must implement the message interface:
    20	//   decoder() []decoder
    21	//   encode(*buffer)
    22	//
    23	// The decode method returns a slice indexed by field number that gives the
    24	// function to decode that field.
    25	// The encode method encodes its receiver into the given buffer.
    26	//
    27	// The two methods are simple enough to be implemented by hand rather than
    28	// by using a protocol compiler.
    29	//
    30	// See profile.go for examples of messages implementing this interface.
    31	//
    32	// There is no support for groups, message sets, or "has" bits.
    33	
    34	package profile
    35	
    36	import "errors"
    37	
    38	type buffer struct {
    39		field int // field tag
    40		typ   int // proto wire type code for field
    41		u64   uint64
    42		data  []byte
    43		tmp   [16]byte
    44	}
    45	
    46	type decoder func(*buffer, message) error
    47	
    48	type message interface {
    49		decoder() []decoder
    50		encode(*buffer)
    51	}
    52	
    53	func marshal(m message) []byte {
    54		var b buffer
    55		m.encode(&b)
    56		return b.data
    57	}
    58	
    59	func encodeVarint(b *buffer, x uint64) {
    60		for x >= 128 {
    61			b.data = append(b.data, byte(x)|0x80)
    62			x >>= 7
    63		}
    64		b.data = append(b.data, byte(x))
    65	}
    66	
    67	func encodeLength(b *buffer, tag int, len int) {
    68		encodeVarint(b, uint64(tag)<<3|2)
    69		encodeVarint(b, uint64(len))
    70	}
    71	
    72	func encodeUint64(b *buffer, tag int, x uint64) {
    73		// append varint to b.data
    74		encodeVarint(b, uint64(tag)<<3)
    75		encodeVarint(b, x)
    76	}
    77	
    78	func encodeUint64s(b *buffer, tag int, x []uint64) {
    79		if len(x) > 2 {
    80			// Use packed encoding
    81			n1 := len(b.data)
    82			for _, u := range x {
    83				encodeVarint(b, u)
    84			}
    85			n2 := len(b.data)
    86			encodeLength(b, tag, n2-n1)
    87			n3 := len(b.data)
    88			copy(b.tmp[:], b.data[n2:n3])
    89			copy(b.data[n1+(n3-n2):], b.data[n1:n2])
    90			copy(b.data[n1:], b.tmp[:n3-n2])
    91			return
    92		}
    93		for _, u := range x {
    94			encodeUint64(b, tag, u)
    95		}
    96	}
    97	
    98	func encodeUint64Opt(b *buffer, tag int, x uint64) {
    99		if x == 0 {
   100			return
   101		}
   102		encodeUint64(b, tag, x)
   103	}
   104	
   105	func encodeInt64(b *buffer, tag int, x int64) {
   106		u := uint64(x)
   107		encodeUint64(b, tag, u)
   108	}
   109	
   110	func encodeInt64s(b *buffer, tag int, x []int64) {
   111		if len(x) > 2 {
   112			// Use packed encoding
   113			n1 := len(b.data)
   114			for _, u := range x {
   115				encodeVarint(b, uint64(u))
   116			}
   117			n2 := len(b.data)
   118			encodeLength(b, tag, n2-n1)
   119			n3 := len(b.data)
   120			copy(b.tmp[:], b.data[n2:n3])
   121			copy(b.data[n1+(n3-n2):], b.data[n1:n2])
   122			copy(b.data[n1:], b.tmp[:n3-n2])
   123			return
   124		}
   125		for _, u := range x {
   126			encodeInt64(b, tag, u)
   127		}
   128	}
   129	
   130	func encodeInt64Opt(b *buffer, tag int, x int64) {
   131		if x == 0 {
   132			return
   133		}
   134		encodeInt64(b, tag, x)
   135	}
   136	
   137	func encodeString(b *buffer, tag int, x string) {
   138		encodeLength(b, tag, len(x))
   139		b.data = append(b.data, x...)
   140	}
   141	
   142	func encodeStrings(b *buffer, tag int, x []string) {
   143		for _, s := range x {
   144			encodeString(b, tag, s)
   145		}
   146	}
   147	
   148	func encodeBool(b *buffer, tag int, x bool) {
   149		if x {
   150			encodeUint64(b, tag, 1)
   151		} else {
   152			encodeUint64(b, tag, 0)
   153		}
   154	}
   155	
   156	func encodeBoolOpt(b *buffer, tag int, x bool) {
   157		if x {
   158			encodeBool(b, tag, x)
   159		}
   160	}
   161	
   162	func encodeMessage(b *buffer, tag int, m message) {
   163		n1 := len(b.data)
   164		m.encode(b)
   165		n2 := len(b.data)
   166		encodeLength(b, tag, n2-n1)
   167		n3 := len(b.data)
   168		copy(b.tmp[:], b.data[n2:n3])
   169		copy(b.data[n1+(n3-n2):], b.data[n1:n2])
   170		copy(b.data[n1:], b.tmp[:n3-n2])
   171	}
   172	
   173	func unmarshal(data []byte, m message) (err error) {
   174		b := buffer{data: data, typ: 2}
   175		return decodeMessage(&b, m)
   176	}
   177	
   178	func le64(p []byte) uint64 {
   179		return uint64(p[0]) | uint64(p[1])<<8 | uint64(p[2])<<16 | uint64(p[3])<<24 | uint64(p[4])<<32 | uint64(p[5])<<40 | uint64(p[6])<<48 | uint64(p[7])<<56
   180	}
   181	
   182	func le32(p []byte) uint32 {
   183		return uint32(p[0]) | uint32(p[1])<<8 | uint32(p[2])<<16 | uint32(p[3])<<24
   184	}
   185	
   186	func decodeVarint(data []byte) (uint64, []byte, error) {
   187		var u uint64
   188		for i := 0; ; i++ {
   189			if i >= 10 || i >= len(data) {
   190				return 0, nil, errors.New("bad varint")
   191			}
   192			u |= uint64(data[i]&0x7F) << uint(7*i)
   193			if data[i]&0x80 == 0 {
   194				return u, data[i+1:], nil
   195			}
   196		}
   197	}
   198	
   199	func decodeField(b *buffer, data []byte) ([]byte, error) {
   200		x, data, err := decodeVarint(data)
   201		if err != nil {
   202			return nil, err
   203		}
   204		b.field = int(x >> 3)
   205		b.typ = int(x & 7)
   206		b.data = nil
   207		b.u64 = 0
   208		switch b.typ {
   209		case 0:
   210			b.u64, data, err = decodeVarint(data)
   211			if err != nil {
   212				return nil, err
   213			}
   214		case 1:
   215			if len(data) < 8 {
   216				return nil, errors.New("not enough data")
   217			}
   218			b.u64 = le64(data[:8])
   219			data = data[8:]
   220		case 2:
   221			var n uint64
   222			n, data, err = decodeVarint(data)
   223			if err != nil {
   224				return nil, err
   225			}
   226			if n > uint64(len(data)) {
   227				return nil, errors.New("too much data")
   228			}
   229			b.data = data[:n]
   230			data = data[n:]
   231		case 5:
   232			if len(data) < 4 {
   233				return nil, errors.New("not enough data")
   234			}
   235			b.u64 = uint64(le32(data[:4]))
   236			data = data[4:]
   237		default:
   238			return nil, errors.New("unknown wire type: " + string(b.typ))
   239		}
   240	
   241		return data, nil
   242	}
   243	
   244	func checkType(b *buffer, typ int) error {
   245		if b.typ != typ {
   246			return errors.New("type mismatch")
   247		}
   248		return nil
   249	}
   250	
   251	func decodeMessage(b *buffer, m message) error {
   252		if err := checkType(b, 2); err != nil {
   253			return err
   254		}
   255		dec := m.decoder()
   256		data := b.data
   257		for len(data) > 0 {
   258			// pull varint field# + type
   259			var err error
   260			data, err = decodeField(b, data)
   261			if err != nil {
   262				return err
   263			}
   264			if b.field >= len(dec) || dec[b.field] == nil {
   265				continue
   266			}
   267			if err := dec[b.field](b, m); err != nil {
   268				return err
   269			}
   270		}
   271		return nil
   272	}
   273	
   274	func decodeInt64(b *buffer, x *int64) error {
   275		if err := checkType(b, 0); err != nil {
   276			return err
   277		}
   278		*x = int64(b.u64)
   279		return nil
   280	}
   281	
   282	func decodeInt64s(b *buffer, x *[]int64) error {
   283		if b.typ == 2 {
   284			// Packed encoding
   285			data := b.data
   286			tmp := make([]int64, 0, len(data)) // Maximally sized
   287			for len(data) > 0 {
   288				var u uint64
   289				var err error
   290	
   291				if u, data, err = decodeVarint(data); err != nil {
   292					return err
   293				}
   294				tmp = append(tmp, int64(u))
   295			}
   296			*x = append(*x, tmp...)
   297			return nil
   298		}
   299		var i int64
   300		if err := decodeInt64(b, &i); err != nil {
   301			return err
   302		}
   303		*x = append(*x, i)
   304		return nil
   305	}
   306	
   307	func decodeUint64(b *buffer, x *uint64) error {
   308		if err := checkType(b, 0); err != nil {
   309			return err
   310		}
   311		*x = b.u64
   312		return nil
   313	}
   314	
   315	func decodeUint64s(b *buffer, x *[]uint64) error {
   316		if b.typ == 2 {
   317			data := b.data
   318			// Packed encoding
   319			tmp := make([]uint64, 0, len(data)) // Maximally sized
   320			for len(data) > 0 {
   321				var u uint64
   322				var err error
   323	
   324				if u, data, err = decodeVarint(data); err != nil {
   325					return err
   326				}
   327				tmp = append(tmp, u)
   328			}
   329			*x = append(*x, tmp...)
   330			return nil
   331		}
   332		var u uint64
   333		if err := decodeUint64(b, &u); err != nil {
   334			return err
   335		}
   336		*x = append(*x, u)
   337		return nil
   338	}
   339	
   340	func decodeString(b *buffer, x *string) error {
   341		if err := checkType(b, 2); err != nil {
   342			return err
   343		}
   344		*x = string(b.data)
   345		return nil
   346	}
   347	
   348	func decodeStrings(b *buffer, x *[]string) error {
   349		var s string
   350		if err := decodeString(b, &s); err != nil {
   351			return err
   352		}
   353		*x = append(*x, s)
   354		return nil
   355	}
   356	
   357	func decodeBool(b *buffer, x *bool) error {
   358		if err := checkType(b, 0); err != nil {
   359			return err
   360		}
   361		if int64(b.u64) == 0 {
   362			*x = false
   363		} else {
   364			*x = true
   365		}
   366		return nil
   367	}
   368	

View as plain text