/*

* Copyright 2014 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.

*/

// independent from idl_parser, since this code is not needed for most clients

#include "flatbuffers/code_generators.h"

#include "flatbuffers/flatbuffers.h"

#include "flatbuffers/idl.h"

#include "flatbuffers/util.h"

namespace flatbuffers {

// Pedantic warning free version of toupper().

inline char ToUpper(char c) { return static_cast<char>(::toupper(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, "", "::"),

cur_name_space_(nullptr) {

const char *keywords[] = { "alignas",

"alignof",

"and",

"and_eq",

"asm",

"atomic_cancel",

"atomic_commit",

"atomic_noexcept",

"auto",

"bitand",

"bitor",

"bool",

"break",

"case",

"catch",

"char",

"char16_t",

"char32_t",

"class",

"compl",

"concept",

"const",

"constexpr",

"const_cast",

"continue",

"co_await",

"co_return",

"co_yield",

"decltype",

"default",

"delete",

"do",

"double",

"dynamic_cast",

"else",

"enum",

"explicit",

"export",

"extern",

"false",

"float",

"for",

"friend",

"goto",

"if",

"import",

"inline",

"int",

"long",

"module",

"mutable",

"namespace",

"new",

"noexcept",

"not",

"not_eq",

"nullptr",

"operator",

"or",

"or_eq",

"private",

"protected",

"public",

"register",

"reinterpret_cast",

"requires",

"return",

"short",

"signed",

"sizeof",

"static",

"static_assert",

"static_cast",

"struct",

"switch",

"synchronized",

"template",

"this",

"thread_local",

"throw",

"true",

"try",

"typedef",

"typeid",

"typename",

"union",

"unsigned",

"using",

"virtual",

"void",

"volatile",

"wchar_t",

"while",

"xor",

"xor_eq",

nullptr };

for (auto kw = keywords; *kw; kw++) keywords_.insert(*kw);

}

std::string GenIncludeGuard() const {

// Generate include guard.

std::string guard = file_name_;

// Remove any non-alpha-numeric characters that may appear in a filename.

struct IsAlnum {

bool operator()(char c) { return !isalnum(c); }

};

guard.erase(std::remove_if(guard.begin(), guard.end(), IsAlnum()),

guard.end());

guard = "FLATBUFFERS_GENERATED_" + guard;

guard += "_";

// For further uniqueness, also add the namespace.

auto name_space = parser_.current_namespace_;

for (auto it = name_space->components.begin();

it != name_space->components.end(); ++it) {

guard += *it + "_";

}

guard += "H_";

std::transform(guard.begin(), guard.end(), guard.begin(), ToUpper);

return guard;

}

void GenIncludeDependencies() {

int num_includes = 0;

for (auto it = parser_.native_included_files_.begin();

it != parser_.native_included_files_.end(); ++it) {

code_ += "#include \"" + *it + "\"";

num_includes++;

}

for (auto it = parser_.included_files_.begin();

it != parser_.included_files_.end(); ++it) {

if (it->second.empty()) continue;

auto noext = flatbuffers::StripExtension(it->second);

auto basename = flatbuffers::StripPath(noext);

code_ += "#include \"" + parser_.opts.include_prefix +

(parser_.opts.keep_include_path ? noext : basename) +

"_generated.h\"";

num_includes++;

}

if (num_includes) code_ += "";

}

std::string EscapeKeyword(const std::string &name) const {

return keywords_.find(name) == keywords_.end() ? name : name + "_";

}

std::string Name(const Definition &def) const {

return EscapeKeyword(def.name);

}

std::string Name(const EnumVal &ev) const { return EscapeKeyword(ev.name); }

// Iterate through all definitions we haven't generate code for (enums,

// structs, and tables) and output them to a single file.

bool generate() {

code_.Clear();

code_ += "// " + std::string(FlatBuffersGeneratedWarning()) + "\n\n";

const auto include_guard = GenIncludeGuard();

code_ += "#ifndef " + include_guard;

code_ += "#define " + include_guard;

code_ += "";

if (parser_.opts.gen_nullable) {

code_ += "#pragma clang system_header\n\n";

}

code_ += "#include \"flatbuffers/flatbuffers.h\"";

if (parser_.uses_flexbuffers_) {

code_ += "#include \"flatbuffers/flexbuffers.h\"";

}

code_ += "";

if (parser_.opts.include_dependence_headers) { GenIncludeDependencies(); }

assert(!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) {

const auto &struct_def = **it;

if (!struct_def.generated) {

SetNameSpace(struct_def.defined_namespace);

code_ += "struct " + Name(struct_def) + ";";

if (parser_.opts.generate_object_based_api && !struct_def.fixed) {

code_ += "struct " +

NativeName(Name(struct_def), &struct_def, parser_.opts) +

";";

}

code_ += "";

}

}

// Generate preablmle code for mini reflection.

if (parser_.opts.mini_reflect != IDLOptions::kNone) {

// To break cyclic dependencies, first pre-declare all tables/structs.

for (auto it = parser_.structs_.vec.begin();

it != parser_.structs_.vec.end(); ++it) {

const auto &struct_def = **it;

if (!struct_def.generated) {

SetNameSpace(struct_def.defined_namespace);

GenMiniReflectPre(&struct_def);

}

}

}

// Generate code for all the enum declarations.

for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();

++it) {

const auto &enum_def = **it;

if (!enum_def.generated) {

SetNameSpace(enum_def.defined_namespace);

GenEnum(enum_def);

}

}

// Generate code for all structs, then all tables.

for (auto it = parser_.structs_.vec.begin();

it != parser_.structs_.vec.end(); ++it) {

const auto &struct_def = **it;

if (struct_def.fixed && !struct_def.generated) {

SetNameSpace(struct_def.defined_namespace);

GenStruct(struct_def);

}

}

for (auto it = parser_.structs_.vec.begin();

it != parser_.structs_.vec.end(); ++it) {

const auto &struct_def = **it;

if (!struct_def.fixed && !struct_def.generated) {

SetNameSpace(struct_def.defined_namespace);

GenTable(struct_def);

}

}

for (auto it = parser_.structs_.vec.begin();

it != parser_.structs_.vec.end(); ++it) {

const auto &struct_def = **it;

if (!struct_def.fixed && !struct_def.generated) {

SetNameSpace(struct_def.defined_namespace);

GenTablePost(struct_def);

}

}

// Generate code for union verifiers.

for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();

++it) {

const auto &enum_def = **it;

if (enum_def.is_union && !enum_def.generated) {

SetNameSpace(enum_def.defined_namespace);

GenUnionPost(enum_def);

}

}

// Generate code for mini reflection.

if (parser_.opts.mini_reflect != IDLOptions::kNone) {

// Then the unions/enums that may refer to them.

for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();

++it) {

const auto &enum_def = **it;

if (!enum_def.generated) {

SetNameSpace(enum_def.defined_namespace);

GenMiniReflect(nullptr, &enum_def);

}

}

// Then the full tables/structs.

for (auto it = parser_.structs_.vec.begin();

it != parser_.structs_.vec.end(); ++it) {

const auto &struct_def = **it;

if (!struct_def.generated) {

SetNameSpace(struct_def.defined_namespace);

GenMiniReflect(&struct_def, nullptr);

}

}

}

// Generate convenient global helper functions:

if (parser_.root_struct_def_) {

auto &struct_def = *parser_.root_struct_def_;

SetNameSpace(struct_def.defined_namespace);

auto name = Name(struct_def);

auto qualified_name = cur_name_space_->GetFullyQualifiedName(name);

auto cpp_name = TranslateNameSpace(qualified_name);

code_.SetValue("STRUCT_NAME", name);

code_.SetValue("CPP_NAME", cpp_name);

code_.SetValue("NULLABLE_EXT", NullableExtension());

// The root datatype accessor:

code_ += "inline \\";

code_ +=

"const {{CPP_NAME}} *{{NULLABLE_EXT}}Get{{STRUCT_NAME}}(const void "

"*buf) {";

code_ += " return flatbuffers::GetRoot<{{CPP_NAME}}>(buf);";

code_ += "}";

code_ += "";

code_ += "inline \\";

code_ +=

"const {{CPP_NAME}} *{{NULLABLE_EXT}}GetSizePrefixed{{STRUCT_NAME}}(const void "

"*buf) {";

code_ += " return flatbuffers::GetSizePrefixedRoot<{{CPP_NAME}}>(buf);";

code_ += "}";

code_ += "";

if (parser_.opts.mutable_buffer) {

code_ += "inline \\";

code_ += "{{STRUCT_NAME}} *GetMutable{{STRUCT_NAME}}(void *buf) {";

code_ += " return flatbuffers::GetMutableRoot<{{STRUCT_NAME}}>(buf);";

code_ += "}";

code_ += "";

}

if (parser_.file_identifier_.length()) {

// Return the identifier

code_ += "inline const char *{{STRUCT_NAME}}Identifier() {";

code_ += " return \"" + parser_.file_identifier_ + "\";";

code_ += "}";

code_ += "";

// Check if a buffer has the identifier.

code_ += "inline \\";

code_ += "bool {{STRUCT_NAME}}BufferHasIdentifier(const void *buf) {";

code_ += " return flatbuffers::BufferHasIdentifier(";

code_ += " buf, {{STRUCT_NAME}}Identifier());";

code_ += "}";

code_ += "";

}

// The root verifier.

if (parser_.file_identifier_.length()) {

code_.SetValue("ID", name + "Identifier()");

} else {

code_.SetValue("ID", "nullptr");

}

code_ += "inline bool Verify{{STRUCT_NAME}}Buffer(";

code_ += " flatbuffers::Verifier &verifier) {";

code_ += " return verifier.VerifyBuffer<{{CPP_NAME}}>({{ID}});";

code_ += "}";

code_ += "";

code_ += "inline bool VerifySizePrefixed{{STRUCT_NAME}}Buffer(";

code_ += " flatbuffers::Verifier &verifier) {";

code_ += " return verifier.VerifySizePrefixedBuffer<{{CPP_NAME}}>({{ID}});";

code_ += "}";

code_ += "";

if (parser_.file_extension_.length()) {

// Return the extension

code_ += "inline const char *{{STRUCT_NAME}}Extension() {";

code_ += " return \"" + parser_.file_extension_ + "\";";

code_ += "}";

code_ += "";

}

// Finish a buffer with a given root object:

code_ += "inline void Finish{{STRUCT_NAME}}Buffer(";

code_ += " flatbuffers::FlatBufferBuilder &fbb,";

code_ += " flatbuffers::Offset<{{CPP_NAME}}> root) {";

if (parser_.file_identifier_.length())

code_ += " fbb.Finish(root, {{STRUCT_NAME}}Identifier());";

else

code_ += " fbb.Finish(root);";

code_ += "}";

code_ += "";

code_ += "inline void FinishSizePrefixed{{STRUCT_NAME}}Buffer(";

code_ += " flatbuffers::FlatBufferBuilder &fbb,";

code_ += " flatbuffers::Offset<{{CPP_NAME}}> root) {";

if (parser_.file_identifier_.length())

code_ += " fbb.FinishSizePrefixed(root, {{STRUCT_NAME}}Identifier());";

else

code_ += " fbb.FinishSizePrefixed(root);";

code_ += "}";

code_ += "";

if (parser_.opts.generate_object_based_api) {

// A convenient root unpack function.

auto native_name =

NativeName(WrapInNameSpace(struct_def), &struct_def, parser_.opts);

code_.SetValue("UNPACK_RETURN",

GenTypeNativePtr(native_name, nullptr, false));

code_.SetValue("UNPACK_TYPE",

GenTypeNativePtr(native_name, nullptr, true));

code_ += "inline {{UNPACK_RETURN}} UnPack{{STRUCT_NAME}}(";

code_ += " const void *buf,";

code_ += " const flatbuffers::resolver_function_t *res = nullptr) {";

code_ += " return {{UNPACK_TYPE}}\\";

code_ += "(Get{{STRUCT_NAME}}(buf)->UnPack(res));";

code_ += "}";

code_ += "";

}

}

if (cur_name_space_) SetNameSpace(nullptr);

// Close the include guard.

code_ += "#endif // " + include_guard;

const auto file_path = GeneratedFileName(path_, file_name_);

const auto final_code = code_.ToString();

return SaveFile(file_path.c_str(), final_code, false);

}

private:

CodeWriter code_;

std::set<std::string> keywords_;

// This tracks the current namespace so we can insert namespace declarations.

const Namespace *cur_name_space_;

const Namespace *CurrentNameSpace() const { return cur_name_space_; }

// 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)) !=

std::string::npos) {

cpp_qualified_name.replace(start_pos, 1, "::");

}

return cpp_qualified_name;

}

void GenComment(const std::vector<std::string> &dc, const char *prefix = "") {

std::string text;

::flatbuffers::GenComment(dc, &text, nullptr, prefix);

code_ += text + "\\";

}

// Return a C++ type from the table in idl.h

std::string GenTypeBasic(const Type &type, bool user_facing_type) const {

static const char *ctypename[] = {

// clang-format off

#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \

#CTYPE,

FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)

#undef FLATBUFFERS_TD

// clang-format on

};

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];

}

// Return a C++ pointer type, specialized to the actual struct/table types,

// and vector element types.

std::string GenTypePointer(const Type &type) const {

switch (type.base_type) {

case BASE_TYPE_STRING: {

return "flatbuffers::String";

}

case BASE_TYPE_VECTOR: {

const auto type_name = GenTypeWire(type.VectorType(), "", false);

return "flatbuffers::Vector<" + type_name + ">";

}

case BASE_TYPE_STRUCT: {

return WrapInNameSpace(*type.struct_def);

}

case BASE_TYPE_UNION:

// fall through

default: { return "void"; }

}

}

// 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) const {

if (IsScalar(type.base_type)) {

return GenTypeBasic(type, user_facing_type) + postfix;

} else if (IsStruct(type)) {

return "const " + GenTypePointer(type) + " *";

} else {

return "flatbuffers::Offset<" + GenTypePointer(type) + ">" + postfix;

}

}

// Return a C++ type for any type (scalar/pointer) that reflects its

// serialized size.

std::string GenTypeSize(const Type &type) const {

if (IsScalar(type.base_type)) {

return GenTypeBasic(type, false);

} else if (IsStruct(type)) {

return GenTypePointer(type);

} else {

return "flatbuffers::uoffset_t";

}

}

std::string NullableExtension() {

return parser_.opts.gen_nullable ? " _Nullable " : "";

}

static std::string NativeName(const std::string &name, const StructDef *sd,

const IDLOptions &opts) {

return sd && !sd->fixed ? opts.object_prefix + name + opts.object_suffix

: name;

}

const std::string &PtrType(const FieldDef *field) {

auto attr = field ? field->attributes.Lookup("cpp_ptr_type") : nullptr;

return attr ? attr->constant : parser_.opts.cpp_object_api_pointer_type;

}

const std::string NativeString(const FieldDef *field) {

auto attr = field ? field->attributes.Lookup("cpp_str_type") : nullptr;

auto &ret = attr ? attr->constant : parser_.opts.cpp_object_api_string_type;

if (ret.empty()) { return "std::string"; }

return ret;

}

std::string GenTypeNativePtr(const std::string &type, const FieldDef *field,

bool is_constructor) {

auto &ptr_type = PtrType(field);

if (ptr_type != "naked") {

return ptr_type + "<" + type + ">";

} else if (is_constructor) {

return "";

} else {

return type + " *";

}

}

std::string GenPtrGet(const FieldDef &field) {

auto &ptr_type = PtrType(&field);

return ptr_type == "naked" ? "" : ".get()";

}

std::string GenTypeNative(const Type &type, bool invector,

const FieldDef &field) {

switch (type.base_type) {

case BASE_TYPE_STRING: {

return NativeString(&field);

}

case BASE_TYPE_VECTOR: {

const auto type_name = GenTypeNative(type.VectorType(), true, field);

if (type.struct_def &&

type.struct_def->attributes.Lookup("native_custom_alloc")) {

auto native_custom_alloc =

type.struct_def->attributes.Lookup("native_custom_alloc");

return "std::vector<" + type_name + "," +

native_custom_alloc->constant + "<" + type_name + ">>";

} else

return "std::vector<" + type_name + ">";

}

case BASE_TYPE_STRUCT: {

auto type_name = WrapInNameSpace(*type.struct_def);

if (IsStruct(type)) {

auto native_type = type.struct_def->attributes.Lookup("native_type");

if (native_type) { type_name = native_type->constant; }

if (invector || field.native_inline) {

return type_name;

} else {

return GenTypeNativePtr(type_name, &field, false);

}

} else {

return GenTypeNativePtr(

NativeName(type_name, type.struct_def, parser_.opts), &field,

false);

}

}

case BASE_TYPE_UNION: {

return type.enum_def->name + "Union";

}

default: { return GenTypeBasic(type, true); }

}

}

// 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) {

if (IsScalar(type.base_type)) {

return GenTypeBasic(type, user_facing_type) + afterbasic;

} else {

return beforeptr + GenTypePointer(type) + afterptr;

}

}

std::string GenEnumDecl(const EnumDef &enum_def) const {

const IDLOptions &opts = parser_.opts;

return (opts.scoped_enums ? "enum class " : "enum ") + Name(enum_def);

}

std::string GenEnumValDecl(const EnumDef &enum_def,

const std::string &enum_val) const {

const IDLOptions &opts = parser_.opts;

return opts.prefixed_enums ? Name(enum_def) + "_" + enum_val : enum_val;

}

std::string GetEnumValUse(const EnumDef &enum_def,

const EnumVal &enum_val) const {

const IDLOptions &opts = parser_.opts;

if (opts.scoped_enums) {

return Name(enum_def) + "::" + Name(enum_val);

} else if (opts.prefixed_enums) {

return Name(enum_def) + "_" + Name(enum_val);

} else {

return Name(enum_val);

}

}

std::string StripUnionType(const std::string &name) {

return name.substr(0, name.size() - strlen(UnionTypeFieldSuffix()));

}

std::string GetUnionElement(const EnumVal &ev, bool wrap, bool actual_type,

bool native_type = false) {

if (ev.union_type.base_type == BASE_TYPE_STRUCT) {

auto name = actual_type ? ev.union_type.struct_def->name : Name(ev);

return wrap ? WrapInNameSpace(ev.union_type.struct_def->defined_namespace,

name)

: name;

} else if (ev.union_type.base_type == BASE_TYPE_STRING) {

return actual_type ? (native_type ? "std::string" : "flatbuffers::String")

: Name(ev);

} else {

assert(false);

return Name(ev);

}

}

std::string UnionVerifySignature(const EnumDef &enum_def) {

return "bool Verify" + Name(enum_def) +

"(flatbuffers::Verifier &verifier, const void *obj, " +

Name(enum_def) + " type)";

}

std::string UnionVectorVerifySignature(const EnumDef &enum_def) {

return "bool Verify" + Name(enum_def) + "Vector" +

"(flatbuffers::Verifier &verifier, " +

"const flatbuffers::Vector<flatbuffers::Offset<void>> *values, " +

"const flatbuffers::Vector<uint8_t> *types)";

}

std::string UnionUnPackSignature(const EnumDef &enum_def, bool inclass) {

return (inclass ? "static " : "") + std::string("void *") +

(inclass ? "" : Name(enum_def) + "Union::") +

"UnPack(const void *obj, " + Name(enum_def) +

" type, const flatbuffers::resolver_function_t *resolver)";

}

std::string UnionPackSignature(const EnumDef &enum_def, bool inclass) {

return "flatbuffers::Offset<void> " +

(inclass ? "" : Name(enum_def) + "Union::") +

"Pack(flatbuffers::FlatBufferBuilder &_fbb, " +

"const flatbuffers::rehasher_function_t *_rehasher" +

(inclass ? " = nullptr" : "") + ") const";

}

std::string TableCreateSignature(const StructDef &struct_def, bool predecl,

const IDLOptions &opts) {

return "flatbuffers::Offset<" + Name(struct_def) + "> Create" +

Name(struct_def) + "(flatbuffers::FlatBufferBuilder &_fbb, const " +

NativeName(Name(struct_def), &struct_def, opts) +

" *_o, const flatbuffers::rehasher_function_t *_rehasher" +

(predecl ? " = nullptr" : "") + ")";

}

std::string TablePackSignature(const StructDef &struct_def, bool inclass,

const IDLOptions &opts) {

return std::string(inclass ? "static " : "") + "flatbuffers::Offset<" +

Name(struct_def) + "> " + (inclass ? "" : Name(struct_def) + "::") +

"Pack(flatbuffers::FlatBufferBuilder &_fbb, " + "const " +

NativeName(Name(struct_def), &struct_def, opts) + "* _o, " +

"const flatbuffers::rehasher_function_t *_rehasher" +

(inclass ? " = nullptr" : "") + ")";

}

std::string TableUnPackSignature(const StructDef &struct_def, bool inclass,

const IDLOptions &opts) {

return NativeName(Name(struct_def), &struct_def, opts) + " *" +

(inclass ? "" : Name(struct_def) + "::") +

"UnPack(const flatbuffers::resolver_function_t *_resolver" +

(inclass ? " = nullptr" : "") + ") const";

}

std::string TableUnPackToSignature(const StructDef &struct_def, bool inclass,

const IDLOptions &opts) {

return "void " + (inclass ? "" : Name(struct_def) + "::") + "UnPackTo(" +

NativeName(Name(struct_def), &struct_def, opts) + " *" +

"_o, const flatbuffers::resolver_function_t *_resolver" +

(inclass ? " = nullptr" : "") + ") const";

}

void GenMiniReflectPre(const StructDef *struct_def) {

code_.SetValue("NAME", struct_def->name);

code_ += "inline flatbuffers::TypeTable *{{NAME}}TypeTable();";

code_ += "";

}

void GenMiniReflect(const StructDef *struct_def, const EnumDef *enum_def) {

code_.SetValue("NAME", struct_def ? struct_def->name : enum_def->name);

code_.SetValue("SEQ_TYPE",

struct_def ? (struct_def->fixed ? "ST_STRUCT" : "ST_TABLE")

: (enum_def->is_union ? "ST_UNION" : "ST_ENUM"));

auto num_fields =

struct_def ? struct_def->fields.vec.size() : enum_def->vals.vec.size();

code_.SetValue("NUM_FIELDS", NumToString(num_fields));

std::vector<std::string> names;

std::vector<Type> types;

bool consecutive_enum_from_zero = true;

if (struct_def) {

for (auto it = struct_def->fields.vec.begin();

it != struct_def->fields.vec.end(); ++it) {

const auto &field = **it;

names.push_back(Name(field));

types.push_back(field.value.type);

}

} else {

for (auto it = enum_def->vals.vec.begin(); it != enum_def->vals.vec.end();

++it) {

const auto &ev = **it;

names.push_back(Name(ev));

types.push_back(enum_def->is_union ? ev.union_type

: Type(enum_def->underlying_type));

if (static_cast<int64_t>(it - enum_def->vals.vec.begin()) != ev.value) {

consecutive_enum_from_zero = false;

}

}

}

std::string ts;

std::vector<std::string> type_refs;

for (auto it = types.begin(); it != types.end(); ++it) {

auto &type = *it;

if (!ts.empty()) ts += ",\n ";

auto is_vector = type.base_type == BASE_TYPE_VECTOR;

auto bt = is_vector ? type.element : type.base_type;

auto et = IsScalar(bt) || bt == BASE_TYPE_STRING

? bt - BASE_TYPE_UTYPE + ET_UTYPE

: ET_SEQUENCE;

int ref_idx = -1;

std::string ref_name =

type.struct_def

? WrapInNameSpace(*type.struct_def)

: type.enum_def ? WrapInNameSpace(*type.enum_def) : "";

if (!ref_name.empty()) {

auto rit = type_refs.begin();

for (; rit != type_refs.end(); ++rit) {

if (*rit == ref_name) {

ref_idx = static_cast<int>(rit - type_refs.begin());

break;

}

}

if (rit == type_refs.end()) {

ref_idx = static_cast<int>(type_refs.size());

type_refs.push_back(ref_name);

}

}

ts += "{ flatbuffers::" + std::string(ElementaryTypeNames()[et]) + ", " +

NumToString(is_vector) + ", " + NumToString(ref_idx) + " }";

}

std::string rs;

for (auto it = type_refs.begin(); it != type_refs.end(); ++it) {

if (!rs.empty()) rs += ",\n ";

rs += *it + "TypeTable";

}

std::string ns;

for (auto it = names.begin(); it != names.end(); ++it) {

if (!ns.empty()) ns += ",\n ";

ns += "\"" + *it + "\"";

}

std::string vs;

if (enum_def && !consecutive_enum_from_zero) {

for (auto it = enum_def->vals.vec.begin(); it != enum_def->vals.vec.end();

++it) {

const auto &ev = **it;

if (!vs.empty()) vs += ", ";

vs += NumToString(ev.value);

}

} else if (struct_def && struct_def->fixed) {

for (auto it = struct_def->fields.vec.begin();

it != struct_def->fields.vec.end(); ++it) {

const auto &field = **it;

vs += NumToString(field.value.offset);

vs += ", ";

}

vs += NumToString(struct_def->bytesize);

}

code_.SetValue("TYPES", ts);

code_.SetValue("REFS", rs);

code_.SetValue("NAMES", ns);

code_.SetValue("VALUES", vs);

code_ += "inline flatbuffers::TypeTable *{{NAME}}TypeTable() {";

if (num_fields) {

code_ += " static flatbuffers::TypeCode type_codes[] = {";

code_ += " {{TYPES}}";

code_ += " };";

}

if (!type_refs.empty()) {

code_ += " static flatbuffers::TypeFunction type_refs[] = {";

code_ += " {{REFS}}";

code_ += " };";

}

if (!vs.empty()) {

code_ += " static const int32_t values[] = { {{VALUES}} };";

}

auto has_names =

num_fields && parser_.opts.mini_reflect == IDLOptions::kTypesAndNames;

if (has_names) {

code_ += " static const char *names[] = {";

code_ += " {{NAMES}}";

code_ += " };";

}

code_ += " static flatbuffers::TypeTable tt = {";

code_ += std::string(" flatbuffers::{{SEQ_TYPE}}, {{NUM_FIELDS}}, ") +

(num_fields ? "type_codes, " : "nullptr, ") +

(!type_refs.empty() ? "type_refs, " : "nullptr, ") +

(!vs.empty() ? "values, " : "nullptr, ") +

(has_names ? "names" : "nullptr");

code_ += " };";

code_ += " return &tt;";

code_ += "}";

code_ += "";

}

// Generate an enum declaration,

// an enum string lookup table,

// and an enum array of values

void GenEnum(const EnumDef &enum_def) {

code_.SetValue("ENUM_NAME", Name(enum_def));

code_.SetValue("BASE_TYPE", GenTypeBasic(enum_def.underlying_type, false));

code_.SetValue("SEP", "");

GenComment(enum_def.doc_comment);

code_ += GenEnumDecl(enum_def) + "\\";

if (parser_.opts.scoped_enums) code_ += " : {{BASE_TYPE}}\\";

code_ += " {";

int64_t anyv = 0;

const EnumVal *minv = nullptr, *maxv = nullptr;

for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();

++it) {

const auto &ev = **it;

GenComment(ev.doc_comment, " ");

code_.SetValue("KEY", GenEnumValDecl(enum_def, Name(ev)));

code_.SetValue("VALUE", NumToString(ev.value));

code_ += "{{SEP}} {{KEY}} = {{VALUE}}\\";

code_.SetValue("SEP", ",\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) {

assert(minv && maxv);

code_.SetValue("SEP", ",\n");

if (enum_def.attributes.Lookup("bit_flags")) {

code_.SetValue("KEY", GenEnumValDecl(enum_def, "NONE"));

code_.SetValue("VALUE", "0");

code_ += "{{SEP}} {{KEY}} = {{VALUE}}\\";

code_.SetValue("KEY", GenEnumValDecl(enum_def, "ANY"));

code_.SetValue("VALUE", NumToString(anyv));

code_ += "{{SEP}} {{KEY}} = {{VALUE}}\\";

} else { // MIN & MAX are useless for bit_flags

code_.SetValue("KEY", GenEnumValDecl(enum_def, "MIN"));

code_.SetValue("VALUE", GenEnumValDecl(enum_def, minv->name));

code_ += "{{SEP}} {{KEY}} = {{VALUE}}\\";

code_.SetValue("KEY", GenEnumValDecl(enum_def, "MAX"));

code_.SetValue("VALUE", GenEnumValDecl(enum_def, maxv->name));

code_ += "{{SEP}} {{KEY}} = {{VALUE}}\\";

}

}

code_ += "";

code_ += "};";

if (parser_.opts.scoped_enums && enum_def.attributes.Lookup("bit_flags")) {

code_ += "DEFINE_BITMASK_OPERATORS({{ENUM_NAME}}, {{BASE_TYPE}})";

}

code_ += "";

// Generate an array of all enumeration values

auto num_fields = NumToString(enum_def.vals.vec.size());

code_ += "inline {{ENUM_NAME}} (&EnumValues{{ENUM_NAME}}())[" + num_fields +

"] {";

code_ += " static {{ENUM_NAME}} values[] = {";

for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();

++it) {

const auto &ev = **it;

auto value = GetEnumValUse(enum_def, ev);

auto suffix = *it != enum_def.vals.vec.back() ? "," : "";

code_ += " " + value + suffix;

}

code_ += " };";

code_ += " return values;";

code_ += "}";

code_ += "";

// 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;

// 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) {

code_ += "inline const char **EnumNames{{ENUM_NAME}}() {";

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();

++it) {

const auto &ev = **it;

while (val++ != ev.value) { code_ += " \"\","; }

code_ += " \"" + Name(ev) + "\",";

}

code_ += " nullptr";

code_ += " };";

code_ += " return names;";

code_ += "}";

code_ += "";

code_ += "inline const char *EnumName{{ENUM_NAME}}({{ENUM_NAME}} e) {";

code_ += " const size_t index = static_cast<int>(e)\\";

if (enum_def.vals.vec.front()->value) {

auto vals = GetEnumValUse(enum_def, *enum_def.vals.vec.front());

code_ += " - static_cast<int>(" + vals + ")\\";

}

code_ += ";";

code_ += " return EnumNames{{ENUM_NAME}}()[index];";

code_ += "}";

code_ += "";

}

// Generate type traits for unions to map from a type to union enum value.

if (enum_def.is_union && !enum_def.uses_type_aliases) {

for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();

++it) {

const auto &ev = **it;

if (it == enum_def.vals.vec.begin()) {

code_ += "template<typename T> struct {{ENUM_NAME}}Traits {";

} else {

auto name = GetUnionElement(ev, true, true);

code_ += "template<> struct {{ENUM_NAME}}Traits<" + name + "> {";

}

auto value = GetEnumValUse(enum_def, ev);

code_ += " static const {{ENUM_NAME}} enum_value = " + value + ";";

code_ += "};";

code_ += "";

}

}