kaitai: adjustments and rearrangements for python2/3 compat

1 files changed, 459 insertions, 0 deletions

diff --git a/python/examples/kaitai/wmf.py b/python/examples/kaitai/wmf.py
new file mode 100644
index 00000000..6cb1c74e
--- /dev/null
+++ b/python/examples/kaitai/wmf.py
@@ -0,0 +1,459 @@
+# 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
+from enum import Enum
+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 Wmf(KaitaiStruct):
+    """WMF (Windows Metafile) is a relatively early vector image format
+    introduced for Microsoft Windows in 1990.
+    
+    Inside, it provides a serialized list of Windows GDI (Graphics
+    Device Interface) function calls, which, if played back, result in
+    an image being drawn on a given surface (display, off-screen buffer,
+    printer, etc).
+    
+    .. seealso::
+       Source - http://www.digitalpreservation.gov/formats/digformatspecs/WindowsMetafileFormat(wmf)Specification.pdf
+    """
+
+    class Func(Enum):
+        eof = 0
+        savedc = 30
+        realizepalette = 53
+        setpalentries = 55
+        createpalette = 247
+        setbkmode = 258
+        setmapmode = 259
+        setrop2 = 260
+        setrelabs = 261
+        setpolyfillmode = 262
+        setstretchbltmode = 263
+        settextcharextra = 264
+        restoredc = 295
+        invertregion = 298
+        paintregion = 299
+        selectclipregion = 300
+        selectobject = 301
+        settextalign = 302
+        resizepalette = 313
+        dibcreatepatternbrush = 322
+        setlayout = 329
+        deleteobject = 496
+        createpatternbrush = 505
+        setbkcolor = 513
+        settextcolor = 521
+        settextjustification = 522
+        setwindoworg = 523
+        setwindowext = 524
+        setviewportorg = 525
+        setviewportext = 526
+        offsetwindoworg = 527
+        offsetviewportorg = 529
+        lineto = 531
+        moveto = 532
+        offsetcliprgn = 544
+        fillregion = 552
+        setmapperflags = 561
+        selectpalette = 564
+        createpenindirect = 762
+        createfontindirect = 763
+        createbrushindirect = 764
+        polygon = 804
+        polyline = 805
+        scalewindowext = 1040
+        scaleviewportext = 1042
+        excludecliprect = 1045
+        intersectcliprect = 1046
+        ellipse = 1048
+        floodfill = 1049
+        rectangle = 1051
+        setpixel = 1055
+        frameregion = 1065
+        animatepalette = 1078
+        textout = 1313
+        polypolygon = 1336
+        extfloodfill = 1352
+        roundrect = 1564
+        patblt = 1565
+        escape = 1574
+        createregion = 1791
+        arc = 2071
+        pie = 2074
+        chord = 2096
+        bitblt = 2338
+        dibbitblt = 2368
+        exttextout = 2610
+        stretchblt = 2851
+        dibstretchblt = 2881
+        setdibtodev = 3379
+        stretchdib = 3907
+
+    class BinRasterOp(Enum):
+        black = 1
+        notmergepen = 2
+        masknotpen = 3
+        notcopypen = 4
+        maskpennot = 5
+        not_ = 6
+        xorpen = 7
+        notmaskpen = 8
+        maskpen = 9
+        notxorpen = 10
+        nop = 11
+        mergenotpen = 12
+        copypen = 13
+        mergepennot = 14
+        mergepen = 15
+        white = 16
+
+    class MixMode(Enum):
+        transparent = 1
+        opaque = 2
+
+    class PolyFillMode(Enum):
+        alternate = 1
+        winding = 2
+    SEQ_FIELDS = ["special_header", "header", "records"]
+    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['special_header']['start'] = self._io.pos()
+        self.special_header = self._root.SpecialHeader(self._io, self, self._root)
+        self.special_header._read()
+        self._debug['special_header']['end'] = self._io.pos()
+        self._debug['header']['start'] = self._io.pos()
+        self.header = self._root.Header(self._io, self, self._root)
+        self.header._read()
+        self._debug['header']['end'] = self._io.pos()
+        self._debug['records']['start'] = self._io.pos()
+        self.records = []
+        i = 0
+        while True:
+            if not 'arr' in self._debug['records']:
+                self._debug['records']['arr'] = []
+            self._debug['records']['arr'].append({'start': self._io.pos()})
+            _t_records = self._root.Record(self._io, self, self._root)
+            _t_records._read()
+            _ = _t_records
+            self.records.append(_)
+            self._debug['records']['arr'][len(self.records) - 1]['end'] = self._io.pos()
+            if _.function == self._root.Func.eof:
+                break
+            i += 1
+        self._debug['records']['end'] = self._io.pos()
+
+    class ParamsSetwindoworg(KaitaiStruct):
+        SEQ_FIELDS = ["y", "x"]
+        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['y']['start'] = self._io.pos()
+            self.y = self._io.read_s2le()
+            self._debug['y']['end'] = self._io.pos()
+            self._debug['x']['start'] = self._io.pos()
+            self.x = self._io.read_s2le()
+            self._debug['x']['end'] = self._io.pos()
+
+
+    class ParamsSetbkmode(KaitaiStruct):
+        SEQ_FIELDS = ["bk_mode"]
+        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['bk_mode']['start'] = self._io.pos()
+            self.bk_mode = KaitaiStream.resolve_enum(self._root.MixMode, self._io.read_u2le())
+            self._debug['bk_mode']['end'] = self._io.pos()
+
+
+    class PointS(KaitaiStruct):
+        SEQ_FIELDS = ["x", "y"]
+        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['x']['start'] = self._io.pos()
+            self.x = self._io.read_s2le()
+            self._debug['x']['end'] = self._io.pos()
+            self._debug['y']['start'] = self._io.pos()
+            self.y = self._io.read_s2le()
+            self._debug['y']['end'] = self._io.pos()
+
+
+    class ParamsSetwindowext(KaitaiStruct):
+        SEQ_FIELDS = ["y", "x"]
+        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['y']['start'] = self._io.pos()
+            self.y = self._io.read_s2le()
+            self._debug['y']['end'] = self._io.pos()
+            self._debug['x']['start'] = self._io.pos()
+            self.x = self._io.read_s2le()
+            self._debug['x']['end'] = self._io.pos()
+
+
+    class ParamsPolygon(KaitaiStruct):
+        SEQ_FIELDS = ["num_points", "points"]
+        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['num_points']['start'] = self._io.pos()
+            self.num_points = self._io.read_s2le()
+            self._debug['num_points']['end'] = self._io.pos()
+            self._debug['points']['start'] = self._io.pos()
+            self.points = [None] * (self.num_points)
+            for i in range(self.num_points):
+                if not 'arr' in self._debug['points']:
+                    self._debug['points']['arr'] = []
+                self._debug['points']['arr'].append({'start': self._io.pos()})
+                _t_points = self._root.PointS(self._io, self, self._root)
+                _t_points._read()
+                self.points[i] = _t_points
+                self._debug['points']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['points']['end'] = self._io.pos()
+
+
+    class Header(KaitaiStruct):
+
+        class MetafileType(Enum):
+            memory_metafile = 1
+            disk_metafile = 2
+        SEQ_FIELDS = ["metafile_type", "header_size", "version", "size", "number_of_objects", "max_record", "number_of_members"]
+        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['metafile_type']['start'] = self._io.pos()
+            self.metafile_type = KaitaiStream.resolve_enum(self._root.Header.MetafileType, self._io.read_u2le())
+            self._debug['metafile_type']['end'] = self._io.pos()
+            self._debug['header_size']['start'] = self._io.pos()
+            self.header_size = self._io.read_u2le()
+            self._debug['header_size']['end'] = self._io.pos()
+            self._debug['version']['start'] = self._io.pos()
+            self.version = self._io.read_u2le()
+            self._debug['version']['end'] = self._io.pos()
+            self._debug['size']['start'] = self._io.pos()
+            self.size = self._io.read_u4le()
+            self._debug['size']['end'] = self._io.pos()
+            self._debug['number_of_objects']['start'] = self._io.pos()
+            self.number_of_objects = self._io.read_u2le()
+            self._debug['number_of_objects']['end'] = self._io.pos()
+            self._debug['max_record']['start'] = self._io.pos()
+            self.max_record = self._io.read_u4le()
+            self._debug['max_record']['end'] = self._io.pos()
+            self._debug['number_of_members']['start'] = self._io.pos()
+            self.number_of_members = self._io.read_u2le()
+            self._debug['number_of_members']['end'] = self._io.pos()
+
+
+    class ColorRef(KaitaiStruct):
+        SEQ_FIELDS = ["red", "green", "blue", "reserved"]
+        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['red']['start'] = self._io.pos()
+            self.red = self._io.read_u1()
+            self._debug['red']['end'] = self._io.pos()
+            self._debug['green']['start'] = self._io.pos()
+            self.green = self._io.read_u1()
+            self._debug['green']['end'] = self._io.pos()
+            self._debug['blue']['start'] = self._io.pos()
+            self.blue = self._io.read_u1()
+            self._debug['blue']['end'] = self._io.pos()
+            self._debug['reserved']['start'] = self._io.pos()
+            self.reserved = self._io.read_u1()
+            self._debug['reserved']['end'] = self._io.pos()
+
+
+    class ParamsSetrop2(KaitaiStruct):
+        SEQ_FIELDS = ["draw_mode"]
+        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['draw_mode']['start'] = self._io.pos()
+            self.draw_mode = KaitaiStream.resolve_enum(self._root.BinRasterOp, self._io.read_u2le())
+            self._debug['draw_mode']['end'] = self._io.pos()
+
+
+    class ParamsSetpolyfillmode(KaitaiStruct):
+        SEQ_FIELDS = ["poly_fill_mode"]
+        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['poly_fill_mode']['start'] = self._io.pos()
+            self.poly_fill_mode = KaitaiStream.resolve_enum(self._root.PolyFillMode, self._io.read_u2le())
+            self._debug['poly_fill_mode']['end'] = self._io.pos()
+
+
+    class ParamsPolyline(KaitaiStruct):
+        SEQ_FIELDS = ["num_points", "points"]
+        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['num_points']['start'] = self._io.pos()
+            self.num_points = self._io.read_s2le()
+            self._debug['num_points']['end'] = self._io.pos()
+            self._debug['points']['start'] = self._io.pos()
+            self.points = [None] * (self.num_points)
+            for i in range(self.num_points):
+                if not 'arr' in self._debug['points']:
+                    self._debug['points']['arr'] = []
+                self._debug['points']['arr'].append({'start': self._io.pos()})
+                _t_points = self._root.PointS(self._io, self, self._root)
+                _t_points._read()
+                self.points[i] = _t_points
+                self._debug['points']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['points']['end'] = self._io.pos()
+
+
+    class SpecialHeader(KaitaiStruct):
+        SEQ_FIELDS = ["magic", "handle", "left", "top", "right", "bottom", "inch", "reserved", "checksum"]
+        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.ensure_fixed_contents(b"\xD7\xCD\xC6\x9A")
+            self._debug['magic']['end'] = self._io.pos()
+            self._debug['handle']['start'] = self._io.pos()
+            self.handle = self._io.ensure_fixed_contents(b"\x00\x00")
+            self._debug['handle']['end'] = self._io.pos()
+            self._debug['left']['start'] = self._io.pos()
+            self.left = self._io.read_s2le()
+            self._debug['left']['end'] = self._io.pos()
+            self._debug['top']['start'] = self._io.pos()
+            self.top = self._io.read_s2le()
+            self._debug['top']['end'] = self._io.pos()
+            self._debug['right']['start'] = self._io.pos()
+            self.right = self._io.read_s2le()
+            self._debug['right']['end'] = self._io.pos()
+            self._debug['bottom']['start'] = self._io.pos()
+            self.bottom = self._io.read_s2le()
+            self._debug['bottom']['end'] = self._io.pos()
+            self._debug['inch']['start'] = self._io.pos()
+            self.inch = self._io.read_u2le()
+            self._debug['inch']['end'] = self._io.pos()
+            self._debug['reserved']['start'] = self._io.pos()
+            self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00")
+            self._debug['reserved']['end'] = self._io.pos()
+            self._debug['checksum']['start'] = self._io.pos()
+            self.checksum = self._io.read_u2le()
+            self._debug['checksum']['end'] = self._io.pos()
+
+
+    class Record(KaitaiStruct):
+        SEQ_FIELDS = ["size", "function", "params"]
+        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['size']['start'] = self._io.pos()
+            self.size = self._io.read_u4le()
+            self._debug['size']['end'] = self._io.pos()
+            self._debug['function']['start'] = self._io.pos()
+            self.function = KaitaiStream.resolve_enum(self._root.Func, self._io.read_u2le())
+            self._debug['function']['end'] = self._io.pos()
+            self._debug['params']['start'] = self._io.pos()
+            _on = self.function
+            if _on == self._root.Func.setbkmode:
+                self._raw_params = self._io.read_bytes(((self.size - 3) * 2))
+                io = KaitaiStream(BytesIO(self._raw_params))
+                self.params = self._root.ParamsSetbkmode(io, self, self._root)
+                self.params._read()
+            elif _on == self._root.Func.polygon:
+                self._raw_params = self._io.read_bytes(((self.size - 3) * 2))
+                io = KaitaiStream(BytesIO(self._raw_params))
+                self.params = self._root.ParamsPolygon(io, self, self._root)
+                self.params._read()
+            elif _on == self._root.Func.setbkcolor:
+                self._raw_params = self._io.read_bytes(((self.size - 3) * 2))
+                io = KaitaiStream(BytesIO(self._raw_params))
+                self.params = self._root.ColorRef(io, self, self._root)
+                self.params._read()
+            elif _on == self._root.Func.setpolyfillmode:
+                self._raw_params = self._io.read_bytes(((self.size - 3) * 2))
+                io = KaitaiStream(BytesIO(self._raw_params))
+                self.params = self._root.ParamsSetpolyfillmode(io, self, self._root)
+                self.params._read()
+            elif _on == self._root.Func.setwindoworg:
+                self._raw_params = self._io.read_bytes(((self.size - 3) * 2))
+                io = KaitaiStream(BytesIO(self._raw_params))
+                self.params = self._root.ParamsSetwindoworg(io, self, self._root)
+                self.params._read()
+            elif _on == self._root.Func.setrop2:
+                self._raw_params = self._io.read_bytes(((self.size - 3) * 2))
+                io = KaitaiStream(BytesIO(self._raw_params))
+                self.params = self._root.ParamsSetrop2(io, self, self._root)
+                self.params._read()
+            elif _on == self._root.Func.setwindowext:
+                self._raw_params = self._io.read_bytes(((self.size - 3) * 2))
+                io = KaitaiStream(BytesIO(self._raw_params))
+                self.params = self._root.ParamsSetwindowext(io, self, self._root)
+                self.params._read()
+            elif _on == self._root.Func.polyline:
+                self._raw_params = self._io.read_bytes(((self.size - 3) * 2))
+                io = KaitaiStream(BytesIO(self._raw_params))
+                self.params = self._root.ParamsPolyline(io, self, self._root)
+                self.params._read()
+            else:
+                self.params = self._io.read_bytes(((self.size - 3) * 2))
+            self._debug['params']['end'] = self._io.pos()
+
+
+