The default waveform style. It is rendered as WSNormal. This is the only style overwritten by TStyled.

An error value. Errors are propagated by translators.

Do not display any value, even if it exists.

Copy the style of the nth subsignal.

A normal value.

A warning value.

An undefined value.

A high impedance value.

A value that does not matter.

A weakly defined value.

A custom color. See Clash.Shockwaves.Style for more information.

A variable in a style configuration file, with a default.

Use the translator of a different type. Note that the width value of the Translators should match that of the target. The TypeRef parameter does not end up in the actual output, but is used to access functionality for the referenced type. Use tRef to create this translator.

A reference to a lookup table. Implement Waveform through WaveformLUT to stably use this functionality.

Select one translator to be used based on the first bits of the binary representation. Translate the rest of the bits using the selected translator. To be exact, if k translators are provided, ceil(log2(k)) bits will be consumed to select the translator.

No subsignals for the translators are created. Keep in mind that problems may occur if two translators specify subsignals with identical names.

Use index to take a slice of the binary data. This slice is interpreted as an unsigned integer. This index value is checked against the ranges in rangeTrans; the first translator with a value in the range is used. If no ranges match, the defTrans is used.

The selected translator is passed the full binary.

• *Important**: Slice indices start to the left, i.e. with the MSB!

Split the binary data into separate fields, translate each of these, and join together the values. Specifically, for each of the listed translators, consume as many bits as specified by the translator, then pass on the rest of the bits to the other translators.

The value is constructed from the values of the subtranslators. A start, stop and separator string can be specified, as well as optional labels to put in front of the different values.

Example:

   data T = T{a::Bool,b::Bool}
   translatorVariantT = TProduct
   { subs = [("a",Bool,"b",Bool)],
   , start = "T{"
   , sep = ","
   , stop = "}"
   , labels = ["a=","b="]
   , preci = -1
   , preco = 11
   }
   

An array value. This behaves much like TProduct, except that no labels can be provided, and all fields use the same translator. The fields are numbered starting from 0.

Advance product type. First, a number of slices of the binary are translated. Then, the subsignals are picked from these translations, and the value is constructed from fixed strings and values from the translators.

• *Important**: Slice indices start to the left, i.e. with the MSB!

Translate the binary data using the translator specified, and duplicate the value into a subsignal of the provided name. This duplication applies the WSInherit 0 style to copy the actual style of the subvalue.

Apply a style to a translation, replacing only WSDefault. This translator is purely cosmetic and otherwise does not influence translation.

Modify the binary input of the contained translator The binary data is modified using bits (see BitPart) before being passed onto the subtranslator.

Translate the binary data as an integer. format and spacer determine how exactly the value is displayed.

A constant translation value. The binary value provided is completely ignored.

A signed decimal value.

An unsigned decimal value.

A hexadecimal value. Supports partially undefined values.

An octal value. Supports partially undefined values.

A binary value. Supports partially undefined values.

A literal string.

The value of a subtranslation parsed with outer precedence.

Return the input binary.

Return the BitList, ignoring the input.

Return a slice of the input. **Important**: slice indices start to the left, i.e. with the MSB!

Pass the binary data onto multiple BitParts, and concatenate their results.

Return `1` if there are undefined bits in the binary.

Return bits in reverse order.

Invert 0 and 1.

Bitwise and. If values of different lengths are provided, values are zero-padded on the left. Short-cirtuits (x & 0 = 0).

Bitwise or. If values of different lengths are provided, values are zero-padded on the left. Short-cirtuits (x | 1 = 1).

Bitwise xor. If multiple values of different lengths are provided, values are zero-padded on the left.

Turn a binary value into a one-hot signal based on the provided range. This essentially loops over all values in the range, creating a 1 iff the input BitPart's result is equal to that value. I.e. BPOneHot (0,3) "10" results in "001".

Turn a binary value into a n-hot signal based on the provided range. This essentially loops over all values in the range, creating a 1 iff the input BitPart's result is less than or equal to that value.

Switch bitparts based on the first bit in the condition bitpart: `BPIf (true) (false) (undef) (cond)`