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
// By default, this json support uses base64 encoding for bytes, because you cannot
7
// store and read any arbitrary string in json (only unicode).
8
// However, the user can configre how to encode/decode bytes.
9
//
10
// This library specifically supports UTF-8 for encoding and decoding only.
11
//
12
// Note that the library will happily encode/decode things which are not valid
13
// json e.g. a map[int64]string. We do it for consistency. With valid json,
14
// we will encode and decode appropriately.
15
// Users can specify their map type if necessary to force it.
16
//
17
// We cannot use strconv.(Q|Unq)uote because json quotes/unquotes differently.
18

19
import (
20
	"encoding/base64"
21
	"math"
22
	"reflect"
23
	"strconv"
24
	"time"
25
	"unicode"
26
	"unicode/utf16"
27
	"unicode/utf8"
28
)
29

30
//--------------------------------
31

32
// jsonLits and jsonLitb are defined at the package level,
33
// so they are guaranteed to be stored efficiently, making
34
// for better append/string comparison/etc.
35
//
36
// (anecdotal evidence from some benchmarking on go 1.20 devel in 20220104)
37
const jsonLits = `"true"false"null"`
38

39
var jsonLitb = []byte(jsonLits)
40

41
const (
42
	jsonLitT = 1
43
	jsonLitF = 6
44
	jsonLitN = 12
45
)
46

47
const jsonEncodeUintSmallsString = "" +
48
	"00010203040506070809" +
49
	"10111213141516171819" +
50
	"20212223242526272829" +
51
	"30313233343536373839" +
52
	"40414243444546474849" +
53
	"50515253545556575859" +
54
	"60616263646566676869" +
55
	"70717273747576777879" +
56
	"80818283848586878889" +
57
	"90919293949596979899"
58

59
var jsonEncodeUintSmallsStringBytes = []byte(jsonEncodeUintSmallsString)
60

61
const (
62
	jsonU4Chk2 = '0'
63
	jsonU4Chk1 = 'a' - 10
64
	jsonU4Chk0 = 'A' - 10
65
)
66

67
const (
68
	// If !jsonValidateSymbols, decoding will be faster, by skipping some checks:
69
	//   - If we see first character of null, false or true,
70
	//     do not validate subsequent characters.
71
	//   - e.g. if we see a n, assume null and skip next 3 characters,
72
	//     and do not validate they are ull.
73
	// P.S. Do not expect a significant decoding boost from this.
74
	jsonValidateSymbols = true
75

76
	// jsonEscapeMultiByteUnicodeSep controls whether some unicode characters
77
	// that are valid json but may bomb in some contexts are escaped during encoeing.
78
	//
79
	// U+2028 is LINE SEPARATOR. U+2029 is PARAGRAPH SEPARATOR.
80
	// Both technically valid JSON, but bomb on JSONP, so fix here unconditionally.
81
	jsonEscapeMultiByteUnicodeSep = true
82

83
	// jsonRecognizeBoolNullInQuotedStr is used during decoding into a blank interface{}
84
	// to control whether we detect quoted values of bools and null where a map key is expected,
85
	// and treat as nil, true or false.
86
	jsonNakedBoolNullInQuotedStr = true
87

88
	// jsonManualInlineDecRdInHotZones controls whether we manually inline some decReader calls.
89
	//
90
	// encode performance is at par with libraries that just iterate over bytes directly,
91
	// because encWr (with inlined bytesEncAppender calls) is inlined.
92
	// Conversely, decode performance suffers because decRd (with inlined bytesDecReader calls)
93
	// isn't inlinable.
94
	//
95
	// To improve decode performamnce from json:
96
	// - readn1 is only called for \u
97
	// - consequently, to optimize json decoding, we specifically need inlining
98
	//   for bytes use-case of some other decReader methods:
99
	//   - jsonReadAsisChars, skipWhitespace (advance) and jsonReadNum
100
	//   - AND THEN readn3, readn4 (for ull, rue and alse).
101
	//   - (readn1 is only called when a char is escaped).
102
	// - without inlining, we still pay the cost of a method invocationK, and this dominates time
103
	// - To mitigate, we manually inline in hot zones
104
	//   *excluding places where used sparingly (e.g. nextValueBytes, and other atypical cases)*.
105
	//   - jsonReadAsisChars *only* called in: appendStringAsBytes
106
	//   - advance called: everywhere
107
	//   - jsonReadNum: decNumBytes, DecodeNaked
108
	// - From running go test (our anecdotal findings):
109
	//   - calling jsonReadAsisChars in appendStringAsBytes: 23431
110
	//   - calling jsonReadNum in decNumBytes: 15251
111
	//   - calling jsonReadNum in DecodeNaked: 612
112
	// Consequently, we manually inline jsonReadAsisChars (in appendStringAsBytes)
113
	// and jsonReadNum (in decNumbytes)
114
	jsonManualInlineDecRdInHotZones = true
115

116
	jsonSpacesOrTabsLen = 128
117

118
	// jsonAlwaysReturnInternString = false
119
)
120

121
var (
122
	// jsonTabs and jsonSpaces are used as caches for indents
123
	jsonTabs, jsonSpaces [jsonSpacesOrTabsLen]byte
124

125
	jsonCharHtmlSafeSet bitset256
126
	jsonCharSafeSet     bitset256
127
)
128

129
func init() {
130
	var i byte
131
	for i = 0; i < jsonSpacesOrTabsLen; i++ {
132
		jsonSpaces[i] = ' '
133
		jsonTabs[i] = '\t'
134
	}
135

136
	// populate the safe values as true: note: ASCII control characters are (0-31)
137
	// jsonCharSafeSet:     all true except (0-31) " \
138
	// jsonCharHtmlSafeSet: all true except (0-31) " \ < > &
139
	for i = 32; i < utf8.RuneSelf; i++ {
140
		switch i {
141
		case '"', '\\':
142
		case '<', '>', '&':
143
			jsonCharSafeSet.set(i) // = true
144
		default:
145
			jsonCharSafeSet.set(i)
146
			jsonCharHtmlSafeSet.set(i)
147
		}
148
	}
149
}
150

151
// ----------------
152

153
type jsonEncState struct {
154
	di int8   // indent per: if negative, use tabs
155
	d  bool   // indenting?
156
	dl uint16 // indent level
157
}
158

159
func (x jsonEncState) captureState() interface{}   { return x }
160
func (x *jsonEncState) restoreState(v interface{}) { *x = v.(jsonEncState) }
161

162
type jsonEncDriver struct {
163
	noBuiltInTypes
164
	h *JsonHandle
165

166
	// se interfaceExtWrapper
167

168
	// ---- cpu cache line boundary?
169
	jsonEncState
170

171
	ks bool // map key as string
172
	is byte // integer as string
173

174
	typical bool
175
	rawext  bool // rawext configured on the handle
176

177
	s *bitset256 // safe set for characters (taking h.HTMLAsIs into consideration)
178

179
	// buf *[]byte // used mostly for encoding []byte
180

181
	// scratch buffer for: encode time, numbers, etc
182
	//
183
	// RFC3339Nano uses 35 chars: 2006-01-02T15:04:05.999999999Z07:00
184
	// MaxUint64 uses 20 chars: 18446744073709551615
185
	// floats are encoded using: f/e fmt, and -1 precision, or 1 if no fractions.
186
	// This means we are limited by the number of characters for the
187
	// mantissa (up to 17), exponent (up to 3), signs (up to 3), dot (up to 1), E (up to 1)
188
	// for a total of 24 characters.
189
	//    -xxx.yyyyyyyyyyyye-zzz
190
	// Consequently, 35 characters should be sufficient for encoding time, integers or floats.
191
	// We use up all the remaining bytes to make this use full cache lines.
192
	b [48]byte
193

194
	e Encoder
195
}
196

197
func (e *jsonEncDriver) encoder() *Encoder { return &e.e }
198

199
func (e *jsonEncDriver) writeIndent() {
200
	e.e.encWr.writen1('\n')
201
	x := int(e.di) * int(e.dl)
202
	if e.di < 0 {
203
		x = -x
204
		for x > jsonSpacesOrTabsLen {
205
			e.e.encWr.writeb(jsonTabs[:])
206
			x -= jsonSpacesOrTabsLen
207
		}
208
		e.e.encWr.writeb(jsonTabs[:x])
209
	} else {
210
		for x > jsonSpacesOrTabsLen {
211
			e.e.encWr.writeb(jsonSpaces[:])
212
			x -= jsonSpacesOrTabsLen
213
		}
214
		e.e.encWr.writeb(jsonSpaces[:x])
215
	}
216
}
217

218
func (e *jsonEncDriver) WriteArrayElem() {
219
	if e.e.c != containerArrayStart {
220
		e.e.encWr.writen1(',')
221
	}
222
	if e.d {
223
		e.writeIndent()
224
	}
225
}
226

227
func (e *jsonEncDriver) WriteMapElemKey() {
228
	if e.e.c != containerMapStart {
229
		e.e.encWr.writen1(',')
230
	}
231
	if e.d {
232
		e.writeIndent()
233
	}
234
}
235

236
func (e *jsonEncDriver) WriteMapElemValue() {
237
	if e.d {
238
		e.e.encWr.writen2(':', ' ')
239
	} else {
240
		e.e.encWr.writen1(':')
241
	}
242
}
243

244
func (e *jsonEncDriver) EncodeNil() {
245
	// We always encode nil as just null (never in quotes)
246
	// so we can easily decode if a nil in the json stream ie if initial token is n.
247

248
	e.e.encWr.writestr(jsonLits[jsonLitN : jsonLitN+4])
249
}
250

251
func (e *jsonEncDriver) EncodeTime(t time.Time) {
252
	// Do NOT use MarshalJSON, as it allocates internally.
253
	// instead, we call AppendFormat directly, using our scratch buffer (e.b)
254

255
	if t.IsZero() {
256
		e.EncodeNil()
257
	} else {
258
		e.b[0] = '"'
259
		b := fmtTime(t, time.RFC3339Nano, e.b[1:1])
260
		e.b[len(b)+1] = '"'
261
		e.e.encWr.writeb(e.b[:len(b)+2])
262
	}
263
}
264

265
func (e *jsonEncDriver) EncodeExt(rv interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
266
	if ext == SelfExt {
267
		e.e.encodeValue(baseRV(rv), e.h.fnNoExt(basetype))
268
	} else if v := ext.ConvertExt(rv); v == nil {
269
		e.EncodeNil()
270
	} else {
271
		e.e.encode(v)
272
	}
273
}
274

275
func (e *jsonEncDriver) EncodeRawExt(re *RawExt) {
276
	// only encodes re.Value (never re.Data)
277
	if re.Value == nil {
278
		e.EncodeNil()
279
	} else {
280
		e.e.encode(re.Value)
281
	}
282
}
283

284
var jsonEncBoolStrs = [2][2]string{
285
	{jsonLits[jsonLitF : jsonLitF+5], jsonLits[jsonLitT : jsonLitT+4]},
286
	{jsonLits[jsonLitF-1 : jsonLitF+6], jsonLits[jsonLitT-1 : jsonLitT+5]},
287
}
288

289
func (e *jsonEncDriver) EncodeBool(b bool) {
290
	e.e.encWr.writestr(
291
		jsonEncBoolStrs[bool2int(e.ks && e.e.c == containerMapKey)%2][bool2int(b)%2])
292
}
293

294
// func (e *jsonEncDriver) EncodeBool(b bool) {
295
// 	if e.ks && e.e.c == containerMapKey {
296
// 		if b {
297
// 			e.e.encWr.writestr(jsonLits[jsonLitT-1 : jsonLitT+5])
298
// 		} else {
299
// 			e.e.encWr.writestr(jsonLits[jsonLitF-1 : jsonLitF+6])
300
// 		}
301
// 	} else {
302
// 		if b {
303
// 			e.e.encWr.writestr(jsonLits[jsonLitT : jsonLitT+4])
304
// 		} else {
305
// 			e.e.encWr.writestr(jsonLits[jsonLitF : jsonLitF+5])
306
// 		}
307
// 	}
308
// }
309

310
func (e *jsonEncDriver) encodeFloat(f float64, bitsize, fmt byte, prec int8) {
311
	var blen uint
312
	if e.ks && e.e.c == containerMapKey {
313
		blen = 2 + uint(len(strconv.AppendFloat(e.b[1:1], f, fmt, int(prec), int(bitsize))))
314
		// _ = e.b[:blen]
315
		e.b[0] = '"'
316
		e.b[blen-1] = '"'
317
		e.e.encWr.writeb(e.b[:blen])
318
	} else {
319
		e.e.encWr.writeb(strconv.AppendFloat(e.b[:0], f, fmt, int(prec), int(bitsize)))
320
	}
321
}
322

323
func (e *jsonEncDriver) EncodeFloat64(f float64) {
324
	if math.IsNaN(f) || math.IsInf(f, 0) {
325
		e.EncodeNil()
326
		return
327
	}
328
	fmt, prec := jsonFloatStrconvFmtPrec64(f)
329
	e.encodeFloat(f, 64, fmt, prec)
330
}
331

332
func (e *jsonEncDriver) EncodeFloat32(f float32) {
333
	if math.IsNaN(float64(f)) || math.IsInf(float64(f), 0) {
334
		e.EncodeNil()
335
		return
336
	}
337
	fmt, prec := jsonFloatStrconvFmtPrec32(f)
338
	e.encodeFloat(float64(f), 32, fmt, prec)
339
}
340

341
func (e *jsonEncDriver) encodeUint(neg bool, quotes bool, u uint64) {
342
	// copied mostly from std library: strconv
343
	// this should only be called on 64bit OS.
344

345
	// const smallsString = jsonEncodeUintSmallsString
346
	var ss = jsonEncodeUintSmallsStringBytes
347

348
	// typically, 19 or 20 bytes sufficient for decimal encoding a uint64
349
	// var a [24]byte
350
	var a = e.b[0:24]
351
	var i = uint(len(a))
352

353
	if quotes {
354
		i--
355
		setByteAt(a, i, '"')
356
		// a[i] = '"'
357
	}
358
	// u guaranteed to fit into a uint (as we are not 32bit OS)
359
	var is uint
360
	var us = uint(u)
361
	for us >= 100 {
362
		is = us % 100 * 2
363
		us /= 100
364
		i -= 2
365
		setByteAt(a, i+1, byteAt(ss, is+1))
366
		setByteAt(a, i, byteAt(ss, is))
367
		// a[i+1] = smallsString[is+1]
368
		// a[i+0] = smallsString[is+0]
369
	}
370

371
	// us < 100
372
	is = us * 2
373
	i--
374
	setByteAt(a, i, byteAt(ss, is+1))
375
	// a[i] = smallsString[is+1]
376
	if us >= 10 {
377
		i--
378
		setByteAt(a, i, byteAt(ss, is))
379
		// a[i] = smallsString[is]
380
	}
381
	if neg {
382
		i--
383
		setByteAt(a, i, '-')
384
		// a[i] = '-'
385
	}
386
	if quotes {
387
		i--
388
		setByteAt(a, i, '"')
389
		// a[i] = '"'
390
	}
391
	e.e.encWr.writeb(a[i:])
392
}
393

394
func (e *jsonEncDriver) EncodeInt(v int64) {
395
	quotes := e.is == 'A' || e.is == 'L' && (v > 1<<53 || v < -(1<<53)) ||
396
		(e.ks && e.e.c == containerMapKey)
397

398
	if cpu32Bit {
399
		if quotes {
400
			blen := 2 + len(strconv.AppendInt(e.b[1:1], v, 10))
401
			e.b[0] = '"'
402
			e.b[blen-1] = '"'
403
			e.e.encWr.writeb(e.b[:blen])
404
		} else {
405
			e.e.encWr.writeb(strconv.AppendInt(e.b[:0], v, 10))
406
		}
407
		return
408
	}
409

410
	if v < 0 {
411
		e.encodeUint(true, quotes, uint64(-v))
412
	} else {
413
		e.encodeUint(false, quotes, uint64(v))
414
	}
415
}
416

417
func (e *jsonEncDriver) EncodeUint(v uint64) {
418
	quotes := e.is == 'A' || e.is == 'L' && v > 1<<53 ||
419
		(e.ks && e.e.c == containerMapKey)
420

421
	if cpu32Bit {
422
		// use strconv directly, as optimized encodeUint only works on 64-bit alone
423
		if quotes {
424
			blen := 2 + len(strconv.AppendUint(e.b[1:1], v, 10))
425
			e.b[0] = '"'
426
			e.b[blen-1] = '"'
427
			e.e.encWr.writeb(e.b[:blen])
428
		} else {
429
			e.e.encWr.writeb(strconv.AppendUint(e.b[:0], v, 10))
430
		}
431
		return
432
	}
433

434
	e.encodeUint(false, quotes, v)
435
}
436

437
func (e *jsonEncDriver) EncodeString(v string) {
438
	if e.h.StringToRaw {
439
		e.EncodeStringBytesRaw(bytesView(v))
440
		return
441
	}
442
	e.quoteStr(v)
443
}
444

445
func (e *jsonEncDriver) EncodeStringBytesRaw(v []byte) {
446
	// if encoding raw bytes and RawBytesExt is configured, use it to encode
447
	if v == nil {
448
		e.EncodeNil()
449
		return
450
	}
451

452
	if e.rawext {
453
		iv := e.h.RawBytesExt.ConvertExt(v)
454
		if iv == nil {
455
			e.EncodeNil()
456
		} else {
457
			e.e.encode(iv)
458
		}
459
		return
460
	}
461

462
	slen := base64.StdEncoding.EncodedLen(len(v)) + 2
463

464
	// bs := e.e.blist.check(*e.buf, n)[:slen]
465
	// *e.buf = bs
466

467
	bs := e.e.blist.peek(slen, false)
468
	bs = bs[:slen]
469

470
	base64.StdEncoding.Encode(bs[1:], v)
471
	bs[len(bs)-1] = '"'
472
	bs[0] = '"'
473
	e.e.encWr.writeb(bs)
474
}
475

476
// indent is done as below:
477
//   - newline and indent are added before each mapKey or arrayElem
478
//   - newline and indent are added before each ending,
479
//     except there was no entry (so we can have {} or [])
480

481
func (e *jsonEncDriver) WriteArrayStart(length int) {
482
	if e.d {
483
		e.dl++
484
	}
485
	e.e.encWr.writen1('[')
486
}
487

488
func (e *jsonEncDriver) WriteArrayEnd() {
489
	if e.d {
490
		e.dl--
491
		e.writeIndent()
492
	}
493
	e.e.encWr.writen1(']')
494
}
495

496
func (e *jsonEncDriver) WriteMapStart(length int) {
497
	if e.d {
498
		e.dl++
499
	}
500
	e.e.encWr.writen1('{')
501
}
502

503
func (e *jsonEncDriver) WriteMapEnd() {
504
	if e.d {
505
		e.dl--
506
		if e.e.c != containerMapStart {
507
			e.writeIndent()
508
		}
509
	}
510
	e.e.encWr.writen1('}')
511
}
512

513
func (e *jsonEncDriver) quoteStr(s string) {
514
	// adapted from std pkg encoding/json
515
	const hex = "0123456789abcdef"
516
	w := e.e.w()
517
	w.writen1('"')
518
	var i, start uint
519
	for i < uint(len(s)) {
520
		// encode all bytes < 0x20 (except \r, \n).
521
		// also encode < > & to prevent security holes when served to some browsers.
522

523
		// We optimize for ascii, by assumining that most characters are in the BMP
524
		// and natively consumed by json without much computation.
525

526
		// if 0x20 <= b && b != '\\' && b != '"' && b != '<' && b != '>' && b != '&' {
527
		// if (htmlasis && jsonCharSafeSet.isset(b)) || jsonCharHtmlSafeSet.isset(b) {
528
		if e.s.isset(s[i]) {
529
			i++
530
			continue
531
		}
532
		// b := s[i]
533
		if s[i] < utf8.RuneSelf {
534
			if start < i {
535
				w.writestr(s[start:i])
536
			}
537
			switch s[i] {
538
			case '\\', '"':
539
				w.writen2('\\', s[i])
540
			case '\n':
541
				w.writen2('\\', 'n')
542
			case '\r':
543
				w.writen2('\\', 'r')
544
			case '\b':
545
				w.writen2('\\', 'b')
546
			case '\f':
547
				w.writen2('\\', 'f')
548
			case '\t':
549
				w.writen2('\\', 't')
550
			default:
551
				w.writestr(`\u00`)
552
				w.writen2(hex[s[i]>>4], hex[s[i]&0xF])
553
			}
554
			i++
555
			start = i
556
			continue
557
		}
558
		c, size := utf8.DecodeRuneInString(s[i:])
559
		if c == utf8.RuneError && size == 1 { // meaning invalid encoding (so output as-is)
560
			if start < i {
561
				w.writestr(s[start:i])
562
			}
563
			w.writestr(`\uFFFD`)
564
			i++
565
			start = i
566
			continue
567
		}
568
		// U+2028 is LINE SEPARATOR. U+2029 is PARAGRAPH SEPARATOR.
569
		// Both technically valid JSON, but bomb on JSONP, so fix here *unconditionally*.
570
		if jsonEscapeMultiByteUnicodeSep && (c == '\u2028' || c == '\u2029') {
571
			if start < i {
572
				w.writestr(s[start:i])
573
			}
574
			w.writestr(`\u202`)
575
			w.writen1(hex[c&0xF])
576
			i += uint(size)
577
			start = i
578
			continue
579
		}
580
		i += uint(size)
581
	}
582
	if start < uint(len(s)) {
583
		w.writestr(s[start:])
584
	}
585
	w.writen1('"')
586
}
587

588
func (e *jsonEncDriver) atEndOfEncode() {
589
	if e.h.TermWhitespace {
590
		var c byte = ' ' // default is that scalar is written, so output space
591
		if e.e.c != 0 {
592
			c = '\n' // for containers (map/list), output a newline
593
		}
594
		e.e.encWr.writen1(c)
595
	}
596
}
597

598
// ----------
599

600
type jsonDecState struct {
601
	rawext bool // rawext configured on the handle
602

603
	tok  uint8   // used to store the token read right after skipWhiteSpace
604
	_    bool    // found null
605
	_    byte    // padding
606
	bstr [4]byte // scratch used for string \UXXX parsing
607

608
	// scratch buffer used for base64 decoding (DecodeBytes in reuseBuf mode),
609
	// or reading doubleQuoted string (DecodeStringAsBytes, DecodeNaked)
610
	buf *[]byte
611
}
612

613
func (x jsonDecState) captureState() interface{}   { return x }
614
func (x *jsonDecState) restoreState(v interface{}) { *x = v.(jsonDecState) }
615

616
type jsonDecDriver struct {
617
	noBuiltInTypes
618
	decDriverNoopNumberHelper
619
	h *JsonHandle
620

621
	jsonDecState
622

623
	// se  interfaceExtWrapper
624

625
	// ---- cpu cache line boundary?
626

627
	d Decoder
628
}
629

630
func (d *jsonDecDriver) descBd() (s string) { panic("descBd unsupported") }
631

632
func (d *jsonDecDriver) decoder() *Decoder {
633
	return &d.d
634
}
635

636
func (d *jsonDecDriver) ReadMapStart() int {
637
	d.advance()
638
	if d.tok == 'n' {
639
		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
640
		return containerLenNil
641
	}
642
	if d.tok != '{' {
643
		d.d.errorf("read map - expect char '%c' but got char '%c'", '{', d.tok)
644
	}
645
	d.tok = 0
646
	return containerLenUnknown
647
}
648

649
func (d *jsonDecDriver) ReadArrayStart() int {
650
	d.advance()
651
	if d.tok == 'n' {
652
		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
653
		return containerLenNil
654
	}
655
	if d.tok != '[' {
656
		d.d.errorf("read array - expect char '%c' but got char '%c'", '[', d.tok)
657
	}
658
	d.tok = 0
659
	return containerLenUnknown
660
}
661

662
// MARKER:
663
// We attempted making sure CheckBreak can be inlined, by moving the skipWhitespace
664
// call to an explicit (noinline) function call.
665
// However, this forces CheckBreak to always incur a function call if there was whitespace,
666
// with no clear benefit.
667

668
func (d *jsonDecDriver) CheckBreak() bool {
669
	d.advance()
670
	return d.tok == '}' || d.tok == ']'
671
}
672

673
func (d *jsonDecDriver) ReadArrayElem() {
674
	const xc uint8 = ','
675
	if d.d.c != containerArrayStart {
676
		d.advance()
677
		if d.tok != xc {
678
			d.readDelimError(xc)
679
		}
680
		d.tok = 0
681
	}
682
}
683

684
func (d *jsonDecDriver) ReadArrayEnd() {
685
	const xc uint8 = ']'
686
	d.advance()
687
	if d.tok != xc {
688
		d.readDelimError(xc)
689
	}
690
	d.tok = 0
691
}
692

693
func (d *jsonDecDriver) ReadMapElemKey() {
694
	const xc uint8 = ','
695
	if d.d.c != containerMapStart {
696
		d.advance()
697
		if d.tok != xc {
698
			d.readDelimError(xc)
699
		}
700
		d.tok = 0
701
	}
702
}
703

704
func (d *jsonDecDriver) ReadMapElemValue() {
705
	const xc uint8 = ':'
706
	d.advance()
707
	if d.tok != xc {
708
		d.readDelimError(xc)
709
	}
710
	d.tok = 0
711
}
712

713
func (d *jsonDecDriver) ReadMapEnd() {
714
	const xc uint8 = '}'
715
	d.advance()
716
	if d.tok != xc {
717
		d.readDelimError(xc)
718
	}
719
	d.tok = 0
720
}
721

722
func (d *jsonDecDriver) readDelimError(xc uint8) {
723
	d.d.errorf("read json delimiter - expect char '%c' but got char '%c'", xc, d.tok)
724
}
725

726
// MARKER: checkLit takes the readn(3|4) result as a parameter so they can be inlined.
727
// We pass the array directly to errorf, as passing slice pushes past inlining threshold,
728
// and passing slice also might cause allocation of the bs array on the heap.
729

730
func (d *jsonDecDriver) checkLit3(got, expect [3]byte) {
731
	d.tok = 0
732
	if jsonValidateSymbols && got != expect {
733
		d.d.errorf("expecting %s: got %s", expect, got)
734
	}
735
}
736

737
func (d *jsonDecDriver) checkLit4(got, expect [4]byte) {
738
	d.tok = 0
739
	if jsonValidateSymbols && got != expect {
740
		d.d.errorf("expecting %s: got %s", expect, got)
741
	}
742
}
743

744
func (d *jsonDecDriver) skipWhitespace() {
745
	d.tok = d.d.decRd.skipWhitespace()
746
}
747

748
func (d *jsonDecDriver) advance() {
749
	if d.tok == 0 {
750
		d.skipWhitespace()
751
	}
752
}
753

754
func (d *jsonDecDriver) nextValueBytes(v []byte) []byte {
755
	v, cursor := d.nextValueBytesR(v)
756
	decNextValueBytesHelper{d: &d.d}.bytesRdV(&v, cursor)
757
	return v
758
}
759

760
func (d *jsonDecDriver) nextValueBytesR(v0 []byte) (v []byte, cursor uint) {
761
	v = v0
762
	var h = decNextValueBytesHelper{d: &d.d}
763
	dr := &d.d.decRd
764

765
	consumeString := func() {
766
	TOP:
767
		bs := dr.jsonReadAsisChars()
768
		h.appendN(&v, bs...)
769
		if bs[len(bs)-1] != '"' {
770
			// last char is '\', so consume next one and try again
771
			h.append1(&v, dr.readn1())
772
			goto TOP
773
		}
774
	}
775

776
	d.advance()           // ignore leading whitespace
777
	cursor = d.d.rb.c - 1 // cursor starts just before non-whitespace token
778

779
	switch d.tok {
780
	default:
781
		h.appendN(&v, dr.jsonReadNum()...)
782
	case 'n':
783
		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
784
		h.appendS(&v, jsonLits[jsonLitN:jsonLitN+4])
785
	case 'f':
786
		d.checkLit4([4]byte{'a', 'l', 's', 'e'}, d.d.decRd.readn4())
787
		h.appendS(&v, jsonLits[jsonLitF:jsonLitF+5])
788
	case 't':
789
		d.checkLit3([3]byte{'r', 'u', 'e'}, d.d.decRd.readn3())
790
		h.appendS(&v, jsonLits[jsonLitT:jsonLitT+4])
791
	case '"':
792
		h.append1(&v, '"')
793
		consumeString()
794
	case '{', '[':
795
		var elem struct{}
796
		var stack []struct{}
797

798
		stack = append(stack, elem)
799

800
		h.append1(&v, d.tok)
801

802
		for len(stack) != 0 {
803
			c := dr.readn1()
804
			h.append1(&v, c)
805
			switch c {
806
			case '"':
807
				consumeString()
808
			case '{', '[':
809
				stack = append(stack, elem)
810
			case '}', ']':
811
				stack = stack[:len(stack)-1]
812
			}
813
		}
814
	}
815
	d.tok = 0
816
	return
817
}
818

819
func (d *jsonDecDriver) TryNil() bool {
820
	d.advance()
821
	// we shouldn't try to see if quoted "null" was here, right?
822
	// only the plain string: `null` denotes a nil (ie not quotes)
823
	if d.tok == 'n' {
824
		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
825
		return true
826
	}
827
	return false
828
}
829

830
func (d *jsonDecDriver) DecodeBool() (v bool) {
831
	d.advance()
832
	// bool can be in quotes if and only if it's a map key
833
	fquot := d.d.c == containerMapKey && d.tok == '"'
834
	if fquot {
835
		d.tok = d.d.decRd.readn1()
836
	}
837
	switch d.tok {
838
	case 'f':
839
		d.checkLit4([4]byte{'a', 'l', 's', 'e'}, d.d.decRd.readn4())
840
		// v = false
841
	case 't':
842
		d.checkLit3([3]byte{'r', 'u', 'e'}, d.d.decRd.readn3())
843
		v = true
844
	case 'n':
845
		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
846
		// v = false
847
	default:
848
		d.d.errorf("decode bool: got first char %c", d.tok)
849
		// v = false // "unreachable"
850
	}
851
	if fquot {
852
		d.d.decRd.readn1()
853
	}
854
	return
855
}
856

857
func (d *jsonDecDriver) DecodeTime() (t time.Time) {
858
	// read string, and pass the string into json.unmarshal
859
	d.advance()
860
	if d.tok == 'n' {
861
		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
862
		return
863
	}
864
	d.ensureReadingString()
865
	bs := d.readUnescapedString()
866
	t, err := time.Parse(time.RFC3339, stringView(bs))
867
	d.d.onerror(err)
868
	return
869
}
870

871
func (d *jsonDecDriver) ContainerType() (vt valueType) {
872
	// check container type by checking the first char
873
	d.advance()
874

875
	// optimize this, so we don't do 4 checks but do one computation.
876
	// return jsonContainerSet[d.tok]
877

878
	// ContainerType is mostly called for Map and Array,
879
	// so this conditional is good enough (max 2 checks typically)
880
	if d.tok == '{' {
881
		return valueTypeMap
882
	} else if d.tok == '[' {
883
		return valueTypeArray
884
	} else if d.tok == 'n' {
885
		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
886
		return valueTypeNil
887
	} else if d.tok == '"' {
888
		return valueTypeString
889
	}
890
	return valueTypeUnset
891
}
892

893
func (d *jsonDecDriver) decNumBytes() (bs []byte) {
894
	d.advance()
895
	dr := &d.d.decRd
896
	if d.tok == '"' {
897
		bs = dr.readUntil('"')
898
	} else if d.tok == 'n' {
899
		d.checkLit3([3]byte{'u', 'l', 'l'}, dr.readn3())
900
	} else {
901
		if jsonManualInlineDecRdInHotZones {
902
			if dr.bytes {
903
				bs = dr.rb.jsonReadNum()
904
			} else {
905
				bs = dr.ri.jsonReadNum()
906
			}
907
		} else {
908
			bs = dr.jsonReadNum()
909
		}
910
	}
911
	d.tok = 0
912
	return
913
}
914

915
func (d *jsonDecDriver) DecodeUint64() (u uint64) {
916
	b := d.decNumBytes()
917
	u, neg, ok := parseInteger_bytes(b)
918
	if neg {
919
		d.d.errorf("negative number cannot be decoded as uint64")
920
	}
921
	if !ok {
922
		d.d.onerror(strconvParseErr(b, "ParseUint"))
923
	}
924
	return
925
}
926

927
func (d *jsonDecDriver) DecodeInt64() (v int64) {
928
	b := d.decNumBytes()
929
	u, neg, ok := parseInteger_bytes(b)
930
	if !ok {
931
		d.d.onerror(strconvParseErr(b, "ParseInt"))
932
	}
933
	if chkOvf.Uint2Int(u, neg) {
934
		d.d.errorf("overflow decoding number from %s", b)
935
	}
936
	if neg {
937
		v = -int64(u)
938
	} else {
939
		v = int64(u)
940
	}
941
	return
942
}
943

944
func (d *jsonDecDriver) DecodeFloat64() (f float64) {
945
	var err error
946
	bs := d.decNumBytes()
947
	if len(bs) == 0 {
948
		return
949
	}
950
	f, err = parseFloat64(bs)
951
	d.d.onerror(err)
952
	return
953
}
954

955
func (d *jsonDecDriver) DecodeFloat32() (f float32) {
956
	var err error
957
	bs := d.decNumBytes()
958
	if len(bs) == 0 {
959
		return
960
	}
961
	f, err = parseFloat32(bs)
962
	d.d.onerror(err)
963
	return
964
}
965

966
func (d *jsonDecDriver) DecodeExt(rv interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
967
	d.advance()
968
	if d.tok == 'n' {
969
		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
970
		return
971
	}
972
	if ext == nil {
973
		re := rv.(*RawExt)
974
		re.Tag = xtag
975
		d.d.decode(&re.Value)
976
	} else if ext == SelfExt {
977
		d.d.decodeValue(baseRV(rv), d.h.fnNoExt(basetype))
978
	} else {
979
		d.d.interfaceExtConvertAndDecode(rv, ext)
980
	}
981
}
982

983
func (d *jsonDecDriver) decBytesFromArray(bs []byte) []byte {
984
	if bs != nil {
985
		bs = bs[:0]
986
	}
987
	d.tok = 0
988
	bs = append(bs, uint8(d.DecodeUint64()))
989
	d.tok = d.d.decRd.skipWhitespace() // skip(&whitespaceCharBitset)
990
	for d.tok != ']' {
991
		if d.tok != ',' {
992
			d.d.errorf("read array element - expect char '%c' but got char '%c'", ',', d.tok)
993
		}
994
		d.tok = 0
995
		bs = append(bs, uint8(chkOvf.UintV(d.DecodeUint64(), 8)))
996
		d.tok = d.d.decRd.skipWhitespace() // skip(&whitespaceCharBitset)
997
	}
998
	d.tok = 0
999
	return bs
1000
}
1001

1002
func (d *jsonDecDriver) DecodeBytes(bs []byte) (bsOut []byte) {
1003
	d.d.decByteState = decByteStateNone
1004
	d.advance()
1005
	if d.tok == 'n' {
1006
		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
1007
		return nil
1008
	}
1009
	// if decoding into raw bytes, and the RawBytesExt is configured, use it to decode.
1010
	if d.rawext {
1011
		bsOut = bs
1012
		d.d.interfaceExtConvertAndDecode(&bsOut, d.h.RawBytesExt)
1013
		return
1014
	}
1015
	// check if an "array" of uint8's (see ContainerType for how to infer if an array)
1016
	if d.tok == '[' {
1017
		// bsOut, _ = fastpathTV.DecSliceUint8V(bs, true, d.d)
1018
		if bs == nil {
1019
			d.d.decByteState = decByteStateReuseBuf
1020
			bs = d.d.b[:]
1021
		}
1022
		return d.decBytesFromArray(bs)
1023
	}
1024

1025
	// base64 encodes []byte{} as "", and we encode nil []byte as null.
1026
	// Consequently, base64 should decode null as a nil []byte, and "" as an empty []byte{}.
1027

1028
	d.ensureReadingString()
1029
	bs1 := d.readUnescapedString()
1030
	slen := base64.StdEncoding.DecodedLen(len(bs1))
1031
	if slen == 0 {
1032
		bsOut = []byte{}
1033
	} else if slen <= cap(bs) {
1034
		bsOut = bs[:slen]
1035
	} else if bs == nil {
1036
		d.d.decByteState = decByteStateReuseBuf
1037
		bsOut = d.d.blist.check(*d.buf, slen)
1038
		bsOut = bsOut[:slen]
1039
		*d.buf = bsOut
1040
	} else {
1041
		bsOut = make([]byte, slen)
1042
	}
1043
	slen2, err := base64.StdEncoding.Decode(bsOut, bs1)
1044
	if err != nil {
1045
		d.d.errorf("error decoding base64 binary '%s': %v", bs1, err)
1046
	}
1047
	if slen != slen2 {
1048
		bsOut = bsOut[:slen2]
1049
	}
1050
	return
1051
}
1052

1053
func (d *jsonDecDriver) DecodeStringAsBytes() (s []byte) {
1054
	d.d.decByteState = decByteStateNone
1055
	d.advance()
1056

1057
	// common case - hoist outside the switch statement
1058
	if d.tok == '"' {
1059
		return d.dblQuoteStringAsBytes()
1060
	}
1061

1062
	// handle non-string scalar: null, true, false or a number
1063
	switch d.tok {
1064
	case 'n':
1065
		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
1066
		return nil // []byte{}
1067
	case 'f':
1068
		d.checkLit4([4]byte{'a', 'l', 's', 'e'}, d.d.decRd.readn4())
1069
		return jsonLitb[jsonLitF : jsonLitF+5]
1070
	case 't':
1071
		d.checkLit3([3]byte{'r', 'u', 'e'}, d.d.decRd.readn3())
1072
		return jsonLitb[jsonLitT : jsonLitT+4]
1073
	default:
1074
		// try to parse a valid number
1075
		d.tok = 0
1076
		return d.d.decRd.jsonReadNum()
1077
	}
1078
}
1079

1080
func (d *jsonDecDriver) ensureReadingString() {
1081
	if d.tok != '"' {
1082
		d.d.errorf("expecting string starting with '\"'; got '%c'", d.tok)
1083
	}
1084
}
1085

1086
func (d *jsonDecDriver) readUnescapedString() (bs []byte) {
1087
	// d.ensureReadingString()
1088
	bs = d.d.decRd.readUntil('"')
1089
	d.tok = 0
1090
	return
1091
}
1092

1093
func (d *jsonDecDriver) dblQuoteStringAsBytes() (buf []byte) {
1094
	checkUtf8 := d.h.ValidateUnicode
1095
	d.d.decByteState = decByteStateNone
1096
	// use a local buf variable, so we don't do pointer chasing within loop
1097
	buf = (*d.buf)[:0]
1098
	dr := &d.d.decRd
1099
	d.tok = 0
1100

1101
	var bs []byte
1102
	var c byte
1103
	var firstTime bool = true
1104

1105
	for {
1106
		if firstTime {
1107
			firstTime = false
1108
			if dr.bytes {
1109
				bs = dr.rb.jsonReadAsisChars()
1110
				if bs[len(bs)-1] == '"' {
1111
					d.d.decByteState = decByteStateZerocopy
1112
					return bs[:len(bs)-1]
1113
				}
1114
				goto APPEND
1115
			}
1116
		}
1117

1118
		if jsonManualInlineDecRdInHotZones {
1119
			if dr.bytes {
1120
				bs = dr.rb.jsonReadAsisChars()
1121
			} else {
1122
				bs = dr.ri.jsonReadAsisChars()
1123
			}
1124
		} else {
1125
			bs = dr.jsonReadAsisChars()
1126
		}
1127

1128
	APPEND:
1129
		_ = bs[0] // bounds check hint - slice must be > 0 elements
1130
		buf = append(buf, bs[:len(bs)-1]...)
1131
		c = bs[len(bs)-1]
1132

1133
		if c == '"' {
1134
			break
1135
		}
1136

1137
		// c is now '\'
1138
		c = dr.readn1()
1139

1140
		switch c {
1141
		case '"', '\\', '/', '\'':
1142
			buf = append(buf, c)
1143
		case 'b':
1144
			buf = append(buf, '\b')
1145
		case 'f':
1146
			buf = append(buf, '\f')
1147
		case 'n':
1148
			buf = append(buf, '\n')
1149
		case 'r':
1150
			buf = append(buf, '\r')
1151
		case 't':
1152
			buf = append(buf, '\t')
1153
		case 'u':
1154
			rr := d.appendStringAsBytesSlashU()
1155
			if checkUtf8 && rr == unicode.ReplacementChar {
1156
				d.d.errorf("invalid UTF-8 character found after: %s", buf)
1157
			}
1158
			buf = append(buf, d.bstr[:utf8.EncodeRune(d.bstr[:], rr)]...)
1159
		default:
1160
			*d.buf = buf
1161
			d.d.errorf("unsupported escaped value: %c", c)
1162
		}
1163
	}
1164
	*d.buf = buf
1165
	d.d.decByteState = decByteStateReuseBuf
1166
	return
1167
}
1168

1169
func (d *jsonDecDriver) appendStringAsBytesSlashU() (r rune) {
1170
	var rr uint32
1171
	var csu [2]byte
1172
	var cs [4]byte = d.d.decRd.readn4()
1173
	if rr = jsonSlashURune(cs); rr == unicode.ReplacementChar {
1174
		return unicode.ReplacementChar
1175
	}
1176
	r = rune(rr)
1177
	if utf16.IsSurrogate(r) {
1178
		csu = d.d.decRd.readn2()
1179
		cs = d.d.decRd.readn4()
1180
		if csu[0] == '\\' && csu[1] == 'u' {
1181
			if rr = jsonSlashURune(cs); rr == unicode.ReplacementChar {
1182
				return unicode.ReplacementChar
1183
			}
1184
			return utf16.DecodeRune(r, rune(rr))
1185
		}
1186
		return unicode.ReplacementChar
1187
	}
1188
	return
1189
}
1190

1191
func jsonSlashURune(cs [4]byte) (rr uint32) {
1192
	for _, c := range cs {
1193
		// best to use explicit if-else
1194
		// - not a table, etc which involve memory loads, array lookup with bounds checks, etc
1195
		if c >= '0' && c <= '9' {
1196
			rr = rr*16 + uint32(c-jsonU4Chk2)
1197
		} else if c >= 'a' && c <= 'f' {
1198
			rr = rr*16 + uint32(c-jsonU4Chk1)
1199
		} else if c >= 'A' && c <= 'F' {
1200
			rr = rr*16 + uint32(c-jsonU4Chk0)
1201
		} else {
1202
			return unicode.ReplacementChar
1203
		}
1204
	}
1205
	return
1206
}
1207

1208
func (d *jsonDecDriver) nakedNum(z *fauxUnion, bs []byte) (err error) {
1209
	// Note: nakedNum is NEVER called with a zero-length []byte
1210
	if d.h.PreferFloat {
1211
		z.v = valueTypeFloat
1212
		z.f, err = parseFloat64(bs)
1213
	} else {
1214
		err = parseNumber(bs, z, d.h.SignedInteger)
1215
	}
1216
	return
1217
}
1218

1219
func (d *jsonDecDriver) DecodeNaked() {
1220
	z := d.d.naked()
1221

1222
	d.advance()
1223
	var bs []byte
1224
	switch d.tok {
1225
	case 'n':
1226
		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
1227
		z.v = valueTypeNil
1228
	case 'f':
1229
		d.checkLit4([4]byte{'a', 'l', 's', 'e'}, d.d.decRd.readn4())
1230
		z.v = valueTypeBool
1231
		z.b = false
1232
	case 't':
1233
		d.checkLit3([3]byte{'r', 'u', 'e'}, d.d.decRd.readn3())
1234
		z.v = valueTypeBool
1235
		z.b = true
1236
	case '{':
1237
		z.v = valueTypeMap // don't consume. kInterfaceNaked will call ReadMapStart
1238
	case '[':
1239
		z.v = valueTypeArray // don't consume. kInterfaceNaked will call ReadArrayStart
1240
	case '"':
1241
		// if a string, and MapKeyAsString, then try to decode it as a bool or number first
1242
		bs = d.dblQuoteStringAsBytes()
1243
		if jsonNakedBoolNullInQuotedStr &&
1244
			d.h.MapKeyAsString && len(bs) > 0 && d.d.c == containerMapKey {
1245
			switch string(bs) {
1246
			// case "null": // nil is never quoted
1247
			// 	z.v = valueTypeNil
1248
			case "true":
1249
				z.v = valueTypeBool
1250
				z.b = true
1251
			case "false":
1252
				z.v = valueTypeBool
1253
				z.b = false
1254
			default:
1255
				// check if a number: float, int or uint
1256
				if err := d.nakedNum(z, bs); err != nil {
1257
					z.v = valueTypeString
1258
					z.s = d.d.stringZC(bs)
1259
				}
1260
			}
1261
		} else {
1262
			z.v = valueTypeString
1263
			z.s = d.d.stringZC(bs)
1264
		}
1265
	default: // number
1266
		bs = d.d.decRd.jsonReadNum()
1267
		d.tok = 0
1268
		if len(bs) == 0 {
1269
			d.d.errorf("decode number from empty string")
1270
		}
1271
		if err := d.nakedNum(z, bs); err != nil {
1272
			d.d.errorf("decode number from %s: %v", bs, err)
1273
		}
1274
	}
1275
}
1276

1277
//----------------------
1278

1279
// JsonHandle is a handle for JSON encoding format.
1280
//
1281
// Json is comprehensively supported:
1282
//   - decodes numbers into interface{} as int, uint or float64
1283
//     based on how the number looks and some config parameters e.g. PreferFloat, SignedInt, etc.
1284
//   - decode integers from float formatted numbers e.g. 1.27e+8
1285
//   - decode any json value (numbers, bool, etc) from quoted strings
1286
//   - configurable way to encode/decode []byte .
1287
//     by default, encodes and decodes []byte using base64 Std Encoding
1288
//   - UTF-8 support for encoding and decoding
1289
//
1290
// It has better performance than the json library in the standard library,
1291
// by leveraging the performance improvements of the codec library.
1292
//
1293
// In addition, it doesn't read more bytes than necessary during a decode, which allows
1294
// reading multiple values from a stream containing json and non-json content.
1295
// For example, a user can read a json value, then a cbor value, then a msgpack value,
1296
// all from the same stream in sequence.
1297
//
1298
// Note that, when decoding quoted strings, invalid UTF-8 or invalid UTF-16 surrogate pairs are
1299
// not treated as an error. Instead, they are replaced by the Unicode replacement character U+FFFD.
1300
//
1301
// Note also that the float values for NaN, +Inf or -Inf are encoded as null,
1302
// as suggested by NOTE 4 of the ECMA-262 ECMAScript Language Specification 5.1 edition.
1303
// see http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf .
1304
//
1305
// Note the following behaviour differences vs std-library encoding/json package:
1306
//   - struct field names matched in case-sensitive manner
1307
type JsonHandle struct {
1308
	textEncodingType
1309
	BasicHandle
1310

1311
	// Indent indicates how a value is encoded.
1312
	//   - If positive, indent by that number of spaces.
1313
	//   - If negative, indent by that number of tabs.
1314
	Indent int8
1315

1316
	// IntegerAsString controls how integers (signed and unsigned) are encoded.
1317
	//
1318
	// Per the JSON Spec, JSON numbers are 64-bit floating point numbers.
1319
	// Consequently, integers > 2^53 cannot be represented as a JSON number without losing precision.
1320
	// This can be mitigated by configuring how to encode integers.
1321
	//
1322
	// IntegerAsString interpretes the following values:
1323
	//   - if 'L', then encode integers > 2^53 as a json string.
1324
	//   - if 'A', then encode all integers as a json string
1325
	//             containing the exact integer representation as a decimal.
1326
	//   - else    encode all integers as a json number (default)
1327
	IntegerAsString byte
1328

1329
	// HTMLCharsAsIs controls how to encode some special characters to html: < > &
1330
	//
1331
	// By default, we encode them as \uXXX
1332
	// to prevent security holes when served from some browsers.
1333
	HTMLCharsAsIs bool
1334

1335
	// PreferFloat says that we will default to decoding a number as a float.
1336
	// If not set, we will examine the characters of the number and decode as an
1337
	// integer type if it doesn't have any of the characters [.eE].
1338
	PreferFloat bool
1339

1340
	// TermWhitespace says that we add a whitespace character
1341
	// at the end of an encoding.
1342
	//
1343
	// The whitespace is important, especially if using numbers in a context
1344
	// where multiple items are written to a stream.
1345
	TermWhitespace bool
1346

1347
	// MapKeyAsString says to encode all map keys as strings.
1348
	//
1349
	// Use this to enforce strict json output.
1350
	// The only caveat is that nil value is ALWAYS written as null (never as "null")
1351
	MapKeyAsString bool
1352

1353
	// _ uint64 // padding (cache line)
1354

1355
	// Note: below, we store hardly-used items e.g. RawBytesExt.
1356
	// These values below may straddle a cache line, but they are hardly-used,
1357
	// so shouldn't contribute to false-sharing except in rare cases.
1358

1359
	// RawBytesExt, if configured, is used to encode and decode raw bytes in a custom way.
1360
	// If not configured, raw bytes are encoded to/from base64 text.
1361
	RawBytesExt InterfaceExt
1362
}
1363

1364
func (h *JsonHandle) isJson() bool { return true }
1365

1366
// Name returns the name of the handle: json
1367
func (h *JsonHandle) Name() string { return "json" }
1368

1369
func (h *JsonHandle) desc(bd byte) string { return string(bd) }
1370

1371
func (h *JsonHandle) typical() bool {
1372
	return h.Indent == 0 && !h.MapKeyAsString && h.IntegerAsString != 'A' && h.IntegerAsString != 'L'
1373
}
1374

1375
func (h *JsonHandle) newEncDriver() encDriver {
1376
	var e = &jsonEncDriver{h: h}
1377
	// var x []byte
1378
	// e.buf = &x
1379
	e.e.e = e
1380
	e.e.js = true
1381
	e.e.init(h)
1382
	e.reset()
1383
	return e
1384
}
1385

1386
func (h *JsonHandle) newDecDriver() decDriver {
1387
	var d = &jsonDecDriver{h: h}
1388
	var x []byte
1389
	d.buf = &x
1390
	d.d.d = d
1391
	d.d.js = true
1392
	d.d.jsms = h.MapKeyAsString
1393
	d.d.init(h)
1394
	d.reset()
1395
	return d
1396
}
1397

1398
func (e *jsonEncDriver) resetState() {
1399
	e.dl = 0
1400
}
1401

1402
func (e *jsonEncDriver) reset() {
1403
	e.resetState()
1404
	// (htmlasis && jsonCharSafeSet.isset(b)) || jsonCharHtmlSafeSet.isset(b)
1405
	// cache values from the handle
1406
	e.typical = e.h.typical()
1407
	if e.h.HTMLCharsAsIs {
1408
		e.s = &jsonCharSafeSet
1409
	} else {
1410
		e.s = &jsonCharHtmlSafeSet
1411
	}
1412
	e.rawext = e.h.RawBytesExt != nil
1413
	e.di = int8(e.h.Indent)
1414
	e.d = e.h.Indent != 0
1415
	e.ks = e.h.MapKeyAsString
1416
	e.is = e.h.IntegerAsString
1417
}
1418

1419
func (d *jsonDecDriver) resetState() {
1420
	*d.buf = d.d.blist.check(*d.buf, 256)
1421
	d.tok = 0
1422
}
1423

1424
func (d *jsonDecDriver) reset() {
1425
	d.resetState()
1426
	d.rawext = d.h.RawBytesExt != nil
1427
}
1428

1429
func jsonFloatStrconvFmtPrec64(f float64) (fmt byte, prec int8) {
1430
	fmt = 'f'
1431
	prec = -1
1432
	fbits := math.Float64bits(f)
1433
	abs := math.Float64frombits(fbits &^ (1 << 63))
1434
	if abs == 0 || abs == 1 {
1435
		prec = 1
1436
	} else if abs < 1e-6 || abs >= 1e21 {
1437
		fmt = 'e'
1438
	} else if noFrac64(fbits) {
1439
		prec = 1
1440
	}
1441
	return
1442
}
1443

1444
func jsonFloatStrconvFmtPrec32(f float32) (fmt byte, prec int8) {
1445
	fmt = 'f'
1446
	prec = -1
1447
	// directly handle Modf (to get fractions) and Abs (to get absolute)
1448
	fbits := math.Float32bits(f)
1449
	abs := math.Float32frombits(fbits &^ (1 << 31))
1450
	if abs == 0 || abs == 1 {
1451
		prec = 1
1452
	} else if abs < 1e-6 || abs >= 1e21 {
1453
		fmt = 'e'
1454
	} else if noFrac32(fbits) {
1455
		prec = 1
1456
	}
1457
	return
1458
}
1459

1460
var _ decDriverContainerTracker = (*jsonDecDriver)(nil)
1461
var _ encDriverContainerTracker = (*jsonEncDriver)(nil)
1462
var _ decDriver = (*jsonDecDriver)(nil)
1463
var _ encDriver = (*jsonEncDriver)(nil)
1464