bool strict_json;
int indent_step;
bool output_enum_identifiers;
+ bool prefixed_enums;
GeneratorOptions() : strict_json(false), indent_step(2),
- output_enum_identifiers(true) {}
+ output_enum_identifiers(true), prefixed_enums(true) {}
};
// Generate text (JSON) from a given FlatBuffer, and a given Parser
// Generate a C++ header from the definitions in the Parser object.
// See idl_gen_cpp.
extern std::string GenerateCPP(const Parser &parser,
- const std::string &include_guard_ident);
+ const std::string &include_guard_ident,
+ const GeneratorOptions &opts);
extern bool GenerateCPP(const Parser &parser,
const std::string &path,
const std::string &file_name,
printf(" -%s %s.\n", generators[i].extension, generators[i].help);
printf(" -o PATH Prefix PATH to all generated files.\n"
" -S Strict JSON: add quotes to field names.\n"
+ " -P Don\'t prefix enum values with the enum name in C++.\n"
"FILEs may depend on declarations in earlier files.\n"
"FILEs after the -- must be binary flatbuffer format files.\n"
"Output files are named using the base file name of the input,"
case 'S':
opts.strict_json = true;
break;
+ case 'P':
+ opts.prefixed_enums = false;
+ break;
case '-': // Separator between text and binary input files.
binary_files_from = filenames.size();
break;
}
}
+static std::string GenEnumVal(const EnumDef &enum_def, const EnumVal &enum_val,
+ const GeneratorOptions &opts) {
+ return opts.prefixed_enums ? enum_def.name + "_" + enum_val.name
+ : enum_val.name;
+}
+
// Generate an enum declaration and an enum string lookup table.
- static void GenEnum(EnumDef &enum_def, std::string *code_ptr,
- std::string *code_ptr_post) {
+static void GenEnum(EnumDef &enum_def, std::string *code_ptr,
+ std::string *code_ptr_post,
+ const GeneratorOptions &opts) {
if (enum_def.generated) return;
std::string &code = *code_ptr;
std::string &code_post = *code_ptr_post;
++it) {
auto &ev = **it;
GenComment(ev.doc_comment, code_ptr, " ");
- code += " " + enum_def.name + "_" + ev.name + " = ";
+ code += " " + GenEnumVal(enum_def, ev, opts) + " = ";
code += NumToString(ev.value);
code += (it + 1) != enum_def.vals.vec.end() ? ",\n" : "\n";
}
code += "inline const char *EnumName" + enum_def.name;
code += "(int e) { return EnumNames" + enum_def.name + "()[e";
if (enum_def.vals.vec.front()->value)
- code += " - " + enum_def.name + "_" + enum_def.vals.vec.front()->name;
+ code += " - " + GenEnumVal(enum_def, *enum_def.vals.vec.front(), opts);
code += "]; }\n\n";
}
it != enum_def.vals.vec.end();
++it) {
auto &ev = **it;
- code_post += " case " + enum_def.name + "_" + ev.name;
+ code_post += " case " + GenEnumVal(enum_def, ev, opts);
if (!ev.value) {
code_post += ": return true;\n"; // "NONE" enum value.
} else {
// Iterate through all definitions we haven't generate code for (enums, structs,
// and tables) and output them to a single file.
-std::string GenerateCPP(const Parser &parser, const std::string &include_guard_ident) {
+std::string GenerateCPP(const Parser &parser,
+ const std::string &include_guard_ident,
+ const GeneratorOptions &opts) {
using namespace cpp;
// Generate code for all the enum declarations.
std::string enum_code, enum_code_post;
for (auto it = parser.enums_.vec.begin();
it != parser.enums_.vec.end(); ++it) {
- GenEnum(**it, &enum_code, &enum_code_post);
+ GenEnum(**it, &enum_code, &enum_code_post, opts);
}
// Generate forward declarations for all structs/tables, since they may
bool GenerateCPP(const Parser &parser,
const std::string &path,
const std::string &file_name,
- const GeneratorOptions & /*opts*/) {
- auto code = GenerateCPP(parser, file_name);
+ const GeneratorOptions &opts) {
+ auto code = GenerateCPP(parser, file_name, opts);
return !code.length() ||
SaveFile((path + file_name + "_generated.h").c_str(), code, false);
}