podman

1
/*
2
 * Copyright 2021 ByteDance Inc.
3
 *
4
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 * you may not use this file except in compliance with the License.
6
 * You may obtain a copy of the License at
7
 *
8
 *     http://www.apache.org/licenses/LICENSE-2.0
9
 *
10
 * Unless required by applicable law or agreed to in writing, software
11
 * distributed under the License is distributed on an "AS IS" BASIS,
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 * See the License for the specific language governing permissions and
14
 * limitations under the License.
15
 */
16

17
package decoder
18

19
import (
20
    `encoding/json`
21
    `fmt`
22
    `reflect`
23
    `sort`
24
    `strconv`
25
    `strings`
26
    `unsafe`
27

28
    `github.com/bytedance/sonic/internal/caching`
29
    `github.com/bytedance/sonic/internal/resolver`
30
    `github.com/bytedance/sonic/internal/rt`
31
    `github.com/bytedance/sonic/option`
32
)
33

34
type _Op uint8
35

36
const (
37
    _OP_any _Op = iota + 1
38
    _OP_dyn
39
    _OP_str
40
    _OP_bin
41
    _OP_bool
42
    _OP_num
43
    _OP_i8
44
    _OP_i16
45
    _OP_i32
46
    _OP_i64
47
    _OP_u8
48
    _OP_u16
49
    _OP_u32
50
    _OP_u64
51
    _OP_f32
52
    _OP_f64
53
    _OP_unquote
54
    _OP_nil_1
55
    _OP_nil_2
56
    _OP_nil_3
57
    _OP_deref
58
    _OP_index
59
    _OP_is_null
60
    _OP_is_null_quote
61
    _OP_map_init
62
    _OP_map_key_i8
63
    _OP_map_key_i16
64
    _OP_map_key_i32
65
    _OP_map_key_i64
66
    _OP_map_key_u8
67
    _OP_map_key_u16
68
    _OP_map_key_u32
69
    _OP_map_key_u64
70
    _OP_map_key_f32
71
    _OP_map_key_f64
72
    _OP_map_key_str
73
    _OP_map_key_utext
74
    _OP_map_key_utext_p
75
    _OP_array_skip
76
    _OP_array_clear
77
    _OP_array_clear_p
78
    _OP_slice_init
79
    _OP_slice_append
80
    _OP_object_skip
81
    _OP_object_next
82
    _OP_struct_field
83
    _OP_unmarshal
84
    _OP_unmarshal_p
85
    _OP_unmarshal_text
86
    _OP_unmarshal_text_p
87
    _OP_lspace
88
    _OP_match_char
89
    _OP_check_char
90
    _OP_load
91
    _OP_save
92
    _OP_drop
93
    _OP_drop_2
94
    _OP_recurse
95
    _OP_goto
96
    _OP_switch
97
    _OP_check_char_0
98
    _OP_dismatch_err
99
    _OP_go_skip
100
    _OP_add
101
    _OP_check_empty
102
    _OP_debug
103
)
104

105
const (
106
    _INT_SIZE = 32 << (^uint(0) >> 63)
107
    _PTR_SIZE = 32 << (^uintptr(0) >> 63)
108
    _PTR_BYTE = unsafe.Sizeof(uintptr(0))
109
)
110

111
const (
112
    _MAX_ILBUF = 100000     // cutoff at 100k of IL instructions
113
    _MAX_FIELDS = 50        // cutoff at 50 fields struct
114
)
115

116
var _OpNames = [256]string {
117
    _OP_any              : "any",
118
    _OP_dyn              : "dyn",
119
    _OP_str              : "str",
120
    _OP_bin              : "bin",
121
    _OP_bool             : "bool",
122
    _OP_num              : "num",
123
    _OP_i8               : "i8",
124
    _OP_i16              : "i16",
125
    _OP_i32              : "i32",
126
    _OP_i64              : "i64",
127
    _OP_u8               : "u8",
128
    _OP_u16              : "u16",
129
    _OP_u32              : "u32",
130
    _OP_u64              : "u64",
131
    _OP_f32              : "f32",
132
    _OP_f64              : "f64",
133
    _OP_unquote          : "unquote",
134
    _OP_nil_1            : "nil_1",
135
    _OP_nil_2            : "nil_2",
136
    _OP_nil_3            : "nil_3",
137
    _OP_deref            : "deref",
138
    _OP_index            : "index",
139
    _OP_is_null          : "is_null",
140
    _OP_is_null_quote    : "is_null_quote",
141
    _OP_map_init         : "map_init",
142
    _OP_map_key_i8       : "map_key_i8",
143
    _OP_map_key_i16      : "map_key_i16",
144
    _OP_map_key_i32      : "map_key_i32",
145
    _OP_map_key_i64      : "map_key_i64",
146
    _OP_map_key_u8       : "map_key_u8",
147
    _OP_map_key_u16      : "map_key_u16",
148
    _OP_map_key_u32      : "map_key_u32",
149
    _OP_map_key_u64      : "map_key_u64",
150
    _OP_map_key_f32      : "map_key_f32",
151
    _OP_map_key_f64      : "map_key_f64",
152
    _OP_map_key_str      : "map_key_str",
153
    _OP_map_key_utext    : "map_key_utext",
154
    _OP_map_key_utext_p  : "map_key_utext_p",
155
    _OP_array_skip       : "array_skip",
156
    _OP_slice_init       : "slice_init",
157
    _OP_slice_append     : "slice_append",
158
    _OP_object_skip      : "object_skip",
159
    _OP_object_next      : "object_next",
160
    _OP_struct_field     : "struct_field",
161
    _OP_unmarshal        : "unmarshal",
162
    _OP_unmarshal_p      : "unmarshal_p",
163
    _OP_unmarshal_text   : "unmarshal_text",
164
    _OP_unmarshal_text_p : "unmarshal_text_p",
165
    _OP_lspace           : "lspace",
166
    _OP_match_char       : "match_char",
167
    _OP_check_char       : "check_char",
168
    _OP_load             : "load",
169
    _OP_save             : "save",
170
    _OP_drop             : "drop",
171
    _OP_drop_2           : "drop_2",
172
    _OP_recurse          : "recurse",
173
    _OP_goto             : "goto",
174
    _OP_switch           : "switch",
175
    _OP_check_char_0     : "check_char_0",
176
    _OP_dismatch_err     : "dismatch_err",
177
    _OP_add              : "add",
178
    _OP_go_skip          : "go_skip",
179
    _OP_check_empty      : "check_empty",
180
    _OP_debug            : "debug",
181
}
182

183
func (self _Op) String() string {
184
    if ret := _OpNames[self]; ret != "" {
185
        return ret
186
    } else {
187
        return "<invalid>"
188
    }
189
}
190

191
func _OP_int() _Op {
192
    switch _INT_SIZE {
193
        case 32: return _OP_i32
194
        case 64: return _OP_i64
195
        default: panic("unsupported int size")
196
    }
197
}
198

199
func _OP_uint() _Op {
200
    switch _INT_SIZE {
201
        case 32: return _OP_u32
202
        case 64: return _OP_u64
203
        default: panic("unsupported uint size")
204
    }
205
}
206

207
func _OP_uintptr() _Op {
208
    switch _PTR_SIZE {
209
        case 32: return _OP_u32
210
        case 64: return _OP_u64
211
        default: panic("unsupported pointer size")
212
    }
213
}
214

215
func _OP_map_key_int() _Op {
216
    switch _INT_SIZE {
217
        case 32: return _OP_map_key_i32
218
        case 64: return _OP_map_key_i64
219
        default: panic("unsupported int size")
220
    }
221
}
222

223
func _OP_map_key_uint() _Op {
224
    switch _INT_SIZE {
225
        case 32: return _OP_map_key_u32
226
        case 64: return _OP_map_key_u64
227
        default: panic("unsupported uint size")
228
    }
229
}
230

231
func _OP_map_key_uintptr() _Op {
232
    switch _PTR_SIZE {
233
        case 32: return _OP_map_key_u32
234
        case 64: return _OP_map_key_u64
235
        default: panic("unsupported pointer size")
236
    }
237
}
238

239
type _Instr struct {
240
    u uint64            // union {op: 8, vb: 8, vi: 48}, iv maybe int or len([]int)
241
    p unsafe.Pointer    // maybe GoSlice.Data, *GoType or *caching.FieldMap
242
}
243

244
func packOp(op _Op) uint64 {
245
    return uint64(op) << 56
246
}
247

248
func newInsOp(op _Op) _Instr {
249
    return _Instr{u: packOp(op)}
250
}
251

252
func newInsVi(op _Op, vi int) _Instr {
253
    return _Instr{u: packOp(op) | rt.PackInt(vi)}
254
}
255

256
func newInsVb(op _Op, vb byte) _Instr {
257
    return _Instr{u: packOp(op) | (uint64(vb) << 48)}
258
}
259

260
func newInsVs(op _Op, vs []int) _Instr {
261
    return _Instr {
262
        u: packOp(op) | rt.PackInt(len(vs)),
263
        p: (*rt.GoSlice)(unsafe.Pointer(&vs)).Ptr,
264
    }
265
}
266

267
func newInsVt(op _Op, vt reflect.Type) _Instr {
268
    return _Instr {
269
        u: packOp(op),
270
        p: unsafe.Pointer(rt.UnpackType(vt)),
271
    }
272
}
273

274
func newInsVf(op _Op, vf *caching.FieldMap) _Instr {
275
    return _Instr {
276
        u: packOp(op),
277
        p: unsafe.Pointer(vf),
278
    }
279
}
280

281
func (self _Instr) op() _Op {
282
    return _Op(self.u >> 56)
283
}
284

285
func (self _Instr) vi() int {
286
    return rt.UnpackInt(self.u)
287
}
288

289
func (self _Instr) vb() byte {
290
    return byte(self.u >> 48)
291
}
292

293
func (self _Instr) vs() (v []int) {
294
    (*rt.GoSlice)(unsafe.Pointer(&v)).Ptr = self.p
295
    (*rt.GoSlice)(unsafe.Pointer(&v)).Cap = self.vi()
296
    (*rt.GoSlice)(unsafe.Pointer(&v)).Len = self.vi()
297
    return
298
}
299

300
func (self _Instr) vf() *caching.FieldMap {
301
    return (*caching.FieldMap)(self.p)
302
}
303

304
func (self _Instr) vk() reflect.Kind {
305
    return (*rt.GoType)(self.p).Kind()
306
}
307

308
func (self _Instr) vt() reflect.Type {
309
    return (*rt.GoType)(self.p).Pack()
310
}
311

312
func (self _Instr) i64() int64 {
313
    return int64(self.vi())
314
}
315

316
func (self _Instr) vlen() int {
317
    return int((*rt.GoType)(self.p).Size)
318
}
319

320
func (self _Instr) isBranch() bool {
321
    switch self.op() {
322
        case _OP_goto          : fallthrough
323
        case _OP_switch        : fallthrough
324
        case _OP_is_null       : fallthrough
325
        case _OP_is_null_quote : fallthrough
326
        case _OP_check_char    : return true
327
        default                : return false
328
    }
329
}
330

331
func (self _Instr) disassemble() string {
332
    switch self.op() {
333
        case _OP_dyn              : fallthrough
334
        case _OP_deref            : fallthrough
335
        case _OP_map_key_i8       : fallthrough
336
        case _OP_map_key_i16      : fallthrough
337
        case _OP_map_key_i32      : fallthrough
338
        case _OP_map_key_i64      : fallthrough
339
        case _OP_map_key_u8       : fallthrough
340
        case _OP_map_key_u16      : fallthrough
341
        case _OP_map_key_u32      : fallthrough
342
        case _OP_map_key_u64      : fallthrough
343
        case _OP_map_key_f32      : fallthrough
344
        case _OP_map_key_f64      : fallthrough
345
        case _OP_map_key_str      : fallthrough
346
        case _OP_map_key_utext    : fallthrough
347
        case _OP_map_key_utext_p  : fallthrough
348
        case _OP_slice_init       : fallthrough
349
        case _OP_slice_append     : fallthrough
350
        case _OP_unmarshal        : fallthrough
351
        case _OP_unmarshal_p      : fallthrough
352
        case _OP_unmarshal_text   : fallthrough
353
        case _OP_unmarshal_text_p : fallthrough
354
        case _OP_recurse          : return fmt.Sprintf("%-18s%s", self.op(), self.vt())
355
        case _OP_goto             : fallthrough
356
        case _OP_is_null_quote    : fallthrough
357
        case _OP_is_null          : return fmt.Sprintf("%-18sL_%d", self.op(), self.vi())
358
        case _OP_index            : fallthrough
359
        case _OP_array_clear      : fallthrough
360
        case _OP_array_clear_p    : return fmt.Sprintf("%-18s%d", self.op(), self.vi())
361
        case _OP_switch           : return fmt.Sprintf("%-18s%s", self.op(), self.formatSwitchLabels())
362
        case _OP_struct_field     : return fmt.Sprintf("%-18s%s", self.op(), self.formatStructFields())
363
        case _OP_match_char       : return fmt.Sprintf("%-18s%s", self.op(), strconv.QuoteRune(rune(self.vb())))
364
        case _OP_check_char       : return fmt.Sprintf("%-18sL_%d, %s", self.op(), self.vi(), strconv.QuoteRune(rune(self.vb())))
365
        default                   : return self.op().String()
366
    }
367
}
368

369
func (self _Instr) formatSwitchLabels() string {
370
    var i int
371
    var v int
372
    var m []string
373

374
    /* format each label */
375
    for i, v = range self.vs() {
376
        m = append(m, fmt.Sprintf("%d=L_%d", i, v))
377
    }
378

379
    /* join them with "," */
380
    return strings.Join(m, ", ")
381
}
382

383
func (self _Instr) formatStructFields() string {
384
    var i uint64
385
    var r []string
386
    var m []struct{i int; n string}
387

388
    /* extract all the fields */
389
    for i = 0; i < self.vf().N; i++ {
390
        if v := self.vf().At(i); v.Hash != 0 {
391
            m = append(m, struct{i int; n string}{i: v.ID, n: v.Name})
392
        }
393
    }
394

395
    /* sort by field name */
396
    sort.Slice(m, func(i, j int) bool {
397
        return m[i].n < m[j].n
398
    })
399

400
    /* format each field */
401
    for _, v := range m {
402
        r = append(r, fmt.Sprintf("%s=%d", v.n, v.i))
403
    }
404

405
    /* join them with "," */
406
    return strings.Join(r, ", ")
407
}
408

409
type (
410
    _Program []_Instr
411
)
412

413
func (self _Program) pc() int {
414
    return len(self)
415
}
416

417
func (self _Program) tag(n int) {
418
    if n >= _MaxStack {
419
        panic("type nesting too deep")
420
    }
421
}
422

423
func (self _Program) pin(i int) {
424
    v := &self[i]
425
    v.u &= 0xffff000000000000
426
    v.u |= rt.PackInt(self.pc())
427
}
428

429
func (self _Program) rel(v []int) {
430
    for _, i := range v {
431
        self.pin(i)
432
    }
433
}
434

435
func (self *_Program) add(op _Op) {
436
    *self = append(*self, newInsOp(op))
437
}
438

439
func (self *_Program) int(op _Op, vi int) {
440
    *self = append(*self, newInsVi(op, vi))
441
}
442

443
func (self *_Program) chr(op _Op, vb byte) {
444
    *self = append(*self, newInsVb(op, vb))
445
}
446

447
func (self *_Program) tab(op _Op, vs []int) {
448
    *self = append(*self, newInsVs(op, vs))
449
}
450

451
func (self *_Program) rtt(op _Op, vt reflect.Type) {
452
    *self = append(*self, newInsVt(op, vt))
453
}
454

455
func (self *_Program) fmv(op _Op, vf *caching.FieldMap) {
456
    *self = append(*self, newInsVf(op, vf))
457
}
458

459
func (self _Program) disassemble() string {
460
    nb  := len(self)
461
    tab := make([]bool, nb + 1)
462
    ret := make([]string, 0, nb + 1)
463

464
    /* prescan to get all the labels */
465
    for _, ins := range self {
466
        if ins.isBranch() {
467
            if ins.op() != _OP_switch {
468
                tab[ins.vi()] = true
469
            } else {
470
                for _, v := range ins.vs() {
471
                    tab[v] = true
472
                }
473
            }
474
        }
475
    }
476

477
    /* disassemble each instruction */
478
    for i, ins := range self {
479
        if !tab[i] {
480
            ret = append(ret, "\t" + ins.disassemble())
481
        } else {
482
            ret = append(ret, fmt.Sprintf("L_%d:\n\t%s", i, ins.disassemble()))
483
        }
484
    }
485

486
    /* add the last label, if needed */
487
    if tab[nb] {
488
        ret = append(ret, fmt.Sprintf("L_%d:", nb))
489
    }
490

491
    /* add an "end" indicator, and join all the strings */
492
    return strings.Join(append(ret, "\tend"), "\n")
493
}
494

495
type _Compiler struct {
496
    opts option.CompileOptions
497
    tab  map[reflect.Type]bool
498
    rec  map[reflect.Type]bool
499
}
500

501
func newCompiler() *_Compiler {
502
    return &_Compiler {
503
        opts: option.DefaultCompileOptions(),
504
        tab: map[reflect.Type]bool{},
505
        rec: map[reflect.Type]bool{},
506
    }
507
}
508

509
func (self *_Compiler) apply(opts option.CompileOptions) *_Compiler {
510
    self.opts = opts
511
    return self
512
}
513

514
func (self *_Compiler) rescue(ep *error) {
515
    if val := recover(); val != nil {
516
        if err, ok := val.(error); ok {
517
            *ep = err
518
        } else {
519
            panic(val)
520
        }
521
    }
522
}
523

524
func (self *_Compiler) compile(vt reflect.Type) (ret _Program, err error) {
525
    defer self.rescue(&err)
526
    self.compileOne(&ret, 0, vt)
527
    return
528
}
529

530
func (self *_Compiler) checkMarshaler(p *_Program, vt reflect.Type) bool {
531
    pt := reflect.PtrTo(vt)
532

533
    /* check for `json.Unmarshaler` with pointer receiver */
534
    if pt.Implements(jsonUnmarshalerType) {
535
        p.rtt(_OP_unmarshal_p, pt)
536
        return true
537
    }
538

539
    /* check for `json.Unmarshaler` */
540
    if vt.Implements(jsonUnmarshalerType) {
541
        p.add(_OP_lspace)
542
        self.compileUnmarshalJson(p, vt)
543
        return true
544
    }
545

546
    /* check for `encoding.TextMarshaler` with pointer receiver */
547
    if pt.Implements(encodingTextUnmarshalerType) {
548
        p.add(_OP_lspace)
549
        self.compileUnmarshalTextPtr(p, pt)
550
        return true
551
    }
552

553
    /* check for `encoding.TextUnmarshaler` */
554
    if vt.Implements(encodingTextUnmarshalerType) {
555
        p.add(_OP_lspace)
556
        self.compileUnmarshalText(p, vt)
557
        return true
558
    }
559
    return false
560
}
561

562
func (self *_Compiler) compileOne(p *_Program, sp int, vt reflect.Type) {
563
    /* check for recursive nesting */
564
    ok := self.tab[vt]
565
    if ok {
566
        p.rtt(_OP_recurse, vt)
567
        return
568
    }
569

570
    if self.checkMarshaler(p, vt) {
571
        return
572
    }
573

574
    /* enter the recursion */
575
    p.add(_OP_lspace)
576
    self.tab[vt] = true
577
    self.compileOps(p, sp, vt)
578
    delete(self.tab, vt)
579
}
580

581
func (self *_Compiler) compileOps(p *_Program, sp int, vt reflect.Type) {
582
    switch vt.Kind() {
583
        case reflect.Bool      : self.compilePrimitive (vt, p, _OP_bool)
584
        case reflect.Int       : self.compilePrimitive (vt, p, _OP_int())
585
        case reflect.Int8      : self.compilePrimitive (vt, p, _OP_i8)
586
        case reflect.Int16     : self.compilePrimitive (vt, p, _OP_i16)
587
        case reflect.Int32     : self.compilePrimitive (vt, p, _OP_i32)
588
        case reflect.Int64     : self.compilePrimitive (vt, p, _OP_i64)
589
        case reflect.Uint      : self.compilePrimitive (vt, p, _OP_uint())
590
        case reflect.Uint8     : self.compilePrimitive (vt, p, _OP_u8)
591
        case reflect.Uint16    : self.compilePrimitive (vt, p, _OP_u16)
592
        case reflect.Uint32    : self.compilePrimitive (vt, p, _OP_u32)
593
        case reflect.Uint64    : self.compilePrimitive (vt, p, _OP_u64)
594
        case reflect.Uintptr   : self.compilePrimitive (vt, p, _OP_uintptr())
595
        case reflect.Float32   : self.compilePrimitive (vt, p, _OP_f32)
596
        case reflect.Float64   : self.compilePrimitive (vt, p, _OP_f64)
597
        case reflect.String    : self.compileString    (p, vt)
598
        case reflect.Array     : self.compileArray     (p, sp, vt)
599
        case reflect.Interface : self.compileInterface (p, vt)
600
        case reflect.Map       : self.compileMap       (p, sp, vt)
601
        case reflect.Ptr       : self.compilePtr       (p, sp, vt)
602
        case reflect.Slice     : self.compileSlice     (p, sp, vt)
603
        case reflect.Struct    : self.compileStruct    (p, sp, vt)
604
        default                : panic                 (&json.UnmarshalTypeError{Type: vt})
605
    }
606
}
607

608
func (self *_Compiler) compileMap(p *_Program, sp int, vt reflect.Type) {
609
    if reflect.PtrTo(vt.Key()).Implements(encodingTextUnmarshalerType) {
610
        self.compileMapOp(p, sp, vt, _OP_map_key_utext_p)
611
    } else if vt.Key().Implements(encodingTextUnmarshalerType) {
612
        self.compileMapOp(p, sp, vt, _OP_map_key_utext)
613
    } else {
614
        self.compileMapUt(p, sp, vt)
615
    }
616
}
617

618
func (self *_Compiler) compileMapUt(p *_Program, sp int, vt reflect.Type) {
619
    switch vt.Key().Kind() {
620
        case reflect.Int     : self.compileMapOp(p, sp, vt, _OP_map_key_int())
621
        case reflect.Int8    : self.compileMapOp(p, sp, vt, _OP_map_key_i8)
622
        case reflect.Int16   : self.compileMapOp(p, sp, vt, _OP_map_key_i16)
623
        case reflect.Int32   : self.compileMapOp(p, sp, vt, _OP_map_key_i32)
624
        case reflect.Int64   : self.compileMapOp(p, sp, vt, _OP_map_key_i64)
625
        case reflect.Uint    : self.compileMapOp(p, sp, vt, _OP_map_key_uint())
626
        case reflect.Uint8   : self.compileMapOp(p, sp, vt, _OP_map_key_u8)
627
        case reflect.Uint16  : self.compileMapOp(p, sp, vt, _OP_map_key_u16)
628
        case reflect.Uint32  : self.compileMapOp(p, sp, vt, _OP_map_key_u32)
629
        case reflect.Uint64  : self.compileMapOp(p, sp, vt, _OP_map_key_u64)
630
        case reflect.Uintptr : self.compileMapOp(p, sp, vt, _OP_map_key_uintptr())
631
        case reflect.Float32 : self.compileMapOp(p, sp, vt, _OP_map_key_f32)
632
        case reflect.Float64 : self.compileMapOp(p, sp, vt, _OP_map_key_f64)
633
        case reflect.String  : self.compileMapOp(p, sp, vt, _OP_map_key_str)
634
        default              : panic(&json.UnmarshalTypeError{Type: vt})
635
    }
636
}
637

638
func (self *_Compiler) compileMapOp(p *_Program, sp int, vt reflect.Type, op _Op) {
639
    i := p.pc()
640
    p.add(_OP_is_null)
641
    p.tag(sp + 1)
642
    skip := self.checkIfSkip(p, vt, '{')
643
    p.add(_OP_save)
644
    p.add(_OP_map_init)
645
    p.add(_OP_save)
646
    p.add(_OP_lspace)
647
    j := p.pc()
648
    p.chr(_OP_check_char, '}')
649
    p.chr(_OP_match_char, '"')
650
    skip2 := p.pc()
651
    p.rtt(op, vt)
652

653
    /* match the value separator */
654
    p.add(_OP_lspace)
655
    p.chr(_OP_match_char, ':')
656
    self.compileOne(p, sp + 2, vt.Elem())
657
    p.pin(skip2)
658
    p.add(_OP_load)
659
    k0 := p.pc()
660
    p.add(_OP_lspace)
661
    k1 := p.pc()
662
    p.chr(_OP_check_char, '}')
663
    p.chr(_OP_match_char, ',')
664
    p.add(_OP_lspace)
665
    p.chr(_OP_match_char, '"')
666
    skip3 := p.pc()
667
    p.rtt(op, vt)
668

669
    /* match the value separator */
670
    p.add(_OP_lspace)
671
    p.chr(_OP_match_char, ':')
672
    self.compileOne(p, sp + 2, vt.Elem())
673
    p.pin(skip3)
674
    p.add(_OP_load)
675
    p.int(_OP_goto, k0)
676
    p.pin(j)
677
    p.pin(k1)
678
    p.add(_OP_drop_2)
679
    x := p.pc()
680
    p.add(_OP_goto)
681
    p.pin(i)
682
    p.add(_OP_nil_1)
683
    p.pin(skip)
684
    p.pin(x)
685
}
686

687
func (self *_Compiler) compilePtr(p *_Program, sp int, et reflect.Type) {
688
    i := p.pc()
689
    p.add(_OP_is_null)
690

691
    /* dereference all the way down */
692
    for et.Kind() == reflect.Ptr {
693
        if self.checkMarshaler(p, et) {
694
            return
695
        }
696
        et = et.Elem()
697
        p.rtt(_OP_deref, et)
698
    }
699

700
    /* check for recursive nesting */
701
    ok := self.tab[et]
702
    if ok {
703
        p.rtt(_OP_recurse, et)
704
    } else {
705
        /* enter the recursion */
706
        p.add(_OP_lspace)
707
        self.tab[et] = true
708

709
        /* not inline the pointer type
710
        * recursing the defined pointer type's elem will casue issue379.
711
        */
712
        self.compileOps(p, sp, et)
713
    }
714
    delete(self.tab, et)
715

716
    j := p.pc()
717
    p.add(_OP_goto)
718

719
    // set val pointer as nil
720
    p.pin(i)
721
    p.add(_OP_nil_1)
722

723
    // nothing todo
724
    p.pin(j)
725
}
726

727
func (self *_Compiler) compileArray(p *_Program, sp int, vt reflect.Type) {
728
    x := p.pc()
729
    p.add(_OP_is_null)
730
    p.tag(sp)
731
    skip := self.checkIfSkip(p, vt, '[')
732
    
733
    p.add(_OP_save)
734
    p.add(_OP_lspace)
735
    v := []int{p.pc()}
736
    p.chr(_OP_check_char, ']')
737

738
    /* decode every item */
739
    for i := 1; i <= vt.Len(); i++ {
740
        self.compileOne(p, sp + 1, vt.Elem())
741
        p.add(_OP_load)
742
        p.int(_OP_index, i * int(vt.Elem().Size()))
743
        p.add(_OP_lspace)
744
        v = append(v, p.pc())
745
        p.chr(_OP_check_char, ']')
746
        p.chr(_OP_match_char, ',')
747
    }
748

749
    /* drop rest of the array */
750
    p.add(_OP_array_skip)
751
    w := p.pc()
752
    p.add(_OP_goto)
753
    p.rel(v)
754

755
    /* check for pointer data */
756
    if rt.UnpackType(vt.Elem()).PtrData == 0 {
757
        p.int(_OP_array_clear, int(vt.Size()))
758
    } else {
759
        p.int(_OP_array_clear_p, int(vt.Size()))
760
    }
761

762
    /* restore the stack */
763
    p.pin(w)
764
    p.add(_OP_drop)
765

766
    p.pin(skip)
767
    p.pin(x)
768
}
769

770
func (self *_Compiler) compileSlice(p *_Program, sp int, vt reflect.Type) {
771
    if vt.Elem().Kind() == byteType.Kind() {
772
        self.compileSliceBin(p, sp, vt)
773
    } else {
774
        self.compileSliceList(p, sp, vt)
775
    }
776
}
777

778
func (self *_Compiler) compileSliceBin(p *_Program, sp int, vt reflect.Type) {
779
    i := p.pc()
780
    p.add(_OP_is_null)
781
    j := p.pc()
782
    p.chr(_OP_check_char, '[')
783
    skip := self.checkIfSkip(p, vt, '"')
784
    k := p.pc()
785
    p.chr(_OP_check_char, '"')
786
    p.add(_OP_bin)
787
    x := p.pc()
788
    p.add(_OP_goto)
789
    p.pin(j)
790
    self.compileSliceBody(p, sp, vt.Elem())
791
    y := p.pc()
792
    p.add(_OP_goto)
793
    p.pin(i)
794
    p.pin(k)
795
    p.add(_OP_nil_3)
796
    p.pin(x)
797
    p.pin(skip)
798
    p.pin(y)
799
}
800

801
func (self *_Compiler) compileSliceList(p *_Program, sp int, vt reflect.Type) {
802
    i := p.pc()
803
    p.add(_OP_is_null)
804
    p.tag(sp)
805
    skip := self.checkIfSkip(p, vt, '[')
806
    self.compileSliceBody(p, sp, vt.Elem())
807
    x := p.pc()
808
    p.add(_OP_goto)
809
    p.pin(i)
810
    p.add(_OP_nil_3)
811
    p.pin(x)
812
    p.pin(skip)
813
}
814

815
func (self *_Compiler) compileSliceBody(p *_Program, sp int, et reflect.Type) {
816
    p.add(_OP_lspace)
817
    j := p.pc()
818
    p.chr(_OP_check_empty, ']')
819
    p.rtt(_OP_slice_init, et)
820
    p.add(_OP_save)
821
    p.rtt(_OP_slice_append, et)
822
    self.compileOne(p, sp + 1, et)
823
    p.add(_OP_load)
824
    k0 := p.pc()
825
    p.add(_OP_lspace)
826
    k1 := p.pc()
827
    p.chr(_OP_check_char, ']')
828
    p.chr(_OP_match_char, ',')
829
    p.rtt(_OP_slice_append, et)
830
    self.compileOne(p, sp + 1, et)
831
    p.add(_OP_load)
832
    p.int(_OP_goto, k0)
833
    p.pin(k1)
834
    p.add(_OP_drop)
835
    p.pin(j)
836
}
837

838
func (self *_Compiler) compileString(p *_Program, vt reflect.Type) {
839
    if vt == jsonNumberType {
840
        self.compilePrimitive(vt, p, _OP_num)
841
    } else {
842
        self.compileStringBody(vt, p)
843
    }
844
}
845

846
func (self *_Compiler) compileStringBody(vt reflect.Type, p *_Program) {
847
    i := p.pc()
848
    p.add(_OP_is_null)
849
    skip := self.checkIfSkip(p, vt, '"')
850
    p.add(_OP_str)
851
    p.pin(i)
852
    p.pin(skip)
853
}
854

855
func (self *_Compiler) compileStruct(p *_Program, sp int, vt reflect.Type) {
856
    if sp >= self.opts.MaxInlineDepth || p.pc() >= _MAX_ILBUF || (sp > 0 && vt.NumField() >= _MAX_FIELDS) {
857
        p.rtt(_OP_recurse, vt)
858
        if self.opts.RecursiveDepth > 0 {
859
            self.rec[vt] = true
860
        }
861
    } else {
862
        self.compileStructBody(p, sp, vt)
863
    }
864
}
865

866
func (self *_Compiler) compileStructBody(p *_Program, sp int, vt reflect.Type) {
867
    fv := resolver.ResolveStruct(vt)
868
    fm, sw := caching.CreateFieldMap(len(fv)), make([]int, len(fv))
869

870
    /* start of object */
871
    p.tag(sp)
872
    n := p.pc()
873
    p.add(_OP_is_null)
874

875
    skip := self.checkIfSkip(p, vt, '{')
876
    
877
    p.add(_OP_save)
878
    p.add(_OP_lspace)
879
    x := p.pc()
880
    p.chr(_OP_check_char, '}')
881
    p.chr(_OP_match_char, '"')
882
    p.fmv(_OP_struct_field, fm)
883
    p.add(_OP_lspace)
884
    p.chr(_OP_match_char, ':')
885
    p.tab(_OP_switch, sw)
886
    p.add(_OP_object_next)
887
    y0 := p.pc()
888
    p.add(_OP_lspace)
889
    y1 := p.pc()
890
    p.chr(_OP_check_char, '}')
891
    p.chr(_OP_match_char, ',')
892

893
    /* special case of an empty struct */
894
    if len(fv) == 0 {
895
        p.add(_OP_object_skip)
896
        goto end_of_object
897
    }
898

899
    /* match the remaining fields */
900
    p.add(_OP_lspace)
901
    p.chr(_OP_match_char, '"')
902
    p.fmv(_OP_struct_field, fm)
903
    p.add(_OP_lspace)
904
    p.chr(_OP_match_char, ':')
905
    p.tab(_OP_switch, sw)
906
    p.add(_OP_object_next)
907
    p.int(_OP_goto, y0)
908

909
    /* process each field */
910
    for i, f := range fv {
911
        sw[i] = p.pc()
912
        fm.Set(f.Name, i)
913

914
        /* index to the field */
915
        for _, o := range f.Path {
916
            if p.int(_OP_index, int(o.Size)); o.Kind == resolver.F_deref {
917
                p.rtt(_OP_deref, o.Type)
918
            }
919
        }
920

921
        /* check for "stringnize" option */
922
        if (f.Opts & resolver.F_stringize) == 0 {
923
            self.compileOne(p, sp + 1, f.Type)
924
        } else {
925
            self.compileStructFieldStr(p, sp + 1, f.Type)
926
        }
927

928
        /* load the state, and try next field */
929
        p.add(_OP_load)
930
        p.int(_OP_goto, y0)
931
    }
932

933
end_of_object:
934
    p.pin(x)
935
    p.pin(y1)
936
    p.add(_OP_drop)
937
    p.pin(n)
938
    p.pin(skip)
939
}
940

941
func (self *_Compiler) compileStructFieldStr(p *_Program, sp int, vt reflect.Type) {
942
    n1 := -1
943
    ft := vt
944
    sv := false
945

946
    /* dereference the pointer if needed */
947
    if ft.Kind() == reflect.Ptr {
948
        ft = ft.Elem()
949
    }
950

951
    /* check if it can be stringized */
952
    switch ft.Kind() {
953
        case reflect.Bool    : sv = true
954
        case reflect.Int     : sv = true
955
        case reflect.Int8    : sv = true
956
        case reflect.Int16   : sv = true
957
        case reflect.Int32   : sv = true
958
        case reflect.Int64   : sv = true
959
        case reflect.Uint    : sv = true
960
        case reflect.Uint8   : sv = true
961
        case reflect.Uint16  : sv = true
962
        case reflect.Uint32  : sv = true
963
        case reflect.Uint64  : sv = true
964
        case reflect.Uintptr : sv = true
965
        case reflect.Float32 : sv = true
966
        case reflect.Float64 : sv = true
967
        case reflect.String  : sv = true
968
    }
969

970
    /* if it's not, ignore the "string" and follow the regular path */
971
    if !sv {
972
        self.compileOne(p, sp, vt)
973
        return
974
    }
975

976
    /* remove the leading space, and match the leading quote */
977
    vk := vt.Kind()
978
    p.add(_OP_lspace)
979
    n0 := p.pc()
980
    p.add(_OP_is_null)
981
    
982
    skip := self.checkIfSkip(p, stringType, '"')
983

984
    /* also check for inner "null" */
985
    n1 = p.pc()
986
    p.add(_OP_is_null_quote)
987

988
    /* dereference the pointer only when it is not null */
989
    if vk == reflect.Ptr {
990
        vt = vt.Elem()
991
        p.rtt(_OP_deref, vt)
992
    }
993

994
    n2 := p.pc()
995
    p.chr(_OP_check_char_0, '"')
996

997
    /* string opcode selector */
998
    _OP_string := func() _Op {
999
        if ft == jsonNumberType {
1000
            return _OP_num
1001
        } else {
1002
            return _OP_unquote
1003
        }
1004
    }
1005

1006
    /* compile for each type */
1007
    switch vt.Kind() {
1008
        case reflect.Bool    : p.add(_OP_bool)
1009
        case reflect.Int     : p.add(_OP_int())
1010
        case reflect.Int8    : p.add(_OP_i8)
1011
        case reflect.Int16   : p.add(_OP_i16)
1012
        case reflect.Int32   : p.add(_OP_i32)
1013
        case reflect.Int64   : p.add(_OP_i64)
1014
        case reflect.Uint    : p.add(_OP_uint())
1015
        case reflect.Uint8   : p.add(_OP_u8)
1016
        case reflect.Uint16  : p.add(_OP_u16)
1017
        case reflect.Uint32  : p.add(_OP_u32)
1018
        case reflect.Uint64  : p.add(_OP_u64)
1019
        case reflect.Uintptr : p.add(_OP_uintptr())
1020
        case reflect.Float32 : p.add(_OP_f32)
1021
        case reflect.Float64 : p.add(_OP_f64)
1022
        case reflect.String  : p.add(_OP_string())
1023
        default              : panic("not reachable")
1024
    }
1025

1026
    /* the closing quote is not needed when parsing a pure string */
1027
    if vt == jsonNumberType || vt.Kind() != reflect.String {
1028
        p.chr(_OP_match_char, '"')
1029
    }
1030

1031
    /* pin the `is_null_quote` jump location */
1032
    if n1 != -1 && vk != reflect.Ptr {
1033
        p.pin(n1)
1034
    }
1035

1036
    /* "null" but not a pointer, act as if the field is not present */
1037
    if vk != reflect.Ptr {
1038
        pc2 := p.pc()
1039
        p.add(_OP_goto)
1040
        p.pin(n2)
1041
        p.rtt(_OP_dismatch_err, vt)
1042
        p.int(_OP_add, 1)
1043
        p.pin(pc2)
1044
        p.pin(n0)
1045
        return
1046
    }
1047

1048
    /* the "null" case of the pointer */
1049
    pc := p.pc()
1050
    p.add(_OP_goto)
1051
    p.pin(n0) // `is_null` jump location
1052
    p.pin(n1) // `is_null_quote` jump location
1053
    p.add(_OP_nil_1)
1054
    pc2 := p.pc()
1055
    p.add(_OP_goto)
1056
    p.pin(n2)
1057
    p.rtt(_OP_dismatch_err, vt)
1058
    p.int(_OP_add, 1)
1059
    p.pin(pc)
1060
    p.pin(pc2)
1061
    p.pin(skip)
1062
}
1063

1064
func (self *_Compiler) compileInterface(p *_Program, vt reflect.Type) {
1065
    i := p.pc()
1066
    p.add(_OP_is_null)
1067

1068
    /* check for empty interface */
1069
    if vt.NumMethod() == 0 {
1070
        p.add(_OP_any)
1071
    } else {
1072
        p.rtt(_OP_dyn, vt)
1073
    }
1074

1075
    /* finish the OpCode */
1076
    j := p.pc()
1077
    p.add(_OP_goto)
1078
    p.pin(i)
1079
    p.add(_OP_nil_2)
1080
    p.pin(j)
1081
}
1082

1083
func (self *_Compiler) compilePrimitive(vt reflect.Type, p *_Program, op _Op) {
1084
    i := p.pc()
1085
    p.add(_OP_is_null)
1086
    // skip := self.checkPrimitive(p, vt)
1087
    p.add(op)
1088
    p.pin(i)
1089
    // p.pin(skip)
1090
}
1091

1092
func (self *_Compiler) compileUnmarshalEnd(p *_Program, vt reflect.Type, i int) {
1093
    j := p.pc()
1094
    k := vt.Kind()
1095

1096
    /* not a pointer */
1097
    if k != reflect.Ptr {
1098
        p.pin(i)
1099
        return
1100
    }
1101

1102
    /* it seems that in Go JSON library, "null" takes priority over any kind of unmarshaler */
1103
    p.add(_OP_goto)
1104
    p.pin(i)
1105
    p.add(_OP_nil_1)
1106
    p.pin(j)
1107
}
1108

1109
func (self *_Compiler) compileUnmarshalJson(p *_Program, vt reflect.Type) {
1110
    i := p.pc()
1111
    v := _OP_unmarshal
1112
    p.add(_OP_is_null)
1113

1114
    /* check for dynamic interface */
1115
    if vt.Kind() == reflect.Interface {
1116
        v = _OP_dyn
1117
    }
1118

1119
    /* call the unmarshaler */
1120
    p.rtt(v, vt)
1121
    self.compileUnmarshalEnd(p, vt, i)
1122
}
1123

1124
func (self *_Compiler) compileUnmarshalText(p *_Program, vt reflect.Type) {
1125
    i := p.pc()
1126
    v := _OP_unmarshal_text
1127
    p.add(_OP_is_null)
1128

1129
    /* check for dynamic interface */
1130
    if vt.Kind() == reflect.Interface {
1131
        v = _OP_dyn
1132
    } else {
1133
        p.chr(_OP_match_char, '"')
1134
    }
1135

1136
    /* call the unmarshaler */
1137
    p.rtt(v, vt)
1138
    self.compileUnmarshalEnd(p, vt, i)
1139
}
1140

1141
func (self *_Compiler) compileUnmarshalTextPtr(p *_Program, vt reflect.Type) {
1142
    i := p.pc()
1143
    p.add(_OP_is_null)
1144
    p.chr(_OP_match_char, '"')
1145
    p.rtt(_OP_unmarshal_text_p, vt)
1146
    p.pin(i)
1147
}
1148

1149
func (self *_Compiler) checkIfSkip(p *_Program, vt reflect.Type, c byte) int {
1150
    j := p.pc()
1151
    p.chr(_OP_check_char_0, c)
1152
    p.rtt(_OP_dismatch_err, vt)
1153
    s := p.pc()
1154
    p.add(_OP_go_skip)
1155
    p.pin(j)
1156
    p.int(_OP_add, 1)
1157
    return s
1158
}
1159