decoder_cursor.tmpl

// Code generated by internal/cmd/codegen decoder-cursor; DO NOT EDIT.
//go:build {{.BuildTag}}

package vibejson

import (
	"math/bits"
	"reflect"
	"strconv"

	"github.com/thesyncim/vibejson/x/byteview"
)

{{if .Go127 -}}
// Bool decodes directly into any defined boolean type.
func (c *decoderCursor) Bool[T boolValue](dst *T) error {
{{else -}}
// Stable compilers do not support generic methods. Compiled plans pass
// pointers to built-in scalar types, so the concrete entry points below keep
// their ordinary routes direct; numeric entry points use a bounded type switch
// and share generic free-function cores. Defined numeric types are uncommon
// and use the reflection fallback at the bottom of this file.

func (c *decoderCursor) Bool(dst *bool) error {
{{end}}
	i := c.i
	if i < len(c.src) {
		switch c.src[i] {
		case 't':
			if literalTrueAt(c.src, i) {
				*dst = true
				c.i = i + 4
				return nil
			}
		case 'f':
			if literalFalseTailAt(c.src, i) {
				*dst = false
				c.i = i + 5
				return nil
			}
		}
	}
	return c.boolSlow(dst)
}

//go:noinline
{{if .Go127 -}}
func (c *decoderCursor) boolSlow[T boolValue](dst *T) error {
{{else -}}
func (c *decoderCursor) boolSlow(dst *bool) error {
{{end}}
	i := c.i
	if i >= len(c.src) {
		{{if .Go127 -}}
		return c.genericExpected[T]("boolean")
		{{else -}}
		return decoderCursorExpected[bool](c, "boolean")
		{{end}}
	}
	if c.src[i] == 'n' {
		if !literalNullAt(c.src, i) {
			return c.err(i, "invalid literal")
		}
		if c.flags&decoderReplace != 0 {
			*dst = false
		}
		c.i = i + 4
		return nil
	}
	switch c.src[i] {
	case 't':
		if !literalTrueAt(c.src, i) {
			return c.err(i, "invalid literal")
		}
		*dst = true
		c.i = i + 4
		return nil
	case 'f':
		if !literalFalseTailAt(c.src, i) {
			return c.err(i, "invalid literal")
		}
		*dst = false
		c.i = i + 5
		return nil
	default:
		{{if .Go127 -}}
		return c.genericExpected[T]("boolean")
		{{else -}}
		return decoderCursorExpected[bool](c, "boolean")
		{{end}}
	}
}

{{if .Go127 -}}
// String decodes directly into any defined string type.
func (c *decoderCursor) String[T stringValue](dst *T) error {
{{else -}}
func (c *decoderCursor) String(dst *string) error {
{{end}}
	i := c.i
	if i < len(c.src) && c.src[i] == '"' {
		start := i + 1
		end, short := scanStringSpecialShort(c.src, start)
		if !short {
			end = scanStringSpecial(c.src, start)
		}
		if end < len(c.src) && c.src[end] == '"' {
			{{if .Go127 -}}
			if !c.reuseOwnedString(string(*dst), start, end) {
				*dst = T(c.ownedString(start, end))
			}
			{{else -}}
			if !c.reuseOwnedString(*dst, start, end) {
				*dst = c.ownedString(start, end)
			}
			{{end}}
			c.i = end + 1
			return nil
		}
	}
	return c.stringSlow(dst)
}

//go:noinline
{{if .Go127 -}}
func (c *decoderCursor) stringSlow[T stringValue](dst *T) error {
{{else -}}
func (c *decoderCursor) stringSlow(dst *string) error {
{{end}}
	if c.i < len(c.src) && c.src[c.i] == 'n' {
		if !literalNullAt(c.src, c.i) {
			return c.err(c.i, "invalid literal")
		}
		if c.flags&decoderReplace != 0 {
			*dst = ""
		}
		c.i += 4
		return nil
	}
	if c.i >= len(c.src) || c.src[c.i] != '"' {
		{{if .Go127 -}}
		return c.genericExpected[T]("string")
		{{else -}}
		return decoderCursorExpected[string](c, "string")
		{{end}}
	}
	start := c.i + 1
	end, short := scanStringSpecialShort(c.src, start)
	if !short {
		end = scanStringSpecial(c.src, start)
	}
	if end < len(c.src) && c.src[end] == '"' {
		{{if .Go127 -}}
		if !c.reuseOwnedString(string(*dst), start, end) {
			text := c.ownedString(start, end)
			*dst = T(text)
		}
		{{else -}}
		if !c.reuseOwnedString(*dst, start, end) {
			*dst = c.ownedString(start, end)
		}
		{{end}}
		c.i = end + 1
		return nil
	}
	if c.flags&decoderZeroCopy != 0 {
		// Reaching this branch means the clean ASCII scan stopped at a high
		// byte, an escape, or invalid syntax. The validator can retain a valid
		// unescaped Unicode span directly instead of reserving an owned arena
		// that zero-copy decoding will never use.
		if next, escaped, ok := scanJSONStringFastFrom(c.src, sliceBase(c.src), end); ok && !escaped {
			text := byteview.String(c.src[start : next-1])
			{{if .Go127 -}}
			*dst = T(text)
			{{else -}}
			*dst = text
			{{end}}
			c.i = next
			return nil
		}
	}
	end, decodedCapacity := rawJSONStringLayoutHint(c.src, c.i+1)
	text, err := c.parseOwnedString(end, decodedCapacity)
	if err != nil {
		return err
	}
	{{if .Go127 -}}
	*dst = T(text)
	{{else -}}
	*dst = text
	{{end}}
	return nil
}

{{if .Go127 -}}
// Number decodes a JSON number's original spelling into a defined string type.
func (c *decoderCursor) Number[T stringValue](dst *T) error {
{{else -}}
func (c *decoderCursor) Number(dst *string) error {
{{end}}
	if c.i < len(c.src) && c.src[c.i] == 'n' {
		if !literalNullAt(c.src, c.i) {
			return c.err(c.i, "invalid literal")
		}
		if c.flags&decoderReplace != 0 {
			*dst = ""
		}
		c.i += 4
		return nil
	}
	if c.i < len(c.src) && c.src[c.i] == '"' {
		{{if .Go127 -}}
		// encoding/json also accepts a JSON string whose unquoted contents
		// spell a valid JSON number; the string decode supplies the
		// ownership rules for the retained spelling.
		{{end}}
		var content string
		if err := c.String(&content); err != nil {
			return err
		}
		if !validNumber(byteview.Bytes(content)) {
			{{if .Go127 -}}
			return c.genericError[T](c.i, "string is not a valid number spelling")
			{{else -}}
			return decoderCursorError[string](c.i, "string is not a valid number spelling")
			{{end}}
		}
		{{if .Go127 -}}
		*dst = T(content)
		{{else -}}
		*dst = content
		{{end}}
		return nil
	}
	{{if .Go127 -}}
	start, end, err := c.numberToken[T]()
	{{else -}}
	start, end, err := c.numberToken()
	{{end}}
	if err != nil {
		return err
	}
	{{if .Go127 -}}
	text := c.ownedString(start, end)
	*dst = T(text)
	{{else -}}
	*dst = c.ownedString(start, end)
	{{end}}
	c.i = end
	return nil
}

{{if not .Go127 -}}
func (c *decoderCursor) Int(dst any) error {
	switch dst := dst.(type) {
	case *int:
		return decoderCursorInt(c, dst)
	case *int8:
		return decoderCursorInt(c, dst)
	case *int16:
		return decoderCursorInt(c, dst)
	case *int32:
		return decoderCursorInt(c, dst)
	case *int64:
		return decoderCursorInt(c, dst)
	default:
		return c.definedInt(dst)
	}
}

func (c *decoderCursor) Uint(dst any) error {
	switch dst := dst.(type) {
	case *uint:
		return decoderCursorUint(c, dst)
	case *uint8:
		return decoderCursorUint(c, dst)
	case *uint16:
		return decoderCursorUint(c, dst)
	case *uint32:
		return decoderCursorUint(c, dst)
	case *uint64:
		return decoderCursorUint(c, dst)
	case *uintptr:
		return decoderCursorUint(c, dst)
	default:
		return c.definedUint(dst)
	}
}

func (c *decoderCursor) Float(dst any) error {
	switch dst := dst.(type) {
	case *float32:
		return decoderCursorFloat(c, dst)
	case *float64:
		return decoderCursorFloat(c, dst)
	default:
		return c.definedFloat(dst)
	}
}

func (c *decoderCursor) numberToken() (start, end int, err error) {
	if c.i >= len(c.src) || (c.src[c.i] != '-' && !IsDigit(c.src[c.i])) {
		return c.i, c.i, decoderCursorExpected[string](c, "number")
	}
	start = c.i
	source := numberSourceOf(c.src)
	end, ok := scanNumberFast(source.PointerAt(0), len(c.src), start)
	if !ok {
		_, msg := scanNumber(c.src, start)
		return start, end, c.err(start, msg)
	}
	return start, end, nil
}

func decoderCursorExpected[T any](c *decoderCursor, jsonType string) error {
	return decoderCursorError[T](c.i, "expected "+jsonType)
}

func decoderCursorError[T any](offset int, reason string) error {
	return &DecodeError{Offset: offset, Type: reflect.TypeFor[T](), Reason: reason}
}

func retagDefinedCursorError(err error, typ reflect.Type) error {
	if decodeErr, ok := err.(*DecodeError); ok {
		decodeErr.Type = typ
	}
	return err
}

func (c *decoderCursor) definedInt(dst any) error {
	v := reflect.ValueOf(dst)
	if v.Kind() != reflect.Pointer || v.IsNil() {
		panic("vibejson: decoderCursor.Int destination is not a non-nil pointer")
	}
	elem := v.Elem()
	var err error
	switch elem.Kind() {
	case reflect.Int:
		var value int
		err = decoderCursorInt(c, &value)
		elem.SetInt(int64(value))
	case reflect.Int8:
		var value int8
		err = decoderCursorInt(c, &value)
		elem.SetInt(int64(value))
	case reflect.Int16:
		var value int16
		err = decoderCursorInt(c, &value)
		elem.SetInt(int64(value))
	case reflect.Int32:
		var value int32
		err = decoderCursorInt(c, &value)
		elem.SetInt(int64(value))
	case reflect.Int64:
		var value int64
		err = decoderCursorInt(c, &value)
		elem.SetInt(value)
	default:
		panic("vibejson: decoderCursor.Int destination has non-integer element")
	}
	return retagDefinedCursorError(err, elem.Type())
}

func (c *decoderCursor) definedUint(dst any) error {
	v := reflect.ValueOf(dst)
	if v.Kind() != reflect.Pointer || v.IsNil() {
		panic("vibejson: decoderCursor.Uint destination is not a non-nil pointer")
	}
	elem := v.Elem()
	var err error
	switch elem.Kind() {
	case reflect.Uint:
		var value uint
		err = decoderCursorUint(c, &value)
		elem.SetUint(uint64(value))
	case reflect.Uint8:
		var value uint8
		err = decoderCursorUint(c, &value)
		elem.SetUint(uint64(value))
	case reflect.Uint16:
		var value uint16
		err = decoderCursorUint(c, &value)
		elem.SetUint(uint64(value))
	case reflect.Uint32:
		var value uint32
		err = decoderCursorUint(c, &value)
		elem.SetUint(uint64(value))
	case reflect.Uint64:
		var value uint64
		err = decoderCursorUint(c, &value)
		elem.SetUint(value)
	case reflect.Uintptr:
		var value uintptr
		err = decoderCursorUint(c, &value)
		elem.SetUint(uint64(value))
	default:
		panic("vibejson: decoderCursor.Uint destination has non-unsigned element")
	}
	return retagDefinedCursorError(err, elem.Type())
}

func (c *decoderCursor) definedFloat(dst any) error {
	v := reflect.ValueOf(dst)
	if v.Kind() != reflect.Pointer || v.IsNil() {
		panic("vibejson: decoderCursor.Float destination is not a non-nil pointer")
	}
	elem := v.Elem()
	var err error
	switch elem.Kind() {
	case reflect.Float32:
		var value float32
		err = decoderCursorFloat(c, &value)
		elem.SetFloat(float64(value))
	case reflect.Float64:
		var value float64
		err = decoderCursorFloat(c, &value)
		elem.SetFloat(value)
	default:
		panic("vibejson: decoderCursor.Float destination has non-float element")
	}
	return retagDefinedCursorError(err, elem.Type())
}

{{end}}
{{if .Go127 -}}
// Int decodes directly into any defined signed integer type.
func (c *decoderCursor) Int[T signedInteger](dst *T) error {
{{else -}}
func decoderCursorInt[T signedInteger](c *decoderCursor, dst *T) error {
{{end}}
	n := len(c.src)
	if c.i < n && c.src[c.i] == 'n' {
		if !literalNullAt(c.src, c.i) {
			return c.err(c.i, "invalid literal")
		}
		if c.flags&decoderReplace != 0 {
			*dst = 0
		}
		c.i += 4
		return nil
	}
	start := c.i
	if start >= n {
		{{if .Go127 -}}
		return c.genericExpected[T]("number")
		{{else -}}
		return decoderCursorExpected[T](c, "number")
		{{end}}
	}
	source := numberSourceOf(c.src)
	i := start
	negative := false
	if source.byteAt(i) == '-' {
		negative = true
		i++
		if i == n {
			return c.err(start, "invalid number")
		}
	}
	if !IsDigit(source.byteAt(i)) {
		{{if .Go127 -}}
		return c.genericExpected[T]("number")
		{{else -}}
		return decoderCursorExpected[T](c, "number")
		{{end}}
	}
	width := numericBitSize[T]()
	limit := uint64(1) << (width - 1)
	if !negative {
		limit--
	}
	cutoff, cutlim := limit/10, limit%10
	value := uint64(0)
	if source.byteAt(i) == '0' {
		i++
		if i < n && IsDigit(source.byteAt(i)) {
			return c.err(start, "invalid leading zero in number")
		}
	} else {
		if i+8 <= n {
			word := loadUint64LE(source.PointerAt(i))
			if invalid := nonDigitMask8(word); invalid != 0 {
				{{if .Go127 -}}
				// One to seven digits ending at a proven non-digit: shift
				// the digits to the top of the word, backfill ASCII zeros,
				// and parse all of them at once. Values this short cannot
				// overflow destinations wider than sixteen bits, so the
				// range check folds away for them.
				{{end}}
				k := bits.TrailingZeros64(invalid) / 8
				s := uint(8-k) * 8
				value = parse8DigitsWord(word<<s | digitLower>>(64-s))
				i += k
				if width <= 16 && value > limit {
					{{if .Go127 -}}
					return c.genericError[T](start, "integer overflow")
					{{else -}}
					return decoderCursorError[T](start, "integer overflow")
					{{end}}
				}
			} else if i+16 <= n && all16Digits(source.PointerAt(i)) {
				value = parse16Digits(source.PointerAt(i))
				i += 16
				if value > limit {
					{{if .Go127 -}}
					return c.genericError[T](start, "integer overflow")
					{{else -}}
					return decoderCursorError[T](start, "integer overflow")
					{{end}}
				}
			} else {
				value = parse8DigitsWord(word)
				i += 8
				if width <= 16 && value > limit {
					{{if .Go127 -}}
					return c.genericError[T](start, "integer overflow")
					{{else -}}
					return decoderCursorError[T](start, "integer overflow")
					{{end}}
				}
			}
		}
		for i < n && IsDigit(source.byteAt(i)) {
			digit := uint64(source.byteAt(i) - '0')
			if value > cutoff || value == cutoff && digit > cutlim {
				{{if .Go127 -}}
				return c.genericError[T](start, "integer overflow")
				{{else -}}
				return decoderCursorError[T](start, "integer overflow")
				{{end}}
			}
			value = value*10 + digit
			i++
		}
	}
	if i < n && (source.byteAt(i) == '.' || source.byteAt(i) == 'e' || source.byteAt(i) == 'E') {
		if _, ok := scanNumberFast(source.PointerAt(0), len(c.src), start); !ok {
			_, message := scanNumber(c.src, start)
			return c.err(start, message)
		}
		{{if .Go127 -}}
		return c.genericError[T](start, "fractional number cannot be stored in an integer")
		{{else -}}
		return decoderCursorError[T](start, "fractional number cannot be stored in an integer")
		{{end}}
	}
	if negative {
		*dst = T(-int64(value))
	} else {
		*dst = T(value)
	}
	c.i = i
	return nil
}

{{if .Go127 -}}
// Uint decodes directly into any defined unsigned integer type.
func (c *decoderCursor) Uint[T unsignedInteger](dst *T) error {
{{else -}}
func decoderCursorUint[T unsignedInteger](c *decoderCursor, dst *T) error {
{{end}}
	n := len(c.src)
	if c.i < n && c.src[c.i] == 'n' {
		if !literalNullAt(c.src, c.i) {
			return c.err(c.i, "invalid literal")
		}
		if c.flags&decoderReplace != 0 {
			*dst = 0
		}
		c.i += 4
		return nil
	}
	start := c.i
	if start >= n {
		{{if .Go127 -}}
		return c.genericExpected[T]("number")
		{{else -}}
		return decoderCursorExpected[T](c, "number")
		{{end}}
	}
	source := numberSourceOf(c.src)
	if !IsDigit(source.byteAt(start)) {
		{{if .Go127 -}}
		return c.genericExpected[T]("number")
		{{else -}}
		return decoderCursorExpected[T](c, "number")
		{{end}}
	}
	width := numericBitSize[T]()
	limit := ^uint64(0)
	if width < 64 {
		limit = uint64(1)<<width - 1
	}
	cutoff, cutlim := limit/10, limit%10
	i := start
	value := uint64(0)
	if source.byteAt(i) == '0' {
		i++
		if i < n && IsDigit(source.byteAt(i)) {
			return c.err(start, "invalid leading zero in number")
		}
	} else {
		if i+8 <= n {
			word := loadUint64LE(source.PointerAt(i))
			if invalid := nonDigitMask8(word); invalid != 0 {
				{{if .Go127 -}}
				// See Int: parse a short digit run in one step.
				{{end}}
				k := bits.TrailingZeros64(invalid) / 8
				s := uint(8-k) * 8
				value = parse8DigitsWord(word<<s | digitLower>>(64-s))
				i += k
				if width <= 16 && value > limit {
					{{if .Go127 -}}
					return c.genericError[T](start, "unsigned integer overflow")
					{{else -}}
					return decoderCursorError[T](start, "unsigned integer overflow")
					{{end}}
				}
			} else if i+16 <= n && all16Digits(source.PointerAt(i)) {
				value = parse16Digits(source.PointerAt(i))
				i += 16
				if value > limit {
					{{if .Go127 -}}
					return c.genericError[T](start, "unsigned integer overflow")
					{{else -}}
					return decoderCursorError[T](start, "unsigned integer overflow")
					{{end}}
				}
			} else {
				value = parse8DigitsWord(word)
				i += 8
				if width <= 16 && value > limit {
					{{if .Go127 -}}
					return c.genericError[T](start, "unsigned integer overflow")
					{{else -}}
					return decoderCursorError[T](start, "unsigned integer overflow")
					{{end}}
				}
			}
		}
		for i < n && IsDigit(source.byteAt(i)) {
			digit := uint64(source.byteAt(i) - '0')
			if value > cutoff || value == cutoff && digit > cutlim {
				{{if .Go127 -}}
				return c.genericError[T](start, "unsigned integer overflow")
				{{else -}}
				return decoderCursorError[T](start, "unsigned integer overflow")
				{{end}}
			}
			value = value*10 + digit
			i++
		}
	}
	if i < n && (source.byteAt(i) == '.' || source.byteAt(i) == 'e' || source.byteAt(i) == 'E') {
		if _, ok := scanNumberFast(source.PointerAt(0), len(c.src), start); !ok {
			_, message := scanNumber(c.src, start)
			return c.err(start, message)
		}
		{{if .Go127 -}}
		return c.genericError[T](start, "fractional number cannot be stored in an unsigned integer")
		{{else -}}
		return decoderCursorError[T](start, "fractional number cannot be stored in an unsigned integer")
		{{end}}
	}
	*dst = T(value)
	c.i = i
	return nil
}

{{if .Go127 -}}
// Float decodes directly into any defined float32 or float64 type.
func (c *decoderCursor) Float[T floatValue](dst *T) error {
{{else -}}
func decoderCursorFloat[T floatValue](c *decoderCursor, dst *T) error {
{{end}}
	i := c.i
	if i < len(c.src) && (c.src[i] == '-' || IsDigit(c.src[i])) {
		source := numberSourceOf(c.src)
		if value, end, ok := shortTypedFloatAt(source.PointerAt(0), len(c.src), i); ok {
			*dst = T(value)
			c.i = end
			return nil
		}
	}
	{{if .Go127 -}}
	return c.floatSlow(dst)
	{{else -}}
	return decoderCursorFloatSlow(c, dst)
	{{end}}
}

//go:noinline
{{if .Go127 -}}
func (c *decoderCursor) floatSlow[T floatValue](dst *T) error {
{{else -}}
func decoderCursorFloatSlow[T floatValue](c *decoderCursor, dst *T) error {
{{end}}
	if c.i < len(c.src) && c.src[c.i] == 'n' {
		if !literalNullAt(c.src, c.i) {
			return c.err(c.i, "invalid literal")
		}
		if c.flags&decoderReplace != 0 {
			*dst = 0
		}
		c.i += 4
		return nil
	}
	if c.i >= len(c.src) || (c.src[c.i] != '-' && !IsDigit(c.src[c.i])) {
		{{if .Go127 -}}
		return c.genericExpected[T]("number")
		{{else -}}
		return decoderCursorExpected[T](c, "number")
		{{end}}
	}
	start := c.i
	source := numberSourceOf(c.src)
	{{if .Go127 -}}
	bits := numericBitSize[T]()
	if bits == 64 {
		// scanTypedFloat64Number validates the digits and fast-paths the values
		// that convert with one exact multiply. Its end and ok drive validation
		// and cursor advance exactly as before, and on the inexact path it hands
		// back the mantissa and exponent it already recovered.
	{{else -}}
	width := numericBitSize[T]()
	if width == 64 {
	{{end}}
		end, value, exact, number, haveNumber, ok := scanTypedFloat64Number(source, len(c.src), start)
		if !ok {
			_, message := scanNumber(c.src, start)
			return c.err(start, message)
		}
		if !exact {
			{{if .Go127 -}}
			// Outside the exact-multiply envelope, round with Eisel-Lemire from
			// the mantissa and exponent the scanner already recovered, and
			// reserve the scalar strconv path for the truncated or tie-ambiguous
			// inputs it defers on. Only wide mantissas re-scan for truncation
			// tracking.
			{{end}}
			if !haveNumber {
				_, number, haveNumber = scanJSONNumber(source.PointerAt(0), len(c.src), start)
				haveNumber = haveNumber && !number.truncated
			}
			if haveNumber {
				if v, exactLemire := eiselLemire64(number.mantissa, number.exponent, number.negative); exactLemire {
					*dst = T(v)
					c.i = end
					return nil
				}
			}
			text := source.stringRange(start, end)
			var err error
			value, err = strconv.ParseFloat(text, 64)
			if err != nil {
				{{if .Go127 -}}
				return c.genericError[T](start, "number out of range")
				{{else -}}
				return decoderCursorError[T](start, "number out of range")
				{{end}}
			}
		}
		*dst = T(value)
		c.i = end
		return nil
	}
	end, integer, negative, isInteger, ok := scanAnyNumberFast(source.PointerAt(0), len(c.src), start)
	if !ok {
		_, message := scanNumber(c.src, start)
		return c.err(start, message)
	}
	text := source.stringRange(start, end)
	var value float64
	var err error
	if isInteger && integer <= uint64(1)<<53 {
		value = float64(integer)
		if negative {
			value = -value
		}
	} else {
		value, err = strconv.ParseFloat(text, 32)
	}
	if err != nil {
		{{if .Go127 -}}
		return c.genericError[T](start, "number out of range")
		{{else -}}
		return decoderCursorError[T](start, "number out of range")
		{{end}}
	}
	*dst = T(value)
	c.i = end
	return nil
}
{{if .Go127}}

func (c *decoderCursor) numberToken[T any]() (start, end int, err error) {
	if c.i >= len(c.src) || (c.src[c.i] != '-' && !IsDigit(c.src[c.i])) {
		return c.i, c.i, c.genericExpected[T]("number")
	}
	start = c.i
	source := numberSourceOf(c.src)
	end, ok := scanNumberFast(source.PointerAt(0), len(c.src), start)
	if !ok {
		_, msg := scanNumber(c.src, start)
		return start, end, c.err(start, msg)
	}
	return start, end, nil
}

func (c *decoderCursor) genericExpected[T any](jsonType string) error {
	return c.genericError[T](c.i, "expected "+jsonType)
}

func (c *decoderCursor) genericError[T any](offset int, reason string) error {
	return &DecodeError{Offset: offset, Type: reflect.TypeFor[T](), Reason: reason}
}
{{end}}

const useStableNumericMethods = {{if .Go127}}false{{else}}true{{end}}
{{if .Go127}}

// These entry points only type-check the compile-time-disabled stable branch
// in common code. The linker drops them from Go 1.27 binaries.
func decoderCursorInt[T signedInteger](c *decoderCursor, dst *T) error { return c.Int(dst) }
func decoderCursorUint[T unsignedInteger](c *decoderCursor, dst *T) error {
	return c.Uint(dst)
}
func decoderCursorFloat[T floatValue](c *decoderCursor, dst *T) error { return c.Float(dst) }
{{end}}

func (c *decoderCursor) IntNative(dst *int) error   { return {{if .Go127}}c.Int(dst){{else}}decoderCursorInt(c, dst){{end}} }
func (c *decoderCursor) Int8(dst *int8) error       { return {{if .Go127}}c.Int(dst){{else}}decoderCursorInt(c, dst){{end}} }
func (c *decoderCursor) Int16(dst *int16) error     { return {{if .Go127}}c.Int(dst){{else}}decoderCursorInt(c, dst){{end}} }
func (c *decoderCursor) Int32(dst *int32) error     { return {{if .Go127}}c.Int(dst){{else}}decoderCursorInt(c, dst){{end}} }
func (c *decoderCursor) Int64(dst *int64) error     { return {{if .Go127}}c.Int(dst){{else}}decoderCursorInt(c, dst){{end}} }
func (c *decoderCursor) UintNative(dst *uint) error { return {{if .Go127}}c.Uint(dst){{else}}decoderCursorUint(c, dst){{end}} }
func (c *decoderCursor) Uint8(dst *uint8) error     { return {{if .Go127}}c.Uint(dst){{else}}decoderCursorUint(c, dst){{end}} }
func (c *decoderCursor) Uint16(dst *uint16) error   { return {{if .Go127}}c.Uint(dst){{else}}decoderCursorUint(c, dst){{end}} }
func (c *decoderCursor) Uint32(dst *uint32) error   { return {{if .Go127}}c.Uint(dst){{else}}decoderCursorUint(c, dst){{end}} }
func (c *decoderCursor) Uint64(dst *uint64) error   { return {{if .Go127}}c.Uint(dst){{else}}decoderCursorUint(c, dst){{end}} }
func (c *decoderCursor) Uintptr(dst *uintptr) error { return {{if .Go127}}c.Uint(dst){{else}}decoderCursorUint(c, dst){{end}} }
func (c *decoderCursor) Float32(dst *float32) error { return {{if .Go127}}c.Float(dst){{else}}decoderCursorFloat(c, dst){{end}} }
func (c *decoderCursor) Float64(dst *float64) error { return {{if .Go127}}c.Float(dst){{else}}decoderCursorFloat(c, dst){{end}} }