libgo/go/runtime/pprof/protobuf.go

   1 // Copyright 2014 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package pprof
   6
   7 // A protobuf is a simple protocol buffer encoder.
   8 type protobuf struct {
   9         data []byte
  10         tmp  [16]byte
  11         nest int
  12 }
  13
  14 func (b *protobuf) varint(x uint64) {
  15         for x >= 128 {
  16                 b.data = append(b.data, byte(x)|0x80)
  17                 x >>= 7
  18         }
  19         b.data = append(b.data, byte(x))
  20 }
  21
  22 func (b *protobuf) length(tag int, len int) {
  23         b.varint(uint64(tag)<<3 | 2)
  24         b.varint(uint64(len))
  25 }
  26
  27 func (b *protobuf) uint64(tag int, x uint64) {
  28         // append varint to b.data
  29         b.varint(uint64(tag)<<3 | 0)
  30         b.varint(x)
  31 }
  32
  33 func (b *protobuf) uint64s(tag int, x []uint64) {
  34         if len(x) > 2 {
  35                 // Use packed encoding
  36                 n1 := len(b.data)
  37                 for _, u := range x {
  38                         b.varint(u)
  39                 }
  40                 n2 := len(b.data)
  41                 b.length(tag, n2-n1)
  42                 n3 := len(b.data)
  43                 copy(b.tmp[:], b.data[n2:n3])
  44                 copy(b.data[n1+(n3-n2):], b.data[n1:n2])
  45                 copy(b.data[n1:], b.tmp[:n3-n2])
  46                 return
  47         }
  48         for _, u := range x {
  49                 b.uint64(tag, u)
  50         }
  51 }
  52
  53 func (b *protobuf) uint64Opt(tag int, x uint64) {
  54         if x == 0 {
  55                 return
  56         }
  57         b.uint64(tag, x)
  58 }
  59
  60 func (b *protobuf) int64(tag int, x int64) {
  61         u := uint64(x)
  62         b.uint64(tag, u)
  63 }
  64
  65 func (b *protobuf) int64Opt(tag int, x int64) {
  66         if x == 0 {
  67                 return
  68         }
  69         b.int64(tag, x)
  70 }
  71
  72 func (b *protobuf) int64s(tag int, x []int64) {
  73         if len(x) > 2 {
  74                 // Use packed encoding
  75                 n1 := len(b.data)
  76                 for _, u := range x {
  77                         b.varint(uint64(u))
  78                 }
  79                 n2 := len(b.data)
  80                 b.length(tag, n2-n1)
  81                 n3 := len(b.data)
  82                 copy(b.tmp[:], b.data[n2:n3])
  83                 copy(b.data[n1+(n3-n2):], b.data[n1:n2])
  84                 copy(b.data[n1:], b.tmp[:n3-n2])
  85                 return
  86         }
  87         for _, u := range x {
  88                 b.int64(tag, u)
  89         }
  90 }
  91
  92 func (b *protobuf) string(tag int, x string) {
  93         b.length(tag, len(x))
  94         b.data = append(b.data, x...)
  95 }
  96
  97 func (b *protobuf) strings(tag int, x []string) {
  98         for _, s := range x {
  99                 b.string(tag, s)
 100         }
 101 }
 102
 103 func (b *protobuf) stringOpt(tag int, x string) {
 104         if x == "" {
 105                 return
 106         }
 107         b.string(tag, x)
 108 }
 109
 110 func (b *protobuf) bool(tag int, x bool) {
 111         if x {
 112                 b.uint64(tag, 1)
 113         } else {
 114                 b.uint64(tag, 0)
 115         }
 116 }
 117
 118 func (b *protobuf) boolOpt(tag int, x bool) {
 119         if x == false {
 120                 return
 121         }
 122         b.bool(tag, x)
 123 }
 124
 125 type msgOffset int
 126
 127 func (b *protobuf) startMessage() msgOffset {
 128         b.nest++
 129         return msgOffset(len(b.data))
 130 }
 131
 132 func (b *protobuf) endMessage(tag int, start msgOffset) {
 133         n1 := int(start)
 134         n2 := len(b.data)
 135         b.length(tag, n2-n1)
 136         n3 := len(b.data)
 137         copy(b.tmp[:], b.data[n2:n3])
 138         copy(b.data[n1+(n3-n2):], b.data[n1:n2])
 139         copy(b.data[n1:], b.tmp[:n3-n2])
 140         b.nest--
 141 }