polyfile-weave 0.5.5__py3-none-any.whl

polyfile/kaitai/parsers/gpt_partition_table.py

@@ -0,0 +1,175 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class GptPartitionTable(KaitaiStruct):
+    """
+    .. seealso::
+       Source - https://en.wikipedia.org/wiki/GUID_Partition_Table
+    """
+    SEQ_FIELDS = []
+    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):
+        pass
+
+    class PartitionEntry(KaitaiStruct):
+        SEQ_FIELDS = ["type_guid", "guid", "first_lba", "last_lba", "attributes", "name"]
+        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['type_guid']['start'] = self._io.pos()
+            self.type_guid = self._io.read_bytes(16)
+            self._debug['type_guid']['end'] = self._io.pos()
+            self._debug['guid']['start'] = self._io.pos()
+            self.guid = self._io.read_bytes(16)
+            self._debug['guid']['end'] = self._io.pos()
+            self._debug['first_lba']['start'] = self._io.pos()
+            self.first_lba = self._io.read_u8le()
+            self._debug['first_lba']['end'] = self._io.pos()
+            self._debug['last_lba']['start'] = self._io.pos()
+            self.last_lba = self._io.read_u8le()
+            self._debug['last_lba']['end'] = self._io.pos()
+            self._debug['attributes']['start'] = self._io.pos()
+            self.attributes = self._io.read_u8le()
+            self._debug['attributes']['end'] = self._io.pos()
+            self._debug['name']['start'] = self._io.pos()
+            self.name = (self._io.read_bytes(72)).decode(u"UTF-16LE")
+            self._debug['name']['end'] = self._io.pos()
+
+
+    class PartitionHeader(KaitaiStruct):
+        SEQ_FIELDS = ["signature", "revision", "header_size", "crc32_header", "reserved", "current_lba", "backup_lba", "first_usable_lba", "last_usable_lba", "disk_guid", "entries_start", "entries_count", "entries_size", "crc32_array"]
+        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['signature']['start'] = self._io.pos()
+            self.signature = self._io.read_bytes(8)
+            self._debug['signature']['end'] = self._io.pos()
+            if not self.signature == b"\x45\x46\x49\x20\x50\x41\x52\x54":
+                raise kaitaistruct.ValidationNotEqualError(b"\x45\x46\x49\x20\x50\x41\x52\x54", self.signature, self._io, u"/types/partition_header/seq/0")
+            self._debug['revision']['start'] = self._io.pos()
+            self.revision = self._io.read_u4le()
+            self._debug['revision']['end'] = self._io.pos()
+            self._debug['header_size']['start'] = self._io.pos()
+            self.header_size = self._io.read_u4le()
+            self._debug['header_size']['end'] = self._io.pos()
+            self._debug['crc32_header']['start'] = self._io.pos()
+            self.crc32_header = self._io.read_u4le()
+            self._debug['crc32_header']['end'] = self._io.pos()
+            self._debug['reserved']['start'] = self._io.pos()
+            self.reserved = self._io.read_u4le()
+            self._debug['reserved']['end'] = self._io.pos()
+            self._debug['current_lba']['start'] = self._io.pos()
+            self.current_lba = self._io.read_u8le()
+            self._debug['current_lba']['end'] = self._io.pos()
+            self._debug['backup_lba']['start'] = self._io.pos()
+            self.backup_lba = self._io.read_u8le()
+            self._debug['backup_lba']['end'] = self._io.pos()
+            self._debug['first_usable_lba']['start'] = self._io.pos()
+            self.first_usable_lba = self._io.read_u8le()
+            self._debug['first_usable_lba']['end'] = self._io.pos()
+            self._debug['last_usable_lba']['start'] = self._io.pos()
+            self.last_usable_lba = self._io.read_u8le()
+            self._debug['last_usable_lba']['end'] = self._io.pos()
+            self._debug['disk_guid']['start'] = self._io.pos()
+            self.disk_guid = self._io.read_bytes(16)
+            self._debug['disk_guid']['end'] = self._io.pos()
+            self._debug['entries_start']['start'] = self._io.pos()
+            self.entries_start = self._io.read_u8le()
+            self._debug['entries_start']['end'] = self._io.pos()
+            self._debug['entries_count']['start'] = self._io.pos()
+            self.entries_count = self._io.read_u4le()
+            self._debug['entries_count']['end'] = self._io.pos()
+            self._debug['entries_size']['start'] = self._io.pos()
+            self.entries_size = self._io.read_u4le()
+            self._debug['entries_size']['end'] = self._io.pos()
+            self._debug['crc32_array']['start'] = self._io.pos()
+            self.crc32_array = self._io.read_u4le()
+            self._debug['crc32_array']['end'] = self._io.pos()
+
+        @property
+        def entries(self):
+            if hasattr(self, '_m_entries'):
+                return self._m_entries if hasattr(self, '_m_entries') else None
+
+            io = self._root._io
+            _pos = io.pos()
+            io.seek((self.entries_start * self._root.sector_size))
+            self._debug['_m_entries']['start'] = io.pos()
+            self._raw__m_entries = [None] * (self.entries_count)
+            self._m_entries = [None] * (self.entries_count)
+            for i in range(self.entries_count):
+                if not 'arr' in self._debug['_m_entries']:
+                    self._debug['_m_entries']['arr'] = []
+                self._debug['_m_entries']['arr'].append({'start': io.pos()})
+                self._raw__m_entries[i] = io.read_bytes(self.entries_size)
+                _io__raw__m_entries = KaitaiStream(BytesIO(self._raw__m_entries[i]))
+                _t__m_entries = GptPartitionTable.PartitionEntry(_io__raw__m_entries, self, self._root)
+                _t__m_entries._read()
+                self._m_entries[i] = _t__m_entries
+                self._debug['_m_entries']['arr'][i]['end'] = io.pos()
+
+            self._debug['_m_entries']['end'] = io.pos()
+            io.seek(_pos)
+            return self._m_entries if hasattr(self, '_m_entries') else None
+
+
+    @property
+    def sector_size(self):
+        if hasattr(self, '_m_sector_size'):
+            return self._m_sector_size if hasattr(self, '_m_sector_size') else None
+
+        self._m_sector_size = 512
+        return self._m_sector_size if hasattr(self, '_m_sector_size') else None
+
+    @property
+    def primary(self):
+        if hasattr(self, '_m_primary'):
+            return self._m_primary if hasattr(self, '_m_primary') else None
+
+        io = self._root._io
+        _pos = io.pos()
+        io.seek(self._root.sector_size)
+        self._debug['_m_primary']['start'] = io.pos()
+        self._m_primary = GptPartitionTable.PartitionHeader(io, self, self._root)
+        self._m_primary._read()
+        self._debug['_m_primary']['end'] = io.pos()
+        io.seek(_pos)
+        return self._m_primary if hasattr(self, '_m_primary') else None
+
+    @property
+    def backup(self):
+        if hasattr(self, '_m_backup'):
+            return self._m_backup if hasattr(self, '_m_backup') else None
+
+        io = self._root._io
+        _pos = io.pos()
+        io.seek((self._io.size() - self._root.sector_size))
+        self._debug['_m_backup']['start'] = io.pos()
+        self._m_backup = GptPartitionTable.PartitionHeader(io, self, self._root)
+        self._m_backup._read()
+        self._debug['_m_backup']['end'] = io.pos()
+        io.seek(_pos)
+        return self._m_backup if hasattr(self, '_m_backup') else None
+
+

polyfile/kaitai/parsers/gran_turismo_vol.py

@@ -0,0 +1,140 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class GranTurismoVol(KaitaiStruct):
+    SEQ_FIELDS = ["magic", "num_files", "num_entries", "reserved", "offsets"]
+    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['magic']['start'] = self._io.pos()
+        self.magic = self._io.read_bytes(8)
+        self._debug['magic']['end'] = self._io.pos()
+        if not self.magic == b"\x47\x54\x46\x53\x00\x00\x00\x00":
+            raise kaitaistruct.ValidationNotEqualError(b"\x47\x54\x46\x53\x00\x00\x00\x00", self.magic, self._io, u"/seq/0")
+        self._debug['num_files']['start'] = self._io.pos()
+        self.num_files = self._io.read_u2le()
+        self._debug['num_files']['end'] = self._io.pos()
+        self._debug['num_entries']['start'] = self._io.pos()
+        self.num_entries = self._io.read_u2le()
+        self._debug['num_entries']['end'] = self._io.pos()
+        self._debug['reserved']['start'] = self._io.pos()
+        self.reserved = self._io.read_bytes(4)
+        self._debug['reserved']['end'] = self._io.pos()
+        if not self.reserved == b"\x00\x00\x00\x00":
+            raise kaitaistruct.ValidationNotEqualError(b"\x00\x00\x00\x00", self.reserved, self._io, u"/seq/3")
+        self._debug['offsets']['start'] = self._io.pos()
+        self.offsets = [None] * (self.num_files)
+        for i in range(self.num_files):
+            if not 'arr' in self._debug['offsets']:
+                self._debug['offsets']['arr'] = []
+            self._debug['offsets']['arr'].append({'start': self._io.pos()})
+            self.offsets[i] = self._io.read_u4le()
+            self._debug['offsets']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['offsets']['end'] = self._io.pos()
+
+    class FileInfo(KaitaiStruct):
+        SEQ_FIELDS = ["timestamp", "offset_idx", "flags", "name"]
+        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['timestamp']['start'] = self._io.pos()
+            self.timestamp = self._io.read_u4le()
+            self._debug['timestamp']['end'] = self._io.pos()
+            self._debug['offset_idx']['start'] = self._io.pos()
+            self.offset_idx = self._io.read_u2le()
+            self._debug['offset_idx']['end'] = self._io.pos()
+            self._debug['flags']['start'] = self._io.pos()
+            self.flags = self._io.read_u1()
+            self._debug['flags']['end'] = self._io.pos()
+            self._debug['name']['start'] = self._io.pos()
+            self.name = (KaitaiStream.bytes_terminate(KaitaiStream.bytes_strip_right(self._io.read_bytes(25), 0), 0, False)).decode(u"ASCII")
+            self._debug['name']['end'] = self._io.pos()
+
+        @property
+        def size(self):
+            if hasattr(self, '_m_size'):
+                return self._m_size if hasattr(self, '_m_size') else None
+
+            self._m_size = ((self._root.offsets[(self.offset_idx + 1)] & 4294965248) - self._root.offsets[self.offset_idx])
+            return self._m_size if hasattr(self, '_m_size') else None
+
+        @property
+        def body(self):
+            if hasattr(self, '_m_body'):
+                return self._m_body if hasattr(self, '_m_body') else None
+
+            if not (self.is_dir):
+                _pos = self._io.pos()
+                self._io.seek((self._root.offsets[self.offset_idx] & 4294965248))
+                self._debug['_m_body']['start'] = self._io.pos()
+                self._m_body = self._io.read_bytes(self.size)
+                self._debug['_m_body']['end'] = self._io.pos()
+                self._io.seek(_pos)
+
+            return self._m_body if hasattr(self, '_m_body') else None
+
+        @property
+        def is_dir(self):
+            if hasattr(self, '_m_is_dir'):
+                return self._m_is_dir if hasattr(self, '_m_is_dir') else None
+
+            self._m_is_dir = (self.flags & 1) != 0
+            return self._m_is_dir if hasattr(self, '_m_is_dir') else None
+
+        @property
+        def is_last_entry(self):
+            if hasattr(self, '_m_is_last_entry'):
+                return self._m_is_last_entry if hasattr(self, '_m_is_last_entry') else None
+
+            self._m_is_last_entry = (self.flags & 128) != 0
+            return self._m_is_last_entry if hasattr(self, '_m_is_last_entry') else None
+
+
+    @property
+    def ofs_dir(self):
+        if hasattr(self, '_m_ofs_dir'):
+            return self._m_ofs_dir if hasattr(self, '_m_ofs_dir') else None
+
+        self._m_ofs_dir = self.offsets[1]
+        return self._m_ofs_dir if hasattr(self, '_m_ofs_dir') else None
+
+    @property
+    def files(self):
+        if hasattr(self, '_m_files'):
+            return self._m_files if hasattr(self, '_m_files') else None
+
+        _pos = self._io.pos()
+        self._io.seek((self.ofs_dir & 4294965248))
+        self._debug['_m_files']['start'] = self._io.pos()
+        self._m_files = [None] * (self._root.num_entries)
+        for i in range(self._root.num_entries):
+            if not 'arr' in self._debug['_m_files']:
+                self._debug['_m_files']['arr'] = []
+            self._debug['_m_files']['arr'].append({'start': self._io.pos()})
+            _t__m_files = GranTurismoVol.FileInfo(self._io, self, self._root)
+            _t__m_files._read()
+            self._m_files[i] = _t__m_files
+            self._debug['_m_files']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['_m_files']['end'] = self._io.pos()
+        self._io.seek(_pos)
+        return self._m_files if hasattr(self, '_m_files') else None
+
+

polyfile/kaitai/parsers/grub2_font.py

@@ -0,0 +1,337 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class Grub2Font(KaitaiStruct):
+    """Bitmap font format for the GRUB 2 bootloader.
+    
+    .. seealso::
+       Source - https://grub.gibibit.com/New_font_format
+    """
+    SEQ_FIELDS = ["magic", "sections"]
+    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['magic']['start'] = self._io.pos()
+        self.magic = self._io.read_bytes(12)
+        self._debug['magic']['end'] = self._io.pos()
+        if not self.magic == b"\x46\x49\x4C\x45\x00\x00\x00\x04\x50\x46\x46\x32":
+            raise kaitaistruct.ValidationNotEqualError(b"\x46\x49\x4C\x45\x00\x00\x00\x04\x50\x46\x46\x32", self.magic, self._io, u"/seq/0")
+        self._debug['sections']['start'] = self._io.pos()
+        self.sections = []
+        i = 0
+        while True:
+            if not 'arr' in self._debug['sections']:
+                self._debug['sections']['arr'] = []
+            self._debug['sections']['arr'].append({'start': self._io.pos()})
+            _t_sections = Grub2Font.Section(self._io, self, self._root)
+            _t_sections._read()
+            _ = _t_sections
+            self.sections.append(_)
+            self._debug['sections']['arr'][len(self.sections) - 1]['end'] = self._io.pos()
+            if _.section_type == u"DATA":
+                break
+            i += 1
+        self._debug['sections']['end'] = self._io.pos()
+
+    class PtszSection(KaitaiStruct):
+        SEQ_FIELDS = ["font_point_size"]
+        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['font_point_size']['start'] = self._io.pos()
+            self.font_point_size = self._io.read_u2be()
+            self._debug['font_point_size']['end'] = self._io.pos()
+
+
+    class FamiSection(KaitaiStruct):
+        SEQ_FIELDS = ["font_family_name"]
+        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['font_family_name']['start'] = self._io.pos()
+            self.font_family_name = (self._io.read_bytes_term(0, False, True, True)).decode(u"ASCII")
+            self._debug['font_family_name']['end'] = self._io.pos()
+
+
+    class WeigSection(KaitaiStruct):
+        SEQ_FIELDS = ["font_weight"]
+        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['font_weight']['start'] = self._io.pos()
+            self.font_weight = (self._io.read_bytes_term(0, False, True, True)).decode(u"ASCII")
+            self._debug['font_weight']['end'] = self._io.pos()
+
+
+    class MaxwSection(KaitaiStruct):
+        SEQ_FIELDS = ["maximum_character_width"]
+        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['maximum_character_width']['start'] = self._io.pos()
+            self.maximum_character_width = self._io.read_u2be()
+            self._debug['maximum_character_width']['end'] = self._io.pos()
+
+
+    class DescSection(KaitaiStruct):
+        SEQ_FIELDS = ["descent_in_pixels"]
+        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['descent_in_pixels']['start'] = self._io.pos()
+            self.descent_in_pixels = self._io.read_u2be()
+            self._debug['descent_in_pixels']['end'] = self._io.pos()
+
+
+    class Section(KaitaiStruct):
+        SEQ_FIELDS = ["section_type", "len_body", "body"]
+        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['section_type']['start'] = self._io.pos()
+            self.section_type = (self._io.read_bytes(4)).decode(u"ASCII")
+            self._debug['section_type']['end'] = self._io.pos()
+            self._debug['len_body']['start'] = self._io.pos()
+            self.len_body = self._io.read_u4be()
+            self._debug['len_body']['end'] = self._io.pos()
+            if self.section_type != u"DATA":
+                self._debug['body']['start'] = self._io.pos()
+                _on = self.section_type
+                if _on == u"MAXH":
+                    self._raw_body = self._io.read_bytes(self.len_body)
+                    _io__raw_body = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = Grub2Font.MaxhSection(_io__raw_body, self, self._root)
+                    self.body._read()
+                elif _on == u"FAMI":
+                    self._raw_body = self._io.read_bytes(self.len_body)
+                    _io__raw_body = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = Grub2Font.FamiSection(_io__raw_body, self, self._root)
+                    self.body._read()
+                elif _on == u"PTSZ":
+                    self._raw_body = self._io.read_bytes(self.len_body)
+                    _io__raw_body = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = Grub2Font.PtszSection(_io__raw_body, self, self._root)
+                    self.body._read()
+                elif _on == u"MAXW":
+                    self._raw_body = self._io.read_bytes(self.len_body)
+                    _io__raw_body = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = Grub2Font.MaxwSection(_io__raw_body, self, self._root)
+                    self.body._read()
+                elif _on == u"SLAN":
+                    self._raw_body = self._io.read_bytes(self.len_body)
+                    _io__raw_body = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = Grub2Font.SlanSection(_io__raw_body, self, self._root)
+                    self.body._read()
+                elif _on == u"WEIG":
+                    self._raw_body = self._io.read_bytes(self.len_body)
+                    _io__raw_body = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = Grub2Font.WeigSection(_io__raw_body, self, self._root)
+                    self.body._read()
+                elif _on == u"CHIX":
+                    self._raw_body = self._io.read_bytes(self.len_body)
+                    _io__raw_body = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = Grub2Font.ChixSection(_io__raw_body, self, self._root)
+                    self.body._read()
+                elif _on == u"DESC":
+                    self._raw_body = self._io.read_bytes(self.len_body)
+                    _io__raw_body = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = Grub2Font.DescSection(_io__raw_body, self, self._root)
+                    self.body._read()
+                elif _on == u"NAME":
+                    self._raw_body = self._io.read_bytes(self.len_body)
+                    _io__raw_body = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = Grub2Font.NameSection(_io__raw_body, self, self._root)
+                    self.body._read()
+                elif _on == u"ASCE":
+                    self._raw_body = self._io.read_bytes(self.len_body)
+                    _io__raw_body = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = Grub2Font.AsceSection(_io__raw_body, self, self._root)
+                    self.body._read()
+                else:
+                    self.body = self._io.read_bytes(self.len_body)
+                self._debug['body']['end'] = self._io.pos()
+
+
+
+    class AsceSection(KaitaiStruct):
+        SEQ_FIELDS = ["ascent_in_pixels"]
+        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['ascent_in_pixels']['start'] = self._io.pos()
+            self.ascent_in_pixels = self._io.read_u2be()
+            self._debug['ascent_in_pixels']['end'] = self._io.pos()
+
+
+    class ChixSection(KaitaiStruct):
+        SEQ_FIELDS = ["characters"]
+        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['characters']['start'] = self._io.pos()
+            self.characters = []
+            i = 0
+            while not self._io.is_eof():
+                if not 'arr' in self._debug['characters']:
+                    self._debug['characters']['arr'] = []
+                self._debug['characters']['arr'].append({'start': self._io.pos()})
+                _t_characters = Grub2Font.ChixSection.Character(self._io, self, self._root)
+                _t_characters._read()
+                self.characters.append(_t_characters)
+                self._debug['characters']['arr'][len(self.characters) - 1]['end'] = self._io.pos()
+                i += 1
+
+            self._debug['characters']['end'] = self._io.pos()
+
+        class Character(KaitaiStruct):
+            SEQ_FIELDS = ["code_point", "flags", "ofs_definition"]
+            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['code_point']['start'] = self._io.pos()
+                self.code_point = self._io.read_u4be()
+                self._debug['code_point']['end'] = self._io.pos()
+                self._debug['flags']['start'] = self._io.pos()
+                self.flags = self._io.read_u1()
+                self._debug['flags']['end'] = self._io.pos()
+                self._debug['ofs_definition']['start'] = self._io.pos()
+                self.ofs_definition = self._io.read_u4be()
+                self._debug['ofs_definition']['end'] = self._io.pos()
+
+            @property
+            def definition(self):
+                if hasattr(self, '_m_definition'):
+                    return self._m_definition if hasattr(self, '_m_definition') else None
+
+                io = self._root._io
+                _pos = io.pos()
+                io.seek(self.ofs_definition)
+                self._debug['_m_definition']['start'] = io.pos()
+                self._m_definition = Grub2Font.ChixSection.CharacterDefinition(io, self, self._root)
+                self._m_definition._read()
+                self._debug['_m_definition']['end'] = io.pos()
+                io.seek(_pos)
+                return self._m_definition if hasattr(self, '_m_definition') else None
+
+
+        class CharacterDefinition(KaitaiStruct):
+            SEQ_FIELDS = ["width", "height", "x_offset", "y_offset", "device_width", "bitmap_data"]
+            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['width']['start'] = self._io.pos()
+                self.width = self._io.read_u2be()
+                self._debug['width']['end'] = self._io.pos()
+                self._debug['height']['start'] = self._io.pos()
+                self.height = self._io.read_u2be()
+                self._debug['height']['end'] = self._io.pos()
+                self._debug['x_offset']['start'] = self._io.pos()
+                self.x_offset = self._io.read_s2be()
+                self._debug['x_offset']['end'] = self._io.pos()
+                self._debug['y_offset']['start'] = self._io.pos()
+                self.y_offset = self._io.read_s2be()
+                self._debug['y_offset']['end'] = self._io.pos()
+                self._debug['device_width']['start'] = self._io.pos()
+                self.device_width = self._io.read_s2be()
+                self._debug['device_width']['end'] = self._io.pos()
+                self._debug['bitmap_data']['start'] = self._io.pos()
+                self.bitmap_data = self._io.read_bytes(((self.width * self.height) + 7) // 8)
+                self._debug['bitmap_data']['end'] = self._io.pos()
+
+
+
+    class MaxhSection(KaitaiStruct):
+        SEQ_FIELDS = ["maximum_character_height"]
+        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['maximum_character_height']['start'] = self._io.pos()
+            self.maximum_character_height = self._io.read_u2be()
+            self._debug['maximum_character_height']['end'] = self._io.pos()
+
+
+    class NameSection(KaitaiStruct):
+        SEQ_FIELDS = ["font_name"]
+        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['font_name']['start'] = self._io.pos()
+            self.font_name = (self._io.read_bytes_term(0, False, True, True)).decode(u"ASCII")
+            self._debug['font_name']['end'] = self._io.pos()
+
+
+    class SlanSection(KaitaiStruct):
+        SEQ_FIELDS = ["font_slant"]
+        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['font_slant']['start'] = self._io.pos()
+            self.font_slant = (self._io.read_bytes_term(0, False, True, True)).decode(u"ASCII")
+            self._debug['font_slant']['end'] = self._io.pos()
+
+
+