src/flatc.cpp

   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
  23 const char *FLATC_VERSION() { return FLATBUFFERS_VERSION(); }
  24
  25 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
  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
  50 void FlatCompiler::Warn(const std::string &warn, bool show_exe_name) const {
  51   params_.warn_fn(this, warn, show_exe_name);
  52 }
  53
  54 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
  59 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(12) << 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   ss <<
  74     "  -o PATH            Prefix PATH to all generated files.\n"
  75     "  -I PATH            Search for includes in the specified path.\n"
  76     "  -M                 Print make rules for generated files.\n"
  77     "  --version          Print the version number of flatc and exit.\n"
  78     "  --strict-json      Strict JSON: field names must be / will be quoted,\n"
  79     "                     no trailing commas in tables/vectors.\n"
  80     "  --allow-non-utf8   Pass non-UTF-8 input through parser and emit nonstandard\n"
  81     "                     \\x escapes in JSON. (Default is to raise parse error on\n"
  82     "                     non-UTF-8 input.)\n"
  83     "  --natural-utf8     Output strings with UTF-8 as human-readable strings.\n"
  84     "                     By default, UTF-8 characters are printed as \\uXXXX escapes.\n"
  85     "  --defaults-json    Output fields whose value is the default when\n"
  86     "                     writing JSON\n"
  87     "  --unknown-json     Allow fields in JSON that are not defined in the\n"
  88     "                     schema. These fields will be discared when generating\n"
  89     "                     binaries.\n"
  90     "  --no-prefix        Don\'t prefix enum values with the enum type in C++.\n"
  91     "  --scoped-enums     Use C++11 style scoped and strongly typed enums.\n"
  92     "                     also implies --no-prefix.\n"
  93     "  --gen-includes     (deprecated), this is the default behavior.\n"
  94     "                     If the original behavior is required (no include\n"
  95     "                     statements) use --no-includes.\n"
  96     "  --no-includes      Don\'t generate include statements for included\n"
  97     "                     schemas the generated file depends on (C++).\n"
  98     "  --gen-mutable      Generate accessors that can mutate buffers in-place.\n"
  99     "  --gen-onefile      Generate single output file for C# and Go.\n"
 100     "  --gen-name-strings Generate type name functions for C++.\n"
 101     "  --gen-object-api   Generate an additional object-based API.\n"
 102     "  --gen-compare      Generate operator== for object-based API types.\n"
 103     "  --gen-nullable     Add Clang _Nullable for C++ pointer. or @Nullable for Java\n"
 104     "  --java-checkerframework Add @Pure for Java.\n"
 105     "  --gen-generated    Add @Generated annotation for Java\n"
 106     "  --gen-all          Generate not just code for the current schema files,\n"
 107     "                     but for all files it includes as well.\n"
 108     "                     If the language uses a single file for output (by default\n"
 109     "                     the case for C++ and JS), all code will end up in this one\n"
 110     "                     file.\n"
 111     "  --cpp-include      Adds an #include in generated file.\n"
 112     "  --cpp-ptr-type T   Set object API pointer type (default std::unique_ptr).\n"
 113     "  --cpp-str-type T   Set object API string type (default std::string).\n"
 114     "                     T::c_str(), T::length() and T::empty() must be supported.\n"
 115     "                     The custom type also needs to be constructible from std::string\n"
 116     "                     (see the --cpp-str-flex-ctor option to change this behavior).\n"
 117     "  --cpp-str-flex-ctor Don't construct custom string types by passing std::string\n"
 118     "                     from Flatbuffers, but (char* + length).\n"
 119     "  --object-prefix    Customise class prefix for C++ object-based API.\n"
 120     "  --object-suffix    Customise class suffix for C++ object-based API.\n"
 121     "                     Default value is \"T\".\n"
 122     "  --no-js-exports    Removes Node.js style export lines in JS.\n"
 123     "  --goog-js-export   Uses goog.exports* for closure compiler exporting in JS.\n"
 124     "  --es6-js-export    Uses ECMAScript 6 export style lines in JS.\n"
 125     "  --go-namespace     Generate the overrided namespace in Golang.\n"
 126     "  --go-import        Generate the overrided import for flatbuffers in Golang\n"
 127     "                     (default is \"github.com/google/flatbuffers/go\").\n"
 128     "  --raw-binary       Allow binaries without file_indentifier to be read.\n"
 129     "                     This may crash flatc given a mismatched schema.\n"
 130     "  --size-prefixed    Input binaries are size prefixed buffers.\n"
 131     "  --proto            Input is a .proto, translate to .fbs.\n"
 132     "  --oneof-union      Translate .proto oneofs to flatbuffer unions.\n"
 133     "  --grpc             Generate GRPC interfaces for the specified languages.\n"
 134     "  --schema           Serialize schemas instead of JSON (use with -b).\n"
 135     "  --bfbs-comments    Add doc comments to the binary schema files.\n"
 136     "  --bfbs-builtins    Add builtin attributes to the binary schema files.\n"
 137     "  --conform FILE     Specify a schema the following schemas should be\n"
 138     "                     an evolution of. Gives errors if not.\n"
 139     "  --conform-includes Include path for the schema given with --conform PATH\n"
 140     "  --include-prefix   Prefix this path to any generated include statements.\n"
 141     "    PATH\n"
 142     "  --keep-prefix      Keep original prefix of schema include statement.\n"
 143     "  --no-fb-import     Don't include flatbuffers import statement for TypeScript.\n"
 144     "  --no-ts-reexport   Don't re-export imported dependencies for TypeScript.\n"
 145     "  --short-names      Use short function names for JS and TypeScript.\n"
 146     "  --reflect-types    Add minimal type reflection to code generation.\n"
 147     "  --reflect-names    Add minimal type/name reflection.\n"
 148     "  --root-type T      Select or override the default root_type\n"
 149     "  --force-defaults   Emit default values in binary output from JSON\n"
 150     "  --force-empty      When serializing from object API representation,\n"
 151     "                     force strings and vectors to empty rather than null.\n"
 152     "  --flexbuffers      Used with \"binary\" and \"json\" options, it generates\n"
 153     "                     data using schema-less FlexBuffers.\n"
 154     "FILEs may be schemas (must end in .fbs), binary schemas (must end in .bfbs),\n"
 155     "or JSON files (conforming to preceding schema). FILEs after the -- must be\n"
 156     "binary flatbuffer format files.\n"
 157     "Output files are named using the base file name of the input,\n"
 158     "and written to the current directory or the path given by -o.\n"
 159     "example: " << program_name << " -c -b schema1.fbs schema2.fbs data.json\n";
 160   // clang-format on
 161   return ss.str();
 162 }
 163
 164 int FlatCompiler::Compile(int argc, const char **argv) {
 165   if (params_.generators == nullptr || params_.num_generators == 0) {
 166     return 0;
 167   }
 168
 169   flatbuffers::IDLOptions opts;
 170   std::string output_path;
 171
 172   bool any_generator = false;
 173   bool print_make_rules = false;
 174   bool raw_binary = false;
 175   bool schema_binary = false;
 176   bool grpc_enabled = false;
 177   std::vector<std::string> filenames;
 178   std::list<std::string> include_directories_storage;
 179   std::vector<const char *> include_directories;
 180   std::vector<const char *> conform_include_directories;
 181   std::vector<bool> generator_enabled(params_.num_generators, false);
 182   size_t binary_files_from = std::numeric_limits<size_t>::max();
 183   std::string conform_to_schema;
 184
 185   for (int argi = 0; argi < argc; argi++) {
 186     std::string arg = argv[argi];
 187     if (arg[0] == '-') {
 188       if (filenames.size() && arg[1] != '-')
 189         Error("invalid option location: " + arg, true);
 190       if (arg == "-o") {
 191         if (++argi >= argc) Error("missing path following: " + arg, true);
 192         output_path = flatbuffers::ConCatPathFileName(
 193             flatbuffers::PosixPath(argv[argi]), "");
 194       } else if (arg == "-I") {
 195         if (++argi >= argc) Error("missing path following" + arg, true);
 196         include_directories_storage.push_back(
 197             flatbuffers::PosixPath(argv[argi]));
 198         include_directories.push_back(
 199             include_directories_storage.back().c_str());
 200       } else if (arg == "--conform") {
 201         if (++argi >= argc) Error("missing path following" + arg, true);
 202         conform_to_schema = flatbuffers::PosixPath(argv[argi]);
 203       } else if (arg == "--conform-includes") {
 204         if (++argi >= argc) Error("missing path following" + arg, true);
 205         include_directories_storage.push_back(
 206             flatbuffers::PosixPath(argv[argi]));
 207         conform_include_directories.push_back(
 208             include_directories_storage.back().c_str());
 209       } else if (arg == "--include-prefix") {
 210         if (++argi >= argc) Error("missing path following" + arg, true);
 211         opts.include_prefix = flatbuffers::ConCatPathFileName(
 212             flatbuffers::PosixPath(argv[argi]), "");
 213       } else if (arg == "--keep-prefix") {
 214         opts.keep_include_path = true;
 215       } else if (arg == "--strict-json") {
 216         opts.strict_json = true;
 217       } else if (arg == "--allow-non-utf8") {
 218         opts.allow_non_utf8 = true;
 219       } else if (arg == "--natural-utf8") {
 220         opts.natural_utf8 = true;
 221       } else if (arg == "--no-js-exports") {
 222         opts.skip_js_exports = true;
 223       } else if (arg == "--goog-js-export") {
 224         opts.use_goog_js_export_format = true;
 225         opts.use_ES6_js_export_format = false;
 226       } else if (arg == "--es6-js-export") {
 227         opts.use_goog_js_export_format = false;
 228         opts.use_ES6_js_export_format = true;
 229       } else if (arg == "--go-namespace") {
 230         if (++argi >= argc) Error("missing golang namespace" + arg, true);
 231         opts.go_namespace = argv[argi];
 232       } else if (arg == "--go-import") {
 233         if (++argi >= argc) Error("missing golang import" + arg, true);
 234         opts.go_import = argv[argi];
 235       } else if (arg == "--defaults-json") {
 236         opts.output_default_scalars_in_json = true;
 237       } else if (arg == "--unknown-json") {
 238         opts.skip_unexpected_fields_in_json = true;
 239       } else if (arg == "--no-prefix") {
 240         opts.prefixed_enums = false;
 241       } else if (arg == "--scoped-enums") {
 242         opts.prefixed_enums = false;
 243         opts.scoped_enums = true;
 244       } else if (arg == "--no-union-value-namespacing") {
 245         opts.union_value_namespacing = false;
 246       } else if (arg == "--gen-mutable") {
 247         opts.mutable_buffer = true;
 248       } else if (arg == "--gen-name-strings") {
 249         opts.generate_name_strings = true;
 250       } else if (arg == "--gen-object-api") {
 251         opts.generate_object_based_api = true;
 252       } else if (arg == "--gen-compare") {
 253         opts.gen_compare = true;
 254       } else if (arg == "--cpp-include") {
 255         if (++argi >= argc) Error("missing include following" + arg, true);
 256         opts.cpp_includes.push_back(argv[argi]);
 257       } else if (arg == "--cpp-ptr-type") {
 258         if (++argi >= argc) Error("missing type following" + arg, true);
 259         opts.cpp_object_api_pointer_type = argv[argi];
 260       } else if (arg == "--cpp-str-type") {
 261         if (++argi >= argc) Error("missing type following" + arg, true);
 262         opts.cpp_object_api_string_type = argv[argi];
 263       } else if (arg == "--cpp-str-flex-ctor") {
 264         opts.cpp_object_api_string_flexible_constructor = true;
 265       } else if (arg == "--gen-nullable") {
 266         opts.gen_nullable = true;
 267       } else if (arg == "--java-checkerframework") {
 268         opts.java_checkerframework = true;
 269       } else if (arg == "--gen-generated") {
 270         opts.gen_generated = true;
 271       } else if (arg == "--object-prefix") {
 272         if (++argi >= argc) Error("missing prefix following" + arg, true);
 273         opts.object_prefix = argv[argi];
 274       } else if (arg == "--object-suffix") {
 275         if (++argi >= argc) Error("missing suffix following" + arg, true);
 276         opts.object_suffix = argv[argi];
 277       } else if (arg == "--gen-all") {
 278         opts.generate_all = true;
 279         opts.include_dependence_headers = false;
 280       } else if (arg == "--gen-includes") {
 281         // Deprecated, remove this option some time in the future.
 282         printf("warning: --gen-includes is deprecated (it is now default)\n");
 283       } else if (arg == "--no-includes") {
 284         opts.include_dependence_headers = false;
 285       } else if (arg == "--gen-onefile") {
 286         opts.one_file = true;
 287       } else if (arg == "--raw-binary") {
 288         raw_binary = true;
 289       } else if (arg == "--size-prefixed") {
 290         opts.size_prefixed = true;
 291       } else if (arg == "--") {  // Separator between text and binary inputs.
 292         binary_files_from = filenames.size();
 293       } else if (arg == "--proto") {
 294         opts.proto_mode = true;
 295       } else if (arg == "--oneof-union") {
 296         opts.proto_oneof_union = true;
 297       } else if (arg == "--schema") {
 298         schema_binary = true;
 299       } else if (arg == "-M") {
 300         print_make_rules = true;
 301       } else if (arg == "--version") {
 302         printf("flatc version %s\n", FLATC_VERSION());
 303         exit(0);
 304       } else if (arg == "--grpc") {
 305         grpc_enabled = true;
 306       } else if (arg == "--bfbs-comments") {
 307         opts.binary_schema_comments = true;
 308       } else if (arg == "--bfbs-builtins") {
 309         opts.binary_schema_builtins = true;
 310       } else if (arg == "--no-fb-import") {
 311         opts.skip_flatbuffers_import = true;
 312       } else if (arg == "--no-ts-reexport") {
 313         opts.reexport_ts_modules = false;
 314       } else if (arg == "--short-names") {
 315         opts.js_ts_short_names = true;
 316       } else if (arg == "--reflect-types") {
 317         opts.mini_reflect = IDLOptions::kTypes;
 318       } else if (arg == "--reflect-names") {
 319         opts.mini_reflect = IDLOptions::kTypesAndNames;
 320       } else if (arg == "--root-type") {
 321         if (++argi >= argc) Error("missing type following" + arg, true);
 322         opts.root_type = argv[argi];
 323       } else if (arg == "--force-defaults") {
 324         opts.force_defaults = true;
 325       } else if (arg == "--force-empty") {
 326         opts.set_empty_to_null = false;
 327       } else if (arg == "--java-primitive-has-method") {
 328         opts.java_primitive_has_method = true;
 329       } else if (arg == "--flexbuffers") {
 330         opts.use_flexbuffers = true;
 331       } else {
 332         for (size_t i = 0; i < params_.num_generators; ++i) {
 333           if (arg == params_.generators[i].generator_opt_long ||
 334               (params_.generators[i].generator_opt_short &&
 335                arg == params_.generators[i].generator_opt_short)) {
 336             generator_enabled[i] = true;
 337             any_generator = true;
 338             opts.lang_to_generate |= params_.generators[i].lang;
 339             goto found;
 340           }
 341         }
 342         Error("unknown commandline argument: " + arg, true);
 343       found:;
 344       }
 345     } else {
 346       filenames.push_back(flatbuffers::PosixPath(argv[argi]));
 347     }
 348   }
 349
 350   if (!filenames.size()) Error("missing input files", false, true);
 351
 352   if (opts.proto_mode) {
 353     if (any_generator)
 354       Error("cannot generate code directly from .proto files", true);
 355   } else if (!any_generator && conform_to_schema.empty()) {
 356     Error("no options: specify at least one generator.", true);
 357   }
 358
 359   flatbuffers::Parser conform_parser;
 360   if (!conform_to_schema.empty()) {
 361     std::string contents;
 362     if (!flatbuffers::LoadFile(conform_to_schema.c_str(), true, &contents))
 363       Error("unable to load schema: " + conform_to_schema);
 364
 365     if (flatbuffers::GetExtension(conform_to_schema) ==
 366         reflection::SchemaExtension()) {
 367       LoadBinarySchema(conform_parser, conform_to_schema, contents);
 368     } else {
 369       ParseFile(conform_parser, conform_to_schema, contents,
 370                 conform_include_directories);
 371     }
 372   }
 373
 374   std::unique_ptr<flatbuffers::Parser> parser(new flatbuffers::Parser(opts));
 375
 376   for (auto file_it = filenames.begin(); file_it != filenames.end();
 377        ++file_it) {
 378     auto &filename = *file_it;
 379     std::string contents;
 380     if (!flatbuffers::LoadFile(filename.c_str(), true, &contents))
 381       Error("unable to load file: " + filename);
 382
 383     bool is_binary =
 384         static_cast<size_t>(file_it - filenames.begin()) >= binary_files_from;
 385     auto ext = flatbuffers::GetExtension(filename);
 386     auto is_schema = ext == "fbs" || ext == "proto";
 387     auto is_binary_schema = ext == reflection::SchemaExtension();
 388     if (is_binary) {
 389       parser->builder_.Clear();
 390       parser->builder_.PushFlatBuffer(
 391           reinterpret_cast<const uint8_t *>(contents.c_str()),
 392           contents.length());
 393       if (!raw_binary) {
 394         // Generally reading binaries that do not correspond to the schema
 395         // will crash, and sadly there's no way around that when the binary
 396         // does not contain a file identifier.
 397         // We'd expect that typically any binary used as a file would have
 398         // such an identifier, so by default we require them to match.
 399         if (!parser->file_identifier_.length()) {
 400           Error("current schema has no file_identifier: cannot test if \"" +
 401                 filename +
 402                 "\" matches the schema, use --raw-binary to read this file"
 403                 " anyway.");
 404         } else if (!flatbuffers::BufferHasIdentifier(
 405                        contents.c_str(), parser->file_identifier_.c_str(), opts.size_prefixed)) {
 406           Error("binary \"" + filename +
 407                 "\" does not have expected file_identifier \"" +
 408                 parser->file_identifier_ +
 409                 "\", use --raw-binary to read this file anyway.");
 410         }
 411       }
 412     } else {
 413       // Check if file contains 0 bytes.
 414       if (!opts.use_flexbuffers && !is_binary_schema &&
 415           contents.length() != strlen(contents.c_str())) {
 416         Error("input file appears to be binary: " + filename, true);
 417       }
 418       if (is_schema) {
 419         // If we're processing multiple schemas, make sure to start each
 420         // one from scratch. If it depends on previous schemas it must do
 421         // so explicitly using an include.
 422         parser.reset(new flatbuffers::Parser(opts));
 423       }
 424       if (is_binary_schema) {
 425         LoadBinarySchema(*parser.get(), filename, contents);
 426       }
 427       if (opts.use_flexbuffers) {
 428         if (opts.lang_to_generate == IDLOptions::kJson) {
 429           parser->flex_root_ = flexbuffers::GetRoot(
 430               reinterpret_cast<const uint8_t *>(contents.c_str()),
 431               contents.size());
 432         } else {
 433           parser->flex_builder_.Clear();
 434           ParseFile(*parser.get(), filename, contents, include_directories);
 435         }
 436       } else {
 437         ParseFile(*parser.get(), filename, contents, include_directories);
 438         if (!is_schema && !parser->builder_.GetSize()) {
 439           // If a file doesn't end in .fbs, it must be json/binary. Ensure we
 440           // didn't just parse a schema with a different extension.
 441           Error("input file is neither json nor a .fbs (schema) file: " +
 442                     filename,
 443                 true);
 444         }
 445       }
 446       if ((is_schema || is_binary_schema) && !conform_to_schema.empty()) {
 447         auto err = parser->ConformTo(conform_parser);
 448         if (!err.empty()) Error("schemas don\'t conform: " + err);
 449       }
 450       if (schema_binary) {
 451         parser->Serialize();
 452         parser->file_extension_ = reflection::SchemaExtension();
 453       }
 454     }
 455
 456     std::string filebase =
 457         flatbuffers::StripPath(flatbuffers::StripExtension(filename));
 458
 459     for (size_t i = 0; i < params_.num_generators; ++i) {
 460       parser->opts.lang = params_.generators[i].lang;
 461       if (generator_enabled[i]) {
 462         if (!print_make_rules) {
 463           flatbuffers::EnsureDirExists(output_path);
 464           if ((!params_.generators[i].schema_only ||
 465                (is_schema || is_binary_schema)) &&
 466               !params_.generators[i].generate(*parser.get(), output_path,
 467                                               filebase)) {
 468             Error(std::string("Unable to generate ") +
 469                   params_.generators[i].lang_name + " for " + filebase);
 470           }
 471         } else {
 472           std::string make_rule = params_.generators[i].make_rule(
 473               *parser.get(), output_path, filename);
 474           if (!make_rule.empty())
 475             printf("%s\n",
 476                    flatbuffers::WordWrap(make_rule, 80, " ", " \\").c_str());
 477         }
 478         if (grpc_enabled) {
 479           if (params_.generators[i].generateGRPC != nullptr) {
 480             if (!params_.generators[i].generateGRPC(*parser.get(), output_path,
 481                                                     filebase)) {
 482               Error(std::string("Unable to generate GRPC interface for") +
 483                     params_.generators[i].lang_name);
 484             }
 485           } else {
 486             Warn(std::string("GRPC interface generator not implemented for ") +
 487                  params_.generators[i].lang_name);
 488           }
 489         }
 490       }
 491     }
 492
 493     if (!opts.root_type.empty()) {
 494       if (!parser->SetRootType(opts.root_type.c_str()))
 495         Error("unknown root type: " + opts.root_type);
 496       else if (parser->root_struct_def_->fixed)
 497         Error("root type must be a table");
 498     }
 499
 500     if (opts.proto_mode) GenerateFBS(*parser.get(), output_path, filebase);
 501
 502     // We do not want to generate code for the definitions in this file
 503     // in any files coming up next.
 504     parser->MarkGenerated();
 505   }
 506   return 0;
 507 }
 508
 509 }  // namespace flatbuffers