From 30ac512a540249e1e716000b970283ac24807073 Mon Sep 17 00:00:00 2001 From: aardappel Date: Wed, 22 May 2019 11:48:10 -0700 Subject: [PATCH] Fixed Lobster implementation to work with latest language features --- lobster/flatbuffers.lobster | 59 +-- samples/monster_generated.lobster | 75 ++-- samples/sample_binary.lobster | 6 +- samples/sample_text.lobster | 12 +- src/idl_gen_lobster.cpp | 38 +- tests/lobstertest.lobster | 12 +- tests/monster_test_generated.lobster | 343 +++++++++--------- .../namespace_test1_generated.lobster | 27 +- .../namespace_test2_generated.lobster | 49 ++- 9 files changed, 309 insertions(+), 312 deletions(-) diff --git a/lobster/flatbuffers.lobster b/lobster/flatbuffers.lobster index 09105e762..03032aa45 100644 --- a/lobster/flatbuffers.lobster +++ b/lobster/flatbuffers.lobster @@ -12,32 +12,33 @@ // See the License for the specific language governing permissions and // limitations under the License. -include "std.lobster" +import std namespace flatbuffers -struct handle: +class handle: buf_:string pos_:int -enum + sz_8 = 1, - sz_16 = 2, - sz_32 = 4, - sz_64 = 8, - sz_voffset = 2, - sz_uoffset = 4, - sz_soffset = 4, - sz_metadata_fields = 2 +enum sizeof: + sz_8 = 1 + sz_16 = 2 + sz_32 = 4 + sz_64 = 8 + sz_voffset = 2 + sz_uoffset = 4 + sz_soffset = 4 + sz_metadata_fields = 2 -struct builder: - buf:string = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +class builder: + buf = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" current_vtable:[int] = [] - head:int = 0 - minalign:int = 1 - object_end:int = 0 + head = 0 + minalign = 1 + object_end = 0 vtables:[int] = [] - nested:int = false - finished:int = false + nested = false + finished = false // Optionally call this right after creating the builder for a larger initial buffer. def Initial(initial_size:int): @@ -75,11 +76,11 @@ struct builder: // Prepend a zero scalar to the object. Later in this function we'll // write an offset here that points to the object's vtable: PrependInt32(0) - object_offset := head + let object_offset = head // Write out new vtable speculatively. - vtable_size := (current_vtable.length + sz_metadata_fields) * sz_voffset + let vtable_size = (current_vtable.length + sz_metadata_fields) * sz_voffset while current_vtable.length: - o := current_vtable.pop() + let o = current_vtable.pop() PrependVOffsetT(if o: object_offset - o else: 0) // The two metadata fields are written last. // First, store the object bytesize: @@ -91,17 +92,18 @@ struct builder: // BenchmarkVtableDeduplication for a case in which this heuristic // saves about 30% of the time used in writing objects with duplicate // tables. - existing_vtable := do(): + def find_existing_table(): reverse(vtables) vt2_offset: // Find the other vtable: - vt2_start := buf.length - vt2_offset - vt2_len := buf.read_int16_le(vt2_start) + let vt2_start = buf.length - vt2_offset + let vt2_len = buf.read_int16_le(vt2_start) // Compare the other vtable to the one under consideration. // If they are equal, return the offset: if vtable_size == vt2_len and not compare_substring(buf, Start(), buf, vt2_start, vtable_size): - return vt2_offset from do - 0 + return vt2_offset + return 0 + let existing_vtable = find_existing_table() if existing_vtable: // Found a duplicate vtable, remove the one we wrote. head = object_offset @@ -119,7 +121,8 @@ struct builder: return object_offset def Pad(n): - for(n): buf, head = buf.write_int8_le_back(head, 0) + for(n): + buf, head = buf.write_int8_le_back(head, 0) def Prep(size, additional_bytes): // Track the biggest thing we've ever aligned to. @@ -127,7 +130,7 @@ struct builder: minalign = size // Find the amount of alignment needed such that `size` is properly // aligned after `additionalBytes`: - align_size := ((~(head + additional_bytes)) + 1) & (size - 1) + let align_size = ((~(head + additional_bytes)) + 1) & (size - 1) Pad(align_size) def PrependUOffsetTRelative(off): @@ -172,7 +175,7 @@ struct builder: // Finish finalizes a buffer, pointing to the given root_table assert not finished assert not nested - prep_size := sz_32 + var prep_size = sz_32 if size_prefix: prep_size += sz_32 Prep(minalign, prep_size) diff --git a/samples/monster_generated.lobster b/samples/monster_generated.lobster index 409e77d74..7bf3f4cca 100644 --- a/samples/monster_generated.lobster +++ b/samples/monster_generated.lobster @@ -1,31 +1,30 @@ // automatically generated by the FlatBuffers compiler, do not modify - -include "flatbuffers.lobster" +import flatbuffers namespace MyGame_Sample -enum + - Color_Red = 0, - Color_Green = 1, +enum Color: + Color_Red = 0 + Color_Green = 1 Color_Blue = 2 -enum + - Equipment_NONE = 0, +enum Equipment: + Equipment_NONE = 0 Equipment_Weapon = 1 -struct Vec3 +class Vec3 -struct Monster +class Monster -struct Weapon +class Weapon -struct Vec3 : flatbuffers_handle +class Vec3 : flatbuffers_handle def x(): - buf_.read_float32_le(pos_ + 0) + return buf_.read_float32_le(pos_ + 0) def y(): - buf_.read_float32_le(pos_ + 4) + return buf_.read_float32_le(pos_ + 4) def z(): - buf_.read_float32_le(pos_ + 8) + return buf_.read_float32_le(pos_ + 8) def CreateVec3(b_:flatbuffers_builder, x:float, y:float, z:float): b_.Prep(4, 12) @@ -34,36 +33,36 @@ def CreateVec3(b_:flatbuffers_builder, x:float, y:float, z:float): b_.PrependFloat32(x) return b_.Offset() -struct Monster : flatbuffers_handle +class Monster : flatbuffers_handle def pos(): - o := buf_.flatbuffers_field_struct(pos_, 4) - if o: MyGame_Sample_Vec3 { buf_, o } else: nil + let o = buf_.flatbuffers_field_struct(pos_, 4) + return if o: MyGame_Sample_Vec3 { buf_, o } else: nil def mana(): - buf_.flatbuffers_field_int16(pos_, 6, 150) + return buf_.flatbuffers_field_int16(pos_, 6, 150) def hp(): - buf_.flatbuffers_field_int16(pos_, 8, 100) + return buf_.flatbuffers_field_int16(pos_, 8, 100) def name(): - buf_.flatbuffers_field_string(pos_, 10) + return buf_.flatbuffers_field_string(pos_, 10) def inventory(i:int): - buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 14) + i * 1) + return buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 14) + i * 1) def inventory_length(): - buf_.flatbuffers_field_vector_len(pos_, 14) + return buf_.flatbuffers_field_vector_len(pos_, 14) def color(): - buf_.flatbuffers_field_int8(pos_, 16, 2) + return buf_.flatbuffers_field_int8(pos_, 16, 2) def weapons(i:int): - MyGame_Sample_Weapon { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 18) + i * 4) } + return MyGame_Sample_Weapon { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 18) + i * 4) } def weapons_length(): - buf_.flatbuffers_field_vector_len(pos_, 18) + return buf_.flatbuffers_field_vector_len(pos_, 18) def equipped_type(): - buf_.flatbuffers_field_int8(pos_, 20, 0) + return buf_.flatbuffers_field_int8(pos_, 20, 0) def equipped_as_Weapon(): - MyGame_Sample_Weapon { buf_, buf_.flatbuffers_field_table(pos_, 22) } + return MyGame_Sample_Weapon { buf_, buf_.flatbuffers_field_table(pos_, 22) } def path(i:int): - MyGame_Sample_Vec3 { buf_, buf_.flatbuffers_field_vector(pos_, 24) + i * 12 } + return MyGame_Sample_Vec3 { buf_, buf_.flatbuffers_field_vector(pos_, 24) + i * 12 } def path_length(): - buf_.flatbuffers_field_vector_len(pos_, 24) + return buf_.flatbuffers_field_vector_len(pos_, 24) -def GetRootAsMonster(buf:string): Monster { buf, buf.flatbuffers_indirect(0) } +def GetRootAsMonster(buf:string): return Monster { buf, buf.flatbuffers_indirect(0) } def MonsterStart(b_:flatbuffers_builder): b_.StartObject(11) @@ -82,7 +81,7 @@ def MonsterStartInventoryVector(b_:flatbuffers_builder, n_:int): def MonsterCreateInventoryVector(b_:flatbuffers_builder, v_:[int]): b_.StartVector(1, v_.length, 1) reverse(v_) e_: b_.PrependUint8(e_) - b_.EndVector(v_.length) + return b_.EndVector(v_.length) def MonsterAddColor(b_:flatbuffers_builder, color:int): b_.PrependInt8Slot(6, color, 2) def MonsterAddWeapons(b_:flatbuffers_builder, weapons:int): @@ -92,7 +91,7 @@ def MonsterStartWeaponsVector(b_:flatbuffers_builder, n_:int): def MonsterCreateWeaponsVector(b_:flatbuffers_builder, v_:[int]): b_.StartVector(4, v_.length, 4) reverse(v_) e_: b_.PrependUOffsetTRelative(e_) - b_.EndVector(v_.length) + return b_.EndVector(v_.length) def MonsterAddEquippedType(b_:flatbuffers_builder, equipped_type:int): b_.PrependUint8Slot(8, equipped_type, 0) def MonsterAddEquipped(b_:flatbuffers_builder, equipped:int): @@ -102,15 +101,15 @@ def MonsterAddPath(b_:flatbuffers_builder, path:int): def MonsterStartPathVector(b_:flatbuffers_builder, n_:int): b_.StartVector(12, n_, 4) def MonsterEnd(b_:flatbuffers_builder): - b_.EndObject() + return b_.EndObject() -struct Weapon : flatbuffers_handle +class Weapon : flatbuffers_handle def name(): - buf_.flatbuffers_field_string(pos_, 4) + return buf_.flatbuffers_field_string(pos_, 4) def damage(): - buf_.flatbuffers_field_int16(pos_, 6, 0) + return buf_.flatbuffers_field_int16(pos_, 6, 0) -def GetRootAsWeapon(buf:string): Weapon { buf, buf.flatbuffers_indirect(0) } +def GetRootAsWeapon(buf:string): return Weapon { buf, buf.flatbuffers_indirect(0) } def WeaponStart(b_:flatbuffers_builder): b_.StartObject(2) @@ -119,5 +118,5 @@ def WeaponAddName(b_:flatbuffers_builder, name:int): def WeaponAddDamage(b_:flatbuffers_builder, damage:int): b_.PrependInt16Slot(1, damage, 0) def WeaponEnd(b_:flatbuffers_builder): - b_.EndObject() + return b_.EndObject() diff --git a/samples/sample_binary.lobster b/samples/sample_binary.lobster index 0434af064..ae3dbe1d1 100644 --- a/samples/sample_binary.lobster +++ b/samples/sample_binary.lobster @@ -12,8 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. -include from "../lobster/" -include "monster_generated.lobster" +import from "../lobster/" +import monster_generated // Example of how to use FlatBuffers to create and read binary buffers. @@ -24,7 +24,7 @@ let b = flatbuffers_builder {} let weapon_names = [ "Sword", "Axe" ] let weapon_damages = [ 3, 5 ] -weapon_offsets := map(weapon_names) name, i: +let weapon_offsets = map(weapon_names) name, i: let ns = b.CreateString(name) b.MyGame_Sample_WeaponStart() b.MyGame_Sample_WeaponAddName(ns) diff --git a/samples/sample_text.lobster b/samples/sample_text.lobster index 9da4fa25e..26b3eaff3 100644 --- a/samples/sample_text.lobster +++ b/samples/sample_text.lobster @@ -12,20 +12,20 @@ // See the License for the specific language governing permissions and // limitations under the License. -include from "../lobster/" -include "monster_generated.lobster" +import from "../lobster/" +import monster_generated // Example how to interop with JSON. // Test loading some JSON, converting it to a binary FlatBuffer and back again. // First read the schema and JSON data. -schema := read_file("monster.fbs", true) -json := read_file("monsterdata.json", true) +let schema = read_file("monster.fbs", true) +let json = read_file("monsterdata.json", true) assert schema and json // Parse JSON to binary: -fb, err1 := flatbuffers_json_to_binary(schema, json, []) +let fb, err1 = flatbuffers_json_to_binary(schema, json, []) assert not err1 // Access one field in it, just to check: @@ -33,7 +33,7 @@ let monster = MyGame_Sample_GetRootAsMonster(fb) assert monster.name == "Orc" // Convert binary back to JSON: -json2, err2 := flatbuffers_binary_to_json(schema, fb, []) +let json2, err2 = flatbuffers_binary_to_json(schema, fb, []) assert not err2 // The generated JSON should be exactly equal to the original! diff --git a/src/idl_gen_lobster.cpp b/src/idl_gen_lobster.cpp index b2e8f4236..ac9aa793b 100644 --- a/src/idl_gen_lobster.cpp +++ b/src/idl_gen_lobster.cpp @@ -31,7 +31,7 @@ class LobsterGenerator : public BaseGenerator { const std::string &file_name) : BaseGenerator(parser, path, file_name, "" /* not used */, "_") { static const char * const keywords[] = { - "nil", "true", "false", "return", "struct", "value", "include", "int", + "nil", "true", "false", "return", "struct", "class", "import", "int", "float", "string", "any", "def", "is", "from", "program", "private", "coroutine", "resource", "enum", "typeof", "var", "let", "pakfile", "switch", "case", "default", "namespace", "not", "and", "or", "bool", @@ -99,11 +99,11 @@ class LobsterGenerator : public BaseGenerator { auto def = " def " + NormalizedName(field); if (IsScalar(field.value.type.base_type)) { if (struct_def.fixed) { - code += def + "():\n buf_.read_" + + code += def + "():\n return buf_.read_" + GenTypeName(field.value.type) + "_le(pos_ + " + offsets + ")\n"; } else { - code += def + "():\n buf_.flatbuffers_field_" + + code += def + "():\n return buf_.flatbuffers_field_" + GenTypeName(field.value.type) + "(pos_, " + offsets + ", " + field.value.constant + ")\n"; } @@ -114,22 +114,22 @@ class LobsterGenerator : public BaseGenerator { auto name = NamespacedName(*field.value.type.struct_def); code += def + "():\n "; if (struct_def.fixed) { - code += name + "{ buf_, pos_ + " + offsets + " }\n"; + code += "return " + name + "{ buf_, pos_ + " + offsets + " }\n"; } else { - code += std::string("o := buf_.flatbuffers_field_") + + code += std::string("let o = buf_.flatbuffers_field_") + (field.value.type.struct_def->fixed ? "struct" : "table") + - "(pos_, " + offsets + ")\n if o: " + name + + "(pos_, " + offsets + ")\n return if o: " + name + " { buf_, o } else: nil\n"; } break; } case BASE_TYPE_STRING: - code += def + "():\n buf_.flatbuffers_field_string(pos_, " + + code += def + "():\n return buf_.flatbuffers_field_string(pos_, " + offsets + ")\n"; break; case BASE_TYPE_VECTOR: { auto vectortype = field.value.type.VectorType(); - code += def + "(i:int):\n "; + code += def + "(i:int):\n return "; if (vectortype.base_type == BASE_TYPE_STRUCT) { auto start = "buf_.flatbuffers_field_vector(pos_, " + offsets + ") + i * " + NumToString(InlineSize(vectortype)); @@ -153,7 +153,7 @@ class LobsterGenerator : public BaseGenerator { it != field.value.type.enum_def->Vals().end(); ++it) { auto &ev = **it; if (ev.IsNonZero()) { - code += def + "_as_" + ev.name + "():\n " + + code += def + "_as_" + ev.name + "():\n return " + NamespacedName(*ev.union_type.struct_def) + " { buf_, buf_.flatbuffers_field_table(pos_, " + offsets + ") }\n"; @@ -165,7 +165,7 @@ class LobsterGenerator : public BaseGenerator { } if (field.value.type.base_type == BASE_TYPE_VECTOR) { code += def + - "_length():\n buf_.flatbuffers_field_vector_len(pos_, " + + "_length():\n return buf_.flatbuffers_field_vector_len(pos_, " + offsets + ")\n"; } } @@ -207,19 +207,19 @@ class LobsterGenerator : public BaseGenerator { NumToString(alignment) + ")\n reverse(v_) e_: b_.Prepend" + GenMethod(vector_type) + - "(e_)\n b_.EndVector(v_.length)\n"; + "(e_)\n return b_.EndVector(v_.length)\n"; } } } code += "def " + NormalizedName(struct_def) + - "End(b_:flatbuffers_builder):\n b_.EndObject()\n\n"; + "End(b_:flatbuffers_builder):\n return b_.EndObject()\n\n"; } void GenStructPreDecl(const StructDef &struct_def, std::string *code_ptr) { if (struct_def.generated) return; std::string &code = *code_ptr; CheckNameSpace(struct_def, &code); - code += "struct " + NormalizedName(struct_def) + "\n\n"; + code += "class " + NormalizedName(struct_def) + "\n\n"; } // Generate struct or table methods. @@ -228,7 +228,7 @@ class LobsterGenerator : public BaseGenerator { std::string &code = *code_ptr; CheckNameSpace(struct_def, &code); GenComment(struct_def.doc_comment, code_ptr, nullptr, ""); - code += "struct " + NormalizedName(struct_def) + " : flatbuffers_handle\n"; + code += "class " + NormalizedName(struct_def) + " : flatbuffers_handle\n"; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { auto &field = **it; @@ -239,7 +239,7 @@ class LobsterGenerator : public BaseGenerator { if (!struct_def.fixed) { // Generate a special accessor for the table that has been declared as // the root type. - code += "def GetRootAs" + NormalizedName(struct_def) + "(buf:string): " + + code += "def GetRootAs" + NormalizedName(struct_def) + "(buf:string): return " + NormalizedName(struct_def) + " { buf, buf.flatbuffers_indirect(0) }\n\n"; } @@ -258,14 +258,12 @@ class LobsterGenerator : public BaseGenerator { std::string &code = *code_ptr; CheckNameSpace(enum_def, &code); GenComment(enum_def.doc_comment, code_ptr, nullptr, ""); - code += "enum + \n"; + code += "enum " + NormalizedName(enum_def) + ":\n"; for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) { auto &ev = **it; GenComment(ev.doc_comment, code_ptr, nullptr, " "); code += " " + enum_def.name + "_" + NormalizedName(ev) + " = " + - enum_def.ToString(ev); - if (it + 1 != enum_def.Vals().end()) code += ","; - code += "\n"; + enum_def.ToString(ev) + "\n"; } code += "\n"; } @@ -336,7 +334,7 @@ class LobsterGenerator : public BaseGenerator { bool generate() { std::string code; code += std::string("// ") + FlatBuffersGeneratedWarning() + - "\n\ninclude \"flatbuffers.lobster\"\n\n"; + "\nimport flatbuffers\n\n"; for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end(); ++it) { auto &enum_def = **it; diff --git a/tests/lobstertest.lobster b/tests/lobstertest.lobster index e4f08087b..aae0be169 100644 --- a/tests/lobstertest.lobster +++ b/tests/lobstertest.lobster @@ -12,8 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. -include from "../lobster/" -include "monster_test_generated.lobster" +import from "../lobster/" +import monster_test_generated def check_read_buffer(buf): // CheckReadBuffer checks that the given buffer is evaluated correctly as the example Monster. @@ -119,14 +119,14 @@ check_read_buffer(fb1) write_file("monsterdata_lobster_wire.mon", fb1) // Test converting the buffer to JSON and parsing the JSON back again. -schema := read_file("monster_test.fbs") +let schema = read_file("monster_test.fbs") assert schema -includedirs := [ "include_test" ] +let includedirs = [ "include_test" ] // Convert binary to JSON: -json, err1 := flatbuffers_binary_to_json(schema, fb1, includedirs) +let json, err1 = flatbuffers_binary_to_json(schema, fb1, includedirs) assert not err1 // Parse JSON back to binary: -fb3, err2 := flatbuffers_json_to_binary(schema, json, includedirs) +let fb3, err2 = flatbuffers_json_to_binary(schema, json, includedirs) assert not err2 // Check the resulting binary again (full roundtrip test): check_read_buffer(fb3) diff --git a/tests/monster_test_generated.lobster b/tests/monster_test_generated.lobster index 63902b8c7..8ad1cd0e9 100644 --- a/tests/monster_test_generated.lobster +++ b/tests/monster_test_generated.lobster @@ -1,87 +1,86 @@ // automatically generated by the FlatBuffers compiler, do not modify - -include "flatbuffers.lobster" +import flatbuffers namespace MyGame_Example -enum + - Color_Red = 1, - Color_Green = 2, +enum Color: + Color_Red = 1 + Color_Green = 2 Color_Blue = 8 -enum + - Any_NONE = 0, - Any_Monster = 1, - Any_TestSimpleTableWithEnum = 2, +enum Any: + Any_NONE = 0 + Any_Monster = 1 + Any_TestSimpleTableWithEnum = 2 Any_MyGame_Example2_Monster = 3 -enum + - AnyUniqueAliases_NONE = 0, - AnyUniqueAliases_M = 1, - AnyUniqueAliases_T = 2, +enum AnyUniqueAliases: + AnyUniqueAliases_NONE = 0 + AnyUniqueAliases_M = 1 + AnyUniqueAliases_T = 2 AnyUniqueAliases_M2 = 3 -enum + - AnyAmbiguousAliases_NONE = 0, - AnyAmbiguousAliases_M1 = 1, - AnyAmbiguousAliases_M2 = 2, +enum AnyAmbiguousAliases: + AnyAmbiguousAliases_NONE = 0 + AnyAmbiguousAliases_M1 = 1 + AnyAmbiguousAliases_M2 = 2 AnyAmbiguousAliases_M3 = 3 namespace MyGame -struct InParentNamespace +class InParentNamespace namespace MyGame_Example2 -struct Monster +class Monster namespace MyGame_Example -struct Test +class Test -struct TestSimpleTableWithEnum +class TestSimpleTableWithEnum -struct Vec3 +class Vec3 -struct Ability +class Ability -struct Stat +class Stat -struct Referrable +class Referrable -struct Monster +class Monster -struct TypeAliases +class TypeAliases namespace MyGame -struct InParentNamespace : flatbuffers_handle +class InParentNamespace : flatbuffers_handle -def GetRootAsInParentNamespace(buf:string): InParentNamespace { buf, buf.flatbuffers_indirect(0) } +def GetRootAsInParentNamespace(buf:string): return InParentNamespace { buf, buf.flatbuffers_indirect(0) } def InParentNamespaceStart(b_:flatbuffers_builder): b_.StartObject(0) def InParentNamespaceEnd(b_:flatbuffers_builder): - b_.EndObject() + return b_.EndObject() namespace MyGame_Example2 -struct Monster : flatbuffers_handle +class Monster : flatbuffers_handle -def GetRootAsMonster(buf:string): Monster { buf, buf.flatbuffers_indirect(0) } +def GetRootAsMonster(buf:string): return Monster { buf, buf.flatbuffers_indirect(0) } def MonsterStart(b_:flatbuffers_builder): b_.StartObject(0) def MonsterEnd(b_:flatbuffers_builder): - b_.EndObject() + return b_.EndObject() namespace MyGame_Example -struct Test : flatbuffers_handle +class Test : flatbuffers_handle def a(): - buf_.read_int16_le(pos_ + 0) + return buf_.read_int16_le(pos_ + 0) def b(): - buf_.read_int8_le(pos_ + 2) + return buf_.read_int8_le(pos_ + 2) def CreateTest(b_:flatbuffers_builder, a:int, b:int): b_.Prep(2, 4) @@ -90,32 +89,32 @@ def CreateTest(b_:flatbuffers_builder, a:int, b:int): b_.PrependInt16(a) return b_.Offset() -struct TestSimpleTableWithEnum : flatbuffers_handle +class TestSimpleTableWithEnum : flatbuffers_handle def color(): - buf_.flatbuffers_field_int8(pos_, 4, 2) + return buf_.flatbuffers_field_int8(pos_, 4, 2) -def GetRootAsTestSimpleTableWithEnum(buf:string): TestSimpleTableWithEnum { buf, buf.flatbuffers_indirect(0) } +def GetRootAsTestSimpleTableWithEnum(buf:string): return TestSimpleTableWithEnum { buf, buf.flatbuffers_indirect(0) } def TestSimpleTableWithEnumStart(b_:flatbuffers_builder): b_.StartObject(1) def TestSimpleTableWithEnumAddColor(b_:flatbuffers_builder, color:int): b_.PrependUint8Slot(0, color, 2) def TestSimpleTableWithEnumEnd(b_:flatbuffers_builder): - b_.EndObject() + return b_.EndObject() -struct Vec3 : flatbuffers_handle +class Vec3 : flatbuffers_handle def x(): - buf_.read_float32_le(pos_ + 0) + return buf_.read_float32_le(pos_ + 0) def y(): - buf_.read_float32_le(pos_ + 4) + return buf_.read_float32_le(pos_ + 4) def z(): - buf_.read_float32_le(pos_ + 8) + return buf_.read_float32_le(pos_ + 8) def test1(): - buf_.read_float64_le(pos_ + 16) + return buf_.read_float64_le(pos_ + 16) def test2(): - buf_.read_int8_le(pos_ + 24) + return buf_.read_int8_le(pos_ + 24) def test3(): - MyGame_Example_Test{ buf_, pos_ + 26 } + return MyGame_Example_Test{ buf_, pos_ + 26 } def CreateVec3(b_:flatbuffers_builder, x:float, y:float, z:float, test1:float, test2:int, test3_a:int, test3_b:int): b_.Prep(8, 32) @@ -133,11 +132,11 @@ def CreateVec3(b_:flatbuffers_builder, x:float, y:float, z:float, test1:float, t b_.PrependFloat32(x) return b_.Offset() -struct Ability : flatbuffers_handle +class Ability : flatbuffers_handle def id(): - buf_.read_int32_le(pos_ + 0) + return buf_.read_int32_le(pos_ + 0) def distance(): - buf_.read_int32_le(pos_ + 4) + return buf_.read_int32_le(pos_ + 4) def CreateAbility(b_:flatbuffers_builder, id:int, distance:int): b_.Prep(4, 8) @@ -145,15 +144,15 @@ def CreateAbility(b_:flatbuffers_builder, id:int, distance:int): b_.PrependUint32(id) return b_.Offset() -struct Stat : flatbuffers_handle +class Stat : flatbuffers_handle def id(): - buf_.flatbuffers_field_string(pos_, 4) + return buf_.flatbuffers_field_string(pos_, 4) def val(): - buf_.flatbuffers_field_int64(pos_, 6, 0) + return buf_.flatbuffers_field_int64(pos_, 6, 0) def count(): - buf_.flatbuffers_field_int16(pos_, 8, 0) + return buf_.flatbuffers_field_int16(pos_, 8, 0) -def GetRootAsStat(buf:string): Stat { buf, buf.flatbuffers_indirect(0) } +def GetRootAsStat(buf:string): return Stat { buf, buf.flatbuffers_indirect(0) } def StatStart(b_:flatbuffers_builder): b_.StartObject(3) @@ -164,173 +163,173 @@ def StatAddVal(b_:flatbuffers_builder, val:int): def StatAddCount(b_:flatbuffers_builder, count:int): b_.PrependUint16Slot(2, count, 0) def StatEnd(b_:flatbuffers_builder): - b_.EndObject() + return b_.EndObject() -struct Referrable : flatbuffers_handle +class Referrable : flatbuffers_handle def id(): - buf_.flatbuffers_field_int64(pos_, 4, 0) + return buf_.flatbuffers_field_int64(pos_, 4, 0) -def GetRootAsReferrable(buf:string): Referrable { buf, buf.flatbuffers_indirect(0) } +def GetRootAsReferrable(buf:string): return Referrable { buf, buf.flatbuffers_indirect(0) } def ReferrableStart(b_:flatbuffers_builder): b_.StartObject(1) def ReferrableAddId(b_:flatbuffers_builder, id:int): b_.PrependUint64Slot(0, id, 0) def ReferrableEnd(b_:flatbuffers_builder): - b_.EndObject() + return b_.EndObject() /// an example documentation comment: monster object -struct Monster : flatbuffers_handle +class Monster : flatbuffers_handle def pos(): - o := buf_.flatbuffers_field_struct(pos_, 4) - if o: MyGame_Example_Vec3 { buf_, o } else: nil + let o = buf_.flatbuffers_field_struct(pos_, 4) + return if o: MyGame_Example_Vec3 { buf_, o } else: nil def mana(): - buf_.flatbuffers_field_int16(pos_, 6, 150) + return buf_.flatbuffers_field_int16(pos_, 6, 150) def hp(): - buf_.flatbuffers_field_int16(pos_, 8, 100) + return buf_.flatbuffers_field_int16(pos_, 8, 100) def name(): - buf_.flatbuffers_field_string(pos_, 10) + return buf_.flatbuffers_field_string(pos_, 10) def inventory(i:int): - buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 14) + i * 1) + return buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 14) + i * 1) def inventory_length(): - buf_.flatbuffers_field_vector_len(pos_, 14) + return buf_.flatbuffers_field_vector_len(pos_, 14) def color(): - buf_.flatbuffers_field_int8(pos_, 16, 8) + return buf_.flatbuffers_field_int8(pos_, 16, 8) def test_type(): - buf_.flatbuffers_field_int8(pos_, 18, 0) + return buf_.flatbuffers_field_int8(pos_, 18, 0) def test_as_Monster(): - MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 20) } + return MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 20) } def test_as_TestSimpleTableWithEnum(): - MyGame_Example_TestSimpleTableWithEnum { buf_, buf_.flatbuffers_field_table(pos_, 20) } + return MyGame_Example_TestSimpleTableWithEnum { buf_, buf_.flatbuffers_field_table(pos_, 20) } def test_as_MyGame_Example2_Monster(): - MyGame_Example2_Monster { buf_, buf_.flatbuffers_field_table(pos_, 20) } + return MyGame_Example2_Monster { buf_, buf_.flatbuffers_field_table(pos_, 20) } def test4(i:int): - MyGame_Example_Test { buf_, buf_.flatbuffers_field_vector(pos_, 22) + i * 4 } + return MyGame_Example_Test { buf_, buf_.flatbuffers_field_vector(pos_, 22) + i * 4 } def test4_length(): - buf_.flatbuffers_field_vector_len(pos_, 22) + return buf_.flatbuffers_field_vector_len(pos_, 22) def testarrayofstring(i:int): - buf_.flatbuffers_string(buf_.flatbuffers_field_vector(pos_, 24) + i * 4) + return buf_.flatbuffers_string(buf_.flatbuffers_field_vector(pos_, 24) + i * 4) def testarrayofstring_length(): - buf_.flatbuffers_field_vector_len(pos_, 24) + return buf_.flatbuffers_field_vector_len(pos_, 24) /// an example documentation comment: this will end up in the generated code /// multiline too def testarrayoftables(i:int): - MyGame_Example_Monster { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 26) + i * 4) } + return MyGame_Example_Monster { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 26) + i * 4) } def testarrayoftables_length(): - buf_.flatbuffers_field_vector_len(pos_, 26) + return buf_.flatbuffers_field_vector_len(pos_, 26) def enemy(): - o := buf_.flatbuffers_field_table(pos_, 28) - if o: MyGame_Example_Monster { buf_, o } else: nil + let o = buf_.flatbuffers_field_table(pos_, 28) + return if o: MyGame_Example_Monster { buf_, o } else: nil def testnestedflatbuffer(i:int): - buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 30) + i * 1) + return buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 30) + i * 1) def testnestedflatbuffer_length(): - buf_.flatbuffers_field_vector_len(pos_, 30) + return buf_.flatbuffers_field_vector_len(pos_, 30) def testempty(): - o := buf_.flatbuffers_field_table(pos_, 32) - if o: MyGame_Example_Stat { buf_, o } else: nil + let o = buf_.flatbuffers_field_table(pos_, 32) + return if o: MyGame_Example_Stat { buf_, o } else: nil def testbool(): - buf_.flatbuffers_field_int8(pos_, 34, 0) + return buf_.flatbuffers_field_int8(pos_, 34, 0) def testhashs32_fnv1(): - buf_.flatbuffers_field_int32(pos_, 36, 0) + return buf_.flatbuffers_field_int32(pos_, 36, 0) def testhashu32_fnv1(): - buf_.flatbuffers_field_int32(pos_, 38, 0) + return buf_.flatbuffers_field_int32(pos_, 38, 0) def testhashs64_fnv1(): - buf_.flatbuffers_field_int64(pos_, 40, 0) + return buf_.flatbuffers_field_int64(pos_, 40, 0) def testhashu64_fnv1(): - buf_.flatbuffers_field_int64(pos_, 42, 0) + return buf_.flatbuffers_field_int64(pos_, 42, 0) def testhashs32_fnv1a(): - buf_.flatbuffers_field_int32(pos_, 44, 0) + return buf_.flatbuffers_field_int32(pos_, 44, 0) def testhashu32_fnv1a(): - buf_.flatbuffers_field_int32(pos_, 46, 0) + return buf_.flatbuffers_field_int32(pos_, 46, 0) def testhashs64_fnv1a(): - buf_.flatbuffers_field_int64(pos_, 48, 0) + return buf_.flatbuffers_field_int64(pos_, 48, 0) def testhashu64_fnv1a(): - buf_.flatbuffers_field_int64(pos_, 50, 0) + return buf_.flatbuffers_field_int64(pos_, 50, 0) def testarrayofbools(i:int): - buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 52) + i * 1) + return buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 52) + i * 1) def testarrayofbools_length(): - buf_.flatbuffers_field_vector_len(pos_, 52) + return buf_.flatbuffers_field_vector_len(pos_, 52) def testf(): - buf_.flatbuffers_field_float32(pos_, 54, 3.14159) + return buf_.flatbuffers_field_float32(pos_, 54, 3.14159) def testf2(): - buf_.flatbuffers_field_float32(pos_, 56, 3.0) + return buf_.flatbuffers_field_float32(pos_, 56, 3.0) def testf3(): - buf_.flatbuffers_field_float32(pos_, 58, 0.0) + return buf_.flatbuffers_field_float32(pos_, 58, 0.0) def testarrayofstring2(i:int): - buf_.flatbuffers_string(buf_.flatbuffers_field_vector(pos_, 60) + i * 4) + return buf_.flatbuffers_string(buf_.flatbuffers_field_vector(pos_, 60) + i * 4) def testarrayofstring2_length(): - buf_.flatbuffers_field_vector_len(pos_, 60) + return buf_.flatbuffers_field_vector_len(pos_, 60) def testarrayofsortedstruct(i:int): - MyGame_Example_Ability { buf_, buf_.flatbuffers_field_vector(pos_, 62) + i * 8 } + return MyGame_Example_Ability { buf_, buf_.flatbuffers_field_vector(pos_, 62) + i * 8 } def testarrayofsortedstruct_length(): - buf_.flatbuffers_field_vector_len(pos_, 62) + return buf_.flatbuffers_field_vector_len(pos_, 62) def flex(i:int): - buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 64) + i * 1) + return buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 64) + i * 1) def flex_length(): - buf_.flatbuffers_field_vector_len(pos_, 64) + return buf_.flatbuffers_field_vector_len(pos_, 64) def test5(i:int): - MyGame_Example_Test { buf_, buf_.flatbuffers_field_vector(pos_, 66) + i * 4 } + return MyGame_Example_Test { buf_, buf_.flatbuffers_field_vector(pos_, 66) + i * 4 } def test5_length(): - buf_.flatbuffers_field_vector_len(pos_, 66) + return buf_.flatbuffers_field_vector_len(pos_, 66) def vector_of_longs(i:int): - buf_.read_int64_le(buf_.flatbuffers_field_vector(pos_, 68) + i * 8) + return buf_.read_int64_le(buf_.flatbuffers_field_vector(pos_, 68) + i * 8) def vector_of_longs_length(): - buf_.flatbuffers_field_vector_len(pos_, 68) + return buf_.flatbuffers_field_vector_len(pos_, 68) def vector_of_doubles(i:int): - buf_.read_float64_le(buf_.flatbuffers_field_vector(pos_, 70) + i * 8) + return buf_.read_float64_le(buf_.flatbuffers_field_vector(pos_, 70) + i * 8) def vector_of_doubles_length(): - buf_.flatbuffers_field_vector_len(pos_, 70) + return buf_.flatbuffers_field_vector_len(pos_, 70) def parent_namespace_test(): - o := buf_.flatbuffers_field_table(pos_, 72) - if o: MyGame_InParentNamespace { buf_, o } else: nil + let o = buf_.flatbuffers_field_table(pos_, 72) + return if o: MyGame_InParentNamespace { buf_, o } else: nil def vector_of_referrables(i:int): - MyGame_Example_Referrable { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 74) + i * 4) } + return MyGame_Example_Referrable { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 74) + i * 4) } def vector_of_referrables_length(): - buf_.flatbuffers_field_vector_len(pos_, 74) + return buf_.flatbuffers_field_vector_len(pos_, 74) def single_weak_reference(): - buf_.flatbuffers_field_int64(pos_, 76, 0) + return buf_.flatbuffers_field_int64(pos_, 76, 0) def vector_of_weak_references(i:int): - buf_.read_int64_le(buf_.flatbuffers_field_vector(pos_, 78) + i * 8) + return buf_.read_int64_le(buf_.flatbuffers_field_vector(pos_, 78) + i * 8) def vector_of_weak_references_length(): - buf_.flatbuffers_field_vector_len(pos_, 78) + return buf_.flatbuffers_field_vector_len(pos_, 78) def vector_of_strong_referrables(i:int): - MyGame_Example_Referrable { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 80) + i * 4) } + return MyGame_Example_Referrable { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 80) + i * 4) } def vector_of_strong_referrables_length(): - buf_.flatbuffers_field_vector_len(pos_, 80) + return buf_.flatbuffers_field_vector_len(pos_, 80) def co_owning_reference(): - buf_.flatbuffers_field_int64(pos_, 82, 0) + return buf_.flatbuffers_field_int64(pos_, 82, 0) def vector_of_co_owning_references(i:int): - buf_.read_int64_le(buf_.flatbuffers_field_vector(pos_, 84) + i * 8) + return buf_.read_int64_le(buf_.flatbuffers_field_vector(pos_, 84) + i * 8) def vector_of_co_owning_references_length(): - buf_.flatbuffers_field_vector_len(pos_, 84) + return buf_.flatbuffers_field_vector_len(pos_, 84) def non_owning_reference(): - buf_.flatbuffers_field_int64(pos_, 86, 0) + return buf_.flatbuffers_field_int64(pos_, 86, 0) def vector_of_non_owning_references(i:int): - buf_.read_int64_le(buf_.flatbuffers_field_vector(pos_, 88) + i * 8) + return buf_.read_int64_le(buf_.flatbuffers_field_vector(pos_, 88) + i * 8) def vector_of_non_owning_references_length(): - buf_.flatbuffers_field_vector_len(pos_, 88) + return buf_.flatbuffers_field_vector_len(pos_, 88) def any_unique_type(): - buf_.flatbuffers_field_int8(pos_, 90, 0) + return buf_.flatbuffers_field_int8(pos_, 90, 0) def any_unique_as_M(): - MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 92) } + return MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 92) } def any_unique_as_T(): - MyGame_Example_TestSimpleTableWithEnum { buf_, buf_.flatbuffers_field_table(pos_, 92) } + return MyGame_Example_TestSimpleTableWithEnum { buf_, buf_.flatbuffers_field_table(pos_, 92) } def any_unique_as_M2(): - MyGame_Example2_Monster { buf_, buf_.flatbuffers_field_table(pos_, 92) } + return MyGame_Example2_Monster { buf_, buf_.flatbuffers_field_table(pos_, 92) } def any_ambiguous_type(): - buf_.flatbuffers_field_int8(pos_, 94, 0) + return buf_.flatbuffers_field_int8(pos_, 94, 0) def any_ambiguous_as_M1(): - MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 96) } + return MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 96) } def any_ambiguous_as_M2(): - MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 96) } + return MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 96) } def any_ambiguous_as_M3(): - MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 96) } + return MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 96) } def vector_of_enums(i:int): - buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 98) + i * 1) + return buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 98) + i * 1) def vector_of_enums_length(): - buf_.flatbuffers_field_vector_len(pos_, 98) + return buf_.flatbuffers_field_vector_len(pos_, 98) -def GetRootAsMonster(buf:string): Monster { buf, buf.flatbuffers_indirect(0) } +def GetRootAsMonster(buf:string): return Monster { buf, buf.flatbuffers_indirect(0) } def MonsterStart(b_:flatbuffers_builder): b_.StartObject(48) @@ -349,7 +348,7 @@ def MonsterStartInventoryVector(b_:flatbuffers_builder, n_:int): def MonsterCreateInventoryVector(b_:flatbuffers_builder, v_:[int]): b_.StartVector(1, v_.length, 1) reverse(v_) e_: b_.PrependUint8(e_) - b_.EndVector(v_.length) + return b_.EndVector(v_.length) def MonsterAddColor(b_:flatbuffers_builder, color:int): b_.PrependUint8Slot(6, color, 8) def MonsterAddTestType(b_:flatbuffers_builder, test_type:int): @@ -367,7 +366,7 @@ def MonsterStartTestarrayofstringVector(b_:flatbuffers_builder, n_:int): def MonsterCreateTestarrayofstringVector(b_:flatbuffers_builder, v_:[int]): b_.StartVector(4, v_.length, 4) reverse(v_) e_: b_.PrependUOffsetTRelative(e_) - b_.EndVector(v_.length) + return b_.EndVector(v_.length) def MonsterAddTestarrayoftables(b_:flatbuffers_builder, testarrayoftables:int): b_.PrependUOffsetTRelativeSlot(11, testarrayoftables, 0) def MonsterStartTestarrayoftablesVector(b_:flatbuffers_builder, n_:int): @@ -375,7 +374,7 @@ def MonsterStartTestarrayoftablesVector(b_:flatbuffers_builder, n_:int): def MonsterCreateTestarrayoftablesVector(b_:flatbuffers_builder, v_:[int]): b_.StartVector(4, v_.length, 4) reverse(v_) e_: b_.PrependUOffsetTRelative(e_) - b_.EndVector(v_.length) + return b_.EndVector(v_.length) def MonsterAddEnemy(b_:flatbuffers_builder, enemy:int): b_.PrependUOffsetTRelativeSlot(12, enemy, 0) def MonsterAddTestnestedflatbuffer(b_:flatbuffers_builder, testnestedflatbuffer:int): @@ -385,7 +384,7 @@ def MonsterStartTestnestedflatbufferVector(b_:flatbuffers_builder, n_:int): def MonsterCreateTestnestedflatbufferVector(b_:flatbuffers_builder, v_:[int]): b_.StartVector(1, v_.length, 1) reverse(v_) e_: b_.PrependUint8(e_) - b_.EndVector(v_.length) + return b_.EndVector(v_.length) def MonsterAddTestempty(b_:flatbuffers_builder, testempty:int): b_.PrependUOffsetTRelativeSlot(14, testempty, 0) def MonsterAddTestbool(b_:flatbuffers_builder, testbool:int): @@ -413,7 +412,7 @@ def MonsterStartTestarrayofboolsVector(b_:flatbuffers_builder, n_:int): def MonsterCreateTestarrayofboolsVector(b_:flatbuffers_builder, v_:[int]): b_.StartVector(1, v_.length, 1) reverse(v_) e_: b_.PrependBool(e_) - b_.EndVector(v_.length) + return b_.EndVector(v_.length) def MonsterAddTestf(b_:flatbuffers_builder, testf:float): b_.PrependFloat32Slot(25, testf, 3.14159) def MonsterAddTestf2(b_:flatbuffers_builder, testf2:float): @@ -427,7 +426,7 @@ def MonsterStartTestarrayofstring2Vector(b_:flatbuffers_builder, n_:int): def MonsterCreateTestarrayofstring2Vector(b_:flatbuffers_builder, v_:[int]): b_.StartVector(4, v_.length, 4) reverse(v_) e_: b_.PrependUOffsetTRelative(e_) - b_.EndVector(v_.length) + return b_.EndVector(v_.length) def MonsterAddTestarrayofsortedstruct(b_:flatbuffers_builder, testarrayofsortedstruct:int): b_.PrependUOffsetTRelativeSlot(29, testarrayofsortedstruct, 0) def MonsterStartTestarrayofsortedstructVector(b_:flatbuffers_builder, n_:int): @@ -439,7 +438,7 @@ def MonsterStartFlexVector(b_:flatbuffers_builder, n_:int): def MonsterCreateFlexVector(b_:flatbuffers_builder, v_:[int]): b_.StartVector(1, v_.length, 1) reverse(v_) e_: b_.PrependUint8(e_) - b_.EndVector(v_.length) + return b_.EndVector(v_.length) def MonsterAddTest5(b_:flatbuffers_builder, test5:int): b_.PrependUOffsetTRelativeSlot(31, test5, 0) def MonsterStartTest5Vector(b_:flatbuffers_builder, n_:int): @@ -451,7 +450,7 @@ def MonsterStartVectorOfLongsVector(b_:flatbuffers_builder, n_:int): def MonsterCreateVectorOfLongsVector(b_:flatbuffers_builder, v_:[int]): b_.StartVector(8, v_.length, 8) reverse(v_) e_: b_.PrependInt64(e_) - b_.EndVector(v_.length) + return b_.EndVector(v_.length) def MonsterAddVectorOfDoubles(b_:flatbuffers_builder, vector_of_doubles:int): b_.PrependUOffsetTRelativeSlot(33, vector_of_doubles, 0) def MonsterStartVectorOfDoublesVector(b_:flatbuffers_builder, n_:int): @@ -459,7 +458,7 @@ def MonsterStartVectorOfDoublesVector(b_:flatbuffers_builder, n_:int): def MonsterCreateVectorOfDoublesVector(b_:flatbuffers_builder, v_:[float]): b_.StartVector(8, v_.length, 8) reverse(v_) e_: b_.PrependFloat64(e_) - b_.EndVector(v_.length) + return b_.EndVector(v_.length) def MonsterAddParentNamespaceTest(b_:flatbuffers_builder, parent_namespace_test:int): b_.PrependUOffsetTRelativeSlot(34, parent_namespace_test, 0) def MonsterAddVectorOfReferrables(b_:flatbuffers_builder, vector_of_referrables:int): @@ -469,7 +468,7 @@ def MonsterStartVectorOfReferrablesVector(b_:flatbuffers_builder, n_:int): def MonsterCreateVectorOfReferrablesVector(b_:flatbuffers_builder, v_:[int]): b_.StartVector(4, v_.length, 4) reverse(v_) e_: b_.PrependUOffsetTRelative(e_) - b_.EndVector(v_.length) + return b_.EndVector(v_.length) def MonsterAddSingleWeakReference(b_:flatbuffers_builder, single_weak_reference:int): b_.PrependUint64Slot(36, single_weak_reference, 0) def MonsterAddVectorOfWeakReferences(b_:flatbuffers_builder, vector_of_weak_references:int): @@ -479,7 +478,7 @@ def MonsterStartVectorOfWeakReferencesVector(b_:flatbuffers_builder, n_:int): def MonsterCreateVectorOfWeakReferencesVector(b_:flatbuffers_builder, v_:[int]): b_.StartVector(8, v_.length, 8) reverse(v_) e_: b_.PrependUint64(e_) - b_.EndVector(v_.length) + return b_.EndVector(v_.length) def MonsterAddVectorOfStrongReferrables(b_:flatbuffers_builder, vector_of_strong_referrables:int): b_.PrependUOffsetTRelativeSlot(38, vector_of_strong_referrables, 0) def MonsterStartVectorOfStrongReferrablesVector(b_:flatbuffers_builder, n_:int): @@ -487,7 +486,7 @@ def MonsterStartVectorOfStrongReferrablesVector(b_:flatbuffers_builder, n_:int): def MonsterCreateVectorOfStrongReferrablesVector(b_:flatbuffers_builder, v_:[int]): b_.StartVector(4, v_.length, 4) reverse(v_) e_: b_.PrependUOffsetTRelative(e_) - b_.EndVector(v_.length) + return b_.EndVector(v_.length) def MonsterAddCoOwningReference(b_:flatbuffers_builder, co_owning_reference:int): b_.PrependUint64Slot(39, co_owning_reference, 0) def MonsterAddVectorOfCoOwningReferences(b_:flatbuffers_builder, vector_of_co_owning_references:int): @@ -497,7 +496,7 @@ def MonsterStartVectorOfCoOwningReferencesVector(b_:flatbuffers_builder, n_:int) def MonsterCreateVectorOfCoOwningReferencesVector(b_:flatbuffers_builder, v_:[int]): b_.StartVector(8, v_.length, 8) reverse(v_) e_: b_.PrependUint64(e_) - b_.EndVector(v_.length) + return b_.EndVector(v_.length) def MonsterAddNonOwningReference(b_:flatbuffers_builder, non_owning_reference:int): b_.PrependUint64Slot(41, non_owning_reference, 0) def MonsterAddVectorOfNonOwningReferences(b_:flatbuffers_builder, vector_of_non_owning_references:int): @@ -507,7 +506,7 @@ def MonsterStartVectorOfNonOwningReferencesVector(b_:flatbuffers_builder, n_:int def MonsterCreateVectorOfNonOwningReferencesVector(b_:flatbuffers_builder, v_:[int]): b_.StartVector(8, v_.length, 8) reverse(v_) e_: b_.PrependUint64(e_) - b_.EndVector(v_.length) + return b_.EndVector(v_.length) def MonsterAddAnyUniqueType(b_:flatbuffers_builder, any_unique_type:int): b_.PrependUint8Slot(43, any_unique_type, 0) def MonsterAddAnyUnique(b_:flatbuffers_builder, any_unique:int): @@ -523,41 +522,41 @@ def MonsterStartVectorOfEnumsVector(b_:flatbuffers_builder, n_:int): def MonsterCreateVectorOfEnumsVector(b_:flatbuffers_builder, v_:[int]): b_.StartVector(1, v_.length, 1) reverse(v_) e_: b_.PrependUint8(e_) - b_.EndVector(v_.length) + return b_.EndVector(v_.length) def MonsterEnd(b_:flatbuffers_builder): - b_.EndObject() + return b_.EndObject() -struct TypeAliases : flatbuffers_handle +class TypeAliases : flatbuffers_handle def i8(): - buf_.flatbuffers_field_int8(pos_, 4, 0) + return buf_.flatbuffers_field_int8(pos_, 4, 0) def u8(): - buf_.flatbuffers_field_int8(pos_, 6, 0) + return buf_.flatbuffers_field_int8(pos_, 6, 0) def i16(): - buf_.flatbuffers_field_int16(pos_, 8, 0) + return buf_.flatbuffers_field_int16(pos_, 8, 0) def u16(): - buf_.flatbuffers_field_int16(pos_, 10, 0) + return buf_.flatbuffers_field_int16(pos_, 10, 0) def i32(): - buf_.flatbuffers_field_int32(pos_, 12, 0) + return buf_.flatbuffers_field_int32(pos_, 12, 0) def u32(): - buf_.flatbuffers_field_int32(pos_, 14, 0) + return buf_.flatbuffers_field_int32(pos_, 14, 0) def i64(): - buf_.flatbuffers_field_int64(pos_, 16, 0) + return buf_.flatbuffers_field_int64(pos_, 16, 0) def u64(): - buf_.flatbuffers_field_int64(pos_, 18, 0) + return buf_.flatbuffers_field_int64(pos_, 18, 0) def f32(): - buf_.flatbuffers_field_float32(pos_, 20, 0.0) + return buf_.flatbuffers_field_float32(pos_, 20, 0.0) def f64(): - buf_.flatbuffers_field_float64(pos_, 22, 0.0) + return buf_.flatbuffers_field_float64(pos_, 22, 0.0) def v8(i:int): - buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 24) + i * 1) + return buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 24) + i * 1) def v8_length(): - buf_.flatbuffers_field_vector_len(pos_, 24) + return buf_.flatbuffers_field_vector_len(pos_, 24) def vf64(i:int): - buf_.read_float64_le(buf_.flatbuffers_field_vector(pos_, 26) + i * 8) + return buf_.read_float64_le(buf_.flatbuffers_field_vector(pos_, 26) + i * 8) def vf64_length(): - buf_.flatbuffers_field_vector_len(pos_, 26) + return buf_.flatbuffers_field_vector_len(pos_, 26) -def GetRootAsTypeAliases(buf:string): TypeAliases { buf, buf.flatbuffers_indirect(0) } +def GetRootAsTypeAliases(buf:string): return TypeAliases { buf, buf.flatbuffers_indirect(0) } def TypeAliasesStart(b_:flatbuffers_builder): b_.StartObject(12) @@ -588,7 +587,7 @@ def TypeAliasesStartV8Vector(b_:flatbuffers_builder, n_:int): def TypeAliasesCreateV8Vector(b_:flatbuffers_builder, v_:[int]): b_.StartVector(1, v_.length, 1) reverse(v_) e_: b_.PrependInt8(e_) - b_.EndVector(v_.length) + return b_.EndVector(v_.length) def TypeAliasesAddVf64(b_:flatbuffers_builder, vf64:int): b_.PrependUOffsetTRelativeSlot(11, vf64, 0) def TypeAliasesStartVf64Vector(b_:flatbuffers_builder, n_:int): @@ -596,7 +595,7 @@ def TypeAliasesStartVf64Vector(b_:flatbuffers_builder, n_:int): def TypeAliasesCreateVf64Vector(b_:flatbuffers_builder, v_:[float]): b_.StartVector(8, v_.length, 8) reverse(v_) e_: b_.PrependFloat64(e_) - b_.EndVector(v_.length) + return b_.EndVector(v_.length) def TypeAliasesEnd(b_:flatbuffers_builder): - b_.EndObject() + return b_.EndObject() diff --git a/tests/namespace_test/namespace_test1_generated.lobster b/tests/namespace_test/namespace_test1_generated.lobster index 7c1924f41..42b0859ec 100644 --- a/tests/namespace_test/namespace_test1_generated.lobster +++ b/tests/namespace_test/namespace_test1_generated.lobster @@ -1,36 +1,35 @@ // automatically generated by the FlatBuffers compiler, do not modify - -include "flatbuffers.lobster" +import flatbuffers namespace NamespaceA_NamespaceB -enum + - EnumInNestedNS_A = 0, - EnumInNestedNS_B = 1, +enum EnumInNestedNS: + EnumInNestedNS_A = 0 + EnumInNestedNS_B = 1 EnumInNestedNS_C = 2 -struct TableInNestedNS +class TableInNestedNS -struct StructInNestedNS +class StructInNestedNS -struct TableInNestedNS : flatbuffers_handle +class TableInNestedNS : flatbuffers_handle def foo(): - buf_.flatbuffers_field_int32(pos_, 4, 0) + return buf_.flatbuffers_field_int32(pos_, 4, 0) -def GetRootAsTableInNestedNS(buf:string): TableInNestedNS { buf, buf.flatbuffers_indirect(0) } +def GetRootAsTableInNestedNS(buf:string): return TableInNestedNS { buf, buf.flatbuffers_indirect(0) } def TableInNestedNSStart(b_:flatbuffers_builder): b_.StartObject(1) def TableInNestedNSAddFoo(b_:flatbuffers_builder, foo:int): b_.PrependInt32Slot(0, foo, 0) def TableInNestedNSEnd(b_:flatbuffers_builder): - b_.EndObject() + return b_.EndObject() -struct StructInNestedNS : flatbuffers_handle +class StructInNestedNS : flatbuffers_handle def a(): - buf_.read_int32_le(pos_ + 0) + return buf_.read_int32_le(pos_ + 0) def b(): - buf_.read_int32_le(pos_ + 4) + return buf_.read_int32_le(pos_ + 4) def CreateStructInNestedNS(b_:flatbuffers_builder, a:int, b:int): b_.Prep(4, 8) diff --git a/tests/namespace_test/namespace_test2_generated.lobster b/tests/namespace_test/namespace_test2_generated.lobster index 8b9809bc4..2a7f2519f 100644 --- a/tests/namespace_test/namespace_test2_generated.lobster +++ b/tests/namespace_test/namespace_test2_generated.lobster @@ -1,30 +1,29 @@ // automatically generated by the FlatBuffers compiler, do not modify - -include "flatbuffers.lobster" +import flatbuffers namespace NamespaceA -struct TableInFirstNS +class TableInFirstNS namespace NamespaceC -struct TableInC +class TableInC namespace NamespaceA -struct SecondTableInA +class SecondTableInA -struct TableInFirstNS : flatbuffers_handle +class TableInFirstNS : flatbuffers_handle def foo_table(): - o := buf_.flatbuffers_field_table(pos_, 4) - if o: NamespaceA_NamespaceB_TableInNestedNS { buf_, o } else: nil + let o = buf_.flatbuffers_field_table(pos_, 4) + return if o: NamespaceA_NamespaceB_TableInNestedNS { buf_, o } else: nil def foo_enum(): - buf_.flatbuffers_field_int8(pos_, 6, 0) + return buf_.flatbuffers_field_int8(pos_, 6, 0) def foo_struct(): - o := buf_.flatbuffers_field_struct(pos_, 8) - if o: NamespaceA_NamespaceB_StructInNestedNS { buf_, o } else: nil + let o = buf_.flatbuffers_field_struct(pos_, 8) + return if o: NamespaceA_NamespaceB_StructInNestedNS { buf_, o } else: nil -def GetRootAsTableInFirstNS(buf:string): TableInFirstNS { buf, buf.flatbuffers_indirect(0) } +def GetRootAsTableInFirstNS(buf:string): return TableInFirstNS { buf, buf.flatbuffers_indirect(0) } def TableInFirstNSStart(b_:flatbuffers_builder): b_.StartObject(3) @@ -35,19 +34,19 @@ def TableInFirstNSAddFooEnum(b_:flatbuffers_builder, foo_enum:int): def TableInFirstNSAddFooStruct(b_:flatbuffers_builder, foo_struct:int): b_.PrependStructSlot(2, foo_struct, 0) def TableInFirstNSEnd(b_:flatbuffers_builder): - b_.EndObject() + return b_.EndObject() namespace NamespaceC -struct TableInC : flatbuffers_handle +class TableInC : flatbuffers_handle def refer_to_a1(): - o := buf_.flatbuffers_field_table(pos_, 4) - if o: NamespaceA_TableInFirstNS { buf_, o } else: nil + let o = buf_.flatbuffers_field_table(pos_, 4) + return if o: NamespaceA_TableInFirstNS { buf_, o } else: nil def refer_to_a2(): - o := buf_.flatbuffers_field_table(pos_, 6) - if o: NamespaceA_SecondTableInA { buf_, o } else: nil + let o = buf_.flatbuffers_field_table(pos_, 6) + return if o: NamespaceA_SecondTableInA { buf_, o } else: nil -def GetRootAsTableInC(buf:string): TableInC { buf, buf.flatbuffers_indirect(0) } +def GetRootAsTableInC(buf:string): return TableInC { buf, buf.flatbuffers_indirect(0) } def TableInCStart(b_:flatbuffers_builder): b_.StartObject(2) @@ -56,21 +55,21 @@ def TableInCAddReferToA1(b_:flatbuffers_builder, refer_to_a1:int): def TableInCAddReferToA2(b_:flatbuffers_builder, refer_to_a2:int): b_.PrependUOffsetTRelativeSlot(1, refer_to_a2, 0) def TableInCEnd(b_:flatbuffers_builder): - b_.EndObject() + return b_.EndObject() namespace NamespaceA -struct SecondTableInA : flatbuffers_handle +class SecondTableInA : flatbuffers_handle def refer_to_c(): - o := buf_.flatbuffers_field_table(pos_, 4) - if o: NamespaceC_TableInC { buf_, o } else: nil + let o = buf_.flatbuffers_field_table(pos_, 4) + return if o: NamespaceC_TableInC { buf_, o } else: nil -def GetRootAsSecondTableInA(buf:string): SecondTableInA { buf, buf.flatbuffers_indirect(0) } +def GetRootAsSecondTableInA(buf:string): return SecondTableInA { buf, buf.flatbuffers_indirect(0) } def SecondTableInAStart(b_:flatbuffers_builder): b_.StartObject(1) def SecondTableInAAddReferToC(b_:flatbuffers_builder, refer_to_c:int): b_.PrependUOffsetTRelativeSlot(0, refer_to_c, 0) def SecondTableInAEnd(b_:flatbuffers_builder): - b_.EndObject() + return b_.EndObject()