compiler.go

Documentation: github.com/bytedance/sonic/internal/encoder

     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)
   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
View as plain text