Regen master kaitai-io/kaitai_struct@8c33def

Author: kaitai-bot

compiled/construct/bits_byte_aligned.py

@@ -1,16 +1,23 @@
 from construct import *
 from construct.lib import *
 
+bits_byte_aligned__foo = Struct(
+	'inner' / ???,
+)
+
 bits_byte_aligned = Struct(
 	'one' / ???,
 	'byte_1' / Int8ub,
 	'two' / ???,
 	'three' / ???,
-	'byte_2' / Int8ub,
+	'byte_2' / FixedSized(1, GreedyBytes),
 	'four' / ???,
-	'byte_3' / FixedSized(1, GreedyBytes),
+	'byte_3' / FixedSized(3, LazyBound(lambda: bits_byte_aligned__foo)),
 	'full_byte' / ???,
 	'byte_4' / Int8ub,
+	'five' / ???,
+	'bytes_term' / NullTerminated(GreedyBytes, term=b"\x45", include=True, consume=True),
+	'six' / ???,
 )
 
 _schema = bits_byte_aligned

compiled/construct/eof_exception_switch_user.py

@@ -0,0 +1,17 @@
+from construct import *
+from construct.lib import *
+
+eof_exception_switch_user__one = Struct(
+	'val' / Int16sl,
+)
+
+eof_exception_switch_user__two = Struct(
+	'val' / Int16ul,
+)
+
+eof_exception_switch_user = Struct(
+	'code' / Int16ul,
+	'data' / Switch(this.code, {2: LazyBound(lambda: eof_exception_switch_user__two), 511: LazyBound(lambda: eof_exception_switch_user__one), }),
+)
+
+_schema = eof_exception_switch_user

compiled/construct/repeat_eos_bits_b1.py

@@ -0,0 +1,8 @@
+from construct import *
+from construct.lib import *
+
+repeat_eos_bits_b1 = Struct(
+	'bits' / GreedyRange(???),
+)
+
+_schema = repeat_eos_bits_b1

compiled/construct/repeat_eos_bit.py compiled/construct/repeat_eos_bits_b4.pycompiled/construct/repeat_eos_bit.py renamed to compiled/construct/repeat_eos_bits_b4.py

@@ -1,8 +1,8 @@
 from construct import *
 from construct.lib import *
 
-repeat_eos_bit = Struct(
+repeat_eos_bits_b4 = Struct(
 	'nibbles' / GreedyRange(???),
 )
 
-_schema = repeat_eos_bit
+_schema = repeat_eos_bits_b4

compiled/construct/switch_repeat_expr.py

@@ -10,9 +10,8 @@
 )
 
 switch_repeat_expr = Struct(
-	'code' / Int8ub,
-	'size' / Int32ul,
-	'body' / Array(1, Switch(this.code, {17: FixedSized(this.size, LazyBound(lambda: switch_repeat_expr__one)), 34: FixedSized(this.size, LazyBound(lambda: switch_repeat_expr__two)), }, default=FixedSized(this.size, GreedyBytes))),
+	'codes' / Array(3, Int8ub),
+	'body' / Array(3, Switch(this.codes[i], {1: FixedSized(4, LazyBound(lambda: switch_repeat_expr__one)), 2: FixedSized(4, LazyBound(lambda: switch_repeat_expr__one)), 7: FixedSized(4, LazyBound(lambda: switch_repeat_expr__two)), }, default=FixedSized(4, GreedyBytes))),
 )
 
 _schema = switch_repeat_expr

compiled/construct/switch_repeat_expr_invalid.py

@@ -10,9 +10,8 @@
 )
 
 switch_repeat_expr_invalid = Struct(
-	'code' / Int8ub,
-	'size' / Int32ul,
-	'body' / Array(1, Switch(this.code, {255: FixedSized(this.size, LazyBound(lambda: switch_repeat_expr_invalid__one)), 34: FixedSized(this.size, LazyBound(lambda: switch_repeat_expr_invalid__two)), }, default=FixedSized(this.size, GreedyBytes))),
+	'codes' / Array(3, Int8ub),
+	'body' / Array(3, Switch(this.codes[i], {1: FixedSized(4, LazyBound(lambda: switch_repeat_expr_invalid__one)), 2: FixedSized(4, LazyBound(lambda: switch_repeat_expr_invalid__two)), }, default=FixedSized(4, GreedyBytes))),
 )
 
 _schema = switch_repeat_expr_invalid

compiled/cpp_stl_11/bits_byte_aligned.cpp

@@ -5,6 +5,8 @@
 bits_byte_aligned_t::bits_byte_aligned_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent, bits_byte_aligned_t* p__root) : kaitai::kstruct(p__io) {
     m__parent = p__parent;
     m__root = p__root ? p__root : this;
+    m_byte_3 = nullptr;
+    m__io__raw_byte_3 = nullptr;
     _read();
 }
 
@@ -13,11 +15,16 @@ void bits_byte_aligned_t::_read() {
     m_byte_1 = m__io->read_u1();
     m_two = m__io->read_bits_int_be(3);
     m_three = m__io->read_bits_int_be(1);
-    m_byte_2 = m__io->read_u1();
+    m_byte_2 = m__io->read_bytes(1);
     m_four = m__io->read_bits_int_be(14);
-    m_byte_3 = m__io->read_bytes(1);
+    m__raw_byte_3 = m__io->read_bytes(3);
+    m__io__raw_byte_3 = std::unique_ptr<kaitai::kstream>(new kaitai::kstream(m__raw_byte_3));
+    m_byte_3 = std::unique_ptr<foo_t>(new foo_t(m__io__raw_byte_3.get(), this, m__root));
     m_full_byte = m__io->read_bits_int_be(8);
     m_byte_4 = m__io->read_u1();
+    m_five = m__io->read_bits_int_be(22);
+    m_bytes_term = m__io->read_bytes_term(69, true, true, true);
+    m_six = m__io->read_bits_int_be(8);
 }
 
 bits_byte_aligned_t::~bits_byte_aligned_t() {
@@ -26,3 +33,20 @@ bits_byte_aligned_t::~bits_byte_aligned_t() {
 
 void bits_byte_aligned_t::_clean_up() {
 }
+
+bits_byte_aligned_t::foo_t::foo_t(kaitai::kstream* p__io, bits_byte_aligned_t* p__parent, bits_byte_aligned_t* p__root) : kaitai::kstruct(p__io) {
+    m__parent = p__parent;
+    m__root = p__root;
+    _read();
+}
+
+void bits_byte_aligned_t::foo_t::_read() {
+    m_inner = m__io->read_bits_int_be(19);
+}
+
+bits_byte_aligned_t::foo_t::~foo_t() {
+    _clean_up();
+}
+
+void bits_byte_aligned_t::foo_t::_clean_up() {
+}

compiled/cpp_stl_11/bits_byte_aligned.h

@@ -15,6 +15,7 @@ class bits_byte_aligned_t;
 class bits_byte_aligned_t : public kaitai::kstruct {
 
 public:
+    class foo_t;
 
     bits_byte_aligned_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent = nullptr, bits_byte_aligned_t* p__root = nullptr);
 
@@ -24,28 +25,62 @@ class bits_byte_aligned_t : public kaitai::kstruct {
 
 public:
     ~bits_byte_aligned_t();
+
+    class foo_t : public kaitai::kstruct {
+
+    public:
+
+        foo_t(kaitai::kstream* p__io, bits_byte_aligned_t* p__parent = nullptr, bits_byte_aligned_t* p__root = nullptr);
+
+    private:
+        void _read();
+        void _clean_up();
+
+    public:
+        ~foo_t();
+        uint64_t inner() const { return m_inner; }
+        bits_byte_aligned_t* _root() const { return m__root; }
+        bits_byte_aligned_t* _parent() const { return m__parent; }
+
+    private:
+        uint64_t m_inner;
+        bits_byte_aligned_t* m__root;
+        bits_byte_aligned_t* m__parent;
+    };
+
+public:
     uint64_t one() const { return m_one; }
     uint8_t byte_1() const { return m_byte_1; }
     uint64_t two() const { return m_two; }
     bool three() const { return m_three; }
-    uint8_t byte_2() const { return m_byte_2; }
+    std::string byte_2() const { return m_byte_2; }
     uint64_t four() const { return m_four; }
-    std::string byte_3() const { return m_byte_3; }
+    foo_t* byte_3() const { return m_byte_3.get(); }
     uint64_t full_byte() const { return m_full_byte; }
     uint8_t byte_4() const { return m_byte_4; }
+    uint64_t five() const { return m_five; }
+    std::string bytes_term() const { return m_bytes_term; }
+    uint64_t six() const { return m_six; }
     bits_byte_aligned_t* _root() const { return m__root; }
     kaitai::kstruct* _parent() const { return m__parent; }
+    std::string _raw_byte_3() const { return m__raw_byte_3; }
+    kaitai::kstream* _io__raw_byte_3() const { return m__io__raw_byte_3.get(); }
 
 private:
     uint64_t m_one;
     uint8_t m_byte_1;
     uint64_t m_two;
     bool m_three;
-    uint8_t m_byte_2;
+    std::string m_byte_2;
     uint64_t m_four;
-    std::string m_byte_3;
+    std::unique_ptr<foo_t> m_byte_3;
     uint64_t m_full_byte;
     uint8_t m_byte_4;
+    uint64_t m_five;
+    std::string m_bytes_term;
+    uint64_t m_six;
     bits_byte_aligned_t* m__root;
     kaitai::kstruct* m__parent;
+    std::string m__raw_byte_3;
+    std::unique_ptr<kaitai::kstream> m__io__raw_byte_3;
 };

compiled/cpp_stl_11/eof_exception_switch_user.cpp

@@ -0,0 +1,69 @@
+// This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+#include "eof_exception_switch_user.h"
+
+eof_exception_switch_user_t::eof_exception_switch_user_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent, eof_exception_switch_user_t* p__root) : kaitai::kstruct(p__io) {
+    m__parent = p__parent;
+    m__root = p__root ? p__root : this;
+    _read();
+}
+
+void eof_exception_switch_user_t::_read() {
+    m_code = m__io->read_u2le();
+    n_data = true;
+    switch (code()) {
+    case 2: {
+        n_data = false;
+        m_data = std::unique_ptr<two_t>(new two_t(m__io, this, m__root));
+        break;
+    }
+    case 511: {
+        n_data = false;
+        m_data = std::unique_ptr<one_t>(new one_t(m__io, this, m__root));
+        break;
+    }
+    }
+}
+
+eof_exception_switch_user_t::~eof_exception_switch_user_t() {
+    _clean_up();
+}
+
+void eof_exception_switch_user_t::_clean_up() {
+    if (!n_data) {
+    }
+}
+
+eof_exception_switch_user_t::one_t::one_t(kaitai::kstream* p__io, eof_exception_switch_user_t* p__parent, eof_exception_switch_user_t* p__root) : kaitai::kstruct(p__io) {
+    m__parent = p__parent;
+    m__root = p__root;
+    _read();
+}
+
+void eof_exception_switch_user_t::one_t::_read() {
+    m_val = m__io->read_s2le();
+}
+
+eof_exception_switch_user_t::one_t::~one_t() {
+    _clean_up();
+}
+
+void eof_exception_switch_user_t::one_t::_clean_up() {
+}
+
+eof_exception_switch_user_t::two_t::two_t(kaitai::kstream* p__io, eof_exception_switch_user_t* p__parent, eof_exception_switch_user_t* p__root) : kaitai::kstruct(p__io) {
+    m__parent = p__parent;
+    m__root = p__root;
+    _read();
+}
+
+void eof_exception_switch_user_t::two_t::_read() {
+    m_val = m__io->read_u2le();
+}
+
+eof_exception_switch_user_t::two_t::~two_t() {
+    _clean_up();
+}
+
+void eof_exception_switch_user_t::two_t::_clean_up() {
+}

compiled/cpp_stl_11/eof_exception_switch_user.h

@@ -0,0 +1,91 @@
+#pragma once
+
+// This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+class eof_exception_switch_user_t;
+
+#include "kaitai/kaitaistruct.h"
+#include <stdint.h>
+#include <memory>
+
+#if KAITAI_STRUCT_VERSION < 11000L
+#error "Incompatible Kaitai Struct C++/STL API: version 0.11 or later is required"
+#endif
+
+class eof_exception_switch_user_t : public kaitai::kstruct {
+
+public:
+    class one_t;
+    class two_t;
+
+    eof_exception_switch_user_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent = nullptr, eof_exception_switch_user_t* p__root = nullptr);
+
+private:
+    void _read();
+    void _clean_up();
+
+public:
+    ~eof_exception_switch_user_t();
+
+    class one_t : public kaitai::kstruct {
+
+    public:
+
+        one_t(kaitai::kstream* p__io, eof_exception_switch_user_t* p__parent = nullptr, eof_exception_switch_user_t* p__root = nullptr);
+
+    private:
+        void _read();
+        void _clean_up();
+
+    public:
+        ~one_t();
+        int16_t val() const { return m_val; }
+        eof_exception_switch_user_t* _root() const { return m__root; }
+        eof_exception_switch_user_t* _parent() const { return m__parent; }
+
+    private:
+        int16_t m_val;
+        eof_exception_switch_user_t* m__root;
+        eof_exception_switch_user_t* m__parent;
+    };
+
+    class two_t : public kaitai::kstruct {
+
+    public:
+
+        two_t(kaitai::kstream* p__io, eof_exception_switch_user_t* p__parent = nullptr, eof_exception_switch_user_t* p__root = nullptr);
+
+    private:
+        void _read();
+        void _clean_up();
+
+    public:
+        ~two_t();
+        uint16_t val() const { return m_val; }
+        eof_exception_switch_user_t* _root() const { return m__root; }
+        eof_exception_switch_user_t* _parent() const { return m__parent; }
+
+    private:
+        uint16_t m_val;
+        eof_exception_switch_user_t* m__root;
+        eof_exception_switch_user_t* m__parent;
+    };
+
+public:
+    uint16_t code() const { return m_code; }
+    kaitai::kstruct* data() const { return m_data.get(); }
+    eof_exception_switch_user_t* _root() const { return m__root; }
+    kaitai::kstruct* _parent() const { return m__parent; }
+
+private:
+    uint16_t m_code;
+    std::unique_ptr<kaitai::kstruct> m_data;
+    bool n_data;
+
+public:
+    bool _is_null_data() { data(); return n_data; };
+
+private:
+    eof_exception_switch_user_t* m__root;
+    kaitai::kstruct* m__parent;
+};