Allow the flatbuffer compiler (flatc) to be built as a library.

Change-Id: I71baff427243f96be1596b01ff3405fdf39386d7

CMakeLists.txt

@@ -48,6 +48,7 @@ set(FlatBuffers_Compiler_SRCS
   src/idl_gen_fbs.cpp
   src/idl_gen_grpc.cpp
   src/flatc.cpp
+  src/flatc_main.cpp
   grpc/src/compiler/schema_interface.h
   grpc/src/compiler/cpp_generator.h
   grpc/src/compiler/cpp_generator.cc

include/flatbuffers/flatc.h

+/*
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "flatbuffers/flatbuffers.h"
+#include "flatbuffers/idl.h"
+#include "flatbuffers/util.h"
+#include <functional>
+#include <limits>
+#include <string>
+
+#ifndef FLATC_H_
+#define FLATC_H_
+
+namespace flatbuffers {
+
+class FlatCompiler {
+ public:
+  // Output generator for the various programming languages and formats we
+  // support.
+  struct Generator {
+    typedef bool (*GenerateFn)(const flatbuffers::Parser &parser,
+                               const std::string &path,
+                               const std::string &file_name);
+    typedef std::string (*MakeRuleFn)(const flatbuffers::Parser &parser,
+                                      const std::string &path,
+                                      const std::string &file_name);
+
+    GenerateFn generate;
+    const char *generator_opt_short;
+    const char *generator_opt_long;
+    const char *lang_name;
+    GenerateFn generateGRPC;
+    flatbuffers::IDLOptions::Language lang;
+    const char *generator_help;
+    MakeRuleFn make_rule;
+  };
+
+  typedef void (*WarnFn)(const FlatCompiler *flatc,
+                         const std::string &warn,
+                         bool show_exe_name);
+
+  typedef void (*ErrorFn)(const FlatCompiler *flatc,
+                          const std::string &err,
+                          bool usage, bool show_exe_name);
+
+  // Parameters required to initialize the FlatCompiler.
+  struct InitParams {
+    InitParams()
+        : generators(nullptr),
+          num_generators(0),
+          warn_fn(nullptr),
+          error_fn(nullptr) {}
+
+    const Generator* generators;
+    size_t num_generators;
+    WarnFn warn_fn;
+    ErrorFn error_fn;
+  };
+
+  explicit FlatCompiler(const InitParams& params) : params_(params) {}
+
+  int Compile(int argc, const char** argv);
+
+  std::string GetUsageString(const char* program_name) const;
+
+ private:
+  void ParseFile(flatbuffers::Parser &parser,
+                 const std::string &filename,
+                 const std::string &contents,
+                 std::vector<const char *> &include_directories) const;
+
+  void Warn(const std::string &warn, bool show_exe_name = true) const;
+
+  void Error(const std::string &err, bool usage = true,
+             bool show_exe_name = true) const;
+
+  InitParams params_;
+};
+
+
+}  // namespace flatbuffers
+
+#endif  // FLATC_H_

src/flatc.cpp

@@ -14,105 +14,50 @@
  * limitations under the License.
  */
 
-#include "flatbuffers/flatbuffers.h"
-#include "flatbuffers/idl.h"
-#include "flatbuffers/util.h"
-#include <limits>
+#include "flatbuffers/flatc.h"
 
 #define FLATC_VERSION "1.5.0 (" __DATE__ ")"
 
-static void Error(const std::string &err, bool usage = false,
-                  bool show_exe_name = true);
+namespace flatbuffers {
 
-// This struct allows us to create a table of all possible output generators
-// for the various programming languages and formats we support.
-struct Generator {
-  bool (*generate)(const flatbuffers::Parser &parser,
-                   const std::string &path,
-                   const std::string &file_name);
-  const char *generator_opt_short;
-  const char *generator_opt_long;
-  const char *lang_name;
-  bool (*generateGRPC)(const flatbuffers::Parser &parser,
-                       const std::string &path,
-                       const std::string &file_name);
-  flatbuffers::IDLOptions::Language lang;
-  const char *generator_help;
+void FlatCompiler::ParseFile(
+    flatbuffers::Parser &parser,
+    const std::string &filename,
+    const std::string &contents,
+    std::vector<const char *> &include_directories) const {
+  auto local_include_directory = flatbuffers::StripFileName(filename);
+  include_directories.push_back(local_include_directory.c_str());
+  include_directories.push_back(nullptr);
+  if (!parser.Parse(contents.c_str(), &include_directories[0],
+                    filename.c_str()))
+    Error(parser.error_, false, false);
+  include_directories.pop_back();
+  include_directories.pop_back();
+}
 
-  std::string (*make_rule)(const flatbuffers::Parser &parser,
-                           const std::string &path,
-                           const std::string &file_name);
-};
+void FlatCompiler::Warn(const std::string &warn, bool show_exe_name) const {
+  params_.warn_fn(this, warn, show_exe_name);
+}
 
-const Generator generators[] = {
-  { flatbuffers::GenerateBinary,   "-b", "--binary", "binary",
-    nullptr,
-    flatbuffers::IDLOptions::kBinary,
-    "Generate wire format binaries for any data definitions",
-    flatbuffers::BinaryMakeRule },
-  { flatbuffers::GenerateTextFile, "-t", "--json", "text",
-    nullptr,
-    flatbuffers::IDLOptions::kJson,
-    "Generate text output for any data definitions",
-    flatbuffers::TextMakeRule },
-  { flatbuffers::GenerateCPP,      "-c", "--cpp", "C++",
-    flatbuffers::GenerateCppGRPC,
-    flatbuffers::IDLOptions::kCpp,
-    "Generate C++ headers for tables/structs",
-    flatbuffers::CPPMakeRule },
-  { flatbuffers::GenerateGo,       "-g", "--go", "Go",
-    flatbuffers::GenerateGoGRPC,
-    flatbuffers::IDLOptions::kGo,
-    "Generate Go files for tables/structs",
-    flatbuffers::GeneralMakeRule },
-  { flatbuffers::GenerateGeneral,  "-j", "--java", "Java",
-    nullptr,
-    flatbuffers::IDLOptions::kJava,
-    "Generate Java classes for tables/structs",
-    flatbuffers::GeneralMakeRule },
-  { flatbuffers::GenerateJS,       "-s", "--js", "JavaScript",
-    nullptr,
-    flatbuffers::IDLOptions::kJs,
-    "Generate JavaScript code for tables/structs",
-    flatbuffers::JSMakeRule },
-  { flatbuffers::GenerateGeneral,  "-n", "--csharp", "C#",
-    nullptr,
-    flatbuffers::IDLOptions::kCSharp,
-    "Generate C# classes for tables/structs",
-    flatbuffers::GeneralMakeRule },
-  { flatbuffers::GeneratePython,   "-p", "--python", "Python",
-    nullptr,
-    flatbuffers::IDLOptions::kPython,
-    "Generate Python files for tables/structs",
-    flatbuffers::GeneralMakeRule },
-  { flatbuffers::GeneratePhp, nullptr, "--php", "PHP",
-    nullptr,
-    flatbuffers::IDLOptions::kPhp,
-    "Generate PHP files for tables/structs",
-    flatbuffers::GeneralMakeRule },
-};
+void FlatCompiler::Error(const std::string &err, bool usage,
+                         bool show_exe_name) const {
+  params_.error_fn(this, err, usage, show_exe_name);
+}
 
-const char *g_program_name = nullptr;
-flatbuffers::Parser *g_parser = nullptr;
+std::string FlatCompiler::GetUsageString(const char* program_name) const {
+  std::stringstream ss;
+  ss << "Usageaa: " << program_name << " [OPTION]... FILE... [-- FILE...]\n";
+  for (size_t i = 0; i < params_.num_generators; ++i) {
+    const Generator& g = params_.generators[i];
 
-static void Warn(const std::string &warn, bool show_exe_name = true) {
-  if (show_exe_name) printf("%s: ", g_program_name);
-  printf("warning: %s\n", warn.c_str());
-}
+    std::stringstream full_name;
+    full_name << std::setw(12) << std::left << g.generator_opt_long;
+    const char *name = g.generator_opt_short ? g.generator_opt_short : "  ";
+    const char *help = g.generator_help;
 
-static void Error(const std::string &err, bool usage, bool show_exe_name) {
-  if (show_exe_name) printf("%s: ", g_program_name);
-  printf("error: %s\n", err.c_str());
-  if (usage) {
-    printf("usage: %s [OPTION]... FILE... [-- FILE...]\n", g_program_name);
-    for (size_t i = 0; i < sizeof(generators) / sizeof(generators[0]); ++i)
-      printf("  %-12s %s %s.\n",
-             generators[i].generator_opt_long,
-             generators[i].generator_opt_short
-               ? generators[i].generator_opt_short
-               : "  ",
-             generators[i].generator_help);
-    printf(
+    ss << "  " << full_name.str() << " " << name << "    " << help << ".\n";
+  }
+  ss <<
       "  -o PATH            Prefix PATH to all generated files.\n"
       "  -I PATH            Search for includes in the specified path.\n"
       "  -M                 Print make rules for generated files.\n"
@@ -154,32 +99,18 @@ static void Error(const std::string &err, bool usage, bool show_exe_name) {
       "FILEs after the -- must be binary flatbuffer format files.\n"
       "Output files are named using the base file name of the input,\n"
       "and written to the current directory or the path given by -o.\n"
-      "example: %s -c -b schema1.fbs schema2.fbs data.json\n",
-      g_program_name);
-  }
-  if (g_parser) delete g_parser;
-  exit(1);
+      "example: " << program_name << " -c -b schema1.fbs schema2.fbs data.json\n";
+  return ss.str();
 }
 
-static void ParseFile(flatbuffers::Parser &parser, const std::string &filename,
-                      const std::string &contents,
-                      std::vector<const char *> &include_directories) {
-  auto local_include_directory = flatbuffers::StripFileName(filename);
-  include_directories.push_back(local_include_directory.c_str());
-  include_directories.push_back(nullptr);
-  if (!parser.Parse(contents.c_str(), &include_directories[0],
-                     filename.c_str()))
-    Error(parser.error_, false, false);
-  include_directories.pop_back();
-  include_directories.pop_back();
-}
+int FlatCompiler::Compile(int argc, const char** argv) {
+  if (params_.generators == nullptr || params_.num_generators == 0) {
+    return 0;
+  }
 
-int main(int argc, const char *argv[]) {
-  g_program_name = argv[0];
   flatbuffers::IDLOptions opts;
   std::string output_path;
-  const size_t num_generators = sizeof(generators) / sizeof(generators[0]);
-  bool generator_enabled[num_generators] = { false };
+
   bool any_generator = false;
   bool print_make_rules = false;
   bool raw_binary = false;
@@ -188,9 +119,11 @@ int main(int argc, const char *argv[]) {
   std::vector<std::string> filenames;
   std::vector<const char *> include_directories;
   std::vector<const char *> conform_include_directories;
+  std::vector<bool> generator_enabled(params_.num_generators, false);
   size_t binary_files_from = std::numeric_limits<size_t>::max();
   std::string conform_to_schema;
-  for (int argi = 1; argi < argc; argi++) {
+
+  for (int argi = 0; argi < argc; argi++) {
     std::string arg = argv[argi];
     if (arg[0] == '-') {
       if (filenames.size() && arg[1] != '-')
@@ -261,13 +194,13 @@ int main(int argc, const char *argv[]) {
       } else if(arg == "--grpc") {
         grpc_enabled = true;
       } else {
-        for (size_t i = 0; i < num_generators; ++i) {
-          if (arg == generators[i].generator_opt_long ||
-              (generators[i].generator_opt_short &&
-               arg == generators[i].generator_opt_short)) {
+        for (size_t i = 0; i < params_.num_generators; ++i) {
+          if (arg == params_.generators[i].generator_opt_long ||
+              (params_.generators[i].generator_opt_short &&
+               arg == params_.generators[i].generator_opt_short)) {
             generator_enabled[i] = true;
             any_generator = true;
-            opts.lang_to_generate |= generators[i].lang;
+            opts.lang_to_generate |= params_.generators[i].lang;
             goto found;
           }
         }
@@ -297,8 +230,8 @@ int main(int argc, const char *argv[]) {
               conform_include_directories);
   }
 
-  // Now process the files:
-  g_parser = new flatbuffers::Parser(opts);
+  std::unique_ptr<flatbuffers::Parser> parser(new flatbuffers::Parser(opts));
+
   for (auto file_it = filenames.begin();
             file_it != filenames.end();
           ++file_it) {
@@ -309,8 +242,8 @@ int main(int argc, const char *argv[]) {
       bool is_binary = static_cast<size_t>(file_it - filenames.begin()) >=
                        binary_files_from;
       if (is_binary) {
-        g_parser->builder_.Clear();
-        g_parser->builder_.PushFlatBuffer(
+        parser->builder_.Clear();
+        parser->builder_.PushFlatBuffer(
           reinterpret_cast<const uint8_t *>(contents.c_str()),
           contents.length());
         if (!raw_binary) {
@@ -319,17 +252,17 @@ int main(int argc, const char *argv[]) {
           // does not contain a file identifier.
           // We'd expect that typically any binary used as a file would have
           // such an identifier, so by default we require them to match.
-          if (!g_parser->file_identifier_.length()) {
+          if (!parser->file_identifier_.length()) {
             Error("current schema has no file_identifier: cannot test if \"" +
                  *file_it +
                  "\" matches the schema, use --raw-binary to read this file"
                  " anyway.");
           } else if (!flatbuffers::BufferHasIdentifier(contents.c_str(),
-                         g_parser->file_identifier_.c_str())) {
+                         parser->file_identifier_.c_str())) {
             Error("binary \"" +
                  *file_it +
                  "\" does not have expected file_identifier \"" +
-                 g_parser->file_identifier_ +
+                 parser->file_identifier_ +
                  "\", use --raw-binary to read this file anyway.");
           }
         }
@@ -343,63 +276,62 @@ int main(int argc, const char *argv[]) {
           // If we're processing multiple schemas, make sure to start each
           // one from scratch. If it depends on previous schemas it must do
           // so explicitly using an include.
-          delete g_parser;
-          g_parser = new flatbuffers::Parser(opts);
+          parser.reset(new flatbuffers::Parser(opts));
         }
-        ParseFile(*g_parser, *file_it, contents, include_directories);
+        ParseFile(*parser.get(), *file_it, contents, include_directories);
         if (is_schema && !conform_to_schema.empty()) {
-          auto err = g_parser->ConformTo(conform_parser);
+          auto err = parser->ConformTo(conform_parser);
           if (!err.empty()) Error("schemas don\'t conform: " + err);
         }
         if (schema_binary) {
-          g_parser->Serialize();
-          g_parser->file_extension_ = reflection::SchemaExtension();
+          parser->Serialize();
+          parser->file_extension_ = reflection::SchemaExtension();
         }
       }
 
       std::string filebase = flatbuffers::StripPath(
                                flatbuffers::StripExtension(*file_it));
 
-      for (size_t i = 0; i < num_generators; ++i) {
-        g_parser->opts.lang = generators[i].lang;
+      for (size_t i = 0; i < params_.num_generators; ++i) {
+        parser->opts.lang = params_.generators[i].lang;
         if (generator_enabled[i]) {
           if (!print_make_rules) {
             flatbuffers::EnsureDirExists(output_path);
-            if (!generators[i].generate(*g_parser, output_path, filebase)) {
+            if (!params_.generators[i].generate(*parser.get(), output_path, filebase)) {
               Error(std::string("Unable to generate ") +
-                    generators[i].lang_name +
+                    params_.generators[i].lang_name +
                     " for " +
                     filebase);
             }
           } else {
-            std::string make_rule = generators[i].make_rule(
-                *g_parser, output_path, *file_it);
+            std::string make_rule = params_.generators[i].make_rule(
+                *parser.get(), output_path, *file_it);
             if (!make_rule.empty())
               printf("%s\n", flatbuffers::WordWrap(
                   make_rule, 80, " ", " \\").c_str());
           }
           if (grpc_enabled) {
-            if (generators[i].generateGRPC != nullptr) {
-              if (!generators[i].generateGRPC(*g_parser, output_path,
+            if (params_.generators[i].generateGRPC != nullptr) {
+              if (!params_.generators[i].generateGRPC(*parser.get(), output_path,
                                               filebase)) {
                 Error(std::string("Unable to generate GRPC interface for") +
-                      generators[i].lang_name);
+                      params_.generators[i].lang_name);
               }
             } else {
               Warn(std::string("GRPC interface generator not implemented for ")
-                   + generators[i].lang_name);
+                   + params_.generators[i].lang_name);
             }
           }
         }
       }
 
-      if (opts.proto_mode) GenerateFBS(*g_parser, output_path, filebase);
+      if (opts.proto_mode) GenerateFBS(*parser.get(), output_path, filebase);
 
       // We do not want to generate code for the definitions in this file
       // in any files coming up next.
-      g_parser->MarkGenerated();
+      parser->MarkGenerated();
   }
-
-  delete g_parser;
   return 0;
 }
+
+}  // namespace flatbuffers

src/flatc_main.cpp

+/*
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "flatbuffers/flatc.h"
+
+static const char *g_program_name = nullptr;
+
+static void Warn(const flatbuffers::FlatCompiler* flatc,
+                 const std::string &warn,
+                 bool show_exe_name) {
+  if (show_exe_name) {
+    printf("%s: ", g_program_name);
+  }
+  printf("warning: %s\n", warn.c_str());
+}
+
+static void Error(const flatbuffers::FlatCompiler* flatc,
+                  const std::string &err,
+                  bool usage,
+                  bool show_exe_name) {
+  if (show_exe_name) {
+    printf("%s: ", g_program_name);
+  }
+  printf("error: %s\n", err.c_str());
+  if (usage) {
+    printf("%s", flatc->GetUsageString(g_program_name).c_str());
+  }
+  exit(1);
+}
+
+int main(int argc, const char *argv[]) {
+  g_program_name = argv[0];
+
+  const flatbuffers::FlatCompiler::Generator generators[] = {
+    { flatbuffers::GenerateBinary,   "-b", "--binary", "binary",
+      nullptr,
+      flatbuffers::IDLOptions::kBinary,
+      "Generate wire format binaries for any data definitions",
+      flatbuffers::BinaryMakeRule },
+    { flatbuffers::GenerateTextFile, "-t", "--json", "text",
+      nullptr,
+      flatbuffers::IDLOptions::kJson,
+      "Generate text output for any data definitions",
+      flatbuffers::TextMakeRule },
+    { flatbuffers::GenerateCPP,      "-c", "--cpp", "C++",
+      flatbuffers::GenerateCppGRPC,
+      flatbuffers::IDLOptions::kCpp,
+      "Generate C++ headers for tables/structs",
+      flatbuffers::CPPMakeRule },
+    { flatbuffers::GenerateGo,       "-g", "--go", "Go",
+      flatbuffers::GenerateGoGRPC,
+      flatbuffers::IDLOptions::kGo,
+      "Generate Go files for tables/structs",
+      flatbuffers::GeneralMakeRule },
+    { flatbuffers::GenerateGeneral,  "-j", "--java", "Java",
+      nullptr,
+      flatbuffers::IDLOptions::kJava,
+      "Generate Java classes for tables/structs",
+      flatbuffers::GeneralMakeRule },
+    { flatbuffers::GenerateJS,       "-s", "--js", "JavaScript",
+      nullptr,
+      flatbuffers::IDLOptions::kJs,
+      "Generate JavaScript code for tables/structs",
+      flatbuffers::JSMakeRule },
+    { flatbuffers::GenerateGeneral,  "-n", "--csharp", "C#",
+      nullptr,
+      flatbuffers::IDLOptions::kCSharp,
+      "Generate C# classes for tables/structs",
+      flatbuffers::GeneralMakeRule },
+    { flatbuffers::GeneratePython,   "-p", "--python", "Python",
+      nullptr,
+      flatbuffers::IDLOptions::kPython,
+      "Generate Python files for tables/structs",
+      flatbuffers::GeneralMakeRule },
+    { flatbuffers::GeneratePhp, nullptr, "--php", "PHP",
+      nullptr,
+      flatbuffers::IDLOptions::kPhp,
+      "Generate PHP files for tables/structs",
+      flatbuffers::GeneralMakeRule },
+    };
+
+  flatbuffers::FlatCompiler::InitParams params;
+  params.generators = generators;
+  params.num_generators = sizeof(generators) / sizeof(generators[0]);
+  params.warn_fn = Warn;
+  params.error_fn = Error;
+
+  flatbuffers::FlatCompiler flatc(params);
+  return flatc.Compile(argc - 1, argv + 1);
+}