codec: remove EncodeAsis and optimize access to jsonEncDriver

First, EncodeAsis is only supported by jsonEncDriver and does the default
implementation of writing bytes to the stream as-is.
There's no need to have an encDriverAsis interface.

So - remove all traces of encDriverAsis, EncodeAsis, etc.

Secondly, we do not need to keep a reference to jsonEncDriver and jsonDecDriver
as those can be retrieved quite performantly via encDriver and decDriver interface.
Instead, we make safe/unsafe ways to grab it easily.

Finally, create the option for making optimized checkBreak that affords
inlining. This is not an option right now, as CheckBreak cannot be inlined.
But set things in place for it.

codec/cbor.go

@@ -883,6 +883,7 @@ func (h *CborHandle) newEncDriver() encDriver {
 func (h *CborHandle) newDecDriver() decDriver {
 	d := &cborDecDriver{h: h, st: h.SkipUnexpectedTags}
 	d.d.d = d
+	d.d.cbor = true
 	d.d.init(h)
 	d.reset()
 	return d

codec/decode.go

@@ -25,7 +25,7 @@ const (
 	decDefSliceCap = 8
 	decDefChanCap  = 64 // should be large, as cap cannot be expanded
 	// decScratchByteArrayLen = cacheLineSize + (5 * 8) // - 5 // + (8 * 2) // - (8 * 1)
-	decScratchByteArrayLen = (5 * 8) // - 5 // + (8 * 2) // - (8 * 1)
+	decScratchByteArrayLen = (6 * 8) // - 5 // + (8 * 2) // - (8 * 1)
 
 	// decContainerLenUnknown is length returned from Read(Map|Array)Len
 	// when a format doesn't know apiori.
@@ -54,7 +54,7 @@ var (
 	errstrOnlyMapOrArrayCanDecodeIntoStruct = "only encoded map or array can be decoded into a struct"
 	errstrCannotDecodeIntoNil               = "cannot decode into nil"
 
-	errmsgExpandSliceOverflow     = "expand slice: slice overflow"
+	// errmsgExpandSliceOverflow     = "expand slice: slice overflow"
 	errmsgExpandSliceCannotChange = "expand slice: cannot change"
 
 	errDecoderNotInitialized = errors.New("Decoder not initialized")
@@ -640,7 +640,7 @@ func (d *Decoder) kStruct(f *codecFnInfo, rv reflect.Value) {
 		hasLen := containerLen >= 0
 
 		var rvkencname []byte
-		for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+		for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 			d.mapElemKey()
 			rvkencname = decStructFieldKey(d.d, f.ti.keyType, &d.b)
 			// xdebugf("key: '%s'", rvkencname)
@@ -686,7 +686,7 @@ func (d *Decoder) kStruct(f *codecFnInfo, rv reflect.Value) {
 			if hasLen && j == containerLen {
 				break
 			}
-			if !hasLen && d.d.CheckBreak() {
+			if !hasLen && d.checkBreak() {
 				checkbreak = true
 				break
 			}
@@ -701,7 +701,7 @@ func (d *Decoder) kStruct(f *codecFnInfo, rv reflect.Value) {
 		if (hasLen && containerLen > len(f.ti.sfiSrc)) || (!hasLen && !checkbreak) {
 			// read remaining values and throw away
 			for j := len(f.ti.sfiSrc); ; j++ {
-				if (hasLen && j == containerLen) || (!hasLen && d.d.CheckBreak()) {
+				if (hasLen && j == containerLen) || (!hasLen && d.checkBreak()) {
 					break
 				}
 				d.arrayElem()
@@ -832,7 +832,7 @@ func (d *Decoder) kSlice(f *codecFnInfo, rv reflect.Value) {
 	var j int
 
 	// xdebug2f("0: rvcap: %d, rvlen: %d", rvcap, rvlen)
-	for ; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for ; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j == 0 && f.seq == seqTypeSlice && rvIsNil(rv) {
 			if hasLen {
 				rvlen = decInferLen(containerLenS, d.h.MaxInitLen, rtelem0Size)
@@ -855,7 +855,7 @@ func (d *Decoder) kSlice(f *codecFnInfo, rv reflect.Value) {
 				// drain completely and return
 				d.swallow()
 				j++
-				for ; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+				for ; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 					slh.ElemContainerState(j)
 					d.swallow()
 				}
@@ -1024,7 +1024,7 @@ func (d *Decoder) kSliceForChan(f *codecFnInfo, rv reflect.Value) {
 	// var rtelem0ZeroValid bool
 	var j int
 
-	for ; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for ; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j == 0 && rvIsNil(rv) {
 			if hasLen {
 				rvlen = decInferLen(containerLenS, d.h.MaxInitLen, rtelem0Size)
@@ -1122,7 +1122,7 @@ func (d *Decoder) kMap(f *codecFnInfo, rv reflect.Value) {
 	hasLen := containerLen > 0
 	var kstrbs []byte
 
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		if j == 0 {
 			// rvvz = reflect.Zero(vtype)
 			// rvkz = reflect.Zero(ktype)
@@ -1345,9 +1345,10 @@ type Decoder struct {
 	mtid uintptr
 	stid uintptr
 
-	jdec *jsonDecDriver
-	h    *BasicHandle
-	hh   Handle
+	// jdec *jsonDecDriver
+	h *BasicHandle
+
+	blist bytesFreelist
 
 	// ---- cpu cache line boundary?
 	decRd
@@ -1359,11 +1360,12 @@ type Decoder struct {
 
 	// _ [4]uint8 // padding
 
-	is map[string]string // used for interning strings
-
+	hh  Handle
 	err error
 
 	// ---- cpu cache line boundary?
+	is map[string]string // used for interning strings
+
 	// ---- writable fields during execution --- *try* to keep in sep cache line
 	maxdepth int16
 	depth    int16
@@ -1383,8 +1385,6 @@ type Decoder struct {
 	// having to get from freelist, use, and return back to freelist.
 	b [decScratchByteArrayLen]byte
 
-	blist bytesFreelist
-
 	// padding - false sharing help // modify 232 if Decoder struct changes.
 	// _ [cacheLineSize - 232%cacheLineSize]byte
 }
@@ -1414,9 +1414,9 @@ func (d *Decoder) r() *decRd {
 }
 
 func (d *Decoder) init(h Handle) {
-	if useFinalizers {
-		// runtime.SetFinalizer(d, (*Decoder).finalize)
-	}
+	// if useFinalizers {
+	// 	runtime.SetFinalizer(d, (*Decoder).finalize)
+	// }
 	d.bytes = true
 	d.err = errDecoderNotInitialized
 	// d.r = &d.decRd
@@ -1692,8 +1692,8 @@ func (d *Decoder) swallow() {
 	case valueTypeMap:
 		containerLen := d.mapStart()
 		hasLen := containerLen >= 0
-		for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
-			// if clenGtEqualZero {if j >= containerLen {break} } else if d.d.CheckBreak() {break}
+		for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+			// if clenGtEqualZero {if j >= containerLen {break} } else if d.checkBreak() {break}
 			d.mapElemKey()
 			d.swallow()
 			d.mapElemValue()
@@ -1703,7 +1703,7 @@ func (d *Decoder) swallow() {
 	case valueTypeArray:
 		containerLen := d.arrayStart()
 		hasLen := containerLen >= 0
-		for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+		for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 			d.arrayElem()
 			d.swallow()
 		}
@@ -2035,7 +2035,7 @@ func (d *Decoder) NumBytesRead() int {
 // Note that we return float64 to reduce unnecessary conversions
 func (d *Decoder) decodeFloat32() float32 {
 	if d.js {
-		return d.jdec.DecodeFloat32() // custom implementation for 32-bit
+		return d.jsondriver().DecodeFloat32() // custom implementation for 32-bit
 	}
 	return float32(chkOvf.Float32V(d.d.DecodeFloat64()))
 }
@@ -2058,14 +2058,14 @@ func (d *Decoder) mapStart() (v int) {
 
 func (d *Decoder) mapElemKey() {
 	if d.js {
-		d.jdec.ReadMapElemKey()
+		d.jsondriver().ReadMapElemKey()
 	}
 	d.c = containerMapKey
 }
 
 func (d *Decoder) mapElemValue() {
 	if d.js {
-		d.jdec.ReadMapElemValue()
+		d.jsondriver().ReadMapElemValue()
 	}
 	d.c = containerMapValue
 }
@@ -2073,20 +2073,22 @@ func (d *Decoder) mapElemValue() {
 func (d *Decoder) mapEnd() {
 	d.d.ReadMapEnd()
 	d.depthDecr()
-	d.c = containerMapEnd
+	// d.c = containerMapEnd
 	d.c = 0
 }
 
 func (d *Decoder) arrayStart() (v int) {
 	v = d.d.ReadArrayStart()
-	d.depthIncr()
-	d.c = containerArrayStart
+	if v != decContainerLenNil {
+		d.depthIncr()
+		d.c = containerArrayStart
+	}
 	return
 }
 
 func (d *Decoder) arrayElem() {
 	if d.js {
-		d.jdec.ReadArrayElem()
+		d.jsondriver().ReadArrayElem()
 	}
 	d.c = containerArrayElem
 }
@@ -2094,7 +2096,7 @@ func (d *Decoder) arrayElem() {
 func (d *Decoder) arrayEnd() {
 	d.d.ReadArrayEnd()
 	d.depthDecr()
-	d.c = containerArrayEnd
+	// d.c = containerArrayEnd
 	d.c = 0
 }
 

codec/encode.go

@@ -55,9 +55,9 @@ type encDriverContainerTracker interface {
 	WriteMapElemValue()
 }
 
-type encDriverAsis interface {
-	EncodeAsis(v []byte)
-}
+// type encDriverAsis interface {
+// 	EncodeAsis(v []byte)
+// }
 
 type encodeError struct {
 	codecError
@@ -834,7 +834,7 @@ func (e *Encoder) kMapCanonical(rtkey, rtval reflect.Type, rv, rvv reflect.Value
 		sort.Sort(bytesRvSlice(mksbv))
 		for j := range mksbv {
 			e.mapElemKey()
-			e.asis(mksbv[j].v)
+			e.encWr.writeb(mksbv[j].v) // e.asis(mksbv[j].v)
 			e.mapElemValue()
 			e.encodeValue(mapGet(rv, mksbv[j].r, rvv), valFn)
 		}
@@ -861,16 +861,18 @@ type Encoder struct {
 	// w *encWr
 
 	// bw *bufio.Writer
-	as encDriverAsis
+	// as encDriverAsis
 
-	jenc *jsonEncDriver
-	h    *BasicHandle
-	hh   Handle
+	// jenc *jsonEncDriver
+	h *BasicHandle
 
-	// ---- cpu cache line boundary
 	encWr
 
-	err error
+	// ---- cpu cache line boundary
+	hh Handle
+
+	blist bytesFreelist
+	err   error
 
 	// ---- cpu cache line boundary
 
@@ -878,10 +880,9 @@ type Encoder struct {
 	ci set // holds set of addresses found during an encoding (if CheckCircularRef=true)
 	// cidef [1]interface{} // default ci
 
-	b [(7 * 8)]byte // for encoding chan byte, (non-addressable) [N]byte, etc
-
 	slist sfiRvFreelist
-	blist bytesFreelist
+
+	b [(2 * 8)]byte // for encoding chan byte, (non-addressable) [N]byte, etc
 
 	// ---- cpu cache line boundary?
 
@@ -914,14 +915,14 @@ func NewEncoderBytes(out *[]byte, h Handle) *Encoder {
 func (e *Encoder) init(h Handle) {
 	e.err = errEncoderNotInitialized
 	e.bytes = true
-	if useFinalizers {
-		// runtime.SetFinalizer(e, (*Encoder).finalize)
-	}
+	// if useFinalizers {
+	// 	runtime.SetFinalizer(e, (*Encoder).finalize)
+	// }
 	// e.w = &e.encWr
 	e.hh = h
 	e.h = basicHandle(h)
 	// e.esep = h.hasElemSeparators()
-	e.as, e.isas = e.e.(encDriverAsis)
+	// e.as, e.isas = e.e.(encDriverAsis)
 	e.be = e.hh.isBinary()
 }
 
@@ -1399,7 +1400,7 @@ func (e *Encoder) marshalAsis(bs []byte, fnerr error) {
 	if bs == nil {
 		e.e.EncodeNil()
 	} else {
-		e.asis(bs)
+		e.encWr.writeb(bs) // e.asis(bs)
 	}
 }
 
@@ -1414,20 +1415,20 @@ func (e *Encoder) marshalRaw(bs []byte, fnerr error) {
 	}
 }
 
-func (e *Encoder) asis(v []byte) {
-	if e.isas {
-		e.as.EncodeAsis(v)
-	} else {
-		e.w().writeb(v)
-	}
-}
+// func (e *Encoder) asis(v []byte) {
+// 	if e.isas {
+// 		e.as.EncodeAsis(v)
+// 	} else {
+// 		e.w().writeb(v)
+// 	}
+// }
 
 func (e *Encoder) rawBytes(vv Raw) {
 	v := []byte(vv)
 	if !e.h.Raw {
 		e.errorf("Raw values cannot be encoded: %v", v)
 	}
-	e.asis(v)
+	e.encWr.writeb(v) // e.asis(v)
 }
 
 func (e *Encoder) wrapErr(v interface{}, err *error) {
@@ -1445,14 +1446,14 @@ func (e *Encoder) mapStart(length int) {
 
 func (e *Encoder) mapElemKey() {
 	if e.js {
-		e.jenc.WriteMapElemKey()
+		e.jsondriver().WriteMapElemKey()
 	}
 	e.c = containerMapKey
 }
 
 func (e *Encoder) mapElemValue() {
 	if e.js {
-		e.jenc.WriteMapElemValue()
+		e.jsondriver().WriteMapElemValue()
 	}
 	e.c = containerMapValue
 }
@@ -1474,7 +1475,7 @@ func (e *Encoder) mapElemValue() {
 
 func (e *Encoder) mapEnd() {
 	e.e.WriteMapEnd()
-	e.c = containerMapEnd
+	// e.c = containerMapEnd
 	e.c = 0
 }
 
@@ -1485,7 +1486,7 @@ func (e *Encoder) arrayStart(length int) {
 
 func (e *Encoder) arrayElem() {
 	if e.js {
-		e.jenc.WriteArrayElem()
+		e.jsondriver().WriteArrayElem()
 	}
 	e.c = containerArrayElem
 }
@@ -1493,7 +1494,7 @@ func (e *Encoder) arrayElem() {
 func (e *Encoder) arrayEnd() {
 	e.e.WriteArrayEnd()
 	e.c = 0
-	e.c = containerArrayEnd
+	// e.c = containerArrayEnd
 }
 
 // ----------

codec/fast-path.generated.go

@@ -4225,7 +4225,7 @@ func (fastpathT) DecSliceIntfY(v []interface{}, d *Decoder) (_ []interface{}, ch
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j == 0 && len(v) == 0 {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
@@ -4262,7 +4262,7 @@ func (fastpathT) DecSliceIntfN(v []interface{}, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j >= len(v) {
 			fastpathDecArrayCannotExpand(slh, hasLen, len(v), j, containerLenS)
 			return
@@ -4322,7 +4322,7 @@ func (fastpathT) DecSliceStringY(v []string, d *Decoder) (_ []string, changed bo
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j == 0 && len(v) == 0 {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
@@ -4359,7 +4359,7 @@ func (fastpathT) DecSliceStringN(v []string, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j >= len(v) {
 			fastpathDecArrayCannotExpand(slh, hasLen, len(v), j, containerLenS)
 			return
@@ -4419,7 +4419,7 @@ func (fastpathT) DecSliceBytesY(v [][]byte, d *Decoder) (_ [][]byte, changed boo
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j == 0 && len(v) == 0 {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 24)
@@ -4456,7 +4456,7 @@ func (fastpathT) DecSliceBytesN(v [][]byte, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j >= len(v) {
 			fastpathDecArrayCannotExpand(slh, hasLen, len(v), j, containerLenS)
 			return
@@ -4516,7 +4516,7 @@ func (fastpathT) DecSliceFloat32Y(v []float32, d *Decoder) (_ []float32, changed
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j == 0 && len(v) == 0 {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
@@ -4553,7 +4553,7 @@ func (fastpathT) DecSliceFloat32N(v []float32, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j >= len(v) {
 			fastpathDecArrayCannotExpand(slh, hasLen, len(v), j, containerLenS)
 			return
@@ -4613,7 +4613,7 @@ func (fastpathT) DecSliceFloat64Y(v []float64, d *Decoder) (_ []float64, changed
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j == 0 && len(v) == 0 {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
@@ -4650,7 +4650,7 @@ func (fastpathT) DecSliceFloat64N(v []float64, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j >= len(v) {
 			fastpathDecArrayCannotExpand(slh, hasLen, len(v), j, containerLenS)
 			return
@@ -4710,7 +4710,7 @@ func (fastpathT) DecSliceUintY(v []uint, d *Decoder) (_ []uint, changed bool) {
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j == 0 && len(v) == 0 {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
@@ -4747,7 +4747,7 @@ func (fastpathT) DecSliceUintN(v []uint, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j >= len(v) {
 			fastpathDecArrayCannotExpand(slh, hasLen, len(v), j, containerLenS)
 			return
@@ -4807,7 +4807,7 @@ func (fastpathT) DecSliceUint16Y(v []uint16, d *Decoder) (_ []uint16, changed bo
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j == 0 && len(v) == 0 {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
@@ -4844,7 +4844,7 @@ func (fastpathT) DecSliceUint16N(v []uint16, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j >= len(v) {
 			fastpathDecArrayCannotExpand(slh, hasLen, len(v), j, containerLenS)
 			return
@@ -4904,7 +4904,7 @@ func (fastpathT) DecSliceUint32Y(v []uint32, d *Decoder) (_ []uint32, changed bo
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j == 0 && len(v) == 0 {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
@@ -4941,7 +4941,7 @@ func (fastpathT) DecSliceUint32N(v []uint32, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j >= len(v) {
 			fastpathDecArrayCannotExpand(slh, hasLen, len(v), j, containerLenS)
 			return
@@ -5001,7 +5001,7 @@ func (fastpathT) DecSliceUint64Y(v []uint64, d *Decoder) (_ []uint64, changed bo
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j == 0 && len(v) == 0 {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
@@ -5038,7 +5038,7 @@ func (fastpathT) DecSliceUint64N(v []uint64, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j >= len(v) {
 			fastpathDecArrayCannotExpand(slh, hasLen, len(v), j, containerLenS)
 			return
@@ -5098,7 +5098,7 @@ func (fastpathT) DecSliceIntY(v []int, d *Decoder) (_ []int, changed bool) {
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j == 0 && len(v) == 0 {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
@@ -5135,7 +5135,7 @@ func (fastpathT) DecSliceIntN(v []int, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j >= len(v) {
 			fastpathDecArrayCannotExpand(slh, hasLen, len(v), j, containerLenS)
 			return
@@ -5195,7 +5195,7 @@ func (fastpathT) DecSliceInt8Y(v []int8, d *Decoder) (_ []int8, changed bool) {
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j == 0 && len(v) == 0 {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
@@ -5232,7 +5232,7 @@ func (fastpathT) DecSliceInt8N(v []int8, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j >= len(v) {
 			fastpathDecArrayCannotExpand(slh, hasLen, len(v), j, containerLenS)
 			return
@@ -5292,7 +5292,7 @@ func (fastpathT) DecSliceInt16Y(v []int16, d *Decoder) (_ []int16, changed bool)
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j == 0 && len(v) == 0 {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
@@ -5329,7 +5329,7 @@ func (fastpathT) DecSliceInt16N(v []int16, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j >= len(v) {
 			fastpathDecArrayCannotExpand(slh, hasLen, len(v), j, containerLenS)
 			return
@@ -5389,7 +5389,7 @@ func (fastpathT) DecSliceInt32Y(v []int32, d *Decoder) (_ []int32, changed bool)
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j == 0 && len(v) == 0 {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
@@ -5426,7 +5426,7 @@ func (fastpathT) DecSliceInt32N(v []int32, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j >= len(v) {
 			fastpathDecArrayCannotExpand(slh, hasLen, len(v), j, containerLenS)
 			return
@@ -5486,7 +5486,7 @@ func (fastpathT) DecSliceInt64Y(v []int64, d *Decoder) (_ []int64, changed bool)
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j == 0 && len(v) == 0 {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
@@ -5523,7 +5523,7 @@ func (fastpathT) DecSliceInt64N(v []int64, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j >= len(v) {
 			fastpathDecArrayCannotExpand(slh, hasLen, len(v), j, containerLenS)
 			return
@@ -5583,7 +5583,7 @@ func (fastpathT) DecSliceBoolY(v []bool, d *Decoder) (_ []bool, changed bool) {
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j == 0 && len(v) == 0 {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
@@ -5620,7 +5620,7 @@ func (fastpathT) DecSliceBoolN(v []bool, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j >= len(v) {
 			fastpathDecArrayCannotExpand(slh, hasLen, len(v), j, containerLenS)
 			return
@@ -5635,7 +5635,7 @@ func fastpathDecArrayCannotExpand(slh decSliceHelper, hasLen bool, lenv, j, cont
 	slh.ElemContainerState(j)
 	slh.d.swallow()
 	j++
-	for ; (hasLen && j < containerLenS) || !(hasLen || slh.d.d.CheckBreak()); j++ {
+	for ; (hasLen && j < containerLenS) || !(hasLen || slh.d.checkBreak()); j++ {
 		slh.ElemContainerState(j)
 		slh.d.swallow()
 	}
@@ -5682,7 +5682,7 @@ func (fastpathT) DecMapStringIntfL(v map[string]interface{}, containerLen int, d
 	var mk string
 	var mv interface{}
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = string(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -5736,7 +5736,7 @@ func (fastpathT) DecMapStringStringL(v map[string]string, containerLen int, d *D
 	var mk string
 	var mv string
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = string(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -5786,7 +5786,7 @@ func (fastpathT) DecMapStringBytesL(v map[string][]byte, containerLen int, d *De
 	var mk string
 	var mv []byte
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = string(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -5840,7 +5840,7 @@ func (fastpathT) DecMapStringUintL(v map[string]uint, containerLen int, d *Decod
 	var mk string
 	var mv uint
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = string(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -5889,7 +5889,7 @@ func (fastpathT) DecMapStringUint8L(v map[string]uint8, containerLen int, d *Dec
 	var mk string
 	var mv uint8
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = string(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -5938,7 +5938,7 @@ func (fastpathT) DecMapStringUint64L(v map[string]uint64, containerLen int, d *D
 	var mk string
 	var mv uint64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = string(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -5987,7 +5987,7 @@ func (fastpathT) DecMapStringIntL(v map[string]int, containerLen int, d *Decoder
 	var mk string
 	var mv int
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = string(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -6036,7 +6036,7 @@ func (fastpathT) DecMapStringInt64L(v map[string]int64, containerLen int, d *Dec
 	var mk string
 	var mv int64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = string(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -6085,7 +6085,7 @@ func (fastpathT) DecMapStringFloat32L(v map[string]float32, containerLen int, d
 	var mk string
 	var mv float32
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = string(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -6134,7 +6134,7 @@ func (fastpathT) DecMapStringFloat64L(v map[string]float64, containerLen int, d
 	var mk string
 	var mv float64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = string(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -6183,7 +6183,7 @@ func (fastpathT) DecMapStringBoolL(v map[string]bool, containerLen int, d *Decod
 	var mk string
 	var mv bool
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = string(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -6233,7 +6233,7 @@ func (fastpathT) DecMapUintIntfL(v map[uint]interface{}, containerLen int, d *De
 	var mk uint
 	var mv interface{}
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
 		d.mapElemValue()
@@ -6287,7 +6287,7 @@ func (fastpathT) DecMapUintStringL(v map[uint]string, containerLen int, d *Decod
 	var mk uint
 	var mv string
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
 		d.mapElemValue()
@@ -6337,7 +6337,7 @@ func (fastpathT) DecMapUintBytesL(v map[uint][]byte, containerLen int, d *Decode
 	var mk uint
 	var mv []byte
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
 		d.mapElemValue()
@@ -6391,7 +6391,7 @@ func (fastpathT) DecMapUintUintL(v map[uint]uint, containerLen int, d *Decoder)
 	var mk uint
 	var mv uint
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
 		d.mapElemValue()
@@ -6440,7 +6440,7 @@ func (fastpathT) DecMapUintUint8L(v map[uint]uint8, containerLen int, d *Decoder
 	var mk uint
 	var mv uint8
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
 		d.mapElemValue()
@@ -6489,7 +6489,7 @@ func (fastpathT) DecMapUintUint64L(v map[uint]uint64, containerLen int, d *Decod
 	var mk uint
 	var mv uint64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
 		d.mapElemValue()
@@ -6538,7 +6538,7 @@ func (fastpathT) DecMapUintIntL(v map[uint]int, containerLen int, d *Decoder) {
 	var mk uint
 	var mv int
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
 		d.mapElemValue()
@@ -6587,7 +6587,7 @@ func (fastpathT) DecMapUintInt64L(v map[uint]int64, containerLen int, d *Decoder
 	var mk uint
 	var mv int64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
 		d.mapElemValue()
@@ -6636,7 +6636,7 @@ func (fastpathT) DecMapUintFloat32L(v map[uint]float32, containerLen int, d *Dec
 	var mk uint
 	var mv float32
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
 		d.mapElemValue()
@@ -6685,7 +6685,7 @@ func (fastpathT) DecMapUintFloat64L(v map[uint]float64, containerLen int, d *Dec
 	var mk uint
 	var mv float64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
 		d.mapElemValue()
@@ -6734,7 +6734,7 @@ func (fastpathT) DecMapUintBoolL(v map[uint]bool, containerLen int, d *Decoder)
 	var mk uint
 	var mv bool
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
 		d.mapElemValue()
@@ -6784,7 +6784,7 @@ func (fastpathT) DecMapUint8IntfL(v map[uint8]interface{}, containerLen int, d *
 	var mk uint8
 	var mv interface{}
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -6838,7 +6838,7 @@ func (fastpathT) DecMapUint8StringL(v map[uint8]string, containerLen int, d *Dec
 	var mk uint8
 	var mv string
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -6888,7 +6888,7 @@ func (fastpathT) DecMapUint8BytesL(v map[uint8][]byte, containerLen int, d *Deco
 	var mk uint8
 	var mv []byte
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -6942,7 +6942,7 @@ func (fastpathT) DecMapUint8UintL(v map[uint8]uint, containerLen int, d *Decoder
 	var mk uint8
 	var mv uint
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -6991,7 +6991,7 @@ func (fastpathT) DecMapUint8Uint8L(v map[uint8]uint8, containerLen int, d *Decod
 	var mk uint8
 	var mv uint8
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -7040,7 +7040,7 @@ func (fastpathT) DecMapUint8Uint64L(v map[uint8]uint64, containerLen int, d *Dec
 	var mk uint8
 	var mv uint64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -7089,7 +7089,7 @@ func (fastpathT) DecMapUint8IntL(v map[uint8]int, containerLen int, d *Decoder)
 	var mk uint8
 	var mv int
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -7138,7 +7138,7 @@ func (fastpathT) DecMapUint8Int64L(v map[uint8]int64, containerLen int, d *Decod
 	var mk uint8
 	var mv int64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -7187,7 +7187,7 @@ func (fastpathT) DecMapUint8Float32L(v map[uint8]float32, containerLen int, d *D
 	var mk uint8
 	var mv float32
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -7236,7 +7236,7 @@ func (fastpathT) DecMapUint8Float64L(v map[uint8]float64, containerLen int, d *D
 	var mk uint8
 	var mv float64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -7285,7 +7285,7 @@ func (fastpathT) DecMapUint8BoolL(v map[uint8]bool, containerLen int, d *Decoder
 	var mk uint8
 	var mv bool
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -7335,7 +7335,7 @@ func (fastpathT) DecMapUint64IntfL(v map[uint64]interface{}, containerLen int, d
 	var mk uint64
 	var mv interface{}
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -7389,7 +7389,7 @@ func (fastpathT) DecMapUint64StringL(v map[uint64]string, containerLen int, d *D
 	var mk uint64
 	var mv string
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -7439,7 +7439,7 @@ func (fastpathT) DecMapUint64BytesL(v map[uint64][]byte, containerLen int, d *De
 	var mk uint64
 	var mv []byte
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -7493,7 +7493,7 @@ func (fastpathT) DecMapUint64UintL(v map[uint64]uint, containerLen int, d *Decod
 	var mk uint64
 	var mv uint
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -7542,7 +7542,7 @@ func (fastpathT) DecMapUint64Uint8L(v map[uint64]uint8, containerLen int, d *Dec
 	var mk uint64
 	var mv uint8
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -7591,7 +7591,7 @@ func (fastpathT) DecMapUint64Uint64L(v map[uint64]uint64, containerLen int, d *D
 	var mk uint64
 	var mv uint64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -7640,7 +7640,7 @@ func (fastpathT) DecMapUint64IntL(v map[uint64]int, containerLen int, d *Decoder
 	var mk uint64
 	var mv int
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -7689,7 +7689,7 @@ func (fastpathT) DecMapUint64Int64L(v map[uint64]int64, containerLen int, d *Dec
 	var mk uint64
 	var mv int64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -7738,7 +7738,7 @@ func (fastpathT) DecMapUint64Float32L(v map[uint64]float32, containerLen int, d
 	var mk uint64
 	var mv float32
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -7787,7 +7787,7 @@ func (fastpathT) DecMapUint64Float64L(v map[uint64]float64, containerLen int, d
 	var mk uint64
 	var mv float64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -7836,7 +7836,7 @@ func (fastpathT) DecMapUint64BoolL(v map[uint64]bool, containerLen int, d *Decod
 	var mk uint64
 	var mv bool
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -7886,7 +7886,7 @@ func (fastpathT) DecMapIntIntfL(v map[int]interface{}, containerLen int, d *Deco
 	var mk int
 	var mv interface{}
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -7940,7 +7940,7 @@ func (fastpathT) DecMapIntStringL(v map[int]string, containerLen int, d *Decoder
 	var mk int
 	var mv string
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -7990,7 +7990,7 @@ func (fastpathT) DecMapIntBytesL(v map[int][]byte, containerLen int, d *Decoder)
 	var mk int
 	var mv []byte
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -8044,7 +8044,7 @@ func (fastpathT) DecMapIntUintL(v map[int]uint, containerLen int, d *Decoder) {
 	var mk int
 	var mv uint
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -8093,7 +8093,7 @@ func (fastpathT) DecMapIntUint8L(v map[int]uint8, containerLen int, d *Decoder)
 	var mk int
 	var mv uint8
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -8142,7 +8142,7 @@ func (fastpathT) DecMapIntUint64L(v map[int]uint64, containerLen int, d *Decoder
 	var mk int
 	var mv uint64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -8191,7 +8191,7 @@ func (fastpathT) DecMapIntIntL(v map[int]int, containerLen int, d *Decoder) {
 	var mk int
 	var mv int
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -8240,7 +8240,7 @@ func (fastpathT) DecMapIntInt64L(v map[int]int64, containerLen int, d *Decoder)
 	var mk int
 	var mv int64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -8289,7 +8289,7 @@ func (fastpathT) DecMapIntFloat32L(v map[int]float32, containerLen int, d *Decod
 	var mk int
 	var mv float32
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -8338,7 +8338,7 @@ func (fastpathT) DecMapIntFloat64L(v map[int]float64, containerLen int, d *Decod
 	var mk int
 	var mv float64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -8387,7 +8387,7 @@ func (fastpathT) DecMapIntBoolL(v map[int]bool, containerLen int, d *Decoder) {
 	var mk int
 	var mv bool
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -8437,7 +8437,7 @@ func (fastpathT) DecMapInt64IntfL(v map[int64]interface{}, containerLen int, d *
 	var mk int64
 	var mv interface{}
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeInt64()
 		d.mapElemValue()
@@ -8491,7 +8491,7 @@ func (fastpathT) DecMapInt64StringL(v map[int64]string, containerLen int, d *Dec
 	var mk int64
 	var mv string
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeInt64()
 		d.mapElemValue()
@@ -8541,7 +8541,7 @@ func (fastpathT) DecMapInt64BytesL(v map[int64][]byte, containerLen int, d *Deco
 	var mk int64
 	var mv []byte
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeInt64()
 		d.mapElemValue()
@@ -8595,7 +8595,7 @@ func (fastpathT) DecMapInt64UintL(v map[int64]uint, containerLen int, d *Decoder
 	var mk int64
 	var mv uint
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeInt64()
 		d.mapElemValue()
@@ -8644,7 +8644,7 @@ func (fastpathT) DecMapInt64Uint8L(v map[int64]uint8, containerLen int, d *Decod
 	var mk int64
 	var mv uint8
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeInt64()
 		d.mapElemValue()
@@ -8693,7 +8693,7 @@ func (fastpathT) DecMapInt64Uint64L(v map[int64]uint64, containerLen int, d *Dec
 	var mk int64
 	var mv uint64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeInt64()
 		d.mapElemValue()
@@ -8742,7 +8742,7 @@ func (fastpathT) DecMapInt64IntL(v map[int64]int, containerLen int, d *Decoder)
 	var mk int64
 	var mv int
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeInt64()
 		d.mapElemValue()
@@ -8791,7 +8791,7 @@ func (fastpathT) DecMapInt64Int64L(v map[int64]int64, containerLen int, d *Decod
 	var mk int64
 	var mv int64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeInt64()
 		d.mapElemValue()
@@ -8840,7 +8840,7 @@ func (fastpathT) DecMapInt64Float32L(v map[int64]float32, containerLen int, d *D
 	var mk int64
 	var mv float32
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeInt64()
 		d.mapElemValue()
@@ -8889,7 +8889,7 @@ func (fastpathT) DecMapInt64Float64L(v map[int64]float64, containerLen int, d *D
 	var mk int64
 	var mv float64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeInt64()
 		d.mapElemValue()
@@ -8938,7 +8938,7 @@ func (fastpathT) DecMapInt64BoolL(v map[int64]bool, containerLen int, d *Decoder
 	var mk int64
 	var mv bool
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeInt64()
 		d.mapElemValue()

codec/fast-path.go.tmpl

@@ -367,7 +367,7 @@ func (fastpathT) {{ .MethodNamePfx "Dec" false }}Y(v []{{ .Elem }}, d *Decoder)
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		if j == 0 && len(v) == 0 {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, {{ .Size }})
@@ -411,7 +411,7 @@ func (fastpathT) {{ .MethodNamePfx "Dec" false }}N(v []{{ .Elem }}, d *Decoder)
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
 		{{/* // if indefinite, etc, then expand the slice if necessary */ -}}
 		if j >= len(v) {
 			fastpathDecArrayCannotExpand(slh, hasLen, len(v), j, containerLenS)
@@ -439,7 +439,7 @@ func fastpathDecArrayCannotExpand(slh decSliceHelper, hasLen bool, lenv, j, cont
 	slh.ElemContainerState(j)
 	slh.d.swallow()
 	j++
-	for ; (hasLen && j < containerLenS) || !(hasLen || slh.d.d.CheckBreak()); j++ {
+	for ; (hasLen && j < containerLenS) || !(hasLen || slh.d.checkBreak()); j++ {
 		slh.ElemContainerState(j)
 		slh.d.swallow()
 	}
@@ -517,7 +517,7 @@ func (fastpathT) {{ .MethodNamePfx "Dec" false }}L(v map[{{ .MapKey }}]{{ .Elem
     var mk {{ .MapKey }}
 	var mv {{ .Elem }}
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.d.CheckBreak()); j++ {
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
 		d.mapElemKey()
 		{{ if eq .MapKey "interface{}" }}mk = nil 
 		d.decode(&mk)

codec/gen-dec-array.go.tmpl

@@ -43,7 +43,7 @@ if {{var "l"}} == 0 {
     {{end -}}
 	var {{var "j"}} int 
     {{/* // var {{var "dn"}} bool */ -}}
-	for {{var "j"}} = 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || r.CheckBreak()); {{var "j"}}++ { // bounds-check-elimination
+	for {{var "j"}} = 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || z.DecCheckBreak()); {{var "j"}}++ { // bounds-check-elimination
 		{{if not isArray}} if {{var "j"}} == 0 && {{var "v"}} == nil {
 			if {{var "hl"}} {
 				{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})

codec/gen-dec-map.go.tmpl

@@ -18,7 +18,7 @@ if z.DecBasicHandle().MapValueReset {
 	{{end}} }
 if {{var "l"}} != 0 {
 	{{var "hl"}} := {{var "l"}} > 0 
-	for {{var "j"}} := 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || r.CheckBreak()); {{var "j"}}++ {
+	for {{var "j"}} := 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || z.DecCheckBreak()); {{var "j"}}++ {
 	z.DecReadMapElemKey() {{/* z.DecSendContainerState(codecSelfer_containerMapKey{{ .Sfx }}) */}}
 	{{ $x := printf "%vmk%v" .TempVar .Rand }}{{ decLineVarK $x -}}
 	{{ if eq .KTyp "interface{}" }}{{/* // special case if a byte array. */ -}}

codec/gen-helper.generated.go

@@ -268,3 +268,6 @@ func (f genHelperDecoder) DecReadMapElemValue() { f.d.mapElemValue() }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecDecodeFloat32() float32 { return f.d.decodeFloat32() }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecCheckBreak() bool { return f.d.checkBreak() }

codec/gen-helper.go.tmpl

@@ -248,4 +248,6 @@ func (f genHelperDecoder) DecReadMapElemValue() { f.d.mapElemValue() }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecDecodeFloat32() float32 { return f.d.decodeFloat32() }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecCheckBreak() bool { return f.d.checkBreak() }
 

codec/gen.generated.go

@@ -28,7 +28,7 @@ if z.DecBasicHandle().MapValueReset {
 	{{end}} }
 if {{var "l"}} != 0 {
 	{{var "hl"}} := {{var "l"}} > 0 
-	for {{var "j"}} := 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || r.CheckBreak()); {{var "j"}}++ {
+	for {{var "j"}} := 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || z.DecCheckBreak()); {{var "j"}}++ {
 	z.DecReadMapElemKey() {{/* z.DecSendContainerState(codecSelfer_containerMapKey{{ .Sfx }}) */}}
 	{{ $x := printf "%vmk%v" .TempVar .Rand }}{{ decLineVarK $x -}}
 	{{ if eq .KTyp "interface{}" }}{{/* // special case if a byte array. */ -}}
@@ -109,7 +109,7 @@ if {{var "l"}} == 0 {
     {{end -}}
 	var {{var "j"}} int 
     {{/* // var {{var "dn"}} bool */ -}}
-	for {{var "j"}} = 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || r.CheckBreak()); {{var "j"}}++ { // bounds-check-elimination
+	for {{var "j"}} = 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || z.DecCheckBreak()); {{var "j"}}++ { // bounds-check-elimination
 		{{if not isArray}} if {{var "j"}} == 0 && {{var "v"}} == nil {
 			if {{var "hl"}} {
 				{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})

codec/gen.go

@@ -1752,12 +1752,12 @@ func (x *genRunner) decStructMap(varname, lenvarname string, rtid uintptr, t ref
 	case genStructMapStyleLenPrefix:
 		x.linef("for %sj%s := 0; %sj%s < %s; %sj%s++ {", tpfx, i, tpfx, i, lenvarname, tpfx, i)
 	case genStructMapStyleCheckBreak:
-		x.linef("for %sj%s := 0; !r.CheckBreak(); %sj%s++ {", tpfx, i, tpfx, i)
+		x.linef("for %sj%s := 0; !z.DecCheckBreak(); %sj%s++ {", tpfx, i, tpfx, i)
 	default: // 0, otherwise.
 		x.linef("var %shl%s bool = %s >= 0", tpfx, i, lenvarname) // has length
 		x.linef("for %sj%s := 0; ; %sj%s++ {", tpfx, i, tpfx, i)
 		x.linef("if %shl%s { if %sj%s >= %s { break }", tpfx, i, tpfx, i, lenvarname)
-		x.line("} else { if r.CheckBreak() { break }; }")
+		x.line("} else { if z.DecCheckBreak() { break }; }")
 	}
 	x.line("z.DecReadMapElemKey()")
 
@@ -1791,7 +1791,7 @@ func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid
 	x.linef("var %shl%s bool = %s >= 0", tpfx, i, lenvarname) // has length
 	if !genDecStructArrayInlineLoopCheck {
 		x.linef("var %sfn%s = func() bool { ", tpfx, i)
-		x.linef("%sj%s++; if %shl%s { %sb%s = %sj%s > %s } else { %sb%s = r.CheckBreak() };",
+		x.linef("%sj%s++; if %shl%s { %sb%s = %sj%s > %s } else { %sb%s = z.DecCheckBreak() };",
 			tpfx, i, tpfx, i, tpfx, i,
 			tpfx, i, lenvarname, tpfx, i)
 		x.linef("if %sb%s { z.DecReadArrayEnd(); return true }; return false", tpfx, i)
@@ -1800,7 +1800,7 @@ func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid
 	var newbuf, nilbuf genBuf
 	for _, si := range tisfi {
 		if genDecStructArrayInlineLoopCheck {
-			x.linef("%sj%s++; if %shl%s { %sb%s = %sj%s > %s } else { %sb%s = r.CheckBreak() }",
+			x.linef("%sj%s++; if %shl%s { %sb%s = %sj%s > %s } else { %sb%s = z.DecCheckBreak() }",
 				tpfx, i, tpfx, i, tpfx, i,
 				tpfx, i, lenvarname, tpfx, i)
 			x.linef("if %sb%s { z.DecReadArrayEnd(); %s }", tpfx, i, breakString)
@@ -1821,7 +1821,7 @@ func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid
 	}
 	// read remaining values and throw away.
 	x.line("for {")
-	x.linef("%sj%s++; if %shl%s { %sb%s = %sj%s > %s } else { %sb%s = r.CheckBreak() }",
+	x.linef("%sj%s++; if %shl%s { %sb%s = %sj%s > %s } else { %sb%s = z.DecCheckBreak() }",
 		tpfx, i, tpfx, i, tpfx, i,
 		tpfx, i, lenvarname, tpfx, i)
 	x.linef("if %sb%s { break }", tpfx, i)

codec/helper.go

@@ -166,17 +166,17 @@ const (
 	// so structFieldInfo fits into 8 bytes
 	maxLevelsEmbedding = 14
 
-	// useFinalizers=true configures finalizers to release pool'ed resources
-	// acquired by Encoder/Decoder during their GC.
-	//
-	// Note that calling SetFinalizer is always expensive,
-	// as code must be run on the systemstack even for SetFinalizer(t, nil).
-	//
-	// We document that folks SHOULD call Release() when done, or they can
-	// explicitly call SetFinalizer themselves e.g.
-	//    runtime.SetFinalizer(e, (*Encoder).Release)
-	//    runtime.SetFinalizer(d, (*Decoder).Release)
-	useFinalizers = false
+	// // useFinalizers=true configures finalizers to release pool'ed resources
+	// // acquired by Encoder/Decoder during their GC.
+	// //
+	// // Note that calling SetFinalizer is always expensive,
+	// // as code must be run on the systemstack even for SetFinalizer(t, nil).
+	// //
+	// // We document that folks SHOULD call Release() when done, or they can
+	// // explicitly call SetFinalizer themselves e.g.
+	// //    runtime.SetFinalizer(e, (*Encoder).Release)
+	// //    runtime.SetFinalizer(d, (*Decoder).Release)
+	// useFinalizers = false
 
 	// // usePool controls whether we use sync.Pool or not.
 	// //
@@ -2248,8 +2248,8 @@ func panicToErr(h errDecorator, err *error) {
 }
 
 func isSliceBoundsError(s string) bool {
-	return strings.Index(s, "index out of range") != -1 ||
-		strings.Index(s, "slice bounds out of range") != -1
+	return strings.Contains(s, "index out of range") ||
+		strings.Contains(s, "slice bounds out of range")
 }
 
 func panicValToErr(h errDecorator, v interface{}, err *error) {

codec/helper_not_unsafe.go

@@ -421,3 +421,19 @@ func mapDelete(m, k reflect.Value) {
 func mapAddressableRV(t reflect.Type, k reflect.Kind) (r reflect.Value) {
 	return // reflect.New(t).Elem()
 }
+
+// ---------- ENCODER optimized ---------------
+
+func (e *Encoder) jsondriver() *jsonEncDriver {
+	return e.e.(*jsonEncDriver)
+}
+
+// ---------- DECODER optimized ---------------
+
+func (d *Decoder) checkBreak() bool {
+	return d.d.CheckBreak()
+}
+
+func (d *Decoder) jsondriver() *jsonDecDriver {
+	return d.d.(*jsonDecDriver)
+}

codec/helper_unsafe.go

@@ -816,8 +816,6 @@ func mapRange(t *mapIter, m, k, v reflect.Value, mapvalues bool) {
 		t.vtyp = nil
 		t.vptr = nil
 	}
-
-	return
 }
 
 func mapGet(m, k, v reflect.Value) (vv reflect.Value) {
@@ -847,12 +845,12 @@ func mapSet(m, k, v reflect.Value) {
 	mapassign(urv.typ, rv2ptr(urv), kptr, vptr)
 }
 
-func mapDelete(m, k reflect.Value) {
-	var urv = (*unsafeReflectValue)(unsafe.Pointer(&k))
-	var kptr = unsafeMapKVPtr(urv)
-	urv = (*unsafeReflectValue)(unsafe.Pointer(&m))
-	mapdelete(urv.typ, rv2ptr(urv), kptr)
-}
+// func mapDelete(m, k reflect.Value) {
+// 	var urv = (*unsafeReflectValue)(unsafe.Pointer(&k))
+// 	var kptr = unsafeMapKVPtr(urv)
+// 	urv = (*unsafeReflectValue)(unsafe.Pointer(&m))
+// 	mapdelete(urv.typ, rv2ptr(urv), kptr)
+// }
 
 // return an addressable reflect value that can be used in mapRange and mapGet operations.
 //
@@ -893,3 +891,35 @@ func unsafe_New(typ unsafe.Pointer) unsafe.Pointer
 //go:linkname typedslicecopy reflect.typedslicecopy
 //go:noescape
 func typedslicecopy(elemType unsafe.Pointer, dst, src unsafeSlice) int
+
+// ---------- ENCODER optimized ---------------
+
+func (e *Encoder) jsondriver() *jsonEncDriver {
+	return (*jsonEncDriver)((*unsafeIntf)(unsafe.Pointer(&e.e)).word)
+}
+
+// ---------- DECODER optimized ---------------
+
+func (d *Decoder) checkBreak() bool {
+	// jsonDecDriver.CheckBreak() CANNOT be inlined.
+	// Consequently, there's no benefit in incurring the cost of this
+	// wrapping function checkBreak.
+	//
+	// It is faster to just call the interface method directly.
+
+	// if d.js {
+	// 	return d.jsondriver().CheckBreak()
+	// }
+	// if d.cbor {
+	// 	return d.cbordriver().CheckBreak()
+	// }
+	return d.d.CheckBreak()
+}
+
+func (d *Decoder) jsondriver() *jsonDecDriver {
+	return (*jsonDecDriver)((*unsafeIntf)(unsafe.Pointer(&d.d)).word)
+}
+
+// func (d *Decoder) cbordriver() *cborDecDriver {
+// 	return (*cborDecDriver)((*unsafeIntf)(unsafe.Pointer(&d.d)).word)
+// }

codec/json.go

@@ -50,8 +50,8 @@ const (
 )
 
 var (
-	jsonLiteralTrueQ  = jsonLiterals[jsonLitTrueQ : jsonLitTrueQ+6]
-	jsonLiteralFalseQ = jsonLiterals[jsonLitFalseQ : jsonLitFalseQ+7]
+	// jsonLiteralTrueQ  = jsonLiterals[jsonLitTrueQ : jsonLitTrueQ+6]
+	// jsonLiteralFalseQ = jsonLiterals[jsonLitFalseQ : jsonLitFalseQ+7]
 	// jsonLiteralNullQ  = jsonLiterals[jsonLitNullQ : jsonLitNullQ+6]
 
 	jsonLiteralTrue  = jsonLiterals[jsonLitTrue : jsonLitTrue+4]
@@ -368,9 +368,9 @@ func (e *jsonEncDriver) EncodeStringBytesRaw(v []byte) {
 	}
 }
 
-func (e *jsonEncDriver) EncodeAsis(v []byte) {
-	e.e.encWr.writeb(v)
-}
+// func (e *jsonEncDriver) EncodeAsis(v []byte) {
+// 	e.e.encWr.writeb(v)
+// }
 
 // indent is done as below:
 //   - newline and indent are added before each mapKey or arrayElem
@@ -732,7 +732,7 @@ func (d *jsonDecDriver) ReadMapEnd() {
 func (d *jsonDecDriver) readLit4True() {
 	bs := d.d.decRd.readn(3)
 	d.tok = 0
-	if jsonValidateSymbols && bs != [rwNLen]byte{'r', 'u', 'e'} { // !bytes.Equal(bs, jsonLiteral4True)
+	if jsonValidateSymbols && bs != [rwNLen]byte{'r', 'u', 'e'} { // !Equal jsonLiteral4True
 		d.d.errorf("expecting %s: got %s", jsonLiteral4True, bs)
 	}
 }
@@ -740,7 +740,7 @@ func (d *jsonDecDriver) readLit4True() {
 func (d *jsonDecDriver) readLit4False() {
 	bs := d.d.decRd.readn(4)
 	d.tok = 0
-	if jsonValidateSymbols && bs != [rwNLen]byte{'a', 'l', 's', 'e'} { // !bytes.Equal(bs, jsonLiteral4False)
+	if jsonValidateSymbols && bs != [rwNLen]byte{'a', 'l', 's', 'e'} { // !Equal jsonLiteral4False
 		d.d.errorf("expecting %s: got %s", jsonLiteral4False, bs)
 	}
 }
@@ -748,7 +748,7 @@ func (d *jsonDecDriver) readLit4False() {
 func (d *jsonDecDriver) readLit4Null() {
 	bs := d.d.decRd.readn(3) // readx(3)
 	d.tok = 0
-	if jsonValidateSymbols && bs != [rwNLen]byte{'u', 'l', 'l'} { // !bytes.Equal(bs, jsonLiteral4Null)
+	if jsonValidateSymbols && bs != [rwNLen]byte{'u', 'l', 'l'} { // !Equal jsonLiteral4Null
 		d.d.errorf("expecting %s: got %s", jsonLiteral4Null, bs)
 	}
 	d.fnil = true
@@ -1506,7 +1506,7 @@ func (h *JsonHandle) typical() bool {
 func (h *JsonHandle) newEncDriver() encDriver {
 	var e = &jsonEncDriver{h: h}
 	e.e.e = e
-	e.e.jenc = e
+	// e.e.jenc = e
 	e.e.js = true
 	e.e.init(h)
 	e.reset()
@@ -1516,7 +1516,7 @@ func (h *JsonHandle) newEncDriver() encDriver {
 func (h *JsonHandle) newDecDriver() decDriver {
 	var d = &jsonDecDriver{h: h}
 	d.d.d = d
-	d.d.jdec = d
+	// d.d.jdec = d
 	d.d.js = true
 	d.d.jsms = h.MapKeyAsString
 	d.d.init(h)

codec/reader.go

@@ -1058,6 +1058,7 @@ type decRd struct {
 	be   bool // is binary encoding
 	js   bool // is json handle
 	jsms bool // is json handle, and MapKeyAsString
+	cbor bool // is cbor handle
 
 	// typ   entryType
 	bytes bool // is bytes reader

codec/writer.go

@@ -344,9 +344,9 @@ func (z *bytesEncAppender) reset(in []byte, out *[]byte) {
 type encWr struct {
 	// esep  bool // whether it has elem separators
 	bytes bool // encoding to []byte
-	isas  bool // whether e.as != nil
-	js    bool // is json encoder?
-	be    bool // is binary encoder?
+	// isas  bool // whether e.as != nil
+	js bool // is json encoder?
+	be bool // is binary encoder?
 
 	c containerState