summaryrefslogtreecommitdiff
path: root/vendor/github.com/goccy/go-json/internal/encoder/encoder.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/goccy/go-json/internal/encoder/encoder.go')
-rw-r--r--vendor/github.com/goccy/go-json/internal/encoder/encoder.go551
1 files changed, 0 insertions, 551 deletions
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/encoder.go b/vendor/github.com/goccy/go-json/internal/encoder/encoder.go
deleted file mode 100644
index b7fa99a96..000000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/encoder.go
+++ /dev/null
@@ -1,551 +0,0 @@
-package encoder
-
-import (
- "bytes"
- "encoding"
- "encoding/base64"
- "encoding/json"
- "fmt"
- "math"
- "reflect"
- "strconv"
- "strings"
- "sync"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-func (t OpType) IsMultipleOpHead() bool {
- switch t {
- case OpStructHead:
- return true
- case OpStructHeadSlice:
- return true
- case OpStructHeadArray:
- return true
- case OpStructHeadMap:
- return true
- case OpStructHeadStruct:
- return true
- case OpStructHeadOmitEmpty:
- return true
- case OpStructHeadOmitEmptySlice:
- return true
- case OpStructHeadOmitEmptyArray:
- return true
- case OpStructHeadOmitEmptyMap:
- return true
- case OpStructHeadOmitEmptyStruct:
- return true
- case OpStructHeadSlicePtr:
- return true
- case OpStructHeadOmitEmptySlicePtr:
- return true
- case OpStructHeadArrayPtr:
- return true
- case OpStructHeadOmitEmptyArrayPtr:
- return true
- case OpStructHeadMapPtr:
- return true
- case OpStructHeadOmitEmptyMapPtr:
- return true
- }
- return false
-}
-
-func (t OpType) IsMultipleOpField() bool {
- switch t {
- case OpStructField:
- return true
- case OpStructFieldSlice:
- return true
- case OpStructFieldArray:
- return true
- case OpStructFieldMap:
- return true
- case OpStructFieldStruct:
- return true
- case OpStructFieldOmitEmpty:
- return true
- case OpStructFieldOmitEmptySlice:
- return true
- case OpStructFieldOmitEmptyArray:
- return true
- case OpStructFieldOmitEmptyMap:
- return true
- case OpStructFieldOmitEmptyStruct:
- return true
- case OpStructFieldSlicePtr:
- return true
- case OpStructFieldOmitEmptySlicePtr:
- return true
- case OpStructFieldArrayPtr:
- return true
- case OpStructFieldOmitEmptyArrayPtr:
- return true
- case OpStructFieldMapPtr:
- return true
- case OpStructFieldOmitEmptyMapPtr:
- return true
- }
- return false
-}
-
-type OpcodeSet struct {
- Type *runtime.Type
- NoescapeKeyCode *Opcode
- EscapeKeyCode *Opcode
- InterfaceNoescapeKeyCode *Opcode
- InterfaceEscapeKeyCode *Opcode
- CodeLength int
- EndCode *Opcode
-}
-
-type CompiledCode struct {
- Code *Opcode
- Linked bool // whether recursive code already have linked
- CurLen uintptr
- NextLen uintptr
-}
-
-const StartDetectingCyclesAfter = 1000
-
-func Load(base uintptr, idx uintptr) uintptr {
- addr := base + idx
- return **(**uintptr)(unsafe.Pointer(&addr))
-}
-
-func Store(base uintptr, idx uintptr, p uintptr) {
- addr := base + idx
- **(**uintptr)(unsafe.Pointer(&addr)) = p
-}
-
-func LoadNPtr(base uintptr, idx uintptr, ptrNum int) uintptr {
- addr := base + idx
- p := **(**uintptr)(unsafe.Pointer(&addr))
- if p == 0 {
- return 0
- }
- return PtrToPtr(p)
- /*
- for i := 0; i < ptrNum; i++ {
- if p == 0 {
- return p
- }
- p = PtrToPtr(p)
- }
- return p
- */
-}
-
-func PtrToUint64(p uintptr) uint64 { return **(**uint64)(unsafe.Pointer(&p)) }
-func PtrToFloat32(p uintptr) float32 { return **(**float32)(unsafe.Pointer(&p)) }
-func PtrToFloat64(p uintptr) float64 { return **(**float64)(unsafe.Pointer(&p)) }
-func PtrToBool(p uintptr) bool { return **(**bool)(unsafe.Pointer(&p)) }
-func PtrToBytes(p uintptr) []byte { return **(**[]byte)(unsafe.Pointer(&p)) }
-func PtrToNumber(p uintptr) json.Number { return **(**json.Number)(unsafe.Pointer(&p)) }
-func PtrToString(p uintptr) string { return **(**string)(unsafe.Pointer(&p)) }
-func PtrToSlice(p uintptr) *runtime.SliceHeader { return *(**runtime.SliceHeader)(unsafe.Pointer(&p)) }
-func PtrToPtr(p uintptr) uintptr {
- return uintptr(**(**unsafe.Pointer)(unsafe.Pointer(&p)))
-}
-func PtrToNPtr(p uintptr, ptrNum int) uintptr {
- for i := 0; i < ptrNum; i++ {
- if p == 0 {
- return 0
- }
- p = PtrToPtr(p)
- }
- return p
-}
-
-func PtrToUnsafePtr(p uintptr) unsafe.Pointer {
- return *(*unsafe.Pointer)(unsafe.Pointer(&p))
-}
-func PtrToInterface(code *Opcode, p uintptr) interface{} {
- return *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: code.Type,
- ptr: *(*unsafe.Pointer)(unsafe.Pointer(&p)),
- }))
-}
-
-func ErrUnsupportedValue(code *Opcode, ptr uintptr) *errors.UnsupportedValueError {
- v := *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: code.Type,
- ptr: *(*unsafe.Pointer)(unsafe.Pointer(&ptr)),
- }))
- return &errors.UnsupportedValueError{
- Value: reflect.ValueOf(v),
- Str: fmt.Sprintf("encountered a cycle via %s", code.Type),
- }
-}
-
-func ErrUnsupportedFloat(v float64) *errors.UnsupportedValueError {
- return &errors.UnsupportedValueError{
- Value: reflect.ValueOf(v),
- Str: strconv.FormatFloat(v, 'g', -1, 64),
- }
-}
-
-func ErrMarshalerWithCode(code *Opcode, err error) *errors.MarshalerError {
- return &errors.MarshalerError{
- Type: runtime.RType2Type(code.Type),
- Err: err,
- }
-}
-
-type emptyInterface struct {
- typ *runtime.Type
- ptr unsafe.Pointer
-}
-
-type MapItem struct {
- Key []byte
- Value []byte
-}
-
-type Mapslice struct {
- Items []MapItem
-}
-
-func (m *Mapslice) Len() int {
- return len(m.Items)
-}
-
-func (m *Mapslice) Less(i, j int) bool {
- return bytes.Compare(m.Items[i].Key, m.Items[j].Key) < 0
-}
-
-func (m *Mapslice) Swap(i, j int) {
- m.Items[i], m.Items[j] = m.Items[j], m.Items[i]
-}
-
-type MapContext struct {
- Pos []int
- Slice *Mapslice
- Buf []byte
-}
-
-var mapContextPool = sync.Pool{
- New: func() interface{} {
- return &MapContext{}
- },
-}
-
-func NewMapContext(mapLen int) *MapContext {
- ctx := mapContextPool.Get().(*MapContext)
- if ctx.Slice == nil {
- ctx.Slice = &Mapslice{
- Items: make([]MapItem, 0, mapLen),
- }
- }
- if cap(ctx.Pos) < (mapLen*2 + 1) {
- ctx.Pos = make([]int, 0, mapLen*2+1)
- ctx.Slice.Items = make([]MapItem, 0, mapLen)
- } else {
- ctx.Pos = ctx.Pos[:0]
- ctx.Slice.Items = ctx.Slice.Items[:0]
- }
- ctx.Buf = ctx.Buf[:0]
- return ctx
-}
-
-func ReleaseMapContext(c *MapContext) {
- mapContextPool.Put(c)
-}
-
-//go:linkname MapIterInit reflect.mapiterinit
-//go:noescape
-func MapIterInit(mapType *runtime.Type, m unsafe.Pointer) unsafe.Pointer
-
-//go:linkname MapIterKey reflect.mapiterkey
-//go:noescape
-func MapIterKey(it unsafe.Pointer) unsafe.Pointer
-
-//go:linkname MapIterNext reflect.mapiternext
-//go:noescape
-func MapIterNext(it unsafe.Pointer)
-
-//go:linkname MapLen reflect.maplen
-//go:noescape
-func MapLen(m unsafe.Pointer) int
-
-func AppendByteSlice(_ *RuntimeContext, b []byte, src []byte) []byte {
- if src == nil {
- return append(b, `null`...)
- }
- encodedLen := base64.StdEncoding.EncodedLen(len(src))
- b = append(b, '"')
- pos := len(b)
- remainLen := cap(b[pos:])
- var buf []byte
- if remainLen > encodedLen {
- buf = b[pos : pos+encodedLen]
- } else {
- buf = make([]byte, encodedLen)
- }
- base64.StdEncoding.Encode(buf, src)
- return append(append(b, buf...), '"')
-}
-
-func AppendFloat32(_ *RuntimeContext, b []byte, v float32) []byte {
- f64 := float64(v)
- abs := math.Abs(f64)
- fmt := byte('f')
- // Note: Must use float32 comparisons for underlying float32 value to get precise cutoffs right.
- if abs != 0 {
- f32 := float32(abs)
- if f32 < 1e-6 || f32 >= 1e21 {
- fmt = 'e'
- }
- }
- return strconv.AppendFloat(b, f64, fmt, -1, 32)
-}
-
-func AppendFloat64(_ *RuntimeContext, b []byte, v float64) []byte {
- abs := math.Abs(v)
- fmt := byte('f')
- // Note: Must use float32 comparisons for underlying float32 value to get precise cutoffs right.
- if abs != 0 {
- if abs < 1e-6 || abs >= 1e21 {
- fmt = 'e'
- }
- }
- return strconv.AppendFloat(b, v, fmt, -1, 64)
-}
-
-func AppendBool(_ *RuntimeContext, b []byte, v bool) []byte {
- if v {
- return append(b, "true"...)
- }
- return append(b, "false"...)
-}
-
-var (
- floatTable = [256]bool{
- '0': true,
- '1': true,
- '2': true,
- '3': true,
- '4': true,
- '5': true,
- '6': true,
- '7': true,
- '8': true,
- '9': true,
- '.': true,
- 'e': true,
- 'E': true,
- '+': true,
- '-': true,
- }
-)
-
-func AppendNumber(_ *RuntimeContext, b []byte, n json.Number) ([]byte, error) {
- if len(n) == 0 {
- return append(b, '0'), nil
- }
- for i := 0; i < len(n); i++ {
- if !floatTable[n[i]] {
- return nil, fmt.Errorf("json: invalid number literal %q", n)
- }
- }
- b = append(b, n...)
- return b, nil
-}
-
-func AppendMarshalJSON(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) {
- rv := reflect.ValueOf(v) // convert by dynamic interface type
- if (code.Flags & AddrForMarshalerFlags) != 0 {
- if rv.CanAddr() {
- rv = rv.Addr()
- } else {
- newV := reflect.New(rv.Type())
- newV.Elem().Set(rv)
- rv = newV
- }
- }
- v = rv.Interface()
- var bb []byte
- if (code.Flags & MarshalerContextFlags) != 0 {
- marshaler, ok := v.(marshalerContext)
- if !ok {
- return AppendNull(ctx, b), nil
- }
- b, err := marshaler.MarshalJSON(ctx.Option.Context)
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- bb = b
- } else {
- marshaler, ok := v.(json.Marshaler)
- if !ok {
- return AppendNull(ctx, b), nil
- }
- b, err := marshaler.MarshalJSON()
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- bb = b
- }
- marshalBuf := ctx.MarshalBuf[:0]
- marshalBuf = append(append(marshalBuf, bb...), nul)
- compactedBuf, err := compact(b, marshalBuf, (ctx.Option.Flag&HTMLEscapeOption) != 0)
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- ctx.MarshalBuf = marshalBuf
- return compactedBuf, nil
-}
-
-func AppendMarshalJSONIndent(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) {
- rv := reflect.ValueOf(v) // convert by dynamic interface type
- if (code.Flags & AddrForMarshalerFlags) != 0 {
- if rv.CanAddr() {
- rv = rv.Addr()
- } else {
- newV := reflect.New(rv.Type())
- newV.Elem().Set(rv)
- rv = newV
- }
- }
- v = rv.Interface()
- var bb []byte
- if (code.Flags & MarshalerContextFlags) != 0 {
- marshaler, ok := v.(marshalerContext)
- if !ok {
- return AppendNull(ctx, b), nil
- }
- b, err := marshaler.MarshalJSON(ctx.Option.Context)
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- bb = b
- } else {
- marshaler, ok := v.(json.Marshaler)
- if !ok {
- return AppendNull(ctx, b), nil
- }
- b, err := marshaler.MarshalJSON()
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- bb = b
- }
- marshalBuf := ctx.MarshalBuf[:0]
- marshalBuf = append(append(marshalBuf, bb...), nul)
- indentedBuf, err := doIndent(
- b,
- marshalBuf,
- string(ctx.Prefix)+strings.Repeat(string(ctx.IndentStr), int(ctx.BaseIndent+code.Indent)),
- string(ctx.IndentStr),
- (ctx.Option.Flag&HTMLEscapeOption) != 0,
- )
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- ctx.MarshalBuf = marshalBuf
- return indentedBuf, nil
-}
-
-func AppendMarshalText(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) {
- rv := reflect.ValueOf(v) // convert by dynamic interface type
- if (code.Flags & AddrForMarshalerFlags) != 0 {
- if rv.CanAddr() {
- rv = rv.Addr()
- } else {
- newV := reflect.New(rv.Type())
- newV.Elem().Set(rv)
- rv = newV
- }
- }
- v = rv.Interface()
- marshaler, ok := v.(encoding.TextMarshaler)
- if !ok {
- return AppendNull(ctx, b), nil
- }
- bytes, err := marshaler.MarshalText()
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- return AppendString(ctx, b, *(*string)(unsafe.Pointer(&bytes))), nil
-}
-
-func AppendMarshalTextIndent(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) {
- rv := reflect.ValueOf(v) // convert by dynamic interface type
- if (code.Flags & AddrForMarshalerFlags) != 0 {
- if rv.CanAddr() {
- rv = rv.Addr()
- } else {
- newV := reflect.New(rv.Type())
- newV.Elem().Set(rv)
- rv = newV
- }
- }
- v = rv.Interface()
- marshaler, ok := v.(encoding.TextMarshaler)
- if !ok {
- return AppendNull(ctx, b), nil
- }
- bytes, err := marshaler.MarshalText()
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- return AppendString(ctx, b, *(*string)(unsafe.Pointer(&bytes))), nil
-}
-
-func AppendNull(_ *RuntimeContext, b []byte) []byte {
- return append(b, "null"...)
-}
-
-func AppendComma(_ *RuntimeContext, b []byte) []byte {
- return append(b, ',')
-}
-
-func AppendCommaIndent(_ *RuntimeContext, b []byte) []byte {
- return append(b, ',', '\n')
-}
-
-func AppendStructEnd(_ *RuntimeContext, b []byte) []byte {
- return append(b, '}', ',')
-}
-
-func AppendStructEndIndent(ctx *RuntimeContext, code *Opcode, b []byte) []byte {
- b = append(b, '\n')
- b = append(b, ctx.Prefix...)
- indentNum := ctx.BaseIndent + code.Indent - 1
- for i := uint32(0); i < indentNum; i++ {
- b = append(b, ctx.IndentStr...)
- }
- return append(b, '}', ',', '\n')
-}
-
-func AppendIndent(ctx *RuntimeContext, b []byte, indent uint32) []byte {
- b = append(b, ctx.Prefix...)
- indentNum := ctx.BaseIndent + indent
- for i := uint32(0); i < indentNum; i++ {
- b = append(b, ctx.IndentStr...)
- }
- return b
-}
-
-func IsNilForMarshaler(v interface{}) bool {
- rv := reflect.ValueOf(v)
- switch rv.Kind() {
- case reflect.Bool:
- return !rv.Bool()
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return rv.Int() == 0
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return rv.Uint() == 0
- case reflect.Float32, reflect.Float64:
- return math.Float64bits(rv.Float()) == 0
- case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Func:
- return rv.IsNil()
- case reflect.Slice:
- return rv.IsNil() || rv.Len() == 0
- }
- return false
-}
generated by cgit v1.2.3 (git 2.46.0) at 2025-07-13 15:17:54 +0000