30218872366

Committed 26 Jul 2026 08:23PM UTC coverage: 86.601%. First build

Build # 30218872366

Build Type

Pull #706

github

Committed by

web-flow

Commit Message

Merge 2c88a83fe into 05c40a991

Pull Request Pull Request #706: Vis

Coverage Stats

1010 of 1215 new or added lines in 8 files covered. (83.13%)

7090 of 8187 relevant lines covered (86.6%)

748.01 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.25

/internal/trexDecoder/trexDecoder.go

// SPDX-License-Identifier: MIT

// Package trexDecoder decodes framed TREX trice byte streams.
package trexDecoder

import (
        "bytes"
        "encoding/binary"
        "encoding/hex"
        "fmt"
        "io"
        "log"
        "math"
        "strings"
        "sync"

        cobs "github.com/rokath/cobs/go"
        "github.com/rokath/tcobs/v1"
        "github.com/rokath/trice/internal/decoder"
        "github.com/rokath/trice/internal/emitter"
        "github.com/rokath/trice/internal/fmtspec"
        "github.com/rokath/trice/internal/id"
        "github.com/rokath/trice/pkg/cipher"
)

const (
        tyIdSize = 2 // tySize is what each trice message starts with: 2 bytes
        ncSize   = 2 // countSize is what each regular trice message contains after an optional target timestamp
        typeS0   = 1 // regular trice format without stamp     : 011iiiiiI NC ...
        typeS2   = 2 // regular trice format with 16-bit stamp : 101iiiiiI TT NC ...
        typeS4   = 3 // regular trice format with 32-bit stamp : 111iiiiiI TT TT NC ...
        typeX0   = 0 // selector-0 extension record without Trice ID, timestamp or cycle counter

        packageFramingNone = iota
        packageFramingCOBS
        packageFramingTCOBS   //v1
        packageFramingTCOBSv2 //v2
)

var (
        // Doubled16BitID enables acceptance of 16-bit IDs repeated twice in the header.
        Doubled16BitID bool

        // AddNewlineToEachTriceMessage appends a newline to each decoded Trice message when needed.
        AddNewlineToEachTriceMessage bool

        // SingleFraming demands that each received package contains at most one Trice message.
        SingleFraming bool

        // DisableCycleErrors suppresses cycle counter mismatch diagnostics.
        DisableCycleErrors bool
)

var specialCaseTriceTypes = map[string]struct{}{
        "TRICES": {}, "TRICEN": {}, "TRICEB": {}, "TRICEF": {},
        "TRICE8B": {}, "TRICE16B": {}, "TRICE32B": {}, "TRICE64B": {},
        "TRICE8F": {}, "TRICE16F": {}, "TRICE32F": {}, "TRICE64F": {},
        "TRICE8C": {}, "TRICE16C": {}, "TRICE32C": {}, "TRICE64C": {},
        "TRICE_S": {}, "TRICE_N": {}, "TRICE_B": {}, "TRICE_F": {},
        "TRICE8_B": {}, "TRICE16_B": {}, "TRICE32_B": {}, "TRICE64_B": {},
        "TRICE8_F": {}, "TRICE16_F": {}, "TRICE32_F": {}, "TRICE64_F": {},
        "TRICE8_C": {}, "TRICE16_C": {}, "TRICE32_C": {}, "TRICE64_C": {},
}

func init() {
        decoder.Register("TREX", New)
}

// trexDec is the decoder instance for TREX-encoded Trices.
type trexDec struct {
        decoder.DecoderData
        cycle          uint8  // cycle date: c0...bf
        pFmt           string // modified trice format string: %u -> %d
        u              []int  // 1: modified format string positions:  %u -> %d, 2: float (%f)
        packageFraming int
        visEnabled     bool              // avoids record-capture work unless the translator has an active -vis router
        visRecord      decoder.VisRecord // typed data for the most recently decoded supported numeric Trice
        visValid       bool              // true only when visRecord belongs to the most recent successful Read
}

// SetVisRecordEnabled controls optional typed-record capture without changing normal decoding.
func (p *trexDec) SetVisRecordEnabled(enabled bool) {
        p.visEnabled = enabled
        if !enabled {
                p.visRecord = decoder.VisRecord{}
                p.visValid = false
        }
}

// VisRecord returns the typed fixed-width numeric record produced by the most recent Read.
//
// Returning a value copy prevents downstream visualization processing from
// retaining or mutating decoder-owned state across subsequent reads.
func (p *trexDec) VisRecord() (decoder.VisRecord, bool) {
        return p.visRecord, p.visValid
}

// New provides a TREX decoder instance.
//
// in is the input byte stream source.
func New(w io.Writer, lut id.TriceIDLookUp, m *sync.RWMutex, li id.TriceIDLookUpLI, in io.Reader, endian bool) decoder.Decoder {
        // Todo: rewrite using the TCOBS Reader. The provided in io.Reader provides a raw data stream.
        // https://github.com/rokath/tcobs/blob/master/TCOBSv1/read.go -> use NewDecoder ...

        p := &trexDec{
                DecoderData: decoder.NewDecoderData(decoder.Config{
                        Out:         w,
                        LUT:         lut,
                        LUTMutex:    m,
                        LI:          li,
                        In:          in,
                        Endian:      endian,
                        NeedBuffers: true,
                }),
                cycle: 0xc0, // start value
        }

        switch strings.ToLower(decoder.PackageFraming) {
        case "cobs":
                p.packageFraming = packageFramingCOBS
        case "tcobs", "tcobsv1":
                p.packageFraming = packageFramingTCOBS
        case "tcobsv2":
                p.packageFraming = packageFramingTCOBSv2
        case "none":
                p.packageFraming = packageFramingNone
        default:
                log.Fatal("Invalid framing switch:\a", decoder.PackageFraming)
        }
        return p
}

// nextData reads with an inner reader a raw byte stream.
//
// When fewer than 4 bytes are available, nextData returns without processing.
// That means the incoming data stream is exhausted and a next try should be started a bit later.
// Some arrived bytes are kept internally and concatenated with the following bytes in a next Read.
// Afterwards 0 or at least 4 bytes are inside p.B
func (p *trexDec) nextData() {
        m, err := p.In.Read(p.InnerBuffer)      // use p.InnerBuffer as destination read buffer
        p.B = append(p.B, p.InnerBuffer[:m]...) // merge with leftovers
        if err != nil && err != io.EOF {        // some serious error
                log.Fatal("ERROR:internal reader error\a", err) // exit
        }
}

// nextPackage reads with an inner reader a TCOBSv1 encoded byte stream.
//
// When no terminating 0 is found in the incoming bytes nextPackage returns without action.
// That means the incoming data stream is exhausted and a next try should be started a bit later.
// Some arrived bytes are kept internally and concatenated with the following bytes in a next Read.
// When a terminating 0 is found in the incoming bytes ReadFromCOBS decodes the COBS package
// and returns it in b and its len in n. If more data arrived after the first terminating 0,
// these are kept internally and concatenated with the following bytes in a next Read.
func (p *trexDec) nextPackage() {
        // Here p.IBuf contains none or available bytes, what can be several trice messages.
        // So first try to process p.IBuf.
        var index int
        for {
                index = bytes.IndexByte(p.IBuf, 0) // find terminating 0
                if index == -1 {                   // p.IBuf has no complete COBS data, so try to read more input
                        m, err := p.In.Read(p.InnerBuffer)            // use p.InnerBuffer as bytes read buffer
                        p.IBuf = append(p.IBuf, p.InnerBuffer[:m]...) // merge with leftovers
                        if err != nil && err != io.EOF {              // some serious error
                                log.Fatal("ERROR:internal reader error\a", err) // exit
                        }
                        index = bytes.IndexByte(p.IBuf, 0) // find terminating 0
                        if index == -1 {                   // p.IBuf has no complete COBS data, so leave
                                // Even err could be io.EOF, some valid data possibly in p.iBUf.
                                // In case of file input (J-LINK usage) a plug off is not detectable here.
                                return // no terminating 0, nothing to do
                        }
                }
                if index != 0 {
                        break
                }
                p.IBuf = p.IBuf[1:] // skip empty frames from 32-bit direct-output delimiter padding
        }
        if decoder.TestTableMode {
                p.printTestTableLine(index + 1)
        }
        // here a complete COBS or TCOBS package exists
        if decoder.DebugOut { // Debug output
                fmt.Fprintf(p.W, "%s: ", decoder.PackageFraming)
                decoder.Dump(p.W, p.IBuf[:index+1])
        }

        frame := p.IBuf[:index]

        switch p.packageFraming {

        case packageFramingCOBS:
                p.B = p.B0                      // make([]byte, decoder.DefaultSize) // todo: avoid allocation
                n, e := cobs.Decode(p.B, frame) // if index is 0, an empty buffer is decoded
                p.IBuf = p.IBuf[index+1:]       // step forward (next package data in p.IBuf now, if any)
                if e != nil {
                        if decoder.Verbose {
                                fmt.Println("\ainconsistent COBS buffer!") // show also terminating 0
                        }
                }
                p.B = p.B[:n]

        case packageFramingTCOBS:
        repeat:
                p.B = p.B0                       // make([]byte, decoder.DefaultSize) // todo: avoid allocation
                n, e := tcobs.Decode(p.B, frame) // if index is 0, an empty buffer is decoded
                // from merging: p.IBuf = p.IBuf[index+1:]        // step forward (next package data in p.IBuf now, if any)
                if e != nil {
                        // remove 3 lines if they exist - see issue #403 for the reason.
                        s := strings.SplitN(strings.ReplaceAll(string(frame), "\r\n", "\n"), "\n", 4)
                        var bytesCount int
                        if len(s) >= 3 {
                                var newLines int
                                fmt.Println(s[0])
                                fmt.Println(s[1])
                                fmt.Println(s[2])
                                for _, b := range frame {
                                        frame = frame[1:]
                                        bytesCount++
                                        if b == 10 {
                                                newLines++
                                                if newLines == 3 {
                                                        break
                                                }
                                        }
                                        continue
                                }
                                index -= bytesCount
                                goto repeat
                        }
                        if decoder.Verbose {
                                fmt.Println(e, "\ainconsistent TCOBSv1 buffer:")
                                fmt.Println(e, hex.Dump(frame)) // show also terminating 0
                        }
                        e = nil
                        p.B = p.B[:0]
                        p.IBuf = p.IBuf[index+1:] // step forward (next package data in p.IBuf now, if any) // from merging:
                } else {
                        p.B = p.B[len(p.B)-n:]    // buffer is filled from the end
                        p.IBuf = p.IBuf[index+1:] // step forward (next package data in p.IBuf now, if any) // from merging:
                }
        default:
                log.Fatalln("unexpected execution path", p.packageFraming)
        }

        if decoder.DebugOut { // Debug output
                fmt.Fprint(p.W, "->TRICE: ")
                decoder.Dump(p.W, p.B)
        }

        if cipher.Password != "" { // encrypted
                cipher.Decrypt(p.B, p.B)
                if decoder.DebugOut { // Debug output
                        fmt.Fprint(p.W, "-> DEC:  ")
                        decoder.Dump(p.W, p.B)
                }
        }
}

// isZero reports whether all bytes in the slice are zero.
func isZero(bytes []byte) bool {
        b := byte(0)
        for _, s := range bytes {
                b |= s
        }
        return b == 0
}

// removeZeroHiByte discards one high-order padding zero byte from a candidate frame.
//
// The removed byte depends on configured endianness.
func (p *trexDec) removeZeroHiByte(s []byte) (r []byte) {
        // The package interpreter does not know the number of padding zeroes, so it needs to discard them one by one.
        // If they are not zero, this is an error.
        switch p.Endian {
        case decoder.BigEndian:
                // Big endian case: 00 00 AA AA C0 00 -> 00 AA AA C0 00 -> still typeX0 -> AA AA C0 00 -> ok next package
                if s[0] != 0 {
                        fmt.Println("unexpected case in line 273", string(s))
                }
                r = s[1:]
        case decoder.LittleEndian:
                // Little endian case: 00 00 AA AA C0 00 -> 00 AA AA C0 00 -> AA00 signals a valid Trice, but it is not! -> We need to remove the HI byte!
                if s[1] != 0 {
                        //log.Fatal("unexpected case", s)
                        // todo: This needs to be disabled for successfully running all test cases.
                        // BUT: deferred package framing NONE does not work
                }
                r = append(s[:1], s[2:]...)
        default:
                fmt.Println("unexpected case 927346193377", string(s))
        }
        return
}

// Read returns a single Trice conversion result or a single error message in b[:n].
// Read is the provided read method for TREX decoding and provides next string as byte slice.
//
// It uses inner reader p.In and internal id look-up table to fill b with a string.
// b is a slice of bytes with a len for the max expected string size.
// n is the count of read bytes inside b.
// Read returns usually one complete trice string or nothing but can return concatenated
// trice strings, each ending with a newline despite the last one, when messages added.
// Read does not process all internally read complete trice packages to be able later to
// separate Trices within one line to keep them separated for color processing.
// Therefore, Read needs to be called cyclically even after returning io.EOF to process internal data.
// When Read returns n=0, all processable complete trice packages are done,
// but the start of a following trice package can be already inside the internal buffer.
// In case of a not matching cycle, a warning message in trice format is prefixed.
// In case of invalid package data, error messages in trice format are returned and the package is dropped.
func (p *trexDec) Read(b []byte) (n int, err error) {
        decoder.BlankMetadata = false
        if p.visEnabled {
                // A failed, incomplete, or unsupported read must never expose the previous record again.
                p.visRecord = decoder.VisRecord{}
                p.visValid = false
        }
        if p.packageFraming == packageFramingNone {
                p.nextData() // returns all unprocessed data inside p.B
                p.B0 = p.B   // keep data for re-sync
        } else {
                if cipher.Password != "" && len(p.B) < 8 && isZero(p.B) {
                        p.B = p.B[:0] // Discard trailing zeroes. ATTENTION: incomplete trice messages containing many zeroes could be problematic here!
                }
                if len(p.B) == 1 { // one leftover byte cannot form a supported framed record
                        n += copy(b[n:], fmt.Sprintln("ERROR:\aunsupported short packet size 1 - ignoring package:"))
                        n += copy(b[n:], fmt.Sprintln(hex.Dump(p.B)))
                        p.B = p.B[:0]
                        return n, nil
                }
                if len(p.B) == 0 { // last decoded package exhausted
                        p.nextPackage() // returns one decoded package inside p.B
                }
        }
        packageSize := len(p.B)
        if packageSize == 1 && p.packageFraming != packageFramingNone {
                n += copy(b[n:], fmt.Sprintln("ERROR:\aunsupported short packet size 1 - ignoring package:"))
                n += copy(b[n:], fmt.Sprintln(hex.Dump(p.B)))
                p.B = p.B[:0]
                return n, nil
        }
        if packageSize < tyIdSize { // not enough data for a next package
                return
        }
        packed := p.B
        tyId := p.ReadU16(p.B)
        p.B = p.B[tyIdSize:]

        triceType := int(tyId >> decoder.IDBits) // most significant bit are the triceType
        if triceType == typeX0 {
                x0 := decoder.HandleTypeX0(packed, p.Endian, p.packageFraming == packageFramingNone)
                if x0.Consumed > len(packed) {
                        x0.Consumed = len(packed)
                }
                p.B = packed[x0.Consumed:]
                decoder.LastTriceID = 0
                decoder.TargetTimestamp = 0
                decoder.TargetTimestampSize = 0
                decoder.BlankMetadata = x0.BlankMetadata
                if x0.Text == "" {
                        return
                }
                n += copy(b[n:], x0.Text)
                return n, nil
        }

        triceID := id.TriceID(0x3FFF & tyId) // 14 least significant bits are the ID
        decoder.LastTriceID = triceID        // used for showID
        decoder.RecordForStatistics(triceID) // This is for the "trice log -stat" flag

        switch triceType {
        case typeS0: // no timestamp
                decoder.TargetTimestampSize = 0
        case typeS2: // 16-bit stamp
                decoder.TargetTimestampSize = 2
                if Doubled16BitID { // p.packageFraming == packageFramingNone || cipher.Password != "" {
                        if len(p.B) < 2 {
                                return // wait for more data
                        }

                        // Without encoding it needs to be done here.
                        // Also encrypted trice messages carry a double 16-bit ID.
                        p.B = p.B[tyIdSize:] // When target encoding is done, it removes the double 16-bit ID at the 16-bit timestamp trices.
                }
        case typeS4: // 32-bit stamp
                decoder.TargetTimestampSize = 4
        default:
                n += copy(b[n:], fmt.Sprintln("ERROR:\aunknown trice type", triceType, "(hint: IDBits value?)"))
                p.B = p.B[:0]
                return n, nil
        }

        if packageSize < tyIdSize+decoder.TargetTimestampSize+ncSize { // for non typeEX trices
                if p.packageFraming != packageFramingNone {
                        n += copy(b[n:], fmt.Sprintln("ERROR:\aunsupported short non-X0 packet size", packageSize, "- ignoring package:"))
                        n += copy(b[n:], fmt.Sprintln(hex.Dump(packed)))
                        p.B = p.B[:0]
                        return n, nil
                }
                return // not enough data
        }

        // try to interpret
        switch triceType {
        case typeS0:
                decoder.TargetTimestamp = 0
        case typeS2: // 16-bit stamp
                decoder.TargetTimestamp = uint64(p.ReadU16(p.B))
        case typeS4: // 32-bit stamp
                decoder.TargetTimestamp = uint64(p.ReadU32(p.B))
        }

        p.B = p.B[decoder.TargetTimestampSize:]

        if len(p.B) < 2 {
                return // wait for more data
        }
        nc := p.ReadU16(p.B) // n = number of data bytes (without timestamp), most significant bit is the count encoding, c = cycle
        p.B = p.B[ncSize:]

        var cycle uint8
        if nc>>15 == 1 { // special case: more than data 127 bytes
                // C code: #define TRICE_LCNT(count) TRICE_PUT16( (0x8000 | (count)) );
                cycle = p.cycle                 // cycle is not transmitted, so set expected value
                p.ParamSpace = int(0x7FFF & nc) // 15 bit for data byte count excluding timestamp
        } else {
                // C code: #define TRICE_CNTC(count) TRICE_PUT16( ((count)<<8) | TRICE_CYCLE )
                cycle = uint8(nc)           // low byte is cycle
                p.ParamSpace = int(nc >> 8) // high byte is 7 bit number of bytes for data count excluding timestamp
        }

        p.TriceSize = tyIdSize + decoder.TargetTimestampSize + ncSize + p.ParamSpace
        if p.TriceSize > packageSize { //  '>' for multiple trices in one package (case TriceOutMultiPackMode), todo: discuss all possible variants
                if p.packageFraming == packageFramingNone {
                        if decoder.Verbose {
                                n += copy(b[n:], fmt.Sprintln("wrn:\adiscarding first byte", p.B0[0], "from:"))
                                n += copy(b[n:], fmt.Sprintln(hex.Dump(p.B0)))
                        }
                        p.B0 = p.B0[1:] // discard first byte and try again
                        p.B = p.B0
                        return
                }
                if decoder.Verbose {
                        n += copy(b[n:], fmt.Sprintln("ERROR:\apackage size", packageSize, "is <", p.TriceSize, " - ignoring package:"))
                        n += copy(b[n:], fmt.Sprintln(hex.Dump(p.B)))
                        n += copy(b[n:], fmt.Sprintln("tyIdSize=", tyIdSize, "tsSize=", decoder.TargetTimestampSize, "ncSize=", ncSize, "ParamSpae=", p.ParamSpace))
                        n += copy(b[n:], fmt.Sprintln(decoder.Hints))
                }
                p.B = p.B[len(p.B):] // discard buffer
        }
        if SingleFraming && p.TriceSize != packageSize {
                if decoder.Verbose {
                        n += copy(b[n:], fmt.Sprintln("ERROR:\asingle framed package size", packageSize, "is !=", p.TriceSize, " - ignoring package:"))
                        n += copy(b[n:], fmt.Sprintln(hex.Dump(p.B)))
                        n += copy(b[n:], fmt.Sprintln("tyIdSize=", tyIdSize, "tsSize=", decoder.TargetTimestampSize, "ncSize=", ncSize, "ParamSpae=", p.ParamSpace))
                        n += copy(b[n:], fmt.Sprintln(decoder.Hints))
                }
                p.B = p.B[len(p.B):] // discard buffer
        }

        // cycle counter automatic & check
        if cycle == 0xc0 && p.cycle != 0xc0 && decoder.InitialCycle { // with cycle counter and seems to be a target reset
                n += copy(b[n:], fmt.Sprintln("warning:\a   Target Reset?   "))
                p.cycle = cycle + 1 // adjust cycle
                decoder.InitialCycle = false
        }
        if cycle == 0xc0 && p.cycle != 0xc0 && !decoder.InitialCycle { // with cycle counter and seems to be a target reset
                //n += copy(b[n:], fmt.Sprintln("info:   Target Reset?   ")) // todo: This line is ok with cycle counter but not without cycle counter
                p.cycle = cycle + 1 // adjust cycle
        }
        if cycle == 0xc0 && p.cycle == 0xc0 && decoder.InitialCycle { // with or without cycle counter and seems to be a target reset
                //n += copy(b[n:], fmt.Sprintln("warning:   Restart?   "))
                p.cycle = cycle + 1 // adjust cycle
                decoder.InitialCycle = false
        }
        if cycle == 0xc0 && p.cycle == 0xc0 && !decoder.InitialCycle { // with or without cycle counter and seems to be a normal case
                p.cycle = cycle + 1 // adjust cycle
        }
        if cycle != 0xc0 && !DisableCycleErrors { // with cycle counter and s.th. lost
                if cycle != p.cycle { // no cycle check for 0xc0 to avoid messages on every target reset and when no cycle counter is active
                        n += copy(b[n:], fmt.Sprintln("CYCLE_ERROR:\a", cycle, "!=", p.cycle, " (count=", emitter.TagEvents("CYCLE_ERROR")+1, ")"))
                        n += copy(b[n:], "                                         ") // len of location information plus stamp: 41 spaces - see NewlineIndent below - todo: make it generic
                        p.cycle = cycle                                               // adjust cycle
                }
                decoder.InitialCycle = false
                p.cycle++
        }

        var ok bool
        p.LutMutex.RLock()
        p.Trice, ok = p.Lut[triceID]
        // Keep the LUT representation separate from the optional display-only newline mutation.
        originalTrice := p.Trice
        if AddNewlineToEachTriceMessage {
                p.Trice.Strg += `\n` // this adds a newline to each single Trice message
        }
        p.LutMutex.RUnlock()
        if !ok {
                if p.packageFraming == packageFramingNone {
                        if decoder.Verbose {
                                n += copy(b[n:], fmt.Sprintln("wrn:\adiscarding first byte", p.B0[0], "from:"))
                                n += copy(b[n:], fmt.Sprintln(hex.Dump(p.B0)))
                        }
                        p.B0 = p.B0[1:] // discard first byte and try again
                        p.B = p.B0
                } else {
                        n += copy(b[n:], fmt.Sprintln("WARNING:\aunknown ID ", triceID, "- ignoring trice ending with:"))
                        n += copy(b[n:], fmt.Sprintln(hex.Dump(p.B)))
                        n += copy(b[n:], fmt.Sprintln(decoder.Hints))
                        p.B = p.B[:0] // discard all
                }
                return
        }

        if p.visEnabled {
                p.visRecord = decoder.VisRecord{
                        ID:         triceID,
                        Type:       originalTrice.Type,
                        Format:     originalTrice.Strg,
                        Stamp:      decoder.TargetTimestamp,
                        StampBits:  decoder.TargetTimestampSize * 8,
                        SingleLine: isSingleVisLine(p.Trice.Strg),
                }
        }
        // Decoder diagnostics prefixed to a valid message make this Read unsuitable
        // for record-oriented visualization, even if the numeric payload decodes.
        hadPrefixedDiagnostic := n != 0
        n += p.sprintTrice(b[n:]) // use param info
        if p.visEnabled && hadPrefixedDiagnostic {
                p.visValid = false
        }
        if len(p.B) < p.ParamSpace {
                if p.packageFraming == packageFramingNone {
                        if decoder.Verbose {
                                n += copy(b[n:], fmt.Sprintln("wrn:discarding first byte", p.B0[0], "from:"))
                                n += copy(b[n:], fmt.Sprintln(hex.Dump(p.B0)))
                        }
                        p.B0 = p.B0[1:] // discard first byte and try again
                        p.B = p.B0
                } else {
                        n += copy(b[n:], fmt.Sprintln("ERROR:ignoring data garbage:"))
                        n += copy(b[n:], fmt.Sprintln(hex.Dump(p.B)))
                        n += copy(b[n:], fmt.Sprintln(decoder.Hints))
                        p.B = p.B[:0] // discard all
                }
        } else {
                if p.packageFraming != packageFramingNone { // COBS | TCOBS are exact
                        p.B = p.B[p.ParamSpace:] // drop param info
                        if len(p.B) < 4 && isZero(p.B) {
                                p.B = p.B[:0] // drop framed direct-output word padding after the decoded Trice
                        }
                } else { // no package framing
                        alignedParamSpace := (p.ParamSpace + 3) & ^3
                        if alignedParamSpace <= len(p.B) && isZero(p.B[p.ParamSpace:alignedParamSpace]) {
                                p.B = p.B[alignedParamSpace:]
                        } else if p.ParamSpace <= len(p.B) {
                                p.B = p.B[p.ParamSpace:]
                        } else {
                                // n += copy(b[n:], fmt.Sprintln("wrn: cannot discard padding bytes", ))
                        }
                }
        }
        return
}

// isSingleVisLine mirrors the line composer's escaped-newline interpretation.
//
// A visualization record is self-contained only when its format contributes
// exactly one logical newline and that newline terminates the message.
func isSingleVisLine(format string) bool {
        var normalized strings.Builder
        normalized.Grow(len(format))
        for i := 0; i < len(format); i++ {
                switch {
                case format[i] == '\r' && i+1 < len(format) && format[i+1] == '\n':
                        normalized.WriteByte('\n')
                        i++
                case format[i] == '\\' && i+1 < len(format) && format[i+1] == '\\':
                        // The line composer protects an escaped backslash before interpreting \n.
                        normalized.WriteByte('\\')
                        i++
                case format[i] == '\\' && i+3 < len(format) &&
                        format[i+1] == 'r' && format[i+2] == '\\' && format[i+3] == 'n':
                        normalized.WriteByte('\n')
                        i += 3
                case format[i] == '\\' && i+1 < len(format) && format[i+1] == 'n':
                        normalized.WriteByte('\n')
                        i++
                default:
                        normalized.WriteByte(format[i])
                }
        }
        logical := normalized.String()
        return strings.Count(logical, "\n") == 1 && strings.HasSuffix(logical, "\n")
}

// sprintTrice writes a trice string or appropriate message into b and returns that len.
//
// p.Trice.Type is the received trice, in fact the name from til.json.
func (p *trexDec) sprintTrice(b []byte) (n int) {

        isSAlias := strings.HasPrefix(p.Trice.Strg, id.SAliasStrgPrefix) && strings.HasSuffix(p.Trice.Strg, id.SAliasStrgSuffix)
        if isSAlias { // A SAlias Strg is covered with id.SAliasStrgPrefix and id.SAliasStrgSuffix in til.json and it needs to be replaced with "%s" here.
                p.Trice.Strg = "%s" // See appropriate comment inside insertTriceIDs().
        }

        p.pFmt, p.u = decoder.UReplaceN(p.Trice.Strg)

        // remove Assert* from triceAssert* name if found
        before, _, found := strings.Cut(p.Trice.Type, "Assert")
        if found {
                p.Trice.Type = strings.TrimSpace(before)
        }

        triceType, err := id.ConstructFullTriceInfo(p.Trice.Type, len(p.u))

        if err != nil {
                n += copy(b[n:], fmt.Sprintln("err:ConstructFullTriceInfo failed with:", p.Trice.Type, len(p.B), "- ignoring package:"))
                return
        }
        ucTriceTypeReceived := strings.ToUpper(p.Trice.Type)   // examples: TRICE_S,   TRICE,   TRICE32,   TRICE16_2
        ucTriceTypeReconstructed := strings.ToUpper(triceType) // examples: TRICE32_S, TRICE0,  TRICE32_4, TRICE16_2
        for _, s := range cobsFunctionPtrList {                // walk through the list and try to find a match for execution
                if s.triceType == ucTriceTypeReconstructed || s.triceType == ucTriceTypeReceived { // match list entry "TRICE..."
                        if len(p.B) < p.ParamSpace {
                                n += copy(b[n:], fmt.Sprintln("err:len(p.B) =", len(p.B), "< p.ParamSpace = ", p.ParamSpace, "- ignoring package:"))
                                n += copy(b[n:], fmt.Sprintln(hex.Dump(p.B[:len(p.B)])))
                                n += copy(b[n:], fmt.Sprintln(decoder.Hints))
                                return
                        }
                        if p.ParamSpace != (s.bitWidth>>3)*s.paramCount {
                                if !isSpecialCaseTriceType(s.triceType) {
                                        n += copy(b[n:], fmt.Sprintln("err:s.triceType =", s.triceType, "ParamSpace =", p.ParamSpace, "not matching with bitWidth ", s.bitWidth, "and paramCount", s.paramCount, "- ignoring package:"))
                                        n += copy(b[n:], fmt.Sprintln(hex.Dump(p.B[:len(p.B)])))
                                        n += copy(b[n:], fmt.Sprintln(decoder.Hints))
                                        return
                                }
                        }
                        p.pFmt = applyMultilineIndent(p.pFmt)

                        n += s.triceFn(p, b, s.bitWidth, s.paramCount) // match found, call handler
                        return
                }
        }
        n += copy(b[n:], fmt.Sprintln("err:Unknown trice.Type:", p.Trice.Type, "and", triceType, "not matching - ignoring trice data:"))
        n += copy(b[n:], fmt.Sprintln(hex.Dump(p.B[:p.ParamSpace])))
        n += copy(b[n:], fmt.Sprintln(decoder.Hints))
        return
}

func isSpecialCaseTriceType(triceType string) bool {
        _, ok := specialCaseTriceTypes[strings.ToUpper(triceType)]
        return ok
}

func applyMultilineIndent(format string) string {
        segments := strings.Split(format, `\n`)
        if len(segments) < 3 {
                return format
        }
        if decoder.NewlineIndent == -1 {
                decoder.NewlineIndent = 12 + 1
                if !(id.LIFnJSON == "off" || id.LIFnJSON == "none") {
                        decoder.NewlineIndent += 28
                }
                if decoder.ShowID != "" {
                        decoder.NewlineIndent += 5
                }
        }
        skip := `\n` + strings.Repeat(" ", decoder.NewlineIndent)
        return strings.TrimRight(strings.Join(segments, skip), " ")
}

func splitChannelFormat(format string) (prefix string, itemFormat string, hadTrailingNewline bool) {
        before, after, found := strings.Cut(format, ":")
        if found {
                prefix = before + ":"
        } else {
                after = format
        }
        itemFormat = strings.TrimSuffix(after, `\n`)
        hadTrailingNewline = len(itemFormat) < len(after)
        return
}

func normalizeBufferItemFormat(format string) (normalized string, kind fmtspec.Kind) {
        // Buffer-format decoding uses a single repeated item verb. Issue #649 added
        // proper support for C length modifiers in the main decoder path, and the
        // buffer path must apply the same normalization to avoid raw `%ld`, `%zx`,
        // `%lx` or `%llx` reaching Go fmt unchanged.
        normalized, specs := fmtspec.Normalize(format)
        if len(specs) == 0 {
                return format, fmtspec.KindSigned
        }
        return normalized, specs[0].Kind
}

func bufferValue8(v byte, kind fmtspec.Kind) interface{} {
        switch kind {
        case fmtspec.KindUnsigned:
                return v
        case fmtspec.KindBasedInteger:
                if decoder.Unsigned {
                        return v
                }
                return int8(v)
        default:
                return int8(v)
        }
}

func bufferValue16(v uint16, kind fmtspec.Kind) interface{} {
        switch kind {
        case fmtspec.KindUnsigned:
                return v
        case fmtspec.KindBasedInteger:
                if decoder.Unsigned {
                        return v
                }
                return int16(v)
        default:
                return int16(v)
        }
}

func bufferValue32(v uint32, kind fmtspec.Kind) interface{} {
        switch kind {
        case fmtspec.KindUnsigned:
                return v
        case fmtspec.KindBasedInteger:
                if decoder.Unsigned {
                        return v
                }
                return int32(v)
        default:
                return int32(v)
        }
}

func bufferValue64(v uint64, kind fmtspec.Kind) interface{} {
        switch kind {
        case fmtspec.KindUnsigned:
                return v
        case fmtspec.KindBasedInteger:
                if decoder.Unsigned {
                        return v
                }
                return int64(v)
        default:
                return int64(v)
        }
}

// triceTypeFn is the type for cobsFunctionPtrList elements.
type triceTypeFn struct {
        triceType  string                                              // triceType describes if parameters, the parameter bit width or if the parameter is a string.
        triceFn    func(p *trexDec, b []byte, bitwidth, count int) int // triceFn performs the conversion to the output string.
        ParamSpace int                                                 // ParamSpace is the count of bytes allocated for the parameters.
        bitWidth   int                                                 // bitWidth is the individual parameter width.
        paramCount int                                                 // paramCount is the amount pf parameters for the format string, which must match the count of format specifiers.
}

// cobsFunctionPtrList is a function pointer list.
var cobsFunctionPtrList = [...]triceTypeFn{
        {"TRICE_0", (*trexDec).trice0, 0, 0, 0},
        {"TRICEC", (*trexDec).triceC, 0, 0, 0},
        {"TRICE8_1", (*trexDec).unSignedOrSignedOut, 1, 8, 1},
        {"TRICE8_2", (*trexDec).unSignedOrSignedOut, 2, 8, 2},
        {"TRICE8_3", (*trexDec).unSignedOrSignedOut, 3, 8, 3},
        {"TRICE8_4", (*trexDec).unSignedOrSignedOut, 4, 8, 4},
        {"TRICE8_5", (*trexDec).unSignedOrSignedOut, 5, 8, 5},
        {"TRICE8_6", (*trexDec).unSignedOrSignedOut, 6, 8, 6},
        {"TRICE8_7", (*trexDec).unSignedOrSignedOut, 7, 8, 7},
        {"TRICE8_8", (*trexDec).unSignedOrSignedOut, 8, 8, 8},
        {"TRICE8_9", (*trexDec).unSignedOrSignedOut, 9, 8, 9},
        {"TRICE8_10", (*trexDec).unSignedOrSignedOut, 10, 8, 10},
        {"TRICE8_11", (*trexDec).unSignedOrSignedOut, 11, 8, 11},
        {"TRICE8_12", (*trexDec).unSignedOrSignedOut, 12, 8, 12},
        {"TRICE16_1", (*trexDec).unSignedOrSignedOut, 2, 16, 1},
        {"TRICE16_2", (*trexDec).unSignedOrSignedOut, 4, 16, 2},
        {"TRICE16_3", (*trexDec).unSignedOrSignedOut, 6, 16, 3},
        {"TRICE16_4", (*trexDec).unSignedOrSignedOut, 8, 16, 4},
        {"TRICE16_5", (*trexDec).unSignedOrSignedOut, 10, 16, 5},
        {"TRICE16_6", (*trexDec).unSignedOrSignedOut, 12, 16, 6},
        {"TRICE16_7", (*trexDec).unSignedOrSignedOut, 14, 16, 7},
        {"TRICE16_8", (*trexDec).unSignedOrSignedOut, 16, 16, 8},
        {"TRICE16_9", (*trexDec).unSignedOrSignedOut, 18, 16, 9},
        {"TRICE16_10", (*trexDec).unSignedOrSignedOut, 20, 16, 10},
        {"TRICE16_11", (*trexDec).unSignedOrSignedOut, 22, 16, 11},
        {"TRICE16_12", (*trexDec).unSignedOrSignedOut, 24, 16, 12},
        {"TRICE32_1", (*trexDec).unSignedOrSignedOut, 4, 32, 1},
        {"TRICE32_2", (*trexDec).unSignedOrSignedOut, 8, 32, 2},
        {"TRICE32_3", (*trexDec).unSignedOrSignedOut, 12, 32, 3},
        {"TRICE32_4", (*trexDec).unSignedOrSignedOut, 16, 32, 4},
        {"TRICE32_5", (*trexDec).unSignedOrSignedOut, 20, 32, 5},
        {"TRICE32_6", (*trexDec).unSignedOrSignedOut, 24, 32, 6},
        {"TRICE32_7", (*trexDec).unSignedOrSignedOut, 28, 32, 7},
        {"TRICE32_8", (*trexDec).unSignedOrSignedOut, 32, 32, 8},
        {"TRICE32_9", (*trexDec).unSignedOrSignedOut, 36, 32, 9},
        {"TRICE32_10", (*trexDec).unSignedOrSignedOut, 40, 32, 10},
        {"TRICE32_11", (*trexDec).unSignedOrSignedOut, 44, 32, 11},
        {"TRICE32_12", (*trexDec).unSignedOrSignedOut, 48, 32, 12},
        {"TRICE64_1", (*trexDec).unSignedOrSignedOut, 8, 64, 1},
        {"TRICE64_2", (*trexDec).unSignedOrSignedOut, 16, 64, 2},
        {"TRICE64_3", (*trexDec).unSignedOrSignedOut, 24, 64, 3},
        {"TRICE64_4", (*trexDec).unSignedOrSignedOut, 32, 64, 4},
        {"TRICE64_5", (*trexDec).unSignedOrSignedOut, 40, 64, 5},
        {"TRICE64_6", (*trexDec).unSignedOrSignedOut, 48, 64, 6},
        {"TRICE64_7", (*trexDec).unSignedOrSignedOut, 56, 64, 7},
        {"TRICE64_8", (*trexDec).unSignedOrSignedOut, 64, 64, 8},
        {"TRICE64_9", (*trexDec).unSignedOrSignedOut, 72, 64, 9},
        {"TRICE64_10", (*trexDec).unSignedOrSignedOut, 80, 64, 10},
        {"TRICE64_11", (*trexDec).unSignedOrSignedOut, 88, 64, 11},
        {"TRICE64_12", (*trexDec).unSignedOrSignedOut, 96, 64, 12},

        {"TRICES", (*trexDec).triceS, -1, 0, 0},
        {"TRICEN", (*trexDec).triceN, -1, 0, 0},

        {"TRICE8F", (*trexDec).trice8F, -1, 0, 0},
        {"TRICE16F", (*trexDec).trice16F, -1, 0, 0},
        {"TRICE32F", (*trexDec).trice32F, -1, 0, 0},
        {"TRICE64F", (*trexDec).trice64F, -1, 0, 0},

        {"TRICE8B", (*trexDec).trice8B, -1, 0, 0},
        {"TRICE16B", (*trexDec).trice16B, -1, 0, 0},
        {"TRICE32B", (*trexDec).trice32B, -1, 0, 0},
        {"TRICE64B", (*trexDec).trice64B, -1, 0, 0},

        {"TRICE8C", (*trexDec).trice8F, -1, 0, 0},
        {"TRICE16C", (*trexDec).trice16F, -1, 0, 0},
        {"TRICE32C", (*trexDec).trice32F, -1, 0, 0},
        {"TRICE64C", (*trexDec).trice64F, -1, 0, 0},
}

func (p *trexDec) alignedParamBytes(b []byte, width int) (s []byte, n int, ok bool) {
        if p.ParamSpace > len(p.B) {
                n += copy(b[n:], fmt.Sprintln("err:len(p.B) =", len(p.B), "< p.ParamSpace = ", p.ParamSpace, "- ignoring package:"))
                n += copy(b[n:], fmt.Sprintln(hex.Dump(p.B[:len(p.B)])))
                n += copy(b[n:], fmt.Sprintln(decoder.Hints))
                return nil, n, false
        }
        if p.ParamSpace%width != 0 {
                dumpLen := p.ParamSpace
                if dumpLen > len(p.B) {
                        dumpLen = len(p.B)
                }
                n += copy(b[n:], fmt.Sprintln("err:", p.Trice.Type, "ParamSpace =", p.ParamSpace, "is not aligned to", width, "byte values - ignoring package:"))
                n += copy(b[n:], fmt.Sprintln(hex.Dump(p.B[:dumpLen])))
                n += copy(b[n:], fmt.Sprintln(decoder.Hints))
                return nil, n, false
        }
        return p.B[:p.ParamSpace], 0, true
}

// triceN converts dynamic strings.
func (p *trexDec) triceN(b []byte, _ int, _ int) int {
        s := string(p.B[:p.ParamSpace])
        // todo: evaluate p.Trice.Strg, use p.SLen and do whatever should be done
        return copy(b, fmt.Sprintf(p.Trice.Strg, s))
}

// triceS converts dynamic strings.
func (p *trexDec) triceS(b []byte, _ int, _ int) int {
        s := string(p.B[:p.ParamSpace])
        return copy(b, fmt.Sprintf(p.Trice.Strg, s))
}

// triceB converts dynamic buffers.
func (p *trexDec) trice8B(b []byte, _ int, _ int) (n int) {
        if decoder.DebugOut {
                fmt.Fprintln(p.W, string(p.B))
        }
        s := p.B[:p.ParamSpace]
        prefix, itemFormat, addLineBreak := splitChannelFormat(p.Trice.Strg)
        itemFormat, itemKind := normalizeBufferItemFormat(itemFormat)
        if prefix != "" {
                n += copy(b[n:], prefix)
        }

        for i := 0; i < len(s); i++ {
                n += copy(b[n:], fmt.Sprintf(itemFormat, bufferValue8(s[i], itemKind)))
        }
        if addLineBreak {
                n += copy(b[n:], fmt.Sprintln())
        }
        return
}

// trice16B converts dynamic buffers.
func (p *trexDec) trice16B(b []byte, _ int, _ int) (n int) {
        if decoder.DebugOut {
                fmt.Fprintln(p.W, string(p.B))
        }
        s, n, ok := p.alignedParamBytes(b, 2)
        if !ok {
                return n
        }
        prefix, itemFormat, addLineBreak := splitChannelFormat(p.Trice.Strg)
        itemFormat, itemKind := normalizeBufferItemFormat(itemFormat)
        if prefix != "" {
                n += copy(b[n:], prefix)
        }

        for i := 0; i < len(s); i += 2 {
                nn := binary.LittleEndian.Uint16(s[i:])
                n += copy(b[n:], fmt.Sprintf(itemFormat, bufferValue16(nn, itemKind)))
        }
        if addLineBreak {
                n += copy(b[n:], fmt.Sprintln())
        }

        return
}

// trice32B converts dynamic buffers.
func (p *trexDec) trice32B(b []byte, _ int, _ int) (n int) {
        if decoder.DebugOut {
                fmt.Fprintln(p.W, string(p.B))
        }
        s, n, ok := p.alignedParamBytes(b, 4)
        if !ok {
                return n
        }
        prefix, itemFormat, addLineBreak := splitChannelFormat(p.Trice.Strg)
        itemFormat, itemKind := normalizeBufferItemFormat(itemFormat)
        if prefix != "" {
                n += copy(b[n:], prefix)
        }

        for i := 0; i < len(s); i += 4 {
                nn := binary.LittleEndian.Uint32(s[i:])
                n += copy(b[n:], fmt.Sprintf(itemFormat, bufferValue32(nn, itemKind)))
        }
        if addLineBreak {
                n += copy(b[n:], fmt.Sprintln())
        }
        return
}

// trice64B converts dynamic buffers.
func (p *trexDec) trice64B(b []byte, _ int, _ int) (n int) {
        if decoder.DebugOut {
                fmt.Fprintln(p.W, string(p.B))
        }
        s, n, ok := p.alignedParamBytes(b, 8)
        if !ok {
                return n
        }
        prefix, itemFormat, addLineBreak := splitChannelFormat(p.Trice.Strg)
        itemFormat, itemKind := normalizeBufferItemFormat(itemFormat)
        if prefix != "" {
                n += copy(b[n:], prefix)
        }

        for i := 0; i < len(s); i += 8 {
                nn := binary.LittleEndian.Uint64(s[i:])
                n += copy(b[n:], fmt.Sprintf(itemFormat, bufferValue64(nn, itemKind)))
        }
        if addLineBreak {
                n += copy(b[n:], fmt.Sprintln())
        }
        return
}

// trice8F display function call with 8-bit parameters.
func (p *trexDec) trice8F(b []byte, _ int, _ int) (n int) {
        if decoder.DebugOut {
                fmt.Fprintln(p.W, string(p.B))
        }
        s := p.B[:p.ParamSpace]
        n += copy(b[n:], fmt.Sprint(p.Trice.Strg))
        for i := 0; i < len(s); i++ {
                n += copy(b[n:], fmt.Sprintf("(%02x)", s[i]))
        }
        n += copy(b[n:], fmt.Sprintln())
        return
}

// trice16F display function call with 16-bit parameters.
func (p *trexDec) trice16F(b []byte, _ int, _ int) (n int) {
        if decoder.DebugOut {
                fmt.Fprintln(p.W, string(p.B))
        }
        s, n, ok := p.alignedParamBytes(b, 2)
        if !ok {
                return n
        }
        n += copy(b[n:], fmt.Sprint(p.Trice.Strg))
        for i := 0; i < len(s); i += 2 {
                n += copy(b[n:], fmt.Sprintf("(%04x)", binary.LittleEndian.Uint16(s[i:])))
        }
        n += copy(b[n:], fmt.Sprintln())
        return
}

// trice32F display function call with 32-bit parameters.
func (p *trexDec) trice32F(b []byte, _ int, _ int) (n int) {
        if decoder.DebugOut {
                fmt.Fprintln(p.W, string(p.B))
        }
        s, n, ok := p.alignedParamBytes(b, 4)
        if !ok {
                return n
        }
        n += copy(b[n:], fmt.Sprint(p.Trice.Strg))
        for i := 0; i < len(s); i += 4 {
                n += copy(b[n:], fmt.Sprintf("(%08x)", binary.LittleEndian.Uint32(s[i:])))
        }
        n += copy(b[n:], fmt.Sprintln())
        return
}

// trice64F display function call with 64-bit parameters.
func (p *trexDec) trice64F(b []byte, _ int, _ int) (n int) {
        if decoder.DebugOut {
                fmt.Fprintln(p.W, string(p.B))
        }
        s, n, ok := p.alignedParamBytes(b, 8)
        if !ok {
                return n
        }
        n += copy(b[n:], fmt.Sprint(p.Trice.Strg))
        for i := 0; i < len(s); i += 8 {
                n += copy(b[n:], fmt.Sprintf("(%016x)", binary.LittleEndian.Uint64(s[i:])))
        }
        n += copy(b[n:], fmt.Sprintln())
        return
}

// trice0 prints the trice format string.
func (p *trexDec) trice0(b []byte, _ int, _ int) int {
        if p.visEnabled {
                p.visRecord.ValueCount = 0
                p.visValid = true
        }
        return copy(b, fmt.Sprint(p.pFmt))
}

// triceC prints a no-payload ABC command as one complete output line.
func (p *trexDec) triceC(b []byte, _ int, _ int) int {
        return copy(b, fmt.Sprintln(p.pFmt))
}

// unSignedOrSignedOut prints p.B according to the format string.
func (p *trexDec) unSignedOrSignedOut(b []byte, bitwidth, count int) int {
        if len(p.u) != count {
                return copy(b, fmt.Sprintln("ERROR: Invalid format specifier count inside", p.Trice.Type, p.Trice.Strg))
        }
        // Keep normal decoding compatible with larger fixed-width Trices. The MVP
        // visualization record deliberately captures only v0 through v11.
        captureVis := p.visEnabled
        var fixedValues [decoder.VisValueCapacity]interface{}
        var values []interface{}
        if count > decoder.VisValueCapacity {
                values = make([]interface{}, count)
        } else {
                values = fixedValues[:count]
        }
        switch bitwidth {
        case 8:
                for i, f := range p.u {
                        switch f {
                        case decoder.UnsignedFormatSpecifier, decoder.PointerFormatSpecifier: // see comment inside decoder.UReplaceN
                                values[i] = p.B[i]
                                if captureVis && i < decoder.VisValueCapacity {
                                        p.setVisUnsigned(i, bitwidth, uint64(p.B[i]))
                                }
                        case decoder.SignedFormatSpecifier:
                                values[i] = int8(p.B[i])
                                if captureVis && i < decoder.VisValueCapacity {
                                        p.setVisSigned(i, bitwidth, int64(int8(p.B[i])))
                                }
                        case decoder.BooleanFormatSpecifier:
                                values[i] = p.B[i] != 0
                                if captureVis && i < decoder.VisValueCapacity {
                                        p.setVisBool(i, bitwidth, p.B[i] != 0)
                                }
                        default:
                                return copy(b, fmt.Sprintln("ERROR: Invalid format specifier (float?) inside", p.Trice.Type, p.Trice.Strg))
                        }
                }
        case 16:
                for i, f := range p.u {
                        n := p.ReadU16(p.B[2*i:])
                        switch f {
                        case decoder.UnsignedFormatSpecifier, decoder.PointerFormatSpecifier: // see comment inside decoder.UReplaceN
                                values[i] = n
                                if captureVis && i < decoder.VisValueCapacity {
                                        p.setVisUnsigned(i, bitwidth, uint64(n))
                                }
                        case decoder.SignedFormatSpecifier:
                                values[i] = int16(n)
                                if captureVis && i < decoder.VisValueCapacity {
                                        p.setVisSigned(i, bitwidth, int64(int16(n)))
                                }
                        case decoder.BooleanFormatSpecifier:
                                values[i] = n != 0
                                if captureVis && i < decoder.VisValueCapacity {
                                        p.setVisBool(i, bitwidth, n != 0)
                                }
                        default:
                                return copy(b, fmt.Sprintln("ERROR: Invalid format specifier (float?) inside", p.Trice.Type, p.Trice.Strg))
                        }
                }
        case 32:
                for i, f := range p.u {
                        n := p.ReadU32(p.B[4*i:])
                        switch f {
                        case decoder.UnsignedFormatSpecifier, decoder.PointerFormatSpecifier: // see comment inside decoder.UReplaceN
                                values[i] = n
                                if captureVis && i < decoder.VisValueCapacity {
                                        p.setVisUnsigned(i, bitwidth, uint64(n))
                                }
                        case decoder.SignedFormatSpecifier:
                                values[i] = int32(n)
                                if captureVis && i < decoder.VisValueCapacity {
                                        p.setVisSigned(i, bitwidth, int64(int32(n)))
                                }
                        case decoder.FloatFormatSpecifier:
                                values[i] = math.Float32frombits(n)
                                if captureVis && i < decoder.VisValueCapacity {
                                        p.setVisFloat(i, bitwidth, float64(math.Float32frombits(n)))
                                }
                        case decoder.BooleanFormatSpecifier:
                                values[i] = n != 0
                                if captureVis && i < decoder.VisValueCapacity {
                                        p.setVisBool(i, bitwidth, n != 0)
                                }
                        default:
                                return copy(b, fmt.Sprintln("ERROR: Invalid format specifier inside", p.Trice.Type, p.Trice.Strg))
                        }
                }
        case 64:
                for i, f := range p.u {
                        n := p.ReadU64(p.B[8*i:])
                        switch f {
                        case decoder.UnsignedFormatSpecifier, decoder.PointerFormatSpecifier: // see comment inside decoder.UReplaceN
                                values[i] = n
                                if captureVis && i < decoder.VisValueCapacity {
                                        p.setVisUnsigned(i, bitwidth, n)
                                }
                        case decoder.SignedFormatSpecifier:
                                values[i] = int64(n)
                                if captureVis && i < decoder.VisValueCapacity {
                                        p.setVisSigned(i, bitwidth, int64(n))
                                }
                        case decoder.FloatFormatSpecifier:
                                values[i] = math.Float64frombits(n)
                                if captureVis && i < decoder.VisValueCapacity {
                                        p.setVisFloat(i, bitwidth, math.Float64frombits(n))
                                }
                        case decoder.BooleanFormatSpecifier:
                                values[i] = n != 0
                                if captureVis && i < decoder.VisValueCapacity {
                                        p.setVisBool(i, bitwidth, n != 0)
                                }
                        default:
                                return copy(b, fmt.Sprintln("ERROR: Invalid format specifier inside", p.Trice.Type, p.Trice.Strg))
                        }
                }
        }
        if captureVis {
                p.visRecord.ValueCount = min(count, decoder.VisValueCapacity)
                p.visValid = true
        }
        return copy(b, fmt.Sprintf(p.pFmt, values...))
}

// setVisSigned stores an exact signed TREX parameter in the pending typed record.
func (p *trexDec) setVisSigned(index, bits int, value int64) {
        p.visRecord.Values[index] = decoder.VisValue{
                Kind:   decoder.VisValueSigned,
                Bits:   bits,
                Signed: value,
        }
}

// setVisUnsigned stores an exact unsigned TREX parameter in the pending typed record.
func (p *trexDec) setVisUnsigned(index, bits int, value uint64) {
        p.visRecord.Values[index] = decoder.VisValue{
                Kind:     decoder.VisValueUnsigned,
                Bits:     bits,
                Unsigned: value,
        }
}

// setVisFloat stores a decoded TREX floating-point parameter in the pending typed record.
func (p *trexDec) setVisFloat(index, bits int, value float64) {
        p.visRecord.Values[index] = decoder.VisValue{
                Kind:  decoder.VisValueFloat,
                Bits:  bits,
                Float: value,
        }
}

// setVisBool stores a decoded TREX Boolean parameter in the pending typed record.
func (p *trexDec) setVisBool(index, bits int, value bool) {
        p.visRecord.Values[index] = decoder.VisValue{
                Kind: decoder.VisValueBool,
                Bits: bits,
                Bool: value,
        }
}

var testTableVirgin = true

// printTestTableLine is used to generate testdata
func (p *trexDec) printTestTableLine(n int) {
        if emitter.NextLine || testTableVirgin {
                emitter.NextLine = false
                testTableVirgin = false
                fmt.Printf("{ []byte{ ")
        }
        for _, b := range p.IBuf[0:n] { // just to see trice bytes per trice
                fmt.Printf("%3d,", b)
        }
}

rokath / trice / 30218872366

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous