1 /*
2 * Copyright 2014 Google Inc. All rights reserved.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "flatbuffers/flatc.h"
18
19 #include <list>
20
21 namespace flatbuffers {
22
FLATC_VERSION()23 const char *FLATC_VERSION() { return FLATBUFFERS_VERSION(); }
24
ParseFile(flatbuffers::Parser & parser,const std::string & filename,const std::string & contents,std::vector<const char * > & include_directories) const25 void FlatCompiler::ParseFile(
26 flatbuffers::Parser &parser, const std::string &filename,
27 const std::string &contents,
28 std::vector<const char *> &include_directories) const {
29 auto local_include_directory = flatbuffers::StripFileName(filename);
30 include_directories.push_back(local_include_directory.c_str());
31 include_directories.push_back(nullptr);
32 if (!parser.Parse(contents.c_str(), &include_directories[0],
33 filename.c_str())) {
34 Error(parser.error_, false, false);
35 }
36 if (!parser.error_.empty()) { Warn(parser.error_, false); }
37 include_directories.pop_back();
38 include_directories.pop_back();
39 }
40
LoadBinarySchema(flatbuffers::Parser & parser,const std::string & filename,const std::string & contents)41 void FlatCompiler::LoadBinarySchema(flatbuffers::Parser &parser,
42 const std::string &filename,
43 const std::string &contents) {
44 if (!parser.Deserialize(reinterpret_cast<const uint8_t *>(contents.c_str()),
45 contents.size())) {
46 Error("failed to load binary schema: " + filename, false, false);
47 }
48 }
49
Warn(const std::string & warn,bool show_exe_name) const50 void FlatCompiler::Warn(const std::string &warn, bool show_exe_name) const {
51 params_.warn_fn(this, warn, show_exe_name);
52 }
53
Error(const std::string & err,bool usage,bool show_exe_name) const54 void FlatCompiler::Error(const std::string &err, bool usage,
55 bool show_exe_name) const {
56 params_.error_fn(this, err, usage, show_exe_name);
57 }
58
GetUsageString(const char * program_name) const59 std::string FlatCompiler::GetUsageString(const char *program_name) const {
60 std::stringstream ss;
61 ss << "Usage: " << program_name << " [OPTION]... FILE... [-- FILE...]\n";
62 for (size_t i = 0; i < params_.num_generators; ++i) {
63 const Generator &g = params_.generators[i];
64
65 std::stringstream full_name;
66 full_name << std::setw(16) << std::left << g.generator_opt_long;
67 const char *name = g.generator_opt_short ? g.generator_opt_short : " ";
68 const char *help = g.generator_help;
69
70 ss << " " << full_name.str() << " " << name << " " << help << ".\n";
71 }
72 // clang-format off
73
74 // Output width
75 // 12345678901234567890123456789012345678901234567890123456789012345678901234567890
76 ss <<
77 " -o PATH Prefix PATH to all generated files.\n"
78 " -I PATH Search for includes in the specified path.\n"
79 " -M Print make rules for generated files.\n"
80 " --version Print the version number of flatc and exit.\n"
81 " --strict-json Strict JSON: field names must be / will be quoted,\n"
82 " no trailing commas in tables/vectors.\n"
83 " --allow-non-utf8 Pass non-UTF-8 input through parser and emit nonstandard\n"
84 " \\x escapes in JSON. (Default is to raise parse error on\n"
85 " non-UTF-8 input.)\n"
86 " --natural-utf8 Output strings with UTF-8 as human-readable strings.\n"
87 " By default, UTF-8 characters are printed as \\uXXXX escapes.\n"
88 " --defaults-json Output fields whose value is the default when\n"
89 " writing JSON\n"
90 " --unknown-json Allow fields in JSON that are not defined in the\n"
91 " schema. These fields will be discared when generating\n"
92 " binaries.\n"
93 " --no-prefix Don\'t prefix enum values with the enum type in C++.\n"
94 " --scoped-enums Use C++11 style scoped and strongly typed enums.\n"
95 " also implies --no-prefix.\n"
96 " --gen-includes (deprecated), this is the default behavior.\n"
97 " If the original behavior is required (no include\n"
98 " statements) use --no-includes.\n"
99 " --no-includes Don\'t generate include statements for included\n"
100 " schemas the generated file depends on (C++ / Python).\n"
101 " --gen-mutable Generate accessors that can mutate buffers in-place.\n"
102 " --gen-onefile Generate single output file for C# and Go.\n"
103 " --gen-name-strings Generate type name functions for C++ and Rust.\n"
104 " --gen-object-api Generate an additional object-based API.\n"
105 " --gen-compare Generate operator== for object-based API types.\n"
106 " --gen-nullable Add Clang _Nullable for C++ pointer. or @Nullable for Java\n"
107 " --java-checkerframe work Add @Pure for Java.\n"
108 " --gen-generated Add @Generated annotation for Java\n"
109 " --gen-jvmstatic Add @JvmStatic annotation for Kotlin methods\n"
110 " in companion object for interop from Java to Kotlin.\n"
111 " --gen-all Generate not just code for the current schema files,\n"
112 " but for all files it includes as well.\n"
113 " If the language uses a single file for output (by default\n"
114 " the case for C++ and JS), all code will end up in this one\n"
115 " file.\n"
116 " --cpp-include Adds an #include in generated file.\n"
117 " --cpp-ptr-type T Set object API pointer type (default std::unique_ptr).\n"
118 " --cpp-str-type T Set object API string type (default std::string).\n"
119 " T::c_str(), T::length() and T::empty() must be supported.\n"
120 " The custom type also needs to be constructible from std::string\n"
121 " (see the --cpp-str-flex-ctor option to change this behavior).\n"
122 " --cpp-str-flex-ctor Don't construct custom string types by passing std::string\n"
123 " from Flatbuffers, but (char* + length).\n"
124 " --cpp-std CPP_STD Generate a C++ code using features of selected C++ standard.\n"
125 " Supported CPP_STD values:\n"
126 " * 'c++0x' - generate code compatible with old compilers;\n"
127 " * 'c++11' - use C++11 code generator (default);\n"
128 " * 'c++17' - use C++17 features in generated code (experimental).\n"
129 " --cpp-static-reflection When using C++17, generate extra code to provide compile-time\n"
130 " (static) reflection of Flatbuffers types. Requires --cpp-std\n"
131 " to be \"c++17\" or higher.\n"
132 " --object-prefix Customise class prefix for C++ object-based API.\n"
133 " --object-suffix Customise class suffix for C++ object-based API.\n"
134 " Default value is \"T\".\n"
135 " --go-namespace Generate the overriding namespace in Golang.\n"
136 " --go-import Generate the overriding import for flatbuffers in Golang\n"
137 " (default is \"github.com/google/flatbuffers/go\").\n"
138 " --raw-binary Allow binaries without file_identifier to be read.\n"
139 " This may crash flatc given a mismatched schema.\n"
140 " --size-prefixed Input binaries are size prefixed buffers.\n"
141 " --proto Input is a .proto, translate to .fbs.\n"
142 " --proto-namespace-suffix Add this namespace to any flatbuffers generated\n"
143 " SUFFIX from protobufs.\n"
144 " --oneof-union Translate .proto oneofs to flatbuffer unions.\n"
145 " --grpc Generate GRPC interfaces for the specified languages.\n"
146 " --schema Serialize schemas instead of JSON (use with -b).\n"
147 " --bfbs-comments Add doc comments to the binary schema files.\n"
148 " --bfbs-builtins Add builtin attributes to the binary schema files.\n"
149 " --bfbs-gen-embed Generate code to embed the bfbs schema to the source.\n"
150 " --conform FILE Specify a schema the following schemas should be\n"
151 " an evolution of. Gives errors if not.\n"
152 " --conform-includes Include path for the schema given with --conform PATH\n"
153 " --filename-suffix The suffix appended to the generated file names.\n"
154 " Default is '_generated'.\n"
155 " --filename-ext The extension appended to the generated file names.\n"
156 " Default is language-specific (e.g., '.h' for C++)\n"
157 " --include-prefix Prefix this path to any generated include statements.\n"
158 " PATH\n"
159 " --keep-prefix Keep original prefix of schema include statement.\n"
160 " --reflect-types Add minimal type reflection to code generation.\n"
161 " --reflect-names Add minimal type/name reflection.\n"
162 " --root-type T Select or override the default root_type\n"
163 " --require-explicit-ids When parsing schemas, require explicit ids (id: x).\n"
164 " --force-defaults Emit default values in binary output from JSON\n"
165 " --force-empty When serializing from object API representation,\n"
166 " force strings and vectors to empty rather than null.\n"
167 " --force-empty-vectors When serializing from object API representation,\n"
168 " force vectors to empty rather than null.\n"
169 " --flexbuffers Used with \"binary\" and \"json\" options, it generates\n"
170 " data using schema-less FlexBuffers.\n"
171 " --no-warnings Inhibit all warning messages.\n"
172 "FILEs may be schemas (must end in .fbs), binary schemas (must end in .bfbs),\n"
173 "or JSON files (conforming to preceding schema). FILEs after the -- must be\n"
174 "binary flatbuffer format files.\n"
175 "Output files are named using the base file name of the input,\n"
176 "and written to the current directory or the path given by -o.\n"
177 "example: " << program_name << " -c -b schema1.fbs schema2.fbs data.json\n";
178 // 12345678901234567890123456789012345678901234567890123456789012345678901234567890
179 // clang-format on
180 return ss.str();
181 }
182
Compile(int argc,const char ** argv)183 int FlatCompiler::Compile(int argc, const char **argv) {
184 if (params_.generators == nullptr || params_.num_generators == 0) {
185 return 0;
186 }
187
188 flatbuffers::IDLOptions opts;
189 std::string output_path;
190
191 bool any_generator = false;
192 bool print_make_rules = false;
193 bool raw_binary = false;
194 bool schema_binary = false;
195 bool grpc_enabled = false;
196 std::vector<std::string> filenames;
197 std::list<std::string> include_directories_storage;
198 std::vector<const char *> include_directories;
199 std::vector<const char *> conform_include_directories;
200 std::vector<bool> generator_enabled(params_.num_generators, false);
201 size_t binary_files_from = std::numeric_limits<size_t>::max();
202 std::string conform_to_schema;
203
204 for (int argi = 0; argi < argc; argi++) {
205 std::string arg = argv[argi];
206 if (arg[0] == '-') {
207 if (filenames.size() && arg[1] != '-')
208 Error("invalid option location: " + arg, true);
209 if (arg == "-o") {
210 if (++argi >= argc) Error("missing path following: " + arg, true);
211 output_path = flatbuffers::ConCatPathFileName(
212 flatbuffers::PosixPath(argv[argi]), "");
213 } else if (arg == "-I") {
214 if (++argi >= argc) Error("missing path following: " + arg, true);
215 include_directories_storage.push_back(
216 flatbuffers::PosixPath(argv[argi]));
217 include_directories.push_back(
218 include_directories_storage.back().c_str());
219 } else if (arg == "--conform") {
220 if (++argi >= argc) Error("missing path following: " + arg, true);
221 conform_to_schema = flatbuffers::PosixPath(argv[argi]);
222 } else if (arg == "--conform-includes") {
223 if (++argi >= argc) Error("missing path following: " + arg, true);
224 include_directories_storage.push_back(
225 flatbuffers::PosixPath(argv[argi]));
226 conform_include_directories.push_back(
227 include_directories_storage.back().c_str());
228 } else if (arg == "--include-prefix") {
229 if (++argi >= argc) Error("missing path following: " + arg, true);
230 opts.include_prefix = flatbuffers::ConCatPathFileName(
231 flatbuffers::PosixPath(argv[argi]), "");
232 } else if (arg == "--keep-prefix") {
233 opts.keep_include_path = true;
234 } else if (arg == "--strict-json") {
235 opts.strict_json = true;
236 } else if (arg == "--allow-non-utf8") {
237 opts.allow_non_utf8 = true;
238 } else if (arg == "--natural-utf8") {
239 opts.natural_utf8 = true;
240 } else if (arg == "--go-namespace") {
241 if (++argi >= argc) Error("missing golang namespace" + arg, true);
242 opts.go_namespace = argv[argi];
243 } else if (arg == "--go-import") {
244 if (++argi >= argc) Error("missing golang import" + arg, true);
245 opts.go_import = argv[argi];
246 } else if (arg == "--defaults-json") {
247 opts.output_default_scalars_in_json = true;
248 } else if (arg == "--unknown-json") {
249 opts.skip_unexpected_fields_in_json = true;
250 } else if (arg == "--no-prefix") {
251 opts.prefixed_enums = false;
252 } else if (arg == "--scoped-enums") {
253 opts.prefixed_enums = false;
254 opts.scoped_enums = true;
255 } else if (arg == "--no-union-value-namespacing") {
256 opts.union_value_namespacing = false;
257 } else if (arg == "--gen-mutable") {
258 opts.mutable_buffer = true;
259 } else if (arg == "--gen-name-strings") {
260 opts.generate_name_strings = true;
261 } else if (arg == "--gen-object-api") {
262 opts.generate_object_based_api = true;
263 } else if (arg == "--gen-compare") {
264 opts.gen_compare = true;
265 } else if (arg == "--cpp-include") {
266 if (++argi >= argc) Error("missing include following: " + arg, true);
267 opts.cpp_includes.push_back(argv[argi]);
268 } else if (arg == "--cpp-ptr-type") {
269 if (++argi >= argc) Error("missing type following: " + arg, true);
270 opts.cpp_object_api_pointer_type = argv[argi];
271 } else if (arg == "--cpp-str-type") {
272 if (++argi >= argc) Error("missing type following: " + arg, true);
273 opts.cpp_object_api_string_type = argv[argi];
274 } else if (arg == "--cpp-str-flex-ctor") {
275 opts.cpp_object_api_string_flexible_constructor = true;
276 } else if (arg == "--no-cpp-direct-copy") {
277 opts.cpp_direct_copy = false;
278 } else if (arg == "--gen-nullable") {
279 opts.gen_nullable = true;
280 } else if (arg == "--java-checkerframework") {
281 opts.java_checkerframework = true;
282 } else if (arg == "--gen-generated") {
283 opts.gen_generated = true;
284 } else if (arg == "--object-prefix") {
285 if (++argi >= argc) Error("missing prefix following: " + arg, true);
286 opts.object_prefix = argv[argi];
287 } else if (arg == "--object-suffix") {
288 if (++argi >= argc) Error("missing suffix following: " + arg, true);
289 opts.object_suffix = argv[argi];
290 } else if (arg == "--gen-all") {
291 opts.generate_all = true;
292 opts.include_dependence_headers = false;
293 } else if (arg == "--gen-includes") {
294 // Deprecated, remove this option some time in the future.
295 Warn("warning: --gen-includes is deprecated (it is now default)\n");
296 } else if (arg == "--no-includes") {
297 opts.include_dependence_headers = false;
298 } else if (arg == "--gen-onefile") {
299 opts.one_file = true;
300 } else if (arg == "--raw-binary") {
301 raw_binary = true;
302 } else if (arg == "--size-prefixed") {
303 opts.size_prefixed = true;
304 } else if (arg == "--") { // Separator between text and binary inputs.
305 binary_files_from = filenames.size();
306 } else if (arg == "--proto") {
307 opts.proto_mode = true;
308 } else if (arg == "--proto-namespace-suffix") {
309 if (++argi >= argc) Error("missing namespace suffix" + arg, true);
310 opts.proto_namespace_suffix = argv[argi];
311 } else if (arg == "--oneof-union") {
312 opts.proto_oneof_union = true;
313 } else if (arg == "--schema") {
314 schema_binary = true;
315 } else if (arg == "-M") {
316 print_make_rules = true;
317 } else if (arg == "--version") {
318 printf("flatc version %s\n", FLATC_VERSION());
319 exit(0);
320 } else if (arg == "--grpc") {
321 grpc_enabled = true;
322 } else if (arg == "--bfbs-comments") {
323 opts.binary_schema_comments = true;
324 } else if (arg == "--bfbs-builtins") {
325 opts.binary_schema_builtins = true;
326 } else if (arg == "--bfbs-gen-embed") {
327 opts.binary_schema_gen_embed = true;
328 } else if (arg == "--reflect-types") {
329 opts.mini_reflect = IDLOptions::kTypes;
330 } else if (arg == "--reflect-names") {
331 opts.mini_reflect = IDLOptions::kTypesAndNames;
332 } else if (arg == "--require-explicit-ids") {
333 opts.require_explicit_ids = true;
334 } else if (arg == "--root-type") {
335 if (++argi >= argc) Error("missing type following: " + arg, true);
336 opts.root_type = argv[argi];
337 } else if (arg == "--filename-suffix") {
338 if (++argi >= argc) Error("missing filename suffix: " + arg, true);
339 opts.filename_suffix = argv[argi];
340 } else if (arg == "--filename-ext") {
341 if (++argi >= argc) Error("missing filename extension: " + arg, true);
342 opts.filename_extension = argv[argi];
343 } else if (arg == "--force-defaults") {
344 opts.force_defaults = true;
345 } else if (arg == "--force-empty") {
346 opts.set_empty_strings_to_null = false;
347 opts.set_empty_vectors_to_null = false;
348 } else if (arg == "--force-empty-vectors") {
349 opts.set_empty_vectors_to_null = false;
350 } else if (arg == "--java-primitive-has-method") {
351 opts.java_primitive_has_method = true;
352 } else if (arg == "--cs-gen-json-serializer") {
353 opts.cs_gen_json_serializer = true;
354 } else if (arg == "--flexbuffers") {
355 opts.use_flexbuffers = true;
356 } else if (arg == "--gen-jvmstatic") {
357 opts.gen_jvmstatic = true;
358 } else if (arg == "--no-warnings") {
359 opts.no_warnings = true;
360 } else if (arg == "--cpp-std") {
361 if (++argi >= argc)
362 Error("missing C++ standard specification" + arg, true);
363 opts.cpp_std = argv[argi];
364 } else if (arg.rfind("--cpp-std=", 0) == 0) {
365 opts.cpp_std = arg.substr(std::string("--cpp-std=").size());
366 } else if (arg == "--cpp-static-reflection") {
367 opts.cpp_static_reflection = true;
368 } else {
369 for (size_t i = 0; i < params_.num_generators; ++i) {
370 if (arg == params_.generators[i].generator_opt_long ||
371 (params_.generators[i].generator_opt_short &&
372 arg == params_.generators[i].generator_opt_short)) {
373 generator_enabled[i] = true;
374 any_generator = true;
375 opts.lang_to_generate |= params_.generators[i].lang;
376 goto found;
377 }
378 }
379 Error("unknown commandline argument: " + arg, true);
380 found:;
381 }
382 } else {
383 filenames.push_back(flatbuffers::PosixPath(argv[argi]));
384 }
385 }
386
387 if (!filenames.size()) Error("missing input files", false, true);
388
389 if (opts.proto_mode) {
390 if (any_generator)
391 Error("cannot generate code directly from .proto files", true);
392 } else if (!any_generator && conform_to_schema.empty()) {
393 Error("no options: specify at least one generator.", true);
394 }
395
396 flatbuffers::Parser conform_parser;
397 if (!conform_to_schema.empty()) {
398 std::string contents;
399 if (!flatbuffers::LoadFile(conform_to_schema.c_str(), true, &contents))
400 Error("unable to load schema: " + conform_to_schema);
401
402 if (flatbuffers::GetExtension(conform_to_schema) ==
403 reflection::SchemaExtension()) {
404 LoadBinarySchema(conform_parser, conform_to_schema, contents);
405 } else {
406 ParseFile(conform_parser, conform_to_schema, contents,
407 conform_include_directories);
408 }
409 }
410
411 std::unique_ptr<flatbuffers::Parser> parser(new flatbuffers::Parser(opts));
412
413 for (auto file_it = filenames.begin(); file_it != filenames.end();
414 ++file_it) {
415 auto &filename = *file_it;
416 std::string contents;
417 if (!flatbuffers::LoadFile(filename.c_str(), true, &contents))
418 Error("unable to load file: " + filename);
419
420 bool is_binary =
421 static_cast<size_t>(file_it - filenames.begin()) >= binary_files_from;
422 auto ext = flatbuffers::GetExtension(filename);
423 auto is_schema = ext == "fbs" || ext == "proto";
424 auto is_binary_schema = ext == reflection::SchemaExtension();
425 if (is_binary) {
426 parser->builder_.Clear();
427 parser->builder_.PushFlatBuffer(
428 reinterpret_cast<const uint8_t *>(contents.c_str()),
429 contents.length());
430 if (!raw_binary) {
431 // Generally reading binaries that do not correspond to the schema
432 // will crash, and sadly there's no way around that when the binary
433 // does not contain a file identifier.
434 // We'd expect that typically any binary used as a file would have
435 // such an identifier, so by default we require them to match.
436 if (!parser->file_identifier_.length()) {
437 Error("current schema has no file_identifier: cannot test if \"" +
438 filename +
439 "\" matches the schema, use --raw-binary to read this file"
440 " anyway.");
441 } else if (!flatbuffers::BufferHasIdentifier(
442 contents.c_str(), parser->file_identifier_.c_str(),
443 opts.size_prefixed)) {
444 Error("binary \"" + filename +
445 "\" does not have expected file_identifier \"" +
446 parser->file_identifier_ +
447 "\", use --raw-binary to read this file anyway.");
448 }
449 }
450 } else {
451 // Check if file contains 0 bytes.
452 if (!opts.use_flexbuffers && !is_binary_schema &&
453 contents.length() != strlen(contents.c_str())) {
454 Error("input file appears to be binary: " + filename, true);
455 }
456 if (is_schema) {
457 // If we're processing multiple schemas, make sure to start each
458 // one from scratch. If it depends on previous schemas it must do
459 // so explicitly using an include.
460 parser.reset(new flatbuffers::Parser(opts));
461 }
462 if (is_binary_schema) {
463 LoadBinarySchema(*parser.get(), filename, contents);
464 }
465 if (opts.use_flexbuffers) {
466 if (opts.lang_to_generate == IDLOptions::kJson) {
467 parser->flex_root_ = flexbuffers::GetRoot(
468 reinterpret_cast<const uint8_t *>(contents.c_str()),
469 contents.size());
470 } else {
471 parser->flex_builder_.Clear();
472 ParseFile(*parser.get(), filename, contents, include_directories);
473 }
474 } else {
475 ParseFile(*parser.get(), filename, contents, include_directories);
476 if (!is_schema && !parser->builder_.GetSize()) {
477 // If a file doesn't end in .fbs, it must be json/binary. Ensure we
478 // didn't just parse a schema with a different extension.
479 Error("input file is neither json nor a .fbs (schema) file: " +
480 filename,
481 true);
482 }
483 }
484 if ((is_schema || is_binary_schema) && !conform_to_schema.empty()) {
485 auto err = parser->ConformTo(conform_parser);
486 if (!err.empty()) Error("schemas don\'t conform: " + err);
487 }
488 if (schema_binary || opts.binary_schema_gen_embed) {
489 parser->Serialize();
490 }
491 if (schema_binary) {
492 parser->file_extension_ = reflection::SchemaExtension();
493 }
494 }
495
496 std::string filebase =
497 flatbuffers::StripPath(flatbuffers::StripExtension(filename));
498
499 for (size_t i = 0; i < params_.num_generators; ++i) {
500 parser->opts.lang = params_.generators[i].lang;
501 if (generator_enabled[i]) {
502 if (!print_make_rules) {
503 flatbuffers::EnsureDirExists(output_path);
504 if ((!params_.generators[i].schema_only ||
505 (is_schema || is_binary_schema)) &&
506 !params_.generators[i].generate(*parser.get(), output_path,
507 filebase)) {
508 Error(std::string("Unable to generate ") +
509 params_.generators[i].lang_name + " for " + filebase);
510 }
511 } else {
512 if (params_.generators[i].make_rule == nullptr) {
513 Error(std::string("Cannot generate make rule for ") +
514 params_.generators[i].lang_name);
515 } else {
516 std::string make_rule = params_.generators[i].make_rule(
517 *parser.get(), output_path, filename);
518 if (!make_rule.empty())
519 printf("%s\n",
520 flatbuffers::WordWrap(make_rule, 80, " ", " \\").c_str());
521 }
522 }
523 if (grpc_enabled) {
524 if (params_.generators[i].generateGRPC != nullptr) {
525 if (!params_.generators[i].generateGRPC(*parser.get(), output_path,
526 filebase)) {
527 Error(std::string("Unable to generate GRPC interface for") +
528 params_.generators[i].lang_name);
529 }
530 } else {
531 Warn(std::string("GRPC interface generator not implemented for ") +
532 params_.generators[i].lang_name);
533 }
534 }
535 }
536 }
537
538 if (!opts.root_type.empty()) {
539 if (!parser->SetRootType(opts.root_type.c_str()))
540 Error("unknown root type: " + opts.root_type);
541 else if (parser->root_struct_def_->fixed)
542 Error("root type must be a table");
543 }
544
545 if (opts.proto_mode) GenerateFBS(*parser.get(), output_path, filebase);
546
547 // We do not want to generate code for the definitions in this file
548 // in any files coming up next.
549 parser->MarkGenerated();
550 }
551 return 0;
552 }
553
554 } // namespace flatbuffers
555