From 9cfefce1524f98e75e09bc742aa0fec9156262fb Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Fri, 16 Sep 2022 00:02:29 +0300 Subject: [PATCH 01/29] Bfbs Nim Generator --- .github/labeler.yml | 10 +- CMakeLists.txt | 40 +- include/flatbuffers/reflection_generated.h | 28 +- nim/flatbuffers.nimble | 7 + nim/flatbuffers/flatbuffers.nim | 7 + nim/flatbuffers/src/builder.nim | 262 +++++++ nim/flatbuffers/src/endian.nim | 12 + nim/flatbuffers/src/struct.nim | 24 + nim/flatbuffers/src/table.nim | 149 ++++ reflection/reflection.fbs | 3 +- src/BUILD.bazel | 4 + src/bfbs_gen.h | 21 +- src/bfbs_gen_nim.cpp | 656 ++++++++++++++++++ src/bfbs_gen_nim.h | 33 + src/flatc_main.cpp | 7 + src/idl_parser.cpp | 34 +- tests/FlatBuffers.Test.Nim/NimTest.sh | 19 + .../tests/moredefaults/test.nim | 55 ++ .../tests/mutatingbool/test.nim | 43 ++ .../tests/mygame/test.nim | 528 ++++++++++++++ .../tests/optional_scalars/test.nim | 29 + 21 files changed, 1921 insertions(+), 50 deletions(-) create mode 100644 nim/flatbuffers.nimble create mode 100644 nim/flatbuffers/flatbuffers.nim create mode 100644 nim/flatbuffers/src/builder.nim create mode 100644 nim/flatbuffers/src/endian.nim create mode 100644 nim/flatbuffers/src/struct.nim create mode 100644 nim/flatbuffers/src/table.nim create mode 100644 src/bfbs_gen_nim.cpp create mode 100644 src/bfbs_gen_nim.h create mode 100755 tests/FlatBuffers.Test.Nim/NimTest.sh create mode 100644 tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim create mode 100644 tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim create mode 100644 tests/FlatBuffers.Test.Nim/tests/mygame/test.nim create mode 100644 tests/FlatBuffers.Test.Nim/tests/optional_scalars/test.nim diff --git a/.github/labeler.yml b/.github/labeler.yml index eb1d7fdf807..dcab0447e8c 100644 --- a/.github/labeler.yml +++ b/.github/labeler.yml @@ -18,6 +18,12 @@ swift: - tests/swift/** - src/idl_gen_swift.cpp +nim: + - '**/*.nim' + - nim/**/* + - src/idl_gen_nim.cpp + - src/bfbs_gen_nim.cpp + javascript: - '**/*.js' - src/idl_gen_ts.cpp @@ -61,7 +67,7 @@ rust: - '**/*.rs' - rust/**/* - src/idl_gen_rust.cpp - + dart: - '**/*.dart' - src/idl_gen_dart.cpp @@ -88,4 +94,4 @@ CI: grpc: - grpc/**/* - - src/idl_gen_grpc.cpp \ No newline at end of file + - src/idl_gen_grpc.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index f5ae5ac81c7..2caccf77aee 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -71,10 +71,10 @@ option(FLATBUFFERS_ENABLE_PCH Only work if CMake supports 'target_precompile_headers'. \" This can speed up compilation time." OFF) -option(FLATBUFFERS_SKIP_MONSTER_EXTRA +option(FLATBUFFERS_SKIP_MONSTER_EXTRA "Skip generating monster_extra.fbs that contains non-supported numerical\" types." OFF) -option(FLATBUFFERS_STRICT_MODE +option(FLATBUFFERS_STRICT_MODE "Build flatbuffers with all warnings as errors (-Werror or /WX)." OFF) @@ -182,6 +182,7 @@ set(FlatBuffers_Compiler_SRCS src/flatc_main.cpp src/bfbs_gen.h src/bfbs_gen_lua.h + src/bfbs_gen_nim.h src/bfbs_namer.h include/flatbuffers/code_generators.h src/binary_annotator.h @@ -189,6 +190,7 @@ set(FlatBuffers_Compiler_SRCS src/annotated_binary_text_gen.h src/annotated_binary_text_gen.cpp src/bfbs_gen_lua.cpp + src/bfbs_gen_nim.cpp src/code_generators.cpp grpc/src/compiler/schema_interface.h grpc/src/compiler/cpp_generator.h @@ -352,8 +354,8 @@ include_directories(grpc) # Creates an interface library that stores the configuration settings that each # target links too. This is a compromise between setting configuration globally -# with add_compile_options() and the more targetted target_compile_options(). -# This way each target in this file can share settings and override them if +# with add_compile_options() and the more targetted target_compile_options(). +# This way each target in this file can share settings and override them if # needed. add_library(ProjectConfig INTERFACE) target_compile_features(ProjectConfig @@ -369,7 +371,7 @@ set(CMAKE_CXX_EXTENSIONS OFF) if(MSVC_LIKE) target_compile_options(ProjectConfig - INTERFACE + INTERFACE /W4 $<$: /WX # Treat all compiler warnings as errors @@ -401,8 +403,8 @@ else() -Wno-error=stringop-overflow > > - -pedantic - -Wextra + -pedantic + -Wextra -Wno-unused-parameter -Wold-style-cast -fsigned-char @@ -416,7 +418,7 @@ else() $<$,3.8>: -Wimplicit-fallthrough -Wextra-semi - $<$: + $<$: -Werror=unused-private-field > > @@ -425,7 +427,7 @@ else() $<$: $<$,4.4>: -Wunused-result - -Wunused-parameter + -Wunused-parameter -Werror=unused-parameter -Wmissing-declarations > @@ -433,7 +435,7 @@ else() -Wzero-as-null-pointer-constant > $<$,7.0>: - -faligned-new + -faligned-new $<$: -Werror=implicit-fallthrough=2 > @@ -463,7 +465,7 @@ if(FLATBUFFERS_BUILD_FLATLIB) add_library(flatbuffers STATIC ${FlatBuffers_Library_SRCS}) # Attach header directory for when build via add_subdirectory(). - target_include_directories(flatbuffers + target_include_directories(flatbuffers INTERFACE $ ) @@ -481,7 +483,7 @@ if(FLATBUFFERS_BUILD_FLATC) endif() target_link_libraries(flatc PRIVATE $) - target_compile_options(flatc + target_compile_options(flatc PUBLIC $<$,$>: /MT @@ -682,13 +684,13 @@ if(FLATBUFFERS_BUILD_GRPCTEST) find_package(gRPC CONFIG REQUIRED) add_executable(grpctest ${FlatBuffers_GRPCTest_SRCS}) add_dependencies(grpctest generated_code) - target_link_libraries(grpctext - PRIVATE + target_link_libraries(grpctext + PRIVATE $ - gRPC::grpc++_unsecure - gRPC::gpr + gRPC::grpc++_unsecure + gRPC::gpr pthread - dl + dl ) endif() @@ -701,8 +703,8 @@ if(FLATBUFFERS_INSTALL) configure_file(CMake/flatbuffers-config-version.cmake.in flatbuffers-config-version.cmake @ONLY) install( - FILES - "CMake/flatbuffers-config.cmake" + FILES + "CMake/flatbuffers-config.cmake" "CMake/BuildFlatBuffers.cmake" "${CMAKE_CURRENT_BINARY_DIR}/flatbuffers-config-version.cmake" DESTINATION ${FB_CMAKE_DIR} diff --git a/include/flatbuffers/reflection_generated.h b/include/flatbuffers/reflection_generated.h index 78674db5d42..d8c47edc0a3 100644 --- a/include/flatbuffers/reflection_generated.h +++ b/include/flatbuffers/reflection_generated.h @@ -580,13 +580,14 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_OFFSET = 10, VT_DEFAULT_INTEGER = 12, VT_DEFAULT_REAL = 14, - VT_DEPRECATED = 16, - VT_REQUIRED = 18, - VT_KEY = 20, - VT_ATTRIBUTES = 22, - VT_DOCUMENTATION = 24, - VT_OPTIONAL = 26, - VT_PADDING = 28 + VT_DEFAULT_STRING = 16, + VT_DEPRECATED = 18, + VT_REQUIRED = 20, + VT_KEY = 22, + VT_ATTRIBUTES = 24, + VT_DOCUMENTATION = 26, + VT_OPTIONAL = 28, + VT_PADDING = 30 }; const flatbuffers::String *name() const { return GetPointer(VT_NAME); @@ -612,6 +613,9 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { double default_real() const { return GetField(VT_DEFAULT_REAL, 0.0); } + const flatbuffers::String *default_string() const { + return GetPointer(VT_DEFAULT_STRING); + } bool deprecated() const { return GetField(VT_DEPRECATED, 0) != 0; } @@ -644,6 +648,8 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VerifyField(verifier, VT_OFFSET, 2) && VerifyField(verifier, VT_DEFAULT_INTEGER, 8) && VerifyField(verifier, VT_DEFAULT_REAL, 8) && + VerifyOffset(verifier, VT_DEFAULT_STRING) && + verifier.VerifyString(default_string()) && VerifyField(verifier, VT_DEPRECATED, 1) && VerifyField(verifier, VT_REQUIRED, 1) && VerifyField(verifier, VT_KEY, 1) && @@ -681,6 +687,9 @@ struct FieldBuilder { void add_default_real(double default_real) { fbb_.AddElement(Field::VT_DEFAULT_REAL, default_real, 0.0); } + void add_default_string(flatbuffers::Offset default_string) { + fbb_.AddOffset(Field::VT_DEFAULT_STRING, default_string); + } void add_deprecated(bool deprecated) { fbb_.AddElement(Field::VT_DEPRECATED, static_cast(deprecated), 0); } @@ -723,6 +732,7 @@ inline flatbuffers::Offset CreateField( uint16_t offset = 0, int64_t default_integer = 0, double default_real = 0.0, + flatbuffers::Offset default_string = 0, bool deprecated = false, bool required = false, bool key = false, @@ -735,6 +745,7 @@ inline flatbuffers::Offset CreateField( builder_.add_default_integer(default_integer); builder_.add_documentation(documentation); builder_.add_attributes(attributes); + builder_.add_default_string(default_string); builder_.add_type(type); builder_.add_name(name); builder_.add_padding(padding); @@ -755,6 +766,7 @@ inline flatbuffers::Offset CreateFieldDirect( uint16_t offset = 0, int64_t default_integer = 0, double default_real = 0.0, + const char *default_string = nullptr, bool deprecated = false, bool required = false, bool key = false, @@ -763,6 +775,7 @@ inline flatbuffers::Offset CreateFieldDirect( bool optional = false, uint16_t padding = 0) { auto name__ = name ? _fbb.CreateString(name) : 0; + auto default_string__ = default_string ? _fbb.CreateString(default_string) : 0; auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables(attributes) : 0; auto documentation__ = documentation ? _fbb.CreateVector>(*documentation) : 0; return reflection::CreateField( @@ -773,6 +786,7 @@ inline flatbuffers::Offset CreateFieldDirect( offset, default_integer, default_real, + default_string__, deprecated, required, key, diff --git a/nim/flatbuffers.nimble b/nim/flatbuffers.nimble new file mode 100644 index 00000000000..cc30478117b --- /dev/null +++ b/nim/flatbuffers.nimble @@ -0,0 +1,7 @@ +version = "1.0.0" +author = "flatbuffers" +description = "Flatbuffers" +license = "Apache 2.0" +srcDir = "flatbuffers" + +requires "nim >= 1.4.0" diff --git a/nim/flatbuffers/flatbuffers.nim b/nim/flatbuffers/flatbuffers.nim new file mode 100644 index 00000000000..b9532877e76 --- /dev/null +++ b/nim/flatbuffers/flatbuffers.nim @@ -0,0 +1,7 @@ +import + src/[ + builder, + struct, + table + ] +export flatbuffers.builder, flatbuffers.table, flatbuffers.struct diff --git a/nim/flatbuffers/src/builder.nim b/nim/flatbuffers/src/builder.nim new file mode 100644 index 00000000000..62ac2edb0be --- /dev/null +++ b/nim/flatbuffers/src/builder.nim @@ -0,0 +1,262 @@ +import math +import table + + +const MAX_BUFFER_SIZE* = 2^31 + + +type Builder* = ref object of RootObj + bytes*: seq[byte] + minalign*: int + current_vtable*: seq[uoffset] + objectEnd*: uoffset + vtables*: seq[uoffset] #? + head*: uoffset + nested*: bool + finished*: bool + vectorNumElems*: uoffset + +using this: var Builder + +func newBuilder*(size: int): Builder = + result = new Builder + result.bytes.setLen(size) + result.minalign = 1 + result.head = size.uoffset + result.nested = false + result.finished = false + result.vectorNumElems = 0 + +proc FinishedBytes*(this): seq[byte] = + if not this.finished: + quit("Builder not finished, Incorrect use of FinishedBytes(): must call 'Finish' first.") + result = this.bytes[this.head..^1] + +proc Output*(this): seq[byte] = + if not this.finished: + quit("Builder not finished, Incorrect use of Output(): must call 'Finish' first.") + + result = this.bytes[this.head..^1] + +func Offset*(this): uoffset = + result = this.bytes.len.uoffset - this.head + +proc StartObject*(this; numfields: int) = + if this.nested: + quit("builder is nested") + + this.current_vtable.setLen(numfields) + for i in this.current_vtable.mitems(): + i = 0 + this.objectEnd = this.Offset() + this.nested = true + +proc GrowByteBuffer*(this) = + if this.bytes.len == MAX_BUFFER_SIZE: + quit("flatbuffers: cannot grow buffer beyond 2 gigabytes") + let oldLen = this.bytes.len + var newLen = min(this.bytes.len * 2, MAX_BUFFER_SIZE) + if newLen == 0: + newLen = 1 + this.bytes.setLen(newLen) + var j = this.bytes.len - 1 + while j >= 0: + if j >= newLen - oldLen: + this.bytes[j] = this.bytes[j - (newLen - oldLen)] + else: + this.bytes[j] = 0 + dec(j) + +proc Place*[T](this; x: T) = + this.head -= uoffset x.sizeof + WriteVal(this.bytes, this.head, x) + +func Pad*(this; n: int) = + for i in 0.. this.minalign: + this.minalign = size + var alignsize = (not (this.bytes.len - this.head.int + additionalBytes)) + 1 + alignsize = alignsize and (size - 1) + + while this.head.int < alignsize + size + additionalBytes: + let oldbufSize = this.bytes.len + this.GrowByteBuffer() + this.head = (this.head.int + this.bytes.len - oldbufSize).uoffset + this.Pad(alignsize) + +proc PrependOffsetRelative*[T: Offsets](this; off: T) = + when T is voffset: + this.Prep(T.sizeof, 0) + if not off.uoffset <= this.Offset: + quit("flatbuffers: Offset arithmetic error.") + this.Place(off) + else: + this.Prep(T.sizeof, 0) + if not off.uoffset <= this.Offset: + quit("flatbuffers: Offset arithmetic error.") + let off2: T = this.Offset.T - off + sizeof(T).T + this.Place(off2) + + +proc Prepend*[T](this; x: T) = + this.Prep(x.sizeof, 0) + this.Place(x) + +proc Slot*(this; slotnum: int) = + this.current_vtable[slotnum] = this.Offset + +proc PrependSlot*[T](this; o: int; x, d: T) = + if x != d: + when T is uoffset or T is soffset or T is voffset: + this.PrependOffsetRelative(x) + else: + this.Prepend(x) + this.Slot(o) + +proc AssertStuctInline(this; obj: uoffset) = + if obj != this.Offset: + quit("flatbuffers: Tried to write a Struct at an Offset that is different from the current Offset of the Builder.") + +proc PrependStructSlot*(this; o: int; x: uoffset; d: uoffset) = + if x != d: + this.AssertStuctInline(x) + this.Slot(o) + +proc Add*[T](this; n: T) = + this.Prep(T.sizeof, 0) + WriteVal(this.bytes, this.head, n) + +proc VtableEqual*(a: seq[uoffset]; objectStart: uoffset; b: seq[byte]): bool = + if a.len * voffset.sizeof != b.len: + return false + + var i = 0 + while i < a.len: + var seq = b[i * voffset.sizeof..<(i + 1) * voffset.sizeof] + let x = GetVal[voffset](addr seq) + + if x == 0 and a[i] == 0: + inc i + continue + + let y = objectStart.soffset - a[i].soffset + if x.soffset != y: + return false + inc i + return true + +proc WriteVtable*(this): uoffset = + this.PrependOffsetRelative(0.soffset) + + let objectOffset = this.Offset + var existingVtable = uoffset 0 + + var i = this.current_vtable.len - 1 + while i >= 0 and this.current_vtable[i] == 0: dec i + + this.current_vtable = this.current_vtable[0..i] + for i in countdown(this.vtables.len - 1, 0): + let + vt2Offset: uoffset = this.vtables[i] + vt2Start: int = this.bytes.len - int vt2Offset + + var seq = this.bytes[vt2Start..cbegin(); it != objects->cend(); ++it) { func(*it); } } -static void ForAllEnumValues(const reflection::Enum *enum_def, - std::function func) { +static void ForAllEnumValues( + const reflection::Enum *enum_def, + std::function func) { for (auto it = enum_def->values()->cbegin(); it != enum_def->values()->cend(); ++it) { func(*it); @@ -91,7 +92,7 @@ static bool IsVector(const reflection::BaseType base_type) { return base_type == reflection::Vector; } -} // namespace +} // namespace // A concrete base Flatbuffer Generator that specific language generators can // derive from. @@ -130,17 +131,23 @@ class BaseBfbsGenerator : public BfbsGenerator { } protected: - const reflection::Object *GetObject(const reflection::Type *type) const { - if (type->index() >= 0 && IsStructOrTable(type->base_type())) { + const reflection::Object *GetObject(const reflection::Type *type, + bool element_type = false) const { + const reflection::BaseType base_type = + element_type ? type->element() : type->base_type(); + if (type->index() >= 0 && IsStructOrTable(base_type)) { return GetObjectByIndex(type->index()); } return nullptr; } - const reflection::Enum *GetEnum(const reflection::Type *type) const { + const reflection::Enum *GetEnum(const reflection::Type *type, + bool element_type = false) const { + const reflection::BaseType base_type = + element_type ? type->element() : type->base_type(); // TODO(derekbailey): it would be better to have a explicit list of allowed // base types, instead of negating Obj types. - if (type->index() >= 0 && !IsStructOrTable(type->base_type())) { + if (type->index() >= 0 && !IsStructOrTable(base_type)) { return GetEnumByIndex(type->index()); } return nullptr; diff --git a/src/bfbs_gen_nim.cpp b/src/bfbs_gen_nim.cpp new file mode 100644 index 00000000000..7e7118c3728 --- /dev/null +++ b/src/bfbs_gen_nim.cpp @@ -0,0 +1,656 @@ +/* + * Copyright 2021 Google Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "bfbs_gen_nim.h" + +#include +#include +#include +#include +#include +#include + +// Ensure no includes to flatc internals. bfbs_gen.h and generator.h are OK. +#include "bfbs_gen.h" +#include "bfbs_namer.h" +#include "flatbuffers/bfbs_generator.h" + +// The intermediate representation schema. +#include "flatbuffers/reflection.h" +#include "flatbuffers/reflection_generated.h" + +namespace flatbuffers { +namespace { + +// To reduce typing +namespace r = ::reflection; + +std::set NimKeywords() { + return { + "addr", "and", "as", "asm", "bind", "block", + "break", "case", "cast", "concept", "const", "continue", + "converter", "defer", "discard", "distinct", "div", "do", + "elif", "else", "end", "enum", "except", "export", + "finally", "for", "from", "func", "if", "import", + "in", "include", "interface", "is", "isnot", "iterator", + "let", "macro", "method", "mixin", "mod", "nil", + "not", "notin", "object", "of", "or", "out", + "proc", "ptr", "raise", "ref", "return", "shl", + "shr", "static", "template", "try", "tuple", "type", + "using", "var", "when", "while", "xor", "yield", + }; +} + +Namer::Config NimDefaultConfig() { + return { /*types=*/Case::kKeep, + /*constants=*/Case::kScreamingSnake, + /*methods=*/Case::kUpperCamel, + /*functions=*/Case::kUpperCamel, + /*fields=*/Case::kLowerCamel, + /*variable=*/Case::kLowerCamel, + /*variants=*/Case::kKeep, + /*enum_variant_seperator=*/".", + /*escape_keywords=*/Namer::Config::Escape::AfterConvertingCase, + /*namespaces=*/Case::kKeep, + /*namespace_seperator=*/"/", + /*object_prefix=*/"", + /*object_suffix=*/"T", + /*keyword_prefix=*/"", + /*keyword_suffix=*/"_", + /*filenames=*/Case::kKeep, + /*directories=*/Case::kKeep, + /*output_path=*/"", + /*filename_suffix=*/"", + /*filename_extension=*/".nim" }; +} + +const std::string Indent = " "; +const std::string Export = "*"; +const std::set builtin_types = { + "uint8", "uint8", "bool", "int8", "uint8", "int16", + "uint16", "int32", "uint32", "int64", "uint64", "float32", + "float64", "string", "int", "uint", "uoffset", "Builder" +}; + +// Returns the correct name for the type +// Type: +// MyGame.Example.Monster: +// Current: +// Monster +// Imported: +// MyGame_Example_Monster.Monster +std::string Denamespace(const std::string &s, bool current = false) { + if (builtin_types.find(s) != builtin_types.end()) { return s; } + std::string prefix; + const size_t pos = s.find_last_of("."); + if (pos != std::string::npos) { prefix = s.substr(0, pos); } + std::string suffix = s.substr(pos + 1); + if (current) { + return suffix; + } else { + std::string underscored = prefix; + underscored += underscored.empty() ? "" : "_"; + std::replace(underscored.begin(), underscored.end(), '.', '_'); + return underscored + suffix + "." + suffix; + } +} + +class NimBfbsGenerator : public BaseBfbsGenerator { + public: + explicit NimBfbsGenerator(const std::string &flatc_version) + : BaseBfbsGenerator(), + keywords_(), + imports_(), + current_obj_(nullptr), + current_enum_(nullptr), + flatc_version_(flatc_version), + namer_(NimDefaultConfig(), NimKeywords()) {} + + GeneratorStatus GenerateFromSchema(const r::Schema *schema) + FLATBUFFERS_OVERRIDE { + ForAllEnums(schema->enums(), [&](const r::Enum *enum_def) { + StartCodeBlock(enum_def); + GenerateEnum(enum_def); + }); + ForAllObjects(schema->objects(), [&](const r::Object *object) { + StartCodeBlock(object); + GenerateObject(object, schema->root_table()); + }); + return OK; + } + + uint64_t SupportedAdvancedFeatures() const FLATBUFFERS_OVERRIDE { + return 0xF; + } + + protected: + void GenerateEnum(const r::Enum *enum_def) { + std::string code; + + std::string ns; + const std::string enum_name = namer_.Type(namer_.Denamespace(enum_def, ns)); + const std::string enum_type = + GenerateTypeBasic(enum_def->underlying_type()); + + GenerateDocumentation(enum_def->documentation(), "", code); + code += "type " + enum_name + Export + "{.pure.} = enum\n"; + + ForAllEnumValues(enum_def, [&](const reflection::EnumVal *enum_val) { + GenerateDocumentation(enum_val->documentation(), " ", code); + code += " " + namer_.Variant(enum_val->name()->str()) + " = " + + NumToString(enum_val->value()) + "." + enum_type + ",\n"; + }); + + EmitCodeBlock(code, enum_name, ns, enum_def->declaration_file()->str()); + } + + void GenerateObject(const r::Object *object, const r::Object *root_object) { + // Register the main flatbuffers module. + RegisterImports("flatbuffers", ""); + std::string code; + + std::string ns; + const std::string object_name = namer_.Type(namer_.Denamespace(object, ns)); + + GenerateDocumentation(object->documentation(), "", code); + code += "type " + object_name + "* = object of FlatObj\n"; + + // Create all the field accessors. + ForAllFields(object, /*reverse=*/false, [&](const r::Field *field) { + // Skip writing deprecated fields altogether. + if (field->deprecated()) { return; } + + const std::string field_name = namer_.Field(field->name()->str()); + const r::BaseType base_type = field->type()->base_type(); + std::string field_type = GenerateType(field->type()); + + if (field->optional() && !object->is_struct()) { + RegisterImports("std/options", ""); + field_type = "Option[" + field_type + "]"; + } + + const std::string offset_prefix = + "let o = self.tab.Offset(" + NumToString(field->offset()) + ")\n"; + const std::string offset_prefix_2 = "if o != 0:\n"; + + if (IsScalar(base_type) || base_type == r::String || + base_type == r::Obj || base_type == r::Union) { + GenerateDocumentation(field->documentation(), "", code); + + std::string getter_signature = "func " + field_name + + "*(self: " + object_name + + "): " + field_type + " =\n"; + std::string getter_code; + std::string setter_signature = "func `" + field_name + + "=`*(self: var " + object_name + + ", n: " + field_type + "): bool =\n"; + std::string setter_code; + + if (base_type == r::Obj || base_type == r::Union || + field->type()->index() >= 0) { + RegisterImports(object, field); + } + + if (object->is_struct()) { + std::string field_getter = + ReplaceString(GenerateGetter(field->type()), "{offset}", + NumToString(field->offset())); + getter_code += " return " + field_getter + "\n"; + + // TODO: parser opts: + // if (parser_.opts.m utable_buffer) { + if (IsScalar(base_type)) { + setter_code += " return self.tab.Mutate(self.tab.Pos + " + + NumToString(field->offset()) + ", n)\n"; + } + //} + } else { + // Table accessors + getter_code += " " + offset_prefix; + getter_code += " " + offset_prefix_2; + std::string field_getter = + ReplaceString(GenerateGetter(field->type()), "{offset}", "o"); + if (field->optional()) { + field_getter = "some(" + field_getter + ")"; + } + getter_code += " return " + field_getter + "\n"; + if (!field->optional()) { + getter_code += " return " + DefaultValue(object, field) + "\n"; + } + + // TODO: parser opts: + // if (parser_.opts.mutable_buffer) { + if (IsScalar(base_type)) { + setter_code += " return self.tab.MutateSlot(" + + NumToString(field->offset()) + ", n)\n"; + } + //} + } + code += getter_signature + getter_code; + // if (parser_.opts.mutable_buffer) { + if (IsScalar(base_type)) { code += setter_signature + setter_code; } + //} + } else if (base_type == r::Array || base_type == r::Vector) { + const r::BaseType vector_base_type = field->type()->element(); + int32_t element_size = field->type()->element_size(); + + if (vector_base_type == r::Obj || vector_base_type == r::Union || + field->type()->index() >= 0) { + RegisterImports(object, field, true); + } + + // Get vector length: + code += "func " + field_name + "Length*(self: " + object_name + + "): int = \n"; + code += " " + offset_prefix; + code += " " + offset_prefix_2; + code += " return self.tab.VectorLen(o)\n"; + + // Get single vector field: + code += "func " + field_name + "*(self: " + object_name + + ", j: int): " + GenerateType(field->type(), true) + " = \n"; + code += " " + offset_prefix; + code += " " + offset_prefix_2; + code += " var x = self.tab.Vector(o)\n"; + code += + " x += j.uoffset * " + NumToString(element_size) + ".uoffset\n"; + code += " return " + + ReplaceString(GenerateGetter(field->type(), true), "{offset}", + "x") + + "\n"; + + // Get entire vector: + code += "func " + field_name + "*(self: " + object_name + + "): " + GenerateType(field->type()) + " = \n"; + code += " let len = self." + field_name + "Length\n"; + code += " for i in countup(0, len - 1):\n"; + code += " result.add(self." + field_name + "(i))\n"; + + (void)IsSingleByte(vector_base_type); // Unused exception + } + }); + + // Create all the builders + if (object->is_struct()) { + code += "proc " + object_name + "Create*(self: var Builder"; + code += GenerateStructBuilderArgs(object); + code += "): uoffset =\n"; + code += AppendStructBuilderBody(object); + code += " return self.Offset()\n"; + } else { + // Table builders + code += "proc " + object_name + "Start*(builder: var Builder) =\n"; + code += " builder.StartObject(" + NumToString(object->fields()->size()) + + ")\n"; + + ForAllFields(object, /*reverse=*/false, [&](const r::Field *field) { + if (field->deprecated()) { return; } + + const std::string field_name = namer_.Field(field->name()->str()); + const std::string variable_name = namer_.Variable(field->name()->str()); + const std::string variable_type = GenerateTypeBasic(field->type()); + + code += "proc " + object_name + "Add" + field_name + + "*(builder: var Builder, " + variable_name + ": " + + variable_type + ") =\n"; + code += " builder.Prepend" + GenerateMethod(field) + "Slot(" + + NumToString(field->id()) + ", " + variable_name + ", default(" + + variable_type + "))\n"; + + if (IsVector(field->type()->base_type())) { + code += "proc " + object_name + "Start" + field_name + + "Vector*(builder: var Builder, numElems: uoffset) =\n"; + + const int32_t element_size = field->type()->element_size(); + int32_t alignment = element_size; + if (IsStruct(field->type(), /*use_element=*/true)) { + alignment = GetObjectByIndex(field->type()->index())->minalign(); + } + + code += " builder.StartVector(" + NumToString(element_size) + + ", numElems, " + NumToString(alignment) + ")\n"; + } + }); + + code += "proc " + object_name + "End*(builder: var Builder): uoffset =\n"; + code += " return builder.EndObject()\n"; + } + EmitCodeBlock(code, object_name, ns, object->declaration_file()->str()); + } + + private: + void GenerateDocumentation( + const flatbuffers::Vector> + *documentation, + std::string indent, std::string &code) const { + flatbuffers::ForAllDocumentation( + documentation, [&](const flatbuffers::String *str) { + code += indent + "# " + str->str() + "\n"; + }); + } + + std::string GenerateStructBuilderArgs(const r::Object *object, + std::string prefix = "") const { + std::string signature; + ForAllFields(object, /*reverse=*/false, [&](const r::Field *field) { + if (IsStructOrTable(field->type()->base_type())) { + const r::Object *field_object = GetObject(field->type()); + signature += GenerateStructBuilderArgs( + field_object, prefix + namer_.Variable(field->name()->str()) + "_"); + } else { + signature += ", " + prefix + namer_.Variable(field->name()->str()) + + ": " + GenerateType(field->type()); + } + }); + return signature; + } + + std::string AppendStructBuilderBody(const r::Object *object, + std::string prefix = "") const { + std::string code; + code += " self.Prep(" + NumToString(object->minalign()) + ", " + + NumToString(object->bytesize()) + ")\n"; + + // We need to reverse the order we iterate over, since we build the + // buffer backwards. + ForAllFields(object, /*reverse=*/true, [&](const r::Field *field) { + const int32_t num_padding_bytes = field->padding(); + if (num_padding_bytes) { + code += " self.Pad(" + NumToString(num_padding_bytes) + ")\n"; + } + if (IsStructOrTable(field->type()->base_type())) { + const r::Object *field_object = GetObject(field->type()); + code += AppendStructBuilderBody( + field_object, prefix + namer_.Variable(field->name()->str()) + "_"); + } else { + code += " self.Prepend(" + prefix + + namer_.Variable(field->name()->str()) + ")\n"; + } + }); + + return code; + } + + std::string GenerateMethod(const r::Field *field) const { + const r::BaseType base_type = field->type()->base_type(); + if (IsStructOrTable(base_type)) { return "Struct"; } + return ""; + } + + std::string GenerateGetter(const r::Type *type, + bool element_type = false) const { + const r::BaseType base_type = + element_type ? type->element() : type->base_type(); + std::string offset = "{offset}"; + if (!element_type) { offset = "self.tab.Pos + " + offset; } + switch (base_type) { + case r::String: return "self.tab.String(" + offset + ")"; + case r::Union: return "self.tab.Union({offset})"; + case r::Obj: { + return GenerateType(type, element_type) + + "(tab: Vtable(Bytes: self.tab.Bytes, Pos: " + offset + "))"; + } + case r::Vector: return GenerateGetter(type, true); + default: + const r::Enum *type_enum = GetEnum(type, element_type); + if (type_enum != nullptr) { + return GenerateType(type, element_type) + "(" + "Get[" + + GenerateType(base_type) + "](self.tab, " + offset + ")" + ")"; + } else { + return "Get[" + GenerateType(base_type) + "](self.tab, " + offset + + ")"; + } + } + } + + std::string GenerateType(const r::Type *type, bool element_type = false, + bool enum_inner = false) const { + const r::BaseType base_type = + element_type ? type->element() : type->base_type(); + if (IsScalar(base_type) && !enum_inner) { + const r::Enum *type_enum = GetEnum(type, element_type); + if (type_enum != nullptr) { + std::string type_name = type_enum->name()->str(); + return Denamespace(namer_.Type(type_name)); + } + } + if (IsScalar(base_type)) { return Denamespace(GenerateType(base_type)); } + switch (base_type) { + case r::String: return "string"; + case r::Vector: { + return "seq[" + GenerateType(type, true) + "]"; + } + case r::Union: return "Vtable"; + case r::Obj: { + const r::Object *type_obj = GetObject(type, element_type); + std::string type_name = type_obj->name()->str(); + return Denamespace(namer_.Type(type_name), type_obj == current_obj_); + } + default: return "uoffset"; + } + } + + std::string GenerateTypeBasic(const r::Type *type, + bool element_type = false) const { + const r::BaseType base_type = + element_type ? type->element() : type->base_type(); + if (IsScalar(base_type)) { + return GenerateType(base_type); + } else { + return "uoffset"; + } + } + + std::string ReplaceString(std::string subject, const std::string &search, + const std::string &replace) { + size_t pos = subject.find(search, 0); + if (pos != std::string::npos) { + subject.replace(pos, search.length(), replace); + } + return subject; + } + + std::string GenerateType(const r::BaseType base_type) const { + switch (base_type) { + case r::None: return "uint8"; + case r::UType: return "uint8"; + case r::Bool: return "bool"; + case r::Byte: return "int8"; + case r::UByte: return "uint8"; + case r::Short: return "int16"; + case r::UShort: return "uint16"; + case r::Int: return "int32"; + case r::UInt: return "uint32"; + case r::Long: return "int64"; + case r::ULong: return "uint64"; + case r::Float: return "float32"; + case r::Double: return "float64"; + case r::String: return "string"; + default: return r::EnumNameBaseType(base_type); + } + } + + std::string DefaultValue(const r::Object *object, + const r::Field *field) const { + const r::BaseType base_type = field->type()->base_type(); + if (IsFloatingPoint(base_type)) { + return NumToString(field->default_real()); + } + if (IsBool(base_type)) { + return field->default_integer() ? "true" : "false"; + } + if (IsScalar(base_type)) { + const r::Enum *type_enum = GetEnum(field->type()); + if (type_enum != nullptr) { + return "type(result)(" + NumToString((field->default_integer())) + ")"; + } + return NumToString((field->default_integer())); + } + if (base_type == r::String) { + return "\"" + field->default_string()->str() + "\""; + } + // represents offsets + return "0"; + } + + void StartCodeBlock(const reflection::Enum *enum_def) { + current_enum_ = enum_def; + current_obj_ = nullptr; + imports_.clear(); + } + + void StartCodeBlock(const reflection::Object *object) { + current_enum_ = nullptr; + current_obj_ = object; + imports_.clear(); + } + + std::vector StringSplit(const std::string orig_str, + const std::string token) { + std::vector result; + std::string str = orig_str; + while (str.size()) { + size_t index = str.find(token); + if (index != std::string::npos) { + result.push_back(str.substr(0, index)); + str = str.substr(index + token.size()); + if (str.size() == 0) result.push_back(str); + } else { + result.push_back(str); + str = ""; + } + } + return result; + } + + std::string GetRelativePathFromNamespace(const std::string &relative_to, + const std::string &str2) { + std::vector relative_to_vec = StringSplit(relative_to, "."); + std::vector str2_vec = StringSplit(str2, "."); + while (relative_to_vec.size() > 0 && str2_vec.size() > 0) { + if (relative_to_vec[0] == str2_vec[0]) { + relative_to_vec.erase(relative_to_vec.begin()); + str2_vec.erase(str2_vec.begin()); + } else { + break; + } + } + relative_to_vec.pop_back(); + for (size_t i = 0; i < relative_to_vec.size(); ++i) { + str2_vec.insert(str2_vec.begin(), std::string("..")); + } + + std::string new_path; + for (size_t i = 0; i < str2_vec.size(); ++i) { + new_path += str2_vec[i]; + if (i != str2_vec.size() - 1) { new_path += "/"; } + } + return new_path; + } + + std::string RegisterImports(const r::Object *object, const r::Field *field, + bool use_element = false) { + std::string type_name; + + const r::BaseType type = + use_element ? field->type()->element() : field->type()->base_type(); + + if (IsStructOrTable(type)) { + const r::Object *object = GetObjectByIndex(field->type()->index()); + if (object == current_obj_) { return namer_.Denamespace(object); } + type_name = object->name()->str(); + } else { + const r::Enum *enum_def = GetEnumByIndex(field->type()->index()); + if (enum_def == current_enum_) { return namer_.Denamespace(enum_def); } + type_name = enum_def->name()->str(); + } + + std::string name = type_name; + std::replace(name.begin(), name.end(), '.', '_'); + std::string import_path = + GetRelativePathFromNamespace(object->name()->str(), type_name); + return RegisterImports(import_path, name); + } + + std::string RegisterImports(const std::string &local_name, + const std::string &imports_name) { + imports_[local_name] = imports_name; + return local_name; + } + + void EmitCodeBlock(const std::string &code_block, const std::string &name, + const std::string &ns, const std::string &declaring_file) { + const std::string full_qualified_name = ns.empty() ? name : ns + "." + name; + + std::string code = "#[ " + full_qualified_name + "\n"; + code += + " Automatically generated by the FlatBuffers compiler, do not " + "modify.\n"; + code += " Or modify. I'm a message, not a cop.\n"; + code += "\n"; + code += " flatc version: " + flatc_version_ + "\n"; + code += "\n"; + code += " Declared by : " + declaring_file + "\n"; + if (schema_->root_table() != nullptr) { + const std::string root_type = schema_->root_table()->name()->str(); + const std::string root_file = + schema_->root_table()->declaration_file()->str(); + code += " Rooting type : " + root_type + " (" + root_file + ")\n"; + } + code += "]#\n\n"; + + if (!imports_.empty()) { + for (auto it = imports_.cbegin(); it != imports_.cend(); ++it) { + if (it->second.empty()) { + code += "import " + it->first + "\n"; + } else { + code += "import " + it->first + " as " + it->second + "\n"; + } + } + code += "\n"; + } + code += code_block; + + // Namespaces are '.' deliminted, so replace it with the path separator. + std::string path = ns; + + if (ns.empty()) { + path = "."; + } else { + std::replace(path.begin(), path.end(), '.', '/'); + } + + // TODO(derekbailey): figure out a save file without depending on util.h + EnsureDirExists(path); + const std::string file_name = path + "/" + namer_.File(name); + SaveFile(file_name.c_str(), code, false); + } + + std::unordered_set keywords_; + std::map imports_; + const r::Object *current_obj_; + const r::Enum *current_enum_; + const std::string flatc_version_; + const BfbsNamer namer_; +}; +} // namespace + +std::unique_ptr NewNimBfbsGenerator( + const std::string &flatc_version) { + return std::unique_ptr(new NimBfbsGenerator(flatc_version)); +} + +} // namespace flatbuffers diff --git a/src/bfbs_gen_nim.h b/src/bfbs_gen_nim.h new file mode 100644 index 00000000000..80be16d0141 --- /dev/null +++ b/src/bfbs_gen_nim.h @@ -0,0 +1,33 @@ +/* + * Copyright 2021 Google Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef FLATBUFFERS_BFBS_GEN_NIM_H_ +#define FLATBUFFERS_BFBS_GEN_NIM_H_ + +#include +#include + +#include "flatbuffers/bfbs_generator.h" + +namespace flatbuffers { + +// Constructs a new Nim Code generator. +std::unique_ptr NewNimBfbsGenerator( + const std::string &flatc_version); + +} // namespace flatbuffers + +#endif // FLATBUFFERS_BFBS_GEN_NIM_H_ diff --git a/src/flatc_main.cpp b/src/flatc_main.cpp index b4c4251c4cb..f2aa781a376 100644 --- a/src/flatc_main.cpp +++ b/src/flatc_main.cpp @@ -18,6 +18,7 @@ #include #include "bfbs_gen_lua.h" +#include "bfbs_gen_nim.h" #include "flatbuffers/base.h" #include "flatbuffers/flatc.h" #include "flatbuffers/util.h" @@ -56,6 +57,8 @@ int main(int argc, const char *argv[]) { std::unique_ptr bfbs_gen_lua = flatbuffers::NewLuaBfbsGenerator(flatbuffers_version); + std::unique_ptr bfbs_gen_nim = + flatbuffers::NewNimBfbsGenerator(flatbuffers_version); g_program_name = argv[0]; @@ -142,6 +145,10 @@ int main(int argc, const char *argv[]) { flatbuffers::FlatCOption{ "", "swift", "", "Generate Swift files for tables/structs" }, nullptr, nullptr, nullptr }, + { nullptr, "Nim", true, nullptr, flatbuffers::IDLOptions::kNim, + flatbuffers::FlatCOption{ "", "nim", "", + "Generate Nim files for tables/structs" }, + nullptr, bfbs_gen_nim.get(), nullptr }, }; flatbuffers::FlatCompiler::InitParams params; diff --git a/src/idl_parser.cpp b/src/idl_parser.cpp index cadcb6a09fc..3a0a0e2947e 100644 --- a/src/idl_parser.cpp +++ b/src/idl_parser.cpp @@ -1584,7 +1584,6 @@ CheckedError Parser::ParseVectorDelimiters(uoffset_t &count, F body) { return NoError(); } - CheckedError Parser::ParseAlignAttribute(const std::string &align_constant, size_t min_align, size_t *align) { // Use uint8_t to avoid problems with size_t==`unsigned long` on LP64. @@ -2550,7 +2549,8 @@ bool Parser::SupportsOptionalScalars(const flatbuffers::IDLOptions &opts) { IDLOptions::kRust | IDLOptions::kSwift | IDLOptions::kLobster | IDLOptions::kKotlin | IDLOptions::kCpp | IDLOptions::kJava | IDLOptions::kCSharp | IDLOptions::kTs | IDLOptions::kBinary | - IDLOptions::kGo | IDLOptions::kPython | IDLOptions::kJson; + IDLOptions::kGo | IDLOptions::kPython | IDLOptions::kJson | + IDLOptions::kNim; unsigned long langs = opts.lang_to_generate; return (langs > 0 && langs < IDLOptions::kMAX) && !(langs & ~supported_langs); } @@ -2561,7 +2561,7 @@ bool Parser::SupportsOptionalScalars() const { bool Parser::SupportsDefaultVectorsAndStrings() const { static FLATBUFFERS_CONSTEXPR unsigned long supported_langs = - IDLOptions::kRust | IDLOptions::kSwift; + IDLOptions::kRust | IDLOptions::kSwift | IDLOptions::kNim; return !(opts.lang_to_generate & ~supported_langs); } @@ -2569,7 +2569,7 @@ bool Parser::SupportsAdvancedUnionFeatures() const { return (opts.lang_to_generate & ~(IDLOptions::kCpp | IDLOptions::kTs | IDLOptions::kPhp | IDLOptions::kJava | IDLOptions::kCSharp | IDLOptions::kKotlin | - IDLOptions::kBinary | IDLOptions::kSwift)) == 0; + IDLOptions::kBinary | IDLOptions::kSwift | IDLOptions::kNim)) == 0; } bool Parser::SupportsAdvancedArrayFeatures() const { @@ -3413,7 +3413,6 @@ CheckedError Parser::CheckPrivatelyLeakedFields(const Definition &def, return NoError(); } - CheckedError Parser::DoParse(const char *source, const char **include_paths, const char *source_filename, const char *include_filename) { @@ -3772,6 +3771,8 @@ Offset FieldDef::Serialize(FlatBufferBuilder *builder, auto docs__ = parser.opts.binary_schema_comments ? builder->CreateVectorOfStrings(doc_comment) : 0; + auto default_string__ = + builder->CreateString(IsString(value.type) ? value.constant : ""); double d; StringToNumber(value.constant.c_str(), &d); return reflection::CreateField( @@ -3779,8 +3780,9 @@ Offset FieldDef::Serialize(FlatBufferBuilder *builder, // Is uint64>max(int64) tested? IsInteger(value.type.base_type) ? StringToInt(value.constant.c_str()) : 0, // result may be platform-dependent if underlying is float (not double) - IsFloat(value.type.base_type) ? d : 0.0, deprecated, IsRequired(), key, - attr__, docs__, IsOptional(), static_cast(padding)); + IsFloat(value.type.base_type) ? d : 0.0, default_string__, deprecated, + IsRequired(), key, attr__, docs__, IsOptional(), + static_cast(padding)); // TODO: value.constant is almost always "0", we could save quite a bit of // space by sharing it. Same for common values of value.type. } @@ -3936,12 +3938,16 @@ bool EnumVal::Deserialize(const Parser &parser, } Offset Type::Serialize(FlatBufferBuilder *builder) const { + size_t element_size = SizeOf(element); + if (base_type == BASE_TYPE_VECTOR && element == BASE_TYPE_STRUCT) { + element_size = struct_def->bytesize; + } return reflection::CreateType( *builder, static_cast(base_type), static_cast(element), struct_def ? struct_def->index : (enum_def ? enum_def->index : -1), fixed_length, static_cast(SizeOf(base_type)), - static_cast(SizeOf(element))); + static_cast(element_size)); } bool Type::Deserialize(const Parser &parser, const reflection::Type *type) { @@ -4120,7 +4126,7 @@ std::string Parser::ConformTo(const Parser &base) { struct_def.defined_namespace->GetFullyQualifiedName(struct_def.name); auto struct_def_base = base.LookupStruct(qualified_name); if (!struct_def_base) continue; - std::set renamed_fields; + std::set renamed_fields; for (auto fit = struct_def.fields.vec.begin(); fit != struct_def.fields.vec.end(); ++fit) { auto &field = **fit; @@ -4149,15 +4155,15 @@ std::string Parser::ConformTo(const Parser &base) { } } } - //deletion of trailing fields are not allowed + // deletion of trailing fields are not allowed for (auto fit = struct_def_base->fields.vec.begin(); - fit != struct_def_base->fields.vec.end(); ++fit ) { + fit != struct_def_base->fields.vec.end(); ++fit) { auto &field_base = **fit; - //not a renamed field + // not a renamed field if (renamed_fields.find(&field_base) == renamed_fields.end()) { auto field = struct_def.fields.Lookup(field_base.name); - if (!field) { - return "field deleted: " + qualified_name + "." + field_base.name; + if (!field) { + return "field deleted: " + qualified_name + "." + field_base.name; } } } diff --git a/tests/FlatBuffers.Test.Nim/NimTest.sh b/tests/FlatBuffers.Test.Nim/NimTest.sh new file mode 100755 index 00000000000..24e9a54159c --- /dev/null +++ b/tests/FlatBuffers.Test.Nim/NimTest.sh @@ -0,0 +1,19 @@ +nim_dir=`pwd` +cd .. +test_dir=`pwd` +alias flatc='${test_dir}/../build/flatc' +shopt -s expand_aliases + +mkdir -p ${nim_dir}/generated +cd ${nim_dir}/generated/ +flatc --nim --gen-mutable -I ${test_dir}/include_test ${test_dir}/monster_test.fbs +flatc --nim ${test_dir}/optional_scalars.fbs +flatc --nim ${test_dir}/more_defaults.fbs +flatc --nim --gen-mutable ${test_dir}/MutatingBool.fbs +cd ${nim_dir} + +testament --megatest:off all +rm -r ${nim_dir}/generated +rm -r ${nim_dir}/nimcache +rm -r ${nim_dir}/testresults +rm -r ${nim_dir}/tests/*/test diff --git a/tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim b/tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim new file mode 100644 index 00000000000..417467a694b --- /dev/null +++ b/tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim @@ -0,0 +1,55 @@ +discard """ + action: "run" + exitcode: 0 + timeout: 60.0 +""" +import std/unittest +import flatbuffers +import ../../generated/MoreDefaults + +suite "TestMoreDefaults": + + test "testFlatbuffersObject": + var fbb = newBuilder(0) + fbb.MoreDefaultsStart() + let root = fbb.MoreDefaultsEnd() + fbb.Finish(root) + + var defaults: MoreDefaults + defaults.GetRootAs(fbb.FinishedBytes(), 0) + check(defaults.emptyString == "") + check(defaults.someString == "some") + check(defaults.ints == []) + check(defaults.floats == []) + check(defaults.bools == []) + check(defaults.intsLength == 0) + check(defaults.floatsLength == 0) + check(defaults.abcsLength == 0) + check(defaults.boolsLength == 0) + + # test "testFlatbuffersObjectAPI": + # let defaults = newMoreDefaultsT() + # check(defaults.emptyString.isSome) + # check(defaults.emptyString.get() == "") + # check(defaults.someString.isSome) + # check(defaults.someString.get() == "some") + # check(defaults.ints == []) + # check(defaults.floats == []) + # check(defaults.abcs == []) + # check(defaults.bools == []) + + # var fbb = newBuilder(0) + # fbb.Finish(defaults.Pack(fbb)) + # var fDefaults: MoreDefaults + # fDefaults.GetRootAs(fbb.FinishedBytes(), 0) + # check(fDefaults.emptyString.isSome) + # check(fDefaults.emptyString.get() == "") + # check(fDefaults.someString.isSome) + # check(fDefaults.someString.get() == "some") + # check(fDefaults.ints == []) + # check(fDefaults.floats == []) + # check(fDefaults.bools == []) + # check(fDefaults.intsLength == 0) + # check(fDefaults.floatsLength == 0) + # check(fDefaults.abcsLength == 0) + # check(fDefaults.boolsLength == 0) diff --git a/tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim b/tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim new file mode 100644 index 00000000000..daec6c2f224 --- /dev/null +++ b/tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim @@ -0,0 +1,43 @@ +discard """ + action: "run" + exitcode: 0 + timeout: 60.0 +""" +import std/unittest +import std/options +import flatbuffers +import ../../generated/TestMutatingBool +import ../../generated/Property + +suite "TestMutatingBool": + + test "MutatingBool": + var builder = newBuilder(1024) + builder.TestMutatingBoolStart() + builder.TestMutatingBoolAddB(builder.PropertyCreate(false)) + let root = builder.TestMutatingBoolEnd() + builder.Finish(root) + + var test_mutating_bool: TestMutatingBool + GetRootAs(test_mutating_bool, builder.FinishedBytes(), 0) + check(test_mutating_bool.b.isSome) + var prop2 = test_mutating_bool.b.get() + check(prop2.property == false) + discard (prop2.property = false) + check(prop2.property == false) + discard (prop2.property = true) + check(prop2.property == true) + + test "EmptyBool": + var builder = newBuilder(1024) + builder.TestMutatingBoolStart() + let root = builder.TestMutatingBoolEnd() + builder.Finish(root) + + var test_mutating_bool: TestMutatingBool + GetRootAs(test_mutating_bool, builder.FinishedBytes(), 0) + check(test_mutating_bool.b.isNone) + + # test "defaultValue": + # let mutatingbool = newTestMutatingBoolT() + # check(mutatingbool.b.isNone) diff --git a/tests/FlatBuffers.Test.Nim/tests/mygame/test.nim b/tests/FlatBuffers.Test.Nim/tests/mygame/test.nim new file mode 100644 index 00000000000..d833b25dc61 --- /dev/null +++ b/tests/FlatBuffers.Test.Nim/tests/mygame/test.nim @@ -0,0 +1,528 @@ +discard """ + action: "run" + exitcode: 0 + timeout: 60.0 +""" +import std/unittest +import std/options +import flatbuffers +import ../../generated/MyGame/Example/Test +import ../../generated/MyGame/Example/Monster +import ../../generated/MyGame/Example/Vec3 +import ../../generated/MyGame/Example/Color as ColorMod +import ../../generated/MyGame/Example/Any as AnyMod + +proc verifyMonster(monster: var Monster) = + check(monster.hp == 80) + check(monster.mana == 150) + check(monster.name == "MyMonster") + check(monster.pos.isSome) + let pos = monster.pos.get() + check(pos.x == 1) + check(pos.y == 2) + check(pos.z == 3) + check(pos.test1 == 3) + check(pos.test2 == Color.Green) + check(pos.test3.a == 5) + check(pos.test3.b == 6) + check(monster.testType == Any.Monster) + check(monster.test.isSome) + let monster2 = Monster(tab: monster.test.get()) + check(monster2.name == "Fred") + check((monster.mana = 10) == false) + check(monster.mana == 150) + check(monster.inventoryLength == 5) + var sum: uint8 = 0 + for item in monster.inventory: + sum += item + check(sum == 10) + check(monster.test4Length == 2) + + let test0 = monster.test4(0) + let test1 = monster.test4(1) + var sum0 = test0.a + test0.b + var sum1 = test1.a + test1.b + check(sum0 + sum1 == 100) + + check(monster.testarrayofstringLength == 2) + check(monster.testarrayofstring(0) == "test1") + check(monster.testarrayofstring(1) == "test2") + check(monster.testbool == true) + + +suite "TestMyGame": + + test "testData": + let data: seq[byte] = @[byte(48), 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, + 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, + 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, + 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, + 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, + 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, + 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, + 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, + 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, + 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, + 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, + 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, + 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0] + var monster: Monster + GetRootAs(monster, data, 0) + verifyMonster(monster) + + test "testCreateString": + var fbb = newBuilder(0) + let name = fbb.Create("Frodo") + fbb.Finish(name) + check(fbb.FinishedBytes() == @[byte(4), 0, 0, 0, 5, 0, 0, 0, 70, 114, 111, + 100, 111, 0, 0, 0]) + + test "testCreateVector": + var fbb = newBuilder(0) + let vec = fbb.Create(@[byte(0), 1, 2, 3, 4]) + fbb.Finish(vec) + check(fbb.FinishedBytes() == @[byte(4), 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, + 0, 0, 0]) + + test "createSimpleMonster": + var fbb = newBuilder(0) + let names = [ + fbb.Create("Frodo"), + fbb.Create("Barney"), + fbb.Create("Wilma"), + ] + fbb.MonsterStart() + fbb.MonsterAddName(names[0]) + let monster = fbb.MonsterEnd() + fbb.Finish(monster) + check(fbb.FinishedBytes() == @[byte(16), 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, + 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, + 114, 111, 100, 111, 0, 0, 0]) + + test "testCreateTestVector": + var fbb = newBuilder(0) + fbb.MonsterStartTest4Vector(2) + discard fbb.TestCreate(a = 30, b = 40) + discard fbb.TestCreate(a = 10, b = 20) + let test4 = fbb.EndVector() + fbb.Finish(test4) + check(fbb.FinishedBytes() == @[byte(4), 0, 0, 0, 2, 0, 0, 0, 10, 0, 20, 0, + 30, 0, 40, 0]) + + test "testTableWithStruct": + var fbb = newBuilder(0) + fbb.MonsterStart() + fbb.MonsterAddPos(fbb.Vec3Create(x = 1, + y = 2, + z = 3, + test1 = 3, + test2 = Color.Green, + test3_a = 5, test3_b = 6)) + + let monster_end = fbb.MonsterEnd() + fbb.Finish(monster_end) + check(fbb.FinishedBytes() == @[byte(12), 0, 0, 0, 0, 0, 6, 0, 36, 0, 4, 0, + 6, 0, 0, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0]) + + test "testCreateMonster": + var fbb = newBuilder(0) + let names = [ + fbb.Create("Frodo"), + fbb.Create("Barney"), + fbb.Create("Wilma"), + ] + + var offsets: seq[uoffset] = @[] + fbb.MonsterStart() + fbb.MonsterAddName(names[0]) + offsets.add(fbb.MonsterEnd()) + fbb.MonsterStart() + fbb.MonsterAddName(names[1]) + offsets.add(fbb.MonsterEnd()) + fbb.MonsterStart() + fbb.MonsterAddName(names[2]) + offsets.add(fbb.MonsterEnd()) + + let str = fbb.Create("MyMonster") + let test1 = fbb.Create("test1") + let test2 = fbb.Create("test2") + let inv = fbb.Create(@[byte(0), 1, 2, 3, 4]) + let fred = fbb.Create("Fred") + fbb.MonsterStart() + fbb.MonsterAddName(fred) + let mon2 = fbb.MonsterEnd() + + fbb.MonsterStartTest4Vector(2) + discard fbb.TestCreate(a = 30, b = 40) + discard fbb.TestCreate(a = 10, b = 20) + let test4 = fbb.EndVector() + + fbb.MonsterStartTestarrayofstringVector(2) + fbb.PrependOffsetRelative(test1) + fbb.PrependOffsetRelative(test2) + let stringTestVector = fbb.EndVector() + + fbb.MonsterStartTestarrayoftablesVector(3) + fbb.PrependOffsetRelative(offsets[0]) + fbb.PrependOffsetRelative(offsets[1]) + fbb.PrependOffsetRelative(offsets[2]) + let tableTestVector = fbb.EndVector() + + fbb.MonsterStart() + fbb.MonsterAddPos(fbb.Vec3Create(x = 1, + y = 2, + z = 3, + test1 = 3, + test2 = Color.Green, + test3_a = 5, test3_b = 6)) + fbb.MonsterAddHp(80) + fbb.MonsterAddName(str) + fbb.MonsterAddInventory(inv) + fbb.MonsterAddTestType(Any.Monster.uint8) + fbb.MonsterAddTest(mon2) + fbb.MonsterAddTest4(test4) + fbb.MonsterAddTestarrayofstring(stringTestVector) + fbb.MonsterAddTestbool(true) + fbb.MonsterAddTestarrayoftables(tableTestVector) + let monster_end = fbb.MonsterEnd() + fbb.Finish(monster_end) + check(fbb.FinishedBytes() == @[byte(40), 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, + 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 1, 76, 0, 0, 0, + 84, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 1, 104, 0, 0, 0, 136, 0, 0, 0, 0, 0, + 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 3, 0, 0, 0, 108, 0, 0, 0, 112, 0, + 0, 0, 128, 0, 0, 0, 2, 0, 0, 0, 52, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, 0, + 10, 0, 20, 0, 30, 0, 40, 0, 168, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, + 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, + 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, + 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, + 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, + 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, + 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, + 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0]) + + + # var test_mutating_bool: TestMutatingBool + # GetRootAs(test_mutating_bool, builder.FinishedBytes(), 0) + # XCTAssertEqual(bytes.sizedByteArray, ) + # let monster = MyGame_Example_Monster.getRootAsMonster(bb: bytes.buffer) + # readMonster(monster: monster) + # mutateMonster(fb: bytes.buffer) + # readMonster(monster: monster) + + + # test "testReadFromOtherLanguages": + # let path = FileManager.default.currentDirectoryPath + # let url = URL(fileURLWithPath: path, isDirectory: true) + # .appendingPathComponent("monsterdata_test").appendingPathExtension("mon") + # guard let data = try? Data(contentsOf: url) else { return } + # let _data = ByteBuffer(data: data) + # readVerifiedMonster(fb: _data) + # } + + # test "testCreateMonster": + # let bytes = createMonster(withPrefix: false) + # // swiftformat:disable all + # check(bytes.sizedByteArray == [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0]) + # // swiftformat:enable all + # let monster = Monster.getRootAsMonster(bb: bytes.buffer) + # readMonster(monster: monster) + # mutateMonster(fb: bytes.buffer) + # readMonster(monster: monster) + # } + + # test "testCreateMonsterResizedBuffer": + # let bytes = createMonster(withPrefix: false) + # // swiftformat:disable all + # check(bytes.sizedByteArray == [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0]) + # // swiftformat:enable all + # readVerifiedMonster(fb: bytes.sizedBuffer) + # } + + # test "testCreateMonsterPrefixed": + # let bytes = createMonster(withPrefix: true) + # // swiftformat:disable all + # check(bytes.sizedByteArray, [44, 1, 0, 0, 44, 0, 0, 0, 77, 79, 78, 83, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, ==0]) + # // swiftformat:enable all + + # var buffer = bytes.buffer + # readMonster(monster: getPrefixedSizeRoot(byteBuffer: &buffer)) + # } + + # test "testCreateMonsterUsingCreateMonsterMethodWithNilPos": + # var fbb = FlatBufferBuilder(initialSize: 1) + # let name = fbb.Create("Frodo") + # let mStart = fbb.MonsterStart() + # Monster.add(name: name, &fbb) + # let root = Monster.endMonster(&fbb, start: mStart) + # fbb.finish(offset: root) + # let newMonster = Monster.getRootAsMonster(bb: fbb.sizedBuffer) + # XCTAssertNil(newMonster.pos) + # check(newMonster.name, "Fro ==o") + # } + + # test "testCreateMonsterUsingCreateMonsterMethodWithPosX": + # var fbb = FlatBufferBuilder(initialSize: 1) + # let name = fbb.Create("Barney") + # let mStart = fbb.MonsterStart() + # Monster.add( + # pos: Vec3( + # x: 10, + # y: 0, + # z: 0, + # test1: 0, + # test2: .blue, + # test3: .init()), + # &fbb) + # Monster.add(name: name, &fbb) + # let root = Monster.endMonster(&fbb, start: mStart) + # fbb.finish(offset: root) + + # let newMonster = Monster.getRootAsMonster(bb: fbb.sizedBuffer) + # check(newMonster.pos!.x == 10) + # check(newMonster.name, "Barn ==y") + # } + + # test "testReadMonsterFromUnsafePointerWithoutCopying": + # // swiftformat:disable all + # var array: [UInt8] = [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0] + # // swiftformat:enable all + # let unpacked = array + # .withUnsafeMutableBytes { (memory) -> MonsterT in + # let bytes = ByteBuffer( + # assumingMemoryBound: memory.baseAddress!, + # capacity: memory.count) + # var monster = Monster.getRootAsMonster(bb: bytes) + # readFlatbufferMonster(monster: &monster) + # let unpacked = monster.unpack() + # return unpacked + # } + # readObjectApi(monster: unpacked) + # } + + # test "testArrayOfBools": + # let boolArray = [false, true, false, true, false, true, false] + # var fbb = FlatBufferBuilder(initialSize: 1) + # let name = fbb.Create("Frodo") + # let bools = fbb.createVector(boolArray) + # let root = Monster.createMonster( + # &fbb, + # nameOffset: name, + # testarrayofboolsVectorOffset: bools) + # fbb.finish(offset: root) + # let monster = Monster.getRootAsMonster(bb: fbb.sizedBuffer) + + # let values = monster.testarrayofbools + + # check(boolArray == values) + + # for i in 0.. FlatBufferBuild": + # var fbb = FlatBufferBuilder(initialSize: 1) + # let names = [ + # fbb.Create("Frodo"), + # fbb.Create("Barney"), + # fbb.Create("Wilma"), + # ] + # var offsets: [Offset] = [] + # let start1 = fbb.MonsterStart() + # Monster.add(name: names[0], &fbb) + # offsets.append(Monster.endMonster(&fbb, start: start1)) + # let start2 = fbb.MonsterStart() + # Monster.add(name: names[1], &fbb) + # offsets.append(Monster.endMonster(&fbb, start: start2)) + # let start3 = fbb.MonsterStart() + # Monster.add(name: names[2], &fbb) + # offsets.append(Monster.endMonster(&fbb, start: start3)) + + # let sortedArray = Monster.sortVectorOfMonster(offsets: offsets, &fbb) + + # let str = fbb.Create("MyMonster") + # let test1 = fbb.Create("test1") + # let test2 = fbb.Create("test2") + # let _inv: [Byte] = [0, 1, 2, 3, 4] + # let inv = fbb.createVector(_inv) + + # let fred = fbb.Create("Fred") + # let mon1Start = fbb.MonsterStart() + # Monster.add(name: fred, &fbb) + # let mon2 = Monster.endMonster(&fbb, start: mon1Start) + + # let test4 = fbb.createVector(ofStructs: [ + # Test(a: 30, b: 40), + # Test(a: 10, b: 20), + # ]) + + # let stringTestVector = fbb.createVector(ofOffsets: [test1, test2]) + # let mStart = fbb.MonsterStart() + # Monster.add( + # pos: Vec3( + # x: 1, + # y: 2, + # z: 3, + # test1: 3, + # test2: Color.Green, + # test3: .init(a: 5, b: 6)), + # &fbb) + # Monster.add(hp: 80, &fbb) + # Monster.add(name: str, &fbb) + # Monster.addVectorOf(inventory: inv, &fbb) + # Monster.add(testType: .monster, &fbb) + # Monster.add(test: mon2, &fbb) + # Monster.addVectorOf(test4: test4, &fbb) + # Monster.addVectorOf(testarrayofstring: stringTestVector, &fbb) + # Monster.add(testbool: true, &fbb) + # Monster.addVectorOf(testarrayoftables: sortedArray, &fbb) + # let end = Monster.endMonster(&fbb, start: mStart) + # Monster.finish(&fbb, end: end, prefix: prefix) + # return fbb + # } + + # test "mutateMonster(fb: ByteBuffe": + # let monster = Monster.getRootAsMonster(bb: fb) + # XCTAssertFalse(monster.mana = 10) + # check(monster.testarrayoftables(0).name, "Barn ==y") + # check(monster.testarrayoftables(1).name, "Fro ==o") + # check(monster.testarrayoftables(2).name, "Wil ==a") + + # // Example of searching for a table by the key + # XCTAssertNotNil(monster.testarrayoftablesBy(key: "Frodo")) + # XCTAssertNotNil(monster.testarrayoftablesBy(key: "Barney")) + # XCTAssertNotNil(monster.testarrayoftablesBy(key: "Wilma")) + + # check(monster.testType, ==.monster) + + # check(monster.inventory = 1 0) == true) + # check(monster.inventory = 2 1) == true) + # check(monster.inventory = 3 2) == true) + # check(monster.inventory = 4 3) == true) + # check(monster.inventory = 5 4) == true) + + # for i in 0.. Date: Fri, 16 Sep 2022 00:13:47 +0300 Subject: [PATCH 02/29] Remove commented out tests --- .../tests/moredefaults/test.nim | 27 -- .../tests/mutatingbool/test.nim | 4 - .../tests/mygame/test.nim | 321 ------------------ 3 files changed, 352 deletions(-) diff --git a/tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim b/tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim index 417467a694b..e300b55535c 100644 --- a/tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim +++ b/tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim @@ -26,30 +26,3 @@ suite "TestMoreDefaults": check(defaults.floatsLength == 0) check(defaults.abcsLength == 0) check(defaults.boolsLength == 0) - - # test "testFlatbuffersObjectAPI": - # let defaults = newMoreDefaultsT() - # check(defaults.emptyString.isSome) - # check(defaults.emptyString.get() == "") - # check(defaults.someString.isSome) - # check(defaults.someString.get() == "some") - # check(defaults.ints == []) - # check(defaults.floats == []) - # check(defaults.abcs == []) - # check(defaults.bools == []) - - # var fbb = newBuilder(0) - # fbb.Finish(defaults.Pack(fbb)) - # var fDefaults: MoreDefaults - # fDefaults.GetRootAs(fbb.FinishedBytes(), 0) - # check(fDefaults.emptyString.isSome) - # check(fDefaults.emptyString.get() == "") - # check(fDefaults.someString.isSome) - # check(fDefaults.someString.get() == "some") - # check(fDefaults.ints == []) - # check(fDefaults.floats == []) - # check(fDefaults.bools == []) - # check(fDefaults.intsLength == 0) - # check(fDefaults.floatsLength == 0) - # check(fDefaults.abcsLength == 0) - # check(fDefaults.boolsLength == 0) diff --git a/tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim b/tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim index daec6c2f224..7b65c0573bf 100644 --- a/tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim +++ b/tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim @@ -37,7 +37,3 @@ suite "TestMutatingBool": var test_mutating_bool: TestMutatingBool GetRootAs(test_mutating_bool, builder.FinishedBytes(), 0) check(test_mutating_bool.b.isNone) - - # test "defaultValue": - # let mutatingbool = newTestMutatingBoolT() - # check(mutatingbool.b.isNone) diff --git a/tests/FlatBuffers.Test.Nim/tests/mygame/test.nim b/tests/FlatBuffers.Test.Nim/tests/mygame/test.nim index d833b25dc61..4f9e1db2143 100644 --- a/tests/FlatBuffers.Test.Nim/tests/mygame/test.nim +++ b/tests/FlatBuffers.Test.Nim/tests/mygame/test.nim @@ -205,324 +205,3 @@ suite "TestMyGame": 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0]) - - - # var test_mutating_bool: TestMutatingBool - # GetRootAs(test_mutating_bool, builder.FinishedBytes(), 0) - # XCTAssertEqual(bytes.sizedByteArray, ) - # let monster = MyGame_Example_Monster.getRootAsMonster(bb: bytes.buffer) - # readMonster(monster: monster) - # mutateMonster(fb: bytes.buffer) - # readMonster(monster: monster) - - - # test "testReadFromOtherLanguages": - # let path = FileManager.default.currentDirectoryPath - # let url = URL(fileURLWithPath: path, isDirectory: true) - # .appendingPathComponent("monsterdata_test").appendingPathExtension("mon") - # guard let data = try? Data(contentsOf: url) else { return } - # let _data = ByteBuffer(data: data) - # readVerifiedMonster(fb: _data) - # } - - # test "testCreateMonster": - # let bytes = createMonster(withPrefix: false) - # // swiftformat:disable all - # check(bytes.sizedByteArray == [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0]) - # // swiftformat:enable all - # let monster = Monster.getRootAsMonster(bb: bytes.buffer) - # readMonster(monster: monster) - # mutateMonster(fb: bytes.buffer) - # readMonster(monster: monster) - # } - - # test "testCreateMonsterResizedBuffer": - # let bytes = createMonster(withPrefix: false) - # // swiftformat:disable all - # check(bytes.sizedByteArray == [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0]) - # // swiftformat:enable all - # readVerifiedMonster(fb: bytes.sizedBuffer) - # } - - # test "testCreateMonsterPrefixed": - # let bytes = createMonster(withPrefix: true) - # // swiftformat:disable all - # check(bytes.sizedByteArray, [44, 1, 0, 0, 44, 0, 0, 0, 77, 79, 78, 83, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, ==0]) - # // swiftformat:enable all - - # var buffer = bytes.buffer - # readMonster(monster: getPrefixedSizeRoot(byteBuffer: &buffer)) - # } - - # test "testCreateMonsterUsingCreateMonsterMethodWithNilPos": - # var fbb = FlatBufferBuilder(initialSize: 1) - # let name = fbb.Create("Frodo") - # let mStart = fbb.MonsterStart() - # Monster.add(name: name, &fbb) - # let root = Monster.endMonster(&fbb, start: mStart) - # fbb.finish(offset: root) - # let newMonster = Monster.getRootAsMonster(bb: fbb.sizedBuffer) - # XCTAssertNil(newMonster.pos) - # check(newMonster.name, "Fro ==o") - # } - - # test "testCreateMonsterUsingCreateMonsterMethodWithPosX": - # var fbb = FlatBufferBuilder(initialSize: 1) - # let name = fbb.Create("Barney") - # let mStart = fbb.MonsterStart() - # Monster.add( - # pos: Vec3( - # x: 10, - # y: 0, - # z: 0, - # test1: 0, - # test2: .blue, - # test3: .init()), - # &fbb) - # Monster.add(name: name, &fbb) - # let root = Monster.endMonster(&fbb, start: mStart) - # fbb.finish(offset: root) - - # let newMonster = Monster.getRootAsMonster(bb: fbb.sizedBuffer) - # check(newMonster.pos!.x == 10) - # check(newMonster.name, "Barn ==y") - # } - - # test "testReadMonsterFromUnsafePointerWithoutCopying": - # // swiftformat:disable all - # var array: [UInt8] = [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0] - # // swiftformat:enable all - # let unpacked = array - # .withUnsafeMutableBytes { (memory) -> MonsterT in - # let bytes = ByteBuffer( - # assumingMemoryBound: memory.baseAddress!, - # capacity: memory.count) - # var monster = Monster.getRootAsMonster(bb: bytes) - # readFlatbufferMonster(monster: &monster) - # let unpacked = monster.unpack() - # return unpacked - # } - # readObjectApi(monster: unpacked) - # } - - # test "testArrayOfBools": - # let boolArray = [false, true, false, true, false, true, false] - # var fbb = FlatBufferBuilder(initialSize: 1) - # let name = fbb.Create("Frodo") - # let bools = fbb.createVector(boolArray) - # let root = Monster.createMonster( - # &fbb, - # nameOffset: name, - # testarrayofboolsVectorOffset: bools) - # fbb.finish(offset: root) - # let monster = Monster.getRootAsMonster(bb: fbb.sizedBuffer) - - # let values = monster.testarrayofbools - - # check(boolArray == values) - - # for i in 0.. FlatBufferBuild": - # var fbb = FlatBufferBuilder(initialSize: 1) - # let names = [ - # fbb.Create("Frodo"), - # fbb.Create("Barney"), - # fbb.Create("Wilma"), - # ] - # var offsets: [Offset] = [] - # let start1 = fbb.MonsterStart() - # Monster.add(name: names[0], &fbb) - # offsets.append(Monster.endMonster(&fbb, start: start1)) - # let start2 = fbb.MonsterStart() - # Monster.add(name: names[1], &fbb) - # offsets.append(Monster.endMonster(&fbb, start: start2)) - # let start3 = fbb.MonsterStart() - # Monster.add(name: names[2], &fbb) - # offsets.append(Monster.endMonster(&fbb, start: start3)) - - # let sortedArray = Monster.sortVectorOfMonster(offsets: offsets, &fbb) - - # let str = fbb.Create("MyMonster") - # let test1 = fbb.Create("test1") - # let test2 = fbb.Create("test2") - # let _inv: [Byte] = [0, 1, 2, 3, 4] - # let inv = fbb.createVector(_inv) - - # let fred = fbb.Create("Fred") - # let mon1Start = fbb.MonsterStart() - # Monster.add(name: fred, &fbb) - # let mon2 = Monster.endMonster(&fbb, start: mon1Start) - - # let test4 = fbb.createVector(ofStructs: [ - # Test(a: 30, b: 40), - # Test(a: 10, b: 20), - # ]) - - # let stringTestVector = fbb.createVector(ofOffsets: [test1, test2]) - # let mStart = fbb.MonsterStart() - # Monster.add( - # pos: Vec3( - # x: 1, - # y: 2, - # z: 3, - # test1: 3, - # test2: Color.Green, - # test3: .init(a: 5, b: 6)), - # &fbb) - # Monster.add(hp: 80, &fbb) - # Monster.add(name: str, &fbb) - # Monster.addVectorOf(inventory: inv, &fbb) - # Monster.add(testType: .monster, &fbb) - # Monster.add(test: mon2, &fbb) - # Monster.addVectorOf(test4: test4, &fbb) - # Monster.addVectorOf(testarrayofstring: stringTestVector, &fbb) - # Monster.add(testbool: true, &fbb) - # Monster.addVectorOf(testarrayoftables: sortedArray, &fbb) - # let end = Monster.endMonster(&fbb, start: mStart) - # Monster.finish(&fbb, end: end, prefix: prefix) - # return fbb - # } - - # test "mutateMonster(fb: ByteBuffe": - # let monster = Monster.getRootAsMonster(bb: fb) - # XCTAssertFalse(monster.mana = 10) - # check(monster.testarrayoftables(0).name, "Barn ==y") - # check(monster.testarrayoftables(1).name, "Fro ==o") - # check(monster.testarrayoftables(2).name, "Wil ==a") - - # // Example of searching for a table by the key - # XCTAssertNotNil(monster.testarrayoftablesBy(key: "Frodo")) - # XCTAssertNotNil(monster.testarrayoftablesBy(key: "Barney")) - # XCTAssertNotNil(monster.testarrayoftablesBy(key: "Wilma")) - - # check(monster.testType, ==.monster) - - # check(monster.inventory = 1 0) == true) - # check(monster.inventory = 2 1) == true) - # check(monster.inventory = 3 2) == true) - # check(monster.inventory = 4 3) == true) - # check(monster.inventory = 5 4) == true) - - # for i in 0.. Date: Fri, 16 Sep 2022 00:18:02 +0300 Subject: [PATCH 03/29] add missing line to idl.h --- include/flatbuffers/idl.h | 1 + 1 file changed, 1 insertion(+) diff --git a/include/flatbuffers/idl.h b/include/flatbuffers/idl.h index 4cfd7ebfb0d..70d86d18e4c 100644 --- a/include/flatbuffers/idl.h +++ b/include/flatbuffers/idl.h @@ -653,6 +653,7 @@ struct IDLOptions { kRust = 1 << 14, kKotlin = 1 << 15, kSwift = 1 << 16, + kNim = 1 << 17, kMAX }; From 7b09a8058b496d50e81f40e46d70e8bb407e1a41 Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Fri, 16 Sep 2022 00:31:13 +0300 Subject: [PATCH 04/29] Commit python reflection changes --- python/flatbuffers/reflection/Field.py | 48 ++++++++++++++++---------- 1 file changed, 29 insertions(+), 19 deletions(-) diff --git a/python/flatbuffers/reflection/Field.py b/python/flatbuffers/reflection/Field.py index 01b52808a1f..6b0c7aaea5e 100644 --- a/python/flatbuffers/reflection/Field.py +++ b/python/flatbuffers/reflection/Field.py @@ -75,29 +75,36 @@ def DefaultReal(self): return 0.0 # Field - def Deprecated(self): + def DefaultString(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # Field + def Deprecated(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # Field def Required(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # Field def Key(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # Field def Attributes(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) if o != 0: x = self._tab.Vector(o) x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 @@ -110,19 +117,19 @@ def Attributes(self, j): # Field def AttributesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) if o != 0: return self._tab.VectorLen(o) return 0 # Field def AttributesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) return o == 0 # Field def Documentation(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) if o != 0: a = self._tab.Vector(o) return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) @@ -130,19 +137,19 @@ def Documentation(self, j): # Field def DocumentationLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) if o != 0: return self._tab.VectorLen(o) return 0 # Field def DocumentationIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) return o == 0 # Field def Optional(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False @@ -150,12 +157,12 @@ def Optional(self): # Number of padding octets to always add after this field. Structs only. # Field def Padding(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30)) if o != 0: return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos) return 0 -def FieldStart(builder): builder.StartObject(13) +def FieldStart(builder): builder.StartObject(14) def Start(builder): return FieldStart(builder) def FieldAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) @@ -176,31 +183,34 @@ def AddDefaultInteger(builder, defaultInteger): def FieldAddDefaultReal(builder, defaultReal): builder.PrependFloat64Slot(5, defaultReal, 0.0) def AddDefaultReal(builder, defaultReal): return FieldAddDefaultReal(builder, defaultReal) -def FieldAddDeprecated(builder, deprecated): builder.PrependBoolSlot(6, deprecated, 0) +def FieldAddDefaultString(builder, defaultString): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(defaultString), 0) +def AddDefaultString(builder, defaultString): + return FieldAddDefaultString(builder, defaultString) +def FieldAddDeprecated(builder, deprecated): builder.PrependBoolSlot(7, deprecated, 0) def AddDeprecated(builder, deprecated): return FieldAddDeprecated(builder, deprecated) -def FieldAddRequired(builder, required): builder.PrependBoolSlot(7, required, 0) +def FieldAddRequired(builder, required): builder.PrependBoolSlot(8, required, 0) def AddRequired(builder, required): return FieldAddRequired(builder, required) -def FieldAddKey(builder, key): builder.PrependBoolSlot(8, key, 0) +def FieldAddKey(builder, key): builder.PrependBoolSlot(9, key, 0) def AddKey(builder, key): return FieldAddKey(builder, key) -def FieldAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) +def FieldAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) def AddAttributes(builder, attributes): return FieldAddAttributes(builder, attributes) def FieldStartAttributesVector(builder, numElems): return builder.StartVector(4, numElems, 4) def StartAttributesVector(builder, numElems): return FieldStartAttributesVector(builder, numElems) -def FieldAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) +def FieldAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) def AddDocumentation(builder, documentation): return FieldAddDocumentation(builder, documentation) def FieldStartDocumentationVector(builder, numElems): return builder.StartVector(4, numElems, 4) def StartDocumentationVector(builder, numElems): return FieldStartDocumentationVector(builder, numElems) -def FieldAddOptional(builder, optional): builder.PrependBoolSlot(11, optional, 0) +def FieldAddOptional(builder, optional): builder.PrependBoolSlot(12, optional, 0) def AddOptional(builder, optional): return FieldAddOptional(builder, optional) -def FieldAddPadding(builder, padding): builder.PrependUint16Slot(12, padding, 0) +def FieldAddPadding(builder, padding): builder.PrependUint16Slot(13, padding, 0) def AddPadding(builder, padding): return FieldAddPadding(builder, padding) def FieldEnd(builder): return builder.EndObject() From 92ac71678cd11f3305d94bf15eb178be93ac8e0f Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Fri, 16 Sep 2022 00:31:13 +0300 Subject: [PATCH 05/29] Commit python reflection changes and move tests --- python/flatbuffers/reflection/Field.py | 48 +++++++++++-------- .../{FlatBuffers.Test.Nim => nim}/NimTest.sh | 0 .../tests/moredefaults/test.nim | 0 .../tests/mutatingbool/test.nim | 0 .../tests/mygame/test.nim | 0 .../tests/optional_scalars/test.nim | 0 6 files changed, 29 insertions(+), 19 deletions(-) rename tests/{FlatBuffers.Test.Nim => nim}/NimTest.sh (100%) rename tests/{FlatBuffers.Test.Nim => nim}/tests/moredefaults/test.nim (100%) rename tests/{FlatBuffers.Test.Nim => nim}/tests/mutatingbool/test.nim (100%) rename tests/{FlatBuffers.Test.Nim => nim}/tests/mygame/test.nim (100%) rename tests/{FlatBuffers.Test.Nim => nim}/tests/optional_scalars/test.nim (100%) diff --git a/python/flatbuffers/reflection/Field.py b/python/flatbuffers/reflection/Field.py index 01b52808a1f..6b0c7aaea5e 100644 --- a/python/flatbuffers/reflection/Field.py +++ b/python/flatbuffers/reflection/Field.py @@ -75,29 +75,36 @@ def DefaultReal(self): return 0.0 # Field - def Deprecated(self): + def DefaultString(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # Field + def Deprecated(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # Field def Required(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # Field def Key(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # Field def Attributes(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) if o != 0: x = self._tab.Vector(o) x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 @@ -110,19 +117,19 @@ def Attributes(self, j): # Field def AttributesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) if o != 0: return self._tab.VectorLen(o) return 0 # Field def AttributesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) return o == 0 # Field def Documentation(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) if o != 0: a = self._tab.Vector(o) return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) @@ -130,19 +137,19 @@ def Documentation(self, j): # Field def DocumentationLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) if o != 0: return self._tab.VectorLen(o) return 0 # Field def DocumentationIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) return o == 0 # Field def Optional(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False @@ -150,12 +157,12 @@ def Optional(self): # Number of padding octets to always add after this field. Structs only. # Field def Padding(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30)) if o != 0: return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos) return 0 -def FieldStart(builder): builder.StartObject(13) +def FieldStart(builder): builder.StartObject(14) def Start(builder): return FieldStart(builder) def FieldAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) @@ -176,31 +183,34 @@ def AddDefaultInteger(builder, defaultInteger): def FieldAddDefaultReal(builder, defaultReal): builder.PrependFloat64Slot(5, defaultReal, 0.0) def AddDefaultReal(builder, defaultReal): return FieldAddDefaultReal(builder, defaultReal) -def FieldAddDeprecated(builder, deprecated): builder.PrependBoolSlot(6, deprecated, 0) +def FieldAddDefaultString(builder, defaultString): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(defaultString), 0) +def AddDefaultString(builder, defaultString): + return FieldAddDefaultString(builder, defaultString) +def FieldAddDeprecated(builder, deprecated): builder.PrependBoolSlot(7, deprecated, 0) def AddDeprecated(builder, deprecated): return FieldAddDeprecated(builder, deprecated) -def FieldAddRequired(builder, required): builder.PrependBoolSlot(7, required, 0) +def FieldAddRequired(builder, required): builder.PrependBoolSlot(8, required, 0) def AddRequired(builder, required): return FieldAddRequired(builder, required) -def FieldAddKey(builder, key): builder.PrependBoolSlot(8, key, 0) +def FieldAddKey(builder, key): builder.PrependBoolSlot(9, key, 0) def AddKey(builder, key): return FieldAddKey(builder, key) -def FieldAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) +def FieldAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) def AddAttributes(builder, attributes): return FieldAddAttributes(builder, attributes) def FieldStartAttributesVector(builder, numElems): return builder.StartVector(4, numElems, 4) def StartAttributesVector(builder, numElems): return FieldStartAttributesVector(builder, numElems) -def FieldAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) +def FieldAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) def AddDocumentation(builder, documentation): return FieldAddDocumentation(builder, documentation) def FieldStartDocumentationVector(builder, numElems): return builder.StartVector(4, numElems, 4) def StartDocumentationVector(builder, numElems): return FieldStartDocumentationVector(builder, numElems) -def FieldAddOptional(builder, optional): builder.PrependBoolSlot(11, optional, 0) +def FieldAddOptional(builder, optional): builder.PrependBoolSlot(12, optional, 0) def AddOptional(builder, optional): return FieldAddOptional(builder, optional) -def FieldAddPadding(builder, padding): builder.PrependUint16Slot(12, padding, 0) +def FieldAddPadding(builder, padding): builder.PrependUint16Slot(13, padding, 0) def AddPadding(builder, padding): return FieldAddPadding(builder, padding) def FieldEnd(builder): return builder.EndObject() diff --git a/tests/FlatBuffers.Test.Nim/NimTest.sh b/tests/nim/NimTest.sh similarity index 100% rename from tests/FlatBuffers.Test.Nim/NimTest.sh rename to tests/nim/NimTest.sh diff --git a/tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim b/tests/nim/tests/moredefaults/test.nim similarity index 100% rename from tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim rename to tests/nim/tests/moredefaults/test.nim diff --git a/tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim b/tests/nim/tests/mutatingbool/test.nim similarity index 100% rename from tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim rename to tests/nim/tests/mutatingbool/test.nim diff --git a/tests/FlatBuffers.Test.Nim/tests/mygame/test.nim b/tests/nim/tests/mygame/test.nim similarity index 100% rename from tests/FlatBuffers.Test.Nim/tests/mygame/test.nim rename to tests/nim/tests/mygame/test.nim diff --git a/tests/FlatBuffers.Test.Nim/tests/optional_scalars/test.nim b/tests/nim/tests/optional_scalars/test.nim similarity index 100% rename from tests/FlatBuffers.Test.Nim/tests/optional_scalars/test.nim rename to tests/nim/tests/optional_scalars/test.nim From 61e2ae3bd1079248ec90c55d064f961c583b0090 Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Fri, 16 Sep 2022 11:28:03 +0300 Subject: [PATCH 06/29] Remove default string addition --- include/flatbuffers/reflection_generated.h | 28 ++++--------- python/flatbuffers/reflection/Field.py | 48 +++++++++------------- reflection/reflection.fbs | 1 - src/bfbs_gen_nim.cpp | 4 +- src/idl_parser.cpp | 11 ++--- tests/nim/tests/moredefaults/test.nim | 1 - 6 files changed, 31 insertions(+), 62 deletions(-) diff --git a/include/flatbuffers/reflection_generated.h b/include/flatbuffers/reflection_generated.h index d8c47edc0a3..78674db5d42 100644 --- a/include/flatbuffers/reflection_generated.h +++ b/include/flatbuffers/reflection_generated.h @@ -580,14 +580,13 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_OFFSET = 10, VT_DEFAULT_INTEGER = 12, VT_DEFAULT_REAL = 14, - VT_DEFAULT_STRING = 16, - VT_DEPRECATED = 18, - VT_REQUIRED = 20, - VT_KEY = 22, - VT_ATTRIBUTES = 24, - VT_DOCUMENTATION = 26, - VT_OPTIONAL = 28, - VT_PADDING = 30 + VT_DEPRECATED = 16, + VT_REQUIRED = 18, + VT_KEY = 20, + VT_ATTRIBUTES = 22, + VT_DOCUMENTATION = 24, + VT_OPTIONAL = 26, + VT_PADDING = 28 }; const flatbuffers::String *name() const { return GetPointer(VT_NAME); @@ -613,9 +612,6 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { double default_real() const { return GetField(VT_DEFAULT_REAL, 0.0); } - const flatbuffers::String *default_string() const { - return GetPointer(VT_DEFAULT_STRING); - } bool deprecated() const { return GetField(VT_DEPRECATED, 0) != 0; } @@ -648,8 +644,6 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VerifyField(verifier, VT_OFFSET, 2) && VerifyField(verifier, VT_DEFAULT_INTEGER, 8) && VerifyField(verifier, VT_DEFAULT_REAL, 8) && - VerifyOffset(verifier, VT_DEFAULT_STRING) && - verifier.VerifyString(default_string()) && VerifyField(verifier, VT_DEPRECATED, 1) && VerifyField(verifier, VT_REQUIRED, 1) && VerifyField(verifier, VT_KEY, 1) && @@ -687,9 +681,6 @@ struct FieldBuilder { void add_default_real(double default_real) { fbb_.AddElement(Field::VT_DEFAULT_REAL, default_real, 0.0); } - void add_default_string(flatbuffers::Offset default_string) { - fbb_.AddOffset(Field::VT_DEFAULT_STRING, default_string); - } void add_deprecated(bool deprecated) { fbb_.AddElement(Field::VT_DEPRECATED, static_cast(deprecated), 0); } @@ -732,7 +723,6 @@ inline flatbuffers::Offset CreateField( uint16_t offset = 0, int64_t default_integer = 0, double default_real = 0.0, - flatbuffers::Offset default_string = 0, bool deprecated = false, bool required = false, bool key = false, @@ -745,7 +735,6 @@ inline flatbuffers::Offset CreateField( builder_.add_default_integer(default_integer); builder_.add_documentation(documentation); builder_.add_attributes(attributes); - builder_.add_default_string(default_string); builder_.add_type(type); builder_.add_name(name); builder_.add_padding(padding); @@ -766,7 +755,6 @@ inline flatbuffers::Offset CreateFieldDirect( uint16_t offset = 0, int64_t default_integer = 0, double default_real = 0.0, - const char *default_string = nullptr, bool deprecated = false, bool required = false, bool key = false, @@ -775,7 +763,6 @@ inline flatbuffers::Offset CreateFieldDirect( bool optional = false, uint16_t padding = 0) { auto name__ = name ? _fbb.CreateString(name) : 0; - auto default_string__ = default_string ? _fbb.CreateString(default_string) : 0; auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables(attributes) : 0; auto documentation__ = documentation ? _fbb.CreateVector>(*documentation) : 0; return reflection::CreateField( @@ -786,7 +773,6 @@ inline flatbuffers::Offset CreateFieldDirect( offset, default_integer, default_real, - default_string__, deprecated, required, key, diff --git a/python/flatbuffers/reflection/Field.py b/python/flatbuffers/reflection/Field.py index 6b0c7aaea5e..01b52808a1f 100644 --- a/python/flatbuffers/reflection/Field.py +++ b/python/flatbuffers/reflection/Field.py @@ -74,37 +74,30 @@ def DefaultReal(self): return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos) return 0.0 - # Field - def DefaultString(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) - if o != 0: - return self._tab.String(o + self._tab.Pos) - return None - # Field def Deprecated(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # Field def Required(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # Field def Key(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # Field def Attributes(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) if o != 0: x = self._tab.Vector(o) x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 @@ -117,19 +110,19 @@ def Attributes(self, j): # Field def AttributesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) if o != 0: return self._tab.VectorLen(o) return 0 # Field def AttributesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) return o == 0 # Field def Documentation(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) if o != 0: a = self._tab.Vector(o) return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) @@ -137,19 +130,19 @@ def Documentation(self, j): # Field def DocumentationLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) if o != 0: return self._tab.VectorLen(o) return 0 # Field def DocumentationIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) return o == 0 # Field def Optional(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False @@ -157,12 +150,12 @@ def Optional(self): # Number of padding octets to always add after this field. Structs only. # Field def Padding(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28)) if o != 0: return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos) return 0 -def FieldStart(builder): builder.StartObject(14) +def FieldStart(builder): builder.StartObject(13) def Start(builder): return FieldStart(builder) def FieldAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) @@ -183,34 +176,31 @@ def AddDefaultInteger(builder, defaultInteger): def FieldAddDefaultReal(builder, defaultReal): builder.PrependFloat64Slot(5, defaultReal, 0.0) def AddDefaultReal(builder, defaultReal): return FieldAddDefaultReal(builder, defaultReal) -def FieldAddDefaultString(builder, defaultString): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(defaultString), 0) -def AddDefaultString(builder, defaultString): - return FieldAddDefaultString(builder, defaultString) -def FieldAddDeprecated(builder, deprecated): builder.PrependBoolSlot(7, deprecated, 0) +def FieldAddDeprecated(builder, deprecated): builder.PrependBoolSlot(6, deprecated, 0) def AddDeprecated(builder, deprecated): return FieldAddDeprecated(builder, deprecated) -def FieldAddRequired(builder, required): builder.PrependBoolSlot(8, required, 0) +def FieldAddRequired(builder, required): builder.PrependBoolSlot(7, required, 0) def AddRequired(builder, required): return FieldAddRequired(builder, required) -def FieldAddKey(builder, key): builder.PrependBoolSlot(9, key, 0) +def FieldAddKey(builder, key): builder.PrependBoolSlot(8, key, 0) def AddKey(builder, key): return FieldAddKey(builder, key) -def FieldAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) +def FieldAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) def AddAttributes(builder, attributes): return FieldAddAttributes(builder, attributes) def FieldStartAttributesVector(builder, numElems): return builder.StartVector(4, numElems, 4) def StartAttributesVector(builder, numElems): return FieldStartAttributesVector(builder, numElems) -def FieldAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) +def FieldAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) def AddDocumentation(builder, documentation): return FieldAddDocumentation(builder, documentation) def FieldStartDocumentationVector(builder, numElems): return builder.StartVector(4, numElems, 4) def StartDocumentationVector(builder, numElems): return FieldStartDocumentationVector(builder, numElems) -def FieldAddOptional(builder, optional): builder.PrependBoolSlot(12, optional, 0) +def FieldAddOptional(builder, optional): builder.PrependBoolSlot(11, optional, 0) def AddOptional(builder, optional): return FieldAddOptional(builder, optional) -def FieldAddPadding(builder, padding): builder.PrependUint16Slot(13, padding, 0) +def FieldAddPadding(builder, padding): builder.PrependUint16Slot(12, padding, 0) def AddPadding(builder, padding): return FieldAddPadding(builder, padding) def FieldEnd(builder): return builder.EndObject() diff --git a/reflection/reflection.fbs b/reflection/reflection.fbs index 25ddf63fe17..287f36e63f9 100644 --- a/reflection/reflection.fbs +++ b/reflection/reflection.fbs @@ -76,7 +76,6 @@ table Field { offset:ushort; // Offset into the vtable for tables, or into the struct. default_integer:long = 0; default_real:double = 0.0; - default_string:string; deprecated:bool = false; required:bool = false; key:bool = false; diff --git a/src/bfbs_gen_nim.cpp b/src/bfbs_gen_nim.cpp index 7e7118c3728..e1ac899554c 100644 --- a/src/bfbs_gen_nim.cpp +++ b/src/bfbs_gen_nim.cpp @@ -499,9 +499,7 @@ class NimBfbsGenerator : public BaseBfbsGenerator { } return NumToString((field->default_integer())); } - if (base_type == r::String) { - return "\"" + field->default_string()->str() + "\""; - } + if (base_type == r::String) { return "\"\""; } // represents offsets return "0"; } diff --git a/src/idl_parser.cpp b/src/idl_parser.cpp index 3a0a0e2947e..966df6dc46a 100644 --- a/src/idl_parser.cpp +++ b/src/idl_parser.cpp @@ -1500,7 +1500,7 @@ CheckedError Parser::ParseTable(const StructDef &struct_def, std::string *value, if (!struct_def.sortbysize || size == SizeOf(field_value.type.base_type)) { switch (field_value.type.base_type) { - // clang-format off +// clang-format off #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \ case BASE_TYPE_ ## ENUM: \ builder_.Pad(field->padding); \ @@ -1627,7 +1627,7 @@ CheckedError Parser::ParseVector(const Type &type, uoffset_t *ovalue, // start at the back, since we're building the data backwards. auto &val = field_stack_.back().first; switch (val.type.base_type) { - // clang-format off +// clang-format off #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE,...) \ case BASE_TYPE_ ## ENUM: \ if (IsStruct(val.type)) SerializeStruct(*val.type.struct_def, val); \ @@ -3771,8 +3771,6 @@ Offset FieldDef::Serialize(FlatBufferBuilder *builder, auto docs__ = parser.opts.binary_schema_comments ? builder->CreateVectorOfStrings(doc_comment) : 0; - auto default_string__ = - builder->CreateString(IsString(value.type) ? value.constant : ""); double d; StringToNumber(value.constant.c_str(), &d); return reflection::CreateField( @@ -3780,9 +3778,8 @@ Offset FieldDef::Serialize(FlatBufferBuilder *builder, // Is uint64>max(int64) tested? IsInteger(value.type.base_type) ? StringToInt(value.constant.c_str()) : 0, // result may be platform-dependent if underlying is float (not double) - IsFloat(value.type.base_type) ? d : 0.0, default_string__, deprecated, - IsRequired(), key, attr__, docs__, IsOptional(), - static_cast(padding)); + IsFloat(value.type.base_type) ? d : 0.0, deprecated, IsRequired(), key, + attr__, docs__, IsOptional(), static_cast(padding)); // TODO: value.constant is almost always "0", we could save quite a bit of // space by sharing it. Same for common values of value.type. } diff --git a/tests/nim/tests/moredefaults/test.nim b/tests/nim/tests/moredefaults/test.nim index e300b55535c..4ba5225ed2b 100644 --- a/tests/nim/tests/moredefaults/test.nim +++ b/tests/nim/tests/moredefaults/test.nim @@ -18,7 +18,6 @@ suite "TestMoreDefaults": var defaults: MoreDefaults defaults.GetRootAs(fbb.FinishedBytes(), 0) check(defaults.emptyString == "") - check(defaults.someString == "some") check(defaults.ints == []) check(defaults.floats == []) check(defaults.bools == []) From bf1dcfc76ef27ad19b55a014efd96aab648abdc5 Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Fri, 16 Sep 2022 12:35:41 +0300 Subject: [PATCH 07/29] Move tests to python file --- nim/flatbuffers.nimble | 2 +- tests/nim/NimTest.sh | 19 ----------- tests/nim/testnim.py | 76 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 77 insertions(+), 20 deletions(-) delete mode 100755 tests/nim/NimTest.sh create mode 100644 tests/nim/testnim.py diff --git a/nim/flatbuffers.nimble b/nim/flatbuffers.nimble index cc30478117b..df16be26a09 100644 --- a/nim/flatbuffers.nimble +++ b/nim/flatbuffers.nimble @@ -1,4 +1,4 @@ -version = "1.0.0" +version = "2.0.8" author = "flatbuffers" description = "Flatbuffers" license = "Apache 2.0" diff --git a/tests/nim/NimTest.sh b/tests/nim/NimTest.sh deleted file mode 100755 index 24e9a54159c..00000000000 --- a/tests/nim/NimTest.sh +++ /dev/null @@ -1,19 +0,0 @@ -nim_dir=`pwd` -cd .. -test_dir=`pwd` -alias flatc='${test_dir}/../build/flatc' -shopt -s expand_aliases - -mkdir -p ${nim_dir}/generated -cd ${nim_dir}/generated/ -flatc --nim --gen-mutable -I ${test_dir}/include_test ${test_dir}/monster_test.fbs -flatc --nim ${test_dir}/optional_scalars.fbs -flatc --nim ${test_dir}/more_defaults.fbs -flatc --nim --gen-mutable ${test_dir}/MutatingBool.fbs -cd ${nim_dir} - -testament --megatest:off all -rm -r ${nim_dir}/generated -rm -r ${nim_dir}/nimcache -rm -r ${nim_dir}/testresults -rm -r ${nim_dir}/tests/*/test diff --git a/tests/nim/testnim.py b/tests/nim/testnim.py new file mode 100644 index 00000000000..0edb77e8efd --- /dev/null +++ b/tests/nim/testnim.py @@ -0,0 +1,76 @@ +import glob +import os +import shutil +import subprocess +import sys +from pathlib import Path + +test_nim_dir = Path(__file__).parent +test_dir = test_nim_dir.parent +generated_dir = test_nim_dir / "generated" +scripts_dir = test_dir.parent / "scripts" +sys.path.insert(0, str(scripts_dir)) +from util import flatc + + +def generate_mygame(): + flatc( + [ + "--nim", + "--gen-mutable", + ], + include=str(test_dir / "include_test"), + schema=test_dir / "monster_test.fbs", + cwd=Path(generated_dir), + ) + + +def generate_optional_scalars(): + flatc( + [ + "--nim", + ], + schema=test_dir / "optional_scalars.fbs", + cwd=Path(generated_dir), + ) + + +def generate_moredefaults(): + flatc( + [ + "--nim", + ], + schema=test_dir / "more_defaults.fbs", + cwd=Path(generated_dir), + ) + + +def generate_mutatingbool(): + flatc( + [ + "--nim", + "--gen-mutable", + ], + schema=test_dir / "MutatingBool.fbs", + cwd=Path(generated_dir), + ) + + +def main(): + generated_dir.mkdir(exist_ok=True) + try: + generate_mygame() + generate_optional_scalars() + generate_moredefaults() + generate_mutatingbool() + subprocess.check_call("testament --megatest:off all".split()) + finally: + shutil.rmtree(generated_dir) + shutil.rmtree(test_nim_dir / "nimcache") + shutil.rmtree(test_nim_dir / "testresults") + for f in glob.glob(str(test_nim_dir / "tests" / "*" / "test")): + os.remove(f) + + +if __name__ == "__main__": + main() From 14c639a496c6611f795a58dfb7bd3305b2549b44 Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Fri, 16 Sep 2022 12:57:55 +0300 Subject: [PATCH 08/29] Fix element size check when element is table --- python/flatbuffers/reflection/Field.py | 48 ++++++++++--------------- samples/monster.bfbs | Bin 2168 -> 2168 bytes src/idl_parser.cpp | 8 +++-- tests/MyGame/Example/Monster.lua | 4 +-- tests/monster_test.afb | 2 +- tests/monster_test.bfbs | Bin 14784 -> 14784 bytes tests/monster_test_bfbs_generated.h | 2 +- 7 files changed, 28 insertions(+), 36 deletions(-) diff --git a/python/flatbuffers/reflection/Field.py b/python/flatbuffers/reflection/Field.py index 6b0c7aaea5e..01b52808a1f 100644 --- a/python/flatbuffers/reflection/Field.py +++ b/python/flatbuffers/reflection/Field.py @@ -74,37 +74,30 @@ def DefaultReal(self): return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos) return 0.0 - # Field - def DefaultString(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) - if o != 0: - return self._tab.String(o + self._tab.Pos) - return None - # Field def Deprecated(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # Field def Required(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # Field def Key(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # Field def Attributes(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) if o != 0: x = self._tab.Vector(o) x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 @@ -117,19 +110,19 @@ def Attributes(self, j): # Field def AttributesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) if o != 0: return self._tab.VectorLen(o) return 0 # Field def AttributesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) return o == 0 # Field def Documentation(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) if o != 0: a = self._tab.Vector(o) return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) @@ -137,19 +130,19 @@ def Documentation(self, j): # Field def DocumentationLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) if o != 0: return self._tab.VectorLen(o) return 0 # Field def DocumentationIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) return o == 0 # Field def Optional(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False @@ -157,12 +150,12 @@ def Optional(self): # Number of padding octets to always add after this field. Structs only. # Field def Padding(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28)) if o != 0: return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos) return 0 -def FieldStart(builder): builder.StartObject(14) +def FieldStart(builder): builder.StartObject(13) def Start(builder): return FieldStart(builder) def FieldAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) @@ -183,34 +176,31 @@ def AddDefaultInteger(builder, defaultInteger): def FieldAddDefaultReal(builder, defaultReal): builder.PrependFloat64Slot(5, defaultReal, 0.0) def AddDefaultReal(builder, defaultReal): return FieldAddDefaultReal(builder, defaultReal) -def FieldAddDefaultString(builder, defaultString): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(defaultString), 0) -def AddDefaultString(builder, defaultString): - return FieldAddDefaultString(builder, defaultString) -def FieldAddDeprecated(builder, deprecated): builder.PrependBoolSlot(7, deprecated, 0) +def FieldAddDeprecated(builder, deprecated): builder.PrependBoolSlot(6, deprecated, 0) def AddDeprecated(builder, deprecated): return FieldAddDeprecated(builder, deprecated) -def FieldAddRequired(builder, required): builder.PrependBoolSlot(8, required, 0) +def FieldAddRequired(builder, required): builder.PrependBoolSlot(7, required, 0) def AddRequired(builder, required): return FieldAddRequired(builder, required) -def FieldAddKey(builder, key): builder.PrependBoolSlot(9, key, 0) +def FieldAddKey(builder, key): builder.PrependBoolSlot(8, key, 0) def AddKey(builder, key): return FieldAddKey(builder, key) -def FieldAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) +def FieldAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) def AddAttributes(builder, attributes): return FieldAddAttributes(builder, attributes) def FieldStartAttributesVector(builder, numElems): return builder.StartVector(4, numElems, 4) def StartAttributesVector(builder, numElems): return FieldStartAttributesVector(builder, numElems) -def FieldAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) +def FieldAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) def AddDocumentation(builder, documentation): return FieldAddDocumentation(builder, documentation) def FieldStartDocumentationVector(builder, numElems): return builder.StartVector(4, numElems, 4) def StartDocumentationVector(builder, numElems): return FieldStartDocumentationVector(builder, numElems) -def FieldAddOptional(builder, optional): builder.PrependBoolSlot(12, optional, 0) +def FieldAddOptional(builder, optional): builder.PrependBoolSlot(11, optional, 0) def AddOptional(builder, optional): return FieldAddOptional(builder, optional) -def FieldAddPadding(builder, padding): builder.PrependUint16Slot(13, padding, 0) +def FieldAddPadding(builder, padding): builder.PrependUint16Slot(12, padding, 0) def AddPadding(builder, padding): return FieldAddPadding(builder, padding) def FieldEnd(builder): return builder.EndObject() diff --git a/samples/monster.bfbs b/samples/monster.bfbs index 99a93f5a0be36e978f8aa8b90286b61203b1f6df..5b47002040811049e12c8439d65f58dde0efc8ce 100644 GIT binary patch delta 14 Wcmew%@Izq317=2^%@3KUvj6}xBL(9C delta 14 Wcmew%@Izq317=2+%@3KUvj6}w^99=g diff --git a/src/idl_parser.cpp b/src/idl_parser.cpp index 966df6dc46a..c2dae160dc9 100644 --- a/src/idl_parser.cpp +++ b/src/idl_parser.cpp @@ -1500,7 +1500,7 @@ CheckedError Parser::ParseTable(const StructDef &struct_def, std::string *value, if (!struct_def.sortbysize || size == SizeOf(field_value.type.base_type)) { switch (field_value.type.base_type) { -// clang-format off + // clang-format off #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \ case BASE_TYPE_ ## ENUM: \ builder_.Pad(field->padding); \ @@ -1627,7 +1627,7 @@ CheckedError Parser::ParseVector(const Type &type, uoffset_t *ovalue, // start at the back, since we're building the data backwards. auto &val = field_stack_.back().first; switch (val.type.base_type) { -// clang-format off + // clang-format off #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE,...) \ case BASE_TYPE_ ## ENUM: \ if (IsStruct(val.type)) SerializeStruct(*val.type.struct_def, val); \ @@ -3936,7 +3936,9 @@ bool EnumVal::Deserialize(const Parser &parser, Offset Type::Serialize(FlatBufferBuilder *builder) const { size_t element_size = SizeOf(element); - if (base_type == BASE_TYPE_VECTOR && element == BASE_TYPE_STRUCT) { + if (base_type == BASE_TYPE_VECTOR && element == BASE_TYPE_STRUCT && + struct_def->bytesize != 0) { + // struct_def->bytesize==0 means struct is table element_size = struct_def->bytesize; } return reflection::CreateType( diff --git a/tests/MyGame/Example/Monster.lua b/tests/MyGame/Example/Monster.lua index 6697c9b2ce1..58ab30445dd 100644 --- a/tests/MyGame/Example/Monster.lua +++ b/tests/MyGame/Example/Monster.lua @@ -359,7 +359,7 @@ function mt:Testarrayofsortedstruct(j) local o = self.view:Offset(62) if o ~= 0 then local x = self.view:Vector(o) - x = x + ((j-1) * 4) + x = x + ((j-1) * 8) local obj = __MyGame_Example_Ability.New() obj:Init(self.view.bytes, x) return obj @@ -852,7 +852,7 @@ function Monster.AddTestarrayofsortedstruct(builder, testarrayofsortedstruct) end function Monster.StartTestarrayofsortedstructVector(builder, numElems) - return builder:StartVector(4, numElems, 4) + return builder:StartVector(8, numElems, 4) end function Monster.AddFlex(builder, flex) diff --git a/tests/monster_test.afb b/tests/monster_test.afb index b98933a78ba..07cb352b418 100644 --- a/tests/monster_test.afb +++ b/tests/monster_test.afb @@ -3438,7 +3438,7 @@ table (reflection.Type): +0x1F5A | 0E | uint8_t | 0x0E (14) | table field `base_type` (Byte) +0x1F5B | 0F | uint8_t | 0x0F (15) | table field `element` (Byte) +0x1F5C | 00 00 00 00 | uint32_t | 0x00000000 (0) | table field `index` (Int) - +0x1F60 | 04 00 00 00 | uint32_t | 0x00000004 (4) | table field `element_size` (UInt) + +0x1F60 | 08 00 00 00 | uint32_t | 0x00000008 (8) | table field `element_size` (UInt) string (reflection.Field.name): +0x1F64 | 17 00 00 00 | uint32_t | 0x00000017 (23) | length of string diff --git a/tests/monster_test.bfbs b/tests/monster_test.bfbs index d389aabf1206e4222b47facfe00ff4b564615092..3838df207a06cdd326074235eca90a7158b2ed77 100644 GIT binary patch delta 14 VcmX?5e4uzkf;=O~=0y2;DF8411xo+` delta 14 VcmX?5e4uzkf;=P3=0y2;DF83!1xEk? diff --git a/tests/monster_test_bfbs_generated.h b/tests/monster_test_bfbs_generated.h index f8bc4aaa435..ac601d6a7d4 100644 --- a/tests/monster_test_bfbs_generated.h +++ b/tests/monster_test_bfbs_generated.h @@ -421,7 +421,7 @@ struct MonsterBinarySchema { 0x1D,0x00,0x3E,0x00,0x48,0x00,0x00,0x00,0x34,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x04,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0xD4,0xE9,0xFF,0xFF,0x10,0x00,0x00,0x00, 0x04,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x32,0x39,0x00,0x00,0x02,0x00,0x00,0x00,0x69,0x64,0x00,0x00, - 0xA4,0xF5,0xFF,0xFF,0x00,0x00,0x0E,0x0F,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x17,0x00,0x00,0x00, + 0xA4,0xF5,0xFF,0xFF,0x00,0x00,0x0E,0x0F,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x17,0x00,0x00,0x00, 0x74,0x65,0x73,0x74,0x61,0x72,0x72,0x61,0x79,0x6F,0x66,0x73,0x6F,0x72,0x74,0x65,0x64,0x73,0x74,0x72, 0x75,0x63,0x74,0x00,0x5C,0xF4,0xFF,0xFF,0x00,0x00,0x00,0x01,0x1C,0x00,0x3C,0x00,0x44,0x00,0x00,0x00, 0x34,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00, From 581ffe1d31984e5bfc51d680f001b2bfcb323550 Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Sun, 18 Sep 2022 22:48:35 +0300 Subject: [PATCH 09/29] remove whitespace changes --- CMakeLists.txt | 38 +++++++++++++++++++------------------- reflection/reflection.fbs | 2 +- 2 files changed, 20 insertions(+), 20 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 2caccf77aee..246f7e92e67 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -71,10 +71,10 @@ option(FLATBUFFERS_ENABLE_PCH Only work if CMake supports 'target_precompile_headers'. \" This can speed up compilation time." OFF) -option(FLATBUFFERS_SKIP_MONSTER_EXTRA +option(FLATBUFFERS_SKIP_MONSTER_EXTRA "Skip generating monster_extra.fbs that contains non-supported numerical\" types." OFF) -option(FLATBUFFERS_STRICT_MODE +option(FLATBUFFERS_STRICT_MODE "Build flatbuffers with all warnings as errors (-Werror or /WX)." OFF) @@ -354,8 +354,8 @@ include_directories(grpc) # Creates an interface library that stores the configuration settings that each # target links too. This is a compromise between setting configuration globally -# with add_compile_options() and the more targetted target_compile_options(). -# This way each target in this file can share settings and override them if +# with add_compile_options() and the more targetted target_compile_options(). +# This way each target in this file can share settings and override them if # needed. add_library(ProjectConfig INTERFACE) target_compile_features(ProjectConfig @@ -371,7 +371,7 @@ set(CMAKE_CXX_EXTENSIONS OFF) if(MSVC_LIKE) target_compile_options(ProjectConfig - INTERFACE + INTERFACE /W4 $<$: /WX # Treat all compiler warnings as errors @@ -403,8 +403,8 @@ else() -Wno-error=stringop-overflow > > - -pedantic - -Wextra + -pedantic + -Wextra -Wno-unused-parameter -Wold-style-cast -fsigned-char @@ -418,7 +418,7 @@ else() $<$,3.8>: -Wimplicit-fallthrough -Wextra-semi - $<$: + $<$: -Werror=unused-private-field > > @@ -427,7 +427,7 @@ else() $<$: $<$,4.4>: -Wunused-result - -Wunused-parameter + -Wunused-parameter -Werror=unused-parameter -Wmissing-declarations > @@ -435,7 +435,7 @@ else() -Wzero-as-null-pointer-constant > $<$,7.0>: - -faligned-new + -faligned-new $<$: -Werror=implicit-fallthrough=2 > @@ -465,7 +465,7 @@ if(FLATBUFFERS_BUILD_FLATLIB) add_library(flatbuffers STATIC ${FlatBuffers_Library_SRCS}) # Attach header directory for when build via add_subdirectory(). - target_include_directories(flatbuffers + target_include_directories(flatbuffers INTERFACE $ ) @@ -483,7 +483,7 @@ if(FLATBUFFERS_BUILD_FLATC) endif() target_link_libraries(flatc PRIVATE $) - target_compile_options(flatc + target_compile_options(flatc PUBLIC $<$,$>: /MT @@ -684,13 +684,13 @@ if(FLATBUFFERS_BUILD_GRPCTEST) find_package(gRPC CONFIG REQUIRED) add_executable(grpctest ${FlatBuffers_GRPCTest_SRCS}) add_dependencies(grpctest generated_code) - target_link_libraries(grpctext - PRIVATE + target_link_libraries(grpctext + PRIVATE $ - gRPC::grpc++_unsecure - gRPC::gpr + gRPC::grpc++_unsecure + gRPC::gpr pthread - dl + dl ) endif() @@ -703,8 +703,8 @@ if(FLATBUFFERS_INSTALL) configure_file(CMake/flatbuffers-config-version.cmake.in flatbuffers-config-version.cmake @ONLY) install( - FILES - "CMake/flatbuffers-config.cmake" + FILES + "CMake/flatbuffers-config.cmake" "CMake/BuildFlatBuffers.cmake" "${CMAKE_CURRENT_BINARY_DIR}/flatbuffers-config-version.cmake" DESTINATION ${FB_CMAKE_DIR} diff --git a/reflection/reflection.fbs b/reflection/reflection.fbs index 287f36e63f9..6dfeff66a13 100644 --- a/reflection/reflection.fbs +++ b/reflection/reflection.fbs @@ -83,7 +83,7 @@ table Field { documentation:[string]; optional:bool = false; /// Number of padding octets to always add after this field. Structs only. - padding:uint16 = 0; + padding:uint16 = 0; } table Object { // Used for both tables and structs. From a5278bd82ddf9211a05fc3585c757634d90de1b7 Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Tue, 20 Sep 2022 13:44:24 +0300 Subject: [PATCH 10/29] add element_type docs and commit further to namer and remove kkeep --- src/bfbs_gen.h | 6 +++ src/bfbs_gen_nim.cpp | 123 +++++++++++++++++++++++-------------------- 2 files changed, 72 insertions(+), 57 deletions(-) diff --git a/src/bfbs_gen.h b/src/bfbs_gen.h index 6dab3d3bd37..a18cdcb9920 100644 --- a/src/bfbs_gen.h +++ b/src/bfbs_gen.h @@ -131,6 +131,9 @@ class BaseBfbsGenerator : public BfbsGenerator { } protected: + // GetObject returns the underlying object struct of the given type + // if element_type is true and GetObject is a list of objects then + // GetObject will correctly return the object struct of the vector's elements const reflection::Object *GetObject(const reflection::Type *type, bool element_type = false) const { const reflection::BaseType base_type = @@ -141,6 +144,9 @@ class BaseBfbsGenerator : public BfbsGenerator { return nullptr; } + // GetEnum returns the underlying enum struct of the given type + // if element_type is true and GetEnum is a list of enums then + // GetEnum will correctly return the enum struct of the vector's elements const reflection::Enum *GetEnum(const reflection::Type *type, bool element_type = false) const { const reflection::BaseType base_type = diff --git a/src/bfbs_gen_nim.cpp b/src/bfbs_gen_nim.cpp index e1ac899554c..8eb45725346 100644 --- a/src/bfbs_gen_nim.cpp +++ b/src/bfbs_gen_nim.cpp @@ -55,13 +55,13 @@ std::set NimKeywords() { } Namer::Config NimDefaultConfig() { - return { /*types=*/Case::kKeep, - /*constants=*/Case::kScreamingSnake, - /*methods=*/Case::kUpperCamel, + return { /*types=*/Case::kUpperCamel, + /*constants=*/Case::kUpperCamel, + /*methods=*/Case::kLowerCamel, /*functions=*/Case::kUpperCamel, /*fields=*/Case::kLowerCamel, /*variable=*/Case::kLowerCamel, - /*variants=*/Case::kKeep, + /*variants=*/Case::kUpperCamel, /*enum_variant_seperator=*/".", /*escape_keywords=*/Namer::Config::Escape::AfterConvertingCase, /*namespaces=*/Case::kKeep, @@ -85,29 +85,6 @@ const std::set builtin_types = { "float64", "string", "int", "uint", "uoffset", "Builder" }; -// Returns the correct name for the type -// Type: -// MyGame.Example.Monster: -// Current: -// Monster -// Imported: -// MyGame_Example_Monster.Monster -std::string Denamespace(const std::string &s, bool current = false) { - if (builtin_types.find(s) != builtin_types.end()) { return s; } - std::string prefix; - const size_t pos = s.find_last_of("."); - if (pos != std::string::npos) { prefix = s.substr(0, pos); } - std::string suffix = s.substr(pos + 1); - if (current) { - return suffix; - } else { - std::string underscored = prefix; - underscored += underscored.empty() ? "" : "_"; - std::replace(underscored.begin(), underscored.end(), '.', '_'); - return underscored + suffix + "." + suffix; - } -} - class NimBfbsGenerator : public BaseBfbsGenerator { public: explicit NimBfbsGenerator(const std::string &flatc_version) @@ -190,13 +167,13 @@ class NimBfbsGenerator : public BaseBfbsGenerator { base_type == r::Obj || base_type == r::Union) { GenerateDocumentation(field->documentation(), "", code); - std::string getter_signature = "func " + field_name + + std::string getter_signature = "func " + namer_.Method(field_name) + "*(self: " + object_name + "): " + field_type + " =\n"; std::string getter_code; - std::string setter_signature = "func `" + field_name + - "=`*(self: var " + object_name + - ", n: " + field_type + "): bool =\n"; + std::string setter_signature = + "func `" + namer_.Method(field_name + "=") + "`*(self: var " + + object_name + ", n: " + field_type + "): bool =\n"; std::string setter_code; if (base_type == r::Obj || base_type == r::Union || @@ -253,14 +230,14 @@ class NimBfbsGenerator : public BaseBfbsGenerator { } // Get vector length: - code += "func " + field_name + "Length*(self: " + object_name + - "): int = \n"; + code += "func " + namer_.Method(field_name + "Length") + + "*(self: " + object_name + "): int = \n"; code += " " + offset_prefix; code += " " + offset_prefix_2; code += " return self.tab.VectorLen(o)\n"; // Get single vector field: - code += "func " + field_name + "*(self: " + object_name + + code += "func " + namer_.Method(field_name) + "*(self: " + object_name + ", j: int): " + GenerateType(field->type(), true) + " = \n"; code += " " + offset_prefix; code += " " + offset_prefix_2; @@ -273,7 +250,7 @@ class NimBfbsGenerator : public BaseBfbsGenerator { "\n"; // Get entire vector: - code += "func " + field_name + "*(self: " + object_name + + code += "func " + namer_.Method(field_name) + "*(self: " + object_name + "): " + GenerateType(field->type()) + " = \n"; code += " let len = self." + field_name + "Length\n"; code += " for i in countup(0, len - 1):\n"; @@ -285,14 +262,16 @@ class NimBfbsGenerator : public BaseBfbsGenerator { // Create all the builders if (object->is_struct()) { - code += "proc " + object_name + "Create*(self: var Builder"; + code += "proc " + namer_.Function(object_name + "Create") + + "*(self: var Builder"; code += GenerateStructBuilderArgs(object); code += "): uoffset =\n"; code += AppendStructBuilderBody(object); code += " return self.Offset()\n"; } else { // Table builders - code += "proc " + object_name + "Start*(builder: var Builder) =\n"; + code += "proc " + namer_.Function(object_name + "Start") + + "*(builder: var Builder) =\n"; code += " builder.StartObject(" + NumToString(object->fields()->size()) + ")\n"; @@ -303,7 +282,7 @@ class NimBfbsGenerator : public BaseBfbsGenerator { const std::string variable_name = namer_.Variable(field->name()->str()); const std::string variable_type = GenerateTypeBasic(field->type()); - code += "proc " + object_name + "Add" + field_name + + code += "proc " + namer_.Function(object_name + "Add" + field_name) + "*(builder: var Builder, " + variable_name + ": " + variable_type + ") =\n"; code += " builder.Prepend" + GenerateMethod(field) + "Slot(" + @@ -311,7 +290,8 @@ class NimBfbsGenerator : public BaseBfbsGenerator { variable_type + "))\n"; if (IsVector(field->type()->base_type())) { - code += "proc " + object_name + "Start" + field_name + + code += "proc " + + namer_.Function(object_name + "Start" + field_name) + "Vector*(builder: var Builder, numElems: uoffset) =\n"; const int32_t element_size = field->type()->element_size(); @@ -325,7 +305,8 @@ class NimBfbsGenerator : public BaseBfbsGenerator { } }); - code += "proc " + object_name + "End*(builder: var Builder): uoffset =\n"; + code += "proc " + namer_.Function(object_name + "End") + + "*(builder: var Builder): uoffset =\n"; code += " return builder.EndObject()\n"; } EmitCodeBlock(code, object_name, ns, object->declaration_file()->str()); @@ -416,6 +397,25 @@ class NimBfbsGenerator : public BaseBfbsGenerator { } } + std::string Denamespace(const std::string &s, std::string &importns, + std::string &ns) const { + if (builtin_types.find(s) != builtin_types.end()) { return s; } + std::string type = namer_.Type(namer_.Denamespace(s, ns)); + importns = ns.empty() ? type : ns + "." + type; + std::replace(importns.begin(), importns.end(), '.', '_'); + return type; + } + + std::string Denamespace(const std::string &s, std::string &importns) const { + std::string ns; + return Denamespace(s, importns, ns); + } + + std::string Denamespace(const std::string &s) const { + std::string importns; + return Denamespace(s, importns); + } + std::string GenerateType(const r::Type *type, bool element_type = false, bool enum_inner = false) const { const r::BaseType base_type = @@ -423,8 +423,9 @@ class NimBfbsGenerator : public BaseBfbsGenerator { if (IsScalar(base_type) && !enum_inner) { const r::Enum *type_enum = GetEnum(type, element_type); if (type_enum != nullptr) { - std::string type_name = type_enum->name()->str(); - return Denamespace(namer_.Type(type_name)); + std::string importns; + std::string type_name = Denamespace(type_enum->name()->str(), importns); + return importns + "." + type_name; } } if (IsScalar(base_type)) { return Denamespace(GenerateType(base_type)); } @@ -436,8 +437,13 @@ class NimBfbsGenerator : public BaseBfbsGenerator { case r::Union: return "Vtable"; case r::Obj: { const r::Object *type_obj = GetObject(type, element_type); - std::string type_name = type_obj->name()->str(); - return Denamespace(namer_.Type(type_name), type_obj == current_obj_); + std::string importns; + std::string type_name = Denamespace(type_obj->name()->str(), importns); + if (type_obj == current_obj_) { + return type_name; + } else { + return importns + "." + type_name; + } } default: return "uoffset"; } @@ -559,34 +565,37 @@ class NimBfbsGenerator : public BaseBfbsGenerator { return new_path; } - std::string RegisterImports(const r::Object *object, const r::Field *field, - bool use_element = false) { + void RegisterImports(const r::Object *object, const r::Field *field, + bool use_element = false) { + std::string importns; std::string type_name; const r::BaseType type = use_element ? field->type()->element() : field->type()->base_type(); if (IsStructOrTable(type)) { - const r::Object *object = GetObjectByIndex(field->type()->index()); - if (object == current_obj_) { return namer_.Denamespace(object); } - type_name = object->name()->str(); + const r::Object *object_def = GetObjectByIndex(field->type()->index()); + if (object_def == current_obj_) { return; } + std::string ns; + type_name = Denamespace(object_def->name()->str(), importns, ns); + type_name = ns.empty() ? type_name : ns + "." + type_name; } else { const r::Enum *enum_def = GetEnumByIndex(field->type()->index()); - if (enum_def == current_enum_) { return namer_.Denamespace(enum_def); } - type_name = enum_def->name()->str(); + if (enum_def == current_enum_) { return; } + std::string ns; + type_name = Denamespace(enum_def->name()->str(), importns, ns); + type_name = ns.empty() ? type_name : ns + "." + type_name; } - std::string name = type_name; - std::replace(name.begin(), name.end(), '.', '_'); std::string import_path = GetRelativePathFromNamespace(object->name()->str(), type_name); - return RegisterImports(import_path, name); + std::replace(type_name.begin(), type_name.end(), '.', '_'); + RegisterImports(import_path, importns); } - std::string RegisterImports(const std::string &local_name, - const std::string &imports_name) { + void RegisterImports(const std::string &local_name, + const std::string &imports_name) { imports_[local_name] = imports_name; - return local_name; } void EmitCodeBlock(const std::string &code_block, const std::string &name, From cfba8fd8627df0cbac36ca5e7bf2bedb41490242 Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Fri, 16 Sep 2022 00:02:29 +0300 Subject: [PATCH 11/29] Bfbs Nim Generator --- .github/labeler.yml | 10 +- CMakeLists.txt | 40 +- include/flatbuffers/reflection_generated.h | 28 +- nim/flatbuffers.nimble | 7 + nim/flatbuffers/flatbuffers.nim | 7 + nim/flatbuffers/src/builder.nim | 262 +++++++ nim/flatbuffers/src/endian.nim | 12 + nim/flatbuffers/src/struct.nim | 24 + nim/flatbuffers/src/table.nim | 149 ++++ reflection/reflection.fbs | 3 +- src/BUILD.bazel | 4 + src/bfbs_gen.h | 21 +- src/bfbs_gen_nim.cpp | 656 ++++++++++++++++++ src/bfbs_gen_nim.h | 33 + src/flatc_main.cpp | 7 + src/idl_parser.cpp | 34 +- tests/FlatBuffers.Test.Nim/NimTest.sh | 19 + .../tests/moredefaults/test.nim | 55 ++ .../tests/mutatingbool/test.nim | 43 ++ .../tests/mygame/test.nim | 528 ++++++++++++++ .../tests/optional_scalars/test.nim | 29 + 21 files changed, 1921 insertions(+), 50 deletions(-) create mode 100644 nim/flatbuffers.nimble create mode 100644 nim/flatbuffers/flatbuffers.nim create mode 100644 nim/flatbuffers/src/builder.nim create mode 100644 nim/flatbuffers/src/endian.nim create mode 100644 nim/flatbuffers/src/struct.nim create mode 100644 nim/flatbuffers/src/table.nim create mode 100644 src/bfbs_gen_nim.cpp create mode 100644 src/bfbs_gen_nim.h create mode 100755 tests/FlatBuffers.Test.Nim/NimTest.sh create mode 100644 tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim create mode 100644 tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim create mode 100644 tests/FlatBuffers.Test.Nim/tests/mygame/test.nim create mode 100644 tests/FlatBuffers.Test.Nim/tests/optional_scalars/test.nim diff --git a/.github/labeler.yml b/.github/labeler.yml index eb1d7fdf807..dcab0447e8c 100644 --- a/.github/labeler.yml +++ b/.github/labeler.yml @@ -18,6 +18,12 @@ swift: - tests/swift/** - src/idl_gen_swift.cpp +nim: + - '**/*.nim' + - nim/**/* + - src/idl_gen_nim.cpp + - src/bfbs_gen_nim.cpp + javascript: - '**/*.js' - src/idl_gen_ts.cpp @@ -61,7 +67,7 @@ rust: - '**/*.rs' - rust/**/* - src/idl_gen_rust.cpp - + dart: - '**/*.dart' - src/idl_gen_dart.cpp @@ -88,4 +94,4 @@ CI: grpc: - grpc/**/* - - src/idl_gen_grpc.cpp \ No newline at end of file + - src/idl_gen_grpc.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 7c740fb2433..1b3576d9292 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -71,10 +71,10 @@ option(FLATBUFFERS_ENABLE_PCH Only work if CMake supports 'target_precompile_headers'. \" This can speed up compilation time." OFF) -option(FLATBUFFERS_SKIP_MONSTER_EXTRA +option(FLATBUFFERS_SKIP_MONSTER_EXTRA "Skip generating monster_extra.fbs that contains non-supported numerical\" types." OFF) -option(FLATBUFFERS_STRICT_MODE +option(FLATBUFFERS_STRICT_MODE "Build flatbuffers with all warnings as errors (-Werror or /WX)." OFF) @@ -182,6 +182,7 @@ set(FlatBuffers_Compiler_SRCS src/flatc_main.cpp src/bfbs_gen.h src/bfbs_gen_lua.h + src/bfbs_gen_nim.h src/bfbs_namer.h include/flatbuffers/code_generators.h src/binary_annotator.h @@ -189,6 +190,7 @@ set(FlatBuffers_Compiler_SRCS src/annotated_binary_text_gen.h src/annotated_binary_text_gen.cpp src/bfbs_gen_lua.cpp + src/bfbs_gen_nim.cpp src/code_generators.cpp grpc/src/compiler/schema_interface.h grpc/src/compiler/cpp_generator.h @@ -356,8 +358,8 @@ include_directories(grpc) # Creates an interface library that stores the configuration settings that each # target links too. This is a compromise between setting configuration globally -# with add_compile_options() and the more targetted target_compile_options(). -# This way each target in this file can share settings and override them if +# with add_compile_options() and the more targetted target_compile_options(). +# This way each target in this file can share settings and override them if # needed. add_library(ProjectConfig INTERFACE) target_compile_features(ProjectConfig @@ -373,7 +375,7 @@ set(CMAKE_CXX_EXTENSIONS OFF) if(MSVC_LIKE) target_compile_options(ProjectConfig - INTERFACE + INTERFACE /W4 $<$: /WX # Treat all compiler warnings as errors @@ -405,8 +407,8 @@ else() -Wno-error=stringop-overflow > > - -pedantic - -Wextra + -pedantic + -Wextra -Wno-unused-parameter -Wold-style-cast -fsigned-char @@ -420,7 +422,7 @@ else() $<$,3.8>: -Wimplicit-fallthrough -Wextra-semi - $<$: + $<$: -Werror=unused-private-field > > @@ -429,7 +431,7 @@ else() $<$: $<$,4.4>: -Wunused-result - -Wunused-parameter + -Wunused-parameter -Werror=unused-parameter -Wmissing-declarations > @@ -437,7 +439,7 @@ else() -Wzero-as-null-pointer-constant > $<$,7.0>: - -faligned-new + -faligned-new $<$: -Werror=implicit-fallthrough=2 > @@ -467,7 +469,7 @@ if(FLATBUFFERS_BUILD_FLATLIB) add_library(flatbuffers STATIC ${FlatBuffers_Library_SRCS}) # Attach header directory for when build via add_subdirectory(). - target_include_directories(flatbuffers + target_include_directories(flatbuffers INTERFACE $ ) @@ -485,7 +487,7 @@ if(FLATBUFFERS_BUILD_FLATC) endif() target_link_libraries(flatc PRIVATE $) - target_compile_options(flatc + target_compile_options(flatc PUBLIC $<$,$>: /MT @@ -687,13 +689,13 @@ if(FLATBUFFERS_BUILD_GRPCTEST) find_package(gRPC CONFIG REQUIRED) add_executable(grpctest ${FlatBuffers_GRPCTest_SRCS}) add_dependencies(grpctest generated_code) - target_link_libraries(grpctext - PRIVATE + target_link_libraries(grpctext + PRIVATE $ - gRPC::grpc++_unsecure - gRPC::gpr + gRPC::grpc++_unsecure + gRPC::gpr pthread - dl + dl ) endif() @@ -706,8 +708,8 @@ if(FLATBUFFERS_INSTALL) configure_file(CMake/flatbuffers-config-version.cmake.in flatbuffers-config-version.cmake @ONLY) install( - FILES - "CMake/flatbuffers-config.cmake" + FILES + "CMake/flatbuffers-config.cmake" "CMake/BuildFlatBuffers.cmake" "${CMAKE_CURRENT_BINARY_DIR}/flatbuffers-config-version.cmake" DESTINATION ${FB_CMAKE_DIR} diff --git a/include/flatbuffers/reflection_generated.h b/include/flatbuffers/reflection_generated.h index 78674db5d42..d8c47edc0a3 100644 --- a/include/flatbuffers/reflection_generated.h +++ b/include/flatbuffers/reflection_generated.h @@ -580,13 +580,14 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_OFFSET = 10, VT_DEFAULT_INTEGER = 12, VT_DEFAULT_REAL = 14, - VT_DEPRECATED = 16, - VT_REQUIRED = 18, - VT_KEY = 20, - VT_ATTRIBUTES = 22, - VT_DOCUMENTATION = 24, - VT_OPTIONAL = 26, - VT_PADDING = 28 + VT_DEFAULT_STRING = 16, + VT_DEPRECATED = 18, + VT_REQUIRED = 20, + VT_KEY = 22, + VT_ATTRIBUTES = 24, + VT_DOCUMENTATION = 26, + VT_OPTIONAL = 28, + VT_PADDING = 30 }; const flatbuffers::String *name() const { return GetPointer(VT_NAME); @@ -612,6 +613,9 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { double default_real() const { return GetField(VT_DEFAULT_REAL, 0.0); } + const flatbuffers::String *default_string() const { + return GetPointer(VT_DEFAULT_STRING); + } bool deprecated() const { return GetField(VT_DEPRECATED, 0) != 0; } @@ -644,6 +648,8 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VerifyField(verifier, VT_OFFSET, 2) && VerifyField(verifier, VT_DEFAULT_INTEGER, 8) && VerifyField(verifier, VT_DEFAULT_REAL, 8) && + VerifyOffset(verifier, VT_DEFAULT_STRING) && + verifier.VerifyString(default_string()) && VerifyField(verifier, VT_DEPRECATED, 1) && VerifyField(verifier, VT_REQUIRED, 1) && VerifyField(verifier, VT_KEY, 1) && @@ -681,6 +687,9 @@ struct FieldBuilder { void add_default_real(double default_real) { fbb_.AddElement(Field::VT_DEFAULT_REAL, default_real, 0.0); } + void add_default_string(flatbuffers::Offset default_string) { + fbb_.AddOffset(Field::VT_DEFAULT_STRING, default_string); + } void add_deprecated(bool deprecated) { fbb_.AddElement(Field::VT_DEPRECATED, static_cast(deprecated), 0); } @@ -723,6 +732,7 @@ inline flatbuffers::Offset CreateField( uint16_t offset = 0, int64_t default_integer = 0, double default_real = 0.0, + flatbuffers::Offset default_string = 0, bool deprecated = false, bool required = false, bool key = false, @@ -735,6 +745,7 @@ inline flatbuffers::Offset CreateField( builder_.add_default_integer(default_integer); builder_.add_documentation(documentation); builder_.add_attributes(attributes); + builder_.add_default_string(default_string); builder_.add_type(type); builder_.add_name(name); builder_.add_padding(padding); @@ -755,6 +766,7 @@ inline flatbuffers::Offset CreateFieldDirect( uint16_t offset = 0, int64_t default_integer = 0, double default_real = 0.0, + const char *default_string = nullptr, bool deprecated = false, bool required = false, bool key = false, @@ -763,6 +775,7 @@ inline flatbuffers::Offset CreateFieldDirect( bool optional = false, uint16_t padding = 0) { auto name__ = name ? _fbb.CreateString(name) : 0; + auto default_string__ = default_string ? _fbb.CreateString(default_string) : 0; auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables(attributes) : 0; auto documentation__ = documentation ? _fbb.CreateVector>(*documentation) : 0; return reflection::CreateField( @@ -773,6 +786,7 @@ inline flatbuffers::Offset CreateFieldDirect( offset, default_integer, default_real, + default_string__, deprecated, required, key, diff --git a/nim/flatbuffers.nimble b/nim/flatbuffers.nimble new file mode 100644 index 00000000000..cc30478117b --- /dev/null +++ b/nim/flatbuffers.nimble @@ -0,0 +1,7 @@ +version = "1.0.0" +author = "flatbuffers" +description = "Flatbuffers" +license = "Apache 2.0" +srcDir = "flatbuffers" + +requires "nim >= 1.4.0" diff --git a/nim/flatbuffers/flatbuffers.nim b/nim/flatbuffers/flatbuffers.nim new file mode 100644 index 00000000000..b9532877e76 --- /dev/null +++ b/nim/flatbuffers/flatbuffers.nim @@ -0,0 +1,7 @@ +import + src/[ + builder, + struct, + table + ] +export flatbuffers.builder, flatbuffers.table, flatbuffers.struct diff --git a/nim/flatbuffers/src/builder.nim b/nim/flatbuffers/src/builder.nim new file mode 100644 index 00000000000..62ac2edb0be --- /dev/null +++ b/nim/flatbuffers/src/builder.nim @@ -0,0 +1,262 @@ +import math +import table + + +const MAX_BUFFER_SIZE* = 2^31 + + +type Builder* = ref object of RootObj + bytes*: seq[byte] + minalign*: int + current_vtable*: seq[uoffset] + objectEnd*: uoffset + vtables*: seq[uoffset] #? + head*: uoffset + nested*: bool + finished*: bool + vectorNumElems*: uoffset + +using this: var Builder + +func newBuilder*(size: int): Builder = + result = new Builder + result.bytes.setLen(size) + result.minalign = 1 + result.head = size.uoffset + result.nested = false + result.finished = false + result.vectorNumElems = 0 + +proc FinishedBytes*(this): seq[byte] = + if not this.finished: + quit("Builder not finished, Incorrect use of FinishedBytes(): must call 'Finish' first.") + result = this.bytes[this.head..^1] + +proc Output*(this): seq[byte] = + if not this.finished: + quit("Builder not finished, Incorrect use of Output(): must call 'Finish' first.") + + result = this.bytes[this.head..^1] + +func Offset*(this): uoffset = + result = this.bytes.len.uoffset - this.head + +proc StartObject*(this; numfields: int) = + if this.nested: + quit("builder is nested") + + this.current_vtable.setLen(numfields) + for i in this.current_vtable.mitems(): + i = 0 + this.objectEnd = this.Offset() + this.nested = true + +proc GrowByteBuffer*(this) = + if this.bytes.len == MAX_BUFFER_SIZE: + quit("flatbuffers: cannot grow buffer beyond 2 gigabytes") + let oldLen = this.bytes.len + var newLen = min(this.bytes.len * 2, MAX_BUFFER_SIZE) + if newLen == 0: + newLen = 1 + this.bytes.setLen(newLen) + var j = this.bytes.len - 1 + while j >= 0: + if j >= newLen - oldLen: + this.bytes[j] = this.bytes[j - (newLen - oldLen)] + else: + this.bytes[j] = 0 + dec(j) + +proc Place*[T](this; x: T) = + this.head -= uoffset x.sizeof + WriteVal(this.bytes, this.head, x) + +func Pad*(this; n: int) = + for i in 0.. this.minalign: + this.minalign = size + var alignsize = (not (this.bytes.len - this.head.int + additionalBytes)) + 1 + alignsize = alignsize and (size - 1) + + while this.head.int < alignsize + size + additionalBytes: + let oldbufSize = this.bytes.len + this.GrowByteBuffer() + this.head = (this.head.int + this.bytes.len - oldbufSize).uoffset + this.Pad(alignsize) + +proc PrependOffsetRelative*[T: Offsets](this; off: T) = + when T is voffset: + this.Prep(T.sizeof, 0) + if not off.uoffset <= this.Offset: + quit("flatbuffers: Offset arithmetic error.") + this.Place(off) + else: + this.Prep(T.sizeof, 0) + if not off.uoffset <= this.Offset: + quit("flatbuffers: Offset arithmetic error.") + let off2: T = this.Offset.T - off + sizeof(T).T + this.Place(off2) + + +proc Prepend*[T](this; x: T) = + this.Prep(x.sizeof, 0) + this.Place(x) + +proc Slot*(this; slotnum: int) = + this.current_vtable[slotnum] = this.Offset + +proc PrependSlot*[T](this; o: int; x, d: T) = + if x != d: + when T is uoffset or T is soffset or T is voffset: + this.PrependOffsetRelative(x) + else: + this.Prepend(x) + this.Slot(o) + +proc AssertStuctInline(this; obj: uoffset) = + if obj != this.Offset: + quit("flatbuffers: Tried to write a Struct at an Offset that is different from the current Offset of the Builder.") + +proc PrependStructSlot*(this; o: int; x: uoffset; d: uoffset) = + if x != d: + this.AssertStuctInline(x) + this.Slot(o) + +proc Add*[T](this; n: T) = + this.Prep(T.sizeof, 0) + WriteVal(this.bytes, this.head, n) + +proc VtableEqual*(a: seq[uoffset]; objectStart: uoffset; b: seq[byte]): bool = + if a.len * voffset.sizeof != b.len: + return false + + var i = 0 + while i < a.len: + var seq = b[i * voffset.sizeof..<(i + 1) * voffset.sizeof] + let x = GetVal[voffset](addr seq) + + if x == 0 and a[i] == 0: + inc i + continue + + let y = objectStart.soffset - a[i].soffset + if x.soffset != y: + return false + inc i + return true + +proc WriteVtable*(this): uoffset = + this.PrependOffsetRelative(0.soffset) + + let objectOffset = this.Offset + var existingVtable = uoffset 0 + + var i = this.current_vtable.len - 1 + while i >= 0 and this.current_vtable[i] == 0: dec i + + this.current_vtable = this.current_vtable[0..i] + for i in countdown(this.vtables.len - 1, 0): + let + vt2Offset: uoffset = this.vtables[i] + vt2Start: int = this.bytes.len - int vt2Offset + + var seq = this.bytes[vt2Start..cbegin(); it != objects->cend(); ++it) { func(*it); } } -static void ForAllEnumValues(const reflection::Enum *enum_def, - std::function func) { +static void ForAllEnumValues( + const reflection::Enum *enum_def, + std::function func) { for (auto it = enum_def->values()->cbegin(); it != enum_def->values()->cend(); ++it) { func(*it); @@ -91,7 +92,7 @@ static bool IsVector(const reflection::BaseType base_type) { return base_type == reflection::Vector; } -} // namespace +} // namespace // A concrete base Flatbuffer Generator that specific language generators can // derive from. @@ -130,17 +131,23 @@ class BaseBfbsGenerator : public BfbsGenerator { } protected: - const reflection::Object *GetObject(const reflection::Type *type) const { - if (type->index() >= 0 && IsStructOrTable(type->base_type())) { + const reflection::Object *GetObject(const reflection::Type *type, + bool element_type = false) const { + const reflection::BaseType base_type = + element_type ? type->element() : type->base_type(); + if (type->index() >= 0 && IsStructOrTable(base_type)) { return GetObjectByIndex(type->index()); } return nullptr; } - const reflection::Enum *GetEnum(const reflection::Type *type) const { + const reflection::Enum *GetEnum(const reflection::Type *type, + bool element_type = false) const { + const reflection::BaseType base_type = + element_type ? type->element() : type->base_type(); // TODO(derekbailey): it would be better to have a explicit list of allowed // base types, instead of negating Obj types. - if (type->index() >= 0 && !IsStructOrTable(type->base_type())) { + if (type->index() >= 0 && !IsStructOrTable(base_type)) { return GetEnumByIndex(type->index()); } return nullptr; diff --git a/src/bfbs_gen_nim.cpp b/src/bfbs_gen_nim.cpp new file mode 100644 index 00000000000..7e7118c3728 --- /dev/null +++ b/src/bfbs_gen_nim.cpp @@ -0,0 +1,656 @@ +/* + * Copyright 2021 Google Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "bfbs_gen_nim.h" + +#include +#include +#include +#include +#include +#include + +// Ensure no includes to flatc internals. bfbs_gen.h and generator.h are OK. +#include "bfbs_gen.h" +#include "bfbs_namer.h" +#include "flatbuffers/bfbs_generator.h" + +// The intermediate representation schema. +#include "flatbuffers/reflection.h" +#include "flatbuffers/reflection_generated.h" + +namespace flatbuffers { +namespace { + +// To reduce typing +namespace r = ::reflection; + +std::set NimKeywords() { + return { + "addr", "and", "as", "asm", "bind", "block", + "break", "case", "cast", "concept", "const", "continue", + "converter", "defer", "discard", "distinct", "div", "do", + "elif", "else", "end", "enum", "except", "export", + "finally", "for", "from", "func", "if", "import", + "in", "include", "interface", "is", "isnot", "iterator", + "let", "macro", "method", "mixin", "mod", "nil", + "not", "notin", "object", "of", "or", "out", + "proc", "ptr", "raise", "ref", "return", "shl", + "shr", "static", "template", "try", "tuple", "type", + "using", "var", "when", "while", "xor", "yield", + }; +} + +Namer::Config NimDefaultConfig() { + return { /*types=*/Case::kKeep, + /*constants=*/Case::kScreamingSnake, + /*methods=*/Case::kUpperCamel, + /*functions=*/Case::kUpperCamel, + /*fields=*/Case::kLowerCamel, + /*variable=*/Case::kLowerCamel, + /*variants=*/Case::kKeep, + /*enum_variant_seperator=*/".", + /*escape_keywords=*/Namer::Config::Escape::AfterConvertingCase, + /*namespaces=*/Case::kKeep, + /*namespace_seperator=*/"/", + /*object_prefix=*/"", + /*object_suffix=*/"T", + /*keyword_prefix=*/"", + /*keyword_suffix=*/"_", + /*filenames=*/Case::kKeep, + /*directories=*/Case::kKeep, + /*output_path=*/"", + /*filename_suffix=*/"", + /*filename_extension=*/".nim" }; +} + +const std::string Indent = " "; +const std::string Export = "*"; +const std::set builtin_types = { + "uint8", "uint8", "bool", "int8", "uint8", "int16", + "uint16", "int32", "uint32", "int64", "uint64", "float32", + "float64", "string", "int", "uint", "uoffset", "Builder" +}; + +// Returns the correct name for the type +// Type: +// MyGame.Example.Monster: +// Current: +// Monster +// Imported: +// MyGame_Example_Monster.Monster +std::string Denamespace(const std::string &s, bool current = false) { + if (builtin_types.find(s) != builtin_types.end()) { return s; } + std::string prefix; + const size_t pos = s.find_last_of("."); + if (pos != std::string::npos) { prefix = s.substr(0, pos); } + std::string suffix = s.substr(pos + 1); + if (current) { + return suffix; + } else { + std::string underscored = prefix; + underscored += underscored.empty() ? "" : "_"; + std::replace(underscored.begin(), underscored.end(), '.', '_'); + return underscored + suffix + "." + suffix; + } +} + +class NimBfbsGenerator : public BaseBfbsGenerator { + public: + explicit NimBfbsGenerator(const std::string &flatc_version) + : BaseBfbsGenerator(), + keywords_(), + imports_(), + current_obj_(nullptr), + current_enum_(nullptr), + flatc_version_(flatc_version), + namer_(NimDefaultConfig(), NimKeywords()) {} + + GeneratorStatus GenerateFromSchema(const r::Schema *schema) + FLATBUFFERS_OVERRIDE { + ForAllEnums(schema->enums(), [&](const r::Enum *enum_def) { + StartCodeBlock(enum_def); + GenerateEnum(enum_def); + }); + ForAllObjects(schema->objects(), [&](const r::Object *object) { + StartCodeBlock(object); + GenerateObject(object, schema->root_table()); + }); + return OK; + } + + uint64_t SupportedAdvancedFeatures() const FLATBUFFERS_OVERRIDE { + return 0xF; + } + + protected: + void GenerateEnum(const r::Enum *enum_def) { + std::string code; + + std::string ns; + const std::string enum_name = namer_.Type(namer_.Denamespace(enum_def, ns)); + const std::string enum_type = + GenerateTypeBasic(enum_def->underlying_type()); + + GenerateDocumentation(enum_def->documentation(), "", code); + code += "type " + enum_name + Export + "{.pure.} = enum\n"; + + ForAllEnumValues(enum_def, [&](const reflection::EnumVal *enum_val) { + GenerateDocumentation(enum_val->documentation(), " ", code); + code += " " + namer_.Variant(enum_val->name()->str()) + " = " + + NumToString(enum_val->value()) + "." + enum_type + ",\n"; + }); + + EmitCodeBlock(code, enum_name, ns, enum_def->declaration_file()->str()); + } + + void GenerateObject(const r::Object *object, const r::Object *root_object) { + // Register the main flatbuffers module. + RegisterImports("flatbuffers", ""); + std::string code; + + std::string ns; + const std::string object_name = namer_.Type(namer_.Denamespace(object, ns)); + + GenerateDocumentation(object->documentation(), "", code); + code += "type " + object_name + "* = object of FlatObj\n"; + + // Create all the field accessors. + ForAllFields(object, /*reverse=*/false, [&](const r::Field *field) { + // Skip writing deprecated fields altogether. + if (field->deprecated()) { return; } + + const std::string field_name = namer_.Field(field->name()->str()); + const r::BaseType base_type = field->type()->base_type(); + std::string field_type = GenerateType(field->type()); + + if (field->optional() && !object->is_struct()) { + RegisterImports("std/options", ""); + field_type = "Option[" + field_type + "]"; + } + + const std::string offset_prefix = + "let o = self.tab.Offset(" + NumToString(field->offset()) + ")\n"; + const std::string offset_prefix_2 = "if o != 0:\n"; + + if (IsScalar(base_type) || base_type == r::String || + base_type == r::Obj || base_type == r::Union) { + GenerateDocumentation(field->documentation(), "", code); + + std::string getter_signature = "func " + field_name + + "*(self: " + object_name + + "): " + field_type + " =\n"; + std::string getter_code; + std::string setter_signature = "func `" + field_name + + "=`*(self: var " + object_name + + ", n: " + field_type + "): bool =\n"; + std::string setter_code; + + if (base_type == r::Obj || base_type == r::Union || + field->type()->index() >= 0) { + RegisterImports(object, field); + } + + if (object->is_struct()) { + std::string field_getter = + ReplaceString(GenerateGetter(field->type()), "{offset}", + NumToString(field->offset())); + getter_code += " return " + field_getter + "\n"; + + // TODO: parser opts: + // if (parser_.opts.m utable_buffer) { + if (IsScalar(base_type)) { + setter_code += " return self.tab.Mutate(self.tab.Pos + " + + NumToString(field->offset()) + ", n)\n"; + } + //} + } else { + // Table accessors + getter_code += " " + offset_prefix; + getter_code += " " + offset_prefix_2; + std::string field_getter = + ReplaceString(GenerateGetter(field->type()), "{offset}", "o"); + if (field->optional()) { + field_getter = "some(" + field_getter + ")"; + } + getter_code += " return " + field_getter + "\n"; + if (!field->optional()) { + getter_code += " return " + DefaultValue(object, field) + "\n"; + } + + // TODO: parser opts: + // if (parser_.opts.mutable_buffer) { + if (IsScalar(base_type)) { + setter_code += " return self.tab.MutateSlot(" + + NumToString(field->offset()) + ", n)\n"; + } + //} + } + code += getter_signature + getter_code; + // if (parser_.opts.mutable_buffer) { + if (IsScalar(base_type)) { code += setter_signature + setter_code; } + //} + } else if (base_type == r::Array || base_type == r::Vector) { + const r::BaseType vector_base_type = field->type()->element(); + int32_t element_size = field->type()->element_size(); + + if (vector_base_type == r::Obj || vector_base_type == r::Union || + field->type()->index() >= 0) { + RegisterImports(object, field, true); + } + + // Get vector length: + code += "func " + field_name + "Length*(self: " + object_name + + "): int = \n"; + code += " " + offset_prefix; + code += " " + offset_prefix_2; + code += " return self.tab.VectorLen(o)\n"; + + // Get single vector field: + code += "func " + field_name + "*(self: " + object_name + + ", j: int): " + GenerateType(field->type(), true) + " = \n"; + code += " " + offset_prefix; + code += " " + offset_prefix_2; + code += " var x = self.tab.Vector(o)\n"; + code += + " x += j.uoffset * " + NumToString(element_size) + ".uoffset\n"; + code += " return " + + ReplaceString(GenerateGetter(field->type(), true), "{offset}", + "x") + + "\n"; + + // Get entire vector: + code += "func " + field_name + "*(self: " + object_name + + "): " + GenerateType(field->type()) + " = \n"; + code += " let len = self." + field_name + "Length\n"; + code += " for i in countup(0, len - 1):\n"; + code += " result.add(self." + field_name + "(i))\n"; + + (void)IsSingleByte(vector_base_type); // Unused exception + } + }); + + // Create all the builders + if (object->is_struct()) { + code += "proc " + object_name + "Create*(self: var Builder"; + code += GenerateStructBuilderArgs(object); + code += "): uoffset =\n"; + code += AppendStructBuilderBody(object); + code += " return self.Offset()\n"; + } else { + // Table builders + code += "proc " + object_name + "Start*(builder: var Builder) =\n"; + code += " builder.StartObject(" + NumToString(object->fields()->size()) + + ")\n"; + + ForAllFields(object, /*reverse=*/false, [&](const r::Field *field) { + if (field->deprecated()) { return; } + + const std::string field_name = namer_.Field(field->name()->str()); + const std::string variable_name = namer_.Variable(field->name()->str()); + const std::string variable_type = GenerateTypeBasic(field->type()); + + code += "proc " + object_name + "Add" + field_name + + "*(builder: var Builder, " + variable_name + ": " + + variable_type + ") =\n"; + code += " builder.Prepend" + GenerateMethod(field) + "Slot(" + + NumToString(field->id()) + ", " + variable_name + ", default(" + + variable_type + "))\n"; + + if (IsVector(field->type()->base_type())) { + code += "proc " + object_name + "Start" + field_name + + "Vector*(builder: var Builder, numElems: uoffset) =\n"; + + const int32_t element_size = field->type()->element_size(); + int32_t alignment = element_size; + if (IsStruct(field->type(), /*use_element=*/true)) { + alignment = GetObjectByIndex(field->type()->index())->minalign(); + } + + code += " builder.StartVector(" + NumToString(element_size) + + ", numElems, " + NumToString(alignment) + ")\n"; + } + }); + + code += "proc " + object_name + "End*(builder: var Builder): uoffset =\n"; + code += " return builder.EndObject()\n"; + } + EmitCodeBlock(code, object_name, ns, object->declaration_file()->str()); + } + + private: + void GenerateDocumentation( + const flatbuffers::Vector> + *documentation, + std::string indent, std::string &code) const { + flatbuffers::ForAllDocumentation( + documentation, [&](const flatbuffers::String *str) { + code += indent + "# " + str->str() + "\n"; + }); + } + + std::string GenerateStructBuilderArgs(const r::Object *object, + std::string prefix = "") const { + std::string signature; + ForAllFields(object, /*reverse=*/false, [&](const r::Field *field) { + if (IsStructOrTable(field->type()->base_type())) { + const r::Object *field_object = GetObject(field->type()); + signature += GenerateStructBuilderArgs( + field_object, prefix + namer_.Variable(field->name()->str()) + "_"); + } else { + signature += ", " + prefix + namer_.Variable(field->name()->str()) + + ": " + GenerateType(field->type()); + } + }); + return signature; + } + + std::string AppendStructBuilderBody(const r::Object *object, + std::string prefix = "") const { + std::string code; + code += " self.Prep(" + NumToString(object->minalign()) + ", " + + NumToString(object->bytesize()) + ")\n"; + + // We need to reverse the order we iterate over, since we build the + // buffer backwards. + ForAllFields(object, /*reverse=*/true, [&](const r::Field *field) { + const int32_t num_padding_bytes = field->padding(); + if (num_padding_bytes) { + code += " self.Pad(" + NumToString(num_padding_bytes) + ")\n"; + } + if (IsStructOrTable(field->type()->base_type())) { + const r::Object *field_object = GetObject(field->type()); + code += AppendStructBuilderBody( + field_object, prefix + namer_.Variable(field->name()->str()) + "_"); + } else { + code += " self.Prepend(" + prefix + + namer_.Variable(field->name()->str()) + ")\n"; + } + }); + + return code; + } + + std::string GenerateMethod(const r::Field *field) const { + const r::BaseType base_type = field->type()->base_type(); + if (IsStructOrTable(base_type)) { return "Struct"; } + return ""; + } + + std::string GenerateGetter(const r::Type *type, + bool element_type = false) const { + const r::BaseType base_type = + element_type ? type->element() : type->base_type(); + std::string offset = "{offset}"; + if (!element_type) { offset = "self.tab.Pos + " + offset; } + switch (base_type) { + case r::String: return "self.tab.String(" + offset + ")"; + case r::Union: return "self.tab.Union({offset})"; + case r::Obj: { + return GenerateType(type, element_type) + + "(tab: Vtable(Bytes: self.tab.Bytes, Pos: " + offset + "))"; + } + case r::Vector: return GenerateGetter(type, true); + default: + const r::Enum *type_enum = GetEnum(type, element_type); + if (type_enum != nullptr) { + return GenerateType(type, element_type) + "(" + "Get[" + + GenerateType(base_type) + "](self.tab, " + offset + ")" + ")"; + } else { + return "Get[" + GenerateType(base_type) + "](self.tab, " + offset + + ")"; + } + } + } + + std::string GenerateType(const r::Type *type, bool element_type = false, + bool enum_inner = false) const { + const r::BaseType base_type = + element_type ? type->element() : type->base_type(); + if (IsScalar(base_type) && !enum_inner) { + const r::Enum *type_enum = GetEnum(type, element_type); + if (type_enum != nullptr) { + std::string type_name = type_enum->name()->str(); + return Denamespace(namer_.Type(type_name)); + } + } + if (IsScalar(base_type)) { return Denamespace(GenerateType(base_type)); } + switch (base_type) { + case r::String: return "string"; + case r::Vector: { + return "seq[" + GenerateType(type, true) + "]"; + } + case r::Union: return "Vtable"; + case r::Obj: { + const r::Object *type_obj = GetObject(type, element_type); + std::string type_name = type_obj->name()->str(); + return Denamespace(namer_.Type(type_name), type_obj == current_obj_); + } + default: return "uoffset"; + } + } + + std::string GenerateTypeBasic(const r::Type *type, + bool element_type = false) const { + const r::BaseType base_type = + element_type ? type->element() : type->base_type(); + if (IsScalar(base_type)) { + return GenerateType(base_type); + } else { + return "uoffset"; + } + } + + std::string ReplaceString(std::string subject, const std::string &search, + const std::string &replace) { + size_t pos = subject.find(search, 0); + if (pos != std::string::npos) { + subject.replace(pos, search.length(), replace); + } + return subject; + } + + std::string GenerateType(const r::BaseType base_type) const { + switch (base_type) { + case r::None: return "uint8"; + case r::UType: return "uint8"; + case r::Bool: return "bool"; + case r::Byte: return "int8"; + case r::UByte: return "uint8"; + case r::Short: return "int16"; + case r::UShort: return "uint16"; + case r::Int: return "int32"; + case r::UInt: return "uint32"; + case r::Long: return "int64"; + case r::ULong: return "uint64"; + case r::Float: return "float32"; + case r::Double: return "float64"; + case r::String: return "string"; + default: return r::EnumNameBaseType(base_type); + } + } + + std::string DefaultValue(const r::Object *object, + const r::Field *field) const { + const r::BaseType base_type = field->type()->base_type(); + if (IsFloatingPoint(base_type)) { + return NumToString(field->default_real()); + } + if (IsBool(base_type)) { + return field->default_integer() ? "true" : "false"; + } + if (IsScalar(base_type)) { + const r::Enum *type_enum = GetEnum(field->type()); + if (type_enum != nullptr) { + return "type(result)(" + NumToString((field->default_integer())) + ")"; + } + return NumToString((field->default_integer())); + } + if (base_type == r::String) { + return "\"" + field->default_string()->str() + "\""; + } + // represents offsets + return "0"; + } + + void StartCodeBlock(const reflection::Enum *enum_def) { + current_enum_ = enum_def; + current_obj_ = nullptr; + imports_.clear(); + } + + void StartCodeBlock(const reflection::Object *object) { + current_enum_ = nullptr; + current_obj_ = object; + imports_.clear(); + } + + std::vector StringSplit(const std::string orig_str, + const std::string token) { + std::vector result; + std::string str = orig_str; + while (str.size()) { + size_t index = str.find(token); + if (index != std::string::npos) { + result.push_back(str.substr(0, index)); + str = str.substr(index + token.size()); + if (str.size() == 0) result.push_back(str); + } else { + result.push_back(str); + str = ""; + } + } + return result; + } + + std::string GetRelativePathFromNamespace(const std::string &relative_to, + const std::string &str2) { + std::vector relative_to_vec = StringSplit(relative_to, "."); + std::vector str2_vec = StringSplit(str2, "."); + while (relative_to_vec.size() > 0 && str2_vec.size() > 0) { + if (relative_to_vec[0] == str2_vec[0]) { + relative_to_vec.erase(relative_to_vec.begin()); + str2_vec.erase(str2_vec.begin()); + } else { + break; + } + } + relative_to_vec.pop_back(); + for (size_t i = 0; i < relative_to_vec.size(); ++i) { + str2_vec.insert(str2_vec.begin(), std::string("..")); + } + + std::string new_path; + for (size_t i = 0; i < str2_vec.size(); ++i) { + new_path += str2_vec[i]; + if (i != str2_vec.size() - 1) { new_path += "/"; } + } + return new_path; + } + + std::string RegisterImports(const r::Object *object, const r::Field *field, + bool use_element = false) { + std::string type_name; + + const r::BaseType type = + use_element ? field->type()->element() : field->type()->base_type(); + + if (IsStructOrTable(type)) { + const r::Object *object = GetObjectByIndex(field->type()->index()); + if (object == current_obj_) { return namer_.Denamespace(object); } + type_name = object->name()->str(); + } else { + const r::Enum *enum_def = GetEnumByIndex(field->type()->index()); + if (enum_def == current_enum_) { return namer_.Denamespace(enum_def); } + type_name = enum_def->name()->str(); + } + + std::string name = type_name; + std::replace(name.begin(), name.end(), '.', '_'); + std::string import_path = + GetRelativePathFromNamespace(object->name()->str(), type_name); + return RegisterImports(import_path, name); + } + + std::string RegisterImports(const std::string &local_name, + const std::string &imports_name) { + imports_[local_name] = imports_name; + return local_name; + } + + void EmitCodeBlock(const std::string &code_block, const std::string &name, + const std::string &ns, const std::string &declaring_file) { + const std::string full_qualified_name = ns.empty() ? name : ns + "." + name; + + std::string code = "#[ " + full_qualified_name + "\n"; + code += + " Automatically generated by the FlatBuffers compiler, do not " + "modify.\n"; + code += " Or modify. I'm a message, not a cop.\n"; + code += "\n"; + code += " flatc version: " + flatc_version_ + "\n"; + code += "\n"; + code += " Declared by : " + declaring_file + "\n"; + if (schema_->root_table() != nullptr) { + const std::string root_type = schema_->root_table()->name()->str(); + const std::string root_file = + schema_->root_table()->declaration_file()->str(); + code += " Rooting type : " + root_type + " (" + root_file + ")\n"; + } + code += "]#\n\n"; + + if (!imports_.empty()) { + for (auto it = imports_.cbegin(); it != imports_.cend(); ++it) { + if (it->second.empty()) { + code += "import " + it->first + "\n"; + } else { + code += "import " + it->first + " as " + it->second + "\n"; + } + } + code += "\n"; + } + code += code_block; + + // Namespaces are '.' deliminted, so replace it with the path separator. + std::string path = ns; + + if (ns.empty()) { + path = "."; + } else { + std::replace(path.begin(), path.end(), '.', '/'); + } + + // TODO(derekbailey): figure out a save file without depending on util.h + EnsureDirExists(path); + const std::string file_name = path + "/" + namer_.File(name); + SaveFile(file_name.c_str(), code, false); + } + + std::unordered_set keywords_; + std::map imports_; + const r::Object *current_obj_; + const r::Enum *current_enum_; + const std::string flatc_version_; + const BfbsNamer namer_; +}; +} // namespace + +std::unique_ptr NewNimBfbsGenerator( + const std::string &flatc_version) { + return std::unique_ptr(new NimBfbsGenerator(flatc_version)); +} + +} // namespace flatbuffers diff --git a/src/bfbs_gen_nim.h b/src/bfbs_gen_nim.h new file mode 100644 index 00000000000..80be16d0141 --- /dev/null +++ b/src/bfbs_gen_nim.h @@ -0,0 +1,33 @@ +/* + * Copyright 2021 Google Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef FLATBUFFERS_BFBS_GEN_NIM_H_ +#define FLATBUFFERS_BFBS_GEN_NIM_H_ + +#include +#include + +#include "flatbuffers/bfbs_generator.h" + +namespace flatbuffers { + +// Constructs a new Nim Code generator. +std::unique_ptr NewNimBfbsGenerator( + const std::string &flatc_version); + +} // namespace flatbuffers + +#endif // FLATBUFFERS_BFBS_GEN_NIM_H_ diff --git a/src/flatc_main.cpp b/src/flatc_main.cpp index b4c4251c4cb..f2aa781a376 100644 --- a/src/flatc_main.cpp +++ b/src/flatc_main.cpp @@ -18,6 +18,7 @@ #include #include "bfbs_gen_lua.h" +#include "bfbs_gen_nim.h" #include "flatbuffers/base.h" #include "flatbuffers/flatc.h" #include "flatbuffers/util.h" @@ -56,6 +57,8 @@ int main(int argc, const char *argv[]) { std::unique_ptr bfbs_gen_lua = flatbuffers::NewLuaBfbsGenerator(flatbuffers_version); + std::unique_ptr bfbs_gen_nim = + flatbuffers::NewNimBfbsGenerator(flatbuffers_version); g_program_name = argv[0]; @@ -142,6 +145,10 @@ int main(int argc, const char *argv[]) { flatbuffers::FlatCOption{ "", "swift", "", "Generate Swift files for tables/structs" }, nullptr, nullptr, nullptr }, + { nullptr, "Nim", true, nullptr, flatbuffers::IDLOptions::kNim, + flatbuffers::FlatCOption{ "", "nim", "", + "Generate Nim files for tables/structs" }, + nullptr, bfbs_gen_nim.get(), nullptr }, }; flatbuffers::FlatCompiler::InitParams params; diff --git a/src/idl_parser.cpp b/src/idl_parser.cpp index d8015cb6e58..d63e6457872 100644 --- a/src/idl_parser.cpp +++ b/src/idl_parser.cpp @@ -1584,7 +1584,6 @@ CheckedError Parser::ParseVectorDelimiters(uoffset_t &count, F body) { return NoError(); } - CheckedError Parser::ParseAlignAttribute(const std::string &align_constant, size_t min_align, size_t *align) { // Use uint8_t to avoid problems with size_t==`unsigned long` on LP64. @@ -2552,7 +2551,8 @@ bool Parser::SupportsOptionalScalars(const flatbuffers::IDLOptions &opts) { IDLOptions::kRust | IDLOptions::kSwift | IDLOptions::kLobster | IDLOptions::kKotlin | IDLOptions::kCpp | IDLOptions::kJava | IDLOptions::kCSharp | IDLOptions::kTs | IDLOptions::kBinary | - IDLOptions::kGo | IDLOptions::kPython | IDLOptions::kJson; + IDLOptions::kGo | IDLOptions::kPython | IDLOptions::kJson | + IDLOptions::kNim; unsigned long langs = opts.lang_to_generate; return (langs > 0 && langs < IDLOptions::kMAX) && !(langs & ~supported_langs); } @@ -2563,7 +2563,7 @@ bool Parser::SupportsOptionalScalars() const { bool Parser::SupportsDefaultVectorsAndStrings() const { static FLATBUFFERS_CONSTEXPR unsigned long supported_langs = - IDLOptions::kRust | IDLOptions::kSwift; + IDLOptions::kRust | IDLOptions::kSwift | IDLOptions::kNim; return !(opts.lang_to_generate & ~supported_langs); } @@ -2571,7 +2571,7 @@ bool Parser::SupportsAdvancedUnionFeatures() const { return (opts.lang_to_generate & ~(IDLOptions::kCpp | IDLOptions::kTs | IDLOptions::kPhp | IDLOptions::kJava | IDLOptions::kCSharp | IDLOptions::kKotlin | - IDLOptions::kBinary | IDLOptions::kSwift)) == 0; + IDLOptions::kBinary | IDLOptions::kSwift | IDLOptions::kNim)) == 0; } bool Parser::SupportsAdvancedArrayFeatures() const { @@ -3415,7 +3415,6 @@ CheckedError Parser::CheckPrivatelyLeakedFields(const Definition &def, return NoError(); } - CheckedError Parser::DoParse(const char *source, const char **include_paths, const char *source_filename, const char *include_filename) { @@ -3774,6 +3773,8 @@ Offset FieldDef::Serialize(FlatBufferBuilder *builder, auto docs__ = parser.opts.binary_schema_comments ? builder->CreateVectorOfStrings(doc_comment) : 0; + auto default_string__ = + builder->CreateString(IsString(value.type) ? value.constant : ""); double d; StringToNumber(value.constant.c_str(), &d); return reflection::CreateField( @@ -3781,8 +3782,9 @@ Offset FieldDef::Serialize(FlatBufferBuilder *builder, // Is uint64>max(int64) tested? IsInteger(value.type.base_type) ? StringToInt(value.constant.c_str()) : 0, // result may be platform-dependent if underlying is float (not double) - IsFloat(value.type.base_type) ? d : 0.0, deprecated, IsRequired(), key, - attr__, docs__, IsOptional(), static_cast(padding)); + IsFloat(value.type.base_type) ? d : 0.0, default_string__, deprecated, + IsRequired(), key, attr__, docs__, IsOptional(), + static_cast(padding)); // TODO: value.constant is almost always "0", we could save quite a bit of // space by sharing it. Same for common values of value.type. } @@ -3938,12 +3940,16 @@ bool EnumVal::Deserialize(const Parser &parser, } Offset Type::Serialize(FlatBufferBuilder *builder) const { + size_t element_size = SizeOf(element); + if (base_type == BASE_TYPE_VECTOR && element == BASE_TYPE_STRUCT) { + element_size = struct_def->bytesize; + } return reflection::CreateType( *builder, static_cast(base_type), static_cast(element), struct_def ? struct_def->index : (enum_def ? enum_def->index : -1), fixed_length, static_cast(SizeOf(base_type)), - static_cast(SizeOf(element))); + static_cast(element_size)); } bool Type::Deserialize(const Parser &parser, const reflection::Type *type) { @@ -4122,7 +4128,7 @@ std::string Parser::ConformTo(const Parser &base) { struct_def.defined_namespace->GetFullyQualifiedName(struct_def.name); auto struct_def_base = base.LookupStruct(qualified_name); if (!struct_def_base) continue; - std::set renamed_fields; + std::set renamed_fields; for (auto fit = struct_def.fields.vec.begin(); fit != struct_def.fields.vec.end(); ++fit) { auto &field = **fit; @@ -4151,15 +4157,15 @@ std::string Parser::ConformTo(const Parser &base) { } } } - //deletion of trailing fields are not allowed + // deletion of trailing fields are not allowed for (auto fit = struct_def_base->fields.vec.begin(); - fit != struct_def_base->fields.vec.end(); ++fit ) { + fit != struct_def_base->fields.vec.end(); ++fit) { auto &field_base = **fit; - //not a renamed field + // not a renamed field if (renamed_fields.find(&field_base) == renamed_fields.end()) { auto field = struct_def.fields.Lookup(field_base.name); - if (!field) { - return "field deleted: " + qualified_name + "." + field_base.name; + if (!field) { + return "field deleted: " + qualified_name + "." + field_base.name; } } } diff --git a/tests/FlatBuffers.Test.Nim/NimTest.sh b/tests/FlatBuffers.Test.Nim/NimTest.sh new file mode 100755 index 00000000000..24e9a54159c --- /dev/null +++ b/tests/FlatBuffers.Test.Nim/NimTest.sh @@ -0,0 +1,19 @@ +nim_dir=`pwd` +cd .. +test_dir=`pwd` +alias flatc='${test_dir}/../build/flatc' +shopt -s expand_aliases + +mkdir -p ${nim_dir}/generated +cd ${nim_dir}/generated/ +flatc --nim --gen-mutable -I ${test_dir}/include_test ${test_dir}/monster_test.fbs +flatc --nim ${test_dir}/optional_scalars.fbs +flatc --nim ${test_dir}/more_defaults.fbs +flatc --nim --gen-mutable ${test_dir}/MutatingBool.fbs +cd ${nim_dir} + +testament --megatest:off all +rm -r ${nim_dir}/generated +rm -r ${nim_dir}/nimcache +rm -r ${nim_dir}/testresults +rm -r ${nim_dir}/tests/*/test diff --git a/tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim b/tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim new file mode 100644 index 00000000000..417467a694b --- /dev/null +++ b/tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim @@ -0,0 +1,55 @@ +discard """ + action: "run" + exitcode: 0 + timeout: 60.0 +""" +import std/unittest +import flatbuffers +import ../../generated/MoreDefaults + +suite "TestMoreDefaults": + + test "testFlatbuffersObject": + var fbb = newBuilder(0) + fbb.MoreDefaultsStart() + let root = fbb.MoreDefaultsEnd() + fbb.Finish(root) + + var defaults: MoreDefaults + defaults.GetRootAs(fbb.FinishedBytes(), 0) + check(defaults.emptyString == "") + check(defaults.someString == "some") + check(defaults.ints == []) + check(defaults.floats == []) + check(defaults.bools == []) + check(defaults.intsLength == 0) + check(defaults.floatsLength == 0) + check(defaults.abcsLength == 0) + check(defaults.boolsLength == 0) + + # test "testFlatbuffersObjectAPI": + # let defaults = newMoreDefaultsT() + # check(defaults.emptyString.isSome) + # check(defaults.emptyString.get() == "") + # check(defaults.someString.isSome) + # check(defaults.someString.get() == "some") + # check(defaults.ints == []) + # check(defaults.floats == []) + # check(defaults.abcs == []) + # check(defaults.bools == []) + + # var fbb = newBuilder(0) + # fbb.Finish(defaults.Pack(fbb)) + # var fDefaults: MoreDefaults + # fDefaults.GetRootAs(fbb.FinishedBytes(), 0) + # check(fDefaults.emptyString.isSome) + # check(fDefaults.emptyString.get() == "") + # check(fDefaults.someString.isSome) + # check(fDefaults.someString.get() == "some") + # check(fDefaults.ints == []) + # check(fDefaults.floats == []) + # check(fDefaults.bools == []) + # check(fDefaults.intsLength == 0) + # check(fDefaults.floatsLength == 0) + # check(fDefaults.abcsLength == 0) + # check(fDefaults.boolsLength == 0) diff --git a/tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim b/tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim new file mode 100644 index 00000000000..daec6c2f224 --- /dev/null +++ b/tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim @@ -0,0 +1,43 @@ +discard """ + action: "run" + exitcode: 0 + timeout: 60.0 +""" +import std/unittest +import std/options +import flatbuffers +import ../../generated/TestMutatingBool +import ../../generated/Property + +suite "TestMutatingBool": + + test "MutatingBool": + var builder = newBuilder(1024) + builder.TestMutatingBoolStart() + builder.TestMutatingBoolAddB(builder.PropertyCreate(false)) + let root = builder.TestMutatingBoolEnd() + builder.Finish(root) + + var test_mutating_bool: TestMutatingBool + GetRootAs(test_mutating_bool, builder.FinishedBytes(), 0) + check(test_mutating_bool.b.isSome) + var prop2 = test_mutating_bool.b.get() + check(prop2.property == false) + discard (prop2.property = false) + check(prop2.property == false) + discard (prop2.property = true) + check(prop2.property == true) + + test "EmptyBool": + var builder = newBuilder(1024) + builder.TestMutatingBoolStart() + let root = builder.TestMutatingBoolEnd() + builder.Finish(root) + + var test_mutating_bool: TestMutatingBool + GetRootAs(test_mutating_bool, builder.FinishedBytes(), 0) + check(test_mutating_bool.b.isNone) + + # test "defaultValue": + # let mutatingbool = newTestMutatingBoolT() + # check(mutatingbool.b.isNone) diff --git a/tests/FlatBuffers.Test.Nim/tests/mygame/test.nim b/tests/FlatBuffers.Test.Nim/tests/mygame/test.nim new file mode 100644 index 00000000000..d833b25dc61 --- /dev/null +++ b/tests/FlatBuffers.Test.Nim/tests/mygame/test.nim @@ -0,0 +1,528 @@ +discard """ + action: "run" + exitcode: 0 + timeout: 60.0 +""" +import std/unittest +import std/options +import flatbuffers +import ../../generated/MyGame/Example/Test +import ../../generated/MyGame/Example/Monster +import ../../generated/MyGame/Example/Vec3 +import ../../generated/MyGame/Example/Color as ColorMod +import ../../generated/MyGame/Example/Any as AnyMod + +proc verifyMonster(monster: var Monster) = + check(monster.hp == 80) + check(monster.mana == 150) + check(monster.name == "MyMonster") + check(monster.pos.isSome) + let pos = monster.pos.get() + check(pos.x == 1) + check(pos.y == 2) + check(pos.z == 3) + check(pos.test1 == 3) + check(pos.test2 == Color.Green) + check(pos.test3.a == 5) + check(pos.test3.b == 6) + check(monster.testType == Any.Monster) + check(monster.test.isSome) + let monster2 = Monster(tab: monster.test.get()) + check(monster2.name == "Fred") + check((monster.mana = 10) == false) + check(monster.mana == 150) + check(monster.inventoryLength == 5) + var sum: uint8 = 0 + for item in monster.inventory: + sum += item + check(sum == 10) + check(monster.test4Length == 2) + + let test0 = monster.test4(0) + let test1 = monster.test4(1) + var sum0 = test0.a + test0.b + var sum1 = test1.a + test1.b + check(sum0 + sum1 == 100) + + check(monster.testarrayofstringLength == 2) + check(monster.testarrayofstring(0) == "test1") + check(monster.testarrayofstring(1) == "test2") + check(monster.testbool == true) + + +suite "TestMyGame": + + test "testData": + let data: seq[byte] = @[byte(48), 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, + 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, + 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, + 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, + 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, + 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, + 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, + 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, + 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, + 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, + 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, + 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, + 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0] + var monster: Monster + GetRootAs(monster, data, 0) + verifyMonster(monster) + + test "testCreateString": + var fbb = newBuilder(0) + let name = fbb.Create("Frodo") + fbb.Finish(name) + check(fbb.FinishedBytes() == @[byte(4), 0, 0, 0, 5, 0, 0, 0, 70, 114, 111, + 100, 111, 0, 0, 0]) + + test "testCreateVector": + var fbb = newBuilder(0) + let vec = fbb.Create(@[byte(0), 1, 2, 3, 4]) + fbb.Finish(vec) + check(fbb.FinishedBytes() == @[byte(4), 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, + 0, 0, 0]) + + test "createSimpleMonster": + var fbb = newBuilder(0) + let names = [ + fbb.Create("Frodo"), + fbb.Create("Barney"), + fbb.Create("Wilma"), + ] + fbb.MonsterStart() + fbb.MonsterAddName(names[0]) + let monster = fbb.MonsterEnd() + fbb.Finish(monster) + check(fbb.FinishedBytes() == @[byte(16), 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, + 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, + 114, 111, 100, 111, 0, 0, 0]) + + test "testCreateTestVector": + var fbb = newBuilder(0) + fbb.MonsterStartTest4Vector(2) + discard fbb.TestCreate(a = 30, b = 40) + discard fbb.TestCreate(a = 10, b = 20) + let test4 = fbb.EndVector() + fbb.Finish(test4) + check(fbb.FinishedBytes() == @[byte(4), 0, 0, 0, 2, 0, 0, 0, 10, 0, 20, 0, + 30, 0, 40, 0]) + + test "testTableWithStruct": + var fbb = newBuilder(0) + fbb.MonsterStart() + fbb.MonsterAddPos(fbb.Vec3Create(x = 1, + y = 2, + z = 3, + test1 = 3, + test2 = Color.Green, + test3_a = 5, test3_b = 6)) + + let monster_end = fbb.MonsterEnd() + fbb.Finish(monster_end) + check(fbb.FinishedBytes() == @[byte(12), 0, 0, 0, 0, 0, 6, 0, 36, 0, 4, 0, + 6, 0, 0, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0]) + + test "testCreateMonster": + var fbb = newBuilder(0) + let names = [ + fbb.Create("Frodo"), + fbb.Create("Barney"), + fbb.Create("Wilma"), + ] + + var offsets: seq[uoffset] = @[] + fbb.MonsterStart() + fbb.MonsterAddName(names[0]) + offsets.add(fbb.MonsterEnd()) + fbb.MonsterStart() + fbb.MonsterAddName(names[1]) + offsets.add(fbb.MonsterEnd()) + fbb.MonsterStart() + fbb.MonsterAddName(names[2]) + offsets.add(fbb.MonsterEnd()) + + let str = fbb.Create("MyMonster") + let test1 = fbb.Create("test1") + let test2 = fbb.Create("test2") + let inv = fbb.Create(@[byte(0), 1, 2, 3, 4]) + let fred = fbb.Create("Fred") + fbb.MonsterStart() + fbb.MonsterAddName(fred) + let mon2 = fbb.MonsterEnd() + + fbb.MonsterStartTest4Vector(2) + discard fbb.TestCreate(a = 30, b = 40) + discard fbb.TestCreate(a = 10, b = 20) + let test4 = fbb.EndVector() + + fbb.MonsterStartTestarrayofstringVector(2) + fbb.PrependOffsetRelative(test1) + fbb.PrependOffsetRelative(test2) + let stringTestVector = fbb.EndVector() + + fbb.MonsterStartTestarrayoftablesVector(3) + fbb.PrependOffsetRelative(offsets[0]) + fbb.PrependOffsetRelative(offsets[1]) + fbb.PrependOffsetRelative(offsets[2]) + let tableTestVector = fbb.EndVector() + + fbb.MonsterStart() + fbb.MonsterAddPos(fbb.Vec3Create(x = 1, + y = 2, + z = 3, + test1 = 3, + test2 = Color.Green, + test3_a = 5, test3_b = 6)) + fbb.MonsterAddHp(80) + fbb.MonsterAddName(str) + fbb.MonsterAddInventory(inv) + fbb.MonsterAddTestType(Any.Monster.uint8) + fbb.MonsterAddTest(mon2) + fbb.MonsterAddTest4(test4) + fbb.MonsterAddTestarrayofstring(stringTestVector) + fbb.MonsterAddTestbool(true) + fbb.MonsterAddTestarrayoftables(tableTestVector) + let monster_end = fbb.MonsterEnd() + fbb.Finish(monster_end) + check(fbb.FinishedBytes() == @[byte(40), 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, + 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 1, 76, 0, 0, 0, + 84, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 1, 104, 0, 0, 0, 136, 0, 0, 0, 0, 0, + 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 3, 0, 0, 0, 108, 0, 0, 0, 112, 0, + 0, 0, 128, 0, 0, 0, 2, 0, 0, 0, 52, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, 0, + 10, 0, 20, 0, 30, 0, 40, 0, 168, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, + 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, + 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, + 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, + 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, + 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, + 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, + 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0]) + + + # var test_mutating_bool: TestMutatingBool + # GetRootAs(test_mutating_bool, builder.FinishedBytes(), 0) + # XCTAssertEqual(bytes.sizedByteArray, ) + # let monster = MyGame_Example_Monster.getRootAsMonster(bb: bytes.buffer) + # readMonster(monster: monster) + # mutateMonster(fb: bytes.buffer) + # readMonster(monster: monster) + + + # test "testReadFromOtherLanguages": + # let path = FileManager.default.currentDirectoryPath + # let url = URL(fileURLWithPath: path, isDirectory: true) + # .appendingPathComponent("monsterdata_test").appendingPathExtension("mon") + # guard let data = try? Data(contentsOf: url) else { return } + # let _data = ByteBuffer(data: data) + # readVerifiedMonster(fb: _data) + # } + + # test "testCreateMonster": + # let bytes = createMonster(withPrefix: false) + # // swiftformat:disable all + # check(bytes.sizedByteArray == [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0]) + # // swiftformat:enable all + # let monster = Monster.getRootAsMonster(bb: bytes.buffer) + # readMonster(monster: monster) + # mutateMonster(fb: bytes.buffer) + # readMonster(monster: monster) + # } + + # test "testCreateMonsterResizedBuffer": + # let bytes = createMonster(withPrefix: false) + # // swiftformat:disable all + # check(bytes.sizedByteArray == [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0]) + # // swiftformat:enable all + # readVerifiedMonster(fb: bytes.sizedBuffer) + # } + + # test "testCreateMonsterPrefixed": + # let bytes = createMonster(withPrefix: true) + # // swiftformat:disable all + # check(bytes.sizedByteArray, [44, 1, 0, 0, 44, 0, 0, 0, 77, 79, 78, 83, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, ==0]) + # // swiftformat:enable all + + # var buffer = bytes.buffer + # readMonster(monster: getPrefixedSizeRoot(byteBuffer: &buffer)) + # } + + # test "testCreateMonsterUsingCreateMonsterMethodWithNilPos": + # var fbb = FlatBufferBuilder(initialSize: 1) + # let name = fbb.Create("Frodo") + # let mStart = fbb.MonsterStart() + # Monster.add(name: name, &fbb) + # let root = Monster.endMonster(&fbb, start: mStart) + # fbb.finish(offset: root) + # let newMonster = Monster.getRootAsMonster(bb: fbb.sizedBuffer) + # XCTAssertNil(newMonster.pos) + # check(newMonster.name, "Fro ==o") + # } + + # test "testCreateMonsterUsingCreateMonsterMethodWithPosX": + # var fbb = FlatBufferBuilder(initialSize: 1) + # let name = fbb.Create("Barney") + # let mStart = fbb.MonsterStart() + # Monster.add( + # pos: Vec3( + # x: 10, + # y: 0, + # z: 0, + # test1: 0, + # test2: .blue, + # test3: .init()), + # &fbb) + # Monster.add(name: name, &fbb) + # let root = Monster.endMonster(&fbb, start: mStart) + # fbb.finish(offset: root) + + # let newMonster = Monster.getRootAsMonster(bb: fbb.sizedBuffer) + # check(newMonster.pos!.x == 10) + # check(newMonster.name, "Barn ==y") + # } + + # test "testReadMonsterFromUnsafePointerWithoutCopying": + # // swiftformat:disable all + # var array: [UInt8] = [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0] + # // swiftformat:enable all + # let unpacked = array + # .withUnsafeMutableBytes { (memory) -> MonsterT in + # let bytes = ByteBuffer( + # assumingMemoryBound: memory.baseAddress!, + # capacity: memory.count) + # var monster = Monster.getRootAsMonster(bb: bytes) + # readFlatbufferMonster(monster: &monster) + # let unpacked = monster.unpack() + # return unpacked + # } + # readObjectApi(monster: unpacked) + # } + + # test "testArrayOfBools": + # let boolArray = [false, true, false, true, false, true, false] + # var fbb = FlatBufferBuilder(initialSize: 1) + # let name = fbb.Create("Frodo") + # let bools = fbb.createVector(boolArray) + # let root = Monster.createMonster( + # &fbb, + # nameOffset: name, + # testarrayofboolsVectorOffset: bools) + # fbb.finish(offset: root) + # let monster = Monster.getRootAsMonster(bb: fbb.sizedBuffer) + + # let values = monster.testarrayofbools + + # check(boolArray == values) + + # for i in 0.. FlatBufferBuild": + # var fbb = FlatBufferBuilder(initialSize: 1) + # let names = [ + # fbb.Create("Frodo"), + # fbb.Create("Barney"), + # fbb.Create("Wilma"), + # ] + # var offsets: [Offset] = [] + # let start1 = fbb.MonsterStart() + # Monster.add(name: names[0], &fbb) + # offsets.append(Monster.endMonster(&fbb, start: start1)) + # let start2 = fbb.MonsterStart() + # Monster.add(name: names[1], &fbb) + # offsets.append(Monster.endMonster(&fbb, start: start2)) + # let start3 = fbb.MonsterStart() + # Monster.add(name: names[2], &fbb) + # offsets.append(Monster.endMonster(&fbb, start: start3)) + + # let sortedArray = Monster.sortVectorOfMonster(offsets: offsets, &fbb) + + # let str = fbb.Create("MyMonster") + # let test1 = fbb.Create("test1") + # let test2 = fbb.Create("test2") + # let _inv: [Byte] = [0, 1, 2, 3, 4] + # let inv = fbb.createVector(_inv) + + # let fred = fbb.Create("Fred") + # let mon1Start = fbb.MonsterStart() + # Monster.add(name: fred, &fbb) + # let mon2 = Monster.endMonster(&fbb, start: mon1Start) + + # let test4 = fbb.createVector(ofStructs: [ + # Test(a: 30, b: 40), + # Test(a: 10, b: 20), + # ]) + + # let stringTestVector = fbb.createVector(ofOffsets: [test1, test2]) + # let mStart = fbb.MonsterStart() + # Monster.add( + # pos: Vec3( + # x: 1, + # y: 2, + # z: 3, + # test1: 3, + # test2: Color.Green, + # test3: .init(a: 5, b: 6)), + # &fbb) + # Monster.add(hp: 80, &fbb) + # Monster.add(name: str, &fbb) + # Monster.addVectorOf(inventory: inv, &fbb) + # Monster.add(testType: .monster, &fbb) + # Monster.add(test: mon2, &fbb) + # Monster.addVectorOf(test4: test4, &fbb) + # Monster.addVectorOf(testarrayofstring: stringTestVector, &fbb) + # Monster.add(testbool: true, &fbb) + # Monster.addVectorOf(testarrayoftables: sortedArray, &fbb) + # let end = Monster.endMonster(&fbb, start: mStart) + # Monster.finish(&fbb, end: end, prefix: prefix) + # return fbb + # } + + # test "mutateMonster(fb: ByteBuffe": + # let monster = Monster.getRootAsMonster(bb: fb) + # XCTAssertFalse(monster.mana = 10) + # check(monster.testarrayoftables(0).name, "Barn ==y") + # check(monster.testarrayoftables(1).name, "Fro ==o") + # check(monster.testarrayoftables(2).name, "Wil ==a") + + # // Example of searching for a table by the key + # XCTAssertNotNil(monster.testarrayoftablesBy(key: "Frodo")) + # XCTAssertNotNil(monster.testarrayoftablesBy(key: "Barney")) + # XCTAssertNotNil(monster.testarrayoftablesBy(key: "Wilma")) + + # check(monster.testType, ==.monster) + + # check(monster.inventory = 1 0) == true) + # check(monster.inventory = 2 1) == true) + # check(monster.inventory = 3 2) == true) + # check(monster.inventory = 4 3) == true) + # check(monster.inventory = 5 4) == true) + + # for i in 0.. Date: Fri, 16 Sep 2022 00:13:47 +0300 Subject: [PATCH 12/29] Remove commented out tests --- .../tests/moredefaults/test.nim | 27 -- .../tests/mutatingbool/test.nim | 4 - .../tests/mygame/test.nim | 321 ------------------ 3 files changed, 352 deletions(-) diff --git a/tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim b/tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim index 417467a694b..e300b55535c 100644 --- a/tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim +++ b/tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim @@ -26,30 +26,3 @@ suite "TestMoreDefaults": check(defaults.floatsLength == 0) check(defaults.abcsLength == 0) check(defaults.boolsLength == 0) - - # test "testFlatbuffersObjectAPI": - # let defaults = newMoreDefaultsT() - # check(defaults.emptyString.isSome) - # check(defaults.emptyString.get() == "") - # check(defaults.someString.isSome) - # check(defaults.someString.get() == "some") - # check(defaults.ints == []) - # check(defaults.floats == []) - # check(defaults.abcs == []) - # check(defaults.bools == []) - - # var fbb = newBuilder(0) - # fbb.Finish(defaults.Pack(fbb)) - # var fDefaults: MoreDefaults - # fDefaults.GetRootAs(fbb.FinishedBytes(), 0) - # check(fDefaults.emptyString.isSome) - # check(fDefaults.emptyString.get() == "") - # check(fDefaults.someString.isSome) - # check(fDefaults.someString.get() == "some") - # check(fDefaults.ints == []) - # check(fDefaults.floats == []) - # check(fDefaults.bools == []) - # check(fDefaults.intsLength == 0) - # check(fDefaults.floatsLength == 0) - # check(fDefaults.abcsLength == 0) - # check(fDefaults.boolsLength == 0) diff --git a/tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim b/tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim index daec6c2f224..7b65c0573bf 100644 --- a/tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim +++ b/tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim @@ -37,7 +37,3 @@ suite "TestMutatingBool": var test_mutating_bool: TestMutatingBool GetRootAs(test_mutating_bool, builder.FinishedBytes(), 0) check(test_mutating_bool.b.isNone) - - # test "defaultValue": - # let mutatingbool = newTestMutatingBoolT() - # check(mutatingbool.b.isNone) diff --git a/tests/FlatBuffers.Test.Nim/tests/mygame/test.nim b/tests/FlatBuffers.Test.Nim/tests/mygame/test.nim index d833b25dc61..4f9e1db2143 100644 --- a/tests/FlatBuffers.Test.Nim/tests/mygame/test.nim +++ b/tests/FlatBuffers.Test.Nim/tests/mygame/test.nim @@ -205,324 +205,3 @@ suite "TestMyGame": 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0]) - - - # var test_mutating_bool: TestMutatingBool - # GetRootAs(test_mutating_bool, builder.FinishedBytes(), 0) - # XCTAssertEqual(bytes.sizedByteArray, ) - # let monster = MyGame_Example_Monster.getRootAsMonster(bb: bytes.buffer) - # readMonster(monster: monster) - # mutateMonster(fb: bytes.buffer) - # readMonster(monster: monster) - - - # test "testReadFromOtherLanguages": - # let path = FileManager.default.currentDirectoryPath - # let url = URL(fileURLWithPath: path, isDirectory: true) - # .appendingPathComponent("monsterdata_test").appendingPathExtension("mon") - # guard let data = try? Data(contentsOf: url) else { return } - # let _data = ByteBuffer(data: data) - # readVerifiedMonster(fb: _data) - # } - - # test "testCreateMonster": - # let bytes = createMonster(withPrefix: false) - # // swiftformat:disable all - # check(bytes.sizedByteArray == [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0]) - # // swiftformat:enable all - # let monster = Monster.getRootAsMonster(bb: bytes.buffer) - # readMonster(monster: monster) - # mutateMonster(fb: bytes.buffer) - # readMonster(monster: monster) - # } - - # test "testCreateMonsterResizedBuffer": - # let bytes = createMonster(withPrefix: false) - # // swiftformat:disable all - # check(bytes.sizedByteArray == [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0]) - # // swiftformat:enable all - # readVerifiedMonster(fb: bytes.sizedBuffer) - # } - - # test "testCreateMonsterPrefixed": - # let bytes = createMonster(withPrefix: true) - # // swiftformat:disable all - # check(bytes.sizedByteArray, [44, 1, 0, 0, 44, 0, 0, 0, 77, 79, 78, 83, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, ==0]) - # // swiftformat:enable all - - # var buffer = bytes.buffer - # readMonster(monster: getPrefixedSizeRoot(byteBuffer: &buffer)) - # } - - # test "testCreateMonsterUsingCreateMonsterMethodWithNilPos": - # var fbb = FlatBufferBuilder(initialSize: 1) - # let name = fbb.Create("Frodo") - # let mStart = fbb.MonsterStart() - # Monster.add(name: name, &fbb) - # let root = Monster.endMonster(&fbb, start: mStart) - # fbb.finish(offset: root) - # let newMonster = Monster.getRootAsMonster(bb: fbb.sizedBuffer) - # XCTAssertNil(newMonster.pos) - # check(newMonster.name, "Fro ==o") - # } - - # test "testCreateMonsterUsingCreateMonsterMethodWithPosX": - # var fbb = FlatBufferBuilder(initialSize: 1) - # let name = fbb.Create("Barney") - # let mStart = fbb.MonsterStart() - # Monster.add( - # pos: Vec3( - # x: 10, - # y: 0, - # z: 0, - # test1: 0, - # test2: .blue, - # test3: .init()), - # &fbb) - # Monster.add(name: name, &fbb) - # let root = Monster.endMonster(&fbb, start: mStart) - # fbb.finish(offset: root) - - # let newMonster = Monster.getRootAsMonster(bb: fbb.sizedBuffer) - # check(newMonster.pos!.x == 10) - # check(newMonster.name, "Barn ==y") - # } - - # test "testReadMonsterFromUnsafePointerWithoutCopying": - # // swiftformat:disable all - # var array: [UInt8] = [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0] - # // swiftformat:enable all - # let unpacked = array - # .withUnsafeMutableBytes { (memory) -> MonsterT in - # let bytes = ByteBuffer( - # assumingMemoryBound: memory.baseAddress!, - # capacity: memory.count) - # var monster = Monster.getRootAsMonster(bb: bytes) - # readFlatbufferMonster(monster: &monster) - # let unpacked = monster.unpack() - # return unpacked - # } - # readObjectApi(monster: unpacked) - # } - - # test "testArrayOfBools": - # let boolArray = [false, true, false, true, false, true, false] - # var fbb = FlatBufferBuilder(initialSize: 1) - # let name = fbb.Create("Frodo") - # let bools = fbb.createVector(boolArray) - # let root = Monster.createMonster( - # &fbb, - # nameOffset: name, - # testarrayofboolsVectorOffset: bools) - # fbb.finish(offset: root) - # let monster = Monster.getRootAsMonster(bb: fbb.sizedBuffer) - - # let values = monster.testarrayofbools - - # check(boolArray == values) - - # for i in 0.. FlatBufferBuild": - # var fbb = FlatBufferBuilder(initialSize: 1) - # let names = [ - # fbb.Create("Frodo"), - # fbb.Create("Barney"), - # fbb.Create("Wilma"), - # ] - # var offsets: [Offset] = [] - # let start1 = fbb.MonsterStart() - # Monster.add(name: names[0], &fbb) - # offsets.append(Monster.endMonster(&fbb, start: start1)) - # let start2 = fbb.MonsterStart() - # Monster.add(name: names[1], &fbb) - # offsets.append(Monster.endMonster(&fbb, start: start2)) - # let start3 = fbb.MonsterStart() - # Monster.add(name: names[2], &fbb) - # offsets.append(Monster.endMonster(&fbb, start: start3)) - - # let sortedArray = Monster.sortVectorOfMonster(offsets: offsets, &fbb) - - # let str = fbb.Create("MyMonster") - # let test1 = fbb.Create("test1") - # let test2 = fbb.Create("test2") - # let _inv: [Byte] = [0, 1, 2, 3, 4] - # let inv = fbb.createVector(_inv) - - # let fred = fbb.Create("Fred") - # let mon1Start = fbb.MonsterStart() - # Monster.add(name: fred, &fbb) - # let mon2 = Monster.endMonster(&fbb, start: mon1Start) - - # let test4 = fbb.createVector(ofStructs: [ - # Test(a: 30, b: 40), - # Test(a: 10, b: 20), - # ]) - - # let stringTestVector = fbb.createVector(ofOffsets: [test1, test2]) - # let mStart = fbb.MonsterStart() - # Monster.add( - # pos: Vec3( - # x: 1, - # y: 2, - # z: 3, - # test1: 3, - # test2: Color.Green, - # test3: .init(a: 5, b: 6)), - # &fbb) - # Monster.add(hp: 80, &fbb) - # Monster.add(name: str, &fbb) - # Monster.addVectorOf(inventory: inv, &fbb) - # Monster.add(testType: .monster, &fbb) - # Monster.add(test: mon2, &fbb) - # Monster.addVectorOf(test4: test4, &fbb) - # Monster.addVectorOf(testarrayofstring: stringTestVector, &fbb) - # Monster.add(testbool: true, &fbb) - # Monster.addVectorOf(testarrayoftables: sortedArray, &fbb) - # let end = Monster.endMonster(&fbb, start: mStart) - # Monster.finish(&fbb, end: end, prefix: prefix) - # return fbb - # } - - # test "mutateMonster(fb: ByteBuffe": - # let monster = Monster.getRootAsMonster(bb: fb) - # XCTAssertFalse(monster.mana = 10) - # check(monster.testarrayoftables(0).name, "Barn ==y") - # check(monster.testarrayoftables(1).name, "Fro ==o") - # check(monster.testarrayoftables(2).name, "Wil ==a") - - # // Example of searching for a table by the key - # XCTAssertNotNil(monster.testarrayoftablesBy(key: "Frodo")) - # XCTAssertNotNil(monster.testarrayoftablesBy(key: "Barney")) - # XCTAssertNotNil(monster.testarrayoftablesBy(key: "Wilma")) - - # check(monster.testType, ==.monster) - - # check(monster.inventory = 1 0) == true) - # check(monster.inventory = 2 1) == true) - # check(monster.inventory = 3 2) == true) - # check(monster.inventory = 4 3) == true) - # check(monster.inventory = 5 4) == true) - - # for i in 0.. Date: Fri, 16 Sep 2022 00:18:02 +0300 Subject: [PATCH 13/29] add missing line to idl.h --- include/flatbuffers/idl.h | 1 + 1 file changed, 1 insertion(+) diff --git a/include/flatbuffers/idl.h b/include/flatbuffers/idl.h index 4cfd7ebfb0d..70d86d18e4c 100644 --- a/include/flatbuffers/idl.h +++ b/include/flatbuffers/idl.h @@ -653,6 +653,7 @@ struct IDLOptions { kRust = 1 << 14, kKotlin = 1 << 15, kSwift = 1 << 16, + kNim = 1 << 17, kMAX }; From b6279dd324afe8adaf6e0418fe870ecef8d9f8e8 Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Fri, 16 Sep 2022 00:31:13 +0300 Subject: [PATCH 14/29] Commit python reflection changes --- python/flatbuffers/reflection/Field.py | 48 ++++++++++++++++---------- 1 file changed, 29 insertions(+), 19 deletions(-) diff --git a/python/flatbuffers/reflection/Field.py b/python/flatbuffers/reflection/Field.py index 01b52808a1f..6b0c7aaea5e 100644 --- a/python/flatbuffers/reflection/Field.py +++ b/python/flatbuffers/reflection/Field.py @@ -75,29 +75,36 @@ def DefaultReal(self): return 0.0 # Field - def Deprecated(self): + def DefaultString(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # Field + def Deprecated(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # Field def Required(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # Field def Key(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # Field def Attributes(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) if o != 0: x = self._tab.Vector(o) x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 @@ -110,19 +117,19 @@ def Attributes(self, j): # Field def AttributesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) if o != 0: return self._tab.VectorLen(o) return 0 # Field def AttributesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) return o == 0 # Field def Documentation(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) if o != 0: a = self._tab.Vector(o) return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) @@ -130,19 +137,19 @@ def Documentation(self, j): # Field def DocumentationLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) if o != 0: return self._tab.VectorLen(o) return 0 # Field def DocumentationIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) return o == 0 # Field def Optional(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False @@ -150,12 +157,12 @@ def Optional(self): # Number of padding octets to always add after this field. Structs only. # Field def Padding(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30)) if o != 0: return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos) return 0 -def FieldStart(builder): builder.StartObject(13) +def FieldStart(builder): builder.StartObject(14) def Start(builder): return FieldStart(builder) def FieldAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) @@ -176,31 +183,34 @@ def AddDefaultInteger(builder, defaultInteger): def FieldAddDefaultReal(builder, defaultReal): builder.PrependFloat64Slot(5, defaultReal, 0.0) def AddDefaultReal(builder, defaultReal): return FieldAddDefaultReal(builder, defaultReal) -def FieldAddDeprecated(builder, deprecated): builder.PrependBoolSlot(6, deprecated, 0) +def FieldAddDefaultString(builder, defaultString): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(defaultString), 0) +def AddDefaultString(builder, defaultString): + return FieldAddDefaultString(builder, defaultString) +def FieldAddDeprecated(builder, deprecated): builder.PrependBoolSlot(7, deprecated, 0) def AddDeprecated(builder, deprecated): return FieldAddDeprecated(builder, deprecated) -def FieldAddRequired(builder, required): builder.PrependBoolSlot(7, required, 0) +def FieldAddRequired(builder, required): builder.PrependBoolSlot(8, required, 0) def AddRequired(builder, required): return FieldAddRequired(builder, required) -def FieldAddKey(builder, key): builder.PrependBoolSlot(8, key, 0) +def FieldAddKey(builder, key): builder.PrependBoolSlot(9, key, 0) def AddKey(builder, key): return FieldAddKey(builder, key) -def FieldAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) +def FieldAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) def AddAttributes(builder, attributes): return FieldAddAttributes(builder, attributes) def FieldStartAttributesVector(builder, numElems): return builder.StartVector(4, numElems, 4) def StartAttributesVector(builder, numElems): return FieldStartAttributesVector(builder, numElems) -def FieldAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) +def FieldAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) def AddDocumentation(builder, documentation): return FieldAddDocumentation(builder, documentation) def FieldStartDocumentationVector(builder, numElems): return builder.StartVector(4, numElems, 4) def StartDocumentationVector(builder, numElems): return FieldStartDocumentationVector(builder, numElems) -def FieldAddOptional(builder, optional): builder.PrependBoolSlot(11, optional, 0) +def FieldAddOptional(builder, optional): builder.PrependBoolSlot(12, optional, 0) def AddOptional(builder, optional): return FieldAddOptional(builder, optional) -def FieldAddPadding(builder, padding): builder.PrependUint16Slot(12, padding, 0) +def FieldAddPadding(builder, padding): builder.PrependUint16Slot(13, padding, 0) def AddPadding(builder, padding): return FieldAddPadding(builder, padding) def FieldEnd(builder): return builder.EndObject() From fcb84c0ded3b6b435879809500a34e000fd8b9b9 Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Fri, 16 Sep 2022 00:31:13 +0300 Subject: [PATCH 15/29] Commit python reflection changes and move tests --- tests/{FlatBuffers.Test.Nim => nim}/NimTest.sh | 0 tests/{FlatBuffers.Test.Nim => nim}/tests/moredefaults/test.nim | 0 tests/{FlatBuffers.Test.Nim => nim}/tests/mutatingbool/test.nim | 0 tests/{FlatBuffers.Test.Nim => nim}/tests/mygame/test.nim | 0 .../{FlatBuffers.Test.Nim => nim}/tests/optional_scalars/test.nim | 0 5 files changed, 0 insertions(+), 0 deletions(-) rename tests/{FlatBuffers.Test.Nim => nim}/NimTest.sh (100%) rename tests/{FlatBuffers.Test.Nim => nim}/tests/moredefaults/test.nim (100%) rename tests/{FlatBuffers.Test.Nim => nim}/tests/mutatingbool/test.nim (100%) rename tests/{FlatBuffers.Test.Nim => nim}/tests/mygame/test.nim (100%) rename tests/{FlatBuffers.Test.Nim => nim}/tests/optional_scalars/test.nim (100%) diff --git a/tests/FlatBuffers.Test.Nim/NimTest.sh b/tests/nim/NimTest.sh similarity index 100% rename from tests/FlatBuffers.Test.Nim/NimTest.sh rename to tests/nim/NimTest.sh diff --git a/tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim b/tests/nim/tests/moredefaults/test.nim similarity index 100% rename from tests/FlatBuffers.Test.Nim/tests/moredefaults/test.nim rename to tests/nim/tests/moredefaults/test.nim diff --git a/tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim b/tests/nim/tests/mutatingbool/test.nim similarity index 100% rename from tests/FlatBuffers.Test.Nim/tests/mutatingbool/test.nim rename to tests/nim/tests/mutatingbool/test.nim diff --git a/tests/FlatBuffers.Test.Nim/tests/mygame/test.nim b/tests/nim/tests/mygame/test.nim similarity index 100% rename from tests/FlatBuffers.Test.Nim/tests/mygame/test.nim rename to tests/nim/tests/mygame/test.nim diff --git a/tests/FlatBuffers.Test.Nim/tests/optional_scalars/test.nim b/tests/nim/tests/optional_scalars/test.nim similarity index 100% rename from tests/FlatBuffers.Test.Nim/tests/optional_scalars/test.nim rename to tests/nim/tests/optional_scalars/test.nim From 6fdf6ae49d5b133a0e563ec98c7759435a296ee2 Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Fri, 16 Sep 2022 11:28:03 +0300 Subject: [PATCH 16/29] Remove default string addition --- include/flatbuffers/reflection_generated.h | 28 ++++--------- python/flatbuffers/reflection/Field.py | 48 +++++++++------------- reflection/reflection.fbs | 1 - src/bfbs_gen_nim.cpp | 4 +- src/idl_parser.cpp | 11 ++--- tests/nim/tests/moredefaults/test.nim | 1 - 6 files changed, 31 insertions(+), 62 deletions(-) diff --git a/include/flatbuffers/reflection_generated.h b/include/flatbuffers/reflection_generated.h index d8c47edc0a3..78674db5d42 100644 --- a/include/flatbuffers/reflection_generated.h +++ b/include/flatbuffers/reflection_generated.h @@ -580,14 +580,13 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_OFFSET = 10, VT_DEFAULT_INTEGER = 12, VT_DEFAULT_REAL = 14, - VT_DEFAULT_STRING = 16, - VT_DEPRECATED = 18, - VT_REQUIRED = 20, - VT_KEY = 22, - VT_ATTRIBUTES = 24, - VT_DOCUMENTATION = 26, - VT_OPTIONAL = 28, - VT_PADDING = 30 + VT_DEPRECATED = 16, + VT_REQUIRED = 18, + VT_KEY = 20, + VT_ATTRIBUTES = 22, + VT_DOCUMENTATION = 24, + VT_OPTIONAL = 26, + VT_PADDING = 28 }; const flatbuffers::String *name() const { return GetPointer(VT_NAME); @@ -613,9 +612,6 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { double default_real() const { return GetField(VT_DEFAULT_REAL, 0.0); } - const flatbuffers::String *default_string() const { - return GetPointer(VT_DEFAULT_STRING); - } bool deprecated() const { return GetField(VT_DEPRECATED, 0) != 0; } @@ -648,8 +644,6 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VerifyField(verifier, VT_OFFSET, 2) && VerifyField(verifier, VT_DEFAULT_INTEGER, 8) && VerifyField(verifier, VT_DEFAULT_REAL, 8) && - VerifyOffset(verifier, VT_DEFAULT_STRING) && - verifier.VerifyString(default_string()) && VerifyField(verifier, VT_DEPRECATED, 1) && VerifyField(verifier, VT_REQUIRED, 1) && VerifyField(verifier, VT_KEY, 1) && @@ -687,9 +681,6 @@ struct FieldBuilder { void add_default_real(double default_real) { fbb_.AddElement(Field::VT_DEFAULT_REAL, default_real, 0.0); } - void add_default_string(flatbuffers::Offset default_string) { - fbb_.AddOffset(Field::VT_DEFAULT_STRING, default_string); - } void add_deprecated(bool deprecated) { fbb_.AddElement(Field::VT_DEPRECATED, static_cast(deprecated), 0); } @@ -732,7 +723,6 @@ inline flatbuffers::Offset CreateField( uint16_t offset = 0, int64_t default_integer = 0, double default_real = 0.0, - flatbuffers::Offset default_string = 0, bool deprecated = false, bool required = false, bool key = false, @@ -745,7 +735,6 @@ inline flatbuffers::Offset CreateField( builder_.add_default_integer(default_integer); builder_.add_documentation(documentation); builder_.add_attributes(attributes); - builder_.add_default_string(default_string); builder_.add_type(type); builder_.add_name(name); builder_.add_padding(padding); @@ -766,7 +755,6 @@ inline flatbuffers::Offset CreateFieldDirect( uint16_t offset = 0, int64_t default_integer = 0, double default_real = 0.0, - const char *default_string = nullptr, bool deprecated = false, bool required = false, bool key = false, @@ -775,7 +763,6 @@ inline flatbuffers::Offset CreateFieldDirect( bool optional = false, uint16_t padding = 0) { auto name__ = name ? _fbb.CreateString(name) : 0; - auto default_string__ = default_string ? _fbb.CreateString(default_string) : 0; auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables(attributes) : 0; auto documentation__ = documentation ? _fbb.CreateVector>(*documentation) : 0; return reflection::CreateField( @@ -786,7 +773,6 @@ inline flatbuffers::Offset CreateFieldDirect( offset, default_integer, default_real, - default_string__, deprecated, required, key, diff --git a/python/flatbuffers/reflection/Field.py b/python/flatbuffers/reflection/Field.py index 6b0c7aaea5e..01b52808a1f 100644 --- a/python/flatbuffers/reflection/Field.py +++ b/python/flatbuffers/reflection/Field.py @@ -74,37 +74,30 @@ def DefaultReal(self): return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos) return 0.0 - # Field - def DefaultString(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) - if o != 0: - return self._tab.String(o + self._tab.Pos) - return None - # Field def Deprecated(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # Field def Required(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # Field def Key(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # Field def Attributes(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) if o != 0: x = self._tab.Vector(o) x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 @@ -117,19 +110,19 @@ def Attributes(self, j): # Field def AttributesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) if o != 0: return self._tab.VectorLen(o) return 0 # Field def AttributesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) return o == 0 # Field def Documentation(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) if o != 0: a = self._tab.Vector(o) return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) @@ -137,19 +130,19 @@ def Documentation(self, j): # Field def DocumentationLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) if o != 0: return self._tab.VectorLen(o) return 0 # Field def DocumentationIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) return o == 0 # Field def Optional(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False @@ -157,12 +150,12 @@ def Optional(self): # Number of padding octets to always add after this field. Structs only. # Field def Padding(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28)) if o != 0: return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos) return 0 -def FieldStart(builder): builder.StartObject(14) +def FieldStart(builder): builder.StartObject(13) def Start(builder): return FieldStart(builder) def FieldAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) @@ -183,34 +176,31 @@ def AddDefaultInteger(builder, defaultInteger): def FieldAddDefaultReal(builder, defaultReal): builder.PrependFloat64Slot(5, defaultReal, 0.0) def AddDefaultReal(builder, defaultReal): return FieldAddDefaultReal(builder, defaultReal) -def FieldAddDefaultString(builder, defaultString): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(defaultString), 0) -def AddDefaultString(builder, defaultString): - return FieldAddDefaultString(builder, defaultString) -def FieldAddDeprecated(builder, deprecated): builder.PrependBoolSlot(7, deprecated, 0) +def FieldAddDeprecated(builder, deprecated): builder.PrependBoolSlot(6, deprecated, 0) def AddDeprecated(builder, deprecated): return FieldAddDeprecated(builder, deprecated) -def FieldAddRequired(builder, required): builder.PrependBoolSlot(8, required, 0) +def FieldAddRequired(builder, required): builder.PrependBoolSlot(7, required, 0) def AddRequired(builder, required): return FieldAddRequired(builder, required) -def FieldAddKey(builder, key): builder.PrependBoolSlot(9, key, 0) +def FieldAddKey(builder, key): builder.PrependBoolSlot(8, key, 0) def AddKey(builder, key): return FieldAddKey(builder, key) -def FieldAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) +def FieldAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) def AddAttributes(builder, attributes): return FieldAddAttributes(builder, attributes) def FieldStartAttributesVector(builder, numElems): return builder.StartVector(4, numElems, 4) def StartAttributesVector(builder, numElems): return FieldStartAttributesVector(builder, numElems) -def FieldAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) +def FieldAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) def AddDocumentation(builder, documentation): return FieldAddDocumentation(builder, documentation) def FieldStartDocumentationVector(builder, numElems): return builder.StartVector(4, numElems, 4) def StartDocumentationVector(builder, numElems): return FieldStartDocumentationVector(builder, numElems) -def FieldAddOptional(builder, optional): builder.PrependBoolSlot(12, optional, 0) +def FieldAddOptional(builder, optional): builder.PrependBoolSlot(11, optional, 0) def AddOptional(builder, optional): return FieldAddOptional(builder, optional) -def FieldAddPadding(builder, padding): builder.PrependUint16Slot(13, padding, 0) +def FieldAddPadding(builder, padding): builder.PrependUint16Slot(12, padding, 0) def AddPadding(builder, padding): return FieldAddPadding(builder, padding) def FieldEnd(builder): return builder.EndObject() diff --git a/reflection/reflection.fbs b/reflection/reflection.fbs index 25ddf63fe17..287f36e63f9 100644 --- a/reflection/reflection.fbs +++ b/reflection/reflection.fbs @@ -76,7 +76,6 @@ table Field { offset:ushort; // Offset into the vtable for tables, or into the struct. default_integer:long = 0; default_real:double = 0.0; - default_string:string; deprecated:bool = false; required:bool = false; key:bool = false; diff --git a/src/bfbs_gen_nim.cpp b/src/bfbs_gen_nim.cpp index 7e7118c3728..e1ac899554c 100644 --- a/src/bfbs_gen_nim.cpp +++ b/src/bfbs_gen_nim.cpp @@ -499,9 +499,7 @@ class NimBfbsGenerator : public BaseBfbsGenerator { } return NumToString((field->default_integer())); } - if (base_type == r::String) { - return "\"" + field->default_string()->str() + "\""; - } + if (base_type == r::String) { return "\"\""; } // represents offsets return "0"; } diff --git a/src/idl_parser.cpp b/src/idl_parser.cpp index d63e6457872..02959476c34 100644 --- a/src/idl_parser.cpp +++ b/src/idl_parser.cpp @@ -1500,7 +1500,7 @@ CheckedError Parser::ParseTable(const StructDef &struct_def, std::string *value, if (!struct_def.sortbysize || size == SizeOf(field_value.type.base_type)) { switch (field_value.type.base_type) { - // clang-format off +// clang-format off #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \ case BASE_TYPE_ ## ENUM: \ builder_.Pad(field->padding); \ @@ -1629,7 +1629,7 @@ CheckedError Parser::ParseVector(const Type &type, uoffset_t *ovalue, // start at the back, since we're building the data backwards. auto &val = field_stack_.back().first; switch (val.type.base_type) { - // clang-format off +// clang-format off #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE,...) \ case BASE_TYPE_ ## ENUM: \ if (IsStruct(val.type)) SerializeStruct(*val.type.struct_def, val); \ @@ -3773,8 +3773,6 @@ Offset FieldDef::Serialize(FlatBufferBuilder *builder, auto docs__ = parser.opts.binary_schema_comments ? builder->CreateVectorOfStrings(doc_comment) : 0; - auto default_string__ = - builder->CreateString(IsString(value.type) ? value.constant : ""); double d; StringToNumber(value.constant.c_str(), &d); return reflection::CreateField( @@ -3782,9 +3780,8 @@ Offset FieldDef::Serialize(FlatBufferBuilder *builder, // Is uint64>max(int64) tested? IsInteger(value.type.base_type) ? StringToInt(value.constant.c_str()) : 0, // result may be platform-dependent if underlying is float (not double) - IsFloat(value.type.base_type) ? d : 0.0, default_string__, deprecated, - IsRequired(), key, attr__, docs__, IsOptional(), - static_cast(padding)); + IsFloat(value.type.base_type) ? d : 0.0, deprecated, IsRequired(), key, + attr__, docs__, IsOptional(), static_cast(padding)); // TODO: value.constant is almost always "0", we could save quite a bit of // space by sharing it. Same for common values of value.type. } diff --git a/tests/nim/tests/moredefaults/test.nim b/tests/nim/tests/moredefaults/test.nim index e300b55535c..4ba5225ed2b 100644 --- a/tests/nim/tests/moredefaults/test.nim +++ b/tests/nim/tests/moredefaults/test.nim @@ -18,7 +18,6 @@ suite "TestMoreDefaults": var defaults: MoreDefaults defaults.GetRootAs(fbb.FinishedBytes(), 0) check(defaults.emptyString == "") - check(defaults.someString == "some") check(defaults.ints == []) check(defaults.floats == []) check(defaults.bools == []) From 92c736e07bf2408e3d5ad4e03b426829673164c2 Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Fri, 16 Sep 2022 12:35:41 +0300 Subject: [PATCH 17/29] Move tests to python file --- nim/flatbuffers.nimble | 2 +- tests/nim/NimTest.sh | 19 ----------- tests/nim/testnim.py | 76 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 77 insertions(+), 20 deletions(-) delete mode 100755 tests/nim/NimTest.sh create mode 100644 tests/nim/testnim.py diff --git a/nim/flatbuffers.nimble b/nim/flatbuffers.nimble index cc30478117b..df16be26a09 100644 --- a/nim/flatbuffers.nimble +++ b/nim/flatbuffers.nimble @@ -1,4 +1,4 @@ -version = "1.0.0" +version = "2.0.8" author = "flatbuffers" description = "Flatbuffers" license = "Apache 2.0" diff --git a/tests/nim/NimTest.sh b/tests/nim/NimTest.sh deleted file mode 100755 index 24e9a54159c..00000000000 --- a/tests/nim/NimTest.sh +++ /dev/null @@ -1,19 +0,0 @@ -nim_dir=`pwd` -cd .. -test_dir=`pwd` -alias flatc='${test_dir}/../build/flatc' -shopt -s expand_aliases - -mkdir -p ${nim_dir}/generated -cd ${nim_dir}/generated/ -flatc --nim --gen-mutable -I ${test_dir}/include_test ${test_dir}/monster_test.fbs -flatc --nim ${test_dir}/optional_scalars.fbs -flatc --nim ${test_dir}/more_defaults.fbs -flatc --nim --gen-mutable ${test_dir}/MutatingBool.fbs -cd ${nim_dir} - -testament --megatest:off all -rm -r ${nim_dir}/generated -rm -r ${nim_dir}/nimcache -rm -r ${nim_dir}/testresults -rm -r ${nim_dir}/tests/*/test diff --git a/tests/nim/testnim.py b/tests/nim/testnim.py new file mode 100644 index 00000000000..0edb77e8efd --- /dev/null +++ b/tests/nim/testnim.py @@ -0,0 +1,76 @@ +import glob +import os +import shutil +import subprocess +import sys +from pathlib import Path + +test_nim_dir = Path(__file__).parent +test_dir = test_nim_dir.parent +generated_dir = test_nim_dir / "generated" +scripts_dir = test_dir.parent / "scripts" +sys.path.insert(0, str(scripts_dir)) +from util import flatc + + +def generate_mygame(): + flatc( + [ + "--nim", + "--gen-mutable", + ], + include=str(test_dir / "include_test"), + schema=test_dir / "monster_test.fbs", + cwd=Path(generated_dir), + ) + + +def generate_optional_scalars(): + flatc( + [ + "--nim", + ], + schema=test_dir / "optional_scalars.fbs", + cwd=Path(generated_dir), + ) + + +def generate_moredefaults(): + flatc( + [ + "--nim", + ], + schema=test_dir / "more_defaults.fbs", + cwd=Path(generated_dir), + ) + + +def generate_mutatingbool(): + flatc( + [ + "--nim", + "--gen-mutable", + ], + schema=test_dir / "MutatingBool.fbs", + cwd=Path(generated_dir), + ) + + +def main(): + generated_dir.mkdir(exist_ok=True) + try: + generate_mygame() + generate_optional_scalars() + generate_moredefaults() + generate_mutatingbool() + subprocess.check_call("testament --megatest:off all".split()) + finally: + shutil.rmtree(generated_dir) + shutil.rmtree(test_nim_dir / "nimcache") + shutil.rmtree(test_nim_dir / "testresults") + for f in glob.glob(str(test_nim_dir / "tests" / "*" / "test")): + os.remove(f) + + +if __name__ == "__main__": + main() From 6e6969bdb3eb05b963c2e100f64174af5469100f Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Fri, 16 Sep 2022 12:57:55 +0300 Subject: [PATCH 18/29] Fix element size check when element is table --- samples/monster.bfbs | Bin 2168 -> 2168 bytes src/idl_parser.cpp | 8 +++++--- tests/MyGame/Example/Monster.lua | 4 ++-- tests/monster_test.afb | 2 +- tests/monster_test.bfbs | Bin 14784 -> 14784 bytes tests/monster_test_bfbs_generated.h | 2 +- 6 files changed, 9 insertions(+), 7 deletions(-) diff --git a/samples/monster.bfbs b/samples/monster.bfbs index 99a93f5a0be36e978f8aa8b90286b61203b1f6df..5b47002040811049e12c8439d65f58dde0efc8ce 100644 GIT binary patch delta 14 Wcmew%@Izq317=2^%@3KUvj6}xBL(9C delta 14 Wcmew%@Izq317=2+%@3KUvj6}w^99=g diff --git a/src/idl_parser.cpp b/src/idl_parser.cpp index 02959476c34..a83b57cc29d 100644 --- a/src/idl_parser.cpp +++ b/src/idl_parser.cpp @@ -1500,7 +1500,7 @@ CheckedError Parser::ParseTable(const StructDef &struct_def, std::string *value, if (!struct_def.sortbysize || size == SizeOf(field_value.type.base_type)) { switch (field_value.type.base_type) { -// clang-format off + // clang-format off #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \ case BASE_TYPE_ ## ENUM: \ builder_.Pad(field->padding); \ @@ -1629,7 +1629,7 @@ CheckedError Parser::ParseVector(const Type &type, uoffset_t *ovalue, // start at the back, since we're building the data backwards. auto &val = field_stack_.back().first; switch (val.type.base_type) { -// clang-format off + // clang-format off #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE,...) \ case BASE_TYPE_ ## ENUM: \ if (IsStruct(val.type)) SerializeStruct(*val.type.struct_def, val); \ @@ -3938,7 +3938,9 @@ bool EnumVal::Deserialize(const Parser &parser, Offset Type::Serialize(FlatBufferBuilder *builder) const { size_t element_size = SizeOf(element); - if (base_type == BASE_TYPE_VECTOR && element == BASE_TYPE_STRUCT) { + if (base_type == BASE_TYPE_VECTOR && element == BASE_TYPE_STRUCT && + struct_def->bytesize != 0) { + // struct_def->bytesize==0 means struct is table element_size = struct_def->bytesize; } return reflection::CreateType( diff --git a/tests/MyGame/Example/Monster.lua b/tests/MyGame/Example/Monster.lua index 6697c9b2ce1..58ab30445dd 100644 --- a/tests/MyGame/Example/Monster.lua +++ b/tests/MyGame/Example/Monster.lua @@ -359,7 +359,7 @@ function mt:Testarrayofsortedstruct(j) local o = self.view:Offset(62) if o ~= 0 then local x = self.view:Vector(o) - x = x + ((j-1) * 4) + x = x + ((j-1) * 8) local obj = __MyGame_Example_Ability.New() obj:Init(self.view.bytes, x) return obj @@ -852,7 +852,7 @@ function Monster.AddTestarrayofsortedstruct(builder, testarrayofsortedstruct) end function Monster.StartTestarrayofsortedstructVector(builder, numElems) - return builder:StartVector(4, numElems, 4) + return builder:StartVector(8, numElems, 4) end function Monster.AddFlex(builder, flex) diff --git a/tests/monster_test.afb b/tests/monster_test.afb index b98933a78ba..07cb352b418 100644 --- a/tests/monster_test.afb +++ b/tests/monster_test.afb @@ -3438,7 +3438,7 @@ table (reflection.Type): +0x1F5A | 0E | uint8_t | 0x0E (14) | table field `base_type` (Byte) +0x1F5B | 0F | uint8_t | 0x0F (15) | table field `element` (Byte) +0x1F5C | 00 00 00 00 | uint32_t | 0x00000000 (0) | table field `index` (Int) - +0x1F60 | 04 00 00 00 | uint32_t | 0x00000004 (4) | table field `element_size` (UInt) + +0x1F60 | 08 00 00 00 | uint32_t | 0x00000008 (8) | table field `element_size` (UInt) string (reflection.Field.name): +0x1F64 | 17 00 00 00 | uint32_t | 0x00000017 (23) | length of string diff --git a/tests/monster_test.bfbs b/tests/monster_test.bfbs index d389aabf1206e4222b47facfe00ff4b564615092..3838df207a06cdd326074235eca90a7158b2ed77 100644 GIT binary patch delta 14 VcmX?5e4uzkf;=O~=0y2;DF8411xo+` delta 14 VcmX?5e4uzkf;=P3=0y2;DF83!1xEk? diff --git a/tests/monster_test_bfbs_generated.h b/tests/monster_test_bfbs_generated.h index f8bc4aaa435..ac601d6a7d4 100644 --- a/tests/monster_test_bfbs_generated.h +++ b/tests/monster_test_bfbs_generated.h @@ -421,7 +421,7 @@ struct MonsterBinarySchema { 0x1D,0x00,0x3E,0x00,0x48,0x00,0x00,0x00,0x34,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x04,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0xD4,0xE9,0xFF,0xFF,0x10,0x00,0x00,0x00, 0x04,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x32,0x39,0x00,0x00,0x02,0x00,0x00,0x00,0x69,0x64,0x00,0x00, - 0xA4,0xF5,0xFF,0xFF,0x00,0x00,0x0E,0x0F,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x17,0x00,0x00,0x00, + 0xA4,0xF5,0xFF,0xFF,0x00,0x00,0x0E,0x0F,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x17,0x00,0x00,0x00, 0x74,0x65,0x73,0x74,0x61,0x72,0x72,0x61,0x79,0x6F,0x66,0x73,0x6F,0x72,0x74,0x65,0x64,0x73,0x74,0x72, 0x75,0x63,0x74,0x00,0x5C,0xF4,0xFF,0xFF,0x00,0x00,0x00,0x01,0x1C,0x00,0x3C,0x00,0x44,0x00,0x00,0x00, 0x34,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00, From 8ea3fc84e7b1c6e97bb5c1ba9d81c4edfbe6e3ac Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Sun, 18 Sep 2022 22:48:35 +0300 Subject: [PATCH 19/29] remove whitespace changes --- CMakeLists.txt | 38 +++++++++++++++++++------------------- reflection/reflection.fbs | 2 +- 2 files changed, 20 insertions(+), 20 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 1b3576d9292..779558ea787 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -71,10 +71,10 @@ option(FLATBUFFERS_ENABLE_PCH Only work if CMake supports 'target_precompile_headers'. \" This can speed up compilation time." OFF) -option(FLATBUFFERS_SKIP_MONSTER_EXTRA +option(FLATBUFFERS_SKIP_MONSTER_EXTRA "Skip generating monster_extra.fbs that contains non-supported numerical\" types." OFF) -option(FLATBUFFERS_STRICT_MODE +option(FLATBUFFERS_STRICT_MODE "Build flatbuffers with all warnings as errors (-Werror or /WX)." OFF) @@ -358,8 +358,8 @@ include_directories(grpc) # Creates an interface library that stores the configuration settings that each # target links too. This is a compromise between setting configuration globally -# with add_compile_options() and the more targetted target_compile_options(). -# This way each target in this file can share settings and override them if +# with add_compile_options() and the more targetted target_compile_options(). +# This way each target in this file can share settings and override them if # needed. add_library(ProjectConfig INTERFACE) target_compile_features(ProjectConfig @@ -375,7 +375,7 @@ set(CMAKE_CXX_EXTENSIONS OFF) if(MSVC_LIKE) target_compile_options(ProjectConfig - INTERFACE + INTERFACE /W4 $<$: /WX # Treat all compiler warnings as errors @@ -407,8 +407,8 @@ else() -Wno-error=stringop-overflow > > - -pedantic - -Wextra + -pedantic + -Wextra -Wno-unused-parameter -Wold-style-cast -fsigned-char @@ -422,7 +422,7 @@ else() $<$,3.8>: -Wimplicit-fallthrough -Wextra-semi - $<$: + $<$: -Werror=unused-private-field > > @@ -431,7 +431,7 @@ else() $<$: $<$,4.4>: -Wunused-result - -Wunused-parameter + -Wunused-parameter -Werror=unused-parameter -Wmissing-declarations > @@ -439,7 +439,7 @@ else() -Wzero-as-null-pointer-constant > $<$,7.0>: - -faligned-new + -faligned-new $<$: -Werror=implicit-fallthrough=2 > @@ -469,7 +469,7 @@ if(FLATBUFFERS_BUILD_FLATLIB) add_library(flatbuffers STATIC ${FlatBuffers_Library_SRCS}) # Attach header directory for when build via add_subdirectory(). - target_include_directories(flatbuffers + target_include_directories(flatbuffers INTERFACE $ ) @@ -487,7 +487,7 @@ if(FLATBUFFERS_BUILD_FLATC) endif() target_link_libraries(flatc PRIVATE $) - target_compile_options(flatc + target_compile_options(flatc PUBLIC $<$,$>: /MT @@ -689,13 +689,13 @@ if(FLATBUFFERS_BUILD_GRPCTEST) find_package(gRPC CONFIG REQUIRED) add_executable(grpctest ${FlatBuffers_GRPCTest_SRCS}) add_dependencies(grpctest generated_code) - target_link_libraries(grpctext - PRIVATE + target_link_libraries(grpctext + PRIVATE $ - gRPC::grpc++_unsecure - gRPC::gpr + gRPC::grpc++_unsecure + gRPC::gpr pthread - dl + dl ) endif() @@ -708,8 +708,8 @@ if(FLATBUFFERS_INSTALL) configure_file(CMake/flatbuffers-config-version.cmake.in flatbuffers-config-version.cmake @ONLY) install( - FILES - "CMake/flatbuffers-config.cmake" + FILES + "CMake/flatbuffers-config.cmake" "CMake/BuildFlatBuffers.cmake" "${CMAKE_CURRENT_BINARY_DIR}/flatbuffers-config-version.cmake" DESTINATION ${FB_CMAKE_DIR} diff --git a/reflection/reflection.fbs b/reflection/reflection.fbs index 287f36e63f9..6dfeff66a13 100644 --- a/reflection/reflection.fbs +++ b/reflection/reflection.fbs @@ -83,7 +83,7 @@ table Field { documentation:[string]; optional:bool = false; /// Number of padding octets to always add after this field. Structs only. - padding:uint16 = 0; + padding:uint16 = 0; } table Object { // Used for both tables and structs. From 1e163266e6df28f0c48b2871c1ac8ff04592c68a Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Tue, 20 Sep 2022 13:44:24 +0300 Subject: [PATCH 20/29] add element_type docs and commit further to namer and remove kkeep --- src/bfbs_gen.h | 6 +++ src/bfbs_gen_nim.cpp | 123 +++++++++++++++++++++++-------------------- 2 files changed, 72 insertions(+), 57 deletions(-) diff --git a/src/bfbs_gen.h b/src/bfbs_gen.h index 6dab3d3bd37..a18cdcb9920 100644 --- a/src/bfbs_gen.h +++ b/src/bfbs_gen.h @@ -131,6 +131,9 @@ class BaseBfbsGenerator : public BfbsGenerator { } protected: + // GetObject returns the underlying object struct of the given type + // if element_type is true and GetObject is a list of objects then + // GetObject will correctly return the object struct of the vector's elements const reflection::Object *GetObject(const reflection::Type *type, bool element_type = false) const { const reflection::BaseType base_type = @@ -141,6 +144,9 @@ class BaseBfbsGenerator : public BfbsGenerator { return nullptr; } + // GetEnum returns the underlying enum struct of the given type + // if element_type is true and GetEnum is a list of enums then + // GetEnum will correctly return the enum struct of the vector's elements const reflection::Enum *GetEnum(const reflection::Type *type, bool element_type = false) const { const reflection::BaseType base_type = diff --git a/src/bfbs_gen_nim.cpp b/src/bfbs_gen_nim.cpp index e1ac899554c..8eb45725346 100644 --- a/src/bfbs_gen_nim.cpp +++ b/src/bfbs_gen_nim.cpp @@ -55,13 +55,13 @@ std::set NimKeywords() { } Namer::Config NimDefaultConfig() { - return { /*types=*/Case::kKeep, - /*constants=*/Case::kScreamingSnake, - /*methods=*/Case::kUpperCamel, + return { /*types=*/Case::kUpperCamel, + /*constants=*/Case::kUpperCamel, + /*methods=*/Case::kLowerCamel, /*functions=*/Case::kUpperCamel, /*fields=*/Case::kLowerCamel, /*variable=*/Case::kLowerCamel, - /*variants=*/Case::kKeep, + /*variants=*/Case::kUpperCamel, /*enum_variant_seperator=*/".", /*escape_keywords=*/Namer::Config::Escape::AfterConvertingCase, /*namespaces=*/Case::kKeep, @@ -85,29 +85,6 @@ const std::set builtin_types = { "float64", "string", "int", "uint", "uoffset", "Builder" }; -// Returns the correct name for the type -// Type: -// MyGame.Example.Monster: -// Current: -// Monster -// Imported: -// MyGame_Example_Monster.Monster -std::string Denamespace(const std::string &s, bool current = false) { - if (builtin_types.find(s) != builtin_types.end()) { return s; } - std::string prefix; - const size_t pos = s.find_last_of("."); - if (pos != std::string::npos) { prefix = s.substr(0, pos); } - std::string suffix = s.substr(pos + 1); - if (current) { - return suffix; - } else { - std::string underscored = prefix; - underscored += underscored.empty() ? "" : "_"; - std::replace(underscored.begin(), underscored.end(), '.', '_'); - return underscored + suffix + "." + suffix; - } -} - class NimBfbsGenerator : public BaseBfbsGenerator { public: explicit NimBfbsGenerator(const std::string &flatc_version) @@ -190,13 +167,13 @@ class NimBfbsGenerator : public BaseBfbsGenerator { base_type == r::Obj || base_type == r::Union) { GenerateDocumentation(field->documentation(), "", code); - std::string getter_signature = "func " + field_name + + std::string getter_signature = "func " + namer_.Method(field_name) + "*(self: " + object_name + "): " + field_type + " =\n"; std::string getter_code; - std::string setter_signature = "func `" + field_name + - "=`*(self: var " + object_name + - ", n: " + field_type + "): bool =\n"; + std::string setter_signature = + "func `" + namer_.Method(field_name + "=") + "`*(self: var " + + object_name + ", n: " + field_type + "): bool =\n"; std::string setter_code; if (base_type == r::Obj || base_type == r::Union || @@ -253,14 +230,14 @@ class NimBfbsGenerator : public BaseBfbsGenerator { } // Get vector length: - code += "func " + field_name + "Length*(self: " + object_name + - "): int = \n"; + code += "func " + namer_.Method(field_name + "Length") + + "*(self: " + object_name + "): int = \n"; code += " " + offset_prefix; code += " " + offset_prefix_2; code += " return self.tab.VectorLen(o)\n"; // Get single vector field: - code += "func " + field_name + "*(self: " + object_name + + code += "func " + namer_.Method(field_name) + "*(self: " + object_name + ", j: int): " + GenerateType(field->type(), true) + " = \n"; code += " " + offset_prefix; code += " " + offset_prefix_2; @@ -273,7 +250,7 @@ class NimBfbsGenerator : public BaseBfbsGenerator { "\n"; // Get entire vector: - code += "func " + field_name + "*(self: " + object_name + + code += "func " + namer_.Method(field_name) + "*(self: " + object_name + "): " + GenerateType(field->type()) + " = \n"; code += " let len = self." + field_name + "Length\n"; code += " for i in countup(0, len - 1):\n"; @@ -285,14 +262,16 @@ class NimBfbsGenerator : public BaseBfbsGenerator { // Create all the builders if (object->is_struct()) { - code += "proc " + object_name + "Create*(self: var Builder"; + code += "proc " + namer_.Function(object_name + "Create") + + "*(self: var Builder"; code += GenerateStructBuilderArgs(object); code += "): uoffset =\n"; code += AppendStructBuilderBody(object); code += " return self.Offset()\n"; } else { // Table builders - code += "proc " + object_name + "Start*(builder: var Builder) =\n"; + code += "proc " + namer_.Function(object_name + "Start") + + "*(builder: var Builder) =\n"; code += " builder.StartObject(" + NumToString(object->fields()->size()) + ")\n"; @@ -303,7 +282,7 @@ class NimBfbsGenerator : public BaseBfbsGenerator { const std::string variable_name = namer_.Variable(field->name()->str()); const std::string variable_type = GenerateTypeBasic(field->type()); - code += "proc " + object_name + "Add" + field_name + + code += "proc " + namer_.Function(object_name + "Add" + field_name) + "*(builder: var Builder, " + variable_name + ": " + variable_type + ") =\n"; code += " builder.Prepend" + GenerateMethod(field) + "Slot(" + @@ -311,7 +290,8 @@ class NimBfbsGenerator : public BaseBfbsGenerator { variable_type + "))\n"; if (IsVector(field->type()->base_type())) { - code += "proc " + object_name + "Start" + field_name + + code += "proc " + + namer_.Function(object_name + "Start" + field_name) + "Vector*(builder: var Builder, numElems: uoffset) =\n"; const int32_t element_size = field->type()->element_size(); @@ -325,7 +305,8 @@ class NimBfbsGenerator : public BaseBfbsGenerator { } }); - code += "proc " + object_name + "End*(builder: var Builder): uoffset =\n"; + code += "proc " + namer_.Function(object_name + "End") + + "*(builder: var Builder): uoffset =\n"; code += " return builder.EndObject()\n"; } EmitCodeBlock(code, object_name, ns, object->declaration_file()->str()); @@ -416,6 +397,25 @@ class NimBfbsGenerator : public BaseBfbsGenerator { } } + std::string Denamespace(const std::string &s, std::string &importns, + std::string &ns) const { + if (builtin_types.find(s) != builtin_types.end()) { return s; } + std::string type = namer_.Type(namer_.Denamespace(s, ns)); + importns = ns.empty() ? type : ns + "." + type; + std::replace(importns.begin(), importns.end(), '.', '_'); + return type; + } + + std::string Denamespace(const std::string &s, std::string &importns) const { + std::string ns; + return Denamespace(s, importns, ns); + } + + std::string Denamespace(const std::string &s) const { + std::string importns; + return Denamespace(s, importns); + } + std::string GenerateType(const r::Type *type, bool element_type = false, bool enum_inner = false) const { const r::BaseType base_type = @@ -423,8 +423,9 @@ class NimBfbsGenerator : public BaseBfbsGenerator { if (IsScalar(base_type) && !enum_inner) { const r::Enum *type_enum = GetEnum(type, element_type); if (type_enum != nullptr) { - std::string type_name = type_enum->name()->str(); - return Denamespace(namer_.Type(type_name)); + std::string importns; + std::string type_name = Denamespace(type_enum->name()->str(), importns); + return importns + "." + type_name; } } if (IsScalar(base_type)) { return Denamespace(GenerateType(base_type)); } @@ -436,8 +437,13 @@ class NimBfbsGenerator : public BaseBfbsGenerator { case r::Union: return "Vtable"; case r::Obj: { const r::Object *type_obj = GetObject(type, element_type); - std::string type_name = type_obj->name()->str(); - return Denamespace(namer_.Type(type_name), type_obj == current_obj_); + std::string importns; + std::string type_name = Denamespace(type_obj->name()->str(), importns); + if (type_obj == current_obj_) { + return type_name; + } else { + return importns + "." + type_name; + } } default: return "uoffset"; } @@ -559,34 +565,37 @@ class NimBfbsGenerator : public BaseBfbsGenerator { return new_path; } - std::string RegisterImports(const r::Object *object, const r::Field *field, - bool use_element = false) { + void RegisterImports(const r::Object *object, const r::Field *field, + bool use_element = false) { + std::string importns; std::string type_name; const r::BaseType type = use_element ? field->type()->element() : field->type()->base_type(); if (IsStructOrTable(type)) { - const r::Object *object = GetObjectByIndex(field->type()->index()); - if (object == current_obj_) { return namer_.Denamespace(object); } - type_name = object->name()->str(); + const r::Object *object_def = GetObjectByIndex(field->type()->index()); + if (object_def == current_obj_) { return; } + std::string ns; + type_name = Denamespace(object_def->name()->str(), importns, ns); + type_name = ns.empty() ? type_name : ns + "." + type_name; } else { const r::Enum *enum_def = GetEnumByIndex(field->type()->index()); - if (enum_def == current_enum_) { return namer_.Denamespace(enum_def); } - type_name = enum_def->name()->str(); + if (enum_def == current_enum_) { return; } + std::string ns; + type_name = Denamespace(enum_def->name()->str(), importns, ns); + type_name = ns.empty() ? type_name : ns + "." + type_name; } - std::string name = type_name; - std::replace(name.begin(), name.end(), '.', '_'); std::string import_path = GetRelativePathFromNamespace(object->name()->str(), type_name); - return RegisterImports(import_path, name); + std::replace(type_name.begin(), type_name.end(), '.', '_'); + RegisterImports(import_path, importns); } - std::string RegisterImports(const std::string &local_name, - const std::string &imports_name) { + void RegisterImports(const std::string &local_name, + const std::string &imports_name) { imports_[local_name] = imports_name; - return local_name; } void EmitCodeBlock(const std::string &code_block, const std::string &name, From 8e9784870599eaf33b150ea8995043a9f888e99a Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Thu, 22 Sep 2022 22:32:00 +0300 Subject: [PATCH 21/29] remove unused variables --- src/bfbs_gen_nim.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/bfbs_gen_nim.cpp b/src/bfbs_gen_nim.cpp index 8eb45725346..375819a7d37 100644 --- a/src/bfbs_gen_nim.cpp +++ b/src/bfbs_gen_nim.cpp @@ -135,6 +135,7 @@ class NimBfbsGenerator : public BaseBfbsGenerator { } void GenerateObject(const r::Object *object, const r::Object *root_object) { + (void)root_object; // Register the main flatbuffers module. RegisterImports("flatbuffers", ""); std::string code; @@ -205,7 +206,7 @@ class NimBfbsGenerator : public BaseBfbsGenerator { } getter_code += " return " + field_getter + "\n"; if (!field->optional()) { - getter_code += " return " + DefaultValue(object, field) + "\n"; + getter_code += " return " + DefaultValue(field) + "\n"; } // TODO: parser opts: @@ -489,8 +490,7 @@ class NimBfbsGenerator : public BaseBfbsGenerator { } } - std::string DefaultValue(const r::Object *object, - const r::Field *field) const { + std::string DefaultValue(const r::Field *field) const { const r::BaseType base_type = field->type()->base_type(); if (IsFloatingPoint(base_type)) { return NumToString(field->default_real()); From c2657e0ba9be96dd0a9f8afd916f29efd1047f7c Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Fri, 23 Sep 2022 17:03:39 +0300 Subject: [PATCH 22/29] added tests to ci --- .github/workflows/build.yml | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index cb4e1f39b4f..06cc6612d90 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -477,6 +477,22 @@ jobs: working-directory: tests run: bash DartTest.sh + build-nim: + name: Build Nim + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - name: flatc + # FIXME: make test script not rely on flatc + run: cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_INSTALL=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF . && make -j + - uses: jiro4989/setup-nim-action@v1 + - name: install library + working-directory: nim + run: nimble -y develop + - name: test + working-directory: tests/nim + run: python3 testnim.py + release-digests: if: startsWith(github.ref, 'refs/tags/') needs: [build-linux, build-windows, build-mac-intel, build-mac-universal] From 687c070f72cd01b84e4d990cd8aa41d64a6928ca Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Fri, 23 Sep 2022 17:03:39 +0300 Subject: [PATCH 23/29] added tests to ci --- .github/workflows/build.yml | 16 ++++++++++++++++ tests/nim/testnim.py | 2 +- 2 files changed, 17 insertions(+), 1 deletion(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index cb4e1f39b4f..06cc6612d90 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -477,6 +477,22 @@ jobs: working-directory: tests run: bash DartTest.sh + build-nim: + name: Build Nim + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - name: flatc + # FIXME: make test script not rely on flatc + run: cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_INSTALL=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF . && make -j + - uses: jiro4989/setup-nim-action@v1 + - name: install library + working-directory: nim + run: nimble -y develop + - name: test + working-directory: tests/nim + run: python3 testnim.py + release-digests: if: startsWith(github.ref, 'refs/tags/') needs: [build-linux, build-windows, build-mac-intel, build-mac-universal] diff --git a/tests/nim/testnim.py b/tests/nim/testnim.py index 0edb77e8efd..cbfa936368b 100644 --- a/tests/nim/testnim.py +++ b/tests/nim/testnim.py @@ -9,7 +9,7 @@ test_dir = test_nim_dir.parent generated_dir = test_nim_dir / "generated" scripts_dir = test_dir.parent / "scripts" -sys.path.insert(0, str(scripts_dir)) +sys.path.insert(0, str(scripts_dir.absolute())) from util import flatc From a8c97e101baff2423083496a2644e8cc6d9a14aa Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Tue, 27 Sep 2022 18:59:21 +0300 Subject: [PATCH 24/29] fixes --- src/bfbs_gen_nim.cpp | 46 ++++++++++++-------------------------------- tests/nim/testnim.py | 2 +- 2 files changed, 13 insertions(+), 35 deletions(-) diff --git a/src/bfbs_gen_nim.cpp b/src/bfbs_gen_nim.cpp index 375819a7d37..b9239d3b55f 100644 --- a/src/bfbs_gen_nim.cpp +++ b/src/bfbs_gen_nim.cpp @@ -104,13 +104,14 @@ class NimBfbsGenerator : public BaseBfbsGenerator { }); ForAllObjects(schema->objects(), [&](const r::Object *object) { StartCodeBlock(object); - GenerateObject(object, schema->root_table()); + GenerateObject(object); }); return OK; } uint64_t SupportedAdvancedFeatures() const FLATBUFFERS_OVERRIDE { - return 0xF; + return r::AdvancedArrayFeatures | r::AdvancedUnionFeatures | + r::OptionalScalars | r::DefaultVectorsAndStrings; } protected: @@ -134,8 +135,7 @@ class NimBfbsGenerator : public BaseBfbsGenerator { EmitCodeBlock(code, enum_name, ns, enum_def->declaration_file()->str()); } - void GenerateObject(const r::Object *object, const r::Object *root_object) { - (void)root_object; + void GenerateObject(const r::Object *object) { // Register the main flatbuffers module. RegisterImports("flatbuffers", ""); std::string code; @@ -184,23 +184,18 @@ class NimBfbsGenerator : public BaseBfbsGenerator { if (object->is_struct()) { std::string field_getter = - ReplaceString(GenerateGetter(field->type()), "{offset}", - NumToString(field->offset())); + GenerateGetter(field->type(), NumToString(field->offset())); getter_code += " return " + field_getter + "\n"; - // TODO: parser opts: - // if (parser_.opts.m utable_buffer) { if (IsScalar(base_type)) { setter_code += " return self.tab.Mutate(self.tab.Pos + " + NumToString(field->offset()) + ", n)\n"; } - //} } else { // Table accessors getter_code += " " + offset_prefix; getter_code += " " + offset_prefix_2; - std::string field_getter = - ReplaceString(GenerateGetter(field->type()), "{offset}", "o"); + std::string field_getter = GenerateGetter(field->type(), "o"); if (field->optional()) { field_getter = "some(" + field_getter + ")"; } @@ -209,18 +204,13 @@ class NimBfbsGenerator : public BaseBfbsGenerator { getter_code += " return " + DefaultValue(field) + "\n"; } - // TODO: parser opts: - // if (parser_.opts.mutable_buffer) { if (IsScalar(base_type)) { setter_code += " return self.tab.MutateSlot(" + NumToString(field->offset()) + ", n)\n"; } - //} } code += getter_signature + getter_code; - // if (parser_.opts.mutable_buffer) { if (IsScalar(base_type)) { code += setter_signature + setter_code; } - //} } else if (base_type == r::Array || base_type == r::Vector) { const r::BaseType vector_base_type = field->type()->element(); int32_t element_size = field->type()->element_size(); @@ -245,10 +235,7 @@ class NimBfbsGenerator : public BaseBfbsGenerator { code += " var x = self.tab.Vector(o)\n"; code += " x += j.uoffset * " + NumToString(element_size) + ".uoffset\n"; - code += " return " + - ReplaceString(GenerateGetter(field->type(), true), "{offset}", - "x") + - "\n"; + code += " return " + GenerateGetter(field->type(), "x", true) + "\n"; // Get entire vector: code += "func " + namer_.Method(field_name) + "*(self: " + object_name + @@ -257,7 +244,7 @@ class NimBfbsGenerator : public BaseBfbsGenerator { code += " for i in countup(0, len - 1):\n"; code += " result.add(self." + field_name + "(i))\n"; - (void)IsSingleByte(vector_base_type); // Unused exception + (void)IsSingleByte(vector_base_type); // unnused function warning } }); @@ -372,20 +359,20 @@ class NimBfbsGenerator : public BaseBfbsGenerator { return ""; } - std::string GenerateGetter(const r::Type *type, + std::string GenerateGetter(const r::Type *type, const std::string &offsetval, bool element_type = false) const { const r::BaseType base_type = element_type ? type->element() : type->base_type(); - std::string offset = "{offset}"; + std::string offset = offsetval; if (!element_type) { offset = "self.tab.Pos + " + offset; } switch (base_type) { case r::String: return "self.tab.String(" + offset + ")"; - case r::Union: return "self.tab.Union({offset})"; + case r::Union: return "self.tab.Union(" + offsetval + ")"; case r::Obj: { return GenerateType(type, element_type) + "(tab: Vtable(Bytes: self.tab.Bytes, Pos: " + offset + "))"; } - case r::Vector: return GenerateGetter(type, true); + case r::Vector: return GenerateGetter(type, offsetval, true); default: const r::Enum *type_enum = GetEnum(type, element_type); if (type_enum != nullptr) { @@ -461,15 +448,6 @@ class NimBfbsGenerator : public BaseBfbsGenerator { } } - std::string ReplaceString(std::string subject, const std::string &search, - const std::string &replace) { - size_t pos = subject.find(search, 0); - if (pos != std::string::npos) { - subject.replace(pos, search.length(), replace); - } - return subject; - } - std::string GenerateType(const r::BaseType base_type) const { switch (base_type) { case r::None: return "uint8"; diff --git a/tests/nim/testnim.py b/tests/nim/testnim.py index 23545b60c0a..39de04096dc 100644 --- a/tests/nim/testnim.py +++ b/tests/nim/testnim.py @@ -9,7 +9,7 @@ test_dir = test_nim_dir.parent generated_dir = test_nim_dir / "generated" root_path = test_dir.parent -flatc_exe = Path("flatc.exe" if platform.system() == "Windows" else "flatc") +flatc_exe = Path("flatc.exe" if platform.system() == "Windows" else "flatc") flatc_path = root_path / flatc_exe assert flatc_path.exists(), "Cannot find the flatc compiler " + str(flatc_path) From 38eef94f8abe75ff562ca3cb9c344f74e9c0e179 Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Fri, 21 Oct 2022 11:23:53 +0300 Subject: [PATCH 25/29] Added reflection type Field, Variable to namer --- src/bfbs_gen_lua.cpp | 17 ++++++++--------- src/bfbs_gen_nim.cpp | 21 ++++++++++----------- src/namer.h | 8 ++++++++ 3 files changed, 26 insertions(+), 20 deletions(-) diff --git a/src/bfbs_gen_lua.cpp b/src/bfbs_gen_lua.cpp index 586f8ad5259..1d829c75871 100644 --- a/src/bfbs_gen_lua.cpp +++ b/src/bfbs_gen_lua.cpp @@ -175,7 +175,7 @@ class LuaBfbsGenerator : public BaseBfbsGenerator { // Skip writing deprecated fields altogether. if (field->deprecated()) { return; } - const std::string field_name = namer_.Field(field->name()->str()); + const std::string field_name = namer_.Field(*field); const r::BaseType base_type = field->type()->base_type(); // Generate some fixed strings so we don't repeat outselves later. @@ -367,9 +367,8 @@ class LuaBfbsGenerator : public BaseBfbsGenerator { ForAllFields(object, /*reverse=*/false, [&](const r::Field *field) { if (field->deprecated()) { return; } - const std::string field_name = namer_.Field(field->name()->str()); - const std::string variable_name = - namer_.Variable(field->name()->str()); + const std::string field_name = namer_.Field(*field); + const std::string variable_name = namer_.Variable(*field); code += "function " + object_name + ".Add" + field_name + "(builder, " + variable_name + ")\n"; @@ -428,9 +427,9 @@ class LuaBfbsGenerator : public BaseBfbsGenerator { if (IsStructOrTable(field->type()->base_type())) { const r::Object *field_object = GetObject(field->type()); signature += GenerateStructBuilderArgs( - field_object, prefix + namer_.Variable(field->name()->str()) + "_"); + field_object, prefix + namer_.Variable(*field) + "_"); } else { - signature += ", " + prefix + namer_.Variable(field->name()->str()); + signature += ", " + prefix + namer_.Variable(*field); } }); return signature; @@ -451,11 +450,11 @@ class LuaBfbsGenerator : public BaseBfbsGenerator { } if (IsStructOrTable(field->type()->base_type())) { const r::Object *field_object = GetObject(field->type()); - code += AppendStructBuilderBody( - field_object, prefix + namer_.Variable(field->name()->str()) + "_"); + code += AppendStructBuilderBody(field_object, + prefix + namer_.Variable(*field) + "_"); } else { code += " builder:Prepend" + GenerateMethod(field) + "(" + prefix + - namer_.Variable(field->name()->str()) + ")\n"; + namer_.Variable(*field) + ")\n"; } }); diff --git a/src/bfbs_gen_nim.cpp b/src/bfbs_gen_nim.cpp index b9239d3b55f..b74d148301e 100644 --- a/src/bfbs_gen_nim.cpp +++ b/src/bfbs_gen_nim.cpp @@ -151,7 +151,7 @@ class NimBfbsGenerator : public BaseBfbsGenerator { // Skip writing deprecated fields altogether. if (field->deprecated()) { return; } - const std::string field_name = namer_.Field(field->name()->str()); + const std::string field_name = namer_.Field(*field); const r::BaseType base_type = field->type()->base_type(); std::string field_type = GenerateType(field->type()); @@ -213,7 +213,7 @@ class NimBfbsGenerator : public BaseBfbsGenerator { if (IsScalar(base_type)) { code += setter_signature + setter_code; } } else if (base_type == r::Array || base_type == r::Vector) { const r::BaseType vector_base_type = field->type()->element(); - int32_t element_size = field->type()->element_size(); + uint32_t element_size = field->type()->element_size(); if (vector_base_type == r::Obj || vector_base_type == r::Union || field->type()->index() >= 0) { @@ -266,8 +266,8 @@ class NimBfbsGenerator : public BaseBfbsGenerator { ForAllFields(object, /*reverse=*/false, [&](const r::Field *field) { if (field->deprecated()) { return; } - const std::string field_name = namer_.Field(field->name()->str()); - const std::string variable_name = namer_.Variable(field->name()->str()); + const std::string field_name = namer_.Field(*field); + const std::string variable_name = namer_.Variable(*field); const std::string variable_type = GenerateTypeBasic(field->type()); code += "proc " + namer_.Function(object_name + "Add" + field_name) + @@ -318,10 +318,10 @@ class NimBfbsGenerator : public BaseBfbsGenerator { if (IsStructOrTable(field->type()->base_type())) { const r::Object *field_object = GetObject(field->type()); signature += GenerateStructBuilderArgs( - field_object, prefix + namer_.Variable(field->name()->str()) + "_"); + field_object, prefix + namer_.Variable(*field) + "_"); } else { - signature += ", " + prefix + namer_.Variable(field->name()->str()) + - ": " + GenerateType(field->type()); + signature += ", " + prefix + namer_.Variable(*field) + ": " + + GenerateType(field->type()); } }); return signature; @@ -342,11 +342,10 @@ class NimBfbsGenerator : public BaseBfbsGenerator { } if (IsStructOrTable(field->type()->base_type())) { const r::Object *field_object = GetObject(field->type()); - code += AppendStructBuilderBody( - field_object, prefix + namer_.Variable(field->name()->str()) + "_"); + code += AppendStructBuilderBody(field_object, + prefix + namer_.Variable(*field) + "_"); } else { - code += " self.Prepend(" + prefix + - namer_.Variable(field->name()->str()) + ")\n"; + code += " self.Prepend(" + prefix + namer_.Variable(*field) + ")\n"; } }); diff --git a/src/namer.h b/src/namer.h index 8fd8354e1a7..deedd2e30a9 100644 --- a/src/namer.h +++ b/src/namer.h @@ -139,6 +139,10 @@ class Namer { return Format(s, config_.variables); } + virtual std::string Variable(const ::reflection::Field &f) const { + return Variable(f.name()->str()); + } + template std::string Variable(const std::string &p, const T &s) const { return Format(p + "_" + s.name, config_.variables); @@ -223,6 +227,10 @@ class Namer { return Format(s, config_.fields); } + virtual std::string Field(const ::reflection::Field &f) const { + return Field(f.name()->str()); + } + virtual std::string Variant(const std::string &s) const { return Format(s, config_.variants); } From aa3fd9eb16e5251cdb10559dcb8d2ed54615e1f9 Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Fri, 21 Oct 2022 16:30:25 +0300 Subject: [PATCH 26/29] Moved reflection namer impl to bfbsnamer --- src/bfbs_namer.h | 10 +++++++++- src/namer.h | 8 -------- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/src/bfbs_namer.h b/src/bfbs_namer.h index 2c6e724ab61..d197574cf71 100644 --- a/src/bfbs_namer.h +++ b/src/bfbs_namer.h @@ -36,8 +36,16 @@ class BfbsNamer : public Namer { std::string Denamespace(T t, const char delimiter = '.') const { return Namer::Denamespace(t->name()->c_str(), delimiter); } + + virtual std::string Field(const ::reflection::Field &f) const { + return Field(f.name()->str()); + } + + virtual std::string Variable(const ::reflection::Field &f) const { + return Variable(f.name()->str()); + } }; } // namespace flatbuffers -#endif // FLATBUFFERS_BFBS_NAMER \ No newline at end of file +#endif // FLATBUFFERS_BFBS_NAMER diff --git a/src/namer.h b/src/namer.h index deedd2e30a9..8fd8354e1a7 100644 --- a/src/namer.h +++ b/src/namer.h @@ -139,10 +139,6 @@ class Namer { return Format(s, config_.variables); } - virtual std::string Variable(const ::reflection::Field &f) const { - return Variable(f.name()->str()); - } - template std::string Variable(const std::string &p, const T &s) const { return Format(p + "_" + s.name, config_.variables); @@ -227,10 +223,6 @@ class Namer { return Format(s, config_.fields); } - virtual std::string Field(const ::reflection::Field &f) const { - return Field(f.name()->str()); - } - virtual std::string Variant(const std::string &s) const { return Format(s, config_.variants); } From 368fd21f8564d1d7247054566156a7730783a35a Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Fri, 21 Oct 2022 16:32:31 +0300 Subject: [PATCH 27/29] Remove whitespace at end of line --- src/bfbs_namer.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/bfbs_namer.h b/src/bfbs_namer.h index d197574cf71..ef6c6c5d861 100644 --- a/src/bfbs_namer.h +++ b/src/bfbs_namer.h @@ -48,4 +48,4 @@ class BfbsNamer : public Namer { } // namespace flatbuffers -#endif // FLATBUFFERS_BFBS_NAMER +#endif // FLATBUFFERS_BFBS_NAMER \ No newline at end of file From 39aeae11b79fd5e1046713d7e48be86b9c1f22ef Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Fri, 21 Oct 2022 16:57:39 +0300 Subject: [PATCH 28/29] Added nim to generated code --- scripts/generate_code.py | 11 +- tests/Abc.nim | 13 + tests/MoreDefaults.nim | 103 +++ tests/MyGame/Example/Ability.nim | 26 + tests/MyGame/Example/Any.nim | 15 + tests/MyGame/Example/AnyAmbiguousAliases.nim | 15 + tests/MyGame/Example/AnyUniqueAliases.nim | 15 + tests/MyGame/Example/Color.nim | 18 + tests/MyGame/Example/LongEnum.nim | 14 + tests/MyGame/Example/Monster.nim | 662 ++++++++++++++++++ tests/MyGame/Example/Race.nim | 15 + tests/MyGame/Example/Referrable.nim | 26 + tests/MyGame/Example/Stat.nim | 42 ++ tests/MyGame/Example/StructOfStructs.nim | 34 + .../Example/StructOfStructsOfStructs.nim | 30 + tests/MyGame/Example/Test.nim | 27 + .../Example/TestSimpleTableWithEnum.nim | 27 + tests/MyGame/Example/TypeAliases.nim | 144 ++++ tests/MyGame/Example/Vec3.nim | 52 ++ tests/MyGame/Example2/Monster.nim | 17 + tests/MyGame/InParentNamespace.nim | 17 + tests/MyGame/OtherNameSpace/FromInclude.nim | 12 + tests/MyGame/OtherNameSpace/TableB.nim | 25 + tests/MyGame/OtherNameSpace/Unused.nim | 21 + tests/Property.nim | 20 + tests/TableA.nim | 25 + tests/TestMutatingBool.nim | 24 + tests/nim/testnim.py | 72 -- tests/nim/tests/moredefaults/test.nim | 2 +- tests/nim/tests/mutatingbool/test.nim | 4 +- tests/nim/tests/mygame/test.nim | 10 +- tests/nim/tests/optional_scalars/test.nim | 2 +- tests/optional_scalars/OptionalByte.nim | 14 + tests/optional_scalars/ScalarStuff.nim | 331 +++++++++ 34 files changed, 1802 insertions(+), 83 deletions(-) create mode 100644 tests/Abc.nim create mode 100644 tests/MoreDefaults.nim create mode 100644 tests/MyGame/Example/Ability.nim create mode 100644 tests/MyGame/Example/Any.nim create mode 100644 tests/MyGame/Example/AnyAmbiguousAliases.nim create mode 100644 tests/MyGame/Example/AnyUniqueAliases.nim create mode 100644 tests/MyGame/Example/Color.nim create mode 100644 tests/MyGame/Example/LongEnum.nim create mode 100644 tests/MyGame/Example/Monster.nim create mode 100644 tests/MyGame/Example/Race.nim create mode 100644 tests/MyGame/Example/Referrable.nim create mode 100644 tests/MyGame/Example/Stat.nim create mode 100644 tests/MyGame/Example/StructOfStructs.nim create mode 100644 tests/MyGame/Example/StructOfStructsOfStructs.nim create mode 100644 tests/MyGame/Example/Test.nim create mode 100644 tests/MyGame/Example/TestSimpleTableWithEnum.nim create mode 100644 tests/MyGame/Example/TypeAliases.nim create mode 100644 tests/MyGame/Example/Vec3.nim create mode 100644 tests/MyGame/Example2/Monster.nim create mode 100644 tests/MyGame/InParentNamespace.nim create mode 100644 tests/MyGame/OtherNameSpace/FromInclude.nim create mode 100644 tests/MyGame/OtherNameSpace/TableB.nim create mode 100644 tests/MyGame/OtherNameSpace/Unused.nim create mode 100644 tests/Property.nim create mode 100644 tests/TableA.nim create mode 100644 tests/TestMutatingBool.nim create mode 100644 tests/optional_scalars/OptionalByte.nim create mode 100644 tests/optional_scalars/ScalarStuff.nim diff --git a/scripts/generate_code.py b/scripts/generate_code.py index 7111d8d313c..44eaeb997bf 100755 --- a/scripts/generate_code.py +++ b/scripts/generate_code.py @@ -305,8 +305,8 @@ def glob(path, pattern): # Generate the annotated binary of the monster_test binary schema. flatc_annotate( - schema="../reflection/reflection.fbs", - file="monster_test.bfbs", + schema="../reflection/reflection.fbs", + file="monster_test.bfbs", include="include_test" ) @@ -449,6 +449,13 @@ def glob(path, pattern): cwd=swift_code_gen ) +# Nim Tests +NIM_OPTS = BASE_OPTS + ["--nim"] +flatc(NIM_OPTS, schema="monster_test.fbs", include="include_test") +flatc(NIM_OPTS, schema="optional_scalars.fbs") +flatc(NIM_OPTS, schema="more_defaults.fbs") +flatc(NIM_OPTS, schema="MutatingBool.fbs") + # --filename-suffix and --filename-ext tests flatc( CPP_OPTS + NO_INCL_OPTS + ["--grpc", "--filename-ext", "hpp"], diff --git a/tests/Abc.nim b/tests/Abc.nim new file mode 100644 index 00000000000..1e3117cfaee --- /dev/null +++ b/tests/Abc.nim @@ -0,0 +1,13 @@ +#[ Abc + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : +]# + +type Abc*{.pure.} = enum + A = 0.int32, + B = 1.int32, + C = 2.int32, diff --git a/tests/MoreDefaults.nim b/tests/MoreDefaults.nim new file mode 100644 index 00000000000..22769ff9cf7 --- /dev/null +++ b/tests/MoreDefaults.nim @@ -0,0 +1,103 @@ +#[ MoreDefaults + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : +]# + +import Abc as Abc +import flatbuffers + +type MoreDefaults* = object of FlatObj +func intsLength*(self: MoreDefaults): int = + let o = self.tab.Offset(4) + if o != 0: + return self.tab.VectorLen(o) +func ints*(self: MoreDefaults, j: int): int32 = + let o = self.tab.Offset(4) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 4.uoffset + return Get[int32](self.tab, x) +func ints*(self: MoreDefaults): seq[int32] = + let len = self.intsLength + for i in countup(0, len - 1): + result.add(self.ints(i)) +func floatsLength*(self: MoreDefaults): int = + let o = self.tab.Offset(6) + if o != 0: + return self.tab.VectorLen(o) +func floats*(self: MoreDefaults, j: int): float32 = + let o = self.tab.Offset(6) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 4.uoffset + return Get[float32](self.tab, x) +func floats*(self: MoreDefaults): seq[float32] = + let len = self.floatsLength + for i in countup(0, len - 1): + result.add(self.floats(i)) +func emptyString*(self: MoreDefaults): string = + let o = self.tab.Offset(8) + if o != 0: + return self.tab.String(self.tab.Pos + o) + return "" +func someString*(self: MoreDefaults): string = + let o = self.tab.Offset(10) + if o != 0: + return self.tab.String(self.tab.Pos + o) + return "" +func abcsLength*(self: MoreDefaults): int = + let o = self.tab.Offset(12) + if o != 0: + return self.tab.VectorLen(o) +func abcs*(self: MoreDefaults, j: int): Abc.Abc = + let o = self.tab.Offset(12) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 4.uoffset + return Abc.Abc(Get[int32](self.tab, x)) +func abcs*(self: MoreDefaults): seq[Abc.Abc] = + let len = self.abcsLength + for i in countup(0, len - 1): + result.add(self.abcs(i)) +func boolsLength*(self: MoreDefaults): int = + let o = self.tab.Offset(14) + if o != 0: + return self.tab.VectorLen(o) +func bools*(self: MoreDefaults, j: int): bool = + let o = self.tab.Offset(14) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 1.uoffset + return Get[bool](self.tab, x) +func bools*(self: MoreDefaults): seq[bool] = + let len = self.boolsLength + for i in countup(0, len - 1): + result.add(self.bools(i)) +proc MoreDefaultsStart*(builder: var Builder) = + builder.StartObject(6) +proc MoreDefaultsAddints*(builder: var Builder, ints: uoffset) = + builder.PrependSlot(0, ints, default(uoffset)) +proc MoreDefaultsStartintsVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(4, numElems, 4) +proc MoreDefaultsAddfloats*(builder: var Builder, floats: uoffset) = + builder.PrependSlot(1, floats, default(uoffset)) +proc MoreDefaultsStartfloatsVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(4, numElems, 4) +proc MoreDefaultsAddemptyString*(builder: var Builder, emptyString: uoffset) = + builder.PrependSlot(2, emptyString, default(uoffset)) +proc MoreDefaultsAddsomeString*(builder: var Builder, someString: uoffset) = + builder.PrependSlot(3, someString, default(uoffset)) +proc MoreDefaultsAddabcs*(builder: var Builder, abcs: uoffset) = + builder.PrependSlot(4, abcs, default(uoffset)) +proc MoreDefaultsStartabcsVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(4, numElems, 4) +proc MoreDefaultsAddbools*(builder: var Builder, bools: uoffset) = + builder.PrependSlot(5, bools, default(uoffset)) +proc MoreDefaultsStartboolsVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(1, numElems, 1) +proc MoreDefaultsEnd*(builder: var Builder): uoffset = + return builder.EndObject() diff --git a/tests/MyGame/Example/Ability.nim b/tests/MyGame/Example/Ability.nim new file mode 100644 index 00000000000..46a09df03b5 --- /dev/null +++ b/tests/MyGame/Example/Ability.nim @@ -0,0 +1,26 @@ +#[ MyGame.Example.Ability + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +import flatbuffers + +type Ability* = object of FlatObj +func id*(self: Ability): uint32 = + return Get[uint32](self.tab, self.tab.Pos + 0) +func `id=`*(self: var Ability, n: uint32): bool = + return self.tab.Mutate(self.tab.Pos + 0, n) +func distance*(self: Ability): uint32 = + return Get[uint32](self.tab, self.tab.Pos + 4) +func `distance=`*(self: var Ability, n: uint32): bool = + return self.tab.Mutate(self.tab.Pos + 4, n) +proc AbilityCreate*(self: var Builder, id: uint32, distance: uint32): uoffset = + self.Prep(4, 8) + self.Prepend(distance) + self.Prepend(id) + return self.Offset() diff --git a/tests/MyGame/Example/Any.nim b/tests/MyGame/Example/Any.nim new file mode 100644 index 00000000000..1ca9da976a8 --- /dev/null +++ b/tests/MyGame/Example/Any.nim @@ -0,0 +1,15 @@ +#[ MyGame.Example.Any + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +type Any*{.pure.} = enum + None = 0.uint8, + Monster = 1.uint8, + TestSimpleTableWithEnum = 2.uint8, + MyGameExample2Monster = 3.uint8, diff --git a/tests/MyGame/Example/AnyAmbiguousAliases.nim b/tests/MyGame/Example/AnyAmbiguousAliases.nim new file mode 100644 index 00000000000..895286d9d26 --- /dev/null +++ b/tests/MyGame/Example/AnyAmbiguousAliases.nim @@ -0,0 +1,15 @@ +#[ MyGame.Example.AnyAmbiguousAliases + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +type AnyAmbiguousAliases*{.pure.} = enum + None = 0.uint8, + M1 = 1.uint8, + M2 = 2.uint8, + M3 = 3.uint8, diff --git a/tests/MyGame/Example/AnyUniqueAliases.nim b/tests/MyGame/Example/AnyUniqueAliases.nim new file mode 100644 index 00000000000..6d904667788 --- /dev/null +++ b/tests/MyGame/Example/AnyUniqueAliases.nim @@ -0,0 +1,15 @@ +#[ MyGame.Example.AnyUniqueAliases + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +type AnyUniqueAliases*{.pure.} = enum + None = 0.uint8, + M = 1.uint8, + Ts = 2.uint8, + M2 = 3.uint8, diff --git a/tests/MyGame/Example/Color.nim b/tests/MyGame/Example/Color.nim new file mode 100644 index 00000000000..e51f2117c88 --- /dev/null +++ b/tests/MyGame/Example/Color.nim @@ -0,0 +1,18 @@ +#[ MyGame.Example.Color + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +# Composite components of Monster color. +type Color*{.pure.} = enum + Red = 1.uint8, + # \brief color Green + # Green is bit_flag with value (1u << 1) + Green = 2.uint8, + # \brief color Blue (1u << 3) + Blue = 8.uint8, diff --git a/tests/MyGame/Example/LongEnum.nim b/tests/MyGame/Example/LongEnum.nim new file mode 100644 index 00000000000..4fa2b5b39a2 --- /dev/null +++ b/tests/MyGame/Example/LongEnum.nim @@ -0,0 +1,14 @@ +#[ MyGame.Example.LongEnum + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +type LongEnum*{.pure.} = enum + LongOne = 2.uint64, + LongTwo = 4.uint64, + LongBig = 1099511627776.uint64, diff --git a/tests/MyGame/Example/Monster.nim b/tests/MyGame/Example/Monster.nim new file mode 100644 index 00000000000..7c4cb6f2ddb --- /dev/null +++ b/tests/MyGame/Example/Monster.nim @@ -0,0 +1,662 @@ +#[ MyGame.Example.Monster + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +import ../InParentNamespace as MyGame_InParentNamespace +import Ability as MyGame_Example_Ability +import Any as MyGame_Example_Any +import AnyAmbiguousAliases as MyGame_Example_AnyAmbiguousAliases +import AnyUniqueAliases as MyGame_Example_AnyUniqueAliases +import Color as MyGame_Example_Color +import LongEnum as MyGame_Example_LongEnum +import Race as MyGame_Example_Race +import Referrable as MyGame_Example_Referrable +import Stat as MyGame_Example_Stat +import Test as MyGame_Example_Test +import Vec3 as MyGame_Example_Vec3 +import flatbuffers +import std/options + +# an example documentation comment: "monster object" +type Monster* = object of FlatObj +func pos*(self: Monster): Option[MyGame_Example_Vec3.Vec3] = + let o = self.tab.Offset(4) + if o != 0: + return some(MyGame_Example_Vec3.Vec3(tab: Vtable(Bytes: self.tab.Bytes, Pos: self.tab.Pos + o))) +func mana*(self: Monster): int16 = + let o = self.tab.Offset(6) + if o != 0: + return Get[int16](self.tab, self.tab.Pos + o) + return 150 +func `mana=`*(self: var Monster, n: int16): bool = + return self.tab.MutateSlot(6, n) +func hp*(self: Monster): int16 = + let o = self.tab.Offset(8) + if o != 0: + return Get[int16](self.tab, self.tab.Pos + o) + return 100 +func `hp=`*(self: var Monster, n: int16): bool = + return self.tab.MutateSlot(8, n) +func name*(self: Monster): string = + let o = self.tab.Offset(10) + if o != 0: + return self.tab.String(self.tab.Pos + o) + return "" +func inventoryLength*(self: Monster): int = + let o = self.tab.Offset(14) + if o != 0: + return self.tab.VectorLen(o) +func inventory*(self: Monster, j: int): uint8 = + let o = self.tab.Offset(14) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 1.uoffset + return Get[uint8](self.tab, x) +func inventory*(self: Monster): seq[uint8] = + let len = self.inventoryLength + for i in countup(0, len - 1): + result.add(self.inventory(i)) +func color*(self: Monster): MyGame_Example_Color.Color = + let o = self.tab.Offset(16) + if o != 0: + return MyGame_Example_Color.Color(Get[uint8](self.tab, self.tab.Pos + o)) + return type(result)(8) +func `color=`*(self: var Monster, n: MyGame_Example_Color.Color): bool = + return self.tab.MutateSlot(16, n) +func testType*(self: Monster): MyGame_Example_Any.Any = + let o = self.tab.Offset(18) + if o != 0: + return MyGame_Example_Any.Any(Get[uint8](self.tab, self.tab.Pos + o)) + return type(result)(0) +func `testType=`*(self: var Monster, n: MyGame_Example_Any.Any): bool = + return self.tab.MutateSlot(18, n) +func test*(self: Monster): Option[Vtable] = + let o = self.tab.Offset(20) + if o != 0: + return some(self.tab.Union(o)) +func test4Length*(self: Monster): int = + let o = self.tab.Offset(22) + if o != 0: + return self.tab.VectorLen(o) +func test4*(self: Monster, j: int): MyGame_Example_Test.Test = + let o = self.tab.Offset(22) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 4.uoffset + return MyGame_Example_Test.Test(tab: Vtable(Bytes: self.tab.Bytes, Pos: x)) +func test4*(self: Monster): seq[MyGame_Example_Test.Test] = + let len = self.test4Length + for i in countup(0, len - 1): + result.add(self.test4(i)) +func testarrayofstringLength*(self: Monster): int = + let o = self.tab.Offset(24) + if o != 0: + return self.tab.VectorLen(o) +func testarrayofstring*(self: Monster, j: int): string = + let o = self.tab.Offset(24) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 4.uoffset + return self.tab.String(x) +func testarrayofstring*(self: Monster): seq[string] = + let len = self.testarrayofstringLength + for i in countup(0, len - 1): + result.add(self.testarrayofstring(i)) +func testarrayoftablesLength*(self: Monster): int = + let o = self.tab.Offset(26) + if o != 0: + return self.tab.VectorLen(o) +func testarrayoftables*(self: Monster, j: int): Monster = + let o = self.tab.Offset(26) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 4.uoffset + return Monster(tab: Vtable(Bytes: self.tab.Bytes, Pos: x)) +func testarrayoftables*(self: Monster): seq[Monster] = + let len = self.testarrayoftablesLength + for i in countup(0, len - 1): + result.add(self.testarrayoftables(i)) +func enemy*(self: Monster): Option[Monster] = + let o = self.tab.Offset(28) + if o != 0: + return some(Monster(tab: Vtable(Bytes: self.tab.Bytes, Pos: self.tab.Pos + o))) +func testnestedflatbufferLength*(self: Monster): int = + let o = self.tab.Offset(30) + if o != 0: + return self.tab.VectorLen(o) +func testnestedflatbuffer*(self: Monster, j: int): uint8 = + let o = self.tab.Offset(30) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 1.uoffset + return Get[uint8](self.tab, x) +func testnestedflatbuffer*(self: Monster): seq[uint8] = + let len = self.testnestedflatbufferLength + for i in countup(0, len - 1): + result.add(self.testnestedflatbuffer(i)) +func testempty*(self: Monster): Option[MyGame_Example_Stat.Stat] = + let o = self.tab.Offset(32) + if o != 0: + return some(MyGame_Example_Stat.Stat(tab: Vtable(Bytes: self.tab.Bytes, Pos: self.tab.Pos + o))) +func testbool*(self: Monster): bool = + let o = self.tab.Offset(34) + if o != 0: + return Get[bool](self.tab, self.tab.Pos + o) + return false +func `testbool=`*(self: var Monster, n: bool): bool = + return self.tab.MutateSlot(34, n) +func testhashs32Fnv1*(self: Monster): int32 = + let o = self.tab.Offset(36) + if o != 0: + return Get[int32](self.tab, self.tab.Pos + o) + return 0 +func `testhashs32Fnv1=`*(self: var Monster, n: int32): bool = + return self.tab.MutateSlot(36, n) +func testhashu32Fnv1*(self: Monster): uint32 = + let o = self.tab.Offset(38) + if o != 0: + return Get[uint32](self.tab, self.tab.Pos + o) + return 0 +func `testhashu32Fnv1=`*(self: var Monster, n: uint32): bool = + return self.tab.MutateSlot(38, n) +func testhashs64Fnv1*(self: Monster): int64 = + let o = self.tab.Offset(40) + if o != 0: + return Get[int64](self.tab, self.tab.Pos + o) + return 0 +func `testhashs64Fnv1=`*(self: var Monster, n: int64): bool = + return self.tab.MutateSlot(40, n) +func testhashu64Fnv1*(self: Monster): uint64 = + let o = self.tab.Offset(42) + if o != 0: + return Get[uint64](self.tab, self.tab.Pos + o) + return 0 +func `testhashu64Fnv1=`*(self: var Monster, n: uint64): bool = + return self.tab.MutateSlot(42, n) +func testhashs32Fnv1a*(self: Monster): int32 = + let o = self.tab.Offset(44) + if o != 0: + return Get[int32](self.tab, self.tab.Pos + o) + return 0 +func `testhashs32Fnv1a=`*(self: var Monster, n: int32): bool = + return self.tab.MutateSlot(44, n) +func testhashu32Fnv1a*(self: Monster): uint32 = + let o = self.tab.Offset(46) + if o != 0: + return Get[uint32](self.tab, self.tab.Pos + o) + return 0 +func `testhashu32Fnv1a=`*(self: var Monster, n: uint32): bool = + return self.tab.MutateSlot(46, n) +func testhashs64Fnv1a*(self: Monster): int64 = + let o = self.tab.Offset(48) + if o != 0: + return Get[int64](self.tab, self.tab.Pos + o) + return 0 +func `testhashs64Fnv1a=`*(self: var Monster, n: int64): bool = + return self.tab.MutateSlot(48, n) +func testhashu64Fnv1a*(self: Monster): uint64 = + let o = self.tab.Offset(50) + if o != 0: + return Get[uint64](self.tab, self.tab.Pos + o) + return 0 +func `testhashu64Fnv1a=`*(self: var Monster, n: uint64): bool = + return self.tab.MutateSlot(50, n) +func testarrayofboolsLength*(self: Monster): int = + let o = self.tab.Offset(52) + if o != 0: + return self.tab.VectorLen(o) +func testarrayofbools*(self: Monster, j: int): bool = + let o = self.tab.Offset(52) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 1.uoffset + return Get[bool](self.tab, x) +func testarrayofbools*(self: Monster): seq[bool] = + let len = self.testarrayofboolsLength + for i in countup(0, len - 1): + result.add(self.testarrayofbools(i)) +func testf*(self: Monster): float32 = + let o = self.tab.Offset(54) + if o != 0: + return Get[float32](self.tab, self.tab.Pos + o) + return 3.14159 +func `testf=`*(self: var Monster, n: float32): bool = + return self.tab.MutateSlot(54, n) +func testf2*(self: Monster): float32 = + let o = self.tab.Offset(56) + if o != 0: + return Get[float32](self.tab, self.tab.Pos + o) + return 3.0 +func `testf2=`*(self: var Monster, n: float32): bool = + return self.tab.MutateSlot(56, n) +func testf3*(self: Monster): float32 = + let o = self.tab.Offset(58) + if o != 0: + return Get[float32](self.tab, self.tab.Pos + o) + return 0.0 +func `testf3=`*(self: var Monster, n: float32): bool = + return self.tab.MutateSlot(58, n) +func testarrayofstring2Length*(self: Monster): int = + let o = self.tab.Offset(60) + if o != 0: + return self.tab.VectorLen(o) +func testarrayofstring2*(self: Monster, j: int): string = + let o = self.tab.Offset(60) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 4.uoffset + return self.tab.String(x) +func testarrayofstring2*(self: Monster): seq[string] = + let len = self.testarrayofstring2Length + for i in countup(0, len - 1): + result.add(self.testarrayofstring2(i)) +func testarrayofsortedstructLength*(self: Monster): int = + let o = self.tab.Offset(62) + if o != 0: + return self.tab.VectorLen(o) +func testarrayofsortedstruct*(self: Monster, j: int): MyGame_Example_Ability.Ability = + let o = self.tab.Offset(62) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 8.uoffset + return MyGame_Example_Ability.Ability(tab: Vtable(Bytes: self.tab.Bytes, Pos: x)) +func testarrayofsortedstruct*(self: Monster): seq[MyGame_Example_Ability.Ability] = + let len = self.testarrayofsortedstructLength + for i in countup(0, len - 1): + result.add(self.testarrayofsortedstruct(i)) +func flexLength*(self: Monster): int = + let o = self.tab.Offset(64) + if o != 0: + return self.tab.VectorLen(o) +func flex*(self: Monster, j: int): uint8 = + let o = self.tab.Offset(64) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 1.uoffset + return Get[uint8](self.tab, x) +func flex*(self: Monster): seq[uint8] = + let len = self.flexLength + for i in countup(0, len - 1): + result.add(self.flex(i)) +func test5Length*(self: Monster): int = + let o = self.tab.Offset(66) + if o != 0: + return self.tab.VectorLen(o) +func test5*(self: Monster, j: int): MyGame_Example_Test.Test = + let o = self.tab.Offset(66) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 4.uoffset + return MyGame_Example_Test.Test(tab: Vtable(Bytes: self.tab.Bytes, Pos: x)) +func test5*(self: Monster): seq[MyGame_Example_Test.Test] = + let len = self.test5Length + for i in countup(0, len - 1): + result.add(self.test5(i)) +func vectorOfLongsLength*(self: Monster): int = + let o = self.tab.Offset(68) + if o != 0: + return self.tab.VectorLen(o) +func vectorOfLongs*(self: Monster, j: int): int64 = + let o = self.tab.Offset(68) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 8.uoffset + return Get[int64](self.tab, x) +func vectorOfLongs*(self: Monster): seq[int64] = + let len = self.vectorOfLongsLength + for i in countup(0, len - 1): + result.add(self.vectorOfLongs(i)) +func vectorOfDoublesLength*(self: Monster): int = + let o = self.tab.Offset(70) + if o != 0: + return self.tab.VectorLen(o) +func vectorOfDoubles*(self: Monster, j: int): float64 = + let o = self.tab.Offset(70) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 8.uoffset + return Get[float64](self.tab, x) +func vectorOfDoubles*(self: Monster): seq[float64] = + let len = self.vectorOfDoublesLength + for i in countup(0, len - 1): + result.add(self.vectorOfDoubles(i)) +func parentNamespaceTest*(self: Monster): Option[MyGame_InParentNamespace.InParentNamespace] = + let o = self.tab.Offset(72) + if o != 0: + return some(MyGame_InParentNamespace.InParentNamespace(tab: Vtable(Bytes: self.tab.Bytes, Pos: self.tab.Pos + o))) +func vectorOfReferrablesLength*(self: Monster): int = + let o = self.tab.Offset(74) + if o != 0: + return self.tab.VectorLen(o) +func vectorOfReferrables*(self: Monster, j: int): MyGame_Example_Referrable.Referrable = + let o = self.tab.Offset(74) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 4.uoffset + return MyGame_Example_Referrable.Referrable(tab: Vtable(Bytes: self.tab.Bytes, Pos: x)) +func vectorOfReferrables*(self: Monster): seq[MyGame_Example_Referrable.Referrable] = + let len = self.vectorOfReferrablesLength + for i in countup(0, len - 1): + result.add(self.vectorOfReferrables(i)) +func singleWeakReference*(self: Monster): uint64 = + let o = self.tab.Offset(76) + if o != 0: + return Get[uint64](self.tab, self.tab.Pos + o) + return 0 +func `singleWeakReference=`*(self: var Monster, n: uint64): bool = + return self.tab.MutateSlot(76, n) +func vectorOfWeakReferencesLength*(self: Monster): int = + let o = self.tab.Offset(78) + if o != 0: + return self.tab.VectorLen(o) +func vectorOfWeakReferences*(self: Monster, j: int): uint64 = + let o = self.tab.Offset(78) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 8.uoffset + return Get[uint64](self.tab, x) +func vectorOfWeakReferences*(self: Monster): seq[uint64] = + let len = self.vectorOfWeakReferencesLength + for i in countup(0, len - 1): + result.add(self.vectorOfWeakReferences(i)) +func vectorOfStrongReferrablesLength*(self: Monster): int = + let o = self.tab.Offset(80) + if o != 0: + return self.tab.VectorLen(o) +func vectorOfStrongReferrables*(self: Monster, j: int): MyGame_Example_Referrable.Referrable = + let o = self.tab.Offset(80) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 4.uoffset + return MyGame_Example_Referrable.Referrable(tab: Vtable(Bytes: self.tab.Bytes, Pos: x)) +func vectorOfStrongReferrables*(self: Monster): seq[MyGame_Example_Referrable.Referrable] = + let len = self.vectorOfStrongReferrablesLength + for i in countup(0, len - 1): + result.add(self.vectorOfStrongReferrables(i)) +func coOwningReference*(self: Monster): uint64 = + let o = self.tab.Offset(82) + if o != 0: + return Get[uint64](self.tab, self.tab.Pos + o) + return 0 +func `coOwningReference=`*(self: var Monster, n: uint64): bool = + return self.tab.MutateSlot(82, n) +func vectorOfCoOwningReferencesLength*(self: Monster): int = + let o = self.tab.Offset(84) + if o != 0: + return self.tab.VectorLen(o) +func vectorOfCoOwningReferences*(self: Monster, j: int): uint64 = + let o = self.tab.Offset(84) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 8.uoffset + return Get[uint64](self.tab, x) +func vectorOfCoOwningReferences*(self: Monster): seq[uint64] = + let len = self.vectorOfCoOwningReferencesLength + for i in countup(0, len - 1): + result.add(self.vectorOfCoOwningReferences(i)) +func nonOwningReference*(self: Monster): uint64 = + let o = self.tab.Offset(86) + if o != 0: + return Get[uint64](self.tab, self.tab.Pos + o) + return 0 +func `nonOwningReference=`*(self: var Monster, n: uint64): bool = + return self.tab.MutateSlot(86, n) +func vectorOfNonOwningReferencesLength*(self: Monster): int = + let o = self.tab.Offset(88) + if o != 0: + return self.tab.VectorLen(o) +func vectorOfNonOwningReferences*(self: Monster, j: int): uint64 = + let o = self.tab.Offset(88) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 8.uoffset + return Get[uint64](self.tab, x) +func vectorOfNonOwningReferences*(self: Monster): seq[uint64] = + let len = self.vectorOfNonOwningReferencesLength + for i in countup(0, len - 1): + result.add(self.vectorOfNonOwningReferences(i)) +func anyUniqueType*(self: Monster): MyGame_Example_AnyUniqueAliases.AnyUniqueAliases = + let o = self.tab.Offset(90) + if o != 0: + return MyGame_Example_AnyUniqueAliases.AnyUniqueAliases(Get[uint8](self.tab, self.tab.Pos + o)) + return type(result)(0) +func `anyUniqueType=`*(self: var Monster, n: MyGame_Example_AnyUniqueAliases.AnyUniqueAliases): bool = + return self.tab.MutateSlot(90, n) +func anyUnique*(self: Monster): Option[Vtable] = + let o = self.tab.Offset(92) + if o != 0: + return some(self.tab.Union(o)) +func anyAmbiguousType*(self: Monster): MyGame_Example_AnyAmbiguousAliases.AnyAmbiguousAliases = + let o = self.tab.Offset(94) + if o != 0: + return MyGame_Example_AnyAmbiguousAliases.AnyAmbiguousAliases(Get[uint8](self.tab, self.tab.Pos + o)) + return type(result)(0) +func `anyAmbiguousType=`*(self: var Monster, n: MyGame_Example_AnyAmbiguousAliases.AnyAmbiguousAliases): bool = + return self.tab.MutateSlot(94, n) +func anyAmbiguous*(self: Monster): Option[Vtable] = + let o = self.tab.Offset(96) + if o != 0: + return some(self.tab.Union(o)) +func vectorOfEnumsLength*(self: Monster): int = + let o = self.tab.Offset(98) + if o != 0: + return self.tab.VectorLen(o) +func vectorOfEnums*(self: Monster, j: int): MyGame_Example_Color.Color = + let o = self.tab.Offset(98) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 1.uoffset + return MyGame_Example_Color.Color(Get[uint8](self.tab, x)) +func vectorOfEnums*(self: Monster): seq[MyGame_Example_Color.Color] = + let len = self.vectorOfEnumsLength + for i in countup(0, len - 1): + result.add(self.vectorOfEnums(i)) +func signedEnum*(self: Monster): MyGame_Example_Race.Race = + let o = self.tab.Offset(100) + if o != 0: + return MyGame_Example_Race.Race(Get[int8](self.tab, self.tab.Pos + o)) + return type(result)(-1) +func `signedEnum=`*(self: var Monster, n: MyGame_Example_Race.Race): bool = + return self.tab.MutateSlot(100, n) +func testrequirednestedflatbufferLength*(self: Monster): int = + let o = self.tab.Offset(102) + if o != 0: + return self.tab.VectorLen(o) +func testrequirednestedflatbuffer*(self: Monster, j: int): uint8 = + let o = self.tab.Offset(102) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 1.uoffset + return Get[uint8](self.tab, x) +func testrequirednestedflatbuffer*(self: Monster): seq[uint8] = + let len = self.testrequirednestedflatbufferLength + for i in countup(0, len - 1): + result.add(self.testrequirednestedflatbuffer(i)) +func scalarKeySortedTablesLength*(self: Monster): int = + let o = self.tab.Offset(104) + if o != 0: + return self.tab.VectorLen(o) +func scalarKeySortedTables*(self: Monster, j: int): MyGame_Example_Stat.Stat = + let o = self.tab.Offset(104) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 4.uoffset + return MyGame_Example_Stat.Stat(tab: Vtable(Bytes: self.tab.Bytes, Pos: x)) +func scalarKeySortedTables*(self: Monster): seq[MyGame_Example_Stat.Stat] = + let len = self.scalarKeySortedTablesLength + for i in countup(0, len - 1): + result.add(self.scalarKeySortedTables(i)) +func nativeInline*(self: Monster): Option[MyGame_Example_Test.Test] = + let o = self.tab.Offset(106) + if o != 0: + return some(MyGame_Example_Test.Test(tab: Vtable(Bytes: self.tab.Bytes, Pos: self.tab.Pos + o))) +func longEnumNonEnumDefault*(self: Monster): MyGame_Example_LongEnum.LongEnum = + let o = self.tab.Offset(108) + if o != 0: + return MyGame_Example_LongEnum.LongEnum(Get[uint64](self.tab, self.tab.Pos + o)) + return type(result)(0) +func `longEnumNonEnumDefault=`*(self: var Monster, n: MyGame_Example_LongEnum.LongEnum): bool = + return self.tab.MutateSlot(108, n) +func longEnumNormalDefault*(self: Monster): MyGame_Example_LongEnum.LongEnum = + let o = self.tab.Offset(110) + if o != 0: + return MyGame_Example_LongEnum.LongEnum(Get[uint64](self.tab, self.tab.Pos + o)) + return type(result)(2) +func `longEnumNormalDefault=`*(self: var Monster, n: MyGame_Example_LongEnum.LongEnum): bool = + return self.tab.MutateSlot(110, n) +proc MonsterStart*(builder: var Builder) = + builder.StartObject(54) +proc MonsterAddpos*(builder: var Builder, pos: uoffset) = + builder.PrependStructSlot(0, pos, default(uoffset)) +proc MonsterAddmana*(builder: var Builder, mana: int16) = + builder.PrependSlot(1, mana, default(int16)) +proc MonsterAddhp*(builder: var Builder, hp: int16) = + builder.PrependSlot(2, hp, default(int16)) +proc MonsterAddname*(builder: var Builder, name: uoffset) = + builder.PrependSlot(3, name, default(uoffset)) +proc MonsterAddinventory*(builder: var Builder, inventory: uoffset) = + builder.PrependSlot(5, inventory, default(uoffset)) +proc MonsterStartinventoryVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(1, numElems, 1) +proc MonsterAddcolor*(builder: var Builder, color: uint8) = + builder.PrependSlot(6, color, default(uint8)) +proc MonsterAddtestType*(builder: var Builder, testType: uint8) = + builder.PrependSlot(7, testType, default(uint8)) +proc MonsterAddtest*(builder: var Builder, test: uoffset) = + builder.PrependSlot(8, test, default(uoffset)) +proc MonsterAddtest4*(builder: var Builder, test4: uoffset) = + builder.PrependSlot(9, test4, default(uoffset)) +proc MonsterStarttest4Vector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(4, numElems, 2) +proc MonsterAddtestarrayofstring*(builder: var Builder, testarrayofstring: uoffset) = + builder.PrependSlot(10, testarrayofstring, default(uoffset)) +proc MonsterStarttestarrayofstringVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(4, numElems, 4) +proc MonsterAddtestarrayoftables*(builder: var Builder, testarrayoftables: uoffset) = + builder.PrependSlot(11, testarrayoftables, default(uoffset)) +proc MonsterStarttestarrayoftablesVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(4, numElems, 4) +proc MonsterAddenemy*(builder: var Builder, enemy: uoffset) = + builder.PrependStructSlot(12, enemy, default(uoffset)) +proc MonsterAddtestnestedflatbuffer*(builder: var Builder, testnestedflatbuffer: uoffset) = + builder.PrependSlot(13, testnestedflatbuffer, default(uoffset)) +proc MonsterStarttestnestedflatbufferVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(1, numElems, 1) +proc MonsterAddtestempty*(builder: var Builder, testempty: uoffset) = + builder.PrependStructSlot(14, testempty, default(uoffset)) +proc MonsterAddtestbool*(builder: var Builder, testbool: bool) = + builder.PrependSlot(15, testbool, default(bool)) +proc MonsterAddtesthashs32Fnv1*(builder: var Builder, testhashs32Fnv1: int32) = + builder.PrependSlot(16, testhashs32Fnv1, default(int32)) +proc MonsterAddtesthashu32Fnv1*(builder: var Builder, testhashu32Fnv1: uint32) = + builder.PrependSlot(17, testhashu32Fnv1, default(uint32)) +proc MonsterAddtesthashs64Fnv1*(builder: var Builder, testhashs64Fnv1: int64) = + builder.PrependSlot(18, testhashs64Fnv1, default(int64)) +proc MonsterAddtesthashu64Fnv1*(builder: var Builder, testhashu64Fnv1: uint64) = + builder.PrependSlot(19, testhashu64Fnv1, default(uint64)) +proc MonsterAddtesthashs32Fnv1a*(builder: var Builder, testhashs32Fnv1a: int32) = + builder.PrependSlot(20, testhashs32Fnv1a, default(int32)) +proc MonsterAddtesthashu32Fnv1a*(builder: var Builder, testhashu32Fnv1a: uint32) = + builder.PrependSlot(21, testhashu32Fnv1a, default(uint32)) +proc MonsterAddtesthashs64Fnv1a*(builder: var Builder, testhashs64Fnv1a: int64) = + builder.PrependSlot(22, testhashs64Fnv1a, default(int64)) +proc MonsterAddtesthashu64Fnv1a*(builder: var Builder, testhashu64Fnv1a: uint64) = + builder.PrependSlot(23, testhashu64Fnv1a, default(uint64)) +proc MonsterAddtestarrayofbools*(builder: var Builder, testarrayofbools: uoffset) = + builder.PrependSlot(24, testarrayofbools, default(uoffset)) +proc MonsterStarttestarrayofboolsVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(1, numElems, 1) +proc MonsterAddtestf*(builder: var Builder, testf: float32) = + builder.PrependSlot(25, testf, default(float32)) +proc MonsterAddtestf2*(builder: var Builder, testf2: float32) = + builder.PrependSlot(26, testf2, default(float32)) +proc MonsterAddtestf3*(builder: var Builder, testf3: float32) = + builder.PrependSlot(27, testf3, default(float32)) +proc MonsterAddtestarrayofstring2*(builder: var Builder, testarrayofstring2: uoffset) = + builder.PrependSlot(28, testarrayofstring2, default(uoffset)) +proc MonsterStarttestarrayofstring2Vector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(4, numElems, 4) +proc MonsterAddtestarrayofsortedstruct*(builder: var Builder, testarrayofsortedstruct: uoffset) = + builder.PrependSlot(29, testarrayofsortedstruct, default(uoffset)) +proc MonsterStarttestarrayofsortedstructVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(8, numElems, 4) +proc MonsterAddflex*(builder: var Builder, flex: uoffset) = + builder.PrependSlot(30, flex, default(uoffset)) +proc MonsterStartflexVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(1, numElems, 1) +proc MonsterAddtest5*(builder: var Builder, test5: uoffset) = + builder.PrependSlot(31, test5, default(uoffset)) +proc MonsterStarttest5Vector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(4, numElems, 2) +proc MonsterAddvectorOfLongs*(builder: var Builder, vectorOfLongs: uoffset) = + builder.PrependSlot(32, vectorOfLongs, default(uoffset)) +proc MonsterStartvectorOfLongsVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(8, numElems, 8) +proc MonsterAddvectorOfDoubles*(builder: var Builder, vectorOfDoubles: uoffset) = + builder.PrependSlot(33, vectorOfDoubles, default(uoffset)) +proc MonsterStartvectorOfDoublesVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(8, numElems, 8) +proc MonsterAddparentNamespaceTest*(builder: var Builder, parentNamespaceTest: uoffset) = + builder.PrependStructSlot(34, parentNamespaceTest, default(uoffset)) +proc MonsterAddvectorOfReferrables*(builder: var Builder, vectorOfReferrables: uoffset) = + builder.PrependSlot(35, vectorOfReferrables, default(uoffset)) +proc MonsterStartvectorOfReferrablesVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(4, numElems, 4) +proc MonsterAddsingleWeakReference*(builder: var Builder, singleWeakReference: uint64) = + builder.PrependSlot(36, singleWeakReference, default(uint64)) +proc MonsterAddvectorOfWeakReferences*(builder: var Builder, vectorOfWeakReferences: uoffset) = + builder.PrependSlot(37, vectorOfWeakReferences, default(uoffset)) +proc MonsterStartvectorOfWeakReferencesVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(8, numElems, 8) +proc MonsterAddvectorOfStrongReferrables*(builder: var Builder, vectorOfStrongReferrables: uoffset) = + builder.PrependSlot(38, vectorOfStrongReferrables, default(uoffset)) +proc MonsterStartvectorOfStrongReferrablesVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(4, numElems, 4) +proc MonsterAddcoOwningReference*(builder: var Builder, coOwningReference: uint64) = + builder.PrependSlot(39, coOwningReference, default(uint64)) +proc MonsterAddvectorOfCoOwningReferences*(builder: var Builder, vectorOfCoOwningReferences: uoffset) = + builder.PrependSlot(40, vectorOfCoOwningReferences, default(uoffset)) +proc MonsterStartvectorOfCoOwningReferencesVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(8, numElems, 8) +proc MonsterAddnonOwningReference*(builder: var Builder, nonOwningReference: uint64) = + builder.PrependSlot(41, nonOwningReference, default(uint64)) +proc MonsterAddvectorOfNonOwningReferences*(builder: var Builder, vectorOfNonOwningReferences: uoffset) = + builder.PrependSlot(42, vectorOfNonOwningReferences, default(uoffset)) +proc MonsterStartvectorOfNonOwningReferencesVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(8, numElems, 8) +proc MonsterAddanyUniqueType*(builder: var Builder, anyUniqueType: uint8) = + builder.PrependSlot(43, anyUniqueType, default(uint8)) +proc MonsterAddanyUnique*(builder: var Builder, anyUnique: uoffset) = + builder.PrependSlot(44, anyUnique, default(uoffset)) +proc MonsterAddanyAmbiguousType*(builder: var Builder, anyAmbiguousType: uint8) = + builder.PrependSlot(45, anyAmbiguousType, default(uint8)) +proc MonsterAddanyAmbiguous*(builder: var Builder, anyAmbiguous: uoffset) = + builder.PrependSlot(46, anyAmbiguous, default(uoffset)) +proc MonsterAddvectorOfEnums*(builder: var Builder, vectorOfEnums: uoffset) = + builder.PrependSlot(47, vectorOfEnums, default(uoffset)) +proc MonsterStartvectorOfEnumsVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(1, numElems, 1) +proc MonsterAddsignedEnum*(builder: var Builder, signedEnum: int8) = + builder.PrependSlot(48, signedEnum, default(int8)) +proc MonsterAddtestrequirednestedflatbuffer*(builder: var Builder, testrequirednestedflatbuffer: uoffset) = + builder.PrependSlot(49, testrequirednestedflatbuffer, default(uoffset)) +proc MonsterStarttestrequirednestedflatbufferVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(1, numElems, 1) +proc MonsterAddscalarKeySortedTables*(builder: var Builder, scalarKeySortedTables: uoffset) = + builder.PrependSlot(50, scalarKeySortedTables, default(uoffset)) +proc MonsterStartscalarKeySortedTablesVector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(4, numElems, 4) +proc MonsterAddnativeInline*(builder: var Builder, nativeInline: uoffset) = + builder.PrependStructSlot(51, nativeInline, default(uoffset)) +proc MonsterAddlongEnumNonEnumDefault*(builder: var Builder, longEnumNonEnumDefault: uint64) = + builder.PrependSlot(52, longEnumNonEnumDefault, default(uint64)) +proc MonsterAddlongEnumNormalDefault*(builder: var Builder, longEnumNormalDefault: uint64) = + builder.PrependSlot(53, longEnumNormalDefault, default(uint64)) +proc MonsterEnd*(builder: var Builder): uoffset = + return builder.EndObject() diff --git a/tests/MyGame/Example/Race.nim b/tests/MyGame/Example/Race.nim new file mode 100644 index 00000000000..998c9c04758 --- /dev/null +++ b/tests/MyGame/Example/Race.nim @@ -0,0 +1,15 @@ +#[ MyGame.Example.Race + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +type Race*{.pure.} = enum + None = -1.int8, + Human = 0.int8, + Dwarf = 1.int8, + Elf = 2.int8, diff --git a/tests/MyGame/Example/Referrable.nim b/tests/MyGame/Example/Referrable.nim new file mode 100644 index 00000000000..189e12262ee --- /dev/null +++ b/tests/MyGame/Example/Referrable.nim @@ -0,0 +1,26 @@ +#[ MyGame.Example.Referrable + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +import flatbuffers + +type Referrable* = object of FlatObj +func id*(self: Referrable): uint64 = + let o = self.tab.Offset(4) + if o != 0: + return Get[uint64](self.tab, self.tab.Pos + o) + return 0 +func `id=`*(self: var Referrable, n: uint64): bool = + return self.tab.MutateSlot(4, n) +proc ReferrableStart*(builder: var Builder) = + builder.StartObject(1) +proc ReferrableAddid*(builder: var Builder, id: uint64) = + builder.PrependSlot(0, id, default(uint64)) +proc ReferrableEnd*(builder: var Builder): uoffset = + return builder.EndObject() diff --git a/tests/MyGame/Example/Stat.nim b/tests/MyGame/Example/Stat.nim new file mode 100644 index 00000000000..1461788ff79 --- /dev/null +++ b/tests/MyGame/Example/Stat.nim @@ -0,0 +1,42 @@ +#[ MyGame.Example.Stat + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +import flatbuffers +import std/options + +type Stat* = object of FlatObj +func id*(self: Stat): Option[string] = + let o = self.tab.Offset(4) + if o != 0: + return some(self.tab.String(self.tab.Pos + o)) +func val*(self: Stat): int64 = + let o = self.tab.Offset(6) + if o != 0: + return Get[int64](self.tab, self.tab.Pos + o) + return 0 +func `val=`*(self: var Stat, n: int64): bool = + return self.tab.MutateSlot(6, n) +func count*(self: Stat): uint16 = + let o = self.tab.Offset(8) + if o != 0: + return Get[uint16](self.tab, self.tab.Pos + o) + return 0 +func `count=`*(self: var Stat, n: uint16): bool = + return self.tab.MutateSlot(8, n) +proc StatStart*(builder: var Builder) = + builder.StartObject(3) +proc StatAddid*(builder: var Builder, id: uoffset) = + builder.PrependSlot(0, id, default(uoffset)) +proc StatAddval*(builder: var Builder, val: int64) = + builder.PrependSlot(1, val, default(int64)) +proc StatAddcount*(builder: var Builder, count: uint16) = + builder.PrependSlot(2, count, default(uint16)) +proc StatEnd*(builder: var Builder): uoffset = + return builder.EndObject() diff --git a/tests/MyGame/Example/StructOfStructs.nim b/tests/MyGame/Example/StructOfStructs.nim new file mode 100644 index 00000000000..5d063396b40 --- /dev/null +++ b/tests/MyGame/Example/StructOfStructs.nim @@ -0,0 +1,34 @@ +#[ MyGame.Example.StructOfStructs + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +import Ability as MyGame_Example_Ability +import Test as MyGame_Example_Test +import flatbuffers + +type StructOfStructs* = object of FlatObj +func a*(self: StructOfStructs): MyGame_Example_Ability.Ability = + return MyGame_Example_Ability.Ability(tab: Vtable(Bytes: self.tab.Bytes, Pos: self.tab.Pos + 0)) +func b*(self: StructOfStructs): MyGame_Example_Test.Test = + return MyGame_Example_Test.Test(tab: Vtable(Bytes: self.tab.Bytes, Pos: self.tab.Pos + 8)) +func c*(self: StructOfStructs): MyGame_Example_Ability.Ability = + return MyGame_Example_Ability.Ability(tab: Vtable(Bytes: self.tab.Bytes, Pos: self.tab.Pos + 12)) +proc StructOfStructsCreate*(self: var Builder, a_id: uint32, a_distance: uint32, b_a: int16, b_b: int8, c_id: uint32, c_distance: uint32): uoffset = + self.Prep(4, 20) + self.Prep(4, 8) + self.Prepend(c_distance) + self.Prepend(c_id) + self.Prep(2, 4) + self.Pad(1) + self.Prepend(b_b) + self.Prepend(b_a) + self.Prep(4, 8) + self.Prepend(a_distance) + self.Prepend(a_id) + return self.Offset() diff --git a/tests/MyGame/Example/StructOfStructsOfStructs.nim b/tests/MyGame/Example/StructOfStructsOfStructs.nim new file mode 100644 index 00000000000..38d6e1935c5 --- /dev/null +++ b/tests/MyGame/Example/StructOfStructsOfStructs.nim @@ -0,0 +1,30 @@ +#[ MyGame.Example.StructOfStructsOfStructs + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +import StructOfStructs as MyGame_Example_StructOfStructs +import flatbuffers + +type StructOfStructsOfStructs* = object of FlatObj +func a*(self: StructOfStructsOfStructs): MyGame_Example_StructOfStructs.StructOfStructs = + return MyGame_Example_StructOfStructs.StructOfStructs(tab: Vtable(Bytes: self.tab.Bytes, Pos: self.tab.Pos + 0)) +proc StructOfStructsOfStructsCreate*(self: var Builder, a_a_id: uint32, a_a_distance: uint32, a_b_a: int16, a_b_b: int8, a_c_id: uint32, a_c_distance: uint32): uoffset = + self.Prep(4, 20) + self.Prep(4, 20) + self.Prep(4, 8) + self.Prepend(a_c_distance) + self.Prepend(a_c_id) + self.Prep(2, 4) + self.Pad(1) + self.Prepend(a_b_b) + self.Prepend(a_b_a) + self.Prep(4, 8) + self.Prepend(a_a_distance) + self.Prepend(a_a_id) + return self.Offset() diff --git a/tests/MyGame/Example/Test.nim b/tests/MyGame/Example/Test.nim new file mode 100644 index 00000000000..1c8d4938b55 --- /dev/null +++ b/tests/MyGame/Example/Test.nim @@ -0,0 +1,27 @@ +#[ MyGame.Example.Test + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +import flatbuffers + +type Test* = object of FlatObj +func a*(self: Test): int16 = + return Get[int16](self.tab, self.tab.Pos + 0) +func `a=`*(self: var Test, n: int16): bool = + return self.tab.Mutate(self.tab.Pos + 0, n) +func b*(self: Test): int8 = + return Get[int8](self.tab, self.tab.Pos + 2) +func `b=`*(self: var Test, n: int8): bool = + return self.tab.Mutate(self.tab.Pos + 2, n) +proc TestCreate*(self: var Builder, a: int16, b: int8): uoffset = + self.Prep(2, 4) + self.Pad(1) + self.Prepend(b) + self.Prepend(a) + return self.Offset() diff --git a/tests/MyGame/Example/TestSimpleTableWithEnum.nim b/tests/MyGame/Example/TestSimpleTableWithEnum.nim new file mode 100644 index 00000000000..9ba66f0fc95 --- /dev/null +++ b/tests/MyGame/Example/TestSimpleTableWithEnum.nim @@ -0,0 +1,27 @@ +#[ MyGame.Example.TestSimpleTableWithEnum + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +import Color as MyGame_Example_Color +import flatbuffers + +type TestSimpleTableWithEnum* = object of FlatObj +func color*(self: TestSimpleTableWithEnum): MyGame_Example_Color.Color = + let o = self.tab.Offset(4) + if o != 0: + return MyGame_Example_Color.Color(Get[uint8](self.tab, self.tab.Pos + o)) + return type(result)(2) +func `color=`*(self: var TestSimpleTableWithEnum, n: MyGame_Example_Color.Color): bool = + return self.tab.MutateSlot(4, n) +proc TestSimpleTableWithEnumStart*(builder: var Builder) = + builder.StartObject(1) +proc TestSimpleTableWithEnumAddcolor*(builder: var Builder, color: uint8) = + builder.PrependSlot(0, color, default(uint8)) +proc TestSimpleTableWithEnumEnd*(builder: var Builder): uoffset = + return builder.EndObject() diff --git a/tests/MyGame/Example/TypeAliases.nim b/tests/MyGame/Example/TypeAliases.nim new file mode 100644 index 00000000000..b3e39def526 --- /dev/null +++ b/tests/MyGame/Example/TypeAliases.nim @@ -0,0 +1,144 @@ +#[ MyGame.Example.TypeAliases + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +import flatbuffers +import std/options + +type TypeAliases* = object of FlatObj +func i8*(self: TypeAliases): int8 = + let o = self.tab.Offset(4) + if o != 0: + return Get[int8](self.tab, self.tab.Pos + o) + return 0 +func `i8=`*(self: var TypeAliases, n: int8): bool = + return self.tab.MutateSlot(4, n) +func u8*(self: TypeAliases): uint8 = + let o = self.tab.Offset(6) + if o != 0: + return Get[uint8](self.tab, self.tab.Pos + o) + return 0 +func `u8=`*(self: var TypeAliases, n: uint8): bool = + return self.tab.MutateSlot(6, n) +func i16*(self: TypeAliases): int16 = + let o = self.tab.Offset(8) + if o != 0: + return Get[int16](self.tab, self.tab.Pos + o) + return 0 +func `i16=`*(self: var TypeAliases, n: int16): bool = + return self.tab.MutateSlot(8, n) +func u16*(self: TypeAliases): uint16 = + let o = self.tab.Offset(10) + if o != 0: + return Get[uint16](self.tab, self.tab.Pos + o) + return 0 +func `u16=`*(self: var TypeAliases, n: uint16): bool = + return self.tab.MutateSlot(10, n) +func i32*(self: TypeAliases): int32 = + let o = self.tab.Offset(12) + if o != 0: + return Get[int32](self.tab, self.tab.Pos + o) + return 0 +func `i32=`*(self: var TypeAliases, n: int32): bool = + return self.tab.MutateSlot(12, n) +func u32*(self: TypeAliases): uint32 = + let o = self.tab.Offset(14) + if o != 0: + return Get[uint32](self.tab, self.tab.Pos + o) + return 0 +func `u32=`*(self: var TypeAliases, n: uint32): bool = + return self.tab.MutateSlot(14, n) +func i64*(self: TypeAliases): int64 = + let o = self.tab.Offset(16) + if o != 0: + return Get[int64](self.tab, self.tab.Pos + o) + return 0 +func `i64=`*(self: var TypeAliases, n: int64): bool = + return self.tab.MutateSlot(16, n) +func u64*(self: TypeAliases): uint64 = + let o = self.tab.Offset(18) + if o != 0: + return Get[uint64](self.tab, self.tab.Pos + o) + return 0 +func `u64=`*(self: var TypeAliases, n: uint64): bool = + return self.tab.MutateSlot(18, n) +func f32*(self: TypeAliases): float32 = + let o = self.tab.Offset(20) + if o != 0: + return Get[float32](self.tab, self.tab.Pos + o) + return 0.0 +func `f32=`*(self: var TypeAliases, n: float32): bool = + return self.tab.MutateSlot(20, n) +func f64*(self: TypeAliases): float64 = + let o = self.tab.Offset(22) + if o != 0: + return Get[float64](self.tab, self.tab.Pos + o) + return 0.0 +func `f64=`*(self: var TypeAliases, n: float64): bool = + return self.tab.MutateSlot(22, n) +func v8Length*(self: TypeAliases): int = + let o = self.tab.Offset(24) + if o != 0: + return self.tab.VectorLen(o) +func v8*(self: TypeAliases, j: int): int8 = + let o = self.tab.Offset(24) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 1.uoffset + return Get[int8](self.tab, x) +func v8*(self: TypeAliases): seq[int8] = + let len = self.v8Length + for i in countup(0, len - 1): + result.add(self.v8(i)) +func vf64Length*(self: TypeAliases): int = + let o = self.tab.Offset(26) + if o != 0: + return self.tab.VectorLen(o) +func vf64*(self: TypeAliases, j: int): float64 = + let o = self.tab.Offset(26) + if o != 0: + var x = self.tab.Vector(o) + x += j.uoffset * 8.uoffset + return Get[float64](self.tab, x) +func vf64*(self: TypeAliases): seq[float64] = + let len = self.vf64Length + for i in countup(0, len - 1): + result.add(self.vf64(i)) +proc TypeAliasesStart*(builder: var Builder) = + builder.StartObject(12) +proc TypeAliasesAddi8*(builder: var Builder, i8: int8) = + builder.PrependSlot(0, i8, default(int8)) +proc TypeAliasesAddu8*(builder: var Builder, u8: uint8) = + builder.PrependSlot(1, u8, default(uint8)) +proc TypeAliasesAddi16*(builder: var Builder, i16: int16) = + builder.PrependSlot(2, i16, default(int16)) +proc TypeAliasesAddu16*(builder: var Builder, u16: uint16) = + builder.PrependSlot(3, u16, default(uint16)) +proc TypeAliasesAddi32*(builder: var Builder, i32: int32) = + builder.PrependSlot(4, i32, default(int32)) +proc TypeAliasesAddu32*(builder: var Builder, u32: uint32) = + builder.PrependSlot(5, u32, default(uint32)) +proc TypeAliasesAddi64*(builder: var Builder, i64: int64) = + builder.PrependSlot(6, i64, default(int64)) +proc TypeAliasesAddu64*(builder: var Builder, u64: uint64) = + builder.PrependSlot(7, u64, default(uint64)) +proc TypeAliasesAddf32*(builder: var Builder, f32: float32) = + builder.PrependSlot(8, f32, default(float32)) +proc TypeAliasesAddf64*(builder: var Builder, f64: float64) = + builder.PrependSlot(9, f64, default(float64)) +proc TypeAliasesAddv8*(builder: var Builder, v8: uoffset) = + builder.PrependSlot(10, v8, default(uoffset)) +proc TypeAliasesStartv8Vector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(1, numElems, 1) +proc TypeAliasesAddvf64*(builder: var Builder, vf64: uoffset) = + builder.PrependSlot(11, vf64, default(uoffset)) +proc TypeAliasesStartvf64Vector*(builder: var Builder, numElems: uoffset) = + builder.StartVector(8, numElems, 8) +proc TypeAliasesEnd*(builder: var Builder): uoffset = + return builder.EndObject() diff --git a/tests/MyGame/Example/Vec3.nim b/tests/MyGame/Example/Vec3.nim new file mode 100644 index 00000000000..012e9bea772 --- /dev/null +++ b/tests/MyGame/Example/Vec3.nim @@ -0,0 +1,52 @@ +#[ MyGame.Example.Vec3 + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +import Color as MyGame_Example_Color +import Test as MyGame_Example_Test +import flatbuffers + +type Vec3* = object of FlatObj +func x*(self: Vec3): float32 = + return Get[float32](self.tab, self.tab.Pos + 0) +func `x=`*(self: var Vec3, n: float32): bool = + return self.tab.Mutate(self.tab.Pos + 0, n) +func y*(self: Vec3): float32 = + return Get[float32](self.tab, self.tab.Pos + 4) +func `y=`*(self: var Vec3, n: float32): bool = + return self.tab.Mutate(self.tab.Pos + 4, n) +func z*(self: Vec3): float32 = + return Get[float32](self.tab, self.tab.Pos + 8) +func `z=`*(self: var Vec3, n: float32): bool = + return self.tab.Mutate(self.tab.Pos + 8, n) +func test1*(self: Vec3): float64 = + return Get[float64](self.tab, self.tab.Pos + 16) +func `test1=`*(self: var Vec3, n: float64): bool = + return self.tab.Mutate(self.tab.Pos + 16, n) +func test2*(self: Vec3): MyGame_Example_Color.Color = + return MyGame_Example_Color.Color(Get[uint8](self.tab, self.tab.Pos + 24)) +func `test2=`*(self: var Vec3, n: MyGame_Example_Color.Color): bool = + return self.tab.Mutate(self.tab.Pos + 24, n) +func test3*(self: Vec3): MyGame_Example_Test.Test = + return MyGame_Example_Test.Test(tab: Vtable(Bytes: self.tab.Bytes, Pos: self.tab.Pos + 26)) +proc Vec3Create*(self: var Builder, x: float32, y: float32, z: float32, test1: float64, test2: MyGame_Example_Color.Color, test3_a: int16, test3_b: int8): uoffset = + self.Prep(8, 32) + self.Pad(2) + self.Prep(2, 4) + self.Pad(1) + self.Prepend(test3_b) + self.Prepend(test3_a) + self.Pad(1) + self.Prepend(test2) + self.Prepend(test1) + self.Pad(4) + self.Prepend(z) + self.Prepend(y) + self.Prepend(x) + return self.Offset() diff --git a/tests/MyGame/Example2/Monster.nim b/tests/MyGame/Example2/Monster.nim new file mode 100644 index 00000000000..4a08c545233 --- /dev/null +++ b/tests/MyGame/Example2/Monster.nim @@ -0,0 +1,17 @@ +#[ MyGame.Example2.Monster + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +import flatbuffers + +type Monster* = object of FlatObj +proc MonsterStart*(builder: var Builder) = + builder.StartObject(0) +proc MonsterEnd*(builder: var Builder): uoffset = + return builder.EndObject() diff --git a/tests/MyGame/InParentNamespace.nim b/tests/MyGame/InParentNamespace.nim new file mode 100644 index 00000000000..22c15680ca1 --- /dev/null +++ b/tests/MyGame/InParentNamespace.nim @@ -0,0 +1,17 @@ +#[ MyGame.InParentNamespace + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +import flatbuffers + +type InParentNamespace* = object of FlatObj +proc InParentNamespaceStart*(builder: var Builder) = + builder.StartObject(0) +proc InParentNamespaceEnd*(builder: var Builder): uoffset = + return builder.EndObject() diff --git a/tests/MyGame/OtherNameSpace/FromInclude.nim b/tests/MyGame/OtherNameSpace/FromInclude.nim new file mode 100644 index 00000000000..739b109ee49 --- /dev/null +++ b/tests/MyGame/OtherNameSpace/FromInclude.nim @@ -0,0 +1,12 @@ +#[ MyGame.OtherNameSpace.FromInclude + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +type FromInclude*{.pure.} = enum + IncludeVal = 0.int64, diff --git a/tests/MyGame/OtherNameSpace/TableB.nim b/tests/MyGame/OtherNameSpace/TableB.nim new file mode 100644 index 00000000000..cd465168972 --- /dev/null +++ b/tests/MyGame/OtherNameSpace/TableB.nim @@ -0,0 +1,25 @@ +#[ MyGame.OtherNameSpace.TableB + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +import ../../TableA as TableA +import flatbuffers +import std/options + +type TableB* = object of FlatObj +func a*(self: TableB): Option[TableA.TableA] = + let o = self.tab.Offset(4) + if o != 0: + return some(TableA.TableA(tab: Vtable(Bytes: self.tab.Bytes, Pos: self.tab.Pos + o))) +proc TableBstart*(builder: var Builder) = + builder.StartObject(1) +proc TableBadda*(builder: var Builder, a: uoffset) = + builder.PrependStructSlot(0, a, default(uoffset)) +proc TableBend*(builder: var Builder): uoffset = + return builder.EndObject() diff --git a/tests/MyGame/OtherNameSpace/Unused.nim b/tests/MyGame/OtherNameSpace/Unused.nim new file mode 100644 index 00000000000..3d6ebca27a6 --- /dev/null +++ b/tests/MyGame/OtherNameSpace/Unused.nim @@ -0,0 +1,21 @@ +#[ MyGame.OtherNameSpace.Unused + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +import flatbuffers + +type Unused* = object of FlatObj +func a*(self: Unused): int32 = + return Get[int32](self.tab, self.tab.Pos + 0) +func `a=`*(self: var Unused, n: int32): bool = + return self.tab.Mutate(self.tab.Pos + 0, n) +proc UnusedCreate*(self: var Builder, a: int32): uoffset = + self.Prep(4, 4) + self.Prepend(a) + return self.Offset() diff --git a/tests/Property.nim b/tests/Property.nim new file mode 100644 index 00000000000..ea66b2013fc --- /dev/null +++ b/tests/Property.nim @@ -0,0 +1,20 @@ +#[ Property + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : +]# + +import flatbuffers + +type Property* = object of FlatObj +func property*(self: Property): bool = + return Get[bool](self.tab, self.tab.Pos + 0) +func `property=`*(self: var Property, n: bool): bool = + return self.tab.Mutate(self.tab.Pos + 0, n) +proc PropertyCreate*(self: var Builder, property: bool): uoffset = + self.Prep(1, 1) + self.Prepend(property) + return self.Offset() diff --git a/tests/TableA.nim b/tests/TableA.nim new file mode 100644 index 00000000000..888e64bd5c9 --- /dev/null +++ b/tests/TableA.nim @@ -0,0 +1,25 @@ +#[ TableA + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : MyGame.Example.Monster () +]# + +import MyGame/OtherNameSpace/TableB as MyGame_OtherNameSpace_TableB +import flatbuffers +import std/options + +type TableA* = object of FlatObj +func b*(self: TableA): Option[MyGame_OtherNameSpace_TableB.TableB] = + let o = self.tab.Offset(4) + if o != 0: + return some(MyGame_OtherNameSpace_TableB.TableB(tab: Vtable(Bytes: self.tab.Bytes, Pos: self.tab.Pos + o))) +proc TableAstart*(builder: var Builder) = + builder.StartObject(1) +proc TableAaddb*(builder: var Builder, b: uoffset) = + builder.PrependStructSlot(0, b, default(uoffset)) +proc TableAend*(builder: var Builder): uoffset = + return builder.EndObject() diff --git a/tests/TestMutatingBool.nim b/tests/TestMutatingBool.nim new file mode 100644 index 00000000000..5661271c768 --- /dev/null +++ b/tests/TestMutatingBool.nim @@ -0,0 +1,24 @@ +#[ TestMutatingBool + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : +]# + +import Property as Property +import flatbuffers +import std/options + +type TestMutatingBool* = object of FlatObj +func b*(self: TestMutatingBool): Option[Property.Property] = + let o = self.tab.Offset(4) + if o != 0: + return some(Property.Property(tab: Vtable(Bytes: self.tab.Bytes, Pos: self.tab.Pos + o))) +proc TestMutatingBoolStart*(builder: var Builder) = + builder.StartObject(1) +proc TestMutatingBoolAddb*(builder: var Builder, b: uoffset) = + builder.PrependStructSlot(0, b, default(uoffset)) +proc TestMutatingBoolEnd*(builder: var Builder): uoffset = + return builder.EndObject() diff --git a/tests/nim/testnim.py b/tests/nim/testnim.py index 39de04096dc..2a54cf3d34c 100644 --- a/tests/nim/testnim.py +++ b/tests/nim/testnim.py @@ -1,89 +1,17 @@ import glob import os -import platform import shutil import subprocess from pathlib import Path test_nim_dir = Path(__file__).absolute().parent test_dir = test_nim_dir.parent -generated_dir = test_nim_dir / "generated" -root_path = test_dir.parent -flatc_exe = Path("flatc.exe" if platform.system() == "Windows" else "flatc") -flatc_path = root_path / flatc_exe -assert flatc_path.exists(), "Cannot find the flatc compiler " + str(flatc_path) - -# Execute the flatc compiler with the specified parameters -def flatc(options, schema, prefix=None, include=None, data=None, cwd=root_path): - cmd = [str(flatc_path)] + options - if prefix: - cmd += ["-o"] + [prefix] - if include: - cmd += ["-I"] + [include] - if isinstance(schema, Path): - cmd += [str(schema)] - elif isinstance(schema, str): - cmd += [schema] - else: - cmd += schema - if data: - cmd += [data] if isinstance(data, str) else data - return subprocess.check_call(cmd, cwd=str(cwd)) - - -def generate_mygame(): - flatc( - [ - "--nim", - "--gen-mutable", - ], - include=str(test_dir / "include_test"), - schema=test_dir / "monster_test.fbs", - cwd=Path(generated_dir), - ) - - -def generate_optional_scalars(): - flatc( - [ - "--nim", - ], - schema=test_dir / "optional_scalars.fbs", - cwd=Path(generated_dir), - ) - - -def generate_moredefaults(): - flatc( - [ - "--nim", - ], - schema=test_dir / "more_defaults.fbs", - cwd=Path(generated_dir), - ) - - -def generate_mutatingbool(): - flatc( - [ - "--nim", - "--gen-mutable", - ], - schema=test_dir / "MutatingBool.fbs", - cwd=Path(generated_dir), - ) def main(): - generated_dir.mkdir(exist_ok=True) try: - generate_mygame() - generate_optional_scalars() - generate_moredefaults() - generate_mutatingbool() subprocess.check_call("testament --megatest:off all".split()) finally: - shutil.rmtree(generated_dir) shutil.rmtree(test_nim_dir / "nimcache") shutil.rmtree(test_nim_dir / "testresults") for f in glob.glob(str(test_nim_dir / "tests" / "*" / "test")): diff --git a/tests/nim/tests/moredefaults/test.nim b/tests/nim/tests/moredefaults/test.nim index 4ba5225ed2b..b49dc169dc0 100644 --- a/tests/nim/tests/moredefaults/test.nim +++ b/tests/nim/tests/moredefaults/test.nim @@ -5,7 +5,7 @@ discard """ """ import std/unittest import flatbuffers -import ../../generated/MoreDefaults +import ../../../MoreDefaults suite "TestMoreDefaults": diff --git a/tests/nim/tests/mutatingbool/test.nim b/tests/nim/tests/mutatingbool/test.nim index 7b65c0573bf..b079cbf484b 100644 --- a/tests/nim/tests/mutatingbool/test.nim +++ b/tests/nim/tests/mutatingbool/test.nim @@ -6,8 +6,8 @@ discard """ import std/unittest import std/options import flatbuffers -import ../../generated/TestMutatingBool -import ../../generated/Property +import ../../../TestMutatingBool +import ../../../Property suite "TestMutatingBool": diff --git a/tests/nim/tests/mygame/test.nim b/tests/nim/tests/mygame/test.nim index 4f9e1db2143..c971d6079d3 100644 --- a/tests/nim/tests/mygame/test.nim +++ b/tests/nim/tests/mygame/test.nim @@ -6,11 +6,11 @@ discard """ import std/unittest import std/options import flatbuffers -import ../../generated/MyGame/Example/Test -import ../../generated/MyGame/Example/Monster -import ../../generated/MyGame/Example/Vec3 -import ../../generated/MyGame/Example/Color as ColorMod -import ../../generated/MyGame/Example/Any as AnyMod +import ../../../MyGame/Example/Test +import ../../../MyGame/Example/Monster +import ../../../MyGame/Example/Vec3 +import ../../../MyGame/Example/Color as ColorMod +import ../../../MyGame/Example/Any as AnyMod proc verifyMonster(monster: var Monster) = check(monster.hp == 80) diff --git a/tests/nim/tests/optional_scalars/test.nim b/tests/nim/tests/optional_scalars/test.nim index 29bf084eb8b..1e02c59e05c 100644 --- a/tests/nim/tests/optional_scalars/test.nim +++ b/tests/nim/tests/optional_scalars/test.nim @@ -6,7 +6,7 @@ discard """ import std/unittest import std/options import flatbuffers -import ../../generated/optional_scalars/ScalarStuff +import ../../../optional_scalars/ScalarStuff suite "TestOptionalScalars": diff --git a/tests/optional_scalars/OptionalByte.nim b/tests/optional_scalars/OptionalByte.nim new file mode 100644 index 00000000000..946cefced36 --- /dev/null +++ b/tests/optional_scalars/OptionalByte.nim @@ -0,0 +1,14 @@ +#[ optional_scalars.OptionalByte + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : optional_scalars.ScalarStuff () +]# + +type OptionalByte*{.pure.} = enum + None = 0.int8, + One = 1.int8, + Two = 2.int8, diff --git a/tests/optional_scalars/ScalarStuff.nim b/tests/optional_scalars/ScalarStuff.nim new file mode 100644 index 00000000000..442101c191c --- /dev/null +++ b/tests/optional_scalars/ScalarStuff.nim @@ -0,0 +1,331 @@ +#[ optional_scalars.ScalarStuff + Automatically generated by the FlatBuffers compiler, do not modify. + Or modify. I'm a message, not a cop. + + flatc version: 22.9.29 + + Declared by : + Rooting type : optional_scalars.ScalarStuff () +]# + +import OptionalByte as optional_scalars_OptionalByte +import flatbuffers +import std/options + +type ScalarStuff* = object of FlatObj +func justI8*(self: ScalarStuff): int8 = + let o = self.tab.Offset(4) + if o != 0: + return Get[int8](self.tab, self.tab.Pos + o) + return 0 +func `justI8=`*(self: var ScalarStuff, n: int8): bool = + return self.tab.MutateSlot(4, n) +func maybeI8*(self: ScalarStuff): Option[int8] = + let o = self.tab.Offset(6) + if o != 0: + return some(Get[int8](self.tab, self.tab.Pos + o)) +func `maybeI8=`*(self: var ScalarStuff, n: Option[int8]): bool = + return self.tab.MutateSlot(6, n) +func defaultI8*(self: ScalarStuff): int8 = + let o = self.tab.Offset(8) + if o != 0: + return Get[int8](self.tab, self.tab.Pos + o) + return 42 +func `defaultI8=`*(self: var ScalarStuff, n: int8): bool = + return self.tab.MutateSlot(8, n) +func justU8*(self: ScalarStuff): uint8 = + let o = self.tab.Offset(10) + if o != 0: + return Get[uint8](self.tab, self.tab.Pos + o) + return 0 +func `justU8=`*(self: var ScalarStuff, n: uint8): bool = + return self.tab.MutateSlot(10, n) +func maybeU8*(self: ScalarStuff): Option[uint8] = + let o = self.tab.Offset(12) + if o != 0: + return some(Get[uint8](self.tab, self.tab.Pos + o)) +func `maybeU8=`*(self: var ScalarStuff, n: Option[uint8]): bool = + return self.tab.MutateSlot(12, n) +func defaultU8*(self: ScalarStuff): uint8 = + let o = self.tab.Offset(14) + if o != 0: + return Get[uint8](self.tab, self.tab.Pos + o) + return 42 +func `defaultU8=`*(self: var ScalarStuff, n: uint8): bool = + return self.tab.MutateSlot(14, n) +func justI16*(self: ScalarStuff): int16 = + let o = self.tab.Offset(16) + if o != 0: + return Get[int16](self.tab, self.tab.Pos + o) + return 0 +func `justI16=`*(self: var ScalarStuff, n: int16): bool = + return self.tab.MutateSlot(16, n) +func maybeI16*(self: ScalarStuff): Option[int16] = + let o = self.tab.Offset(18) + if o != 0: + return some(Get[int16](self.tab, self.tab.Pos + o)) +func `maybeI16=`*(self: var ScalarStuff, n: Option[int16]): bool = + return self.tab.MutateSlot(18, n) +func defaultI16*(self: ScalarStuff): int16 = + let o = self.tab.Offset(20) + if o != 0: + return Get[int16](self.tab, self.tab.Pos + o) + return 42 +func `defaultI16=`*(self: var ScalarStuff, n: int16): bool = + return self.tab.MutateSlot(20, n) +func justU16*(self: ScalarStuff): uint16 = + let o = self.tab.Offset(22) + if o != 0: + return Get[uint16](self.tab, self.tab.Pos + o) + return 0 +func `justU16=`*(self: var ScalarStuff, n: uint16): bool = + return self.tab.MutateSlot(22, n) +func maybeU16*(self: ScalarStuff): Option[uint16] = + let o = self.tab.Offset(24) + if o != 0: + return some(Get[uint16](self.tab, self.tab.Pos + o)) +func `maybeU16=`*(self: var ScalarStuff, n: Option[uint16]): bool = + return self.tab.MutateSlot(24, n) +func defaultU16*(self: ScalarStuff): uint16 = + let o = self.tab.Offset(26) + if o != 0: + return Get[uint16](self.tab, self.tab.Pos + o) + return 42 +func `defaultU16=`*(self: var ScalarStuff, n: uint16): bool = + return self.tab.MutateSlot(26, n) +func justI32*(self: ScalarStuff): int32 = + let o = self.tab.Offset(28) + if o != 0: + return Get[int32](self.tab, self.tab.Pos + o) + return 0 +func `justI32=`*(self: var ScalarStuff, n: int32): bool = + return self.tab.MutateSlot(28, n) +func maybeI32*(self: ScalarStuff): Option[int32] = + let o = self.tab.Offset(30) + if o != 0: + return some(Get[int32](self.tab, self.tab.Pos + o)) +func `maybeI32=`*(self: var ScalarStuff, n: Option[int32]): bool = + return self.tab.MutateSlot(30, n) +func defaultI32*(self: ScalarStuff): int32 = + let o = self.tab.Offset(32) + if o != 0: + return Get[int32](self.tab, self.tab.Pos + o) + return 42 +func `defaultI32=`*(self: var ScalarStuff, n: int32): bool = + return self.tab.MutateSlot(32, n) +func justU32*(self: ScalarStuff): uint32 = + let o = self.tab.Offset(34) + if o != 0: + return Get[uint32](self.tab, self.tab.Pos + o) + return 0 +func `justU32=`*(self: var ScalarStuff, n: uint32): bool = + return self.tab.MutateSlot(34, n) +func maybeU32*(self: ScalarStuff): Option[uint32] = + let o = self.tab.Offset(36) + if o != 0: + return some(Get[uint32](self.tab, self.tab.Pos + o)) +func `maybeU32=`*(self: var ScalarStuff, n: Option[uint32]): bool = + return self.tab.MutateSlot(36, n) +func defaultU32*(self: ScalarStuff): uint32 = + let o = self.tab.Offset(38) + if o != 0: + return Get[uint32](self.tab, self.tab.Pos + o) + return 42 +func `defaultU32=`*(self: var ScalarStuff, n: uint32): bool = + return self.tab.MutateSlot(38, n) +func justI64*(self: ScalarStuff): int64 = + let o = self.tab.Offset(40) + if o != 0: + return Get[int64](self.tab, self.tab.Pos + o) + return 0 +func `justI64=`*(self: var ScalarStuff, n: int64): bool = + return self.tab.MutateSlot(40, n) +func maybeI64*(self: ScalarStuff): Option[int64] = + let o = self.tab.Offset(42) + if o != 0: + return some(Get[int64](self.tab, self.tab.Pos + o)) +func `maybeI64=`*(self: var ScalarStuff, n: Option[int64]): bool = + return self.tab.MutateSlot(42, n) +func defaultI64*(self: ScalarStuff): int64 = + let o = self.tab.Offset(44) + if o != 0: + return Get[int64](self.tab, self.tab.Pos + o) + return 42 +func `defaultI64=`*(self: var ScalarStuff, n: int64): bool = + return self.tab.MutateSlot(44, n) +func justU64*(self: ScalarStuff): uint64 = + let o = self.tab.Offset(46) + if o != 0: + return Get[uint64](self.tab, self.tab.Pos + o) + return 0 +func `justU64=`*(self: var ScalarStuff, n: uint64): bool = + return self.tab.MutateSlot(46, n) +func maybeU64*(self: ScalarStuff): Option[uint64] = + let o = self.tab.Offset(48) + if o != 0: + return some(Get[uint64](self.tab, self.tab.Pos + o)) +func `maybeU64=`*(self: var ScalarStuff, n: Option[uint64]): bool = + return self.tab.MutateSlot(48, n) +func defaultU64*(self: ScalarStuff): uint64 = + let o = self.tab.Offset(50) + if o != 0: + return Get[uint64](self.tab, self.tab.Pos + o) + return 42 +func `defaultU64=`*(self: var ScalarStuff, n: uint64): bool = + return self.tab.MutateSlot(50, n) +func justF32*(self: ScalarStuff): float32 = + let o = self.tab.Offset(52) + if o != 0: + return Get[float32](self.tab, self.tab.Pos + o) + return 0.0 +func `justF32=`*(self: var ScalarStuff, n: float32): bool = + return self.tab.MutateSlot(52, n) +func maybeF32*(self: ScalarStuff): Option[float32] = + let o = self.tab.Offset(54) + if o != 0: + return some(Get[float32](self.tab, self.tab.Pos + o)) +func `maybeF32=`*(self: var ScalarStuff, n: Option[float32]): bool = + return self.tab.MutateSlot(54, n) +func defaultF32*(self: ScalarStuff): float32 = + let o = self.tab.Offset(56) + if o != 0: + return Get[float32](self.tab, self.tab.Pos + o) + return 42.0 +func `defaultF32=`*(self: var ScalarStuff, n: float32): bool = + return self.tab.MutateSlot(56, n) +func justF64*(self: ScalarStuff): float64 = + let o = self.tab.Offset(58) + if o != 0: + return Get[float64](self.tab, self.tab.Pos + o) + return 0.0 +func `justF64=`*(self: var ScalarStuff, n: float64): bool = + return self.tab.MutateSlot(58, n) +func maybeF64*(self: ScalarStuff): Option[float64] = + let o = self.tab.Offset(60) + if o != 0: + return some(Get[float64](self.tab, self.tab.Pos + o)) +func `maybeF64=`*(self: var ScalarStuff, n: Option[float64]): bool = + return self.tab.MutateSlot(60, n) +func defaultF64*(self: ScalarStuff): float64 = + let o = self.tab.Offset(62) + if o != 0: + return Get[float64](self.tab, self.tab.Pos + o) + return 42.0 +func `defaultF64=`*(self: var ScalarStuff, n: float64): bool = + return self.tab.MutateSlot(62, n) +func justBool*(self: ScalarStuff): bool = + let o = self.tab.Offset(64) + if o != 0: + return Get[bool](self.tab, self.tab.Pos + o) + return false +func `justBool=`*(self: var ScalarStuff, n: bool): bool = + return self.tab.MutateSlot(64, n) +func maybeBool*(self: ScalarStuff): Option[bool] = + let o = self.tab.Offset(66) + if o != 0: + return some(Get[bool](self.tab, self.tab.Pos + o)) +func `maybeBool=`*(self: var ScalarStuff, n: Option[bool]): bool = + return self.tab.MutateSlot(66, n) +func defaultBool*(self: ScalarStuff): bool = + let o = self.tab.Offset(68) + if o != 0: + return Get[bool](self.tab, self.tab.Pos + o) + return true +func `defaultBool=`*(self: var ScalarStuff, n: bool): bool = + return self.tab.MutateSlot(68, n) +func justEnum*(self: ScalarStuff): optional_scalars_OptionalByte.OptionalByte = + let o = self.tab.Offset(70) + if o != 0: + return optional_scalars_OptionalByte.OptionalByte(Get[int8](self.tab, self.tab.Pos + o)) + return type(result)(0) +func `justEnum=`*(self: var ScalarStuff, n: optional_scalars_OptionalByte.OptionalByte): bool = + return self.tab.MutateSlot(70, n) +func maybeEnum*(self: ScalarStuff): Option[optional_scalars_OptionalByte.OptionalByte] = + let o = self.tab.Offset(72) + if o != 0: + return some(optional_scalars_OptionalByte.OptionalByte(Get[int8](self.tab, self.tab.Pos + o))) +func `maybeEnum=`*(self: var ScalarStuff, n: Option[optional_scalars_OptionalByte.OptionalByte]): bool = + return self.tab.MutateSlot(72, n) +func defaultEnum*(self: ScalarStuff): optional_scalars_OptionalByte.OptionalByte = + let o = self.tab.Offset(74) + if o != 0: + return optional_scalars_OptionalByte.OptionalByte(Get[int8](self.tab, self.tab.Pos + o)) + return type(result)(1) +func `defaultEnum=`*(self: var ScalarStuff, n: optional_scalars_OptionalByte.OptionalByte): bool = + return self.tab.MutateSlot(74, n) +proc ScalarStuffStart*(builder: var Builder) = + builder.StartObject(36) +proc ScalarStuffAddjustI8*(builder: var Builder, justI8: int8) = + builder.PrependSlot(0, justI8, default(int8)) +proc ScalarStuffAddmaybeI8*(builder: var Builder, maybeI8: int8) = + builder.PrependSlot(1, maybeI8, default(int8)) +proc ScalarStuffAdddefaultI8*(builder: var Builder, defaultI8: int8) = + builder.PrependSlot(2, defaultI8, default(int8)) +proc ScalarStuffAddjustU8*(builder: var Builder, justU8: uint8) = + builder.PrependSlot(3, justU8, default(uint8)) +proc ScalarStuffAddmaybeU8*(builder: var Builder, maybeU8: uint8) = + builder.PrependSlot(4, maybeU8, default(uint8)) +proc ScalarStuffAdddefaultU8*(builder: var Builder, defaultU8: uint8) = + builder.PrependSlot(5, defaultU8, default(uint8)) +proc ScalarStuffAddjustI16*(builder: var Builder, justI16: int16) = + builder.PrependSlot(6, justI16, default(int16)) +proc ScalarStuffAddmaybeI16*(builder: var Builder, maybeI16: int16) = + builder.PrependSlot(7, maybeI16, default(int16)) +proc ScalarStuffAdddefaultI16*(builder: var Builder, defaultI16: int16) = + builder.PrependSlot(8, defaultI16, default(int16)) +proc ScalarStuffAddjustU16*(builder: var Builder, justU16: uint16) = + builder.PrependSlot(9, justU16, default(uint16)) +proc ScalarStuffAddmaybeU16*(builder: var Builder, maybeU16: uint16) = + builder.PrependSlot(10, maybeU16, default(uint16)) +proc ScalarStuffAdddefaultU16*(builder: var Builder, defaultU16: uint16) = + builder.PrependSlot(11, defaultU16, default(uint16)) +proc ScalarStuffAddjustI32*(builder: var Builder, justI32: int32) = + builder.PrependSlot(12, justI32, default(int32)) +proc ScalarStuffAddmaybeI32*(builder: var Builder, maybeI32: int32) = + builder.PrependSlot(13, maybeI32, default(int32)) +proc ScalarStuffAdddefaultI32*(builder: var Builder, defaultI32: int32) = + builder.PrependSlot(14, defaultI32, default(int32)) +proc ScalarStuffAddjustU32*(builder: var Builder, justU32: uint32) = + builder.PrependSlot(15, justU32, default(uint32)) +proc ScalarStuffAddmaybeU32*(builder: var Builder, maybeU32: uint32) = + builder.PrependSlot(16, maybeU32, default(uint32)) +proc ScalarStuffAdddefaultU32*(builder: var Builder, defaultU32: uint32) = + builder.PrependSlot(17, defaultU32, default(uint32)) +proc ScalarStuffAddjustI64*(builder: var Builder, justI64: int64) = + builder.PrependSlot(18, justI64, default(int64)) +proc ScalarStuffAddmaybeI64*(builder: var Builder, maybeI64: int64) = + builder.PrependSlot(19, maybeI64, default(int64)) +proc ScalarStuffAdddefaultI64*(builder: var Builder, defaultI64: int64) = + builder.PrependSlot(20, defaultI64, default(int64)) +proc ScalarStuffAddjustU64*(builder: var Builder, justU64: uint64) = + builder.PrependSlot(21, justU64, default(uint64)) +proc ScalarStuffAddmaybeU64*(builder: var Builder, maybeU64: uint64) = + builder.PrependSlot(22, maybeU64, default(uint64)) +proc ScalarStuffAdddefaultU64*(builder: var Builder, defaultU64: uint64) = + builder.PrependSlot(23, defaultU64, default(uint64)) +proc ScalarStuffAddjustF32*(builder: var Builder, justF32: float32) = + builder.PrependSlot(24, justF32, default(float32)) +proc ScalarStuffAddmaybeF32*(builder: var Builder, maybeF32: float32) = + builder.PrependSlot(25, maybeF32, default(float32)) +proc ScalarStuffAdddefaultF32*(builder: var Builder, defaultF32: float32) = + builder.PrependSlot(26, defaultF32, default(float32)) +proc ScalarStuffAddjustF64*(builder: var Builder, justF64: float64) = + builder.PrependSlot(27, justF64, default(float64)) +proc ScalarStuffAddmaybeF64*(builder: var Builder, maybeF64: float64) = + builder.PrependSlot(28, maybeF64, default(float64)) +proc ScalarStuffAdddefaultF64*(builder: var Builder, defaultF64: float64) = + builder.PrependSlot(29, defaultF64, default(float64)) +proc ScalarStuffAddjustBool*(builder: var Builder, justBool: bool) = + builder.PrependSlot(30, justBool, default(bool)) +proc ScalarStuffAddmaybeBool*(builder: var Builder, maybeBool: bool) = + builder.PrependSlot(31, maybeBool, default(bool)) +proc ScalarStuffAdddefaultBool*(builder: var Builder, defaultBool: bool) = + builder.PrependSlot(32, defaultBool, default(bool)) +proc ScalarStuffAddjustEnum*(builder: var Builder, justEnum: int8) = + builder.PrependSlot(33, justEnum, default(int8)) +proc ScalarStuffAddmaybeEnum*(builder: var Builder, maybeEnum: int8) = + builder.PrependSlot(34, maybeEnum, default(int8)) +proc ScalarStuffAdddefaultEnum*(builder: var Builder, defaultEnum: int8) = + builder.PrependSlot(35, defaultEnum, default(int8)) +proc ScalarStuffEnd*(builder: var Builder): uoffset = + return builder.EndObject() From e6dacdfa0aa4530a462d6de38d56e26ddc56486c Mon Sep 17 00:00:00 2001 From: Dan Lapid Date: Fri, 21 Oct 2022 16:58:31 +0300 Subject: [PATCH 29/29] Revert whitespace removal --- scripts/generate_code.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/scripts/generate_code.py b/scripts/generate_code.py index 44eaeb997bf..96a7b8eaa99 100755 --- a/scripts/generate_code.py +++ b/scripts/generate_code.py @@ -305,8 +305,8 @@ def glob(path, pattern): # Generate the annotated binary of the monster_test binary schema. flatc_annotate( - schema="../reflection/reflection.fbs", - file="monster_test.bfbs", + schema="../reflection/reflection.fbs", + file="monster_test.bfbs", include="include_test" )