podman

1
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
2
// Use of this source code is governed by a MIT license found in the LICENSE file.
3

4
package codec
5

6
import (
7
	"math"
8
	"reflect"
9
	"time"
10
)
11

12
const (
13
	_               uint8 = iota
14
	simpleVdNil           = 1
15
	simpleVdFalse         = 2
16
	simpleVdTrue          = 3
17
	simpleVdFloat32       = 4
18
	simpleVdFloat64       = 5
19

20
	// each lasts for 4 (ie n, n+1, n+2, n+3)
21
	simpleVdPosInt = 8
22
	simpleVdNegInt = 12
23

24
	simpleVdTime = 24
25

26
	// containers: each lasts for 4 (ie n, n+1, n+2, ... n+7)
27
	simpleVdString    = 216
28
	simpleVdByteArray = 224
29
	simpleVdArray     = 232
30
	simpleVdMap       = 240
31
	simpleVdExt       = 248
32
)
33

34
var simpledescNames = map[byte]string{
35
	simpleVdNil:     "null",
36
	simpleVdFalse:   "false",
37
	simpleVdTrue:    "true",
38
	simpleVdFloat32: "float32",
39
	simpleVdFloat64: "float64",
40

41
	simpleVdPosInt: "+int",
42
	simpleVdNegInt: "-int",
43

44
	simpleVdTime: "time",
45

46
	simpleVdString:    "string",
47
	simpleVdByteArray: "binary",
48
	simpleVdArray:     "array",
49
	simpleVdMap:       "map",
50
	simpleVdExt:       "ext",
51
}
52

53
func simpledesc(bd byte) (s string) {
54
	s = simpledescNames[bd]
55
	if s == "" {
56
		s = "unknown"
57
	}
58
	return
59
}
60

61
type simpleEncDriver struct {
62
	noBuiltInTypes
63
	encDriverNoopContainerWriter
64
	encDriverNoState
65
	h *SimpleHandle
66
	// b [8]byte
67
	e Encoder
68
}
69

70
func (e *simpleEncDriver) encoder() *Encoder {
71
	return &e.e
72
}
73

74
func (e *simpleEncDriver) EncodeNil() {
75
	e.e.encWr.writen1(simpleVdNil)
76
}
77

78
func (e *simpleEncDriver) EncodeBool(b bool) {
79
	if e.h.EncZeroValuesAsNil && e.e.c != containerMapKey && !b {
80
		e.EncodeNil()
81
		return
82
	}
83
	if b {
84
		e.e.encWr.writen1(simpleVdTrue)
85
	} else {
86
		e.e.encWr.writen1(simpleVdFalse)
87
	}
88
}
89

90
func (e *simpleEncDriver) EncodeFloat32(f float32) {
91
	if e.h.EncZeroValuesAsNil && e.e.c != containerMapKey && f == 0.0 {
92
		e.EncodeNil()
93
		return
94
	}
95
	e.e.encWr.writen1(simpleVdFloat32)
96
	bigen.writeUint32(e.e.w(), math.Float32bits(f))
97
}
98

99
func (e *simpleEncDriver) EncodeFloat64(f float64) {
100
	if e.h.EncZeroValuesAsNil && e.e.c != containerMapKey && f == 0.0 {
101
		e.EncodeNil()
102
		return
103
	}
104
	e.e.encWr.writen1(simpleVdFloat64)
105
	bigen.writeUint64(e.e.w(), math.Float64bits(f))
106
}
107

108
func (e *simpleEncDriver) EncodeInt(v int64) {
109
	if v < 0 {
110
		e.encUint(uint64(-v), simpleVdNegInt)
111
	} else {
112
		e.encUint(uint64(v), simpleVdPosInt)
113
	}
114
}
115

116
func (e *simpleEncDriver) EncodeUint(v uint64) {
117
	e.encUint(v, simpleVdPosInt)
118
}
119

120
func (e *simpleEncDriver) encUint(v uint64, bd uint8) {
121
	if e.h.EncZeroValuesAsNil && e.e.c != containerMapKey && v == 0 {
122
		e.EncodeNil()
123
		return
124
	}
125
	if v <= math.MaxUint8 {
126
		e.e.encWr.writen2(bd, uint8(v))
127
	} else if v <= math.MaxUint16 {
128
		e.e.encWr.writen1(bd + 1)
129
		bigen.writeUint16(e.e.w(), uint16(v))
130
	} else if v <= math.MaxUint32 {
131
		e.e.encWr.writen1(bd + 2)
132
		bigen.writeUint32(e.e.w(), uint32(v))
133
	} else { // if v <= math.MaxUint64 {
134
		e.e.encWr.writen1(bd + 3)
135
		bigen.writeUint64(e.e.w(), v)
136
	}
137
}
138

139
func (e *simpleEncDriver) encLen(bd byte, length int) {
140
	if length == 0 {
141
		e.e.encWr.writen1(bd)
142
	} else if length <= math.MaxUint8 {
143
		e.e.encWr.writen1(bd + 1)
144
		e.e.encWr.writen1(uint8(length))
145
	} else if length <= math.MaxUint16 {
146
		e.e.encWr.writen1(bd + 2)
147
		bigen.writeUint16(e.e.w(), uint16(length))
148
	} else if int64(length) <= math.MaxUint32 {
149
		e.e.encWr.writen1(bd + 3)
150
		bigen.writeUint32(e.e.w(), uint32(length))
151
	} else {
152
		e.e.encWr.writen1(bd + 4)
153
		bigen.writeUint64(e.e.w(), uint64(length))
154
	}
155
}
156

157
func (e *simpleEncDriver) EncodeExt(v interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
158
	var bs0, bs []byte
159
	if ext == SelfExt {
160
		bs0 = e.e.blist.get(1024)
161
		bs = bs0
162
		e.e.sideEncode(v, basetype, &bs)
163
	} else {
164
		bs = ext.WriteExt(v)
165
	}
166
	if bs == nil {
167
		e.EncodeNil()
168
		goto END
169
	}
170
	e.encodeExtPreamble(uint8(xtag), len(bs))
171
	e.e.encWr.writeb(bs)
172
END:
173
	if ext == SelfExt {
174
		e.e.blist.put(bs)
175
		if !byteSliceSameData(bs0, bs) {
176
			e.e.blist.put(bs0)
177
		}
178
	}
179
}
180

181
func (e *simpleEncDriver) EncodeRawExt(re *RawExt) {
182
	e.encodeExtPreamble(uint8(re.Tag), len(re.Data))
183
	e.e.encWr.writeb(re.Data)
184
}
185

186
func (e *simpleEncDriver) encodeExtPreamble(xtag byte, length int) {
187
	e.encLen(simpleVdExt, length)
188
	e.e.encWr.writen1(xtag)
189
}
190

191
func (e *simpleEncDriver) WriteArrayStart(length int) {
192
	e.encLen(simpleVdArray, length)
193
}
194

195
func (e *simpleEncDriver) WriteMapStart(length int) {
196
	e.encLen(simpleVdMap, length)
197
}
198

199
func (e *simpleEncDriver) EncodeString(v string) {
200
	if e.h.EncZeroValuesAsNil && e.e.c != containerMapKey && v == "" {
201
		e.EncodeNil()
202
		return
203
	}
204
	if e.h.StringToRaw {
205
		e.encLen(simpleVdByteArray, len(v))
206
	} else {
207
		e.encLen(simpleVdString, len(v))
208
	}
209
	e.e.encWr.writestr(v)
210
}
211

212
func (e *simpleEncDriver) EncodeStringBytesRaw(v []byte) {
213
	// if e.h.EncZeroValuesAsNil && e.c != containerMapKey && v == nil {
214
	if v == nil {
215
		e.EncodeNil()
216
		return
217
	}
218
	e.encLen(simpleVdByteArray, len(v))
219
	e.e.encWr.writeb(v)
220
}
221

222
func (e *simpleEncDriver) EncodeTime(t time.Time) {
223
	// if e.h.EncZeroValuesAsNil && e.c != containerMapKey && t.IsZero() {
224
	if t.IsZero() {
225
		e.EncodeNil()
226
		return
227
	}
228
	v, err := t.MarshalBinary()
229
	e.e.onerror(err)
230
	e.e.encWr.writen2(simpleVdTime, uint8(len(v)))
231
	e.e.encWr.writeb(v)
232
}
233

234
//------------------------------------
235

236
type simpleDecDriver struct {
237
	h *SimpleHandle
238
	bdAndBdread
239
	_ bool
240
	noBuiltInTypes
241
	decDriverNoopContainerReader
242
	decDriverNoopNumberHelper
243
	d Decoder
244
}
245

246
func (d *simpleDecDriver) decoder() *Decoder {
247
	return &d.d
248
}
249

250
func (d *simpleDecDriver) descBd() string {
251
	return sprintf("%v (%s)", d.bd, simpledesc(d.bd))
252
}
253

254
func (d *simpleDecDriver) readNextBd() {
255
	d.bd = d.d.decRd.readn1()
256
	d.bdRead = true
257
}
258

259
func (d *simpleDecDriver) advanceNil() (null bool) {
260
	if !d.bdRead {
261
		d.readNextBd()
262
	}
263
	if d.bd == simpleVdNil {
264
		d.bdRead = false
265
		return true // null = true
266
	}
267
	return
268
}
269

270
func (d *simpleDecDriver) ContainerType() (vt valueType) {
271
	if !d.bdRead {
272
		d.readNextBd()
273
	}
274
	switch d.bd {
275
	case simpleVdNil:
276
		d.bdRead = false
277
		return valueTypeNil
278
	case simpleVdByteArray, simpleVdByteArray + 1,
279
		simpleVdByteArray + 2, simpleVdByteArray + 3, simpleVdByteArray + 4:
280
		return valueTypeBytes
281
	case simpleVdString, simpleVdString + 1,
282
		simpleVdString + 2, simpleVdString + 3, simpleVdString + 4:
283
		return valueTypeString
284
	case simpleVdArray, simpleVdArray + 1,
285
		simpleVdArray + 2, simpleVdArray + 3, simpleVdArray + 4:
286
		return valueTypeArray
287
	case simpleVdMap, simpleVdMap + 1,
288
		simpleVdMap + 2, simpleVdMap + 3, simpleVdMap + 4:
289
		return valueTypeMap
290
	}
291
	return valueTypeUnset
292
}
293

294
func (d *simpleDecDriver) TryNil() bool {
295
	return d.advanceNil()
296
}
297

298
func (d *simpleDecDriver) decFloat() (f float64, ok bool) {
299
	ok = true
300
	switch d.bd {
301
	case simpleVdFloat32:
302
		f = float64(math.Float32frombits(bigen.Uint32(d.d.decRd.readn4())))
303
	case simpleVdFloat64:
304
		f = math.Float64frombits(bigen.Uint64(d.d.decRd.readn8()))
305
	default:
306
		ok = false
307
	}
308
	return
309
}
310

311
func (d *simpleDecDriver) decInteger() (ui uint64, neg, ok bool) {
312
	ok = true
313
	switch d.bd {
314
	case simpleVdPosInt:
315
		ui = uint64(d.d.decRd.readn1())
316
	case simpleVdPosInt + 1:
317
		ui = uint64(bigen.Uint16(d.d.decRd.readn2()))
318
	case simpleVdPosInt + 2:
319
		ui = uint64(bigen.Uint32(d.d.decRd.readn4()))
320
	case simpleVdPosInt + 3:
321
		ui = uint64(bigen.Uint64(d.d.decRd.readn8()))
322
	case simpleVdNegInt:
323
		ui = uint64(d.d.decRd.readn1())
324
		neg = true
325
	case simpleVdNegInt + 1:
326
		ui = uint64(bigen.Uint16(d.d.decRd.readn2()))
327
		neg = true
328
	case simpleVdNegInt + 2:
329
		ui = uint64(bigen.Uint32(d.d.decRd.readn4()))
330
		neg = true
331
	case simpleVdNegInt + 3:
332
		ui = uint64(bigen.Uint64(d.d.decRd.readn8()))
333
		neg = true
334
	default:
335
		ok = false
336
		// d.d.errorf("integer only valid from pos/neg integer1..8. Invalid descriptor: %v", d.bd)
337
	}
338
	// DO NOT do this check below, because callers may only want the unsigned value:
339
	//
340
	// if ui > math.MaxInt64 {
341
	// 	d.d.errorf("decIntAny: Integer out of range for signed int64: %v", ui)
342
	//		return
343
	// }
344
	return
345
}
346

347
func (d *simpleDecDriver) DecodeInt64() (i int64) {
348
	if d.advanceNil() {
349
		return
350
	}
351
	i = decNegintPosintFloatNumberHelper{&d.d}.int64(d.decInteger())
352
	d.bdRead = false
353
	return
354
}
355

356
func (d *simpleDecDriver) DecodeUint64() (ui uint64) {
357
	if d.advanceNil() {
358
		return
359
	}
360
	ui = decNegintPosintFloatNumberHelper{&d.d}.uint64(d.decInteger())
361
	d.bdRead = false
362
	return
363
}
364

365
func (d *simpleDecDriver) DecodeFloat64() (f float64) {
366
	if d.advanceNil() {
367
		return
368
	}
369
	f = decNegintPosintFloatNumberHelper{&d.d}.float64(d.decFloat())
370
	d.bdRead = false
371
	return
372
}
373

374
// bool can be decoded from bool only (single byte).
375
func (d *simpleDecDriver) DecodeBool() (b bool) {
376
	if d.advanceNil() {
377
		return
378
	}
379
	if d.bd == simpleVdFalse {
380
	} else if d.bd == simpleVdTrue {
381
		b = true
382
	} else {
383
		d.d.errorf("cannot decode bool - %s: %x", msgBadDesc, d.bd)
384
	}
385
	d.bdRead = false
386
	return
387
}
388

389
func (d *simpleDecDriver) ReadMapStart() (length int) {
390
	if d.advanceNil() {
391
		return containerLenNil
392
	}
393
	d.bdRead = false
394
	return d.decLen()
395
}
396

397
func (d *simpleDecDriver) ReadArrayStart() (length int) {
398
	if d.advanceNil() {
399
		return containerLenNil
400
	}
401
	d.bdRead = false
402
	return d.decLen()
403
}
404

405
func (d *simpleDecDriver) uint2Len(ui uint64) int {
406
	if chkOvf.Uint(ui, intBitsize) {
407
		d.d.errorf("overflow integer: %v", ui)
408
	}
409
	return int(ui)
410
}
411

412
func (d *simpleDecDriver) decLen() int {
413
	switch d.bd & 7 { // d.bd % 8 {
414
	case 0:
415
		return 0
416
	case 1:
417
		return int(d.d.decRd.readn1())
418
	case 2:
419
		return int(bigen.Uint16(d.d.decRd.readn2()))
420
	case 3:
421
		return d.uint2Len(uint64(bigen.Uint32(d.d.decRd.readn4())))
422
	case 4:
423
		return d.uint2Len(bigen.Uint64(d.d.decRd.readn8()))
424
	}
425
	d.d.errorf("cannot read length: bd%%8 must be in range 0..4. Got: %d", d.bd%8)
426
	return -1
427
}
428

429
func (d *simpleDecDriver) DecodeStringAsBytes() (s []byte) {
430
	return d.DecodeBytes(nil)
431
}
432

433
func (d *simpleDecDriver) DecodeBytes(bs []byte) (bsOut []byte) {
434
	d.d.decByteState = decByteStateNone
435
	if d.advanceNil() {
436
		return
437
	}
438
	// check if an "array" of uint8's (see ContainerType for how to infer if an array)
439
	if d.bd >= simpleVdArray && d.bd <= simpleVdMap+4 {
440
		if bs == nil {
441
			d.d.decByteState = decByteStateReuseBuf
442
			bs = d.d.b[:]
443
		}
444
		slen := d.ReadArrayStart()
445
		var changed bool
446
		if bs, changed = usableByteSlice(bs, slen); changed {
447
			d.d.decByteState = decByteStateNone
448
		}
449
		for i := 0; i < len(bs); i++ {
450
			bs[i] = uint8(chkOvf.UintV(d.DecodeUint64(), 8))
451
		}
452
		for i := len(bs); i < slen; i++ {
453
			bs = append(bs, uint8(chkOvf.UintV(d.DecodeUint64(), 8)))
454
		}
455
		return bs
456
	}
457

458
	clen := d.decLen()
459
	d.bdRead = false
460
	if d.d.zerocopy() {
461
		d.d.decByteState = decByteStateZerocopy
462
		return d.d.decRd.rb.readx(uint(clen))
463
	}
464
	if bs == nil {
465
		d.d.decByteState = decByteStateReuseBuf
466
		bs = d.d.b[:]
467
	}
468
	return decByteSlice(d.d.r(), clen, d.d.h.MaxInitLen, bs)
469
}
470

471
func (d *simpleDecDriver) DecodeTime() (t time.Time) {
472
	if d.advanceNil() {
473
		return
474
	}
475
	if d.bd != simpleVdTime {
476
		d.d.errorf("invalid descriptor for time.Time - expect 0x%x, received 0x%x", simpleVdTime, d.bd)
477
	}
478
	d.bdRead = false
479
	clen := uint(d.d.decRd.readn1())
480
	b := d.d.decRd.readx(clen)
481
	d.d.onerror((&t).UnmarshalBinary(b))
482
	return
483
}
484

485
func (d *simpleDecDriver) DecodeExt(rv interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
486
	if xtag > 0xff {
487
		d.d.errorf("ext: tag must be <= 0xff; got: %v", xtag)
488
	}
489
	if d.advanceNil() {
490
		return
491
	}
492
	xbs, realxtag1, zerocopy := d.decodeExtV(ext != nil, uint8(xtag))
493
	realxtag := uint64(realxtag1)
494
	if ext == nil {
495
		re := rv.(*RawExt)
496
		re.Tag = realxtag
497
		re.setData(xbs, zerocopy)
498
	} else if ext == SelfExt {
499
		d.d.sideDecode(rv, basetype, xbs)
500
	} else {
501
		ext.ReadExt(rv, xbs)
502
	}
503
}
504

505
func (d *simpleDecDriver) decodeExtV(verifyTag bool, tag byte) (xbs []byte, xtag byte, zerocopy bool) {
506
	switch d.bd {
507
	case simpleVdExt, simpleVdExt + 1, simpleVdExt + 2, simpleVdExt + 3, simpleVdExt + 4:
508
		l := d.decLen()
509
		xtag = d.d.decRd.readn1()
510
		if verifyTag && xtag != tag {
511
			d.d.errorf("wrong extension tag. Got %b. Expecting: %v", xtag, tag)
512
		}
513
		if d.d.bytes {
514
			xbs = d.d.decRd.rb.readx(uint(l))
515
			zerocopy = true
516
		} else {
517
			xbs = decByteSlice(d.d.r(), l, d.d.h.MaxInitLen, d.d.b[:])
518
		}
519
	case simpleVdByteArray, simpleVdByteArray + 1,
520
		simpleVdByteArray + 2, simpleVdByteArray + 3, simpleVdByteArray + 4:
521
		xbs = d.DecodeBytes(nil)
522
	default:
523
		d.d.errorf("ext - %s - expecting extensions/bytearray, got: 0x%x", msgBadDesc, d.bd)
524
	}
525
	d.bdRead = false
526
	return
527
}
528

529
func (d *simpleDecDriver) DecodeNaked() {
530
	if !d.bdRead {
531
		d.readNextBd()
532
	}
533

534
	n := d.d.naked()
535
	var decodeFurther bool
536

537
	switch d.bd {
538
	case simpleVdNil:
539
		n.v = valueTypeNil
540
	case simpleVdFalse:
541
		n.v = valueTypeBool
542
		n.b = false
543
	case simpleVdTrue:
544
		n.v = valueTypeBool
545
		n.b = true
546
	case simpleVdPosInt, simpleVdPosInt + 1, simpleVdPosInt + 2, simpleVdPosInt + 3:
547
		if d.h.SignedInteger {
548
			n.v = valueTypeInt
549
			n.i = d.DecodeInt64()
550
		} else {
551
			n.v = valueTypeUint
552
			n.u = d.DecodeUint64()
553
		}
554
	case simpleVdNegInt, simpleVdNegInt + 1, simpleVdNegInt + 2, simpleVdNegInt + 3:
555
		n.v = valueTypeInt
556
		n.i = d.DecodeInt64()
557
	case simpleVdFloat32:
558
		n.v = valueTypeFloat
559
		n.f = d.DecodeFloat64()
560
	case simpleVdFloat64:
561
		n.v = valueTypeFloat
562
		n.f = d.DecodeFloat64()
563
	case simpleVdTime:
564
		n.v = valueTypeTime
565
		n.t = d.DecodeTime()
566
	case simpleVdString, simpleVdString + 1,
567
		simpleVdString + 2, simpleVdString + 3, simpleVdString + 4:
568
		n.v = valueTypeString
569
		n.s = d.d.stringZC(d.DecodeStringAsBytes())
570
	case simpleVdByteArray, simpleVdByteArray + 1,
571
		simpleVdByteArray + 2, simpleVdByteArray + 3, simpleVdByteArray + 4:
572
		d.d.fauxUnionReadRawBytes(false)
573
	case simpleVdExt, simpleVdExt + 1, simpleVdExt + 2, simpleVdExt + 3, simpleVdExt + 4:
574
		n.v = valueTypeExt
575
		l := d.decLen()
576
		n.u = uint64(d.d.decRd.readn1())
577
		if d.d.bytes {
578
			n.l = d.d.decRd.rb.readx(uint(l))
579
		} else {
580
			n.l = decByteSlice(d.d.r(), l, d.d.h.MaxInitLen, d.d.b[:])
581
		}
582
	case simpleVdArray, simpleVdArray + 1, simpleVdArray + 2,
583
		simpleVdArray + 3, simpleVdArray + 4:
584
		n.v = valueTypeArray
585
		decodeFurther = true
586
	case simpleVdMap, simpleVdMap + 1, simpleVdMap + 2, simpleVdMap + 3, simpleVdMap + 4:
587
		n.v = valueTypeMap
588
		decodeFurther = true
589
	default:
590
		d.d.errorf("cannot infer value - %s 0x%x", msgBadDesc, d.bd)
591
	}
592

593
	if !decodeFurther {
594
		d.bdRead = false
595
	}
596
}
597

598
func (d *simpleDecDriver) nextValueBytes(v0 []byte) (v []byte) {
599
	if !d.bdRead {
600
		d.readNextBd()
601
	}
602
	v = v0
603
	var h = decNextValueBytesHelper{d: &d.d}
604
	var cursor = d.d.rb.c - 1
605
	h.append1(&v, d.bd)
606
	v = d.nextValueBytesBdReadR(v)
607
	d.bdRead = false
608
	h.bytesRdV(&v, cursor)
609
	return
610
}
611

612
func (d *simpleDecDriver) nextValueBytesR(v0 []byte) (v []byte) {
613
	d.readNextBd()
614
	v = v0
615
	var h = decNextValueBytesHelper{d: &d.d}
616
	h.append1(&v, d.bd)
617
	return d.nextValueBytesBdReadR(v)
618
}
619

620
func (d *simpleDecDriver) nextValueBytesBdReadR(v0 []byte) (v []byte) {
621
	v = v0
622
	var h = decNextValueBytesHelper{d: &d.d}
623

624
	c := d.bd
625

626
	var length uint
627

628
	switch c {
629
	case simpleVdNil, simpleVdFalse, simpleVdTrue, simpleVdString, simpleVdByteArray:
630
		// pass
631
	case simpleVdPosInt, simpleVdNegInt:
632
		h.append1(&v, d.d.decRd.readn1())
633
	case simpleVdPosInt + 1, simpleVdNegInt + 1:
634
		h.appendN(&v, d.d.decRd.readx(2)...)
635
	case simpleVdPosInt + 2, simpleVdNegInt + 2, simpleVdFloat32:
636
		h.appendN(&v, d.d.decRd.readx(4)...)
637
	case simpleVdPosInt + 3, simpleVdNegInt + 3, simpleVdFloat64:
638
		h.appendN(&v, d.d.decRd.readx(8)...)
639
	case simpleVdTime:
640
		c = d.d.decRd.readn1()
641
		h.append1(&v, c)
642
		h.appendN(&v, d.d.decRd.readx(uint(c))...)
643

644
	default:
645
		switch c & 7 { // c % 8 {
646
		case 0:
647
			length = 0
648
		case 1:
649
			b := d.d.decRd.readn1()
650
			length = uint(b)
651
			h.append1(&v, b)
652
		case 2:
653
			x := d.d.decRd.readn2()
654
			length = uint(bigen.Uint16(x))
655
			h.appendN(&v, x[:]...)
656
		case 3:
657
			x := d.d.decRd.readn4()
658
			length = uint(bigen.Uint32(x))
659
			h.appendN(&v, x[:]...)
660
		case 4:
661
			x := d.d.decRd.readn8()
662
			length = uint(bigen.Uint64(x))
663
			h.appendN(&v, x[:]...)
664
		}
665

666
		bExt := c >= simpleVdExt && c <= simpleVdExt+7
667
		bStr := c >= simpleVdString && c <= simpleVdString+7
668
		bByteArray := c >= simpleVdByteArray && c <= simpleVdByteArray+7
669
		bArray := c >= simpleVdArray && c <= simpleVdArray+7
670
		bMap := c >= simpleVdMap && c <= simpleVdMap+7
671

672
		if !(bExt || bStr || bByteArray || bArray || bMap) {
673
			d.d.errorf("cannot infer value - %s 0x%x", msgBadDesc, c)
674
		}
675

676
		if bExt {
677
			h.append1(&v, d.d.decRd.readn1()) // tag
678
		}
679

680
		if length == 0 {
681
			break
682
		}
683

684
		if bArray {
685
			for i := uint(0); i < length; i++ {
686
				v = d.nextValueBytesR(v)
687
			}
688
		} else if bMap {
689
			for i := uint(0); i < length; i++ {
690
				v = d.nextValueBytesR(v)
691
				v = d.nextValueBytesR(v)
692
			}
693
		} else {
694
			h.appendN(&v, d.d.decRd.readx(length)...)
695
		}
696
	}
697
	return
698
}
699

700
//------------------------------------
701

702
// SimpleHandle is a Handle for a very simple encoding format.
703
//
704
// simple is a simplistic codec similar to binc, but not as compact.
705
//   - Encoding of a value is always preceded by the descriptor byte (bd)
706
//   - True, false, nil are encoded fully in 1 byte (the descriptor)
707
//   - Integers (intXXX, uintXXX) are encoded in 1, 2, 4 or 8 bytes (plus a descriptor byte).
708
//     There are positive (uintXXX and intXXX >= 0) and negative (intXXX < 0) integers.
709
//   - Floats are encoded in 4 or 8 bytes (plus a descriptor byte)
710
//   - Length of containers (strings, bytes, array, map, extensions)
711
//     are encoded in 0, 1, 2, 4 or 8 bytes.
712
//     Zero-length containers have no length encoded.
713
//     For others, the number of bytes is given by pow(2, bd%3)
714
//   - maps are encoded as [bd] [length] [[key][value]]...
715
//   - arrays are encoded as [bd] [length] [value]...
716
//   - extensions are encoded as [bd] [length] [tag] [byte]...
717
//   - strings/bytearrays are encoded as [bd] [length] [byte]...
718
//   - time.Time are encoded as [bd] [length] [byte]...
719
//
720
// The full spec will be published soon.
721
type SimpleHandle struct {
722
	binaryEncodingType
723
	BasicHandle
724
	// EncZeroValuesAsNil says to encode zero values for numbers, bool, string, etc as nil
725
	EncZeroValuesAsNil bool
726
}
727

728
// Name returns the name of the handle: simple
729
func (h *SimpleHandle) Name() string { return "simple" }
730

731
func (h *SimpleHandle) desc(bd byte) string { return simpledesc(bd) }
732

733
func (h *SimpleHandle) newEncDriver() encDriver {
734
	var e = &simpleEncDriver{h: h}
735
	e.e.e = e
736
	e.e.init(h)
737
	e.reset()
738
	return e
739
}
740

741
func (h *SimpleHandle) newDecDriver() decDriver {
742
	d := &simpleDecDriver{h: h}
743
	d.d.d = d
744
	d.d.init(h)
745
	d.reset()
746
	return d
747
}
748

749
var _ decDriver = (*simpleDecDriver)(nil)
750
var _ encDriver = (*simpleEncDriver)(nil)
751