1571 lines
37 KiB
Go
1571 lines
37 KiB
Go
package encoder
|
|
|
|
import (
|
|
"context"
|
|
"encoding"
|
|
"encoding/json"
|
|
"fmt"
|
|
"reflect"
|
|
"strings"
|
|
"sync/atomic"
|
|
"unsafe"
|
|
|
|
"github.com/goccy/go-json/internal/errors"
|
|
"github.com/goccy/go-json/internal/runtime"
|
|
)
|
|
|
|
type marshalerContext interface {
|
|
MarshalJSON(context.Context) ([]byte, error)
|
|
}
|
|
|
|
var (
|
|
marshalJSONType = reflect.TypeOf((*json.Marshaler)(nil)).Elem()
|
|
marshalJSONContextType = reflect.TypeOf((*marshalerContext)(nil)).Elem()
|
|
marshalTextType = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
|
|
jsonNumberType = reflect.TypeOf(json.Number(""))
|
|
cachedOpcodeSets []*OpcodeSet
|
|
cachedOpcodeMap unsafe.Pointer // map[uintptr]*OpcodeSet
|
|
typeAddr *runtime.TypeAddr
|
|
)
|
|
|
|
func init() {
|
|
typeAddr = runtime.AnalyzeTypeAddr()
|
|
if typeAddr == nil {
|
|
typeAddr = &runtime.TypeAddr{}
|
|
}
|
|
cachedOpcodeSets = make([]*OpcodeSet, typeAddr.AddrRange>>typeAddr.AddrShift)
|
|
}
|
|
|
|
func loadOpcodeMap() map[uintptr]*OpcodeSet {
|
|
p := atomic.LoadPointer(&cachedOpcodeMap)
|
|
return *(*map[uintptr]*OpcodeSet)(unsafe.Pointer(&p))
|
|
}
|
|
|
|
func storeOpcodeSet(typ uintptr, set *OpcodeSet, m map[uintptr]*OpcodeSet) {
|
|
newOpcodeMap := make(map[uintptr]*OpcodeSet, len(m)+1)
|
|
newOpcodeMap[typ] = set
|
|
|
|
for k, v := range m {
|
|
newOpcodeMap[k] = v
|
|
}
|
|
|
|
atomic.StorePointer(&cachedOpcodeMap, *(*unsafe.Pointer)(unsafe.Pointer(&newOpcodeMap)))
|
|
}
|
|
|
|
func compileToGetCodeSetSlowPath(typeptr uintptr) (*OpcodeSet, error) {
|
|
opcodeMap := loadOpcodeMap()
|
|
if codeSet, exists := opcodeMap[typeptr]; exists {
|
|
return codeSet, nil
|
|
}
|
|
|
|
// noescape trick for header.typ ( reflect.*rtype )
|
|
copiedType := *(**runtime.Type)(unsafe.Pointer(&typeptr))
|
|
|
|
noescapeKeyCode, err := compileHead(&compileContext{
|
|
typ: copiedType,
|
|
structTypeToCompiledCode: map[uintptr]*CompiledCode{},
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
escapeKeyCode, err := compileHead(&compileContext{
|
|
typ: copiedType,
|
|
structTypeToCompiledCode: map[uintptr]*CompiledCode{},
|
|
escapeKey: true,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
noescapeKeyCode = copyOpcode(noescapeKeyCode)
|
|
escapeKeyCode = copyOpcode(escapeKeyCode)
|
|
setTotalLengthToInterfaceOp(noescapeKeyCode)
|
|
setTotalLengthToInterfaceOp(escapeKeyCode)
|
|
interfaceNoescapeKeyCode := copyToInterfaceOpcode(noescapeKeyCode)
|
|
interfaceEscapeKeyCode := copyToInterfaceOpcode(escapeKeyCode)
|
|
codeLength := noescapeKeyCode.TotalLength()
|
|
codeSet := &OpcodeSet{
|
|
Type: copiedType,
|
|
NoescapeKeyCode: noescapeKeyCode,
|
|
EscapeKeyCode: escapeKeyCode,
|
|
InterfaceNoescapeKeyCode: interfaceNoescapeKeyCode,
|
|
InterfaceEscapeKeyCode: interfaceEscapeKeyCode,
|
|
CodeLength: codeLength,
|
|
EndCode: ToEndCode(interfaceNoescapeKeyCode),
|
|
}
|
|
storeOpcodeSet(typeptr, codeSet, opcodeMap)
|
|
return codeSet, nil
|
|
}
|
|
|
|
func compileHead(ctx *compileContext) (*Opcode, error) {
|
|
typ := ctx.typ
|
|
switch {
|
|
case implementsMarshalJSON(typ):
|
|
return compileMarshalJSON(ctx)
|
|
case implementsMarshalText(typ):
|
|
return compileMarshalText(ctx)
|
|
}
|
|
|
|
isPtr := false
|
|
orgType := typ
|
|
if typ.Kind() == reflect.Ptr {
|
|
typ = typ.Elem()
|
|
isPtr = true
|
|
}
|
|
switch {
|
|
case implementsMarshalJSON(typ):
|
|
return compileMarshalJSON(ctx)
|
|
case implementsMarshalText(typ):
|
|
return compileMarshalText(ctx)
|
|
}
|
|
switch typ.Kind() {
|
|
case reflect.Slice:
|
|
ctx := ctx.withType(typ)
|
|
elem := typ.Elem()
|
|
if elem.Kind() == reflect.Uint8 {
|
|
p := runtime.PtrTo(elem)
|
|
if !implementsMarshalJSONType(p) && !p.Implements(marshalTextType) {
|
|
if isPtr {
|
|
return compileBytesPtr(ctx)
|
|
}
|
|
return compileBytes(ctx)
|
|
}
|
|
}
|
|
code, err := compileSlice(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
optimizeStructEnd(code)
|
|
linkRecursiveCode(code)
|
|
return code, nil
|
|
case reflect.Map:
|
|
if isPtr {
|
|
return compilePtr(ctx.withType(runtime.PtrTo(typ)))
|
|
}
|
|
code, err := compileMap(ctx.withType(typ))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
optimizeStructEnd(code)
|
|
linkRecursiveCode(code)
|
|
return code, nil
|
|
case reflect.Struct:
|
|
code, err := compileStruct(ctx.withType(typ), isPtr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
optimizeStructEnd(code)
|
|
linkRecursiveCode(code)
|
|
return code, nil
|
|
case reflect.Int:
|
|
ctx := ctx.withType(typ)
|
|
if isPtr {
|
|
return compileIntPtr(ctx)
|
|
}
|
|
return compileInt(ctx)
|
|
case reflect.Int8:
|
|
ctx := ctx.withType(typ)
|
|
if isPtr {
|
|
return compileInt8Ptr(ctx)
|
|
}
|
|
return compileInt8(ctx)
|
|
case reflect.Int16:
|
|
ctx := ctx.withType(typ)
|
|
if isPtr {
|
|
return compileInt16Ptr(ctx)
|
|
}
|
|
return compileInt16(ctx)
|
|
case reflect.Int32:
|
|
ctx := ctx.withType(typ)
|
|
if isPtr {
|
|
return compileInt32Ptr(ctx)
|
|
}
|
|
return compileInt32(ctx)
|
|
case reflect.Int64:
|
|
ctx := ctx.withType(typ)
|
|
if isPtr {
|
|
return compileInt64Ptr(ctx)
|
|
}
|
|
return compileInt64(ctx)
|
|
case reflect.Uint, reflect.Uintptr:
|
|
ctx := ctx.withType(typ)
|
|
if isPtr {
|
|
return compileUintPtr(ctx)
|
|
}
|
|
return compileUint(ctx)
|
|
case reflect.Uint8:
|
|
ctx := ctx.withType(typ)
|
|
if isPtr {
|
|
return compileUint8Ptr(ctx)
|
|
}
|
|
return compileUint8(ctx)
|
|
case reflect.Uint16:
|
|
ctx := ctx.withType(typ)
|
|
if isPtr {
|
|
return compileUint16Ptr(ctx)
|
|
}
|
|
return compileUint16(ctx)
|
|
case reflect.Uint32:
|
|
ctx := ctx.withType(typ)
|
|
if isPtr {
|
|
return compileUint32Ptr(ctx)
|
|
}
|
|
return compileUint32(ctx)
|
|
case reflect.Uint64:
|
|
ctx := ctx.withType(typ)
|
|
if isPtr {
|
|
return compileUint64Ptr(ctx)
|
|
}
|
|
return compileUint64(ctx)
|
|
case reflect.Float32:
|
|
ctx := ctx.withType(typ)
|
|
if isPtr {
|
|
return compileFloat32Ptr(ctx)
|
|
}
|
|
return compileFloat32(ctx)
|
|
case reflect.Float64:
|
|
ctx := ctx.withType(typ)
|
|
if isPtr {
|
|
return compileFloat64Ptr(ctx)
|
|
}
|
|
return compileFloat64(ctx)
|
|
case reflect.String:
|
|
ctx := ctx.withType(typ)
|
|
if isPtr {
|
|
return compileStringPtr(ctx)
|
|
}
|
|
return compileString(ctx)
|
|
case reflect.Bool:
|
|
ctx := ctx.withType(typ)
|
|
if isPtr {
|
|
return compileBoolPtr(ctx)
|
|
}
|
|
return compileBool(ctx)
|
|
case reflect.Interface:
|
|
ctx := ctx.withType(typ)
|
|
if isPtr {
|
|
return compileInterfacePtr(ctx)
|
|
}
|
|
return compileInterface(ctx)
|
|
default:
|
|
if isPtr && typ.Implements(marshalTextType) {
|
|
typ = orgType
|
|
}
|
|
code, err := compile(ctx.withType(typ), isPtr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
optimizeStructEnd(code)
|
|
linkRecursiveCode(code)
|
|
return code, nil
|
|
}
|
|
}
|
|
|
|
func linkRecursiveCode(c *Opcode) {
|
|
for code := c; code.Op != OpEnd && code.Op != OpRecursiveEnd; {
|
|
switch code.Op {
|
|
case OpRecursive, OpRecursivePtr:
|
|
if code.Jmp.Linked {
|
|
code = code.Next
|
|
continue
|
|
}
|
|
code.Jmp.Code = copyOpcode(code.Jmp.Code)
|
|
|
|
c := code.Jmp.Code
|
|
c.End.Next = newEndOp(&compileContext{})
|
|
c.Op = c.Op.PtrHeadToHead()
|
|
|
|
beforeLastCode := c.End
|
|
lastCode := beforeLastCode.Next
|
|
|
|
lastCode.Idx = beforeLastCode.Idx + uintptrSize
|
|
lastCode.ElemIdx = lastCode.Idx + uintptrSize
|
|
lastCode.Length = lastCode.Idx + 2*uintptrSize
|
|
|
|
// extend length to alloc slot for elemIdx + length
|
|
totalLength := uintptr(code.TotalLength() + 3)
|
|
nextTotalLength := uintptr(c.TotalLength() + 3)
|
|
|
|
c.End.Next.Op = OpRecursiveEnd
|
|
|
|
code.Jmp.CurLen = totalLength
|
|
code.Jmp.NextLen = nextTotalLength
|
|
code.Jmp.Linked = true
|
|
|
|
linkRecursiveCode(code.Jmp.Code)
|
|
|
|
code = code.Next
|
|
continue
|
|
}
|
|
switch code.Op.CodeType() {
|
|
case CodeArrayElem, CodeSliceElem, CodeMapKey:
|
|
code = code.End
|
|
default:
|
|
code = code.Next
|
|
}
|
|
}
|
|
}
|
|
|
|
func optimizeStructEnd(c *Opcode) {
|
|
for code := c; code.Op != OpEnd; {
|
|
if code.Op == OpRecursive || code.Op == OpRecursivePtr {
|
|
// ignore if exists recursive operation
|
|
return
|
|
}
|
|
switch code.Op.CodeType() {
|
|
case CodeArrayElem, CodeSliceElem, CodeMapKey:
|
|
code = code.End
|
|
default:
|
|
code = code.Next
|
|
}
|
|
}
|
|
|
|
for code := c; code.Op != OpEnd; {
|
|
switch code.Op.CodeType() {
|
|
case CodeArrayElem, CodeSliceElem, CodeMapKey:
|
|
code = code.End
|
|
case CodeStructEnd:
|
|
switch code.Op {
|
|
case OpStructEnd:
|
|
prev := code.PrevField
|
|
prevOp := prev.Op.String()
|
|
if strings.Contains(prevOp, "Head") ||
|
|
strings.Contains(prevOp, "Slice") ||
|
|
strings.Contains(prevOp, "Array") ||
|
|
strings.Contains(prevOp, "Map") ||
|
|
strings.Contains(prevOp, "MarshalJSON") ||
|
|
strings.Contains(prevOp, "MarshalText") {
|
|
// not exists field
|
|
code = code.Next
|
|
break
|
|
}
|
|
if prev.Op != prev.Op.FieldToEnd() {
|
|
prev.Op = prev.Op.FieldToEnd()
|
|
prev.Next = code.Next
|
|
}
|
|
code = code.Next
|
|
default:
|
|
code = code.Next
|
|
}
|
|
default:
|
|
code = code.Next
|
|
}
|
|
}
|
|
}
|
|
|
|
func implementsMarshalJSON(typ *runtime.Type) bool {
|
|
if !implementsMarshalJSONType(typ) {
|
|
return false
|
|
}
|
|
if typ.Kind() != reflect.Ptr {
|
|
return true
|
|
}
|
|
// type kind is reflect.Ptr
|
|
if !implementsMarshalJSONType(typ.Elem()) {
|
|
return true
|
|
}
|
|
// needs to dereference
|
|
return false
|
|
}
|
|
|
|
func implementsMarshalText(typ *runtime.Type) bool {
|
|
if !typ.Implements(marshalTextType) {
|
|
return false
|
|
}
|
|
if typ.Kind() != reflect.Ptr {
|
|
return true
|
|
}
|
|
// type kind is reflect.Ptr
|
|
if !typ.Elem().Implements(marshalTextType) {
|
|
return true
|
|
}
|
|
// needs to dereference
|
|
return false
|
|
}
|
|
|
|
func compile(ctx *compileContext, isPtr bool) (*Opcode, error) {
|
|
typ := ctx.typ
|
|
switch {
|
|
case implementsMarshalJSON(typ):
|
|
return compileMarshalJSON(ctx)
|
|
case implementsMarshalText(typ):
|
|
return compileMarshalText(ctx)
|
|
}
|
|
switch typ.Kind() {
|
|
case reflect.Ptr:
|
|
return compilePtr(ctx)
|
|
case reflect.Slice:
|
|
elem := typ.Elem()
|
|
if elem.Kind() == reflect.Uint8 {
|
|
p := runtime.PtrTo(elem)
|
|
if !implementsMarshalJSONType(p) && !p.Implements(marshalTextType) {
|
|
return compileBytes(ctx)
|
|
}
|
|
}
|
|
return compileSlice(ctx)
|
|
case reflect.Array:
|
|
return compileArray(ctx)
|
|
case reflect.Map:
|
|
return compileMap(ctx)
|
|
case reflect.Struct:
|
|
return compileStruct(ctx, isPtr)
|
|
case reflect.Interface:
|
|
return compileInterface(ctx)
|
|
case reflect.Int:
|
|
return compileInt(ctx)
|
|
case reflect.Int8:
|
|
return compileInt8(ctx)
|
|
case reflect.Int16:
|
|
return compileInt16(ctx)
|
|
case reflect.Int32:
|
|
return compileInt32(ctx)
|
|
case reflect.Int64:
|
|
return compileInt64(ctx)
|
|
case reflect.Uint:
|
|
return compileUint(ctx)
|
|
case reflect.Uint8:
|
|
return compileUint8(ctx)
|
|
case reflect.Uint16:
|
|
return compileUint16(ctx)
|
|
case reflect.Uint32:
|
|
return compileUint32(ctx)
|
|
case reflect.Uint64:
|
|
return compileUint64(ctx)
|
|
case reflect.Uintptr:
|
|
return compileUint(ctx)
|
|
case reflect.Float32:
|
|
return compileFloat32(ctx)
|
|
case reflect.Float64:
|
|
return compileFloat64(ctx)
|
|
case reflect.String:
|
|
return compileString(ctx)
|
|
case reflect.Bool:
|
|
return compileBool(ctx)
|
|
}
|
|
return nil, &errors.UnsupportedTypeError{Type: runtime.RType2Type(typ)}
|
|
}
|
|
|
|
func convertPtrOp(code *Opcode) OpType {
|
|
ptrHeadOp := code.Op.HeadToPtrHead()
|
|
if code.Op != ptrHeadOp {
|
|
if code.PtrNum > 0 {
|
|
// ptr field and ptr head
|
|
code.PtrNum--
|
|
}
|
|
return ptrHeadOp
|
|
}
|
|
switch code.Op {
|
|
case OpInt:
|
|
return OpIntPtr
|
|
case OpUint:
|
|
return OpUintPtr
|
|
case OpFloat32:
|
|
return OpFloat32Ptr
|
|
case OpFloat64:
|
|
return OpFloat64Ptr
|
|
case OpString:
|
|
return OpStringPtr
|
|
case OpBool:
|
|
return OpBoolPtr
|
|
case OpBytes:
|
|
return OpBytesPtr
|
|
case OpNumber:
|
|
return OpNumberPtr
|
|
case OpArray:
|
|
return OpArrayPtr
|
|
case OpSlice:
|
|
return OpSlicePtr
|
|
case OpMap:
|
|
return OpMapPtr
|
|
case OpMarshalJSON:
|
|
return OpMarshalJSONPtr
|
|
case OpMarshalText:
|
|
return OpMarshalTextPtr
|
|
case OpInterface:
|
|
return OpInterfacePtr
|
|
case OpRecursive:
|
|
return OpRecursivePtr
|
|
}
|
|
return code.Op
|
|
}
|
|
|
|
func compileKey(ctx *compileContext) (*Opcode, error) {
|
|
typ := ctx.typ
|
|
switch {
|
|
case implementsMarshalJSON(typ):
|
|
return compileMarshalJSON(ctx)
|
|
case implementsMarshalText(typ):
|
|
return compileMarshalText(ctx)
|
|
}
|
|
switch typ.Kind() {
|
|
case reflect.Ptr:
|
|
return compilePtr(ctx)
|
|
case reflect.String:
|
|
return compileString(ctx)
|
|
case reflect.Int:
|
|
return compileIntString(ctx)
|
|
case reflect.Int8:
|
|
return compileInt8String(ctx)
|
|
case reflect.Int16:
|
|
return compileInt16String(ctx)
|
|
case reflect.Int32:
|
|
return compileInt32String(ctx)
|
|
case reflect.Int64:
|
|
return compileInt64String(ctx)
|
|
case reflect.Uint:
|
|
return compileUintString(ctx)
|
|
case reflect.Uint8:
|
|
return compileUint8String(ctx)
|
|
case reflect.Uint16:
|
|
return compileUint16String(ctx)
|
|
case reflect.Uint32:
|
|
return compileUint32String(ctx)
|
|
case reflect.Uint64:
|
|
return compileUint64String(ctx)
|
|
case reflect.Uintptr:
|
|
return compileUintString(ctx)
|
|
}
|
|
return nil, &errors.UnsupportedTypeError{Type: runtime.RType2Type(typ)}
|
|
}
|
|
|
|
func compilePtr(ctx *compileContext) (*Opcode, error) {
|
|
code, err := compile(ctx.withType(ctx.typ.Elem()), true)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
code.Op = convertPtrOp(code)
|
|
code.PtrNum++
|
|
return code, nil
|
|
}
|
|
|
|
func compileMarshalJSON(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpMarshalJSON)
|
|
typ := ctx.typ
|
|
if isPtrMarshalJSONType(typ) {
|
|
code.Flags |= AddrForMarshalerFlags
|
|
}
|
|
if typ.Implements(marshalJSONContextType) || runtime.PtrTo(typ).Implements(marshalJSONContextType) {
|
|
code.Flags |= MarshalerContextFlags
|
|
}
|
|
if isNilableType(typ) {
|
|
code.Flags |= IsNilableTypeFlags
|
|
} else {
|
|
code.Flags &= ^IsNilableTypeFlags
|
|
}
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileMarshalText(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpMarshalText)
|
|
typ := ctx.typ
|
|
if !typ.Implements(marshalTextType) && runtime.PtrTo(typ).Implements(marshalTextType) {
|
|
code.Flags |= AddrForMarshalerFlags
|
|
}
|
|
if isNilableType(typ) {
|
|
code.Flags |= IsNilableTypeFlags
|
|
} else {
|
|
code.Flags &= ^IsNilableTypeFlags
|
|
}
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
const intSize = 32 << (^uint(0) >> 63)
|
|
|
|
func compileInt(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpInt)
|
|
code.NumBitSize = intSize
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileIntPtr(ctx *compileContext) (*Opcode, error) {
|
|
code, err := compileInt(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
code.Op = OpIntPtr
|
|
return code, nil
|
|
}
|
|
|
|
func compileInt8(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpInt)
|
|
code.NumBitSize = 8
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileInt8Ptr(ctx *compileContext) (*Opcode, error) {
|
|
code, err := compileInt8(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
code.Op = OpIntPtr
|
|
return code, nil
|
|
}
|
|
|
|
func compileInt16(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpInt)
|
|
code.NumBitSize = 16
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileInt16Ptr(ctx *compileContext) (*Opcode, error) {
|
|
code, err := compileInt16(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
code.Op = OpIntPtr
|
|
return code, nil
|
|
}
|
|
|
|
func compileInt32(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpInt)
|
|
code.NumBitSize = 32
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileInt32Ptr(ctx *compileContext) (*Opcode, error) {
|
|
code, err := compileInt32(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
code.Op = OpIntPtr
|
|
return code, nil
|
|
}
|
|
|
|
func compileInt64(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpInt)
|
|
code.NumBitSize = 64
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileInt64Ptr(ctx *compileContext) (*Opcode, error) {
|
|
code, err := compileInt64(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
code.Op = OpIntPtr
|
|
return code, nil
|
|
}
|
|
|
|
func compileUint(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpUint)
|
|
code.NumBitSize = intSize
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileUintPtr(ctx *compileContext) (*Opcode, error) {
|
|
code, err := compileUint(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
code.Op = OpUintPtr
|
|
return code, nil
|
|
}
|
|
|
|
func compileUint8(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpUint)
|
|
code.NumBitSize = 8
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileUint8Ptr(ctx *compileContext) (*Opcode, error) {
|
|
code, err := compileUint8(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
code.Op = OpUintPtr
|
|
return code, nil
|
|
}
|
|
|
|
func compileUint16(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpUint)
|
|
code.NumBitSize = 16
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileUint16Ptr(ctx *compileContext) (*Opcode, error) {
|
|
code, err := compileUint16(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
code.Op = OpUintPtr
|
|
return code, nil
|
|
}
|
|
|
|
func compileUint32(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpUint)
|
|
code.NumBitSize = 32
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileUint32Ptr(ctx *compileContext) (*Opcode, error) {
|
|
code, err := compileUint32(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
code.Op = OpUintPtr
|
|
return code, nil
|
|
}
|
|
|
|
func compileUint64(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpUint)
|
|
code.NumBitSize = 64
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileUint64Ptr(ctx *compileContext) (*Opcode, error) {
|
|
code, err := compileUint64(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
code.Op = OpUintPtr
|
|
return code, nil
|
|
}
|
|
|
|
func compileIntString(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpIntString)
|
|
code.NumBitSize = intSize
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileInt8String(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpIntString)
|
|
code.NumBitSize = 8
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileInt16String(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpIntString)
|
|
code.NumBitSize = 16
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileInt32String(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpIntString)
|
|
code.NumBitSize = 32
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileInt64String(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpIntString)
|
|
code.NumBitSize = 64
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileUintString(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpUintString)
|
|
code.NumBitSize = intSize
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileUint8String(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpUintString)
|
|
code.NumBitSize = 8
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileUint16String(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpUintString)
|
|
code.NumBitSize = 16
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileUint32String(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpUintString)
|
|
code.NumBitSize = 32
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileUint64String(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpUintString)
|
|
code.NumBitSize = 64
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileFloat32(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpFloat32)
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileFloat32Ptr(ctx *compileContext) (*Opcode, error) {
|
|
code, err := compileFloat32(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
code.Op = OpFloat32Ptr
|
|
return code, nil
|
|
}
|
|
|
|
func compileFloat64(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpFloat64)
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileFloat64Ptr(ctx *compileContext) (*Opcode, error) {
|
|
code, err := compileFloat64(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
code.Op = OpFloat64Ptr
|
|
return code, nil
|
|
}
|
|
|
|
func compileString(ctx *compileContext) (*Opcode, error) {
|
|
var op OpType
|
|
if ctx.typ == runtime.Type2RType(jsonNumberType) {
|
|
op = OpNumber
|
|
} else {
|
|
op = OpString
|
|
}
|
|
code := newOpCode(ctx, op)
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileStringPtr(ctx *compileContext) (*Opcode, error) {
|
|
code, err := compileString(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if code.Op == OpNumber {
|
|
code.Op = OpNumberPtr
|
|
} else {
|
|
code.Op = OpStringPtr
|
|
}
|
|
return code, nil
|
|
}
|
|
|
|
func compileBool(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpBool)
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileBoolPtr(ctx *compileContext) (*Opcode, error) {
|
|
code, err := compileBool(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
code.Op = OpBoolPtr
|
|
return code, nil
|
|
}
|
|
|
|
func compileBytes(ctx *compileContext) (*Opcode, error) {
|
|
code := newOpCode(ctx, OpBytes)
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileBytesPtr(ctx *compileContext) (*Opcode, error) {
|
|
code, err := compileBytes(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
code.Op = OpBytesPtr
|
|
return code, nil
|
|
}
|
|
|
|
func compileInterface(ctx *compileContext) (*Opcode, error) {
|
|
code := newInterfaceCode(ctx)
|
|
ctx.incIndex()
|
|
return code, nil
|
|
}
|
|
|
|
func compileInterfacePtr(ctx *compileContext) (*Opcode, error) {
|
|
code, err := compileInterface(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
code.Op = OpInterfacePtr
|
|
return code, nil
|
|
}
|
|
|
|
func compileSlice(ctx *compileContext) (*Opcode, error) {
|
|
elem := ctx.typ.Elem()
|
|
size := elem.Size()
|
|
|
|
header := newSliceHeaderCode(ctx)
|
|
ctx.incIndex()
|
|
|
|
code, err := compileListElem(ctx.withType(elem).incIndent())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
code.Flags |= IndirectFlags
|
|
|
|
// header => opcode => elem => end
|
|
// ^ |
|
|
// |________|
|
|
|
|
elemCode := newSliceElemCode(ctx, header, size)
|
|
ctx.incIndex()
|
|
|
|
end := newOpCode(ctx, OpSliceEnd)
|
|
ctx.incIndex()
|
|
|
|
header.End = end
|
|
header.Next = code
|
|
code.BeforeLastCode().Next = (*Opcode)(unsafe.Pointer(elemCode))
|
|
elemCode.Next = code
|
|
elemCode.End = end
|
|
return (*Opcode)(unsafe.Pointer(header)), nil
|
|
}
|
|
|
|
func compileListElem(ctx *compileContext) (*Opcode, error) {
|
|
typ := ctx.typ
|
|
switch {
|
|
case isPtrMarshalJSONType(typ):
|
|
return compileMarshalJSON(ctx)
|
|
case !typ.Implements(marshalTextType) && runtime.PtrTo(typ).Implements(marshalTextType):
|
|
return compileMarshalText(ctx)
|
|
case typ.Kind() == reflect.Map:
|
|
return compilePtr(ctx.withType(runtime.PtrTo(typ)))
|
|
default:
|
|
code, err := compile(ctx, false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if code.Op == OpMapPtr {
|
|
code.PtrNum++
|
|
}
|
|
return code, nil
|
|
}
|
|
}
|
|
|
|
func compileArray(ctx *compileContext) (*Opcode, error) {
|
|
typ := ctx.typ
|
|
elem := typ.Elem()
|
|
alen := typ.Len()
|
|
size := elem.Size()
|
|
|
|
header := newArrayHeaderCode(ctx, alen)
|
|
ctx.incIndex()
|
|
|
|
code, err := compileListElem(ctx.withType(elem).incIndent())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
code.Flags |= IndirectFlags
|
|
// header => opcode => elem => end
|
|
// ^ |
|
|
// |________|
|
|
|
|
elemCode := newArrayElemCode(ctx, header, alen, size)
|
|
ctx.incIndex()
|
|
|
|
end := newOpCode(ctx, OpArrayEnd)
|
|
ctx.incIndex()
|
|
|
|
header.End = end
|
|
header.Next = code
|
|
code.BeforeLastCode().Next = (*Opcode)(unsafe.Pointer(elemCode))
|
|
elemCode.Next = code
|
|
elemCode.End = end
|
|
return (*Opcode)(unsafe.Pointer(header)), nil
|
|
}
|
|
|
|
func compileMap(ctx *compileContext) (*Opcode, error) {
|
|
// header => code => value => code => key => code => value => code => end
|
|
// ^ |
|
|
// |_______________________|
|
|
ctx = ctx.incIndent()
|
|
header := newMapHeaderCode(ctx)
|
|
ctx.incIndex()
|
|
|
|
typ := ctx.typ
|
|
keyType := ctx.typ.Key()
|
|
keyCode, err := compileKey(ctx.withType(keyType))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
value := newMapValueCode(ctx, header)
|
|
ctx.incIndex()
|
|
|
|
valueCode, err := compileMapValue(ctx.withType(typ.Elem()))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
valueCode.Flags |= IndirectFlags
|
|
|
|
key := newMapKeyCode(ctx, header)
|
|
ctx.incIndex()
|
|
|
|
ctx = ctx.decIndent()
|
|
|
|
end := newMapEndCode(ctx, header)
|
|
ctx.incIndex()
|
|
|
|
header.Next = keyCode
|
|
keyCode.BeforeLastCode().Next = (*Opcode)(unsafe.Pointer(value))
|
|
value.Next = valueCode
|
|
valueCode.BeforeLastCode().Next = (*Opcode)(unsafe.Pointer(key))
|
|
key.Next = keyCode
|
|
|
|
header.End = end
|
|
key.End = end
|
|
value.End = end
|
|
|
|
return (*Opcode)(unsafe.Pointer(header)), nil
|
|
}
|
|
|
|
func compileMapValue(ctx *compileContext) (*Opcode, error) {
|
|
switch ctx.typ.Kind() {
|
|
case reflect.Map:
|
|
return compilePtr(ctx.withType(runtime.PtrTo(ctx.typ)))
|
|
default:
|
|
code, err := compile(ctx, false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if code.Op == OpMapPtr {
|
|
code.PtrNum++
|
|
}
|
|
return code, nil
|
|
}
|
|
}
|
|
|
|
func optimizeStructHeader(code *Opcode, tag *runtime.StructTag) OpType {
|
|
headType := code.ToHeaderType(tag.IsString)
|
|
if tag.IsOmitEmpty {
|
|
headType = headType.HeadToOmitEmptyHead()
|
|
}
|
|
return headType
|
|
}
|
|
|
|
func optimizeStructField(code *Opcode, tag *runtime.StructTag) OpType {
|
|
fieldType := code.ToFieldType(tag.IsString)
|
|
if tag.IsOmitEmpty {
|
|
fieldType = fieldType.FieldToOmitEmptyField()
|
|
}
|
|
return fieldType
|
|
}
|
|
|
|
func recursiveCode(ctx *compileContext, jmp *CompiledCode) *Opcode {
|
|
code := newRecursiveCode(ctx, jmp)
|
|
ctx.incIndex()
|
|
return code
|
|
}
|
|
|
|
func compiledCode(ctx *compileContext) *Opcode {
|
|
typ := ctx.typ
|
|
typeptr := uintptr(unsafe.Pointer(typ))
|
|
if cc, exists := ctx.structTypeToCompiledCode[typeptr]; exists {
|
|
return recursiveCode(ctx, cc)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func structHeader(ctx *compileContext, fieldCode *Opcode, valueCode *Opcode, tag *runtime.StructTag) *Opcode {
|
|
op := optimizeStructHeader(valueCode, tag)
|
|
fieldCode.Op = op
|
|
fieldCode.NumBitSize = valueCode.NumBitSize
|
|
fieldCode.PtrNum = valueCode.PtrNum
|
|
if op.IsMultipleOpHead() {
|
|
return valueCode.BeforeLastCode()
|
|
}
|
|
ctx.decOpcodeIndex()
|
|
return fieldCode
|
|
}
|
|
|
|
func structField(ctx *compileContext, fieldCode *Opcode, valueCode *Opcode, tag *runtime.StructTag) *Opcode {
|
|
op := optimizeStructField(valueCode, tag)
|
|
fieldCode.Op = op
|
|
fieldCode.NumBitSize = valueCode.NumBitSize
|
|
fieldCode.PtrNum = valueCode.PtrNum
|
|
if op.IsMultipleOpField() {
|
|
return valueCode.BeforeLastCode()
|
|
}
|
|
ctx.decIndex()
|
|
return fieldCode
|
|
}
|
|
|
|
func isNotExistsField(head *Opcode) bool {
|
|
if head == nil {
|
|
return false
|
|
}
|
|
if head.Op != OpStructHead {
|
|
return false
|
|
}
|
|
if (head.Flags & AnonymousHeadFlags) == 0 {
|
|
return false
|
|
}
|
|
if head.Next == nil {
|
|
return false
|
|
}
|
|
if head.NextField == nil {
|
|
return false
|
|
}
|
|
if head.NextField.Op != OpStructAnonymousEnd {
|
|
return false
|
|
}
|
|
if head.Next.Op == OpStructAnonymousEnd {
|
|
return true
|
|
}
|
|
if head.Next.Op.CodeType() != CodeStructField {
|
|
return false
|
|
}
|
|
return isNotExistsField(head.Next)
|
|
}
|
|
|
|
func optimizeAnonymousFields(head *Opcode) {
|
|
code := head
|
|
var prev *Opcode
|
|
removedFields := map[*Opcode]struct{}{}
|
|
for {
|
|
if code.Op == OpStructEnd {
|
|
break
|
|
}
|
|
if code.Op == OpStructField {
|
|
codeType := code.Next.Op.CodeType()
|
|
if codeType == CodeStructField {
|
|
if isNotExistsField(code.Next) {
|
|
code.Next = code.NextField
|
|
diff := code.Next.DisplayIdx - code.DisplayIdx
|
|
for i := uint32(0); i < diff; i++ {
|
|
code.Next.decOpcodeIndex()
|
|
}
|
|
linkPrevToNextField(code, removedFields)
|
|
code = prev
|
|
}
|
|
}
|
|
}
|
|
prev = code
|
|
code = code.NextField
|
|
}
|
|
}
|
|
|
|
type structFieldPair struct {
|
|
prevField *Opcode
|
|
curField *Opcode
|
|
isTaggedKey bool
|
|
linked bool
|
|
}
|
|
|
|
func anonymousStructFieldPairMap(tags runtime.StructTags, named string, valueCode *Opcode) map[string][]structFieldPair {
|
|
anonymousFields := map[string][]structFieldPair{}
|
|
f := valueCode
|
|
var prevAnonymousField *Opcode
|
|
removedFields := map[*Opcode]struct{}{}
|
|
for {
|
|
existsKey := tags.ExistsKey(f.DisplayKey)
|
|
isHeadOp := strings.Contains(f.Op.String(), "Head")
|
|
if existsKey && f.Next != nil && strings.Contains(f.Next.Op.String(), "Recursive") {
|
|
// through
|
|
} else if isHeadOp && (f.Flags&AnonymousHeadFlags) == 0 {
|
|
if existsKey {
|
|
// TODO: need to remove this head
|
|
f.Op = OpStructHead
|
|
f.Flags |= AnonymousKeyFlags
|
|
f.Flags |= AnonymousHeadFlags
|
|
} else if named == "" {
|
|
f.Flags |= AnonymousHeadFlags
|
|
}
|
|
} else if named == "" && f.Op == OpStructEnd {
|
|
f.Op = OpStructAnonymousEnd
|
|
} else if existsKey {
|
|
diff := f.NextField.DisplayIdx - f.DisplayIdx
|
|
for i := uint32(0); i < diff; i++ {
|
|
f.NextField.decOpcodeIndex()
|
|
}
|
|
linkPrevToNextField(f, removedFields)
|
|
}
|
|
|
|
if f.DisplayKey == "" {
|
|
if f.NextField == nil {
|
|
break
|
|
}
|
|
prevAnonymousField = f
|
|
f = f.NextField
|
|
continue
|
|
}
|
|
|
|
key := fmt.Sprintf("%s.%s", named, f.DisplayKey)
|
|
anonymousFields[key] = append(anonymousFields[key], structFieldPair{
|
|
prevField: prevAnonymousField,
|
|
curField: f,
|
|
isTaggedKey: (f.Flags & IsTaggedKeyFlags) != 0,
|
|
})
|
|
if f.Next != nil && f.NextField != f.Next && f.Next.Op.CodeType() == CodeStructField {
|
|
for k, v := range anonymousFieldPairRecursively(named, f.Next) {
|
|
anonymousFields[k] = append(anonymousFields[k], v...)
|
|
}
|
|
}
|
|
if f.NextField == nil {
|
|
break
|
|
}
|
|
prevAnonymousField = f
|
|
f = f.NextField
|
|
}
|
|
return anonymousFields
|
|
}
|
|
|
|
func anonymousFieldPairRecursively(named string, valueCode *Opcode) map[string][]structFieldPair {
|
|
anonymousFields := map[string][]structFieldPair{}
|
|
f := valueCode
|
|
var prevAnonymousField *Opcode
|
|
for {
|
|
if f.DisplayKey != "" && (f.Flags&AnonymousHeadFlags) != 0 {
|
|
key := fmt.Sprintf("%s.%s", named, f.DisplayKey)
|
|
anonymousFields[key] = append(anonymousFields[key], structFieldPair{
|
|
prevField: prevAnonymousField,
|
|
curField: f,
|
|
isTaggedKey: (f.Flags & IsTaggedKeyFlags) != 0,
|
|
})
|
|
if f.Next != nil && f.NextField != f.Next && f.Next.Op.CodeType() == CodeStructField {
|
|
for k, v := range anonymousFieldPairRecursively(named, f.Next) {
|
|
anonymousFields[k] = append(anonymousFields[k], v...)
|
|
}
|
|
}
|
|
}
|
|
if f.NextField == nil {
|
|
break
|
|
}
|
|
prevAnonymousField = f
|
|
f = f.NextField
|
|
}
|
|
return anonymousFields
|
|
}
|
|
|
|
func optimizeConflictAnonymousFields(anonymousFields map[string][]structFieldPair) {
|
|
removedFields := map[*Opcode]struct{}{}
|
|
for _, fieldPairs := range anonymousFields {
|
|
if len(fieldPairs) == 1 {
|
|
continue
|
|
}
|
|
// conflict anonymous fields
|
|
taggedPairs := []structFieldPair{}
|
|
for _, fieldPair := range fieldPairs {
|
|
if fieldPair.isTaggedKey {
|
|
taggedPairs = append(taggedPairs, fieldPair)
|
|
} else {
|
|
if !fieldPair.linked {
|
|
if fieldPair.prevField == nil {
|
|
// head operation
|
|
fieldPair.curField.Op = OpStructHead
|
|
fieldPair.curField.Flags |= AnonymousHeadFlags
|
|
fieldPair.curField.Flags |= AnonymousKeyFlags
|
|
} else {
|
|
diff := fieldPair.curField.NextField.DisplayIdx - fieldPair.curField.DisplayIdx
|
|
for i := uint32(0); i < diff; i++ {
|
|
fieldPair.curField.NextField.decOpcodeIndex()
|
|
}
|
|
removedFields[fieldPair.curField] = struct{}{}
|
|
linkPrevToNextField(fieldPair.curField, removedFields)
|
|
}
|
|
fieldPair.linked = true
|
|
}
|
|
}
|
|
}
|
|
if len(taggedPairs) > 1 {
|
|
for _, fieldPair := range taggedPairs {
|
|
if !fieldPair.linked {
|
|
if fieldPair.prevField == nil {
|
|
// head operation
|
|
fieldPair.curField.Op = OpStructHead
|
|
fieldPair.curField.Flags |= AnonymousHeadFlags
|
|
fieldPair.curField.Flags |= AnonymousKeyFlags
|
|
} else {
|
|
diff := fieldPair.curField.NextField.DisplayIdx - fieldPair.curField.DisplayIdx
|
|
removedFields[fieldPair.curField] = struct{}{}
|
|
for i := uint32(0); i < diff; i++ {
|
|
fieldPair.curField.NextField.decOpcodeIndex()
|
|
}
|
|
linkPrevToNextField(fieldPair.curField, removedFields)
|
|
}
|
|
fieldPair.linked = true
|
|
}
|
|
}
|
|
} else {
|
|
for _, fieldPair := range taggedPairs {
|
|
fieldPair.curField.Flags &= ^IsTaggedKeyFlags
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func isNilableType(typ *runtime.Type) bool {
|
|
switch typ.Kind() {
|
|
case reflect.Ptr:
|
|
return true
|
|
case reflect.Map:
|
|
return true
|
|
case reflect.Func:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func compileStruct(ctx *compileContext, isPtr bool) (*Opcode, error) {
|
|
if code := compiledCode(ctx); code != nil {
|
|
return code, nil
|
|
}
|
|
typ := ctx.typ
|
|
typeptr := uintptr(unsafe.Pointer(typ))
|
|
compiled := &CompiledCode{}
|
|
ctx.structTypeToCompiledCode[typeptr] = compiled
|
|
// header => code => structField => code => end
|
|
// ^ |
|
|
// |__________|
|
|
fieldNum := typ.NumField()
|
|
indirect := runtime.IfaceIndir(typ)
|
|
fieldIdx := 0
|
|
disableIndirectConversion := false
|
|
var (
|
|
head *Opcode
|
|
code *Opcode
|
|
prevField *Opcode
|
|
)
|
|
ctx = ctx.incIndent()
|
|
tags := runtime.StructTags{}
|
|
anonymousFields := map[string][]structFieldPair{}
|
|
for i := 0; i < fieldNum; i++ {
|
|
field := typ.Field(i)
|
|
if runtime.IsIgnoredStructField(field) {
|
|
continue
|
|
}
|
|
tags = append(tags, runtime.StructTagFromField(field))
|
|
}
|
|
for i, tag := range tags {
|
|
field := tag.Field
|
|
fieldType := runtime.Type2RType(field.Type)
|
|
fieldOpcodeIndex := ctx.opcodeIndex
|
|
fieldPtrIndex := ctx.ptrIndex
|
|
ctx.incIndex()
|
|
|
|
nilcheck := true
|
|
addrForMarshaler := false
|
|
isIndirectSpecialCase := isPtr && i == 0 && fieldNum == 1
|
|
isNilableType := isNilableType(fieldType)
|
|
|
|
var valueCode *Opcode
|
|
switch {
|
|
case isIndirectSpecialCase && !isNilableType && isPtrMarshalJSONType(fieldType):
|
|
// *struct{ field T } => struct { field *T }
|
|
// func (*T) MarshalJSON() ([]byte, error)
|
|
// move pointer position from head to first field
|
|
code, err := compileMarshalJSON(ctx.withType(fieldType))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
addrForMarshaler = true
|
|
valueCode = code
|
|
nilcheck = false
|
|
indirect = false
|
|
disableIndirectConversion = true
|
|
case isIndirectSpecialCase && !isNilableType && isPtrMarshalTextType(fieldType):
|
|
// *struct{ field T } => struct { field *T }
|
|
// func (*T) MarshalText() ([]byte, error)
|
|
// move pointer position from head to first field
|
|
code, err := compileMarshalText(ctx.withType(fieldType))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
addrForMarshaler = true
|
|
valueCode = code
|
|
nilcheck = false
|
|
indirect = false
|
|
disableIndirectConversion = true
|
|
case isPtr && isPtrMarshalJSONType(fieldType):
|
|
// *struct{ field T }
|
|
// func (*T) MarshalJSON() ([]byte, error)
|
|
code, err := compileMarshalJSON(ctx.withType(fieldType))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
addrForMarshaler = true
|
|
nilcheck = false
|
|
valueCode = code
|
|
case isPtr && isPtrMarshalTextType(fieldType):
|
|
// *struct{ field T }
|
|
// func (*T) MarshalText() ([]byte, error)
|
|
code, err := compileMarshalText(ctx.withType(fieldType))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
addrForMarshaler = true
|
|
nilcheck = false
|
|
valueCode = code
|
|
default:
|
|
code, err := compile(ctx.withType(fieldType), isPtr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
valueCode = code
|
|
}
|
|
|
|
if field.Anonymous && !tag.IsTaggedKey {
|
|
tagKey := ""
|
|
if tag.IsTaggedKey {
|
|
tagKey = tag.Key
|
|
}
|
|
for k, v := range anonymousStructFieldPairMap(tags, tagKey, valueCode) {
|
|
anonymousFields[k] = append(anonymousFields[k], v...)
|
|
}
|
|
|
|
valueCode.decIndent()
|
|
|
|
// fix issue144
|
|
if !(isPtr && strings.Contains(valueCode.Op.String(), "Marshal")) {
|
|
if indirect {
|
|
valueCode.Flags |= IndirectFlags
|
|
} else {
|
|
valueCode.Flags &= ^IndirectFlags
|
|
}
|
|
}
|
|
} else {
|
|
if indirect {
|
|
// if parent is indirect type, set child indirect property to true
|
|
valueCode.Flags |= IndirectFlags
|
|
} else {
|
|
// if parent is not indirect type, set child indirect property to false.
|
|
// but if parent's indirect is false and isPtr is true, then indirect must be true.
|
|
// Do this only if indirectConversion is enabled at the end of compileStruct.
|
|
if i == 0 {
|
|
valueCode.Flags &= ^IndirectFlags
|
|
}
|
|
}
|
|
}
|
|
var flags OpFlags
|
|
if indirect {
|
|
flags |= IndirectFlags
|
|
}
|
|
if field.Anonymous {
|
|
flags |= AnonymousKeyFlags
|
|
}
|
|
if tag.IsTaggedKey {
|
|
flags |= IsTaggedKeyFlags
|
|
}
|
|
if nilcheck {
|
|
flags |= NilCheckFlags
|
|
}
|
|
if addrForMarshaler {
|
|
flags |= AddrForMarshalerFlags
|
|
}
|
|
if strings.Contains(valueCode.Op.String(), "Ptr") || valueCode.Op == OpInterface {
|
|
flags |= IsNextOpPtrTypeFlags
|
|
}
|
|
if isNilableType {
|
|
flags |= IsNilableTypeFlags
|
|
}
|
|
var key string
|
|
if ctx.escapeKey {
|
|
rctx := &RuntimeContext{Option: &Option{Flag: HTMLEscapeOption}}
|
|
key = fmt.Sprintf(`%s:`, string(AppendString(rctx, []byte{}, tag.Key)))
|
|
} else {
|
|
key = fmt.Sprintf(`"%s":`, tag.Key)
|
|
}
|
|
fieldCode := &Opcode{
|
|
Idx: opcodeOffset(fieldPtrIndex),
|
|
Next: valueCode,
|
|
Flags: flags,
|
|
Key: key,
|
|
Offset: uint32(field.Offset),
|
|
Type: valueCode.Type,
|
|
DisplayIdx: fieldOpcodeIndex,
|
|
Indent: ctx.indent,
|
|
DisplayKey: tag.Key,
|
|
}
|
|
if fieldIdx == 0 {
|
|
code = structHeader(ctx, fieldCode, valueCode, tag)
|
|
head = fieldCode
|
|
prevField = fieldCode
|
|
} else {
|
|
fieldCode.Idx = head.Idx
|
|
code.Next = fieldCode
|
|
code = structField(ctx, fieldCode, valueCode, tag)
|
|
prevField.NextField = fieldCode
|
|
fieldCode.PrevField = prevField
|
|
prevField = fieldCode
|
|
}
|
|
fieldIdx++
|
|
}
|
|
|
|
structEndCode := &Opcode{
|
|
Op: OpStructEnd,
|
|
Next: newEndOp(ctx),
|
|
Type: nil,
|
|
Indent: ctx.indent,
|
|
}
|
|
|
|
ctx = ctx.decIndent()
|
|
|
|
// no struct field
|
|
if head == nil {
|
|
head = &Opcode{
|
|
Op: OpStructHead,
|
|
Idx: opcodeOffset(ctx.ptrIndex),
|
|
NextField: structEndCode,
|
|
Type: typ,
|
|
DisplayIdx: ctx.opcodeIndex,
|
|
Indent: ctx.indent,
|
|
}
|
|
structEndCode.PrevField = head
|
|
ctx.incIndex()
|
|
code = head
|
|
}
|
|
|
|
structEndCode.DisplayIdx = ctx.opcodeIndex
|
|
structEndCode.Idx = opcodeOffset(ctx.ptrIndex)
|
|
ctx.incIndex()
|
|
|
|
if prevField != nil && prevField.NextField == nil {
|
|
prevField.NextField = structEndCode
|
|
structEndCode.PrevField = prevField
|
|
}
|
|
|
|
head.End = structEndCode
|
|
code.Next = structEndCode
|
|
optimizeConflictAnonymousFields(anonymousFields)
|
|
optimizeAnonymousFields(head)
|
|
ret := (*Opcode)(unsafe.Pointer(head))
|
|
compiled.Code = ret
|
|
|
|
delete(ctx.structTypeToCompiledCode, typeptr)
|
|
|
|
if !disableIndirectConversion && (head.Flags&IndirectFlags == 0) && isPtr {
|
|
headCode := head
|
|
for strings.Contains(headCode.Op.String(), "Head") {
|
|
headCode.Flags |= IndirectFlags
|
|
headCode = headCode.Next
|
|
}
|
|
}
|
|
|
|
return ret, nil
|
|
}
|
|
|
|
func implementsMarshalJSONType(typ *runtime.Type) bool {
|
|
return typ.Implements(marshalJSONType) || typ.Implements(marshalJSONContextType)
|
|
}
|
|
|
|
func isPtrMarshalJSONType(typ *runtime.Type) bool {
|
|
return !implementsMarshalJSONType(typ) && implementsMarshalJSONType(runtime.PtrTo(typ))
|
|
}
|
|
|
|
func isPtrMarshalTextType(typ *runtime.Type) bool {
|
|
return !typ.Implements(marshalTextType) && runtime.PtrTo(typ).Implements(marshalTextType)
|
|
}
|