BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-16 17:22:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

[C++] Refactor to conform to Google C++ style guide (#5608)

Browse Source 
* Automatic refractor of C++ headers to Google C++ style guide

* Automatic refractor of C++ source to Google C++ style guide

* Automatic refractor of C++ tests to Google C++ style guide

* Fixed clang-format issues by running clang-format twice to correct itself. Kotlin was missing clang-format on after turning it off, so it was changed,
This commit is contained in:
Derek Bailey
2019-11-07 12:22:54 -08:00
committed by Wouter van Oortmerssen
parent e837d5a296
commit f0f0efe7b8
36 changed files with 3157 additions and 3294 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
src/idl_gen_lobster.cpp
View File

@@ -27,14 +27,16 @@ namespace lobster {
class LobsterGenerator : public BaseGenerator {
public:
LobsterGenerator(const Parser &parser, const std::string &path,
const std::string &file_name)
LobsterGenerator(const Parser &parser, const std::string &path,
const std::string &file_name)
: BaseGenerator(parser, path, file_name, "" /* not used */, "_") {
static const char * const keywords[] = {
"nil", "true", "false", "return", "struct", "class", "import", "int",
"float", "string", "any", "def", "is", "from", "program", "private",
"coroutine", "resource", "enum", "typeof", "var", "let", "pakfile",
"switch", "case", "default", "namespace", "not", "and", "or", "bool",
static const char *const keywords[] = {
"nil", "true", "false", "return", "struct", "class",
"import", "int", "float", "string", "any", "def",
"is", "from", "program", "private", "coroutine", "resource",
"enum", "typeof", "var", "let", "pakfile", "switch",
"case", "default", "namespace", "not", "and", "or",
"bool",
};
keywords_.insert(std::begin(keywords), std::end(keywords));
}
@@ -66,7 +68,8 @@ class LobsterGenerator : public BaseGenerator {
std::string LobsterType(const Type &type) {
if (IsFloat(type.base_type)) return "float";
if (IsScalar(type.base_type) && type.enum_def) return NormalizedName(*type.enum_def);
if (IsScalar(type.base_type) && type.enum_def)
return NormalizedName(*type.enum_def);
if (!IsScalar(type.base_type)) return "flatbuffers_offset";
return "int";
}
@@ -74,14 +77,14 @@ class LobsterGenerator : public BaseGenerator {
// Returns the method name for use with add/put calls.
std::string GenMethod(const Type &type) {
return IsScalar(type.base_type)
? MakeCamel(GenTypeBasic(type))
: (IsStruct(type) ? "Struct" : "UOffsetTRelative");
? MakeCamel(GenTypeBasic(type))
: (IsStruct(type) ? "Struct" : "UOffsetTRelative");
}
// This uses Python names for now..
std::string GenTypeBasic(const Type &type) {
static const char *ctypename[] = {
// clang-format off
// clang-format off
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
#PTYPE,
@@ -93,8 +96,8 @@ class LobsterGenerator : public BaseGenerator {
}
// Generate a struct field, conditioned on its child type(s).
void GenStructAccessor(const StructDef &struct_def,
const FieldDef &field, std::string *code_ptr) {
void GenStructAccessor(const StructDef &struct_def, const FieldDef &field,
std::string *code_ptr) {
GenComment(field.doc_comment, code_ptr, nullptr, " ");
std::string &code = *code_ptr;
auto offsets = NumToString(field.value.offset);
@@ -102,13 +105,12 @@ class LobsterGenerator : public BaseGenerator {
if (IsScalar(field.value.type.base_type)) {
std::string acc;
if (struct_def.fixed) {
acc = "buf_.read_" + GenTypeName(field.value.type) +
"_le(pos_ + " + offsets + ")";
acc = "buf_.read_" + GenTypeName(field.value.type) + "_le(pos_ + " +
offsets + ")";
} else {
acc = "buf_.flatbuffers_field_" +
GenTypeName(field.value.type) + "(pos_, " + offsets + ", " +
field.value.constant + ")";
acc = "buf_.flatbuffers_field_" + GenTypeName(field.value.type) +
"(pos_, " + offsets + ", " + field.value.constant + ")";
}
if (field.value.type.enum_def)
acc = NormalizedName(*field.value.type.enum_def) + "(" + acc + ")";
@@ -130,7 +132,8 @@ class LobsterGenerator : public BaseGenerator {
break;
}
case BASE_TYPE_STRING:
code += def + "():\n return buf_.flatbuffers_field_string(pos_, " +
code += def +
"():\n return buf_.flatbuffers_field_string(pos_, " +
offsets + ")\n";
break;
case BASE_TYPE_VECTOR: {
@@ -171,19 +174,20 @@ class LobsterGenerator : public BaseGenerator {
}
if (field.value.type.base_type == BASE_TYPE_VECTOR) {
code += def +
"_length():\n return buf_.flatbuffers_field_vector_len(pos_, " +
"_length():\n return "
"buf_.flatbuffers_field_vector_len(pos_, " +
offsets + ")\n";
}
}
// Generate table constructors, conditioned on its members' types.
void GenTableBuilders(const StructDef &struct_def,
std::string *code_ptr) {
void GenTableBuilders(const StructDef &struct_def, std::string *code_ptr) {
std::string &code = *code_ptr;
code += "struct " + NormalizedName(struct_def) +
"Builder:\n b_:flatbuffers_builder\n";
code += " def start():\n b_.StartObject(" +
NumToString(struct_def.fields.vec.size()) + ")\n return this\n";
NumToString(struct_def.fields.vec.size()) +
")\n return this\n";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
auto &field = **it;
@@ -209,8 +213,8 @@ class LobsterGenerator : public BaseGenerator {
auto vector_type = field.value.type.VectorType();
auto alignment = InlineAlignment(vector_type);
auto elem_size = InlineSize(vector_type);
code += NumToString(elem_size) + ", n_, " + NumToString(alignment) +
")\n";
code +=
NumToString(elem_size) + ", n_, " + NumToString(alignment) + ")\n";
if (vector_type.base_type != BASE_TYPE_STRUCT ||
!vector_type.struct_def->fixed) {
code += "def " + NormalizedName(struct_def) + "Create" +
@@ -218,8 +222,7 @@ class LobsterGenerator : public BaseGenerator {
"Vector(b_:flatbuffers_builder, v_:[" +
LobsterType(vector_type) + "]):\n b_.StartVector(" +
NumToString(elem_size) + ", v_.length, " +
NumToString(alignment) +
")\n reverse(v_) e_: b_.Prepend" +
NumToString(alignment) + ")\n reverse(v_) e_: b_.Prepend" +
GenMethod(vector_type) +
"(e_)\n return b_.EndVector(v_.length)\n";
}
@@ -243,7 +246,7 @@ class LobsterGenerator : public BaseGenerator {
GenComment(struct_def.doc_comment, code_ptr, nullptr, "");
code += "class " + NormalizedName(struct_def) + " : flatbuffers_handle\n";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
it != struct_def.fields.vec.end(); ++it) {
auto &field = **it;
if (field.deprecated) continue;
GenStructAccessor(struct_def, field, code_ptr);
@@ -252,8 +255,8 @@ class LobsterGenerator : public BaseGenerator {
if (!struct_def.fixed) {
// Generate a special accessor for the table that has been declared as
// the root type.
code += "def GetRootAs" + NormalizedName(struct_def) + "(buf:string): return " +
NormalizedName(struct_def) +
code += "def GetRootAs" + NormalizedName(struct_def) +
"(buf:string): return " + NormalizedName(struct_def) +
" { buf, buf.flatbuffers_indirect(0) }\n\n";
}
if (struct_def.fixed) {
@@ -283,8 +286,8 @@ class LobsterGenerator : public BaseGenerator {
// Recursively generate arguments for a constructor, to deal with nested
// structs.
void StructBuilderArgs(const StructDef &struct_def,
const char *nameprefix, std::string *code_ptr) {
void StructBuilderArgs(const StructDef &struct_def, const char *nameprefix,
std::string *code_ptr) {
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
auto &field = **it;
@@ -293,7 +296,8 @@ class LobsterGenerator : public BaseGenerator {
// don't clash, and to make it obvious these arguments are constructing
// a nested struct, prefix the name with the field name.
StructBuilderArgs(*field.value.type.struct_def,
(nameprefix + (NormalizedName(field) + "_")).c_str(), code_ptr);
(nameprefix + (NormalizedName(field) + "_")).c_str(),
code_ptr);
} else {
std::string &code = *code_ptr;
code += ", " + (nameprefix + NormalizedName(field)) + ":" +
@@ -304,8 +308,8 @@ class LobsterGenerator : public BaseGenerator {
// Recursively generate struct construction statements and instert manual
// padding.
void StructBuilderBody(const StructDef &struct_def,
const char *nameprefix, std::string *code_ptr) {
void StructBuilderBody(const StructDef &struct_def, const char *nameprefix,
std::string *code_ptr) {
std::string &code = *code_ptr;
code += " b_.Prep(" + NumToString(struct_def.minalign) + ", " +
NumToString(struct_def.bytesize) + ")\n";
@@ -316,7 +320,8 @@ class LobsterGenerator : public BaseGenerator {
code += " b_.Pad(" + NumToString(field.padding) + ")\n";
if (IsStruct(field.value.type)) {
StructBuilderBody(*field.value.type.struct_def,
(nameprefix + (NormalizedName(field) + "_")).c_str(), code_ptr);
(nameprefix + (NormalizedName(field) + "_")).c_str(),
code_ptr);
} else {
code += " b_.Prepend" + GenMethod(field.value.type) + "(" +
nameprefix + NormalizedName(field) + ")\n";
@@ -325,11 +330,10 @@ class LobsterGenerator : public BaseGenerator {
}
// Create a struct with a builder and the struct's arguments.
void GenStructBuilder(const StructDef &struct_def,
std::string *code_ptr) {
void GenStructBuilder(const StructDef &struct_def, std::string *code_ptr) {
std::string &code = *code_ptr;
code += "def Create" + NormalizedName(struct_def) +
"(b_:flatbuffers_builder";
code +=
"def Create" + NormalizedName(struct_def) + "(b_:flatbuffers_builder";
StructBuilderArgs(struct_def, "", code_ptr);
code += "):\n";
StructBuilderBody(struct_def, "", code_ptr);
@@ -363,8 +367,8 @@ class LobsterGenerator : public BaseGenerator {
auto &struct_def = **it;
GenStruct(struct_def, &code);
}
return SaveFile((path_ + file_name_ + "_generated.lobster").c_str(),
code, false);
return SaveFile((path_ + file_name_ + "_generated.lobster").c_str(), code,
false);
}
private:
@@ -375,7 +379,7 @@ class LobsterGenerator : public BaseGenerator {
} // namespace lobster
bool GenerateLobster(const Parser &parser, const std::string &path,
const std::string &file_name) {
const std::string &file_name) {
lobster::LobsterGenerator generator(parser, path, file_name);
return generator.generate();
}