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 encoder
18

19
import (
20
    `fmt`
21
    `reflect`
22
    `strconv`
23
    `strings`
24
    `unsafe`
25

26
    `github.com/bytedance/sonic/internal/resolver`
27
    `github.com/bytedance/sonic/internal/rt`
28
    `github.com/bytedance/sonic/option`
29
)
30

31
type _Op uint8
32

33
const (
34
    _OP_null _Op = iota + 1
35
    _OP_empty_arr
36
    _OP_empty_obj
37
    _OP_bool
38
    _OP_i8
39
    _OP_i16
40
    _OP_i32
41
    _OP_i64
42
    _OP_u8
43
    _OP_u16
44
    _OP_u32
45
    _OP_u64
46
    _OP_f32
47
    _OP_f64
48
    _OP_str
49
    _OP_bin
50
    _OP_quote
51
    _OP_number
52
    _OP_eface
53
    _OP_iface
54
    _OP_byte
55
    _OP_text
56
    _OP_deref
57
    _OP_index
58
    _OP_load
59
    _OP_save
60
    _OP_drop
61
    _OP_drop_2
62
    _OP_recurse
63
    _OP_is_nil
64
    _OP_is_nil_p1
65
    _OP_is_zero_1
66
    _OP_is_zero_2
67
    _OP_is_zero_4
68
    _OP_is_zero_8
69
    _OP_is_zero_map
70
    _OP_goto
71
    _OP_map_iter
72
    _OP_map_stop
73
    _OP_map_check_key
74
    _OP_map_write_key
75
    _OP_map_value_next
76
    _OP_slice_len
77
    _OP_slice_next
78
    _OP_marshal
79
    _OP_marshal_p
80
    _OP_marshal_text
81
    _OP_marshal_text_p
82
    _OP_cond_set
83
    _OP_cond_testc
84
)
85

86
const (
87
    _INT_SIZE = 32 << (^uint(0) >> 63)
88
    _PTR_SIZE = 32 << (^uintptr(0) >> 63)
89
    _PTR_BYTE = unsafe.Sizeof(uintptr(0))
90
)
91

92
const (
93
    _MAX_ILBUF = 100000     // cutoff at 100k of IL instructions
94
    _MAX_FIELDS = 50        // cutoff at 50 fields struct
95
)
96

97
var _OpNames = [256]string {
98
    _OP_null           : "null",
99
    _OP_empty_arr      : "empty_arr",
100
    _OP_empty_obj      : "empty_obj",
101
    _OP_bool           : "bool",
102
    _OP_i8             : "i8",
103
    _OP_i16            : "i16",
104
    _OP_i32            : "i32",
105
    _OP_i64            : "i64",
106
    _OP_u8             : "u8",
107
    _OP_u16            : "u16",
108
    _OP_u32            : "u32",
109
    _OP_u64            : "u64",
110
    _OP_f32            : "f32",
111
    _OP_f64            : "f64",
112
    _OP_str            : "str",
113
    _OP_bin            : "bin",
114
    _OP_quote          : "quote",
115
    _OP_number         : "number",
116
    _OP_eface          : "eface",
117
    _OP_iface          : "iface",
118
    _OP_byte           : "byte",
119
    _OP_text           : "text",
120
    _OP_deref          : "deref",
121
    _OP_index          : "index",
122
    _OP_load           : "load",
123
    _OP_save           : "save",
124
    _OP_drop           : "drop",
125
    _OP_drop_2         : "drop_2",
126
    _OP_recurse        : "recurse",
127
    _OP_is_nil         : "is_nil",
128
    _OP_is_nil_p1      : "is_nil_p1",
129
    _OP_is_zero_1      : "is_zero_1",
130
    _OP_is_zero_2      : "is_zero_2",
131
    _OP_is_zero_4      : "is_zero_4",
132
    _OP_is_zero_8      : "is_zero_8",
133
    _OP_is_zero_map    : "is_zero_map",
134
    _OP_goto           : "goto",
135
    _OP_map_iter       : "map_iter",
136
    _OP_map_stop       : "map_stop",
137
    _OP_map_check_key  : "map_check_key",
138
    _OP_map_write_key  : "map_write_key",
139
    _OP_map_value_next : "map_value_next",
140
    _OP_slice_len      : "slice_len",
141
    _OP_slice_next     : "slice_next",
142
    _OP_marshal        : "marshal",
143
    _OP_marshal_p      : "marshal_p",
144
    _OP_marshal_text   : "marshal_text",
145
    _OP_marshal_text_p : "marshal_text_p",
146
    _OP_cond_set       : "cond_set",
147
    _OP_cond_testc     : "cond_testc",
148
}
149

150
func (self _Op) String() string {
151
    if ret := _OpNames[self]; ret != "" {
152
        return ret
153
    } else {
154
        return "<invalid>"
155
    }
156
}
157

158
func _OP_int() _Op {
159
    switch _INT_SIZE {
160
        case 32: return _OP_i32
161
        case 64: return _OP_i64
162
        default: panic("unsupported int size")
163
    }
164
}
165

166
func _OP_uint() _Op {
167
    switch _INT_SIZE {
168
        case 32: return _OP_u32
169
        case 64: return _OP_u64
170
        default: panic("unsupported uint size")
171
    }
172
}
173

174
func _OP_uintptr() _Op {
175
    switch _PTR_SIZE {
176
        case 32: return _OP_u32
177
        case 64: return _OP_u64
178
        default: panic("unsupported pointer size")
179
    }
180
}
181

182
func _OP_is_zero_ints() _Op {
183
    switch _INT_SIZE {
184
        case 32: return _OP_is_zero_4
185
        case 64: return _OP_is_zero_8
186
        default: panic("unsupported integer size")
187
    }
188
}
189

190
type _Instr struct {
191
    u uint64            // union {op: 8, _: 8, vi: 48}, vi maybe int or len(str)
192
    p unsafe.Pointer    // maybe GoString.Ptr, or *GoType
193
}
194

195
func packOp(op _Op) uint64 {
196
    return uint64(op) << 56
197
}
198

199
func newInsOp(op _Op) _Instr {
200
    return _Instr{u: packOp(op)}
201
}
202

203
func newInsVi(op _Op, vi int) _Instr {
204
    return _Instr{u: packOp(op) | rt.PackInt(vi)}
205
}
206

207
func newInsVs(op _Op, vs string) _Instr {
208
    return _Instr {
209
        u: packOp(op) | rt.PackInt(len(vs)),
210
        p: (*rt.GoString)(unsafe.Pointer(&vs)).Ptr,
211
    }
212
}
213

214
func newInsVt(op _Op, vt reflect.Type) _Instr {
215
    return _Instr {
216
        u: packOp(op),
217
        p: unsafe.Pointer(rt.UnpackType(vt)),
218
    }
219
}
220

221
func newInsVp(op _Op, vt reflect.Type, pv bool) _Instr {
222
    i := 0
223
    if pv {
224
        i = 1
225
    }
226
    return _Instr {
227
        u: packOp(op) | rt.PackInt(i),
228
        p: unsafe.Pointer(rt.UnpackType(vt)),
229
    }
230
}
231

232
func (self _Instr) op() _Op {
233
    return _Op(self.u >> 56)
234
}
235

236
func (self _Instr) vi() int {
237
    return rt.UnpackInt(self.u)
238
}
239

240
func (self _Instr) vf() uint8 {
241
    return (*rt.GoType)(self.p).KindFlags
242
}
243

244
func (self _Instr) vs() (v string) {
245
    (*rt.GoString)(unsafe.Pointer(&v)).Ptr = self.p
246
    (*rt.GoString)(unsafe.Pointer(&v)).Len = self.vi()
247
    return
248
}
249

250
func (self _Instr) vk() reflect.Kind {
251
    return (*rt.GoType)(self.p).Kind()
252
}
253

254
func (self _Instr) vt() reflect.Type {
255
    return (*rt.GoType)(self.p).Pack()
256
}
257

258
func (self _Instr) vp() (vt reflect.Type, pv bool) {
259
    return (*rt.GoType)(self.p).Pack(), rt.UnpackInt(self.u) == 1
260
}
261

262
func (self _Instr) i64() int64 {
263
    return int64(self.vi())
264
}
265

266
func (self _Instr) vlen() int {
267
    return int((*rt.GoType)(self.p).Size)
268
}
269

270
func (self _Instr) isBranch() bool {
271
    switch self.op() {
272
        case _OP_goto          : fallthrough
273
        case _OP_is_nil        : fallthrough
274
        case _OP_is_nil_p1     : fallthrough
275
        case _OP_is_zero_1     : fallthrough
276
        case _OP_is_zero_2     : fallthrough
277
        case _OP_is_zero_4     : fallthrough
278
        case _OP_is_zero_8     : fallthrough
279
        case _OP_map_check_key : fallthrough
280
        case _OP_map_write_key : fallthrough
281
        case _OP_slice_next    : fallthrough
282
        case _OP_cond_testc    : return true
283
        default                : return false
284
    }
285
}
286

287
func (self _Instr) disassemble() string {
288
    switch self.op() {
289
        case _OP_byte           : return fmt.Sprintf("%-18s%s", self.op().String(), strconv.QuoteRune(rune(self.vi())))
290
        case _OP_text           : return fmt.Sprintf("%-18s%s", self.op().String(), strconv.Quote(self.vs()))
291
        case _OP_index          : return fmt.Sprintf("%-18s%d", self.op().String(), self.vi())
292
        case _OP_recurse        : fallthrough
293
        case _OP_map_iter       : fallthrough
294
        case _OP_marshal        : fallthrough
295
        case _OP_marshal_p      : fallthrough
296
        case _OP_marshal_text   : fallthrough
297
        case _OP_marshal_text_p : return fmt.Sprintf("%-18s%s", self.op().String(), self.vt())
298
        case _OP_goto           : fallthrough
299
        case _OP_is_nil         : fallthrough
300
        case _OP_is_nil_p1      : fallthrough
301
        case _OP_is_zero_1      : fallthrough
302
        case _OP_is_zero_2      : fallthrough
303
        case _OP_is_zero_4      : fallthrough
304
        case _OP_is_zero_8      : fallthrough
305
        case _OP_is_zero_map    : fallthrough
306
        case _OP_cond_testc     : fallthrough
307
        case _OP_map_check_key  : fallthrough
308
        case _OP_map_write_key  : return fmt.Sprintf("%-18sL_%d", self.op().String(), self.vi())
309
        case _OP_slice_next     : return fmt.Sprintf("%-18sL_%d, %s", self.op().String(), self.vi(), self.vt())
310
        default                 : return self.op().String()
311
    }
312
}
313

314
type (
315
	_Program []_Instr
316
)
317

318
func (self _Program) pc() int {
319
    return len(self)
320
}
321

322
func (self _Program) tag(n int) {
323
    if n >= _MaxStack {
324
        panic("type nesting too deep")
325
    }
326
}
327

328
func (self _Program) pin(i int) {
329
    v := &self[i]
330
    v.u &= 0xffff000000000000
331
    v.u |= rt.PackInt(self.pc())
332
}
333

334
func (self _Program) rel(v []int) {
335
    for _, i := range v {
336
        self.pin(i)
337
    }
338
}
339

340
func (self *_Program) add(op _Op) {
341
    *self = append(*self, newInsOp(op))
342
}
343

344
func (self *_Program) key(op _Op) {
345
    *self = append(*self,
346
        newInsVi(_OP_byte, '"'),
347
        newInsOp(op),
348
        newInsVi(_OP_byte, '"'),
349
    )
350
}
351

352
func (self *_Program) int(op _Op, vi int) {
353
    *self = append(*self, newInsVi(op, vi))
354
}
355

356
func (self *_Program) str(op _Op, vs string) {
357
    *self = append(*self, newInsVs(op, vs))
358
}
359

360
func (self *_Program) rtt(op _Op, vt reflect.Type) {
361
    *self = append(*self, newInsVt(op, vt))
362
}
363

364
func (self *_Program) vp(op _Op, vt reflect.Type, pv bool) {
365
    *self = append(*self, newInsVp(op, vt, pv))
366
}
367

368
func (self _Program) disassemble() string {
369
    nb  := len(self)
370
    tab := make([]bool, nb + 1)
371
    ret := make([]string, 0, nb + 1)
372

373
    /* prescan to get all the labels */
374
    for _, ins := range self {
375
        if ins.isBranch() {
376
            tab[ins.vi()] = true
377
        }
378
    }
379

380
    /* disassemble each instruction */
381
    for i, ins := range self {
382
        if !tab[i] {
383
            ret = append(ret, "\t" + ins.disassemble())
384
        } else {
385
            ret = append(ret, fmt.Sprintf("L_%d:\n\t%s", i, ins.disassemble()))
386
        }
387
    }
388

389
    /* add the last label, if needed */
390
    if tab[nb] {
391
        ret = append(ret, fmt.Sprintf("L_%d:", nb))
392
    }
393

394
    /* add an "end" indicator, and join all the strings */
395
    return strings.Join(append(ret, "\tend"), "\n")
396
}
397

398
type _Compiler struct {
399
    opts option.CompileOptions
400
    pv   bool
401
    tab  map[reflect.Type]bool
402
    rec  map[reflect.Type]uint8
403
}
404

405
func newCompiler() *_Compiler {
406
    return &_Compiler {
407
        opts: option.DefaultCompileOptions(),
408
        tab: map[reflect.Type]bool{},
409
        rec: map[reflect.Type]uint8{},
410
    }
411
}
412

413
func (self *_Compiler) apply(opts option.CompileOptions) *_Compiler {
414
    self.opts = opts
415
    if self.opts.RecursiveDepth > 0 {
416
        self.rec = map[reflect.Type]uint8{}
417
    }
418
    return self
419
}
420

421
func (self *_Compiler) rescue(ep *error) {
422
    if val := recover(); val != nil {
423
        if err, ok := val.(error); ok {
424
            *ep = err
425
        } else {
426
            panic(val)
427
        }
428
    }
429
}
430

431
func (self *_Compiler) compile(vt reflect.Type, pv bool) (ret _Program, err error) {
432
    defer self.rescue(&err)
433
    self.compileOne(&ret, 0, vt, pv)
434
    return
435
}
436

437
func (self *_Compiler) compileOne(p *_Program, sp int, vt reflect.Type, pv bool) {
438
    if self.tab[vt] {
439
        p.vp(_OP_recurse, vt, pv)
440
    } else {
441
        self.compileRec(p, sp, vt, pv)
442
    }
443
}
444

445
func (self *_Compiler) compileRec(p *_Program, sp int, vt reflect.Type, pv bool) {
446
    pr := self.pv
447
    pt := reflect.PtrTo(vt)
448

449
    /* check for addressable `json.Marshaler` with pointer receiver */
450
    if pv && pt.Implements(jsonMarshalerType) {
451
        p.rtt(_OP_marshal_p, pt)
452
        return
453
    }
454

455
    /* check for `json.Marshaler` */
456
    if vt.Implements(jsonMarshalerType) {
457
        self.compileMarshaler(p, _OP_marshal, vt, jsonMarshalerType)
458
        return
459
    }
460

461
    /* check for addressable `encoding.TextMarshaler` with pointer receiver */
462
    if pv && pt.Implements(encodingTextMarshalerType) {
463
        p.rtt(_OP_marshal_text_p, pt)
464
        return
465
    }
466

467
    /* check for `encoding.TextMarshaler` */
468
    if vt.Implements(encodingTextMarshalerType) {
469
        self.compileMarshaler(p, _OP_marshal_text, vt, encodingTextMarshalerType)
470
        return
471
    }
472

473
    /* enter the recursion, and compile the type */
474
    self.pv = pv
475
    self.tab[vt] = true
476
    self.compileOps(p, sp, vt)
477

478
    /* exit the recursion */
479
    self.pv = pr
480
    delete(self.tab, vt)
481
}
482

483
func (self *_Compiler) compileOps(p *_Program, sp int, vt reflect.Type) {
484
    switch vt.Kind() {
485
        case reflect.Bool      : p.add(_OP_bool)
486
        case reflect.Int       : p.add(_OP_int())
487
        case reflect.Int8      : p.add(_OP_i8)
488
        case reflect.Int16     : p.add(_OP_i16)
489
        case reflect.Int32     : p.add(_OP_i32)
490
        case reflect.Int64     : p.add(_OP_i64)
491
        case reflect.Uint      : p.add(_OP_uint())
492
        case reflect.Uint8     : p.add(_OP_u8)
493
        case reflect.Uint16    : p.add(_OP_u16)
494
        case reflect.Uint32    : p.add(_OP_u32)
495
        case reflect.Uint64    : p.add(_OP_u64)
496
        case reflect.Uintptr   : p.add(_OP_uintptr())
497
        case reflect.Float32   : p.add(_OP_f32)
498
        case reflect.Float64   : p.add(_OP_f64)
499
        case reflect.String    : self.compileString    (p, vt)
500
        case reflect.Array     : self.compileArray     (p, sp, vt.Elem(), vt.Len())
501
        case reflect.Interface : self.compileInterface (p, vt)
502
        case reflect.Map       : self.compileMap       (p, sp, vt)
503
        case reflect.Ptr       : self.compilePtr       (p, sp, vt.Elem())
504
        case reflect.Slice     : self.compileSlice     (p, sp, vt.Elem())
505
        case reflect.Struct    : self.compileStruct    (p, sp, vt)
506
        default                : panic                 (error_type(vt))
507
    }
508
}
509

510
func (self *_Compiler) compileNil(p *_Program, sp int, vt reflect.Type, nil_op _Op, fn func(*_Program, int, reflect.Type)) {
511
    x := p.pc()
512
    p.add(_OP_is_nil)
513
    fn(p, sp, vt)
514
    e := p.pc()
515
    p.add(_OP_goto)
516
    p.pin(x)
517
    p.add(nil_op)
518
    p.pin(e)
519
}
520

521
func (self *_Compiler) compilePtr(p *_Program, sp int, vt reflect.Type) {
522
    self.compileNil(p, sp, vt, _OP_null, self.compilePtrBody)
523
}
524

525
func (self *_Compiler) compilePtrBody(p *_Program, sp int, vt reflect.Type) {
526
    p.tag(sp)
527
    p.add(_OP_save)
528
    p.add(_OP_deref)
529
    self.compileOne(p, sp + 1, vt, true)
530
    p.add(_OP_drop)
531
}
532

533
func (self *_Compiler) compileMap(p *_Program, sp int, vt reflect.Type) {
534
    self.compileNil(p, sp, vt, _OP_empty_obj, self.compileMapBody)
535
}
536

537
func (self *_Compiler) compileMapBody(p *_Program, sp int, vt reflect.Type) {
538
    p.tag(sp + 1)
539
    p.int(_OP_byte, '{')
540
    p.add(_OP_save)
541
    p.rtt(_OP_map_iter, vt)
542
    p.add(_OP_save)
543
    i := p.pc()
544
    p.add(_OP_map_check_key)
545
    u := p.pc()
546
    p.add(_OP_map_write_key)
547
    self.compileMapBodyKey(p, vt.Key())
548
    p.pin(u)
549
    p.int(_OP_byte, ':')
550
    p.add(_OP_map_value_next)
551
    self.compileOne(p, sp + 2, vt.Elem(), false)
552
    j := p.pc()
553
    p.add(_OP_map_check_key)
554
    p.int(_OP_byte, ',')
555
    v := p.pc()
556
    p.add(_OP_map_write_key)
557
    self.compileMapBodyKey(p, vt.Key())
558
    p.pin(v)
559
    p.int(_OP_byte, ':')
560
    p.add(_OP_map_value_next)
561
    self.compileOne(p, sp + 2, vt.Elem(), false)
562
    p.int(_OP_goto, j)
563
    p.pin(i)
564
    p.pin(j)
565
    p.add(_OP_map_stop)
566
    p.add(_OP_drop_2)
567
    p.int(_OP_byte, '}')
568
}
569

570
func (self *_Compiler) compileMapBodyKey(p *_Program, vk reflect.Type) {
571
    if !vk.Implements(encodingTextMarshalerType) {
572
        self.compileMapBodyTextKey(p, vk)
573
    } else {
574
        self.compileMapBodyUtextKey(p, vk)
575
    }
576
}
577

578
func (self *_Compiler) compileMapBodyTextKey(p *_Program, vk reflect.Type) {
579
    switch vk.Kind() {
580
        case reflect.Invalid : panic("map key is nil")
581
        case reflect.Bool    : p.key(_OP_bool)
582
        case reflect.Int     : p.key(_OP_int())
583
        case reflect.Int8    : p.key(_OP_i8)
584
        case reflect.Int16   : p.key(_OP_i16)
585
        case reflect.Int32   : p.key(_OP_i32)
586
        case reflect.Int64   : p.key(_OP_i64)
587
        case reflect.Uint    : p.key(_OP_uint())
588
        case reflect.Uint8   : p.key(_OP_u8)
589
        case reflect.Uint16  : p.key(_OP_u16)
590
        case reflect.Uint32  : p.key(_OP_u32)
591
        case reflect.Uint64  : p.key(_OP_u64)
592
        case reflect.Uintptr : p.key(_OP_uintptr())
593
        case reflect.Float32 : p.key(_OP_f32)
594
        case reflect.Float64 : p.key(_OP_f64)
595
        case reflect.String  : self.compileString(p, vk)
596
        default              : panic(error_type(vk))
597
    }
598
}
599

600
func (self *_Compiler) compileMapBodyUtextKey(p *_Program, vk reflect.Type) {
601
    if vk.Kind() != reflect.Ptr {
602
        p.rtt(_OP_marshal_text, vk)
603
    } else {
604
        self.compileMapBodyUtextPtr(p, vk)
605
    }
606
}
607

608
func (self *_Compiler) compileMapBodyUtextPtr(p *_Program, vk reflect.Type) {
609
    i := p.pc()
610
    p.add(_OP_is_nil)
611
    p.rtt(_OP_marshal_text, vk)
612
    j := p.pc()
613
    p.add(_OP_goto)
614
    p.pin(i)
615
    p.str(_OP_text, "\"\"")
616
    p.pin(j)
617
}
618

619
func (self *_Compiler) compileSlice(p *_Program, sp int, vt reflect.Type) {
620
    self.compileNil(p, sp, vt, _OP_empty_arr, self.compileSliceBody)
621
}
622

623
func (self *_Compiler) compileSliceBody(p *_Program, sp int, vt reflect.Type) {
624
    if isSimpleByte(vt) {
625
        p.add(_OP_bin)
626
    } else {
627
        self.compileSliceArray(p, sp, vt)
628
    }
629
}
630

631
func (self *_Compiler) compileSliceArray(p *_Program, sp int, vt reflect.Type) {
632
    p.tag(sp)
633
    p.int(_OP_byte, '[')
634
    p.add(_OP_save)
635
    p.add(_OP_slice_len)
636
    i := p.pc()
637
    p.rtt(_OP_slice_next, vt)
638
    self.compileOne(p, sp + 1, vt, true)
639
    j := p.pc()
640
    p.rtt(_OP_slice_next, vt)
641
    p.int(_OP_byte, ',')
642
    self.compileOne(p, sp + 1, vt, true)
643
    p.int(_OP_goto, j)
644
    p.pin(i)
645
    p.pin(j)
646
    p.add(_OP_drop)
647
    p.int(_OP_byte, ']')
648
}
649

650
func (self *_Compiler) compileArray(p *_Program, sp int, vt reflect.Type, nb int) {
651
    p.tag(sp)
652
    p.int(_OP_byte, '[')
653
    p.add(_OP_save)
654

655
    /* first item */
656
    if nb != 0 {
657
        self.compileOne(p, sp + 1, vt, self.pv)
658
        p.add(_OP_load)
659
    }
660

661
    /* remaining items */
662
    for i := 1; i < nb; i++ {
663
        p.int(_OP_byte, ',')
664
        p.int(_OP_index, i * int(vt.Size()))
665
        self.compileOne(p, sp + 1, vt, self.pv)
666
        p.add(_OP_load)
667
    }
668

669
    /* end of array */
670
    p.add(_OP_drop)
671
    p.int(_OP_byte, ']')
672
}
673

674
func (self *_Compiler) compileString(p *_Program, vt reflect.Type) {
675
    if vt != jsonNumberType {
676
        p.add(_OP_str)
677
    } else {
678
        p.add(_OP_number)
679
    }
680
}
681

682
func (self *_Compiler) compileStruct(p *_Program, sp int, vt reflect.Type) {
683
    if sp >= self.opts.MaxInlineDepth || p.pc() >= _MAX_ILBUF || (sp > 0 && vt.NumField() >= _MAX_FIELDS) {
684
        p.vp(_OP_recurse, vt, self.pv)
685
        if self.opts.RecursiveDepth > 0 {
686
            if self.pv {
687
                self.rec[vt] = 1
688
            } else {
689
                self.rec[vt] = 0
690
            }
691
        }
692
    } else {
693
        self.compileStructBody(p, sp, vt)
694
    }
695
}
696

697
func (self *_Compiler) compileStructBody(p *_Program, sp int, vt reflect.Type) {
698
    p.tag(sp)
699
    p.int(_OP_byte, '{')
700
    p.add(_OP_save)
701
    p.add(_OP_cond_set)
702

703
    /* compile each field */
704
    for _, fv := range resolver.ResolveStruct(vt) {
705
        var s []int
706
        var o resolver.Offset
707

708
        /* "omitempty" for arrays */
709
        if fv.Type.Kind() == reflect.Array {
710
            if fv.Type.Len() == 0 && (fv.Opts & resolver.F_omitempty) != 0 {
711
                continue
712
            }
713
        }
714

715
        /* index to the field */
716
        for _, o = range fv.Path {
717
            if p.int(_OP_index, int(o.Size)); o.Kind == resolver.F_deref {
718
                s = append(s, p.pc())
719
                p.add(_OP_is_nil)
720
                p.add(_OP_deref)
721
            }
722
        }
723

724
        /* check for "omitempty" option */
725
        if fv.Type.Kind() != reflect.Struct && fv.Type.Kind() != reflect.Array && (fv.Opts & resolver.F_omitempty) != 0 {
726
            s = append(s, p.pc())
727
            self.compileStructFieldZero(p, fv.Type)
728
        }
729

730
        /* add the comma if not the first element */
731
        i := p.pc()
732
        p.add(_OP_cond_testc)
733
        p.int(_OP_byte, ',')
734
        p.pin(i)
735

736
        /* compile the key and value */
737
        ft := fv.Type
738
        p.str(_OP_text, Quote(fv.Name) + ":")
739

740
        /* check for "stringnize" option */
741
        if (fv.Opts & resolver.F_stringize) == 0 {
742
            self.compileOne(p, sp + 1, ft, self.pv)
743
        } else {
744
            self.compileStructFieldStr(p, sp + 1, ft)
745
        }
746

747
        /* patch the skipping jumps and reload the struct pointer */
748
        p.rel(s)
749
        p.add(_OP_load)
750
    }
751

752
    /* end of object */
753
    p.add(_OP_drop)
754
    p.int(_OP_byte, '}')
755
}
756

757
func (self *_Compiler) compileStructFieldStr(p *_Program, sp int, vt reflect.Type) {
758
    pc := -1
759
    ft := vt
760
    sv := false
761

762
    /* dereference the pointer if needed */
763
    if ft.Kind() == reflect.Ptr {
764
        ft = ft.Elem()
765
    }
766

767
    /* check if it can be stringized */
768
    switch ft.Kind() {
769
        case reflect.Bool    : sv = true
770
        case reflect.Int     : sv = true
771
        case reflect.Int8    : sv = true
772
        case reflect.Int16   : sv = true
773
        case reflect.Int32   : sv = true
774
        case reflect.Int64   : sv = true
775
        case reflect.Uint    : sv = true
776
        case reflect.Uint8   : sv = true
777
        case reflect.Uint16  : sv = true
778
        case reflect.Uint32  : sv = true
779
        case reflect.Uint64  : sv = true
780
        case reflect.Uintptr : sv = true
781
        case reflect.Float32 : sv = true
782
        case reflect.Float64 : sv = true
783
        case reflect.String  : sv = true
784
    }
785

786
    /* if it's not, ignore the "string" and follow the regular path */
787
    if !sv {
788
        self.compileOne(p, sp, vt, self.pv)
789
        return
790
    }
791

792
    /* dereference the pointer */
793
    if vt.Kind() == reflect.Ptr {
794
        pc = p.pc()
795
        vt = vt.Elem()
796
        p.add(_OP_is_nil)
797
        p.add(_OP_deref)
798
    }
799

800
    /* special case of a double-quoted string */
801
    if ft != jsonNumberType && ft.Kind() == reflect.String {
802
        p.add(_OP_quote)
803
    } else {
804
        self.compileStructFieldQuoted(p, sp, vt)
805
    }
806

807
    /* the "null" case of the pointer */
808
    if pc != -1 {
809
        e := p.pc()
810
        p.add(_OP_goto)
811
        p.pin(pc)
812
        p.add(_OP_null)
813
        p.pin(e)
814
    }
815
}
816

817
func (self *_Compiler) compileStructFieldZero(p *_Program, vt reflect.Type) {
818
    switch vt.Kind() {
819
        case reflect.Bool      : p.add(_OP_is_zero_1)
820
        case reflect.Int       : p.add(_OP_is_zero_ints())
821
        case reflect.Int8      : p.add(_OP_is_zero_1)
822
        case reflect.Int16     : p.add(_OP_is_zero_2)
823
        case reflect.Int32     : p.add(_OP_is_zero_4)
824
        case reflect.Int64     : p.add(_OP_is_zero_8)
825
        case reflect.Uint      : p.add(_OP_is_zero_ints())
826
        case reflect.Uint8     : p.add(_OP_is_zero_1)
827
        case reflect.Uint16    : p.add(_OP_is_zero_2)
828
        case reflect.Uint32    : p.add(_OP_is_zero_4)
829
        case reflect.Uint64    : p.add(_OP_is_zero_8)
830
        case reflect.Uintptr   : p.add(_OP_is_nil)
831
        case reflect.Float32   : p.add(_OP_is_zero_4)
832
        case reflect.Float64   : p.add(_OP_is_zero_8)
833
        case reflect.String    : p.add(_OP_is_nil_p1)
834
        case reflect.Interface : p.add(_OP_is_nil_p1)
835
        case reflect.Map       : p.add(_OP_is_zero_map)
836
        case reflect.Ptr       : p.add(_OP_is_nil)
837
        case reflect.Slice     : p.add(_OP_is_nil_p1)
838
        default                : panic(error_type(vt))
839
    }
840
}
841

842
func (self *_Compiler) compileStructFieldQuoted(p *_Program, sp int, vt reflect.Type) {
843
    p.int(_OP_byte, '"')
844
    self.compileOne(p, sp, vt, self.pv)
845
    p.int(_OP_byte, '"')
846
}
847

848
func (self *_Compiler) compileInterface(p *_Program, vt reflect.Type) {
849
    x := p.pc()
850
    p.add(_OP_is_nil_p1)
851

852
    /* iface and efaces are different */
853
    if vt.NumMethod() == 0 {
854
        p.add(_OP_eface)
855
    } else {
856
        p.add(_OP_iface)
857
    }
858

859
    /* the "null" value */
860
    e := p.pc()
861
    p.add(_OP_goto)
862
    p.pin(x)
863
    p.add(_OP_null)
864
    p.pin(e)
865
}
866

867
func (self *_Compiler) compileMarshaler(p *_Program, op _Op, vt reflect.Type, mt reflect.Type) {
868
    pc := p.pc()
869
    vk := vt.Kind()
870

871
    /* direct receiver */
872
    if vk != reflect.Ptr {
873
        p.rtt(op, vt)
874
        return
875
    }
876

877
    /* value receiver with a pointer type, check for nil before calling the marshaler */
878
    p.add(_OP_is_nil)
879
    p.rtt(op, vt)
880
    i := p.pc()
881
    p.add(_OP_goto)
882
    p.pin(pc)
883
    p.add(_OP_null)
884
    p.pin(i)
885
}
886