BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-05 13:08:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

[C#] Fix nested structs and arrays in Object API (#5765)

Browse Source 
* [C#] Fix nested structs and arrays in Object API

The adds support for nested structs and fixed size arrays in the C#
Object API codegen which previously generated invalid code that wouldn't
compile.

- Nested structs would originally generate syntax errors due to adding an
  additional `.` to separate fields.
- Fixed size arrays of nested structs would originally generate code for
  the first field in the top most struct, and would lead to a compiler
  error due to referencing undefined variables.

* [C#] fix nested structs and arrays of structs.

* fix nested structs + arrays

* add table support

* Cleanup code

Co-authored-by: mugisoba <mugisoba+github@icloud.com>
This commit is contained in:
Anass Al
2020-04-06 09:27:13 -07:00
committed by GitHub
parent 408f11fbdd
commit fb96fadc20
2 changed files with 96 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

168
src/idl_gen_csharp.cpp
View File

@@ -38,6 +38,11 @@ static CommentConfig comment_config = {
namespace csharp {
class CSharpGenerator : public BaseGenerator {
struct FieldArrayLength {
std::string name;
int length;
};
public:
CSharpGenerator(const Parser &parser, const std::string &path,
const std::string &file_name)
@@ -1540,6 +1545,15 @@ class CSharpGenerator : public BaseGenerator {
GenOffsetType(*field.value.type.struct_def) +
") : " + GenTypeGet(field.value.type) +
".Pack(builder, _o." + camel_name + ");\n";
} else if (struct_def.fixed && struct_has_create) {
std::vector<FieldArrayLength> array_lengths;
FieldArrayLength tmp_array_length = {
field.name,
field.value.type.fixed_length,
};
array_lengths.push_back(tmp_array_length);
GenStructPackDecl_ObjectAPI(*field.value.type.struct_def, code_ptr,
array_lengths);
}
break;
}
@@ -1620,12 +1634,14 @@ class CSharpGenerator : public BaseGenerator {
}
case BASE_TYPE_ARRAY: {
if (field.value.type.struct_def != nullptr) {
std::vector<std::string> name_vec;
name_vec.push_back(field.name);
std::vector<int> array_length_vec;
array_length_vec.push_back(field.value.type.fixed_length);
GenArrayPackDecl_ObjectAPI(*field.value.type.struct_def, code_ptr,
name_vec, array_length_vec);
std::vector<FieldArrayLength> array_lengths;
FieldArrayLength tmp_array_length = {
field.name,
field.value.type.fixed_length,
};
array_lengths.push_back(tmp_array_length);
GenStructPackDecl_ObjectAPI(*field.value.type.struct_def, code_ptr,
array_lengths);
} else {
code += " var _" + field.name + " = _o." + camel_name + ";\n";
}
@@ -1656,8 +1672,9 @@ class CSharpGenerator : public BaseGenerator {
switch (field.value.type.base_type) {
case BASE_TYPE_STRUCT: {
if (struct_def.fixed) {
GenStructArgs_ObjectAPI(*field.value.type.struct_def, code_ptr,
" _o." + camel_name + ".");
GenStructPackCall_ObjectAPI(*field.value.type.struct_def,
code_ptr,
" _" + field.name + "_");
} else {
code += ",\n";
if (field.value.type.struct_def->fixed) {
@@ -1674,8 +1691,9 @@ class CSharpGenerator : public BaseGenerator {
}
case BASE_TYPE_ARRAY: {
if (field.value.type.struct_def != nullptr) {
GenArrayPackCall_ObjectAPI(*field.value.type.struct_def, code_ptr,
" _" + field.name + "_");
GenStructPackCall_ObjectAPI(*field.value.type.struct_def,
code_ptr,
" _" + field.name + "_");
} else {
code += ",\n";
code += " _" + field.name;
@@ -1745,28 +1763,9 @@ class CSharpGenerator : public BaseGenerator {
code += " }\n";
}
void GenStructArgs_ObjectAPI(const StructDef &struct_def,
std::string *code_ptr,
std::string prefix) const {
auto &code = *code_ptr;
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
auto &field = **it;
const auto &field_type = field.value.type;
if (IsStruct(field_type)) {
GenStructArgs_ObjectAPI(*field_type.struct_def, code_ptr,
prefix + "." + MakeCamel(field.name) + ".");
} else {
code += ",\n";
code += prefix + MakeCamel(field.name);
}
}
}
void GenArrayPackDecl_ObjectAPI(const StructDef &struct_def,
std::string *code_ptr,
std::vector<std::string> name_vec,
std::vector<int> array_length_vec) const {
void GenStructPackDecl_ObjectAPI(
const StructDef &struct_def, std::string *code_ptr,
std::vector<FieldArrayLength> &array_lengths) const {
auto &code = *code_ptr;
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
@@ -1774,64 +1773,81 @@ class CSharpGenerator : public BaseGenerator {
auto is_array = IsArray(field.value.type);
const auto &field_type =
is_array ? field.value.type.VectorType() : field.value.type;
if (!IsStruct(field_type)) {
auto tmp_name_vec = name_vec;
tmp_name_vec.push_back(field.name);
auto tmp_array_length_vec = array_length_vec;
if (is_array) {
tmp_array_length_vec.push_back(field_type.fixed_length);
FieldArrayLength tmp_array_length = {
field.name,
field_type.fixed_length,
};
array_lengths.push_back(tmp_array_length);
if (field_type.struct_def != nullptr) {
GenStructPackDecl_ObjectAPI(*field_type.struct_def, code_ptr,
array_lengths);
} else {
std::vector<FieldArrayLength> array_only_lengths;
for (size_t i = 0; i < array_lengths.size(); ++i) {
if (array_lengths[i].length > 0) {
array_only_lengths.push_back(array_lengths[i]);
}
}
std::string name;
for (size_t tmp_name_index = 0; tmp_name_index < tmp_name_vec.size();
++tmp_name_index) {
name += "_" + tmp_name_vec[tmp_name_index];
for (size_t i = 0; i < array_lengths.size(); ++i) {
name += "_" + array_lengths[i].name;
}
code += " var " + name + " = new " + GenTypeBasic(field_type) + "[";
code += NumToString(tmp_array_length_vec[0]);
for (size_t i = 1; i < tmp_array_length_vec.size(); ++i) {
auto array_length = tmp_array_length_vec[i];
code += "," + NumToString(array_length);
}
code += "];\n";
code += " ";
// initialize array
for (size_t i = 0; i < tmp_array_length_vec.size(); ++i) {
auto array_length = tmp_array_length_vec[i];
auto idx = "idx" + NumToString(i);
code += "for (var " + idx + " = 0; " + idx + " < " +
NumToString(array_length) + "; ++" + idx + ") {";
}
code += name + "[idx0";
for (size_t i = 1; i < tmp_array_length_vec.size(); ++i) {
auto idx = "idx" + NumToString(i);
code += "," + idx;
}
code += "] = _o";
for (size_t i = 0; i < tmp_array_length_vec.size(); ++i) {
auto idx = "idx" + NumToString(i);
code += "." + MakeCamel(tmp_name_vec[i]) + "[" + idx + "]";
}
if (!is_array) { code += "." + MakeCamel(field.name); }
code += ";";
for (size_t i = 0; i < tmp_array_length_vec.size(); ++i) {
code += "}";
code += " var " + name + " = ";
if (array_only_lengths.size() > 0) {
code += "new " + GenTypeBasic(field_type) + "[";
for (size_t i = 0; i < array_only_lengths.size(); ++i) {
if (i != 0) { code += ","; }
code += NumToString(array_only_lengths[i].length);
}
code += "];\n";
code += " ";
// initialize array
for (size_t i = 0; i < array_only_lengths.size(); ++i) {
auto idx = "idx" + NumToString(i);
code += "for (var " + idx + " = 0; " + idx + " < " +
NumToString(array_only_lengths[i].length) + "; ++" + idx +
") {";
}
for (size_t i = 0; i < array_only_lengths.size(); ++i) {
auto idx = "idx" + NumToString(i);
if (i == 0) {
code += name + "[" + idx;
} else {
code += "," + idx;
}
}
code += "] = _o";
for (size_t i = 0, j = 0; i < array_lengths.size(); ++i) {
code += "." + MakeCamel(array_lengths[i].name);
if (array_lengths[i].length <= 0) continue;
code += "[idx" + NumToString(j++) + "]";
}
code += ";";
for (size_t i = 0; i < array_only_lengths.size(); ++i) { code += "}"; }
} else {
code += "_o";
for (size_t i = 0; i < array_lengths.size(); ++i) {
code += "." + MakeCamel(array_lengths[i].name);
}
code += ";";
}
code += "\n";
}
array_lengths.pop_back();
}
}
void GenArrayPackCall_ObjectAPI(const StructDef &struct_def,
std::string *code_ptr,
std::string prefix) const {
void GenStructPackCall_ObjectAPI(const StructDef &struct_def,
std::string *code_ptr,
std::string prefix) const {
auto &code = *code_ptr;
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
auto &field = **it;
const auto &field_type = field.value.type;
if (IsStruct(field_type)) {
GenArrayPackCall_ObjectAPI(*field_type.struct_def, code_ptr,
prefix + field.name + "_");
if (field_type.struct_def != nullptr) {
GenStructPackCall_ObjectAPI(*field_type.struct_def, code_ptr,
prefix + field.name + "_");
} else {
code += ",\n";
code += prefix + field.name;