1// Created by decgen --output dec_helpers.go; DO NOT EDIT
2
3// Copyright 2014 The Go Authors. All rights reserved.
4// Use of this source code is governed by a BSD-style
5// license that can be found in the LICENSE file.
6
7package gob
8
9import (
10	"math"
11	"reflect"
12)
13
14var decArrayHelper = map[reflect.Kind]decHelper{
15	reflect.Bool:       decBoolArray,
16	reflect.Complex64:  decComplex64Array,
17	reflect.Complex128: decComplex128Array,
18	reflect.Float32:    decFloat32Array,
19	reflect.Float64:    decFloat64Array,
20	reflect.Int:        decIntArray,
21	reflect.Int16:      decInt16Array,
22	reflect.Int32:      decInt32Array,
23	reflect.Int64:      decInt64Array,
24	reflect.Int8:       decInt8Array,
25	reflect.String:     decStringArray,
26	reflect.Uint:       decUintArray,
27	reflect.Uint16:     decUint16Array,
28	reflect.Uint32:     decUint32Array,
29	reflect.Uint64:     decUint64Array,
30	reflect.Uintptr:    decUintptrArray,
31}
32
33var decSliceHelper = map[reflect.Kind]decHelper{
34	reflect.Bool:       decBoolSlice,
35	reflect.Complex64:  decComplex64Slice,
36	reflect.Complex128: decComplex128Slice,
37	reflect.Float32:    decFloat32Slice,
38	reflect.Float64:    decFloat64Slice,
39	reflect.Int:        decIntSlice,
40	reflect.Int16:      decInt16Slice,
41	reflect.Int32:      decInt32Slice,
42	reflect.Int64:      decInt64Slice,
43	reflect.Int8:       decInt8Slice,
44	reflect.String:     decStringSlice,
45	reflect.Uint:       decUintSlice,
46	reflect.Uint16:     decUint16Slice,
47	reflect.Uint32:     decUint32Slice,
48	reflect.Uint64:     decUint64Slice,
49	reflect.Uintptr:    decUintptrSlice,
50}
51
52func decBoolArray(state *decoderState, v reflect.Value, length int, ovfl error) bool {
53	// Can only slice if it is addressable.
54	if !v.CanAddr() {
55		return false
56	}
57	return decBoolSlice(state, v.Slice(0, v.Len()), length, ovfl)
58}
59
60func decBoolSlice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
61	slice, ok := v.Interface().([]bool)
62	if !ok {
63		// It is kind bool but not type bool. TODO: We can handle this unsafely.
64		return false
65	}
66	for i := 0; i < length; i++ {
67		if state.b.Len() == 0 {
68			errorf("decoding bool array or slice: length exceeds input size (%d elements)", length)
69		}
70		slice[i] = state.decodeUint() != 0
71	}
72	return true
73}
74
75func decComplex64Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
76	// Can only slice if it is addressable.
77	if !v.CanAddr() {
78		return false
79	}
80	return decComplex64Slice(state, v.Slice(0, v.Len()), length, ovfl)
81}
82
83func decComplex64Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
84	slice, ok := v.Interface().([]complex64)
85	if !ok {
86		// It is kind complex64 but not type complex64. TODO: We can handle this unsafely.
87		return false
88	}
89	for i := 0; i < length; i++ {
90		if state.b.Len() == 0 {
91			errorf("decoding complex64 array or slice: length exceeds input size (%d elements)", length)
92		}
93		real := float32FromBits(state.decodeUint(), ovfl)
94		imag := float32FromBits(state.decodeUint(), ovfl)
95		slice[i] = complex(float32(real), float32(imag))
96	}
97	return true
98}
99
100func decComplex128Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
101	// Can only slice if it is addressable.
102	if !v.CanAddr() {
103		return false
104	}
105	return decComplex128Slice(state, v.Slice(0, v.Len()), length, ovfl)
106}
107
108func decComplex128Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
109	slice, ok := v.Interface().([]complex128)
110	if !ok {
111		// It is kind complex128 but not type complex128. TODO: We can handle this unsafely.
112		return false
113	}
114	for i := 0; i < length; i++ {
115		if state.b.Len() == 0 {
116			errorf("decoding complex128 array or slice: length exceeds input size (%d elements)", length)
117		}
118		real := float64FromBits(state.decodeUint())
119		imag := float64FromBits(state.decodeUint())
120		slice[i] = complex(real, imag)
121	}
122	return true
123}
124
125func decFloat32Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
126	// Can only slice if it is addressable.
127	if !v.CanAddr() {
128		return false
129	}
130	return decFloat32Slice(state, v.Slice(0, v.Len()), length, ovfl)
131}
132
133func decFloat32Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
134	slice, ok := v.Interface().([]float32)
135	if !ok {
136		// It is kind float32 but not type float32. TODO: We can handle this unsafely.
137		return false
138	}
139	for i := 0; i < length; i++ {
140		if state.b.Len() == 0 {
141			errorf("decoding float32 array or slice: length exceeds input size (%d elements)", length)
142		}
143		slice[i] = float32(float32FromBits(state.decodeUint(), ovfl))
144	}
145	return true
146}
147
148func decFloat64Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
149	// Can only slice if it is addressable.
150	if !v.CanAddr() {
151		return false
152	}
153	return decFloat64Slice(state, v.Slice(0, v.Len()), length, ovfl)
154}
155
156func decFloat64Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
157	slice, ok := v.Interface().([]float64)
158	if !ok {
159		// It is kind float64 but not type float64. TODO: We can handle this unsafely.
160		return false
161	}
162	for i := 0; i < length; i++ {
163		if state.b.Len() == 0 {
164			errorf("decoding float64 array or slice: length exceeds input size (%d elements)", length)
165		}
166		slice[i] = float64FromBits(state.decodeUint())
167	}
168	return true
169}
170
171func decIntArray(state *decoderState, v reflect.Value, length int, ovfl error) bool {
172	// Can only slice if it is addressable.
173	if !v.CanAddr() {
174		return false
175	}
176	return decIntSlice(state, v.Slice(0, v.Len()), length, ovfl)
177}
178
179func decIntSlice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
180	slice, ok := v.Interface().([]int)
181	if !ok {
182		// It is kind int but not type int. TODO: We can handle this unsafely.
183		return false
184	}
185	for i := 0; i < length; i++ {
186		if state.b.Len() == 0 {
187			errorf("decoding int array or slice: length exceeds input size (%d elements)", length)
188		}
189		x := state.decodeInt()
190		// MinInt and MaxInt
191		if x < ^int64(^uint(0)>>1) || int64(^uint(0)>>1) < x {
192			error_(ovfl)
193		}
194		slice[i] = int(x)
195	}
196	return true
197}
198
199func decInt16Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
200	// Can only slice if it is addressable.
201	if !v.CanAddr() {
202		return false
203	}
204	return decInt16Slice(state, v.Slice(0, v.Len()), length, ovfl)
205}
206
207func decInt16Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
208	slice, ok := v.Interface().([]int16)
209	if !ok {
210		// It is kind int16 but not type int16. TODO: We can handle this unsafely.
211		return false
212	}
213	for i := 0; i < length; i++ {
214		if state.b.Len() == 0 {
215			errorf("decoding int16 array or slice: length exceeds input size (%d elements)", length)
216		}
217		x := state.decodeInt()
218		if x < math.MinInt16 || math.MaxInt16 < x {
219			error_(ovfl)
220		}
221		slice[i] = int16(x)
222	}
223	return true
224}
225
226func decInt32Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
227	// Can only slice if it is addressable.
228	if !v.CanAddr() {
229		return false
230	}
231	return decInt32Slice(state, v.Slice(0, v.Len()), length, ovfl)
232}
233
234func decInt32Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
235	slice, ok := v.Interface().([]int32)
236	if !ok {
237		// It is kind int32 but not type int32. TODO: We can handle this unsafely.
238		return false
239	}
240	for i := 0; i < length; i++ {
241		if state.b.Len() == 0 {
242			errorf("decoding int32 array or slice: length exceeds input size (%d elements)", length)
243		}
244		x := state.decodeInt()
245		if x < math.MinInt32 || math.MaxInt32 < x {
246			error_(ovfl)
247		}
248		slice[i] = int32(x)
249	}
250	return true
251}
252
253func decInt64Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
254	// Can only slice if it is addressable.
255	if !v.CanAddr() {
256		return false
257	}
258	return decInt64Slice(state, v.Slice(0, v.Len()), length, ovfl)
259}
260
261func decInt64Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
262	slice, ok := v.Interface().([]int64)
263	if !ok {
264		// It is kind int64 but not type int64. TODO: We can handle this unsafely.
265		return false
266	}
267	for i := 0; i < length; i++ {
268		if state.b.Len() == 0 {
269			errorf("decoding int64 array or slice: length exceeds input size (%d elements)", length)
270		}
271		slice[i] = state.decodeInt()
272	}
273	return true
274}
275
276func decInt8Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
277	// Can only slice if it is addressable.
278	if !v.CanAddr() {
279		return false
280	}
281	return decInt8Slice(state, v.Slice(0, v.Len()), length, ovfl)
282}
283
284func decInt8Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
285	slice, ok := v.Interface().([]int8)
286	if !ok {
287		// It is kind int8 but not type int8. TODO: We can handle this unsafely.
288		return false
289	}
290	for i := 0; i < length; i++ {
291		if state.b.Len() == 0 {
292			errorf("decoding int8 array or slice: length exceeds input size (%d elements)", length)
293		}
294		x := state.decodeInt()
295		if x < math.MinInt8 || math.MaxInt8 < x {
296			error_(ovfl)
297		}
298		slice[i] = int8(x)
299	}
300	return true
301}
302
303func decStringArray(state *decoderState, v reflect.Value, length int, ovfl error) bool {
304	// Can only slice if it is addressable.
305	if !v.CanAddr() {
306		return false
307	}
308	return decStringSlice(state, v.Slice(0, v.Len()), length, ovfl)
309}
310
311func decStringSlice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
312	slice, ok := v.Interface().([]string)
313	if !ok {
314		// It is kind string but not type string. TODO: We can handle this unsafely.
315		return false
316	}
317	for i := 0; i < length; i++ {
318		if state.b.Len() == 0 {
319			errorf("decoding string array or slice: length exceeds input size (%d elements)", length)
320		}
321		u := state.decodeUint()
322		n := int(u)
323		if n < 0 || uint64(n) != u || n > state.b.Len() {
324			errorf("length of string exceeds input size (%d bytes)", u)
325		}
326		if n > state.b.Len() {
327			errorf("string data too long for buffer: %d", n)
328		}
329		// Read the data.
330		data := state.b.Bytes()
331		if len(data) < n {
332			errorf("invalid string length %d: exceeds input size %d", n, len(data))
333		}
334		slice[i] = string(data[:n])
335		state.b.Drop(n)
336	}
337	return true
338}
339
340func decUintArray(state *decoderState, v reflect.Value, length int, ovfl error) bool {
341	// Can only slice if it is addressable.
342	if !v.CanAddr() {
343		return false
344	}
345	return decUintSlice(state, v.Slice(0, v.Len()), length, ovfl)
346}
347
348func decUintSlice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
349	slice, ok := v.Interface().([]uint)
350	if !ok {
351		// It is kind uint but not type uint. TODO: We can handle this unsafely.
352		return false
353	}
354	for i := 0; i < length; i++ {
355		if state.b.Len() == 0 {
356			errorf("decoding uint array or slice: length exceeds input size (%d elements)", length)
357		}
358		x := state.decodeUint()
359		/*TODO if math.MaxUint32 < x {
360			error_(ovfl)
361		}*/
362		slice[i] = uint(x)
363	}
364	return true
365}
366
367func decUint16Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
368	// Can only slice if it is addressable.
369	if !v.CanAddr() {
370		return false
371	}
372	return decUint16Slice(state, v.Slice(0, v.Len()), length, ovfl)
373}
374
375func decUint16Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
376	slice, ok := v.Interface().([]uint16)
377	if !ok {
378		// It is kind uint16 but not type uint16. TODO: We can handle this unsafely.
379		return false
380	}
381	for i := 0; i < length; i++ {
382		if state.b.Len() == 0 {
383			errorf("decoding uint16 array or slice: length exceeds input size (%d elements)", length)
384		}
385		x := state.decodeUint()
386		if math.MaxUint16 < x {
387			error_(ovfl)
388		}
389		slice[i] = uint16(x)
390	}
391	return true
392}
393
394func decUint32Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
395	// Can only slice if it is addressable.
396	if !v.CanAddr() {
397		return false
398	}
399	return decUint32Slice(state, v.Slice(0, v.Len()), length, ovfl)
400}
401
402func decUint32Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
403	slice, ok := v.Interface().([]uint32)
404	if !ok {
405		// It is kind uint32 but not type uint32. TODO: We can handle this unsafely.
406		return false
407	}
408	for i := 0; i < length; i++ {
409		if state.b.Len() == 0 {
410			errorf("decoding uint32 array or slice: length exceeds input size (%d elements)", length)
411		}
412		x := state.decodeUint()
413		if math.MaxUint32 < x {
414			error_(ovfl)
415		}
416		slice[i] = uint32(x)
417	}
418	return true
419}
420
421func decUint64Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
422	// Can only slice if it is addressable.
423	if !v.CanAddr() {
424		return false
425	}
426	return decUint64Slice(state, v.Slice(0, v.Len()), length, ovfl)
427}
428
429func decUint64Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
430	slice, ok := v.Interface().([]uint64)
431	if !ok {
432		// It is kind uint64 but not type uint64. TODO: We can handle this unsafely.
433		return false
434	}
435	for i := 0; i < length; i++ {
436		if state.b.Len() == 0 {
437			errorf("decoding uint64 array or slice: length exceeds input size (%d elements)", length)
438		}
439		slice[i] = state.decodeUint()
440	}
441	return true
442}
443
444func decUintptrArray(state *decoderState, v reflect.Value, length int, ovfl error) bool {
445	// Can only slice if it is addressable.
446	if !v.CanAddr() {
447		return false
448	}
449	return decUintptrSlice(state, v.Slice(0, v.Len()), length, ovfl)
450}
451
452func decUintptrSlice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
453	slice, ok := v.Interface().([]uintptr)
454	if !ok {
455		// It is kind uintptr but not type uintptr. TODO: We can handle this unsafely.
456		return false
457	}
458	for i := 0; i < length; i++ {
459		if state.b.Len() == 0 {
460			errorf("decoding uintptr array or slice: length exceeds input size (%d elements)", length)
461		}
462		x := state.decodeUint()
463		if uint64(^uintptr(0)) < x {
464			error_(ovfl)
465		}
466		slice[i] = uintptr(x)
467	}
468	return true
469}
470