diff --git a/include/flatbuffers/code_generators.h b/include/flatbuffers/code_generators.h index 666e1aa8c..6b27ea780 100644 --- a/include/flatbuffers/code_generators.h +++ b/include/flatbuffers/code_generators.h @@ -17,48 +17,23 @@ #ifndef FLATBUFFERS_CODE_GENERATORS_H_ #define FLATBUFFERS_CODE_GENERATORS_H_ -/** This file defines some classes, that code generators should extend to gain - common functionalities : - - BaseGenerator is the base class for all (binary, textual, strongly typed, - dynamically typed, whatever) generators. - It is really abstract, general and flexible and doesn't do much appart from - holding the parser, a path and a filename being processed. - Still, it brings a common structure (normalization) among generators - - The many advantages of object based generators will come later from : - - A) the CodeWriter class (semi-automatic indentation (python), semi-automatic - (C++) namespace scopes, export to different files (classic, top level - methods), - simpler code to generate string from things (comments (vector of strings), - indentation commands (TAB BAT), newlines (NL), numbers, const char* or - std::string) - - B) the Generator subclass (heritance for supporting different versions of a - language, avoid field name clash, write text/binary to file, types - management, - common computations and sctructures : enum analysis (function, array, map, - ordered list + binarysearch),...) - -*/ namespace flatbuffers { class BaseGenerator { -public: - BaseGenerator(const Parser &parser_, const std::string &path_, - const std::string &file_name_) - : parser(parser_), path(path_), file_name(file_name_){}; + public: + BaseGenerator(const Parser &parser, const std::string &path, + const std::string &file_name) + : parser_(parser), path_(path), file_name_(file_name){}; virtual bool generate() = 0; -protected: + protected: virtual ~BaseGenerator(){}; - const Parser &parser; - const std::string &path; - const std::string &file_name; + const Parser &parser_; + const std::string &path_; + const std::string &file_name_; }; -} // namespace flatbuffers +} // namespace flatbuffers -#endif // FLATBUFFERS_CODE_GENERATORS_H_ +#endif // FLATBUFFERS_CODE_GENERATORS_H_ diff --git a/src/idl_gen_cpp.cpp b/src/idl_gen_cpp.cpp index 7ea09c281..c1b6ba566 100644 --- a/src/idl_gen_cpp.cpp +++ b/src/idl_gen_cpp.cpp @@ -716,194 +716,195 @@ static std::string GeneratedFileName(const std::string &path, 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, + 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() { - // Check if we have any code to generate at all, to avoid an empty header. - for (auto it = parser.enums_.vec.begin(); it != parser.enums_.vec.end(); - ++it) { - if (!(*it)->generated) goto generate_code; - } - for (auto it = parser.structs_.vec.begin(); it != parser.structs_.vec.end(); - ++it) { - if (!(*it)->generated) goto generate_code; - } - // No code to generate, exit: - return true; + // Check if we have any code to generate at all, to avoid an empty header. + for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end(); + ++it) { + if (!(*it)->generated) goto generate_code; + } + for (auto it = parser_.structs_.vec.begin(); it != parser_.structs_.vec.end(); + ++it) { + if (!(*it)->generated) goto generate_code; + } + // No code to generate, exit: + return true; generate_code: - using namespace cpp; + using namespace cpp; - std::string code; - code = "// automatically generated by the FlatBuffers compiler," - " do not modify\n\n"; + std::string code; + code = + "// automatically generated by the FlatBuffers compiler," + " do not modify\n\n"; - // 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"; + // 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"; + 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 (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"; } } - 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 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); + } } - } - - // 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); + } } - } - 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 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); - // 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"; + // The root datatype accessor: + code += "inline const " + cpp_qualified_name + " *Get"; code += name; - code += "(void *buf) { return flatbuffers::GetMutableRoot<"; - code += name + ">(buf); }\n\n"; + 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"; } - // The root verifier: - code += "inline bool Verify"; - code += name; - code += "Buffer(flatbuffers::Verifier &verifier) { " - "return verifier.VerifyBuffer<"; - code += cpp_qualified_name + ">(); }\n\n"; + assert(code_generator_cur_name_space); + CloseNestedNameSpaces(code_generator_cur_name_space, &code); - if (parser.file_identifier_.length()) { - // Return the identifier - code += "inline const char *" + name; - code += "Identifier() { return \"" + parser.file_identifier_; - code += "\"; }\n\n"; + code_generator_cur_name_space = nullptr; - // 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"; - } + // Close the include guard. + code += "\n#endif // " + include_guard + "\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); + return SaveFile(GeneratedFileName(path_, file_name_).c_str(), code, false); } }; -} // namespace cpp +} // namespace cpp - -bool GenerateCPP(const Parser &parser, - const std::string &path, +bool GenerateCPP(const Parser &parser, const std::string &path, const std::string &file_name) { cpp::CppGenerator *generator = new cpp::CppGenerator(parser, path, file_name); return generator->generate(); diff --git a/src/idl_gen_general.cpp b/src/idl_gen_general.cpp index 09913c4c3..a763d969b 100644 --- a/src/idl_gen_general.cpp +++ b/src/idl_gen_general.cpp @@ -1147,58 +1147,54 @@ static bool SaveClass(const LanguageParameters &lang, const Parser &parser, return SaveFile(filename.c_str(), code, false); } -/** it'll be split later in java/csharp... and moved to separate files */ namespace general { -/** members methods signature will be simpler as they won't have to pass parser, - * filename & path */ -/** more features coming through the JavaGenerator, CSharpGenerator ...*/ class GeneralGenerator : public BaseGenerator { -public: - GeneralGenerator(const Parser &parser_, const std::string &path_, - const std::string &file_name_) - : BaseGenerator(parser_, path_, file_name_){}; + public: + GeneralGenerator(const Parser &parser, const std::string &path, + const std::string &file_name) + : BaseGenerator(parser, path, file_name){}; bool generate() { - assert(parser.opts.lang <= IDLOptions::kMAX); - auto lang = language_parameters[parser.opts.lang]; - std::string one_file_code; + assert(parser_.opts.lang <= IDLOptions::kMAX); + auto lang = language_parameters[parser_.opts.lang]; + std::string one_file_code; - for (auto it = parser.enums_.vec.begin(); - it != parser.enums_.vec.end(); ++it) { - std::string enumcode; - GenEnum(lang, parser, **it, &enumcode); - if (parser.opts.one_file) { - one_file_code += enumcode; + for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end(); + ++it) { + std::string enumcode; + GenEnum(lang, parser_, **it, &enumcode); + if (parser_.opts.one_file) { + one_file_code += enumcode; + } else { + if (!SaveClass(lang, parser_, (**it).name, enumcode, path_, false, + false)) + return false; + } } - else { - if (!SaveClass(lang, parser, (**it).name, enumcode, path, false, false)) - return false; - } - } - for (auto it = parser.structs_.vec.begin(); - it != parser.structs_.vec.end(); ++it) { - std::string declcode; - GenStruct(lang, parser, **it, &declcode); - if (parser.opts.one_file) { - one_file_code += declcode; + for (auto it = parser_.structs_.vec.begin(); + it != parser_.structs_.vec.end(); ++it) { + std::string declcode; + GenStruct(lang, parser_, **it, &declcode); + if (parser_.opts.one_file) { + one_file_code += declcode; + } else { + if (!SaveClass(lang, parser_, (**it).name, declcode, path_, true, + false)) + return false; + } } - else { - if (!SaveClass(lang, parser, (**it).name, declcode, path, true, false)) - return false; - } - } - if (parser.opts.one_file) { - return SaveClass(lang, parser, file_name, one_file_code,path, true, true); - } - return true; + if (parser_.opts.one_file) { + return SaveClass(lang, parser_, file_name_, one_file_code, path_, true, + true); + } + return true; } }; -} // namespace general +} // namespace general -bool GenerateGeneral(const Parser &parser, - const std::string &path, - const std::string & file_name) { +bool GenerateGeneral(const Parser &parser, const std::string &path, + const std::string &file_name) { general::GeneralGenerator *generator = new general::GeneralGenerator(parser, path, file_name); return generator->generate(); diff --git a/src/idl_gen_go.cpp b/src/idl_gen_go.cpp index 473e0fe60..f674d1f47 100644 --- a/src/idl_gen_go.cpp +++ b/src/idl_gen_go.cpp @@ -662,35 +662,32 @@ static void GenStructBuilder(const StructDef &struct_def, } class GoGenerator : public BaseGenerator { -public: - GoGenerator(const Parser &parser_, const std::string &path_, - const std::string &file_name_) - : BaseGenerator(parser_, path_, file_name_){}; + public: + GoGenerator(const Parser &parser, const std::string &path, + const std::string &file_name) + : BaseGenerator(parser, path, file_name){}; bool generate() { - for (auto it = parser.enums_.vec.begin(); - it != parser.enums_.vec.end(); ++it) { - std::string enumcode; - go::GenEnum(**it, &enumcode); - if (!go::SaveType(parser, **it, enumcode, path, false)) - return false; - } + for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end(); + ++it) { + std::string enumcode; + go::GenEnum(**it, &enumcode); + if (!go::SaveType(parser_, **it, enumcode, path_, false)) return false; + } - for (auto it = parser.structs_.vec.begin(); - it != parser.structs_.vec.end(); ++it) { - std::string declcode; - go::GenStruct(**it, &declcode, parser.root_struct_def_); - if (!go::SaveType(parser, **it, declcode, path, true)) - return false; - } + for (auto it = parser_.structs_.vec.begin(); + it != parser_.structs_.vec.end(); ++it) { + std::string declcode; + go::GenStruct(**it, &declcode, parser_.root_struct_def_); + if (!go::SaveType(parser_, **it, declcode, path_, true)) return false; + } - return true; + return true; } }; } // namespace go -bool GenerateGo(const Parser &parser, - const std::string &path, - const std::string & file_name) { +bool GenerateGo(const Parser &parser, const std::string &path, + const std::string &file_name) { go::GoGenerator *generator = new go::GoGenerator(parser, path, file_name); return generator->generate(); }