summaryrefslogtreecommitdiff
path: root/vendor/github.com/goccy/go-json/internal/decoder/compile.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/goccy/go-json/internal/decoder/compile.go')
-rw-r--r--vendor/github.com/goccy/go-json/internal/decoder/compile.go487
1 files changed, 487 insertions, 0 deletions
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/compile.go b/vendor/github.com/goccy/go-json/internal/decoder/compile.go
new file mode 100644
index 000000000..fab643764
--- /dev/null
+++ b/vendor/github.com/goccy/go-json/internal/decoder/compile.go
@@ -0,0 +1,487 @@
+package decoder
+
+import (
+ "encoding/json"
+ "fmt"
+ "reflect"
+ "strings"
+ "sync/atomic"
+ "unicode"
+ "unsafe"
+
+ "github.com/goccy/go-json/internal/runtime"
+)
+
+var (
+ jsonNumberType = reflect.TypeOf(json.Number(""))
+ typeAddr *runtime.TypeAddr
+ cachedDecoderMap unsafe.Pointer // map[uintptr]decoder
+ cachedDecoder []Decoder
+)
+
+func init() {
+ typeAddr = runtime.AnalyzeTypeAddr()
+ if typeAddr == nil {
+ typeAddr = &runtime.TypeAddr{}
+ }
+ cachedDecoder = make([]Decoder, typeAddr.AddrRange>>typeAddr.AddrShift+1)
+}
+
+func loadDecoderMap() map[uintptr]Decoder {
+ p := atomic.LoadPointer(&cachedDecoderMap)
+ return *(*map[uintptr]Decoder)(unsafe.Pointer(&p))
+}
+
+func storeDecoder(typ uintptr, dec Decoder, m map[uintptr]Decoder) {
+ newDecoderMap := make(map[uintptr]Decoder, len(m)+1)
+ newDecoderMap[typ] = dec
+
+ for k, v := range m {
+ newDecoderMap[k] = v
+ }
+
+ atomic.StorePointer(&cachedDecoderMap, *(*unsafe.Pointer)(unsafe.Pointer(&newDecoderMap)))
+}
+
+func compileToGetDecoderSlowPath(typeptr uintptr, typ *runtime.Type) (Decoder, error) {
+ decoderMap := loadDecoderMap()
+ if dec, exists := decoderMap[typeptr]; exists {
+ return dec, nil
+ }
+
+ dec, err := compileHead(typ, map[uintptr]Decoder{})
+ if err != nil {
+ return nil, err
+ }
+ storeDecoder(typeptr, dec, decoderMap)
+ return dec, nil
+}
+
+func compileHead(typ *runtime.Type, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
+ switch {
+ case implementsUnmarshalJSONType(runtime.PtrTo(typ)):
+ return newUnmarshalJSONDecoder(runtime.PtrTo(typ), "", ""), nil
+ case runtime.PtrTo(typ).Implements(unmarshalTextType):
+ return newUnmarshalTextDecoder(runtime.PtrTo(typ), "", ""), nil
+ }
+ return compile(typ.Elem(), "", "", structTypeToDecoder)
+}
+
+func compile(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
+ switch {
+ case implementsUnmarshalJSONType(runtime.PtrTo(typ)):
+ return newUnmarshalJSONDecoder(runtime.PtrTo(typ), structName, fieldName), nil
+ case runtime.PtrTo(typ).Implements(unmarshalTextType):
+ return newUnmarshalTextDecoder(runtime.PtrTo(typ), structName, fieldName), nil
+ }
+
+ switch typ.Kind() {
+ case reflect.Ptr:
+ return compilePtr(typ, structName, fieldName, structTypeToDecoder)
+ case reflect.Struct:
+ return compileStruct(typ, structName, fieldName, structTypeToDecoder)
+ case reflect.Slice:
+ elem := typ.Elem()
+ if elem.Kind() == reflect.Uint8 {
+ return compileBytes(elem, structName, fieldName)
+ }
+ return compileSlice(typ, structName, fieldName, structTypeToDecoder)
+ case reflect.Array:
+ return compileArray(typ, structName, fieldName, structTypeToDecoder)
+ case reflect.Map:
+ return compileMap(typ, structName, fieldName, structTypeToDecoder)
+ case reflect.Interface:
+ return compileInterface(typ, structName, fieldName)
+ case reflect.Uintptr:
+ return compileUint(typ, structName, fieldName)
+ case reflect.Int:
+ return compileInt(typ, structName, fieldName)
+ case reflect.Int8:
+ return compileInt8(typ, structName, fieldName)
+ case reflect.Int16:
+ return compileInt16(typ, structName, fieldName)
+ case reflect.Int32:
+ return compileInt32(typ, structName, fieldName)
+ case reflect.Int64:
+ return compileInt64(typ, structName, fieldName)
+ case reflect.Uint:
+ return compileUint(typ, structName, fieldName)
+ case reflect.Uint8:
+ return compileUint8(typ, structName, fieldName)
+ case reflect.Uint16:
+ return compileUint16(typ, structName, fieldName)
+ case reflect.Uint32:
+ return compileUint32(typ, structName, fieldName)
+ case reflect.Uint64:
+ return compileUint64(typ, structName, fieldName)
+ case reflect.String:
+ return compileString(typ, structName, fieldName)
+ case reflect.Bool:
+ return compileBool(structName, fieldName)
+ case reflect.Float32:
+ return compileFloat32(structName, fieldName)
+ case reflect.Float64:
+ return compileFloat64(structName, fieldName)
+ case reflect.Func:
+ return compileFunc(typ, structName, fieldName)
+ }
+ return newInvalidDecoder(typ, structName, fieldName), nil
+}
+
+func isStringTagSupportedType(typ *runtime.Type) bool {
+ switch {
+ case implementsUnmarshalJSONType(runtime.PtrTo(typ)):
+ return false
+ case runtime.PtrTo(typ).Implements(unmarshalTextType):
+ return false
+ }
+ switch typ.Kind() {
+ case reflect.Map:
+ return false
+ case reflect.Slice:
+ return false
+ case reflect.Array:
+ return false
+ case reflect.Struct:
+ return false
+ case reflect.Interface:
+ return false
+ }
+ return true
+}
+
+func compileMapKey(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
+ if runtime.PtrTo(typ).Implements(unmarshalTextType) {
+ return newUnmarshalTextDecoder(runtime.PtrTo(typ), structName, fieldName), nil
+ }
+ if typ.Kind() == reflect.String {
+ return newStringDecoder(structName, fieldName), nil
+ }
+ dec, err := compile(typ, structName, fieldName, structTypeToDecoder)
+ if err != nil {
+ return nil, err
+ }
+ for {
+ switch t := dec.(type) {
+ case *stringDecoder, *interfaceDecoder:
+ return dec, nil
+ case *boolDecoder, *intDecoder, *uintDecoder, *numberDecoder:
+ return newWrappedStringDecoder(typ, dec, structName, fieldName), nil
+ case *ptrDecoder:
+ dec = t.dec
+ default:
+ return newInvalidDecoder(typ, structName, fieldName), nil
+ }
+ }
+}
+
+func compilePtr(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
+ dec, err := compile(typ.Elem(), structName, fieldName, structTypeToDecoder)
+ if err != nil {
+ return nil, err
+ }
+ return newPtrDecoder(dec, typ.Elem(), structName, fieldName), nil
+}
+
+func compileInt(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
+ return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) {
+ *(*int)(p) = int(v)
+ }), nil
+}
+
+func compileInt8(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
+ return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) {
+ *(*int8)(p) = int8(v)
+ }), nil
+}
+
+func compileInt16(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
+ return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) {
+ *(*int16)(p) = int16(v)
+ }), nil
+}
+
+func compileInt32(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
+ return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) {
+ *(*int32)(p) = int32(v)
+ }), nil
+}
+
+func compileInt64(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
+ return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) {
+ *(*int64)(p) = v
+ }), nil
+}
+
+func compileUint(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
+ return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) {
+ *(*uint)(p) = uint(v)
+ }), nil
+}
+
+func compileUint8(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
+ return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) {
+ *(*uint8)(p) = uint8(v)
+ }), nil
+}
+
+func compileUint16(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
+ return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) {
+ *(*uint16)(p) = uint16(v)
+ }), nil
+}
+
+func compileUint32(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
+ return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) {
+ *(*uint32)(p) = uint32(v)
+ }), nil
+}
+
+func compileUint64(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
+ return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) {
+ *(*uint64)(p) = v
+ }), nil
+}
+
+func compileFloat32(structName, fieldName string) (Decoder, error) {
+ return newFloatDecoder(structName, fieldName, func(p unsafe.Pointer, v float64) {
+ *(*float32)(p) = float32(v)
+ }), nil
+}
+
+func compileFloat64(structName, fieldName string) (Decoder, error) {
+ return newFloatDecoder(structName, fieldName, func(p unsafe.Pointer, v float64) {
+ *(*float64)(p) = v
+ }), nil
+}
+
+func compileString(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
+ if typ == runtime.Type2RType(jsonNumberType) {
+ return newNumberDecoder(structName, fieldName, func(p unsafe.Pointer, v json.Number) {
+ *(*json.Number)(p) = v
+ }), nil
+ }
+ return newStringDecoder(structName, fieldName), nil
+}
+
+func compileBool(structName, fieldName string) (Decoder, error) {
+ return newBoolDecoder(structName, fieldName), nil
+}
+
+func compileBytes(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
+ return newBytesDecoder(typ, structName, fieldName), nil
+}
+
+func compileSlice(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
+ elem := typ.Elem()
+ decoder, err := compile(elem, structName, fieldName, structTypeToDecoder)
+ if err != nil {
+ return nil, err
+ }
+ return newSliceDecoder(decoder, elem, elem.Size(), structName, fieldName), nil
+}
+
+func compileArray(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
+ elem := typ.Elem()
+ decoder, err := compile(elem, structName, fieldName, structTypeToDecoder)
+ if err != nil {
+ return nil, err
+ }
+ return newArrayDecoder(decoder, elem, typ.Len(), structName, fieldName), nil
+}
+
+func compileMap(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
+ keyDec, err := compileMapKey(typ.Key(), structName, fieldName, structTypeToDecoder)
+ if err != nil {
+ return nil, err
+ }
+ valueDec, err := compile(typ.Elem(), structName, fieldName, structTypeToDecoder)
+ if err != nil {
+ return nil, err
+ }
+ return newMapDecoder(typ, typ.Key(), keyDec, typ.Elem(), valueDec, structName, fieldName), nil
+}
+
+func compileInterface(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
+ return newInterfaceDecoder(typ, structName, fieldName), nil
+}
+
+func compileFunc(typ *runtime.Type, strutName, fieldName string) (Decoder, error) {
+ return newFuncDecoder(typ, strutName, fieldName), nil
+}
+
+func typeToStructTags(typ *runtime.Type) runtime.StructTags {
+ tags := runtime.StructTags{}
+ fieldNum := typ.NumField()
+ for i := 0; i < fieldNum; i++ {
+ field := typ.Field(i)
+ if runtime.IsIgnoredStructField(field) {
+ continue
+ }
+ tags = append(tags, runtime.StructTagFromField(field))
+ }
+ return tags
+}
+
+func compileStruct(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
+ fieldNum := typ.NumField()
+ fieldMap := map[string]*structFieldSet{}
+ typeptr := uintptr(unsafe.Pointer(typ))
+ if dec, exists := structTypeToDecoder[typeptr]; exists {
+ return dec, nil
+ }
+ structDec := newStructDecoder(structName, fieldName, fieldMap)
+ structTypeToDecoder[typeptr] = structDec
+ structName = typ.Name()
+ tags := typeToStructTags(typ)
+ allFields := []*structFieldSet{}
+ for i := 0; i < fieldNum; i++ {
+ field := typ.Field(i)
+ if runtime.IsIgnoredStructField(field) {
+ continue
+ }
+ isUnexportedField := unicode.IsLower([]rune(field.Name)[0])
+ tag := runtime.StructTagFromField(field)
+ dec, err := compile(runtime.Type2RType(field.Type), structName, field.Name, structTypeToDecoder)
+ if err != nil {
+ return nil, err
+ }
+ if field.Anonymous && !tag.IsTaggedKey {
+ if stDec, ok := dec.(*structDecoder); ok {
+ if runtime.Type2RType(field.Type) == typ {
+ // recursive definition
+ continue
+ }
+ for k, v := range stDec.fieldMap {
+ if tags.ExistsKey(k) {
+ continue
+ }
+ fieldSet := &structFieldSet{
+ dec: v.dec,
+ offset: field.Offset + v.offset,
+ isTaggedKey: v.isTaggedKey,
+ key: k,
+ keyLen: int64(len(k)),
+ }
+ allFields = append(allFields, fieldSet)
+ }
+ } else if pdec, ok := dec.(*ptrDecoder); ok {
+ contentDec := pdec.contentDecoder()
+ if pdec.typ == typ {
+ // recursive definition
+ continue
+ }
+ var fieldSetErr error
+ if isUnexportedField {
+ fieldSetErr = fmt.Errorf(
+ "json: cannot set embedded pointer to unexported struct: %v",
+ field.Type.Elem(),
+ )
+ }
+ if dec, ok := contentDec.(*structDecoder); ok {
+ for k, v := range dec.fieldMap {
+ if tags.ExistsKey(k) {
+ continue
+ }
+ fieldSet := &structFieldSet{
+ dec: newAnonymousFieldDecoder(pdec.typ, v.offset, v.dec),
+ offset: field.Offset,
+ isTaggedKey: v.isTaggedKey,
+ key: k,
+ keyLen: int64(len(k)),
+ err: fieldSetErr,
+ }
+ allFields = append(allFields, fieldSet)
+ }
+ } else {
+ fieldSet := &structFieldSet{
+ dec: pdec,
+ offset: field.Offset,
+ isTaggedKey: tag.IsTaggedKey,
+ key: field.Name,
+ keyLen: int64(len(field.Name)),
+ }
+ allFields = append(allFields, fieldSet)
+ }
+ } else {
+ fieldSet := &structFieldSet{
+ dec: dec,
+ offset: field.Offset,
+ isTaggedKey: tag.IsTaggedKey,
+ key: field.Name,
+ keyLen: int64(len(field.Name)),
+ }
+ allFields = append(allFields, fieldSet)
+ }
+ } else {
+ if tag.IsString && isStringTagSupportedType(runtime.Type2RType(field.Type)) {
+ dec = newWrappedStringDecoder(runtime.Type2RType(field.Type), dec, structName, field.Name)
+ }
+ var key string
+ if tag.Key != "" {
+ key = tag.Key
+ } else {
+ key = field.Name
+ }
+ fieldSet := &structFieldSet{
+ dec: dec,
+ offset: field.Offset,
+ isTaggedKey: tag.IsTaggedKey,
+ key: key,
+ keyLen: int64(len(key)),
+ }
+ allFields = append(allFields, fieldSet)
+ }
+ }
+ for _, set := range filterDuplicatedFields(allFields) {
+ fieldMap[set.key] = set
+ lower := strings.ToLower(set.key)
+ if _, exists := fieldMap[lower]; !exists {
+ // first win
+ fieldMap[lower] = set
+ }
+ }
+ delete(structTypeToDecoder, typeptr)
+ structDec.tryOptimize()
+ return structDec, nil
+}
+
+func filterDuplicatedFields(allFields []*structFieldSet) []*structFieldSet {
+ fieldMap := map[string][]*structFieldSet{}
+ for _, field := range allFields {
+ fieldMap[field.key] = append(fieldMap[field.key], field)
+ }
+ duplicatedFieldMap := map[string]struct{}{}
+ for k, sets := range fieldMap {
+ sets = filterFieldSets(sets)
+ if len(sets) != 1 {
+ duplicatedFieldMap[k] = struct{}{}
+ }
+ }
+
+ filtered := make([]*structFieldSet, 0, len(allFields))
+ for _, field := range allFields {
+ if _, exists := duplicatedFieldMap[field.key]; exists {
+ continue
+ }
+ filtered = append(filtered, field)
+ }
+ return filtered
+}
+
+func filterFieldSets(sets []*structFieldSet) []*structFieldSet {
+ if len(sets) == 1 {
+ return sets
+ }
+ filtered := make([]*structFieldSet, 0, len(sets))
+ for _, set := range sets {
+ if set.isTaggedKey {
+ filtered = append(filtered, set)
+ }
+ }
+ return filtered
+}
+
+func implementsUnmarshalJSONType(typ *runtime.Type) bool {
+ return typ.Implements(unmarshalJSONType) || typ.Implements(unmarshalJSONContextType)
+}
generated by cgit v1.2.3 (git 2.46.0) at 2025-07-12 23:34:17 +0000