Toolchain find and verify (#199)

- Reworked Toolchain::Find and Toolchain::Verify APIs
- Added support for Custom Toolchain verification

Author: coder137

buildcc/lib/args/include/args/args.h

@@ -48,32 +48,32 @@ struct ArgToolchainState {
 struct ArgToolchain {
   ArgToolchain(){};
   ArgToolchain(ToolchainId initial_id, const std::string &initial_name,
-               const ToolchainBinaries &initial_binaries)
-      : id(initial_id), name(initial_name), binaries(initial_binaries) {}
+               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,
-                     ToolchainBinaries(initial_assembler, initial_c_compiler,
-                                       initial_cpp_compiler, initial_archiver,
-                                       initial_linker)) {}
+                     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, binaries);
+    return BaseToolchain(id, name, executables);
   }
 
   ArgToolchainState state;
   ToolchainId id{ToolchainId::Undefined};
   std::string name{""};
-  ToolchainBinaries binaries;
+  ToolchainExecutables executables;
 };
 
 // NOTE, Incomplete without pch_compile_command

buildcc/lib/args/src/args.cpp

@@ -99,16 +99,16 @@ void Args::AddToolchain(const std::string &name, const std::string &description,
       ->transform(CLI::CheckedTransformer(kToolchainIdMap, CLI::ignore_case))
       ->default_val(initial.id);
   t_user->add_option(kToolchainNameParam, out.name)->default_val(initial.name);
-  t_user->add_option(kToolchainAsmCompilerParam, out.binaries.assembler)
-      ->default_val(initial.binaries.assembler);
-  t_user->add_option(kToolchainCCompilerParam, out.binaries.c_compiler)
-      ->default_val(initial.binaries.c_compiler);
-  t_user->add_option(kToolchainCppCompilerParam, out.binaries.cpp_compiler)
-      ->default_val(initial.binaries.cpp_compiler);
-  t_user->add_option(kToolchainArchiverParam, out.binaries.archiver)
-      ->default_val(initial.binaries.archiver);
-  t_user->add_option(kToolchainLinkerParam, out.binaries.linker)
-      ->default_val(initial.binaries.linker);
+  t_user->add_option(kToolchainAsmCompilerParam, out.executables.assembler)
+      ->default_val(initial.executables.assembler);
+  t_user->add_option(kToolchainCCompilerParam, out.executables.c_compiler)
+      ->default_val(initial.executables.c_compiler);
+  t_user->add_option(kToolchainCppCompilerParam, out.executables.cpp_compiler)
+      ->default_val(initial.executables.cpp_compiler);
+  t_user->add_option(kToolchainArchiverParam, out.executables.archiver)
+      ->default_val(initial.executables.archiver);
+  t_user->add_option(kToolchainLinkerParam, out.executables.linker)
+      ->default_val(initial.executables.linker);
 }
 
 void Args::AddTarget(const std::string &name, const std::string &description,

buildcc/lib/args/test/test_args.cpp

@@ -68,11 +68,11 @@ TEST(ArgsTestGroup, Args_CustomToolchain) {
   CHECK_FALSE(gcc_toolchain.state.test);
   CHECK(gcc_toolchain.id == buildcc::ToolchainId::Gcc);
   STRCMP_EQUAL(gcc_toolchain.name.c_str(), "gcc");
-  STRCMP_EQUAL(gcc_toolchain.binaries.assembler.c_str(), "as");
-  STRCMP_EQUAL(gcc_toolchain.binaries.c_compiler.c_str(), "gcc");
-  STRCMP_EQUAL(gcc_toolchain.binaries.cpp_compiler.c_str(), "g++");
-  STRCMP_EQUAL(gcc_toolchain.binaries.archiver.c_str(), "ar");
-  STRCMP_EQUAL(gcc_toolchain.binaries.linker.c_str(), "ld");
+  STRCMP_EQUAL(gcc_toolchain.executables.assembler.c_str(), "as");
+  STRCMP_EQUAL(gcc_toolchain.executables.c_compiler.c_str(), "gcc");
+  STRCMP_EQUAL(gcc_toolchain.executables.cpp_compiler.c_str(), "g++");
+  STRCMP_EQUAL(gcc_toolchain.executables.archiver.c_str(), "ar");
+  STRCMP_EQUAL(gcc_toolchain.executables.linker.c_str(), "ld");
 }
 
 TEST(ArgsTestGroup, Args_MultipleCustomToolchain) {
@@ -106,22 +106,22 @@ TEST(ArgsTestGroup, Args_MultipleCustomToolchain) {
   CHECK_FALSE(gcc_toolchain.state.test);
   CHECK(gcc_toolchain.id == buildcc::ToolchainId::Gcc);
   STRCMP_EQUAL(gcc_toolchain.name.c_str(), "gcc");
-  STRCMP_EQUAL(gcc_toolchain.binaries.assembler.c_str(), "as");
-  STRCMP_EQUAL(gcc_toolchain.binaries.c_compiler.c_str(), "gcc");
-  STRCMP_EQUAL(gcc_toolchain.binaries.cpp_compiler.c_str(), "g++");
-  STRCMP_EQUAL(gcc_toolchain.binaries.archiver.c_str(), "ar");
-  STRCMP_EQUAL(gcc_toolchain.binaries.linker.c_str(), "ld");
+  STRCMP_EQUAL(gcc_toolchain.executables.assembler.c_str(), "as");
+  STRCMP_EQUAL(gcc_toolchain.executables.c_compiler.c_str(), "gcc");
+  STRCMP_EQUAL(gcc_toolchain.executables.cpp_compiler.c_str(), "g++");
+  STRCMP_EQUAL(gcc_toolchain.executables.archiver.c_str(), "ar");
+  STRCMP_EQUAL(gcc_toolchain.executables.linker.c_str(), "ld");
 
   // MSVC
   CHECK_TRUE(msvc_toolchain.state.build);
   CHECK_TRUE(msvc_toolchain.state.test);
   CHECK(msvc_toolchain.id == buildcc::ToolchainId::Msvc);
   STRCMP_EQUAL(msvc_toolchain.name.c_str(), "msvc");
-  STRCMP_EQUAL(msvc_toolchain.binaries.assembler.c_str(), "cl");
-  STRCMP_EQUAL(msvc_toolchain.binaries.c_compiler.c_str(), "cl");
-  STRCMP_EQUAL(msvc_toolchain.binaries.cpp_compiler.c_str(), "cl");
-  STRCMP_EQUAL(msvc_toolchain.binaries.archiver.c_str(), "lib");
-  STRCMP_EQUAL(msvc_toolchain.binaries.linker.c_str(), "link");
+  STRCMP_EQUAL(msvc_toolchain.executables.assembler.c_str(), "cl");
+  STRCMP_EQUAL(msvc_toolchain.executables.c_compiler.c_str(), "cl");
+  STRCMP_EQUAL(msvc_toolchain.executables.cpp_compiler.c_str(), "cl");
+  STRCMP_EQUAL(msvc_toolchain.executables.archiver.c_str(), "lib");
+  STRCMP_EQUAL(msvc_toolchain.executables.linker.c_str(), "link");
 }
 
 TEST(ArgsTestGroup, Args_DuplicateCustomToolchain) {
@@ -167,11 +167,11 @@ TEST(ArgsTestGroup, Args_CustomTarget) {
   CHECK_FALSE(gcc_toolchain.state.test);
   CHECK(gcc_toolchain.id == buildcc::ToolchainId::Gcc);
   STRCMP_EQUAL(gcc_toolchain.name.c_str(), "gcc");
-  STRCMP_EQUAL(gcc_toolchain.binaries.assembler.c_str(), "as");
-  STRCMP_EQUAL(gcc_toolchain.binaries.c_compiler.c_str(), "gcc");
-  STRCMP_EQUAL(gcc_toolchain.binaries.cpp_compiler.c_str(), "g++");
-  STRCMP_EQUAL(gcc_toolchain.binaries.archiver.c_str(), "ar");
-  STRCMP_EQUAL(gcc_toolchain.binaries.linker.c_str(), "ld");
+  STRCMP_EQUAL(gcc_toolchain.executables.assembler.c_str(), "as");
+  STRCMP_EQUAL(gcc_toolchain.executables.c_compiler.c_str(), "gcc");
+  STRCMP_EQUAL(gcc_toolchain.executables.cpp_compiler.c_str(), "g++");
+  STRCMP_EQUAL(gcc_toolchain.executables.archiver.c_str(), "ar");
+  STRCMP_EQUAL(gcc_toolchain.executables.linker.c_str(), "ld");
 
   // Target
   STRCMP_EQUAL(gcc_target.compile_command.c_str(),
@@ -221,11 +221,11 @@ TEST(ArgsTestGroup, Args_MultipleCustomTarget) {
   CHECK_FALSE(gcc_toolchain.state.test);
   CHECK(gcc_toolchain.id == buildcc::ToolchainId::Gcc);
   STRCMP_EQUAL(gcc_toolchain.name.c_str(), "gcc");
-  STRCMP_EQUAL(gcc_toolchain.binaries.assembler.c_str(), "as");
-  STRCMP_EQUAL(gcc_toolchain.binaries.c_compiler.c_str(), "gcc");
-  STRCMP_EQUAL(gcc_toolchain.binaries.cpp_compiler.c_str(), "g++");
-  STRCMP_EQUAL(gcc_toolchain.binaries.archiver.c_str(), "ar");
-  STRCMP_EQUAL(gcc_toolchain.binaries.linker.c_str(), "ld");
+  STRCMP_EQUAL(gcc_toolchain.executables.assembler.c_str(), "as");
+  STRCMP_EQUAL(gcc_toolchain.executables.c_compiler.c_str(), "gcc");
+  STRCMP_EQUAL(gcc_toolchain.executables.cpp_compiler.c_str(), "g++");
+  STRCMP_EQUAL(gcc_toolchain.executables.archiver.c_str(), "ar");
+  STRCMP_EQUAL(gcc_toolchain.executables.linker.c_str(), "ld");
 
   // Target
   STRCMP_EQUAL(gcc_target.compile_command.c_str(),
@@ -242,11 +242,11 @@ TEST(ArgsTestGroup, Args_MultipleCustomTarget) {
   CHECK_TRUE(msvc_toolchain.state.test);
   CHECK(msvc_toolchain.id == buildcc::ToolchainId::Msvc);
   STRCMP_EQUAL(msvc_toolchain.name.c_str(), "msvc");
-  STRCMP_EQUAL(msvc_toolchain.binaries.assembler.c_str(), "cl");
-  STRCMP_EQUAL(msvc_toolchain.binaries.c_compiler.c_str(), "cl");
-  STRCMP_EQUAL(msvc_toolchain.binaries.cpp_compiler.c_str(), "cl");
-  STRCMP_EQUAL(msvc_toolchain.binaries.archiver.c_str(), "lib");
-  STRCMP_EQUAL(msvc_toolchain.binaries.linker.c_str(), "link");
+  STRCMP_EQUAL(msvc_toolchain.executables.assembler.c_str(), "cl");
+  STRCMP_EQUAL(msvc_toolchain.executables.c_compiler.c_str(), "cl");
+  STRCMP_EQUAL(msvc_toolchain.executables.cpp_compiler.c_str(), "cl");
+  STRCMP_EQUAL(msvc_toolchain.executables.archiver.c_str(), "lib");
+  STRCMP_EQUAL(msvc_toolchain.executables.linker.c_str(), "link");
 
   // Target
   STRCMP_EQUAL(msvc_target.compile_command.c_str(),

buildcc/lib/target/test/target/test_toolchain_flag_api.cpp

@@ -85,5 +85,6 @@ TEST(ToolchainFlagApiTestGroup, BasicTargetTest) {
 }
 
 int main(int ac, char **av) {
+  MemoryLeakWarningPlugin::turnOffNewDeleteOverloads();
   return CommandLineTestRunner::RunAllTests(ac, av);
 }

buildcc/lib/toolchain/CMakeLists.txt

@@ -6,14 +6,14 @@ set(TOOLCHAIN_SRCS
     include/toolchain/common/function_lock.h
 
     # API
+    src/api/toolchain_find.cpp
+    src/api/toolchain_verify.cpp
+    include/toolchain/api/toolchain_find.h
+    include/toolchain/api/toolchain_verify.h
     include/toolchain/api/flag_api.h
 
     src/toolchain/toolchain.cpp
     include/toolchain/toolchain.h
-
-    # Features
-    src/api/toolchain_verify.cpp
-    include/toolchain/api/toolchain_verify.h
 )
 if (${TESTING})
     add_library(mock_toolchain
@@ -32,10 +32,10 @@ if (${TESTING})
         ${TEST_LINK_LIBS}
     )
 
-    add_executable(test_toolchain_verify
-        test/test_toolchain_verify.cpp
+    add_executable(test_toolchain_id
+        test/test_toolchain_id.cpp
     )
-    target_link_libraries(test_toolchain_verify PRIVATE 
+    target_link_libraries(test_toolchain_id PRIVATE
         mock_toolchain
     )
 
@@ -46,10 +46,28 @@ if (${TESTING})
         mock_toolchain
     )
 
+    add_executable(test_toolchain_find
+        test/test_toolchain_find.cpp
+    )
+    target_link_libraries(test_toolchain_find PRIVATE 
+        mock_toolchain
+    )
+
+    add_executable(test_toolchain_verify
+        test/test_toolchain_verify.cpp
+    )
+    target_link_libraries(test_toolchain_verify PRIVATE 
+        mock_toolchain
+    )
+
+    add_test(NAME test_toolchain_id COMMAND test_toolchain_id)
+    add_test(NAME test_toolchain_config COMMAND test_toolchain_config)
+    add_test(NAME test_toolchain_find COMMAND test_toolchain_find
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/test
+    )
     add_test(NAME test_toolchain_verify COMMAND test_toolchain_verify
         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/test
     )
-    add_test(NAME test_toolchain_config COMMAND test_toolchain_config)
 endif()
 
 if(${BUILDCC_BUILD_AS_SINGLE_LIB})

buildcc/lib/toolchain/include/toolchain/api/toolchain_find.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2021-2022 Niket Naidu. 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.
+ */
+
+#ifndef TOOLCHAIN_TOOLCHAIN_FIND_H_
+#define TOOLCHAIN_TOOLCHAIN_FIND_H_
+
+#include <filesystem>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+#include "schema/path.h"
+
+namespace fs = std::filesystem;
+
+namespace buildcc {
+
+/**
+ * @brief Configure the behaviour of Toolchain::Find API. By default searches
+ * the directories mentioned in the ENV{PATH} variable to find the toolchain.
+ * @param absolute_search_paths absolute_search_paths expect directories that
+ * are iterated for exact toolchain matches
+ * @param env_vars env_vars contain paths that are seperated by OS delimiter.
+ * These are converted to paths and searched similarly to absolute_search_paths
+ * <br>
+ * NOTE: env_vars must contain single absolute paths or multiple absolute
+ * paths seperated by OS delimiter <br>
+ * Example: [Windows]   "absolute_path_1;absolute_path_2;..." <br>
+ * Example: [Linux]     "absolute_path_1:absolute_path_2:..." <br>
+ */
+struct ToolchainFindConfig {
+  ToolchainFindConfig(
+      const std::unordered_set<std::string> &env_vars = {"PATH"},
+      const fs_unordered_set &absolute_search_paths = {})
+      : env_vars(env_vars), absolute_search_paths(absolute_search_paths) {}
+
+  std::unordered_set<std::string> env_vars;
+  fs_unordered_set absolute_search_paths;
+};
+
+template <typename T> class ToolchainFind {
+public:
+  std::vector<fs::path>
+  Find(const ToolchainFindConfig &config = ToolchainFindConfig()) const;
+};
+
+} // namespace buildcc
+
+#endif