diff options
Diffstat (limited to 'python/examples/kaitai/kaitai_struct_formats/common')
4 files changed, 323 insertions, 0 deletions
diff --git a/python/examples/kaitai/kaitai_struct_formats/common/__init__.py b/python/examples/kaitai/kaitai_struct_formats/common/__init__.py new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/python/examples/kaitai/kaitai_struct_formats/common/__init__.py diff --git a/python/examples/kaitai/kaitai_struct_formats/common/bcd.py b/python/examples/kaitai/kaitai_struct_formats/common/bcd.py new file mode 100644 index 00000000..d75829d2 --- /dev/null +++ b/python/examples/kaitai/kaitai_struct_formats/common/bcd.py @@ -0,0 +1,111 @@ +from __future__ import absolute_import +# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild + +from pkg_resources import parse_version +from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO +import collections + + +if parse_version(ks_version) < parse_version('0.7'): + raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version)) + +class Bcd(KaitaiStruct): + """BCD (Binary Coded Decimals) is a common way to encode integer + numbers in a way that makes human-readable output somewhat + simpler. In this encoding scheme, every decimal digit is encoded as + either a single byte (8 bits), or a nibble (half of a byte, 4 + bits). This obviously wastes a lot of bits, but it makes translation + into human-readable string much easier than traditional + binary-to-decimal conversion process, which includes lots of + divisions by 10. + + For example, encoding integer 31337 in 8-digit, 8 bits per digit, + big endian order of digits BCD format yields + + ``` + 00 00 00 03 01 03 03 07 + ``` + + Encoding the same integer as 8-digit, 4 bits per digit, little + endian order BCD format would yield: + + ``` + 73 31 30 00 + ``` + + Using this type of encoding in Kaitai Struct is pretty + straightforward: one calls for this type, specifying desired + encoding parameters, and gets result using either `as_int` or + `as_str` attributes. + """ + SEQ_FIELDS = ["digits"] + def __init__(self, num_digits, bits_per_digit, is_le, _io, _parent=None, _root=None): + self._io = _io + self._parent = _parent + self._root = _root if _root else self + self.num_digits = num_digits + self.bits_per_digit = bits_per_digit + self.is_le = is_le + self._debug = collections.defaultdict(dict) + + def _read(self): + self._debug['digits']['start'] = self._io.pos() + self.digits = [None] * (self.num_digits) + for i in range(self.num_digits): + if not 'arr' in self._debug['digits']: + self._debug['digits']['arr'] = [] + self._debug['digits']['arr'].append({'start': self._io.pos()}) + _on = self.bits_per_digit + if _on == 4: + if not 'arr' in self._debug['digits']: + self._debug['digits']['arr'] = [] + self._debug['digits']['arr'].append({'start': self._io.pos()}) + self.digits[i] = self._io.read_bits_int(4) + self._debug['digits']['arr'][i]['end'] = self._io.pos() + elif _on == 8: + if not 'arr' in self._debug['digits']: + self._debug['digits']['arr'] = [] + self._debug['digits']['arr'].append({'start': self._io.pos()}) + self.digits[i] = self._io.read_u1() + self._debug['digits']['arr'][i]['end'] = self._io.pos() + self._debug['digits']['arr'][i]['end'] = self._io.pos() + + self._debug['digits']['end'] = self._io.pos() + + @property + def as_int(self): + """Value of this BCD number as integer. Endianness would be selected based on `is_le` parameter given.""" + if hasattr(self, '_m_as_int'): + return self._m_as_int if hasattr(self, '_m_as_int') else None + + self._m_as_int = (self.as_int_le if self.is_le else self.as_int_be) + return self._m_as_int if hasattr(self, '_m_as_int') else None + + @property + def as_int_le(self): + """Value of this BCD number as integer (treating digit order as little-endian).""" + if hasattr(self, '_m_as_int_le'): + return self._m_as_int_le if hasattr(self, '_m_as_int_le') else None + + self._m_as_int_le = (self.digits[0] + (0 if self.num_digits < 2 else ((self.digits[1] * 10) + (0 if self.num_digits < 3 else ((self.digits[2] * 100) + (0 if self.num_digits < 4 else ((self.digits[3] * 1000) + (0 if self.num_digits < 5 else ((self.digits[4] * 10000) + (0 if self.num_digits < 6 else ((self.digits[5] * 100000) + (0 if self.num_digits < 7 else ((self.digits[6] * 1000000) + (0 if self.num_digits < 8 else (self.digits[7] * 10000000))))))))))))))) + return self._m_as_int_le if hasattr(self, '_m_as_int_le') else None + + @property + def last_idx(self): + """Index of last digit (0-based).""" + if hasattr(self, '_m_last_idx'): + return self._m_last_idx if hasattr(self, '_m_last_idx') else None + + self._m_last_idx = (self.num_digits - 1) + return self._m_last_idx if hasattr(self, '_m_last_idx') else None + + @property + def as_int_be(self): + """Value of this BCD number as integer (treating digit order as big-endian).""" + if hasattr(self, '_m_as_int_be'): + return self._m_as_int_be if hasattr(self, '_m_as_int_be') else None + + self._m_as_int_be = (self.digits[self.last_idx] + (0 if self.num_digits < 2 else ((self.digits[(self.last_idx - 1)] * 10) + (0 if self.num_digits < 3 else ((self.digits[(self.last_idx - 2)] * 100) + (0 if self.num_digits < 4 else ((self.digits[(self.last_idx - 3)] * 1000) + (0 if self.num_digits < 5 else ((self.digits[(self.last_idx - 4)] * 10000) + (0 if self.num_digits < 6 else ((self.digits[(self.last_idx - 5)] * 100000) + (0 if self.num_digits < 7 else ((self.digits[(self.last_idx - 6)] * 1000000) + (0 if self.num_digits < 8 else (self.digits[(self.last_idx - 7)] * 10000000))))))))))))))) + return self._m_as_int_be if hasattr(self, '_m_as_int_be') else None + + diff --git a/python/examples/kaitai/kaitai_struct_formats/common/vlq_base128_be.py b/python/examples/kaitai/kaitai_struct_formats/common/vlq_base128_be.py new file mode 100644 index 00000000..097d1e36 --- /dev/null +++ b/python/examples/kaitai/kaitai_struct_formats/common/vlq_base128_be.py @@ -0,0 +1,103 @@ +from __future__ import absolute_import +# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild + +from pkg_resources import parse_version +from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO +import collections + + +if parse_version(ks_version) < parse_version('0.7'): + raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version)) + +class VlqBase128Be(KaitaiStruct): + """A variable-length unsigned integer using base128 encoding. 1-byte groups + consist of 1-bit flag of continuation and 7-bit value chunk, and are ordered + "most significant group first", i.e. in "big-endian" manner. + + This particular encoding is specified and used in: + + * Standard MIDI file format + * ASN.1 BER encoding + + More information on this encoding is available at + https://en.wikipedia.org/wiki/Variable-length_quantity + + This particular implementation supports serialized values to up 8 bytes long. + """ + SEQ_FIELDS = ["groups"] + def __init__(self, _io, _parent=None, _root=None): + self._io = _io + self._parent = _parent + self._root = _root if _root else self + self._debug = collections.defaultdict(dict) + + def _read(self): + self._debug['groups']['start'] = self._io.pos() + self.groups = [] + i = 0 + while True: + if not 'arr' in self._debug['groups']: + self._debug['groups']['arr'] = [] + self._debug['groups']['arr'].append({'start': self._io.pos()}) + _t_groups = self._root.Group(self._io, self, self._root) + _t_groups._read() + _ = _t_groups + self.groups.append(_) + self._debug['groups']['arr'][len(self.groups) - 1]['end'] = self._io.pos() + if not (_.has_next): + break + i += 1 + self._debug['groups']['end'] = self._io.pos() + + class Group(KaitaiStruct): + """One byte group, clearly divided into 7-bit "value" chunk and 1-bit "continuation" flag. + """ + SEQ_FIELDS = ["b"] + def __init__(self, _io, _parent=None, _root=None): + self._io = _io + self._parent = _parent + self._root = _root if _root else self + self._debug = collections.defaultdict(dict) + + def _read(self): + self._debug['b']['start'] = self._io.pos() + self.b = self._io.read_u1() + self._debug['b']['end'] = self._io.pos() + + @property + def has_next(self): + """If true, then we have more bytes to read.""" + if hasattr(self, '_m_has_next'): + return self._m_has_next if hasattr(self, '_m_has_next') else None + + self._m_has_next = (self.b & 128) != 0 + return self._m_has_next if hasattr(self, '_m_has_next') else None + + @property + def value(self): + """The 7-bit (base128) numeric value chunk of this group.""" + if hasattr(self, '_m_value'): + return self._m_value if hasattr(self, '_m_value') else None + + self._m_value = (self.b & 127) + return self._m_value if hasattr(self, '_m_value') else None + + + @property + def last(self): + if hasattr(self, '_m_last'): + return self._m_last if hasattr(self, '_m_last') else None + + self._m_last = (len(self.groups) - 1) + return self._m_last if hasattr(self, '_m_last') else None + + @property + def value(self): + """Resulting value as normal integer.""" + if hasattr(self, '_m_value'): + return self._m_value if hasattr(self, '_m_value') else None + + self._m_value = (((((((self.groups[self.last].value + ((self.groups[(self.last - 1)].value << 7) if self.last >= 1 else 0)) + ((self.groups[(self.last - 2)].value << 14) if self.last >= 2 else 0)) + ((self.groups[(self.last - 3)].value << 21) if self.last >= 3 else 0)) + ((self.groups[(self.last - 4)].value << 28) if self.last >= 4 else 0)) + ((self.groups[(self.last - 5)].value << 35) if self.last >= 5 else 0)) + ((self.groups[(self.last - 6)].value << 42) if self.last >= 6 else 0)) + ((self.groups[(self.last - 7)].value << 49) if self.last >= 7 else 0)) + return self._m_value if hasattr(self, '_m_value') else None + + diff --git a/python/examples/kaitai/kaitai_struct_formats/common/vlq_base128_le.py b/python/examples/kaitai/kaitai_struct_formats/common/vlq_base128_le.py new file mode 100644 index 00000000..ae49cffc --- /dev/null +++ b/python/examples/kaitai/kaitai_struct_formats/common/vlq_base128_le.py @@ -0,0 +1,109 @@ +from __future__ import absolute_import +# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild + +from pkg_resources import parse_version +from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO +import collections + + +if parse_version(ks_version) < parse_version('0.7'): + raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version)) + +class VlqBase128Le(KaitaiStruct): + """A variable-length unsigned integer using base128 encoding. 1-byte groups + consist of 1-bit flag of continuation and 7-bit value chunk, and are ordered + "least significant group first", i.e. in "little-endian" manner. + + This particular encoding is specified and used in: + + * DWARF debug file format, where it's dubbed "unsigned LEB128" or "ULEB128". + http://dwarfstd.org/doc/dwarf-2.0.0.pdf - page 139 + * Google Protocol Buffers, where it's called "Base 128 Varints". + https://developers.google.com/protocol-buffers/docs/encoding?csw=1#varints + * Apache Lucene, where it's called "VInt" + http://lucene.apache.org/core/3_5_0/fileformats.html#VInt + * Apache Avro uses this as a basis for integer encoding, adding ZigZag on + top of it for signed ints + http://avro.apache.org/docs/current/spec.html#binary_encode_primitive + + More information on this encoding is available at https://en.wikipedia.org/wiki/LEB128 + + This particular implementation supports serialized values to up 8 bytes long. + """ + SEQ_FIELDS = ["groups"] + def __init__(self, _io, _parent=None, _root=None): + self._io = _io + self._parent = _parent + self._root = _root if _root else self + self._debug = collections.defaultdict(dict) + + def _read(self): + self._debug['groups']['start'] = self._io.pos() + self.groups = [] + i = 0 + while True: + if not 'arr' in self._debug['groups']: + self._debug['groups']['arr'] = [] + self._debug['groups']['arr'].append({'start': self._io.pos()}) + _t_groups = self._root.Group(self._io, self, self._root) + _t_groups._read() + _ = _t_groups + self.groups.append(_) + self._debug['groups']['arr'][len(self.groups) - 1]['end'] = self._io.pos() + if not (_.has_next): + break + i += 1 + self._debug['groups']['end'] = self._io.pos() + + class Group(KaitaiStruct): + """One byte group, clearly divided into 7-bit "value" chunk and 1-bit "continuation" flag. + """ + SEQ_FIELDS = ["b"] + def __init__(self, _io, _parent=None, _root=None): + self._io = _io + self._parent = _parent + self._root = _root if _root else self + self._debug = collections.defaultdict(dict) + + def _read(self): + self._debug['b']['start'] = self._io.pos() + self.b = self._io.read_u1() + self._debug['b']['end'] = self._io.pos() + + @property + def has_next(self): + """If true, then we have more bytes to read.""" + if hasattr(self, '_m_has_next'): + return self._m_has_next if hasattr(self, '_m_has_next') else None + + self._m_has_next = (self.b & 128) != 0 + return self._m_has_next if hasattr(self, '_m_has_next') else None + + @property + def value(self): + """The 7-bit (base128) numeric value chunk of this group.""" + if hasattr(self, '_m_value'): + return self._m_value if hasattr(self, '_m_value') else None + + self._m_value = (self.b & 127) + return self._m_value if hasattr(self, '_m_value') else None + + + @property + def len(self): + if hasattr(self, '_m_len'): + return self._m_len if hasattr(self, '_m_len') else None + + self._m_len = len(self.groups) + return self._m_len if hasattr(self, '_m_len') else None + + @property + def value(self): + """Resulting value as normal integer.""" + if hasattr(self, '_m_value'): + return self._m_value if hasattr(self, '_m_value') else None + + self._m_value = (((((((self.groups[0].value + ((self.groups[1].value << 7) if self.len >= 2 else 0)) + ((self.groups[2].value << 14) if self.len >= 3 else 0)) + ((self.groups[3].value << 21) if self.len >= 4 else 0)) + ((self.groups[4].value << 28) if self.len >= 5 else 0)) + ((self.groups[5].value << 35) if self.len >= 6 else 0)) + ((self.groups[6].value << 42) if self.len >= 7 else 0)) + ((self.groups[7].value << 49) if self.len >= 8 else 0)) + return self._m_value if hasattr(self, '_m_value') else None + + |