1// Code generated by internal/cmd/generator. DO NOT EDIT!
2package vm
3
4import (
5 "math"
6 "reflect"
7 "sort"
8 "unsafe"
9
10 "github.com/goccy/go-json/internal/encoder"
11 "github.com/goccy/go-json/internal/runtime"
12)
13
14func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) {
15 recursiveLevel := 0
16 ptrOffset := uintptr(0)
17 ctxptr := ctx.Ptr()
18 var code *encoder.Opcode
19 if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 {
20 code = codeSet.EscapeKeyCode
21 } else {
22 code = codeSet.NoescapeKeyCode
23 }
24
25 for {
26 switch code.Op {
27 default:
28 return nil, errUnimplementedOp(code.Op)
29 case encoder.OpPtr:
30 p := load(ctxptr, code.Idx)
31 code = code.Next
32 store(ctxptr, code.Idx, ptrToPtr(p))
33 case encoder.OpIntPtr:
34 p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
35 if p == 0 {
36 b = appendNullComma(ctx, b)
37 code = code.Next
38 break
39 }
40 store(ctxptr, code.Idx, p)
41 fallthrough
42 case encoder.OpInt:
43 b = appendInt(ctx, b, load(ctxptr, code.Idx), code)
44 b = appendComma(ctx, b)
45 code = code.Next
46 case encoder.OpUintPtr:
47 p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
48 if p == 0 {
49 b = appendNullComma(ctx, b)
50 code = code.Next
51 break
52 }
53 store(ctxptr, code.Idx, p)
54 fallthrough
55 case encoder.OpUint:
56 b = appendUint(ctx, b, load(ctxptr, code.Idx), code)
57 b = appendComma(ctx, b)
58 code = code.Next
59 case encoder.OpIntString:
60 b = append(b, '"')
61 b = appendInt(ctx, b, load(ctxptr, code.Idx), code)
62 b = append(b, '"')
63 b = appendComma(ctx, b)
64 code = code.Next
65 case encoder.OpUintString:
66 b = append(b, '"')
67 b = appendUint(ctx, b, load(ctxptr, code.Idx), code)
68 b = append(b, '"')
69 b = appendComma(ctx, b)
70 code = code.Next
71 case encoder.OpFloat32Ptr:
72 p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
73 if p == 0 {
74 b = appendNull(ctx, b)
75 b = appendComma(ctx, b)
76 code = code.Next
77 break
78 }
79 store(ctxptr, code.Idx, p)
80 fallthrough
81 case encoder.OpFloat32:
82 b = appendFloat32(ctx, b, ptrToFloat32(load(ctxptr, code.Idx)))
83 b = appendComma(ctx, b)
84 code = code.Next
85 case encoder.OpFloat64Ptr:
86 p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
87 if p == 0 {
88 b = appendNullComma(ctx, b)
89 code = code.Next
90 break
91 }
92 store(ctxptr, code.Idx, p)
93 fallthrough
94 case encoder.OpFloat64:
95 v := ptrToFloat64(load(ctxptr, code.Idx))
96 if math.IsInf(v, 0) || math.IsNaN(v) {
97 return nil, errUnsupportedFloat(v)
98 }
99 b = appendFloat64(ctx, b, v)
100 b = appendComma(ctx, b)
101 code = code.Next
102 case encoder.OpStringPtr:
103 p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
104 if p == 0 {
105 b = appendNullComma(ctx, b)
106 code = code.Next
107 break
108 }
109 store(ctxptr, code.Idx, p)
110 fallthrough
111 case encoder.OpString:
112 b = appendString(ctx, b, ptrToString(load(ctxptr, code.Idx)))
113 b = appendComma(ctx, b)
114 code = code.Next
115 case encoder.OpBoolPtr:
116 p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
117 if p == 0 {
118 b = appendNullComma(ctx, b)
119 code = code.Next
120 break
121 }
122 store(ctxptr, code.Idx, p)
123 fallthrough
124 case encoder.OpBool:
125 b = appendBool(ctx, b, ptrToBool(load(ctxptr, code.Idx)))
126 b = appendComma(ctx, b)
127 code = code.Next
128 case encoder.OpBytesPtr:
129 p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
130 if p == 0 {
131 b = appendNullComma(ctx, b)
132 code = code.Next
133 break
134 }
135 store(ctxptr, code.Idx, p)
136 fallthrough
137 case encoder.OpBytes:
138 b = appendByteSlice(ctx, b, ptrToBytes(load(ctxptr, code.Idx)))
139 b = appendComma(ctx, b)
140 code = code.Next
141 case encoder.OpNumberPtr:
142 p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
143 if p == 0 {
144 b = appendNullComma(ctx, b)
145 code = code.Next
146 break
147 }
148 store(ctxptr, code.Idx, p)
149 fallthrough
150 case encoder.OpNumber:
151 bb, err := appendNumber(ctx, b, ptrToNumber(load(ctxptr, code.Idx)))
152 if err != nil {
153 return nil, err
154 }
155 b = appendComma(ctx, bb)
156 code = code.Next
157 case encoder.OpInterfacePtr:
158 p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
159 if p == 0 {
160 b = appendNullComma(ctx, b)
161 code = code.Next
162 break
163 }
164 store(ctxptr, code.Idx, p)
165 fallthrough
166 case encoder.OpInterface:
167 p := load(ctxptr, code.Idx)
168 if p == 0 {
169 b = appendNullComma(ctx, b)
170 code = code.Next
171 break
172 }
173 if recursiveLevel > encoder.StartDetectingCyclesAfter {
174 for _, seen := range ctx.SeenPtr {
175 if p == seen {
176 return nil, errUnsupportedValue(code, p)
177 }
178 }
179 }
180 ctx.SeenPtr = append(ctx.SeenPtr, p)
181 var (
182 typ *runtime.Type
183 ifacePtr unsafe.Pointer
184 )
185 up := ptrToUnsafePtr(p)
186 if code.Flags&encoder.NonEmptyInterfaceFlags != 0 {
187 iface := (*nonEmptyInterface)(up)
188 ifacePtr = iface.ptr
189 if iface.itab != nil {
190 typ = iface.itab.typ
191 }
192 } else {
193 iface := (*emptyInterface)(up)
194 ifacePtr = iface.ptr
195 typ = iface.typ
196 }
197 if ifacePtr == nil {
198 isDirectedNil := typ != nil && typ.Kind() == reflect.Struct && !runtime.IfaceIndir(typ)
199 if !isDirectedNil {
200 b = appendNullComma(ctx, b)
201 code = code.Next
202 break
203 }
204 }
205 ctx.KeepRefs = append(ctx.KeepRefs, up)
206 ifaceCodeSet, err := encoder.CompileToGetCodeSet(ctx, uintptr(unsafe.Pointer(typ)))
207 if err != nil {
208 return nil, err
209 }
210
211 totalLength := uintptr(code.Length) + 3
212 nextTotalLength := uintptr(ifaceCodeSet.CodeLength) + 3
213
214 var c *encoder.Opcode
215 if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 {
216 c = ifaceCodeSet.InterfaceEscapeKeyCode
217 } else {
218 c = ifaceCodeSet.InterfaceNoescapeKeyCode
219 }
220 curlen := uintptr(len(ctx.Ptrs))
221 offsetNum := ptrOffset / uintptrSize
222 oldOffset := ptrOffset
223 ptrOffset += totalLength * uintptrSize
224 oldBaseIndent := ctx.BaseIndent
225 ctx.BaseIndent += code.Indent
226
227 newLen := offsetNum + totalLength + nextTotalLength
228 if curlen < newLen {
229 ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...)
230 }
231 ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr
232
233 end := ifaceCodeSet.EndCode
234 store(ctxptr, c.Idx, uintptr(ifacePtr))
235 store(ctxptr, end.Idx, oldOffset)
236 store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next)))
237 storeIndent(ctxptr, end, uintptr(oldBaseIndent))
238 code = c
239 recursiveLevel++
240 case encoder.OpInterfaceEnd:
241 recursiveLevel--
242
243 // restore ctxptr
244 offset := load(ctxptr, code.Idx)
245 restoreIndent(ctx, code, ctxptr)
246 ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1]
247
248 codePtr := load(ctxptr, code.ElemIdx)
249 code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr))
250 ctxptr = ctx.Ptr() + offset
251 ptrOffset = offset
252 case encoder.OpMarshalJSONPtr:
253 p := load(ctxptr, code.Idx)
254 if p == 0 {
255 b = appendNullComma(ctx, b)
256 code = code.Next
257 break
258 }
259 store(ctxptr, code.Idx, ptrToPtr(p))
260 fallthrough
261 case encoder.OpMarshalJSON:
262 p := load(ctxptr, code.Idx)
263 if p == 0 {
264 b = appendNullComma(ctx, b)
265 code = code.Next
266 break
267 }
268 if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
269 p = ptrToPtr(p)
270 }
271 bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
272 if err != nil {
273 return nil, err
274 }
275 b = appendComma(ctx, bb)
276 code = code.Next
277 case encoder.OpMarshalTextPtr:
278 p := load(ctxptr, code.Idx)
279 if p == 0 {
280 b = appendNullComma(ctx, b)
281 code = code.Next
282 break
283 }
284 store(ctxptr, code.Idx, ptrToPtr(p))
285 fallthrough
286 case encoder.OpMarshalText:
287 p := load(ctxptr, code.Idx)
288 if p == 0 {
289 b = append(b, `""`...)
290 b = appendComma(ctx, b)
291 code = code.Next
292 break
293 }
294 if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
295 p = ptrToPtr(p)
296 }
297 bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
298 if err != nil {
299 return nil, err
300 }
301 b = appendComma(ctx, bb)
302 code = code.Next
303 case encoder.OpSlicePtr:
304 p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
305 if p == 0 {
306 b = appendNullComma(ctx, b)
307 code = code.End.Next
308 break
309 }
310 store(ctxptr, code.Idx, p)
311 fallthrough
312 case encoder.OpSlice:
313 p := load(ctxptr, code.Idx)
314 slice := ptrToSlice(p)
315 if p == 0 || slice.Data == nil {
316 b = appendNullComma(ctx, b)
317 code = code.End.Next
318 break
319 }
320 store(ctxptr, code.ElemIdx, 0)
321 store(ctxptr, code.Length, uintptr(slice.Len))
322 store(ctxptr, code.Idx, uintptr(slice.Data))
323 if slice.Len > 0 {
324 b = appendArrayHead(ctx, code, b)
325 code = code.Next
326 store(ctxptr, code.Idx, uintptr(slice.Data))
327 } else {
328 b = appendEmptyArray(ctx, b)
329 code = code.End.Next
330 }
331 case encoder.OpSliceElem:
332 idx := load(ctxptr, code.ElemIdx)
333 length := load(ctxptr, code.Length)
334 idx++
335 if idx < length {
336 b = appendArrayElemIndent(ctx, code, b)
337 store(ctxptr, code.ElemIdx, idx)
338 data := load(ctxptr, code.Idx)
339 size := uintptr(code.Size)
340 code = code.Next
341 store(ctxptr, code.Idx, data+idx*size)
342 } else {
343 b = appendArrayEnd(ctx, code, b)
344 code = code.End.Next
345 }
346 case encoder.OpArrayPtr:
347 p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
348 if p == 0 {
349 b = appendNullComma(ctx, b)
350 code = code.End.Next
351 break
352 }
353 store(ctxptr, code.Idx, p)
354 fallthrough
355 case encoder.OpArray:
356 p := load(ctxptr, code.Idx)
357 if p == 0 {
358 b = appendNullComma(ctx, b)
359 code = code.End.Next
360 break
361 }
362 if code.Length > 0 {
363 b = appendArrayHead(ctx, code, b)
364 store(ctxptr, code.ElemIdx, 0)
365 code = code.Next
366 store(ctxptr, code.Idx, p)
367 } else {
368 b = appendEmptyArray(ctx, b)
369 code = code.End.Next
370 }
371 case encoder.OpArrayElem:
372 idx := load(ctxptr, code.ElemIdx)
373 idx++
374 if idx < uintptr(code.Length) {
375 b = appendArrayElemIndent(ctx, code, b)
376 store(ctxptr, code.ElemIdx, idx)
377 p := load(ctxptr, code.Idx)
378 size := uintptr(code.Size)
379 code = code.Next
380 store(ctxptr, code.Idx, p+idx*size)
381 } else {
382 b = appendArrayEnd(ctx, code, b)
383 code = code.End.Next
384 }
385 case encoder.OpMapPtr:
386 p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
387 if p == 0 {
388 b = appendNullComma(ctx, b)
389 code = code.End.Next
390 break
391 }
392 store(ctxptr, code.Idx, p)
393 fallthrough
394 case encoder.OpMap:
395 p := load(ctxptr, code.Idx)
396 if p == 0 {
397 b = appendNullComma(ctx, b)
398 code = code.End.Next
399 break
400 }
401 uptr := ptrToUnsafePtr(p)
402 mlen := maplen(uptr)
403 if mlen <= 0 {
404 b = appendEmptyObject(ctx, b)
405 code = code.End.Next
406 break
407 }
408 b = appendStructHead(ctx, b)
409 unorderedMap := (ctx.Option.Flag & encoder.UnorderedMapOption) != 0
410 mapCtx := encoder.NewMapContext(mlen, unorderedMap)
411 mapiterinit(code.Type, uptr, &mapCtx.Iter)
412 store(ctxptr, code.Idx, uintptr(unsafe.Pointer(mapCtx)))
413 ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx))
414 if unorderedMap {
415 b = appendMapKeyIndent(ctx, code.Next, b)
416 } else {
417 mapCtx.Start = len(b)
418 mapCtx.First = len(b)
419 }
420 key := mapiterkey(&mapCtx.Iter)
421 store(ctxptr, code.Next.Idx, uintptr(key))
422 code = code.Next
423 case encoder.OpMapKey:
424 mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
425 idx := mapCtx.Idx
426 idx++
427 if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
428 if idx < mapCtx.Len {
429 b = appendMapKeyIndent(ctx, code, b)
430 mapCtx.Idx = int(idx)
431 key := mapiterkey(&mapCtx.Iter)
432 store(ctxptr, code.Next.Idx, uintptr(key))
433 code = code.Next
434 } else {
435 b = appendObjectEnd(ctx, code, b)
436 encoder.ReleaseMapContext(mapCtx)
437 code = code.End.Next
438 }
439 } else {
440 mapCtx.Slice.Items[mapCtx.Idx].Value = b[mapCtx.Start:len(b)]
441 if idx < mapCtx.Len {
442 mapCtx.Idx = int(idx)
443 mapCtx.Start = len(b)
444 key := mapiterkey(&mapCtx.Iter)
445 store(ctxptr, code.Next.Idx, uintptr(key))
446 code = code.Next
447 } else {
448 code = code.End
449 }
450 }
451 case encoder.OpMapValue:
452 mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
453 if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
454 b = appendColon(ctx, b)
455 } else {
456 mapCtx.Slice.Items[mapCtx.Idx].Key = b[mapCtx.Start:len(b)]
457 mapCtx.Start = len(b)
458 }
459 value := mapitervalue(&mapCtx.Iter)
460 store(ctxptr, code.Next.Idx, uintptr(value))
461 mapiternext(&mapCtx.Iter)
462 code = code.Next
463 case encoder.OpMapEnd:
464 // this operation only used by sorted map.
465 mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
466 sort.Sort(mapCtx.Slice)
467 buf := mapCtx.Buf
468 for _, item := range mapCtx.Slice.Items {
469 buf = appendMapKeyValue(ctx, code, buf, item.Key, item.Value)
470 }
471 buf = appendMapEnd(ctx, code, buf)
472 b = b[:mapCtx.First]
473 b = append(b, buf...)
474 mapCtx.Buf = buf
475 encoder.ReleaseMapContext(mapCtx)
476 code = code.Next
477 case encoder.OpRecursivePtr:
478 p := load(ctxptr, code.Idx)
479 if p == 0 {
480 code = code.Next
481 break
482 }
483 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
484 fallthrough
485 case encoder.OpRecursive:
486 ptr := load(ctxptr, code.Idx)
487 if ptr != 0 {
488 if recursiveLevel > encoder.StartDetectingCyclesAfter {
489 for _, seen := range ctx.SeenPtr {
490 if ptr == seen {
491 return nil, errUnsupportedValue(code, ptr)
492 }
493 }
494 }
495 }
496 ctx.SeenPtr = append(ctx.SeenPtr, ptr)
497 c := code.Jmp.Code
498 curlen := uintptr(len(ctx.Ptrs))
499 offsetNum := ptrOffset / uintptrSize
500 oldOffset := ptrOffset
501 ptrOffset += code.Jmp.CurLen * uintptrSize
502 oldBaseIndent := ctx.BaseIndent
503 indentDiffFromTop := c.Indent - 1
504 ctx.BaseIndent += code.Indent - indentDiffFromTop
505
506 newLen := offsetNum + code.Jmp.CurLen + code.Jmp.NextLen
507 if curlen < newLen {
508 ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...)
509 }
510 ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr
511
512 store(ctxptr, c.Idx, ptr)
513 store(ctxptr, c.End.Next.Idx, oldOffset)
514 store(ctxptr, c.End.Next.ElemIdx, uintptr(unsafe.Pointer(code.Next)))
515 storeIndent(ctxptr, c.End.Next, uintptr(oldBaseIndent))
516 code = c
517 recursiveLevel++
518 case encoder.OpRecursiveEnd:
519 recursiveLevel--
520
521 // restore ctxptr
522 restoreIndent(ctx, code, ctxptr)
523 offset := load(ctxptr, code.Idx)
524 ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1]
525
526 codePtr := load(ctxptr, code.ElemIdx)
527 code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr))
528 ctxptr = ctx.Ptr() + offset
529 ptrOffset = offset
530 case encoder.OpStructPtrHead:
531 p := load(ctxptr, code.Idx)
532 if p == 0 {
533 if code.Flags&encoder.AnonymousHeadFlags == 0 {
534 b = appendNullComma(ctx, b)
535 }
536 code = code.End.Next
537 break
538 }
539 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
540 fallthrough
541 case encoder.OpStructHead:
542 p := load(ctxptr, code.Idx)
543 if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) {
544 if code.Flags&encoder.AnonymousHeadFlags == 0 {
545 b = appendNullComma(ctx, b)
546 }
547 code = code.End.Next
548 break
549 }
550 if code.Flags&encoder.AnonymousHeadFlags == 0 {
551 b = appendStructHead(ctx, b)
552 }
553 if len(code.Key) > 0 {
554 if (code.Flags&encoder.IsTaggedKeyFlags) != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 {
555 b = appendStructKey(ctx, code, b)
556 }
557 }
558 p += uintptr(code.Offset)
559 code = code.Next
560 store(ctxptr, code.Idx, p)
561 case encoder.OpStructPtrHeadOmitEmpty:
562 p := load(ctxptr, code.Idx)
563 if p == 0 {
564 if code.Flags&encoder.AnonymousHeadFlags == 0 {
565 b = appendNullComma(ctx, b)
566 }
567 code = code.End.Next
568 break
569 }
570 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
571 fallthrough
572 case encoder.OpStructHeadOmitEmpty:
573 p := load(ctxptr, code.Idx)
574 if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) {
575 if code.Flags&encoder.AnonymousHeadFlags == 0 {
576 b = appendNullComma(ctx, b)
577 }
578 code = code.End.Next
579 break
580 }
581 if code.Flags&encoder.AnonymousHeadFlags == 0 {
582 b = appendStructHead(ctx, b)
583 }
584 p += uintptr(code.Offset)
585 if p == 0 || (ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0) {
586 code = code.NextField
587 } else {
588 b = appendStructKey(ctx, code, b)
589 code = code.Next
590 store(ctxptr, code.Idx, p)
591 }
592 case encoder.OpStructPtrHeadInt:
593 if (code.Flags & encoder.IndirectFlags) != 0 {
594 p := load(ctxptr, code.Idx)
595 if p == 0 {
596 if code.Flags&encoder.AnonymousHeadFlags == 0 {
597 b = appendNullComma(ctx, b)
598 }
599 code = code.End.Next
600 break
601 }
602 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
603 }
604 fallthrough
605 case encoder.OpStructHeadInt:
606 p := load(ctxptr, code.Idx)
607 if p == 0 {
608 if code.Flags&encoder.AnonymousHeadFlags == 0 {
609 b = appendNullComma(ctx, b)
610 }
611 code = code.End.Next
612 break
613 }
614 if code.Flags&encoder.AnonymousHeadFlags == 0 {
615 b = appendStructHead(ctx, b)
616 }
617 b = appendStructKey(ctx, code, b)
618 b = appendInt(ctx, b, p+uintptr(code.Offset), code)
619 b = appendComma(ctx, b)
620 code = code.Next
621 case encoder.OpStructPtrHeadOmitEmptyInt:
622 if (code.Flags & encoder.IndirectFlags) != 0 {
623 p := load(ctxptr, code.Idx)
624 if p == 0 {
625 if code.Flags&encoder.AnonymousHeadFlags == 0 {
626 b = appendNullComma(ctx, b)
627 }
628 code = code.End.Next
629 break
630 }
631 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
632 }
633 fallthrough
634 case encoder.OpStructHeadOmitEmptyInt:
635 p := load(ctxptr, code.Idx)
636 if p == 0 {
637 if code.Flags&encoder.AnonymousHeadFlags == 0 {
638 b = appendNullComma(ctx, b)
639 }
640 code = code.End.Next
641 break
642 }
643 if code.Flags&encoder.AnonymousHeadFlags == 0 {
644 b = appendStructHead(ctx, b)
645 }
646 u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
647 v := u64 & ((1 << code.NumBitSize) - 1)
648 if v == 0 {
649 code = code.NextField
650 } else {
651 b = appendStructKey(ctx, code, b)
652 b = appendInt(ctx, b, p+uintptr(code.Offset), code)
653 b = appendComma(ctx, b)
654 code = code.Next
655 }
656 case encoder.OpStructPtrHeadIntString:
657 if (code.Flags & encoder.IndirectFlags) != 0 {
658 p := load(ctxptr, code.Idx)
659 if p == 0 {
660 if code.Flags&encoder.AnonymousHeadFlags == 0 {
661 b = appendNullComma(ctx, b)
662 }
663 code = code.End.Next
664 break
665 }
666 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
667 }
668 fallthrough
669 case encoder.OpStructHeadIntString:
670 p := load(ctxptr, code.Idx)
671 if p == 0 {
672 if code.Flags&encoder.AnonymousHeadFlags == 0 {
673 b = appendNullComma(ctx, b)
674 }
675 code = code.End.Next
676 break
677 }
678 if code.Flags&encoder.AnonymousHeadFlags == 0 {
679 b = appendStructHead(ctx, b)
680 }
681 b = appendStructKey(ctx, code, b)
682 b = append(b, '"')
683 b = appendInt(ctx, b, p+uintptr(code.Offset), code)
684 b = append(b, '"')
685 b = appendComma(ctx, b)
686 code = code.Next
687 case encoder.OpStructPtrHeadOmitEmptyIntString:
688 if (code.Flags & encoder.IndirectFlags) != 0 {
689 p := load(ctxptr, code.Idx)
690 if p == 0 {
691 if code.Flags&encoder.AnonymousHeadFlags == 0 {
692 b = appendNullComma(ctx, b)
693 }
694 code = code.End.Next
695 break
696 }
697 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
698 }
699 fallthrough
700 case encoder.OpStructHeadOmitEmptyIntString:
701 p := load(ctxptr, code.Idx)
702 if p == 0 {
703 if code.Flags&encoder.AnonymousHeadFlags == 0 {
704 b = appendNullComma(ctx, b)
705 }
706 code = code.End.Next
707 break
708 }
709 if code.Flags&encoder.AnonymousHeadFlags == 0 {
710 b = appendStructHead(ctx, b)
711 }
712 p += uintptr(code.Offset)
713 u64 := ptrToUint64(p, code.NumBitSize)
714 v := u64 & ((1 << code.NumBitSize) - 1)
715 if v == 0 {
716 code = code.NextField
717 } else {
718 b = appendStructKey(ctx, code, b)
719 b = append(b, '"')
720 b = appendInt(ctx, b, p, code)
721 b = append(b, '"')
722 b = appendComma(ctx, b)
723 code = code.Next
724 }
725 case encoder.OpStructPtrHeadIntPtr:
726 p := load(ctxptr, code.Idx)
727 if p == 0 {
728 if code.Flags&encoder.AnonymousHeadFlags == 0 {
729 b = appendNullComma(ctx, b)
730 }
731 code = code.End.Next
732 break
733 }
734 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
735 fallthrough
736 case encoder.OpStructHeadIntPtr:
737 p := load(ctxptr, code.Idx)
738 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
739 if code.Flags&encoder.AnonymousHeadFlags == 0 {
740 b = appendNullComma(ctx, b)
741 }
742 code = code.End.Next
743 break
744 }
745 if code.Flags&encoder.AnonymousHeadFlags == 0 {
746 b = appendStructHead(ctx, b)
747 }
748 b = appendStructKey(ctx, code, b)
749 if (code.Flags & encoder.IndirectFlags) != 0 {
750 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
751 }
752 if p == 0 {
753 b = appendNull(ctx, b)
754 } else {
755 b = appendInt(ctx, b, p, code)
756 }
757 b = appendComma(ctx, b)
758 code = code.Next
759 case encoder.OpStructPtrHeadOmitEmptyIntPtr:
760 p := load(ctxptr, code.Idx)
761 if p == 0 {
762 if code.Flags&encoder.AnonymousHeadFlags == 0 {
763 b = appendNullComma(ctx, b)
764 }
765 code = code.End.Next
766 break
767 }
768 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
769 fallthrough
770 case encoder.OpStructHeadOmitEmptyIntPtr:
771 p := load(ctxptr, code.Idx)
772 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
773 if code.Flags&encoder.AnonymousHeadFlags == 0 {
774 b = appendNullComma(ctx, b)
775 }
776 code = code.End.Next
777 break
778 }
779 if code.Flags&encoder.AnonymousHeadFlags == 0 {
780 b = appendStructHead(ctx, b)
781 }
782 if (code.Flags & encoder.IndirectFlags) != 0 {
783 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
784 }
785 if p != 0 {
786 b = appendStructKey(ctx, code, b)
787 b = appendInt(ctx, b, p, code)
788 b = appendComma(ctx, b)
789 }
790 code = code.Next
791 case encoder.OpStructPtrHeadIntPtrString:
792 p := load(ctxptr, code.Idx)
793 if p == 0 {
794 if code.Flags&encoder.AnonymousHeadFlags == 0 {
795 b = appendNullComma(ctx, b)
796 }
797 code = code.End.Next
798 break
799 }
800 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
801 fallthrough
802 case encoder.OpStructHeadIntPtrString:
803 p := load(ctxptr, code.Idx)
804 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
805 if code.Flags&encoder.AnonymousHeadFlags == 0 {
806 b = appendNullComma(ctx, b)
807 }
808 code = code.End.Next
809 break
810 }
811 if code.Flags&encoder.AnonymousHeadFlags == 0 {
812 b = appendStructHead(ctx, b)
813 }
814 b = appendStructKey(ctx, code, b)
815 if (code.Flags & encoder.IndirectFlags) != 0 {
816 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
817 }
818 if p == 0 {
819 b = appendNull(ctx, b)
820 } else {
821 b = append(b, '"')
822 b = appendInt(ctx, b, p, code)
823 b = append(b, '"')
824 }
825 b = appendComma(ctx, b)
826 code = code.Next
827 case encoder.OpStructPtrHeadOmitEmptyIntPtrString:
828 p := load(ctxptr, code.Idx)
829 if p == 0 {
830 if code.Flags&encoder.AnonymousHeadFlags == 0 {
831 b = appendNullComma(ctx, b)
832 }
833 code = code.End.Next
834 break
835 }
836 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
837 fallthrough
838 case encoder.OpStructHeadOmitEmptyIntPtrString:
839 p := load(ctxptr, code.Idx)
840 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
841 if code.Flags&encoder.AnonymousHeadFlags == 0 {
842 b = appendNullComma(ctx, b)
843 }
844 code = code.End.Next
845 break
846 }
847 if code.Flags&encoder.AnonymousHeadFlags == 0 {
848 b = appendStructHead(ctx, b)
849 }
850 if (code.Flags & encoder.IndirectFlags) != 0 {
851 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
852 }
853 if p != 0 {
854 b = appendStructKey(ctx, code, b)
855 b = append(b, '"')
856 b = appendInt(ctx, b, p, code)
857 b = append(b, '"')
858 b = appendComma(ctx, b)
859 }
860 code = code.Next
861 case encoder.OpStructPtrHeadUint:
862 if (code.Flags & encoder.IndirectFlags) != 0 {
863 p := load(ctxptr, code.Idx)
864 if p == 0 {
865 if code.Flags&encoder.AnonymousHeadFlags == 0 {
866 b = appendNullComma(ctx, b)
867 }
868 code = code.End.Next
869 break
870 }
871 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
872 }
873 fallthrough
874 case encoder.OpStructHeadUint:
875 p := load(ctxptr, code.Idx)
876 if p == 0 {
877 if code.Flags&encoder.AnonymousHeadFlags == 0 {
878 b = appendNullComma(ctx, b)
879 }
880 code = code.End.Next
881 break
882 }
883 if code.Flags&encoder.AnonymousHeadFlags == 0 {
884 b = appendStructHead(ctx, b)
885 }
886 b = appendStructKey(ctx, code, b)
887 b = appendUint(ctx, b, p+uintptr(code.Offset), code)
888 b = appendComma(ctx, b)
889 code = code.Next
890 case encoder.OpStructPtrHeadOmitEmptyUint:
891 if (code.Flags & encoder.IndirectFlags) != 0 {
892 p := load(ctxptr, code.Idx)
893 if p == 0 {
894 if code.Flags&encoder.AnonymousHeadFlags == 0 {
895 b = appendNullComma(ctx, b)
896 }
897 code = code.End.Next
898 break
899 }
900 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
901 }
902 fallthrough
903 case encoder.OpStructHeadOmitEmptyUint:
904 p := load(ctxptr, code.Idx)
905 if p == 0 {
906 if code.Flags&encoder.AnonymousHeadFlags == 0 {
907 b = appendNullComma(ctx, b)
908 }
909 code = code.End.Next
910 break
911 }
912 if code.Flags&encoder.AnonymousHeadFlags == 0 {
913 b = appendStructHead(ctx, b)
914 }
915 u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
916 v := u64 & ((1 << code.NumBitSize) - 1)
917 if v == 0 {
918 code = code.NextField
919 } else {
920 b = appendStructKey(ctx, code, b)
921 b = appendUint(ctx, b, p+uintptr(code.Offset), code)
922 b = appendComma(ctx, b)
923 code = code.Next
924 }
925 case encoder.OpStructPtrHeadUintString:
926 if (code.Flags & encoder.IndirectFlags) != 0 {
927 p := load(ctxptr, code.Idx)
928 if p == 0 {
929 if code.Flags&encoder.AnonymousHeadFlags == 0 {
930 b = appendNullComma(ctx, b)
931 }
932 code = code.End.Next
933 break
934 }
935 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
936 }
937 fallthrough
938 case encoder.OpStructHeadUintString:
939 p := load(ctxptr, code.Idx)
940 if p == 0 {
941 if code.Flags&encoder.AnonymousHeadFlags == 0 {
942 b = appendNullComma(ctx, b)
943 }
944 code = code.End.Next
945 break
946 }
947 if code.Flags&encoder.AnonymousHeadFlags == 0 {
948 b = appendStructHead(ctx, b)
949 }
950 b = appendStructKey(ctx, code, b)
951 b = append(b, '"')
952 b = appendUint(ctx, b, p+uintptr(code.Offset), code)
953 b = append(b, '"')
954 b = appendComma(ctx, b)
955 code = code.Next
956 case encoder.OpStructPtrHeadOmitEmptyUintString:
957 if (code.Flags & encoder.IndirectFlags) != 0 {
958 p := load(ctxptr, code.Idx)
959 if p == 0 {
960 if code.Flags&encoder.AnonymousHeadFlags == 0 {
961 b = appendNullComma(ctx, b)
962 }
963 code = code.End.Next
964 break
965 }
966 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
967 }
968 fallthrough
969 case encoder.OpStructHeadOmitEmptyUintString:
970 p := load(ctxptr, code.Idx)
971 if p == 0 {
972 if code.Flags&encoder.AnonymousHeadFlags == 0 {
973 b = appendNullComma(ctx, b)
974 }
975 code = code.End.Next
976 break
977 }
978 if code.Flags&encoder.AnonymousHeadFlags == 0 {
979 b = appendStructHead(ctx, b)
980 }
981 u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
982 v := u64 & ((1 << code.NumBitSize) - 1)
983 if v == 0 {
984 code = code.NextField
985 } else {
986 b = appendStructKey(ctx, code, b)
987 b = append(b, '"')
988 b = appendUint(ctx, b, p+uintptr(code.Offset), code)
989 b = append(b, '"')
990 b = appendComma(ctx, b)
991 code = code.Next
992 }
993 case encoder.OpStructPtrHeadUintPtr:
994 p := load(ctxptr, code.Idx)
995 if p == 0 {
996 if code.Flags&encoder.AnonymousHeadFlags == 0 {
997 b = appendNullComma(ctx, b)
998 }
999 code = code.End.Next
1000 break
1001 }
1002 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1003 fallthrough
1004 case encoder.OpStructHeadUintPtr:
1005 p := load(ctxptr, code.Idx)
1006 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
1007 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1008 b = appendNullComma(ctx, b)
1009 }
1010 code = code.End.Next
1011 break
1012 }
1013 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1014 b = appendStructHead(ctx, b)
1015 }
1016 b = appendStructKey(ctx, code, b)
1017 if (code.Flags & encoder.IndirectFlags) != 0 {
1018 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
1019 }
1020 if p == 0 {
1021 b = appendNull(ctx, b)
1022 } else {
1023 b = appendUint(ctx, b, p, code)
1024 }
1025 b = appendComma(ctx, b)
1026 code = code.Next
1027 case encoder.OpStructPtrHeadOmitEmptyUintPtr:
1028 p := load(ctxptr, code.Idx)
1029 if p == 0 {
1030 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1031 b = appendNullComma(ctx, b)
1032 }
1033 code = code.End.Next
1034 break
1035 }
1036 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1037 fallthrough
1038 case encoder.OpStructHeadOmitEmptyUintPtr:
1039 p := load(ctxptr, code.Idx)
1040 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
1041 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1042 b = appendNullComma(ctx, b)
1043 }
1044 code = code.End.Next
1045 break
1046 }
1047 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1048 b = appendStructHead(ctx, b)
1049 }
1050 if (code.Flags & encoder.IndirectFlags) != 0 {
1051 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
1052 }
1053 if p != 0 {
1054 b = appendStructKey(ctx, code, b)
1055 b = appendUint(ctx, b, p, code)
1056 b = appendComma(ctx, b)
1057 }
1058 code = code.Next
1059 case encoder.OpStructPtrHeadUintPtrString:
1060 p := load(ctxptr, code.Idx)
1061 if p == 0 {
1062 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1063 b = appendNullComma(ctx, b)
1064 }
1065 code = code.End.Next
1066 break
1067 }
1068 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1069 fallthrough
1070 case encoder.OpStructHeadUintPtrString:
1071 p := load(ctxptr, code.Idx)
1072 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
1073 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1074 b = appendNullComma(ctx, b)
1075 }
1076 code = code.End.Next
1077 break
1078 }
1079 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1080 b = appendStructHead(ctx, b)
1081 }
1082 b = appendStructKey(ctx, code, b)
1083 if (code.Flags & encoder.IndirectFlags) != 0 {
1084 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
1085 }
1086 if p == 0 {
1087 b = appendNull(ctx, b)
1088 } else {
1089 b = append(b, '"')
1090 b = appendUint(ctx, b, p, code)
1091 b = append(b, '"')
1092 }
1093 b = appendComma(ctx, b)
1094 code = code.Next
1095 case encoder.OpStructPtrHeadOmitEmptyUintPtrString:
1096 p := load(ctxptr, code.Idx)
1097 if p == 0 {
1098 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1099 b = appendNullComma(ctx, b)
1100 }
1101 code = code.End.Next
1102 break
1103 }
1104 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1105 fallthrough
1106 case encoder.OpStructHeadOmitEmptyUintPtrString:
1107 p := load(ctxptr, code.Idx)
1108 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
1109 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1110 b = appendNullComma(ctx, b)
1111 }
1112 code = code.End.Next
1113 break
1114 }
1115 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1116 b = appendStructHead(ctx, b)
1117 }
1118 if (code.Flags & encoder.IndirectFlags) != 0 {
1119 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
1120 }
1121 if p != 0 {
1122 b = appendStructKey(ctx, code, b)
1123 b = append(b, '"')
1124 b = appendUint(ctx, b, p, code)
1125 b = append(b, '"')
1126 b = appendComma(ctx, b)
1127 }
1128 code = code.Next
1129 case encoder.OpStructPtrHeadFloat32:
1130 if (code.Flags & encoder.IndirectFlags) != 0 {
1131 p := load(ctxptr, code.Idx)
1132 if p == 0 {
1133 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1134 b = appendNullComma(ctx, b)
1135 }
1136 code = code.End.Next
1137 break
1138 }
1139 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1140 }
1141 fallthrough
1142 case encoder.OpStructHeadFloat32:
1143 p := load(ctxptr, code.Idx)
1144 if p == 0 {
1145 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1146 b = appendNullComma(ctx, b)
1147 }
1148 code = code.End.Next
1149 break
1150 }
1151 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1152 b = appendStructHead(ctx, b)
1153 }
1154 b = appendStructKey(ctx, code, b)
1155 b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
1156 b = appendComma(ctx, b)
1157 code = code.Next
1158 case encoder.OpStructPtrHeadOmitEmptyFloat32:
1159 if (code.Flags & encoder.IndirectFlags) != 0 {
1160 p := load(ctxptr, code.Idx)
1161 if p == 0 {
1162 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1163 b = appendNullComma(ctx, b)
1164 }
1165 code = code.End.Next
1166 break
1167 }
1168 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1169 }
1170 fallthrough
1171 case encoder.OpStructHeadOmitEmptyFloat32:
1172 p := load(ctxptr, code.Idx)
1173 if p == 0 {
1174 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1175 b = appendNullComma(ctx, b)
1176 }
1177 code = code.End.Next
1178 break
1179 }
1180 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1181 b = appendStructHead(ctx, b)
1182 }
1183 v := ptrToFloat32(p + uintptr(code.Offset))
1184 if v == 0 {
1185 code = code.NextField
1186 } else {
1187 b = appendStructKey(ctx, code, b)
1188 b = appendFloat32(ctx, b, v)
1189 b = appendComma(ctx, b)
1190 code = code.Next
1191 }
1192 case encoder.OpStructPtrHeadFloat32String:
1193 if (code.Flags & encoder.IndirectFlags) != 0 {
1194 p := load(ctxptr, code.Idx)
1195 if p == 0 {
1196 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1197 b = appendNullComma(ctx, b)
1198 }
1199 code = code.End.Next
1200 break
1201 }
1202 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1203 }
1204 fallthrough
1205 case encoder.OpStructHeadFloat32String:
1206 p := load(ctxptr, code.Idx)
1207 if p == 0 {
1208 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1209 b = appendNullComma(ctx, b)
1210 }
1211 code = code.End.Next
1212 break
1213 }
1214 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1215 b = appendStructHead(ctx, b)
1216 }
1217 b = appendStructKey(ctx, code, b)
1218 b = append(b, '"')
1219 b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
1220 b = append(b, '"')
1221 b = appendComma(ctx, b)
1222 code = code.Next
1223 case encoder.OpStructPtrHeadOmitEmptyFloat32String:
1224 if (code.Flags & encoder.IndirectFlags) != 0 {
1225 p := load(ctxptr, code.Idx)
1226 if p == 0 {
1227 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1228 b = appendNullComma(ctx, b)
1229 }
1230 code = code.End.Next
1231 break
1232 }
1233 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1234 }
1235 fallthrough
1236 case encoder.OpStructHeadOmitEmptyFloat32String:
1237 p := load(ctxptr, code.Idx)
1238 if p == 0 {
1239 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1240 b = appendNullComma(ctx, b)
1241 }
1242 code = code.End.Next
1243 break
1244 }
1245 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1246 b = appendStructHead(ctx, b)
1247 }
1248 v := ptrToFloat32(p + uintptr(code.Offset))
1249 if v == 0 {
1250 code = code.NextField
1251 } else {
1252 b = appendStructKey(ctx, code, b)
1253 b = append(b, '"')
1254 b = appendFloat32(ctx, b, v)
1255 b = append(b, '"')
1256 b = appendComma(ctx, b)
1257 code = code.Next
1258 }
1259 case encoder.OpStructPtrHeadFloat32Ptr:
1260 p := load(ctxptr, code.Idx)
1261 if p == 0 {
1262 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1263 b = appendNullComma(ctx, b)
1264 }
1265 code = code.End.Next
1266 break
1267 }
1268 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1269 fallthrough
1270 case encoder.OpStructHeadFloat32Ptr:
1271 p := load(ctxptr, code.Idx)
1272 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
1273 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1274 b = appendNullComma(ctx, b)
1275 }
1276 code = code.End.Next
1277 break
1278 }
1279 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1280 b = appendStructHead(ctx, b)
1281 }
1282 b = appendStructKey(ctx, code, b)
1283 if (code.Flags & encoder.IndirectFlags) != 0 {
1284 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
1285 }
1286 if p == 0 {
1287 b = appendNull(ctx, b)
1288 } else {
1289 b = appendFloat32(ctx, b, ptrToFloat32(p))
1290 }
1291 b = appendComma(ctx, b)
1292 code = code.Next
1293 case encoder.OpStructPtrHeadOmitEmptyFloat32Ptr:
1294 p := load(ctxptr, code.Idx)
1295 if p == 0 {
1296 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1297 b = appendNullComma(ctx, b)
1298 }
1299 code = code.End.Next
1300 break
1301 }
1302 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1303 fallthrough
1304 case encoder.OpStructHeadOmitEmptyFloat32Ptr:
1305 p := load(ctxptr, code.Idx)
1306 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
1307 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1308 b = appendNullComma(ctx, b)
1309 }
1310 code = code.End.Next
1311 break
1312 }
1313 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1314 b = appendStructHead(ctx, b)
1315 }
1316 if (code.Flags & encoder.IndirectFlags) != 0 {
1317 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
1318 }
1319 if p != 0 {
1320 b = appendStructKey(ctx, code, b)
1321 b = appendFloat32(ctx, b, ptrToFloat32(p))
1322 b = appendComma(ctx, b)
1323 }
1324 code = code.Next
1325 case encoder.OpStructPtrHeadFloat32PtrString:
1326 p := load(ctxptr, code.Idx)
1327 if p == 0 {
1328 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1329 b = appendNullComma(ctx, b)
1330 }
1331 code = code.End.Next
1332 break
1333 }
1334 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1335 fallthrough
1336 case encoder.OpStructHeadFloat32PtrString:
1337 p := load(ctxptr, code.Idx)
1338 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
1339 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1340 b = appendNullComma(ctx, b)
1341 }
1342 code = code.End.Next
1343 break
1344 }
1345 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1346 b = appendStructHead(ctx, b)
1347 }
1348 b = appendStructKey(ctx, code, b)
1349 if (code.Flags & encoder.IndirectFlags) != 0 {
1350 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
1351 }
1352 if p == 0 {
1353 b = appendNull(ctx, b)
1354 } else {
1355 b = append(b, '"')
1356 b = appendFloat32(ctx, b, ptrToFloat32(p))
1357 b = append(b, '"')
1358 }
1359 b = appendComma(ctx, b)
1360 code = code.Next
1361 case encoder.OpStructPtrHeadOmitEmptyFloat32PtrString:
1362 p := load(ctxptr, code.Idx)
1363 if p == 0 {
1364 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1365 b = appendNullComma(ctx, b)
1366 }
1367 code = code.End.Next
1368 break
1369 }
1370 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1371 fallthrough
1372 case encoder.OpStructHeadOmitEmptyFloat32PtrString:
1373 p := load(ctxptr, code.Idx)
1374 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
1375 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1376 b = appendNullComma(ctx, b)
1377 }
1378 code = code.End.Next
1379 break
1380 }
1381 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1382 b = appendStructHead(ctx, b)
1383 }
1384 if (code.Flags & encoder.IndirectFlags) != 0 {
1385 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
1386 }
1387 if p != 0 {
1388 b = appendStructKey(ctx, code, b)
1389 b = append(b, '"')
1390 b = appendFloat32(ctx, b, ptrToFloat32(p))
1391 b = append(b, '"')
1392 b = appendComma(ctx, b)
1393 }
1394 code = code.Next
1395 case encoder.OpStructPtrHeadFloat64:
1396 if (code.Flags & encoder.IndirectFlags) != 0 {
1397 p := load(ctxptr, code.Idx)
1398 if p == 0 {
1399 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1400 b = appendNullComma(ctx, b)
1401 }
1402 code = code.End.Next
1403 break
1404 }
1405 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1406 }
1407 fallthrough
1408 case encoder.OpStructHeadFloat64:
1409 p := load(ctxptr, code.Idx)
1410 if p == 0 {
1411 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1412 b = appendNullComma(ctx, b)
1413 }
1414 code = code.End.Next
1415 break
1416 }
1417 v := ptrToFloat64(p + uintptr(code.Offset))
1418 if math.IsInf(v, 0) || math.IsNaN(v) {
1419 return nil, errUnsupportedFloat(v)
1420 }
1421 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1422 b = appendStructHead(ctx, b)
1423 }
1424 b = appendStructKey(ctx, code, b)
1425 b = appendFloat64(ctx, b, v)
1426 b = appendComma(ctx, b)
1427 code = code.Next
1428 case encoder.OpStructPtrHeadOmitEmptyFloat64:
1429 if (code.Flags & encoder.IndirectFlags) != 0 {
1430 p := load(ctxptr, code.Idx)
1431 if p == 0 {
1432 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1433 b = appendNullComma(ctx, b)
1434 }
1435 code = code.End.Next
1436 break
1437 }
1438 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1439 }
1440 fallthrough
1441 case encoder.OpStructHeadOmitEmptyFloat64:
1442 p := load(ctxptr, code.Idx)
1443 if p == 0 {
1444 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1445 b = appendNullComma(ctx, b)
1446 }
1447 code = code.End.Next
1448 break
1449 }
1450 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1451 b = appendStructHead(ctx, b)
1452 }
1453 v := ptrToFloat64(p + uintptr(code.Offset))
1454 if v == 0 {
1455 code = code.NextField
1456 } else {
1457 if math.IsInf(v, 0) || math.IsNaN(v) {
1458 return nil, errUnsupportedFloat(v)
1459 }
1460 b = appendStructKey(ctx, code, b)
1461 b = appendFloat64(ctx, b, v)
1462 b = appendComma(ctx, b)
1463 code = code.Next
1464 }
1465 case encoder.OpStructPtrHeadFloat64String:
1466 if (code.Flags & encoder.IndirectFlags) != 0 {
1467 p := load(ctxptr, code.Idx)
1468 if p == 0 {
1469 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1470 b = appendNullComma(ctx, b)
1471 }
1472 code = code.End.Next
1473 break
1474 }
1475 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1476 }
1477 fallthrough
1478 case encoder.OpStructHeadFloat64String:
1479 p := load(ctxptr, code.Idx)
1480 if p == 0 {
1481 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1482 b = appendNullComma(ctx, b)
1483 }
1484 code = code.End.Next
1485 break
1486 }
1487 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1488 b = appendStructHead(ctx, b)
1489 }
1490 v := ptrToFloat64(p + uintptr(code.Offset))
1491 if math.IsInf(v, 0) || math.IsNaN(v) {
1492 return nil, errUnsupportedFloat(v)
1493 }
1494 b = appendStructKey(ctx, code, b)
1495 b = append(b, '"')
1496 b = appendFloat64(ctx, b, v)
1497 b = append(b, '"')
1498 b = appendComma(ctx, b)
1499 code = code.Next
1500 case encoder.OpStructPtrHeadOmitEmptyFloat64String:
1501 if (code.Flags & encoder.IndirectFlags) != 0 {
1502 p := load(ctxptr, code.Idx)
1503 if p == 0 {
1504 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1505 b = appendNullComma(ctx, b)
1506 }
1507 code = code.End.Next
1508 break
1509 }
1510 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1511 }
1512 fallthrough
1513 case encoder.OpStructHeadOmitEmptyFloat64String:
1514 p := load(ctxptr, code.Idx)
1515 if p == 0 {
1516 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1517 b = appendNullComma(ctx, b)
1518 }
1519 code = code.End.Next
1520 break
1521 }
1522 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1523 b = appendStructHead(ctx, b)
1524 }
1525 v := ptrToFloat64(p + uintptr(code.Offset))
1526 if v == 0 {
1527 code = code.NextField
1528 } else {
1529 if math.IsInf(v, 0) || math.IsNaN(v) {
1530 return nil, errUnsupportedFloat(v)
1531 }
1532 b = appendStructKey(ctx, code, b)
1533 b = append(b, '"')
1534 b = appendFloat64(ctx, b, v)
1535 b = append(b, '"')
1536 b = appendComma(ctx, b)
1537 code = code.Next
1538 }
1539 case encoder.OpStructPtrHeadFloat64Ptr:
1540 p := load(ctxptr, code.Idx)
1541 if p == 0 {
1542 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1543 b = appendNullComma(ctx, b)
1544 }
1545 code = code.End.Next
1546 break
1547 }
1548 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1549 fallthrough
1550 case encoder.OpStructHeadFloat64Ptr:
1551 p := load(ctxptr, code.Idx)
1552 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
1553 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1554 b = appendNullComma(ctx, b)
1555 }
1556 code = code.End.Next
1557 break
1558 }
1559 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1560 b = appendStructHead(ctx, b)
1561 }
1562 b = appendStructKey(ctx, code, b)
1563 if (code.Flags & encoder.IndirectFlags) != 0 {
1564 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
1565 }
1566 if p == 0 {
1567 b = appendNull(ctx, b)
1568 } else {
1569 v := ptrToFloat64(p)
1570 if math.IsInf(v, 0) || math.IsNaN(v) {
1571 return nil, errUnsupportedFloat(v)
1572 }
1573 b = appendFloat64(ctx, b, v)
1574 }
1575 b = appendComma(ctx, b)
1576 code = code.Next
1577 case encoder.OpStructPtrHeadOmitEmptyFloat64Ptr:
1578 p := load(ctxptr, code.Idx)
1579 if p == 0 {
1580 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1581 b = appendNullComma(ctx, b)
1582 }
1583 code = code.End.Next
1584 break
1585 }
1586 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1587 fallthrough
1588 case encoder.OpStructHeadOmitEmptyFloat64Ptr:
1589 p := load(ctxptr, code.Idx)
1590 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
1591 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1592 b = appendNullComma(ctx, b)
1593 }
1594 code = code.End.Next
1595 break
1596 }
1597 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1598 b = appendStructHead(ctx, b)
1599 }
1600 if (code.Flags & encoder.IndirectFlags) != 0 {
1601 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
1602 }
1603 if p != 0 {
1604 b = appendStructKey(ctx, code, b)
1605 v := ptrToFloat64(p)
1606 if math.IsInf(v, 0) || math.IsNaN(v) {
1607 return nil, errUnsupportedFloat(v)
1608 }
1609 b = appendFloat64(ctx, b, v)
1610 b = appendComma(ctx, b)
1611 }
1612 code = code.Next
1613 case encoder.OpStructPtrHeadFloat64PtrString:
1614 p := load(ctxptr, code.Idx)
1615 if p == 0 {
1616 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1617 b = appendNullComma(ctx, b)
1618 }
1619 code = code.End.Next
1620 break
1621 }
1622 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1623 fallthrough
1624 case encoder.OpStructHeadFloat64PtrString:
1625 p := load(ctxptr, code.Idx)
1626 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
1627 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1628 b = appendNullComma(ctx, b)
1629 }
1630 code = code.End.Next
1631 break
1632 }
1633 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1634 b = appendStructHead(ctx, b)
1635 }
1636 b = appendStructKey(ctx, code, b)
1637 if (code.Flags & encoder.IndirectFlags) != 0 {
1638 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
1639 }
1640 if p == 0 {
1641 b = appendNull(ctx, b)
1642 } else {
1643 b = append(b, '"')
1644 v := ptrToFloat64(p)
1645 if math.IsInf(v, 0) || math.IsNaN(v) {
1646 return nil, errUnsupportedFloat(v)
1647 }
1648 b = appendFloat64(ctx, b, v)
1649 b = append(b, '"')
1650 }
1651 b = appendComma(ctx, b)
1652 code = code.Next
1653 case encoder.OpStructPtrHeadOmitEmptyFloat64PtrString:
1654 p := load(ctxptr, code.Idx)
1655 if p == 0 {
1656 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1657 b = appendNullComma(ctx, b)
1658 }
1659 code = code.End.Next
1660 break
1661 }
1662 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1663 fallthrough
1664 case encoder.OpStructHeadOmitEmptyFloat64PtrString:
1665 p := load(ctxptr, code.Idx)
1666 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
1667 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1668 b = appendNullComma(ctx, b)
1669 }
1670 code = code.End.Next
1671 break
1672 }
1673 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1674 b = appendStructHead(ctx, b)
1675 }
1676 if (code.Flags & encoder.IndirectFlags) != 0 {
1677 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
1678 }
1679 if p != 0 {
1680 b = appendStructKey(ctx, code, b)
1681 b = append(b, '"')
1682 v := ptrToFloat64(p)
1683 if math.IsInf(v, 0) || math.IsNaN(v) {
1684 return nil, errUnsupportedFloat(v)
1685 }
1686 b = appendFloat64(ctx, b, v)
1687 b = append(b, '"')
1688 b = appendComma(ctx, b)
1689 }
1690 code = code.Next
1691 case encoder.OpStructPtrHeadString:
1692 if (code.Flags & encoder.IndirectFlags) != 0 {
1693 p := load(ctxptr, code.Idx)
1694 if p == 0 {
1695 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1696 b = appendNullComma(ctx, b)
1697 }
1698 code = code.End.Next
1699 break
1700 }
1701 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1702 }
1703 fallthrough
1704 case encoder.OpStructHeadString:
1705 p := load(ctxptr, code.Idx)
1706 if p == 0 {
1707 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1708 b = appendNull(ctx, b)
1709 b = appendComma(ctx, b)
1710 }
1711 code = code.End.Next
1712 break
1713 }
1714 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1715 b = appendStructHead(ctx, b)
1716 }
1717 b = appendStructKey(ctx, code, b)
1718 b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset)))
1719 b = appendComma(ctx, b)
1720 code = code.Next
1721 case encoder.OpStructPtrHeadOmitEmptyString:
1722 if (code.Flags & encoder.IndirectFlags) != 0 {
1723 p := load(ctxptr, code.Idx)
1724 if p == 0 {
1725 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1726 b = appendNullComma(ctx, b)
1727 }
1728 code = code.End.Next
1729 break
1730 }
1731 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1732 }
1733 fallthrough
1734 case encoder.OpStructHeadOmitEmptyString:
1735 p := load(ctxptr, code.Idx)
1736 if p == 0 {
1737 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1738 b = appendNullComma(ctx, b)
1739 }
1740 code = code.End.Next
1741 break
1742 }
1743 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1744 b = appendStructHead(ctx, b)
1745 }
1746 v := ptrToString(p + uintptr(code.Offset))
1747 if v == "" {
1748 code = code.NextField
1749 } else {
1750 b = appendStructKey(ctx, code, b)
1751 b = appendString(ctx, b, v)
1752 b = appendComma(ctx, b)
1753 code = code.Next
1754 }
1755 case encoder.OpStructPtrHeadStringString:
1756 if (code.Flags & encoder.IndirectFlags) != 0 {
1757 p := load(ctxptr, code.Idx)
1758 if p == 0 {
1759 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1760 b = appendNullComma(ctx, b)
1761 }
1762 code = code.End.Next
1763 break
1764 }
1765 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1766 }
1767 fallthrough
1768 case encoder.OpStructHeadStringString:
1769 p := load(ctxptr, code.Idx)
1770 if p == 0 {
1771 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1772 b = appendNullComma(ctx, b)
1773 }
1774 code = code.End.Next
1775 break
1776 }
1777 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1778 b = appendStructHead(ctx, b)
1779 }
1780 b = appendStructKey(ctx, code, b)
1781 b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p+uintptr(code.Offset)))))
1782 b = appendComma(ctx, b)
1783 code = code.Next
1784 case encoder.OpStructPtrHeadOmitEmptyStringString:
1785 if (code.Flags & encoder.IndirectFlags) != 0 {
1786 p := load(ctxptr, code.Idx)
1787 if p == 0 {
1788 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1789 b = appendNullComma(ctx, b)
1790 }
1791 code = code.End.Next
1792 break
1793 }
1794 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1795 }
1796 fallthrough
1797 case encoder.OpStructHeadOmitEmptyStringString:
1798 p := load(ctxptr, code.Idx)
1799 if p == 0 {
1800 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1801 b = appendNullComma(ctx, b)
1802 }
1803 code = code.End.Next
1804 break
1805 }
1806 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1807 b = appendStructHead(ctx, b)
1808 }
1809 v := ptrToString(p + uintptr(code.Offset))
1810 if v == "" {
1811 code = code.NextField
1812 } else {
1813 b = appendStructKey(ctx, code, b)
1814 b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
1815 b = appendComma(ctx, b)
1816 code = code.Next
1817 }
1818 case encoder.OpStructPtrHeadStringPtr:
1819 p := load(ctxptr, code.Idx)
1820 if p == 0 {
1821 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1822 b = appendNullComma(ctx, b)
1823 }
1824 code = code.End.Next
1825 break
1826 }
1827 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1828 fallthrough
1829 case encoder.OpStructHeadStringPtr:
1830 p := load(ctxptr, code.Idx)
1831 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
1832 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1833 b = appendNullComma(ctx, b)
1834 }
1835 code = code.End.Next
1836 break
1837 }
1838 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1839 b = appendStructHead(ctx, b)
1840 }
1841 b = appendStructKey(ctx, code, b)
1842 if (code.Flags & encoder.IndirectFlags) != 0 {
1843 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
1844 }
1845 if p == 0 {
1846 b = appendNull(ctx, b)
1847 } else {
1848 b = appendString(ctx, b, ptrToString(p))
1849 }
1850 b = appendComma(ctx, b)
1851 code = code.Next
1852 case encoder.OpStructPtrHeadOmitEmptyStringPtr:
1853 p := load(ctxptr, code.Idx)
1854 if p == 0 {
1855 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1856 b = appendNullComma(ctx, b)
1857 }
1858 code = code.End.Next
1859 break
1860 }
1861 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1862 fallthrough
1863 case encoder.OpStructHeadOmitEmptyStringPtr:
1864 p := load(ctxptr, code.Idx)
1865 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
1866 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1867 b = appendNullComma(ctx, b)
1868 }
1869 code = code.End.Next
1870 break
1871 }
1872 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1873 b = appendStructHead(ctx, b)
1874 }
1875 if (code.Flags & encoder.IndirectFlags) != 0 {
1876 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
1877 }
1878 if p != 0 {
1879 b = appendStructKey(ctx, code, b)
1880 b = appendString(ctx, b, ptrToString(p))
1881 b = appendComma(ctx, b)
1882 }
1883 code = code.Next
1884 case encoder.OpStructPtrHeadStringPtrString:
1885 p := load(ctxptr, code.Idx)
1886 if p == 0 {
1887 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1888 b = appendNullComma(ctx, b)
1889 }
1890 code = code.End.Next
1891 break
1892 }
1893 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1894 fallthrough
1895 case encoder.OpStructHeadStringPtrString:
1896 p := load(ctxptr, code.Idx)
1897 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
1898 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1899 b = appendNullComma(ctx, b)
1900 }
1901 code = code.End.Next
1902 break
1903 }
1904 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1905 b = appendStructHead(ctx, b)
1906 }
1907 b = appendStructKey(ctx, code, b)
1908 if (code.Flags & encoder.IndirectFlags) != 0 {
1909 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
1910 }
1911 if p == 0 {
1912 b = appendNull(ctx, b)
1913 } else {
1914 b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
1915 }
1916 b = appendComma(ctx, b)
1917 code = code.Next
1918 case encoder.OpStructPtrHeadOmitEmptyStringPtrString:
1919 p := load(ctxptr, code.Idx)
1920 if p == 0 {
1921 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1922 b = appendNullComma(ctx, b)
1923 }
1924 code = code.End.Next
1925 break
1926 }
1927 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1928 fallthrough
1929 case encoder.OpStructHeadOmitEmptyStringPtrString:
1930 p := load(ctxptr, code.Idx)
1931 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
1932 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1933 b = appendNullComma(ctx, b)
1934 }
1935 code = code.End.Next
1936 break
1937 }
1938 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1939 b = appendStructHead(ctx, b)
1940 }
1941 if (code.Flags & encoder.IndirectFlags) != 0 {
1942 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
1943 }
1944 if p != 0 {
1945 b = appendStructKey(ctx, code, b)
1946 b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
1947 b = appendComma(ctx, b)
1948 }
1949 code = code.Next
1950 case encoder.OpStructPtrHeadBool:
1951 if (code.Flags & encoder.IndirectFlags) != 0 {
1952 p := load(ctxptr, code.Idx)
1953 if p == 0 {
1954 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1955 b = appendNullComma(ctx, b)
1956 }
1957 code = code.End.Next
1958 break
1959 }
1960 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1961 }
1962 fallthrough
1963 case encoder.OpStructHeadBool:
1964 p := load(ctxptr, code.Idx)
1965 if p == 0 {
1966 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1967 b = appendNullComma(ctx, b)
1968 }
1969 code = code.End.Next
1970 break
1971 }
1972 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1973 b = appendStructHead(ctx, b)
1974 }
1975 b = appendStructKey(ctx, code, b)
1976 b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
1977 b = appendComma(ctx, b)
1978 code = code.Next
1979 case encoder.OpStructPtrHeadOmitEmptyBool:
1980 if (code.Flags & encoder.IndirectFlags) != 0 {
1981 p := load(ctxptr, code.Idx)
1982 if p == 0 {
1983 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1984 b = appendNullComma(ctx, b)
1985 }
1986 code = code.End.Next
1987 break
1988 }
1989 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
1990 }
1991 fallthrough
1992 case encoder.OpStructHeadOmitEmptyBool:
1993 p := load(ctxptr, code.Idx)
1994 if p == 0 {
1995 if code.Flags&encoder.AnonymousHeadFlags == 0 {
1996 b = appendNullComma(ctx, b)
1997 }
1998 code = code.End.Next
1999 break
2000 }
2001 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2002 b = appendStructHead(ctx, b)
2003 }
2004 v := ptrToBool(p + uintptr(code.Offset))
2005 if v {
2006 b = appendStructKey(ctx, code, b)
2007 b = appendBool(ctx, b, v)
2008 b = appendComma(ctx, b)
2009 code = code.Next
2010 } else {
2011 code = code.NextField
2012 }
2013 case encoder.OpStructPtrHeadBoolString:
2014 if (code.Flags & encoder.IndirectFlags) != 0 {
2015 p := load(ctxptr, code.Idx)
2016 if p == 0 {
2017 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2018 b = appendNullComma(ctx, b)
2019 }
2020 code = code.End.Next
2021 break
2022 }
2023 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2024 }
2025 fallthrough
2026 case encoder.OpStructHeadBoolString:
2027 p := load(ctxptr, code.Idx)
2028 if p == 0 {
2029 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2030 b = appendNullComma(ctx, b)
2031 }
2032 code = code.End.Next
2033 break
2034 }
2035 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2036 b = appendStructHead(ctx, b)
2037 }
2038 b = appendStructKey(ctx, code, b)
2039 b = append(b, '"')
2040 b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
2041 b = append(b, '"')
2042 b = appendComma(ctx, b)
2043 code = code.Next
2044 case encoder.OpStructPtrHeadOmitEmptyBoolString:
2045 if (code.Flags & encoder.IndirectFlags) != 0 {
2046 p := load(ctxptr, code.Idx)
2047 if p == 0 {
2048 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2049 b = appendNullComma(ctx, b)
2050 }
2051 code = code.End.Next
2052 break
2053 }
2054 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2055 }
2056 fallthrough
2057 case encoder.OpStructHeadOmitEmptyBoolString:
2058 p := load(ctxptr, code.Idx)
2059 if p == 0 {
2060 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2061 b = appendNullComma(ctx, b)
2062 }
2063 code = code.End.Next
2064 break
2065 }
2066 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2067 b = appendStructHead(ctx, b)
2068 }
2069 v := ptrToBool(p + uintptr(code.Offset))
2070 if v {
2071 b = appendStructKey(ctx, code, b)
2072 b = append(b, '"')
2073 b = appendBool(ctx, b, v)
2074 b = append(b, '"')
2075 b = appendComma(ctx, b)
2076 code = code.Next
2077 } else {
2078 code = code.NextField
2079 }
2080 case encoder.OpStructPtrHeadBoolPtr:
2081 p := load(ctxptr, code.Idx)
2082 if p == 0 {
2083 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2084 b = appendNullComma(ctx, b)
2085 }
2086 code = code.End.Next
2087 break
2088 }
2089 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2090 fallthrough
2091 case encoder.OpStructHeadBoolPtr:
2092 p := load(ctxptr, code.Idx)
2093 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2094 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2095 b = appendNullComma(ctx, b)
2096 }
2097 code = code.End.Next
2098 break
2099 }
2100 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2101 b = appendStructHead(ctx, b)
2102 }
2103 b = appendStructKey(ctx, code, b)
2104 if (code.Flags & encoder.IndirectFlags) != 0 {
2105 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
2106 }
2107 if p == 0 {
2108 b = appendNull(ctx, b)
2109 } else {
2110 b = appendBool(ctx, b, ptrToBool(p))
2111 }
2112 b = appendComma(ctx, b)
2113 code = code.Next
2114 case encoder.OpStructPtrHeadOmitEmptyBoolPtr:
2115 p := load(ctxptr, code.Idx)
2116 if p == 0 {
2117 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2118 b = appendNullComma(ctx, b)
2119 }
2120 code = code.End.Next
2121 break
2122 }
2123 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2124 fallthrough
2125 case encoder.OpStructHeadOmitEmptyBoolPtr:
2126 p := load(ctxptr, code.Idx)
2127 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2128 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2129 b = appendNullComma(ctx, b)
2130 }
2131 code = code.End.Next
2132 break
2133 }
2134 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2135 b = appendStructHead(ctx, b)
2136 }
2137 if (code.Flags & encoder.IndirectFlags) != 0 {
2138 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
2139 }
2140 if p != 0 {
2141 b = appendStructKey(ctx, code, b)
2142 b = appendBool(ctx, b, ptrToBool(p))
2143 b = appendComma(ctx, b)
2144 }
2145 code = code.Next
2146 case encoder.OpStructPtrHeadBoolPtrString:
2147 p := load(ctxptr, code.Idx)
2148 if p == 0 {
2149 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2150 b = appendNullComma(ctx, b)
2151 }
2152 code = code.End.Next
2153 break
2154 }
2155 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2156 fallthrough
2157 case encoder.OpStructHeadBoolPtrString:
2158 p := load(ctxptr, code.Idx)
2159 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2160 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2161 b = appendNullComma(ctx, b)
2162 }
2163 code = code.End.Next
2164 break
2165 }
2166 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2167 b = appendStructHead(ctx, b)
2168 }
2169 b = appendStructKey(ctx, code, b)
2170 if (code.Flags & encoder.IndirectFlags) != 0 {
2171 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
2172 }
2173 if p == 0 {
2174 b = appendNull(ctx, b)
2175 } else {
2176 b = append(b, '"')
2177 b = appendBool(ctx, b, ptrToBool(p))
2178 b = append(b, '"')
2179 }
2180 b = appendComma(ctx, b)
2181 code = code.Next
2182 case encoder.OpStructPtrHeadOmitEmptyBoolPtrString:
2183 p := load(ctxptr, code.Idx)
2184 if p == 0 {
2185 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2186 b = appendNullComma(ctx, b)
2187 }
2188 code = code.End.Next
2189 break
2190 }
2191 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2192 fallthrough
2193 case encoder.OpStructHeadOmitEmptyBoolPtrString:
2194 p := load(ctxptr, code.Idx)
2195 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2196 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2197 b = appendNullComma(ctx, b)
2198 }
2199 code = code.End.Next
2200 break
2201 }
2202 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2203 b = appendStructHead(ctx, b)
2204 }
2205 if (code.Flags & encoder.IndirectFlags) != 0 {
2206 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
2207 }
2208 if p != 0 {
2209 b = appendStructKey(ctx, code, b)
2210 b = append(b, '"')
2211 b = appendBool(ctx, b, ptrToBool(p))
2212 b = append(b, '"')
2213 b = appendComma(ctx, b)
2214 }
2215 code = code.Next
2216 case encoder.OpStructPtrHeadBytes:
2217 if (code.Flags & encoder.IndirectFlags) != 0 {
2218 p := load(ctxptr, code.Idx)
2219 if p == 0 {
2220 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2221 b = appendNullComma(ctx, b)
2222 }
2223 code = code.End.Next
2224 break
2225 }
2226 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2227 }
2228 fallthrough
2229 case encoder.OpStructHeadBytes:
2230 p := load(ctxptr, code.Idx)
2231 if p == 0 {
2232 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2233 b = appendNullComma(ctx, b)
2234 }
2235 code = code.End.Next
2236 break
2237 }
2238 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2239 b = appendStructHead(ctx, b)
2240 }
2241 b = appendStructKey(ctx, code, b)
2242 b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset)))
2243 b = appendComma(ctx, b)
2244 code = code.Next
2245 case encoder.OpStructPtrHeadOmitEmptyBytes:
2246 if (code.Flags & encoder.IndirectFlags) != 0 {
2247 p := load(ctxptr, code.Idx)
2248 if p == 0 {
2249 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2250 b = appendNullComma(ctx, b)
2251 }
2252 code = code.End.Next
2253 break
2254 }
2255 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2256 }
2257 fallthrough
2258 case encoder.OpStructHeadOmitEmptyBytes:
2259 p := load(ctxptr, code.Idx)
2260 if p == 0 {
2261 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2262 b = appendNullComma(ctx, b)
2263 }
2264 code = code.End.Next
2265 break
2266 }
2267 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2268 b = appendStructHead(ctx, b)
2269 }
2270 v := ptrToBytes(p + uintptr(code.Offset))
2271 if len(v) == 0 {
2272 code = code.NextField
2273 } else {
2274 b = appendStructKey(ctx, code, b)
2275 b = appendByteSlice(ctx, b, v)
2276 b = appendComma(ctx, b)
2277 code = code.Next
2278 }
2279 case encoder.OpStructPtrHeadBytesPtr:
2280 p := load(ctxptr, code.Idx)
2281 if p == 0 {
2282 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2283 b = appendNullComma(ctx, b)
2284 }
2285 code = code.End.Next
2286 break
2287 }
2288 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2289 fallthrough
2290 case encoder.OpStructHeadBytesPtr:
2291 p := load(ctxptr, code.Idx)
2292 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2293 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2294 b = appendNullComma(ctx, b)
2295 }
2296 code = code.End.Next
2297 break
2298 }
2299 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2300 b = appendStructHead(ctx, b)
2301 }
2302 b = appendStructKey(ctx, code, b)
2303 if (code.Flags & encoder.IndirectFlags) != 0 {
2304 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
2305 }
2306 if p == 0 {
2307 b = appendNull(ctx, b)
2308 } else {
2309 b = appendByteSlice(ctx, b, ptrToBytes(p))
2310 }
2311 b = appendComma(ctx, b)
2312 code = code.Next
2313 case encoder.OpStructPtrHeadOmitEmptyBytesPtr:
2314 p := load(ctxptr, code.Idx)
2315 if p == 0 {
2316 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2317 b = appendNullComma(ctx, b)
2318 }
2319 code = code.End.Next
2320 break
2321 }
2322 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2323 fallthrough
2324 case encoder.OpStructHeadOmitEmptyBytesPtr:
2325 p := load(ctxptr, code.Idx)
2326 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2327 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2328 b = appendNullComma(ctx, b)
2329 }
2330 code = code.End.Next
2331 break
2332 }
2333 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2334 b = appendStructHead(ctx, b)
2335 }
2336 if (code.Flags & encoder.IndirectFlags) != 0 {
2337 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
2338 }
2339 if p != 0 {
2340 b = appendStructKey(ctx, code, b)
2341 b = appendByteSlice(ctx, b, ptrToBytes(p))
2342 b = appendComma(ctx, b)
2343 }
2344 code = code.Next
2345 case encoder.OpStructPtrHeadNumber:
2346 if (code.Flags & encoder.IndirectFlags) != 0 {
2347 p := load(ctxptr, code.Idx)
2348 if p == 0 {
2349 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2350 b = appendNullComma(ctx, b)
2351 }
2352 code = code.End.Next
2353 break
2354 }
2355 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2356 }
2357 fallthrough
2358 case encoder.OpStructHeadNumber:
2359 p := load(ctxptr, code.Idx)
2360 if p == 0 {
2361 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2362 b = appendNullComma(ctx, b)
2363 }
2364 code = code.End.Next
2365 break
2366 }
2367 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2368 b = appendStructHead(ctx, b)
2369 }
2370 b = appendStructKey(ctx, code, b)
2371 bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
2372 if err != nil {
2373 return nil, err
2374 }
2375 b = appendComma(ctx, bb)
2376 code = code.Next
2377 case encoder.OpStructPtrHeadOmitEmptyNumber:
2378 if (code.Flags & encoder.IndirectFlags) != 0 {
2379 p := load(ctxptr, code.Idx)
2380 if p == 0 {
2381 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2382 b = appendNullComma(ctx, b)
2383 }
2384 code = code.End.Next
2385 break
2386 }
2387 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2388 }
2389 fallthrough
2390 case encoder.OpStructHeadOmitEmptyNumber:
2391 p := load(ctxptr, code.Idx)
2392 if p == 0 {
2393 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2394 b = appendNullComma(ctx, b)
2395 }
2396 code = code.End.Next
2397 break
2398 }
2399 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2400 b = appendStructHead(ctx, b)
2401 }
2402 v := ptrToNumber(p + uintptr(code.Offset))
2403 if v == "" {
2404 code = code.NextField
2405 } else {
2406 b = appendStructKey(ctx, code, b)
2407 bb, err := appendNumber(ctx, b, v)
2408 if err != nil {
2409 return nil, err
2410 }
2411 b = appendComma(ctx, bb)
2412 code = code.Next
2413 }
2414 case encoder.OpStructPtrHeadNumberString:
2415 if (code.Flags & encoder.IndirectFlags) != 0 {
2416 p := load(ctxptr, code.Idx)
2417 if p == 0 {
2418 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2419 b = appendNullComma(ctx, b)
2420 }
2421 code = code.End.Next
2422 break
2423 }
2424 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2425 }
2426 fallthrough
2427 case encoder.OpStructHeadNumberString:
2428 p := load(ctxptr, code.Idx)
2429 if p == 0 {
2430 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2431 b = appendNullComma(ctx, b)
2432 }
2433 code = code.End.Next
2434 break
2435 }
2436 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2437 b = appendStructHead(ctx, b)
2438 }
2439 b = appendStructKey(ctx, code, b)
2440 b = append(b, '"')
2441 bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
2442 if err != nil {
2443 return nil, err
2444 }
2445 b = append(bb, '"')
2446 b = appendComma(ctx, b)
2447 code = code.Next
2448 case encoder.OpStructPtrHeadOmitEmptyNumberString:
2449 if (code.Flags & encoder.IndirectFlags) != 0 {
2450 p := load(ctxptr, code.Idx)
2451 if p == 0 {
2452 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2453 b = appendNullComma(ctx, b)
2454 }
2455 code = code.End.Next
2456 break
2457 }
2458 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2459 }
2460 fallthrough
2461 case encoder.OpStructHeadOmitEmptyNumberString:
2462 p := load(ctxptr, code.Idx)
2463 if p == 0 {
2464 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2465 b = appendNullComma(ctx, b)
2466 }
2467 code = code.End.Next
2468 break
2469 }
2470 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2471 b = appendStructHead(ctx, b)
2472 }
2473 v := ptrToNumber(p + uintptr(code.Offset))
2474 if v == "" {
2475 code = code.NextField
2476 } else {
2477 b = appendStructKey(ctx, code, b)
2478 b = append(b, '"')
2479 bb, err := appendNumber(ctx, b, v)
2480 if err != nil {
2481 return nil, err
2482 }
2483 b = append(bb, '"')
2484 b = appendComma(ctx, b)
2485 code = code.Next
2486 }
2487 case encoder.OpStructPtrHeadNumberPtr:
2488 p := load(ctxptr, code.Idx)
2489 if p == 0 {
2490 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2491 b = appendNullComma(ctx, b)
2492 }
2493 code = code.End.Next
2494 break
2495 }
2496 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2497 fallthrough
2498 case encoder.OpStructHeadNumberPtr:
2499 p := load(ctxptr, code.Idx)
2500 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2501 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2502 b = appendNullComma(ctx, b)
2503 }
2504 code = code.End.Next
2505 break
2506 }
2507 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2508 b = appendStructHead(ctx, b)
2509 }
2510 b = appendStructKey(ctx, code, b)
2511 if (code.Flags & encoder.IndirectFlags) != 0 {
2512 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
2513 }
2514 if p == 0 {
2515 b = appendNull(ctx, b)
2516 } else {
2517 bb, err := appendNumber(ctx, b, ptrToNumber(p))
2518 if err != nil {
2519 return nil, err
2520 }
2521 b = bb
2522 }
2523 b = appendComma(ctx, b)
2524 code = code.Next
2525 case encoder.OpStructPtrHeadOmitEmptyNumberPtr:
2526 p := load(ctxptr, code.Idx)
2527 if p == 0 {
2528 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2529 b = appendNullComma(ctx, b)
2530 }
2531 code = code.End.Next
2532 break
2533 }
2534 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2535 fallthrough
2536 case encoder.OpStructHeadOmitEmptyNumberPtr:
2537 p := load(ctxptr, code.Idx)
2538 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2539 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2540 b = appendNullComma(ctx, b)
2541 }
2542 code = code.End.Next
2543 break
2544 }
2545 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2546 b = appendStructHead(ctx, b)
2547 }
2548 if (code.Flags & encoder.IndirectFlags) != 0 {
2549 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
2550 }
2551 if p != 0 {
2552 b = appendStructKey(ctx, code, b)
2553 bb, err := appendNumber(ctx, b, ptrToNumber(p))
2554 if err != nil {
2555 return nil, err
2556 }
2557 b = appendComma(ctx, bb)
2558 }
2559 code = code.Next
2560 case encoder.OpStructPtrHeadNumberPtrString:
2561 p := load(ctxptr, code.Idx)
2562 if p == 0 {
2563 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2564 b = appendNullComma(ctx, b)
2565 }
2566 code = code.End.Next
2567 break
2568 }
2569 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2570 fallthrough
2571 case encoder.OpStructHeadNumberPtrString:
2572 p := load(ctxptr, code.Idx)
2573 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2574 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2575 b = appendNullComma(ctx, b)
2576 }
2577 code = code.End.Next
2578 break
2579 }
2580 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2581 b = appendStructHead(ctx, b)
2582 }
2583 b = appendStructKey(ctx, code, b)
2584 if (code.Flags & encoder.IndirectFlags) != 0 {
2585 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
2586 }
2587 if p == 0 {
2588 b = appendNull(ctx, b)
2589 } else {
2590 b = append(b, '"')
2591 bb, err := appendNumber(ctx, b, ptrToNumber(p))
2592 if err != nil {
2593 return nil, err
2594 }
2595 b = append(bb, '"')
2596 }
2597 b = appendComma(ctx, b)
2598 code = code.Next
2599 case encoder.OpStructPtrHeadOmitEmptyNumberPtrString:
2600 p := load(ctxptr, code.Idx)
2601 if p == 0 {
2602 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2603 b = appendNullComma(ctx, b)
2604 }
2605 code = code.End.Next
2606 break
2607 }
2608 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2609 fallthrough
2610 case encoder.OpStructHeadOmitEmptyNumberPtrString:
2611 p := load(ctxptr, code.Idx)
2612 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2613 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2614 b = appendNullComma(ctx, b)
2615 }
2616 code = code.End.Next
2617 break
2618 }
2619 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2620 b = appendStructHead(ctx, b)
2621 }
2622 if (code.Flags & encoder.IndirectFlags) != 0 {
2623 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
2624 }
2625 if p != 0 {
2626 b = appendStructKey(ctx, code, b)
2627 b = append(b, '"')
2628 bb, err := appendNumber(ctx, b, ptrToNumber(p))
2629 if err != nil {
2630 return nil, err
2631 }
2632 b = append(bb, '"')
2633 b = appendComma(ctx, b)
2634 }
2635 code = code.Next
2636 case encoder.OpStructPtrHeadArray, encoder.OpStructPtrHeadSlice:
2637 if (code.Flags & encoder.IndirectFlags) != 0 {
2638 p := load(ctxptr, code.Idx)
2639 if p == 0 {
2640 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2641 b = appendNullComma(ctx, b)
2642 }
2643 code = code.End.Next
2644 break
2645 }
2646 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2647 }
2648 fallthrough
2649 case encoder.OpStructHeadArray, encoder.OpStructHeadSlice:
2650 p := load(ctxptr, code.Idx)
2651 if p == 0 {
2652 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2653 b = appendNullComma(ctx, b)
2654 }
2655 code = code.End.Next
2656 break
2657 }
2658 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2659 b = appendStructHead(ctx, b)
2660 }
2661 b = appendStructKey(ctx, code, b)
2662 p += uintptr(code.Offset)
2663 code = code.Next
2664 store(ctxptr, code.Idx, p)
2665 case encoder.OpStructPtrHeadOmitEmptyArray:
2666 if (code.Flags & encoder.IndirectFlags) != 0 {
2667 p := load(ctxptr, code.Idx)
2668 if p == 0 {
2669 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2670 b = appendNullComma(ctx, b)
2671 }
2672 code = code.End.Next
2673 break
2674 }
2675 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2676 }
2677 fallthrough
2678 case encoder.OpStructHeadOmitEmptyArray:
2679 p := load(ctxptr, code.Idx)
2680 if p == 0 {
2681 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2682 b = appendNullComma(ctx, b)
2683 }
2684 code = code.End.Next
2685 break
2686 }
2687 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2688 b = appendStructHead(ctx, b)
2689 }
2690 p += uintptr(code.Offset)
2691 b = appendStructKey(ctx, code, b)
2692 code = code.Next
2693 store(ctxptr, code.Idx, p)
2694 case encoder.OpStructPtrHeadOmitEmptySlice:
2695 if (code.Flags & encoder.IndirectFlags) != 0 {
2696 p := load(ctxptr, code.Idx)
2697 if p == 0 {
2698 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2699 b = appendNullComma(ctx, b)
2700 }
2701 code = code.End.Next
2702 break
2703 }
2704 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2705 }
2706 fallthrough
2707 case encoder.OpStructHeadOmitEmptySlice:
2708 p := load(ctxptr, code.Idx)
2709 if p == 0 {
2710 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2711 b = appendNullComma(ctx, b)
2712 }
2713 code = code.End.Next
2714 break
2715 }
2716 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2717 b = appendStructHead(ctx, b)
2718 }
2719 p += uintptr(code.Offset)
2720 slice := ptrToSlice(p)
2721 if slice.Len == 0 {
2722 code = code.NextField
2723 } else {
2724 b = appendStructKey(ctx, code, b)
2725 code = code.Next
2726 store(ctxptr, code.Idx, p)
2727 }
2728 case encoder.OpStructPtrHeadArrayPtr, encoder.OpStructPtrHeadSlicePtr:
2729 p := load(ctxptr, code.Idx)
2730 if p == 0 {
2731 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2732 b = appendNullComma(ctx, b)
2733 }
2734 code = code.End.Next
2735 break
2736 }
2737 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2738 fallthrough
2739 case encoder.OpStructHeadArrayPtr, encoder.OpStructHeadSlicePtr:
2740 p := load(ctxptr, code.Idx)
2741 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2742 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2743 b = appendNullComma(ctx, b)
2744 }
2745 code = code.End.Next
2746 break
2747 }
2748 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2749 b = appendStructHead(ctx, b)
2750 }
2751 b = appendStructKey(ctx, code, b)
2752 if (code.Flags & encoder.IndirectFlags) != 0 {
2753 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
2754 }
2755 if p == 0 {
2756 b = appendNullComma(ctx, b)
2757 code = code.NextField
2758 } else {
2759 code = code.Next
2760 store(ctxptr, code.Idx, p)
2761 }
2762 case encoder.OpStructPtrHeadOmitEmptyArrayPtr, encoder.OpStructPtrHeadOmitEmptySlicePtr:
2763 p := load(ctxptr, code.Idx)
2764 if p == 0 {
2765 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2766 b = appendNullComma(ctx, b)
2767 }
2768 code = code.End.Next
2769 break
2770 }
2771 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2772 fallthrough
2773 case encoder.OpStructHeadOmitEmptyArrayPtr, encoder.OpStructHeadOmitEmptySlicePtr:
2774 p := load(ctxptr, code.Idx)
2775 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2776 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2777 b = appendNullComma(ctx, b)
2778 }
2779 code = code.End.Next
2780 break
2781 }
2782 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2783 b = appendStructHead(ctx, b)
2784 }
2785 if (code.Flags & encoder.IndirectFlags) != 0 {
2786 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
2787 }
2788 if p == 0 {
2789 code = code.NextField
2790 } else {
2791 b = appendStructKey(ctx, code, b)
2792 code = code.Next
2793 store(ctxptr, code.Idx, p)
2794 }
2795 case encoder.OpStructPtrHeadMap:
2796 p := load(ctxptr, code.Idx)
2797 if p == 0 {
2798 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2799 b = appendNullComma(ctx, b)
2800 }
2801 code = code.End.Next
2802 break
2803 }
2804 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2805 fallthrough
2806 case encoder.OpStructHeadMap:
2807 p := load(ctxptr, code.Idx)
2808 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2809 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2810 b = appendNullComma(ctx, b)
2811 }
2812 code = code.End.Next
2813 break
2814 }
2815 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2816 b = appendStructHead(ctx, b)
2817 }
2818 b = appendStructKey(ctx, code, b)
2819 if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2820 p = ptrToPtr(p + uintptr(code.Offset))
2821 }
2822 code = code.Next
2823 store(ctxptr, code.Idx, p)
2824 case encoder.OpStructPtrHeadOmitEmptyMap:
2825 p := load(ctxptr, code.Idx)
2826 if p == 0 {
2827 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2828 b = appendNullComma(ctx, b)
2829 }
2830 code = code.End.Next
2831 break
2832 }
2833 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2834 fallthrough
2835 case encoder.OpStructHeadOmitEmptyMap:
2836 p := load(ctxptr, code.Idx)
2837 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2838 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2839 b = appendNullComma(ctx, b)
2840 }
2841 code = code.End.Next
2842 break
2843 }
2844 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2845 b = appendStructHead(ctx, b)
2846 }
2847 if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2848 p = ptrToPtr(p + uintptr(code.Offset))
2849 }
2850 if maplen(ptrToUnsafePtr(p)) == 0 {
2851 code = code.NextField
2852 } else {
2853 b = appendStructKey(ctx, code, b)
2854 code = code.Next
2855 store(ctxptr, code.Idx, p)
2856 }
2857 case encoder.OpStructPtrHeadMapPtr:
2858 p := load(ctxptr, code.Idx)
2859 if p == 0 {
2860 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2861 b = appendNullComma(ctx, b)
2862 }
2863 code = code.End.Next
2864 break
2865 }
2866 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2867 fallthrough
2868 case encoder.OpStructHeadMapPtr:
2869 p := load(ctxptr, code.Idx)
2870 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2871 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2872 b = appendNullComma(ctx, b)
2873 }
2874 code = code.End.Next
2875 break
2876 }
2877 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2878 b = appendStructHead(ctx, b)
2879 }
2880 b = appendStructKey(ctx, code, b)
2881 if p == 0 {
2882 b = appendNullComma(ctx, b)
2883 code = code.NextField
2884 break
2885 }
2886 p = ptrToPtr(p + uintptr(code.Offset))
2887 if p == 0 {
2888 b = appendNullComma(ctx, b)
2889 code = code.NextField
2890 } else {
2891 if (code.Flags & encoder.IndirectFlags) != 0 {
2892 p = ptrToNPtr(p, code.PtrNum)
2893 }
2894 code = code.Next
2895 store(ctxptr, code.Idx, p)
2896 }
2897 case encoder.OpStructPtrHeadOmitEmptyMapPtr:
2898 p := load(ctxptr, code.Idx)
2899 if p == 0 {
2900 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2901 b = appendNullComma(ctx, b)
2902 }
2903 code = code.End.Next
2904 break
2905 }
2906 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2907 fallthrough
2908 case encoder.OpStructHeadOmitEmptyMapPtr:
2909 p := load(ctxptr, code.Idx)
2910 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2911 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2912 b = appendNullComma(ctx, b)
2913 }
2914 code = code.End.Next
2915 break
2916 }
2917 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2918 b = appendStructHead(ctx, b)
2919 }
2920 if p == 0 {
2921 code = code.NextField
2922 break
2923 }
2924 p = ptrToPtr(p + uintptr(code.Offset))
2925 if p == 0 {
2926 code = code.NextField
2927 } else {
2928 if (code.Flags & encoder.IndirectFlags) != 0 {
2929 p = ptrToNPtr(p, code.PtrNum)
2930 }
2931 b = appendStructKey(ctx, code, b)
2932 code = code.Next
2933 store(ctxptr, code.Idx, p)
2934 }
2935 case encoder.OpStructPtrHeadMarshalJSON:
2936 p := load(ctxptr, code.Idx)
2937 if p == 0 {
2938 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2939 b = appendNullComma(ctx, b)
2940 }
2941 code = code.End.Next
2942 break
2943 }
2944 if (code.Flags & encoder.IndirectFlags) != 0 {
2945 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2946 }
2947 fallthrough
2948 case encoder.OpStructHeadMarshalJSON:
2949 p := load(ctxptr, code.Idx)
2950 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2951 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2952 b = appendNullComma(ctx, b)
2953 }
2954 code = code.End.Next
2955 break
2956 }
2957 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2958 b = appendStructHead(ctx, b)
2959 }
2960 b = appendStructKey(ctx, code, b)
2961 p += uintptr(code.Offset)
2962 if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
2963 if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalJSON {
2964 p = ptrToPtr(p)
2965 }
2966 }
2967 if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
2968 b = appendNull(ctx, b)
2969 } else {
2970 bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
2971 if err != nil {
2972 return nil, err
2973 }
2974 b = bb
2975 }
2976 b = appendComma(ctx, b)
2977 code = code.Next
2978 case encoder.OpStructPtrHeadOmitEmptyMarshalJSON:
2979 p := load(ctxptr, code.Idx)
2980 if p == 0 {
2981 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2982 b = appendNullComma(ctx, b)
2983 }
2984 code = code.End.Next
2985 break
2986 }
2987 if (code.Flags & encoder.IndirectFlags) != 0 {
2988 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
2989 }
2990 fallthrough
2991 case encoder.OpStructHeadOmitEmptyMarshalJSON:
2992 p := load(ctxptr, code.Idx)
2993 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
2994 if code.Flags&encoder.AnonymousHeadFlags == 0 {
2995 b = appendNullComma(ctx, b)
2996 }
2997 code = code.End.Next
2998 break
2999 }
3000 if code.Flags&encoder.AnonymousHeadFlags == 0 {
3001 b = appendStructHead(ctx, b)
3002 }
3003 p += uintptr(code.Offset)
3004 if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
3005 if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON {
3006 p = ptrToPtr(p)
3007 }
3008 }
3009 iface := ptrToInterface(code, p)
3010 if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) {
3011 code = code.NextField
3012 } else {
3013 b = appendStructKey(ctx, code, b)
3014 bb, err := appendMarshalJSON(ctx, code, b, iface)
3015 if err != nil {
3016 return nil, err
3017 }
3018 b = bb
3019 b = appendComma(ctx, b)
3020 code = code.Next
3021 }
3022 case encoder.OpStructPtrHeadMarshalJSONPtr:
3023 p := load(ctxptr, code.Idx)
3024 if p == 0 {
3025 if code.Flags&encoder.AnonymousHeadFlags == 0 {
3026 b = appendNullComma(ctx, b)
3027 }
3028 code = code.End.Next
3029 break
3030 }
3031 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
3032 fallthrough
3033 case encoder.OpStructHeadMarshalJSONPtr:
3034 p := load(ctxptr, code.Idx)
3035 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
3036 if code.Flags&encoder.AnonymousHeadFlags == 0 {
3037 b = appendNullComma(ctx, b)
3038 }
3039 code = code.End.Next
3040 break
3041 }
3042 if code.Flags&encoder.AnonymousHeadFlags == 0 {
3043 b = appendStructHead(ctx, b)
3044 }
3045 b = appendStructKey(ctx, code, b)
3046 if (code.Flags & encoder.IndirectFlags) != 0 {
3047 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3048 }
3049 if p == 0 {
3050 b = appendNull(ctx, b)
3051 } else {
3052 bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
3053 if err != nil {
3054 return nil, err
3055 }
3056 b = bb
3057 }
3058 b = appendComma(ctx, b)
3059 code = code.Next
3060 case encoder.OpStructPtrHeadOmitEmptyMarshalJSONPtr:
3061 p := load(ctxptr, code.Idx)
3062 if p == 0 {
3063 if code.Flags&encoder.AnonymousHeadFlags == 0 {
3064 b = appendNullComma(ctx, b)
3065 }
3066 code = code.End.Next
3067 break
3068 }
3069 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
3070 fallthrough
3071 case encoder.OpStructHeadOmitEmptyMarshalJSONPtr:
3072 p := load(ctxptr, code.Idx)
3073 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
3074 if code.Flags&encoder.AnonymousHeadFlags == 0 {
3075 b = appendNullComma(ctx, b)
3076 }
3077 code = code.End.Next
3078 break
3079 }
3080 if (code.Flags & encoder.IndirectFlags) != 0 {
3081 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3082 }
3083 if code.Flags&encoder.AnonymousHeadFlags == 0 {
3084 b = appendStructHead(ctx, b)
3085 }
3086 if p == 0 {
3087 code = code.NextField
3088 } else {
3089 b = appendStructKey(ctx, code, b)
3090 bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
3091 if err != nil {
3092 return nil, err
3093 }
3094 b = bb
3095 b = appendComma(ctx, b)
3096 code = code.Next
3097 }
3098 case encoder.OpStructPtrHeadMarshalText:
3099 p := load(ctxptr, code.Idx)
3100 if p == 0 {
3101 if code.Flags&encoder.AnonymousHeadFlags == 0 {
3102 b = appendNullComma(ctx, b)
3103 }
3104 code = code.End.Next
3105 break
3106 }
3107 if (code.Flags & encoder.IndirectFlags) != 0 {
3108 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
3109 }
3110 fallthrough
3111 case encoder.OpStructHeadMarshalText:
3112 p := load(ctxptr, code.Idx)
3113 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
3114 if code.Flags&encoder.AnonymousHeadFlags == 0 {
3115 b = appendNullComma(ctx, b)
3116 }
3117 code = code.End.Next
3118 break
3119 }
3120 if code.Flags&encoder.AnonymousHeadFlags == 0 {
3121 b = appendStructHead(ctx, b)
3122 }
3123 b = appendStructKey(ctx, code, b)
3124 p += uintptr(code.Offset)
3125 if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
3126 if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalText {
3127 p = ptrToPtr(p)
3128 }
3129 }
3130 if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
3131 b = appendNull(ctx, b)
3132 } else {
3133 bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
3134 if err != nil {
3135 return nil, err
3136 }
3137 b = bb
3138 }
3139 b = appendComma(ctx, b)
3140 code = code.Next
3141 case encoder.OpStructPtrHeadOmitEmptyMarshalText:
3142 p := load(ctxptr, code.Idx)
3143 if p == 0 {
3144 if code.Flags&encoder.AnonymousHeadFlags == 0 {
3145 b = appendNullComma(ctx, b)
3146 }
3147 code = code.End.Next
3148 break
3149 }
3150 if (code.Flags & encoder.IndirectFlags) != 0 {
3151 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
3152 }
3153 fallthrough
3154 case encoder.OpStructHeadOmitEmptyMarshalText:
3155 p := load(ctxptr, code.Idx)
3156 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
3157 if code.Flags&encoder.AnonymousHeadFlags == 0 {
3158 b = appendNullComma(ctx, b)
3159 }
3160 code = code.End.Next
3161 break
3162 }
3163 if code.Flags&encoder.AnonymousHeadFlags == 0 {
3164 b = appendStructHead(ctx, b)
3165 }
3166 p += uintptr(code.Offset)
3167 if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
3168 if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText {
3169 p = ptrToPtr(p)
3170 }
3171 }
3172 if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
3173 code = code.NextField
3174 } else {
3175 b = appendStructKey(ctx, code, b)
3176 bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
3177 if err != nil {
3178 return nil, err
3179 }
3180 b = bb
3181 b = appendComma(ctx, b)
3182 code = code.Next
3183 }
3184 case encoder.OpStructPtrHeadMarshalTextPtr:
3185 p := load(ctxptr, code.Idx)
3186 if p == 0 {
3187 if code.Flags&encoder.AnonymousHeadFlags == 0 {
3188 b = appendNullComma(ctx, b)
3189 }
3190 code = code.End.Next
3191 break
3192 }
3193 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
3194 fallthrough
3195 case encoder.OpStructHeadMarshalTextPtr:
3196 p := load(ctxptr, code.Idx)
3197 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
3198 if code.Flags&encoder.AnonymousHeadFlags == 0 {
3199 b = appendNullComma(ctx, b)
3200 }
3201 code = code.End.Next
3202 break
3203 }
3204 if code.Flags&encoder.AnonymousHeadFlags == 0 {
3205 b = appendStructHead(ctx, b)
3206 }
3207 b = appendStructKey(ctx, code, b)
3208 if (code.Flags & encoder.IndirectFlags) != 0 {
3209 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3210 }
3211 if p == 0 {
3212 b = appendNull(ctx, b)
3213 } else {
3214 bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
3215 if err != nil {
3216 return nil, err
3217 }
3218 b = bb
3219 }
3220 b = appendComma(ctx, b)
3221 code = code.Next
3222 case encoder.OpStructPtrHeadOmitEmptyMarshalTextPtr:
3223 p := load(ctxptr, code.Idx)
3224 if p == 0 {
3225 if code.Flags&encoder.AnonymousHeadFlags == 0 {
3226 b = appendNullComma(ctx, b)
3227 }
3228 code = code.End.Next
3229 break
3230 }
3231 store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
3232 fallthrough
3233 case encoder.OpStructHeadOmitEmptyMarshalTextPtr:
3234 p := load(ctxptr, code.Idx)
3235 if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
3236 if code.Flags&encoder.AnonymousHeadFlags == 0 {
3237 b = appendNullComma(ctx, b)
3238 }
3239 code = code.End.Next
3240 break
3241 }
3242 if (code.Flags & encoder.IndirectFlags) != 0 {
3243 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3244 }
3245 if code.Flags&encoder.AnonymousHeadFlags == 0 {
3246 b = appendStructHead(ctx, b)
3247 }
3248 if p == 0 {
3249 code = code.NextField
3250 } else {
3251 b = appendStructKey(ctx, code, b)
3252 bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
3253 if err != nil {
3254 return nil, err
3255 }
3256 b = bb
3257 b = appendComma(ctx, b)
3258 code = code.Next
3259 }
3260 case encoder.OpStructField:
3261 if code.Flags&encoder.IsTaggedKeyFlags != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 {
3262 b = appendStructKey(ctx, code, b)
3263 }
3264 p := load(ctxptr, code.Idx) + uintptr(code.Offset)
3265 code = code.Next
3266 store(ctxptr, code.Idx, p)
3267 case encoder.OpStructFieldOmitEmpty:
3268 p := load(ctxptr, code.Idx)
3269 p += uintptr(code.Offset)
3270 if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 {
3271 code = code.NextField
3272 } else {
3273 b = appendStructKey(ctx, code, b)
3274 code = code.Next
3275 store(ctxptr, code.Idx, p)
3276 }
3277 case encoder.OpStructFieldInt:
3278 p := load(ctxptr, code.Idx)
3279 b = appendStructKey(ctx, code, b)
3280 b = appendInt(ctx, b, p+uintptr(code.Offset), code)
3281 b = appendComma(ctx, b)
3282 code = code.Next
3283 case encoder.OpStructFieldOmitEmptyInt:
3284 p := load(ctxptr, code.Idx)
3285 u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
3286 v := u64 & ((1 << code.NumBitSize) - 1)
3287 if v != 0 {
3288 b = appendStructKey(ctx, code, b)
3289 b = appendInt(ctx, b, p+uintptr(code.Offset), code)
3290 b = appendComma(ctx, b)
3291 }
3292 code = code.Next
3293 case encoder.OpStructFieldIntString:
3294 p := load(ctxptr, code.Idx)
3295 b = appendStructKey(ctx, code, b)
3296 b = append(b, '"')
3297 b = appendInt(ctx, b, p+uintptr(code.Offset), code)
3298 b = append(b, '"')
3299 b = appendComma(ctx, b)
3300 code = code.Next
3301 case encoder.OpStructFieldOmitEmptyIntString:
3302 p := load(ctxptr, code.Idx)
3303 u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
3304 v := u64 & ((1 << code.NumBitSize) - 1)
3305 if v != 0 {
3306 b = appendStructKey(ctx, code, b)
3307 b = append(b, '"')
3308 b = appendInt(ctx, b, p+uintptr(code.Offset), code)
3309 b = append(b, '"')
3310 b = appendComma(ctx, b)
3311 }
3312 code = code.Next
3313 case encoder.OpStructFieldIntPtr:
3314 p := load(ctxptr, code.Idx)
3315 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3316 b = appendStructKey(ctx, code, b)
3317 if p == 0 {
3318 b = appendNull(ctx, b)
3319 } else {
3320 b = appendInt(ctx, b, p, code)
3321 }
3322 b = appendComma(ctx, b)
3323 code = code.Next
3324 case encoder.OpStructFieldOmitEmptyIntPtr:
3325 p := load(ctxptr, code.Idx)
3326 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3327 if p != 0 {
3328 b = appendStructKey(ctx, code, b)
3329 b = appendInt(ctx, b, p, code)
3330 b = appendComma(ctx, b)
3331 }
3332 code = code.Next
3333 case encoder.OpStructFieldIntPtrString:
3334 p := load(ctxptr, code.Idx)
3335 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3336 b = appendStructKey(ctx, code, b)
3337 if p == 0 {
3338 b = appendNull(ctx, b)
3339 } else {
3340 b = append(b, '"')
3341 b = appendInt(ctx, b, p, code)
3342 b = append(b, '"')
3343 }
3344 b = appendComma(ctx, b)
3345 code = code.Next
3346 case encoder.OpStructFieldOmitEmptyIntPtrString:
3347 p := load(ctxptr, code.Idx)
3348 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3349 if p != 0 {
3350 b = appendStructKey(ctx, code, b)
3351 b = append(b, '"')
3352 b = appendInt(ctx, b, p, code)
3353 b = append(b, '"')
3354 b = appendComma(ctx, b)
3355 }
3356 code = code.Next
3357 case encoder.OpStructFieldUint:
3358 p := load(ctxptr, code.Idx)
3359 b = appendStructKey(ctx, code, b)
3360 b = appendUint(ctx, b, p+uintptr(code.Offset), code)
3361 b = appendComma(ctx, b)
3362 code = code.Next
3363 case encoder.OpStructFieldOmitEmptyUint:
3364 p := load(ctxptr, code.Idx)
3365 u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
3366 v := u64 & ((1 << code.NumBitSize) - 1)
3367 if v != 0 {
3368 b = appendStructKey(ctx, code, b)
3369 b = appendUint(ctx, b, p+uintptr(code.Offset), code)
3370 b = appendComma(ctx, b)
3371 }
3372 code = code.Next
3373 case encoder.OpStructFieldUintString:
3374 p := load(ctxptr, code.Idx)
3375 b = appendStructKey(ctx, code, b)
3376 b = append(b, '"')
3377 b = appendUint(ctx, b, p+uintptr(code.Offset), code)
3378 b = append(b, '"')
3379 b = appendComma(ctx, b)
3380 code = code.Next
3381 case encoder.OpStructFieldOmitEmptyUintString:
3382 p := load(ctxptr, code.Idx)
3383 u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
3384 v := u64 & ((1 << code.NumBitSize) - 1)
3385 if v != 0 {
3386 b = appendStructKey(ctx, code, b)
3387 b = append(b, '"')
3388 b = appendUint(ctx, b, p+uintptr(code.Offset), code)
3389 b = append(b, '"')
3390 b = appendComma(ctx, b)
3391 }
3392 code = code.Next
3393 case encoder.OpStructFieldUintPtr:
3394 p := load(ctxptr, code.Idx)
3395 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3396 b = appendStructKey(ctx, code, b)
3397 if p == 0 {
3398 b = appendNull(ctx, b)
3399 } else {
3400 b = appendUint(ctx, b, p, code)
3401 }
3402 b = appendComma(ctx, b)
3403 code = code.Next
3404 case encoder.OpStructFieldOmitEmptyUintPtr:
3405 p := load(ctxptr, code.Idx)
3406 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3407 if p != 0 {
3408 b = appendStructKey(ctx, code, b)
3409 b = appendUint(ctx, b, p, code)
3410 b = appendComma(ctx, b)
3411 }
3412 code = code.Next
3413 case encoder.OpStructFieldUintPtrString:
3414 p := load(ctxptr, code.Idx)
3415 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3416 b = appendStructKey(ctx, code, b)
3417 if p == 0 {
3418 b = appendNull(ctx, b)
3419 } else {
3420 b = append(b, '"')
3421 b = appendUint(ctx, b, p, code)
3422 b = append(b, '"')
3423 }
3424 b = appendComma(ctx, b)
3425 code = code.Next
3426 case encoder.OpStructFieldOmitEmptyUintPtrString:
3427 p := load(ctxptr, code.Idx)
3428 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3429 if p != 0 {
3430 b = appendStructKey(ctx, code, b)
3431 b = append(b, '"')
3432 b = appendUint(ctx, b, p, code)
3433 b = append(b, '"')
3434 b = appendComma(ctx, b)
3435 }
3436 code = code.Next
3437 case encoder.OpStructFieldFloat32:
3438 p := load(ctxptr, code.Idx)
3439 b = appendStructKey(ctx, code, b)
3440 b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
3441 b = appendComma(ctx, b)
3442 code = code.Next
3443 case encoder.OpStructFieldOmitEmptyFloat32:
3444 p := load(ctxptr, code.Idx)
3445 v := ptrToFloat32(p + uintptr(code.Offset))
3446 if v != 0 {
3447 b = appendStructKey(ctx, code, b)
3448 b = appendFloat32(ctx, b, v)
3449 b = appendComma(ctx, b)
3450 }
3451 code = code.Next
3452 case encoder.OpStructFieldFloat32String:
3453 p := load(ctxptr, code.Idx)
3454 b = appendStructKey(ctx, code, b)
3455 b = append(b, '"')
3456 b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
3457 b = append(b, '"')
3458 b = appendComma(ctx, b)
3459 code = code.Next
3460 case encoder.OpStructFieldOmitEmptyFloat32String:
3461 p := load(ctxptr, code.Idx)
3462 v := ptrToFloat32(p + uintptr(code.Offset))
3463 if v != 0 {
3464 b = appendStructKey(ctx, code, b)
3465 b = append(b, '"')
3466 b = appendFloat32(ctx, b, v)
3467 b = append(b, '"')
3468 b = appendComma(ctx, b)
3469 }
3470 code = code.Next
3471 case encoder.OpStructFieldFloat32Ptr:
3472 p := load(ctxptr, code.Idx)
3473 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3474 b = appendStructKey(ctx, code, b)
3475 if p == 0 {
3476 b = appendNull(ctx, b)
3477 } else {
3478 b = appendFloat32(ctx, b, ptrToFloat32(p))
3479 }
3480 b = appendComma(ctx, b)
3481 code = code.Next
3482 case encoder.OpStructFieldOmitEmptyFloat32Ptr:
3483 p := load(ctxptr, code.Idx)
3484 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3485 if p != 0 {
3486 b = appendStructKey(ctx, code, b)
3487 b = appendFloat32(ctx, b, ptrToFloat32(p))
3488 b = appendComma(ctx, b)
3489 }
3490 code = code.Next
3491 case encoder.OpStructFieldFloat32PtrString:
3492 p := load(ctxptr, code.Idx)
3493 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3494 b = appendStructKey(ctx, code, b)
3495 if p == 0 {
3496 b = appendNull(ctx, b)
3497 } else {
3498 b = append(b, '"')
3499 b = appendFloat32(ctx, b, ptrToFloat32(p))
3500 b = append(b, '"')
3501 }
3502 b = appendComma(ctx, b)
3503 code = code.Next
3504 case encoder.OpStructFieldOmitEmptyFloat32PtrString:
3505 p := load(ctxptr, code.Idx)
3506 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3507 if p != 0 {
3508 b = appendStructKey(ctx, code, b)
3509 b = append(b, '"')
3510 b = appendFloat32(ctx, b, ptrToFloat32(p))
3511 b = append(b, '"')
3512 b = appendComma(ctx, b)
3513 }
3514 code = code.Next
3515 case encoder.OpStructFieldFloat64:
3516 p := load(ctxptr, code.Idx)
3517 b = appendStructKey(ctx, code, b)
3518 v := ptrToFloat64(p + uintptr(code.Offset))
3519 if math.IsInf(v, 0) || math.IsNaN(v) {
3520 return nil, errUnsupportedFloat(v)
3521 }
3522 b = appendFloat64(ctx, b, v)
3523 b = appendComma(ctx, b)
3524 code = code.Next
3525 case encoder.OpStructFieldOmitEmptyFloat64:
3526 p := load(ctxptr, code.Idx)
3527 v := ptrToFloat64(p + uintptr(code.Offset))
3528 if v != 0 {
3529 if math.IsInf(v, 0) || math.IsNaN(v) {
3530 return nil, errUnsupportedFloat(v)
3531 }
3532 b = appendStructKey(ctx, code, b)
3533 b = appendFloat64(ctx, b, v)
3534 b = appendComma(ctx, b)
3535 }
3536 code = code.Next
3537 case encoder.OpStructFieldFloat64String:
3538 p := load(ctxptr, code.Idx)
3539 v := ptrToFloat64(p + uintptr(code.Offset))
3540 if math.IsInf(v, 0) || math.IsNaN(v) {
3541 return nil, errUnsupportedFloat(v)
3542 }
3543 b = appendStructKey(ctx, code, b)
3544 b = append(b, '"')
3545 b = appendFloat64(ctx, b, v)
3546 b = append(b, '"')
3547 b = appendComma(ctx, b)
3548 code = code.Next
3549 case encoder.OpStructFieldOmitEmptyFloat64String:
3550 p := load(ctxptr, code.Idx)
3551 v := ptrToFloat64(p + uintptr(code.Offset))
3552 if v != 0 {
3553 if math.IsInf(v, 0) || math.IsNaN(v) {
3554 return nil, errUnsupportedFloat(v)
3555 }
3556 b = appendStructKey(ctx, code, b)
3557 b = append(b, '"')
3558 b = appendFloat64(ctx, b, v)
3559 b = append(b, '"')
3560 b = appendComma(ctx, b)
3561 }
3562 code = code.Next
3563 case encoder.OpStructFieldFloat64Ptr:
3564 p := load(ctxptr, code.Idx)
3565 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3566 b = appendStructKey(ctx, code, b)
3567 if p == 0 {
3568 b = appendNullComma(ctx, b)
3569 code = code.Next
3570 break
3571 }
3572 v := ptrToFloat64(p)
3573 if math.IsInf(v, 0) || math.IsNaN(v) {
3574 return nil, errUnsupportedFloat(v)
3575 }
3576 b = appendFloat64(ctx, b, v)
3577 b = appendComma(ctx, b)
3578 code = code.Next
3579 case encoder.OpStructFieldOmitEmptyFloat64Ptr:
3580 p := load(ctxptr, code.Idx)
3581 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3582 if p != 0 {
3583 b = appendStructKey(ctx, code, b)
3584 v := ptrToFloat64(p)
3585 if math.IsInf(v, 0) || math.IsNaN(v) {
3586 return nil, errUnsupportedFloat(v)
3587 }
3588 b = appendFloat64(ctx, b, v)
3589 b = appendComma(ctx, b)
3590 }
3591 code = code.Next
3592 case encoder.OpStructFieldFloat64PtrString:
3593 p := load(ctxptr, code.Idx)
3594 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3595 b = appendStructKey(ctx, code, b)
3596 if p == 0 {
3597 b = appendNull(ctx, b)
3598 } else {
3599 v := ptrToFloat64(p)
3600 if math.IsInf(v, 0) || math.IsNaN(v) {
3601 return nil, errUnsupportedFloat(v)
3602 }
3603 b = append(b, '"')
3604 b = appendFloat64(ctx, b, v)
3605 b = append(b, '"')
3606 }
3607 b = appendComma(ctx, b)
3608 code = code.Next
3609 case encoder.OpStructFieldOmitEmptyFloat64PtrString:
3610 p := load(ctxptr, code.Idx)
3611 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3612 if p != 0 {
3613 b = appendStructKey(ctx, code, b)
3614 b = append(b, '"')
3615 v := ptrToFloat64(p)
3616 if math.IsInf(v, 0) || math.IsNaN(v) {
3617 return nil, errUnsupportedFloat(v)
3618 }
3619 b = appendFloat64(ctx, b, v)
3620 b = append(b, '"')
3621 b = appendComma(ctx, b)
3622 }
3623 code = code.Next
3624 case encoder.OpStructFieldString:
3625 p := load(ctxptr, code.Idx)
3626 b = appendStructKey(ctx, code, b)
3627 b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset)))
3628 b = appendComma(ctx, b)
3629 code = code.Next
3630 case encoder.OpStructFieldOmitEmptyString:
3631 p := load(ctxptr, code.Idx)
3632 v := ptrToString(p + uintptr(code.Offset))
3633 if v != "" {
3634 b = appendStructKey(ctx, code, b)
3635 b = appendString(ctx, b, v)
3636 b = appendComma(ctx, b)
3637 }
3638 code = code.Next
3639 case encoder.OpStructFieldStringString:
3640 p := load(ctxptr, code.Idx)
3641 s := ptrToString(p + uintptr(code.Offset))
3642 b = appendStructKey(ctx, code, b)
3643 b = appendString(ctx, b, string(appendString(ctx, []byte{}, s)))
3644 b = appendComma(ctx, b)
3645 code = code.Next
3646 case encoder.OpStructFieldOmitEmptyStringString:
3647 p := load(ctxptr, code.Idx)
3648 v := ptrToString(p + uintptr(code.Offset))
3649 if v != "" {
3650 b = appendStructKey(ctx, code, b)
3651 b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
3652 b = appendComma(ctx, b)
3653 }
3654 code = code.Next
3655 case encoder.OpStructFieldStringPtr:
3656 p := load(ctxptr, code.Idx)
3657 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3658 b = appendStructKey(ctx, code, b)
3659 if p == 0 {
3660 b = appendNull(ctx, b)
3661 } else {
3662 b = appendString(ctx, b, ptrToString(p))
3663 }
3664 b = appendComma(ctx, b)
3665 code = code.Next
3666 case encoder.OpStructFieldOmitEmptyStringPtr:
3667 p := load(ctxptr, code.Idx)
3668 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3669 if p != 0 {
3670 b = appendStructKey(ctx, code, b)
3671 b = appendString(ctx, b, ptrToString(p))
3672 b = appendComma(ctx, b)
3673 }
3674 code = code.Next
3675 case encoder.OpStructFieldStringPtrString:
3676 p := load(ctxptr, code.Idx)
3677 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3678 b = appendStructKey(ctx, code, b)
3679 if p == 0 {
3680 b = appendNull(ctx, b)
3681 } else {
3682 b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
3683 }
3684 b = appendComma(ctx, b)
3685 code = code.Next
3686 case encoder.OpStructFieldOmitEmptyStringPtrString:
3687 p := load(ctxptr, code.Idx)
3688 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3689 if p != 0 {
3690 b = appendStructKey(ctx, code, b)
3691 b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
3692 b = appendComma(ctx, b)
3693 }
3694 code = code.Next
3695 case encoder.OpStructFieldBool:
3696 p := load(ctxptr, code.Idx)
3697 b = appendStructKey(ctx, code, b)
3698 b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
3699 b = appendComma(ctx, b)
3700 code = code.Next
3701 case encoder.OpStructFieldOmitEmptyBool:
3702 p := load(ctxptr, code.Idx)
3703 v := ptrToBool(p + uintptr(code.Offset))
3704 if v {
3705 b = appendStructKey(ctx, code, b)
3706 b = appendBool(ctx, b, v)
3707 b = appendComma(ctx, b)
3708 }
3709 code = code.Next
3710 case encoder.OpStructFieldBoolString:
3711 p := load(ctxptr, code.Idx)
3712 b = appendStructKey(ctx, code, b)
3713 b = append(b, '"')
3714 b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
3715 b = append(b, '"')
3716 b = appendComma(ctx, b)
3717 code = code.Next
3718 case encoder.OpStructFieldOmitEmptyBoolString:
3719 p := load(ctxptr, code.Idx)
3720 v := ptrToBool(p + uintptr(code.Offset))
3721 if v {
3722 b = appendStructKey(ctx, code, b)
3723 b = append(b, '"')
3724 b = appendBool(ctx, b, v)
3725 b = append(b, '"')
3726 b = appendComma(ctx, b)
3727 }
3728 code = code.Next
3729 case encoder.OpStructFieldBoolPtr:
3730 p := load(ctxptr, code.Idx)
3731 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3732 b = appendStructKey(ctx, code, b)
3733 if p == 0 {
3734 b = appendNull(ctx, b)
3735 } else {
3736 b = appendBool(ctx, b, ptrToBool(p))
3737 }
3738 b = appendComma(ctx, b)
3739 code = code.Next
3740 case encoder.OpStructFieldOmitEmptyBoolPtr:
3741 p := load(ctxptr, code.Idx)
3742 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3743 if p != 0 {
3744 b = appendStructKey(ctx, code, b)
3745 b = appendBool(ctx, b, ptrToBool(p))
3746 b = appendComma(ctx, b)
3747 }
3748 code = code.Next
3749 case encoder.OpStructFieldBoolPtrString:
3750 p := load(ctxptr, code.Idx)
3751 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3752 b = appendStructKey(ctx, code, b)
3753 if p == 0 {
3754 b = appendNull(ctx, b)
3755 } else {
3756 b = append(b, '"')
3757 b = appendBool(ctx, b, ptrToBool(p))
3758 b = append(b, '"')
3759 }
3760 b = appendComma(ctx, b)
3761 code = code.Next
3762 case encoder.OpStructFieldOmitEmptyBoolPtrString:
3763 p := load(ctxptr, code.Idx)
3764 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3765 if p != 0 {
3766 b = appendStructKey(ctx, code, b)
3767 b = append(b, '"')
3768 b = appendBool(ctx, b, ptrToBool(p))
3769 b = append(b, '"')
3770 b = appendComma(ctx, b)
3771 }
3772 code = code.Next
3773 case encoder.OpStructFieldBytes:
3774 p := load(ctxptr, code.Idx)
3775 b = appendStructKey(ctx, code, b)
3776 b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset)))
3777 b = appendComma(ctx, b)
3778 code = code.Next
3779 case encoder.OpStructFieldOmitEmptyBytes:
3780 p := load(ctxptr, code.Idx)
3781 v := ptrToBytes(p + uintptr(code.Offset))
3782 if len(v) > 0 {
3783 b = appendStructKey(ctx, code, b)
3784 b = appendByteSlice(ctx, b, v)
3785 b = appendComma(ctx, b)
3786 }
3787 code = code.Next
3788 case encoder.OpStructFieldBytesPtr:
3789 p := load(ctxptr, code.Idx)
3790 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3791 b = appendStructKey(ctx, code, b)
3792 if p == 0 {
3793 b = appendNull(ctx, b)
3794 } else {
3795 b = appendByteSlice(ctx, b, ptrToBytes(p))
3796 }
3797 b = appendComma(ctx, b)
3798 code = code.Next
3799 case encoder.OpStructFieldOmitEmptyBytesPtr:
3800 p := load(ctxptr, code.Idx)
3801 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3802 if p != 0 {
3803 b = appendStructKey(ctx, code, b)
3804 b = appendByteSlice(ctx, b, ptrToBytes(p))
3805 b = appendComma(ctx, b)
3806 }
3807 code = code.Next
3808 case encoder.OpStructFieldNumber:
3809 p := load(ctxptr, code.Idx)
3810 b = appendStructKey(ctx, code, b)
3811 bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
3812 if err != nil {
3813 return nil, err
3814 }
3815 b = appendComma(ctx, bb)
3816 code = code.Next
3817 case encoder.OpStructFieldOmitEmptyNumber:
3818 p := load(ctxptr, code.Idx)
3819 v := ptrToNumber(p + uintptr(code.Offset))
3820 if v != "" {
3821 b = appendStructKey(ctx, code, b)
3822 bb, err := appendNumber(ctx, b, v)
3823 if err != nil {
3824 return nil, err
3825 }
3826 b = appendComma(ctx, bb)
3827 }
3828 code = code.Next
3829 case encoder.OpStructFieldNumberString:
3830 p := load(ctxptr, code.Idx)
3831 b = appendStructKey(ctx, code, b)
3832 b = append(b, '"')
3833 bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
3834 if err != nil {
3835 return nil, err
3836 }
3837 b = append(bb, '"')
3838 b = appendComma(ctx, b)
3839 code = code.Next
3840 case encoder.OpStructFieldOmitEmptyNumberString:
3841 p := load(ctxptr, code.Idx)
3842 v := ptrToNumber(p + uintptr(code.Offset))
3843 if v != "" {
3844 b = appendStructKey(ctx, code, b)
3845 b = append(b, '"')
3846 bb, err := appendNumber(ctx, b, v)
3847 if err != nil {
3848 return nil, err
3849 }
3850 b = append(bb, '"')
3851 b = appendComma(ctx, b)
3852 }
3853 code = code.Next
3854 case encoder.OpStructFieldNumberPtr:
3855 p := load(ctxptr, code.Idx)
3856 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3857 b = appendStructKey(ctx, code, b)
3858 if p == 0 {
3859 b = appendNull(ctx, b)
3860 } else {
3861 bb, err := appendNumber(ctx, b, ptrToNumber(p))
3862 if err != nil {
3863 return nil, err
3864 }
3865 b = bb
3866 }
3867 b = appendComma(ctx, b)
3868 code = code.Next
3869 case encoder.OpStructFieldOmitEmptyNumberPtr:
3870 p := load(ctxptr, code.Idx)
3871 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3872 if p != 0 {
3873 b = appendStructKey(ctx, code, b)
3874 bb, err := appendNumber(ctx, b, ptrToNumber(p))
3875 if err != nil {
3876 return nil, err
3877 }
3878 b = appendComma(ctx, bb)
3879 }
3880 code = code.Next
3881 case encoder.OpStructFieldNumberPtrString:
3882 p := load(ctxptr, code.Idx)
3883 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3884 b = appendStructKey(ctx, code, b)
3885 if p == 0 {
3886 b = appendNull(ctx, b)
3887 } else {
3888 b = append(b, '"')
3889 bb, err := appendNumber(ctx, b, ptrToNumber(p))
3890 if err != nil {
3891 return nil, err
3892 }
3893 b = append(bb, '"')
3894 }
3895 b = appendComma(ctx, b)
3896 code = code.Next
3897 case encoder.OpStructFieldOmitEmptyNumberPtrString:
3898 p := load(ctxptr, code.Idx)
3899 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3900 if p != 0 {
3901 b = appendStructKey(ctx, code, b)
3902 b = append(b, '"')
3903 bb, err := appendNumber(ctx, b, ptrToNumber(p))
3904 if err != nil {
3905 return nil, err
3906 }
3907 b = append(bb, '"')
3908 b = appendComma(ctx, b)
3909 }
3910 code = code.Next
3911 case encoder.OpStructFieldMarshalJSON:
3912 p := load(ctxptr, code.Idx)
3913 b = appendStructKey(ctx, code, b)
3914 p += uintptr(code.Offset)
3915 if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
3916 p = ptrToPtr(p)
3917 }
3918 if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
3919 b = appendNull(ctx, b)
3920 } else {
3921 bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
3922 if err != nil {
3923 return nil, err
3924 }
3925 b = bb
3926 }
3927 b = appendComma(ctx, b)
3928 code = code.Next
3929 case encoder.OpStructFieldOmitEmptyMarshalJSON:
3930 p := load(ctxptr, code.Idx)
3931 p += uintptr(code.Offset)
3932 if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
3933 p = ptrToPtr(p)
3934 }
3935 if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
3936 code = code.NextField
3937 break
3938 }
3939 iface := ptrToInterface(code, p)
3940 if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) {
3941 code = code.NextField
3942 break
3943 }
3944 b = appendStructKey(ctx, code, b)
3945 bb, err := appendMarshalJSON(ctx, code, b, iface)
3946 if err != nil {
3947 return nil, err
3948 }
3949 b = appendComma(ctx, bb)
3950 code = code.Next
3951 case encoder.OpStructFieldMarshalJSONPtr:
3952 p := load(ctxptr, code.Idx)
3953 b = appendStructKey(ctx, code, b)
3954 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3955 if p == 0 {
3956 b = appendNull(ctx, b)
3957 } else {
3958 bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
3959 if err != nil {
3960 return nil, err
3961 }
3962 b = bb
3963 }
3964 b = appendComma(ctx, b)
3965 code = code.Next
3966 case encoder.OpStructFieldOmitEmptyMarshalJSONPtr:
3967 p := load(ctxptr, code.Idx)
3968 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
3969 if p != 0 {
3970 b = appendStructKey(ctx, code, b)
3971 bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
3972 if err != nil {
3973 return nil, err
3974 }
3975 b = appendComma(ctx, bb)
3976 }
3977 code = code.Next
3978 case encoder.OpStructFieldMarshalText:
3979 p := load(ctxptr, code.Idx)
3980 b = appendStructKey(ctx, code, b)
3981 p += uintptr(code.Offset)
3982 if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
3983 p = ptrToPtr(p)
3984 }
3985 if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
3986 b = appendNull(ctx, b)
3987 } else {
3988 bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
3989 if err != nil {
3990 return nil, err
3991 }
3992 b = bb
3993 }
3994 b = appendComma(ctx, b)
3995 code = code.Next
3996 case encoder.OpStructFieldOmitEmptyMarshalText:
3997 p := load(ctxptr, code.Idx)
3998 p += uintptr(code.Offset)
3999 if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
4000 p = ptrToPtr(p)
4001 }
4002 if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
4003 code = code.NextField
4004 break
4005 }
4006 b = appendStructKey(ctx, code, b)
4007 bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
4008 if err != nil {
4009 return nil, err
4010 }
4011 b = appendComma(ctx, bb)
4012 code = code.Next
4013 case encoder.OpStructFieldMarshalTextPtr:
4014 p := load(ctxptr, code.Idx)
4015 b = appendStructKey(ctx, code, b)
4016 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4017 if p == 0 {
4018 b = appendNull(ctx, b)
4019 } else {
4020 bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
4021 if err != nil {
4022 return nil, err
4023 }
4024 b = bb
4025 }
4026 b = appendComma(ctx, b)
4027 code = code.Next
4028 case encoder.OpStructFieldOmitEmptyMarshalTextPtr:
4029 p := load(ctxptr, code.Idx)
4030 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4031 if p != 0 {
4032 b = appendStructKey(ctx, code, b)
4033 bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
4034 if err != nil {
4035 return nil, err
4036 }
4037 b = appendComma(ctx, bb)
4038 }
4039 code = code.Next
4040 case encoder.OpStructFieldArray:
4041 b = appendStructKey(ctx, code, b)
4042 p := load(ctxptr, code.Idx)
4043 p += uintptr(code.Offset)
4044 code = code.Next
4045 store(ctxptr, code.Idx, p)
4046 case encoder.OpStructFieldOmitEmptyArray:
4047 b = appendStructKey(ctx, code, b)
4048 p := load(ctxptr, code.Idx)
4049 p += uintptr(code.Offset)
4050 code = code.Next
4051 store(ctxptr, code.Idx, p)
4052 case encoder.OpStructFieldArrayPtr:
4053 b = appendStructKey(ctx, code, b)
4054 p := load(ctxptr, code.Idx)
4055 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4056 code = code.Next
4057 store(ctxptr, code.Idx, p)
4058 case encoder.OpStructFieldOmitEmptyArrayPtr:
4059 p := load(ctxptr, code.Idx)
4060 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4061 if p != 0 {
4062 b = appendStructKey(ctx, code, b)
4063 code = code.Next
4064 store(ctxptr, code.Idx, p)
4065 } else {
4066 code = code.NextField
4067 }
4068 case encoder.OpStructFieldSlice:
4069 b = appendStructKey(ctx, code, b)
4070 p := load(ctxptr, code.Idx)
4071 p += uintptr(code.Offset)
4072 code = code.Next
4073 store(ctxptr, code.Idx, p)
4074 case encoder.OpStructFieldOmitEmptySlice:
4075 p := load(ctxptr, code.Idx)
4076 p += uintptr(code.Offset)
4077 slice := ptrToSlice(p)
4078 if slice.Len == 0 {
4079 code = code.NextField
4080 } else {
4081 b = appendStructKey(ctx, code, b)
4082 code = code.Next
4083 store(ctxptr, code.Idx, p)
4084 }
4085 case encoder.OpStructFieldSlicePtr:
4086 b = appendStructKey(ctx, code, b)
4087 p := load(ctxptr, code.Idx)
4088 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4089 code = code.Next
4090 store(ctxptr, code.Idx, p)
4091 case encoder.OpStructFieldOmitEmptySlicePtr:
4092 p := load(ctxptr, code.Idx)
4093 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4094 if p != 0 {
4095 b = appendStructKey(ctx, code, b)
4096 code = code.Next
4097 store(ctxptr, code.Idx, p)
4098 } else {
4099 code = code.NextField
4100 }
4101 case encoder.OpStructFieldMap:
4102 b = appendStructKey(ctx, code, b)
4103 p := load(ctxptr, code.Idx)
4104 p = ptrToPtr(p + uintptr(code.Offset))
4105 code = code.Next
4106 store(ctxptr, code.Idx, p)
4107 case encoder.OpStructFieldOmitEmptyMap:
4108 p := load(ctxptr, code.Idx)
4109 p = ptrToPtr(p + uintptr(code.Offset))
4110 if p == 0 || maplen(ptrToUnsafePtr(p)) == 0 {
4111 code = code.NextField
4112 } else {
4113 b = appendStructKey(ctx, code, b)
4114 code = code.Next
4115 store(ctxptr, code.Idx, p)
4116 }
4117 case encoder.OpStructFieldMapPtr:
4118 b = appendStructKey(ctx, code, b)
4119 p := load(ctxptr, code.Idx)
4120 p = ptrToPtr(p + uintptr(code.Offset))
4121 if p != 0 {
4122 p = ptrToNPtr(p, code.PtrNum)
4123 }
4124 code = code.Next
4125 store(ctxptr, code.Idx, p)
4126 case encoder.OpStructFieldOmitEmptyMapPtr:
4127 p := load(ctxptr, code.Idx)
4128 p = ptrToPtr(p + uintptr(code.Offset))
4129 if p != 0 {
4130 p = ptrToNPtr(p, code.PtrNum)
4131 }
4132 if p != 0 {
4133 b = appendStructKey(ctx, code, b)
4134 code = code.Next
4135 store(ctxptr, code.Idx, p)
4136 } else {
4137 code = code.NextField
4138 }
4139 case encoder.OpStructFieldStruct:
4140 b = appendStructKey(ctx, code, b)
4141 p := load(ctxptr, code.Idx)
4142 p += uintptr(code.Offset)
4143 code = code.Next
4144 store(ctxptr, code.Idx, p)
4145 case encoder.OpStructFieldOmitEmptyStruct:
4146 p := load(ctxptr, code.Idx)
4147 p += uintptr(code.Offset)
4148 if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 {
4149 code = code.NextField
4150 } else {
4151 b = appendStructKey(ctx, code, b)
4152 code = code.Next
4153 store(ctxptr, code.Idx, p)
4154 }
4155 case encoder.OpStructEnd:
4156 b = appendStructEndSkipLast(ctx, code, b)
4157 code = code.Next
4158 case encoder.OpStructEndInt:
4159 p := load(ctxptr, code.Idx)
4160 b = appendStructKey(ctx, code, b)
4161 b = appendInt(ctx, b, p+uintptr(code.Offset), code)
4162 b = appendStructEnd(ctx, code, b)
4163 code = code.Next
4164 case encoder.OpStructEndOmitEmptyInt:
4165 p := load(ctxptr, code.Idx)
4166 u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
4167 v := u64 & ((1 << code.NumBitSize) - 1)
4168 if v != 0 {
4169 b = appendStructKey(ctx, code, b)
4170 b = appendInt(ctx, b, p+uintptr(code.Offset), code)
4171 b = appendStructEnd(ctx, code, b)
4172 } else {
4173 b = appendStructEndSkipLast(ctx, code, b)
4174 }
4175 code = code.Next
4176 case encoder.OpStructEndIntString:
4177 p := load(ctxptr, code.Idx)
4178 b = appendStructKey(ctx, code, b)
4179 b = append(b, '"')
4180 b = appendInt(ctx, b, p+uintptr(code.Offset), code)
4181 b = append(b, '"')
4182 b = appendStructEnd(ctx, code, b)
4183 code = code.Next
4184 case encoder.OpStructEndOmitEmptyIntString:
4185 p := load(ctxptr, code.Idx)
4186 u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
4187 v := u64 & ((1 << code.NumBitSize) - 1)
4188 if v != 0 {
4189 b = appendStructKey(ctx, code, b)
4190 b = append(b, '"')
4191 b = appendInt(ctx, b, p+uintptr(code.Offset), code)
4192 b = append(b, '"')
4193 b = appendStructEnd(ctx, code, b)
4194 } else {
4195 b = appendStructEndSkipLast(ctx, code, b)
4196 }
4197 code = code.Next
4198 case encoder.OpStructEndIntPtr:
4199 b = appendStructKey(ctx, code, b)
4200 p := load(ctxptr, code.Idx)
4201 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4202 if p == 0 {
4203 b = appendNull(ctx, b)
4204 } else {
4205 b = appendInt(ctx, b, p, code)
4206 }
4207 b = appendStructEnd(ctx, code, b)
4208 code = code.Next
4209 case encoder.OpStructEndOmitEmptyIntPtr:
4210 p := load(ctxptr, code.Idx)
4211 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4212 if p != 0 {
4213 b = appendStructKey(ctx, code, b)
4214 b = appendInt(ctx, b, p, code)
4215 b = appendStructEnd(ctx, code, b)
4216 } else {
4217 b = appendStructEndSkipLast(ctx, code, b)
4218 }
4219 code = code.Next
4220 case encoder.OpStructEndIntPtrString:
4221 b = appendStructKey(ctx, code, b)
4222 p := load(ctxptr, code.Idx)
4223 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4224 if p == 0 {
4225 b = appendNull(ctx, b)
4226 } else {
4227 b = append(b, '"')
4228 b = appendInt(ctx, b, p, code)
4229 b = append(b, '"')
4230 }
4231 b = appendStructEnd(ctx, code, b)
4232 code = code.Next
4233 case encoder.OpStructEndOmitEmptyIntPtrString:
4234 p := load(ctxptr, code.Idx)
4235 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4236 if p != 0 {
4237 b = appendStructKey(ctx, code, b)
4238 b = append(b, '"')
4239 b = appendInt(ctx, b, p, code)
4240 b = append(b, '"')
4241 b = appendStructEnd(ctx, code, b)
4242 } else {
4243 b = appendStructEndSkipLast(ctx, code, b)
4244 }
4245 code = code.Next
4246 case encoder.OpStructEndUint:
4247 p := load(ctxptr, code.Idx)
4248 b = appendStructKey(ctx, code, b)
4249 b = appendUint(ctx, b, p+uintptr(code.Offset), code)
4250 b = appendStructEnd(ctx, code, b)
4251 code = code.Next
4252 case encoder.OpStructEndOmitEmptyUint:
4253 p := load(ctxptr, code.Idx)
4254 u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
4255 v := u64 & ((1 << code.NumBitSize) - 1)
4256 if v != 0 {
4257 b = appendStructKey(ctx, code, b)
4258 b = appendUint(ctx, b, p+uintptr(code.Offset), code)
4259 b = appendStructEnd(ctx, code, b)
4260 } else {
4261 b = appendStructEndSkipLast(ctx, code, b)
4262 }
4263 code = code.Next
4264 case encoder.OpStructEndUintString:
4265 p := load(ctxptr, code.Idx)
4266 b = appendStructKey(ctx, code, b)
4267 b = append(b, '"')
4268 b = appendUint(ctx, b, p+uintptr(code.Offset), code)
4269 b = append(b, '"')
4270 b = appendStructEnd(ctx, code, b)
4271 code = code.Next
4272 case encoder.OpStructEndOmitEmptyUintString:
4273 p := load(ctxptr, code.Idx)
4274 u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
4275 v := u64 & ((1 << code.NumBitSize) - 1)
4276 if v != 0 {
4277 b = appendStructKey(ctx, code, b)
4278 b = append(b, '"')
4279 b = appendUint(ctx, b, p+uintptr(code.Offset), code)
4280 b = append(b, '"')
4281 b = appendStructEnd(ctx, code, b)
4282 } else {
4283 b = appendStructEndSkipLast(ctx, code, b)
4284 }
4285 code = code.Next
4286 case encoder.OpStructEndUintPtr:
4287 b = appendStructKey(ctx, code, b)
4288 p := load(ctxptr, code.Idx)
4289 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4290 if p == 0 {
4291 b = appendNull(ctx, b)
4292 } else {
4293 b = appendUint(ctx, b, p, code)
4294 }
4295 b = appendStructEnd(ctx, code, b)
4296 code = code.Next
4297 case encoder.OpStructEndOmitEmptyUintPtr:
4298 p := load(ctxptr, code.Idx)
4299 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4300 if p != 0 {
4301 b = appendStructKey(ctx, code, b)
4302 b = appendUint(ctx, b, p, code)
4303 b = appendStructEnd(ctx, code, b)
4304 } else {
4305 b = appendStructEndSkipLast(ctx, code, b)
4306 }
4307 code = code.Next
4308 case encoder.OpStructEndUintPtrString:
4309 b = appendStructKey(ctx, code, b)
4310 p := load(ctxptr, code.Idx)
4311 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4312 if p == 0 {
4313 b = appendNull(ctx, b)
4314 } else {
4315 b = append(b, '"')
4316 b = appendUint(ctx, b, p, code)
4317 b = append(b, '"')
4318 }
4319 b = appendStructEnd(ctx, code, b)
4320 code = code.Next
4321 case encoder.OpStructEndOmitEmptyUintPtrString:
4322 p := load(ctxptr, code.Idx)
4323 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4324 if p != 0 {
4325 b = appendStructKey(ctx, code, b)
4326 b = append(b, '"')
4327 b = appendUint(ctx, b, p, code)
4328 b = append(b, '"')
4329 b = appendStructEnd(ctx, code, b)
4330 } else {
4331 b = appendStructEndSkipLast(ctx, code, b)
4332 }
4333 code = code.Next
4334 case encoder.OpStructEndFloat32:
4335 p := load(ctxptr, code.Idx)
4336 b = appendStructKey(ctx, code, b)
4337 b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
4338 b = appendStructEnd(ctx, code, b)
4339 code = code.Next
4340 case encoder.OpStructEndOmitEmptyFloat32:
4341 p := load(ctxptr, code.Idx)
4342 v := ptrToFloat32(p + uintptr(code.Offset))
4343 if v != 0 {
4344 b = appendStructKey(ctx, code, b)
4345 b = appendFloat32(ctx, b, v)
4346 b = appendStructEnd(ctx, code, b)
4347 } else {
4348 b = appendStructEndSkipLast(ctx, code, b)
4349 }
4350 code = code.Next
4351 case encoder.OpStructEndFloat32String:
4352 p := load(ctxptr, code.Idx)
4353 b = appendStructKey(ctx, code, b)
4354 b = append(b, '"')
4355 b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
4356 b = append(b, '"')
4357 b = appendStructEnd(ctx, code, b)
4358 code = code.Next
4359 case encoder.OpStructEndOmitEmptyFloat32String:
4360 p := load(ctxptr, code.Idx)
4361 v := ptrToFloat32(p + uintptr(code.Offset))
4362 if v != 0 {
4363 b = appendStructKey(ctx, code, b)
4364 b = append(b, '"')
4365 b = appendFloat32(ctx, b, v)
4366 b = append(b, '"')
4367 b = appendStructEnd(ctx, code, b)
4368 } else {
4369 b = appendStructEndSkipLast(ctx, code, b)
4370 }
4371 code = code.Next
4372 case encoder.OpStructEndFloat32Ptr:
4373 b = appendStructKey(ctx, code, b)
4374 p := load(ctxptr, code.Idx)
4375 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4376 if p == 0 {
4377 b = appendNull(ctx, b)
4378 } else {
4379 b = appendFloat32(ctx, b, ptrToFloat32(p))
4380 }
4381 b = appendStructEnd(ctx, code, b)
4382 code = code.Next
4383 case encoder.OpStructEndOmitEmptyFloat32Ptr:
4384 p := load(ctxptr, code.Idx)
4385 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4386 if p != 0 {
4387 b = appendStructKey(ctx, code, b)
4388 b = appendFloat32(ctx, b, ptrToFloat32(p))
4389 b = appendStructEnd(ctx, code, b)
4390 } else {
4391 b = appendStructEndSkipLast(ctx, code, b)
4392 }
4393 code = code.Next
4394 case encoder.OpStructEndFloat32PtrString:
4395 b = appendStructKey(ctx, code, b)
4396 p := load(ctxptr, code.Idx)
4397 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4398 if p == 0 {
4399 b = appendNull(ctx, b)
4400 } else {
4401 b = append(b, '"')
4402 b = appendFloat32(ctx, b, ptrToFloat32(p))
4403 b = append(b, '"')
4404 }
4405 b = appendStructEnd(ctx, code, b)
4406 code = code.Next
4407 case encoder.OpStructEndOmitEmptyFloat32PtrString:
4408 p := load(ctxptr, code.Idx)
4409 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4410 if p != 0 {
4411 b = appendStructKey(ctx, code, b)
4412 b = append(b, '"')
4413 b = appendFloat32(ctx, b, ptrToFloat32(p))
4414 b = append(b, '"')
4415 b = appendStructEnd(ctx, code, b)
4416 } else {
4417 b = appendStructEndSkipLast(ctx, code, b)
4418 }
4419 code = code.Next
4420 case encoder.OpStructEndFloat64:
4421 p := load(ctxptr, code.Idx)
4422 v := ptrToFloat64(p + uintptr(code.Offset))
4423 if math.IsInf(v, 0) || math.IsNaN(v) {
4424 return nil, errUnsupportedFloat(v)
4425 }
4426 b = appendStructKey(ctx, code, b)
4427 b = appendFloat64(ctx, b, v)
4428 b = appendStructEnd(ctx, code, b)
4429 code = code.Next
4430 case encoder.OpStructEndOmitEmptyFloat64:
4431 p := load(ctxptr, code.Idx)
4432 v := ptrToFloat64(p + uintptr(code.Offset))
4433 if v != 0 {
4434 if math.IsInf(v, 0) || math.IsNaN(v) {
4435 return nil, errUnsupportedFloat(v)
4436 }
4437 b = appendStructKey(ctx, code, b)
4438 b = appendFloat64(ctx, b, v)
4439 b = appendStructEnd(ctx, code, b)
4440 } else {
4441 b = appendStructEndSkipLast(ctx, code, b)
4442 }
4443 code = code.Next
4444 case encoder.OpStructEndFloat64String:
4445 p := load(ctxptr, code.Idx)
4446 v := ptrToFloat64(p + uintptr(code.Offset))
4447 if math.IsInf(v, 0) || math.IsNaN(v) {
4448 return nil, errUnsupportedFloat(v)
4449 }
4450 b = appendStructKey(ctx, code, b)
4451 b = append(b, '"')
4452 b = appendFloat64(ctx, b, v)
4453 b = append(b, '"')
4454 b = appendStructEnd(ctx, code, b)
4455 code = code.Next
4456 case encoder.OpStructEndOmitEmptyFloat64String:
4457 p := load(ctxptr, code.Idx)
4458 v := ptrToFloat64(p + uintptr(code.Offset))
4459 if v != 0 {
4460 if math.IsInf(v, 0) || math.IsNaN(v) {
4461 return nil, errUnsupportedFloat(v)
4462 }
4463 b = appendStructKey(ctx, code, b)
4464 b = append(b, '"')
4465 b = appendFloat64(ctx, b, v)
4466 b = append(b, '"')
4467 b = appendStructEnd(ctx, code, b)
4468 } else {
4469 b = appendStructEndSkipLast(ctx, code, b)
4470 }
4471 code = code.Next
4472 case encoder.OpStructEndFloat64Ptr:
4473 b = appendStructKey(ctx, code, b)
4474 p := load(ctxptr, code.Idx)
4475 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4476 if p == 0 {
4477 b = appendNull(ctx, b)
4478 b = appendStructEnd(ctx, code, b)
4479 code = code.Next
4480 break
4481 }
4482 v := ptrToFloat64(p)
4483 if math.IsInf(v, 0) || math.IsNaN(v) {
4484 return nil, errUnsupportedFloat(v)
4485 }
4486 b = appendFloat64(ctx, b, v)
4487 b = appendStructEnd(ctx, code, b)
4488 code = code.Next
4489 case encoder.OpStructEndOmitEmptyFloat64Ptr:
4490 p := load(ctxptr, code.Idx)
4491 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4492 if p != 0 {
4493 b = appendStructKey(ctx, code, b)
4494 v := ptrToFloat64(p)
4495 if math.IsInf(v, 0) || math.IsNaN(v) {
4496 return nil, errUnsupportedFloat(v)
4497 }
4498 b = appendFloat64(ctx, b, v)
4499 b = appendStructEnd(ctx, code, b)
4500 } else {
4501 b = appendStructEndSkipLast(ctx, code, b)
4502 }
4503 code = code.Next
4504 case encoder.OpStructEndFloat64PtrString:
4505 b = appendStructKey(ctx, code, b)
4506 p := load(ctxptr, code.Idx)
4507 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4508 if p == 0 {
4509 b = appendNull(ctx, b)
4510 } else {
4511 b = append(b, '"')
4512 v := ptrToFloat64(p)
4513 if math.IsInf(v, 0) || math.IsNaN(v) {
4514 return nil, errUnsupportedFloat(v)
4515 }
4516 b = appendFloat64(ctx, b, v)
4517 b = append(b, '"')
4518 }
4519 b = appendStructEnd(ctx, code, b)
4520 code = code.Next
4521 case encoder.OpStructEndOmitEmptyFloat64PtrString:
4522 p := load(ctxptr, code.Idx)
4523 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4524 if p != 0 {
4525 b = appendStructKey(ctx, code, b)
4526 v := ptrToFloat64(p)
4527 if math.IsInf(v, 0) || math.IsNaN(v) {
4528 return nil, errUnsupportedFloat(v)
4529 }
4530 b = append(b, '"')
4531 b = appendFloat64(ctx, b, v)
4532 b = append(b, '"')
4533 b = appendStructEnd(ctx, code, b)
4534 } else {
4535 b = appendStructEndSkipLast(ctx, code, b)
4536 }
4537 code = code.Next
4538 case encoder.OpStructEndString:
4539 p := load(ctxptr, code.Idx)
4540 b = appendStructKey(ctx, code, b)
4541 b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset)))
4542 b = appendStructEnd(ctx, code, b)
4543 code = code.Next
4544 case encoder.OpStructEndOmitEmptyString:
4545 p := load(ctxptr, code.Idx)
4546 v := ptrToString(p + uintptr(code.Offset))
4547 if v != "" {
4548 b = appendStructKey(ctx, code, b)
4549 b = appendString(ctx, b, v)
4550 b = appendStructEnd(ctx, code, b)
4551 } else {
4552 b = appendStructEndSkipLast(ctx, code, b)
4553 }
4554 code = code.Next
4555 case encoder.OpStructEndStringString:
4556 p := load(ctxptr, code.Idx)
4557 b = appendStructKey(ctx, code, b)
4558 s := ptrToString(p + uintptr(code.Offset))
4559 b = appendString(ctx, b, string(appendString(ctx, []byte{}, s)))
4560 b = appendStructEnd(ctx, code, b)
4561 code = code.Next
4562 case encoder.OpStructEndOmitEmptyStringString:
4563 p := load(ctxptr, code.Idx)
4564 v := ptrToString(p + uintptr(code.Offset))
4565 if v != "" {
4566 b = appendStructKey(ctx, code, b)
4567 b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
4568 b = appendStructEnd(ctx, code, b)
4569 } else {
4570 b = appendStructEndSkipLast(ctx, code, b)
4571 }
4572 code = code.Next
4573 case encoder.OpStructEndStringPtr:
4574 b = appendStructKey(ctx, code, b)
4575 p := load(ctxptr, code.Idx)
4576 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4577 if p == 0 {
4578 b = appendNull(ctx, b)
4579 } else {
4580 b = appendString(ctx, b, ptrToString(p))
4581 }
4582 b = appendStructEnd(ctx, code, b)
4583 code = code.Next
4584 case encoder.OpStructEndOmitEmptyStringPtr:
4585 p := load(ctxptr, code.Idx)
4586 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4587 if p != 0 {
4588 b = appendStructKey(ctx, code, b)
4589 b = appendString(ctx, b, ptrToString(p))
4590 b = appendStructEnd(ctx, code, b)
4591 } else {
4592 b = appendStructEndSkipLast(ctx, code, b)
4593 }
4594 code = code.Next
4595 case encoder.OpStructEndStringPtrString:
4596 b = appendStructKey(ctx, code, b)
4597 p := load(ctxptr, code.Idx)
4598 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4599 if p == 0 {
4600 b = appendNull(ctx, b)
4601 } else {
4602 b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
4603 }
4604 b = appendStructEnd(ctx, code, b)
4605 code = code.Next
4606 case encoder.OpStructEndOmitEmptyStringPtrString:
4607 p := load(ctxptr, code.Idx)
4608 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4609 if p != 0 {
4610 b = appendStructKey(ctx, code, b)
4611 b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
4612 b = appendStructEnd(ctx, code, b)
4613 } else {
4614 b = appendStructEndSkipLast(ctx, code, b)
4615 }
4616 code = code.Next
4617 case encoder.OpStructEndBool:
4618 p := load(ctxptr, code.Idx)
4619 b = appendStructKey(ctx, code, b)
4620 b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
4621 b = appendStructEnd(ctx, code, b)
4622 code = code.Next
4623 case encoder.OpStructEndOmitEmptyBool:
4624 p := load(ctxptr, code.Idx)
4625 v := ptrToBool(p + uintptr(code.Offset))
4626 if v {
4627 b = appendStructKey(ctx, code, b)
4628 b = appendBool(ctx, b, v)
4629 b = appendStructEnd(ctx, code, b)
4630 } else {
4631 b = appendStructEndSkipLast(ctx, code, b)
4632 }
4633 code = code.Next
4634 case encoder.OpStructEndBoolString:
4635 p := load(ctxptr, code.Idx)
4636 b = appendStructKey(ctx, code, b)
4637 b = append(b, '"')
4638 b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
4639 b = append(b, '"')
4640 b = appendStructEnd(ctx, code, b)
4641 code = code.Next
4642 case encoder.OpStructEndOmitEmptyBoolString:
4643 p := load(ctxptr, code.Idx)
4644 v := ptrToBool(p + uintptr(code.Offset))
4645 if v {
4646 b = appendStructKey(ctx, code, b)
4647 b = append(b, '"')
4648 b = appendBool(ctx, b, v)
4649 b = append(b, '"')
4650 b = appendStructEnd(ctx, code, b)
4651 } else {
4652 b = appendStructEndSkipLast(ctx, code, b)
4653 }
4654 code = code.Next
4655 case encoder.OpStructEndBoolPtr:
4656 b = appendStructKey(ctx, code, b)
4657 p := load(ctxptr, code.Idx)
4658 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4659 if p == 0 {
4660 b = appendNull(ctx, b)
4661 } else {
4662 b = appendBool(ctx, b, ptrToBool(p))
4663 }
4664 b = appendStructEnd(ctx, code, b)
4665 code = code.Next
4666 case encoder.OpStructEndOmitEmptyBoolPtr:
4667 p := load(ctxptr, code.Idx)
4668 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4669 if p != 0 {
4670 b = appendStructKey(ctx, code, b)
4671 b = appendBool(ctx, b, ptrToBool(p))
4672 b = appendStructEnd(ctx, code, b)
4673 } else {
4674 b = appendStructEndSkipLast(ctx, code, b)
4675 }
4676 code = code.Next
4677 case encoder.OpStructEndBoolPtrString:
4678 b = appendStructKey(ctx, code, b)
4679 p := load(ctxptr, code.Idx)
4680 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4681 if p == 0 {
4682 b = appendNull(ctx, b)
4683 } else {
4684 b = append(b, '"')
4685 b = appendBool(ctx, b, ptrToBool(p))
4686 b = append(b, '"')
4687 }
4688 b = appendStructEnd(ctx, code, b)
4689 code = code.Next
4690 case encoder.OpStructEndOmitEmptyBoolPtrString:
4691 p := load(ctxptr, code.Idx)
4692 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4693 if p != 0 {
4694 b = appendStructKey(ctx, code, b)
4695 b = append(b, '"')
4696 b = appendBool(ctx, b, ptrToBool(p))
4697 b = append(b, '"')
4698 b = appendStructEnd(ctx, code, b)
4699 } else {
4700 b = appendStructEndSkipLast(ctx, code, b)
4701 }
4702 code = code.Next
4703 case encoder.OpStructEndBytes:
4704 p := load(ctxptr, code.Idx)
4705 b = appendStructKey(ctx, code, b)
4706 b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset)))
4707 b = appendStructEnd(ctx, code, b)
4708 code = code.Next
4709 case encoder.OpStructEndOmitEmptyBytes:
4710 p := load(ctxptr, code.Idx)
4711 v := ptrToBytes(p + uintptr(code.Offset))
4712 if len(v) > 0 {
4713 b = appendStructKey(ctx, code, b)
4714 b = appendByteSlice(ctx, b, v)
4715 b = appendStructEnd(ctx, code, b)
4716 } else {
4717 b = appendStructEndSkipLast(ctx, code, b)
4718 }
4719 code = code.Next
4720 case encoder.OpStructEndBytesPtr:
4721 b = appendStructKey(ctx, code, b)
4722 p := load(ctxptr, code.Idx)
4723 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4724 if p == 0 {
4725 b = appendNull(ctx, b)
4726 } else {
4727 b = appendByteSlice(ctx, b, ptrToBytes(p))
4728 }
4729 b = appendStructEnd(ctx, code, b)
4730 code = code.Next
4731 case encoder.OpStructEndOmitEmptyBytesPtr:
4732 p := load(ctxptr, code.Idx)
4733 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4734 if p != 0 {
4735 b = appendStructKey(ctx, code, b)
4736 b = appendByteSlice(ctx, b, ptrToBytes(p))
4737 b = appendStructEnd(ctx, code, b)
4738 } else {
4739 b = appendStructEndSkipLast(ctx, code, b)
4740 }
4741 code = code.Next
4742 case encoder.OpStructEndNumber:
4743 p := load(ctxptr, code.Idx)
4744 b = appendStructKey(ctx, code, b)
4745 bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
4746 if err != nil {
4747 return nil, err
4748 }
4749 b = appendStructEnd(ctx, code, bb)
4750 code = code.Next
4751 case encoder.OpStructEndOmitEmptyNumber:
4752 p := load(ctxptr, code.Idx)
4753 v := ptrToNumber(p + uintptr(code.Offset))
4754 if v != "" {
4755 b = appendStructKey(ctx, code, b)
4756 bb, err := appendNumber(ctx, b, v)
4757 if err != nil {
4758 return nil, err
4759 }
4760 b = appendStructEnd(ctx, code, bb)
4761 } else {
4762 b = appendStructEndSkipLast(ctx, code, b)
4763 }
4764 code = code.Next
4765 case encoder.OpStructEndNumberString:
4766 p := load(ctxptr, code.Idx)
4767 b = appendStructKey(ctx, code, b)
4768 b = append(b, '"')
4769 bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
4770 if err != nil {
4771 return nil, err
4772 }
4773 b = append(bb, '"')
4774 b = appendStructEnd(ctx, code, b)
4775 code = code.Next
4776 case encoder.OpStructEndOmitEmptyNumberString:
4777 p := load(ctxptr, code.Idx)
4778 v := ptrToNumber(p + uintptr(code.Offset))
4779 if v != "" {
4780 b = appendStructKey(ctx, code, b)
4781 b = append(b, '"')
4782 bb, err := appendNumber(ctx, b, v)
4783 if err != nil {
4784 return nil, err
4785 }
4786 b = append(bb, '"')
4787 b = appendStructEnd(ctx, code, b)
4788 } else {
4789 b = appendStructEndSkipLast(ctx, code, b)
4790 }
4791 code = code.Next
4792 case encoder.OpStructEndNumberPtr:
4793 b = appendStructKey(ctx, code, b)
4794 p := load(ctxptr, code.Idx)
4795 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4796 if p == 0 {
4797 b = appendNull(ctx, b)
4798 } else {
4799 bb, err := appendNumber(ctx, b, ptrToNumber(p))
4800 if err != nil {
4801 return nil, err
4802 }
4803 b = bb
4804 }
4805 b = appendStructEnd(ctx, code, b)
4806 code = code.Next
4807 case encoder.OpStructEndOmitEmptyNumberPtr:
4808 p := load(ctxptr, code.Idx)
4809 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4810 if p != 0 {
4811 b = appendStructKey(ctx, code, b)
4812 bb, err := appendNumber(ctx, b, ptrToNumber(p))
4813 if err != nil {
4814 return nil, err
4815 }
4816 b = appendStructEnd(ctx, code, bb)
4817 } else {
4818 b = appendStructEndSkipLast(ctx, code, b)
4819 }
4820 code = code.Next
4821 case encoder.OpStructEndNumberPtrString:
4822 b = appendStructKey(ctx, code, b)
4823 p := load(ctxptr, code.Idx)
4824 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4825 if p == 0 {
4826 b = appendNull(ctx, b)
4827 } else {
4828 b = append(b, '"')
4829 bb, err := appendNumber(ctx, b, ptrToNumber(p))
4830 if err != nil {
4831 return nil, err
4832 }
4833 b = append(bb, '"')
4834 }
4835 b = appendStructEnd(ctx, code, b)
4836 code = code.Next
4837 case encoder.OpStructEndOmitEmptyNumberPtrString:
4838 p := load(ctxptr, code.Idx)
4839 p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
4840 if p != 0 {
4841 b = appendStructKey(ctx, code, b)
4842 b = append(b, '"')
4843 bb, err := appendNumber(ctx, b, ptrToNumber(p))
4844 if err != nil {
4845 return nil, err
4846 }
4847 b = append(bb, '"')
4848 b = appendStructEnd(ctx, code, b)
4849 } else {
4850 b = appendStructEndSkipLast(ctx, code, b)
4851 }
4852 code = code.Next
4853 case encoder.OpEnd:
4854 goto END
4855 }
4856 }
4857END:
4858 return b, nil
4859}
View as plain text