coder137 · coder137 · Apr 28, 2022 · Apr 25, 2022 · Apr 25, 2022 · Apr 25, 2022
diff --git a/bootstrap/main.buildcc.cpp b/bootstrap/main.buildcc.cpp
@@ -41,7 +41,8 @@ int main(int argc, char **argv) {
   Reg::Init();
   Reg::Call(Args::Clean()).Func(clean_cb);
 
-  BaseToolchain toolchain = custom_toolchain_arg.ConstructToolchain();
+  auto &toolchain = custom_toolchain_arg;
+  toolchain.SetToolchainInfoFunc(GlobalToolchainInfo::Get(toolchain.id));
 
   BuildBuildCC buildcc(
       toolchain, TargetEnv(Project::GetRootDir(), Project::GetBuildDir()));

diff --git a/bootstrap/src/build_buildcc.cpp b/bootstrap/src/build_buildcc.cpp
@@ -90,6 +90,7 @@ void buildcc_cb(BaseTarget &target, const BaseGenerator &schema_gen,
   target.GlobHeaders("lib/args/include/args");
 
   // Specialized Toolchains
+  target.GlobSources("toolchains/src");
   target.AddIncludeDir("toolchains/include");
   target.GlobHeaders("toolchains/include/toolchains");
 

diff --git a/buildcc/buildcc.h b/buildcc/buildcc.h
@@ -39,6 +39,10 @@
 #include "toolchains/toolchain_gcc.h"
 #include "toolchains/toolchain_msvc.h"
 #include "toolchains/toolchain_mingw.h"
+#include "toolchains/toolchain_generic.h"
+#include "toolchains/toolchain_custom.h"
+
+#include "toolchains/toolchain_infos.h"
 
 // TODO, Add more specialized toolchains here
 

diff --git a/buildcc/lib/args/include/args/args.h b/buildcc/lib/args/include/args/args.h
@@ -47,35 +47,31 @@ struct ArgToolchainState {
  * command line
  * Bundled with Toolchain State
  */
-struct ArgToolchain {
-  ArgToolchain() = default;
+class ArgToolchain : public Toolchain {
+public:
+  ArgToolchain()
+      : Toolchain(ToolchainId::Undefined, "", ToolchainExecutables()){};
   ArgToolchain(ToolchainId initial_id, const std::string &initial_name,
                const ToolchainExecutables &initial_executables)
-      : id(initial_id), name(initial_name), executables(initial_executables) {}
-  ArgToolchain(ToolchainId initial_id, const std::string &initial_name,
-               const std::string &initial_assembler,
-               const std::string &initial_c_compiler,
-               const std::string &initial_cpp_compiler,
-               const std::string &initial_archiver,
-               const std::string &initial_linker)
-      : ArgToolchain(initial_id, initial_name,
-                     ToolchainExecutables(initial_assembler, initial_c_compiler,
-                                          initial_cpp_compiler,
-                                          initial_archiver, initial_linker)) {}
-
-  /**
-   * @brief Construct a BaseToolchain from the arguments supplied through the
-   * command line information
-   */
-  // TODO, Update this for lock and ToolchainConfig
-  BaseToolchain ConstructToolchain() const {
-    return BaseToolchain(id, name, executables);
-  }
+      : Toolchain(initial_id, initial_name, initial_executables) {}
+  [[deprecated]] ArgToolchain(ToolchainId initial_id,
+                              const std::string &initial_name,
+                              const std::string &initial_assembler,
+                              const std::string &initial_c_compiler,
+                              const std::string &initial_cpp_compiler,
+                              const std::string &initial_archiver,
+                              const std::string &initial_linker)
+      : Toolchain(initial_id, initial_name,
+                  ToolchainExecutables(initial_assembler, initial_c_compiler,
+                                       initial_cpp_compiler, initial_archiver,
+                                       initial_linker)) {}
 
+public:
   ArgToolchainState state;
-  ToolchainId id{ToolchainId::Undefined};
-  std::string name{""};
-  ToolchainExecutables executables;
+  ToolchainId &id = RefId();
+  std::string &name = RefName();
+  ToolchainExecutables &executables = RefExecutables();
+  ToolchainConfig &config = RefConfig();
 };
 
 // NOTE, Incomplete without pch_compile_command

diff --git a/buildcc/lib/args/src/register.cpp b/buildcc/lib/args/src/register.cpp
@@ -23,6 +23,7 @@
 
 #include "env/assert_fatal.h"
 #include "env/env.h"
+#include "env/storage.h"
 
 namespace fs = std::filesystem;
 
@@ -67,13 +68,28 @@ namespace buildcc {
 
 std::unique_ptr<Reg::Instance> Reg::instance_;
 
+void SystemInit() {
+  Project::Init(fs::current_path() / Args::GetProjectRootDir(),
+                fs::current_path() / Args::GetProjectBuildDir());
+  env::set_log_level(Args::GetLogLevel());
+
+  // Top down (what is init first gets deinit last)
+  std::atexit([]() {
+    Project::Deinit();
+    Reg::Deinit();
+    Args::Deinit();
+    Storage::Clear();
+  });
+}
+
 void Reg::Init() {
   if (!instance_) {
     instance_ = std::make_unique<Instance>();
+    env::assert_fatal(static_cast<bool>(instance_), "Reg::Init failed");
     env::assert_fatal(Args::IsParsed(), "Setup your Args");
-    Project::Init(fs::current_path() / Args::GetProjectRootDir(),
-                  fs::current_path() / Args::GetProjectBuildDir());
-    env::set_log_level(Args::GetLogLevel());
+
+    // Initialize everything else here
+    SystemInit();
   }
 }
 

diff --git a/buildcc/lib/env/include/env/storage.h b/buildcc/lib/env/include/env/storage.h
@@ -32,13 +32,7 @@ namespace buildcc {
 class ScopedStorage {
 public:
   ScopedStorage() {}
-  ~ScopedStorage() {
-    for (const auto &ptr_iter : ptrs_) {
-      ptr_iter.second.destructor();
-    }
-    ptrs_.clear();
-    env::assert_fatal(ptrs_.empty(), "Memory not deallocated");
-  }
+  ~ScopedStorage() { Clear(); }
 
   ScopedStorage(const ScopedStorage &) = delete;
 
@@ -58,10 +52,15 @@ class ScopedStorage {
     return *ptr;
   }
 
-  template <typename T> void Remove(T *ptr) { delete ptr; }
+  void Clear() {
+    for (const auto &ptr_iter : ptrs_) {
+      ptr_iter.second.destructor();
+    }
+    ptrs_.clear();
+  }
 
   template <typename T> const T &ConstRef(const std::string &identifier) const {
-    env::assert_fatal(ptrs_.find(identifier) != ptrs_.end(),
+    env::assert_fatal(Contains(identifier),
                       fmt::format("Could not find '{}'", identifier));
     const PtrMetadata &metadata = ptrs_.at(identifier);
     env::assert_fatal(
@@ -77,12 +76,30 @@ class ScopedStorage {
         static_cast<const ScopedStorage &>(*this).ConstRef<T>(identifier));
   }
 
+  bool Contains(const std::string &identifier) const {
+    return (ptrs_.find(identifier) != ptrs_.end());
+  }
+
+  template <typename T> bool Valid(const std::string &identifier) const {
+    if (!Contains(identifier)) {
+      return false;
+    }
+    const PtrMetadata &metadata = ptrs_.at(identifier);
+    if (typeid(T).name() != metadata.typeid_name) {
+      return false;
+    }
+    return true;
+  }
+
+protected:
+  template <typename T> void Remove(T *ptr) { delete ptr; }
+
 private:
   /**
    * @brief
    * @param ptr Can hold data of any type
-   * @param typeid_name We cannot store a template type so this is the next best
-   * thing
+   * @param typeid_name We cannot store a template type so this is the next
+   * best thing
    * @param desstructor Destructor callback to delete ptr
    */
   struct PtrMetadata {
@@ -101,14 +118,13 @@ class Storage {
   Storage(const Storage &) = delete;
   Storage(Storage &&) = delete;
 
-  static void Init() { internal_ = std::make_unique<ScopedStorage>(); }
-  static void Deinit() { internal_.reset(nullptr); }
-
   template <typename T, typename... Params>
   static T &Add(const std::string &identifier, Params &&...params) {
     return Ref().Add<T, Params...>(identifier, std::forward<Params>(params)...);
   }
 
+  static void Clear() { Ref().Clear(); }
+
   template <typename T>
   static const T &ConstRef(const std::string &identifier) {
     return Ref().ConstRef<T>(identifier);
@@ -118,11 +134,19 @@ class Storage {
     return Ref().Ref<T>(identifier);
   }
 
+  static bool Contains(const std::string &identifier) {
+    return Ref().Contains(identifier);
+  }
+
+  template <typename T> static bool Valid(const std::string &identifier) {
+    return Ref().Valid<T>(identifier);
+  }
+
 private:
   static ScopedStorage &Ref();
 
 private:
-  static std::unique_ptr<ScopedStorage> internal_;
+  static ScopedStorage internal_;
 };
 
 } // namespace buildcc

diff --git a/buildcc/lib/env/src/storage.cpp b/buildcc/lib/env/src/storage.cpp
@@ -18,12 +18,8 @@
 
 namespace buildcc {
 
-std::unique_ptr<ScopedStorage> Storage::internal_;
+ScopedStorage Storage::internal_;
 
-ScopedStorage &Storage::Ref() {
-  env::assert_fatal(internal_ != nullptr,
-                    "Initialize Storage using the Storage::Init API");
-  return *internal_;
-}
+ScopedStorage &Storage::Ref() { return internal_; }
 
 } // namespace buildcc
diff --git a/buildcc/lib/env/test/test_storage.cpp b/buildcc/lib/env/test/test_storage.cpp
@@ -15,14 +15,23 @@ TEST_GROUP(ScopedStorageTestGroup)
 TEST_GROUP(StorageTestGroup)
 {
   void setup() {
-    buildcc::Storage::Init();
+    MemoryLeakWarningPlugin::saveAndDisableNewDeleteOverloads();
   }
   void teardown() {
-    buildcc::Storage::Deinit();
+    buildcc::Storage::Clear();
+    MemoryLeakWarningPlugin::restoreNewDeleteOverloads();
   }
 };
 // clang-format on
 
+class MyScopedStorage : public buildcc::ScopedStorage {
+public:
+  // We want to unit test this
+  template <typename T> void Remove(T *ptr) {
+    this->ScopedStorage::Remove<T>(ptr);
+  }
+};
+
 class BigObj {};
 
 class BigObjWithParameters {
@@ -42,19 +51,29 @@ class BigObjWithParameters {
 static BigObj obj;
 
 TEST(ScopedStorageTestGroup, BasicUsage) {
-  buildcc::ScopedStorage storage;
+  MyScopedStorage storage;
   storage.Add<BigObjWithParameters>("identifier", "name", 10, obj);
   storage.Add<BigObjWithParameters>("identifier2", "name2", 12, obj);
 
   // Usage
   storage.ConstRef<BigObjWithParameters>("identifier").GetName();
   storage.Ref<BigObjWithParameters>("identifier2").GetName();
 
+  CHECK_TRUE(storage.Contains("identifier"));
+  CHECK_FALSE(storage.Contains("identifier_does_not_exist"));
+
+  CHECK_TRUE(storage.Valid<BigObjWithParameters>("identifier"));
+  CHECK_FALSE(storage.Valid<BigObjWithParameters>("wrong_identifier"));
+  CHECK_FALSE(storage.Valid<int>("identifier"));
+
+  storage.Clear();
+  CHECK_FALSE(storage.Contains("identifier"));
+
   // Automatic cleanup here
 }
 
 TEST(ScopedStorageTestGroup, IncorrectUsage) {
-  buildcc::ScopedStorage storage;
+  MyScopedStorage storage;
   storage.Add<BigObjWithParameters>("identifier", "name", 10, obj);
 
   // We try to cast to a different type!
@@ -65,13 +84,13 @@ TEST(ScopedStorageTestGroup, IncorrectUsage) {
                storage.Ref<BigObjWithParameters>("identifier2"));
 }
 
-std::string &toReference(std::string *pointer) { return *pointer; }
-
 TEST(ScopedStorageTestGroup, NullptrDelete) {
-  buildcc::ScopedStorage storage;
+  MyScopedStorage storage;
   storage.Remove<std::string>(nullptr);
 }
 
+//
+
 TEST(StorageTestGroup, BasicUsage) {
   buildcc::Storage::Add<BigObjWithParameters>("identifier", "name", 10, obj);
   buildcc::Storage::Add<BigObjWithParameters>("identifier2", "name2", 12, obj);
@@ -84,14 +103,14 @@ TEST(StorageTestGroup, BasicUsage) {
 
   STRCMP_EQUAL(bigobj.c_str(), "name");
   STRCMP_EQUAL(bigobj2.c_str(), "name2");
-}
 
-TEST(StorageTestGroup, UsageWithoutInit) {
-  buildcc::Storage::Deinit();
+  CHECK_TRUE(buildcc::Storage::Contains("identifier"));
+  CHECK_FALSE(buildcc::Storage::Contains("identifier_does_not_exist"));
 
-  CHECK_THROWS(std::exception, buildcc::Storage::Add<int>("integer"));
-  CHECK_THROWS(std::exception, buildcc::Storage::Ref<int>("integer"));
-  CHECK_THROWS(std::exception, buildcc::Storage::ConstRef<int>("integer"));
+  CHECK_TRUE(buildcc::Storage::Valid<BigObjWithParameters>("identifier"));
+  CHECK_FALSE(
+      buildcc::Storage::Valid<BigObjWithParameters>("wrong_identifier"));
+  CHECK_FALSE(buildcc::Storage::Valid<BigObj>("identifier"));
 }
 
 int main(int ac, char **av) {

diff --git a/buildcc/lib/target/src/target_info/target_info.cpp b/buildcc/lib/target/src/target_info/target_info.cpp
@@ -21,8 +21,9 @@ namespace buildcc {
 // PRIVATE
 
 void TargetInfo::Initialize() {
-  toolchain_.GetLockInfo().ExpectsLock(
-      "Toolchain should be locked before usage through `Toolchain::Lock`");
+  // TODO, Update this later
+  // toolchain_.GetLockInfo().ExpectsLock(
+  //     "Toolchain should be locked before usage through `Toolchain::Lock`");
 
   std::for_each(toolchain_.GetPreprocessorFlags().begin(),
                 toolchain_.GetPreprocessorFlags().end(),

diff --git a/buildcc/lib/target/test/target/test_toolchain_flag_api.cpp b/buildcc/lib/target/test/target/test_toolchain_flag_api.cpp
@@ -17,6 +17,7 @@ TEST_GROUP(ToolchainFlagApiTestGroup)
 TEST(ToolchainFlagApiTestGroup, BasicToolchainTest_Lock) {
   buildcc::Toolchain toolchain(buildcc::ToolchainId::Gcc, "gcc", "as", "gcc",
                                "g++", "ar", "ld");
+  toolchain.Lock();
   CHECK_THROWS(std::exception, toolchain.AddPreprocessorFlag("-preprocessor"));
   CHECK_THROWS(std::exception, toolchain.AddAsmCompileFlag("-asm"));
   CHECK_THROWS(std::exception, toolchain.AddPchCompileFlag("-pchcompile"));
@@ -29,7 +30,7 @@ TEST(ToolchainFlagApiTestGroup, BasicToolchainTest_Lock) {
 
 TEST(ToolchainFlagApiTestGroup, BasicToolchainTest_Unlock) {
   buildcc::Toolchain toolchain(buildcc::ToolchainId::Gcc, "gcc", "as", "gcc",
-                               "g++", "ar", "ld", false);
+                               "g++", "ar", "ld");
   toolchain.AddPreprocessorFlag("-preprocessor");
   toolchain.AddAsmCompileFlag("-asm");
   toolchain.AddPchCompileFlag("-pchcompile");
@@ -55,7 +56,7 @@ TEST(ToolchainFlagApiTestGroup, BasicToolchainTest_Unlock) {
 
 TEST(ToolchainFlagApiTestGroup, BasicTargetTest) {
   buildcc::Toolchain toolchain(buildcc::ToolchainId::Gcc, "gcc", "as", "gcc",
-                               "g++", "ar", "ld", false);
+                               "g++", "ar", "ld");
 
   toolchain.AddPreprocessorFlag("-preprocessor");
   toolchain.AddAsmCompileFlag("-asm");
@@ -67,7 +68,9 @@ TEST(ToolchainFlagApiTestGroup, BasicTargetTest) {
   toolchain.AddLinkFlag("-link");
 
   CHECK_FALSE(toolchain.GetLockInfo().IsLocked());
-  { CHECK_THROWS(std::exception, (buildcc::TargetInfo(toolchain, ""))); }
+  // TODO, Add this in later
+  // * We should lock our toolchain before using it
+  // { CHECK_THROWS(std::exception, (buildcc::TargetInfo(toolchain, ""))); }
 
   toolchain.Lock();
   CHECK_TRUE(toolchain.GetLockInfo().IsLocked());