coder137 · coder137 · Apr 8, 2022 · Mar 29, 2022 · Mar 29, 2022 · Mar 29, 2022
diff --git a/bootstrap/include/bootstrap/build_buildcc.h b/bootstrap/include/bootstrap/build_buildcc.h
@@ -59,9 +59,8 @@ class BuildBuildCC {
   static constexpr const char *const kBuildccLibName = "libbuildcc";
 
 public:
-  BuildBuildCC(Register &reg, const BaseToolchain &toolchain,
-               const TargetEnv &env)
-      : reg_(reg), toolchain_(toolchain), env_(env) {}
+  BuildBuildCC(const BaseToolchain &toolchain, const TargetEnv &env)
+      : toolchain_(toolchain), env_(env) {}
   BuildBuildCC(const BuildBuildCC &) = delete;
 
   void Setup(const ArgToolchainState &state);
@@ -75,7 +74,6 @@ class BuildBuildCC {
   }
 
 private:
-  Register &reg_;
   const BaseToolchain &toolchain_;
   TargetEnv env_;
 

diff --git a/bootstrap/include/bootstrap/build_tpl.h b/bootstrap/include/bootstrap/build_tpl.h
@@ -21,13 +21,7 @@
 
 namespace buildcc {
 
-struct TplConfig {
-  TplConfig() = default;
-
-  OsId os_id{OsId::Linux};
-};
-
-void tpl_cb(BaseTarget &target, const TplConfig &config = TplConfig());
+void tpl_cb(BaseTarget &target);
 
 } // namespace buildcc
 

diff --git a/bootstrap/main.buildcc.cpp b/bootstrap/main.buildcc.cpp
@@ -38,31 +38,32 @@ int main(int argc, char **argv) {
       .AddToolchain("host", "Host Toolchain", custom_toolchain_arg)
       .Parse(argc, argv);
 
-  Register reg;
-  reg.Clean(clean_cb);
+  Reg::Init();
+  Reg::Call(Args::Clean()).Func(clean_cb);
 
   BaseToolchain toolchain = custom_toolchain_arg.ConstructToolchain();
+  toolchain.Verify();
 
   BuildBuildCC buildcc(
-      reg, toolchain, TargetEnv(Project::GetRootDir(), Project::GetBuildDir()));
+      toolchain, TargetEnv(Project::GetRootDir(), Project::GetBuildDir()));
   buildcc.Setup(custom_toolchain_arg.state);
 
   const auto &buildcc_lib = buildcc.GetBuildcc();
   ExecutableTarget_generic buildcc_hybrid_simple_example(
       "buildcc_hybrid_simple_example", toolchain, "example/hybrid/simple");
-  reg.Build(custom_toolchain_arg.state, hybrid_simple_example_cb,
-            buildcc_hybrid_simple_example, buildcc_lib);
-  reg.Dep(buildcc_hybrid_simple_example, buildcc_lib);
+  Reg::Toolchain(custom_toolchain_arg.state)
+      .Build(hybrid_simple_example_cb, buildcc_hybrid_simple_example,
+             buildcc_lib)
+      .Dep(buildcc_hybrid_simple_example, buildcc_lib);
 
   // Runners
-  reg.RunBuild();
-  reg.RunTest();
+  Reg::Run();
 
   // - Clang Compile Commands
   plugin::ClangCompileCommands({&buildcc_lib}).Generate();
 
   // - Plugin Graph
-  std::string output = reg.GetTaskflow().dump();
+  std::string output = Reg::GetTaskflow().dump();
   const bool saved = env::save_file("graph.dot", output, false);
   env::assert_fatal(saved, "Could not save graph.dot file");
 

diff --git a/bootstrap/src/build_buildcc.cpp b/bootstrap/src/build_buildcc.cpp
@@ -131,7 +131,6 @@ void buildcc_cb(BaseTarget &target, const BaseGenerator &schema_gen,
   if constexpr (env::is_win()) {
     // TODO, Clang
     switch (target.GetToolchain().GetId()) {
-    case ToolchainId::Gcc:
     case ToolchainId::MinGW: {
       target.AddPreprocessorFlag("-DFMT_HEADER_ONLY=1");
       target.AddPreprocessorFlag("-DSPDLOG_FMT_EXTERNAL");
@@ -147,7 +146,7 @@ void buildcc_cb(BaseTarget &target, const BaseGenerator &schema_gen,
     }
   }
 
-  if constexpr (env::is_linux()) {
+  if constexpr (env::is_linux() || env::is_unix() || env::is_clang()) {
     // TODO, Clang
     switch (target.GetToolchain().GetId()) {
     case ToolchainId::Gcc: {
@@ -196,51 +195,41 @@ void BuildBuildCC::Setup(const ArgToolchainState &state) {
       TargetEnv(env_.GetTargetRootDir() / "third_party" / "flatbuffers",
                 env_.GetTargetBuildDir()));
 
-  reg_.CallbackIf(state, global_flags_cb, flatc_exe, toolchain_);
-  reg_.Build(state, build_flatc_exe_cb, flatc_exe);
-
   // Schema
   auto &schema_gen = storage_.Add<BaseGenerator>(
       kSchemaGenName, kSchemaGenName,
       TargetEnv(env_.GetTargetRootDir() / "buildcc" / "schema",
                 env_.GetTargetBuildDir() / toolchain_.GetName()));
-  reg_.Build(schema_gen_cb, schema_gen, flatc_exe);
-  reg_.Dep(schema_gen, flatc_exe);
 
   // Flatbuffers HO lib
   auto &flatbuffers_ho_lib = storage_.Add<TargetInfo>(
       kFlatbuffersHoName, toolchain_,
       TargetEnv(env_.GetTargetRootDir() / "third_party" / "flatbuffers",
                 env_.GetTargetBuildDir()));
-  reg_.CallbackIf(state, flatbuffers_ho_cb, flatbuffers_ho_lib);
 
   // CLI11 HO lib
   auto &cli11_ho_lib = storage_.Add<TargetInfo>(
       kCli11HoName, toolchain_,
       TargetEnv(env_.GetTargetRootDir() / "third_party" / "CLI11",
                 env_.GetTargetBuildDir()));
-  reg_.CallbackIf(state, cli11_ho_cb, cli11_ho_lib);
 
   // fmt HO lib
   auto &fmt_ho_lib = storage_.Add<TargetInfo>(
       kFmtHoName, toolchain_,
       TargetEnv(env_.GetTargetRootDir() / "third_party" / "fmt",
                 env_.GetTargetBuildDir()));
-  reg_.CallbackIf(state, fmt_ho_cb, fmt_ho_lib);
 
   // spdlog HO lib
   auto &spdlog_ho_lib = storage_.Add<TargetInfo>(
       kSpdlogHoName, toolchain_,
       TargetEnv(env_.GetTargetRootDir() / "third_party" / "spdlog",
                 env_.GetTargetBuildDir()));
-  reg_.CallbackIf(state, spdlog_ho_cb, spdlog_ho_lib);
 
   // taskflow HO lib
   auto &taskflow_ho_lib = storage_.Add<TargetInfo>(
       kTaskflowHoName, toolchain_,
       TargetEnv(env_.GetTargetRootDir() / "third_party" / "taskflow",
                 env_.GetTargetBuildDir()));
-  reg_.CallbackIf(state, taskflow_ho_cb, taskflow_ho_lib);
 
   // Tiny-process-library lib
   // TODO, Make this a generic selection between StaticTarget and
@@ -250,21 +239,31 @@ void BuildBuildCC::Setup(const ArgToolchainState &state) {
       TargetEnv(env_.GetTargetRootDir() / "third_party" /
                     "tiny-process-library",
                 env_.GetTargetBuildDir()));
-  reg_.CallbackIf(state, global_flags_cb, tpl_lib, toolchain_);
-  TplConfig tpl_config;
-  tpl_config.os_id = get_host_os();
-  reg_.Build(state, tpl_cb, tpl_lib, tpl_config);
 
+  // BuildCC lib
   // TODO, Make this a generic selection between StaticTarget and
   // DynamicTarget
   auto &buildcc_lib = storage_.Add<StaticTarget_generic>(
       kBuildccLibName, kBuildccLibName, toolchain_,
       TargetEnv(env_.GetTargetRootDir() / "buildcc", env_.GetTargetBuildDir()));
-  reg_.CallbackIf(state, global_flags_cb, buildcc_lib, toolchain_);
-  reg_.Build(state, buildcc_cb, buildcc_lib, schema_gen, flatbuffers_ho_lib,
-             fmt_ho_lib, spdlog_ho_lib, cli11_ho_lib, taskflow_ho_lib, tpl_lib);
-  reg_.Dep(buildcc_lib, schema_gen);
-  reg_.Dep(buildcc_lib, tpl_lib);
+
+  Reg::Toolchain(state)
+      .Func(global_flags_cb, flatc_exe, toolchain_)
+      .Build(build_flatc_exe_cb, flatc_exe)
+      .Build(schema_gen_cb, schema_gen, flatc_exe)
+      .Dep(schema_gen, flatc_exe)
+      .Func(flatbuffers_ho_cb, flatbuffers_ho_lib)
+      .Func(cli11_ho_cb, cli11_ho_lib)
+      .Func(fmt_ho_cb, fmt_ho_lib)
+      .Func(spdlog_ho_cb, spdlog_ho_lib)
+      .Func(taskflow_ho_cb, taskflow_ho_lib)
+      .Func(global_flags_cb, tpl_lib, toolchain_)
+      .Build(tpl_cb, tpl_lib)
+      .Func(global_flags_cb, buildcc_lib, toolchain_)
+      .Build(buildcc_cb, buildcc_lib, schema_gen, flatbuffers_ho_lib,
+             fmt_ho_lib, spdlog_ho_lib, cli11_ho_lib, taskflow_ho_lib, tpl_lib)
+      .Dep(buildcc_lib, schema_gen)
+      .Dep(buildcc_lib, tpl_lib);
 }
 
 } // namespace buildcc
diff --git a/bootstrap/src/build_tpl.cpp b/bootstrap/src/build_tpl.cpp
@@ -18,22 +18,17 @@
 
 namespace buildcc {
 
-void tpl_cb(BaseTarget &target, const TplConfig &config) {
+void tpl_cb(BaseTarget &target) {
   target.AddSource("process.cpp");
   target.AddIncludeDir("");
   target.AddHeader("process.hpp");
 
-  switch (config.os_id) {
-  case OsId::Win:
+  if constexpr (env::is_win()) {
     target.AddSource("process_win.cpp");
-    break;
-  case OsId::Linux:
-  case OsId::Unix:
-  case OsId::Mac:
+  }
+
+  if constexpr (env::is_linux() || env::is_unix() || env::is_clang()) {
     target.AddSource("process_unix.cpp");
-    break;
-  default:
-    break;
   }
 
   target.Build();

diff --git a/buildcc/lib/args/include/args/args.h b/buildcc/lib/args/include/args/args.h
@@ -27,13 +27,14 @@
 
 #include "toolchain/toolchain.h"
 
+#include "target/common/target_config.h"
+
 namespace fs = std::filesystem;
 
 namespace buildcc {
 
 /**
- * @brief Toolchain State used by the Register module to selectively build or
- * test targets
+ * @brief Toolchain State used to selectively build and test targets
  */
 struct ArgToolchainState {
   bool build{false};
@@ -81,8 +82,15 @@ struct ArgToolchain {
 struct ArgTarget {
   ArgTarget(){};
 
-  std::string compile_command{""};
-  std::string link_command{""};
+  TargetConfig GetTargetConfig() {
+    TargetConfig config;
+    config.compile_command = compile_command;
+    config.link_command = link_command;
+    return config;
+  }
+
+  std::string compile_command;
+  std::string link_command;
 };
 
 struct ArgCustom {
@@ -91,56 +99,8 @@ struct ArgCustom {
 
 class Args {
 private:
-  class Instance {
-  public:
-    /**
-     * @brief Parse command line information to CLI11
-     *
-     * @param argc from int main(int argc, char ** argv)
-     * @param argv from int main(int argc, char ** argv)
-     */
-    static void Parse(int argc, const char *const *argv);
-
-    /**
-     * @brief Add toolchain with a unique name and description
-     *
-     * @param out Receive the toolchain information through the CLI
-     * @param initial Set the default toolchain information as a fallback
-     */
-    Instance &AddToolchain(const std::string &name,
-                           const std::string &description, ArgToolchain &out,
-                           const ArgToolchain &initial = ArgToolchain());
-
-    /**
-     * @brief Add toolchain with a unique name and description
-     *
-     * @param out Receive the toolchain information through the CLI
-     * @param initial Set the default toolchain information as a fallback
-     */
-    Instance &AddTarget(const std::string &name, const std::string &description,
-                        ArgTarget &out, const ArgTarget &initial = ArgTarget());
-
-    /**
-     * @brief Custom callback for data
-     *
-     * @param add_cb Add callback that exposes underlying CLI::App
-     */
-    Instance &AddCustomCallback(const std::function<void(CLI::App &)> &add_cb);
-
-    /**
-     * @brief Add custom data
-     *
-     * @param data Derive from `buildcc::ArgCustom` and override the `Add` API
-     */
-    Instance &AddCustomData(ArgCustom &data);
-  };
-
-  struct Internal {
-    Instance instance;
-    CLI::App app{"BuildCC Buildsystem"};
-    CLI::App *toolchain{nullptr};
-    CLI::App *target{nullptr};
-  };
+  class Instance;
+  struct Internal;
 
 public:
   Args() = delete;
@@ -151,6 +111,8 @@ class Args {
   static void Deinit();
 
   // Getters
+  static bool IsInit();
+  static bool IsParsed();
   static bool Clean();
   static env::LogLevel GetLogLevel();
 
@@ -159,12 +121,64 @@ class Args {
 
 private:
   static void RootArgs();
-  static CLI::App &Ref();
+  static Internal &RefInternal();
+  static CLI::App &RefApp();
 
 private:
   static std::unique_ptr<Internal> internal_;
 };
 
+class Args::Instance {
+public:
+  /**
+   * @brief Parse command line information to CLI11
+   *
+   * @param argc from int main(int argc, char ** argv)
+   * @param argv from int main(int argc, char ** argv)
+   */
+  static void Parse(int argc, const char *const *argv);
+
+  /**
+   * @brief Add toolchain with a unique name and description
+   *
+   * @param out Receive the toolchain information through the CLI
+   * @param initial Set the default toolchain information as a fallback
+   */
+  Instance &AddToolchain(const std::string &name,
+                         const std::string &description, ArgToolchain &out,
+                         const ArgToolchain &initial = ArgToolchain());
+
+  /**
+   * @brief Add toolchain with a unique name and description
+   *
+   * @param out Receive the toolchain information through the CLI
+   * @param initial Set the default toolchain information as a fallback
+   */
+  Instance &AddTarget(const std::string &name, const std::string &description,
+                      ArgTarget &out, const ArgTarget &initial = ArgTarget());
+
+  /**
+   * @brief Custom callback for data
+   *
+   * @param add_cb Add callback that exposes underlying CLI::App
+   */
+  Instance &AddCustomCallback(const std::function<void(CLI::App &)> &add_cb);
+
+  /**
+   * @brief Add custom data
+   *
+   * @param data Derive from `buildcc::ArgCustom` and override the `Add` API
+   */
+  Instance &AddCustomData(ArgCustom &data);
+};
+
+struct Args::Internal {
+  Instance instance;
+  CLI::App app{"BuildCC Buildsystem"};
+  CLI::App *toolchain{nullptr};
+  CLI::App *target{nullptr};
+};
+
 } // namespace buildcc
 
 #endif