decode: Cleanup io panic a bit

wader · wader · commit ee2ee24dbbcf · 2024-04-12T17:23:03.000+02:00
diff --git a/format/asn1/asn1_ber.go b/format/asn1/asn1_ber.go
@@ -281,7 +281,7 @@ func decodeASN1BERValue(d *decode.D, bib *bitio.Buffer, sb *strings.Builder, par
 			if bib != nil {
 				// TODO: helper?
 				if _, err := bitio.Copy(bib, br); err != nil {
-					d.IOPanic(err, "bitio.Copy")
+					d.IOPanic(err, "value", "bitio.Copy")
 				}
 			}
 			if unusedBitsCount > 0 {
@@ -292,7 +292,7 @@ func decodeASN1BERValue(d *decode.D, bib *bitio.Buffer, sb *strings.Builder, par
 			if bib != nil {
 				// TODO: helper?
 				if _, err := bitio.Copy(bib, br); err != nil {
-					d.IOPanic(err, "bitio.Copy")
+					d.IOPanic(err, "value", "bitio.Copy")
 				}
 			}
 		case class == classUniversal && tag == universalTypeNull:
diff --git a/format/gzip/gzip.go b/format/gzip/gzip.go
@@ -114,7 +114,7 @@ func gzipDecodeMember(d *decode.D) bitio.ReaderAtSeeker {
 		readCompressedSize, uncompressedBR, err =
 			d.FieldReaderRange("uncompressed", d.Pos(), d.BitsLeft(), rFn)
 		if err != nil {
-			d.IOPanic(err, "TryFieldReaderRange")
+			d.IOPanic(err, "uncompressed", "FieldReaderRange")
 		}
 		d.FieldRawLen("compressed", readCompressedSize)
 		crc32W := crc32.NewIEEE()
@@ -149,7 +149,7 @@ func gzipDecode(d *decode.D) any {
 
 	cbr, err := bitio.NewMultiReader(brs...)
 	if err != nil {
-		d.IOPanic(err, "NewMultiReader")
+		d.IOPanic(err, "members", "NewMultiReader")
 	}
 	dv, _, _ := d.TryFieldFormatBitBuf("uncompressed", cbr, &probeGroup, format.Probe_In{})
 	if dv == nil {
diff --git a/format/id3/id3v2.go b/format/id3/id3v2.go
@@ -302,7 +302,7 @@ func textNullLenFn(encoding int, notFoundFixedBytes int) func(d *decode.D) strin
 			func(v uint64) bool { return v == 0 },
 		)
 		if err != nil {
-			d.IOPanic(err, "textNullLenFn")
+			d.IOPanic(err, "", "textNullLenFn")
 		}
 		if offset < 0 {
 			if notFoundFixedBytes < 0 {
diff --git a/pkg/decode/decode.go b/pkg/decode/decode.go
@@ -263,7 +263,7 @@ func (d *D) TryCopyBits(w io.Writer, r bitio.Reader) (int64, error) {
 func (d *D) CopyBits(w io.Writer, r bitio.Reader) int64 {
 	n, err := d.TryCopyBits(w, r)
 	if err != nil {
-		d.IOPanic(err, "CopyBits: Copy")
+		d.IOPanic(err, "", "CopyBits")
 	}
 	return n
 }
@@ -277,15 +277,15 @@ func (d *D) TryCopy(w io.Writer, r io.Reader) (int64, error) {
 func (d *D) Copy(w io.Writer, r io.Reader) int64 {
 	n, err := d.TryCopy(w, r)
 	if err != nil {
-		d.IOPanic(err, "Copy")
+		d.IOPanic(err, "", "Copy")
 	}
 	return n
 }
 
 func (d *D) CloneReadSeeker(br bitio.ReadSeeker) bitio.ReadSeeker {
 	br, err := bitio.CloneReadSeeker(br)
 	if err != nil {
-		d.IOPanic(err, "CloneReadSeeker")
+		d.IOPanic(err, "", "CloneReadSeeker")
 	}
 	return br
 }
@@ -308,7 +308,7 @@ func (d *D) TryReadAllBits(r bitio.Reader) ([]byte, error) {
 func (d *D) ReadAllBits(r bitio.Reader) []byte {
 	buf, err := d.TryReadAllBits(r)
 	if err != nil {
-		d.IOPanic(err, "Bytes ReadAllBytes")
+		d.IOPanic(err, "", "ReadAllBytes")
 	}
 	return buf
 }
@@ -350,7 +350,7 @@ func (d *D) FillGaps(r ranges.Range, namePrefix string) {
 	for i, gap := range gaps {
 		br, err := bitiox.Range(d.bitBuf, gap.Start, gap.Len)
 		if err != nil {
-			d.IOPanic(err, "FillGaps: Range")
+			d.IOPanic(err, namePrefix, "bitiox.Range")
 		}
 
 		v := &Value{
@@ -380,8 +380,8 @@ func (d *D) Fatalf(format string, a ...any) {
 	panic(DecoderError{Reason: fmt.Sprintf(format, a...), Pos: d.Pos()})
 }
 
-func (d *D) IOPanic(err error, op string) {
-	panic(IOError{Err: err, Pos: d.Pos(), Op: op})
+func (d *D) IOPanic(err error, name string, op string) {
+	panic(IOError{Err: err, Name: name, Pos: d.Pos(), Op: op})
 }
 
 // TryBits reads nBits bits from buffer
@@ -543,7 +543,7 @@ func (d *D) TryPeekFind(nBits int, seekBits int64, maxLen int64, fn func(v uint6
 func (d *D) PeekFind(nBits int, seekBits int64, maxLen int64, fn func(v uint64) bool) (int64, uint64) {
 	peekBits, v, err := d.TryPeekFind(nBits, seekBits, maxLen, fn)
 	if err != nil {
-		d.IOPanic(err, "PeekFind: TryPeekFind")
+		d.IOPanic(err, "", "PeekFind")
 	}
 	if peekBits == -1 {
 		d.Errorf("peek not found")
@@ -771,7 +771,7 @@ func (d *D) TrySeekRel(delta int64, fns ...func(d *D)) (int64, error) {
 func (d *D) SeekRel(delta int64, fns ...func(d *D)) int64 {
 	n, err := d.trySeekAbs(d.Pos()+delta, fns...)
 	if err != nil {
-		d.IOPanic(err, "SeekRel")
+		d.IOPanic(err, "", "SeekRel")
 	}
 	return n
 }
@@ -785,7 +785,7 @@ func (d *D) TrySeekAbs(pos int64, fns ...func(d *D)) (int64, error) {
 func (d *D) SeekAbs(pos int64, fns ...func(d *D)) int64 {
 	n, err := d.trySeekAbs(pos, fns...)
 	if err != nil {
-		d.IOPanic(err, "SeekAbs")
+		d.IOPanic(err, "", "SeekAbs")
 	}
 	return n
 }
@@ -955,7 +955,7 @@ func (d *D) RangeFn(firstBit int64, nBits int64, fn func(d *D)) int64 {
 	// TODO: do some kind of DecodeLimitedLen/RangeFn?
 	br := d.BitBufRange(0, firstBit+nBits)
 	if _, err := br.SeekBits(firstBit, io.SeekStart); err != nil {
-		d.IOPanic(err, "RangeFn: SeekAbs")
+		d.IOPanic(err, "", "RangeFn: SeekAbs")
 	}
 
 	nd := *d
@@ -979,7 +979,7 @@ func (d *D) Format(group *Group, inArg any) any {
 		ReadBuf:     d.readBuf,
 	})
 	if dv == nil || dv.Errors() != nil {
-		d.IOPanic(err, "Format: decode")
+		d.IOPanic(err, "", "Format: decode")
 	}
 
 	switch vv := dv.V.(type) {
@@ -992,7 +992,7 @@ func (d *D) Format(group *Group, inArg any) any {
 	}
 
 	if _, err := d.bitBuf.SeekBits(dv.Range.Len, io.SeekCurrent); err != nil {
-		d.IOPanic(err, "Format: SeekRel")
+		d.IOPanic(err, "", "Format: SeekRel")
 	}
 
 	return v
@@ -1015,7 +1015,7 @@ func (d *D) TryFieldFormat(name string, group *Group, inArg any) (*Value, any, e
 
 	d.AddChild(dv)
 	if _, err := d.bitBuf.SeekBits(dv.Range.Len, io.SeekCurrent); err != nil {
-		d.IOPanic(err, "TryFieldFormat: SeekRel")
+		d.IOPanic(err, name, "TryFieldFormat: SeekRel")
 	}
 
 	return dv, v, err
@@ -1024,7 +1024,7 @@ func (d *D) TryFieldFormat(name string, group *Group, inArg any) (*Value, any, e
 func (d *D) FieldFormat(name string, group *Group, inArg any) (*Value, any) {
 	dv, v, err := d.TryFieldFormat(name, group, inArg)
 	if dv == nil || dv.Errors() != nil {
-		d.IOPanic(err, "FieldFormat: TryFieldFormat")
+		d.IOPanic(err, name, "FieldFormat: TryFieldFormat")
 	}
 	return dv, v
 }
@@ -1054,7 +1054,7 @@ func (d *D) TryFieldFormatLen(name string, nBits int64, group *Group, inArg any)
 
 	d.AddChild(dv)
 	if _, err := d.bitBuf.SeekBits(nBits, io.SeekCurrent); err != nil {
-		d.IOPanic(err, "TryFieldFormatLen: SeekRel")
+		d.IOPanic(err, name, "TryFieldFormatLen: SeekRel")
 	}
 
 	return dv, v, err
@@ -1063,7 +1063,7 @@ func (d *D) TryFieldFormatLen(name string, nBits int64, group *Group, inArg any)
 func (d *D) FieldFormatLen(name string, nBits int64, group *Group, inArg any) (*Value, any) {
 	dv, v, err := d.TryFieldFormatLen(name, nBits, group, inArg)
 	if dv == nil || dv.Errors() != nil {
-		d.IOPanic(err, "FieldFormatLen: TryFieldFormatLen")
+		d.IOPanic(err, name, "FieldFormatLen: TryFieldFormatLen")
 	}
 	return dv, v
 }
@@ -1100,7 +1100,7 @@ func (d *D) TryFieldFormatRange(name string, firstBit int64, nBits int64, group
 func (d *D) FieldFormatRange(name string, firstBit int64, nBits int64, group *Group, inArg any) (*Value, any) {
 	dv, v, err := d.TryFieldFormatRange(name, firstBit, nBits, group, inArg)
 	if dv == nil || dv.Errors() != nil {
-		d.IOPanic(err, "FieldFormatRange: TryFieldFormatRange")
+		d.IOPanic(err, name, "FieldFormatRange: TryFieldFormatRange")
 	}
 
 	return dv, v
@@ -1130,7 +1130,7 @@ func (d *D) TryFieldFormatBitBuf(name string, br bitio.ReaderAtSeeker, group *Gr
 func (d *D) FieldFormatBitBuf(name string, br bitio.ReaderAtSeeker, group *Group, inArg any) (*Value, any) {
 	dv, v, err := d.TryFieldFormatBitBuf(name, br, group, inArg)
 	if dv == nil || dv.Errors() != nil {
-		d.IOPanic(err, "FieldFormatBitBuf: TryFieldFormatBitBuf")
+		d.IOPanic(err, name, "FieldFormatBitBuf: TryFieldFormatBitBuf")
 	}
 
 	return dv, v
@@ -1141,7 +1141,7 @@ func (d *D) FieldFormatBitBuf(name string, br bitio.ReaderAtSeeker, group *Group
 func (d *D) FieldRootBitBuf(name string, br bitio.ReaderAtSeeker, sms ...scalar.BitBufMapper) *Value {
 	brLen, err := bitiox.Len(br)
 	if err != nil {
-		d.IOPanic(err, "br Len")
+		d.IOPanic(err, name, "br Len")
 	}
 
 	v := &Value{}
@@ -1188,17 +1188,17 @@ func (d *D) FieldStructRootBitBufFn(name string, br bitio.ReaderAtSeeker, fn fun
 func (d *D) FieldFormatReaderLen(name string, nBits int64, fn func(r io.Reader) (io.ReadCloser, error), group *Group) (*Value, any) {
 	br, err := d.TryBitBufLen(nBits)
 	if err != nil {
-		d.IOPanic(err, "FieldFormatReaderLen: BitBufLen")
+		d.IOPanic(err, name, "FieldFormatReaderLen: BitBufLen")
 	}
 
 	bbBR := bitio.NewIOReader(br)
 	r, err := fn(bbBR)
 	if err != nil {
-		d.IOPanic(err, "FieldFormatReaderLen: fn")
+		d.IOPanic(err, name, "FieldFormatReaderLen: fn")
 	}
 	rBuf, err := io.ReadAll(r)
 	if err != nil {
-		d.IOPanic(err, "FieldFormatReaderLen: ReadAll")
+		d.IOPanic(err, name, "FieldFormatReaderLen: ReadAll")
 	}
 	rBR := bitio.NewBitReader(rBuf, -1)
 
@@ -1245,7 +1245,7 @@ func (d *D) FieldReaderRange(name string, startBit int64, nBits int64, fn func(r
 func (d *D) FieldReaderRangeFormat(name string, startBit int64, nBits int64, fn func(r io.Reader) io.Reader, group *Group, inArg any) (int64, bitio.ReaderAtSeeker, *Value, any) {
 	cz, rBR, dv, v, err := d.TryFieldReaderRangeFormat(name, startBit, nBits, fn, group, inArg)
 	if err != nil {
-		d.IOPanic(err, "TryFieldReaderRangeFormat")
+		d.IOPanic(err, name, "TryFieldReaderRangeFormat")
 	}
 	return cz, rBR, dv, v
 }
@@ -1268,7 +1268,7 @@ func (d *D) TryFieldValue(name string, fn func() (*Value, error)) (*Value, error
 func (d *D) FieldValue(name string, fn func() *Value) *Value {
 	v, err := d.TryFieldValue(name, func() (*Value, error) { return fn(), nil })
 	if err != nil {
-		d.IOPanic(err, "FieldValue: TryFieldValue")
+		d.IOPanic(err, name, "FieldValue: TryFieldValue")
 	}
 	return v
 }
diff --git a/pkg/decode/decode_gen.go b/pkg/decode/decode_gen.go
diff --git a/pkg/decode/decode_gen.go.tmpl b/pkg/decode/decode_gen.go.tmpl

Original file line number	Diff line number	Diff line change
`@@ -281,7 +281,7 @@ func decodeASN1BERValue(d decode.D, bib bitio.Buffer, sb *strings.Builder, par`
`281`	`281`	`if bib != nil {`
`282`	`282`	`// TODO: helper?`
`283`	`283`	`if _, err := bitio.Copy(bib, br); err != nil {`
`284`		`- d.IOPanic(err, "bitio.Copy")`
	`284`	`+ d.IOPanic(err, "value", "bitio.Copy")`
`285`	`285`	`}`
`286`	`286`	`}`
`287`	`287`	`if unusedBitsCount > 0 {`
`@@ -292,7 +292,7 @@ func decodeASN1BERValue(d decode.D, bib bitio.Buffer, sb *strings.Builder, par`
`292`	`292`	`if bib != nil {`
`293`	`293`	`// TODO: helper?`
`294`	`294`	`if _, err := bitio.Copy(bib, br); err != nil {`
`295`		`- d.IOPanic(err, "bitio.Copy")`
	`295`	`+ d.IOPanic(err, "value", "bitio.Copy")`
`296`	`296`	`}`
`297`	`297`	`}`
`298`	`298`	`case class == classUniversal && tag == universalTypeNull:`
Original file line number	Diff line number	Diff line change
`@@ -302,7 +302,7 @@ func textNullLenFn(encoding int, notFoundFixedBytes int) func(d *decode.D) strin`
`302`	`302`	`func(v uint64) bool { return v == 0 },`
`303`	`303`	`)`
`304`	`304`	`if err != nil {`
`305`		`- d.IOPanic(err, "textNullLenFn")`
	`305`	`+ d.IOPanic(err, "", "textNullLenFn")`
`306`	`306`	`}`
`307`	`307`	`if offset < 0 {`
`308`	`308`	`if notFoundFixedBytes < 0 {`
Original file line number	Diff line number	Diff line change
`@@ -263,7 +263,7 @@ func (d *D) TryCopyBits(w io.Writer, r bitio.Reader) (int64, error) {`
`263`	`263`	`func (d *D) CopyBits(w io.Writer, r bitio.Reader) int64 {`
`264`	`264`	`n, err := d.TryCopyBits(w, r)`
`265`	`265`	`if err != nil {`
`266`		`- d.IOPanic(err, "CopyBits: Copy")`
	`266`	`+ d.IOPanic(err, "", "CopyBits")`
`267`	`267`	`}`
`268`	`268`	`return n`
`269`	`269`	`}`
`@@ -277,15 +277,15 @@ func (d *D) TryCopy(w io.Writer, r io.Reader) (int64, error) {`
`277`	`277`	`func (d *D) Copy(w io.Writer, r io.Reader) int64 {`
`278`	`278`	`n, err := d.TryCopy(w, r)`
`279`	`279`	`if err != nil {`
`280`		`- d.IOPanic(err, "Copy")`
	`280`	`+ d.IOPanic(err, "", "Copy")`
`281`	`281`	`}`
`282`	`282`	`return n`
`283`	`283`	`}`
`284`	`284`
`285`	`285`	`func (d *D) CloneReadSeeker(br bitio.ReadSeeker) bitio.ReadSeeker {`
`286`	`286`	`br, err := bitio.CloneReadSeeker(br)`
`287`	`287`	`if err != nil {`
`288`		`- d.IOPanic(err, "CloneReadSeeker")`
	`288`	`+ d.IOPanic(err, "", "CloneReadSeeker")`
`289`	`289`	`}`
`290`	`290`	`return br`
`291`	`291`	`}`
`@@ -308,7 +308,7 @@ func (d *D) TryReadAllBits(r bitio.Reader) ([]byte, error) {`
`308`	`308`	`func (d *D) ReadAllBits(r bitio.Reader) []byte {`
`309`	`309`	`buf, err := d.TryReadAllBits(r)`
`310`	`310`	`if err != nil {`
`311`		`- d.IOPanic(err, "Bytes ReadAllBytes")`
	`311`	`+ d.IOPanic(err, "", "ReadAllBytes")`
`312`	`312`	`}`
`313`	`313`	`return buf`
`314`	`314`	`}`
`@@ -350,7 +350,7 @@ func (d *D) FillGaps(r ranges.Range, namePrefix string) {`
`350`	`350`	`for i, gap := range gaps {`
`351`	`351`	`br, err := bitiox.Range(d.bitBuf, gap.Start, gap.Len)`
`352`	`352`	`if err != nil {`
`353`		`- d.IOPanic(err, "FillGaps: Range")`
	`353`	`+ d.IOPanic(err, namePrefix, "bitiox.Range")`
`354`	`354`	`}`
`355`	`355`
`356`	`356`	`v := &Value{`
`@@ -380,8 +380,8 @@ func (d *D) Fatalf(format string, a ...any) {`
`380`	`380`	`panic(DecoderError{Reason: fmt.Sprintf(format, a...), Pos: d.Pos()})`
`381`	`381`	`}`
`382`	`382`
`383`		`-func (d *D) IOPanic(err error, op string) {`
`384`		`- panic(IOError{Err: err, Pos: d.Pos(), Op: op})`
	`383`	`+func (d *D) IOPanic(err error, name string, op string) {`
	`384`	`+ panic(IOError{Err: err, Name: name, Pos: d.Pos(), Op: op})`
`385`	`385`	`}`
`386`	`386`
`387`	`387`	`// TryBits reads nBits bits from buffer`
`@@ -543,7 +543,7 @@ func (d *D) TryPeekFind(nBits int, seekBits int64, maxLen int64, fn func(v uint6`
`543`	`543`	`func (d *D) PeekFind(nBits int, seekBits int64, maxLen int64, fn func(v uint64) bool) (int64, uint64) {`
`544`	`544`	`peekBits, v, err := d.TryPeekFind(nBits, seekBits, maxLen, fn)`
`545`	`545`	`if err != nil {`
`546`		`- d.IOPanic(err, "PeekFind: TryPeekFind")`
	`546`	`+ d.IOPanic(err, "", "PeekFind")`
`547`	`547`	`}`
`548`	`548`	`if peekBits == -1 {`
`549`	`549`	`d.Errorf("peek not found")`
`@@ -771,7 +771,7 @@ func (d D) TrySeekRel(delta int64, fns ...func(d D)) (int64, error) {`
`771`	`771`	`func (d D) SeekRel(delta int64, fns ...func(d D)) int64 {`
`772`	`772`	`n, err := d.trySeekAbs(d.Pos()+delta, fns...)`
`773`	`773`	`if err != nil {`
`774`		`- d.IOPanic(err, "SeekRel")`
	`774`	`+ d.IOPanic(err, "", "SeekRel")`
`775`	`775`	`}`
`776`	`776`	`return n`
`777`	`777`	`}`
`@@ -785,7 +785,7 @@ func (d D) TrySeekAbs(pos int64, fns ...func(d D)) (int64, error) {`
`785`	`785`	`func (d D) SeekAbs(pos int64, fns ...func(d D)) int64 {`
`786`	`786`	`n, err := d.trySeekAbs(pos, fns...)`
`787`	`787`	`if err != nil {`
`788`		`- d.IOPanic(err, "SeekAbs")`
	`788`	`+ d.IOPanic(err, "", "SeekAbs")`
`789`	`789`	`}`
`790`	`790`	`return n`
`791`	`791`	`}`
`@@ -955,7 +955,7 @@ func (d D) RangeFn(firstBit int64, nBits int64, fn func(d D)) int64 {`
`955`	`955`	`// TODO: do some kind of DecodeLimitedLen/RangeFn?`
`956`	`956`	`br := d.BitBufRange(0, firstBit+nBits)`
`957`	`957`	`if _, err := br.SeekBits(firstBit, io.SeekStart); err != nil {`
`958`		`- d.IOPanic(err, "RangeFn: SeekAbs")`
	`958`	`+ d.IOPanic(err, "", "RangeFn: SeekAbs")`
`959`	`959`	`}`
`960`	`960`
`961`	`961`	`nd := *d`
`@@ -979,7 +979,7 @@ func (d D) Format(group Group, inArg any) any {`
`979`	`979`	`ReadBuf: d.readBuf,`
`980`	`980`	`})`
`981`	`981`	`if dv == nil \|\| dv.Errors() != nil {`
`982`		`- d.IOPanic(err, "Format: decode")`
	`982`	`+ d.IOPanic(err, "", "Format: decode")`
`983`	`983`	`}`
`984`	`984`
`985`	`985`	`switch vv := dv.V.(type) {`
`@@ -992,7 +992,7 @@ func (d D) Format(group Group, inArg any) any {`
`992`	`992`	`}`
`993`	`993`
`994`	`994`	`if _, err := d.bitBuf.SeekBits(dv.Range.Len, io.SeekCurrent); err != nil {`
`995`		`- d.IOPanic(err, "Format: SeekRel")`
	`995`	`+ d.IOPanic(err, "", "Format: SeekRel")`
`996`	`996`	`}`
`997`	`997`
`998`	`998`	`return v`
`@@ -1015,7 +1015,7 @@ func (d D) TryFieldFormat(name string, group Group, inArg any) (*Value, any, e`
`1015`	`1015`
`1016`	`1016`	`d.AddChild(dv)`
`1017`	`1017`	`if _, err := d.bitBuf.SeekBits(dv.Range.Len, io.SeekCurrent); err != nil {`
`1018`		`- d.IOPanic(err, "TryFieldFormat: SeekRel")`
	`1018`	`+ d.IOPanic(err, name, "TryFieldFormat: SeekRel")`
`1019`	`1019`	`}`
`1020`	`1020`
`1021`	`1021`	`return dv, v, err`
`@@ -1024,7 +1024,7 @@ func (d D) TryFieldFormat(name string, group Group, inArg any) (*Value, any, e`
`1024`	`1024`	`func (d D) FieldFormat(name string, group Group, inArg any) (*Value, any) {`
`1025`	`1025`	`dv, v, err := d.TryFieldFormat(name, group, inArg)`
`1026`	`1026`	`if dv == nil \|\| dv.Errors() != nil {`
`1027`		`- d.IOPanic(err, "FieldFormat: TryFieldFormat")`
	`1027`	`+ d.IOPanic(err, name, "FieldFormat: TryFieldFormat")`
`1028`	`1028`	`}`
`1029`	`1029`	`return dv, v`
`1030`	`1030`	`}`
`@@ -1054,7 +1054,7 @@ func (d D) TryFieldFormatLen(name string, nBits int64, group Group, inArg any)`
`1054`	`1054`
`1055`	`1055`	`d.AddChild(dv)`
`1056`	`1056`	`if _, err := d.bitBuf.SeekBits(nBits, io.SeekCurrent); err != nil {`
`1057`		`- d.IOPanic(err, "TryFieldFormatLen: SeekRel")`
	`1057`	`+ d.IOPanic(err, name, "TryFieldFormatLen: SeekRel")`
`1058`	`1058`	`}`
`1059`	`1059`
`1060`	`1060`	`return dv, v, err`
`@@ -1063,7 +1063,7 @@ func (d D) TryFieldFormatLen(name string, nBits int64, group Group, inArg any)`
`1063`	`1063`	`func (d D) FieldFormatLen(name string, nBits int64, group Group, inArg any) (*Value, any) {`
`1064`	`1064`	`dv, v, err := d.TryFieldFormatLen(name, nBits, group, inArg)`
`1065`	`1065`	`if dv == nil \|\| dv.Errors() != nil {`
`1066`		`- d.IOPanic(err, "FieldFormatLen: TryFieldFormatLen")`
	`1066`	`+ d.IOPanic(err, name, "FieldFormatLen: TryFieldFormatLen")`
`1067`	`1067`	`}`
`1068`	`1068`	`return dv, v`
`1069`	`1069`	`}`
`@@ -1100,7 +1100,7 @@ func (d *D) TryFieldFormatRange(name string, firstBit int64, nBits int64, group`
`1100`	`1100`	`func (d D) FieldFormatRange(name string, firstBit int64, nBits int64, group Group, inArg any) (*Value, any) {`
`1101`	`1101`	`dv, v, err := d.TryFieldFormatRange(name, firstBit, nBits, group, inArg)`
`1102`	`1102`	`if dv == nil \|\| dv.Errors() != nil {`
`1103`		`- d.IOPanic(err, "FieldFormatRange: TryFieldFormatRange")`
	`1103`	`+ d.IOPanic(err, name, "FieldFormatRange: TryFieldFormatRange")`
`1104`	`1104`	`}`
`1105`	`1105`
`1106`	`1106`	`return dv, v`
`@@ -1130,7 +1130,7 @@ func (d D) TryFieldFormatBitBuf(name string, br bitio.ReaderAtSeeker, group Gr`
`1130`	`1130`	`func (d D) FieldFormatBitBuf(name string, br bitio.ReaderAtSeeker, group Group, inArg any) (*Value, any) {`
`1131`	`1131`	`dv, v, err := d.TryFieldFormatBitBuf(name, br, group, inArg)`
`1132`	`1132`	`if dv == nil \|\| dv.Errors() != nil {`
`1133`		`- d.IOPanic(err, "FieldFormatBitBuf: TryFieldFormatBitBuf")`
	`1133`	`+ d.IOPanic(err, name, "FieldFormatBitBuf: TryFieldFormatBitBuf")`
`1134`	`1134`	`}`
`1135`	`1135`
`1136`	`1136`	`return dv, v`
`@@ -1141,7 +1141,7 @@ func (d D) FieldFormatBitBuf(name string, br bitio.ReaderAtSeeker, group Group`
`1141`	`1141`	`func (d D) FieldRootBitBuf(name string, br bitio.ReaderAtSeeker, sms ...scalar.BitBufMapper) Value {`
`1142`	`1142`	`brLen, err := bitiox.Len(br)`
`1143`	`1143`	`if err != nil {`
`1144`		`- d.IOPanic(err, "br Len")`
	`1144`	`+ d.IOPanic(err, name, "br Len")`
`1145`	`1145`	`}`
`1146`	`1146`
`1147`	`1147`	`v := &Value{}`
`@@ -1188,17 +1188,17 @@ func (d *D) FieldStructRootBitBufFn(name string, br bitio.ReaderAtSeeker, fn fun`
`1188`	`1188`	`func (d D) FieldFormatReaderLen(name string, nBits int64, fn func(r io.Reader) (io.ReadCloser, error), group Group) (*Value, any) {`
`1189`	`1189`	`br, err := d.TryBitBufLen(nBits)`
`1190`	`1190`	`if err != nil {`
`1191`		`- d.IOPanic(err, "FieldFormatReaderLen: BitBufLen")`
	`1191`	`+ d.IOPanic(err, name, "FieldFormatReaderLen: BitBufLen")`
`1192`	`1192`	`}`
`1193`	`1193`
`1194`	`1194`	`bbBR := bitio.NewIOReader(br)`
`1195`	`1195`	`r, err := fn(bbBR)`
`1196`	`1196`	`if err != nil {`
`1197`		`- d.IOPanic(err, "FieldFormatReaderLen: fn")`
	`1197`	`+ d.IOPanic(err, name, "FieldFormatReaderLen: fn")`
`1198`	`1198`	`}`
`1199`	`1199`	`rBuf, err := io.ReadAll(r)`
`1200`	`1200`	`if err != nil {`
`1201`		`- d.IOPanic(err, "FieldFormatReaderLen: ReadAll")`
	`1201`	`+ d.IOPanic(err, name, "FieldFormatReaderLen: ReadAll")`
`1202`	`1202`	`}`
`1203`	`1203`	`rBR := bitio.NewBitReader(rBuf, -1)`
`1204`	`1204`
`@@ -1245,7 +1245,7 @@ func (d *D) FieldReaderRange(name string, startBit int64, nBits int64, fn func(r`
`1245`	`1245`	`func (d D) FieldReaderRangeFormat(name string, startBit int64, nBits int64, fn func(r io.Reader) io.Reader, group Group, inArg any) (int64, bitio.ReaderAtSeeker, *Value, any) {`
`1246`	`1246`	`cz, rBR, dv, v, err := d.TryFieldReaderRangeFormat(name, startBit, nBits, fn, group, inArg)`
`1247`	`1247`	`if err != nil {`
`1248`		`- d.IOPanic(err, "TryFieldReaderRangeFormat")`
	`1248`	`+ d.IOPanic(err, name, "TryFieldReaderRangeFormat")`
`1249`	`1249`	`}`
`1250`	`1250`	`return cz, rBR, dv, v`
`1251`	`1251`	`}`
`@@ -1268,7 +1268,7 @@ func (d D) TryFieldValue(name string, fn func() (Value, error)) (*Value, error`
`1268`	`1268`	`func (d D) FieldValue(name string, fn func() Value) *Value {`
`1269`	`1269`	`v, err := d.TryFieldValue(name, func() (*Value, error) { return fn(), nil })`
`1270`	`1270`	`if err != nil {`
`1271`		`- d.IOPanic(err, "FieldValue: TryFieldValue")`
	`1271`	`+ d.IOPanic(err, name, "FieldValue: TryFieldValue")`
`1272`	`1272`	`}`
`1273`	`1273`	`return v`
`1274`	`1274`	`}`