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
34package profile
35
36import (
37	"errors"
38	"fmt"
39)
40
41type buffer struct {
42	field    int // field tag
43	typ      int // proto wire type code for field
44	u64      uint64
45	data     []byte
46	tmp      [16]byte
47	tmpLines []Line // temporary storage used while decoding "repeated Line".
48}
49
50type decoder func(*buffer, message) error
51
52type message interface {
53	decoder() []decoder
54	encode(*buffer)
55}
56
57func marshal(m message) []byte {
58	var b buffer
59	m.encode(&b)
60	return b.data
61}
62
63func encodeVarint(b *buffer, x uint64) {
64	for x >= 128 {
65		b.data = append(b.data, byte(x)|0x80)
66		x >>= 7
67	}
68	b.data = append(b.data, byte(x))
69}
70
71func encodeLength(b *buffer, tag int, len int) {
72	encodeVarint(b, uint64(tag)<<3|2)
73	encodeVarint(b, uint64(len))
74}
75
76func encodeUint64(b *buffer, tag int, x uint64) {
77	// append varint to b.data
78	encodeVarint(b, uint64(tag)<<3)
79	encodeVarint(b, x)
80}
81
82func encodeUint64s(b *buffer, tag int, x []uint64) {
83	if len(x) > 2 {
84		// Use packed encoding
85		n1 := len(b.data)
86		for _, u := range x {
87			encodeVarint(b, u)
88		}
89		n2 := len(b.data)
90		encodeLength(b, tag, n2-n1)
91		n3 := len(b.data)
92		copy(b.tmp[:], b.data[n2:n3])
93		copy(b.data[n1+(n3-n2):], b.data[n1:n2])
94		copy(b.data[n1:], b.tmp[:n3-n2])
95		return
96	}
97	for _, u := range x {
98		encodeUint64(b, tag, u)
99	}
100}
101
102func encodeUint64Opt(b *buffer, tag int, x uint64) {
103	if x == 0 {
104		return
105	}
106	encodeUint64(b, tag, x)
107}
108
109func encodeInt64(b *buffer, tag int, x int64) {
110	u := uint64(x)
111	encodeUint64(b, tag, u)
112}
113
114func encodeInt64s(b *buffer, tag int, x []int64) {
115	if len(x) > 2 {
116		// Use packed encoding
117		n1 := len(b.data)
118		for _, u := range x {
119			encodeVarint(b, uint64(u))
120		}
121		n2 := len(b.data)
122		encodeLength(b, tag, n2-n1)
123		n3 := len(b.data)
124		copy(b.tmp[:], b.data[n2:n3])
125		copy(b.data[n1+(n3-n2):], b.data[n1:n2])
126		copy(b.data[n1:], b.tmp[:n3-n2])
127		return
128	}
129	for _, u := range x {
130		encodeInt64(b, tag, u)
131	}
132}
133
134func encodeInt64Opt(b *buffer, tag int, x int64) {
135	if x == 0 {
136		return
137	}
138	encodeInt64(b, tag, x)
139}
140
141func encodeString(b *buffer, tag int, x string) {
142	encodeLength(b, tag, len(x))
143	b.data = append(b.data, x...)
144}
145
146func encodeStrings(b *buffer, tag int, x []string) {
147	for _, s := range x {
148		encodeString(b, tag, s)
149	}
150}
151
152func encodeBool(b *buffer, tag int, x bool) {
153	if x {
154		encodeUint64(b, tag, 1)
155	} else {
156		encodeUint64(b, tag, 0)
157	}
158}
159
160func encodeBoolOpt(b *buffer, tag int, x bool) {
161	if x {
162		encodeBool(b, tag, x)
163	}
164}
165
166func encodeMessage(b *buffer, tag int, m message) {
167	n1 := len(b.data)
168	m.encode(b)
169	n2 := len(b.data)
170	encodeLength(b, tag, n2-n1)
171	n3 := len(b.data)
172	copy(b.tmp[:], b.data[n2:n3])
173	copy(b.data[n1+(n3-n2):], b.data[n1:n2])
174	copy(b.data[n1:], b.tmp[:n3-n2])
175}
176
177func unmarshal(data []byte, m message) (err error) {
178	b := buffer{data: data, typ: 2}
179	return decodeMessage(&b, m)
180}
181
182func le64(p []byte) uint64 {
183	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
184}
185
186func le32(p []byte) uint32 {
187	return uint32(p[0]) | uint32(p[1])<<8 | uint32(p[2])<<16 | uint32(p[3])<<24
188}
189
190func decodeVarint(data []byte) (uint64, []byte, error) {
191	var u uint64
192	for i := 0; ; i++ {
193		if i >= 10 || i >= len(data) {
194			return 0, nil, errors.New("bad varint")
195		}
196		u |= uint64(data[i]&0x7F) << uint(7*i)
197		if data[i]&0x80 == 0 {
198			return u, data[i+1:], nil
199		}
200	}
201}
202
203func decodeField(b *buffer, data []byte) ([]byte, error) {
204	x, data, err := decodeVarint(data)
205	if err != nil {
206		return nil, err
207	}
208	b.field = int(x >> 3)
209	b.typ = int(x & 7)
210	b.data = nil
211	b.u64 = 0
212	switch b.typ {
213	case 0:
214		b.u64, data, err = decodeVarint(data)
215		if err != nil {
216			return nil, err
217		}
218	case 1:
219		if len(data) < 8 {
220			return nil, errors.New("not enough data")
221		}
222		b.u64 = le64(data[:8])
223		data = data[8:]
224	case 2:
225		var n uint64
226		n, data, err = decodeVarint(data)
227		if err != nil {
228			return nil, err
229		}
230		if n > uint64(len(data)) {
231			return nil, errors.New("too much data")
232		}
233		b.data = data[:n]
234		data = data[n:]
235	case 5:
236		if len(data) < 4 {
237			return nil, errors.New("not enough data")
238		}
239		b.u64 = uint64(le32(data[:4]))
240		data = data[4:]
241	default:
242		return nil, fmt.Errorf("unknown wire type: %d", b.typ)
243	}
244
245	return data, nil
246}
247
248func checkType(b *buffer, typ int) error {
249	if b.typ != typ {
250		return errors.New("type mismatch")
251	}
252	return nil
253}
254
255func decodeMessage(b *buffer, m message) error {
256	if err := checkType(b, 2); err != nil {
257		return err
258	}
259	dec := m.decoder()
260	data := b.data
261	for len(data) > 0 {
262		// pull varint field# + type
263		var err error
264		data, err = decodeField(b, data)
265		if err != nil {
266			return err
267		}
268		if b.field >= len(dec) || dec[b.field] == nil {
269			continue
270		}
271		if err := dec[b.field](b, m); err != nil {
272			return err
273		}
274	}
275	return nil
276}
277
278func decodeInt64(b *buffer, x *int64) error {
279	if err := checkType(b, 0); err != nil {
280		return err
281	}
282	*x = int64(b.u64)
283	return nil
284}
285
286func decodeInt64s(b *buffer, x *[]int64) error {
287	if b.typ == 2 {
288		// Packed encoding
289		data := b.data
290		for len(data) > 0 {
291			var u uint64
292			var err error
293
294			if u, data, err = decodeVarint(data); err != nil {
295				return err
296			}
297			*x = append(*x, int64(u))
298		}
299		return nil
300	}
301	var i int64
302	if err := decodeInt64(b, &i); err != nil {
303		return err
304	}
305	*x = append(*x, i)
306	return nil
307}
308
309func decodeUint64(b *buffer, x *uint64) error {
310	if err := checkType(b, 0); err != nil {
311		return err
312	}
313	*x = b.u64
314	return nil
315}
316
317func decodeUint64s(b *buffer, x *[]uint64) error {
318	if b.typ == 2 {
319		data := b.data
320		// Packed encoding
321		for len(data) > 0 {
322			var u uint64
323			var err error
324
325			if u, data, err = decodeVarint(data); err != nil {
326				return err
327			}
328			*x = append(*x, u)
329		}
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
340func 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
348func 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
357func 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