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(),
 406                        opts.size_prefixed)) {
 407           Error("binary \"" + filename +
 408                 "\" does not have expected file_identifier \"" +
 409                 parser->file_identifier_ +
 410                 "\", use --raw-binary to read this file anyway.");
 411         }
 412       }
 413     } else {
 414       // Check if file contains 0 bytes.
 415       if (!opts.use_flexbuffers && !is_binary_schema &&
 416           contents.length() != strlen(contents.c_str())) {
 417         Error("input file appears to be binary: " + filename, true);
 418       }
 419       if (is_schema) {
 420         // If we're processing multiple schemas, make sure to start each
 421         // one from scratch. If it depends on previous schemas it must do
 422         // so explicitly using an include.
 423         parser.reset(new flatbuffers::Parser(opts));
 424       }
 425       if (is_binary_schema) {
 426         LoadBinarySchema(*parser.get(), filename, contents);
 427       }
 428       if (opts.use_flexbuffers) {
 429         if (opts.lang_to_generate == IDLOptions::kJson) {
 430           parser->flex_root_ = flexbuffers::GetRoot(
 431               reinterpret_cast<const uint8_t *>(contents.c_str()),
 432               contents.size());
 433         } else {
 434           parser->flex_builder_.Clear();
 435           ParseFile(*parser.get(), filename, contents, include_directories);
 436         }
 437       } else {
 438         ParseFile(*parser.get(), filename, contents, include_directories);
 439         if (!is_schema && !parser->builder_.GetSize()) {
 440           // If a file doesn't end in .fbs, it must be json/binary. Ensure we
 441           // didn't just parse a schema with a different extension.
 442           Error("input file is neither json nor a .fbs (schema) file: " +
 443                     filename,
 444                 true);
 445         }
 446       }
 447       if ((is_schema || is_binary_schema) && !conform_to_schema.empty()) {
 448         auto err = parser->ConformTo(conform_parser);
 449         if (!err.empty()) Error("schemas don\'t conform: " + err);
 450       }
 451       if (schema_binary) {
 452         parser->Serialize();
 453         parser->file_extension_ = reflection::SchemaExtension();
 454       }
 455     }
 456
 457     std::string filebase =
 458         flatbuffers::StripPath(flatbuffers::StripExtension(filename));
 459
 460     for (size_t i = 0; i < params_.num_generators; ++i) {
 461       parser->opts.lang = params_.generators[i].lang;
 462       if (generator_enabled[i]) {
 463         if (!print_make_rules) {
 464           flatbuffers::EnsureDirExists(output_path);
 465           if ((!params_.generators[i].schema_only ||
 466                (is_schema || is_binary_schema)) &&
 467               !params_.generators[i].generate(*parser.get(), output_path,
 468                                               filebase)) {
 469             Error(std::string("Unable to generate ") +
 470                   params_.generators[i].lang_name + " for " + filebase);
 471           }
 472         } else {
 473           std::string make_rule = params_.generators[i].make_rule(
 474               *parser.get(), output_path, filename);
 475           if (!make_rule.empty())
 476             printf("%s\n",
 477                    flatbuffers::WordWrap(make_rule, 80, " ", " \\").c_str());
 478         }
 479         if (grpc_enabled) {
 480           if (params_.generators[i].generateGRPC != nullptr) {
 481             if (!params_.generators[i].generateGRPC(*parser.get(), output_path,
 482                                                     filebase)) {
 483               Error(std::string("Unable to generate GRPC interface for") +
 484                     params_.generators[i].lang_name);
 485             }
 486           } else {
 487             Warn(std::string("GRPC interface generator not implemented for ") +
 488                  params_.generators[i].lang_name);
 489           }
 490         }
 491       }
 492     }
 493
 494     if (!opts.root_type.empty()) {
 495       if (!parser->SetRootType(opts.root_type.c_str()))
 496         Error("unknown root type: " + opts.root_type);
 497       else if (parser->root_struct_def_->fixed)
 498         Error("root type must be a table");
 499     }
 500
 501     if (opts.proto_mode) GenerateFBS(*parser.get(), output_path, filebase);
 502
 503     // We do not want to generate code for the definitions in this file
 504     // in any files coming up next.
 505     parser->MarkGenerated();
 506   }
 507   return 0;
 508 }
 509
 510 }  // namespace flatbuffers