Jan 8, 2022 · Jan 5, 2022 · Jan 5, 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
 [toolchain.custom]
 [toolchain.host]
 build = true
 test = true

diff --git a/bootstrap/config/toolchain_win_gcc.toml b/bootstrap/config/toolchain_win_gcc.toml
 [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
 [toolchain.custom]
 [toolchain.host]
 build = true
 test = true

diff --git a/bootstrap/include/bootstrap/build_tpl.h b/bootstrap/include/bootstrap/build_tpl.h

 namespacebuildcc {

 voidtpl_cb(BaseTarget &target);
 structTplConfig {
 TplConfig() =default;

  OsId os_id{OsId::Linux};
 };

 voidtpl_cb(BaseTarget &target,const TplConfig &config = TplConfig());

 }// namespace buildcc

diff --git a/bootstrap/main.buildcc.cpp b/bootstrap/main.buildcc.cpp
 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
  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");
                    "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
 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
                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
  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

 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
    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

 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
      ->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

 } // 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

  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
      {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
    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
 }

 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 =
Original file line number	Diff line number	Diff line change
		@@ -1,4 +1,4 @@
		[toolchain.custom]
		[toolchain.host]
		build = true
		test = true

Expand Down
Original file line number	Diff line number	Diff line change
		@@ -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"
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -21,7 +21,13 @@

		namespacebuildcc {

		voidtpl_cb(BaseTarget &target);
		structTplConfig {
		TplConfig() =default;

		OsId os_id{OsId::Linux};
		};

		voidtpl_cb(BaseTarget &target,const TplConfig &config = TplConfig());

		}// namespace buildcc

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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()));
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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");
Expand DownExpand Up		@@ -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
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -21,7 +21,6 @@ namespace buildcc {
		void cli11_ho_cb(TargetInfo &info) {
		info.AddIncludeDir("include");
		info.GlobHeaders("include/CLI");
		// TODO, Add PCH
		}

		} // namespace buildcc
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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();
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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);
Expand Down