Skip to content

F
flatbuffers
Commit a9194c4c authored by lakedaemon's avatar lakedaemon
Browse files
Options

cpp generator : pulling all methods inside the class

parent ca32eb77
Show whitespace changes
Inline Side-by-side
Showing with 370 additions and 384 deletions
src/idl_gen_cpp.cpp
View file @ a9194c4c
......@@ -22,72 +22,247 @@
#include "flatbuffers/code_generators.h"
namespace flatbuffers {
struct IsAlnum {
bool operator()(char c) {
return !isalnum(c);
}
};
static std::string GeneratedFileName(const std::string &path,
const std::string &file_name) {
return path + file_name + "_generated.h";
}
namespace cpp {
class CppGenerator : public BaseGenerator {
public:
CppGenerator(const Parser &parser, const std::string &path,
const std::string &file_name)
: BaseGenerator(parser, path, file_name){};
// Iterate through all definitions we haven't generate code for (enums,
// structs,
// and tables) and output them to a single file.
bool generate() {
if (IsEverythingGenerated()) return true;
std::string code;
code = code + "// " + FlatBuffersGeneratedWarning();
// Generate include guard.
std::string include_guard_ident = file_name_;
// Remove any non-alpha-numeric characters that may appear in a filename.
include_guard_ident.erase(
std::remove_if(include_guard_ident.begin(), include_guard_ident.end(),
IsAlnum()),
include_guard_ident.end());
std::string include_guard = "FLATBUFFERS_GENERATED_" + include_guard_ident;
include_guard += "_";
// For further uniqueness, also add the namespace.
auto name_space = parser_.namespaces_.back();
for (auto it = name_space->components.begin();
it != name_space->components.end(); ++it) {
include_guard += *it + "_";
}
include_guard += "H_";
std::transform(include_guard.begin(), include_guard.end(),
include_guard.begin(), ::toupper);
code += "#ifndef " + include_guard + "\n";
code += "#define " + include_guard + "\n\n";
code += "#include \"flatbuffers/flatbuffers.h\"\n\n";
if (parser_.opts.include_dependence_headers) {
int num_includes = 0;
for (auto it = parser_.included_files_.begin();
it != parser_.included_files_.end(); ++it) {
auto basename =
flatbuffers::StripPath(flatbuffers::StripExtension(it->first));
if (basename != file_name_) {
code += "#include \"" + basename + "_generated.h\"\n";
num_includes++;
}
}
if (num_includes) code += "\n";
}
assert(!code_generator_cur_name_space);
// Generate forward declarations for all structs/tables, since they may
// have circular references.
for (auto it = parser_.structs_.vec.begin();
it != parser_.structs_.vec.end(); ++it) {
auto &struct_def = **it;
if (!struct_def.generated) {
CheckNameSpace(struct_def, &code);
code += "struct " + struct_def.name + ";\n\n";
}
}
// Generate code for all the enum declarations.
for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
++it) {
auto &enum_def = **it;
if (!enum_def.generated) {
CheckNameSpace(**it, &code);
GenEnum(**it, &code);
}
}
// This tracks the current namespace so we can insert namespace declarations.
// TODO(wvo): this needs to be moved into a code generator context object.
static const Namespace *code_generator_cur_name_space = nullptr;
// Generate code for all structs, then all tables.
for (auto it = parser_.structs_.vec.begin();
it != parser_.structs_.vec.end(); ++it) {
auto &struct_def = **it;
if (struct_def.fixed && !struct_def.generated) {
CheckNameSpace(struct_def, &code);
GenStruct(struct_def, &code);
}
}
for (auto it = parser_.structs_.vec.begin();
it != parser_.structs_.vec.end(); ++it) {
auto &struct_def = **it;
if (!struct_def.fixed && !struct_def.generated) {
CheckNameSpace(struct_def, &code);
GenTable(struct_def, &code);
}
}
// Ensure that a type is prefixed with its namespace whenever it is used
// outside of its namespace.
static std::string WrapInNameSpace(const Namespace *ns,
const std::string &name) {
// Generate code for union verifiers.
for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
++it) {
auto &enum_def = **it;
if (enum_def.is_union && !enum_def.generated) {
CheckNameSpace(enum_def, &code);
GenEnumPost(enum_def, &code);
}
}
// Generate convenient global helper functions:
if (parser_.root_struct_def_) {
CheckNameSpace(*parser_.root_struct_def_, &code);
auto &name = parser_.root_struct_def_->name;
std::string qualified_name =
parser_.namespaces_.back()->GetFullyQualifiedName(name);
std::string cpp_qualified_name = TranslateNameSpace(qualified_name);
// The root datatype accessor:
code += "inline const " + cpp_qualified_name + " *Get";
code += name;
code += "(const void *buf) { return flatbuffers::GetRoot<";
code += cpp_qualified_name + ">(buf); }\n\n";
if (parser_.opts.mutable_buffer) {
code += "inline " + name + " *GetMutable";
code += name;
code += "(void *buf) { return flatbuffers::GetMutableRoot<";
code += name + ">(buf); }\n\n";
}
// The root verifier:
code += "inline bool Verify";
code += name;
code +=
"Buffer(flatbuffers::Verifier &verifier) { "
"return verifier.VerifyBuffer<";
code += cpp_qualified_name + ">(); }\n\n";
if (parser_.file_identifier_.length()) {
// Return the identifier
code += "inline const char *" + name;
code += "Identifier() { return \"" + parser_.file_identifier_;
code += "\"; }\n\n";
// Check if a buffer has the identifier.
code += "inline bool " + name;
code += "BufferHasIdentifier(const void *buf) { return flatbuffers::";
code += "BufferHasIdentifier(buf, ";
code += name + "Identifier()); }\n\n";
}
if (parser_.file_extension_.length()) {
// Return the extension
code += "inline const char *" + name;
code += "Extension() { return \"" + parser_.file_extension_;
code += "\"; }\n\n";
}
// Finish a buffer with a given root object:
code += "inline void Finish" + name;
code +=
"Buffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset<";
code += cpp_qualified_name + "> root) { fbb.Finish(root";
if (parser_.file_identifier_.length())
code += ", " + name + "Identifier()";
code += "); }\n\n";
}
assert(code_generator_cur_name_space);
CloseNestedNameSpaces(code_generator_cur_name_space, &code);
code_generator_cur_name_space = nullptr;
// Close the include guard.
code += "\n#endif // " + include_guard + "\n";
return SaveFile(GeneratedFileName(path_, file_name_).c_str(), code, false);
}
private:
// This tracks the current namespace so we can insert namespace declarations.
const Namespace *code_generator_cur_name_space = nullptr;
// Ensure that a type is prefixed with its namespace whenever it is used
// outside of its namespace.
std::string WrapInNameSpace(const Namespace *ns, const std::string &name) {
if (code_generator_cur_name_space != ns) {
std::string qualified_name;
for (auto it = ns->components.begin();
it != ns->components.end(); ++it) {
for (auto it = ns->components.begin(); it != ns->components.end(); ++it) {
qualified_name += *it + "::";
}
return qualified_name + name;
} else {
return name;
}
}
}
static std::string WrapInNameSpace(const Definition &def) {
std::string WrapInNameSpace(const Definition &def) {
return WrapInNameSpace(def.defined_namespace, def.name);
}
}
// Translates a qualified name in flatbuffer text format to the same name in
// the equivalent C++ namespace.
static std::string TranslateNameSpace(const std::string &qualified_name) {
// Translates a qualified name in flatbuffer text format to the same name in
// the equivalent C++ namespace.
static std::string TranslateNameSpace(const std::string &qualified_name) {
std::string cpp_qualified_name = qualified_name;
size_t start_pos = 0;
while((start_pos = cpp_qualified_name.find(".", start_pos)) !=
while ((start_pos = cpp_qualified_name.find(".", start_pos)) !=
std::string::npos) {
cpp_qualified_name.replace(start_pos, 1, "::");
}
return cpp_qualified_name;
}
}
// Return a C++ type from the table in idl.h
static std::string GenTypeBasic(const Type &type, bool user_facing_type) {
// Return a C++ type from the table in idl.h
std::string GenTypeBasic(const Type &type, bool user_facing_type) {
static const char *ctypename[] = {
#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \
#CTYPE,
#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) #CTYPE,
FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
#undef FLATBUFFERS_TD
#undef FLATBUFFERS_TD
};
if (user_facing_type) {
if (type.enum_def) return WrapInNameSpace(*type.enum_def);
if (type.base_type == BASE_TYPE_BOOL) return "bool";
}
return ctypename[type.base_type];
}
static std::string GenTypeWire(const Parser &parser, const Type &type,
const char *postfix, bool user_facing_type);
}
// Return a C++ pointer type, specialized to the actual struct/table types,
// and vector element types.
static std::string GenTypePointer(const Parser &parser, const Type &type) {
// Return a C++ pointer type, specialized to the actual struct/table types,
// and vector element types.
std::string GenTypePointer(const Type &type) {
switch (type.base_type) {
case BASE_TYPE_STRING:
return "flatbuffers::String";
case BASE_TYPE_VECTOR:
return "flatbuffers::Vector<" +
GenTypeWire(parser, type.VectorType(), "", false) + ">";
GenTypeWire(type.VectorType(), "", false) + ">";
case BASE_TYPE_STRUCT: {
return WrapInNameSpace(*type.struct_def);
}
......@@ -96,51 +271,52 @@ static std::string GenTypePointer(const Parser &parser, const Type &type) {
default:
return "void";
}
}
}
// Return a C++ type for any type (scalar/pointer) specifically for
// building a flatbuffer.
static std::string GenTypeWire(const Parser &parser, const Type &type,
// Return a C++ type for any type (scalar/pointer) specifically for
// building a flatbuffer.
std::string GenTypeWire(const Type &type,
const char *postfix, bool user_facing_type) {
return IsScalar(type.base_type)
? GenTypeBasic(type, user_facing_type) + postfix
: IsStruct(type)
? "const " + GenTypePointer(parser, type) + " *"
: "flatbuffers::Offset<" + GenTypePointer(parser, type) + ">" + postfix;
}
? "const " + GenTypePointer(type) + " *"
: "flatbuffers::Offset<" + GenTypePointer(type) +
">" + postfix;
}
// Return a C++ type for any type (scalar/pointer) that reflects its
// serialized size.
static std::string GenTypeSize(const Parser &parser, const Type &type) {
// Return a C++ type for any type (scalar/pointer) that reflects its
// serialized size.
std::string GenTypeSize(const Type &type) {
return IsScalar(type.base_type)
? GenTypeBasic(type, false)
: IsStruct(type)
? GenTypePointer(parser, type)
: IsStruct(type) ? GenTypePointer(type)
: "flatbuffers::uoffset_t";
}
}
// Return a C++ type for any type (scalar/pointer) specifically for
// using a flatbuffer.
static std::string GenTypeGet(const Parser &parser, const Type &type,
// Return a C++ type for any type (scalar/pointer) specifically for
// using a flatbuffer.
std::string GenTypeGet(const Type &type,
const char *afterbasic, const char *beforeptr,
const char *afterptr, bool user_facing_type) {
return IsScalar(type.base_type)
? GenTypeBasic(type, user_facing_type) + afterbasic
: beforeptr + GenTypePointer(parser, type) + afterptr;
}
: beforeptr + GenTypePointer(type) + afterptr;
}
static std::string GenEnumDecl(const EnumDef &enum_def,
static std::string GenEnumDecl(const EnumDef &enum_def,
const IDLOptions &opts) {
return (opts.scoped_enums ? "enum class " : "enum ") + enum_def.name;
}
}
static std::string GenEnumVal(const EnumDef &enum_def,
static std::string GenEnumVal(const EnumDef &enum_def,
const std::string &enum_val,
const IDLOptions &opts) {
return opts.prefixed_enums ? enum_def.name + "_" + enum_val : enum_val;
}
}
static std::string GetEnumVal(const EnumDef &enum_def, const EnumVal &enum_val,
static std::string GetEnumVal(const EnumDef &enum_def,
const EnumVal &enum_val,
const IDLOptions &opts) {
if (opts.scoped_enums) {
return enum_def.name + "::" + enum_val.name;
......@@ -149,70 +325,70 @@ static std::string GetEnumVal(const EnumDef &enum_def, const EnumVal &enum_val,
} else {
return enum_val.name;
}
}
}
std::string EnumSignature(EnumDef &enum_def) {
std::string EnumSignature(EnumDef &enum_def) {
return "inline bool Verify" + enum_def.name +
"(flatbuffers::Verifier &verifier, " +
"const void *union_obj, " + enum_def.name + " type)";
}
"(flatbuffers::Verifier &verifier, " + "const void *union_obj, " +
enum_def.name + " type)";
}
// Generate an enum declaration and an enum string lookup table.
static void GenEnum(const Parser &parser, EnumDef &enum_def,
std::string *code_ptr) {
// Generate an enum declaration and an enum string lookup table.
void GenEnum(EnumDef &enum_def, std::string *code_ptr) {
std::string &code = *code_ptr;
GenComment(enum_def.doc_comment, code_ptr, nullptr);
code += GenEnumDecl(enum_def, parser.opts);
if (parser.opts.scoped_enums)
code += GenEnumDecl(enum_def, parser_.opts);
if (parser_.opts.scoped_enums)
code += " : " + GenTypeBasic(enum_def.underlying_type, false);
code += " {\n";
int64_t anyv = 0;
EnumVal *minv = nullptr, *maxv = nullptr;
for (auto it = enum_def.vals.vec.begin();
it != enum_def.vals.vec.end();
for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
++it) {
auto &ev = **it;
GenComment(ev.doc_comment, code_ptr, nullptr, " ");
code += " " + GenEnumVal(enum_def, ev.name, parser.opts) + " = ";
code += " " + GenEnumVal(enum_def, ev.name, parser_.opts) + " = ";
code += NumToString(ev.value) + ",\n";
minv = !minv || minv->value > ev.value ? &ev : minv;
maxv = !maxv || maxv->value < ev.value ? &ev : maxv;
anyv |= ev.value;
}
if (parser.opts.scoped_enums || parser.opts.prefixed_enums) {
if (parser_.opts.scoped_enums || parser_.opts.prefixed_enums) {
assert(minv && maxv);
if (enum_def.attributes.Lookup("bit_flags")) {
if (minv->value != 0) // If the user didn't defined NONE value
code += " " + GenEnumVal(enum_def, "NONE", parser.opts) + " = 0,\n";
code += " " + GenEnumVal(enum_def, "NONE", parser_.opts) + " = 0,\n";
if (maxv->value != anyv) // If the user didn't defined ANY value
code += " " + GenEnumVal(enum_def, "ANY", parser.opts) + " = " + NumToString(anyv) + "\n";
code += " " + GenEnumVal(enum_def, "ANY", parser_.opts) + " = " +
NumToString(anyv) + "\n";
} else { // MIN & MAX are useless for bit_flags
code += " " + GenEnumVal(enum_def, "MIN", parser.opts) + " = ";
code += GenEnumVal(enum_def, minv->name, parser.opts) + ",\n";
code += " " + GenEnumVal(enum_def, "MAX", parser.opts) + " = ";
code += GenEnumVal(enum_def, maxv->name, parser.opts) + "\n";
code += " " + GenEnumVal(enum_def, "MIN", parser_.opts) + " = ";
code += GenEnumVal(enum_def, minv->name, parser_.opts) + ",\n";
code += " " + GenEnumVal(enum_def, "MAX", parser_.opts) + " = ";
code += GenEnumVal(enum_def, maxv->name, parser_.opts) + "\n";
}
}
code += "};\n";
if (parser.opts.scoped_enums && enum_def.attributes.Lookup("bit_flags"))
code += "DEFINE_BITMASK_OPERATORS(" + enum_def.name + ", " + GenTypeBasic(enum_def.underlying_type, false) + ")\n";
if (parser_.opts.scoped_enums && enum_def.attributes.Lookup("bit_flags"))
code += "DEFINE_BITMASK_OPERATORS(" + enum_def.name + ", " +
GenTypeBasic(enum_def.underlying_type, false) + ")\n";
code += "\n";
// Generate a generate string table for enum values.
// Problem is, if values are very sparse that could generate really big
// tables. Ideally in that case we generate a map lookup instead, but for
// the moment we simply don't output a table at all.
auto range = enum_def.vals.vec.back()->value -
enum_def.vals.vec.front()->value + 1;
auto range =
enum_def.vals.vec.back()->value - enum_def.vals.vec.front()->value + 1;
// Average distance between values above which we consider a table
// "too sparse". Change at will.
static const int kMaxSparseness = 5;
if (range / static_cast<int64_t>(enum_def.vals.vec.size()) < kMaxSparseness) {
if (range / static_cast<int64_t>(enum_def.vals.vec.size()) <
kMaxSparseness) {
code += "inline const char **EnumNames" + enum_def.name + "() {\n";
code += " static const char *names[] = { ";
auto val = enum_def.vals.vec.front()->value;
for (auto it = enum_def.vals.vec.begin();
it != enum_def.vals.vec.end();
for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
++it) {
while (val++ != (*it)->value) code += "\"\", ";
code += "\"" + (*it)->name + "\", ";
......@@ -223,7 +399,8 @@ static void GenEnum(const Parser &parser, EnumDef &enum_def,
code += "()[static_cast<int>(e)";
if (enum_def.vals.vec.front()->value) {
code += " - static_cast<int>(";
code += GetEnumVal(enum_def, *enum_def.vals.vec.front(), parser.opts) +")";
code +=
GetEnumVal(enum_def, *enum_def.vals.vec.front(), parser_.opts) + ")";
}
code += "]; }\n\n";
}
......@@ -231,10 +408,9 @@ static void GenEnum(const Parser &parser, EnumDef &enum_def,
if (enum_def.is_union) {
code += EnumSignature(enum_def) + ";\n\n";
}
}
}
static void GenEnumPost(const Parser &parser, EnumDef &enum_def,
std::string *code_ptr_post) {
void GenEnumPost(EnumDef &enum_def, std::string *code_ptr_post) {
// Generate a verifier function for this union that can be called by the
// table verifier functions. It uses a switch case to select a specific
// verifier function to call, this should be safe even if the union type
......@@ -242,11 +418,10 @@ static void GenEnumPost(const Parser &parser, EnumDef &enum_def,
// on the wrong type.
std::string &code_post = *code_ptr_post;
code_post += EnumSignature(enum_def) + " {\n switch (type) {\n";
for (auto it = enum_def.vals.vec.begin();
it != enum_def.vals.vec.end();
for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
++it) {
auto &ev = **it;
code_post += " case " + GetEnumVal(enum_def, ev, parser.opts);
code_post += " case " + GetEnumVal(enum_def, ev, parser_.opts);
if (!ev.value) {
code_post += ": return true;\n"; // "NONE" enum value.
} else {
......@@ -256,49 +431,52 @@ static void GenEnumPost(const Parser &parser, EnumDef &enum_def,
}
}
code_post += " default: return false;\n }\n}\n\n";
}
}
// Generates a value with optionally a cast applied if the field has a
// different underlying type from its interface type (currently only the
// case for enums. "from" specify the direction, true meaning from the
// underlying type to the interface type.
std::string GenUnderlyingCast(const FieldDef &field, bool from,
// Generates a value with optionally a cast applied if the field has a
// different underlying type from its interface type (currently only the
// case for enums. "from" specify the direction, true meaning from the
// underlying type to the interface type.
std::string GenUnderlyingCast(const FieldDef &field, bool from,
const std::string &val) {
if (from && field.value.type.base_type == BASE_TYPE_BOOL) {
return val + " != 0";
} else if ((field.value.type.enum_def &&
IsScalar(field.value.type.base_type)) ||
field.value.type.base_type == BASE_TYPE_BOOL) {
return "static_cast<" + GenTypeBasic(field.value.type, from) +
">(" + val + ")";
return "static_cast<" + GenTypeBasic(field.value.type, from) + ">(" +
val + ")";
} else {
return val;
}
}
}
std::string GenFieldOffsetName(const FieldDef &field) {
std::string GenFieldOffsetName(const FieldDef &field) {
std::string uname = field.name;
std::transform(uname.begin(), uname.end(), uname.begin(), ::toupper);
return "VT_" + uname;
}
}
static void GenFullyQualifiedNameGetter(const Parser &parser, const std::string& name, std::string &code) {
if (parser.opts.generate_name_strings) {
code += " static FLATBUFFERS_CONSTEXPR const char *GetFullyQualifiedName() {\n";
code += " return \"" + parser.namespaces_.back()->GetFullyQualifiedName(name) + "\";\n";
void GenFullyQualifiedNameGetter(const std::string &name,
std::string &code) {
if (parser_.opts.generate_name_strings) {
code +=
" static FLATBUFFERS_CONSTEXPR const char *GetFullyQualifiedName() "
"{\n";
code += " return \"" +
parser_.namespaces_.back()->GetFullyQualifiedName(name) + "\";\n";
code += " }\n";
}
}
}
std::string GenDefaultConstant(const FieldDef &field) {
std::string GenDefaultConstant(const FieldDef &field) {
return field.value.type.base_type == BASE_TYPE_FLOAT
? field.value.constant + "f"
: field.value.constant;
}
}
// Generate an accessor struct, builder structs & function for a table.
static void GenTable(const Parser &parser, StructDef &struct_def,
std::string *code_ptr) {
// Generate an accessor struct, builder structs & function for a table.
void GenTable(StructDef &struct_def, std::string *code_ptr) {
std::string &code = *code_ptr;
// Generate an accessor struct, with methods of the form:
// type name() const { return GetField<type>(offset, defaultval); }
......@@ -307,18 +485,19 @@ static void GenTable(const Parser &parser, StructDef &struct_def,
code += " FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table";
code += " {\n";
// Generate GetFullyQualifiedName
GenFullyQualifiedNameGetter(parser, struct_def.name, code);
GenFullyQualifiedNameGetter(struct_def.name, code);
// Generate field id constants.
if (struct_def.fields.vec.size() > 0) {
code += " enum {\n";
bool is_first_field = true; // track the first field that's not deprecated
bool is_first_field =
true; // track the first field that's not deprecated
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) { // Deprecated fields won't be accessible.
if (!is_first_field) {
// Add trailing comma and newline to previous element. Don't add trailing comma to
// Add trailing comma and newline to previous element. Don't add
// trailing comma to
// last element since older versions of gcc complain about this.
code += ",\n";
} else {
......@@ -332,23 +511,22 @@ static void GenTable(const Parser &parser, StructDef &struct_def,
}
// Generate the accessors.
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) { // Deprecated fields won't be accessible.
auto is_scalar = IsScalar(field.value.type.base_type);
GenComment(field.doc_comment, code_ptr, nullptr, " ");
code += " " + GenTypeGet(parser, field.value.type, " ", "const ", " *",
true);
code += " " +
GenTypeGet(field.value.type, " ", "const ", " *", true);
code += field.name + "() const { return ";
// Call a different accessor for pointers, that indirects.
auto accessor = is_scalar
auto accessor =
is_scalar
? "GetField<"
: (IsStruct(field.value.type) ? "GetStruct<" : "GetPointer<");
auto offsetstr = GenFieldOffsetName(field);
auto call =
accessor +
GenTypeGet(parser, field.value.type, "", "const ", " *", false) +
auto call = accessor + GenTypeGet(field.value.type, "",
"const ", " *", false) +
">(" + offsetstr;
// Default value as second arg for non-pointer types.
if (IsScalar(field.value.type.base_type))
......@@ -356,15 +534,17 @@ static void GenTable(const Parser &parser, StructDef &struct_def,
call += ")";
code += GenUnderlyingCast(field, true, call);
code += "; }\n";
if (parser.opts.mutable_buffer) {
if (parser_.opts.mutable_buffer) {
if (is_scalar) {
code += " bool mutate_" + field.name + "(";
code += GenTypeBasic(field.value.type, true);
code += " _" + field.name + ") { return SetField(" + offsetstr + ", ";
code +=
" _" + field.name + ") { return SetField(" + offsetstr + ", ";
code += GenUnderlyingCast(field, false, "_" + field.name);
code += "); }\n";
} else {
auto type = GenTypeGet(parser, field.value.type, " ", "", " *", true);
auto type =
GenTypeGet(field.value.type, " ", "", " *", true);
code += " " + type + "mutable_" + field.name + "() { return ";
code += GenUnderlyingCast(field, true,
accessor + type + ">(" + offsetstr + ")");
......@@ -374,8 +554,9 @@ static void GenTable(const Parser &parser, StructDef &struct_def,
auto nested = field.attributes.Lookup("nested_flatbuffer");
if (nested) {
std::string qualified_name =
parser.namespaces_.back()->GetFullyQualifiedName(nested->constant);
auto nested_root = parser.structs_.Lookup(qualified_name);
parser_.namespaces_.back()->GetFullyQualifiedName(
nested->constant);
auto nested_root = parser_.structs_.Lookup(qualified_name);
assert(nested_root); // Guaranteed to exist by parser.
(void)nested_root;
std::string cpp_qualified_name = TranslateNameSpace(qualified_name);
......@@ -397,11 +578,9 @@ static void GenTable(const Parser &parser, StructDef &struct_def,
code += "const char *val) const { return strcmp(" + field.name;
code += "()->c_str(), val); }\n";
} else {
if (parser.opts.scoped_enums &&
field.value.type.enum_def &&
if (parser_.opts.scoped_enums && field.value.type.enum_def &&
IsScalar(field.value.type.base_type)) {
code += GenTypeGet(parser, field.value.type, " ", "const ", " *",
true);
code += GenTypeGet(field.value.type, " ", "const ", " *", true);
} else {
code += GenTypeBasic(field.value.type, false);
}
......@@ -417,18 +596,18 @@ static void GenTable(const Parser &parser, StructDef &struct_def,
code += " return VerifyTableStart(verifier)";
std::string prefix = " &&\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) {
code += prefix + "VerifyField";
if (field.required) code += "Required";
code += "<" + GenTypeSize(parser, field.value.type);
code += "<" + GenTypeSize(field.value.type);
code += ">(verifier, " + GenFieldOffsetName(field) + ")";
switch (field.value.type.base_type) {
case BASE_TYPE_UNION:
code += prefix + "Verify" + field.value.type.enum_def->name;
code += "(verifier, " + field.name + "(), " + field.name + "_type())";
code +=
"(verifier, " + field.name + "(), " + field.name + "_type())";
break;
case BASE_TYPE_STRUCT:
if (!field.value.type.struct_def->fixed) {
......@@ -449,7 +628,8 @@ static void GenTable(const Parser &parser, StructDef &struct_def,
}
case BASE_TYPE_STRUCT: {
if (!field.value.type.struct_def->fixed) {
code += prefix + "verifier.VerifyVectorOfTables(" + field.name;
code +=
prefix + "verifier.VerifyVectorOfTables(" + field.name;
code += "())";
}
break;
......@@ -468,20 +648,20 @@ static void GenTable(const Parser &parser, StructDef &struct_def,
code += "};\n\n";
// Generate a builder struct, with methods of the form:
// void add_name(type name) { fbb_.AddElement<type>(offset, name, default); }
// void add_name(type name) { fbb_.AddElement<type>(offset, name, default);
// }
code += "struct " + struct_def.name;
code += "Builder {\n flatbuffers::FlatBufferBuilder &fbb_;\n";
code += " flatbuffers::uoffset_t start_;\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) {
code += " void add_" + field.name + "(";
code += GenTypeWire(parser, field.value.type, " ", true) + field.name;
code += GenTypeWire(field.value.type, " ", true) + field.name;
code += ") { fbb_.Add";
if (IsScalar(field.value.type.base_type)) {
code += "Element<" + GenTypeWire(parser, field.value.type, "", false);
code += "Element<" + GenTypeWire(field.value.type, "", false);
code += ">";
} else if (IsStruct(field.value.type)) {
code += "Struct";
......@@ -505,8 +685,7 @@ static void GenTable(const Parser &parser, StructDef &struct_def,
code += ">(fbb_.EndTable(start_, ";
code += NumToString(struct_def.fields.vec.size()) + "));\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 && field.required) {
code += " fbb_.Required(o, ";
......@@ -522,19 +701,19 @@ static void GenTable(const Parser &parser, StructDef &struct_def,
code += struct_def.name;
code += "(flatbuffers::FlatBufferBuilder &_fbb";
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) {
code += ",\n " + GenTypeWire(parser, field.value.type, " ", true);
code += ",\n " + GenTypeWire(field.value.type, " ", true);
code += field.name + " = ";
if (field.value.type.enum_def && IsScalar(field.value.type.base_type)) {
auto ev = field.value.type.enum_def->ReverseLookup(
static_cast<int>(StringToInt(field.value.constant.c_str())), false);
static_cast<int>(StringToInt(field.value.constant.c_str())),
false);
if (ev) {
code += WrapInNameSpace(field.value.type.enum_def->defined_namespace,
GetEnumVal(*field.value.type.enum_def, *ev,
parser.opts));
code += WrapInNameSpace(
field.value.type.enum_def->defined_namespace,
GetEnumVal(*field.value.type.enum_def, *ev, parser_.opts));
} else {
code += GenUnderlyingCast(field, true, field.value.constant);
}
......@@ -547,25 +726,22 @@ static void GenTable(const Parser &parser, StructDef &struct_def,
}
code += ") {\n " + struct_def.name + "Builder builder_(_fbb);\n";
for (size_t size = struct_def.sortbysize ? sizeof(largest_scalar_t) : 1;
size;
size /= 2) {
size; size /= 2) {
for (auto it = struct_def.fields.vec.rbegin();
it != struct_def.fields.vec.rend();
++it) {
it != struct_def.fields.vec.rend(); ++it) {
auto &field = **it;
if (!field.deprecated &&
(!struct_def.sortbysize ||
if (!field.deprecated && (!struct_def.sortbysize ||
size == SizeOf(field.value.type.base_type))) {
code += " builder_.add_" + field.name + "(" + field.name + ");\n";
}
}
}
code += " return builder_.Finish();\n}\n\n";
}
}
static void GenPadding(const FieldDef &field, std::string &code,
static void GenPadding(const FieldDef &field, std::string &code,
int &padding_id,
const std::function<void (int bits, std::string &code,
const std::function<void(int bits, std::string &code,
int &padding_id)> &f) {
if (field.padding) {
for (int i = 0; i < 4; i++)
......@@ -573,26 +749,25 @@ static void GenPadding(const FieldDef &field, std::string &code,
f((1 << i) * 8, code, padding_id);
assert(!(field.padding & ~0xF));
}
}
}
static void PaddingDefinition(int bits, std::string &code, int &padding_id) {
code += " int" + NumToString(bits) +
"_t __padding" + NumToString(padding_id++) + ";\n";
}
static void PaddingDefinition(int bits, std::string &code, int &padding_id) {
code += " int" + NumToString(bits) + "_t __padding" +
NumToString(padding_id++) + ";\n";
}
static void PaddingDeclaration(int bits, std::string &code, int &padding_id) {
static void PaddingDeclaration(int bits, std::string &code, int &padding_id) {
(void)bits;
code += " (void)__padding" + NumToString(padding_id++) + ";";
}
}
static void PaddingInitializer(int bits, std::string &code, int &padding_id) {
static void PaddingInitializer(int bits, std::string &code, int &padding_id) {
(void)bits;
code += ", __padding" + NumToString(padding_id++) + "(0)";
}
}
// Generate an accessor struct with constructor for a flatbuffers struct.
static void GenStruct(const Parser &parser, StructDef &struct_def,
std::string *code_ptr) {
// Generate an accessor struct with constructor for a flatbuffers struct.
void GenStruct(StructDef &struct_def, std::string *code_ptr) {
if (struct_def.generated) return;
std::string &code = *code_ptr;
......@@ -602,37 +777,35 @@ static void GenStruct(const Parser &parser, StructDef &struct_def,
// Variables are private because they contain little endian data on all
// platforms.
GenComment(struct_def.doc_comment, code_ptr, nullptr);
code += "MANUALLY_ALIGNED_STRUCT(" + NumToString(struct_def.minalign) + ") ";
code +=
"MANUALLY_ALIGNED_STRUCT(" + NumToString(struct_def.minalign) + ") ";
code += struct_def.name + " FLATBUFFERS_FINAL_CLASS {\n private:\n";
int padding_id = 0;
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;
code += " " + GenTypeGet(parser, field.value.type, " ", "", " ", false);
code += " " + GenTypeGet(field.value.type, " ", "", " ", false);
code += field.name + "_;\n";
GenPadding(field, code, padding_id, PaddingDefinition);
}
// Generate GetFullyQualifiedName
code += "\n public:\n";
GenFullyQualifiedNameGetter(parser, struct_def.name, code);
GenFullyQualifiedNameGetter(struct_def.name, code);
// Generate a constructor that takes all fields as arguments.
code += " " + struct_def.name + "(";
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 (it != struct_def.fields.vec.begin()) code += ", ";
code += GenTypeGet(parser, field.value.type, " ", "const ", " &", true);
code += GenTypeGet(field.value.type, " ", "const ", " &", true);
code += "_" + field.name;
}
code += ")\n : ";
padding_id = 0;
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 (it != struct_def.fields.vec.begin()) code += ", ";
code += field.name + "_(";
......@@ -649,8 +822,7 @@ static void GenStruct(const Parser &parser, StructDef &struct_def,
code += " {";
padding_id = 0;
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;
GenPadding(field, code, padding_id, PaddingDeclaration);
}
......@@ -659,20 +831,19 @@ static void GenStruct(const Parser &parser, StructDef &struct_def,
// Generate accessor methods of the form:
// type name() const { return flatbuffers::EndianScalar(name_); }
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;
GenComment(field.doc_comment, code_ptr, nullptr, " ");
auto is_scalar = IsScalar(field.value.type.base_type);
code += " " + GenTypeGet(parser, field.value.type, " ", "const ", " &",
true);
code += " " +
GenTypeGet(field.value.type, " ", "const ", " &", true);
code += field.name + "() const { return ";
code += GenUnderlyingCast(field, true,
is_scalar
code += GenUnderlyingCast(
field, true, is_scalar
? "flatbuffers::EndianScalar(" + field.name + "_)"
: field.name + "_");
code += "; }\n";
if (parser.opts.mutable_buffer) {
if (parser_.opts.mutable_buffer) {
if (is_scalar) {
code += " void mutate_" + field.name + "(";
code += GenTypeBasic(field.value.type, true);
......@@ -682,7 +853,7 @@ static void GenStruct(const Parser &parser, StructDef &struct_def,
code += "); }\n";
} else {
code += " ";
code += GenTypeGet(parser, field.value.type, "", "", " &", true);
code += GenTypeGet(field.value.type, "", "", " &", true);
code += "mutable_" + field.name + "() { return " + field.name;
code += "_; }\n";
}
......@@ -690,21 +861,21 @@ static void GenStruct(const Parser &parser, StructDef &struct_def,
}
code += "};\nSTRUCT_END(" + struct_def.name + ", ";
code += NumToString(struct_def.bytesize) + ");\n\n";
}
}
void GenerateNestedNameSpaces(const Namespace *ns, std::string *code_ptr) {
void GenerateNestedNameSpaces(const Namespace *ns, std::string *code_ptr) {
for (auto it = ns->components.begin(); it != ns->components.end(); ++it) {
*code_ptr += "namespace " + *it + " {\n";
}
}
}
void CloseNestedNameSpaces(const Namespace *ns, std::string *code_ptr) {
void CloseNestedNameSpaces(const Namespace *ns, std::string *code_ptr) {
for (auto it = ns->components.rbegin(); it != ns->components.rend(); ++it) {
*code_ptr += "} // namespace " + *it + "\n";
}
}
}
void CheckNameSpace(const Definition &def, std::string *code_ptr) {
void CheckNameSpace(const Definition &def, std::string *code_ptr) {
// Set up the correct namespace. Only open a namespace if
// the existing one is different.
// TODO: this could be done more intelligently, by sorting to
......@@ -719,191 +890,6 @@ void CheckNameSpace(const Definition &def, std::string *code_ptr) {
code_generator_cur_name_space = def.defined_namespace;
if (code_generator_cur_name_space->components.size()) *code_ptr += "\n";
}
}
} // namespace cpp
struct IsAlnum {
bool operator()(char c) {
return !isalnum(c);
}
};
static std::string GeneratedFileName(const std::string &path,
const std::string &file_name) {
return path + file_name + "_generated.h";
}
namespace cpp {
class CppGenerator : public BaseGenerator {
public:
CppGenerator(const Parser &parser, const std::string &path,
const std::string &file_name)
: BaseGenerator(parser, path, file_name){};
// Iterate through all definitions we haven't generate code for (enums,
// structs,
// and tables) and output them to a single file.
bool generate() {
if (IsEverythingGenerated()) return true;
std::string code;
code = code + "// " + FlatBuffersGeneratedWarning();
// Generate include guard.
std::string include_guard_ident = file_name_;
// Remove any non-alpha-numeric characters that may appear in a filename.
include_guard_ident.erase(
std::remove_if(include_guard_ident.begin(), include_guard_ident.end(),
IsAlnum()),
include_guard_ident.end());
std::string include_guard = "FLATBUFFERS_GENERATED_" + include_guard_ident;
include_guard += "_";
// For further uniqueness, also add the namespace.
auto name_space = parser_.namespaces_.back();
for (auto it = name_space->components.begin();
it != name_space->components.end(); ++it) {
include_guard += *it + "_";
}
include_guard += "H_";
std::transform(include_guard.begin(), include_guard.end(),
include_guard.begin(), ::toupper);
code += "#ifndef " + include_guard + "\n";
code += "#define " + include_guard + "\n\n";
code += "#include \"flatbuffers/flatbuffers.h\"\n\n";
if (parser_.opts.include_dependence_headers) {
int num_includes = 0;
for (auto it = parser_.included_files_.begin();
it != parser_.included_files_.end(); ++it) {
auto basename =
flatbuffers::StripPath(flatbuffers::StripExtension(it->first));
if (basename != file_name_) {
code += "#include \"" + basename + "_generated.h\"\n";
num_includes++;
}
}
if (num_includes) code += "\n";
}
assert(!code_generator_cur_name_space);
// Generate forward declarations for all structs/tables, since they may
// have circular references.
for (auto it = parser_.structs_.vec.begin(); it != parser_.structs_.vec.end();
++it) {
auto &struct_def = **it;
if (!struct_def.generated) {
CheckNameSpace(struct_def, &code);
code += "struct " + struct_def.name + ";\n\n";
}
}
// Generate code for all the enum declarations.
for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
++it) {
auto &enum_def = **it;
if (!enum_def.generated) {
CheckNameSpace(**it, &code);
GenEnum(parser_, **it, &code);
}
}
// Generate code for all structs, then all tables.
for (auto it = parser_.structs_.vec.begin(); it != parser_.structs_.vec.end();
++it) {
auto &struct_def = **it;
if (struct_def.fixed && !struct_def.generated) {
CheckNameSpace(struct_def, &code);
GenStruct(parser_, struct_def, &code);
}
}
for (auto it = parser_.structs_.vec.begin(); it != parser_.structs_.vec.end();
++it) {
auto &struct_def = **it;
if (!struct_def.fixed && !struct_def.generated) {
CheckNameSpace(struct_def, &code);
GenTable(parser_, struct_def, &code);
}
}
// Generate code for union verifiers.
for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
++it) {
auto &enum_def = **it;
if (enum_def.is_union && !enum_def.generated) {
CheckNameSpace(enum_def, &code);
GenEnumPost(parser_, enum_def, &code);
}
}
// Generate convenient global helper functions:
if (parser_.root_struct_def_) {
CheckNameSpace(*parser_.root_struct_def_, &code);
auto &name = parser_.root_struct_def_->name;
std::string qualified_name =
parser_.namespaces_.back()->GetFullyQualifiedName(name);
std::string cpp_qualified_name = TranslateNameSpace(qualified_name);
// The root datatype accessor:
code += "inline const " + cpp_qualified_name + " *Get";
code += name;
code += "(const void *buf) { return flatbuffers::GetRoot<";
code += cpp_qualified_name + ">(buf); }\n\n";
if (parser_.opts.mutable_buffer) {
code += "inline " + name + " *GetMutable";
code += name;
code += "(void *buf) { return flatbuffers::GetMutableRoot<";
code += name + ">(buf); }\n\n";
}
// The root verifier:
code += "inline bool Verify";
code += name;
code +=
"Buffer(flatbuffers::Verifier &verifier) { "
"return verifier.VerifyBuffer<";
code += cpp_qualified_name + ">(); }\n\n";
if (parser_.file_identifier_.length()) {
// Return the identifier
code += "inline const char *" + name;
code += "Identifier() { return \"" + parser_.file_identifier_;
code += "\"; }\n\n";
// Check if a buffer has the identifier.
code += "inline bool " + name;
code += "BufferHasIdentifier(const void *buf) { return flatbuffers::";
code += "BufferHasIdentifier(buf, ";
code += name + "Identifier()); }\n\n";
}
if (parser_.file_extension_.length()) {
// Return the extension
code += "inline const char *" + name;
code += "Extension() { return \"" + parser_.file_extension_;
code += "\"; }\n\n";
}
// Finish a buffer with a given root object:
code += "inline void Finish" + name;
code +=
"Buffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset<";
code += cpp_qualified_name + "> root) { fbb.Finish(root";
if (parser_.file_identifier_.length())
code += ", " + name + "Identifier()";
code += "); }\n\n";
}
assert(code_generator_cur_name_space);
CloseNestedNameSpaces(code_generator_cur_name_space, &code);
code_generator_cur_name_space = nullptr;
// Close the include guard.
code += "\n#endif // " + include_guard + "\n";
return SaveFile(GeneratedFileName(path_, file_name_).c_str(), code, false);
}
};
} // namespace cpp
......
tests/monster_test_generated.h
View file @ a9194c4c
......@@ -22,8 +22,8 @@ enum Color {
Color_Red = 1,
Color_Green = 2,
Color_Blue = 8,
Color_MIN = Color_Red,
Color_MAX = Color_Blue
Color_NONE = 0,
Color_ANY = 11
};
inline const char **EnumNamesColor() {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment