mirror of https://github.com/goccy/go-json.git
104 lines
2.7 KiB
Go
104 lines
2.7 KiB
Go
package vm_indent
|
|
|
|
import (
|
|
"encoding/json"
|
|
"unsafe"
|
|
|
|
"github.com/goccy/go-json/internal/encoder"
|
|
"github.com/goccy/go-json/internal/runtime"
|
|
)
|
|
|
|
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))
|
|
for i := 0; i < ptrNum; i++ {
|
|
if p == 0 {
|
|
return 0
|
|
}
|
|
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 *encoder.Opcode, p uintptr) interface{} {
|
|
return *(*interface{})(unsafe.Pointer(&emptyInterface{
|
|
typ: code.Type,
|
|
ptr: *(*unsafe.Pointer)(unsafe.Pointer(&p)),
|
|
}))
|
|
}
|
|
|
|
func appendBool(b []byte, v bool) []byte {
|
|
if v {
|
|
return append(b, "true"...)
|
|
}
|
|
return append(b, "false"...)
|
|
}
|
|
|
|
func appendNull(b []byte) []byte {
|
|
return append(b, "null"...)
|
|
}
|
|
|
|
func appendComma(b []byte) []byte {
|
|
return append(b, ',', '\n')
|
|
}
|
|
|
|
func appendStructHead(b []byte) []byte {
|
|
return append(b, '{', '\n')
|
|
}
|
|
|
|
func appendStructKey(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
|
|
b = appendIndent(ctx, b, code.Indent)
|
|
b = append(b, code.Key...)
|
|
return append(b, ' ')
|
|
}
|
|
|
|
func appendStructEndSkipLast(ctx *encoder.RuntimeContext, b []byte, code *encoder.Opcode) []byte {
|
|
last := len(b) - 1
|
|
if b[last-1] == '{' {
|
|
b[last] = '}'
|
|
} else {
|
|
if b[last] == '\n' {
|
|
// to remove ',' and '\n' characters
|
|
b = b[:len(b)-2]
|
|
}
|
|
b = append(b, '\n')
|
|
b = appendIndent(ctx, b, code.Indent-1)
|
|
b = append(b, '}')
|
|
}
|
|
return appendComma(b)
|
|
}
|