From 3b7d5a6996606c326960f689d93e1ca6c723e4c9 Mon Sep 17 00:00:00 2001 From: Masaaki Goshima Date: Thu, 11 Feb 2021 00:33:54 +0900 Subject: [PATCH] Remove unnecessary dependency on decoder --- decode.go | 4 +- decode_compile.go | 125 +++++++++++++++++++-------------------- decode_compile_norace.go | 7 +-- decode_compile_race.go | 7 +-- decode_interface.go | 16 +++-- 5 files changed, 77 insertions(+), 82 deletions(-) diff --git a/decode.go b/decode.go index 0f79c7b..6abb85f 100644 --- a/decode.go +++ b/decode.go @@ -68,7 +68,7 @@ func (d *Decoder) decode(src []byte, header *interfaceHeader) error { if err := d.validateType(copiedType, ptr); err != nil { return err } - dec, err := d.compileToGetDecoder(typeptr, typ) + dec, err := decodeCompileToGetDecoder(typeptr, typ) if err != nil { return err } @@ -127,7 +127,7 @@ func (d *Decoder) Decode(v interface{}) error { return err } - dec, err := d.compileToGetDecoder(typeptr, typ) + dec, err := decodeCompileToGetDecoder(typeptr, typ) if err != nil { return err } diff --git a/decode_compile.go b/decode_compile.go index a18fa27..1398850 100644 --- a/decode_compile.go +++ b/decode_compile.go @@ -6,14 +6,13 @@ import ( "unsafe" ) -func (d *Decoder) compileToGetDecoderSlowPath(typeptr uintptr, typ *rtype) (decoder, error) { +func decodeCompileToGetDecoderSlowPath(typeptr uintptr, typ *rtype) (decoder, error) { decoderMap := loadDecoderMap() if dec, exists := decoderMap[typeptr]; exists { return dec, nil } - d.structTypeToDecoder = map[uintptr]decoder{} - dec, err := d.compileHead(typ) + dec, err := decodeCompileHead(typ, map[uintptr]decoder{}) if err != nil { return nil, err } @@ -21,17 +20,17 @@ func (d *Decoder) compileToGetDecoderSlowPath(typeptr uintptr, typ *rtype) (deco return dec, nil } -func (d *Decoder) compileHead(typ *rtype) (decoder, error) { +func decodeCompileHead(typ *rtype, structTypeToDecoder map[uintptr]decoder) (decoder, error) { switch { case rtype_ptrTo(typ).Implements(unmarshalJSONType): return newUnmarshalJSONDecoder(rtype_ptrTo(typ), "", ""), nil case rtype_ptrTo(typ).Implements(unmarshalTextType): return newUnmarshalTextDecoder(rtype_ptrTo(typ), "", ""), nil } - return d.compile(typ.Elem(), "", "") + return decodeCompile(typ.Elem(), "", "", structTypeToDecoder) } -func (d *Decoder) compile(typ *rtype, structName, fieldName string) (decoder, error) { +func decodeCompile(typ *rtype, structName, fieldName string, structTypeToDecoder map[uintptr]decoder) (decoder, error) { switch { case rtype_ptrTo(typ).Implements(unmarshalJSONType): return newUnmarshalJSONDecoder(rtype_ptrTo(typ), structName, fieldName), nil @@ -41,51 +40,51 @@ func (d *Decoder) compile(typ *rtype, structName, fieldName string) (decoder, er switch typ.Kind() { case reflect.Ptr: - return d.compilePtr(typ, structName, fieldName) + return decodeCompilePtr(typ, structName, fieldName, structTypeToDecoder) case reflect.Struct: - return d.compileStruct(typ, structName, fieldName) + return decodeCompileStruct(typ, structName, fieldName, structTypeToDecoder) case reflect.Slice: elem := typ.Elem() if elem.Kind() == reflect.Uint8 { - return d.compileBytes(elem, structName, fieldName) + return decodeCompileBytes(elem, structName, fieldName) } - return d.compileSlice(typ, structName, fieldName) + return decodeCompileSlice(typ, structName, fieldName, structTypeToDecoder) case reflect.Array: - return d.compileArray(typ, structName, fieldName) + return decodeCompileArray(typ, structName, fieldName, structTypeToDecoder) case reflect.Map: - return d.compileMap(typ, structName, fieldName) + return decodeCompileMap(typ, structName, fieldName, structTypeToDecoder) case reflect.Interface: - return d.compileInterface(typ, structName, fieldName) + return decodeCompileInterface(typ, structName, fieldName) case reflect.Uintptr: - return d.compileUint(typ, structName, fieldName) + return decodeCompileUint(typ, structName, fieldName) case reflect.Int: - return d.compileInt(typ, structName, fieldName) + return decodeCompileInt(typ, structName, fieldName) case reflect.Int8: - return d.compileInt8(typ, structName, fieldName) + return decodeCompileInt8(typ, structName, fieldName) case reflect.Int16: - return d.compileInt16(typ, structName, fieldName) + return decodeCompileInt16(typ, structName, fieldName) case reflect.Int32: - return d.compileInt32(typ, structName, fieldName) + return decodeCompileInt32(typ, structName, fieldName) case reflect.Int64: - return d.compileInt64(typ, structName, fieldName) + return decodeCompileInt64(typ, structName, fieldName) case reflect.Uint: - return d.compileUint(typ, structName, fieldName) + return decodeCompileUint(typ, structName, fieldName) case reflect.Uint8: - return d.compileUint8(typ, structName, fieldName) + return decodeCompileUint8(typ, structName, fieldName) case reflect.Uint16: - return d.compileUint16(typ, structName, fieldName) + return decodeCompileUint16(typ, structName, fieldName) case reflect.Uint32: - return d.compileUint32(typ, structName, fieldName) + return decodeCompileUint32(typ, structName, fieldName) case reflect.Uint64: - return d.compileUint64(typ, structName, fieldName) + return decodeCompileUint64(typ, structName, fieldName) case reflect.String: - return d.compileString(structName, fieldName) + return decodeCompileString(structName, fieldName) case reflect.Bool: - return d.compileBool(structName, fieldName) + return decodeCompileBool(structName, fieldName) case reflect.Float32: - return d.compileFloat32(structName, fieldName) + return decodeCompileFloat32(structName, fieldName) case reflect.Float64: - return d.compileFloat64(structName, fieldName) + return decodeCompileFloat64(structName, fieldName) } return nil, &UnmarshalTypeError{ Value: "object", @@ -94,11 +93,11 @@ func (d *Decoder) compile(typ *rtype, structName, fieldName string) (decoder, er } } -func (d *Decoder) compileMapKey(typ *rtype, structName, fieldName string) (decoder, error) { +func decodeCompileMapKey(typ *rtype, structName, fieldName string, structTypeToDecoder map[uintptr]decoder) (decoder, error) { if rtype_ptrTo(typ).Implements(unmarshalTextType) { return newUnmarshalTextDecoder(rtype_ptrTo(typ), structName, fieldName), nil } - dec, err := d.compile(typ, structName, fieldName) + dec, err := decodeCompile(typ, structName, fieldName, structTypeToDecoder) if err != nil { return nil, err } @@ -122,133 +121,133 @@ ERROR: } } -func (d *Decoder) compilePtr(typ *rtype, structName, fieldName string) (decoder, error) { - dec, err := d.compile(typ.Elem(), structName, fieldName) +func decodeCompilePtr(typ *rtype, structName, fieldName string, structTypeToDecoder map[uintptr]decoder) (decoder, error) { + dec, err := decodeCompile(typ.Elem(), structName, fieldName, structTypeToDecoder) if err != nil { return nil, err } return newPtrDecoder(dec, typ.Elem(), structName, fieldName), nil } -func (d *Decoder) compileInt(typ *rtype, structName, fieldName string) (decoder, error) { +func decodeCompileInt(typ *rtype, structName, fieldName string) (decoder, error) { return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) { *(*int)(p) = int(v) }), nil } -func (d *Decoder) compileInt8(typ *rtype, structName, fieldName string) (decoder, error) { +func decodeCompileInt8(typ *rtype, structName, fieldName string) (decoder, error) { return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) { *(*int8)(p) = int8(v) }), nil } -func (d *Decoder) compileInt16(typ *rtype, structName, fieldName string) (decoder, error) { +func decodeCompileInt16(typ *rtype, structName, fieldName string) (decoder, error) { return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) { *(*int16)(p) = int16(v) }), nil } -func (d *Decoder) compileInt32(typ *rtype, structName, fieldName string) (decoder, error) { +func decodeCompileInt32(typ *rtype, structName, fieldName string) (decoder, error) { return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) { *(*int32)(p) = int32(v) }), nil } -func (d *Decoder) compileInt64(typ *rtype, structName, fieldName string) (decoder, error) { +func decodeCompileInt64(typ *rtype, structName, fieldName string) (decoder, error) { return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) { *(*int64)(p) = v }), nil } -func (d *Decoder) compileUint(typ *rtype, structName, fieldName string) (decoder, error) { +func decodeCompileUint(typ *rtype, structName, fieldName string) (decoder, error) { return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) { *(*uint)(p) = uint(v) }), nil } -func (d *Decoder) compileUint8(typ *rtype, structName, fieldName string) (decoder, error) { +func decodeCompileUint8(typ *rtype, structName, fieldName string) (decoder, error) { return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) { *(*uint8)(p) = uint8(v) }), nil } -func (d *Decoder) compileUint16(typ *rtype, structName, fieldName string) (decoder, error) { +func decodeCompileUint16(typ *rtype, structName, fieldName string) (decoder, error) { return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) { *(*uint16)(p) = uint16(v) }), nil } -func (d *Decoder) compileUint32(typ *rtype, structName, fieldName string) (decoder, error) { +func decodeCompileUint32(typ *rtype, structName, fieldName string) (decoder, error) { return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) { *(*uint32)(p) = uint32(v) }), nil } -func (d *Decoder) compileUint64(typ *rtype, structName, fieldName string) (decoder, error) { +func decodeCompileUint64(typ *rtype, structName, fieldName string) (decoder, error) { return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) { *(*uint64)(p) = v }), nil } -func (d *Decoder) compileFloat32(structName, fieldName string) (decoder, error) { +func decodeCompileFloat32(structName, fieldName string) (decoder, error) { return newFloatDecoder(structName, fieldName, func(p unsafe.Pointer, v float64) { *(*float32)(p) = float32(v) }), nil } -func (d *Decoder) compileFloat64(structName, fieldName string) (decoder, error) { +func decodeCompileFloat64(structName, fieldName string) (decoder, error) { return newFloatDecoder(structName, fieldName, func(p unsafe.Pointer, v float64) { *(*float64)(p) = v }), nil } -func (d *Decoder) compileString(structName, fieldName string) (decoder, error) { +func decodeCompileString(structName, fieldName string) (decoder, error) { return newStringDecoder(structName, fieldName), nil } -func (d *Decoder) compileBool(structName, fieldName string) (decoder, error) { +func decodeCompileBool(structName, fieldName string) (decoder, error) { return newBoolDecoder(structName, fieldName), nil } -func (d *Decoder) compileBytes(typ *rtype, structName, fieldName string) (decoder, error) { +func decodeCompileBytes(typ *rtype, structName, fieldName string) (decoder, error) { return newBytesDecoder(typ, structName, fieldName), nil } -func (d *Decoder) compileSlice(typ *rtype, structName, fieldName string) (decoder, error) { +func decodeCompileSlice(typ *rtype, structName, fieldName string, structTypeToDecoder map[uintptr]decoder) (decoder, error) { elem := typ.Elem() - decoder, err := d.compile(elem, structName, fieldName) + decoder, err := decodeCompile(elem, structName, fieldName, structTypeToDecoder) if err != nil { return nil, err } return newSliceDecoder(decoder, elem, elem.Size(), structName, fieldName), nil } -func (d *Decoder) compileArray(typ *rtype, structName, fieldName string) (decoder, error) { +func decodeCompileArray(typ *rtype, structName, fieldName string, structTypeToDecoder map[uintptr]decoder) (decoder, error) { elem := typ.Elem() - decoder, err := d.compile(elem, structName, fieldName) + decoder, err := decodeCompile(elem, structName, fieldName, structTypeToDecoder) if err != nil { return nil, err } return newArrayDecoder(decoder, elem, typ.Len(), structName, fieldName), nil } -func (d *Decoder) compileMap(typ *rtype, structName, fieldName string) (decoder, error) { - keyDec, err := d.compileMapKey(typ.Key(), structName, fieldName) +func decodeCompileMap(typ *rtype, structName, fieldName string, structTypeToDecoder map[uintptr]decoder) (decoder, error) { + keyDec, err := decodeCompileMapKey(typ.Key(), structName, fieldName, structTypeToDecoder) if err != nil { return nil, err } - valueDec, err := d.compile(typ.Elem(), structName, fieldName) + valueDec, err := decodeCompile(typ.Elem(), structName, fieldName, structTypeToDecoder) if err != nil { return nil, err } return newMapDecoder(typ, typ.Key(), keyDec, typ.Elem(), valueDec, structName, fieldName), nil } -func (d *Decoder) compileInterface(typ *rtype, structName, fieldName string) (decoder, error) { - return newInterfaceDecoder(d, typ, structName, fieldName), nil +func decodeCompileInterface(typ *rtype, structName, fieldName string) (decoder, error) { + return newInterfaceDecoder(typ, structName, fieldName), nil } -func (d *Decoder) removeConflictFields(fieldMap map[string]*structFieldSet, conflictedMap map[string]struct{}, dec *structDecoder, baseOffset uintptr) { +func decodeRemoveConflictFields(fieldMap map[string]*structFieldSet, conflictedMap map[string]struct{}, dec *structDecoder, baseOffset uintptr) { for k, v := range dec.fieldMap { if _, exists := conflictedMap[k]; exists { // already conflicted key @@ -303,16 +302,16 @@ func (d *Decoder) removeConflictFields(fieldMap map[string]*structFieldSet, conf } } -func (d *Decoder) compileStruct(typ *rtype, structName, fieldName string) (decoder, error) { +func decodeCompileStruct(typ *rtype, structName, fieldName string, structTypeToDecoder map[uintptr]decoder) (decoder, error) { fieldNum := typ.NumField() conflictedMap := map[string]struct{}{} fieldMap := map[string]*structFieldSet{} typeptr := uintptr(unsafe.Pointer(typ)) - if dec, exists := d.structTypeToDecoder[typeptr]; exists { + if dec, exists := structTypeToDecoder[typeptr]; exists { return dec, nil } structDec := newStructDecoder(structName, fieldName, fieldMap) - d.structTypeToDecoder[typeptr] = structDec + structTypeToDecoder[typeptr] = structDec structName = typ.Name() for i := 0; i < fieldNum; i++ { field := typ.Field(i) @@ -320,7 +319,7 @@ func (d *Decoder) compileStruct(typ *rtype, structName, fieldName string) (decod continue } tag := structTagFromField(field) - dec, err := d.compile(type2rtype(field.Type), structName, field.Name) + dec, err := decodeCompile(type2rtype(field.Type), structName, field.Name, structTypeToDecoder) if err != nil { return nil, err } @@ -330,7 +329,7 @@ func (d *Decoder) compileStruct(typ *rtype, structName, fieldName string) (decod // recursive definition continue } - d.removeConflictFields(fieldMap, conflictedMap, stDec, field.Offset) + decodeRemoveConflictFields(fieldMap, conflictedMap, stDec, field.Offset) } else if pdec, ok := dec.(*ptrDecoder); ok { contentDec := pdec.contentDecoder() if pdec.typ == typ { @@ -416,7 +415,7 @@ func (d *Decoder) compileStruct(typ *rtype, structName, fieldName string) (decod } } } - delete(d.structTypeToDecoder, typeptr) + delete(structTypeToDecoder, typeptr) structDec.tryOptimize() return structDec, nil } diff --git a/decode_compile_norace.go b/decode_compile_norace.go index ed3a4ac..3ad763c 100644 --- a/decode_compile_norace.go +++ b/decode_compile_norace.go @@ -2,9 +2,9 @@ package json -func (d *Decoder) compileToGetDecoder(typeptr uintptr, typ *rtype) (decoder, error) { +func decodeCompileToGetDecoder(typeptr uintptr, typ *rtype) (decoder, error) { if typeptr > maxTypeAddr { - return d.compileToGetDecoderSlowPath(typeptr, typ) + return decodeCompileToGetDecoderSlowPath(typeptr, typ) } index := typeptr - baseTypeAddr @@ -12,8 +12,7 @@ func (d *Decoder) compileToGetDecoder(typeptr uintptr, typ *rtype) (decoder, err return dec, nil } - d.structTypeToDecoder = map[uintptr]decoder{} - dec, err := d.compileHead(typ) + dec, err := decodeCompileHead(typ, map[uintptr]decoder{}) if err != nil { return nil, err } diff --git a/decode_compile_race.go b/decode_compile_race.go index d136f9e..921af83 100644 --- a/decode_compile_race.go +++ b/decode_compile_race.go @@ -8,9 +8,9 @@ import ( var decMu sync.RWMutex -func (d *Decoder) compileToGetDecoder(typeptr uintptr, typ *rtype) (decoder, error) { +func decodeCompileToGetDecoder(typeptr uintptr, typ *rtype) (decoder, error) { if typeptr > maxTypeAddr { - return d.compileToGetDecoderSlowPath(typeptr, typ) + return decodeCompileToGetDecoderSlowPath(typeptr, typ) } index := typeptr - baseTypeAddr @@ -21,8 +21,7 @@ func (d *Decoder) compileToGetDecoder(typeptr uintptr, typ *rtype) (decoder, err } decMu.RUnlock() - d.structTypeToDecoder = map[uintptr]decoder{} - dec, err := d.compileHead(typ) + dec, err := decodeCompileHead(typ, map[uintptr]decoder{}) if err != nil { return nil, err } diff --git a/decode_interface.go b/decode_interface.go index 25696a0..bf26954 100644 --- a/decode_interface.go +++ b/decode_interface.go @@ -10,15 +10,13 @@ type interfaceDecoder struct { typ *rtype structName string fieldName string - dec *Decoder } -func newInterfaceDecoder(dec *Decoder, typ *rtype, structName, fieldName string) *interfaceDecoder { +func newInterfaceDecoder(typ *rtype, structName, fieldName string) *interfaceDecoder { return &interfaceDecoder{ typ: typ, structName: structName, fieldName: fieldName, - dec: dec, } } @@ -84,7 +82,7 @@ func (d *interfaceDecoder) decodeStreamEmptyInterface(s *stream, p unsafe.Pointe stringType, newStringDecoder(d.structName, d.fieldName), interfaceMapType.Elem(), - newInterfaceDecoder(d.dec, d.typ, d.structName, d.fieldName), + newInterfaceDecoder(d.typ, d.structName, d.fieldName), d.structName, d.fieldName, ).decodeStream(s, ptr); err != nil { @@ -96,7 +94,7 @@ func (d *interfaceDecoder) decodeStreamEmptyInterface(s *stream, p unsafe.Pointe var v []interface{} ptr := unsafe.Pointer(&v) if err := newSliceDecoder( - newInterfaceDecoder(d.dec, d.typ, d.structName, d.fieldName), + newInterfaceDecoder(d.typ, d.structName, d.fieldName), d.typ, d.typ.Size(), d.structName, @@ -190,7 +188,7 @@ func (d *interfaceDecoder) decodeStream(s *stream, p unsafe.Pointer) error { *(*interface{})(p) = nil return nil } - decoder, err := d.dec.compileToGetDecoder(uintptr(unsafe.Pointer(typ)), typ) + decoder, err := decodeCompileToGetDecoder(uintptr(unsafe.Pointer(typ)), typ) if err != nil { return err } @@ -230,7 +228,7 @@ func (d *interfaceDecoder) decode(buf []byte, cursor int64, p unsafe.Pointer) (i **(**interface{})(unsafe.Pointer(&p)) = nil return cursor, nil } - decoder, err := d.dec.compileToGetDecoder(uintptr(unsafe.Pointer(typ)), typ) + decoder, err := decodeCompileToGetDecoder(uintptr(unsafe.Pointer(typ)), typ) if err != nil { return 0, err } @@ -248,7 +246,7 @@ func (d *interfaceDecoder) decodeEmptyInterface(buf []byte, cursor int64, p unsa stringType, newStringDecoder(d.structName, d.fieldName), interfaceMapType.Elem(), - newInterfaceDecoder(d.dec, d.typ, d.structName, d.fieldName), + newInterfaceDecoder(d.typ, d.structName, d.fieldName), d.structName, d.fieldName, ) cursor, err := dec.decode(buf, cursor, ptr) @@ -261,7 +259,7 @@ func (d *interfaceDecoder) decodeEmptyInterface(buf []byte, cursor int64, p unsa var v []interface{} ptr := unsafe.Pointer(&v) dec := newSliceDecoder( - newInterfaceDecoder(d.dec, d.typ, d.structName, d.fieldName), + newInterfaceDecoder(d.typ, d.structName, d.fieldName), d.typ, d.typ.Size(), d.structName, d.fieldName,