coder137 · coder137 · Jan 8, 2022 · Jan 5, 2022 · Jan 5, 2022 · Jan 5, 2022
diff --git a/bootstrap/config/toolchain_linux_gcc.toml b/bootstrap/config/toolchain_linux_gcc.toml
@@ -1,4 +1,4 @@
-[toolchain.custom]
+[toolchain.host]
 build = true
 test = true
 

diff --git a/bootstrap/config/toolchain_win_gcc.toml b/bootstrap/config/toolchain_win_gcc.toml
@@ -1,8 +1,8 @@
-[toolchain.custom]
+[toolchain.host]
 build = true
 test = true
 
-id = "gcc"
+id = "mingw"
 name = "x86_64-w64-mingw32"
 asm_compiler = "as"
 c_compiler = "gcc"

diff --git a/bootstrap/config/toolchain_win_msvc.toml b/bootstrap/config/toolchain_win_msvc.toml
@@ -1,4 +1,4 @@
-[toolchain.custom]
+[toolchain.host]
 build = true
 test = true
 

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

diff --git a/bootstrap/main.buildcc.cpp b/bootstrap/main.buildcc.cpp
@@ -35,15 +35,14 @@ static void hybrid_simple_example_cb(BaseTarget &target,
 int main(int argc, char **argv) {
   Args args;
   ArgToolchain custom_toolchain_arg;
-  args.AddToolchain("custom", "Host Toolchain", custom_toolchain_arg);
+  args.AddToolchain("host", "Host Toolchain", custom_toolchain_arg);
   args.Parse(argc, argv);
 
   Register reg(args);
   reg.Clean(clean_cb);
 
   BaseToolchain toolchain = custom_toolchain_arg.ConstructToolchain();
 
-  PersistentStorage storage;
   BuildBuildCC buildcc(
       reg, toolchain,
       TargetEnv(env::get_project_root_dir(), env::get_project_build_dir()));

diff --git a/bootstrap/src/build_buildcc.cpp b/bootstrap/src/build_buildcc.cpp
@@ -54,8 +54,10 @@ void buildcc_cb(BaseTarget &target, const BaseGenerator &schema_gen,
   target.GlobHeaders("lib/env/include/env");
 
   // TOOLCHAIN
+  target.GlobSources("lib/toolchain/src/api");
   target.AddIncludeDir("lib/toolchain/include");
   target.GlobHeaders("lib/toolchain/include/toolchain");
+  target.GlobHeaders("lib/toolchain/include/toolchain/api");
 
   // TARGET
   target.GlobSources("lib/target/src/common");
@@ -238,7 +240,9 @@ void BuildBuildCC::Setup(const ArgToolchainState &state) {
                     "tiny-process-library",
                 env_.GetTargetBuildDir()));
   reg_.CallbackIf(state, global_flags_cb, tpl_lib, toolchain_);
-  reg_.Build(state, tpl_cb, tpl_lib);
+  TplConfig tpl_config;
+  tpl_config.os_id = get_host_os();
+  reg_.Build(state, tpl_cb, tpl_lib, tpl_config);
 
   // TODO, Make this a generic selection between StaticTarget and
   // DynamicTarget

diff --git a/bootstrap/src/build_cli11.cpp b/bootstrap/src/build_cli11.cpp
@@ -21,7 +21,6 @@ namespace buildcc {
 void cli11_ho_cb(TargetInfo &info) {
   info.AddIncludeDir("include");
   info.GlobHeaders("include/CLI");
-  // TODO, Add PCH
 }
 
 } // namespace buildcc
diff --git a/bootstrap/src/build_flatbuffers.cpp b/bootstrap/src/build_flatbuffers.cpp
@@ -82,45 +82,30 @@ void build_flatc_exe_cb(BaseTarget &target) {
                 kFlatcPreprocessorFlags.cend(),
                 [&](const auto &f) { target.AddPreprocessorFlag(f); });
 
-  if constexpr (env::is_win()) {
-    switch (target.GetToolchain().GetId()) {
-    case ToolchainId::Gcc:
-    case ToolchainId::MinGW:
-      std::for_each(kFlatcGccCppCompileFlags.cbegin(),
-                    kFlatcGccCppCompileFlags.cend(),
-                    [&](const auto &f) { target.AddCppCompileFlag(f); });
-      break;
-    case ToolchainId::Msvc:
-      std::for_each(kFlatcMsvcCppCompileFlags.cbegin(),
-                    kFlatcMsvcCppCompileFlags.cend(),
-                    [&](const auto &f) { target.AddCppCompileFlag(f); });
-      break;
-    default:
-      break;
-    }
+  switch (target.GetToolchain().GetId()) {
+  case ToolchainId::Gcc:
+  case ToolchainId::MinGW:
+    std::for_each(kFlatcGccCppCompileFlags.cbegin(),
+                  kFlatcGccCppCompileFlags.cend(),
+                  [&](const auto &f) { target.AddCppCompileFlag(f); });
+    break;
+  case ToolchainId::Msvc:
+    std::for_each(kFlatcMsvcCppCompileFlags.cbegin(),
+                  kFlatcMsvcCppCompileFlags.cend(),
+                  [&](const auto &f) { target.AddCppCompileFlag(f); });
+    break;
+  case ToolchainId::Clang:
+    break;
+  default:
+    break;
   }
 
-  if constexpr (env::is_linux()) {
-    switch (target.GetToolchain().GetId()) {
-    case ToolchainId::Gcc:
-      std::for_each(kFlatcGccCppCompileFlags.cbegin(),
-                    kFlatcGccCppCompileFlags.cend(),
-                    [&](const auto &f) { target.AddCppCompileFlag(f); });
-      break;
-    default:
-      break;
-    }
-  }
-
-  // TODO, Add PCH
-
   target.Build();
 }
 
 void flatbuffers_ho_cb(TargetInfo &info) {
   info.AddIncludeDir("include");
   info.GlobHeaders("include/flatbuffers");
-  // TODO, Add PCH
 }
 
 } // namespace buildcc
diff --git a/bootstrap/src/build_taskflow.cpp b/bootstrap/src/build_taskflow.cpp
@@ -23,7 +23,12 @@ void taskflow_ho_cb(TargetInfo &info) {
   info.GlobHeaders("taskflow");
   info.GlobHeaders("taskflow/core");
   info.GlobHeaders("taskflow/core/algorithm");
-  // TODO, Track more header files
+  info.GlobHeaders("taskflow/cuda");
+  info.GlobHeaders("taskflow/cuda/cuda_algorithm");
+  info.GlobHeaders("taskflow/dsl");
+  info.GlobHeaders("taskflow/sycl");
+  info.GlobHeaders("taskflow/sycl/sycl_algorithm");
+  info.GlobHeaders("taskflow/utility");
 }
 
 } // namespace buildcc
diff --git a/bootstrap/src/build_tpl.cpp b/bootstrap/src/build_tpl.cpp
@@ -18,15 +18,22 @@
 
 namespace buildcc {
 
-void tpl_cb(BaseTarget &target) {
+void tpl_cb(BaseTarget &target, const TplConfig &config) {
   target.AddSource("process.cpp");
   target.AddIncludeDir("");
   target.AddHeader("process.hpp");
 
-  if constexpr (env::is_win()) {
+  switch (config.os_id) {
+  case OsId::Win:
     target.AddSource("process_win.cpp");
-  } else {
+    break;
+  case OsId::Linux:
+  case OsId::Unix:
+  case OsId::Mac:
     target.AddSource("process_unix.cpp");
+    break;
+  default:
+    break;
   }
 
   target.Build();

diff --git a/buildcc/lib/args/include/args/persistent_storage.h b/buildcc/lib/args/include/args/persistent_storage.h
@@ -48,7 +48,7 @@ class PersistentStorage {
     metadata.ptr = (void *)ptr;
     metadata.typeid_name = typeid(T).name();
     metadata.destructor = [this, identifier, ptr]() {
-      env::log_info("Cleaning", identifier);
+      env::log_trace("Cleaning", identifier);
       Remove<T>(ptr);
     };
     ptrs_.emplace(identifier, metadata);

diff --git a/buildcc/lib/args/src/args.cpp b/buildcc/lib/args/src/args.cpp
@@ -77,11 +77,12 @@ const std::unordered_map<const char *, buildcc::env::LogLevel> kLogLevelMap{
 
 const std::unordered_map<const char *, buildcc::base::Toolchain::Id>
     kToolchainIdMap{
-        {"gcc", buildcc::base::Toolchain::Id::Gcc},
-        {"msvc", buildcc::base::Toolchain::Id::Msvc},
-        {"clang", buildcc::base::Toolchain::Id::Clang},
-        {"custom", buildcc::base::Toolchain::Id::Custom},
-        {"undefined", buildcc::base::Toolchain::Id::Undefined},
+        {"gcc", buildcc::ToolchainId::Gcc},
+        {"msvc", buildcc::ToolchainId::Msvc},
+        {"mingw", buildcc::ToolchainId::MinGW},
+        {"clang", buildcc::ToolchainId::Clang},
+        {"custom", buildcc::ToolchainId::Custom},
+        {"undefined", buildcc::ToolchainId::Undefined},
     };
 
 } // namespace
@@ -136,19 +137,17 @@ void Args::RootArgs() {
       ->expected(kMinFiles, kMaxFiles);
 
   // Root flags
+  auto *root_group = app_.add_option_group(kRootGroup);
 
-  app_.add_flag(kCleanParam, clean_, kCleanDesc)->group(kRootGroup);
-  app_.add_option(kLoglevelParam, loglevel_, kLoglevelDesc)
-      ->transform(CLI::CheckedTransformer(kLogLevelMap, CLI::ignore_case))
-      ->group(kRootGroup);
+  root_group->add_flag(kCleanParam, clean_, kCleanDesc);
+  root_group->add_option(kLoglevelParam, loglevel_, kLoglevelDesc)
+      ->transform(CLI::CheckedTransformer(kLogLevelMap, CLI::ignore_case));
 
   // Dir flags
-  app_.add_option(kRootDirParam, project_root_dir_, kRootDirDesc)
-      ->required()
-      ->group(kRootGroup);
-  app_.add_option(kBuildDirParam, project_build_dir_, kBuildDirDesc)
-      ->required()
-      ->group(kRootGroup);
+  root_group->add_option(kRootDirParam, project_root_dir_, kRootDirDesc)
+      ->required();
+  root_group->add_option(kBuildDirParam, project_build_dir_, kBuildDirDesc)
+      ->required();
 }
 
 } // namespace buildcc
diff --git a/buildcc/lib/env/include/env/host_os.h b/buildcc/lib/env/include/env/host_os.h
@@ -56,4 +56,37 @@ inline constexpr bool is_unix() {
 
 } // namespace buildcc::env
 
+namespace buildcc {
+
+enum class OsId {
+  Linux,
+  Win,
+  Mac,
+  Unix,
+  Undefined,
+};
+
+inline constexpr OsId get_host_os() {
+  OsId os_id = OsId::Undefined;
+  if constexpr (env::is_linux()) {
+    os_id = OsId::Linux;
+  }
+
+  if constexpr (env::is_unix()) {
+    os_id = OsId::Unix;
+  }
+
+  if constexpr (env::is_win()) {
+    os_id = OsId::Win;
+  }
+
+  if constexpr (env::is_mac()) {
+    os_id = OsId::Mac;
+  }
+
+  return os_id;
+}
+
+} // namespace buildcc
+
 #endif
diff --git a/buildcc/lib/target/src/api/include_api.cpp b/buildcc/lib/target/src/api/include_api.cpp
@@ -54,7 +54,6 @@ void IncludeApi<T>::GlobHeadersAbsolute(const fs::path &absolute_path) {
 
   for (const auto &p : fs::directory_iterator(absolute_path)) {
     if (t.config_.IsValidHeader(p.path())) {
-      env::log_trace(__FUNCTION__, fmt::format("Added header {}", p.path()));
       AddHeaderAbsolute(p.path());
     }
   }

diff --git a/buildcc/lib/target/src/target/build.cpp b/buildcc/lib/target/src/target/build.cpp
@@ -86,11 +86,11 @@ void Target::Build() {
       {kLinkFlags, internal::aggregate(GetLinkFlags())},
 
       // Toolchain executables here
-      {kAsmCompiler, toolchain_.GetAsmCompiler()},
-      {kCCompiler, toolchain_.GetCCompiler()},
-      {kCppCompiler, toolchain_.GetCppCompiler()},
-      {kArchiver, toolchain_.GetArchiver()},
-      {kLinker, toolchain_.GetLinker()},
+      {kAsmCompiler, fmt::format("{}", fs::path(toolchain_.GetAsmCompiler()))},
+      {kCCompiler, fmt::format("{}", fs::path(toolchain_.GetCCompiler()))},
+      {kCppCompiler, fmt::format("{}", fs::path(toolchain_.GetCppCompiler()))},
+      {kArchiver, fmt::format("{}", fs::path(toolchain_.GetArchiver()))},
+      {kLinker, fmt::format("{}", fs::path(toolchain_.GetLinker()))},
   });
 
   // Load the serialized file

diff --git a/buildcc/lib/target/src/target/friend/compile_object.cpp b/buildcc/lib/target/src/target/friend/compile_object.cpp
@@ -50,7 +50,7 @@ void CompileObject::CacheCompileCommands() {
     const std::string selected_aggregated_compile_flags =
         target_.SelectCompileFlags(type).value_or("");
     const std::string selected_compiler =
-        target_.SelectCompiler(type).value_or("");
+        fmt::format("{}", fs::path(target_.SelectCompiler(type).value_or("")));
     object_iter.second.command = target_.command_.Construct(
         target_.GetConfig().compile_command,
         {

diff --git a/buildcc/lib/target/src/target/friend/compile_pch.cpp b/buildcc/lib/target/src/target/friend/compile_pch.cpp
@@ -136,9 +136,10 @@ fs::path CompilePch::ConstructObjectPath() const {
 }
 
 std::string CompilePch::ConstructCompileCommand() const {
-  const std::string compiler = target_.GetState().contains_cpp
-                                   ? target_.GetToolchain().GetCppCompiler()
-                                   : target_.GetToolchain().GetCCompiler();
+  std::string compiler = target_.GetState().contains_cpp
+                             ? target_.GetToolchain().GetCppCompiler()
+                             : target_.GetToolchain().GetCCompiler();
+  compiler = fmt::format("{}", fs::path(compiler));
   const TargetFileExt file_ext_type =
       target_.GetState().contains_cpp ? TargetFileExt::Cpp : TargetFileExt::C;
   const std::string compile_flags =