package encoder import ( "fmt" "reflect" "unsafe" "github.com/goccy/go-json/internal/runtime" ) type Code interface { Kind() CodeKind ToOpcode(*compileContext) Opcodes Filter(*FieldQuery) Code } type AnonymousCode interface { ToAnonymousOpcode(*compileContext) Opcodes } type Opcodes []*Opcode func (o Opcodes) First() *Opcode { if len(o) == 0 { return nil } return o[0] } func (o Opcodes) Last() *Opcode { if len(o) == 0 { return nil } return o[len(o)-1] } func (o Opcodes) Add(codes ...*Opcode) Opcodes { return append(o, codes...) } type CodeKind int const ( CodeKindInterface CodeKind = iota CodeKindPtr CodeKindInt CodeKindUint CodeKindFloat CodeKindString CodeKindBool CodeKindStruct CodeKindMap CodeKindSlice CodeKindArray CodeKindBytes CodeKindMarshalJSON CodeKindMarshalText CodeKindRecursive ) type IntCode struct { typ *runtime.Type bitSize uint8 isString bool isPtr bool } func (c *IntCode) Kind() CodeKind { return CodeKindInt } func (c *IntCode) ToOpcode(ctx *compileContext) Opcodes { var code *Opcode switch { case c.isPtr: code = newOpCode(ctx, c.typ, OpIntPtr) case c.isString: code = newOpCode(ctx, c.typ, OpIntString) default: code = newOpCode(ctx, c.typ, OpInt) } code.NumBitSize = c.bitSize ctx.incIndex() return Opcodes{code} } func (c *IntCode) Filter(_ *FieldQuery) Code { return c } type UintCode struct { typ *runtime.Type bitSize uint8 isString bool isPtr bool } func (c *UintCode) Kind() CodeKind { return CodeKindUint } func (c *UintCode) ToOpcode(ctx *compileContext) Opcodes { var code *Opcode switch { case c.isPtr: code = newOpCode(ctx, c.typ, OpUintPtr) case c.isString: code = newOpCode(ctx, c.typ, OpUintString) default: code = newOpCode(ctx, c.typ, OpUint) } code.NumBitSize = c.bitSize ctx.incIndex() return Opcodes{code} } func (c *UintCode) Filter(_ *FieldQuery) Code { return c } type FloatCode struct { typ *runtime.Type bitSize uint8 isPtr bool } func (c *FloatCode) Kind() CodeKind { return CodeKindFloat } func (c *FloatCode) ToOpcode(ctx *compileContext) Opcodes { var code *Opcode switch { case c.isPtr: switch c.bitSize { case 32: code = newOpCode(ctx, c.typ, OpFloat32Ptr) default: code = newOpCode(ctx, c.typ, OpFloat64Ptr) } default: switch c.bitSize { case 32: code = newOpCode(ctx, c.typ, OpFloat32) default: code = newOpCode(ctx, c.typ, OpFloat64) } } ctx.incIndex() return Opcodes{code} } func (c *FloatCode) Filter(_ *FieldQuery) Code { return c } type StringCode struct { typ *runtime.Type isPtr bool } func (c *StringCode) Kind() CodeKind { return CodeKindString } func (c *StringCode) ToOpcode(ctx *compileContext) Opcodes { isJSONNumberType := c.typ == runtime.Type2RType(jsonNumberType) var code *Opcode if c.isPtr { if isJSONNumberType { code = newOpCode(ctx, c.typ, OpNumberPtr) } else { code = newOpCode(ctx, c.typ, OpStringPtr) } } else { if isJSONNumberType { code = newOpCode(ctx, c.typ, OpNumber) } else { code = newOpCode(ctx, c.typ, OpString) } } ctx.incIndex() return Opcodes{code} } func (c *StringCode) Filter(_ *FieldQuery) Code { return c } type BoolCode struct { typ *runtime.Type isPtr bool } func (c *BoolCode) Kind() CodeKind { return CodeKindBool } func (c *BoolCode) ToOpcode(ctx *compileContext) Opcodes { var code *Opcode switch { case c.isPtr: code = newOpCode(ctx, c.typ, OpBoolPtr) default: code = newOpCode(ctx, c.typ, OpBool) } ctx.incIndex() return Opcodes{code} } func (c *BoolCode) Filter(_ *FieldQuery) Code { return c } type BytesCode struct { typ *runtime.Type isPtr bool } func (c *BytesCode) Kind() CodeKind { return CodeKindBytes } func (c *BytesCode) ToOpcode(ctx *compileContext) Opcodes { var code *Opcode switch { case c.isPtr: code = newOpCode(ctx, c.typ, OpBytesPtr) default: code = newOpCode(ctx, c.typ, OpBytes) } ctx.incIndex() return Opcodes{code} } func (c *BytesCode) Filter(_ *FieldQuery) Code { return c } type SliceCode struct { typ *runtime.Type value Code } func (c *SliceCode) Kind() CodeKind { return CodeKindSlice } func (c *SliceCode) ToOpcode(ctx *compileContext) Opcodes { // header => opcode => elem => end // ^ | // |________| size := c.typ.Elem().Size() header := newSliceHeaderCode(ctx, c.typ) ctx.incIndex() ctx.incIndent() codes := c.value.ToOpcode(ctx) ctx.decIndent() codes.First().Flags |= IndirectFlags elemCode := newSliceElemCode(ctx, c.typ.Elem(), header, size) ctx.incIndex() end := newOpCode(ctx, c.typ, OpSliceEnd) ctx.incIndex() header.End = end header.Next = codes.First() codes.Last().Next = elemCode elemCode.Next = codes.First() elemCode.End = end return Opcodes{header}.Add(codes...).Add(elemCode).Add(end) } func (c *SliceCode) Filter(_ *FieldQuery) Code { return c } type ArrayCode struct { typ *runtime.Type value Code } func (c *ArrayCode) Kind() CodeKind { return CodeKindArray } func (c *ArrayCode) ToOpcode(ctx *compileContext) Opcodes { // header => opcode => elem => end // ^ | // |________| elem := c.typ.Elem() alen := c.typ.Len() size := elem.Size() header := newArrayHeaderCode(ctx, c.typ, alen) ctx.incIndex() ctx.incIndent() codes := c.value.ToOpcode(ctx) ctx.decIndent() codes.First().Flags |= IndirectFlags elemCode := newArrayElemCode(ctx, elem, header, alen, size) ctx.incIndex() end := newOpCode(ctx, c.typ, OpArrayEnd) ctx.incIndex() header.End = end header.Next = codes.First() codes.Last().Next = elemCode elemCode.Next = codes.First() elemCode.End = end return Opcodes{header}.Add(codes...).Add(elemCode).Add(end) } func (c *ArrayCode) Filter(_ *FieldQuery) Code { return c } type MapCode struct { typ *runtime.Type key Code value Code } func (c *MapCode) Kind() CodeKind { return CodeKindMap } func (c *MapCode) ToOpcode(ctx *compileContext) Opcodes { // header => code => value => code => key => code => value => code => end // ^ | // |_______________________| header := newMapHeaderCode(ctx, c.typ) ctx.incIndex() keyCodes := c.key.ToOpcode(ctx) value := newMapValueCode(ctx, c.typ.Elem(), header) ctx.incIndex() ctx.incIndent() valueCodes := c.value.ToOpcode(ctx) ctx.decIndent() valueCodes.First().Flags |= IndirectFlags key := newMapKeyCode(ctx, c.typ.Key(), header) ctx.incIndex() end := newMapEndCode(ctx, c.typ, header) ctx.incIndex() header.Next = keyCodes.First() keyCodes.Last().Next = value value.Next = valueCodes.First() valueCodes.Last().Next = key key.Next = keyCodes.First() header.End = end key.End = end value.End = end return Opcodes{header}.Add(keyCodes...).Add(value).Add(valueCodes...).Add(key).Add(end) } func (c *MapCode) Filter(_ *FieldQuery) Code { return c } type StructCode struct { typ *runtime.Type fields []*StructFieldCode isPtr bool disableIndirectConversion bool isIndirect bool isRecursive bool } func (c *StructCode) Kind() CodeKind { return CodeKindStruct } func (c *StructCode) lastFieldCode(field *StructFieldCode, firstField *Opcode) *Opcode { if isEmbeddedStruct(field) { return c.lastAnonymousFieldCode(firstField) } lastField := firstField for lastField.NextField != nil { lastField = lastField.NextField } return lastField } func (c *StructCode) lastAnonymousFieldCode(firstField *Opcode) *Opcode { // firstField is special StructHead operation for anonymous structure. // So, StructHead's next operation is truly struct head operation. for firstField.Op == OpStructHead || firstField.Op == OpStructField { firstField = firstField.Next } lastField := firstField for lastField.NextField != nil { lastField = lastField.NextField } return lastField } func (c *StructCode) ToOpcode(ctx *compileContext) Opcodes { // header => code => structField => code => end // ^ | // |__________| if c.isRecursive { recursive := newRecursiveCode(ctx, c.typ, &CompiledCode{}) recursive.Type = c.typ ctx.incIndex() *ctx.recursiveCodes = append(*ctx.recursiveCodes, recursive) return Opcodes{recursive} } codes := Opcodes{} var prevField *Opcode ctx.incIndent() for idx, field := range c.fields { isFirstField := idx == 0 isEndField := idx == len(c.fields)-1 fieldCodes := field.ToOpcode(ctx, isFirstField, isEndField) for _, code := range fieldCodes { if c.isIndirect { code.Flags |= IndirectFlags } } firstField := fieldCodes.First() if len(codes) > 0 { codes.Last().Next = firstField firstField.Idx = codes.First().Idx } if prevField != nil { prevField.NextField = firstField } if isEndField { endField := fieldCodes.Last() if len(codes) > 0 { codes.First().End = endField } else { firstField.End = endField } codes = codes.Add(fieldCodes...) break } prevField = c.lastFieldCode(field, firstField) codes = codes.Add(fieldCodes...) } if len(codes) == 0 { head := &Opcode{ Op: OpStructHead, Idx: opcodeOffset(ctx.ptrIndex), Type: c.typ, DisplayIdx: ctx.opcodeIndex, Indent: ctx.indent, } ctx.incOpcodeIndex() end := &Opcode{ Op: OpStructEnd, Idx: opcodeOffset(ctx.ptrIndex), DisplayIdx: ctx.opcodeIndex, Indent: ctx.indent, } head.NextField = end head.Next = end head.End = end codes = codes.Add(head, end) ctx.incIndex() } ctx.decIndent() ctx.structTypeToCodes[uintptr(unsafe.Pointer(c.typ))] = codes return codes } func (c *StructCode) ToAnonymousOpcode(ctx *compileContext) Opcodes { // header => code => structField => code => end // ^ | // |__________| if c.isRecursive { recursive := newRecursiveCode(ctx, c.typ, &CompiledCode{}) recursive.Type = c.typ ctx.incIndex() *ctx.recursiveCodes = append(*ctx.recursiveCodes, recursive) return Opcodes{recursive} } codes := Opcodes{} var prevField *Opcode for idx, field := range c.fields { isFirstField := idx == 0 isEndField := idx == len(c.fields)-1 fieldCodes := field.ToAnonymousOpcode(ctx, isFirstField, isEndField) for _, code := range fieldCodes { if c.isIndirect { code.Flags |= IndirectFlags } } firstField := fieldCodes.First() if len(codes) > 0 { codes.Last().Next = firstField firstField.Idx = codes.First().Idx } if prevField != nil { prevField.NextField = firstField } if isEndField { lastField := fieldCodes.Last() if len(codes) > 0 { codes.First().End = lastField } else { firstField.End = lastField } } prevField = firstField codes = codes.Add(fieldCodes...) } return codes } func (c *StructCode) removeFieldsByTags(tags runtime.StructTags) { fields := make([]*StructFieldCode, 0, len(c.fields)) for _, field := range c.fields { if field.isAnonymous { structCode := field.getAnonymousStruct() if structCode != nil && !structCode.isRecursive { structCode.removeFieldsByTags(tags) if len(structCode.fields) > 0 { fields = append(fields, field) } continue } } if tags.ExistsKey(field.key) { continue } fields = append(fields, field) } c.fields = fields } func (c *StructCode) enableIndirect() { if c.isIndirect { return } c.isIndirect = true if len(c.fields) == 0 { return } structCode := c.fields[0].getStruct() if structCode == nil { return } structCode.enableIndirect() } func (c *StructCode) Filter(query *FieldQuery) Code { fieldMap := map[string]*FieldQuery{} for _, field := range query.Fields { fieldMap[field.Name] = field } fields := make([]*StructFieldCode, 0, len(c.fields)) for _, field := range c.fields { query, exists := fieldMap[field.key] if !exists { continue } fieldCode := &StructFieldCode{ typ: field.typ, key: field.key, tag: field.tag, value: field.value, offset: field.offset, isAnonymous: field.isAnonymous, isTaggedKey: field.isTaggedKey, isNilableType: field.isNilableType, isNilCheck: field.isNilCheck, isAddrForMarshaler: field.isAddrForMarshaler, isNextOpPtrType: field.isNextOpPtrType, } if len(query.Fields) > 0 { fieldCode.value = fieldCode.value.Filter(query) } fields = append(fields, fieldCode) } return &StructCode{ typ: c.typ, fields: fields, isPtr: c.isPtr, disableIndirectConversion: c.disableIndirectConversion, isIndirect: c.isIndirect, isRecursive: c.isRecursive, } } type StructFieldCode struct { typ *runtime.Type key string tag *runtime.StructTag value Code offset uintptr isAnonymous bool isTaggedKey bool isNilableType bool isNilCheck bool isAddrForMarshaler bool isNextOpPtrType bool isMarshalerContext bool } func (c *StructFieldCode) getStruct() *StructCode { value := c.value ptr, ok := value.(*PtrCode) if ok { value = ptr.value } structCode, ok := value.(*StructCode) if ok { return structCode } return nil } func (c *StructFieldCode) getAnonymousStruct() *StructCode { if !c.isAnonymous { return nil } return c.getStruct() } 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 (c *StructFieldCode) headerOpcodes(ctx *compileContext, field *Opcode, valueCodes Opcodes) Opcodes { value := valueCodes.First() op := optimizeStructHeader(value, c.tag) field.Op = op if value.Flags&MarshalerContextFlags != 0 { field.Flags |= MarshalerContextFlags } field.NumBitSize = value.NumBitSize field.PtrNum = value.PtrNum field.FieldQuery = value.FieldQuery fieldCodes := Opcodes{field} if op.IsMultipleOpHead() { field.Next = value fieldCodes = fieldCodes.Add(valueCodes...) } else { ctx.decIndex() } return fieldCodes } func (c *StructFieldCode) fieldOpcodes(ctx *compileContext, field *Opcode, valueCodes Opcodes) Opcodes { value := valueCodes.First() op := optimizeStructField(value, c.tag) field.Op = op if value.Flags&MarshalerContextFlags != 0 { field.Flags |= MarshalerContextFlags } field.NumBitSize = value.NumBitSize field.PtrNum = value.PtrNum field.FieldQuery = value.FieldQuery fieldCodes := Opcodes{field} if op.IsMultipleOpField() { field.Next = value fieldCodes = fieldCodes.Add(valueCodes...) } else { ctx.decIndex() } return fieldCodes } func (c *StructFieldCode) addStructEndCode(ctx *compileContext, codes Opcodes) Opcodes { end := &Opcode{ Op: OpStructEnd, Idx: opcodeOffset(ctx.ptrIndex), DisplayIdx: ctx.opcodeIndex, Indent: ctx.indent, } codes.Last().Next = end code := codes.First() for code.Op == OpStructField || code.Op == OpStructHead { code = code.Next } for code.NextField != nil { code = code.NextField } code.NextField = end codes = codes.Add(end) ctx.incOpcodeIndex() return codes } func (c *StructFieldCode) structKey(ctx *compileContext) string { if ctx.escapeKey { rctx := &RuntimeContext{Option: &Option{Flag: HTMLEscapeOption}} return fmt.Sprintf(`%s:`, string(AppendString(rctx, []byte{}, c.key))) } return fmt.Sprintf(`"%s":`, c.key) } func (c *StructFieldCode) flags() OpFlags { var flags OpFlags if c.isTaggedKey { flags |= IsTaggedKeyFlags } if c.isNilableType { flags |= IsNilableTypeFlags } if c.isNilCheck { flags |= NilCheckFlags } if c.isAddrForMarshaler { flags |= AddrForMarshalerFlags } if c.isNextOpPtrType { flags |= IsNextOpPtrTypeFlags } if c.isAnonymous { flags |= AnonymousKeyFlags } if c.isMarshalerContext { flags |= MarshalerContextFlags } return flags } func (c *StructFieldCode) toValueOpcodes(ctx *compileContext) Opcodes { if c.isAnonymous { anonymCode, ok := c.value.(AnonymousCode) if ok { return anonymCode.ToAnonymousOpcode(ctx) } } return c.value.ToOpcode(ctx) } func (c *StructFieldCode) ToOpcode(ctx *compileContext, isFirstField, isEndField bool) Opcodes { field := &Opcode{ Idx: opcodeOffset(ctx.ptrIndex), Flags: c.flags(), Key: c.structKey(ctx), Offset: uint32(c.offset), Type: c.typ, DisplayIdx: ctx.opcodeIndex, Indent: ctx.indent, DisplayKey: c.key, } ctx.incIndex() valueCodes := c.toValueOpcodes(ctx) if isFirstField { codes := c.headerOpcodes(ctx, field, valueCodes) if isEndField { codes = c.addStructEndCode(ctx, codes) } return codes } codes := c.fieldOpcodes(ctx, field, valueCodes) if isEndField { if isEnableStructEndOptimization(c.value) { field.Op = field.Op.FieldToEnd() } else { codes = c.addStructEndCode(ctx, codes) } } return codes } func (c *StructFieldCode) ToAnonymousOpcode(ctx *compileContext, isFirstField, isEndField bool) Opcodes { field := &Opcode{ Idx: opcodeOffset(ctx.ptrIndex), Flags: c.flags() | AnonymousHeadFlags, Key: c.structKey(ctx), Offset: uint32(c.offset), Type: c.typ, DisplayIdx: ctx.opcodeIndex, Indent: ctx.indent, DisplayKey: c.key, } ctx.incIndex() valueCodes := c.toValueOpcodes(ctx) if isFirstField { return c.headerOpcodes(ctx, field, valueCodes) } return c.fieldOpcodes(ctx, field, valueCodes) } func isEnableStructEndOptimization(value Code) bool { switch value.Kind() { case CodeKindInt, CodeKindUint, CodeKindFloat, CodeKindString, CodeKindBool, CodeKindBytes: return true case CodeKindPtr: return isEnableStructEndOptimization(value.(*PtrCode).value) default: return false } } type InterfaceCode struct { typ *runtime.Type fieldQuery *FieldQuery isPtr bool } func (c *InterfaceCode) Kind() CodeKind { return CodeKindInterface } func (c *InterfaceCode) ToOpcode(ctx *compileContext) Opcodes { var code *Opcode switch { case c.isPtr: code = newOpCode(ctx, c.typ, OpInterfacePtr) default: code = newOpCode(ctx, c.typ, OpInterface) } code.FieldQuery = c.fieldQuery if c.typ.NumMethod() > 0 { code.Flags |= NonEmptyInterfaceFlags } ctx.incIndex() return Opcodes{code} } func (c *InterfaceCode) Filter(query *FieldQuery) Code { return &InterfaceCode{ typ: c.typ, fieldQuery: query, isPtr: c.isPtr, } } type MarshalJSONCode struct { typ *runtime.Type fieldQuery *FieldQuery isAddrForMarshaler bool isNilableType bool isMarshalerContext bool } func (c *MarshalJSONCode) Kind() CodeKind { return CodeKindMarshalJSON } func (c *MarshalJSONCode) ToOpcode(ctx *compileContext) Opcodes { code := newOpCode(ctx, c.typ, OpMarshalJSON) code.FieldQuery = c.fieldQuery if c.isAddrForMarshaler { code.Flags |= AddrForMarshalerFlags } if c.isMarshalerContext { code.Flags |= MarshalerContextFlags } if c.isNilableType { code.Flags |= IsNilableTypeFlags } else { code.Flags &= ^IsNilableTypeFlags } ctx.incIndex() return Opcodes{code} } func (c *MarshalJSONCode) Filter(query *FieldQuery) Code { return &MarshalJSONCode{ typ: c.typ, fieldQuery: query, isAddrForMarshaler: c.isAddrForMarshaler, isNilableType: c.isNilableType, isMarshalerContext: c.isMarshalerContext, } } type MarshalTextCode struct { typ *runtime.Type fieldQuery *FieldQuery isAddrForMarshaler bool isNilableType bool } func (c *MarshalTextCode) Kind() CodeKind { return CodeKindMarshalText } func (c *MarshalTextCode) ToOpcode(ctx *compileContext) Opcodes { code := newOpCode(ctx, c.typ, OpMarshalText) code.FieldQuery = c.fieldQuery if c.isAddrForMarshaler { code.Flags |= AddrForMarshalerFlags } if c.isNilableType { code.Flags |= IsNilableTypeFlags } else { code.Flags &= ^IsNilableTypeFlags } ctx.incIndex() return Opcodes{code} } func (c *MarshalTextCode) Filter(query *FieldQuery) Code { return &MarshalTextCode{ typ: c.typ, fieldQuery: query, isAddrForMarshaler: c.isAddrForMarshaler, isNilableType: c.isNilableType, } } type PtrCode struct { typ *runtime.Type value Code ptrNum uint8 } func (c *PtrCode) Kind() CodeKind { return CodeKindPtr } func (c *PtrCode) ToOpcode(ctx *compileContext) Opcodes { codes := c.value.ToOpcode(ctx) codes.First().Op = convertPtrOp(codes.First()) codes.First().PtrNum = c.ptrNum return codes } func (c *PtrCode) ToAnonymousOpcode(ctx *compileContext) Opcodes { var codes Opcodes anonymCode, ok := c.value.(AnonymousCode) if ok { codes = anonymCode.ToAnonymousOpcode(ctx) } else { codes = c.value.ToOpcode(ctx) } codes.First().Op = convertPtrOp(codes.First()) codes.First().PtrNum = c.ptrNum return codes } func (c *PtrCode) Filter(query *FieldQuery) Code { return &PtrCode{ typ: c.typ, value: c.value.Filter(query), ptrNum: c.ptrNum, } } 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 isEmbeddedStruct(field *StructFieldCode) bool { if !field.isAnonymous { return false } t := field.typ if t.Kind() == reflect.Ptr { t = t.Elem() } return t.Kind() == reflect.Struct }