From 994dc9ea9d57705f375065bbed394194d619907c Mon Sep 17 00:00:00 2001 From: Masaaki Goshima Date: Fri, 25 Jun 2021 20:17:12 +0900 Subject: [PATCH 1/3] Fix encoding of empty interface type --- internal/cmd/generator/main.go | 1 + internal/cmd/generator/vm.go.tmpl | 45 +- internal/encoder/compiler.go | 15 +- internal/encoder/compiler_norace.go | 15 +- internal/encoder/compiler_race.go | 15 +- internal/encoder/encoder.go | 11 +- internal/encoder/opcode.go | 47 +- internal/encoder/optype.go | 780 +++++++++++++------------ internal/encoder/vm/vm.go | 45 +- internal/encoder/vm_color/vm.go | 45 +- internal/encoder/vm_color_indent/vm.go | 45 +- internal/encoder/vm_indent/vm.go | 45 +- 12 files changed, 683 insertions(+), 426 deletions(-) diff --git a/internal/cmd/generator/main.go b/internal/cmd/generator/main.go index b3fb697..ac2df79 100644 --- a/internal/cmd/generator/main.go +++ b/internal/cmd/generator/main.go @@ -200,6 +200,7 @@ func (t OpType) FieldToOmitEmptyField() OpType { createOpType("Recursive", "Op"), createOpType("RecursivePtr", "Op"), createOpType("RecursiveEnd", "Op"), + createOpType("InterfaceEnd", "Op"), createOpType("StructAnonymousEnd", "StructEnd"), } for _, typ := range primitiveTypesUpper { diff --git a/internal/cmd/generator/vm.go.tmpl b/internal/cmd/generator/vm.go.tmpl index 242c3a4..cf1ff39 100644 --- a/internal/cmd/generator/vm.go.tmpl +++ b/internal/cmd/generator/vm.go.tmpl @@ -190,15 +190,52 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b code = code.Next break } - bb, err := appendInterface(ctx, codeSet, code, b, iface, ptrOffset) + + ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(iface)) + ifaceCodeSet, err := encoder.CompileToGetCodeSet(uintptr(unsafe.Pointer(iface.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(iface.ptr)) + store(ctxptr, end.Idx, oldOffset) + store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next))) + storeIndent(ctxptr, c, uintptr(oldBaseIndent)) + code = c + case encoder.OpInterfaceEnd: + offset := load(ctxptr, code.Idx) + // restore ctxptr + 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 { diff --git a/internal/encoder/compiler.go b/internal/encoder/compiler.go index 04a3446..f930efa 100644 --- a/internal/encoder/compiler.go +++ b/internal/encoder/compiler.go @@ -78,12 +78,19 @@ func compileToGetCodeSetSlowPath(typeptr uintptr) (*OpcodeSet, error) { } noescapeKeyCode = copyOpcode(noescapeKeyCode) escapeKeyCode = copyOpcode(escapeKeyCode) + setTotalLengthToInterfaceOp(noescapeKeyCode) + setTotalLengthToInterfaceOp(escapeKeyCode) + interfaceNoescapeKeyCode := copyToInterfaceOpcode(noescapeKeyCode) + interfaceEscapeKeyCode := copyToInterfaceOpcode(escapeKeyCode) codeLength := noescapeKeyCode.TotalLength() codeSet := &OpcodeSet{ - Type: copiedType, - NoescapeKeyCode: noescapeKeyCode, - EscapeKeyCode: escapeKeyCode, - CodeLength: codeLength, + Type: copiedType, + NoescapeKeyCode: noescapeKeyCode, + EscapeKeyCode: escapeKeyCode, + InterfaceNoescapeKeyCode: interfaceNoescapeKeyCode, + InterfaceEscapeKeyCode: interfaceEscapeKeyCode, + CodeLength: codeLength, + EndCode: ToEndCode(interfaceNoescapeKeyCode), } storeOpcodeSet(typeptr, codeSet, opcodeMap) return codeSet, nil diff --git a/internal/encoder/compiler_norace.go b/internal/encoder/compiler_norace.go index e5e58d4..9d337f1 100644 --- a/internal/encoder/compiler_norace.go +++ b/internal/encoder/compiler_norace.go @@ -37,12 +37,19 @@ func CompileToGetCodeSet(typeptr uintptr) (*OpcodeSet, error) { } noescapeKeyCode = copyOpcode(noescapeKeyCode) escapeKeyCode = copyOpcode(escapeKeyCode) + setTotalLengthToInterfaceOp(noescapeKeyCode) + setTotalLengthToInterfaceOp(escapeKeyCode) + interfaceNoescapeKeyCode := copyToInterfaceOpcode(noescapeKeyCode) + interfaceEscapeKeyCode := copyToInterfaceOpcode(escapeKeyCode) codeLength := noescapeKeyCode.TotalLength() codeSet := &OpcodeSet{ - Type: copiedType, - NoescapeKeyCode: noescapeKeyCode, - EscapeKeyCode: escapeKeyCode, - 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/internal/encoder/compiler_race.go b/internal/encoder/compiler_race.go index a1d5f84..3a239e9 100644 --- a/internal/encoder/compiler_race.go +++ b/internal/encoder/compiler_race.go @@ -44,12 +44,19 @@ func CompileToGetCodeSet(typeptr uintptr) (*OpcodeSet, error) { noescapeKeyCode = copyOpcode(noescapeKeyCode) escapeKeyCode = copyOpcode(escapeKeyCode) + setTotalLengthToInterfaceOp(noescapeKeyCode) + setTotalLengthToInterfaceOp(escapeKeyCode) + interfaceNoescapeKeyCode := copyToInterfaceOpcode(noescapeKeyCode) + interfaceEscapeKeyCode := copyToInterfaceOpcode(escapeKeyCode) codeLength := noescapeKeyCode.TotalLength() codeSet := &OpcodeSet{ - Type: copiedType, - NoescapeKeyCode: noescapeKeyCode, - EscapeKeyCode: escapeKeyCode, - 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/internal/encoder/encoder.go b/internal/encoder/encoder.go index 35b8159..b7fa99a 100644 --- a/internal/encoder/encoder.go +++ b/internal/encoder/encoder.go @@ -94,10 +94,13 @@ func (t OpType) IsMultipleOpField() bool { } type OpcodeSet struct { - Type *runtime.Type - NoescapeKeyCode *Opcode - EscapeKeyCode *Opcode - CodeLength int + Type *runtime.Type + NoescapeKeyCode *Opcode + EscapeKeyCode *Opcode + InterfaceNoescapeKeyCode *Opcode + InterfaceEscapeKeyCode *Opcode + CodeLength int + EndCode *Opcode } type CompiledCode struct { diff --git a/internal/encoder/opcode.go b/internal/encoder/opcode.go index 3330207..e2e1323 100644 --- a/internal/encoder/opcode.go +++ b/internal/encoder/opcode.go @@ -285,6 +285,46 @@ 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) + copied.Op = copied.Op.PtrHeadToHead() + 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, @@ -354,7 +394,8 @@ func (c *Opcode) BeforeLastCode() *Opcode { func (c *Opcode) TotalLength() int { var idx int - for code := c; code.Op != OpEnd; { + code := c + for code.Op != OpEnd && code.Op != OpInterfaceEnd { maxIdx := int(code.MaxIdx() / uintptrSize) if idx < maxIdx { idx = maxIdx @@ -369,6 +410,10 @@ func (c *Opcode) TotalLength() int { code = code.Next } } + maxIdx := int(code.MaxIdx() / uintptrSize) + if idx < maxIdx { + idx = maxIdx + } return idx + 1 } diff --git a/internal/encoder/optype.go b/internal/encoder/optype.go index 50dd8b2..335fc04 100644 --- a/internal/encoder/optype.go +++ b/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", @@ -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/internal/encoder/vm/vm.go b/internal/encoder/vm/vm.go index 242c3a4..cf1ff39 100644 --- a/internal/encoder/vm/vm.go +++ b/internal/encoder/vm/vm.go @@ -190,15 +190,52 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b code = code.Next break } - bb, err := appendInterface(ctx, codeSet, code, b, iface, ptrOffset) + + ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(iface)) + ifaceCodeSet, err := encoder.CompileToGetCodeSet(uintptr(unsafe.Pointer(iface.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(iface.ptr)) + store(ctxptr, end.Idx, oldOffset) + store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next))) + storeIndent(ctxptr, c, uintptr(oldBaseIndent)) + code = c + case encoder.OpInterfaceEnd: + offset := load(ctxptr, code.Idx) + // restore ctxptr + 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 { diff --git a/internal/encoder/vm_color/vm.go b/internal/encoder/vm_color/vm.go index 0447c74..d8b01b4 100644 --- a/internal/encoder/vm_color/vm.go +++ b/internal/encoder/vm_color/vm.go @@ -190,15 +190,52 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b code = code.Next break } - bb, err := appendInterface(ctx, codeSet, code, b, iface, ptrOffset) + + ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(iface)) + ifaceCodeSet, err := encoder.CompileToGetCodeSet(uintptr(unsafe.Pointer(iface.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(iface.ptr)) + store(ctxptr, end.Idx, oldOffset) + store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next))) + storeIndent(ctxptr, c, uintptr(oldBaseIndent)) + code = c + case encoder.OpInterfaceEnd: + offset := load(ctxptr, code.Idx) + // restore ctxptr + 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 { diff --git a/internal/encoder/vm_color_indent/vm.go b/internal/encoder/vm_color_indent/vm.go index b142463..f6260cc 100644 --- a/internal/encoder/vm_color_indent/vm.go +++ b/internal/encoder/vm_color_indent/vm.go @@ -190,15 +190,52 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b code = code.Next break } - bb, err := appendInterface(ctx, codeSet, code, b, iface, ptrOffset) + + ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(iface)) + ifaceCodeSet, err := encoder.CompileToGetCodeSet(uintptr(unsafe.Pointer(iface.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(iface.ptr)) + store(ctxptr, end.Idx, oldOffset) + store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next))) + storeIndent(ctxptr, c, uintptr(oldBaseIndent)) + code = c + case encoder.OpInterfaceEnd: + offset := load(ctxptr, code.Idx) + // restore ctxptr + 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 { diff --git a/internal/encoder/vm_indent/vm.go b/internal/encoder/vm_indent/vm.go index cbcf3d0..55bc116 100644 --- a/internal/encoder/vm_indent/vm.go +++ b/internal/encoder/vm_indent/vm.go @@ -190,15 +190,52 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b code = code.Next break } - bb, err := appendInterface(ctx, codeSet, code, b, iface, ptrOffset) + + ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(iface)) + ifaceCodeSet, err := encoder.CompileToGetCodeSet(uintptr(unsafe.Pointer(iface.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(iface.ptr)) + store(ctxptr, end.Idx, oldOffset) + store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next))) + storeIndent(ctxptr, c, uintptr(oldBaseIndent)) + code = c + case encoder.OpInterfaceEnd: + offset := load(ctxptr, code.Idx) + // restore ctxptr + 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 { From f93d82dee66c7360a885dd316cca60c1a22e4238 Mon Sep 17 00:00:00 2001 From: Masaaki Goshima Date: Fri, 25 Jun 2021 22:27:00 +0900 Subject: [PATCH 2/3] Fix storeIndent --- internal/cmd/generator/vm.go.tmpl | 4 +-- internal/encoder/vm/util.go | 33 -------------------- internal/encoder/vm/vm.go | 4 +-- internal/encoder/vm_color/util.go | 33 -------------------- internal/encoder/vm_color/vm.go | 4 +-- internal/encoder/vm_color_indent/util.go | 39 +----------------------- internal/encoder/vm_color_indent/vm.go | 4 +-- internal/encoder/vm_indent/util.go | 39 +----------------------- internal/encoder/vm_indent/vm.go | 4 +-- 9 files changed, 12 insertions(+), 152 deletions(-) diff --git a/internal/cmd/generator/vm.go.tmpl b/internal/cmd/generator/vm.go.tmpl index cf1ff39..17374ba 100644 --- a/internal/cmd/generator/vm.go.tmpl +++ b/internal/cmd/generator/vm.go.tmpl @@ -224,7 +224,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b store(ctxptr, c.Idx, uintptr(iface.ptr)) store(ctxptr, end.Idx, oldOffset) store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next))) - storeIndent(ctxptr, c, uintptr(oldBaseIndent)) + storeIndent(ctxptr, end, uintptr(oldBaseIndent)) code = c case encoder.OpInterfaceEnd: offset := load(ctxptr, code.Idx) @@ -533,7 +533,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b 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: diff --git a/internal/encoder/vm/util.go b/internal/encoder/vm/util.go index 7e358e2..c559447 100644 --- a/internal/encoder/vm/util.go +++ b/internal/encoder/vm/util.go @@ -123,39 +123,6 @@ func appendMapEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte return b } -func appendInterface(ctx *encoder.RuntimeContext, codeSet *encoder.OpcodeSet, _ *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) - 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) } diff --git a/internal/encoder/vm/vm.go b/internal/encoder/vm/vm.go index cf1ff39..17374ba 100644 --- a/internal/encoder/vm/vm.go +++ b/internal/encoder/vm/vm.go @@ -224,7 +224,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b store(ctxptr, c.Idx, uintptr(iface.ptr)) store(ctxptr, end.Idx, oldOffset) store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next))) - storeIndent(ctxptr, c, uintptr(oldBaseIndent)) + storeIndent(ctxptr, end, uintptr(oldBaseIndent)) code = c case encoder.OpInterfaceEnd: offset := load(ctxptr, code.Idx) @@ -533,7 +533,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b 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: diff --git a/internal/encoder/vm_color/util.go b/internal/encoder/vm_color/util.go index 58dd9eb..516536d 100644 --- a/internal/encoder/vm_color/util.go +++ b/internal/encoder/vm_color/util.go @@ -176,39 +176,6 @@ func appendMapEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte return b } -func appendInterface(ctx *encoder.RuntimeContext, codeSet *encoder.OpcodeSet, _ *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) - 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) } diff --git a/internal/encoder/vm_color/vm.go b/internal/encoder/vm_color/vm.go index d8b01b4..33bea71 100644 --- a/internal/encoder/vm_color/vm.go +++ b/internal/encoder/vm_color/vm.go @@ -224,7 +224,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b store(ctxptr, c.Idx, uintptr(iface.ptr)) store(ctxptr, end.Idx, oldOffset) store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next))) - storeIndent(ctxptr, c, uintptr(oldBaseIndent)) + storeIndent(ctxptr, end, uintptr(oldBaseIndent)) code = c case encoder.OpInterfaceEnd: offset := load(ctxptr, code.Idx) @@ -533,7 +533,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b 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: diff --git a/internal/encoder/vm_color_indent/util.go b/internal/encoder/vm_color_indent/util.go index 58f88e5..9f98781 100644 --- a/internal/encoder/vm_color_indent/util.go +++ b/internal/encoder/vm_color_indent/util.go @@ -163,43 +163,6 @@ func appendColon(_ *encoder.RuntimeContext, b []byte) []byte { return append(b, ':', ' ') } -func appendInterface(ctx *encoder.RuntimeContext, codeSet *encoder.OpcodeSet, 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) - 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...) @@ -292,7 +255,7 @@ func restoreIndent(ctx *encoder.RuntimeContext, code *encoder.Opcode, ctxptr uin } 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/internal/encoder/vm_color_indent/vm.go b/internal/encoder/vm_color_indent/vm.go index f6260cc..523cb45 100644 --- a/internal/encoder/vm_color_indent/vm.go +++ b/internal/encoder/vm_color_indent/vm.go @@ -224,7 +224,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b store(ctxptr, c.Idx, uintptr(iface.ptr)) store(ctxptr, end.Idx, oldOffset) store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next))) - storeIndent(ctxptr, c, uintptr(oldBaseIndent)) + storeIndent(ctxptr, end, uintptr(oldBaseIndent)) code = c case encoder.OpInterfaceEnd: offset := load(ctxptr, code.Idx) @@ -533,7 +533,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b 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: diff --git a/internal/encoder/vm_indent/util.go b/internal/encoder/vm_indent/util.go index 2e057aa..5f5d8a5 100644 --- a/internal/encoder/vm_indent/util.go +++ b/internal/encoder/vm_indent/util.go @@ -111,43 +111,6 @@ func appendColon(_ *encoder.RuntimeContext, b []byte) []byte { return append(b, ':', ' ') } -func appendInterface(ctx *encoder.RuntimeContext, codeSet *encoder.OpcodeSet, 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) - 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...) @@ -229,7 +192,7 @@ func restoreIndent(ctx *encoder.RuntimeContext, code *encoder.Opcode, ctxptr uin } 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/internal/encoder/vm_indent/vm.go b/internal/encoder/vm_indent/vm.go index 55bc116..2d2dcb5 100644 --- a/internal/encoder/vm_indent/vm.go +++ b/internal/encoder/vm_indent/vm.go @@ -224,7 +224,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b store(ctxptr, c.Idx, uintptr(iface.ptr)) store(ctxptr, end.Idx, oldOffset) store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next))) - storeIndent(ctxptr, c, uintptr(oldBaseIndent)) + storeIndent(ctxptr, end, uintptr(oldBaseIndent)) code = c case encoder.OpInterfaceEnd: offset := load(ctxptr, code.Idx) @@ -533,7 +533,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b 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: From 12e4bdc2f295c451f5d98900ac5b4c2166a63123 Mon Sep 17 00:00:00 2001 From: Masaaki Goshima Date: Fri, 25 Jun 2021 22:55:00 +0900 Subject: [PATCH 3/3] Fix dump of opcode --- internal/encoder/opcode.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/encoder/opcode.go b/internal/encoder/opcode.go index e2e1323..37dd3f5 100644 --- a/internal/encoder/opcode.go +++ b/internal/encoder/opcode.go @@ -553,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))