diff options
Diffstat (limited to 'vendor/github.com/goccy/go-json/internal')
53 files changed, 13234 insertions, 7402 deletions
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go b/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go new file mode 100644 index 000000000..030cb7a97 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go @@ -0,0 +1,37 @@ +package decoder + +import ( + "unsafe" + + "github.com/goccy/go-json/internal/runtime" +) + +type anonymousFieldDecoder struct { + structType *runtime.Type + offset uintptr + dec Decoder +} + +func newAnonymousFieldDecoder(structType *runtime.Type, offset uintptr, dec Decoder) *anonymousFieldDecoder { + return &anonymousFieldDecoder{ + structType: structType, + offset: offset, + dec: dec, + } +} + +func (d *anonymousFieldDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + if *(*unsafe.Pointer)(p) == nil { + *(*unsafe.Pointer)(p) = unsafe_New(d.structType) + } + p = *(*unsafe.Pointer)(p) + return d.dec.DecodeStream(s, depth, unsafe.Pointer(uintptr(p)+d.offset)) +} + +func (d *anonymousFieldDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + if *(*unsafe.Pointer)(p) == nil { + *(*unsafe.Pointer)(p) = unsafe_New(d.structType) + } + p = *(*unsafe.Pointer)(p) + return d.dec.Decode(ctx, cursor, depth, unsafe.Pointer(uintptr(p)+d.offset)) +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/array.go b/vendor/github.com/goccy/go-json/internal/decoder/array.go new file mode 100644 index 000000000..21f1fd585 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/array.go @@ -0,0 +1,169 @@ +package decoder + +import ( + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type arrayDecoder struct { + elemType *runtime.Type + size uintptr + valueDecoder Decoder + alen int + structName string + fieldName string + zeroValue unsafe.Pointer +} + +func newArrayDecoder(dec Decoder, elemType *runtime.Type, alen int, structName, fieldName string) *arrayDecoder { + zeroValue := *(*unsafe.Pointer)(unsafe_New(elemType)) + return &arrayDecoder{ + valueDecoder: dec, + elemType: elemType, + size: elemType.Size(), + alen: alen, + structName: structName, + fieldName: fieldName, + zeroValue: zeroValue, + } +} + +func (d *arrayDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + depth++ + if depth > maxDecodeNestingDepth { + return errors.ErrExceededMaxDepth(s.char(), s.cursor) + } + + for { + switch s.char() { + case ' ', '\n', '\t', '\r': + case 'n': + if err := nullBytes(s); err != nil { + return err + } + return nil + case '[': + idx := 0 + s.cursor++ + if s.skipWhiteSpace() == ']' { + for idx < d.alen { + *(*unsafe.Pointer)(unsafe.Pointer(uintptr(p) + uintptr(idx)*d.size)) = d.zeroValue + idx++ + } + s.cursor++ + return nil + } + for { + if idx < d.alen { + if err := d.valueDecoder.DecodeStream(s, depth, unsafe.Pointer(uintptr(p)+uintptr(idx)*d.size)); err != nil { + return err + } + } else { + if err := s.skipValue(depth); err != nil { + return err + } + } + idx++ + switch s.skipWhiteSpace() { + case ']': + for idx < d.alen { + *(*unsafe.Pointer)(unsafe.Pointer(uintptr(p) + uintptr(idx)*d.size)) = d.zeroValue + idx++ + } + s.cursor++ + return nil + case ',': + s.cursor++ + continue + case nul: + if s.read() { + s.cursor++ + continue + } + goto ERROR + default: + goto ERROR + } + } + case nul: + if s.read() { + continue + } + goto ERROR + default: + goto ERROR + } + s.cursor++ + } +ERROR: + return errors.ErrUnexpectedEndOfJSON("array", s.totalOffset()) +} + +func (d *arrayDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + depth++ + if depth > maxDecodeNestingDepth { + return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor) + } + + for { + switch buf[cursor] { + case ' ', '\n', '\t', '\r': + cursor++ + continue + case 'n': + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + return cursor, nil + case '[': + idx := 0 + cursor++ + cursor = skipWhiteSpace(buf, cursor) + if buf[cursor] == ']' { + for idx < d.alen { + *(*unsafe.Pointer)(unsafe.Pointer(uintptr(p) + uintptr(idx)*d.size)) = d.zeroValue + idx++ + } + cursor++ + return cursor, nil + } + for { + if idx < d.alen { + c, err := d.valueDecoder.Decode(ctx, cursor, depth, unsafe.Pointer(uintptr(p)+uintptr(idx)*d.size)) + if err != nil { + return 0, err + } + cursor = c + } else { + c, err := skipValue(buf, cursor, depth) + if err != nil { + return 0, err + } + cursor = c + } + idx++ + cursor = skipWhiteSpace(buf, cursor) + switch buf[cursor] { + case ']': + for idx < d.alen { + *(*unsafe.Pointer)(unsafe.Pointer(uintptr(p) + uintptr(idx)*d.size)) = d.zeroValue + idx++ + } + cursor++ + return cursor, nil + case ',': + cursor++ + continue + default: + return 0, errors.ErrInvalidCharacter(buf[cursor], "array", cursor) + } + } + default: + return 0, errors.ErrUnexpectedEndOfJSON("array", cursor) + } + } +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/bool.go b/vendor/github.com/goccy/go-json/internal/decoder/bool.go new file mode 100644 index 000000000..455042a53 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/bool.go @@ -0,0 +1,78 @@ +package decoder + +import ( + "unsafe" + + "github.com/goccy/go-json/internal/errors" +) + +type boolDecoder struct { + structName string + fieldName string +} + +func newBoolDecoder(structName, fieldName string) *boolDecoder { + return &boolDecoder{structName: structName, fieldName: fieldName} +} + +func (d *boolDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + c := s.skipWhiteSpace() + for { + switch c { + case 't': + if err := trueBytes(s); err != nil { + return err + } + **(**bool)(unsafe.Pointer(&p)) = true + return nil + case 'f': + if err := falseBytes(s); err != nil { + return err + } + **(**bool)(unsafe.Pointer(&p)) = false + return nil + case 'n': + if err := nullBytes(s); err != nil { + return err + } + return nil + case nul: + if s.read() { + c = s.char() + continue + } + goto ERROR + } + break + } +ERROR: + return errors.ErrUnexpectedEndOfJSON("bool", s.totalOffset()) +} + +func (d *boolDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + cursor = skipWhiteSpace(buf, cursor) + switch buf[cursor] { + case 't': + if err := validateTrue(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + **(**bool)(unsafe.Pointer(&p)) = true + return cursor, nil + case 'f': + if err := validateFalse(buf, cursor); err != nil { + return 0, err + } + cursor += 5 + **(**bool)(unsafe.Pointer(&p)) = false + return cursor, nil + case 'n': + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + return cursor, nil + } + return 0, errors.ErrUnexpectedEndOfJSON("bool", cursor) +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/bytes.go b/vendor/github.com/goccy/go-json/internal/decoder/bytes.go new file mode 100644 index 000000000..01a37fef4 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/bytes.go @@ -0,0 +1,114 @@ +package decoder + +import ( + "encoding/base64" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type bytesDecoder struct { + typ *runtime.Type + sliceDecoder Decoder + stringDecoder *stringDecoder + structName string + fieldName string +} + +func byteUnmarshalerSliceDecoder(typ *runtime.Type, structName string, fieldName string) Decoder { + var unmarshalDecoder Decoder + switch { + case runtime.PtrTo(typ).Implements(unmarshalJSONType): + unmarshalDecoder = newUnmarshalJSONDecoder(runtime.PtrTo(typ), structName, fieldName) + case runtime.PtrTo(typ).Implements(unmarshalTextType): + unmarshalDecoder = newUnmarshalTextDecoder(runtime.PtrTo(typ), structName, fieldName) + } + if unmarshalDecoder == nil { + return nil + } + return newSliceDecoder(unmarshalDecoder, typ, 1, structName, fieldName) +} + +func newBytesDecoder(typ *runtime.Type, structName string, fieldName string) *bytesDecoder { + return &bytesDecoder{ + typ: typ, + sliceDecoder: byteUnmarshalerSliceDecoder(typ, structName, fieldName), + stringDecoder: newStringDecoder(structName, fieldName), + structName: structName, + fieldName: fieldName, + } +} + +func (d *bytesDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + bytes, err := d.decodeStreamBinary(s, depth, p) + if err != nil { + return err + } + if bytes == nil { + s.reset() + return nil + } + decodedLen := base64.StdEncoding.DecodedLen(len(bytes)) + buf := make([]byte, decodedLen) + n, err := base64.StdEncoding.Decode(buf, bytes) + if err != nil { + return err + } + *(*[]byte)(p) = buf[:n] + s.reset() + return nil +} + +func (d *bytesDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + bytes, c, err := d.decodeBinary(ctx, cursor, depth, p) + if err != nil { + return 0, err + } + if bytes == nil { + return c, nil + } + cursor = c + decodedLen := base64.StdEncoding.DecodedLen(len(bytes)) + b := make([]byte, decodedLen) + n, err := base64.StdEncoding.Decode(b, bytes) + if err != nil { + return 0, err + } + *(*[]byte)(p) = b[:n] + return cursor, nil +} + +func (d *bytesDecoder) decodeStreamBinary(s *Stream, depth int64, p unsafe.Pointer) ([]byte, error) { + c := s.skipWhiteSpace() + if c == '[' { + if d.sliceDecoder == nil { + return nil, &errors.UnmarshalTypeError{ + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + } + err := d.sliceDecoder.DecodeStream(s, depth, p) + return nil, err + } + return d.stringDecoder.decodeStreamByte(s) +} + +func (d *bytesDecoder) decodeBinary(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) ([]byte, int64, error) { + buf := ctx.Buf + cursor = skipWhiteSpace(buf, cursor) + if buf[cursor] == '[' { + if d.sliceDecoder == nil { + return nil, 0, &errors.UnmarshalTypeError{ + Type: runtime.RType2Type(d.typ), + Offset: cursor, + } + } + c, err := d.sliceDecoder.Decode(ctx, cursor, depth, p) + if err != nil { + return nil, 0, err + } + return nil, c, nil + } + return d.stringDecoder.decodeByte(buf, cursor) +} 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..08dd044e6 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/compile.go @@ -0,0 +1,510 @@ +package decoder + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" + "sync/atomic" + "unicode" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "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) +} + +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 nil, &errors.UnmarshalTypeError{ + Value: "object", + Type: runtime.RType2Type(typ), + Offset: 0, + Struct: structName, + Field: fieldName, + } +} + +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 + } + 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: + goto ERROR + } + } +ERROR: + return nil, &errors.UnmarshalTypeError{ + Value: "object", + Type: runtime.RType2Type(typ), + Offset: 0, + Struct: structName, + Field: fieldName, + } +} + +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 removeConflictFields(fieldMap map[string]*structFieldSet, conflictedMap map[string]struct{}, dec *structDecoder, field reflect.StructField) { + for k, v := range dec.fieldMap { + if _, exists := conflictedMap[k]; exists { + // already conflicted key + continue + } + set, exists := fieldMap[k] + if !exists { + fieldSet := &structFieldSet{ + dec: v.dec, + offset: field.Offset + v.offset, + isTaggedKey: v.isTaggedKey, + key: k, + keyLen: int64(len(k)), + } + fieldMap[k] = fieldSet + lower := strings.ToLower(k) + if _, exists := fieldMap[lower]; !exists { + fieldMap[lower] = fieldSet + } + continue + } + if set.isTaggedKey { + if v.isTaggedKey { + // conflict tag key + delete(fieldMap, k) + delete(fieldMap, strings.ToLower(k)) + conflictedMap[k] = struct{}{} + conflictedMap[strings.ToLower(k)] = struct{}{} + } + } else { + if v.isTaggedKey { + fieldSet := &structFieldSet{ + dec: v.dec, + offset: field.Offset + v.offset, + isTaggedKey: v.isTaggedKey, + key: k, + keyLen: int64(len(k)), + } + fieldMap[k] = fieldSet + lower := strings.ToLower(k) + if _, exists := fieldMap[lower]; !exists { + fieldMap[lower] = fieldSet + } + } else { + // conflict tag key + delete(fieldMap, k) + delete(fieldMap, strings.ToLower(k)) + conflictedMap[k] = struct{}{} + conflictedMap[strings.ToLower(k)] = struct{}{} + } + } + } +} + +func compileStruct(typ *runtime.Type, 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 := structTypeToDecoder[typeptr]; exists { + return dec, nil + } + structDec := newStructDecoder(structName, fieldName, fieldMap) + structTypeToDecoder[typeptr] = structDec + structName = typ.Name() + 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 + } + removeConflictFields(fieldMap, conflictedMap, stDec, field) + } 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 _, exists := conflictedMap[k]; exists { + // already conflicted key + continue + } + set, exists := fieldMap[k] + if !exists { + fieldSet := &structFieldSet{ + dec: newAnonymousFieldDecoder(pdec.typ, v.offset, v.dec), + offset: field.Offset, + isTaggedKey: v.isTaggedKey, + key: k, + keyLen: int64(len(k)), + err: fieldSetErr, + } + fieldMap[k] = fieldSet + lower := strings.ToLower(k) + if _, exists := fieldMap[lower]; !exists { + fieldMap[lower] = fieldSet + } + continue + } + if set.isTaggedKey { + if v.isTaggedKey { + // conflict tag key + delete(fieldMap, k) + delete(fieldMap, strings.ToLower(k)) + conflictedMap[k] = struct{}{} + conflictedMap[strings.ToLower(k)] = struct{}{} + } + } else { + if v.isTaggedKey { + fieldSet := &structFieldSet{ + dec: newAnonymousFieldDecoder(pdec.typ, v.offset, v.dec), + offset: field.Offset, + isTaggedKey: v.isTaggedKey, + key: k, + keyLen: int64(len(k)), + err: fieldSetErr, + } + fieldMap[k] = fieldSet + lower := strings.ToLower(k) + if _, exists := fieldMap[lower]; !exists { + fieldMap[lower] = fieldSet + } + } else { + // conflict tag key + delete(fieldMap, k) + delete(fieldMap, strings.ToLower(k)) + conflictedMap[k] = struct{}{} + conflictedMap[strings.ToLower(k)] = struct{}{} + } + } + } + } + } + } 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)), + } + fieldMap[key] = fieldSet + lower := strings.ToLower(key) + if _, exists := fieldMap[lower]; !exists { + fieldMap[lower] = fieldSet + } + } + } + delete(structTypeToDecoder, typeptr) + structDec.tryOptimize() + return structDec, nil +} + +func implementsUnmarshalJSONType(typ *runtime.Type) bool { + return typ.Implements(unmarshalJSONType) || typ.Implements(unmarshalJSONContextType) +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/compile_norace.go b/vendor/github.com/goccy/go-json/internal/decoder/compile_norace.go new file mode 100644 index 000000000..592f63737 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/compile_norace.go @@ -0,0 +1,28 @@ +// +build !race + +package decoder + +import ( + "unsafe" + + "github.com/goccy/go-json/internal/runtime" +) + +func CompileToGetDecoder(typ *runtime.Type) (Decoder, error) { + typeptr := uintptr(unsafe.Pointer(typ)) + if typeptr > typeAddr.MaxTypeAddr { + return compileToGetDecoderSlowPath(typeptr, typ) + } + + index := (typeptr - typeAddr.BaseTypeAddr) >> typeAddr.AddrShift + if dec := cachedDecoder[index]; dec != nil { + return dec, nil + } + + dec, err := compileHead(typ, map[uintptr]Decoder{}) + if err != nil { + return nil, err + } + cachedDecoder[index] = dec + return dec, nil +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/compile_race.go b/vendor/github.com/goccy/go-json/internal/decoder/compile_race.go new file mode 100644 index 000000000..b691bc947 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/compile_race.go @@ -0,0 +1,36 @@ +// +build race + +package decoder + +import ( + "sync" + "unsafe" + + "github.com/goccy/go-json/internal/runtime" +) + +var decMu sync.RWMutex + +func CompileToGetDecoder(typ *runtime.Type) (Decoder, error) { + typeptr := uintptr(unsafe.Pointer(typ)) + if typeptr > typeAddr.MaxTypeAddr { + return compileToGetDecoderSlowPath(typeptr, typ) + } + + index := (typeptr - typeAddr.BaseTypeAddr) >> typeAddr.AddrShift + decMu.RLock() + if dec := cachedDecoder[index]; dec != nil { + decMu.RUnlock() + return dec, nil + } + decMu.RUnlock() + + dec, err := compileHead(typ, map[uintptr]Decoder{}) + if err != nil { + return nil, err + } + decMu.Lock() + cachedDecoder[index] = dec + decMu.Unlock() + return dec, nil +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/context.go b/vendor/github.com/goccy/go-json/internal/decoder/context.go new file mode 100644 index 000000000..cb2ffdafd --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/context.go @@ -0,0 +1,254 @@ +package decoder + +import ( + "sync" + "unsafe" + + "github.com/goccy/go-json/internal/errors" +) + +type RuntimeContext struct { + Buf []byte + Option *Option +} + +var ( + runtimeContextPool = sync.Pool{ + New: func() interface{} { + return &RuntimeContext{ + Option: &Option{}, + } + }, + } +) + +func TakeRuntimeContext() *RuntimeContext { + return runtimeContextPool.Get().(*RuntimeContext) +} + +func ReleaseRuntimeContext(ctx *RuntimeContext) { + runtimeContextPool.Put(ctx) +} + +var ( + isWhiteSpace = [256]bool{} +) + +func init() { + isWhiteSpace[' '] = true + isWhiteSpace['\n'] = true + isWhiteSpace['\t'] = true + isWhiteSpace['\r'] = true +} + +func char(ptr unsafe.Pointer, offset int64) byte { + return *(*byte)(unsafe.Pointer(uintptr(ptr) + uintptr(offset))) +} + +func skipWhiteSpace(buf []byte, cursor int64) int64 { + for isWhiteSpace[buf[cursor]] { + cursor++ + } + return cursor +} + +func skipObject(buf []byte, cursor, depth int64) (int64, error) { + braceCount := 1 + for { + switch buf[cursor] { + case '{': + braceCount++ + depth++ + if depth > maxDecodeNestingDepth { + return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor) + } + case '}': + depth-- + braceCount-- + if braceCount == 0 { + return cursor + 1, nil + } + case '[': + depth++ + if depth > maxDecodeNestingDepth { + return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor) + } + case ']': + depth-- + case '"': + for { + cursor++ + switch buf[cursor] { + case '\\': + cursor++ + if buf[cursor] == nul { + return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + case '"': + goto SWITCH_OUT + case nul: + return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + } + case nul: + return 0, errors.ErrUnexpectedEndOfJSON("object of object", cursor) + } + SWITCH_OUT: + cursor++ + } +} + +func skipArray(buf []byte, cursor, depth int64) (int64, error) { + bracketCount := 1 + for { + switch buf[cursor] { + case '[': + bracketCount++ + depth++ + if depth > maxDecodeNestingDepth { + return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor) + } + case ']': + bracketCount-- + depth-- + if bracketCount == 0 { + return cursor + 1, nil + } + case '{': + depth++ + if depth > maxDecodeNestingDepth { + return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor) + } + case '}': + depth-- + case '"': + for { + cursor++ + switch buf[cursor] { + case '\\': + cursor++ + if buf[cursor] == nul { + return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + case '"': + goto SWITCH_OUT + case nul: + return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + } + case nul: + return 0, errors.ErrUnexpectedEndOfJSON("array of object", cursor) + } + SWITCH_OUT: + cursor++ + } +} + +func skipValue(buf []byte, cursor, depth int64) (int64, error) { + for { + switch buf[cursor] { + case ' ', '\t', '\n', '\r': + cursor++ + continue + case '{': + return skipObject(buf, cursor+1, depth+1) + case '[': + return skipArray(buf, cursor+1, depth+1) + case '"': + for { + cursor++ + switch buf[cursor] { + case '\\': + cursor++ + if buf[cursor] == nul { + return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + case '"': + return cursor + 1, nil + case nul: + return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + } + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + for { + cursor++ + if floatTable[buf[cursor]] { + continue + } + break + } + return cursor, nil + case 't': + if err := validateTrue(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + return cursor, nil + case 'f': + if err := validateFalse(buf, cursor); err != nil { + return 0, err + } + cursor += 5 + return cursor, nil + case 'n': + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + return cursor, nil + default: + return cursor, errors.ErrUnexpectedEndOfJSON("null", cursor) + } + } +} + +func validateTrue(buf []byte, cursor int64) error { + if cursor+3 >= int64(len(buf)) { + return errors.ErrUnexpectedEndOfJSON("true", cursor) + } + if buf[cursor+1] != 'r' { + return errors.ErrInvalidCharacter(buf[cursor+1], "true", cursor) + } + if buf[cursor+2] != 'u' { + return errors.ErrInvalidCharacter(buf[cursor+2], "true", cursor) + } + if buf[cursor+3] != 'e' { + return errors.ErrInvalidCharacter(buf[cursor+3], "true", cursor) + } + return nil +} + +func validateFalse(buf []byte, cursor int64) error { + if cursor+4 >= int64(len(buf)) { + return errors.ErrUnexpectedEndOfJSON("false", cursor) + } + if buf[cursor+1] != 'a' { + return errors.ErrInvalidCharacter(buf[cursor+1], "false", cursor) + } + if buf[cursor+2] != 'l' { + return errors.ErrInvalidCharacter(buf[cursor+2], "false", cursor) + } + if buf[cursor+3] != 's' { + return errors.ErrInvalidCharacter(buf[cursor+3], "false", cursor) + } + if buf[cursor+4] != 'e' { + return errors.ErrInvalidCharacter(buf[cursor+4], "false", cursor) + } + return nil +} + +func validateNull(buf []byte, cursor int64) error { + if cursor+3 >= int64(len(buf)) { + return errors.ErrUnexpectedEndOfJSON("null", cursor) + } + if buf[cursor+1] != 'u' { + return errors.ErrInvalidCharacter(buf[cursor+1], "null", cursor) + } + if buf[cursor+2] != 'l' { + return errors.ErrInvalidCharacter(buf[cursor+2], "null", cursor) + } + if buf[cursor+3] != 'l' { + return errors.ErrInvalidCharacter(buf[cursor+3], "null", cursor) + } + return nil +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/float.go b/vendor/github.com/goccy/go-json/internal/decoder/float.go new file mode 100644 index 000000000..dfb7168da --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/float.go @@ -0,0 +1,158 @@ +package decoder + +import ( + "strconv" + "unsafe" + + "github.com/goccy/go-json/internal/errors" +) + +type floatDecoder struct { + op func(unsafe.Pointer, float64) + structName string + fieldName string +} + +func newFloatDecoder(structName, fieldName string, op func(unsafe.Pointer, float64)) *floatDecoder { + return &floatDecoder{op: op, structName: structName, fieldName: fieldName} +} + +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, + } + + validEndNumberChar = [256]bool{ + nul: true, + ' ': true, + '\t': true, + '\r': true, + '\n': true, + ',': true, + ':': true, + '}': true, + ']': true, + } +) + +func floatBytes(s *Stream) []byte { + start := s.cursor + for { + s.cursor++ + if floatTable[s.char()] { + continue + } else if s.char() == nul { + if s.read() { + s.cursor-- // for retry current character + continue + } + } + break + } + return s.buf[start:s.cursor] +} + +func (d *floatDecoder) decodeStreamByte(s *Stream) ([]byte, error) { + for { + switch s.char() { + case ' ', '\n', '\t', '\r': + s.cursor++ + continue + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return floatBytes(s), nil + case 'n': + if err := nullBytes(s); err != nil { + return nil, err + } + return nil, nil + case nul: + if s.read() { + continue + } + goto ERROR + default: + goto ERROR + } + } +ERROR: + return nil, errors.ErrUnexpectedEndOfJSON("float", s.totalOffset()) +} + +func (d *floatDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) { + for { + switch buf[cursor] { + case ' ', '\n', '\t', '\r': + cursor++ + continue + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + start := cursor + cursor++ + for floatTable[buf[cursor]] { + cursor++ + } + num := buf[start:cursor] + return num, cursor, nil + case 'n': + if err := validateNull(buf, cursor); err != nil { + return nil, 0, err + } + cursor += 4 + return nil, cursor, nil + default: + return nil, 0, errors.ErrUnexpectedEndOfJSON("float", cursor) + } + } +} + +func (d *floatDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + bytes, err := d.decodeStreamByte(s) + if err != nil { + return err + } + if bytes == nil { + return nil + } + str := *(*string)(unsafe.Pointer(&bytes)) + f64, err := strconv.ParseFloat(str, 64) + if err != nil { + return errors.ErrSyntax(err.Error(), s.totalOffset()) + } + d.op(p, f64) + return nil +} + +func (d *floatDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + bytes, c, err := d.decodeByte(buf, cursor) + if err != nil { + return 0, err + } + if bytes == nil { + return c, nil + } + cursor = c + if !validEndNumberChar[buf[cursor]] { + return 0, errors.ErrUnexpectedEndOfJSON("float", cursor) + } + s := *(*string)(unsafe.Pointer(&bytes)) + f64, err := strconv.ParseFloat(s, 64) + if err != nil { + return 0, errors.ErrSyntax(err.Error(), cursor) + } + d.op(p, f64) + return cursor, nil +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/func.go b/vendor/github.com/goccy/go-json/internal/decoder/func.go new file mode 100644 index 000000000..ee3563711 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/func.go @@ -0,0 +1,141 @@ +package decoder + +import ( + "bytes" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type funcDecoder struct { + typ *runtime.Type + structName string + fieldName string +} + +func newFuncDecoder(typ *runtime.Type, structName, fieldName string) *funcDecoder { + fnDecoder := &funcDecoder{typ, structName, fieldName} + return fnDecoder +} + +func (d *funcDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + s.skipWhiteSpace() + start := s.cursor + if err := s.skipValue(depth); err != nil { + return err + } + src := s.buf[start:s.cursor] + if len(src) > 0 { + switch src[0] { + case '"': + return &errors.UnmarshalTypeError{ + Value: "string", + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + case '[': + return &errors.UnmarshalTypeError{ + Value: "array", + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + case '{': + return &errors.UnmarshalTypeError{ + Value: "object", + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return &errors.UnmarshalTypeError{ + Value: "number", + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + case 'n': + if err := nullBytes(s); err != nil { + return err + } + *(*unsafe.Pointer)(p) = nil + return nil + case 't': + if err := trueBytes(s); err == nil { + return &errors.UnmarshalTypeError{ + Value: "boolean", + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + } + case 'f': + if err := falseBytes(s); err == nil { + return &errors.UnmarshalTypeError{ + Value: "boolean", + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + } + } + } + return errors.ErrInvalidBeginningOfValue(s.buf[s.cursor], s.totalOffset()) +} + +func (d *funcDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + cursor = skipWhiteSpace(buf, cursor) + start := cursor + end, err := skipValue(buf, cursor, depth) + if err != nil { + return 0, err + } + src := buf[start:end] + if len(src) > 0 { + switch src[0] { + case '"': + return 0, &errors.UnmarshalTypeError{ + Value: "string", + Type: runtime.RType2Type(d.typ), + Offset: start, + } + case '[': + return 0, &errors.UnmarshalTypeError{ + Value: "array", + Type: runtime.RType2Type(d.typ), + Offset: start, + } + case '{': + return 0, &errors.UnmarshalTypeError{ + Value: "object", + Type: runtime.RType2Type(d.typ), + Offset: start, + } + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return 0, &errors.UnmarshalTypeError{ + Value: "number", + Type: runtime.RType2Type(d.typ), + Offset: start, + } + case 'n': + if bytes.Equal(src, nullbytes) { + *(*unsafe.Pointer)(p) = nil + return end, nil + } + case 't': + if err := validateTrue(buf, start); err == nil { + return 0, &errors.UnmarshalTypeError{ + Value: "boolean", + Type: runtime.RType2Type(d.typ), + Offset: start, + } + } + case 'f': + if err := validateFalse(buf, start); err == nil { + return 0, &errors.UnmarshalTypeError{ + Value: "boolean", + Type: runtime.RType2Type(d.typ), + Offset: start, + } + } + } + } + return cursor, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor) +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/int.go b/vendor/github.com/goccy/go-json/internal/decoder/int.go new file mode 100644 index 000000000..7edfb0411 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/int.go @@ -0,0 +1,242 @@ +package decoder + +import ( + "fmt" + "reflect" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type intDecoder struct { + typ *runtime.Type + kind reflect.Kind + op func(unsafe.Pointer, int64) + structName string + fieldName string +} + +func newIntDecoder(typ *runtime.Type, structName, fieldName string, op func(unsafe.Pointer, int64)) *intDecoder { + return &intDecoder{ + typ: typ, + kind: typ.Kind(), + op: op, + structName: structName, + fieldName: fieldName, + } +} + +func (d *intDecoder) typeError(buf []byte, offset int64) *errors.UnmarshalTypeError { + return &errors.UnmarshalTypeError{ + Value: fmt.Sprintf("number %s", string(buf)), + Type: runtime.RType2Type(d.typ), + Struct: d.structName, + Field: d.fieldName, + Offset: offset, + } +} + +var ( + pow10i64 = [...]int64{ + 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09, + 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, + } + pow10i64Len = len(pow10i64) +) + +func (d *intDecoder) parseInt(b []byte) (int64, error) { + isNegative := false + if b[0] == '-' { + b = b[1:] + isNegative = true + } + maxDigit := len(b) + if maxDigit > pow10i64Len { + return 0, fmt.Errorf("invalid length of number") + } + sum := int64(0) + for i := 0; i < maxDigit; i++ { + c := int64(b[i]) - 48 + digitValue := pow10i64[maxDigit-i-1] + sum += c * digitValue + } + if isNegative { + return -1 * sum, nil + } + return sum, nil +} + +var ( + numTable = [256]bool{ + '0': true, + '1': true, + '2': true, + '3': true, + '4': true, + '5': true, + '6': true, + '7': true, + '8': true, + '9': true, + } +) + +var ( + numZeroBuf = []byte{'0'} +) + +func (d *intDecoder) decodeStreamByte(s *Stream) ([]byte, error) { + for { + switch s.char() { + case ' ', '\n', '\t', '\r': + s.cursor++ + continue + case '-': + start := s.cursor + for { + s.cursor++ + if numTable[s.char()] { + continue + } else if s.char() == nul { + if s.read() { + s.cursor-- // for retry current character + continue + } + } + break + } + num := s.buf[start:s.cursor] + if len(num) < 2 { + goto ERROR + } + return num, nil + case '0': + s.cursor++ + return numZeroBuf, nil + case '1', '2', '3', '4', '5', '6', '7', '8', '9': + start := s.cursor + for { + s.cursor++ + if numTable[s.char()] { + continue + } else if s.char() == nul { + if s.read() { + s.cursor-- // for retry current character + continue + } + } + break + } + num := s.buf[start:s.cursor] + return num, nil + case 'n': + if err := nullBytes(s); err != nil { + return nil, err + } + return nil, nil + case nul: + if s.read() { + continue + } + goto ERROR + default: + return nil, d.typeError([]byte{s.char()}, s.totalOffset()) + } + } +ERROR: + return nil, errors.ErrUnexpectedEndOfJSON("number(integer)", s.totalOffset()) +} + +func (d *intDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) { + b := (*sliceHeader)(unsafe.Pointer(&buf)).data + for { + switch char(b, cursor) { + case ' ', '\n', '\t', '\r': + cursor++ + continue + case '0': + cursor++ + return numZeroBuf, cursor, nil + case '-', '1', '2', '3', '4', '5', '6', '7', '8', '9': + start := cursor + cursor++ + for numTable[char(b, cursor)] { + cursor++ + } + num := buf[start:cursor] + return num, cursor, nil + case 'n': + if err := validateNull(buf, cursor); err != nil { + return nil, 0, err + } + cursor += 4 + return nil, cursor, nil + default: + return nil, 0, d.typeError([]byte{char(b, cursor)}, cursor) + } + } +} + +func (d *intDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + bytes, err := d.decodeStreamByte(s) + if err != nil { + return err + } + if bytes == nil { + return nil + } + i64, err := d.parseInt(bytes) + if err != nil { + return d.typeError(bytes, s.totalOffset()) + } + switch d.kind { + case reflect.Int8: + if i64 <= -1*(1<<7) || (1<<7) <= i64 { + return d.typeError(bytes, s.totalOffset()) + } + case reflect.Int16: + if i64 <= -1*(1<<15) || (1<<15) <= i64 { + return d.typeError(bytes, s.totalOffset()) + } + case reflect.Int32: + if i64 <= -1*(1<<31) || (1<<31) <= i64 { + return d.typeError(bytes, s.totalOffset()) + } + } + d.op(p, i64) + s.reset() + return nil +} + +func (d *intDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + bytes, c, err := d.decodeByte(ctx.Buf, cursor) + if err != nil { + return 0, err + } + if bytes == nil { + return c, nil + } + cursor = c + + i64, err := d.parseInt(bytes) + if err != nil { + return 0, d.typeError(bytes, cursor) + } + switch d.kind { + case reflect.Int8: + if i64 <= -1*(1<<7) || (1<<7) <= i64 { + return 0, d.typeError(bytes, cursor) + } + case reflect.Int16: + if i64 <= -1*(1<<15) || (1<<15) <= i64 { + return 0, d.typeError(bytes, cursor) + } + case reflect.Int32: + if i64 <= -1*(1<<31) || (1<<31) <= i64 { + return 0, d.typeError(bytes, cursor) + } + } + d.op(p, i64) + return cursor, nil +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/interface.go b/vendor/github.com/goccy/go-json/internal/decoder/interface.go new file mode 100644 index 000000000..4dbb4be4a --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/interface.go @@ -0,0 +1,458 @@ +package decoder + +import ( + "bytes" + "encoding" + "encoding/json" + "reflect" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type interfaceDecoder struct { + typ *runtime.Type + structName string + fieldName string + sliceDecoder *sliceDecoder + mapDecoder *mapDecoder + floatDecoder *floatDecoder + numberDecoder *numberDecoder + stringDecoder *stringDecoder +} + +func newEmptyInterfaceDecoder(structName, fieldName string) *interfaceDecoder { + ifaceDecoder := &interfaceDecoder{ + typ: emptyInterfaceType, + structName: structName, + fieldName: fieldName, + floatDecoder: newFloatDecoder(structName, fieldName, func(p unsafe.Pointer, v float64) { + *(*interface{})(p) = v + }), + numberDecoder: newNumberDecoder(structName, fieldName, func(p unsafe.Pointer, v json.Number) { + *(*interface{})(p) = v + }), + stringDecoder: newStringDecoder(structName, fieldName), + } + ifaceDecoder.sliceDecoder = newSliceDecoder( + ifaceDecoder, + emptyInterfaceType, + emptyInterfaceType.Size(), + structName, fieldName, + ) + ifaceDecoder.mapDecoder = newMapDecoder( + interfaceMapType, + stringType, + ifaceDecoder.stringDecoder, + interfaceMapType.Elem(), + ifaceDecoder, + structName, + fieldName, + ) + return ifaceDecoder +} + +func newInterfaceDecoder(typ *runtime.Type, structName, fieldName string) *interfaceDecoder { + emptyIfaceDecoder := newEmptyInterfaceDecoder(structName, fieldName) + stringDecoder := newStringDecoder(structName, fieldName) + return &interfaceDecoder{ + typ: typ, + structName: structName, + fieldName: fieldName, + sliceDecoder: newSliceDecoder( + emptyIfaceDecoder, + emptyInterfaceType, + emptyInterfaceType.Size(), + structName, fieldName, + ), + mapDecoder: newMapDecoder( + interfaceMapType, + stringType, + stringDecoder, + interfaceMapType.Elem(), + emptyIfaceDecoder, + structName, + fieldName, + ), + floatDecoder: newFloatDecoder(structName, fieldName, func(p unsafe.Pointer, v float64) { + *(*interface{})(p) = v + }), + numberDecoder: newNumberDecoder(structName, fieldName, func(p unsafe.Pointer, v json.Number) { + *(*interface{})(p) = v + }), + stringDecoder: stringDecoder, + } +} + +func (d *interfaceDecoder) numDecoder(s *Stream) Decoder { + if s.UseNumber { + return d.numberDecoder + } + return d.floatDecoder +} + +var ( + emptyInterfaceType = runtime.Type2RType(reflect.TypeOf((*interface{})(nil)).Elem()) + interfaceMapType = runtime.Type2RType( + reflect.TypeOf((*map[string]interface{})(nil)).Elem(), + ) + stringType = runtime.Type2RType( + reflect.TypeOf(""), + ) +) + +func decodeStreamUnmarshaler(s *Stream, depth int64, unmarshaler json.Unmarshaler) error { + start := s.cursor + if err := s.skipValue(depth); err != nil { + return err + } + src := s.buf[start:s.cursor] + dst := make([]byte, len(src)) + copy(dst, src) + + if err := unmarshaler.UnmarshalJSON(dst); err != nil { + return err + } + return nil +} + +func decodeStreamUnmarshalerContext(s *Stream, depth int64, unmarshaler unmarshalerContext) error { + start := s.cursor + if err := s.skipValue(depth); err != nil { + return err + } + src := s.buf[start:s.cursor] + dst := make([]byte, len(src)) + copy(dst, src) + + if err := unmarshaler.UnmarshalJSON(s.Option.Context, dst); err != nil { + return err + } + return nil +} + +func decodeUnmarshaler(buf []byte, cursor, depth int64, unmarshaler json.Unmarshaler) (int64, error) { + cursor = skipWhiteSpace(buf, cursor) + start := cursor + end, err := skipValue(buf, cursor, depth) + if err != nil { + return 0, err + } + src := buf[start:end] + dst := make([]byte, len(src)) + copy(dst, src) + + if err := unmarshaler.UnmarshalJSON(dst); err != nil { + return 0, err + } + return end, nil +} + +func decodeUnmarshalerContext(ctx *RuntimeContext, buf []byte, cursor, depth int64, unmarshaler unmarshalerContext) (int64, error) { + cursor = skipWhiteSpace(buf, cursor) + start := cursor + end, err := skipValue(buf, cursor, depth) + if err != nil { + return 0, err + } + src := buf[start:end] + dst := make([]byte, len(src)) + copy(dst, src) + + if err := unmarshaler.UnmarshalJSON(ctx.Option.Context, dst); err != nil { + return 0, err + } + return end, nil +} + +func decodeStreamTextUnmarshaler(s *Stream, depth int64, unmarshaler encoding.TextUnmarshaler, p unsafe.Pointer) error { + start := s.cursor + if err := s.skipValue(depth); err != nil { + return err + } + src := s.buf[start:s.cursor] + if bytes.Equal(src, nullbytes) { + *(*unsafe.Pointer)(p) = nil + return nil + } + + dst := make([]byte, len(src)) + copy(dst, src) + + if err := unmarshaler.UnmarshalText(dst); err != nil { + return err + } + return nil +} + +func decodeTextUnmarshaler(buf []byte, cursor, depth int64, unmarshaler encoding.TextUnmarshaler, p unsafe.Pointer) (int64, error) { + cursor = skipWhiteSpace(buf, cursor) + start := cursor + end, err := skipValue(buf, cursor, depth) + if err != nil { + return 0, err + } + src := buf[start:end] + if bytes.Equal(src, nullbytes) { + *(*unsafe.Pointer)(p) = nil + return end, nil + } + if s, ok := unquoteBytes(src); ok { + src = s + } + if err := unmarshaler.UnmarshalText(src); err != nil { + return 0, err + } + return end, nil +} + +func (d *interfaceDecoder) decodeStreamEmptyInterface(s *Stream, depth int64, p unsafe.Pointer) error { + c := s.skipWhiteSpace() + for { + switch c { + case '{': + var v map[string]interface{} + ptr := unsafe.Pointer(&v) + if err := d.mapDecoder.DecodeStream(s, depth, ptr); err != nil { + return err + } + *(*interface{})(p) = v + return nil + case '[': + var v []interface{} + ptr := unsafe.Pointer(&v) + if err := d.sliceDecoder.DecodeStream(s, depth, ptr); err != nil { + return err + } + *(*interface{})(p) = v + return nil + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return d.numDecoder(s).DecodeStream(s, depth, p) + case '"': + s.cursor++ + start := s.cursor + for { + switch s.char() { + case '\\': + if _, err := decodeEscapeString(s, nil); err != nil { + return err + } + case '"': + literal := s.buf[start:s.cursor] + s.cursor++ + *(*interface{})(p) = string(literal) + return nil + case nul: + if s.read() { + continue + } + return errors.ErrUnexpectedEndOfJSON("string", s.totalOffset()) + } + s.cursor++ + } + case 't': + if err := trueBytes(s); err != nil { + return err + } + **(**interface{})(unsafe.Pointer(&p)) = true + return nil + case 'f': + if err := falseBytes(s); err != nil { + return err + } + **(**interface{})(unsafe.Pointer(&p)) = false + return nil + case 'n': + if err := nullBytes(s); err != nil { + return err + } + *(*interface{})(p) = nil + return nil + case nul: + if s.read() { + c = s.char() + continue + } + } + break + } + return errors.ErrInvalidBeginningOfValue(c, s.totalOffset()) +} + +type emptyInterface struct { + typ *runtime.Type + ptr unsafe.Pointer +} + +func (d *interfaceDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + runtimeInterfaceValue := *(*interface{})(unsafe.Pointer(&emptyInterface{ + typ: d.typ, + ptr: p, + })) + rv := reflect.ValueOf(runtimeInterfaceValue) + if rv.NumMethod() > 0 && rv.CanInterface() { + if u, ok := rv.Interface().(unmarshalerContext); ok { + return decodeStreamUnmarshalerContext(s, depth, u) + } + if u, ok := rv.Interface().(json.Unmarshaler); ok { + return decodeStreamUnmarshaler(s, depth, u) + } + if u, ok := rv.Interface().(encoding.TextUnmarshaler); ok { + return decodeStreamTextUnmarshaler(s, depth, u, p) + } + if s.skipWhiteSpace() == 'n' { + if err := nullBytes(s); err != nil { + return err + } + *(*interface{})(p) = nil + return nil + } + return d.errUnmarshalType(rv.Type(), s.totalOffset()) + } + iface := rv.Interface() + ifaceHeader := (*emptyInterface)(unsafe.Pointer(&iface)) + typ := ifaceHeader.typ + if ifaceHeader.ptr == nil || d.typ == typ || typ == nil { + // concrete type is empty interface + return d.decodeStreamEmptyInterface(s, depth, p) + } + if typ.Kind() == reflect.Ptr && typ.Elem() == d.typ || typ.Kind() != reflect.Ptr { + return d.decodeStreamEmptyInterface(s, depth, p) + } + if s.skipWhiteSpace() == 'n' { + if err := nullBytes(s); err != nil { + return err + } + *(*interface{})(p) = nil + return nil + } + decoder, err := CompileToGetDecoder(typ) + if err != nil { + return err + } + return decoder.DecodeStream(s, depth, ifaceHeader.ptr) +} + +func (d *interfaceDecoder) errUnmarshalType(typ reflect.Type, offset int64) *errors.UnmarshalTypeError { + return &errors.UnmarshalTypeError{ + Value: typ.String(), + Type: typ, + Offset: offset, + Struct: d.structName, + Field: d.fieldName, + } +} + +func (d *interfaceDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + runtimeInterfaceValue := *(*interface{})(unsafe.Pointer(&emptyInterface{ + typ: d.typ, + ptr: p, + })) + rv := reflect.ValueOf(runtimeInterfaceValue) + if rv.NumMethod() > 0 && rv.CanInterface() { + if u, ok := rv.Interface().(unmarshalerContext); ok { + return decodeUnmarshalerContext(ctx, buf, cursor, depth, u) + } + if u, ok := rv.Interface().(json.Unmarshaler); ok { + return decodeUnmarshaler(buf, cursor, depth, u) + } + if u, ok := rv.Interface().(encoding.TextUnmarshaler); ok { + return decodeTextUnmarshaler(buf, cursor, depth, u, p) + } + cursor = skipWhiteSpace(buf, cursor) + if buf[cursor] == 'n' { + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + **(**interface{})(unsafe.Pointer(&p)) = nil + return cursor, nil + } + return 0, d.errUnmarshalType(rv.Type(), cursor) + } + + iface := rv.Interface() + ifaceHeader := (*emptyInterface)(unsafe.Pointer(&iface)) + typ := ifaceHeader.typ + if ifaceHeader.ptr == nil || d.typ == typ || typ == nil { + // concrete type is empty interface + return d.decodeEmptyInterface(ctx, cursor, depth, p) + } + if typ.Kind() == reflect.Ptr && typ.Elem() == d.typ || typ.Kind() != reflect.Ptr { + return d.decodeEmptyInterface(ctx, cursor, depth, p) + } + cursor = skipWhiteSpace(buf, cursor) + if buf[cursor] == 'n' { + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + **(**interface{})(unsafe.Pointer(&p)) = nil + return cursor, nil + } + decoder, err := CompileToGetDecoder(typ) + if err != nil { + return 0, err + } + return decoder.Decode(ctx, cursor, depth, ifaceHeader.ptr) +} + +func (d *interfaceDecoder) decodeEmptyInterface(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + cursor = skipWhiteSpace(buf, cursor) + switch buf[cursor] { + case '{': + var v map[string]interface{} + ptr := unsafe.Pointer(&v) + cursor, err := d.mapDecoder.Decode(ctx, cursor, depth, ptr) + if err != nil { + return 0, err + } + **(**interface{})(unsafe.Pointer(&p)) = v + return cursor, nil + case '[': + var v []interface{} + ptr := unsafe.Pointer(&v) + cursor, err := d.sliceDecoder.Decode(ctx, cursor, depth, ptr) + if err != nil { + return 0, err + } + **(**interface{})(unsafe.Pointer(&p)) = v + return cursor, nil + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return d.floatDecoder.Decode(ctx, cursor, depth, p) + case '"': + var v string + ptr := unsafe.Pointer(&v) + cursor, err := d.stringDecoder.Decode(ctx, cursor, depth, ptr) + if err != nil { + return 0, err + } + **(**interface{})(unsafe.Pointer(&p)) = v + return cursor, nil + case 't': + if err := validateTrue(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + **(**interface{})(unsafe.Pointer(&p)) = true + return cursor, nil + case 'f': + if err := validateFalse(buf, cursor); err != nil { + return 0, err + } + cursor += 5 + **(**interface{})(unsafe.Pointer(&p)) = false + return cursor, nil + case 'n': + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + **(**interface{})(unsafe.Pointer(&p)) = nil + return cursor, nil + } + return cursor, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor) +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/map.go b/vendor/github.com/goccy/go-json/internal/decoder/map.go new file mode 100644 index 000000000..bb18ef995 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/map.go @@ -0,0 +1,186 @@ +package decoder + +import ( + "reflect" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type mapDecoder struct { + mapType *runtime.Type + keyType *runtime.Type + valueType *runtime.Type + canUseAssignFaststrType bool + keyDecoder Decoder + valueDecoder Decoder + structName string + fieldName string +} + +func newMapDecoder(mapType *runtime.Type, keyType *runtime.Type, keyDec Decoder, valueType *runtime.Type, valueDec Decoder, structName, fieldName string) *mapDecoder { + return &mapDecoder{ + mapType: mapType, + keyDecoder: keyDec, + keyType: keyType, + canUseAssignFaststrType: canUseAssignFaststrType(keyType, valueType), + valueType: valueType, + valueDecoder: valueDec, + structName: structName, + fieldName: fieldName, + } +} + +const ( + mapMaxElemSize = 128 +) + +// See detail: https://github.com/goccy/go-json/pull/283 +func canUseAssignFaststrType(key *runtime.Type, value *runtime.Type) bool { + indirectElem := value.Size() > mapMaxElemSize + if indirectElem { + return false + } + return key.Kind() == reflect.String +} + +//go:linkname makemap reflect.makemap +func makemap(*runtime.Type, int) unsafe.Pointer + +//nolint:golint +//go:linkname mapassign_faststr runtime.mapassign_faststr +//go:noescape +func mapassign_faststr(t *runtime.Type, m unsafe.Pointer, s string) unsafe.Pointer + +//go:linkname mapassign reflect.mapassign +//go:noescape +func mapassign(t *runtime.Type, m unsafe.Pointer, k, v unsafe.Pointer) + +func (d *mapDecoder) mapassign(t *runtime.Type, m, k, v unsafe.Pointer) { + if d.canUseAssignFaststrType { + mapV := mapassign_faststr(t, m, *(*string)(k)) + typedmemmove(d.valueType, mapV, v) + } else { + mapassign(t, m, k, v) + } +} + +func (d *mapDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + depth++ + if depth > maxDecodeNestingDepth { + return errors.ErrExceededMaxDepth(s.char(), s.cursor) + } + + switch s.skipWhiteSpace() { + case 'n': + if err := nullBytes(s); err != nil { + return err + } + **(**unsafe.Pointer)(unsafe.Pointer(&p)) = nil + return nil + case '{': + default: + return errors.ErrExpected("{ character for map value", s.totalOffset()) + } + mapValue := *(*unsafe.Pointer)(p) + if mapValue == nil { + mapValue = makemap(d.mapType, 0) + } + if s.buf[s.cursor+1] == '}' { + *(*unsafe.Pointer)(p) = mapValue + s.cursor += 2 + return nil + } + for { + s.cursor++ + k := unsafe_New(d.keyType) + if err := d.keyDecoder.DecodeStream(s, depth, k); err != nil { + return err + } + s.skipWhiteSpace() + if !s.equalChar(':') { + return errors.ErrExpected("colon after object key", s.totalOffset()) + } + s.cursor++ + v := unsafe_New(d.valueType) + if err := d.valueDecoder.DecodeStream(s, depth, v); err != nil { + return err + } + d.mapassign(d.mapType, mapValue, k, v) + s.skipWhiteSpace() + if s.equalChar('}') { + **(**unsafe.Pointer)(unsafe.Pointer(&p)) = mapValue + s.cursor++ + return nil + } + if !s.equalChar(',') { + return errors.ErrExpected("comma after object value", s.totalOffset()) + } + } +} + +func (d *mapDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + depth++ + if depth > maxDecodeNestingDepth { + return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor) + } + + cursor = skipWhiteSpace(buf, cursor) + buflen := int64(len(buf)) + if buflen < 2 { + return 0, errors.ErrExpected("{} for map", cursor) + } + switch buf[cursor] { + case 'n': + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + **(**unsafe.Pointer)(unsafe.Pointer(&p)) = nil + return cursor, nil + case '{': + default: + return 0, errors.ErrExpected("{ character for map value", cursor) + } + cursor++ + cursor = skipWhiteSpace(buf, cursor) + mapValue := *(*unsafe.Pointer)(p) + if mapValue == nil { + mapValue = makemap(d.mapType, 0) + } + if buf[cursor] == '}' { + **(**unsafe.Pointer)(unsafe.Pointer(&p)) = mapValue + cursor++ + return cursor, nil + } + for { + k := unsafe_New(d.keyType) + keyCursor, err := d.keyDecoder.Decode(ctx, cursor, depth, k) + if err != nil { + return 0, err + } + cursor = skipWhiteSpace(buf, keyCursor) + if buf[cursor] != ':' { + return 0, errors.ErrExpected("colon after object key", cursor) + } + cursor++ + v := unsafe_New(d.valueType) + valueCursor, err := d.valueDecoder.Decode(ctx, cursor, depth, v) + if err != nil { + return 0, err + } + d.mapassign(d.mapType, mapValue, k, v) + cursor = skipWhiteSpace(buf, valueCursor) + if buf[cursor] == '}' { + **(**unsafe.Pointer)(unsafe.Pointer(&p)) = mapValue + cursor++ + return cursor, nil + } + if buf[cursor] != ',' { + return 0, errors.ErrExpected("comma after object value", cursor) + } + cursor++ + } +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/number.go b/vendor/github.com/goccy/go-json/internal/decoder/number.go new file mode 100644 index 000000000..bf63773e3 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/number.go @@ -0,0 +1,112 @@ +package decoder + +import ( + "encoding/json" + "strconv" + "unsafe" + + "github.com/goccy/go-json/internal/errors" +) + +type numberDecoder struct { + stringDecoder *stringDecoder + op func(unsafe.Pointer, json.Number) + structName string + fieldName string +} + +func newNumberDecoder(structName, fieldName string, op func(unsafe.Pointer, json.Number)) *numberDecoder { + return &numberDecoder{ + stringDecoder: newStringDecoder(structName, fieldName), + op: op, + structName: structName, + fieldName: fieldName, + } +} + +func (d *numberDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + bytes, err := d.decodeStreamByte(s) + if err != nil { + return err + } + if _, err := strconv.ParseFloat(*(*string)(unsafe.Pointer(&bytes)), 64); err != nil { + return errors.ErrSyntax(err.Error(), s.totalOffset()) + } + d.op(p, json.Number(string(bytes))) + s.reset() + return nil +} + +func (d *numberDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + bytes, c, err := d.decodeByte(ctx.Buf, cursor) + if err != nil { + return 0, err + } + if _, err := strconv.ParseFloat(*(*string)(unsafe.Pointer(&bytes)), 64); err != nil { + return 0, errors.ErrSyntax(err.Error(), c) + } + cursor = c + s := *(*string)(unsafe.Pointer(&bytes)) + d.op(p, json.Number(s)) + return cursor, nil +} + +func (d *numberDecoder) decodeStreamByte(s *Stream) ([]byte, error) { + start := s.cursor + for { + switch s.char() { + case ' ', '\n', '\t', '\r': + s.cursor++ + continue + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return floatBytes(s), nil + case 'n': + if err := nullBytes(s); err != nil { + return nil, err + } + return nil, nil + case '"': + return d.stringDecoder.decodeStreamByte(s) + case nul: + if s.read() { + continue + } + goto ERROR + default: + goto ERROR + } + } +ERROR: + if s.cursor == start { + return nil, errors.ErrInvalidBeginningOfValue(s.char(), s.totalOffset()) + } + return nil, errors.ErrUnexpectedEndOfJSON("json.Number", s.totalOffset()) +} + +func (d *numberDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) { + for { + switch buf[cursor] { + case ' ', '\n', '\t', '\r': + cursor++ + continue + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + start := cursor + cursor++ + for floatTable[buf[cursor]] { + cursor++ + } + num := buf[start:cursor] + return num, cursor, nil + case 'n': + if err := validateNull(buf, cursor); err != nil { + return nil, 0, err + } + cursor += 4 + return nil, cursor, nil + case '"': + return d.stringDecoder.decodeByte(buf, cursor) + default: + return nil, 0, errors.ErrUnexpectedEndOfJSON("json.Number", cursor) + } + } +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/option.go b/vendor/github.com/goccy/go-json/internal/decoder/option.go new file mode 100644 index 000000000..e41f876b0 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/option.go @@ -0,0 +1,15 @@ +package decoder + +import "context" + +type OptionFlags uint8 + +const ( + FirstWinOption OptionFlags = 1 << iota + ContextOption +) + +type Option struct { + Flags OptionFlags + Context context.Context +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/ptr.go b/vendor/github.com/goccy/go-json/internal/decoder/ptr.go new file mode 100644 index 000000000..2c83b9c44 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/ptr.go @@ -0,0 +1,87 @@ +package decoder + +import ( + "unsafe" + + "github.com/goccy/go-json/internal/runtime" +) + +type ptrDecoder struct { + dec Decoder + typ *runtime.Type + structName string + fieldName string +} + +func newPtrDecoder(dec Decoder, typ *runtime.Type, structName, fieldName string) *ptrDecoder { + return &ptrDecoder{ + dec: dec, + typ: typ, + structName: structName, + fieldName: fieldName, + } +} + +func (d *ptrDecoder) contentDecoder() Decoder { + dec, ok := d.dec.(*ptrDecoder) + if !ok { + return d.dec + } + return dec.contentDecoder() +} + +//nolint:golint +//go:linkname unsafe_New reflect.unsafe_New +func unsafe_New(*runtime.Type) unsafe.Pointer + +func (d *ptrDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + if s.skipWhiteSpace() == nul { + s.read() + } + if s.char() == 'n' { + if err := nullBytes(s); err != nil { + return err + } + *(*unsafe.Pointer)(p) = nil + return nil + } + var newptr unsafe.Pointer + if *(*unsafe.Pointer)(p) == nil { + newptr = unsafe_New(d.typ) + *(*unsafe.Pointer)(p) = newptr + } else { + newptr = *(*unsafe.Pointer)(p) + } + if err := d.dec.DecodeStream(s, depth, newptr); err != nil { + return err + } + return nil +} + +func (d *ptrDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + cursor = skipWhiteSpace(buf, cursor) + if buf[cursor] == 'n' { + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + if p != nil { + *(*unsafe.Pointer)(p) = nil + } + cursor += 4 + return cursor, nil + } + var newptr unsafe.Pointer + if *(*unsafe.Pointer)(p) == nil { + newptr = unsafe_New(d.typ) + *(*unsafe.Pointer)(p) = newptr + } else { + newptr = *(*unsafe.Pointer)(p) + } + c, err := d.dec.Decode(ctx, cursor, depth, newptr) + if err != nil { + return 0, err + } + cursor = c + return cursor, nil +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/slice.go b/vendor/github.com/goccy/go-json/internal/decoder/slice.go new file mode 100644 index 000000000..85b6e1119 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/slice.go @@ -0,0 +1,301 @@ +package decoder + +import ( + "reflect" + "sync" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +var ( + sliceType = runtime.Type2RType( + reflect.TypeOf((*sliceHeader)(nil)).Elem(), + ) + nilSlice = unsafe.Pointer(&sliceHeader{}) +) + +type sliceDecoder struct { + elemType *runtime.Type + isElemPointerType bool + valueDecoder Decoder + size uintptr + arrayPool sync.Pool + structName string + fieldName string +} + +// If use reflect.SliceHeader, data type is uintptr. +// In this case, Go compiler cannot trace reference created by newArray(). +// So, define using unsafe.Pointer as data type +type sliceHeader struct { + data unsafe.Pointer + len int + cap int +} + +const ( + defaultSliceCapacity = 2 +) + +func newSliceDecoder(dec Decoder, elemType *runtime.Type, size uintptr, structName, fieldName string) *sliceDecoder { + return &sliceDecoder{ + valueDecoder: dec, + elemType: elemType, + isElemPointerType: elemType.Kind() == reflect.Ptr || elemType.Kind() == reflect.Map, + size: size, + arrayPool: sync.Pool{ + New: func() interface{} { + return &sliceHeader{ + data: newArray(elemType, defaultSliceCapacity), + len: 0, + cap: defaultSliceCapacity, + } + }, + }, + structName: structName, + fieldName: fieldName, + } +} + +func (d *sliceDecoder) newSlice(src *sliceHeader) *sliceHeader { + slice := d.arrayPool.Get().(*sliceHeader) + if src.len > 0 { + // copy original elem + if slice.cap < src.cap { + data := newArray(d.elemType, src.cap) + slice = &sliceHeader{data: data, len: src.len, cap: src.cap} + } else { + slice.len = src.len + } + copySlice(d.elemType, *slice, *src) + } else { + slice.len = 0 + } + return slice +} + +func (d *sliceDecoder) releaseSlice(p *sliceHeader) { + d.arrayPool.Put(p) +} + +//go:linkname copySlice reflect.typedslicecopy +func copySlice(elemType *runtime.Type, dst, src sliceHeader) int + +//go:linkname newArray reflect.unsafe_NewArray +func newArray(*runtime.Type, int) unsafe.Pointer + +//go:linkname typedmemmove reflect.typedmemmove +func typedmemmove(t *runtime.Type, dst, src unsafe.Pointer) + +func (d *sliceDecoder) errNumber(offset int64) *errors.UnmarshalTypeError { + return &errors.UnmarshalTypeError{ + Value: "number", + Type: reflect.SliceOf(runtime.RType2Type(d.elemType)), + Struct: d.structName, + Field: d.fieldName, + Offset: offset, + } +} + +func (d *sliceDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + depth++ + if depth > maxDecodeNestingDepth { + return errors.ErrExceededMaxDepth(s.char(), s.cursor) + } + + for { + switch s.char() { + case ' ', '\n', '\t', '\r': + s.cursor++ + continue + case 'n': + if err := nullBytes(s); err != nil { + return err + } + typedmemmove(sliceType, p, nilSlice) + return nil + case '[': + s.cursor++ + if s.skipWhiteSpace() == ']' { + dst := (*sliceHeader)(p) + if dst.data == nil { + dst.data = newArray(d.elemType, 0) + } else { + dst.len = 0 + } + s.cursor++ + return nil + } + idx := 0 + slice := d.newSlice((*sliceHeader)(p)) + srcLen := slice.len + capacity := slice.cap + data := slice.data + for { + if capacity <= idx { + src := sliceHeader{data: data, len: idx, cap: capacity} + capacity *= 2 + data = newArray(d.elemType, capacity) + dst := sliceHeader{data: data, len: idx, cap: capacity} + copySlice(d.elemType, dst, src) + } + ep := unsafe.Pointer(uintptr(data) + uintptr(idx)*d.size) + + // if srcLen is greater than idx, keep the original reference + if srcLen <= idx { + if d.isElemPointerType { + **(**unsafe.Pointer)(unsafe.Pointer(&ep)) = nil // initialize elem pointer + } else { + // assign new element to the slice + typedmemmove(d.elemType, ep, unsafe_New(d.elemType)) + } + } + + if err := d.valueDecoder.DecodeStream(s, depth, ep); err != nil { + return err + } + s.skipWhiteSpace() + RETRY: + switch s.char() { + case ']': + slice.cap = capacity + slice.len = idx + 1 + slice.data = data + dst := (*sliceHeader)(p) + dst.len = idx + 1 + if dst.len > dst.cap { + dst.data = newArray(d.elemType, dst.len) + dst.cap = dst.len + } + copySlice(d.elemType, *dst, *slice) + d.releaseSlice(slice) + s.cursor++ + return nil + case ',': + idx++ + case nul: + if s.read() { + goto RETRY + } + slice.cap = capacity + slice.data = data + d.releaseSlice(slice) + goto ERROR + default: + slice.cap = capacity + slice.data = data + d.releaseSlice(slice) + goto ERROR + } + s.cursor++ + } + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return d.errNumber(s.totalOffset()) + case nul: + if s.read() { + continue + } + goto ERROR + default: + goto ERROR + } + } +ERROR: + return errors.ErrUnexpectedEndOfJSON("slice", s.totalOffset()) +} + +func (d *sliceDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + depth++ + if depth > maxDecodeNestingDepth { + return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor) + } + + for { + switch buf[cursor] { + case ' ', '\n', '\t', '\r': + cursor++ + continue + case 'n': + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + typedmemmove(sliceType, p, nilSlice) + return cursor, nil + case '[': + cursor++ + cursor = skipWhiteSpace(buf, cursor) + if buf[cursor] == ']' { + dst := (*sliceHeader)(p) + if dst.data == nil { + dst.data = newArray(d.elemType, 0) + } else { + dst.len = 0 + } + cursor++ + return cursor, nil + } + idx := 0 + slice := d.newSlice((*sliceHeader)(p)) + srcLen := slice.len + capacity := slice.cap + data := slice.data + for { + if capacity <= idx { + src := sliceHeader{data: data, len: idx, cap: capacity} + capacity *= 2 + data = newArray(d.elemType, capacity) + dst := sliceHeader{data: data, len: idx, cap: capacity} + copySlice(d.elemType, dst, src) + } + ep := unsafe.Pointer(uintptr(data) + uintptr(idx)*d.size) + // if srcLen is greater than idx, keep the original reference + if srcLen <= idx { + if d.isElemPointerType { + **(**unsafe.Pointer)(unsafe.Pointer(&ep)) = nil // initialize elem pointer + } else { + // assign new element to the slice + typedmemmove(d.elemType, ep, unsafe_New(d.elemType)) + } + } + c, err := d.valueDecoder.Decode(ctx, cursor, depth, ep) + if err != nil { + return 0, err + } + cursor = c + cursor = skipWhiteSpace(buf, cursor) + switch buf[cursor] { + case ']': + slice.cap = capacity + slice.len = idx + 1 + slice.data = data + dst := (*sliceHeader)(p) + dst.len = idx + 1 + if dst.len > dst.cap { + dst.data = newArray(d.elemType, dst.len) + dst.cap = dst.len + } + copySlice(d.elemType, *dst, *slice) + d.releaseSlice(slice) + cursor++ + return cursor, nil + case ',': + idx++ + default: + slice.cap = capacity + slice.data = data + d.releaseSlice(slice) + return 0, errors.ErrInvalidCharacter(buf[cursor], "slice", cursor) + } + cursor++ + } + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return 0, d.errNumber(cursor) + default: + return 0, errors.ErrUnexpectedEndOfJSON("slice", cursor) + } + } +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/stream.go b/vendor/github.com/goccy/go-json/internal/decoder/stream.go new file mode 100644 index 000000000..c27468348 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/stream.go @@ -0,0 +1,554 @@ +package decoder + +import ( + "bytes" + "encoding/json" + "io" + "strconv" + "unsafe" + + "github.com/goccy/go-json/internal/errors" +) + +const ( + initBufSize = 512 +) + +type Stream struct { + buf []byte + bufSize int64 + length int64 + r io.Reader + offset int64 + cursor int64 + filledBuffer bool + allRead bool + UseNumber bool + DisallowUnknownFields bool + Option *Option +} + +func NewStream(r io.Reader) *Stream { + return &Stream{ + r: r, + bufSize: initBufSize, + buf: make([]byte, initBufSize), + Option: &Option{}, + } +} + +func (s *Stream) TotalOffset() int64 { + return s.totalOffset() +} + +func (s *Stream) Buffered() io.Reader { + buflen := int64(len(s.buf)) + for i := s.cursor; i < buflen; i++ { + if s.buf[i] == nul { + return bytes.NewReader(s.buf[s.cursor:i]) + } + } + return bytes.NewReader(s.buf[s.cursor:]) +} + +func (s *Stream) PrepareForDecode() error { + for { + switch s.char() { + case ' ', '\t', '\r', '\n': + s.cursor++ + continue + case ',', ':': + s.cursor++ + return nil + case nul: + if s.read() { + continue + } + return io.EOF + } + break + } + return nil +} + +func (s *Stream) totalOffset() int64 { + return s.offset + s.cursor +} + +func (s *Stream) char() byte { + return s.buf[s.cursor] +} + +func (s *Stream) equalChar(c byte) bool { + cur := s.buf[s.cursor] + if cur == nul { + s.read() + cur = s.buf[s.cursor] + } + return cur == c +} + +func (s *Stream) stat() ([]byte, int64, unsafe.Pointer) { + return s.buf, s.cursor, (*sliceHeader)(unsafe.Pointer(&s.buf)).data +} + +func (s *Stream) bufptr() unsafe.Pointer { + return (*sliceHeader)(unsafe.Pointer(&s.buf)).data +} + +func (s *Stream) statForRetry() ([]byte, int64, unsafe.Pointer) { + s.cursor-- // for retry ( because caller progress cursor position in each loop ) + return s.buf, s.cursor, (*sliceHeader)(unsafe.Pointer(&s.buf)).data +} + +func (s *Stream) Reset() { + s.reset() + s.bufSize = initBufSize +} + +func (s *Stream) More() bool { + for { + switch s.char() { + case ' ', '\n', '\r', '\t': + s.cursor++ + continue + case '}', ']': + return false + case nul: + if s.read() { + continue + } + return false + } + break + } + return true +} + +func (s *Stream) Token() (interface{}, error) { + for { + c := s.char() + switch c { + case ' ', '\n', '\r', '\t': + s.cursor++ + case '{', '[', ']', '}': + s.cursor++ + return json.Delim(c), nil + case ',', ':': + s.cursor++ + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + bytes := floatBytes(s) + s := *(*string)(unsafe.Pointer(&bytes)) + f64, err := strconv.ParseFloat(s, 64) + if err != nil { + return nil, err + } + return f64, nil + case '"': + bytes, err := stringBytes(s) + if err != nil { + return nil, err + } + return string(bytes), nil + case 't': + if err := trueBytes(s); err != nil { + return nil, err + } + return true, nil + case 'f': + if err := falseBytes(s); err != nil { + return nil, err + } + return false, nil + case 'n': + if err := nullBytes(s); err != nil { + return nil, err + } + return nil, nil + case nul: + if s.read() { + continue + } + goto END + default: + return nil, errors.ErrInvalidCharacter(s.char(), "token", s.totalOffset()) + } + } +END: + return nil, io.EOF +} + +func (s *Stream) reset() { + s.offset += s.cursor + s.buf = s.buf[s.cursor:] + s.length -= s.cursor + s.cursor = 0 +} + +func (s *Stream) readBuf() []byte { + if s.filledBuffer { + s.bufSize *= 2 + remainBuf := s.buf + s.buf = make([]byte, s.bufSize) + copy(s.buf, remainBuf) + } + remainLen := s.length - s.cursor + remainNotNulCharNum := int64(0) + for i := int64(0); i < remainLen; i++ { + if s.buf[s.cursor+i] == nul { + break + } + remainNotNulCharNum++ + } + s.length = s.cursor + remainNotNulCharNum + return s.buf[s.cursor+remainNotNulCharNum:] +} + +func (s *Stream) read() bool { + if s.allRead { + return false + } + buf := s.readBuf() + last := len(buf) - 1 + buf[last] = nul + n, err := s.r.Read(buf[:last]) + s.length += int64(n) + if n == last { + s.filledBuffer = true + } else { + s.filledBuffer = false + } + if err == io.EOF { + s.allRead = true + } else if err != nil { + return false + } + return true +} + +func (s *Stream) skipWhiteSpace() byte { + p := s.bufptr() +LOOP: + c := char(p, s.cursor) + switch c { + case ' ', '\n', '\t', '\r': + s.cursor++ + goto LOOP + case nul: + if s.read() { + p = s.bufptr() + goto LOOP + } + } + return c +} + +func (s *Stream) skipObject(depth int64) error { + braceCount := 1 + _, cursor, p := s.stat() + for { + switch char(p, cursor) { + case '{': + braceCount++ + depth++ + if depth > maxDecodeNestingDepth { + return errors.ErrExceededMaxDepth(s.char(), s.cursor) + } + case '}': + braceCount-- + depth-- + if braceCount == 0 { + s.cursor = cursor + 1 + return nil + } + case '[': + depth++ + if depth > maxDecodeNestingDepth { + return errors.ErrExceededMaxDepth(s.char(), s.cursor) + } + case ']': + depth-- + case '"': + for { + cursor++ + switch char(p, cursor) { + case '\\': + cursor++ + if char(p, cursor) == nul { + s.cursor = cursor + if s.read() { + _, cursor, p = s.statForRetry() + continue + } + return errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + case '"': + goto SWITCH_OUT + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.statForRetry() + continue + } + return errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + } + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + return errors.ErrUnexpectedEndOfJSON("object of object", cursor) + } + SWITCH_OUT: + cursor++ + } +} + +func (s *Stream) skipArray(depth int64) error { + bracketCount := 1 + _, cursor, p := s.stat() + for { + switch char(p, cursor) { + case '[': + bracketCount++ + depth++ + if depth > maxDecodeNestingDepth { + return errors.ErrExceededMaxDepth(s.char(), s.cursor) + } + case ']': + bracketCount-- + depth-- + if bracketCount == 0 { + s.cursor = cursor + 1 + return nil + } + case '{': + depth++ + if depth > maxDecodeNestingDepth { + return errors.ErrExceededMaxDepth(s.char(), s.cursor) + } + case '}': + depth-- + case '"': + for { + cursor++ + switch char(p, cursor) { + case '\\': + cursor++ + if char(p, cursor) == nul { + s.cursor = cursor + if s.read() { + _, cursor, p = s.statForRetry() + continue + } + return errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + case '"': + goto SWITCH_OUT + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.statForRetry() + continue + } + return errors.ErrUnexpectedEndOfJSON("string of object", cursor) + } + } + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + return errors.ErrUnexpectedEndOfJSON("array of object", cursor) + } + SWITCH_OUT: + cursor++ + } +} + +func (s *Stream) skipValue(depth int64) error { + _, cursor, p := s.stat() + for { + switch char(p, cursor) { + case ' ', '\n', '\t', '\r': + cursor++ + continue + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + return errors.ErrUnexpectedEndOfJSON("value of object", s.totalOffset()) + case '{': + s.cursor = cursor + 1 + return s.skipObject(depth + 1) + case '[': + s.cursor = cursor + 1 + return s.skipArray(depth + 1) + case '"': + for { + cursor++ + switch char(p, cursor) { + case '\\': + cursor++ + if char(p, cursor) == nul { + s.cursor = cursor + if s.read() { + _, cursor, p = s.statForRetry() + continue + } + return errors.ErrUnexpectedEndOfJSON("value of string", s.totalOffset()) + } + case '"': + s.cursor = cursor + 1 + return nil + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.statForRetry() + continue + } + return errors.ErrUnexpectedEndOfJSON("value of string", s.totalOffset()) + } + } + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + for { + cursor++ + c := char(p, cursor) + if floatTable[c] { + continue + } else if c == nul { + if s.read() { + s.cursor-- // for retry current character + _, cursor, p = s.stat() + continue + } + } + s.cursor = cursor + return nil + } + case 't': + s.cursor = cursor + if err := trueBytes(s); err != nil { + return err + } + return nil + case 'f': + s.cursor = cursor + if err := falseBytes(s); err != nil { + return err + } + return nil + case 'n': + s.cursor = cursor + if err := nullBytes(s); err != nil { + return err + } + return nil + } + cursor++ + } +} + +func nullBytes(s *Stream) error { + // current cursor's character is 'n' + s.cursor++ + if s.char() != 'u' { + if err := retryReadNull(s); err != nil { + return err + } + } + s.cursor++ + if s.char() != 'l' { + if err := retryReadNull(s); err != nil { + return err + } + } + s.cursor++ + if s.char() != 'l' { + if err := retryReadNull(s); err != nil { + return err + } + } + s.cursor++ + return nil +} + +func retryReadNull(s *Stream) error { + if s.char() == nul && s.read() { + return nil + } + return errors.ErrInvalidCharacter(s.char(), "null", s.totalOffset()) +} + +func trueBytes(s *Stream) error { + // current cursor's character is 't' + s.cursor++ + if s.char() != 'r' { + if err := retryReadTrue(s); err != nil { + return err + } + } + s.cursor++ + if s.char() != 'u' { + if err := retryReadTrue(s); err != nil { + return err + } + } + s.cursor++ + if s.char() != 'e' { + if err := retryReadTrue(s); err != nil { + return err + } + } + s.cursor++ + return nil +} + +func retryReadTrue(s *Stream) error { + if s.char() == nul && s.read() { + return nil + } + return errors.ErrInvalidCharacter(s.char(), "bool(true)", s.totalOffset()) +} + +func falseBytes(s *Stream) error { + // current cursor's character is 'f' + s.cursor++ + if s.char() != 'a' { + if err := retryReadFalse(s); err != nil { + return err + } + } + s.cursor++ + if s.char() != 'l' { + if err := retryReadFalse(s); err != nil { + return err + } + } + s.cursor++ + if s.char() != 's' { + if err := retryReadFalse(s); err != nil { + return err + } + } + s.cursor++ + if s.char() != 'e' { + if err := retryReadFalse(s); err != nil { + return err + } + } + s.cursor++ + return nil +} + +func retryReadFalse(s *Stream) error { + if s.char() == nul && s.read() { + return nil + } + return errors.ErrInvalidCharacter(s.char(), "bool(false)", s.totalOffset()) +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/string.go b/vendor/github.com/goccy/go-json/internal/decoder/string.go new file mode 100644 index 000000000..65b100488 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/string.go @@ -0,0 +1,371 @@ +package decoder + +import ( + "reflect" + "unicode" + "unicode/utf16" + "unicode/utf8" + "unsafe" + + "github.com/goccy/go-json/internal/errors" +) + +type stringDecoder struct { + structName string + fieldName string +} + +func newStringDecoder(structName, fieldName string) *stringDecoder { + return &stringDecoder{ + structName: structName, + fieldName: fieldName, + } +} + +func (d *stringDecoder) errUnmarshalType(typeName string, offset int64) *errors.UnmarshalTypeError { + return &errors.UnmarshalTypeError{ + Value: typeName, + Type: reflect.TypeOf(""), + Offset: offset, + Struct: d.structName, + Field: d.fieldName, + } +} + +func (d *stringDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + bytes, err := d.decodeStreamByte(s) + if err != nil { + return err + } + if bytes == nil { + return nil + } + **(**string)(unsafe.Pointer(&p)) = *(*string)(unsafe.Pointer(&bytes)) + s.reset() + return nil +} + +func (d *stringDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + bytes, c, err := d.decodeByte(ctx.Buf, cursor) + if err != nil { + return 0, err + } + if bytes == nil { + return c, nil + } + cursor = c + **(**string)(unsafe.Pointer(&p)) = *(*string)(unsafe.Pointer(&bytes)) + return cursor, nil +} + +var ( + hexToInt = [256]int{ + '0': 0, + '1': 1, + '2': 2, + '3': 3, + '4': 4, + '5': 5, + '6': 6, + '7': 7, + '8': 8, + '9': 9, + 'A': 10, + 'B': 11, + 'C': 12, + 'D': 13, + 'E': 14, + 'F': 15, + 'a': 10, + 'b': 11, + 'c': 12, + 'd': 13, + 'e': 14, + 'f': 15, + } +) + +func unicodeToRune(code []byte) rune { + var r rune + for i := 0; i < len(code); i++ { + r = r*16 + rune(hexToInt[code[i]]) + } + return r +} + +func decodeUnicodeRune(s *Stream, p unsafe.Pointer) (rune, int64, unsafe.Pointer, error) { + const defaultOffset = 5 + const surrogateOffset = 11 + + if s.cursor+defaultOffset >= s.length { + if !s.read() { + return rune(0), 0, nil, errors.ErrInvalidCharacter(s.char(), "escaped string", s.totalOffset()) + } + p = s.bufptr() + } + + r := unicodeToRune(s.buf[s.cursor+1 : s.cursor+defaultOffset]) + if utf16.IsSurrogate(r) { + if s.cursor+surrogateOffset >= s.length { + s.read() + p = s.bufptr() + } + if s.cursor+surrogateOffset >= s.length || s.buf[s.cursor+defaultOffset] != '\\' || s.buf[s.cursor+defaultOffset+1] != 'u' { + return unicode.ReplacementChar, defaultOffset, p, nil + } + r2 := unicodeToRune(s.buf[s.cursor+defaultOffset+2 : s.cursor+surrogateOffset]) + if r := utf16.DecodeRune(r, r2); r != unicode.ReplacementChar { + return r, surrogateOffset, p, nil + } + } + return r, defaultOffset, p, nil +} + +func decodeUnicode(s *Stream, p unsafe.Pointer) (unsafe.Pointer, error) { + const backSlashAndULen = 2 // length of \u + + r, offset, pp, err := decodeUnicodeRune(s, p) + if err != nil { + return nil, err + } + unicode := []byte(string(r)) + unicodeLen := int64(len(unicode)) + s.buf = append(append(s.buf[:s.cursor-1], unicode...), s.buf[s.cursor+offset:]...) + unicodeOrgLen := offset - 1 + s.length = s.length - (backSlashAndULen + (unicodeOrgLen - unicodeLen)) + s.cursor = s.cursor - backSlashAndULen + unicodeLen + return pp, nil +} + +func decodeEscapeString(s *Stream, p unsafe.Pointer) (unsafe.Pointer, error) { + s.cursor++ +RETRY: + switch s.buf[s.cursor] { + case '"': + s.buf[s.cursor] = '"' + case '\\': + s.buf[s.cursor] = '\\' + case '/': + s.buf[s.cursor] = '/' + case 'b': + s.buf[s.cursor] = '\b' + case 'f': + s.buf[s.cursor] = '\f' + case 'n': + s.buf[s.cursor] = '\n' + case 'r': + s.buf[s.cursor] = '\r' + case 't': + s.buf[s.cursor] = '\t' + case 'u': + return decodeUnicode(s, p) + case nul: + if !s.read() { + return nil, errors.ErrInvalidCharacter(s.char(), "escaped string", s.totalOffset()) + } + goto RETRY + default: + return nil, errors.ErrUnexpectedEndOfJSON("string", s.totalOffset()) + } + s.buf = append(s.buf[:s.cursor-1], s.buf[s.cursor:]...) + s.length-- + s.cursor-- + p = s.bufptr() + return p, nil +} + +var ( + runeErrBytes = []byte(string(utf8.RuneError)) + runeErrBytesLen = int64(len(runeErrBytes)) +) + +func stringBytes(s *Stream) ([]byte, error) { + _, cursor, p := s.stat() + cursor++ // skip double quote char + start := cursor + for { + switch char(p, cursor) { + case '\\': + s.cursor = cursor + pp, err := decodeEscapeString(s, p) + if err != nil { + return nil, err + } + p = pp + cursor = s.cursor + case '"': + literal := s.buf[start:cursor] + cursor++ + s.cursor = cursor + return literal, nil + case + // 0x00 is nul, 0x5c is '\\', 0x22 is '"' . + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, // 0x00-0x0F + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, // 0x10-0x1F + 0x20, 0x21 /*0x22,*/, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, // 0x20-0x2F + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, // 0x30-0x3F + 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, // 0x40-0x4F + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B /*0x5C,*/, 0x5D, 0x5E, 0x5F, // 0x50-0x5F + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, // 0x60-0x6F + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F: // 0x70-0x7F + // character is ASCII. skip to next char + case + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, // 0x80-0x8F + 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, // 0x90-0x9F + 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, // 0xA0-0xAF + 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, // 0xB0-0xBF + 0xC0, 0xC1, // 0xC0-0xC1 + 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF: // 0xF5-0xFE + // character is invalid + s.buf = append(append(append([]byte{}, s.buf[:cursor]...), runeErrBytes...), s.buf[cursor+1:]...) + _, _, p = s.stat() + cursor += runeErrBytesLen + s.length += runeErrBytesLen + continue + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + goto ERROR + case 0xEF: + // RuneError is {0xEF, 0xBF, 0xBD} + if s.buf[cursor+1] == 0xBF && s.buf[cursor+2] == 0xBD { + // found RuneError: skip + cursor += 2 + break + } + fallthrough + default: + // multi bytes character + if !utf8.FullRune(s.buf[cursor : len(s.buf)-1]) { + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + goto ERROR + } + r, size := utf8.DecodeRune(s.buf[cursor:]) + if r == utf8.RuneError { + s.buf = append(append(append([]byte{}, s.buf[:cursor]...), runeErrBytes...), s.buf[cursor+1:]...) + cursor += runeErrBytesLen + s.length += runeErrBytesLen + _, _, p = s.stat() + } else { + cursor += int64(size) + } + continue + } + cursor++ + } +ERROR: + return nil, errors.ErrUnexpectedEndOfJSON("string", s.totalOffset()) +} + +func (d *stringDecoder) decodeStreamByte(s *Stream) ([]byte, error) { + for { + switch s.char() { + case ' ', '\n', '\t', '\r': + s.cursor++ + continue + case '[': + return nil, d.errUnmarshalType("array", s.totalOffset()) + case '{': + return nil, d.errUnmarshalType("object", s.totalOffset()) + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return nil, d.errUnmarshalType("number", s.totalOffset()) + case '"': + return stringBytes(s) + case 'n': + if err := nullBytes(s); err != nil { + return nil, err + } + return nil, nil + case nul: + if s.read() { + continue + } + } + break + } + return nil, errors.ErrInvalidBeginningOfValue(s.char(), s.totalOffset()) +} + +func (d *stringDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) { + for { + switch buf[cursor] { + case ' ', '\n', '\t', '\r': + cursor++ + case '[': + return nil, 0, d.errUnmarshalType("array", cursor) + case '{': + return nil, 0, d.errUnmarshalType("object", cursor) + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return nil, 0, d.errUnmarshalType("number", cursor) + case '"': + cursor++ + start := cursor + b := (*sliceHeader)(unsafe.Pointer(&buf)).data + for { + switch char(b, cursor) { + case '\\': + cursor++ + switch char(b, cursor) { + case '"': + buf[cursor] = '"' + buf = append(buf[:cursor-1], buf[cursor:]...) + case '\\': + buf[cursor] = '\\' + buf = append(buf[:cursor-1], buf[cursor:]...) + case '/': + buf[cursor] = '/' + buf = append(buf[:cursor-1], buf[cursor:]...) + case 'b': + buf[cursor] = '\b' + buf = append(buf[:cursor-1], buf[cursor:]...) + case 'f': + buf[cursor] = '\f' + buf = append(buf[:cursor-1], buf[cursor:]...) + case 'n': + buf[cursor] = '\n' + buf = append(buf[:cursor-1], buf[cursor:]...) + case 'r': + buf[cursor] = '\r' + buf = append(buf[:cursor-1], buf[cursor:]...) + case 't': + buf[cursor] = '\t' + buf = append(buf[:cursor-1], buf[cursor:]...) + case 'u': + buflen := int64(len(buf)) + if cursor+5 >= buflen { + return nil, 0, errors.ErrUnexpectedEndOfJSON("escaped string", cursor) + } + code := unicodeToRune(buf[cursor+1 : cursor+5]) + unicode := []byte(string(code)) + buf = append(append(buf[:cursor-1], unicode...), buf[cursor+5:]...) + default: + return nil, 0, errors.ErrUnexpectedEndOfJSON("escaped string", cursor) + } + continue + case '"': + literal := buf[start:cursor] + cursor++ + return literal, cursor, nil + case nul: + return nil, 0, errors.ErrUnexpectedEndOfJSON("string", cursor) + } + cursor++ + } + case 'n': + if err := validateNull(buf, cursor); err != nil { + return nil, 0, err + } + cursor += 4 + return nil, cursor, nil + default: + return nil, 0, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor) + } + } +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/struct.go b/vendor/github.com/goccy/go-json/internal/decoder/struct.go new file mode 100644 index 000000000..2c6468045 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/struct.go @@ -0,0 +1,819 @@ +package decoder + +import ( + "fmt" + "math" + "math/bits" + "sort" + "strings" + "unicode" + "unicode/utf16" + "unsafe" + + "github.com/goccy/go-json/internal/errors" +) + +type structFieldSet struct { + dec Decoder + offset uintptr + isTaggedKey bool + fieldIdx int + key string + keyLen int64 + err error +} + +type structDecoder struct { + fieldMap map[string]*structFieldSet + fieldUniqueNameNum int + stringDecoder *stringDecoder + structName string + fieldName string + isTriedOptimize bool + keyBitmapUint8 [][256]uint8 + keyBitmapUint16 [][256]uint16 + sortedFieldSets []*structFieldSet + keyDecoder func(*structDecoder, []byte, int64) (int64, *structFieldSet, error) + keyStreamDecoder func(*structDecoder, *Stream) (*structFieldSet, string, error) +} + +var ( + largeToSmallTable [256]byte +) + +func init() { + for i := 0; i < 256; i++ { + c := i + if 'A' <= c && c <= 'Z' { + c += 'a' - 'A' + } + largeToSmallTable[i] = byte(c) + } +} + +func newStructDecoder(structName, fieldName string, fieldMap map[string]*structFieldSet) *structDecoder { + return &structDecoder{ + fieldMap: fieldMap, + stringDecoder: newStringDecoder(structName, fieldName), + structName: structName, + fieldName: fieldName, + keyDecoder: decodeKey, + keyStreamDecoder: decodeKeyStream, + } +} + +const ( + allowOptimizeMaxKeyLen = 64 + allowOptimizeMaxFieldLen = 16 +) + +func (d *structDecoder) tryOptimize() { + fieldUniqueNameMap := map[string]int{} + fieldIdx := -1 + for k, v := range d.fieldMap { + lower := strings.ToLower(k) + idx, exists := fieldUniqueNameMap[lower] + if exists { + v.fieldIdx = idx + } else { + fieldIdx++ + v.fieldIdx = fieldIdx + } + fieldUniqueNameMap[lower] = fieldIdx + } + d.fieldUniqueNameNum = len(fieldUniqueNameMap) + + if d.isTriedOptimize { + return + } + fieldMap := map[string]*structFieldSet{} + conflicted := map[string]struct{}{} + for k, v := range d.fieldMap { + key := strings.ToLower(k) + if key != k { + // already exists same key (e.g. Hello and HELLO has same lower case key + if _, exists := conflicted[key]; exists { + d.isTriedOptimize = true + return + } + conflicted[key] = struct{}{} + } + if field, exists := fieldMap[key]; exists { + if field != v { + d.isTriedOptimize = true + return + } + } + fieldMap[key] = v + } + + if len(fieldMap) > allowOptimizeMaxFieldLen { + d.isTriedOptimize = true + return + } + + var maxKeyLen int + sortedKeys := []string{} + for key := range fieldMap { + keyLen := len(key) + if keyLen > allowOptimizeMaxKeyLen { + d.isTriedOptimize = true + return + } + if maxKeyLen < keyLen { + maxKeyLen = keyLen + } + sortedKeys = append(sortedKeys, key) + } + sort.Strings(sortedKeys) + + // By allocating one extra capacity than `maxKeyLen`, + // it is possible to avoid the process of comparing the index of the key with the length of the bitmap each time. + bitmapLen := maxKeyLen + 1 + if len(sortedKeys) <= 8 { + keyBitmap := make([][256]uint8, bitmapLen) + for i, key := range sortedKeys { + for j := 0; j < len(key); j++ { + c := key[j] + keyBitmap[j][c] |= (1 << uint(i)) + } + d.sortedFieldSets = append(d.sortedFieldSets, fieldMap[key]) + } + d.keyBitmapUint8 = keyBitmap + d.keyDecoder = decodeKeyByBitmapUint8 + d.keyStreamDecoder = decodeKeyByBitmapUint8Stream + } else { + keyBitmap := make([][256]uint16, bitmapLen) + for i, key := range sortedKeys { + for j := 0; j < len(key); j++ { + c := key[j] + keyBitmap[j][c] |= (1 << uint(i)) + } + d.sortedFieldSets = append(d.sortedFieldSets, fieldMap[key]) + } + d.keyBitmapUint16 = keyBitmap + d.keyDecoder = decodeKeyByBitmapUint16 + d.keyStreamDecoder = decodeKeyByBitmapUint16Stream + } +} + +// decode from '\uXXXX' +func decodeKeyCharByUnicodeRune(buf []byte, cursor int64) ([]byte, int64) { + const defaultOffset = 4 + const surrogateOffset = 6 + + r := unicodeToRune(buf[cursor : cursor+defaultOffset]) + if utf16.IsSurrogate(r) { + cursor += defaultOffset + if cursor+surrogateOffset >= int64(len(buf)) || buf[cursor] != '\\' || buf[cursor+1] != 'u' { + return []byte(string(unicode.ReplacementChar)), cursor + defaultOffset - 1 + } + cursor += 2 + r2 := unicodeToRune(buf[cursor : cursor+defaultOffset]) + if r := utf16.DecodeRune(r, r2); r != unicode.ReplacementChar { + return []byte(string(r)), cursor + defaultOffset - 1 + } + } + return []byte(string(r)), cursor + defaultOffset - 1 +} + +func decodeKeyCharByEscapedChar(buf []byte, cursor int64) ([]byte, int64) { + c := buf[cursor] + cursor++ + switch c { + case '"': + return []byte{'"'}, cursor + case '\\': + return []byte{'\\'}, cursor + case '/': + return []byte{'/'}, cursor + case 'b': + return []byte{'\b'}, cursor + case 'f': + return []byte{'\f'}, cursor + case 'n': + return []byte{'\n'}, cursor + case 'r': + return []byte{'\r'}, cursor + case 't': + return []byte{'\t'}, cursor + case 'u': + return decodeKeyCharByUnicodeRune(buf, cursor) + } + return nil, cursor +} + +func decodeKeyByBitmapUint8(d *structDecoder, buf []byte, cursor int64) (int64, *structFieldSet, error) { + var ( + curBit uint8 = math.MaxUint8 + ) + b := (*sliceHeader)(unsafe.Pointer(&buf)).data + for { + switch char(b, cursor) { + case ' ', '\n', '\t', '\r': + cursor++ + case '"': + cursor++ + c := char(b, cursor) + switch c { + case '"': + cursor++ + return cursor, nil, nil + case nul: + return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor) + } + keyIdx := 0 + bitmap := d.keyBitmapUint8 + start := cursor + for { + c := char(b, cursor) + switch c { + case '"': + fieldSetIndex := bits.TrailingZeros8(curBit) + field := d.sortedFieldSets[fieldSetIndex] + keyLen := cursor - start + cursor++ + if keyLen < field.keyLen { + // early match + return cursor, nil, nil + } + return cursor, field, nil + case nul: + return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor) + case '\\': + cursor++ + chars, nextCursor := decodeKeyCharByEscapedChar(buf, cursor) + for _, c := range chars { + curBit &= bitmap[keyIdx][largeToSmallTable[c]] + if curBit == 0 { + return decodeKeyNotFound(b, cursor) + } + keyIdx++ + } + cursor = nextCursor + default: + curBit &= bitmap[keyIdx][largeToSmallTable[c]] + if curBit == 0 { + return decodeKeyNotFound(b, cursor) + } + keyIdx++ + } + cursor++ + } + default: + return cursor, nil, errors.ErrInvalidBeginningOfValue(char(b, cursor), cursor) + } + } +} + +func decodeKeyByBitmapUint16(d *structDecoder, buf []byte, cursor int64) (int64, *structFieldSet, error) { + var ( + curBit uint16 = math.MaxUint16 + ) + b := (*sliceHeader)(unsafe.Pointer(&buf)).data + for { + switch char(b, cursor) { + case ' ', '\n', '\t', '\r': + cursor++ + case '"': + cursor++ + c := char(b, cursor) + switch c { + case '"': + cursor++ + return cursor, nil, nil + case nul: + return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor) + } + keyIdx := 0 + bitmap := d.keyBitmapUint16 + start := cursor + for { + c := char(b, cursor) + switch c { + case '"': + fieldSetIndex := bits.TrailingZeros16(curBit) + field := d.sortedFieldSets[fieldSetIndex] + keyLen := cursor - start + cursor++ + if keyLen < field.keyLen { + // early match + return cursor, nil, nil + } + return cursor, field, nil + case nul: + return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor) + case '\\': + cursor++ + chars, nextCursor := decodeKeyCharByEscapedChar(buf, cursor) + for _, c := range chars { + curBit &= bitmap[keyIdx][largeToSmallTable[c]] + if curBit == 0 { + return decodeKeyNotFound(b, cursor) + } + keyIdx++ + } + cursor = nextCursor + default: + curBit &= bitmap[keyIdx][largeToSmallTable[c]] + if curBit == 0 { + return decodeKeyNotFound(b, cursor) + } + keyIdx++ + } + cursor++ + } + default: + return cursor, nil, errors.ErrInvalidBeginningOfValue(char(b, cursor), cursor) + } + } +} + +func decodeKeyNotFound(b unsafe.Pointer, cursor int64) (int64, *structFieldSet, error) { + for { + cursor++ + switch char(b, cursor) { + case '"': + cursor++ + return cursor, nil, nil + case '\\': + cursor++ + if char(b, cursor) == nul { + return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor) + } + case nul: + return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor) + } + } +} + +func decodeKey(d *structDecoder, buf []byte, cursor int64) (int64, *structFieldSet, error) { + key, c, err := d.stringDecoder.decodeByte(buf, cursor) + if err != nil { + return 0, nil, err + } + cursor = c + k := *(*string)(unsafe.Pointer(&key)) + field, exists := d.fieldMap[k] + if !exists { + return cursor, nil, nil + } + return cursor, field, nil +} + +func decodeKeyByBitmapUint8Stream(d *structDecoder, s *Stream) (*structFieldSet, string, error) { + var ( + curBit uint8 = math.MaxUint8 + ) + _, cursor, p := s.stat() + for { + switch char(p, cursor) { + case ' ', '\n', '\t', '\r': + cursor++ + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + return nil, "", errors.ErrInvalidBeginningOfValue(char(p, cursor), s.totalOffset()) + case '"': + cursor++ + FIRST_CHAR: + start := cursor + switch char(p, cursor) { + case '"': + cursor++ + s.cursor = cursor + return nil, "", nil + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + goto FIRST_CHAR + } + return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset()) + } + keyIdx := 0 + bitmap := d.keyBitmapUint8 + for { + c := char(p, cursor) + switch c { + case '"': + fieldSetIndex := bits.TrailingZeros8(curBit) + field := d.sortedFieldSets[fieldSetIndex] + keyLen := cursor - start + cursor++ + s.cursor = cursor + if keyLen < field.keyLen { + // early match + return nil, field.key, nil + } + return field, field.key, nil + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset()) + case '\\': + s.cursor = cursor + 1 // skip '\' char + chars, err := decodeKeyCharByEscapeCharStream(s) + if err != nil { + return nil, "", err + } + cursor = s.cursor + for _, c := range chars { + curBit &= bitmap[keyIdx][largeToSmallTable[c]] + if curBit == 0 { + s.cursor = cursor + return decodeKeyNotFoundStream(s, start) + } + keyIdx++ + } + default: + curBit &= bitmap[keyIdx][largeToSmallTable[c]] + if curBit == 0 { + s.cursor = cursor + return decodeKeyNotFoundStream(s, start) + } + keyIdx++ + } + cursor++ + } + default: + return nil, "", errors.ErrInvalidBeginningOfValue(char(p, cursor), s.totalOffset()) + } + } +} + +func decodeKeyByBitmapUint16Stream(d *structDecoder, s *Stream) (*structFieldSet, string, error) { + var ( + curBit uint16 = math.MaxUint16 + ) + _, cursor, p := s.stat() + for { + switch char(p, cursor) { + case ' ', '\n', '\t', '\r': + cursor++ + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + return nil, "", errors.ErrInvalidBeginningOfValue(char(p, cursor), s.totalOffset()) + case '"': + cursor++ + FIRST_CHAR: + start := cursor + switch char(p, cursor) { + case '"': + cursor++ + s.cursor = cursor + return nil, "", nil + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + goto FIRST_CHAR + } + return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset()) + } + keyIdx := 0 + bitmap := d.keyBitmapUint16 + for { + c := char(p, cursor) + switch c { + case '"': + fieldSetIndex := bits.TrailingZeros16(curBit) + field := d.sortedFieldSets[fieldSetIndex] + keyLen := cursor - start + cursor++ + s.cursor = cursor + if keyLen < field.keyLen { + // early match + return nil, field.key, nil + } + return field, field.key, nil + case nul: + s.cursor = cursor + if s.read() { + _, cursor, p = s.stat() + continue + } + return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset()) + case '\\': + s.cursor = cursor + 1 // skip '\' char + chars, err := decodeKeyCharByEscapeCharStream(s) + if err != nil { + return nil, "", err + } + cursor = s.cursor + for _, c := range chars { + curBit &= bitmap[keyIdx][largeToSmallTable[c]] + if curBit == 0 { + s.cursor = cursor + return decodeKeyNotFoundStream(s, start) + } + keyIdx++ + } + default: + curBit &= bitmap[keyIdx][largeToSmallTable[c]] + if curBit == 0 { + s.cursor = cursor + return decodeKeyNotFoundStream(s, start) + } + keyIdx++ + } + cursor++ + } + default: + return nil, "", errors.ErrInvalidBeginningOfValue(char(p, cursor), s.totalOffset()) + } + } +} + +// decode from '\uXXXX' +func decodeKeyCharByUnicodeRuneStream(s *Stream) ([]byte, error) { + const defaultOffset = 4 + const surrogateOffset = 6 + + if s.cursor+defaultOffset >= s.length { + if !s.read() { + return nil, errors.ErrInvalidCharacter(s.char(), "escaped unicode char", s.totalOffset()) + } + } + + r := unicodeToRune(s.buf[s.cursor : s.cursor+defaultOffset]) + if utf16.IsSurrogate(r) { + s.cursor += defaultOffset + if s.cursor+surrogateOffset >= s.length { + s.read() + } + if s.cursor+surrogateOffset >= s.length || s.buf[s.cursor] != '\\' || s.buf[s.cursor+1] != 'u' { + s.cursor += defaultOffset - 1 + return []byte(string(unicode.ReplacementChar)), nil + } + r2 := unicodeToRune(s.buf[s.cursor+defaultOffset+2 : s.cursor+surrogateOffset]) + if r := utf16.DecodeRune(r, r2); r != unicode.ReplacementChar { + s.cursor += defaultOffset - 1 + return []byte(string(r)), nil + } + } + s.cursor += defaultOffset - 1 + return []byte(string(r)), nil +} + +func decodeKeyCharByEscapeCharStream(s *Stream) ([]byte, error) { + c := s.buf[s.cursor] + s.cursor++ +RETRY: + switch c { + case '"': + return []byte{'"'}, nil + case '\\': + return []byte{'\\'}, nil + case '/': + return []byte{'/'}, nil + case 'b': + return []byte{'\b'}, nil + case 'f': + return []byte{'\f'}, nil + case 'n': + return []byte{'\n'}, nil + case 'r': + return []byte{'\r'}, nil + case 't': + return []byte{'\t'}, nil + case 'u': + return decodeKeyCharByUnicodeRuneStream(s) + case nul: + if !s.read() { + return nil, errors.ErrInvalidCharacter(s.char(), "escaped char", s.totalOffset()) + } + goto RETRY + default: + return nil, errors.ErrUnexpectedEndOfJSON("struct field", s.totalOffset()) + } +} + +func decodeKeyNotFoundStream(s *Stream, start int64) (*structFieldSet, string, error) { + buf, cursor, p := s.stat() + for { + cursor++ + switch char(p, cursor) { + case '"': + b := buf[start:cursor] + key := *(*string)(unsafe.Pointer(&b)) + cursor++ + s.cursor = cursor + return nil, key, nil + case '\\': + cursor++ + if char(p, cursor) == nul { + s.cursor = cursor + if !s.read() { + return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset()) + } + buf, cursor, p = s.statForRetry() + } + case nul: + s.cursor = cursor + if !s.read() { + return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset()) + } + buf, cursor, p = s.statForRetry() + } + } +} + +func decodeKeyStream(d *structDecoder, s *Stream) (*structFieldSet, string, error) { + key, err := d.stringDecoder.decodeStreamByte(s) + if err != nil { + return nil, "", err + } + k := *(*string)(unsafe.Pointer(&key)) + return d.fieldMap[k], k, nil +} + +func (d *structDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + depth++ + if depth > maxDecodeNestingDepth { + return errors.ErrExceededMaxDepth(s.char(), s.cursor) + } + + c := s.skipWhiteSpace() + switch c { + case 'n': + if err := nullBytes(s); err != nil { + return err + } + return nil + default: + if s.char() != '{' { + return errors.ErrInvalidBeginningOfValue(s.char(), s.totalOffset()) + } + } + s.cursor++ + if s.skipWhiteSpace() == '}' { + s.cursor++ + return nil + } + var ( + seenFields map[int]struct{} + seenFieldNum int + ) + firstWin := (s.Option.Flags & FirstWinOption) != 0 + if firstWin { + seenFields = make(map[int]struct{}, d.fieldUniqueNameNum) + } + for { + s.reset() + field, key, err := d.keyStreamDecoder(d, s) + if err != nil { + return err + } + if s.skipWhiteSpace() != ':' { + return errors.ErrExpected("colon after object key", s.totalOffset()) + } + s.cursor++ + if field != nil { + if field.err != nil { + return field.err + } + if firstWin { + if _, exists := seenFields[field.fieldIdx]; exists { + if err := s.skipValue(depth); err != nil { + return err + } + } else { + if err := field.dec.DecodeStream(s, depth, unsafe.Pointer(uintptr(p)+field.offset)); err != nil { + return err + } + seenFieldNum++ + if d.fieldUniqueNameNum <= seenFieldNum { + return s.skipObject(depth) + } + seenFields[field.fieldIdx] = struct{}{} + } + } else { + if err := field.dec.DecodeStream(s, depth, unsafe.Pointer(uintptr(p)+field.offset)); err != nil { + return err + } + } + } else if s.DisallowUnknownFields { + return fmt.Errorf("json: unknown field %q", key) + } else { + if err := s.skipValue(depth); err != nil { + return err + } + } + c := s.skipWhiteSpace() + if c == '}' { + s.cursor++ + return nil + } + if c != ',' { + return errors.ErrExpected("comma after object element", s.totalOffset()) + } + s.cursor++ + } +} + +func (d *structDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + depth++ + if depth > maxDecodeNestingDepth { + return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor) + } + buflen := int64(len(buf)) + cursor = skipWhiteSpace(buf, cursor) + b := (*sliceHeader)(unsafe.Pointer(&buf)).data + switch char(b, cursor) { + case 'n': + if err := validateNull(buf, cursor); err != nil { + return 0, err + } + cursor += 4 + return cursor, nil + case '{': + default: + return 0, errors.ErrInvalidBeginningOfValue(char(b, cursor), cursor) + } + cursor++ + cursor = skipWhiteSpace(buf, cursor) + if buf[cursor] == '}' { + cursor++ + return cursor, nil + } + var ( + seenFields map[int]struct{} + seenFieldNum int + ) + firstWin := (ctx.Option.Flags & FirstWinOption) != 0 + if firstWin { + seenFields = make(map[int]struct{}, d.fieldUniqueNameNum) + } + for { + c, field, err := d.keyDecoder(d, buf, cursor) + if err != nil { + return 0, err + } + cursor = skipWhiteSpace(buf, c) + if char(b, cursor) != ':' { + return 0, errors.ErrExpected("colon after object key", cursor) + } + cursor++ + if cursor >= buflen { + return 0, errors.ErrExpected("object value after colon", cursor) + } + if field != nil { + if field.err != nil { + return 0, field.err + } + if firstWin { + if _, exists := seenFields[field.fieldIdx]; exists { + c, err := skipValue(buf, cursor, depth) + if err != nil { + return 0, err + } + cursor = c + } else { + c, err := field.dec.Decode(ctx, cursor, depth, unsafe.Pointer(uintptr(p)+field.offset)) + if err != nil { + return 0, err + } + cursor = c + seenFieldNum++ + if d.fieldUniqueNameNum <= seenFieldNum { + return skipObject(buf, cursor, depth) + } + seenFields[field.fieldIdx] = struct{}{} + } + } else { + c, err := field.dec.Decode(ctx, cursor, depth, unsafe.Pointer(uintptr(p)+field.offset)) + if err != nil { + return 0, err + } + cursor = c + } + } else { + c, err := skipValue(buf, cursor, depth) + if err != nil { + return 0, err + } + cursor = c + } + cursor = skipWhiteSpace(buf, cursor) + if char(b, cursor) == '}' { + cursor++ + return cursor, nil + } + if char(b, cursor) != ',' { + return 0, errors.ErrExpected("comma after object element", cursor) + } + cursor++ + } +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/type.go b/vendor/github.com/goccy/go-json/internal/decoder/type.go new file mode 100644 index 000000000..70e9907c8 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/type.go @@ -0,0 +1,29 @@ +package decoder + +import ( + "context" + "encoding" + "encoding/json" + "reflect" + "unsafe" +) + +type Decoder interface { + Decode(*RuntimeContext, int64, int64, unsafe.Pointer) (int64, error) + DecodeStream(*Stream, int64, unsafe.Pointer) error +} + +const ( + nul = '\000' + maxDecodeNestingDepth = 10000 +) + +type unmarshalerContext interface { + UnmarshalJSON(context.Context, []byte) error +} + +var ( + unmarshalJSONType = reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + unmarshalJSONContextType = reflect.TypeOf((*unmarshalerContext)(nil)).Elem() + unmarshalTextType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem() +) diff --git a/vendor/github.com/goccy/go-json/internal/decoder/uint.go b/vendor/github.com/goccy/go-json/internal/decoder/uint.go new file mode 100644 index 000000000..a62c51492 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/uint.go @@ -0,0 +1,190 @@ +package decoder + +import ( + "fmt" + "reflect" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type uintDecoder struct { + typ *runtime.Type + kind reflect.Kind + op func(unsafe.Pointer, uint64) + structName string + fieldName string +} + +func newUintDecoder(typ *runtime.Type, structName, fieldName string, op func(unsafe.Pointer, uint64)) *uintDecoder { + return &uintDecoder{ + typ: typ, + kind: typ.Kind(), + op: op, + structName: structName, + fieldName: fieldName, + } +} + +func (d *uintDecoder) typeError(buf []byte, offset int64) *errors.UnmarshalTypeError { + return &errors.UnmarshalTypeError{ + Value: fmt.Sprintf("number %s", string(buf)), + Type: runtime.RType2Type(d.typ), + Offset: offset, + } +} + +var ( + pow10u64 = [...]uint64{ + 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09, + 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, + } + pow10u64Len = len(pow10u64) +) + +func (d *uintDecoder) parseUint(b []byte) (uint64, error) { + maxDigit := len(b) + if maxDigit > pow10u64Len { + return 0, fmt.Errorf("invalid length of number") + } + sum := uint64(0) + for i := 0; i < maxDigit; i++ { + c := uint64(b[i]) - 48 + digitValue := pow10u64[maxDigit-i-1] + sum += c * digitValue + } + return sum, nil +} + +func (d *uintDecoder) decodeStreamByte(s *Stream) ([]byte, error) { + for { + switch s.char() { + case ' ', '\n', '\t', '\r': + s.cursor++ + continue + case '0': + s.cursor++ + return numZeroBuf, nil + case '1', '2', '3', '4', '5', '6', '7', '8', '9': + start := s.cursor + for { + s.cursor++ + if numTable[s.char()] { + continue + } else if s.char() == nul { + if s.read() { + s.cursor-- // for retry current character + continue + } + } + break + } + num := s.buf[start:s.cursor] + return num, nil + case 'n': + if err := nullBytes(s); err != nil { + return nil, err + } + return nil, nil + case nul: + if s.read() { + continue + } + default: + return nil, d.typeError([]byte{s.char()}, s.totalOffset()) + } + break + } + return nil, errors.ErrUnexpectedEndOfJSON("number(unsigned integer)", s.totalOffset()) +} + +func (d *uintDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) { + for { + switch buf[cursor] { + case ' ', '\n', '\t', '\r': + cursor++ + continue + case '0': + cursor++ + return numZeroBuf, cursor, nil + case '1', '2', '3', '4', '5', '6', '7', '8', '9': + start := cursor + cursor++ + for numTable[buf[cursor]] { + cursor++ + } + num := buf[start:cursor] + return num, cursor, nil + case 'n': + if err := validateNull(buf, cursor); err != nil { + return nil, 0, err + } + cursor += 4 + return nil, cursor, nil + default: + return nil, 0, d.typeError([]byte{buf[cursor]}, cursor) + } + } +} + +func (d *uintDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + bytes, err := d.decodeStreamByte(s) + if err != nil { + return err + } + if bytes == nil { + return nil + } + u64, err := d.parseUint(bytes) + if err != nil { + return d.typeError(bytes, s.totalOffset()) + } + switch d.kind { + case reflect.Uint8: + if (1 << 8) <= u64 { + return d.typeError(bytes, s.totalOffset()) + } + case reflect.Uint16: + if (1 << 16) <= u64 { + return d.typeError(bytes, s.totalOffset()) + } + case reflect.Uint32: + if (1 << 32) <= u64 { + return d.typeError(bytes, s.totalOffset()) + } + } + d.op(p, u64) + return nil +} + +func (d *uintDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + bytes, c, err := d.decodeByte(ctx.Buf, cursor) + if err != nil { + return 0, err + } + if bytes == nil { + return c, nil + } + cursor = c + u64, err := d.parseUint(bytes) + if err != nil { + return 0, d.typeError(bytes, cursor) + } + switch d.kind { + case reflect.Uint8: + if (1 << 8) <= u64 { + return 0, d.typeError(bytes, cursor) + } + case reflect.Uint16: + if (1 << 16) <= u64 { + return 0, d.typeError(bytes, cursor) + } + case reflect.Uint32: + if (1 << 32) <= u64 { + return 0, d.typeError(bytes, cursor) + } + } + d.op(p, u64) + return cursor, nil +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go new file mode 100644 index 000000000..d90f39cc5 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go @@ -0,0 +1,91 @@ +package decoder + +import ( + "encoding/json" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type unmarshalJSONDecoder struct { + typ *runtime.Type + structName string + fieldName string +} + +func newUnmarshalJSONDecoder(typ *runtime.Type, structName, fieldName string) *unmarshalJSONDecoder { + return &unmarshalJSONDecoder{ + typ: typ, + structName: structName, + fieldName: fieldName, + } +} + +func (d *unmarshalJSONDecoder) annotateError(cursor int64, err error) { + switch e := err.(type) { + case *errors.UnmarshalTypeError: + e.Struct = d.structName + e.Field = d.fieldName + case *errors.SyntaxError: + e.Offset = cursor + } +} + +func (d *unmarshalJSONDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + s.skipWhiteSpace() + start := s.cursor + if err := s.skipValue(depth); err != nil { + return err + } + src := s.buf[start:s.cursor] + dst := make([]byte, len(src)) + copy(dst, src) + + v := *(*interface{})(unsafe.Pointer(&emptyInterface{ + typ: d.typ, + ptr: p, + })) + if (s.Option.Flags & ContextOption) != 0 { + if err := v.(unmarshalerContext).UnmarshalJSON(s.Option.Context, dst); err != nil { + d.annotateError(s.cursor, err) + return err + } + } else { + if err := v.(json.Unmarshaler).UnmarshalJSON(dst); err != nil { + d.annotateError(s.cursor, err) + return err + } + } + return nil +} + +func (d *unmarshalJSONDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + cursor = skipWhiteSpace(buf, cursor) + start := cursor + end, err := skipValue(buf, cursor, depth) + if err != nil { + return 0, err + } + src := buf[start:end] + dst := make([]byte, len(src)) + copy(dst, src) + + v := *(*interface{})(unsafe.Pointer(&emptyInterface{ + typ: d.typ, + ptr: p, + })) + if (ctx.Option.Flags & ContextOption) != 0 { + if err := v.(unmarshalerContext).UnmarshalJSON(ctx.Option.Context, dst); err != nil { + d.annotateError(cursor, err) + return 0, err + } + } else { + if err := v.(json.Unmarshaler).UnmarshalJSON(dst); err != nil { + d.annotateError(cursor, err) + return 0, err + } + } + return end, nil +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go new file mode 100644 index 000000000..1ef287782 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go @@ -0,0 +1,280 @@ +package decoder + +import ( + "bytes" + "encoding" + "unicode" + "unicode/utf16" + "unicode/utf8" + "unsafe" + + "github.com/goccy/go-json/internal/errors" + "github.com/goccy/go-json/internal/runtime" +) + +type unmarshalTextDecoder struct { + typ *runtime.Type + structName string + fieldName string +} + +func newUnmarshalTextDecoder(typ *runtime.Type, structName, fieldName string) *unmarshalTextDecoder { + return &unmarshalTextDecoder{ + typ: typ, + structName: structName, + fieldName: fieldName, + } +} + +func (d *unmarshalTextDecoder) annotateError(cursor int64, err error) { + switch e := err.(type) { + case *errors.UnmarshalTypeError: + e.Struct = d.structName + e.Field = d.fieldName + case *errors.SyntaxError: + e.Offset = cursor + } +} + +var ( + nullbytes = []byte(`null`) +) + +func (d *unmarshalTextDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + s.skipWhiteSpace() + start := s.cursor + if err := s.skipValue(depth); err != nil { + return err + } + src := s.buf[start:s.cursor] + if len(src) > 0 { + switch src[0] { + case '[': + return &errors.UnmarshalTypeError{ + Value: "array", + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + case '{': + return &errors.UnmarshalTypeError{ + Value: "object", + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return &errors.UnmarshalTypeError{ + Value: "number", + Type: runtime.RType2Type(d.typ), + Offset: s.totalOffset(), + } + case 'n': + if bytes.Equal(src, nullbytes) { + *(*unsafe.Pointer)(p) = nil + return nil + } + } + } + dst := make([]byte, len(src)) + copy(dst, src) + + if b, ok := unquoteBytes(dst); ok { + dst = b + } + v := *(*interface{})(unsafe.Pointer(&emptyInterface{ + typ: d.typ, + ptr: p, + })) + if err := v.(encoding.TextUnmarshaler).UnmarshalText(dst); err != nil { + d.annotateError(s.cursor, err) + return err + } + return nil +} + +func (d *unmarshalTextDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + buf := ctx.Buf + cursor = skipWhiteSpace(buf, cursor) + start := cursor + end, err := skipValue(buf, cursor, depth) + if err != nil { + return 0, err + } + src := buf[start:end] + if len(src) > 0 { + switch src[0] { + case '[': + return 0, &errors.UnmarshalTypeError{ + Value: "array", + Type: runtime.RType2Type(d.typ), + Offset: start, + } + case '{': + return 0, &errors.UnmarshalTypeError{ + Value: "object", + Type: runtime.RType2Type(d.typ), + Offset: start, + } + case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + return 0, &errors.UnmarshalTypeError{ + Value: "number", + Type: runtime.RType2Type(d.typ), + Offset: start, + } + case 'n': + if bytes.Equal(src, nullbytes) { + *(*unsafe.Pointer)(p) = nil + return end, nil + } + } + } + + if s, ok := unquoteBytes(src); ok { + src = s + } + v := *(*interface{})(unsafe.Pointer(&emptyInterface{ + typ: d.typ, + ptr: *(*unsafe.Pointer)(unsafe.Pointer(&p)), + })) + if err := v.(encoding.TextUnmarshaler).UnmarshalText(src); err != nil { + d.annotateError(cursor, err) + return 0, err + } + return end, nil +} + +func unquoteBytes(s []byte) (t []byte, ok bool) { + length := len(s) + if length < 2 || s[0] != '"' || s[length-1] != '"' { + return + } + s = s[1 : length-1] + length -= 2 + + // Check for unusual characters. If there are none, + // then no unquoting is needed, so return a slice of the + // original bytes. + r := 0 + for r < length { + c := s[r] + if c == '\\' || c == '"' || c < ' ' { + break + } + if c < utf8.RuneSelf { + r++ + continue + } + rr, size := utf8.DecodeRune(s[r:]) + if rr == utf8.RuneError && size == 1 { + break + } + r += size + } + if r == length { + return s, true + } + + b := make([]byte, length+2*utf8.UTFMax) + w := copy(b, s[0:r]) + for r < length { + // Out of room? Can only happen if s is full of + // malformed UTF-8 and we're replacing each + // byte with RuneError. + if w >= len(b)-2*utf8.UTFMax { + nb := make([]byte, (len(b)+utf8.UTFMax)*2) + copy(nb, b[0:w]) + b = nb + } + switch c := s[r]; { + case c == '\\': + r++ + if r >= length { + return + } + switch s[r] { + default: + return + case '"', '\\', '/', '\'': + b[w] = s[r] + r++ + w++ + case 'b': + b[w] = '\b' + r++ + w++ + case 'f': + b[w] = '\f' + r++ + w++ + case 'n': + b[w] = '\n' + r++ + w++ + case 'r': + b[w] = '\r' + r++ + w++ + case 't': + b[w] = '\t' + r++ + w++ + case 'u': + r-- + rr := getu4(s[r:]) + if rr < 0 { + return + } + r += 6 + if utf16.IsSurrogate(rr) { + rr1 := getu4(s[r:]) + if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar { + // A valid pair; consume. + r += 6 + w += utf8.EncodeRune(b[w:], dec) + break + } + // Invalid surrogate; fall back to replacement rune. + rr = unicode.ReplacementChar + } + w += utf8.EncodeRune(b[w:], rr) + } + + // Quote, control characters are invalid. + case c == '"', c < ' ': + return + + // ASCII + case c < utf8.RuneSelf: + b[w] = c + r++ + w++ + + // Coerce to well-formed UTF-8. + default: + rr, size := utf8.DecodeRune(s[r:]) + r += size + w += utf8.EncodeRune(b[w:], rr) + } + } + return b[0:w], true +} + +func getu4(s []byte) rune { + if len(s) < 6 || s[0] != '\\' || s[1] != 'u' { + return -1 + } + var r rune + for _, c := range s[2:6] { + switch { + case '0' <= c && c <= '9': + c = c - '0' + case 'a' <= c && c <= 'f': + c = c - 'a' + 10 + case 'A' <= c && c <= 'F': + c = c - 'A' + 10 + default: + return -1 + } + r = r*16 + rune(c) + } + return r +} diff --git a/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go b/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go new file mode 100644 index 000000000..66227ae02 --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go @@ -0,0 +1,68 @@ +package decoder + +import ( + "reflect" + "unsafe" + + "github.com/goccy/go-json/internal/runtime" +) + +type wrappedStringDecoder struct { + typ *runtime.Type + dec Decoder + stringDecoder *stringDecoder + structName string + fieldName string + isPtrType bool +} + +func newWrappedStringDecoder(typ *runtime.Type, dec Decoder, structName, fieldName string) *wrappedStringDecoder { + return &wrappedStringDecoder{ + typ: typ, + dec: dec, + stringDecoder: newStringDecoder(structName, fieldName), + structName: structName, + fieldName: fieldName, + isPtrType: typ.Kind() == reflect.Ptr, + } +} + +func (d *wrappedStringDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error { + bytes, err := d.stringDecoder.decodeStreamByte(s) + if err != nil { + return err + } + if bytes == nil { + if d.isPtrType { + *(*unsafe.Pointer)(p) = nil + } + return nil + } + b := make([]byte, len(bytes)+1) + copy(b, bytes) + if _, err := d.dec.Decode(&RuntimeContext{Buf: b}, 0, depth, p); err != nil { + return err + } + return nil +} + +func (d *wrappedStringDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) { + bytes, c, err := d.stringDecoder.decodeByte(ctx.Buf, cursor) + if err != nil { + return 0, err + } + if bytes == nil { + if d.isPtrType { + *(*unsafe.Pointer)(p) = nil + } + return c, nil + } + bytes = append(bytes, nul) + oldBuf := ctx.Buf + ctx.Buf = bytes + if _, err := d.dec.Decode(ctx, 0, depth, p); err != nil { + return 0, err + } + ctx.Buf = oldBuf + return c, nil +} diff --git a/vendor/github.com/goccy/go-json/internal/encoder/compiler.go b/vendor/github.com/goccy/go-json/internal/encoder/compiler.go index 486c80f18..c627ed307 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/compiler.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/compiler.go @@ -1,6 +1,7 @@ package encoder import ( + "context" "encoding" "encoding/json" "fmt" @@ -13,13 +14,18 @@ import ( "github.com/goccy/go-json/internal/runtime" ) +type marshalerContext interface { + MarshalJSON(context.Context) ([]byte, error) +} + var ( - marshalJSONType = reflect.TypeOf((*json.Marshaler)(nil)).Elem() - marshalTextType = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem() - jsonNumberType = reflect.TypeOf(json.Number("")) - cachedOpcodeSets []*OpcodeSet - cachedOpcodeMap unsafe.Pointer // map[uintptr]*OpcodeSet - typeAddr *runtime.TypeAddr + marshalJSONType = reflect.TypeOf((*json.Marshaler)(nil)).Elem() + marshalJSONContextType = reflect.TypeOf((*marshalerContext)(nil)).Elem() + marshalTextType = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem() + jsonNumberType = reflect.TypeOf(json.Number("")) + cachedOpcodeSets []*OpcodeSet + cachedOpcodeMap unsafe.Pointer // map[uintptr]*OpcodeSet + typeAddr *runtime.TypeAddr ) func init() { @@ -55,19 +61,36 @@ func compileToGetCodeSetSlowPath(typeptr uintptr) (*OpcodeSet, error) { // noescape trick for header.typ ( reflect.*rtype ) copiedType := *(**runtime.Type)(unsafe.Pointer(&typeptr)) - code, err := compileHead(&compileContext{ + noescapeKeyCode, err := compileHead(&compileContext{ + typ: copiedType, + structTypeToCompiledCode: map[uintptr]*CompiledCode{}, + }) + if err != nil { + return nil, err + } + escapeKeyCode, err := compileHead(&compileContext{ typ: copiedType, structTypeToCompiledCode: map[uintptr]*CompiledCode{}, + escapeKey: true, }) if err != nil { return nil, err } - code = copyOpcode(code) - codeLength := code.TotalLength() + noescapeKeyCode = copyOpcode(noescapeKeyCode) + escapeKeyCode = copyOpcode(escapeKeyCode) + setTotalLengthToInterfaceOp(noescapeKeyCode) + setTotalLengthToInterfaceOp(escapeKeyCode) + interfaceNoescapeKeyCode := copyToInterfaceOpcode(noescapeKeyCode) + interfaceEscapeKeyCode := copyToInterfaceOpcode(escapeKeyCode) + codeLength := noescapeKeyCode.TotalLength() codeSet := &OpcodeSet{ - Type: copiedType, - Code: code, - CodeLength: codeLength, + Type: copiedType, + NoescapeKeyCode: noescapeKeyCode, + EscapeKeyCode: escapeKeyCode, + InterfaceNoescapeKeyCode: interfaceNoescapeKeyCode, + InterfaceEscapeKeyCode: interfaceEscapeKeyCode, + CodeLength: codeLength, + EndCode: ToEndCode(interfaceNoescapeKeyCode), } storeOpcodeSet(typeptr, codeSet, opcodeMap) return codeSet, nil @@ -100,7 +123,7 @@ func compileHead(ctx *compileContext) (*Opcode, error) { elem := typ.Elem() if elem.Kind() == reflect.Uint8 { p := runtime.PtrTo(elem) - if !p.Implements(marshalJSONType) && !p.Implements(marshalTextType) { + if !implementsMarshalJSONType(p) && !p.Implements(marshalTextType) { if isPtr { return compileBytesPtr(ctx) } @@ -246,6 +269,7 @@ func linkRecursiveCode(c *Opcode) { continue } code.Jmp.Code = copyOpcode(code.Jmp.Code) + c := code.Jmp.Code c.End.Next = newEndOp(&compileContext{}) c.Op = c.Op.PtrHeadToHead() @@ -258,8 +282,8 @@ func linkRecursiveCode(c *Opcode) { lastCode.Length = lastCode.Idx + 2*uintptrSize // extend length to alloc slot for elemIdx + length - totalLength := uintptr(code.TotalLength() + 2) - nextTotalLength := uintptr(c.TotalLength() + 2) + totalLength := uintptr(code.TotalLength() + 3) + nextTotalLength := uintptr(c.TotalLength() + 3) c.End.Next.Op = OpRecursiveEnd @@ -268,6 +292,7 @@ func linkRecursiveCode(c *Opcode) { code.Jmp.Linked = true linkRecursiveCode(code.Jmp.Code) + code = code.Next continue } @@ -328,14 +353,14 @@ func optimizeStructEnd(c *Opcode) { } func implementsMarshalJSON(typ *runtime.Type) bool { - if !typ.Implements(marshalJSONType) { + if !implementsMarshalJSONType(typ) { return false } if typ.Kind() != reflect.Ptr { return true } // type kind is reflect.Ptr - if !typ.Elem().Implements(marshalJSONType) { + if !implementsMarshalJSONType(typ.Elem()) { return true } // needs to dereference @@ -372,7 +397,7 @@ func compile(ctx *compileContext, isPtr bool) (*Opcode, error) { elem := typ.Elem() if elem.Kind() == reflect.Uint8 { p := runtime.PtrTo(elem) - if !p.Implements(marshalJSONType) && !p.Implements(marshalTextType) { + if !implementsMarshalJSONType(p) && !p.Implements(marshalTextType) { return compileBytes(ctx) } } @@ -474,8 +499,6 @@ func compileKey(ctx *compileContext) (*Opcode, error) { switch typ.Kind() { case reflect.Ptr: return compilePtr(ctx) - case reflect.Interface: - return compileInterface(ctx) case reflect.String: return compileString(ctx) case reflect.Int: @@ -517,10 +540,17 @@ func compilePtr(ctx *compileContext) (*Opcode, error) { func compileMarshalJSON(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpMarshalJSON) typ := ctx.typ - if !typ.Implements(marshalJSONType) && runtime.PtrTo(typ).Implements(marshalJSONType) { - code.AddrForMarshaler = true + if isPtrMarshalJSONType(typ) { + code.Flags |= AddrForMarshalerFlags + } + if typ.Implements(marshalJSONContextType) || runtime.PtrTo(typ).Implements(marshalJSONContextType) { + code.Flags |= MarshalerContextFlags + } + if isNilableType(typ) { + code.Flags |= IsNilableTypeFlags + } else { + code.Flags &= ^IsNilableTypeFlags } - code.IsNilableType = isNilableType(typ) ctx.incIndex() return code, nil } @@ -529,9 +559,13 @@ func compileMarshalText(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpMarshalText) typ := ctx.typ if !typ.Implements(marshalTextType) && runtime.PtrTo(typ).Implements(marshalTextType) { - code.AddrForMarshaler = true + code.Flags |= AddrForMarshalerFlags + } + if isNilableType(typ) { + code.Flags |= IsNilableTypeFlags + } else { + code.Flags &= ^IsNilableTypeFlags } - code.IsNilableType = isNilableType(typ) ctx.incIndex() return code, nil } @@ -540,7 +574,7 @@ const intSize = 32 << (^uint(0) >> 63) func compileInt(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpInt) - code.setMaskAndRshiftNum(intSize) + code.NumBitSize = intSize ctx.incIndex() return code, nil } @@ -556,7 +590,7 @@ func compileIntPtr(ctx *compileContext) (*Opcode, error) { func compileInt8(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpInt) - code.setMaskAndRshiftNum(8) + code.NumBitSize = 8 ctx.incIndex() return code, nil } @@ -572,7 +606,7 @@ func compileInt8Ptr(ctx *compileContext) (*Opcode, error) { func compileInt16(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpInt) - code.setMaskAndRshiftNum(16) + code.NumBitSize = 16 ctx.incIndex() return code, nil } @@ -588,7 +622,7 @@ func compileInt16Ptr(ctx *compileContext) (*Opcode, error) { func compileInt32(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpInt) - code.setMaskAndRshiftNum(32) + code.NumBitSize = 32 ctx.incIndex() return code, nil } @@ -604,7 +638,7 @@ func compileInt32Ptr(ctx *compileContext) (*Opcode, error) { func compileInt64(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpInt) - code.setMaskAndRshiftNum(64) + code.NumBitSize = 64 ctx.incIndex() return code, nil } @@ -620,7 +654,7 @@ func compileInt64Ptr(ctx *compileContext) (*Opcode, error) { func compileUint(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpUint) - code.setMaskAndRshiftNum(intSize) + code.NumBitSize = intSize ctx.incIndex() return code, nil } @@ -636,7 +670,7 @@ func compileUintPtr(ctx *compileContext) (*Opcode, error) { func compileUint8(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpUint) - code.setMaskAndRshiftNum(8) + code.NumBitSize = 8 ctx.incIndex() return code, nil } @@ -652,7 +686,7 @@ func compileUint8Ptr(ctx *compileContext) (*Opcode, error) { func compileUint16(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpUint) - code.setMaskAndRshiftNum(16) + code.NumBitSize = 16 ctx.incIndex() return code, nil } @@ -668,7 +702,7 @@ func compileUint16Ptr(ctx *compileContext) (*Opcode, error) { func compileUint32(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpUint) - code.setMaskAndRshiftNum(32) + code.NumBitSize = 32 ctx.incIndex() return code, nil } @@ -684,7 +718,7 @@ func compileUint32Ptr(ctx *compileContext) (*Opcode, error) { func compileUint64(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpUint) - code.setMaskAndRshiftNum(64) + code.NumBitSize = 64 ctx.incIndex() return code, nil } @@ -700,70 +734,70 @@ func compileUint64Ptr(ctx *compileContext) (*Opcode, error) { func compileIntString(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpIntString) - code.setMaskAndRshiftNum(intSize) + code.NumBitSize = intSize ctx.incIndex() return code, nil } func compileInt8String(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpIntString) - code.setMaskAndRshiftNum(8) + code.NumBitSize = 8 ctx.incIndex() return code, nil } func compileInt16String(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpIntString) - code.setMaskAndRshiftNum(16) + code.NumBitSize = 16 ctx.incIndex() return code, nil } func compileInt32String(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpIntString) - code.setMaskAndRshiftNum(32) + code.NumBitSize = 32 ctx.incIndex() return code, nil } func compileInt64String(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpIntString) - code.setMaskAndRshiftNum(64) + code.NumBitSize = 64 ctx.incIndex() return code, nil } func compileUintString(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpUintString) - code.setMaskAndRshiftNum(intSize) + code.NumBitSize = intSize ctx.incIndex() return code, nil } func compileUint8String(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpUintString) - code.setMaskAndRshiftNum(8) + code.NumBitSize = 8 ctx.incIndex() return code, nil } func compileUint16String(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpUintString) - code.setMaskAndRshiftNum(16) + code.NumBitSize = 16 ctx.incIndex() return code, nil } func compileUint32String(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpUintString) - code.setMaskAndRshiftNum(32) + code.NumBitSize = 32 ctx.incIndex() return code, nil } func compileUint64String(ctx *compileContext) (*Opcode, error) { code := newOpCode(ctx, OpUintString) - code.setMaskAndRshiftNum(64) + code.NumBitSize = 64 ctx.incIndex() return code, nil } @@ -879,7 +913,7 @@ func compileSlice(ctx *compileContext) (*Opcode, error) { if err != nil { return nil, err } - code.Indirect = true + code.Flags |= IndirectFlags // header => opcode => elem => end // ^ | @@ -891,7 +925,6 @@ func compileSlice(ctx *compileContext) (*Opcode, error) { end := newOpCode(ctx, OpSliceEnd) ctx.incIndex() - header.Elem = elemCode header.End = end header.Next = code code.BeforeLastCode().Next = (*Opcode)(unsafe.Pointer(elemCode)) @@ -903,7 +936,7 @@ func compileSlice(ctx *compileContext) (*Opcode, error) { func compileListElem(ctx *compileContext) (*Opcode, error) { typ := ctx.typ switch { - case !typ.Implements(marshalJSONType) && runtime.PtrTo(typ).Implements(marshalJSONType): + case isPtrMarshalJSONType(typ): return compileMarshalJSON(ctx) case !typ.Implements(marshalTextType) && runtime.PtrTo(typ).Implements(marshalTextType): return compileMarshalText(ctx) @@ -934,7 +967,7 @@ func compileArray(ctx *compileContext) (*Opcode, error) { if err != nil { return nil, err } - code.Indirect = true + code.Flags |= IndirectFlags // header => opcode => elem => end // ^ | // |________| @@ -945,7 +978,6 @@ func compileArray(ctx *compileContext) (*Opcode, error) { end := newOpCode(ctx, OpArrayEnd) ctx.incIndex() - header.Elem = elemCode header.End = end header.Next = code code.BeforeLastCode().Next = (*Opcode)(unsafe.Pointer(elemCode)) @@ -976,16 +1008,13 @@ func compileMap(ctx *compileContext) (*Opcode, error) { if err != nil { return nil, err } - valueCode.Indirect = true + valueCode.Flags |= IndirectFlags key := newMapKeyCode(ctx, header) ctx.incIndex() ctx = ctx.decIndent() - header.MapKey = key - header.MapValue = value - end := newMapEndCode(ctx, header) ctx.incIndex() @@ -1052,8 +1081,7 @@ func compiledCode(ctx *compileContext) *Opcode { func structHeader(ctx *compileContext, fieldCode *Opcode, valueCode *Opcode, tag *runtime.StructTag) *Opcode { op := optimizeStructHeader(valueCode, tag) fieldCode.Op = op - fieldCode.Mask = valueCode.Mask - fieldCode.RshiftNum = valueCode.RshiftNum + fieldCode.NumBitSize = valueCode.NumBitSize fieldCode.PtrNum = valueCode.PtrNum if op.IsMultipleOpHead() { return valueCode.BeforeLastCode() @@ -1065,9 +1093,8 @@ func structHeader(ctx *compileContext, fieldCode *Opcode, valueCode *Opcode, tag func structField(ctx *compileContext, fieldCode *Opcode, valueCode *Opcode, tag *runtime.StructTag) *Opcode { op := optimizeStructField(valueCode, tag) fieldCode.Op = op + fieldCode.NumBitSize = valueCode.NumBitSize fieldCode.PtrNum = valueCode.PtrNum - fieldCode.Mask = valueCode.Mask - fieldCode.RshiftNum = valueCode.RshiftNum if op.IsMultipleOpField() { return valueCode.BeforeLastCode() } @@ -1082,7 +1109,7 @@ func isNotExistsField(head *Opcode) bool { if head.Op != OpStructHead { return false } - if !head.AnonymousHead { + if (head.Flags & AnonymousHeadFlags) == 0 { return false } if head.Next == nil { @@ -1117,7 +1144,7 @@ func optimizeAnonymousFields(head *Opcode) { if isNotExistsField(code.Next) { code.Next = code.NextField diff := code.Next.DisplayIdx - code.DisplayIdx - for i := 0; i < diff; i++ { + for i := uint32(0); i < diff; i++ { code.Next.decOpcodeIndex() } linkPrevToNextField(code, removedFields) @@ -1147,20 +1174,20 @@ func anonymousStructFieldPairMap(tags runtime.StructTags, named string, valueCod isHeadOp := strings.Contains(f.Op.String(), "Head") if existsKey && f.Next != nil && strings.Contains(f.Next.Op.String(), "Recursive") { // through - } else if isHeadOp && !f.AnonymousHead { + } else if isHeadOp && (f.Flags&AnonymousHeadFlags) == 0 { if existsKey { // TODO: need to remove this head f.Op = OpStructHead - f.AnonymousKey = true - f.AnonymousHead = true + f.Flags |= AnonymousKeyFlags + f.Flags |= AnonymousHeadFlags } else if named == "" { - f.AnonymousHead = true + f.Flags |= AnonymousHeadFlags } } else if named == "" && f.Op == OpStructEnd { f.Op = OpStructAnonymousEnd } else if existsKey { diff := f.NextField.DisplayIdx - f.DisplayIdx - for i := 0; i < diff; i++ { + for i := uint32(0); i < diff; i++ { f.NextField.decOpcodeIndex() } linkPrevToNextField(f, removedFields) @@ -1179,7 +1206,7 @@ func anonymousStructFieldPairMap(tags runtime.StructTags, named string, valueCod anonymousFields[key] = append(anonymousFields[key], structFieldPair{ prevField: prevAnonymousField, curField: f, - isTaggedKey: f.IsTaggedKey, + isTaggedKey: (f.Flags & IsTaggedKeyFlags) != 0, }) if f.Next != nil && f.NextField != f.Next && f.Next.Op.CodeType() == CodeStructField { for k, v := range anonymousFieldPairRecursively(named, f.Next) { @@ -1200,12 +1227,12 @@ func anonymousFieldPairRecursively(named string, valueCode *Opcode) map[string][ f := valueCode var prevAnonymousField *Opcode for { - if f.DisplayKey != "" && f.AnonymousHead { + if f.DisplayKey != "" && (f.Flags&AnonymousHeadFlags) != 0 { key := fmt.Sprintf("%s.%s", named, f.DisplayKey) anonymousFields[key] = append(anonymousFields[key], structFieldPair{ prevField: prevAnonymousField, curField: f, - isTaggedKey: f.IsTaggedKey, + isTaggedKey: (f.Flags & IsTaggedKeyFlags) != 0, }) if f.Next != nil && f.NextField != f.Next && f.Next.Op.CodeType() == CodeStructField { for k, v := range anonymousFieldPairRecursively(named, f.Next) { @@ -1238,11 +1265,11 @@ func optimizeConflictAnonymousFields(anonymousFields map[string][]structFieldPai if fieldPair.prevField == nil { // head operation fieldPair.curField.Op = OpStructHead - fieldPair.curField.AnonymousHead = true - fieldPair.curField.AnonymousKey = true + fieldPair.curField.Flags |= AnonymousHeadFlags + fieldPair.curField.Flags |= AnonymousKeyFlags } else { diff := fieldPair.curField.NextField.DisplayIdx - fieldPair.curField.DisplayIdx - for i := 0; i < diff; i++ { + for i := uint32(0); i < diff; i++ { fieldPair.curField.NextField.decOpcodeIndex() } removedFields[fieldPair.curField] = struct{}{} @@ -1258,12 +1285,12 @@ func optimizeConflictAnonymousFields(anonymousFields map[string][]structFieldPai if fieldPair.prevField == nil { // head operation fieldPair.curField.Op = OpStructHead - fieldPair.curField.AnonymousHead = true - fieldPair.curField.AnonymousKey = true + fieldPair.curField.Flags |= AnonymousHeadFlags + fieldPair.curField.Flags |= AnonymousKeyFlags } else { diff := fieldPair.curField.NextField.DisplayIdx - fieldPair.curField.DisplayIdx removedFields[fieldPair.curField] = struct{}{} - for i := 0; i < diff; i++ { + for i := uint32(0); i < diff; i++ { fieldPair.curField.NextField.decOpcodeIndex() } linkPrevToNextField(fieldPair.curField, removedFields) @@ -1273,7 +1300,7 @@ func optimizeConflictAnonymousFields(anonymousFields map[string][]structFieldPai } } else { for _, fieldPair := range taggedPairs { - fieldPair.curField.IsTaggedKey = false + fieldPair.curField.Flags &= ^IsTaggedKeyFlags } } } @@ -1390,7 +1417,7 @@ func compileStruct(ctx *compileContext, isPtr bool) (*Opcode, error) { valueCode = code } - if field.Anonymous { + if field.Anonymous && !tag.IsTaggedKey { tagKey := "" if tag.IsTaggedKey { tagKey = tag.Key @@ -1398,50 +1425,76 @@ func compileStruct(ctx *compileContext, isPtr bool) (*Opcode, error) { for k, v := range anonymousStructFieldPairMap(tags, tagKey, valueCode) { anonymousFields[k] = append(anonymousFields[k], v...) } + valueCode.decIndent() // fix issue144 if !(isPtr && strings.Contains(valueCode.Op.String(), "Marshal")) { - valueCode.Indirect = indirect + if indirect { + valueCode.Flags |= IndirectFlags + } else { + valueCode.Flags &= ^IndirectFlags + } } } else { if indirect { // if parent is indirect type, set child indirect property to true - valueCode.Indirect = indirect + valueCode.Flags |= IndirectFlags } else { - // if parent is not indirect type and child have only one field, set child indirect property to false - if i == 0 && valueCode.NextField != nil && valueCode.NextField.Op == OpStructEnd { - valueCode.Indirect = indirect + // if parent is not indirect type, set child indirect property to false. + // but if parent's indirect is false and isPtr is true, then indirect must be true. + // Do this only if indirectConversion is enabled at the end of compileStruct. + if i == 0 { + valueCode.Flags &= ^IndirectFlags } } } - key := fmt.Sprintf(`"%s":`, tag.Key) - escapedKey := fmt.Sprintf(`%s:`, string(AppendEscapedString([]byte{}, tag.Key))) + var flags OpFlags + if indirect { + flags |= IndirectFlags + } + if field.Anonymous { + flags |= AnonymousKeyFlags + } + if tag.IsTaggedKey { + flags |= IsTaggedKeyFlags + } + if nilcheck { + flags |= NilCheckFlags + } + if addrForMarshaler { + flags |= AddrForMarshalerFlags + } + if strings.Contains(valueCode.Op.String(), "Ptr") || valueCode.Op == OpInterface { + flags |= IsNextOpPtrTypeFlags + } + if isNilableType { + flags |= IsNilableTypeFlags + } + var key string + if ctx.escapeKey { + rctx := &RuntimeContext{Option: &Option{Flag: HTMLEscapeOption}} + key = fmt.Sprintf(`%s:`, string(AppendString(rctx, []byte{}, tag.Key))) + } else { + key = fmt.Sprintf(`"%s":`, tag.Key) + } fieldCode := &Opcode{ - Type: valueCode.Type, - DisplayIdx: fieldOpcodeIndex, - Idx: opcodeOffset(fieldPtrIndex), - Next: valueCode, - Indent: ctx.indent, - AnonymousKey: field.Anonymous, - Key: []byte(key), - EscapedKey: []byte(escapedKey), - IsTaggedKey: tag.IsTaggedKey, - DisplayKey: tag.Key, - Offset: field.Offset, - Indirect: indirect, - Nilcheck: nilcheck, - AddrForMarshaler: addrForMarshaler, - IsNextOpPtrType: strings.Contains(valueCode.Op.String(), "Ptr") || valueCode.Op == OpInterface, - IsNilableType: isNilableType, + Idx: opcodeOffset(fieldPtrIndex), + Next: valueCode, + Flags: flags, + Key: key, + Offset: uint32(field.Offset), + Type: valueCode.Type, + DisplayIdx: fieldOpcodeIndex, + Indent: ctx.indent, + DisplayKey: tag.Key, } if fieldIdx == 0 { - fieldCode.HeadIdx = fieldCode.Idx code = structHeader(ctx, fieldCode, valueCode, tag) head = fieldCode prevField = fieldCode } else { - fieldCode.HeadIdx = head.HeadIdx + fieldCode.Idx = head.Idx code.Next = fieldCode code = structField(ctx, fieldCode, valueCode, tag) prevField.NextField = fieldCode @@ -1455,7 +1508,6 @@ func compileStruct(ctx *compileContext, isPtr bool) (*Opcode, error) { Op: OpStructEnd, Type: nil, Indent: ctx.indent, - Next: newEndOp(ctx), } ctx = ctx.decIndent() @@ -1464,12 +1516,11 @@ func compileStruct(ctx *compileContext, isPtr bool) (*Opcode, error) { if head == nil { head = &Opcode{ Op: OpStructHead, + Idx: opcodeOffset(ctx.ptrIndex), + NextField: structEndCode, Type: typ, DisplayIdx: ctx.opcodeIndex, - Idx: opcodeOffset(ctx.ptrIndex), - HeadIdx: opcodeOffset(ctx.ptrIndex), Indent: ctx.indent, - NextField: structEndCode, } structEndCode.PrevField = head ctx.incIndex() @@ -1479,6 +1530,7 @@ func compileStruct(ctx *compileContext, isPtr bool) (*Opcode, error) { structEndCode.DisplayIdx = ctx.opcodeIndex structEndCode.Idx = opcodeOffset(ctx.ptrIndex) ctx.incIndex() + structEndCode.Next = newEndOp(ctx) if prevField != nil && prevField.NextField == nil { prevField.NextField = structEndCode @@ -1494,15 +1546,23 @@ func compileStruct(ctx *compileContext, isPtr bool) (*Opcode, error) { delete(ctx.structTypeToCompiledCode, typeptr) - if !disableIndirectConversion && !head.Indirect && isPtr { - head.Indirect = true + if !disableIndirectConversion && (head.Flags&IndirectFlags == 0) && isPtr { + headCode := head + for strings.Contains(headCode.Op.String(), "Head") { + headCode.Flags |= IndirectFlags + headCode = headCode.Next + } } return ret, nil } +func implementsMarshalJSONType(typ *runtime.Type) bool { + return typ.Implements(marshalJSONType) || typ.Implements(marshalJSONContextType) +} + func isPtrMarshalJSONType(typ *runtime.Type) bool { - return !typ.Implements(marshalJSONType) && runtime.PtrTo(typ).Implements(marshalJSONType) + return !implementsMarshalJSONType(typ) && implementsMarshalJSONType(runtime.PtrTo(typ)) } func isPtrMarshalTextType(typ *runtime.Type) bool { diff --git a/vendor/github.com/goccy/go-json/internal/encoder/compiler_norace.go b/vendor/github.com/goccy/go-json/internal/encoder/compiler_norace.go index acc2658b5..9d337f12b 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/compiler_norace.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/compiler_norace.go @@ -20,19 +20,36 @@ func CompileToGetCodeSet(typeptr uintptr) (*OpcodeSet, error) { // noescape trick for header.typ ( reflect.*rtype ) copiedType := *(**runtime.Type)(unsafe.Pointer(&typeptr)) - code, err := compileHead(&compileContext{ + noescapeKeyCode, err := compileHead(&compileContext{ typ: copiedType, structTypeToCompiledCode: map[uintptr]*CompiledCode{}, }) if err != nil { return nil, err } - code = copyOpcode(code) - codeLength := code.TotalLength() + escapeKeyCode, err := compileHead(&compileContext{ + typ: copiedType, + structTypeToCompiledCode: map[uintptr]*CompiledCode{}, + escapeKey: true, + }) + if err != nil { + return nil, err + } + noescapeKeyCode = copyOpcode(noescapeKeyCode) + escapeKeyCode = copyOpcode(escapeKeyCode) + setTotalLengthToInterfaceOp(noescapeKeyCode) + setTotalLengthToInterfaceOp(escapeKeyCode) + interfaceNoescapeKeyCode := copyToInterfaceOpcode(noescapeKeyCode) + interfaceEscapeKeyCode := copyToInterfaceOpcode(escapeKeyCode) + codeLength := noescapeKeyCode.TotalLength() codeSet := &OpcodeSet{ - Type: copiedType, - Code: code, - CodeLength: codeLength, + Type: copiedType, + NoescapeKeyCode: noescapeKeyCode, + EscapeKeyCode: escapeKeyCode, + InterfaceNoescapeKeyCode: interfaceNoescapeKeyCode, + InterfaceEscapeKeyCode: interfaceEscapeKeyCode, + CodeLength: codeLength, + EndCode: ToEndCode(interfaceNoescapeKeyCode), } cachedOpcodeSets[index] = codeSet return codeSet, nil diff --git a/vendor/github.com/goccy/go-json/internal/encoder/compiler_race.go b/vendor/github.com/goccy/go-json/internal/encoder/compiler_race.go index 63b7733e0..3a239e9d9 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/compiler_race.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/compiler_race.go @@ -26,19 +26,37 @@ func CompileToGetCodeSet(typeptr uintptr) (*OpcodeSet, error) { // noescape trick for header.typ ( reflect.*rtype ) copiedType := *(**runtime.Type)(unsafe.Pointer(&typeptr)) - code, err := compileHead(&compileContext{ + noescapeKeyCode, err := compileHead(&compileContext{ typ: copiedType, structTypeToCompiledCode: map[uintptr]*CompiledCode{}, }) if err != nil { return nil, err } - code = copyOpcode(code) - codeLength := code.TotalLength() + escapeKeyCode, err := compileHead(&compileContext{ + typ: copiedType, + structTypeToCompiledCode: map[uintptr]*CompiledCode{}, + escapeKey: true, + }) + if err != nil { + return nil, err + } + + noescapeKeyCode = copyOpcode(noescapeKeyCode) + escapeKeyCode = copyOpcode(escapeKeyCode) + setTotalLengthToInterfaceOp(noescapeKeyCode) + setTotalLengthToInterfaceOp(escapeKeyCode) + interfaceNoescapeKeyCode := copyToInterfaceOpcode(noescapeKeyCode) + interfaceEscapeKeyCode := copyToInterfaceOpcode(escapeKeyCode) + codeLength := noescapeKeyCode.TotalLength() codeSet := &OpcodeSet{ - Type: copiedType, - Code: code, - CodeLength: codeLength, + Type: copiedType, + NoescapeKeyCode: noescapeKeyCode, + EscapeKeyCode: escapeKeyCode, + InterfaceNoescapeKeyCode: interfaceNoescapeKeyCode, + InterfaceEscapeKeyCode: interfaceEscapeKeyCode, + CodeLength: codeLength, + EndCode: ToEndCode(interfaceNoescapeKeyCode), } setsMu.Lock() cachedOpcodeSets[index] = codeSet diff --git a/vendor/github.com/goccy/go-json/internal/encoder/context.go b/vendor/github.com/goccy/go-json/internal/encoder/context.go index d7e030eaa..61b890806 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/context.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/context.go @@ -1,6 +1,7 @@ package encoder import ( + "context" "sync" "unsafe" @@ -9,9 +10,10 @@ import ( type compileContext struct { typ *runtime.Type - opcodeIndex int + opcodeIndex uint32 ptrIndex int - indent int + indent uint32 + escapeKey bool structTypeToCompiledCode map[uintptr]*CompiledCode parent *compileContext @@ -23,6 +25,7 @@ func (c *compileContext) context() *compileContext { opcodeIndex: c.opcodeIndex, ptrIndex: c.ptrIndex, indent: c.indent, + escapeKey: c.escapeKey, structTypeToCompiledCode: c.structTypeToCompiledCode, parent: c, } @@ -95,20 +98,23 @@ var ( Buf: make([]byte, 0, bufSize), Ptrs: make([]uintptr, 128), KeepRefs: make([]unsafe.Pointer, 0, 8), + Option: &Option{}, } }, } ) type RuntimeContext struct { + Context context.Context Buf []byte MarshalBuf []byte Ptrs []uintptr KeepRefs []unsafe.Pointer SeenPtr []uintptr - BaseIndent int + BaseIndent uint32 Prefix []byte IndentStr []byte + Option *Option } func (c *RuntimeContext) Init(p uintptr, codelen int) { diff --git a/vendor/github.com/goccy/go-json/internal/encoder/encoder.go b/vendor/github.com/goccy/go-json/internal/encoder/encoder.go index ef6b910ad..b7fa99a96 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/encoder.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/encoder.go @@ -17,14 +17,6 @@ import ( "github.com/goccy/go-json/internal/runtime" ) -type Option int - -const ( - HTMLEscapeOption Option = 1 << iota - IndentOption - UnorderedMapOption -) - func (t OpType) IsMultipleOpHead() bool { switch t { case OpStructHead: @@ -102,9 +94,13 @@ func (t OpType) IsMultipleOpField() bool { } type OpcodeSet struct { - Type *runtime.Type - Code *Opcode - CodeLength int + Type *runtime.Type + NoescapeKeyCode *Opcode + EscapeKeyCode *Opcode + InterfaceNoescapeKeyCode *Opcode + InterfaceEscapeKeyCode *Opcode + CodeLength int + EndCode *Opcode } type CompiledCode struct { @@ -276,7 +272,7 @@ func MapIterNext(it unsafe.Pointer) //go:noescape func MapLen(m unsafe.Pointer) int -func AppendByteSlice(b []byte, src []byte) []byte { +func AppendByteSlice(_ *RuntimeContext, b []byte, src []byte) []byte { if src == nil { return append(b, `null`...) } @@ -294,7 +290,7 @@ func AppendByteSlice(b []byte, src []byte) []byte { return append(append(b, buf...), '"') } -func AppendFloat32(b []byte, v float32) []byte { +func AppendFloat32(_ *RuntimeContext, b []byte, v float32) []byte { f64 := float64(v) abs := math.Abs(f64) fmt := byte('f') @@ -308,7 +304,7 @@ func AppendFloat32(b []byte, v float32) []byte { return strconv.AppendFloat(b, f64, fmt, -1, 32) } -func AppendFloat64(b []byte, v float64) []byte { +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. @@ -320,7 +316,7 @@ func AppendFloat64(b []byte, v float64) []byte { return strconv.AppendFloat(b, v, fmt, -1, 64) } -func AppendBool(b []byte, v bool) []byte { +func AppendBool(_ *RuntimeContext, b []byte, v bool) []byte { if v { return append(b, "true"...) } @@ -347,7 +343,7 @@ var ( } ) -func AppendNumber(b []byte, n json.Number) ([]byte, error) { +func AppendNumber(_ *RuntimeContext, b []byte, n json.Number) ([]byte, error) { if len(n) == 0 { return append(b, '0'), nil } @@ -360,9 +356,9 @@ func AppendNumber(b []byte, n json.Number) ([]byte, error) { return b, nil } -func AppendMarshalJSON(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}, escape bool) ([]byte, error) { +func AppendMarshalJSON(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) { rv := reflect.ValueOf(v) // convert by dynamic interface type - if code.AddrForMarshaler { + if (code.Flags & AddrForMarshalerFlags) != 0 { if rv.CanAddr() { rv = rv.Addr() } else { @@ -372,17 +368,31 @@ func AppendMarshalJSON(ctx *RuntimeContext, code *Opcode, b []byte, v interface{ } } v = rv.Interface() - marshaler, ok := v.(json.Marshaler) - if !ok { - return AppendNull(b), nil - } - bb, err := marshaler.MarshalJSON() - if err != nil { - return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err} + 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, escape) + compactedBuf, err := compact(b, marshalBuf, (ctx.Option.Flag&HTMLEscapeOption) != 0) if err != nil { return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err} } @@ -390,9 +400,9 @@ func AppendMarshalJSON(ctx *RuntimeContext, code *Opcode, b []byte, v interface{ return compactedBuf, nil } -func AppendMarshalJSONIndent(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}, escape bool) ([]byte, error) { +func AppendMarshalJSONIndent(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) { rv := reflect.ValueOf(v) // convert by dynamic interface type - if code.AddrForMarshaler { + if (code.Flags & AddrForMarshalerFlags) != 0 { if rv.CanAddr() { rv = rv.Addr() } else { @@ -402,22 +412,36 @@ func AppendMarshalJSONIndent(ctx *RuntimeContext, code *Opcode, b []byte, v inte } } v = rv.Interface() - marshaler, ok := v.(json.Marshaler) - if !ok { - return AppendNull(b), nil - } - bb, err := marshaler.MarshalJSON() - if err != nil { - return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err} + 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), ctx.BaseIndent+code.Indent), + string(ctx.Prefix)+strings.Repeat(string(ctx.IndentStr), int(ctx.BaseIndent+code.Indent)), string(ctx.IndentStr), - escape, + (ctx.Option.Flag&HTMLEscapeOption) != 0, ) if err != nil { return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err} @@ -426,9 +450,9 @@ func AppendMarshalJSONIndent(ctx *RuntimeContext, code *Opcode, b []byte, v inte return indentedBuf, nil } -func AppendMarshalText(code *Opcode, b []byte, v interface{}, escape bool) ([]byte, error) { +func AppendMarshalText(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) { rv := reflect.ValueOf(v) // convert by dynamic interface type - if code.AddrForMarshaler { + if (code.Flags & AddrForMarshalerFlags) != 0 { if rv.CanAddr() { rv = rv.Addr() } else { @@ -440,21 +464,18 @@ func AppendMarshalText(code *Opcode, b []byte, v interface{}, escape bool) ([]by v = rv.Interface() marshaler, ok := v.(encoding.TextMarshaler) if !ok { - return AppendNull(b), nil + return AppendNull(ctx, b), nil } bytes, err := marshaler.MarshalText() if err != nil { return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err} } - if escape { - return AppendEscapedString(b, *(*string)(unsafe.Pointer(&bytes))), nil - } - return AppendString(b, *(*string)(unsafe.Pointer(&bytes))), nil + return AppendString(ctx, b, *(*string)(unsafe.Pointer(&bytes))), nil } -func AppendMarshalTextIndent(code *Opcode, b []byte, v interface{}, escape bool) ([]byte, error) { +func AppendMarshalTextIndent(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) { rv := reflect.ValueOf(v) // convert by dynamic interface type - if code.AddrForMarshaler { + if (code.Flags & AddrForMarshalerFlags) != 0 { if rv.CanAddr() { rv = rv.Addr() } else { @@ -466,31 +487,28 @@ func AppendMarshalTextIndent(code *Opcode, b []byte, v interface{}, escape bool) v = rv.Interface() marshaler, ok := v.(encoding.TextMarshaler) if !ok { - return AppendNull(b), nil + return AppendNull(ctx, b), nil } bytes, err := marshaler.MarshalText() if err != nil { return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err} } - if escape { - return AppendEscapedString(b, *(*string)(unsafe.Pointer(&bytes))), nil - } - return AppendString(b, *(*string)(unsafe.Pointer(&bytes))), nil + return AppendString(ctx, b, *(*string)(unsafe.Pointer(&bytes))), nil } -func AppendNull(b []byte) []byte { +func AppendNull(_ *RuntimeContext, b []byte) []byte { return append(b, "null"...) } -func AppendComma(b []byte) []byte { +func AppendComma(_ *RuntimeContext, b []byte) []byte { return append(b, ',') } -func AppendCommaIndent(b []byte) []byte { +func AppendCommaIndent(_ *RuntimeContext, b []byte) []byte { return append(b, ',', '\n') } -func AppendStructEnd(b []byte) []byte { +func AppendStructEnd(_ *RuntimeContext, b []byte) []byte { return append(b, '}', ',') } @@ -498,16 +516,16 @@ 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 := 0; i < indentNum; i++ { + for i := uint32(0); i < indentNum; i++ { b = append(b, ctx.IndentStr...) } return append(b, '}', ',', '\n') } -func AppendIndent(ctx *RuntimeContext, b []byte, indent int) []byte { +func AppendIndent(ctx *RuntimeContext, b []byte, indent uint32) []byte { b = append(b, ctx.Prefix...) indentNum := ctx.BaseIndent + indent - for i := 0; i < indentNum; i++ { + for i := uint32(0); i < indentNum; i++ { b = append(b, ctx.IndentStr...) } return b diff --git a/vendor/github.com/goccy/go-json/internal/encoder/int.go b/vendor/github.com/goccy/go-json/internal/encoder/int.go index 70ea5f7d7..3a3482d5b 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/int.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/int.go @@ -49,9 +49,14 @@ var intBELookup = [100]uint16{ var intLookup = [2]*[100]uint16{&intLELookup, &intBELookup} -func AppendInt(out []byte, u64 uint64, code *Opcode) []byte { - n := u64 & code.Mask - negative := (u64>>code.RshiftNum)&1 == 1 +func numMask(numBitSize uint8) uint64 { + return 1<<numBitSize - 1 +} + +func AppendInt(_ *RuntimeContext, out []byte, u64 uint64, code *Opcode) []byte { + mask := numMask(code.NumBitSize) + n := u64 & mask + negative := (u64>>(code.NumBitSize-1))&1 == 1 if !negative { if n < 10 { return append(out, byte(n+'0')) @@ -60,7 +65,7 @@ func AppendInt(out []byte, u64 uint64, code *Opcode) []byte { return append(out, byte(u), byte(u>>8)) } } else { - n = -n & code.Mask + n = -n & mask } lookup := intLookup[endianness] @@ -91,8 +96,9 @@ func AppendInt(out []byte, u64 uint64, code *Opcode) []byte { return append(out, b[i:]...) } -func AppendUint(out []byte, u64 uint64, code *Opcode) []byte { - n := u64 & code.Mask +func AppendUint(_ *RuntimeContext, out []byte, u64 uint64, code *Opcode) []byte { + mask := numMask(code.NumBitSize) + n := u64 & mask if n < 10 { return append(out, byte(n+'0')) } else if n < 100 { diff --git a/vendor/github.com/goccy/go-json/internal/encoder/opcode.go b/vendor/github.com/goccy/go-json/internal/encoder/opcode.go index 0dfd6fb95..7c50eefae 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/opcode.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/opcode.go @@ -2,7 +2,6 @@ package encoder import ( "fmt" - "math" "strings" "unsafe" @@ -11,61 +10,61 @@ import ( const uintptrSize = 4 << (^uintptr(0) >> 63) +type OpFlags uint16 + +const ( + AnonymousHeadFlags OpFlags = 1 << 0 + AnonymousKeyFlags OpFlags = 1 << 1 + IndirectFlags OpFlags = 1 << 2 + IsTaggedKeyFlags OpFlags = 1 << 3 + NilCheckFlags OpFlags = 1 << 4 + AddrForMarshalerFlags OpFlags = 1 << 5 + IsNextOpPtrTypeFlags OpFlags = 1 << 6 + IsNilableTypeFlags OpFlags = 1 << 7 + MarshalerContextFlags OpFlags = 1 << 8 + NonEmptyInterfaceFlags OpFlags = 1 << 9 +) + type Opcode struct { - Op OpType // operation type - Type *runtime.Type // go type - DisplayIdx int // opcode index - Key []byte // struct field key - EscapedKey []byte // struct field key ( HTML escaped ) - PtrNum int // pointer number: e.g. double pointer is 2. - DisplayKey string // key text to display - IsTaggedKey bool // whether tagged key - AnonymousKey bool // whether anonymous key - AnonymousHead bool // whether anonymous head or not - Indirect bool // whether indirect or not - Nilcheck bool // whether needs to nilcheck or not - AddrForMarshaler bool // whether needs to addr for marshaler or not - IsNextOpPtrType bool // whether next operation is ptr type or not - IsNilableType bool // whether type is nilable or not - RshiftNum uint8 // use to take bit for judging whether negative integer or not - Mask uint64 // mask for number - Indent int // indent number - - Idx uintptr // offset to access ptr - HeadIdx uintptr // offset to access slice/struct head - ElemIdx uintptr // offset to access array/slice/map elem - Length uintptr // offset to access slice/map length or array length - MapIter uintptr // offset to access map iterator - MapPos uintptr // offset to access position list for sorted map - Offset uintptr // offset size from struct header - Size uintptr // array/slice elem size - - MapKey *Opcode // map key - MapValue *Opcode // map value - Elem *Opcode // array/slice elem - End *Opcode // array/slice/struct/map end - PrevField *Opcode // prev struct field - NextField *Opcode // next struct field - Next *Opcode // next opcode - Jmp *CompiledCode // for recursive call -} - -func rshitNum(bitSize uint8) uint8 { - return bitSize - 1 -} - -func (c *Opcode) setMaskAndRshiftNum(bitSize uint8) { - switch bitSize { - case 8: - c.Mask = math.MaxUint8 - case 16: - c.Mask = math.MaxUint16 - case 32: - c.Mask = math.MaxUint32 - case 64: - c.Mask = math.MaxUint64 + Op OpType // operation type + Idx uint32 // offset to access ptr + Next *Opcode // next opcode + End *Opcode // array/slice/struct/map end + NextField *Opcode // next struct field + Key string // struct field key + Offset uint32 // offset size from struct header + PtrNum uint8 // pointer number: e.g. double pointer is 2. + NumBitSize uint8 + Flags OpFlags + + Type *runtime.Type // go type + PrevField *Opcode // prev struct field + Jmp *CompiledCode // for recursive call + ElemIdx uint32 // offset to access array/slice/map elem + Length uint32 // offset to access slice/map length or array length + MapIter uint32 // offset to access map iterator + MapPos uint32 // offset to access position list for sorted map + Indent uint32 // indent number + Size uint32 // array/slice elem size + DisplayIdx uint32 // opcode index + DisplayKey string // key text to display +} + +func (c *Opcode) MaxIdx() uint32 { + max := uint32(0) + for _, value := range []uint32{ + c.Idx, + c.ElemIdx, + c.Length, + c.MapIter, + c.MapPos, + c.Size, + } { + if max < value { + max = value + } } - c.RshiftNum = rshitNum(bitSize) + return max } func (c *Opcode) ToHeaderType(isString bool) OpType { @@ -278,8 +277,8 @@ func newOpCode(ctx *compileContext, op OpType) *Opcode { return newOpCodeWithNext(ctx, op, newEndOp(ctx)) } -func opcodeOffset(idx int) uintptr { - return uintptr(idx) * uintptrSize +func opcodeOffset(idx int) uint32 { + return uint32(idx) * uintptrSize } func copyOpcode(code *Opcode) *Opcode { @@ -287,14 +286,53 @@ func copyOpcode(code *Opcode) *Opcode { return code.copy(codeMap) } +func setTotalLengthToInterfaceOp(code *Opcode) { + c := code + for c.Op != OpEnd && c.Op != OpInterfaceEnd { + if c.Op == OpInterface { + c.Length = uint32(code.TotalLength()) + } + switch c.Op.CodeType() { + case CodeArrayElem, CodeSliceElem, CodeMapKey: + c = c.End + default: + c = c.Next + } + } +} + +func ToEndCode(code *Opcode) *Opcode { + c := code + for c.Op != OpEnd && c.Op != OpInterfaceEnd { + switch c.Op.CodeType() { + case CodeArrayElem, CodeSliceElem, CodeMapKey: + c = c.End + default: + c = c.Next + } + } + return c +} + +func copyToInterfaceOpcode(code *Opcode) *Opcode { + copied := copyOpcode(code) + c := copied + c = ToEndCode(c) + c.Idx += uintptrSize + c.ElemIdx = c.Idx + uintptrSize + c.Length = c.Idx + 2*uintptrSize + c.Op = OpInterfaceEnd + return copied +} + func newOpCodeWithNext(ctx *compileContext, op OpType, next *Opcode) *Opcode { return &Opcode{ Op: op, + Idx: opcodeOffset(ctx.ptrIndex), + Next: next, Type: ctx.typ, DisplayIdx: ctx.opcodeIndex, Indent: ctx.indent, - Idx: opcodeOffset(ctx.ptrIndex), - Next: next, } } @@ -311,37 +349,24 @@ func (c *Opcode) copy(codeMap map[uintptr]*Opcode) *Opcode { return code } copied := &Opcode{ - Op: c.Op, - Type: c.Type, - DisplayIdx: c.DisplayIdx, - Key: c.Key, - EscapedKey: c.EscapedKey, - DisplayKey: c.DisplayKey, - PtrNum: c.PtrNum, - Mask: c.Mask, - RshiftNum: c.RshiftNum, - IsTaggedKey: c.IsTaggedKey, - AnonymousKey: c.AnonymousKey, - AnonymousHead: c.AnonymousHead, - Indirect: c.Indirect, - Nilcheck: c.Nilcheck, - AddrForMarshaler: c.AddrForMarshaler, - IsNextOpPtrType: c.IsNextOpPtrType, - IsNilableType: c.IsNilableType, - Indent: c.Indent, - Idx: c.Idx, - HeadIdx: c.HeadIdx, - ElemIdx: c.ElemIdx, - Length: c.Length, - MapIter: c.MapIter, - MapPos: c.MapPos, - Offset: c.Offset, - Size: c.Size, + Op: c.Op, + Key: c.Key, + PtrNum: c.PtrNum, + NumBitSize: c.NumBitSize, + Flags: c.Flags, + Idx: c.Idx, + Offset: c.Offset, + Type: c.Type, + DisplayIdx: c.DisplayIdx, + DisplayKey: c.DisplayKey, + ElemIdx: c.ElemIdx, + Length: c.Length, + MapIter: c.MapIter, + MapPos: c.MapPos, + Size: c.Size, + Indent: c.Indent, } codeMap[addr] = copied - copied.MapKey = c.MapKey.copy(codeMap) - copied.MapValue = c.MapValue.copy(codeMap) - copied.Elem = c.Elem.copy(codeMap) copied.End = c.End.copy(codeMap) copied.PrevField = c.PrevField.copy(codeMap) copied.NextField = c.NextField.copy(codeMap) @@ -369,8 +394,12 @@ func (c *Opcode) BeforeLastCode() *Opcode { func (c *Opcode) TotalLength() int { var idx int - for code := c; code.Op != OpEnd; { - idx = int(code.Idx / uintptrSize) + code := c + for code.Op != OpEnd && code.Op != OpInterfaceEnd { + maxIdx := int(code.MaxIdx() / uintptrSize) + if idx < maxIdx { + idx = maxIdx + } if code.Op == OpRecursiveEnd { break } @@ -381,15 +410,18 @@ func (c *Opcode) TotalLength() int { code = code.Next } } - return idx + 2 // opEnd + 1 + maxIdx := int(code.MaxIdx() / uintptrSize) + if idx < maxIdx { + idx = maxIdx + } + return idx + 1 } func (c *Opcode) decOpcodeIndex() { for code := c; code.Op != OpEnd; { code.DisplayIdx-- - code.Idx -= uintptrSize - if code.HeadIdx > 0 { - code.HeadIdx -= uintptrSize + if code.Idx > 0 { + code.Idx -= uintptrSize } if code.ElemIdx > 0 { code.ElemIdx -= uintptrSize @@ -422,19 +454,18 @@ func (c *Opcode) decIndent() { } func (c *Opcode) dumpHead(code *Opcode) string { - var length uintptr + var length uint32 if code.Op.CodeType() == CodeArrayHead { length = code.Length } else { length = code.Length / uintptrSize } return fmt.Sprintf( - `[%d]%s%s ([idx:%d][headIdx:%d][elemIdx:%d][length:%d])`, + `[%d]%s%s ([idx:%d][elemIdx:%d][length:%d])`, code.DisplayIdx, - strings.Repeat("-", code.Indent), + strings.Repeat("-", int(code.Indent)), code.Op, code.Idx/uintptrSize, - code.HeadIdx/uintptrSize, code.ElemIdx/uintptrSize, length, ) @@ -442,12 +473,11 @@ func (c *Opcode) dumpHead(code *Opcode) string { func (c *Opcode) dumpMapHead(code *Opcode) string { return fmt.Sprintf( - `[%d]%s%s ([idx:%d][headIdx:%d][elemIdx:%d][length:%d][mapIter:%d])`, + `[%d]%s%s ([idx:%d][elemIdx:%d][length:%d][mapIter:%d])`, code.DisplayIdx, - strings.Repeat("-", code.Indent), + strings.Repeat("-", int(code.Indent)), code.Op, code.Idx/uintptrSize, - code.HeadIdx/uintptrSize, code.ElemIdx/uintptrSize, code.Length/uintptrSize, code.MapIter/uintptrSize, @@ -458,7 +488,7 @@ func (c *Opcode) dumpMapEnd(code *Opcode) string { return fmt.Sprintf( `[%d]%s%s ([idx:%d][mapPos:%d][length:%d])`, code.DisplayIdx, - strings.Repeat("-", code.Indent), + strings.Repeat("-", int(code.Indent)), code.Op, code.Idx/uintptrSize, code.MapPos/uintptrSize, @@ -467,19 +497,18 @@ func (c *Opcode) dumpMapEnd(code *Opcode) string { } func (c *Opcode) dumpElem(code *Opcode) string { - var length uintptr + var length uint32 if code.Op.CodeType() == CodeArrayElem { length = code.Length } else { length = code.Length / uintptrSize } return fmt.Sprintf( - `[%d]%s%s ([idx:%d][headIdx:%d][elemIdx:%d][length:%d][size:%d])`, + `[%d]%s%s ([idx:%d][elemIdx:%d][length:%d][size:%d])`, code.DisplayIdx, - strings.Repeat("-", code.Indent), + strings.Repeat("-", int(code.Indent)), code.Op, code.Idx/uintptrSize, - code.HeadIdx/uintptrSize, code.ElemIdx/uintptrSize, length, code.Size, @@ -488,14 +517,13 @@ func (c *Opcode) dumpElem(code *Opcode) string { func (c *Opcode) dumpField(code *Opcode) string { return fmt.Sprintf( - `[%d]%s%s ([idx:%d][key:%s][offset:%d][headIdx:%d])`, + `[%d]%s%s ([idx:%d][key:%s][offset:%d])`, code.DisplayIdx, - strings.Repeat("-", code.Indent), + strings.Repeat("-", int(code.Indent)), code.Op, code.Idx/uintptrSize, code.DisplayKey, code.Offset, - code.HeadIdx/uintptrSize, ) } @@ -503,7 +531,7 @@ func (c *Opcode) dumpKey(code *Opcode) string { return fmt.Sprintf( `[%d]%s%s ([idx:%d][elemIdx:%d][length:%d][mapIter:%d])`, code.DisplayIdx, - strings.Repeat("-", code.Indent), + strings.Repeat("-", int(code.Indent)), code.Op, code.Idx/uintptrSize, code.ElemIdx/uintptrSize, @@ -516,7 +544,7 @@ func (c *Opcode) dumpValue(code *Opcode) string { return fmt.Sprintf( `[%d]%s%s ([idx:%d][mapIter:%d])`, code.DisplayIdx, - strings.Repeat("-", code.Indent), + strings.Repeat("-", int(code.Indent)), code.Op, code.Idx/uintptrSize, code.MapIter/uintptrSize, @@ -525,7 +553,7 @@ func (c *Opcode) dumpValue(code *Opcode) string { func (c *Opcode) Dump() string { codes := []string{} - for code := c; code.Op != OpEnd; { + for code := c; code.Op != OpEnd && code.Op != OpInterfaceEnd; { switch code.Op.CodeType() { case CodeSliceHead: codes = append(codes, c.dumpHead(code)) @@ -555,7 +583,7 @@ func (c *Opcode) Dump() string { codes = append(codes, fmt.Sprintf( "[%d]%s%s ([idx:%d])", code.DisplayIdx, - strings.Repeat("-", code.Indent), + strings.Repeat("-", int(code.Indent)), code.Op, code.Idx/uintptrSize, )) @@ -610,9 +638,8 @@ func newSliceHeaderCode(ctx *compileContext) *Opcode { length := opcodeOffset(ctx.ptrIndex) return &Opcode{ Op: OpSlice, - DisplayIdx: ctx.opcodeIndex, Idx: idx, - HeadIdx: idx, + DisplayIdx: ctx.opcodeIndex, ElemIdx: elemIdx, Length: length, Indent: ctx.indent, @@ -622,13 +649,12 @@ func newSliceHeaderCode(ctx *compileContext) *Opcode { func newSliceElemCode(ctx *compileContext, head *Opcode, size uintptr) *Opcode { return &Opcode{ Op: OpSliceElem, + Idx: head.Idx, DisplayIdx: ctx.opcodeIndex, - Idx: opcodeOffset(ctx.ptrIndex), - HeadIdx: head.Idx, ElemIdx: head.ElemIdx, Length: head.Length, Indent: ctx.indent, - Size: size, + Size: uint32(size), } } @@ -638,25 +664,23 @@ func newArrayHeaderCode(ctx *compileContext, alen int) *Opcode { elemIdx := opcodeOffset(ctx.ptrIndex) return &Opcode{ Op: OpArray, - DisplayIdx: ctx.opcodeIndex, Idx: idx, - HeadIdx: idx, + DisplayIdx: ctx.opcodeIndex, ElemIdx: elemIdx, Indent: ctx.indent, - Length: uintptr(alen), + Length: uint32(alen), } } func newArrayElemCode(ctx *compileContext, head *Opcode, length int, size uintptr) *Opcode { return &Opcode{ Op: OpArrayElem, + Idx: head.Idx, DisplayIdx: ctx.opcodeIndex, - Idx: opcodeOffset(ctx.ptrIndex), ElemIdx: head.ElemIdx, - HeadIdx: head.HeadIdx, - Length: uintptr(length), + Length: uint32(length), Indent: ctx.indent, - Size: size, + Size: uint32(size), } } @@ -670,9 +694,9 @@ func newMapHeaderCode(ctx *compileContext) *Opcode { mapIter := opcodeOffset(ctx.ptrIndex) return &Opcode{ Op: OpMap, + Idx: idx, Type: ctx.typ, DisplayIdx: ctx.opcodeIndex, - Idx: idx, ElemIdx: elemIdx, Length: length, MapIter: mapIter, @@ -683,8 +707,8 @@ func newMapHeaderCode(ctx *compileContext) *Opcode { func newMapKeyCode(ctx *compileContext, head *Opcode) *Opcode { return &Opcode{ Op: OpMapKey, - DisplayIdx: ctx.opcodeIndex, Idx: opcodeOffset(ctx.ptrIndex), + DisplayIdx: ctx.opcodeIndex, ElemIdx: head.ElemIdx, Length: head.Length, MapIter: head.MapIter, @@ -695,8 +719,8 @@ func newMapKeyCode(ctx *compileContext, head *Opcode) *Opcode { func newMapValueCode(ctx *compileContext, head *Opcode) *Opcode { return &Opcode{ Op: OpMapValue, - DisplayIdx: ctx.opcodeIndex, Idx: opcodeOffset(ctx.ptrIndex), + DisplayIdx: ctx.opcodeIndex, ElemIdx: head.ElemIdx, Length: head.Length, MapIter: head.MapIter, @@ -710,34 +734,39 @@ func newMapEndCode(ctx *compileContext, head *Opcode) *Opcode { idx := opcodeOffset(ctx.ptrIndex) return &Opcode{ Op: OpMapEnd, - DisplayIdx: ctx.opcodeIndex, Idx: idx, + Next: newEndOp(ctx), + DisplayIdx: ctx.opcodeIndex, Length: head.Length, MapPos: mapPos, Indent: ctx.indent, - Next: newEndOp(ctx), } } func newInterfaceCode(ctx *compileContext) *Opcode { + var flag OpFlags + if ctx.typ.NumMethod() > 0 { + flag |= NonEmptyInterfaceFlags + } return &Opcode{ Op: OpInterface, + Idx: opcodeOffset(ctx.ptrIndex), + Next: newEndOp(ctx), Type: ctx.typ, DisplayIdx: ctx.opcodeIndex, - Idx: opcodeOffset(ctx.ptrIndex), Indent: ctx.indent, - Next: newEndOp(ctx), + Flags: flag, } } func newRecursiveCode(ctx *compileContext, jmp *CompiledCode) *Opcode { return &Opcode{ Op: OpRecursive, + Idx: opcodeOffset(ctx.ptrIndex), + Next: newEndOp(ctx), Type: ctx.typ, DisplayIdx: ctx.opcodeIndex, - Idx: opcodeOffset(ctx.ptrIndex), Indent: ctx.indent, - Next: newEndOp(ctx), Jmp: jmp, } } diff --git a/vendor/github.com/goccy/go-json/internal/encoder/option.go b/vendor/github.com/goccy/go-json/internal/encoder/option.go new file mode 100644 index 000000000..f5f1f044e --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/option.go @@ -0,0 +1,41 @@ +package encoder + +import "context" + +type OptionFlag uint8 + +const ( + HTMLEscapeOption OptionFlag = 1 << iota + IndentOption + UnorderedMapOption + DebugOption + ColorizeOption + ContextOption +) + +type Option struct { + Flag OptionFlag + ColorScheme *ColorScheme + Context context.Context +} + +type EncodeFormat struct { + Header string + Footer string +} + +type EncodeFormatScheme struct { + Int EncodeFormat + Uint EncodeFormat + Float EncodeFormat + Bool EncodeFormat + String EncodeFormat + Binary EncodeFormat + ObjectKey EncodeFormat + Null EncodeFormat +} + +type ( + ColorScheme = EncodeFormatScheme + ColorFormat = EncodeFormat +) diff --git a/vendor/github.com/goccy/go-json/internal/encoder/optype.go b/vendor/github.com/goccy/go-json/internal/encoder/optype.go index 21ac3457c..335fc043e 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/optype.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/optype.go @@ -22,7 +22,7 @@ const ( CodeStructEnd CodeType = 11 ) -var opTypeStrings = [400]string{ +var opTypeStrings = [401]string{ "End", "Interface", "Ptr", @@ -36,6 +36,7 @@ var opTypeStrings = [400]string{ "Recursive", "RecursivePtr", "RecursiveEnd", + "InterfaceEnd", "StructAnonymousEnd", "Int", "Uint", @@ -425,7 +426,7 @@ var opTypeStrings = [400]string{ "StructEndOmitEmpty", } -type OpType int +type OpType uint16 const ( OpEnd OpType = 0 @@ -441,397 +442,398 @@ const ( OpRecursive OpType = 10 OpRecursivePtr OpType = 11 OpRecursiveEnd OpType = 12 - OpStructAnonymousEnd OpType = 13 - OpInt OpType = 14 - OpUint OpType = 15 - OpFloat32 OpType = 16 - OpFloat64 OpType = 17 - OpBool OpType = 18 - OpString OpType = 19 - OpBytes OpType = 20 - OpNumber OpType = 21 - OpArray OpType = 22 - OpMap OpType = 23 - OpSlice OpType = 24 - OpStruct OpType = 25 - OpMarshalJSON OpType = 26 - OpMarshalText OpType = 27 - OpIntString OpType = 28 - OpUintString OpType = 29 - OpFloat32String OpType = 30 - OpFloat64String OpType = 31 - OpBoolString OpType = 32 - OpStringString OpType = 33 - OpNumberString OpType = 34 - OpIntPtr OpType = 35 - OpUintPtr OpType = 36 - OpFloat32Ptr OpType = 37 - OpFloat64Ptr OpType = 38 - OpBoolPtr OpType = 39 - OpStringPtr OpType = 40 - OpBytesPtr OpType = 41 - OpNumberPtr OpType = 42 - OpArrayPtr OpType = 43 - OpMapPtr OpType = 44 - OpSlicePtr OpType = 45 - OpMarshalJSONPtr OpType = 46 - OpMarshalTextPtr OpType = 47 - OpInterfacePtr OpType = 48 - OpIntPtrString OpType = 49 - OpUintPtrString OpType = 50 - OpFloat32PtrString OpType = 51 - OpFloat64PtrString OpType = 52 - OpBoolPtrString OpType = 53 - OpStringPtrString OpType = 54 - OpNumberPtrString OpType = 55 - OpStructHeadInt OpType = 56 - OpStructHeadOmitEmptyInt OpType = 57 - OpStructPtrHeadInt OpType = 58 - OpStructPtrHeadOmitEmptyInt OpType = 59 - OpStructHeadUint OpType = 60 - OpStructHeadOmitEmptyUint OpType = 61 - OpStructPtrHeadUint OpType = 62 - OpStructPtrHeadOmitEmptyUint OpType = 63 - OpStructHeadFloat32 OpType = 64 - OpStructHeadOmitEmptyFloat32 OpType = 65 - OpStructPtrHeadFloat32 OpType = 66 - OpStructPtrHeadOmitEmptyFloat32 OpType = 67 - OpStructHeadFloat64 OpType = 68 - OpStructHeadOmitEmptyFloat64 OpType = 69 - OpStructPtrHeadFloat64 OpType = 70 - OpStructPtrHeadOmitEmptyFloat64 OpType = 71 - OpStructHeadBool OpType = 72 - OpStructHeadOmitEmptyBool OpType = 73 - OpStructPtrHeadBool OpType = 74 - OpStructPtrHeadOmitEmptyBool OpType = 75 - OpStructHeadString OpType = 76 - OpStructHeadOmitEmptyString OpType = 77 - OpStructPtrHeadString OpType = 78 - OpStructPtrHeadOmitEmptyString OpType = 79 - OpStructHeadBytes OpType = 80 - OpStructHeadOmitEmptyBytes OpType = 81 - OpStructPtrHeadBytes OpType = 82 - OpStructPtrHeadOmitEmptyBytes OpType = 83 - OpStructHeadNumber OpType = 84 - OpStructHeadOmitEmptyNumber OpType = 85 - OpStructPtrHeadNumber OpType = 86 - OpStructPtrHeadOmitEmptyNumber OpType = 87 - OpStructHeadArray OpType = 88 - OpStructHeadOmitEmptyArray OpType = 89 - OpStructPtrHeadArray OpType = 90 - OpStructPtrHeadOmitEmptyArray OpType = 91 - OpStructHeadMap OpType = 92 - OpStructHeadOmitEmptyMap OpType = 93 - OpStructPtrHeadMap OpType = 94 - OpStructPtrHeadOmitEmptyMap OpType = 95 - OpStructHeadSlice OpType = 96 - OpStructHeadOmitEmptySlice OpType = 97 - OpStructPtrHeadSlice OpType = 98 - OpStructPtrHeadOmitEmptySlice OpType = 99 - OpStructHeadStruct OpType = 100 - OpStructHeadOmitEmptyStruct OpType = 101 - OpStructPtrHeadStruct OpType = 102 - OpStructPtrHeadOmitEmptyStruct OpType = 103 - OpStructHeadMarshalJSON OpType = 104 - OpStructHeadOmitEmptyMarshalJSON OpType = 105 - OpStructPtrHeadMarshalJSON OpType = 106 - OpStructPtrHeadOmitEmptyMarshalJSON OpType = 107 - OpStructHeadMarshalText OpType = 108 - OpStructHeadOmitEmptyMarshalText OpType = 109 - OpStructPtrHeadMarshalText OpType = 110 - OpStructPtrHeadOmitEmptyMarshalText OpType = 111 - OpStructHeadIntString OpType = 112 - OpStructHeadOmitEmptyIntString OpType = 113 - OpStructPtrHeadIntString OpType = 114 - OpStructPtrHeadOmitEmptyIntString OpType = 115 - OpStructHeadUintString OpType = 116 - OpStructHeadOmitEmptyUintString OpType = 117 - OpStructPtrHeadUintString OpType = 118 - OpStructPtrHeadOmitEmptyUintString OpType = 119 - OpStructHeadFloat32String OpType = 120 - OpStructHeadOmitEmptyFloat32String OpType = 121 - OpStructPtrHeadFloat32String OpType = 122 - OpStructPtrHeadOmitEmptyFloat32String OpType = 123 - OpStructHeadFloat64String OpType = 124 - OpStructHeadOmitEmptyFloat64String OpType = 125 - OpStructPtrHeadFloat64String OpType = 126 - OpStructPtrHeadOmitEmptyFloat64String OpType = 127 - OpStructHeadBoolString OpType = 128 - OpStructHeadOmitEmptyBoolString OpType = 129 - OpStructPtrHeadBoolString OpType = 130 - OpStructPtrHeadOmitEmptyBoolString OpType = 131 - OpStructHeadStringString OpType = 132 - OpStructHeadOmitEmptyStringString OpType = 133 - OpStructPtrHeadStringString OpType = 134 - OpStructPtrHeadOmitEmptyStringString OpType = 135 - OpStructHeadNumberString OpType = 136 - OpStructHeadOmitEmptyNumberString OpType = 137 - OpStructPtrHeadNumberString OpType = 138 - OpStructPtrHeadOmitEmptyNumberString OpType = 139 - OpStructHeadIntPtr OpType = 140 - OpStructHeadOmitEmptyIntPtr OpType = 141 - OpStructPtrHeadIntPtr OpType = 142 - OpStructPtrHeadOmitEmptyIntPtr OpType = 143 - OpStructHeadUintPtr OpType = 144 - OpStructHeadOmitEmptyUintPtr OpType = 145 - OpStructPtrHeadUintPtr OpType = 146 - OpStructPtrHeadOmitEmptyUintPtr OpType = 147 - OpStructHeadFloat32Ptr OpType = 148 - OpStructHeadOmitEmptyFloat32Ptr OpType = 149 - OpStructPtrHeadFloat32Ptr OpType = 150 - OpStructPtrHeadOmitEmptyFloat32Ptr OpType = 151 - OpStructHeadFloat64Ptr OpType = 152 - OpStructHeadOmitEmptyFloat64Ptr OpType = 153 - OpStructPtrHeadFloat64Ptr OpType = 154 - OpStructPtrHeadOmitEmptyFloat64Ptr OpType = 155 - OpStructHeadBoolPtr OpType = 156 - OpStructHeadOmitEmptyBoolPtr OpType = 157 - OpStructPtrHeadBoolPtr OpType = 158 - OpStructPtrHeadOmitEmptyBoolPtr OpType = 159 - OpStructHeadStringPtr OpType = 160 - OpStructHeadOmitEmptyStringPtr OpType = 161 - OpStructPtrHeadStringPtr OpType = 162 - OpStructPtrHeadOmitEmptyStringPtr OpType = 163 - OpStructHeadBytesPtr OpType = 164 - OpStructHeadOmitEmptyBytesPtr OpType = 165 - OpStructPtrHeadBytesPtr OpType = 166 - OpStructPtrHeadOmitEmptyBytesPtr OpType = 167 - OpStructHeadNumberPtr OpType = 168 - OpStructHeadOmitEmptyNumberPtr OpType = 169 - OpStructPtrHeadNumberPtr OpType = 170 - OpStructPtrHeadOmitEmptyNumberPtr OpType = 171 - OpStructHeadArrayPtr OpType = 172 - OpStructHeadOmitEmptyArrayPtr OpType = 173 - OpStructPtrHeadArrayPtr OpType = 174 - OpStructPtrHeadOmitEmptyArrayPtr OpType = 175 - OpStructHeadMapPtr OpType = 176 - OpStructHeadOmitEmptyMapPtr OpType = 177 - OpStructPtrHeadMapPtr OpType = 178 - OpStructPtrHeadOmitEmptyMapPtr OpType = 179 - OpStructHeadSlicePtr OpType = 180 - OpStructHeadOmitEmptySlicePtr OpType = 181 - OpStructPtrHeadSlicePtr OpType = 182 - OpStructPtrHeadOmitEmptySlicePtr OpType = 183 - OpStructHeadMarshalJSONPtr OpType = 184 - OpStructHeadOmitEmptyMarshalJSONPtr OpType = 185 - OpStructPtrHeadMarshalJSONPtr OpType = 186 - OpStructPtrHeadOmitEmptyMarshalJSONPtr OpType = 187 - OpStructHeadMarshalTextPtr OpType = 188 - OpStructHeadOmitEmptyMarshalTextPtr OpType = 189 - OpStructPtrHeadMarshalTextPtr OpType = 190 - OpStructPtrHeadOmitEmptyMarshalTextPtr OpType = 191 - OpStructHeadInterfacePtr OpType = 192 - OpStructHeadOmitEmptyInterfacePtr OpType = 193 - OpStructPtrHeadInterfacePtr OpType = 194 - OpStructPtrHeadOmitEmptyInterfacePtr OpType = 195 - OpStructHeadIntPtrString OpType = 196 - OpStructHeadOmitEmptyIntPtrString OpType = 197 - OpStructPtrHeadIntPtrString OpType = 198 - OpStructPtrHeadOmitEmptyIntPtrString OpType = 199 - OpStructHeadUintPtrString OpType = 200 - OpStructHeadOmitEmptyUintPtrString OpType = 201 - OpStructPtrHeadUintPtrString OpType = 202 - OpStructPtrHeadOmitEmptyUintPtrString OpType = 203 - OpStructHeadFloat32PtrString OpType = 204 - OpStructHeadOmitEmptyFloat32PtrString OpType = 205 - OpStructPtrHeadFloat32PtrString OpType = 206 - OpStructPtrHeadOmitEmptyFloat32PtrString OpType = 207 - OpStructHeadFloat64PtrString OpType = 208 - OpStructHeadOmitEmptyFloat64PtrString OpType = 209 - OpStructPtrHeadFloat64PtrString OpType = 210 - OpStructPtrHeadOmitEmptyFloat64PtrString OpType = 211 - OpStructHeadBoolPtrString OpType = 212 - OpStructHeadOmitEmptyBoolPtrString OpType = 213 - OpStructPtrHeadBoolPtrString OpType = 214 - OpStructPtrHeadOmitEmptyBoolPtrString OpType = 215 - OpStructHeadStringPtrString OpType = 216 - OpStructHeadOmitEmptyStringPtrString OpType = 217 - OpStructPtrHeadStringPtrString OpType = 218 - OpStructPtrHeadOmitEmptyStringPtrString OpType = 219 - OpStructHeadNumberPtrString OpType = 220 - OpStructHeadOmitEmptyNumberPtrString OpType = 221 - OpStructPtrHeadNumberPtrString OpType = 222 - OpStructPtrHeadOmitEmptyNumberPtrString OpType = 223 - OpStructHead OpType = 224 - OpStructHeadOmitEmpty OpType = 225 - OpStructPtrHead OpType = 226 - OpStructPtrHeadOmitEmpty OpType = 227 - OpStructFieldInt OpType = 228 - OpStructFieldOmitEmptyInt OpType = 229 - OpStructEndInt OpType = 230 - OpStructEndOmitEmptyInt OpType = 231 - OpStructFieldUint OpType = 232 - OpStructFieldOmitEmptyUint OpType = 233 - OpStructEndUint OpType = 234 - OpStructEndOmitEmptyUint OpType = 235 - OpStructFieldFloat32 OpType = 236 - OpStructFieldOmitEmptyFloat32 OpType = 237 - OpStructEndFloat32 OpType = 238 - OpStructEndOmitEmptyFloat32 OpType = 239 - OpStructFieldFloat64 OpType = 240 - OpStructFieldOmitEmptyFloat64 OpType = 241 - OpStructEndFloat64 OpType = 242 - OpStructEndOmitEmptyFloat64 OpType = 243 - OpStructFieldBool OpType = 244 - OpStructFieldOmitEmptyBool OpType = 245 - OpStructEndBool OpType = 246 - OpStructEndOmitEmptyBool OpType = 247 - OpStructFieldString OpType = 248 - OpStructFieldOmitEmptyString OpType = 249 - OpStructEndString OpType = 250 - OpStructEndOmitEmptyString OpType = 251 - OpStructFieldBytes OpType = 252 - OpStructFieldOmitEmptyBytes OpType = 253 - OpStructEndBytes OpType = 254 - OpStructEndOmitEmptyBytes OpType = 255 - OpStructFieldNumber OpType = 256 - OpStructFieldOmitEmptyNumber OpType = 257 - OpStructEndNumber OpType = 258 - OpStructEndOmitEmptyNumber OpType = 259 - OpStructFieldArray OpType = 260 - OpStructFieldOmitEmptyArray OpType = 261 - OpStructEndArray OpType = 262 - OpStructEndOmitEmptyArray OpType = 263 - OpStructFieldMap OpType = 264 - OpStructFieldOmitEmptyMap OpType = 265 - OpStructEndMap OpType = 266 - OpStructEndOmitEmptyMap OpType = 267 - OpStructFieldSlice OpType = 268 - OpStructFieldOmitEmptySlice OpType = 269 - OpStructEndSlice OpType = 270 - OpStructEndOmitEmptySlice OpType = 271 - OpStructFieldStruct OpType = 272 - OpStructFieldOmitEmptyStruct OpType = 273 - OpStructEndStruct OpType = 274 - OpStructEndOmitEmptyStruct OpType = 275 - OpStructFieldMarshalJSON OpType = 276 - OpStructFieldOmitEmptyMarshalJSON OpType = 277 - OpStructEndMarshalJSON OpType = 278 - OpStructEndOmitEmptyMarshalJSON OpType = 279 - OpStructFieldMarshalText OpType = 280 - OpStructFieldOmitEmptyMarshalText OpType = 281 - OpStructEndMarshalText OpType = 282 - OpStructEndOmitEmptyMarshalText OpType = 283 - OpStructFieldIntString OpType = 284 - OpStructFieldOmitEmptyIntString OpType = 285 - OpStructEndIntString OpType = 286 - OpStructEndOmitEmptyIntString OpType = 287 - OpStructFieldUintString OpType = 288 - OpStructFieldOmitEmptyUintString OpType = 289 - OpStructEndUintString OpType = 290 - OpStructEndOmitEmptyUintString OpType = 291 - OpStructFieldFloat32String OpType = 292 - OpStructFieldOmitEmptyFloat32String OpType = 293 - OpStructEndFloat32String OpType = 294 - OpStructEndOmitEmptyFloat32String OpType = 295 - OpStructFieldFloat64String OpType = 296 - OpStructFieldOmitEmptyFloat64String OpType = 297 - OpStructEndFloat64String OpType = 298 - OpStructEndOmitEmptyFloat64String OpType = 299 - OpStructFieldBoolString OpType = 300 - OpStructFieldOmitEmptyBoolString OpType = 301 - OpStructEndBoolString OpType = 302 - OpStructEndOmitEmptyBoolString OpType = 303 - OpStructFieldStringString OpType = 304 - OpStructFieldOmitEmptyStringString OpType = 305 - OpStructEndStringString OpType = 306 - OpStructEndOmitEmptyStringString OpType = 307 - OpStructFieldNumberString OpType = 308 - OpStructFieldOmitEmptyNumberString OpType = 309 - OpStructEndNumberString OpType = 310 - OpStructEndOmitEmptyNumberString OpType = 311 - OpStructFieldIntPtr OpType = 312 - OpStructFieldOmitEmptyIntPtr OpType = 313 - OpStructEndIntPtr OpType = 314 - OpStructEndOmitEmptyIntPtr OpType = 315 - OpStructFieldUintPtr OpType = 316 - OpStructFieldOmitEmptyUintPtr OpType = 317 - OpStructEndUintPtr OpType = 318 - OpStructEndOmitEmptyUintPtr OpType = 319 - OpStructFieldFloat32Ptr OpType = 320 - OpStructFieldOmitEmptyFloat32Ptr OpType = 321 - OpStructEndFloat32Ptr OpType = 322 - OpStructEndOmitEmptyFloat32Ptr OpType = 323 - OpStructFieldFloat64Ptr OpType = 324 - OpStructFieldOmitEmptyFloat64Ptr OpType = 325 - OpStructEndFloat64Ptr OpType = 326 - OpStructEndOmitEmptyFloat64Ptr OpType = 327 - OpStructFieldBoolPtr OpType = 328 - OpStructFieldOmitEmptyBoolPtr OpType = 329 - OpStructEndBoolPtr OpType = 330 - OpStructEndOmitEmptyBoolPtr OpType = 331 - OpStructFieldStringPtr OpType = 332 - OpStructFieldOmitEmptyStringPtr OpType = 333 - OpStructEndStringPtr OpType = 334 - OpStructEndOmitEmptyStringPtr OpType = 335 - OpStructFieldBytesPtr OpType = 336 - OpStructFieldOmitEmptyBytesPtr OpType = 337 - OpStructEndBytesPtr OpType = 338 - OpStructEndOmitEmptyBytesPtr OpType = 339 - OpStructFieldNumberPtr OpType = 340 - OpStructFieldOmitEmptyNumberPtr OpType = 341 - OpStructEndNumberPtr OpType = 342 - OpStructEndOmitEmptyNumberPtr OpType = 343 - OpStructFieldArrayPtr OpType = 344 - OpStructFieldOmitEmptyArrayPtr OpType = 345 - OpStructEndArrayPtr OpType = 346 - OpStructEndOmitEmptyArrayPtr OpType = 347 - OpStructFieldMapPtr OpType = 348 - OpStructFieldOmitEmptyMapPtr OpType = 349 - OpStructEndMapPtr OpType = 350 - OpStructEndOmitEmptyMapPtr OpType = 351 - OpStructFieldSlicePtr OpType = 352 - OpStructFieldOmitEmptySlicePtr OpType = 353 - OpStructEndSlicePtr OpType = 354 - OpStructEndOmitEmptySlicePtr OpType = 355 - OpStructFieldMarshalJSONPtr OpType = 356 - OpStructFieldOmitEmptyMarshalJSONPtr OpType = 357 - OpStructEndMarshalJSONPtr OpType = 358 - OpStructEndOmitEmptyMarshalJSONPtr OpType = 359 - OpStructFieldMarshalTextPtr OpType = 360 - OpStructFieldOmitEmptyMarshalTextPtr OpType = 361 - OpStructEndMarshalTextPtr OpType = 362 - OpStructEndOmitEmptyMarshalTextPtr OpType = 363 - OpStructFieldInterfacePtr OpType = 364 - OpStructFieldOmitEmptyInterfacePtr OpType = 365 - OpStructEndInterfacePtr OpType = 366 - OpStructEndOmitEmptyInterfacePtr OpType = 367 - OpStructFieldIntPtrString OpType = 368 - OpStructFieldOmitEmptyIntPtrString OpType = 369 - OpStructEndIntPtrString OpType = 370 - OpStructEndOmitEmptyIntPtrString OpType = 371 - OpStructFieldUintPtrString OpType = 372 - OpStructFieldOmitEmptyUintPtrString OpType = 373 - OpStructEndUintPtrString OpType = 374 - OpStructEndOmitEmptyUintPtrString OpType = 375 - OpStructFieldFloat32PtrString OpType = 376 - OpStructFieldOmitEmptyFloat32PtrString OpType = 377 - OpStructEndFloat32PtrString OpType = 378 - OpStructEndOmitEmptyFloat32PtrString OpType = 379 - OpStructFieldFloat64PtrString OpType = 380 - OpStructFieldOmitEmptyFloat64PtrString OpType = 381 - OpStructEndFloat64PtrString OpType = 382 - OpStructEndOmitEmptyFloat64PtrString OpType = 383 - OpStructFieldBoolPtrString OpType = 384 - OpStructFieldOmitEmptyBoolPtrString OpType = 385 - OpStructEndBoolPtrString OpType = 386 - OpStructEndOmitEmptyBoolPtrString OpType = 387 - OpStructFieldStringPtrString OpType = 388 - OpStructFieldOmitEmptyStringPtrString OpType = 389 - OpStructEndStringPtrString OpType = 390 - OpStructEndOmitEmptyStringPtrString OpType = 391 - OpStructFieldNumberPtrString OpType = 392 - OpStructFieldOmitEmptyNumberPtrString OpType = 393 - OpStructEndNumberPtrString OpType = 394 - OpStructEndOmitEmptyNumberPtrString OpType = 395 - OpStructField OpType = 396 - OpStructFieldOmitEmpty OpType = 397 - OpStructEnd OpType = 398 - OpStructEndOmitEmpty OpType = 399 + OpInterfaceEnd OpType = 13 + OpStructAnonymousEnd OpType = 14 + OpInt OpType = 15 + OpUint OpType = 16 + OpFloat32 OpType = 17 + OpFloat64 OpType = 18 + OpBool OpType = 19 + OpString OpType = 20 + OpBytes OpType = 21 + OpNumber OpType = 22 + OpArray OpType = 23 + OpMap OpType = 24 + OpSlice OpType = 25 + OpStruct OpType = 26 + OpMarshalJSON OpType = 27 + OpMarshalText OpType = 28 + OpIntString OpType = 29 + OpUintString OpType = 30 + OpFloat32String OpType = 31 + OpFloat64String OpType = 32 + OpBoolString OpType = 33 + OpStringString OpType = 34 + OpNumberString OpType = 35 + OpIntPtr OpType = 36 + OpUintPtr OpType = 37 + OpFloat32Ptr OpType = 38 + OpFloat64Ptr OpType = 39 + OpBoolPtr OpType = 40 + OpStringPtr OpType = 41 + OpBytesPtr OpType = 42 + OpNumberPtr OpType = 43 + OpArrayPtr OpType = 44 + OpMapPtr OpType = 45 + OpSlicePtr OpType = 46 + OpMarshalJSONPtr OpType = 47 + OpMarshalTextPtr OpType = 48 + OpInterfacePtr OpType = 49 + OpIntPtrString OpType = 50 + OpUintPtrString OpType = 51 + OpFloat32PtrString OpType = 52 + OpFloat64PtrString OpType = 53 + OpBoolPtrString OpType = 54 + OpStringPtrString OpType = 55 + OpNumberPtrString OpType = 56 + OpStructHeadInt OpType = 57 + OpStructHeadOmitEmptyInt OpType = 58 + OpStructPtrHeadInt OpType = 59 + OpStructPtrHeadOmitEmptyInt OpType = 60 + OpStructHeadUint OpType = 61 + OpStructHeadOmitEmptyUint OpType = 62 + OpStructPtrHeadUint OpType = 63 + OpStructPtrHeadOmitEmptyUint OpType = 64 + OpStructHeadFloat32 OpType = 65 + OpStructHeadOmitEmptyFloat32 OpType = 66 + OpStructPtrHeadFloat32 OpType = 67 + OpStructPtrHeadOmitEmptyFloat32 OpType = 68 + OpStructHeadFloat64 OpType = 69 + OpStructHeadOmitEmptyFloat64 OpType = 70 + OpStructPtrHeadFloat64 OpType = 71 + OpStructPtrHeadOmitEmptyFloat64 OpType = 72 + OpStructHeadBool OpType = 73 + OpStructHeadOmitEmptyBool OpType = 74 + OpStructPtrHeadBool OpType = 75 + OpStructPtrHeadOmitEmptyBool OpType = 76 + OpStructHeadString OpType = 77 + OpStructHeadOmitEmptyString OpType = 78 + OpStructPtrHeadString OpType = 79 + OpStructPtrHeadOmitEmptyString OpType = 80 + OpStructHeadBytes OpType = 81 + OpStructHeadOmitEmptyBytes OpType = 82 + OpStructPtrHeadBytes OpType = 83 + OpStructPtrHeadOmitEmptyBytes OpType = 84 + OpStructHeadNumber OpType = 85 + OpStructHeadOmitEmptyNumber OpType = 86 + OpStructPtrHeadNumber OpType = 87 + OpStructPtrHeadOmitEmptyNumber OpType = 88 + OpStructHeadArray OpType = 89 + OpStructHeadOmitEmptyArray OpType = 90 + OpStructPtrHeadArray OpType = 91 + OpStructPtrHeadOmitEmptyArray OpType = 92 + OpStructHeadMap OpType = 93 + OpStructHeadOmitEmptyMap OpType = 94 + OpStructPtrHeadMap OpType = 95 + OpStructPtrHeadOmitEmptyMap OpType = 96 + OpStructHeadSlice OpType = 97 + OpStructHeadOmitEmptySlice OpType = 98 + OpStructPtrHeadSlice OpType = 99 + OpStructPtrHeadOmitEmptySlice OpType = 100 + OpStructHeadStruct OpType = 101 + OpStructHeadOmitEmptyStruct OpType = 102 + OpStructPtrHeadStruct OpType = 103 + OpStructPtrHeadOmitEmptyStruct OpType = 104 + OpStructHeadMarshalJSON OpType = 105 + OpStructHeadOmitEmptyMarshalJSON OpType = 106 + OpStructPtrHeadMarshalJSON OpType = 107 + OpStructPtrHeadOmitEmptyMarshalJSON OpType = 108 + OpStructHeadMarshalText OpType = 109 + OpStructHeadOmitEmptyMarshalText OpType = 110 + OpStructPtrHeadMarshalText OpType = 111 + OpStructPtrHeadOmitEmptyMarshalText OpType = 112 + OpStructHeadIntString OpType = 113 + OpStructHeadOmitEmptyIntString OpType = 114 + OpStructPtrHeadIntString OpType = 115 + OpStructPtrHeadOmitEmptyIntString OpType = 116 + OpStructHeadUintString OpType = 117 + OpStructHeadOmitEmptyUintString OpType = 118 + OpStructPtrHeadUintString OpType = 119 + OpStructPtrHeadOmitEmptyUintString OpType = 120 + OpStructHeadFloat32String OpType = 121 + OpStructHeadOmitEmptyFloat32String OpType = 122 + OpStructPtrHeadFloat32String OpType = 123 + OpStructPtrHeadOmitEmptyFloat32String OpType = 124 + OpStructHeadFloat64String OpType = 125 + OpStructHeadOmitEmptyFloat64String OpType = 126 + OpStructPtrHeadFloat64String OpType = 127 + OpStructPtrHeadOmitEmptyFloat64String OpType = 128 + OpStructHeadBoolString OpType = 129 + OpStructHeadOmitEmptyBoolString OpType = 130 + OpStructPtrHeadBoolString OpType = 131 + OpStructPtrHeadOmitEmptyBoolString OpType = 132 + OpStructHeadStringString OpType = 133 + OpStructHeadOmitEmptyStringString OpType = 134 + OpStructPtrHeadStringString OpType = 135 + OpStructPtrHeadOmitEmptyStringString OpType = 136 + OpStructHeadNumberString OpType = 137 + OpStructHeadOmitEmptyNumberString OpType = 138 + OpStructPtrHeadNumberString OpType = 139 + OpStructPtrHeadOmitEmptyNumberString OpType = 140 + OpStructHeadIntPtr OpType = 141 + OpStructHeadOmitEmptyIntPtr OpType = 142 + OpStructPtrHeadIntPtr OpType = 143 + OpStructPtrHeadOmitEmptyIntPtr OpType = 144 + OpStructHeadUintPtr OpType = 145 + OpStructHeadOmitEmptyUintPtr OpType = 146 + OpStructPtrHeadUintPtr OpType = 147 + OpStructPtrHeadOmitEmptyUintPtr OpType = 148 + OpStructHeadFloat32Ptr OpType = 149 + OpStructHeadOmitEmptyFloat32Ptr OpType = 150 + OpStructPtrHeadFloat32Ptr OpType = 151 + OpStructPtrHeadOmitEmptyFloat32Ptr OpType = 152 + OpStructHeadFloat64Ptr OpType = 153 + OpStructHeadOmitEmptyFloat64Ptr OpType = 154 + OpStructPtrHeadFloat64Ptr OpType = 155 + OpStructPtrHeadOmitEmptyFloat64Ptr OpType = 156 + OpStructHeadBoolPtr OpType = 157 + OpStructHeadOmitEmptyBoolPtr OpType = 158 + OpStructPtrHeadBoolPtr OpType = 159 + OpStructPtrHeadOmitEmptyBoolPtr OpType = 160 + OpStructHeadStringPtr OpType = 161 + OpStructHeadOmitEmptyStringPtr OpType = 162 + OpStructPtrHeadStringPtr OpType = 163 + OpStructPtrHeadOmitEmptyStringPtr OpType = 164 + OpStructHeadBytesPtr OpType = 165 + OpStructHeadOmitEmptyBytesPtr OpType = 166 + OpStructPtrHeadBytesPtr OpType = 167 + OpStructPtrHeadOmitEmptyBytesPtr OpType = 168 + OpStructHeadNumberPtr OpType = 169 + OpStructHeadOmitEmptyNumberPtr OpType = 170 + OpStructPtrHeadNumberPtr OpType = 171 + OpStructPtrHeadOmitEmptyNumberPtr OpType = 172 + OpStructHeadArrayPtr OpType = 173 + OpStructHeadOmitEmptyArrayPtr OpType = 174 + OpStructPtrHeadArrayPtr OpType = 175 + OpStructPtrHeadOmitEmptyArrayPtr OpType = 176 + OpStructHeadMapPtr OpType = 177 + OpStructHeadOmitEmptyMapPtr OpType = 178 + OpStructPtrHeadMapPtr OpType = 179 + OpStructPtrHeadOmitEmptyMapPtr OpType = 180 + OpStructHeadSlicePtr OpType = 181 + OpStructHeadOmitEmptySlicePtr OpType = 182 + OpStructPtrHeadSlicePtr OpType = 183 + OpStructPtrHeadOmitEmptySlicePtr OpType = 184 + OpStructHeadMarshalJSONPtr OpType = 185 + OpStructHeadOmitEmptyMarshalJSONPtr OpType = 186 + OpStructPtrHeadMarshalJSONPtr OpType = 187 + OpStructPtrHeadOmitEmptyMarshalJSONPtr OpType = 188 + OpStructHeadMarshalTextPtr OpType = 189 + OpStructHeadOmitEmptyMarshalTextPtr OpType = 190 + OpStructPtrHeadMarshalTextPtr OpType = 191 + OpStructPtrHeadOmitEmptyMarshalTextPtr OpType = 192 + OpStructHeadInterfacePtr OpType = 193 + OpStructHeadOmitEmptyInterfacePtr OpType = 194 + OpStructPtrHeadInterfacePtr OpType = 195 + OpStructPtrHeadOmitEmptyInterfacePtr OpType = 196 + OpStructHeadIntPtrString OpType = 197 + OpStructHeadOmitEmptyIntPtrString OpType = 198 + OpStructPtrHeadIntPtrString OpType = 199 + OpStructPtrHeadOmitEmptyIntPtrString OpType = 200 + OpStructHeadUintPtrString OpType = 201 + OpStructHeadOmitEmptyUintPtrString OpType = 202 + OpStructPtrHeadUintPtrString OpType = 203 + OpStructPtrHeadOmitEmptyUintPtrString OpType = 204 + OpStructHeadFloat32PtrString OpType = 205 + OpStructHeadOmitEmptyFloat32PtrString OpType = 206 + OpStructPtrHeadFloat32PtrString OpType = 207 + OpStructPtrHeadOmitEmptyFloat32PtrString OpType = 208 + OpStructHeadFloat64PtrString OpType = 209 + OpStructHeadOmitEmptyFloat64PtrString OpType = 210 + OpStructPtrHeadFloat64PtrString OpType = 211 + OpStructPtrHeadOmitEmptyFloat64PtrString OpType = 212 + OpStructHeadBoolPtrString OpType = 213 + OpStructHeadOmitEmptyBoolPtrString OpType = 214 + OpStructPtrHeadBoolPtrString OpType = 215 + OpStructPtrHeadOmitEmptyBoolPtrString OpType = 216 + OpStructHeadStringPtrString OpType = 217 + OpStructHeadOmitEmptyStringPtrString OpType = 218 + OpStructPtrHeadStringPtrString OpType = 219 + OpStructPtrHeadOmitEmptyStringPtrString OpType = 220 + OpStructHeadNumberPtrString OpType = 221 + OpStructHeadOmitEmptyNumberPtrString OpType = 222 + OpStructPtrHeadNumberPtrString OpType = 223 + OpStructPtrHeadOmitEmptyNumberPtrString OpType = 224 + OpStructHead OpType = 225 + OpStructHeadOmitEmpty OpType = 226 + OpStructPtrHead OpType = 227 + OpStructPtrHeadOmitEmpty OpType = 228 + OpStructFieldInt OpType = 229 + OpStructFieldOmitEmptyInt OpType = 230 + OpStructEndInt OpType = 231 + OpStructEndOmitEmptyInt OpType = 232 + OpStructFieldUint OpType = 233 + OpStructFieldOmitEmptyUint OpType = 234 + OpStructEndUint OpType = 235 + OpStructEndOmitEmptyUint OpType = 236 + OpStructFieldFloat32 OpType = 237 + OpStructFieldOmitEmptyFloat32 OpType = 238 + OpStructEndFloat32 OpType = 239 + OpStructEndOmitEmptyFloat32 OpType = 240 + OpStructFieldFloat64 OpType = 241 + OpStructFieldOmitEmptyFloat64 OpType = 242 + OpStructEndFloat64 OpType = 243 + OpStructEndOmitEmptyFloat64 OpType = 244 + OpStructFieldBool OpType = 245 + OpStructFieldOmitEmptyBool OpType = 246 + OpStructEndBool OpType = 247 + OpStructEndOmitEmptyBool OpType = 248 + OpStructFieldString OpType = 249 + OpStructFieldOmitEmptyString OpType = 250 + OpStructEndString OpType = 251 + OpStructEndOmitEmptyString OpType = 252 + OpStructFieldBytes OpType = 253 + OpStructFieldOmitEmptyBytes OpType = 254 + OpStructEndBytes OpType = 255 + OpStructEndOmitEmptyBytes OpType = 256 + OpStructFieldNumber OpType = 257 + OpStructFieldOmitEmptyNumber OpType = 258 + OpStructEndNumber OpType = 259 + OpStructEndOmitEmptyNumber OpType = 260 + OpStructFieldArray OpType = 261 + OpStructFieldOmitEmptyArray OpType = 262 + OpStructEndArray OpType = 263 + OpStructEndOmitEmptyArray OpType = 264 + OpStructFieldMap OpType = 265 + OpStructFieldOmitEmptyMap OpType = 266 + OpStructEndMap OpType = 267 + OpStructEndOmitEmptyMap OpType = 268 + OpStructFieldSlice OpType = 269 + OpStructFieldOmitEmptySlice OpType = 270 + OpStructEndSlice OpType = 271 + OpStructEndOmitEmptySlice OpType = 272 + OpStructFieldStruct OpType = 273 + OpStructFieldOmitEmptyStruct OpType = 274 + OpStructEndStruct OpType = 275 + OpStructEndOmitEmptyStruct OpType = 276 + OpStructFieldMarshalJSON OpType = 277 + OpStructFieldOmitEmptyMarshalJSON OpType = 278 + OpStructEndMarshalJSON OpType = 279 + OpStructEndOmitEmptyMarshalJSON OpType = 280 + OpStructFieldMarshalText OpType = 281 + OpStructFieldOmitEmptyMarshalText OpType = 282 + OpStructEndMarshalText OpType = 283 + OpStructEndOmitEmptyMarshalText OpType = 284 + OpStructFieldIntString OpType = 285 + OpStructFieldOmitEmptyIntString OpType = 286 + OpStructEndIntString OpType = 287 + OpStructEndOmitEmptyIntString OpType = 288 + OpStructFieldUintString OpType = 289 + OpStructFieldOmitEmptyUintString OpType = 290 + OpStructEndUintString OpType = 291 + OpStructEndOmitEmptyUintString OpType = 292 + OpStructFieldFloat32String OpType = 293 + OpStructFieldOmitEmptyFloat32String OpType = 294 + OpStructEndFloat32String OpType = 295 + OpStructEndOmitEmptyFloat32String OpType = 296 + OpStructFieldFloat64String OpType = 297 + OpStructFieldOmitEmptyFloat64String OpType = 298 + OpStructEndFloat64String OpType = 299 + OpStructEndOmitEmptyFloat64String OpType = 300 + OpStructFieldBoolString OpType = 301 + OpStructFieldOmitEmptyBoolString OpType = 302 + OpStructEndBoolString OpType = 303 + OpStructEndOmitEmptyBoolString OpType = 304 + OpStructFieldStringString OpType = 305 + OpStructFieldOmitEmptyStringString OpType = 306 + OpStructEndStringString OpType = 307 + OpStructEndOmitEmptyStringString OpType = 308 + OpStructFieldNumberString OpType = 309 + OpStructFieldOmitEmptyNumberString OpType = 310 + OpStructEndNumberString OpType = 311 + OpStructEndOmitEmptyNumberString OpType = 312 + OpStructFieldIntPtr OpType = 313 + OpStructFieldOmitEmptyIntPtr OpType = 314 + OpStructEndIntPtr OpType = 315 + OpStructEndOmitEmptyIntPtr OpType = 316 + OpStructFieldUintPtr OpType = 317 + OpStructFieldOmitEmptyUintPtr OpType = 318 + OpStructEndUintPtr OpType = 319 + OpStructEndOmitEmptyUintPtr OpType = 320 + OpStructFieldFloat32Ptr OpType = 321 + OpStructFieldOmitEmptyFloat32Ptr OpType = 322 + OpStructEndFloat32Ptr OpType = 323 + OpStructEndOmitEmptyFloat32Ptr OpType = 324 + OpStructFieldFloat64Ptr OpType = 325 + OpStructFieldOmitEmptyFloat64Ptr OpType = 326 + OpStructEndFloat64Ptr OpType = 327 + OpStructEndOmitEmptyFloat64Ptr OpType = 328 + OpStructFieldBoolPtr OpType = 329 + OpStructFieldOmitEmptyBoolPtr OpType = 330 + OpStructEndBoolPtr OpType = 331 + OpStructEndOmitEmptyBoolPtr OpType = 332 + OpStructFieldStringPtr OpType = 333 + OpStructFieldOmitEmptyStringPtr OpType = 334 + OpStructEndStringPtr OpType = 335 + OpStructEndOmitEmptyStringPtr OpType = 336 + OpStructFieldBytesPtr OpType = 337 + OpStructFieldOmitEmptyBytesPtr OpType = 338 + OpStructEndBytesPtr OpType = 339 + OpStructEndOmitEmptyBytesPtr OpType = 340 + OpStructFieldNumberPtr OpType = 341 + OpStructFieldOmitEmptyNumberPtr OpType = 342 + OpStructEndNumberPtr OpType = 343 + OpStructEndOmitEmptyNumberPtr OpType = 344 + OpStructFieldArrayPtr OpType = 345 + OpStructFieldOmitEmptyArrayPtr OpType = 346 + OpStructEndArrayPtr OpType = 347 + OpStructEndOmitEmptyArrayPtr OpType = 348 + OpStructFieldMapPtr OpType = 349 + OpStructFieldOmitEmptyMapPtr OpType = 350 + OpStructEndMapPtr OpType = 351 + OpStructEndOmitEmptyMapPtr OpType = 352 + OpStructFieldSlicePtr OpType = 353 + OpStructFieldOmitEmptySlicePtr OpType = 354 + OpStructEndSlicePtr OpType = 355 + OpStructEndOmitEmptySlicePtr OpType = 356 + OpStructFieldMarshalJSONPtr OpType = 357 + OpStructFieldOmitEmptyMarshalJSONPtr OpType = 358 + OpStructEndMarshalJSONPtr OpType = 359 + OpStructEndOmitEmptyMarshalJSONPtr OpType = 360 + OpStructFieldMarshalTextPtr OpType = 361 + OpStructFieldOmitEmptyMarshalTextPtr OpType = 362 + OpStructEndMarshalTextPtr OpType = 363 + OpStructEndOmitEmptyMarshalTextPtr OpType = 364 + OpStructFieldInterfacePtr OpType = 365 + OpStructFieldOmitEmptyInterfacePtr OpType = 366 + OpStructEndInterfacePtr OpType = 367 + OpStructEndOmitEmptyInterfacePtr OpType = 368 + OpStructFieldIntPtrString OpType = 369 + OpStructFieldOmitEmptyIntPtrString OpType = 370 + OpStructEndIntPtrString OpType = 371 + OpStructEndOmitEmptyIntPtrString OpType = 372 + OpStructFieldUintPtrString OpType = 373 + OpStructFieldOmitEmptyUintPtrString OpType = 374 + OpStructEndUintPtrString OpType = 375 + OpStructEndOmitEmptyUintPtrString OpType = 376 + OpStructFieldFloat32PtrString OpType = 377 + OpStructFieldOmitEmptyFloat32PtrString OpType = 378 + OpStructEndFloat32PtrString OpType = 379 + OpStructEndOmitEmptyFloat32PtrString OpType = 380 + OpStructFieldFloat64PtrString OpType = 381 + OpStructFieldOmitEmptyFloat64PtrString OpType = 382 + OpStructEndFloat64PtrString OpType = 383 + OpStructEndOmitEmptyFloat64PtrString OpType = 384 + OpStructFieldBoolPtrString OpType = 385 + OpStructFieldOmitEmptyBoolPtrString OpType = 386 + OpStructEndBoolPtrString OpType = 387 + OpStructEndOmitEmptyBoolPtrString OpType = 388 + OpStructFieldStringPtrString OpType = 389 + OpStructFieldOmitEmptyStringPtrString OpType = 390 + OpStructEndStringPtrString OpType = 391 + OpStructEndOmitEmptyStringPtrString OpType = 392 + OpStructFieldNumberPtrString OpType = 393 + OpStructFieldOmitEmptyNumberPtrString OpType = 394 + OpStructEndNumberPtrString OpType = 395 + OpStructEndOmitEmptyNumberPtrString OpType = 396 + OpStructField OpType = 397 + OpStructFieldOmitEmpty OpType = 398 + OpStructEnd OpType = 399 + OpStructEndOmitEmpty OpType = 400 ) func (t OpType) String() string { - if int(t) >= 400 { + if int(t) >= 401 { return "" } return opTypeStrings[int(t)] diff --git a/vendor/github.com/goccy/go-json/internal/encoder/string.go b/vendor/github.com/goccy/go-json/internal/encoder/string.go index 26da31a5e..a699dba19 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/string.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/string.go @@ -405,7 +405,10 @@ func stringToUint64Slice(s string) []uint64 { })) } -func AppendEscapedString(buf []byte, s string) []byte { +func AppendString(ctx *RuntimeContext, buf []byte, s string) []byte { + if ctx.Option.Flag&HTMLEscapeOption == 0 { + return appendString(buf, s) + } valLen := len(s) if valLen == 0 { return append(buf, `""`...) @@ -531,7 +534,7 @@ ESCAPE_END: return append(append(buf, s[i:]...), '"') } -func AppendString(buf []byte, s string) []byte { +func appendString(buf []byte, s string) []byte { valLen := len(s) if valLen == 0 { return append(buf, `""`...) diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm/debug_vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm/debug_vm.go index 43525e1f5..05509feda 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/vm/debug_vm.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm/debug_vm.go @@ -6,15 +6,22 @@ import ( "github.com/goccy/go-json/internal/encoder" ) -func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt encoder.Option) ([]byte, error) { +func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) { defer func() { + var code *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + code = codeSet.EscapeKeyCode + } else { + code = codeSet.NoescapeKeyCode + } + if err := recover(); err != nil { fmt.Println("=============[DEBUG]===============") fmt.Println("* [TYPE]") fmt.Println(codeSet.Type) fmt.Printf("\n") fmt.Println("* [ALL OPCODE]") - fmt.Println(codeSet.Code.Dump()) + fmt.Println(code.Dump()) fmt.Printf("\n") fmt.Println("* [CONTEXT]") fmt.Printf("%+v\n", ctx) @@ -23,5 +30,5 @@ func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, } }() - return Run(ctx, b, codeSet, opt) + return Run(ctx, b, codeSet) } diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm/hack.go b/vendor/github.com/goccy/go-json/internal/encoder/vm/hack.go index ec24ee32e..65252b4a5 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/vm/hack.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm/hack.go @@ -2,8 +2,8 @@ package vm import ( // HACK: compile order - // `vm`, `vm_escaped`, `vm_indent`, `vm_escaped_indent` packages uses a lot of memory to compile, + // `vm`, `vm_indent`, `vm_color`, `vm_color_indent` packages uses a lot of memory to compile, // so forcibly make dependencies and avoid compiling in concurrent. - // dependency order: vm => vm_escaped => vm_indent => vm_escaped_indent - _ "github.com/goccy/go-json/internal/encoder/vm_escaped" + // dependency order: vm => vm_indent => vm_color => vm_color_indent + _ "github.com/goccy/go-json/internal/encoder/vm_indent" ) diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm/util.go b/vendor/github.com/goccy/go-json/internal/encoder/vm/util.go index 01e608f52..f06f9c8c4 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/vm/util.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm/util.go @@ -33,24 +33,33 @@ type emptyInterface struct { ptr unsafe.Pointer } +type nonEmptyInterface struct { + itab *struct { + ityp *runtime.Type // static interface type + typ *runtime.Type // dynamic concrete type + // unused fields... + } + ptr unsafe.Pointer +} + func errUnimplementedOp(op encoder.OpType) error { return fmt.Errorf("encoder: opcode %s has not been implemented", op) } -func load(base uintptr, idx uintptr) uintptr { - addr := base + idx +func load(base uintptr, idx uint32) uintptr { + addr := base + uintptr(idx) return **(**uintptr)(unsafe.Pointer(&addr)) } -func store(base uintptr, idx uintptr, p uintptr) { - addr := base + idx +func store(base uintptr, idx uint32, p uintptr) { + addr := base + uintptr(idx) **(**uintptr)(unsafe.Pointer(&addr)) = p } -func loadNPtr(base uintptr, idx uintptr, ptrNum int) uintptr { - addr := base + idx +func loadNPtr(base uintptr, idx uint32, ptrNum uint8) uintptr { + addr := base + uintptr(idx) p := **(**uintptr)(unsafe.Pointer(&addr)) - for i := 0; i < ptrNum; i++ { + for i := uint8(0); i < ptrNum; i++ { if p == 0 { return 0 } @@ -70,8 +79,8 @@ func ptrToSlice(p uintptr) *runtime.SliceHeader { return *(**runtime.SliceHeader 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++ { +func ptrToNPtr(p uintptr, ptrNum uint8) uintptr { + for i := uint8(0); i < ptrNum; i++ { if p == 0 { return 0 } @@ -90,22 +99,22 @@ func ptrToInterface(code *encoder.Opcode, p uintptr) interface{} { })) } -func appendBool(b []byte, v bool) []byte { +func appendBool(_ *encoder.RuntimeContext, b []byte, v bool) []byte { if v { return append(b, "true"...) } return append(b, "false"...) } -func appendNull(b []byte) []byte { +func appendNull(_ *encoder.RuntimeContext, b []byte) []byte { return append(b, "null"...) } -func appendComma(b []byte) []byte { +func appendComma(_ *encoder.RuntimeContext, b []byte) []byte { return append(b, ',') } -func appendColon(b []byte) []byte { +func appendColon(_ *encoder.RuntimeContext, b []byte) []byte { last := len(b) - 1 b[last] = ':' return b @@ -123,45 +132,12 @@ func appendMapEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte return b } -func appendInterface(ctx *encoder.RuntimeContext, codeSet *encoder.OpcodeSet, opt encoder.Option, _ *encoder.Opcode, b []byte, iface *emptyInterface, ptrOffset uintptr) ([]byte, error) { - ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(iface)) - ifaceCodeSet, err := encoder.CompileToGetCodeSet(uintptr(unsafe.Pointer(iface.typ))) - if err != nil { - return nil, err - } - - totalLength := uintptr(codeSet.CodeLength) - nextTotalLength := uintptr(ifaceCodeSet.CodeLength) - - curlen := uintptr(len(ctx.Ptrs)) - offsetNum := ptrOffset / uintptrSize - - newLen := offsetNum + totalLength + nextTotalLength - if curlen < newLen { - ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...) - } - oldPtrs := ctx.Ptrs - - newPtrs := ctx.Ptrs[(ptrOffset+totalLength*uintptrSize)/uintptrSize:] - newPtrs[0] = uintptr(iface.ptr) - - ctx.Ptrs = newPtrs - - bb, err := Run(ctx, b, ifaceCodeSet, opt) - if err != nil { - return nil, err - } - - ctx.Ptrs = oldPtrs - return bb, nil -} - func appendMarshalJSON(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { - return encoder.AppendMarshalJSON(ctx, code, b, v, false) + return encoder.AppendMarshalJSON(ctx, code, b, v) } -func appendMarshalText(code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { - return encoder.AppendMarshalText(code, b, v, false) +func appendMarshalText(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { + return encoder.AppendMarshalText(ctx, code, b, v) } func appendArrayHead(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { @@ -174,11 +150,11 @@ func appendArrayEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []by return append(b, ',') } -func appendEmptyArray(b []byte) []byte { +func appendEmptyArray(_ *encoder.RuntimeContext, b []byte) []byte { return append(b, '[', ']', ',') } -func appendEmptyObject(b []byte) []byte { +func appendEmptyObject(_ *encoder.RuntimeContext, b []byte) []byte { return append(b, '{', '}', ',') } @@ -188,7 +164,7 @@ func appendObjectEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []b return append(b, ',') } -func appendStructHead(b []byte) []byte { +func appendStructHead(_ *encoder.RuntimeContext, b []byte) []byte { return append(b, '{') } @@ -204,7 +180,7 @@ func appendStructEndSkipLast(ctx *encoder.RuntimeContext, code *encoder.Opcode, last := len(b) - 1 if b[last] == ',' { b[last] = '}' - return appendComma(b) + return appendComma(ctx, b) } return appendStructEnd(ctx, code, b) } diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm/vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm/vm.go index 952236425..5857249da 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/vm/vm.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm/vm.go @@ -7,13 +7,19 @@ import ( "unsafe" "github.com/goccy/go-json/internal/encoder" + "github.com/goccy/go-json/internal/runtime" ) -func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt encoder.Option) ([]byte, error) { +func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) { recursiveLevel := 0 ptrOffset := uintptr(0) ctxptr := ctx.Ptr() - code := codeSet.Code + var code *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + code = codeSet.EscapeKeyCode + } else { + code = codeSet.NoescapeKeyCode + } for { switch code.Op { @@ -26,62 +32,62 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpIntPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpInt: - b = appendInt(b, ptrToUint64(load(ctxptr, code.Idx)), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpUintPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpUint: - b = appendUint(b, ptrToUint64(load(ctxptr, code.Idx)), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpIntString: b = append(b, '"') - b = appendInt(b, ptrToUint64(load(ctxptr, code.Idx)), code) + b = appendInt(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpUintString: b = append(b, '"') - b = appendUint(b, ptrToUint64(load(ctxptr, code.Idx)), code) + b = appendUint(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpFloat32Ptr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpFloat32: - b = appendFloat32(b, ptrToFloat32(load(ctxptr, code.Idx))) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) code = code.Next case encoder.OpFloat64Ptr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -92,73 +98,73 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next case encoder.OpStringPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpString: - b = appendString(b, ptrToString(load(ctxptr, code.Idx))) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) code = code.Next case encoder.OpBoolPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpBool: - b = appendBool(b, ptrToBool(load(ctxptr, code.Idx))) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) code = code.Next case encoder.OpBytesPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpBytes: - b = appendByteSlice(b, ptrToBytes(load(ctxptr, code.Idx))) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) code = code.Next case encoder.OpNumberPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpNumber: - bb, err := appendNumber(b, ptrToNumber(load(ctxptr, code.Idx))) + bb, err := appendNumber(ctx, b, ptrToNumber(load(ctxptr, code.Idx))) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpInterfacePtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -167,38 +173,92 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpInterface: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } - for _, seen := range ctx.SeenPtr { - if p == seen { - return nil, errUnsupportedValue(code, p) + if recursiveLevel > encoder.StartDetectingCyclesAfter { + for _, seen := range ctx.SeenPtr { + if p == seen { + return nil, errUnsupportedValue(code, p) + } } } ctx.SeenPtr = append(ctx.SeenPtr, p) - iface := (*emptyInterface)(ptrToUnsafePtr(p)) - if iface.ptr == nil { - b = appendNull(b) - b = appendComma(b) + var ( + typ *runtime.Type + ifacePtr unsafe.Pointer + ) + up := ptrToUnsafePtr(p) + if code.Flags&encoder.NonEmptyInterfaceFlags != 0 { + iface := (*nonEmptyInterface)(up) + ifacePtr = iface.ptr + typ = iface.itab.typ + } else { + iface := (*emptyInterface)(up) + ifacePtr = iface.ptr + typ = iface.typ + } + if ifacePtr == nil { + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } - bb, err := appendInterface(ctx, codeSet, opt, code, b, iface, ptrOffset) + ctx.KeepRefs = append(ctx.KeepRefs, up) + ifaceCodeSet, err := encoder.CompileToGetCodeSet(uintptr(unsafe.Pointer(typ))) if err != nil { return nil, err } - ctxptr = ctx.Ptr() + + totalLength := uintptr(code.Length) + 3 + nextTotalLength := uintptr(ifaceCodeSet.CodeLength) + 3 + + var c *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + c = ifaceCodeSet.InterfaceEscapeKeyCode + } else { + c = ifaceCodeSet.InterfaceNoescapeKeyCode + } + curlen := uintptr(len(ctx.Ptrs)) + offsetNum := ptrOffset / uintptrSize + oldOffset := ptrOffset + ptrOffset += totalLength * uintptrSize + oldBaseIndent := ctx.BaseIndent + indentDiffFromTop := c.Indent - 1 + ctx.BaseIndent += code.Indent - indentDiffFromTop + + newLen := offsetNum + totalLength + nextTotalLength + if curlen < newLen { + ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...) + } + ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr + + end := ifaceCodeSet.EndCode + store(ctxptr, c.Idx, uintptr(ifacePtr)) + store(ctxptr, end.Idx, oldOffset) + store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next))) + storeIndent(ctxptr, end, uintptr(oldBaseIndent)) + code = c + recursiveLevel++ + case encoder.OpInterfaceEnd: + recursiveLevel-- + + // restore ctxptr + offset := load(ctxptr, code.Idx) + restoreIndent(ctx, code, ctxptr) ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1] - b = bb - code = code.Next + codePtr := load(ctxptr, code.ElemIdx) + code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr)) + ctxptr = ctx.Ptr() + offset + ptrOffset = offset case encoder.OpMarshalJSONPtr: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -207,25 +267,25 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpMarshalJSON: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } - if code.IsNilableType && code.Indirect { + if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 { p = ptrToPtr(p) } bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpMarshalTextPtr: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -235,24 +295,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt p := load(ctxptr, code.Idx) if p == 0 { b = append(b, `""`...) - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next break } - if code.IsNilableType && code.Indirect { + if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 { p = ptrToPtr(p) } - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpSlicePtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -262,8 +322,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt p := load(ctxptr, code.Idx) slice := ptrToSlice(p) if p == 0 || slice.Data == nil { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -275,7 +335,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next store(ctxptr, code.Idx, uintptr(slice.Data)) } else { - b = appendEmptyArray(b) + b = appendEmptyArray(ctx, b) code = code.End.Next } case encoder.OpSliceElem: @@ -285,8 +345,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if idx < length { b = appendArrayElemIndent(ctx, code, b) store(ctxptr, code.ElemIdx, idx) - data := load(ctxptr, code.HeadIdx) - size := code.Size + data := load(ctxptr, code.Idx) + size := uintptr(code.Size) code = code.Next store(ctxptr, code.Idx, data+idx*size) } else { @@ -296,8 +356,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpArrayPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -306,8 +366,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpArray: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -317,17 +377,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next store(ctxptr, code.Idx, p) } else { - b = appendEmptyArray(b) + b = appendEmptyArray(ctx, b) code = code.End.Next } case encoder.OpArrayElem: idx := load(ctxptr, code.ElemIdx) idx++ - if idx < code.Length { + if idx < uintptr(code.Length) { b = appendArrayElemIndent(ctx, code, b) store(ctxptr, code.ElemIdx, idx) - p := load(ctxptr, code.HeadIdx) - size := code.Size + p := load(ctxptr, code.Idx) + size := uintptr(code.Size) code = code.Next store(ctxptr, code.Idx, p+idx*size) } else { @@ -337,8 +397,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpMapPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -347,31 +407,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpMap: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } uptr := ptrToUnsafePtr(p) mlen := maplen(uptr) if mlen <= 0 { - b = appendEmptyObject(b) + b = appendEmptyObject(ctx, b) code = code.End.Next break } - b = appendStructHead(b) + b = appendStructHead(ctx, b) iter := mapiterinit(code.Type, uptr) ctx.KeepRefs = append(ctx.KeepRefs, iter) store(ctxptr, code.ElemIdx, 0) store(ctxptr, code.Length, uintptr(mlen)) store(ctxptr, code.MapIter, uintptr(iter)) - if (opt & encoder.UnorderedMapOption) == 0 { + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { + b = appendMapKeyIndent(ctx, code.Next, b) + } else { mapCtx := encoder.NewMapContext(mlen) mapCtx.Pos = append(mapCtx.Pos, len(b)) ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx)) store(ctxptr, code.End.MapPos, uintptr(unsafe.Pointer(mapCtx))) - } else { - b = appendMapKeyIndent(ctx, code.Next, b) } key := mapiterkey(iter) store(ctxptr, code.Next.Idx, uintptr(key)) @@ -380,7 +440,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt idx := load(ctxptr, code.ElemIdx) length := load(ctxptr, code.Length) idx++ - if (opt & encoder.UnorderedMapOption) != 0 { + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { if idx < length { b = appendMapKeyIndent(ctx, code, b) store(ctxptr, code.ElemIdx, idx) @@ -409,8 +469,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } } case encoder.OpMapValue: - if (opt & encoder.UnorderedMapOption) != 0 { - b = appendColon(b) + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { + b = appendColon(ctx, b) } else { ptr := load(ctxptr, code.End.MapPos) mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(ptr)) @@ -479,7 +539,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt oldOffset := ptrOffset ptrOffset += code.Jmp.CurLen * uintptrSize oldBaseIndent := ctx.BaseIndent - ctx.BaseIndent += code.Indent - 1 + indentDiffFromTop := c.Indent - 1 + ctx.BaseIndent += code.Indent - indentDiffFromTop newLen := offsetNum + code.Jmp.CurLen + code.Jmp.NextLen if curlen < newLen { @@ -490,7 +551,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt store(ctxptr, c.Idx, ptr) store(ctxptr, c.End.Next.Idx, oldOffset) store(ctxptr, c.End.Next.ElemIdx, uintptr(unsafe.Pointer(code.Next))) - storeIndent(ctxptr, c, uintptr(oldBaseIndent)) + storeIndent(ctxptr, c.End.Next, uintptr(oldBaseIndent)) code = c recursiveLevel++ case encoder.OpRecursiveEnd: @@ -508,9 +569,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHead: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -519,29 +580,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHead: p := load(ctxptr, code.Idx) - if p == 0 && (code.Indirect || code.Next.Op == encoder.OpStructEnd) { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if !code.AnonymousKey && len(code.Key) > 0 { - b = appendStructKey(ctx, code, b) + if len(code.Key) > 0 { + if (code.Flags&encoder.IsTaggedKeyFlags) != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 { + b = appendStructKey(ctx, code, b) + } } - p += code.Offset + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructPtrHeadOmitEmpty: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -550,19 +613,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmpty: p := load(ctxptr, code.Idx) - if p == 0 && (code.Indirect || code.Next.Op == encoder.OpStructEnd) { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - p += code.Offset - if p == 0 || (ptrToPtr(p) == 0 && code.IsNextOpPtrType) { + p += uintptr(code.Offset) + if p == 0 || (ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0) { code = code.NextField } else { b = appendStructKey(ctx, code, b) @@ -570,12 +633,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt store(ctxptr, code.Idx, p) } case encoder.OpStructPtrHeadInt: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -586,27 +649,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadInt: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p+code.Offset), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyInt: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -617,33 +680,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyInt: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendInt(b, u64, code) - b = appendComma(b) + b = appendInt(ctx, b, u64, code) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadIntString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -654,29 +717,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadIntString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p+code.Offset), code) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyIntString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -687,34 +750,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyIntString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, u64, code) + b = appendInt(ctx, b, u64, code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadIntPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -723,34 +786,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadIntPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyIntPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -759,32 +822,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyIntPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(p), code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadIntPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -793,36 +856,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadIntPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyIntPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -831,35 +894,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyIntPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadUint: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -870,27 +933,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadUint: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p+code.Offset), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyUint: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -901,33 +964,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyUint: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendUint(b, u64, code) - b = appendComma(b) + b = appendUint(ctx, b, u64, code) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadUintString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -938,29 +1001,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadUintString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p+code.Offset), code) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyUintString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -971,34 +1034,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyUintString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, u64, code) + b = appendUint(ctx, b, u64, code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadUintPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1007,34 +1070,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadUintPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyUintPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1043,32 +1106,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyUintPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(p), code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadUintPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1077,36 +1140,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadUintPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyUintPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1115,35 +1178,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyUintPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadFloat32: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1154,27 +1217,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadFloat32: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat32: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1185,32 +1248,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyFloat32: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat32(p + code.Offset) + v := ptrToFloat32(p + uintptr(code.Offset)) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, v) - b = appendComma(b) + b = appendFloat32(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadFloat32String: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1221,29 +1284,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadFloat32String: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat32String: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1254,33 +1317,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyFloat32String: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat32(p + code.Offset) + v := ptrToFloat32(p + uintptr(code.Offset)) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, v) + b = appendFloat32(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadFloat32Ptr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1289,34 +1352,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadFloat32Ptr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat32Ptr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1325,32 +1388,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyFloat32Ptr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p)) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadFloat32PtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1359,36 +1422,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadFloat32PtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat32PtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1397,35 +1460,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyFloat32PtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadFloat64: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1436,31 +1499,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadFloat64: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat64: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1471,17 +1534,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyFloat64: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if v == 0 { code = code.NextField } else { @@ -1489,17 +1552,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadFloat64String: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1510,33 +1573,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadFloat64String: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat64String: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1547,17 +1610,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyFloat64String: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if v == 0 { code = code.NextField } else { @@ -1566,17 +1629,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadFloat64Ptr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1585,38 +1648,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadFloat64Ptr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat64Ptr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1625,19 +1688,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyFloat64Ptr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) @@ -1645,16 +1708,16 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadFloat64PtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1663,40 +1726,40 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadFloat64PtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat64PtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1705,19 +1768,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyFloat64PtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) @@ -1726,18 +1789,18 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1748,27 +1811,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p+code.Offset)) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1779,32 +1842,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToString(p + code.Offset) + v := ptrToString(p + uintptr(code.Offset)) if v == "" { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendString(b, v) - b = appendComma(b) + b = appendString(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadStringString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1815,27 +1878,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadStringString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, ptrToString(p+code.Offset)))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p+uintptr(code.Offset))))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyStringString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1846,31 +1909,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyStringString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToString(p + code.Offset) + v := ptrToString(p + uintptr(code.Offset)) if v == "" { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, v))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadStringPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1879,34 +1942,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadStringPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, ptrToString(p)) + b = appendString(ctx, b, ptrToString(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyStringPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1915,32 +1978,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyStringPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p)) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadStringPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1949,34 +2012,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadStringPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyStringPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1985,33 +2048,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyStringPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadBool: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2022,27 +2085,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadBool: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p+code.Offset)) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBool: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2053,32 +2116,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyBool: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToBool(p + code.Offset) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) - b = appendBool(b, v) - b = appendComma(b) + b = appendBool(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } else { code = code.NextField } case encoder.OpStructPtrHeadBoolString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2089,29 +2152,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadBoolString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p+code.Offset)) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBoolString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2122,23 +2185,23 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyBoolString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToBool(p + code.Offset) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, v) + b = appendBool(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } else { code = code.NextField @@ -2146,9 +2209,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadBoolPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2157,34 +2220,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadBoolPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBoolPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2193,32 +2256,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyBoolPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p)) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadBoolPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2227,36 +2290,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadBoolPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBoolPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2265,35 +2328,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyBoolPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadBytes: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2304,27 +2367,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadBytes: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p+code.Offset)) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBytes: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2335,31 +2398,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyBytes: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToBytes(p + code.Offset) + v := ptrToBytes(p + uintptr(code.Offset)) if len(v) == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, v) - b = appendComma(b) + b = appendByteSlice(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadBytesPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2368,34 +2431,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadBytesPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendByteSlice(b, ptrToBytes(p)) + b = appendByteSlice(ctx, b, ptrToBytes(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBytesPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2404,33 +2467,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyBytesPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p)) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadNumber: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2441,30 +2504,30 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadNumber: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpStructPtrHeadOmitEmptyNumber: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2475,35 +2538,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyNumber: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToNumber(p + code.Offset) + v := ptrToNumber(p + uintptr(code.Offset)) if v == "" { code = code.NextField } else { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next } case encoder.OpStructPtrHeadNumberString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2514,32 +2577,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadNumberString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyNumberString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2550,36 +2613,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyNumberString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToNumber(p + code.Offset) + v := ptrToNumber(p + uintptr(code.Offset)) if v == "" { code = code.NextField } else { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadNumberPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2588,38 +2651,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadNumberPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyNumberPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2628,35 +2691,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyNumberPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructPtrHeadNumberPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2665,39 +2728,39 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadNumberPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = append(bb, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyNumberPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2706,38 +2769,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyNumberPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadArray, encoder.OpStructPtrHeadSlice: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2748,27 +2811,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadArray, encoder.OpStructHeadSlice: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - p += code.Offset + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructPtrHeadOmitEmptyArray: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2779,27 +2842,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyArray: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - p += code.Offset + p += uintptr(code.Offset) b = appendStructKey(ctx, code, b) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructPtrHeadOmitEmptySlice: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2810,17 +2873,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptySlice: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - p += code.Offset + p += uintptr(code.Offset) slice := ptrToSlice(p) if slice.Len == 0 { code = code.NextField @@ -2832,9 +2895,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadArrayPtr, encoder.OpStructPtrHeadSlicePtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2843,24 +2906,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadArrayPtr, encoder.OpStructHeadSlicePtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.NextField } else { code = code.Next @@ -2869,9 +2932,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadOmitEmptyArrayPtr, encoder.OpStructPtrHeadOmitEmptySlicePtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2880,19 +2943,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyArrayPtr, encoder.OpStructHeadOmitEmptySlicePtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { code = code.NextField @@ -2904,9 +2967,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadMap: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2915,29 +2978,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadMap: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if p != 0 && code.Indirect { - p = ptrToPtr(p + code.Offset) + if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p + uintptr(code.Offset)) } code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructPtrHeadOmitEmptyMap: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2946,19 +3009,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyMap: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if p != 0 && code.Indirect { - p = ptrToPtr(p + code.Offset) + if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p + uintptr(code.Offset)) } if maplen(ptrToUnsafePtr(p)) == 0 { code = code.NextField @@ -2970,9 +3033,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadMapPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2981,31 +3044,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadMapPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.NextField break } - p = ptrToPtr(p + code.Offset) + p = ptrToPtr(p + uintptr(code.Offset)) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.NextField } else { - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p = ptrToNPtr(p, code.PtrNum) } code = code.Next @@ -3014,9 +3077,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadOmitEmptyMapPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3025,26 +3088,26 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyMapPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } if p == 0 { code = code.NextField break } - p = ptrToPtr(p + code.Offset) + p = ptrToPtr(p + uintptr(code.Offset)) if p == 0 { code = code.NextField } else { - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p = ptrToNPtr(p, code.PtrNum) } b = appendStructKey(ctx, code, b) @@ -3054,38 +3117,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadMarshalJSON: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) } fallthrough case encoder.OpStructHeadMarshalJSON: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.IsNilableType { - if code.Indirect || code.Op == encoder.OpStructPtrHeadMarshalJSON { - p = ptrToPtr(p + code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalJSON { + p = ptrToPtr(p + uintptr(code.Offset)) } } - if p == 0 && code.Nilcheck { - b = appendNull(b) + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) } else { bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { @@ -3093,42 +3156,42 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyMarshalJSON: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) } fallthrough case encoder.OpStructHeadOmitEmptyMarshalJSON: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.IsNilableType { - if code.Indirect || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON { - p = ptrToPtr(p + code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON { + p = ptrToPtr(p + uintptr(code.Offset)) } } iface := ptrToInterface(code, p) - if code.Nilcheck && encoder.IsNilForMarshaler(iface) { + if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) { code = code.NextField } else { b = appendStructKey(ctx, code, b) @@ -3137,15 +3200,15 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt return nil, err } b = bb - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadMarshalJSONPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3154,23 +3217,23 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadMarshalJSONPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { @@ -3178,14 +3241,14 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyMarshalJSONPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3194,19 +3257,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyMarshalJSONPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } if p == 0 { code = code.NextField @@ -3217,103 +3280,103 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt return nil, err } b = bb - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadMarshalText: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) } fallthrough case encoder.OpStructHeadMarshalText: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.IsNilableType { - if code.Indirect || code.Op == encoder.OpStructPtrHeadMarshalText { - p = ptrToPtr(p + code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalText { + p = ptrToPtr(p + uintptr(code.Offset)) } } - if p == 0 && code.Nilcheck { - b = appendNull(b) + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) } else { - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyMarshalText: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) } fallthrough case encoder.OpStructHeadOmitEmptyMarshalText: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.IsNilableType { - if code.Indirect || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText { - p = ptrToPtr(p + code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText { + p = ptrToPtr(p + uintptr(code.Offset)) } } - if p == 0 && code.Nilcheck { + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadMarshalTextPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3322,38 +3385,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadMarshalTextPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyMarshalTextPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3362,43 +3425,43 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyMarshalTextPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } if p == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructField: - if !code.AnonymousKey { + if code.Flags&encoder.IsTaggedKeyFlags != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 { b = appendStructKey(ctx, code, b) } - p := load(ctxptr, code.HeadIdx) + code.Offset + p := load(ctxptr, code.Idx) + uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmpty: - p := load(ctxptr, code.HeadIdx) - p += code.Offset - if ptrToPtr(p) == 0 && code.IsNextOpPtrType { + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) @@ -3406,298 +3469,298 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt store(ctxptr, code.Idx, p) } case encoder.OpStructFieldInt: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p+code.Offset), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyInt: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, u64, code) - b = appendComma(b) + b = appendInt(ctx, b, u64, code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldIntString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p+code.Offset), code) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyIntString: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, u64, code) + b = appendInt(ctx, b, u64, code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldIntPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyIntPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(p), code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldIntPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyIntPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldUint: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p+code.Offset), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyUint: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, u64, code) - b = appendComma(b) + b = appendUint(ctx, b, u64, code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldUintString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p+code.Offset), code) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyUintString: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, u64, code) + b = appendUint(ctx, b, u64, code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldUintPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyUintPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(p), code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldUintPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyUintPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat32: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat32: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat32(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, v) - b = appendComma(b) + b = appendFloat32(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat32String: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat32String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat32(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, v) + b = appendFloat32(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat32Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat32Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p)) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat32PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat32PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat64: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat64: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if v != 0 { if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat64String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat64String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if v != 0 { if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat64Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -3705,42 +3768,42 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat64Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat64PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat64PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') @@ -3748,307 +3811,307 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p+code.Offset)) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyString: - p := load(ctxptr, code.HeadIdx) - v := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - b = appendString(b, v) - b = appendComma(b) + b = appendString(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldStringString: - p := load(ctxptr, code.HeadIdx) - s := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + s := ptrToString(p + uintptr(code.Offset)) b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, s))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, s))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyStringString: - p := load(ctxptr, code.HeadIdx) - v := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, v))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldStringPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, ptrToString(p)) + b = appendString(ctx, b, ptrToString(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyStringPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p)) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldStringPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyStringPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBool: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p+code.Offset)) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBool: - p := load(ctxptr, code.HeadIdx) - v := ptrToBool(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) - b = appendBool(b, v) - b = appendComma(b) + b = appendBool(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBoolString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p+code.Offset)) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBoolString: - p := load(ctxptr, code.HeadIdx) - v := ptrToBool(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, v) + b = appendBool(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBoolPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBoolPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p)) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBoolPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBoolPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBytes: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p+code.Offset)) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBytes: - p := load(ctxptr, code.HeadIdx) - v := ptrToBytes(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBytes(p + uintptr(code.Offset)) if len(v) > 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, v) - b = appendComma(b) + b = appendByteSlice(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBytesPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendByteSlice(b, ptrToBytes(p)) + b = appendByteSlice(ctx, b, ptrToBytes(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBytesPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p)) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldNumber: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpStructFieldOmitEmptyNumber: - p := load(ctxptr, code.HeadIdx) - v := ptrToNumber(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructFieldNumberString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyNumberString: - p := load(ctxptr, code.HeadIdx) - v := ptrToNumber(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldNumberPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyNumberPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructFieldNumberPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = append(bb, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyNumberPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldMarshalJSON: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - p += code.Offset - if code.IsNilableType { + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { p = ptrToPtr(p) } - if p == 0 && code.Nilcheck { - b = appendNull(b) + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) } else { bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { @@ -4056,20 +4119,20 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyMarshalJSON: - p := load(ctxptr, code.HeadIdx) - p += code.Offset - if code.IsNilableType { + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { p = ptrToPtr(p) } - if p == 0 && code.Nilcheck { + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { code = code.NextField break } iface := ptrToInterface(code, p) - if code.Nilcheck && encoder.IsNilForMarshaler(iface) { + if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) { code = code.NextField break } @@ -4078,14 +4141,14 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpStructFieldMarshalJSONPtr: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { @@ -4093,103 +4156,103 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyMarshalJSONPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructFieldMarshalText: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - p += code.Offset - if code.IsNilableType { + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { p = ptrToPtr(p) } - if p == 0 && code.Nilcheck { - b = appendNull(b) + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) } else { - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyMarshalText: - p := load(ctxptr, code.HeadIdx) - p += code.Offset - if code.IsNilableType { + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { p = ptrToPtr(p) } - if p == 0 && code.Nilcheck { + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { code = code.NextField break } b = appendStructKey(ctx, code, b) - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpStructFieldMarshalTextPtr: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyMarshalTextPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructFieldArray: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyArray: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldArrayPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyArrayPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) code = code.Next @@ -4199,13 +4262,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldSlice: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptySlice: - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) slice := ptrToSlice(p) if slice.Len == 0 { code = code.NextField @@ -4216,13 +4279,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldSlicePtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptySlicePtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) code = code.Next @@ -4232,13 +4295,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldMap: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToPtr(p + code.Offset) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyMap: - p := load(ctxptr, code.HeadIdx) - p = ptrToPtr(p + code.Offset) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) if p == 0 || maplen(ptrToUnsafePtr(p)) == 0 { code = code.NextField } else { @@ -4248,16 +4311,16 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldMapPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToPtr(p + code.Offset) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) if p != 0 { p = ptrToNPtr(p, code.PtrNum) } code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyMapPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToPtr(p + code.Offset) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) if p != 0 { p = ptrToNPtr(p, code.PtrNum) } @@ -4270,14 +4333,14 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldStruct: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyStruct: - p := load(ctxptr, code.HeadIdx) - p += code.Offset - if ptrToPtr(p) == 0 && code.IsNextOpPtrType { + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) @@ -4290,39 +4353,39 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt b = appendStructEndSkipLast(ctx, code, b) code = code.Next case encoder.OpStructEndInt: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p+code.Offset), code) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyInt: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, u64, code) + b = appendInt(ctx, b, u64, code) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndIntString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p+code.Offset), code) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyIntString: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, u64, code) + b = appendInt(ctx, b, u64, code) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4331,21 +4394,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndIntPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyIntPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4353,24 +4416,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndIntPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyIntPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4378,39 +4441,39 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndUint: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p+code.Offset), code) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyUint: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, u64, code) + b = appendUint(ctx, b, u64, code) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndUintString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p+code.Offset), code) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyUintString: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, u64, code) + b = appendUint(ctx, b, u64, code) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4419,21 +4482,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndUintPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyUintPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4441,24 +4504,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndUintPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyUintPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4466,37 +4529,37 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndFloat32: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat32: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat32(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, v) + b = appendFloat32(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndFloat32String: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat32String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat32(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, v) + b = appendFloat32(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4505,21 +4568,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndFloat32Ptr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat32Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4527,24 +4590,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndFloat32PtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat32PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4552,51 +4615,51 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndFloat64: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat64: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if v != 0 { if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndFloat64String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat64String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if v != 0 { if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4605,10 +4668,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndFloat64Ptr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) b = appendStructEnd(ctx, code, b) code = code.Next break @@ -4617,19 +4680,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat64Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4637,24 +4700,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndFloat64PtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat64PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) v := ptrToFloat64(p) @@ -4662,7 +4725,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt return nil, errUnsupportedFloat(v) } b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4670,35 +4733,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p+code.Offset)) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyString: - p := load(ctxptr, code.HeadIdx) - v := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - b = appendString(b, v) + b = appendString(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndStringString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - s := ptrToString(p + code.Offset) - b = appendString(b, string(appendString([]byte{}, s))) + s := ptrToString(p + uintptr(code.Offset)) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, s))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyStringString: - p := load(ctxptr, code.HeadIdx) - v := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, v))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4706,21 +4769,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndStringPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, ptrToString(p)) + b = appendString(ctx, b, ptrToString(p)) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyStringPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p)) + b = appendString(ctx, b, ptrToString(p)) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4728,58 +4791,58 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndStringPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyStringPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndBool: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p+code.Offset)) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBool: - p := load(ctxptr, code.HeadIdx) - v := ptrToBool(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) - b = appendBool(b, v) + b = appendBool(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndBoolString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p+code.Offset)) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBoolString: - p := load(ctxptr, code.HeadIdx) - v := ptrToBool(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, v) + b = appendBool(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4788,21 +4851,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndBoolPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBoolPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4810,24 +4873,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndBoolPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBoolPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4835,17 +4898,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndBytes: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p+code.Offset)) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBytes: - p := load(ctxptr, code.HeadIdx) - v := ptrToBytes(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBytes(p + uintptr(code.Offset)) if len(v) > 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, v) + b = appendByteSlice(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4853,41 +4916,41 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndBytesPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendByteSlice(b, ptrToBytes(p)) + b = appendByteSlice(ctx, b, ptrToBytes(p)) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBytesPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p)) + b = appendByteSlice(ctx, b, ptrToBytes(p)) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndNumber: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } b = appendStructEnd(ctx, code, bb) code = code.Next case encoder.OpStructEndOmitEmptyNumber: - p := load(ctxptr, code.HeadIdx) - v := ptrToNumber(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } @@ -4897,10 +4960,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndNumberString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } @@ -4908,12 +4971,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyNumberString: - p := load(ctxptr, code.HeadIdx) - v := ptrToNumber(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } @@ -4925,12 +4988,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndNumberPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } @@ -4939,11 +5002,11 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyNumberPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } @@ -4954,13 +5017,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndNumberPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } @@ -4969,12 +5032,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyNumberPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_escaped/debug_vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/debug_vm.go index 0139f5755..6a6a33d22 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/vm_escaped/debug_vm.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/debug_vm.go @@ -1,4 +1,4 @@ -package vm_escaped +package vm_color import ( "fmt" @@ -6,7 +6,14 @@ import ( "github.com/goccy/go-json/internal/encoder" ) -func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt encoder.Option) ([]byte, error) { +func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) { + var code *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + code = codeSet.EscapeKeyCode + } else { + code = codeSet.NoescapeKeyCode + } + defer func() { if err := recover(); err != nil { fmt.Println("=============[DEBUG]===============") @@ -14,7 +21,7 @@ func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, fmt.Println(codeSet.Type) fmt.Printf("\n") fmt.Println("* [ALL OPCODE]") - fmt.Println(codeSet.Code.Dump()) + fmt.Println(code.Dump()) fmt.Printf("\n") fmt.Println("* [CONTEXT]") fmt.Printf("%+v\n", ctx) @@ -23,5 +30,5 @@ func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, } }() - return Run(ctx, b, codeSet, opt) + return Run(ctx, b, codeSet) } diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color/hack.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/hack.go new file mode 100644 index 000000000..12ec56c5b --- /dev/null +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/hack.go @@ -0,0 +1,9 @@ +package vm_color + +import ( + // HACK: compile order + // `vm`, `vm_indent`, `vm_color`, `vm_color_indent` packages uses a lot of memory to compile, + // so forcibly make dependencies and avoid compiling in concurrent. + // dependency order: vm => vm_indent => vm_color => vm_color_indent + _ "github.com/goccy/go-json/internal/encoder/vm_color_indent" +) diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_escaped/util.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/util.go index 129eb2cfa..710087f64 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/vm_escaped/util.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/util.go @@ -1,4 +1,4 @@ -package vm_escaped +package vm_color import ( "encoding/json" @@ -12,13 +12,6 @@ import ( const uintptrSize = 4 << (^uintptr(0) >> 63) var ( - appendInt = encoder.AppendInt - appendUint = encoder.AppendUint - appendFloat32 = encoder.AppendFloat32 - appendFloat64 = encoder.AppendFloat64 - appendString = encoder.AppendEscapedString - appendByteSlice = encoder.AppendByteSlice - appendNumber = encoder.AppendNumber errUnsupportedValue = encoder.ErrUnsupportedValue errUnsupportedFloat = encoder.ErrUnsupportedFloat mapiterinit = encoder.MapIterInit @@ -33,24 +26,33 @@ type emptyInterface struct { ptr unsafe.Pointer } +type nonEmptyInterface struct { + itab *struct { + ityp *runtime.Type // static interface type + typ *runtime.Type // dynamic concrete type + // unused fields... + } + ptr unsafe.Pointer +} + func errUnimplementedOp(op encoder.OpType) error { - return fmt.Errorf("encoder (escaped): opcode %s has not been implemented", op) + return fmt.Errorf("encoder: opcode %s has not been implemented", op) } -func load(base uintptr, idx uintptr) uintptr { - addr := base + idx +func load(base uintptr, idx uint32) uintptr { + addr := base + uintptr(idx) return **(**uintptr)(unsafe.Pointer(&addr)) } -func store(base uintptr, idx uintptr, p uintptr) { - addr := base + idx +func store(base uintptr, idx uint32, p uintptr) { + addr := base + uintptr(idx) **(**uintptr)(unsafe.Pointer(&addr)) = p } -func loadNPtr(base uintptr, idx uintptr, ptrNum int) uintptr { - addr := base + idx +func loadNPtr(base uintptr, idx uint32, ptrNum uint8) uintptr { + addr := base + uintptr(idx) p := **(**uintptr)(unsafe.Pointer(&addr)) - for i := 0; i < ptrNum; i++ { + for i := uint8(0); i < ptrNum; i++ { if p == 0 { return 0 } @@ -70,8 +72,8 @@ func ptrToSlice(p uintptr) *runtime.SliceHeader { return *(**runtime.SliceHeader 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++ { +func ptrToNPtr(p uintptr, ptrNum uint8) uintptr { + for i := uint8(0); i < ptrNum; i++ { if p == 0 { return 0 } @@ -90,78 +92,111 @@ func ptrToInterface(code *encoder.Opcode, p uintptr) interface{} { })) } -func appendBool(b []byte, v bool) []byte { +func appendInt(ctx *encoder.RuntimeContext, b []byte, v uint64, code *encoder.Opcode) []byte { + format := ctx.Option.ColorScheme.Int + b = append(b, format.Header...) + b = encoder.AppendInt(ctx, b, v, code) + return append(b, format.Footer...) +} + +func appendUint(ctx *encoder.RuntimeContext, b []byte, v uint64, code *encoder.Opcode) []byte { + format := ctx.Option.ColorScheme.Uint + b = append(b, format.Header...) + b = encoder.AppendUint(ctx, b, v, code) + return append(b, format.Footer...) +} + +func appendFloat32(ctx *encoder.RuntimeContext, b []byte, v float32) []byte { + format := ctx.Option.ColorScheme.Float + b = append(b, format.Header...) + b = encoder.AppendFloat32(ctx, b, v) + return append(b, format.Footer...) +} + +func appendFloat64(ctx *encoder.RuntimeContext, b []byte, v float64) []byte { + format := ctx.Option.ColorScheme.Float + b = append(b, format.Header...) + b = encoder.AppendFloat64(ctx, b, v) + return append(b, format.Footer...) +} + +func appendString(ctx *encoder.RuntimeContext, b []byte, v string) []byte { + format := ctx.Option.ColorScheme.String + b = append(b, format.Header...) + b = encoder.AppendString(ctx, b, v) + return append(b, format.Footer...) +} + +func appendByteSlice(ctx *encoder.RuntimeContext, b []byte, src []byte) []byte { + format := ctx.Option.ColorScheme.Binary + b = append(b, format.Header...) + b = encoder.AppendByteSlice(ctx, b, src) + return append(b, format.Footer...) +} + +func appendNumber(ctx *encoder.RuntimeContext, b []byte, n json.Number) ([]byte, error) { + format := ctx.Option.ColorScheme.Int + b = append(b, format.Header...) + bb, err := encoder.AppendNumber(ctx, b, n) + if err != nil { + return nil, err + } + return append(bb, format.Footer...), nil +} + +func appendBool(ctx *encoder.RuntimeContext, b []byte, v bool) []byte { + format := ctx.Option.ColorScheme.Bool + b = append(b, format.Header...) if v { - return append(b, "true"...) + b = append(b, "true"...) + } else { + b = append(b, "false"...) } - return append(b, "false"...) + return append(b, format.Footer...) } -func appendNull(b []byte) []byte { - return append(b, "null"...) +func appendNull(ctx *encoder.RuntimeContext, b []byte) []byte { + format := ctx.Option.ColorScheme.Null + b = append(b, format.Header...) + b = append(b, "null"...) + return append(b, format.Footer...) } -func appendComma(b []byte) []byte { +func appendComma(_ *encoder.RuntimeContext, b []byte) []byte { return append(b, ',') } -func appendColon(b []byte) []byte { +func appendColon(_ *encoder.RuntimeContext, b []byte) []byte { last := len(b) - 1 b[last] = ':' return b } func appendMapKeyValue(_ *encoder.RuntimeContext, _ *encoder.Opcode, b, key, value []byte) []byte { - b = append(b, key...) - b[len(b)-1] = ':' + b = append(b, key[:len(key)-1]...) + b = append(b, ':') return append(b, value...) } func appendMapEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { - b[len(b)-1] = '}' + last := len(b) - 1 + b[last] = '}' b = append(b, ',') return b } -func appendInterface(ctx *encoder.RuntimeContext, codeSet *encoder.OpcodeSet, opt encoder.Option, _ *encoder.Opcode, b []byte, iface *emptyInterface, ptrOffset uintptr) ([]byte, error) { - ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(iface)) - ifaceCodeSet, err := encoder.CompileToGetCodeSet(uintptr(unsafe.Pointer(iface.typ))) - if err != nil { - return nil, err - } - - totalLength := uintptr(codeSet.CodeLength) - nextTotalLength := uintptr(ifaceCodeSet.CodeLength) - - curlen := uintptr(len(ctx.Ptrs)) - offsetNum := ptrOffset / uintptrSize - - newLen := offsetNum + totalLength + nextTotalLength - if curlen < newLen { - ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...) - } - oldPtrs := ctx.Ptrs - - newPtrs := ctx.Ptrs[(ptrOffset+totalLength*uintptrSize)/uintptrSize:] - newPtrs[0] = uintptr(iface.ptr) - - ctx.Ptrs = newPtrs +func appendMarshalJSON(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { + return encoder.AppendMarshalJSON(ctx, code, b, v) +} - bb, err := Run(ctx, b, ifaceCodeSet, opt) +func appendMarshalText(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { + format := ctx.Option.ColorScheme.String + b = append(b, format.Header...) + bb, err := encoder.AppendMarshalText(ctx, code, b, v) if err != nil { return nil, err } - - ctx.Ptrs = oldPtrs - return bb, nil -} - -func appendMarshalJSON(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { - return encoder.AppendMarshalJSON(ctx, code, b, v, true) -} - -func appendMarshalText(code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { - return encoder.AppendMarshalText(code, b, v, true) + return append(bb, format.Footer...), nil } func appendArrayHead(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { @@ -174,11 +209,11 @@ func appendArrayEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []by return append(b, ',') } -func appendEmptyArray(b []byte) []byte { +func appendEmptyArray(_ *encoder.RuntimeContext, b []byte) []byte { return append(b, '[', ']', ',') } -func appendEmptyObject(b []byte) []byte { +func appendEmptyObject(_ *encoder.RuntimeContext, b []byte) []byte { return append(b, '{', '}', ',') } @@ -188,12 +223,17 @@ func appendObjectEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []b return append(b, ',') } -func appendStructHead(b []byte) []byte { +func appendStructHead(_ *encoder.RuntimeContext, b []byte) []byte { return append(b, '{') } -func appendStructKey(_ *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { - return append(b, code.EscapedKey...) +func appendStructKey(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { + format := ctx.Option.ColorScheme.ObjectKey + b = append(b, format.Header...) + b = append(b, code.Key[:len(code.Key)-1]...) + b = append(b, format.Footer...) + + return append(b, ':') } func appendStructEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { @@ -204,7 +244,7 @@ func appendStructEndSkipLast(ctx *encoder.RuntimeContext, code *encoder.Opcode, last := len(b) - 1 if b[last] == ',' { b[last] = '}' - return appendComma(b) + return appendComma(ctx, b) } return appendStructEnd(ctx, code, b) } diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_escaped_indent/vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/vm.go index 2288602c9..73af8842e 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/vm_escaped_indent/vm.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/vm.go @@ -1,5 +1,5 @@ // Code generated by internal/cmd/generator. DO NOT EDIT! -package vm_escaped_indent +package vm_color import ( "math" @@ -7,13 +7,19 @@ import ( "unsafe" "github.com/goccy/go-json/internal/encoder" + "github.com/goccy/go-json/internal/runtime" ) -func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt encoder.Option) ([]byte, error) { +func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) { recursiveLevel := 0 ptrOffset := uintptr(0) ctxptr := ctx.Ptr() - code := codeSet.Code + var code *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + code = codeSet.EscapeKeyCode + } else { + code = codeSet.NoescapeKeyCode + } for { switch code.Op { @@ -26,62 +32,62 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpIntPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpInt: - b = appendInt(b, ptrToUint64(load(ctxptr, code.Idx)), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpUintPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpUint: - b = appendUint(b, ptrToUint64(load(ctxptr, code.Idx)), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpIntString: b = append(b, '"') - b = appendInt(b, ptrToUint64(load(ctxptr, code.Idx)), code) + b = appendInt(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpUintString: b = append(b, '"') - b = appendUint(b, ptrToUint64(load(ctxptr, code.Idx)), code) + b = appendUint(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpFloat32Ptr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpFloat32: - b = appendFloat32(b, ptrToFloat32(load(ctxptr, code.Idx))) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) code = code.Next case encoder.OpFloat64Ptr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -92,73 +98,73 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next case encoder.OpStringPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpString: - b = appendString(b, ptrToString(load(ctxptr, code.Idx))) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) code = code.Next case encoder.OpBoolPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpBool: - b = appendBool(b, ptrToBool(load(ctxptr, code.Idx))) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) code = code.Next case encoder.OpBytesPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpBytes: - b = appendByteSlice(b, ptrToBytes(load(ctxptr, code.Idx))) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) code = code.Next case encoder.OpNumberPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpNumber: - bb, err := appendNumber(b, ptrToNumber(load(ctxptr, code.Idx))) + bb, err := appendNumber(ctx, b, ptrToNumber(load(ctxptr, code.Idx))) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpInterfacePtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -167,38 +173,92 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpInterface: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } - for _, seen := range ctx.SeenPtr { - if p == seen { - return nil, errUnsupportedValue(code, p) + if recursiveLevel > encoder.StartDetectingCyclesAfter { + for _, seen := range ctx.SeenPtr { + if p == seen { + return nil, errUnsupportedValue(code, p) + } } } ctx.SeenPtr = append(ctx.SeenPtr, p) - iface := (*emptyInterface)(ptrToUnsafePtr(p)) - if iface.ptr == nil { - b = appendNull(b) - b = appendComma(b) + var ( + typ *runtime.Type + ifacePtr unsafe.Pointer + ) + up := ptrToUnsafePtr(p) + if code.Flags&encoder.NonEmptyInterfaceFlags != 0 { + iface := (*nonEmptyInterface)(up) + ifacePtr = iface.ptr + typ = iface.itab.typ + } else { + iface := (*emptyInterface)(up) + ifacePtr = iface.ptr + typ = iface.typ + } + if ifacePtr == nil { + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } - bb, err := appendInterface(ctx, codeSet, opt, code, b, iface, ptrOffset) + ctx.KeepRefs = append(ctx.KeepRefs, up) + ifaceCodeSet, err := encoder.CompileToGetCodeSet(uintptr(unsafe.Pointer(typ))) if err != nil { return nil, err } - ctxptr = ctx.Ptr() + + totalLength := uintptr(code.Length) + 3 + nextTotalLength := uintptr(ifaceCodeSet.CodeLength) + 3 + + var c *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + c = ifaceCodeSet.InterfaceEscapeKeyCode + } else { + c = ifaceCodeSet.InterfaceNoescapeKeyCode + } + curlen := uintptr(len(ctx.Ptrs)) + offsetNum := ptrOffset / uintptrSize + oldOffset := ptrOffset + ptrOffset += totalLength * uintptrSize + oldBaseIndent := ctx.BaseIndent + indentDiffFromTop := c.Indent - 1 + ctx.BaseIndent += code.Indent - indentDiffFromTop + + newLen := offsetNum + totalLength + nextTotalLength + if curlen < newLen { + ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...) + } + ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr + + end := ifaceCodeSet.EndCode + store(ctxptr, c.Idx, uintptr(ifacePtr)) + store(ctxptr, end.Idx, oldOffset) + store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next))) + storeIndent(ctxptr, end, uintptr(oldBaseIndent)) + code = c + recursiveLevel++ + case encoder.OpInterfaceEnd: + recursiveLevel-- + + // restore ctxptr + offset := load(ctxptr, code.Idx) + restoreIndent(ctx, code, ctxptr) ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1] - b = bb - code = code.Next + codePtr := load(ctxptr, code.ElemIdx) + code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr)) + ctxptr = ctx.Ptr() + offset + ptrOffset = offset case encoder.OpMarshalJSONPtr: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -207,25 +267,25 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpMarshalJSON: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } - if code.IsNilableType && code.Indirect { + if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 { p = ptrToPtr(p) } bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpMarshalTextPtr: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -235,24 +295,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt p := load(ctxptr, code.Idx) if p == 0 { b = append(b, `""`...) - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next break } - if code.IsNilableType && code.Indirect { + if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 { p = ptrToPtr(p) } - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpSlicePtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -262,8 +322,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt p := load(ctxptr, code.Idx) slice := ptrToSlice(p) if p == 0 || slice.Data == nil { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -275,7 +335,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next store(ctxptr, code.Idx, uintptr(slice.Data)) } else { - b = appendEmptyArray(b) + b = appendEmptyArray(ctx, b) code = code.End.Next } case encoder.OpSliceElem: @@ -285,8 +345,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if idx < length { b = appendArrayElemIndent(ctx, code, b) store(ctxptr, code.ElemIdx, idx) - data := load(ctxptr, code.HeadIdx) - size := code.Size + data := load(ctxptr, code.Idx) + size := uintptr(code.Size) code = code.Next store(ctxptr, code.Idx, data+idx*size) } else { @@ -296,8 +356,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpArrayPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -306,8 +366,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpArray: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -317,17 +377,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next store(ctxptr, code.Idx, p) } else { - b = appendEmptyArray(b) + b = appendEmptyArray(ctx, b) code = code.End.Next } case encoder.OpArrayElem: idx := load(ctxptr, code.ElemIdx) idx++ - if idx < code.Length { + if idx < uintptr(code.Length) { b = appendArrayElemIndent(ctx, code, b) store(ctxptr, code.ElemIdx, idx) - p := load(ctxptr, code.HeadIdx) - size := code.Size + p := load(ctxptr, code.Idx) + size := uintptr(code.Size) code = code.Next store(ctxptr, code.Idx, p+idx*size) } else { @@ -337,8 +397,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpMapPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -347,31 +407,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpMap: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } uptr := ptrToUnsafePtr(p) mlen := maplen(uptr) if mlen <= 0 { - b = appendEmptyObject(b) + b = appendEmptyObject(ctx, b) code = code.End.Next break } - b = appendStructHead(b) + b = appendStructHead(ctx, b) iter := mapiterinit(code.Type, uptr) ctx.KeepRefs = append(ctx.KeepRefs, iter) store(ctxptr, code.ElemIdx, 0) store(ctxptr, code.Length, uintptr(mlen)) store(ctxptr, code.MapIter, uintptr(iter)) - if (opt & encoder.UnorderedMapOption) == 0 { + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { + b = appendMapKeyIndent(ctx, code.Next, b) + } else { mapCtx := encoder.NewMapContext(mlen) mapCtx.Pos = append(mapCtx.Pos, len(b)) ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx)) store(ctxptr, code.End.MapPos, uintptr(unsafe.Pointer(mapCtx))) - } else { - b = appendMapKeyIndent(ctx, code.Next, b) } key := mapiterkey(iter) store(ctxptr, code.Next.Idx, uintptr(key)) @@ -380,7 +440,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt idx := load(ctxptr, code.ElemIdx) length := load(ctxptr, code.Length) idx++ - if (opt & encoder.UnorderedMapOption) != 0 { + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { if idx < length { b = appendMapKeyIndent(ctx, code, b) store(ctxptr, code.ElemIdx, idx) @@ -409,8 +469,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } } case encoder.OpMapValue: - if (opt & encoder.UnorderedMapOption) != 0 { - b = appendColon(b) + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { + b = appendColon(ctx, b) } else { ptr := load(ctxptr, code.End.MapPos) mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(ptr)) @@ -479,7 +539,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt oldOffset := ptrOffset ptrOffset += code.Jmp.CurLen * uintptrSize oldBaseIndent := ctx.BaseIndent - ctx.BaseIndent += code.Indent - 1 + indentDiffFromTop := c.Indent - 1 + ctx.BaseIndent += code.Indent - indentDiffFromTop newLen := offsetNum + code.Jmp.CurLen + code.Jmp.NextLen if curlen < newLen { @@ -490,7 +551,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt store(ctxptr, c.Idx, ptr) store(ctxptr, c.End.Next.Idx, oldOffset) store(ctxptr, c.End.Next.ElemIdx, uintptr(unsafe.Pointer(code.Next))) - storeIndent(ctxptr, c, uintptr(oldBaseIndent)) + storeIndent(ctxptr, c.End.Next, uintptr(oldBaseIndent)) code = c recursiveLevel++ case encoder.OpRecursiveEnd: @@ -508,9 +569,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHead: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -519,29 +580,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHead: p := load(ctxptr, code.Idx) - if p == 0 && (code.Indirect || code.Next.Op == encoder.OpStructEnd) { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if !code.AnonymousKey && len(code.Key) > 0 { - b = appendStructKey(ctx, code, b) + if len(code.Key) > 0 { + if (code.Flags&encoder.IsTaggedKeyFlags) != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 { + b = appendStructKey(ctx, code, b) + } } - p += code.Offset + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructPtrHeadOmitEmpty: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -550,19 +613,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmpty: p := load(ctxptr, code.Idx) - if p == 0 && (code.Indirect || code.Next.Op == encoder.OpStructEnd) { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - p += code.Offset - if p == 0 || (ptrToPtr(p) == 0 && code.IsNextOpPtrType) { + p += uintptr(code.Offset) + if p == 0 || (ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0) { code = code.NextField } else { b = appendStructKey(ctx, code, b) @@ -570,12 +633,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt store(ctxptr, code.Idx, p) } case encoder.OpStructPtrHeadInt: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -586,27 +649,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadInt: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p+code.Offset), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyInt: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -617,33 +680,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyInt: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendInt(b, u64, code) - b = appendComma(b) + b = appendInt(ctx, b, u64, code) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadIntString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -654,29 +717,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadIntString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p+code.Offset), code) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyIntString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -687,34 +750,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyIntString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, u64, code) + b = appendInt(ctx, b, u64, code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadIntPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -723,34 +786,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadIntPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyIntPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -759,32 +822,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyIntPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(p), code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadIntPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -793,36 +856,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadIntPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyIntPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -831,35 +894,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyIntPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadUint: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -870,27 +933,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadUint: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p+code.Offset), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyUint: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -901,33 +964,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyUint: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendUint(b, u64, code) - b = appendComma(b) + b = appendUint(ctx, b, u64, code) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadUintString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -938,29 +1001,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadUintString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p+code.Offset), code) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyUintString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -971,34 +1034,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyUintString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, u64, code) + b = appendUint(ctx, b, u64, code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadUintPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1007,34 +1070,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadUintPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyUintPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1043,32 +1106,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyUintPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(p), code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadUintPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1077,36 +1140,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadUintPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyUintPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1115,35 +1178,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyUintPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadFloat32: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1154,27 +1217,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadFloat32: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat32: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1185,32 +1248,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyFloat32: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat32(p + code.Offset) + v := ptrToFloat32(p + uintptr(code.Offset)) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, v) - b = appendComma(b) + b = appendFloat32(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadFloat32String: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1221,29 +1284,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadFloat32String: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat32String: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1254,33 +1317,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyFloat32String: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat32(p + code.Offset) + v := ptrToFloat32(p + uintptr(code.Offset)) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, v) + b = appendFloat32(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadFloat32Ptr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1289,34 +1352,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadFloat32Ptr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat32Ptr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1325,32 +1388,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyFloat32Ptr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p)) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadFloat32PtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1359,36 +1422,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadFloat32PtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat32PtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1397,35 +1460,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyFloat32PtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadFloat64: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1436,31 +1499,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadFloat64: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat64: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1471,17 +1534,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyFloat64: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if v == 0 { code = code.NextField } else { @@ -1489,17 +1552,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadFloat64String: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1510,33 +1573,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadFloat64String: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat64String: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1547,17 +1610,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyFloat64String: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if v == 0 { code = code.NextField } else { @@ -1566,17 +1629,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadFloat64Ptr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1585,38 +1648,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadFloat64Ptr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat64Ptr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1625,19 +1688,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyFloat64Ptr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) @@ -1645,16 +1708,16 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadFloat64PtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1663,40 +1726,40 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadFloat64PtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat64PtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1705,19 +1768,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyFloat64PtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) @@ -1726,18 +1789,18 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1748,27 +1811,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p+code.Offset)) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1779,32 +1842,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToString(p + code.Offset) + v := ptrToString(p + uintptr(code.Offset)) if v == "" { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendString(b, v) - b = appendComma(b) + b = appendString(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadStringString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1815,27 +1878,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadStringString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, ptrToString(p+code.Offset)))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p+uintptr(code.Offset))))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyStringString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1846,31 +1909,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyStringString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToString(p + code.Offset) + v := ptrToString(p + uintptr(code.Offset)) if v == "" { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, v))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadStringPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1879,34 +1942,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadStringPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, ptrToString(p)) + b = appendString(ctx, b, ptrToString(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyStringPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1915,32 +1978,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyStringPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p)) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadStringPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1949,34 +2012,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadStringPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyStringPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1985,33 +2048,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyStringPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadBool: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2022,27 +2085,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadBool: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p+code.Offset)) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBool: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2053,32 +2116,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyBool: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToBool(p + code.Offset) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) - b = appendBool(b, v) - b = appendComma(b) + b = appendBool(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } else { code = code.NextField } case encoder.OpStructPtrHeadBoolString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2089,29 +2152,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadBoolString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p+code.Offset)) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBoolString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2122,23 +2185,23 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyBoolString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToBool(p + code.Offset) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, v) + b = appendBool(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } else { code = code.NextField @@ -2146,9 +2209,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadBoolPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2157,34 +2220,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadBoolPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBoolPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2193,32 +2256,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyBoolPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p)) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadBoolPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2227,36 +2290,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadBoolPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBoolPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2265,35 +2328,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyBoolPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadBytes: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2304,27 +2367,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadBytes: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p+code.Offset)) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBytes: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2335,31 +2398,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyBytes: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToBytes(p + code.Offset) + v := ptrToBytes(p + uintptr(code.Offset)) if len(v) == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, v) - b = appendComma(b) + b = appendByteSlice(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadBytesPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2368,34 +2431,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadBytesPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendByteSlice(b, ptrToBytes(p)) + b = appendByteSlice(ctx, b, ptrToBytes(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBytesPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2404,33 +2467,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyBytesPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p)) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadNumber: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2441,30 +2504,30 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadNumber: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpStructPtrHeadOmitEmptyNumber: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2475,35 +2538,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyNumber: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToNumber(p + code.Offset) + v := ptrToNumber(p + uintptr(code.Offset)) if v == "" { code = code.NextField } else { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next } case encoder.OpStructPtrHeadNumberString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2514,32 +2577,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadNumberString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyNumberString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2550,36 +2613,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyNumberString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToNumber(p + code.Offset) + v := ptrToNumber(p + uintptr(code.Offset)) if v == "" { code = code.NextField } else { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadNumberPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2588,38 +2651,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadNumberPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyNumberPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2628,35 +2691,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyNumberPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructPtrHeadNumberPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2665,39 +2728,39 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadNumberPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = append(bb, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyNumberPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2706,38 +2769,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyNumberPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadArray, encoder.OpStructPtrHeadSlice: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2748,27 +2811,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadArray, encoder.OpStructHeadSlice: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - p += code.Offset + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructPtrHeadOmitEmptyArray: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2779,27 +2842,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyArray: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - p += code.Offset + p += uintptr(code.Offset) b = appendStructKey(ctx, code, b) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructPtrHeadOmitEmptySlice: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2810,17 +2873,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptySlice: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - p += code.Offset + p += uintptr(code.Offset) slice := ptrToSlice(p) if slice.Len == 0 { code = code.NextField @@ -2832,9 +2895,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadArrayPtr, encoder.OpStructPtrHeadSlicePtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2843,24 +2906,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadArrayPtr, encoder.OpStructHeadSlicePtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.NextField } else { code = code.Next @@ -2869,9 +2932,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadOmitEmptyArrayPtr, encoder.OpStructPtrHeadOmitEmptySlicePtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2880,19 +2943,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyArrayPtr, encoder.OpStructHeadOmitEmptySlicePtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { code = code.NextField @@ -2904,9 +2967,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadMap: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2915,29 +2978,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadMap: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if p != 0 && code.Indirect { - p = ptrToPtr(p + code.Offset) + if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p + uintptr(code.Offset)) } code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructPtrHeadOmitEmptyMap: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2946,19 +3009,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyMap: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if p != 0 && code.Indirect { - p = ptrToPtr(p + code.Offset) + if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p + uintptr(code.Offset)) } if maplen(ptrToUnsafePtr(p)) == 0 { code = code.NextField @@ -2970,9 +3033,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadMapPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2981,31 +3044,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadMapPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.NextField break } - p = ptrToPtr(p + code.Offset) + p = ptrToPtr(p + uintptr(code.Offset)) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.NextField } else { - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p = ptrToNPtr(p, code.PtrNum) } code = code.Next @@ -3014,9 +3077,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadOmitEmptyMapPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3025,26 +3088,26 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyMapPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } if p == 0 { code = code.NextField break } - p = ptrToPtr(p + code.Offset) + p = ptrToPtr(p + uintptr(code.Offset)) if p == 0 { code = code.NextField } else { - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p = ptrToNPtr(p, code.PtrNum) } b = appendStructKey(ctx, code, b) @@ -3054,38 +3117,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadMarshalJSON: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) } fallthrough case encoder.OpStructHeadMarshalJSON: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.IsNilableType { - if code.Indirect || code.Op == encoder.OpStructPtrHeadMarshalJSON { - p = ptrToPtr(p + code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalJSON { + p = ptrToPtr(p + uintptr(code.Offset)) } } - if p == 0 && code.Nilcheck { - b = appendNull(b) + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) } else { bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { @@ -3093,42 +3156,42 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyMarshalJSON: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) } fallthrough case encoder.OpStructHeadOmitEmptyMarshalJSON: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.IsNilableType { - if code.Indirect || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON { - p = ptrToPtr(p + code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON { + p = ptrToPtr(p + uintptr(code.Offset)) } } iface := ptrToInterface(code, p) - if code.Nilcheck && encoder.IsNilForMarshaler(iface) { + if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) { code = code.NextField } else { b = appendStructKey(ctx, code, b) @@ -3137,15 +3200,15 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt return nil, err } b = bb - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadMarshalJSONPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3154,23 +3217,23 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadMarshalJSONPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { @@ -3178,14 +3241,14 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyMarshalJSONPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3194,19 +3257,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyMarshalJSONPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } if p == 0 { code = code.NextField @@ -3217,103 +3280,103 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt return nil, err } b = bb - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadMarshalText: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) } fallthrough case encoder.OpStructHeadMarshalText: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.IsNilableType { - if code.Indirect || code.Op == encoder.OpStructPtrHeadMarshalText { - p = ptrToPtr(p + code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalText { + p = ptrToPtr(p + uintptr(code.Offset)) } } - if p == 0 && code.Nilcheck { - b = appendNull(b) + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) } else { - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyMarshalText: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) } fallthrough case encoder.OpStructHeadOmitEmptyMarshalText: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.IsNilableType { - if code.Indirect || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText { - p = ptrToPtr(p + code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText { + p = ptrToPtr(p + uintptr(code.Offset)) } } - if p == 0 && code.Nilcheck { + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadMarshalTextPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3322,38 +3385,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadMarshalTextPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyMarshalTextPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3362,43 +3425,43 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyMarshalTextPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } if p == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructField: - if !code.AnonymousKey { + if code.Flags&encoder.IsTaggedKeyFlags != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 { b = appendStructKey(ctx, code, b) } - p := load(ctxptr, code.HeadIdx) + code.Offset + p := load(ctxptr, code.Idx) + uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmpty: - p := load(ctxptr, code.HeadIdx) - p += code.Offset - if ptrToPtr(p) == 0 && code.IsNextOpPtrType { + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) @@ -3406,298 +3469,298 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt store(ctxptr, code.Idx, p) } case encoder.OpStructFieldInt: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p+code.Offset), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyInt: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, u64, code) - b = appendComma(b) + b = appendInt(ctx, b, u64, code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldIntString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p+code.Offset), code) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyIntString: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, u64, code) + b = appendInt(ctx, b, u64, code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldIntPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyIntPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(p), code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldIntPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyIntPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldUint: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p+code.Offset), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyUint: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, u64, code) - b = appendComma(b) + b = appendUint(ctx, b, u64, code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldUintString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p+code.Offset), code) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyUintString: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, u64, code) + b = appendUint(ctx, b, u64, code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldUintPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyUintPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(p), code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldUintPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyUintPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat32: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat32: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat32(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, v) - b = appendComma(b) + b = appendFloat32(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat32String: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat32String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat32(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, v) + b = appendFloat32(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat32Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat32Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p)) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat32PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat32PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat64: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat64: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if v != 0 { if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat64String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat64String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if v != 0 { if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat64Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -3705,42 +3768,42 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat64Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat64PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat64PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') @@ -3748,307 +3811,307 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p+code.Offset)) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyString: - p := load(ctxptr, code.HeadIdx) - v := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - b = appendString(b, v) - b = appendComma(b) + b = appendString(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldStringString: - p := load(ctxptr, code.HeadIdx) - s := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + s := ptrToString(p + uintptr(code.Offset)) b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, s))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, s))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyStringString: - p := load(ctxptr, code.HeadIdx) - v := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, v))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldStringPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, ptrToString(p)) + b = appendString(ctx, b, ptrToString(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyStringPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p)) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldStringPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyStringPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBool: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p+code.Offset)) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBool: - p := load(ctxptr, code.HeadIdx) - v := ptrToBool(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) - b = appendBool(b, v) - b = appendComma(b) + b = appendBool(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBoolString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p+code.Offset)) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBoolString: - p := load(ctxptr, code.HeadIdx) - v := ptrToBool(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, v) + b = appendBool(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBoolPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBoolPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p)) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBoolPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBoolPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBytes: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p+code.Offset)) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBytes: - p := load(ctxptr, code.HeadIdx) - v := ptrToBytes(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBytes(p + uintptr(code.Offset)) if len(v) > 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, v) - b = appendComma(b) + b = appendByteSlice(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBytesPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendByteSlice(b, ptrToBytes(p)) + b = appendByteSlice(ctx, b, ptrToBytes(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBytesPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p)) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldNumber: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpStructFieldOmitEmptyNumber: - p := load(ctxptr, code.HeadIdx) - v := ptrToNumber(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructFieldNumberString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyNumberString: - p := load(ctxptr, code.HeadIdx) - v := ptrToNumber(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldNumberPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyNumberPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructFieldNumberPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = append(bb, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyNumberPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldMarshalJSON: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - p += code.Offset - if code.IsNilableType { + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { p = ptrToPtr(p) } - if p == 0 && code.Nilcheck { - b = appendNull(b) + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) } else { bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { @@ -4056,20 +4119,20 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyMarshalJSON: - p := load(ctxptr, code.HeadIdx) - p += code.Offset - if code.IsNilableType { + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { p = ptrToPtr(p) } - if p == 0 && code.Nilcheck { + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { code = code.NextField break } iface := ptrToInterface(code, p) - if code.Nilcheck && encoder.IsNilForMarshaler(iface) { + if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) { code = code.NextField break } @@ -4078,14 +4141,14 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpStructFieldMarshalJSONPtr: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { @@ -4093,103 +4156,103 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyMarshalJSONPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructFieldMarshalText: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - p += code.Offset - if code.IsNilableType { + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { p = ptrToPtr(p) } - if p == 0 && code.Nilcheck { - b = appendNull(b) + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) } else { - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyMarshalText: - p := load(ctxptr, code.HeadIdx) - p += code.Offset - if code.IsNilableType { + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { p = ptrToPtr(p) } - if p == 0 && code.Nilcheck { + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { code = code.NextField break } b = appendStructKey(ctx, code, b) - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpStructFieldMarshalTextPtr: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyMarshalTextPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructFieldArray: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyArray: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldArrayPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyArrayPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) code = code.Next @@ -4199,13 +4262,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldSlice: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptySlice: - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) slice := ptrToSlice(p) if slice.Len == 0 { code = code.NextField @@ -4216,13 +4279,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldSlicePtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptySlicePtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) code = code.Next @@ -4232,13 +4295,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldMap: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToPtr(p + code.Offset) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyMap: - p := load(ctxptr, code.HeadIdx) - p = ptrToPtr(p + code.Offset) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) if p == 0 || maplen(ptrToUnsafePtr(p)) == 0 { code = code.NextField } else { @@ -4248,16 +4311,16 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldMapPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToPtr(p + code.Offset) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) if p != 0 { p = ptrToNPtr(p, code.PtrNum) } code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyMapPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToPtr(p + code.Offset) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) if p != 0 { p = ptrToNPtr(p, code.PtrNum) } @@ -4270,14 +4333,14 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldStruct: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyStruct: - p := load(ctxptr, code.HeadIdx) - p += code.Offset - if ptrToPtr(p) == 0 && code.IsNextOpPtrType { + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) @@ -4290,39 +4353,39 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt b = appendStructEndSkipLast(ctx, code, b) code = code.Next case encoder.OpStructEndInt: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p+code.Offset), code) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyInt: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, u64, code) + b = appendInt(ctx, b, u64, code) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndIntString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p+code.Offset), code) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyIntString: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, u64, code) + b = appendInt(ctx, b, u64, code) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4331,21 +4394,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndIntPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyIntPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4353,24 +4416,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndIntPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyIntPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4378,39 +4441,39 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndUint: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p+code.Offset), code) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyUint: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, u64, code) + b = appendUint(ctx, b, u64, code) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndUintString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p+code.Offset), code) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyUintString: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, u64, code) + b = appendUint(ctx, b, u64, code) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4419,21 +4482,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndUintPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyUintPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4441,24 +4504,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndUintPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyUintPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4466,37 +4529,37 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndFloat32: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat32: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat32(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, v) + b = appendFloat32(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndFloat32String: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat32String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat32(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, v) + b = appendFloat32(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4505,21 +4568,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndFloat32Ptr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat32Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4527,24 +4590,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndFloat32PtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat32PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4552,51 +4615,51 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndFloat64: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat64: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if v != 0 { if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndFloat64String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat64String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if v != 0 { if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4605,10 +4668,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndFloat64Ptr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) b = appendStructEnd(ctx, code, b) code = code.Next break @@ -4617,19 +4680,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat64Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4637,24 +4700,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndFloat64PtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat64PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) v := ptrToFloat64(p) @@ -4662,7 +4725,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt return nil, errUnsupportedFloat(v) } b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4670,35 +4733,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p+code.Offset)) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyString: - p := load(ctxptr, code.HeadIdx) - v := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - b = appendString(b, v) + b = appendString(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndStringString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - s := ptrToString(p + code.Offset) - b = appendString(b, string(appendString([]byte{}, s))) + s := ptrToString(p + uintptr(code.Offset)) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, s))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyStringString: - p := load(ctxptr, code.HeadIdx) - v := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, v))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4706,21 +4769,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndStringPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, ptrToString(p)) + b = appendString(ctx, b, ptrToString(p)) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyStringPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p)) + b = appendString(ctx, b, ptrToString(p)) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4728,58 +4791,58 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndStringPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyStringPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndBool: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p+code.Offset)) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBool: - p := load(ctxptr, code.HeadIdx) - v := ptrToBool(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) - b = appendBool(b, v) + b = appendBool(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndBoolString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p+code.Offset)) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBoolString: - p := load(ctxptr, code.HeadIdx) - v := ptrToBool(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, v) + b = appendBool(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4788,21 +4851,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndBoolPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBoolPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4810,24 +4873,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndBoolPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBoolPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4835,17 +4898,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndBytes: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p+code.Offset)) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBytes: - p := load(ctxptr, code.HeadIdx) - v := ptrToBytes(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBytes(p + uintptr(code.Offset)) if len(v) > 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, v) + b = appendByteSlice(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4853,41 +4916,41 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndBytesPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendByteSlice(b, ptrToBytes(p)) + b = appendByteSlice(ctx, b, ptrToBytes(p)) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBytesPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p)) + b = appendByteSlice(ctx, b, ptrToBytes(p)) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndNumber: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } b = appendStructEnd(ctx, code, bb) code = code.Next case encoder.OpStructEndOmitEmptyNumber: - p := load(ctxptr, code.HeadIdx) - v := ptrToNumber(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } @@ -4897,10 +4960,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndNumberString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } @@ -4908,12 +4971,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyNumberString: - p := load(ctxptr, code.HeadIdx) - v := ptrToNumber(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } @@ -4925,12 +4988,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndNumberPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } @@ -4939,11 +5002,11 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyNumberPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } @@ -4954,13 +5017,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndNumberPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } @@ -4969,12 +5032,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyNumberPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_escaped_indent/debug_vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/debug_vm.go index 970ab47fa..a68bbf6bf 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/vm_escaped_indent/debug_vm.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/debug_vm.go @@ -1,4 +1,4 @@ -package vm_escaped_indent +package vm_color_indent import ( "fmt" @@ -6,7 +6,14 @@ import ( "github.com/goccy/go-json/internal/encoder" ) -func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt encoder.Option) ([]byte, error) { +func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) { + var code *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + code = codeSet.EscapeKeyCode + } else { + code = codeSet.NoescapeKeyCode + } + defer func() { if err := recover(); err != nil { fmt.Println("=============[DEBUG]===============") @@ -14,7 +21,7 @@ func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, fmt.Println(codeSet.Type) fmt.Printf("\n") fmt.Println("* [ALL OPCODE]") - fmt.Println(codeSet.Code.Dump()) + fmt.Println(code.Dump()) fmt.Printf("\n") fmt.Println("* [CONTEXT]") fmt.Printf("%+v\n", ctx) @@ -23,5 +30,5 @@ func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, } }() - return Run(ctx, b, codeSet, opt) + return Run(ctx, b, codeSet) } diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_escaped_indent/util.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/util.go index 60d73e090..1399a25b6 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/vm_escaped_indent/util.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/util.go @@ -1,4 +1,4 @@ -package vm_escaped_indent +package vm_color_indent import ( "encoding/json" @@ -12,15 +12,8 @@ import ( const uintptrSize = 4 << (^uintptr(0) >> 63) var ( - appendInt = encoder.AppendInt - appendUint = encoder.AppendUint - appendFloat32 = encoder.AppendFloat32 - appendFloat64 = encoder.AppendFloat64 - appendString = encoder.AppendString - appendByteSlice = encoder.AppendByteSlice - appendNumber = encoder.AppendNumber - appendStructEnd = encoder.AppendStructEndIndent appendIndent = encoder.AppendIndent + appendStructEnd = encoder.AppendStructEndIndent errUnsupportedValue = encoder.ErrUnsupportedValue errUnsupportedFloat = encoder.ErrUnsupportedFloat mapiterinit = encoder.MapIterInit @@ -35,24 +28,33 @@ type emptyInterface struct { ptr unsafe.Pointer } +type nonEmptyInterface struct { + itab *struct { + ityp *runtime.Type // static interface type + typ *runtime.Type // dynamic concrete type + // unused fields... + } + ptr unsafe.Pointer +} + func errUnimplementedOp(op encoder.OpType) error { - return fmt.Errorf("encoder (indent+escaped): opcode %s has not been implemented", op) + return fmt.Errorf("encoder (indent): opcode %s has not been implemented", op) } -func load(base uintptr, idx uintptr) uintptr { - addr := base + idx +func load(base uintptr, idx uint32) uintptr { + addr := base + uintptr(idx) return **(**uintptr)(unsafe.Pointer(&addr)) } -func store(base uintptr, idx uintptr, p uintptr) { - addr := base + idx +func store(base uintptr, idx uint32, p uintptr) { + addr := base + uintptr(idx) **(**uintptr)(unsafe.Pointer(&addr)) = p } -func loadNPtr(base uintptr, idx uintptr, ptrNum int) uintptr { - addr := base + idx +func loadNPtr(base uintptr, idx uint32, ptrNum uint8) uintptr { + addr := base + uintptr(idx) p := **(**uintptr)(unsafe.Pointer(&addr)) - for i := 0; i < ptrNum; i++ { + for i := uint8(0); i < ptrNum; i++ { if p == 0 { return 0 } @@ -72,8 +74,8 @@ func ptrToSlice(p uintptr) *runtime.SliceHeader { return *(**runtime.SliceHeader 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++ { +func ptrToNPtr(p uintptr, ptrNum uint8) uintptr { + for i := uint8(0); i < ptrNum; i++ { if p == 0 { return 0 } @@ -92,60 +94,82 @@ func ptrToInterface(code *encoder.Opcode, p uintptr) interface{} { })) } -func appendBool(b []byte, v bool) []byte { - if v { - return append(b, "true"...) - } - return append(b, "false"...) +func appendInt(ctx *encoder.RuntimeContext, b []byte, v uint64, code *encoder.Opcode) []byte { + format := ctx.Option.ColorScheme.Int + b = append(b, format.Header...) + b = encoder.AppendInt(ctx, b, v, code) + return append(b, format.Footer...) } -func appendNull(b []byte) []byte { - return append(b, "null"...) +func appendUint(ctx *encoder.RuntimeContext, b []byte, v uint64, code *encoder.Opcode) []byte { + format := ctx.Option.ColorScheme.Uint + b = append(b, format.Header...) + b = encoder.AppendUint(ctx, b, v, code) + return append(b, format.Footer...) } -func appendComma(b []byte) []byte { - return append(b, ',', '\n') +func appendFloat32(ctx *encoder.RuntimeContext, b []byte, v float32) []byte { + format := ctx.Option.ColorScheme.Float + b = append(b, format.Header...) + b = encoder.AppendFloat32(ctx, b, v) + return append(b, format.Footer...) } -func appendColon(b []byte) []byte { - return append(b, ':', ' ') +func appendFloat64(ctx *encoder.RuntimeContext, b []byte, v float64) []byte { + format := ctx.Option.ColorScheme.Float + b = append(b, format.Header...) + b = encoder.AppendFloat64(ctx, b, v) + return append(b, format.Footer...) +} + +func appendString(ctx *encoder.RuntimeContext, b []byte, v string) []byte { + format := ctx.Option.ColorScheme.String + b = append(b, format.Header...) + b = encoder.AppendString(ctx, b, v) + return append(b, format.Footer...) +} + +func appendByteSlice(ctx *encoder.RuntimeContext, b []byte, src []byte) []byte { + format := ctx.Option.ColorScheme.Binary + b = append(b, format.Header...) + b = encoder.AppendByteSlice(ctx, b, src) + return append(b, format.Footer...) } -func appendInterface(ctx *encoder.RuntimeContext, codeSet *encoder.OpcodeSet, opt encoder.Option, code *encoder.Opcode, b []byte, iface *emptyInterface, ptrOffset uintptr) ([]byte, error) { - ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(iface)) - ifaceCodeSet, err := encoder.CompileToGetCodeSet(uintptr(unsafe.Pointer(iface.typ))) +func appendNumber(ctx *encoder.RuntimeContext, b []byte, n json.Number) ([]byte, error) { + format := ctx.Option.ColorScheme.Int + b = append(b, format.Header...) + bb, err := encoder.AppendNumber(ctx, b, n) if err != nil { return nil, err } + return append(bb, format.Footer...), nil +} - totalLength := uintptr(codeSet.CodeLength) - nextTotalLength := uintptr(ifaceCodeSet.CodeLength) - - curlen := uintptr(len(ctx.Ptrs)) - offsetNum := ptrOffset / uintptrSize - - newLen := offsetNum + totalLength + nextTotalLength - if curlen < newLen { - ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...) +func appendBool(ctx *encoder.RuntimeContext, b []byte, v bool) []byte { + format := ctx.Option.ColorScheme.Bool + b = append(b, format.Header...) + if v { + b = append(b, "true"...) + } else { + b = append(b, "false"...) } - oldPtrs := ctx.Ptrs - - newPtrs := ctx.Ptrs[(ptrOffset+totalLength*uintptrSize)/uintptrSize:] - newPtrs[0] = uintptr(iface.ptr) - - ctx.Ptrs = newPtrs + return append(b, format.Footer...) +} - oldBaseIndent := ctx.BaseIndent - ctx.BaseIndent = code.Indent - bb, err := Run(ctx, b, ifaceCodeSet, opt) - if err != nil { - return nil, err - } - ctx.BaseIndent = oldBaseIndent +func appendNull(ctx *encoder.RuntimeContext, b []byte) []byte { + format := ctx.Option.ColorScheme.Null + b = append(b, format.Header...) + b = append(b, "null"...) + return append(b, format.Footer...) +} - ctx.Ptrs = oldPtrs +func appendComma(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, ',', '\n') +} - return bb, nil +func appendColon(_ *encoder.RuntimeContext, b []byte) []byte { + return append(b, ':', ' ') } func appendMapKeyValue(ctx *encoder.RuntimeContext, code *encoder.Opcode, b, key, value []byte) []byte { @@ -175,11 +199,11 @@ func appendArrayEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) return append(b, ']', ',', '\n') } -func appendEmptyArray(b []byte) []byte { +func appendEmptyArray(_ *encoder.RuntimeContext, b []byte) []byte { return append(b, '[', ']', ',', '\n') } -func appendEmptyObject(b []byte) []byte { +func appendEmptyObject(_ *encoder.RuntimeContext, b []byte) []byte { return append(b, '{', '}', ',', '\n') } @@ -191,21 +215,32 @@ func appendObjectEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte } func appendMarshalJSON(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { - return encoder.AppendMarshalJSONIndent(ctx, code, b, v, true) + return encoder.AppendMarshalJSONIndent(ctx, code, b, v) } -func appendMarshalText(code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { - return encoder.AppendMarshalTextIndent(code, b, v, true) +func appendMarshalText(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { + format := ctx.Option.ColorScheme.String + b = append(b, format.Header...) + bb, err := encoder.AppendMarshalTextIndent(ctx, code, b, v) + if err != nil { + return nil, err + } + return append(bb, format.Footer...), nil } -func appendStructHead(b []byte) []byte { +func appendStructHead(_ *encoder.RuntimeContext, 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.EscapedKey...) - return append(b, ' ') + + format := ctx.Option.ColorScheme.ObjectKey + b = append(b, format.Header...) + b = append(b, code.Key[:len(code.Key)-1]...) + b = append(b, format.Footer...) + + return append(b, ':', ' ') } func appendStructEndSkipLast(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { @@ -221,15 +256,15 @@ func appendStructEndSkipLast(ctx *encoder.RuntimeContext, code *encoder.Opcode, b = appendIndent(ctx, b, code.Indent-1) b = append(b, '}') } - return appendComma(b) + return appendComma(ctx, b) } func restoreIndent(ctx *encoder.RuntimeContext, code *encoder.Opcode, ctxptr uintptr) { - ctx.BaseIndent = int(load(ctxptr, code.Length)) + ctx.BaseIndent = uint32(load(ctxptr, code.Length)) } func storeIndent(ctxptr uintptr, code *encoder.Opcode, indent uintptr) { - store(ctxptr, code.End.Next.Length, indent) + store(ctxptr, code.Length, indent) } func appendArrayElemIndent(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_escaped/vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/vm.go index 03d5b4e95..7b7844ec5 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/vm_escaped/vm.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/vm.go @@ -1,5 +1,5 @@ // Code generated by internal/cmd/generator. DO NOT EDIT! -package vm_escaped +package vm_color_indent import ( "math" @@ -7,13 +7,19 @@ import ( "unsafe" "github.com/goccy/go-json/internal/encoder" + "github.com/goccy/go-json/internal/runtime" ) -func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt encoder.Option) ([]byte, error) { +func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) { recursiveLevel := 0 ptrOffset := uintptr(0) ctxptr := ctx.Ptr() - code := codeSet.Code + var code *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + code = codeSet.EscapeKeyCode + } else { + code = codeSet.NoescapeKeyCode + } for { switch code.Op { @@ -26,62 +32,62 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpIntPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpInt: - b = appendInt(b, ptrToUint64(load(ctxptr, code.Idx)), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpUintPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpUint: - b = appendUint(b, ptrToUint64(load(ctxptr, code.Idx)), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpIntString: b = append(b, '"') - b = appendInt(b, ptrToUint64(load(ctxptr, code.Idx)), code) + b = appendInt(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpUintString: b = append(b, '"') - b = appendUint(b, ptrToUint64(load(ctxptr, code.Idx)), code) + b = appendUint(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpFloat32Ptr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpFloat32: - b = appendFloat32(b, ptrToFloat32(load(ctxptr, code.Idx))) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) code = code.Next case encoder.OpFloat64Ptr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -92,73 +98,73 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next case encoder.OpStringPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpString: - b = appendString(b, ptrToString(load(ctxptr, code.Idx))) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) code = code.Next case encoder.OpBoolPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpBool: - b = appendBool(b, ptrToBool(load(ctxptr, code.Idx))) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) code = code.Next case encoder.OpBytesPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpBytes: - b = appendByteSlice(b, ptrToBytes(load(ctxptr, code.Idx))) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) code = code.Next case encoder.OpNumberPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpNumber: - bb, err := appendNumber(b, ptrToNumber(load(ctxptr, code.Idx))) + bb, err := appendNumber(ctx, b, ptrToNumber(load(ctxptr, code.Idx))) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpInterfacePtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -167,38 +173,92 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpInterface: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } - for _, seen := range ctx.SeenPtr { - if p == seen { - return nil, errUnsupportedValue(code, p) + if recursiveLevel > encoder.StartDetectingCyclesAfter { + for _, seen := range ctx.SeenPtr { + if p == seen { + return nil, errUnsupportedValue(code, p) + } } } ctx.SeenPtr = append(ctx.SeenPtr, p) - iface := (*emptyInterface)(ptrToUnsafePtr(p)) - if iface.ptr == nil { - b = appendNull(b) - b = appendComma(b) + var ( + typ *runtime.Type + ifacePtr unsafe.Pointer + ) + up := ptrToUnsafePtr(p) + if code.Flags&encoder.NonEmptyInterfaceFlags != 0 { + iface := (*nonEmptyInterface)(up) + ifacePtr = iface.ptr + typ = iface.itab.typ + } else { + iface := (*emptyInterface)(up) + ifacePtr = iface.ptr + typ = iface.typ + } + if ifacePtr == nil { + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } - bb, err := appendInterface(ctx, codeSet, opt, code, b, iface, ptrOffset) + ctx.KeepRefs = append(ctx.KeepRefs, up) + ifaceCodeSet, err := encoder.CompileToGetCodeSet(uintptr(unsafe.Pointer(typ))) if err != nil { return nil, err } - ctxptr = ctx.Ptr() + + totalLength := uintptr(code.Length) + 3 + nextTotalLength := uintptr(ifaceCodeSet.CodeLength) + 3 + + var c *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + c = ifaceCodeSet.InterfaceEscapeKeyCode + } else { + c = ifaceCodeSet.InterfaceNoescapeKeyCode + } + curlen := uintptr(len(ctx.Ptrs)) + offsetNum := ptrOffset / uintptrSize + oldOffset := ptrOffset + ptrOffset += totalLength * uintptrSize + oldBaseIndent := ctx.BaseIndent + indentDiffFromTop := c.Indent - 1 + ctx.BaseIndent += code.Indent - indentDiffFromTop + + newLen := offsetNum + totalLength + nextTotalLength + if curlen < newLen { + ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...) + } + ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr + + end := ifaceCodeSet.EndCode + store(ctxptr, c.Idx, uintptr(ifacePtr)) + store(ctxptr, end.Idx, oldOffset) + store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next))) + storeIndent(ctxptr, end, uintptr(oldBaseIndent)) + code = c + recursiveLevel++ + case encoder.OpInterfaceEnd: + recursiveLevel-- + + // restore ctxptr + offset := load(ctxptr, code.Idx) + restoreIndent(ctx, code, ctxptr) ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1] - b = bb - code = code.Next + codePtr := load(ctxptr, code.ElemIdx) + code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr)) + ctxptr = ctx.Ptr() + offset + ptrOffset = offset case encoder.OpMarshalJSONPtr: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -207,25 +267,25 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpMarshalJSON: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } - if code.IsNilableType && code.Indirect { + if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 { p = ptrToPtr(p) } bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpMarshalTextPtr: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -235,24 +295,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt p := load(ctxptr, code.Idx) if p == 0 { b = append(b, `""`...) - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next break } - if code.IsNilableType && code.Indirect { + if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 { p = ptrToPtr(p) } - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpSlicePtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -262,8 +322,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt p := load(ctxptr, code.Idx) slice := ptrToSlice(p) if p == 0 || slice.Data == nil { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -275,7 +335,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next store(ctxptr, code.Idx, uintptr(slice.Data)) } else { - b = appendEmptyArray(b) + b = appendEmptyArray(ctx, b) code = code.End.Next } case encoder.OpSliceElem: @@ -285,8 +345,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if idx < length { b = appendArrayElemIndent(ctx, code, b) store(ctxptr, code.ElemIdx, idx) - data := load(ctxptr, code.HeadIdx) - size := code.Size + data := load(ctxptr, code.Idx) + size := uintptr(code.Size) code = code.Next store(ctxptr, code.Idx, data+idx*size) } else { @@ -296,8 +356,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpArrayPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -306,8 +366,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpArray: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -317,17 +377,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next store(ctxptr, code.Idx, p) } else { - b = appendEmptyArray(b) + b = appendEmptyArray(ctx, b) code = code.End.Next } case encoder.OpArrayElem: idx := load(ctxptr, code.ElemIdx) idx++ - if idx < code.Length { + if idx < uintptr(code.Length) { b = appendArrayElemIndent(ctx, code, b) store(ctxptr, code.ElemIdx, idx) - p := load(ctxptr, code.HeadIdx) - size := code.Size + p := load(ctxptr, code.Idx) + size := uintptr(code.Size) code = code.Next store(ctxptr, code.Idx, p+idx*size) } else { @@ -337,8 +397,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpMapPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -347,31 +407,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpMap: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } uptr := ptrToUnsafePtr(p) mlen := maplen(uptr) if mlen <= 0 { - b = appendEmptyObject(b) + b = appendEmptyObject(ctx, b) code = code.End.Next break } - b = appendStructHead(b) + b = appendStructHead(ctx, b) iter := mapiterinit(code.Type, uptr) ctx.KeepRefs = append(ctx.KeepRefs, iter) store(ctxptr, code.ElemIdx, 0) store(ctxptr, code.Length, uintptr(mlen)) store(ctxptr, code.MapIter, uintptr(iter)) - if (opt & encoder.UnorderedMapOption) == 0 { + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { + b = appendMapKeyIndent(ctx, code.Next, b) + } else { mapCtx := encoder.NewMapContext(mlen) mapCtx.Pos = append(mapCtx.Pos, len(b)) ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx)) store(ctxptr, code.End.MapPos, uintptr(unsafe.Pointer(mapCtx))) - } else { - b = appendMapKeyIndent(ctx, code.Next, b) } key := mapiterkey(iter) store(ctxptr, code.Next.Idx, uintptr(key)) @@ -380,7 +440,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt idx := load(ctxptr, code.ElemIdx) length := load(ctxptr, code.Length) idx++ - if (opt & encoder.UnorderedMapOption) != 0 { + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { if idx < length { b = appendMapKeyIndent(ctx, code, b) store(ctxptr, code.ElemIdx, idx) @@ -409,8 +469,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } } case encoder.OpMapValue: - if (opt & encoder.UnorderedMapOption) != 0 { - b = appendColon(b) + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { + b = appendColon(ctx, b) } else { ptr := load(ctxptr, code.End.MapPos) mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(ptr)) @@ -479,7 +539,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt oldOffset := ptrOffset ptrOffset += code.Jmp.CurLen * uintptrSize oldBaseIndent := ctx.BaseIndent - ctx.BaseIndent += code.Indent - 1 + indentDiffFromTop := c.Indent - 1 + ctx.BaseIndent += code.Indent - indentDiffFromTop newLen := offsetNum + code.Jmp.CurLen + code.Jmp.NextLen if curlen < newLen { @@ -490,7 +551,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt store(ctxptr, c.Idx, ptr) store(ctxptr, c.End.Next.Idx, oldOffset) store(ctxptr, c.End.Next.ElemIdx, uintptr(unsafe.Pointer(code.Next))) - storeIndent(ctxptr, c, uintptr(oldBaseIndent)) + storeIndent(ctxptr, c.End.Next, uintptr(oldBaseIndent)) code = c recursiveLevel++ case encoder.OpRecursiveEnd: @@ -508,9 +569,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHead: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -519,29 +580,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHead: p := load(ctxptr, code.Idx) - if p == 0 && (code.Indirect || code.Next.Op == encoder.OpStructEnd) { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if !code.AnonymousKey && len(code.Key) > 0 { - b = appendStructKey(ctx, code, b) + if len(code.Key) > 0 { + if (code.Flags&encoder.IsTaggedKeyFlags) != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 { + b = appendStructKey(ctx, code, b) + } } - p += code.Offset + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructPtrHeadOmitEmpty: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -550,19 +613,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmpty: p := load(ctxptr, code.Idx) - if p == 0 && (code.Indirect || code.Next.Op == encoder.OpStructEnd) { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - p += code.Offset - if p == 0 || (ptrToPtr(p) == 0 && code.IsNextOpPtrType) { + p += uintptr(code.Offset) + if p == 0 || (ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0) { code = code.NextField } else { b = appendStructKey(ctx, code, b) @@ -570,12 +633,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt store(ctxptr, code.Idx, p) } case encoder.OpStructPtrHeadInt: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -586,27 +649,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadInt: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p+code.Offset), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyInt: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -617,33 +680,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyInt: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendInt(b, u64, code) - b = appendComma(b) + b = appendInt(ctx, b, u64, code) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadIntString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -654,29 +717,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadIntString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p+code.Offset), code) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyIntString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -687,34 +750,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyIntString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, u64, code) + b = appendInt(ctx, b, u64, code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadIntPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -723,34 +786,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadIntPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyIntPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -759,32 +822,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyIntPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(p), code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadIntPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -793,36 +856,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadIntPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyIntPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -831,35 +894,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyIntPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadUint: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -870,27 +933,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadUint: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p+code.Offset), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyUint: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -901,33 +964,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyUint: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendUint(b, u64, code) - b = appendComma(b) + b = appendUint(ctx, b, u64, code) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadUintString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -938,29 +1001,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadUintString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p+code.Offset), code) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyUintString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -971,34 +1034,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyUintString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, u64, code) + b = appendUint(ctx, b, u64, code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadUintPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1007,34 +1070,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadUintPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyUintPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1043,32 +1106,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyUintPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(p), code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadUintPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1077,36 +1140,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadUintPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyUintPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1115,35 +1178,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyUintPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadFloat32: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1154,27 +1217,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadFloat32: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat32: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1185,32 +1248,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyFloat32: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat32(p + code.Offset) + v := ptrToFloat32(p + uintptr(code.Offset)) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, v) - b = appendComma(b) + b = appendFloat32(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadFloat32String: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1221,29 +1284,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadFloat32String: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat32String: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1254,33 +1317,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyFloat32String: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat32(p + code.Offset) + v := ptrToFloat32(p + uintptr(code.Offset)) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, v) + b = appendFloat32(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadFloat32Ptr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1289,34 +1352,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadFloat32Ptr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat32Ptr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1325,32 +1388,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyFloat32Ptr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p)) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadFloat32PtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1359,36 +1422,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadFloat32PtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat32PtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1397,35 +1460,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyFloat32PtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadFloat64: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1436,31 +1499,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadFloat64: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat64: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1471,17 +1534,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyFloat64: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if v == 0 { code = code.NextField } else { @@ -1489,17 +1552,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadFloat64String: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1510,33 +1573,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadFloat64String: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat64String: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1547,17 +1610,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyFloat64String: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if v == 0 { code = code.NextField } else { @@ -1566,17 +1629,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadFloat64Ptr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1585,38 +1648,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadFloat64Ptr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat64Ptr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1625,19 +1688,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyFloat64Ptr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) @@ -1645,16 +1708,16 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadFloat64PtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1663,40 +1726,40 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadFloat64PtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat64PtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1705,19 +1768,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyFloat64PtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) @@ -1726,18 +1789,18 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1748,27 +1811,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p+code.Offset)) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1779,32 +1842,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToString(p + code.Offset) + v := ptrToString(p + uintptr(code.Offset)) if v == "" { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendString(b, v) - b = appendComma(b) + b = appendString(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadStringString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1815,27 +1878,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadStringString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, ptrToString(p+code.Offset)))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p+uintptr(code.Offset))))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyStringString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1846,31 +1909,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyStringString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToString(p + code.Offset) + v := ptrToString(p + uintptr(code.Offset)) if v == "" { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, v))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadStringPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1879,34 +1942,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadStringPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, ptrToString(p)) + b = appendString(ctx, b, ptrToString(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyStringPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1915,32 +1978,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyStringPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p)) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadStringPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1949,34 +2012,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadStringPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyStringPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1985,33 +2048,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyStringPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadBool: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2022,27 +2085,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadBool: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p+code.Offset)) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBool: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2053,32 +2116,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyBool: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToBool(p + code.Offset) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) - b = appendBool(b, v) - b = appendComma(b) + b = appendBool(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } else { code = code.NextField } case encoder.OpStructPtrHeadBoolString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2089,29 +2152,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadBoolString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p+code.Offset)) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBoolString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2122,23 +2185,23 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyBoolString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToBool(p + code.Offset) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, v) + b = appendBool(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } else { code = code.NextField @@ -2146,9 +2209,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadBoolPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2157,34 +2220,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadBoolPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBoolPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2193,32 +2256,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyBoolPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p)) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadBoolPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2227,36 +2290,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadBoolPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBoolPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2265,35 +2328,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyBoolPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadBytes: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2304,27 +2367,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadBytes: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p+code.Offset)) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBytes: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2335,31 +2398,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyBytes: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToBytes(p + code.Offset) + v := ptrToBytes(p + uintptr(code.Offset)) if len(v) == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, v) - b = appendComma(b) + b = appendByteSlice(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadBytesPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2368,34 +2431,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadBytesPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendByteSlice(b, ptrToBytes(p)) + b = appendByteSlice(ctx, b, ptrToBytes(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBytesPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2404,33 +2467,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyBytesPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p)) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadNumber: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2441,30 +2504,30 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadNumber: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpStructPtrHeadOmitEmptyNumber: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2475,35 +2538,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyNumber: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToNumber(p + code.Offset) + v := ptrToNumber(p + uintptr(code.Offset)) if v == "" { code = code.NextField } else { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next } case encoder.OpStructPtrHeadNumberString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2514,32 +2577,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadNumberString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyNumberString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2550,36 +2613,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyNumberString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToNumber(p + code.Offset) + v := ptrToNumber(p + uintptr(code.Offset)) if v == "" { code = code.NextField } else { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadNumberPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2588,38 +2651,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadNumberPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyNumberPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2628,35 +2691,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyNumberPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructPtrHeadNumberPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2665,39 +2728,39 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadNumberPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = append(bb, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyNumberPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2706,38 +2769,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyNumberPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadArray, encoder.OpStructPtrHeadSlice: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2748,27 +2811,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadArray, encoder.OpStructHeadSlice: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - p += code.Offset + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructPtrHeadOmitEmptyArray: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2779,27 +2842,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyArray: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - p += code.Offset + p += uintptr(code.Offset) b = appendStructKey(ctx, code, b) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructPtrHeadOmitEmptySlice: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2810,17 +2873,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptySlice: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - p += code.Offset + p += uintptr(code.Offset) slice := ptrToSlice(p) if slice.Len == 0 { code = code.NextField @@ -2832,9 +2895,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadArrayPtr, encoder.OpStructPtrHeadSlicePtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2843,24 +2906,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadArrayPtr, encoder.OpStructHeadSlicePtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.NextField } else { code = code.Next @@ -2869,9 +2932,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadOmitEmptyArrayPtr, encoder.OpStructPtrHeadOmitEmptySlicePtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2880,19 +2943,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyArrayPtr, encoder.OpStructHeadOmitEmptySlicePtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { code = code.NextField @@ -2904,9 +2967,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadMap: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2915,29 +2978,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadMap: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if p != 0 && code.Indirect { - p = ptrToPtr(p + code.Offset) + if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p + uintptr(code.Offset)) } code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructPtrHeadOmitEmptyMap: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2946,19 +3009,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyMap: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if p != 0 && code.Indirect { - p = ptrToPtr(p + code.Offset) + if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p + uintptr(code.Offset)) } if maplen(ptrToUnsafePtr(p)) == 0 { code = code.NextField @@ -2970,9 +3033,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadMapPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2981,31 +3044,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadMapPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.NextField break } - p = ptrToPtr(p + code.Offset) + p = ptrToPtr(p + uintptr(code.Offset)) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.NextField } else { - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p = ptrToNPtr(p, code.PtrNum) } code = code.Next @@ -3014,9 +3077,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadOmitEmptyMapPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3025,26 +3088,26 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyMapPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } if p == 0 { code = code.NextField break } - p = ptrToPtr(p + code.Offset) + p = ptrToPtr(p + uintptr(code.Offset)) if p == 0 { code = code.NextField } else { - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p = ptrToNPtr(p, code.PtrNum) } b = appendStructKey(ctx, code, b) @@ -3054,38 +3117,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadMarshalJSON: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) } fallthrough case encoder.OpStructHeadMarshalJSON: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.IsNilableType { - if code.Indirect || code.Op == encoder.OpStructPtrHeadMarshalJSON { - p = ptrToPtr(p + code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalJSON { + p = ptrToPtr(p + uintptr(code.Offset)) } } - if p == 0 && code.Nilcheck { - b = appendNull(b) + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) } else { bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { @@ -3093,42 +3156,42 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyMarshalJSON: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) } fallthrough case encoder.OpStructHeadOmitEmptyMarshalJSON: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.IsNilableType { - if code.Indirect || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON { - p = ptrToPtr(p + code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON { + p = ptrToPtr(p + uintptr(code.Offset)) } } iface := ptrToInterface(code, p) - if code.Nilcheck && encoder.IsNilForMarshaler(iface) { + if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) { code = code.NextField } else { b = appendStructKey(ctx, code, b) @@ -3137,15 +3200,15 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt return nil, err } b = bb - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadMarshalJSONPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3154,23 +3217,23 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadMarshalJSONPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { @@ -3178,14 +3241,14 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyMarshalJSONPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3194,19 +3257,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyMarshalJSONPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } if p == 0 { code = code.NextField @@ -3217,103 +3280,103 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt return nil, err } b = bb - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadMarshalText: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) } fallthrough case encoder.OpStructHeadMarshalText: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.IsNilableType { - if code.Indirect || code.Op == encoder.OpStructPtrHeadMarshalText { - p = ptrToPtr(p + code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalText { + p = ptrToPtr(p + uintptr(code.Offset)) } } - if p == 0 && code.Nilcheck { - b = appendNull(b) + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) } else { - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyMarshalText: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) } fallthrough case encoder.OpStructHeadOmitEmptyMarshalText: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.IsNilableType { - if code.Indirect || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText { - p = ptrToPtr(p + code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText { + p = ptrToPtr(p + uintptr(code.Offset)) } } - if p == 0 && code.Nilcheck { + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadMarshalTextPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3322,38 +3385,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadMarshalTextPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyMarshalTextPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3362,43 +3425,43 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyMarshalTextPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } if p == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructField: - if !code.AnonymousKey { + if code.Flags&encoder.IsTaggedKeyFlags != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 { b = appendStructKey(ctx, code, b) } - p := load(ctxptr, code.HeadIdx) + code.Offset + p := load(ctxptr, code.Idx) + uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmpty: - p := load(ctxptr, code.HeadIdx) - p += code.Offset - if ptrToPtr(p) == 0 && code.IsNextOpPtrType { + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) @@ -3406,298 +3469,298 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt store(ctxptr, code.Idx, p) } case encoder.OpStructFieldInt: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p+code.Offset), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyInt: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, u64, code) - b = appendComma(b) + b = appendInt(ctx, b, u64, code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldIntString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p+code.Offset), code) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyIntString: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, u64, code) + b = appendInt(ctx, b, u64, code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldIntPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyIntPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(p), code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldIntPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyIntPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldUint: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p+code.Offset), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyUint: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, u64, code) - b = appendComma(b) + b = appendUint(ctx, b, u64, code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldUintString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p+code.Offset), code) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyUintString: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, u64, code) + b = appendUint(ctx, b, u64, code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldUintPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyUintPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(p), code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldUintPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyUintPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat32: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat32: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat32(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, v) - b = appendComma(b) + b = appendFloat32(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat32String: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat32String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat32(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, v) + b = appendFloat32(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat32Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat32Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p)) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat32PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat32PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat64: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat64: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if v != 0 { if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat64String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat64String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if v != 0 { if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat64Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -3705,42 +3768,42 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat64Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat64PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat64PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') @@ -3748,307 +3811,307 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p+code.Offset)) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyString: - p := load(ctxptr, code.HeadIdx) - v := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - b = appendString(b, v) - b = appendComma(b) + b = appendString(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldStringString: - p := load(ctxptr, code.HeadIdx) - s := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + s := ptrToString(p + uintptr(code.Offset)) b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, s))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, s))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyStringString: - p := load(ctxptr, code.HeadIdx) - v := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, v))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldStringPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, ptrToString(p)) + b = appendString(ctx, b, ptrToString(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyStringPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p)) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldStringPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyStringPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBool: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p+code.Offset)) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBool: - p := load(ctxptr, code.HeadIdx) - v := ptrToBool(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) - b = appendBool(b, v) - b = appendComma(b) + b = appendBool(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBoolString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p+code.Offset)) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBoolString: - p := load(ctxptr, code.HeadIdx) - v := ptrToBool(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, v) + b = appendBool(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBoolPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBoolPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p)) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBoolPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBoolPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBytes: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p+code.Offset)) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBytes: - p := load(ctxptr, code.HeadIdx) - v := ptrToBytes(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBytes(p + uintptr(code.Offset)) if len(v) > 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, v) - b = appendComma(b) + b = appendByteSlice(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBytesPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendByteSlice(b, ptrToBytes(p)) + b = appendByteSlice(ctx, b, ptrToBytes(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBytesPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p)) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldNumber: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpStructFieldOmitEmptyNumber: - p := load(ctxptr, code.HeadIdx) - v := ptrToNumber(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructFieldNumberString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyNumberString: - p := load(ctxptr, code.HeadIdx) - v := ptrToNumber(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldNumberPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyNumberPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructFieldNumberPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = append(bb, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyNumberPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldMarshalJSON: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - p += code.Offset - if code.IsNilableType { + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { p = ptrToPtr(p) } - if p == 0 && code.Nilcheck { - b = appendNull(b) + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) } else { bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { @@ -4056,20 +4119,20 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyMarshalJSON: - p := load(ctxptr, code.HeadIdx) - p += code.Offset - if code.IsNilableType { + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { p = ptrToPtr(p) } - if p == 0 && code.Nilcheck { + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { code = code.NextField break } iface := ptrToInterface(code, p) - if code.Nilcheck && encoder.IsNilForMarshaler(iface) { + if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) { code = code.NextField break } @@ -4078,14 +4141,14 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpStructFieldMarshalJSONPtr: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { @@ -4093,103 +4156,103 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyMarshalJSONPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructFieldMarshalText: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - p += code.Offset - if code.IsNilableType { + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { p = ptrToPtr(p) } - if p == 0 && code.Nilcheck { - b = appendNull(b) + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) } else { - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyMarshalText: - p := load(ctxptr, code.HeadIdx) - p += code.Offset - if code.IsNilableType { + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { p = ptrToPtr(p) } - if p == 0 && code.Nilcheck { + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { code = code.NextField break } b = appendStructKey(ctx, code, b) - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpStructFieldMarshalTextPtr: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyMarshalTextPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructFieldArray: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyArray: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldArrayPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyArrayPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) code = code.Next @@ -4199,13 +4262,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldSlice: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptySlice: - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) slice := ptrToSlice(p) if slice.Len == 0 { code = code.NextField @@ -4216,13 +4279,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldSlicePtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptySlicePtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) code = code.Next @@ -4232,13 +4295,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldMap: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToPtr(p + code.Offset) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyMap: - p := load(ctxptr, code.HeadIdx) - p = ptrToPtr(p + code.Offset) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) if p == 0 || maplen(ptrToUnsafePtr(p)) == 0 { code = code.NextField } else { @@ -4248,16 +4311,16 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldMapPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToPtr(p + code.Offset) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) if p != 0 { p = ptrToNPtr(p, code.PtrNum) } code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyMapPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToPtr(p + code.Offset) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) if p != 0 { p = ptrToNPtr(p, code.PtrNum) } @@ -4270,14 +4333,14 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldStruct: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyStruct: - p := load(ctxptr, code.HeadIdx) - p += code.Offset - if ptrToPtr(p) == 0 && code.IsNextOpPtrType { + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) @@ -4290,39 +4353,39 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt b = appendStructEndSkipLast(ctx, code, b) code = code.Next case encoder.OpStructEndInt: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p+code.Offset), code) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyInt: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, u64, code) + b = appendInt(ctx, b, u64, code) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndIntString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p+code.Offset), code) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyIntString: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, u64, code) + b = appendInt(ctx, b, u64, code) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4331,21 +4394,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndIntPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyIntPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4353,24 +4416,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndIntPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyIntPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4378,39 +4441,39 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndUint: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p+code.Offset), code) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyUint: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, u64, code) + b = appendUint(ctx, b, u64, code) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndUintString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p+code.Offset), code) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyUintString: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, u64, code) + b = appendUint(ctx, b, u64, code) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4419,21 +4482,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndUintPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyUintPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4441,24 +4504,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndUintPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyUintPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4466,37 +4529,37 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndFloat32: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat32: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat32(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, v) + b = appendFloat32(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndFloat32String: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat32String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat32(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, v) + b = appendFloat32(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4505,21 +4568,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndFloat32Ptr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat32Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4527,24 +4590,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndFloat32PtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat32PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4552,51 +4615,51 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndFloat64: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat64: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if v != 0 { if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndFloat64String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat64String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if v != 0 { if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4605,10 +4668,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndFloat64Ptr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) b = appendStructEnd(ctx, code, b) code = code.Next break @@ -4617,19 +4680,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat64Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4637,24 +4700,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndFloat64PtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat64PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) v := ptrToFloat64(p) @@ -4662,7 +4725,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt return nil, errUnsupportedFloat(v) } b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4670,35 +4733,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p+code.Offset)) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyString: - p := load(ctxptr, code.HeadIdx) - v := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - b = appendString(b, v) + b = appendString(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndStringString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - s := ptrToString(p + code.Offset) - b = appendString(b, string(appendString([]byte{}, s))) + s := ptrToString(p + uintptr(code.Offset)) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, s))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyStringString: - p := load(ctxptr, code.HeadIdx) - v := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, v))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4706,21 +4769,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndStringPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, ptrToString(p)) + b = appendString(ctx, b, ptrToString(p)) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyStringPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p)) + b = appendString(ctx, b, ptrToString(p)) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4728,58 +4791,58 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndStringPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyStringPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndBool: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p+code.Offset)) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBool: - p := load(ctxptr, code.HeadIdx) - v := ptrToBool(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) - b = appendBool(b, v) + b = appendBool(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndBoolString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p+code.Offset)) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBoolString: - p := load(ctxptr, code.HeadIdx) - v := ptrToBool(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, v) + b = appendBool(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4788,21 +4851,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndBoolPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBoolPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4810,24 +4873,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndBoolPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBoolPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4835,17 +4898,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndBytes: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p+code.Offset)) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBytes: - p := load(ctxptr, code.HeadIdx) - v := ptrToBytes(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBytes(p + uintptr(code.Offset)) if len(v) > 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, v) + b = appendByteSlice(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4853,41 +4916,41 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndBytesPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendByteSlice(b, ptrToBytes(p)) + b = appendByteSlice(ctx, b, ptrToBytes(p)) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBytesPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p)) + b = appendByteSlice(ctx, b, ptrToBytes(p)) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndNumber: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } b = appendStructEnd(ctx, code, bb) code = code.Next case encoder.OpStructEndOmitEmptyNumber: - p := load(ctxptr, code.HeadIdx) - v := ptrToNumber(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } @@ -4897,10 +4960,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndNumberString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } @@ -4908,12 +4971,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyNumberString: - p := load(ctxptr, code.HeadIdx) - v := ptrToNumber(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } @@ -4925,12 +4988,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndNumberPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } @@ -4939,11 +5002,11 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyNumberPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } @@ -4954,13 +5017,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndNumberPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } @@ -4969,12 +5032,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyNumberPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_escaped/hack.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_escaped/hack.go deleted file mode 100644 index 3ac51dda3..000000000 --- a/vendor/github.com/goccy/go-json/internal/encoder/vm_escaped/hack.go +++ /dev/null @@ -1,9 +0,0 @@ -package vm_escaped - -import ( - // HACK: compile order - // `vm`, `vm_escaped`, `vm_indent`, `vm_escaped_indent` packages uses a lot of memory to compile, - // so forcibly make dependencies and avoid compiling in concurrent. - // dependency order: vm => vm_escaped => vm_indent => vm_escaped_indent - _ "github.com/goccy/go-json/internal/encoder/vm_indent" -) diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_escaped_indent/hack.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_escaped_indent/hack.go deleted file mode 100644 index 49d3ceccd..000000000 --- a/vendor/github.com/goccy/go-json/internal/encoder/vm_escaped_indent/hack.go +++ /dev/null @@ -1,6 +0,0 @@ -package vm_escaped_indent - -// HACK: compile order -// `vm`, `vm_escaped`, `vm_indent`, `vm_escaped_indent` packages uses a lot of memory to compile, -// so forcibly make dependencies and avoid compiling in concurrent. -// dependency order: vm => vm_escaped => vm_indent => vm_escaped_indent diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/debug_vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/debug_vm.go index 4b78e9e33..4cfd17ab2 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/debug_vm.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/debug_vm.go @@ -6,7 +6,14 @@ import ( "github.com/goccy/go-json/internal/encoder" ) -func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt encoder.Option) ([]byte, error) { +func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) { + var code *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + code = codeSet.EscapeKeyCode + } else { + code = codeSet.NoescapeKeyCode + } + defer func() { if err := recover(); err != nil { fmt.Println("=============[DEBUG]===============") @@ -14,7 +21,7 @@ func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, fmt.Println(codeSet.Type) fmt.Printf("\n") fmt.Println("* [ALL OPCODE]") - fmt.Println(codeSet.Code.Dump()) + fmt.Println(code.Dump()) fmt.Printf("\n") fmt.Println("* [CONTEXT]") fmt.Printf("%+v\n", ctx) @@ -23,5 +30,5 @@ func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, } }() - return Run(ctx, b, codeSet, opt) + return Run(ctx, b, codeSet) } diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/hack.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/hack.go index 789ade895..9e245bfe5 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/hack.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/hack.go @@ -2,8 +2,8 @@ package vm_indent import ( // HACK: compile order - // `vm`, `vm_escaped`, `vm_indent`, `vm_escaped_indent` packages uses a lot of memory to compile, + // `vm`, `vm_indent`, `vm_color`, `vm_color_indent` packages uses a lot of memory to compile, // so forcibly make dependencies and avoid compiling in concurrent. - // dependency order: vm => vm_escaped => vm_indent => vm_escaped_indent - _ "github.com/goccy/go-json/internal/encoder/vm_escaped_indent" + // dependency order: vm => vm_indent => vm_color => vm_color_indent + _ "github.com/goccy/go-json/internal/encoder/vm_color" ) diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/util.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/util.go index d73fb7b83..2e3c35fb9 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/util.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/util.go @@ -35,24 +35,33 @@ type emptyInterface struct { ptr unsafe.Pointer } +type nonEmptyInterface struct { + itab *struct { + ityp *runtime.Type // static interface type + typ *runtime.Type // dynamic concrete type + // unused fields... + } + ptr unsafe.Pointer +} + func errUnimplementedOp(op encoder.OpType) error { return fmt.Errorf("encoder (indent): opcode %s has not been implemented", op) } -func load(base uintptr, idx uintptr) uintptr { - addr := base + idx +func load(base uintptr, idx uint32) uintptr { + addr := base + uintptr(idx) return **(**uintptr)(unsafe.Pointer(&addr)) } -func store(base uintptr, idx uintptr, p uintptr) { - addr := base + idx +func store(base uintptr, idx uint32, p uintptr) { + addr := base + uintptr(idx) **(**uintptr)(unsafe.Pointer(&addr)) = p } -func loadNPtr(base uintptr, idx uintptr, ptrNum int) uintptr { - addr := base + idx +func loadNPtr(base uintptr, idx uint32, ptrNum uint8) uintptr { + addr := base + uintptr(idx) p := **(**uintptr)(unsafe.Pointer(&addr)) - for i := 0; i < ptrNum; i++ { + for i := uint8(0); i < ptrNum; i++ { if p == 0 { return 0 } @@ -72,8 +81,8 @@ func ptrToSlice(p uintptr) *runtime.SliceHeader { return *(**runtime.SliceHeader 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++ { +func ptrToNPtr(p uintptr, ptrNum uint8) uintptr { + for i := uint8(0); i < ptrNum; i++ { if p == 0 { return 0 } @@ -92,62 +101,25 @@ func ptrToInterface(code *encoder.Opcode, p uintptr) interface{} { })) } -func appendBool(b []byte, v bool) []byte { +func appendBool(_ *encoder.RuntimeContext, b []byte, v bool) []byte { if v { return append(b, "true"...) } return append(b, "false"...) } -func appendNull(b []byte) []byte { +func appendNull(_ *encoder.RuntimeContext, b []byte) []byte { return append(b, "null"...) } -func appendComma(b []byte) []byte { +func appendComma(_ *encoder.RuntimeContext, b []byte) []byte { return append(b, ',', '\n') } -func appendColon(b []byte) []byte { +func appendColon(_ *encoder.RuntimeContext, b []byte) []byte { return append(b, ':', ' ') } -func appendInterface(ctx *encoder.RuntimeContext, codeSet *encoder.OpcodeSet, opt encoder.Option, code *encoder.Opcode, b []byte, iface *emptyInterface, ptrOffset uintptr) ([]byte, error) { - ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(iface)) - ifaceCodeSet, err := encoder.CompileToGetCodeSet(uintptr(unsafe.Pointer(iface.typ))) - if err != nil { - return nil, err - } - - totalLength := uintptr(codeSet.CodeLength) - nextTotalLength := uintptr(ifaceCodeSet.CodeLength) - - curlen := uintptr(len(ctx.Ptrs)) - offsetNum := ptrOffset / uintptrSize - - newLen := offsetNum + totalLength + nextTotalLength - if curlen < newLen { - ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...) - } - oldPtrs := ctx.Ptrs - - newPtrs := ctx.Ptrs[(ptrOffset+totalLength*uintptrSize)/uintptrSize:] - newPtrs[0] = uintptr(iface.ptr) - - ctx.Ptrs = newPtrs - - oldBaseIndent := ctx.BaseIndent - ctx.BaseIndent = code.Indent - bb, err := Run(ctx, b, ifaceCodeSet, opt) - if err != nil { - return nil, err - } - ctx.BaseIndent = oldBaseIndent - - ctx.Ptrs = oldPtrs - - return bb, nil -} - func appendMapKeyValue(ctx *encoder.RuntimeContext, code *encoder.Opcode, b, key, value []byte) []byte { b = appendIndent(ctx, b, code.Indent+1) b = append(b, key...) @@ -175,11 +147,11 @@ func appendArrayEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) return append(b, ']', ',', '\n') } -func appendEmptyArray(b []byte) []byte { +func appendEmptyArray(_ *encoder.RuntimeContext, b []byte) []byte { return append(b, '[', ']', ',', '\n') } -func appendEmptyObject(b []byte) []byte { +func appendEmptyObject(_ *encoder.RuntimeContext, b []byte) []byte { return append(b, '{', '}', ',', '\n') } @@ -191,14 +163,14 @@ func appendObjectEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte } func appendMarshalJSON(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { - return encoder.AppendMarshalJSONIndent(ctx, code, b, v, false) + return encoder.AppendMarshalJSONIndent(ctx, code, b, v) } -func appendMarshalText(code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { - return encoder.AppendMarshalTextIndent(code, b, v, false) +func appendMarshalText(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) { + return encoder.AppendMarshalTextIndent(ctx, code, b, v) } -func appendStructHead(b []byte) []byte { +func appendStructHead(_ *encoder.RuntimeContext, b []byte) []byte { return append(b, '{', '\n') } @@ -221,15 +193,15 @@ func appendStructEndSkipLast(ctx *encoder.RuntimeContext, code *encoder.Opcode, b = appendIndent(ctx, b, code.Indent-1) b = append(b, '}') } - return appendComma(b) + return appendComma(ctx, b) } func restoreIndent(ctx *encoder.RuntimeContext, code *encoder.Opcode, ctxptr uintptr) { - ctx.BaseIndent = int(load(ctxptr, code.Length)) + ctx.BaseIndent = uint32(load(ctxptr, code.Length)) } func storeIndent(ctxptr uintptr, code *encoder.Opcode, indent uintptr) { - store(ctxptr, code.End.Next.Length, indent) + store(ctxptr, code.Length, indent) } func appendArrayElemIndent(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go index b470adaf4..6e05155f1 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go @@ -7,13 +7,19 @@ import ( "unsafe" "github.com/goccy/go-json/internal/encoder" + "github.com/goccy/go-json/internal/runtime" ) -func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt encoder.Option) ([]byte, error) { +func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) { recursiveLevel := 0 ptrOffset := uintptr(0) ctxptr := ctx.Ptr() - code := codeSet.Code + var code *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + code = codeSet.EscapeKeyCode + } else { + code = codeSet.NoescapeKeyCode + } for { switch code.Op { @@ -26,62 +32,62 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpIntPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpInt: - b = appendInt(b, ptrToUint64(load(ctxptr, code.Idx)), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpUintPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpUint: - b = appendUint(b, ptrToUint64(load(ctxptr, code.Idx)), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpIntString: b = append(b, '"') - b = appendInt(b, ptrToUint64(load(ctxptr, code.Idx)), code) + b = appendInt(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpUintString: b = append(b, '"') - b = appendUint(b, ptrToUint64(load(ctxptr, code.Idx)), code) + b = appendUint(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpFloat32Ptr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpFloat32: - b = appendFloat32(b, ptrToFloat32(load(ctxptr, code.Idx))) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) code = code.Next case encoder.OpFloat64Ptr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -92,73 +98,73 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next case encoder.OpStringPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpString: - b = appendString(b, ptrToString(load(ctxptr, code.Idx))) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) code = code.Next case encoder.OpBoolPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpBool: - b = appendBool(b, ptrToBool(load(ctxptr, code.Idx))) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) code = code.Next case encoder.OpBytesPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpBytes: - b = appendByteSlice(b, ptrToBytes(load(ctxptr, code.Idx))) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(load(ctxptr, code.Idx))) + b = appendComma(ctx, b) code = code.Next case encoder.OpNumberPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } store(ctxptr, code.Idx, p) fallthrough case encoder.OpNumber: - bb, err := appendNumber(b, ptrToNumber(load(ctxptr, code.Idx))) + bb, err := appendNumber(ctx, b, ptrToNumber(load(ctxptr, code.Idx))) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpInterfacePtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -167,38 +173,92 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpInterface: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } - for _, seen := range ctx.SeenPtr { - if p == seen { - return nil, errUnsupportedValue(code, p) + if recursiveLevel > encoder.StartDetectingCyclesAfter { + for _, seen := range ctx.SeenPtr { + if p == seen { + return nil, errUnsupportedValue(code, p) + } } } ctx.SeenPtr = append(ctx.SeenPtr, p) - iface := (*emptyInterface)(ptrToUnsafePtr(p)) - if iface.ptr == nil { - b = appendNull(b) - b = appendComma(b) + var ( + typ *runtime.Type + ifacePtr unsafe.Pointer + ) + up := ptrToUnsafePtr(p) + if code.Flags&encoder.NonEmptyInterfaceFlags != 0 { + iface := (*nonEmptyInterface)(up) + ifacePtr = iface.ptr + typ = iface.itab.typ + } else { + iface := (*emptyInterface)(up) + ifacePtr = iface.ptr + typ = iface.typ + } + if ifacePtr == nil { + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } - bb, err := appendInterface(ctx, codeSet, opt, code, b, iface, ptrOffset) + ctx.KeepRefs = append(ctx.KeepRefs, up) + ifaceCodeSet, err := encoder.CompileToGetCodeSet(uintptr(unsafe.Pointer(typ))) if err != nil { return nil, err } - ctxptr = ctx.Ptr() + + totalLength := uintptr(code.Length) + 3 + nextTotalLength := uintptr(ifaceCodeSet.CodeLength) + 3 + + var c *encoder.Opcode + if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 { + c = ifaceCodeSet.InterfaceEscapeKeyCode + } else { + c = ifaceCodeSet.InterfaceNoescapeKeyCode + } + curlen := uintptr(len(ctx.Ptrs)) + offsetNum := ptrOffset / uintptrSize + oldOffset := ptrOffset + ptrOffset += totalLength * uintptrSize + oldBaseIndent := ctx.BaseIndent + indentDiffFromTop := c.Indent - 1 + ctx.BaseIndent += code.Indent - indentDiffFromTop + + newLen := offsetNum + totalLength + nextTotalLength + if curlen < newLen { + ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...) + } + ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr + + end := ifaceCodeSet.EndCode + store(ctxptr, c.Idx, uintptr(ifacePtr)) + store(ctxptr, end.Idx, oldOffset) + store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next))) + storeIndent(ctxptr, end, uintptr(oldBaseIndent)) + code = c + recursiveLevel++ + case encoder.OpInterfaceEnd: + recursiveLevel-- + + // restore ctxptr + offset := load(ctxptr, code.Idx) + restoreIndent(ctx, code, ctxptr) ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1] - b = bb - code = code.Next + codePtr := load(ctxptr, code.ElemIdx) + code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr)) + ctxptr = ctx.Ptr() + offset + ptrOffset = offset case encoder.OpMarshalJSONPtr: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -207,25 +267,25 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpMarshalJSON: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } - if code.IsNilableType && code.Indirect { + if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 { p = ptrToPtr(p) } bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpMarshalTextPtr: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -235,24 +295,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt p := load(ctxptr, code.Idx) if p == 0 { b = append(b, `""`...) - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next break } - if code.IsNilableType && code.Indirect { + if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 { p = ptrToPtr(p) } - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpSlicePtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -262,8 +322,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt p := load(ctxptr, code.Idx) slice := ptrToSlice(p) if p == 0 || slice.Data == nil { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -275,7 +335,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next store(ctxptr, code.Idx, uintptr(slice.Data)) } else { - b = appendEmptyArray(b) + b = appendEmptyArray(ctx, b) code = code.End.Next } case encoder.OpSliceElem: @@ -285,8 +345,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if idx < length { b = appendArrayElemIndent(ctx, code, b) store(ctxptr, code.ElemIdx, idx) - data := load(ctxptr, code.HeadIdx) - size := code.Size + data := load(ctxptr, code.Idx) + size := uintptr(code.Size) code = code.Next store(ctxptr, code.Idx, data+idx*size) } else { @@ -296,8 +356,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpArrayPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -306,8 +366,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpArray: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -317,17 +377,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next store(ctxptr, code.Idx, p) } else { - b = appendEmptyArray(b) + b = appendEmptyArray(ctx, b) code = code.End.Next } case encoder.OpArrayElem: idx := load(ctxptr, code.ElemIdx) idx++ - if idx < code.Length { + if idx < uintptr(code.Length) { b = appendArrayElemIndent(ctx, code, b) store(ctxptr, code.ElemIdx, idx) - p := load(ctxptr, code.HeadIdx) - size := code.Size + p := load(ctxptr, code.Idx) + size := uintptr(code.Size) code = code.Next store(ctxptr, code.Idx, p+idx*size) } else { @@ -337,8 +397,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpMapPtr: p := loadNPtr(ctxptr, code.Idx, code.PtrNum) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } @@ -347,31 +407,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpMap: p := load(ctxptr, code.Idx) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.End.Next break } uptr := ptrToUnsafePtr(p) mlen := maplen(uptr) if mlen <= 0 { - b = appendEmptyObject(b) + b = appendEmptyObject(ctx, b) code = code.End.Next break } - b = appendStructHead(b) + b = appendStructHead(ctx, b) iter := mapiterinit(code.Type, uptr) ctx.KeepRefs = append(ctx.KeepRefs, iter) store(ctxptr, code.ElemIdx, 0) store(ctxptr, code.Length, uintptr(mlen)) store(ctxptr, code.MapIter, uintptr(iter)) - if (opt & encoder.UnorderedMapOption) == 0 { + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { + b = appendMapKeyIndent(ctx, code.Next, b) + } else { mapCtx := encoder.NewMapContext(mlen) mapCtx.Pos = append(mapCtx.Pos, len(b)) ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx)) store(ctxptr, code.End.MapPos, uintptr(unsafe.Pointer(mapCtx))) - } else { - b = appendMapKeyIndent(ctx, code.Next, b) } key := mapiterkey(iter) store(ctxptr, code.Next.Idx, uintptr(key)) @@ -380,7 +440,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt idx := load(ctxptr, code.ElemIdx) length := load(ctxptr, code.Length) idx++ - if (opt & encoder.UnorderedMapOption) != 0 { + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { if idx < length { b = appendMapKeyIndent(ctx, code, b) store(ctxptr, code.ElemIdx, idx) @@ -409,8 +469,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } } case encoder.OpMapValue: - if (opt & encoder.UnorderedMapOption) != 0 { - b = appendColon(b) + if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 { + b = appendColon(ctx, b) } else { ptr := load(ctxptr, code.End.MapPos) mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(ptr)) @@ -479,7 +539,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt oldOffset := ptrOffset ptrOffset += code.Jmp.CurLen * uintptrSize oldBaseIndent := ctx.BaseIndent - ctx.BaseIndent += code.Indent - 1 + indentDiffFromTop := c.Indent - 1 + ctx.BaseIndent += code.Indent - indentDiffFromTop newLen := offsetNum + code.Jmp.CurLen + code.Jmp.NextLen if curlen < newLen { @@ -490,7 +551,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt store(ctxptr, c.Idx, ptr) store(ctxptr, c.End.Next.Idx, oldOffset) store(ctxptr, c.End.Next.ElemIdx, uintptr(unsafe.Pointer(code.Next))) - storeIndent(ctxptr, c, uintptr(oldBaseIndent)) + storeIndent(ctxptr, c.End.Next, uintptr(oldBaseIndent)) code = c recursiveLevel++ case encoder.OpRecursiveEnd: @@ -508,9 +569,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHead: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -519,29 +580,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHead: p := load(ctxptr, code.Idx) - if p == 0 && (code.Indirect || code.Next.Op == encoder.OpStructEnd) { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if !code.AnonymousKey && len(code.Key) > 0 { - b = appendStructKey(ctx, code, b) + if len(code.Key) > 0 { + if (code.Flags&encoder.IsTaggedKeyFlags) != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 { + b = appendStructKey(ctx, code, b) + } } - p += code.Offset + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructPtrHeadOmitEmpty: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -550,19 +613,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmpty: p := load(ctxptr, code.Idx) - if p == 0 && (code.Indirect || code.Next.Op == encoder.OpStructEnd) { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - p += code.Offset - if p == 0 || (ptrToPtr(p) == 0 && code.IsNextOpPtrType) { + p += uintptr(code.Offset) + if p == 0 || (ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0) { code = code.NextField } else { b = appendStructKey(ctx, code, b) @@ -570,12 +633,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt store(ctxptr, code.Idx, p) } case encoder.OpStructPtrHeadInt: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -586,27 +649,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadInt: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p+code.Offset), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyInt: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -617,33 +680,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyInt: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendInt(b, u64, code) - b = appendComma(b) + b = appendInt(ctx, b, u64, code) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadIntString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -654,29 +717,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadIntString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p+code.Offset), code) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyIntString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -687,34 +750,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyIntString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, u64, code) + b = appendInt(ctx, b, u64, code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadIntPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -723,34 +786,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadIntPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyIntPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -759,32 +822,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyIntPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(p), code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadIntPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -793,36 +856,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadIntPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyIntPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -831,35 +894,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyIntPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadUint: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -870,27 +933,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadUint: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p+code.Offset), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyUint: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -901,33 +964,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyUint: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendUint(b, u64, code) - b = appendComma(b) + b = appendUint(ctx, b, u64, code) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadUintString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -938,29 +1001,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadUintString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p+code.Offset), code) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyUintString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -971,34 +1034,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyUintString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, u64, code) + b = appendUint(ctx, b, u64, code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadUintPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1007,34 +1070,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadUintPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyUintPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1043,32 +1106,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyUintPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(p), code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadUintPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1077,36 +1140,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadUintPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyUintPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1115,35 +1178,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyUintPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadFloat32: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1154,27 +1217,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadFloat32: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat32: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1185,32 +1248,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyFloat32: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat32(p + code.Offset) + v := ptrToFloat32(p + uintptr(code.Offset)) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, v) - b = appendComma(b) + b = appendFloat32(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadFloat32String: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1221,29 +1284,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadFloat32String: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat32String: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1254,33 +1317,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyFloat32String: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat32(p + code.Offset) + v := ptrToFloat32(p + uintptr(code.Offset)) if v == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, v) + b = appendFloat32(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadFloat32Ptr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1289,34 +1352,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadFloat32Ptr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat32Ptr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1325,32 +1388,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyFloat32Ptr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p)) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadFloat32PtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1359,36 +1422,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadFloat32PtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat32PtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1397,35 +1460,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyFloat32PtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadFloat64: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1436,31 +1499,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadFloat64: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat64: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1471,17 +1534,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyFloat64: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if v == 0 { code = code.NextField } else { @@ -1489,17 +1552,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadFloat64String: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1510,33 +1573,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadFloat64String: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat64String: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1547,17 +1610,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyFloat64String: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if v == 0 { code = code.NextField } else { @@ -1566,17 +1629,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadFloat64Ptr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1585,38 +1648,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadFloat64Ptr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat64Ptr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1625,19 +1688,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyFloat64Ptr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) @@ -1645,16 +1708,16 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadFloat64PtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1663,40 +1726,40 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadFloat64PtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyFloat64PtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1705,19 +1768,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyFloat64PtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) @@ -1726,18 +1789,18 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1748,27 +1811,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p+code.Offset)) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1779,32 +1842,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToString(p + code.Offset) + v := ptrToString(p + uintptr(code.Offset)) if v == "" { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendString(b, v) - b = appendComma(b) + b = appendString(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadStringString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1815,27 +1878,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadStringString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, ptrToString(p+code.Offset)))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p+uintptr(code.Offset))))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyStringString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1846,31 +1909,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyStringString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToString(p + code.Offset) + v := ptrToString(p + uintptr(code.Offset)) if v == "" { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, v))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadStringPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1879,34 +1942,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadStringPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, ptrToString(p)) + b = appendString(ctx, b, ptrToString(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyStringPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1915,32 +1978,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyStringPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p)) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadStringPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1949,34 +2012,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadStringPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyStringPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -1985,33 +2048,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyStringPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadBool: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2022,27 +2085,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadBool: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p+code.Offset)) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBool: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2053,32 +2116,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyBool: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToBool(p + code.Offset) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) - b = appendBool(b, v) - b = appendComma(b) + b = appendBool(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } else { code = code.NextField } case encoder.OpStructPtrHeadBoolString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2089,29 +2152,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadBoolString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p+code.Offset)) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBoolString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2122,23 +2185,23 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyBoolString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToBool(p + code.Offset) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, v) + b = appendBool(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } else { code = code.NextField @@ -2146,9 +2209,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadBoolPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2157,34 +2220,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadBoolPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBoolPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2193,32 +2256,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyBoolPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p)) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadBoolPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2227,36 +2290,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadBoolPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBoolPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2265,35 +2328,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyBoolPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadBytes: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2304,27 +2367,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadBytes: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p+code.Offset)) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBytes: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2335,31 +2398,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyBytes: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToBytes(p + code.Offset) + v := ptrToBytes(p + uintptr(code.Offset)) if len(v) == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, v) - b = appendComma(b) + b = appendByteSlice(ctx, b, v) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadBytesPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2368,34 +2431,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadBytesPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendByteSlice(b, ptrToBytes(p)) + b = appendByteSlice(ctx, b, ptrToBytes(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyBytesPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2404,33 +2467,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyBytesPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p)) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadNumber: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2441,30 +2504,30 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadNumber: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpStructPtrHeadOmitEmptyNumber: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2475,35 +2538,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyNumber: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToNumber(p + code.Offset) + v := ptrToNumber(p + uintptr(code.Offset)) if v == "" { code = code.NextField } else { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next } case encoder.OpStructPtrHeadNumberString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2514,32 +2577,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadNumberString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyNumberString: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2550,36 +2613,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyNumberString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - v := ptrToNumber(p + code.Offset) + v := ptrToNumber(p + uintptr(code.Offset)) if v == "" { code = code.NextField } else { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadNumberPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2588,38 +2651,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadNumberPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyNumberPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2628,35 +2691,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyNumberPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructPtrHeadNumberPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2665,39 +2728,39 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadNumberPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = append(bb, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyNumberPtrString: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2706,38 +2769,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyNumberPtrString: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructPtrHeadArray, encoder.OpStructPtrHeadSlice: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2748,27 +2811,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadArray, encoder.OpStructHeadSlice: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - p += code.Offset + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructPtrHeadOmitEmptyArray: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2779,27 +2842,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptyArray: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - p += code.Offset + p += uintptr(code.Offset) b = appendStructKey(ctx, code, b) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructPtrHeadOmitEmptySlice: - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2810,17 +2873,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructHeadOmitEmptySlice: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - p += code.Offset + p += uintptr(code.Offset) slice := ptrToSlice(p) if slice.Len == 0 { code = code.NextField @@ -2832,9 +2895,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadArrayPtr, encoder.OpStructPtrHeadSlicePtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2843,24 +2906,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadArrayPtr, encoder.OpStructHeadSlicePtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.NextField } else { code = code.Next @@ -2869,9 +2932,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadOmitEmptyArrayPtr, encoder.OpStructPtrHeadOmitEmptySlicePtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2880,19 +2943,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyArrayPtr, encoder.OpStructHeadOmitEmptySlicePtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { code = code.NextField @@ -2904,9 +2967,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadMap: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2915,29 +2978,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadMap: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if p != 0 && code.Indirect { - p = ptrToPtr(p + code.Offset) + if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p + uintptr(code.Offset)) } code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructPtrHeadOmitEmptyMap: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2946,19 +3009,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyMap: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if p != 0 && code.Indirect { - p = ptrToPtr(p + code.Offset) + if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 { + p = ptrToPtr(p + uintptr(code.Offset)) } if maplen(ptrToUnsafePtr(p)) == 0 { code = code.NextField @@ -2970,9 +3033,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadMapPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -2981,31 +3044,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadMapPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.NextField break } - p = ptrToPtr(p + code.Offset) + p = ptrToPtr(p + uintptr(code.Offset)) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.NextField } else { - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p = ptrToNPtr(p, code.PtrNum) } code = code.Next @@ -3014,9 +3077,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadOmitEmptyMapPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3025,26 +3088,26 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyMapPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } if p == 0 { code = code.NextField break } - p = ptrToPtr(p + code.Offset) + p = ptrToPtr(p + uintptr(code.Offset)) if p == 0 { code = code.NextField } else { - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { p = ptrToNPtr(p, code.PtrNum) } b = appendStructKey(ctx, code, b) @@ -3054,38 +3117,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt case encoder.OpStructPtrHeadMarshalJSON: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) } fallthrough case encoder.OpStructHeadMarshalJSON: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.IsNilableType { - if code.Indirect || code.Op == encoder.OpStructPtrHeadMarshalJSON { - p = ptrToPtr(p + code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalJSON { + p = ptrToPtr(p + uintptr(code.Offset)) } } - if p == 0 && code.Nilcheck { - b = appendNull(b) + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) } else { bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { @@ -3093,42 +3156,42 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyMarshalJSON: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) } fallthrough case encoder.OpStructHeadOmitEmptyMarshalJSON: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.IsNilableType { - if code.Indirect || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON { - p = ptrToPtr(p + code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON { + p = ptrToPtr(p + uintptr(code.Offset)) } } iface := ptrToInterface(code, p) - if code.Nilcheck && encoder.IsNilForMarshaler(iface) { + if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) { code = code.NextField } else { b = appendStructKey(ctx, code, b) @@ -3137,15 +3200,15 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt return nil, err } b = bb - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadMarshalJSONPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3154,23 +3217,23 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadMarshalJSONPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { @@ -3178,14 +3241,14 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyMarshalJSONPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3194,19 +3257,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyMarshalJSONPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } if p == 0 { code = code.NextField @@ -3217,103 +3280,103 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt return nil, err } b = bb - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadMarshalText: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) } fallthrough case encoder.OpStructHeadMarshalText: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.IsNilableType { - if code.Indirect || code.Op == encoder.OpStructPtrHeadMarshalText { - p = ptrToPtr(p + code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalText { + p = ptrToPtr(p + uintptr(code.Offset)) } } - if p == 0 && code.Nilcheck { - b = appendNull(b) + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) } else { - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyMarshalText: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { + if (code.Flags & encoder.IndirectFlags) != 0 { store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum)) } fallthrough case encoder.OpStructHeadOmitEmptyMarshalText: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } - if code.IsNilableType { - if code.Indirect || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText { - p = ptrToPtr(p + code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { + if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText { + p = ptrToPtr(p + uintptr(code.Offset)) } } - if p == 0 && code.Nilcheck { + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructPtrHeadMarshalTextPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3322,38 +3385,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadMarshalTextPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } b = appendStructKey(ctx, code, b) - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructPtrHeadOmitEmptyMarshalTextPtr: p := load(ctxptr, code.Idx) if p == 0 { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break @@ -3362,43 +3425,43 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt fallthrough case encoder.OpStructHeadOmitEmptyMarshalTextPtr: p := load(ctxptr, code.Idx) - if p == 0 && code.Indirect { - if !code.AnonymousHead { - b = appendNull(b) - b = appendComma(b) + if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 { + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendNull(ctx, b) + b = appendComma(ctx, b) } code = code.End.Next break } - if code.Indirect { - p = ptrToNPtr(p+code.Offset, code.PtrNum) + if (code.Flags & encoder.IndirectFlags) != 0 { + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) } - if !code.AnonymousHead { - b = appendStructHead(b) + if code.Flags&encoder.AnonymousHeadFlags == 0 { + b = appendStructHead(ctx, b) } if p == 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next } case encoder.OpStructField: - if !code.AnonymousKey { + if code.Flags&encoder.IsTaggedKeyFlags != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 { b = appendStructKey(ctx, code, b) } - p := load(ctxptr, code.HeadIdx) + code.Offset + p := load(ctxptr, code.Idx) + uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmpty: - p := load(ctxptr, code.HeadIdx) - p += code.Offset - if ptrToPtr(p) == 0 && code.IsNextOpPtrType { + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) @@ -3406,298 +3469,298 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt store(ctxptr, code.Idx, p) } case encoder.OpStructFieldInt: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p+code.Offset), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyInt: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, u64, code) - b = appendComma(b) + b = appendInt(ctx, b, u64, code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldIntString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p+code.Offset), code) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyIntString: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, u64, code) + b = appendInt(ctx, b, u64, code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldIntPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyIntPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p), code) - b = appendComma(b) + b = appendInt(ctx, b, ptrToUint64(p), code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldIntPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyIntPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldUint: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p+code.Offset), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyUint: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, u64, code) - b = appendComma(b) + b = appendUint(ctx, b, u64, code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldUintString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p+code.Offset), code) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyUintString: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, u64, code) + b = appendUint(ctx, b, u64, code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldUintPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyUintPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p), code) - b = appendComma(b) + b = appendUint(ctx, b, ptrToUint64(p), code) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldUintPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyUintPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat32: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat32: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat32(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, v) - b = appendComma(b) + b = appendFloat32(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat32String: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat32String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat32(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, v) + b = appendFloat32(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat32Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat32Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p)) - b = appendComma(b) + b = appendFloat32(ctx, b, ptrToFloat32(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat32PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat32PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat64: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - v := ptrToFloat64(p + code.Offset) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat64: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if v != 0 { if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat64String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat64String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if v != 0 { if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat64Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) - b = appendComma(b) + b = appendNull(ctx, b) + b = appendComma(ctx, b) code = code.Next break } @@ -3705,42 +3768,42 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat64Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) - b = appendComma(b) + b = appendFloat64(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldFloat64PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyFloat64PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') @@ -3748,307 +3811,307 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p+code.Offset)) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyString: - p := load(ctxptr, code.HeadIdx) - v := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - b = appendString(b, v) - b = appendComma(b) + b = appendString(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldStringString: - p := load(ctxptr, code.HeadIdx) - s := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + s := ptrToString(p + uintptr(code.Offset)) b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, s))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, s))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyStringString: - p := load(ctxptr, code.HeadIdx) - v := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, v))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldStringPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, ptrToString(p)) + b = appendString(ctx, b, ptrToString(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyStringPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p)) - b = appendComma(b) + b = appendString(ctx, b, ptrToString(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldStringPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyStringPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) - b = appendComma(b) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBool: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p+code.Offset)) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBool: - p := load(ctxptr, code.HeadIdx) - v := ptrToBool(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) - b = appendBool(b, v) - b = appendComma(b) + b = appendBool(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBoolString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p+code.Offset)) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBoolString: - p := load(ctxptr, code.HeadIdx) - v := ptrToBool(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, v) + b = appendBool(ctx, b, v) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBoolPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBoolPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p)) - b = appendComma(b) + b = appendBool(ctx, b, ptrToBool(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBoolPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBoolPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBytes: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p+code.Offset)) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBytes: - p := load(ctxptr, code.HeadIdx) - v := ptrToBytes(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBytes(p + uintptr(code.Offset)) if len(v) > 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, v) - b = appendComma(b) + b = appendByteSlice(ctx, b, v) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldBytesPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendByteSlice(b, ptrToBytes(p)) + b = appendByteSlice(ctx, b, ptrToBytes(p)) } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyBytesPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p)) - b = appendComma(b) + b = appendByteSlice(ctx, b, ptrToBytes(p)) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldNumber: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpStructFieldOmitEmptyNumber: - p := load(ctxptr, code.HeadIdx) - v := ptrToNumber(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructFieldNumberString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyNumberString: - p := load(ctxptr, code.HeadIdx) - v := ptrToNumber(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldNumberPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyNumberPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructFieldNumberPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) b = appendStructKey(ctx, code, b) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = append(bb, '"') } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyNumberPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } b = append(bb, '"') - b = appendComma(b) + b = appendComma(ctx, b) } code = code.Next case encoder.OpStructFieldMarshalJSON: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - p += code.Offset - if code.IsNilableType { + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { p = ptrToPtr(p) } - if p == 0 && code.Nilcheck { - b = appendNull(b) + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) } else { bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { @@ -4056,20 +4119,20 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyMarshalJSON: - p := load(ctxptr, code.HeadIdx) - p += code.Offset - if code.IsNilableType { + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { p = ptrToPtr(p) } - if p == 0 && code.Nilcheck { + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { code = code.NextField break } iface := ptrToInterface(code, p) - if code.Nilcheck && encoder.IsNilForMarshaler(iface) { + if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) { code = code.NextField break } @@ -4078,14 +4141,14 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpStructFieldMarshalJSONPtr: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { @@ -4093,103 +4156,103 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyMarshalJSONPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructFieldMarshalText: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - p += code.Offset - if code.IsNilableType { + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { p = ptrToPtr(p) } - if p == 0 && code.Nilcheck { - b = appendNull(b) + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { + b = appendNull(ctx, b) } else { - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyMarshalText: - p := load(ctxptr, code.HeadIdx) - p += code.Offset - if code.IsNilableType { + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if (code.Flags & encoder.IsNilableTypeFlags) != 0 { p = ptrToPtr(p) } - if p == 0 && code.Nilcheck { + if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 { code = code.NextField break } b = appendStructKey(ctx, code, b) - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) code = code.Next case encoder.OpStructFieldMarshalTextPtr: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } b = bb } - b = appendComma(b) + b = appendComma(ctx, b) code = code.Next case encoder.OpStructFieldOmitEmptyMarshalTextPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - bb, err := appendMarshalText(code, b, ptrToInterface(code, p)) + bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p)) if err != nil { return nil, err } - b = appendComma(bb) + b = appendComma(ctx, bb) } code = code.Next case encoder.OpStructFieldArray: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyArray: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldArrayPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyArrayPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) code = code.Next @@ -4199,13 +4262,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldSlice: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptySlice: - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) slice := ptrToSlice(p) if slice.Len == 0 { code = code.NextField @@ -4216,13 +4279,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldSlicePtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptySlicePtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) code = code.Next @@ -4232,13 +4295,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldMap: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToPtr(p + code.Offset) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyMap: - p := load(ctxptr, code.HeadIdx) - p = ptrToPtr(p + code.Offset) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) if p == 0 || maplen(ptrToUnsafePtr(p)) == 0 { code = code.NextField } else { @@ -4248,16 +4311,16 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldMapPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToPtr(p + code.Offset) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) if p != 0 { p = ptrToNPtr(p, code.PtrNum) } code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyMapPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToPtr(p + code.Offset) + p := load(ctxptr, code.Idx) + p = ptrToPtr(p + uintptr(code.Offset)) if p != 0 { p = ptrToNPtr(p, code.PtrNum) } @@ -4270,14 +4333,14 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } case encoder.OpStructFieldStruct: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p += code.Offset + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) code = code.Next store(ctxptr, code.Idx, p) case encoder.OpStructFieldOmitEmptyStruct: - p := load(ctxptr, code.HeadIdx) - p += code.Offset - if ptrToPtr(p) == 0 && code.IsNextOpPtrType { + p := load(ctxptr, code.Idx) + p += uintptr(code.Offset) + if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 { code = code.NextField } else { b = appendStructKey(ctx, code, b) @@ -4290,39 +4353,39 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt b = appendStructEndSkipLast(ctx, code, b) code = code.Next case encoder.OpStructEndInt: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p+code.Offset), code) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyInt: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, u64, code) + b = appendInt(ctx, b, u64, code) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndIntString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p+code.Offset), code) + b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyIntString: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, u64, code) + b = appendInt(ctx, b, u64, code) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4331,21 +4394,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndIntPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyIntPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4353,24 +4416,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndIntPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyIntPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendInt(b, ptrToUint64(p), code) + b = appendInt(ctx, b, ptrToUint64(p), code) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4378,39 +4441,39 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndUint: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p+code.Offset), code) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyUint: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, u64, code) + b = appendUint(ctx, b, u64, code) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndUintString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p+code.Offset), code) + b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyUintString: - p := load(ctxptr, code.HeadIdx) - u64 := ptrToUint64(p + code.Offset) - v := u64 & code.Mask + p := load(ctxptr, code.Idx) + u64 := ptrToUint64(p + uintptr(code.Offset)) + v := u64 & ((1 << code.NumBitSize) - 1) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, u64, code) + b = appendUint(ctx, b, u64, code) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4419,21 +4482,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndUintPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyUintPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4441,24 +4504,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndUintPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyUintPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendUint(b, ptrToUint64(p), code) + b = appendUint(ctx, b, ptrToUint64(p), code) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4466,37 +4529,37 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndFloat32: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat32: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat32(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) if v != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, v) + b = appendFloat32(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndFloat32String: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p+code.Offset)) + b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset))) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat32String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat32(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat32(p + uintptr(code.Offset)) if v != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, v) + b = appendFloat32(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4505,21 +4568,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndFloat32Ptr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat32Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4527,24 +4590,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndFloat32PtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat32PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat32(b, ptrToFloat32(p)) + b = appendFloat32(ctx, b, ptrToFloat32(p)) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4552,51 +4615,51 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndFloat64: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat64: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if v != 0 { if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndFloat64String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat64String: - p := load(ctxptr, code.HeadIdx) - v := ptrToFloat64(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToFloat64(p + uintptr(code.Offset)) if v != 0 { if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4605,10 +4668,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndFloat64Ptr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) b = appendStructEnd(ctx, code, b) code = code.Next break @@ -4617,19 +4680,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat64Ptr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4637,24 +4700,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndFloat64PtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') v := ptrToFloat64(p) if math.IsInf(v, 0) || math.IsNaN(v) { return nil, errUnsupportedFloat(v) } - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyFloat64PtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) v := ptrToFloat64(p) @@ -4662,7 +4725,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt return nil, errUnsupportedFloat(v) } b = append(b, '"') - b = appendFloat64(b, v) + b = appendFloat64(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4670,35 +4733,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p+code.Offset)) + b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyString: - p := load(ctxptr, code.HeadIdx) - v := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - b = appendString(b, v) + b = appendString(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndStringString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - s := ptrToString(p + code.Offset) - b = appendString(b, string(appendString([]byte{}, s))) + s := ptrToString(p + uintptr(code.Offset)) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, s))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyStringString: - p := load(ctxptr, code.HeadIdx) - v := ptrToString(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToString(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, v))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, v))) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4706,21 +4769,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndStringPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, ptrToString(p)) + b = appendString(ctx, b, ptrToString(p)) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyStringPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, ptrToString(p)) + b = appendString(ctx, b, ptrToString(p)) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4728,58 +4791,58 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndStringPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyStringPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendString(b, string(appendString([]byte{}, ptrToString(p)))) + b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p)))) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndBool: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p+code.Offset)) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBool: - p := load(ctxptr, code.HeadIdx) - v := ptrToBool(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) - b = appendBool(b, v) + b = appendBool(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndBoolString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p+code.Offset)) + b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset))) b = append(b, '"') b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBoolString: - p := load(ctxptr, code.HeadIdx) - v := ptrToBool(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBool(p + uintptr(code.Offset)) if v { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, v) + b = appendBool(ctx, b, v) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4788,21 +4851,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndBoolPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBoolPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4810,24 +4873,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndBoolPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBoolPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - b = appendBool(b, ptrToBool(p)) + b = appendBool(ctx, b, ptrToBool(p)) b = append(b, '"') b = appendStructEnd(ctx, code, b) } else { @@ -4835,17 +4898,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndBytes: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p+code.Offset)) + b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset))) b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBytes: - p := load(ctxptr, code.HeadIdx) - v := ptrToBytes(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToBytes(p + uintptr(code.Offset)) if len(v) > 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, v) + b = appendByteSlice(ctx, b, v) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) @@ -4853,41 +4916,41 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndBytesPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - b = appendByteSlice(b, ptrToBytes(p)) + b = appendByteSlice(ctx, b, ptrToBytes(p)) } b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyBytesPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - b = appendByteSlice(b, ptrToBytes(p)) + b = appendByteSlice(ctx, b, ptrToBytes(p)) b = appendStructEnd(ctx, code, b) } else { b = appendStructEndSkipLast(ctx, code, b) } code = code.Next case encoder.OpStructEndNumber: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } b = appendStructEnd(ctx, code, bb) code = code.Next case encoder.OpStructEndOmitEmptyNumber: - p := load(ctxptr, code.HeadIdx) - v := ptrToNumber(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } @@ -4897,10 +4960,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt } code = code.Next case encoder.OpStructEndNumberString: - p := load(ctxptr, code.HeadIdx) + p := load(ctxptr, code.Idx) b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p+code.Offset)) + bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset))) if err != nil { return nil, err } @@ -4908,12 +4971,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyNumberString: - p := load(ctxptr, code.HeadIdx) - v := ptrToNumber(p + code.Offset) + p := load(ctxptr, code.Idx) + v := ptrToNumber(p + uintptr(code.Offset)) if v != "" { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, v) + bb, err := appendNumber(ctx, b, v) if err != nil { return nil, err } @@ -4925,12 +4988,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndNumberPtr: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } @@ -4939,11 +5002,11 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyNumberPtr: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } @@ -4954,13 +5017,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt code = code.Next case encoder.OpStructEndNumberPtrString: b = appendStructKey(ctx, code, b) - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p == 0 { - b = appendNull(b) + b = appendNull(ctx, b) } else { b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } @@ -4969,12 +5032,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt b = appendStructEnd(ctx, code, b) code = code.Next case encoder.OpStructEndOmitEmptyNumberPtrString: - p := load(ctxptr, code.HeadIdx) - p = ptrToNPtr(p+code.Offset, code.PtrNum) + p := load(ctxptr, code.Idx) + p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum) if p != 0 { b = appendStructKey(ctx, code, b) b = append(b, '"') - bb, err := appendNumber(b, ptrToNumber(p)) + bb, err := appendNumber(ctx, b, ptrToNumber(p)) if err != nil { return nil, err } diff --git a/vendor/github.com/goccy/go-json/internal/errors/error.go b/vendor/github.com/goccy/go-json/internal/errors/error.go index 329e2f12d..d58e39f4e 100644 --- a/vendor/github.com/goccy/go-json/internal/errors/error.go +++ b/vendor/github.com/goccy/go-json/internal/errors/error.go @@ -155,3 +155,10 @@ func ErrInvalidCharacter(c byte, context string, cursor int64) *SyntaxError { Offset: cursor, } } + +func ErrInvalidBeginningOfValue(c byte, cursor int64) *SyntaxError { + return &SyntaxError{ + msg: fmt.Sprintf("invalid character '%c' looking for beginning of value", c), + Offset: cursor, + } +} |