generalmimon
commented
4 years ago ternary operators in encoding
Unfortunately, key encoding supports only literal constant values, it doesn't support KS expressions. So you really have to create two separate attributes and switch them using if.
And note that even if it supported expressions, any encoding identifier would be a string, and every string literal in KS has to be enclosed in quotes:
encoding: 'is_wide ? "utf16" : "utf8"'
encoding: '"utf-8"' # ' for YAML, " for KS expressionbyte array with ternary to_s
don't know how to call method 'identifier(to_s)' of object type 'BytesLimitType(...)'
This bug has been fixed in 0.9 in commit https://github.com/kaitai-io/kaitai_struct_compiler/commit/375a140bb96adeb4c6031e478fad4e03eeabfefb. Make sure you have the latest development 0.9 KS compiler installed (https://kaitai.io/#download), or make your life easier and use the devel Web IDE, which has always the latest KSC.
The other thing is that this expression
value: 'bytes.to_s(utf8)'is incorrect, because the string utf8 must be enclosed in quotes to be a string literal ("utf8"). Referencing utf8 would access the value of an attribute with id: utf8, which can be a seq field or for example a value instance:
instances:
utf8:
value: 'true ? "utf8" : "ascii"'If any attribute called utf8 (referenced in the expression bytes.to_s(utf8)) doesn't exist, the compiler in the devel Web IDE should throw an error like unable to access 'utf8' in test::encoded_string context, but that unfortunately doesn't happen for some reason. Let's add this to the growing list of compiler bugs :-|
I was surprised that field "bytes" was BytesLimitType and not a raw byte array.
BytesLimitType actually is a raw byte array. This is just an internal compiler data type of a seq or instances field parsed from stream defined using the size key. If the byte array would be delimited using terminator byte, it would be called BytesTerminatedType and so on.
The DataType class inside the compiler internals stores all information needed to be able to parse an attribute, i.e. it is a more convenient representation of parsing-relevant keys in the attribute definition. For example, the BytesLimitType case class looks like this:
case class BytesLimitType(
size: Ast.expr,
terminator: Option[Int],
include: Boolean,
padRight: Option[Int],
override val process: Option[ProcessExpr]
) extends BytesTypeBut if everything works correctly, this type diversity should not be a problem when you're e.g. working with BytesLimitType and CalcBytesType (i.e. created from a byte literal like [0xca, 0xfe]) in the same value instance or when you're calling some methods on them, because they all derive from an abstract class BytesType, and this type is used anywhere where it doesn't matter which specific byte array it is.
conditional fields and a ternary instance value
This is an instance of issue https://github.com/kaitai-io/kaitai_struct/issues/318, and again, the solution is to download the latest development (unstable) 0.9 version of KSC or use the devel Web IDE.
dgelessus
hallipr
webbnh
KOLANICH
hakanai
I need to parse null-termintated strings with conditional encoding utf16 or utf8 The strings are stored as Length + Value, with length negated for utf16.
If I use separate types with type switching wide_string (utf16) and narrow_string (utf8), when comparing strings, I'm forced to continually cast them to the same type. I'm not sure I can do this when I compile to C#.
I've tried several approaches that avoid type switching and casting:
ternary operators in encoding
error: The encoding label provided ... is invalid.
byte array with ternary to_s
error: don't know how to call method 'identifier(to_s)'
I was surprised that field "bytes" was BytesLimitType and not a raw byte array.
conditional fields and a ternary instance value
error: can't combine output types
This works but is hacky: Conditional fields and ternary instance, forcing string type using .reverse.reverse or .substring(0, length).