Merge branch 'master' of https://github.com/Microsoft/vcpkg into patch-vs2013

# Conflicts:
#	scripts/cmake/vcpkg_configure_cmake.cmake
#	toolsrc/src/vcpkg/vcpkgpaths.cpp

27 files changed, 320 insertions, 231 deletions

diff --git a/toolsrc/include/pch.h b/toolsrc/include/pch.h
index 8333eb927..5c31fbbd1 100644
--- a/toolsrc/include/pch.h
+++ b/toolsrc/include/pch.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#if defined(_WIN32)
 #define NOMINMAX
 #define WIN32_LEAN_AND_MEAN
 
@@ -9,6 +10,13 @@
 #pragma warning(suppress : 4768)
 #include <Shlobj.h>
 
+#include <process.h>
+#include <shellapi.h>
+#include <winhttp.h>
+#else
+#include <unistd.h>
+#endif
+
 #include <algorithm>
 #include <array>
 #include <atomic>
@@ -19,7 +27,12 @@
 #include <cstdarg>
 #include <cstddef>
 #include <cstdint>
+#if defined(_WIN32)
 #include <filesystem>
+#else
+#include <experimental/filesystem>
+#endif
+#include <cstring>
 #include <fstream>
 #include <functional>
 #include <iomanip>
@@ -28,18 +41,17 @@
 #include <map>
 #include <memory>
 #include <mutex>
-#include <process.h>
 #include <regex>
 #include <set>
-#include <shellapi.h>
 #include <stdexcept>
 #include <string>
 #include <sys/timeb.h>
+#include <sys/types.h>
 #include <system_error>
+#include <thread>
 #include <time.h>
 #include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
 #include <vector>
-#include <winhttp.h>
diff --git a/toolsrc/include/vcpkg/base/cstringview.h b/toolsrc/include/vcpkg/base/cstringview.h
index 341830f05..0441bc573 100644
--- a/toolsrc/include/vcpkg/base/cstringview.h
+++ b/toolsrc/include/vcpkg/base/cstringview.h
@@ -1,97 +1,71 @@
 #pragma once
 
+#include <string.h>
 #include <string>
 
 namespace vcpkg
 {
-    template<class CharType>
-    struct BasicCStringView
+    struct CStringView
     {
-        constexpr BasicCStringView() : cstr(nullptr) {}
-        constexpr BasicCStringView(const CharType* cstr) : cstr(cstr) {}
-        constexpr BasicCStringView(const BasicCStringView&) = default;
-        BasicCStringView(const std::basic_string<CharType>& str) : cstr(str.c_str()) {}
+        constexpr CStringView() : cstr(nullptr) {}
+        constexpr CStringView(const char* cstr) : cstr(cstr) {}
+        constexpr CStringView(const CStringView&) = default;
+        CStringView(const std::string& str) : cstr(str.c_str()) {}
 
-        constexpr const CharType* c_str() const { return cstr; }
+        constexpr const char* c_str() const { return cstr; }
 
     private:
-        const CharType* cstr;
+        const char* cstr;
+    };
+
+    struct CWStringView
+    {
+        constexpr CWStringView() : cstr(nullptr) {}
+        constexpr CWStringView(const wchar_t* cstr) : cstr(cstr) {}
+        constexpr CWStringView(const CWStringView&) = default;
+        CWStringView(const std::wstring& str) : cstr(str.c_str()) {}
+
+        constexpr const wchar_t* c_str() const { return cstr; }
+
+    private:
+        const wchar_t* cstr;
     };
 
     namespace details
     {
         inline bool vcpkg_strcmp(const char* l, const char* r) { return strcmp(l, r) == 0; }
-        inline bool vcpkg_strcmp(const wchar_t* l, const wchar_t* r) { return wcscmp(l, r) == 0; }
     }
 
-    template<class CharType>
-    bool operator==(const BasicCStringView<CharType>& l, const BasicCStringView<CharType>& r)
+    inline bool operator==(const CStringView& l, const CStringView& r)
     {
         return details::vcpkg_strcmp(l.c_str(), r.c_str());
     }
 
-    template<class CharType>
-    bool operator==(const CharType* l, const BasicCStringView<CharType>& r)
-    {
-        return details::vcpkg_strcmp(l, r.c_str());
-    }
+    inline bool operator==(const char* l, const CStringView& r) { return details::vcpkg_strcmp(l, r.c_str()); }
 
-    template<class CharType>
-    bool operator==(const BasicCStringView<CharType>& r, const CharType* l)
-    {
-        return details::vcpkg_strcmp(l, r.c_str());
-    }
+    inline bool operator==(const CStringView& r, const char* l) { return details::vcpkg_strcmp(l, r.c_str()); }
 
-    template<class CharType>
-    bool operator==(const std::basic_string<CharType>& l, const BasicCStringView<CharType>& r)
-    {
-        return l == r.c_str();
-    }
+    inline bool operator==(const std::string& l, const CStringView& r) { return l == r.c_str(); }
 
-    template<class CharType>
-    bool operator==(const BasicCStringView<CharType>& r, const std::basic_string<CharType>& l)
-    {
-        return l == r.c_str();
-    }
+    inline bool operator==(const CStringView& r, const std::string& l) { return l == r.c_str(); }
 
     // notequals
-    template<class CharType>
-    bool operator!=(const BasicCStringView<CharType>& l, const BasicCStringView<CharType>& r)
+    inline bool operator!=(const CStringView& l, const CStringView& r)
     {
         return !details::vcpkg_strcmp(l.c_str(), r.c_str());
     }
 
-    template<class CharType>
-    bool operator!=(const CharType* l, const BasicCStringView<CharType>& r)
-    {
-        return !details::vcpkg_strcmp(l, r.c_str());
-    }
+    inline bool operator!=(const char* l, const CStringView& r) { return !details::vcpkg_strcmp(l, r.c_str()); }
 
-    template<class CharType>
-    bool operator!=(const BasicCStringView<CharType>& r, const CharType* l)
-    {
-        return !details::vcpkg_strcmp(l, r.c_str());
-    }
+    inline bool operator!=(const CStringView& r, const char* l) { return !details::vcpkg_strcmp(l, r.c_str()); }
 
-    template<class CharType>
-    bool operator!=(const BasicCStringView<CharType>& r, const std::basic_string<CharType>& l)
-    {
-        return l != r.c_str();
-    }
+    inline bool operator!=(const CStringView& r, const std::string& l) { return l != r.c_str(); }
 
-    template<class CharType>
-    bool operator!=(const std::basic_string<CharType>& l, const BasicCStringView<CharType>& r)
-    {
-        return l != r.c_str();
-    }
+    inline bool operator!=(const std::string& l, const CStringView& r) { return l != r.c_str(); }
 
-    using CStringView = BasicCStringView<char>;
-    using CWStringView = BasicCStringView<wchar_t>;
+    inline std::string operator+(std::string&& l, const CStringView& r) { return std::move(l) + r.c_str(); }
 
     inline const char* to_printf_arg(const CStringView string_view) { return string_view.c_str(); }
 
-    inline const wchar_t* to_wprintf_arg(const CWStringView string_view) { return string_view.c_str(); }
-
     static_assert(sizeof(CStringView) == sizeof(void*), "CStringView must be a simple wrapper around char*");
-    static_assert(sizeof(CWStringView) == sizeof(void*), "CWStringView must be a simple wrapper around wchar_t*");
 }
diff --git a/toolsrc/include/vcpkg/base/expected.h b/toolsrc/include/vcpkg/base/expected.h
index a946c442e..b3b81ae81 100644
--- a/toolsrc/include/vcpkg/base/expected.h
+++ b/toolsrc/include/vcpkg/base/expected.h
@@ -33,7 +33,7 @@ namespace vcpkg
         ErrorHolder() = default;
         ErrorHolder(const std::error_code& err) : m_err(err) {}
 
-        constexpr bool has_error() const { return bool(m_err); }
+        bool has_error() const { return bool(m_err); }
 
         const std::error_code& error() const { return m_err; }
         std::error_code& error() { return m_err; }
diff --git a/toolsrc/include/vcpkg/base/files.h b/toolsrc/include/vcpkg/base/files.h
index f4bcf742c..63cf3c6fd 100644
--- a/toolsrc/include/vcpkg/base/files.h
+++ b/toolsrc/include/vcpkg/base/files.h
@@ -2,7 +2,11 @@
 
 #include <vcpkg/base/expected.h>
 
+#if defined(_WIN32)
 #include <filesystem>
+#else
+#include <experimental/filesystem>
+#endif
 
 namespace fs
 {
@@ -19,7 +23,7 @@ namespace fs
 
 namespace vcpkg::Files
 {
-    __interface Filesystem
+    struct Filesystem
     {
         virtual Expected<std::string> read_contents(const fs::path& file_path) const = 0;
         virtual Expected<std::vector<std::string>> read_lines(const fs::path& file_path) const = 0;
@@ -40,8 +44,10 @@ namespace vcpkg::Files
         virtual bool create_directory(const fs::path& path, std::error_code& ec) = 0;
         virtual bool create_directories(const fs::path& path, std::error_code& ec) = 0;
         virtual void copy(const fs::path& oldpath, const fs::path& newpath, fs::copy_options opts) = 0;
-        virtual bool copy_file(
-            const fs::path& oldpath, const fs::path& newpath, fs::copy_options opts, std::error_code& ec) = 0;
+        virtual bool copy_file(const fs::path& oldpath,
+                               const fs::path& newpath,
+                               fs::copy_options opts,
+                               std::error_code& ec) = 0;
         virtual fs::file_status status(const fs::path& path, std::error_code& ec) const = 0;
     };
 
@@ -53,5 +59,5 @@ namespace vcpkg::Files
 
     void print_paths(const std::vector<fs::path>& paths);
 
-    std::vector<fs::path> find_from_PATH(const std::wstring& name);
+    std::vector<fs::path> find_from_PATH(const std::string& name);
 }
diff --git a/toolsrc/include/vcpkg/base/graphs.h b/toolsrc/include/vcpkg/base/graphs.h
index ff56cb298..b585d2bb9 100644
--- a/toolsrc/include/vcpkg/base/graphs.h
+++ b/toolsrc/include/vcpkg/base/graphs.h
@@ -20,11 +20,11 @@ namespace vcpkg::Graphs
     };
 
     template<class V, class U>
-    __interface AdjacencyProvider
+    struct AdjacencyProvider
     {
-        std::vector<V> adjacency_list(const U& vertex) const;
+        virtual std::vector<V> adjacency_list(const U& vertex) const = 0;
 
-        U load_vertex_data(const V& vertex) const;
+        virtual U load_vertex_data(const V& vertex) const = 0;
     };
 
     template<class V, class U>
diff --git a/toolsrc/include/vcpkg/base/lineinfo.h b/toolsrc/include/vcpkg/base/lineinfo.h
index 62973462a..e7e8c3031 100644
--- a/toolsrc/include/vcpkg/base/lineinfo.h
+++ b/toolsrc/include/vcpkg/base/lineinfo.h
@@ -9,7 +9,7 @@ namespace vcpkg
         int line_number;
         const char* file_name;
 
-        constexpr LineInfo() : line_number(0), file_name(nullptr) {}
+        constexpr LineInfo() : line_number(0), file_name("") {}
         constexpr LineInfo(const int lineno, const char* filename) : line_number(lineno), file_name(filename) {}
 
         std::string to_string() const;
diff --git a/toolsrc/include/vcpkg/base/span.h b/toolsrc/include/vcpkg/base/span.h
index 6be546351..158f1ac74 100644
--- a/toolsrc/include/vcpkg/base/span.h
+++ b/toolsrc/include/vcpkg/base/span.h
@@ -57,4 +57,16 @@ namespace vcpkg
     {

         return {v.data(), v.size()};

     }

+

+    template<class T>

+    constexpr T* begin(Span<T> sp)

+    {

+        return sp.begin();

+    }

+

+    template<class T>

+    constexpr T* end(Span<T> sp)

+    {

+        return sp.end();

+    }

 }
\ No newline at end of file
diff --git a/toolsrc/include/vcpkg/base/strings.h b/toolsrc/include/vcpkg/base/strings.h
index 59823deb8..ee1b2fc28 100644
--- a/toolsrc/include/vcpkg/base/strings.h
+++ b/toolsrc/include/vcpkg/base/strings.h
@@ -16,30 +16,17 @@ namespace vcpkg::Strings::details
 
     inline const char* to_printf_arg(const char* s) { return s; }
 
-    inline int to_printf_arg(const int s) { return s; }
-
-    inline long long to_printf_arg(const long long s) { return s; }
-
-    inline unsigned long to_printf_arg(const unsigned long s) { return s; }
-
-    inline size_t to_printf_arg(const size_t s) { return s; }
-
-    inline double to_printf_arg(const double s) { return s; }
+    template<class T, class = std::enable_if_t<std::is_arithmetic<T>::value>>
+    T to_printf_arg(T s)
+    {
+        return s;
+    }
 
     std::string format_internal(const char* fmtstr, ...);
-
-    inline const wchar_t* to_wprintf_arg(const std::wstring& s) { return s.c_str(); }
-
-    inline const wchar_t* to_wprintf_arg(const wchar_t* s) { return s; }
-
-    std::wstring wformat_internal(const wchar_t* fmtstr, ...);
 }
 
 namespace vcpkg::Strings
 {
-    static constexpr const char* EMPTY = "";
-    static constexpr const wchar_t* WEMPTY = L"";
-
     template<class... Args>
     std::string format(const char* fmtstr, const Args&... args)
     {
@@ -47,39 +34,32 @@ namespace vcpkg::Strings
         return details::format_internal(fmtstr, to_printf_arg(to_printf_arg(args))...);
     }
 
-    template<class... Args>
-    std::wstring wformat(const wchar_t* fmtstr, const Args&... args)
-    {
-        using vcpkg::Strings::details::to_wprintf_arg;
-        return details::wformat_internal(fmtstr, to_wprintf_arg(to_wprintf_arg(args))...);
-    }
-
-    std::wstring to_utf16(const CStringView s);
+    std::wstring to_utf16(const CStringView& s);
 
-    std::string to_utf8(const CWStringView w);
+    std::string to_utf8(const CWStringView& w);
 
     std::string::const_iterator case_insensitive_ascii_find(const std::string& s, const std::string& pattern);
 
     bool case_insensitive_ascii_contains(const std::string& s, const std::string& pattern);
 
-    bool case_insensitive_ascii_compare(const CStringView left, const CStringView right);
+    bool case_insensitive_ascii_equals(const CStringView left, const CStringView right);
 
     std::string ascii_to_lowercase(const std::string& input);
 
     bool case_insensitive_ascii_starts_with(const std::string& s, const std::string& pattern);
 
-    template<class Container, class Transformer, class CharType>
-    std::basic_string<CharType> join(const CharType* delimiter, const Container& v, Transformer transformer)
+    template<class Container, class Transformer>
+    std::string join(const char* delimiter, const Container& v, Transformer transformer)
     {
         const auto begin = v.begin();
         const auto end = v.end();
 
         if (begin == end)
         {
-            return std::basic_string<CharType>();
+            return std::string();
         }
 
-        std::basic_string<CharType> output;
+        std::string output;
         output.append(transformer(*begin));
         for (auto it = std::next(begin); it != end; ++it)
         {
@@ -89,16 +69,16 @@ namespace vcpkg::Strings
 
         return output;
     }
-    template<class Container, class CharType>
-    std::basic_string<CharType> join(const CharType* delimiter, const Container& v)
+    template<class Container>
+    std::string join(const char* delimiter, const Container& v)
     {
         using Element = decltype(*v.begin());
         return join(delimiter, v, [](const Element& x) -> const Element& { return x; });
     }
 
-    void trim(std::string* s);
+    std::string replace_all(std::string&& s, const std::string& search, const std::string& rep);
 
-    std::string trimmed(const std::string& s);
+    std::string trim(std::string&& s);
 
     void trim_all_and_remove_whitespace_strings(std::vector<std::string>* strings);
 
diff --git a/toolsrc/include/vcpkg/base/system.h b/toolsrc/include/vcpkg/base/system.h
index a2e8f3f45..9f2d91435 100644
--- a/toolsrc/include/vcpkg/base/system.h
+++ b/toolsrc/include/vcpkg/base/system.h
@@ -4,8 +4,6 @@
 #include <vcpkg/base/optional.h>
 #include <vcpkg/base/strings.h>
 
-#include <Windows.h>
-
 namespace vcpkg::System
 {
     tm get_current_date_time();
@@ -18,13 +16,15 @@ namespace vcpkg::System
         std::string output;
     };
 
-    int cmd_execute_clean(const CWStringView cmd_line);
+    int cmd_execute_clean(const CStringView cmd_line);
 
-    int cmd_execute(const CWStringView cmd_line);
+    int cmd_execute(const CStringView cmd_line);
 
-    ExitCodeAndOutput cmd_execute_and_capture_output(const CWStringView cmd_line);
+    ExitCodeAndOutput cmd_execute_and_capture_output(const CStringView cmd_line);
 
-    std::wstring create_powershell_script_cmd(const fs::path& script_path, const CWStringView args = Strings::WEMPTY);
+    std::string powershell_execute_and_capture_output(const std::string& title,
+                                                      const fs::path& script_path,
+                                                      const CStringView args = "");
 
     enum class Color
     {
@@ -40,32 +40,32 @@ namespace vcpkg::System
     void println(const Color c, const CStringView message);
 
     template<class Arg1, class... Args>
-    void print(const char* messageTemplate, const Arg1& messageArg1, const Args&... messageArgs)
+    void print(const char* message_template, const Arg1& message_arg1, const Args&... message_args)
     {
-        return System::print(Strings::format(messageTemplate, messageArg1, messageArgs...));
+        return System::print(Strings::format(message_template, message_arg1, message_args...));
     }
 
     template<class Arg1, class... Args>
-    void print(const Color c, const char* messageTemplate, const Arg1& messageArg1, const Args&... messageArgs)
+    void print(const Color c, const char* message_template, const Arg1& message_arg1, const Args&... message_args)
     {
-        return System::print(c, Strings::format(messageTemplate, messageArg1, messageArgs...));
+        return System::print(c, Strings::format(message_template, message_arg1, message_args...));
     }
 
     template<class Arg1, class... Args>
-    void println(const char* messageTemplate, const Arg1& messageArg1, const Args&... messageArgs)
+    void println(const char* message_template, const Arg1& message_arg1, const Args&... message_args)
     {
-        return System::println(Strings::format(messageTemplate, messageArg1, messageArgs...));
+        return System::println(Strings::format(message_template, message_arg1, message_args...));
     }
 
     template<class Arg1, class... Args>
-    void println(const Color c, const char* messageTemplate, const Arg1& messageArg1, const Args&... messageArgs)
+    void println(const Color c, const char* message_template, const Arg1& message_arg1, const Args&... message_args)
     {
-        return System::println(c, Strings::format(messageTemplate, messageArg1, messageArgs...));
+        return System::println(c, Strings::format(message_template, message_arg1, message_args...));
     }
 
-    Optional<std::wstring> get_environment_variable(const CWStringView varname) noexcept;
+    Optional<std::string> get_environment_variable(const CStringView varname) noexcept;
 
-    Optional<std::wstring> get_registry_string(HKEY base, const CWStringView subkey, const CWStringView valuename);
+    Optional<std::string> get_registry_string(void* base_hkey, const CStringView subkey, const CStringView valuename);
 
     enum class CPUArchitecture
     {
@@ -75,7 +75,7 @@ namespace vcpkg::System
         ARM64,
     };
 
-    Optional<CPUArchitecture> to_cpu_architecture(CStringView arch);
+    Optional<CPUArchitecture> to_cpu_architecture(const CStringView& arch);
 
     CPUArchitecture get_host_processor();
 
@@ -92,17 +92,17 @@ namespace vcpkg::Debug
     void println(const System::Color c, const CStringView message);
 
     template<class Arg1, class... Args>
-    void println(const char* messageTemplate, const Arg1& messageArg1, const Args&... messageArgs)
+    void println(const char* message_template, const Arg1& message_arg1, const Args&... message_args)
     {
-        return Debug::println(Strings::format(messageTemplate, messageArg1, messageArgs...));
+        return Debug::println(Strings::format(message_template, message_arg1, message_args...));
     }
 
     template<class Arg1, class... Args>
     void println(const System::Color c,
-                 const char* messageTemplate,
-                 const Arg1& messageArg1,
-                 const Args&... messageArgs)
+                 const char* message_template,
+                 const Arg1& message_arg1,
+                 const Args&... message_args)
     {
-        return Debug::println(c, Strings::format(messageTemplate, messageArg1, messageArgs...));
+        return Debug::println(c, Strings::format(message_template, message_arg1, message_args...));
     }
 }
diff --git a/toolsrc/include/vcpkg/base/util.h b/toolsrc/include/vcpkg/base/util.h
index 3834580b6..155b16cf7 100644
--- a/toolsrc/include/vcpkg/base/util.h
+++ b/toolsrc/include/vcpkg/base/util.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <algorithm>
 #include <map>
 #include <mutex>
 #include <utility>
@@ -7,8 +8,29 @@
 
 namespace vcpkg::Util
 {
+    template<class Container>
+    using ElementT = std::remove_reference_t<decltype(*begin(std::declval<Container>()))>;
+
+    namespace Vectors
+    {
+        template<class Container, class T = ElementT<Container>>
+        void concatenate(std::vector<T>* augend, const Container& addend)
+        {
+            augend->insert(augend->end(), addend.begin(), addend.end());
+        }
+    }
+
+    namespace Sets
+    {
+        template<class Container, class T = ElementT<Container>>
+        bool contains(const Container& container, const T& item)
+        {
+            return container.find(item) != container.cend();
+        }
+    }
+
     template<class Cont, class Func>
-    using FmapOut = decltype(std::declval<Func>()(*begin(std::declval<Cont>())));
+    using FmapOut = decltype(std::declval<Func&>()(*begin(std::declval<Cont&>())));
 
     template<class Cont, class Func, class Out = FmapOut<Cont, Func>>
     std::vector<Out> fmap(Cont&& xs, Func&& f)
@@ -71,9 +93,6 @@ namespace vcpkg::Util
         return std::find_if(begin(cont), end(cont), pred);
     }
 
-    template<class Container>
-    using ElementT = std::remove_reference_t<decltype(*begin(std::declval<Container>()))>;
-
     template<class Container, class T = ElementT<Container>>
     std::vector<T*> element_pointers(Container&& cont)
     {
@@ -89,7 +108,7 @@ namespace vcpkg::Util
     }
 
     template<class K, class V, class Container, class Func>
-    void group_by(const Container& cont, _Inout_ std::map<K, std::vector<const V*>>* output, Func&& f)
+    void group_by(const Container& cont, std::map<K, std::vector<const V*>>* output, Func&& f)
     {
         for (const V& element : cont)
         {
@@ -98,6 +117,22 @@ namespace vcpkg::Util
         }
     }
 
+    template<class Range>
+    void sort(Range& cont)
+    {
+        using std::begin;
+        using std::end;
+        std::sort(begin(cont), end(cont));
+    }
+
+    template<class Range1, class Range2>
+    bool all_equal(const Range1& r1, const Range2& r2)
+    {
+        using std::begin;
+        using std::end;
+        return std::equal(begin(r1), end(r1), begin(r2), end(r2));
+    }
+
     template<class AssocContainer, class K = std::decay_t<decltype(begin(std::declval<AssocContainer>())->first)>>
     std::vector<K> extract_keys(AssocContainer&& input_map)
     {
@@ -153,4 +188,4 @@ namespace vcpkg::Util
         std::unique_lock<std::mutex> m_lock;
         T& m_ptr;
     };
-}
\ No newline at end of file
+}
diff --git a/toolsrc/include/vcpkg/binaryparagraph.h b/toolsrc/include/vcpkg/binaryparagraph.h
index 7eb50a6d7..f59bf693a 100644
--- a/toolsrc/include/vcpkg/binaryparagraph.h
+++ b/toolsrc/include/vcpkg/binaryparagraph.h
@@ -30,6 +30,7 @@ namespace vcpkg
         std::string feature;
         std::vector<std::string> default_features;
         std::vector<std::string> depends;
+        std::string abi;
     };
 
     struct BinaryControlFile
diff --git a/toolsrc/include/vcpkg/build.h b/toolsrc/include/vcpkg/build.h
index f146e9951..824f3ccaf 100644
--- a/toolsrc/include/vcpkg/build.h
+++ b/toolsrc/include/vcpkg/build.h
@@ -18,10 +18,10 @@ namespace vcpkg::Build
 {
     namespace Command
     {
-        void perform_and_exit(const FullPackageSpec& full_spec,
-                              const fs::path& port_dir,
-                              const std::unordered_set<std::string>& options,
-                              const VcpkgPaths& paths);
+        void perform_and_exit_ex(const FullPackageSpec& full_spec,
+                                 const fs::path& port_dir,
+                                 const ParsedArguments& options,
+                                 const VcpkgPaths& paths);
 
         void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet);
     }
@@ -65,15 +65,17 @@ namespace vcpkg::Build
         BUILD_FAILED,
         POST_BUILD_CHECKS_FAILED,
         FILE_CONFLICTS,
-        CASCADED_DUE_TO_MISSING_DEPENDENCIES
+        CASCADED_DUE_TO_MISSING_DEPENDENCIES,
+        EXCLUDED,
     };
 
-    static constexpr std::array<BuildResult, 5> BUILD_RESULT_VALUES = {
+    static constexpr std::array<BuildResult, 6> BUILD_RESULT_VALUES = {
         BuildResult::SUCCEEDED,
         BuildResult::BUILD_FAILED,
         BuildResult::POST_BUILD_CHECKS_FAILED,
         BuildResult::FILE_CONFLICTS,
-        BuildResult::CASCADED_DUE_TO_MISSING_DEPENDENCIES};
+        BuildResult::CASCADED_DUE_TO_MISSING_DEPENDENCIES,
+        BuildResult::EXCLUDED};
 
     const std::string& to_string(const BuildResult build_result);
     std::string create_error_message(const BuildResult build_result, const PackageSpec& spec);
@@ -96,7 +98,7 @@ namespace vcpkg::Build
         Optional<fs::path> visual_studio_path;
     };
 
-    std::wstring make_build_env_cmd(const PreBuildInfo& pre_build_info, const Toolset& toolset);
+    std::string make_build_env_cmd(const PreBuildInfo& pre_build_info, const Toolset& toolset);
 
     struct ExtendedBuildResult
     {
diff --git a/toolsrc/include/vcpkg/commands.h b/toolsrc/include/vcpkg/commands.h
index e00812c98..74fd80c03 100644
--- a/toolsrc/include/vcpkg/commands.h
+++ b/toolsrc/include/vcpkg/commands.h
@@ -23,16 +23,19 @@ namespace vcpkg::Commands
 
     namespace CI
     {
+        extern const CommandStructure COMMAND_STRUCTURE;
         void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet);
     }
 
     namespace Env
     {
+        extern const CommandStructure COMMAND_STRUCTURE;
         void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet);
     }
 
     namespace Create
     {
+        extern const CommandStructure COMMAND_STRUCTURE;
         void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths);
     }
 
@@ -49,16 +52,19 @@ namespace vcpkg::Commands
 
     namespace Search
     {
+        extern const CommandStructure COMMAND_STRUCTURE;
         void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths);
     }
 
     namespace List
     {
+        extern const CommandStructure COMMAND_STRUCTURE;
         void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths);
     }
 
     namespace Owns
     {
+        extern const CommandStructure COMMAND_STRUCTURE;
         void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths);
     }
 
@@ -75,6 +81,7 @@ namespace vcpkg::Commands
     namespace Integrate
     {
         extern const char* const INTEGRATE_COMMAND_HELPSTRING;
+        extern const CommandStructure COMMAND_STRUCTURE;
 
         void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths);
     }
@@ -98,6 +105,7 @@ namespace vcpkg::Commands
 
     namespace Contact
     {
+        extern const CommandStructure COMMAND_STRUCTURE;
         const std::string& email();
         void perform_and_exit(const VcpkgCmdArguments& args);
     }
diff --git a/toolsrc/include/vcpkg/dependencies.h b/toolsrc/include/vcpkg/dependencies.h
index 2301dbc36..5411ee166 100644
--- a/toolsrc/include/vcpkg/dependencies.h
+++ b/toolsrc/include/vcpkg/dependencies.h
@@ -3,6 +3,7 @@
 #include <vcpkg/base/graphs.h>
 #include <vcpkg/base/optional.h>
 #include <vcpkg/base/util.h>
+#include <vcpkg/build.h>
 #include <vcpkg/packagespec.h>
 #include <vcpkg/statusparagraphs.h>
 #include <vcpkg/vcpkgpaths.h>
@@ -18,6 +19,9 @@ namespace vcpkg::Dependencies
         AUTO_SELECTED
     };
 
+    std::string to_output_string(RequestType request_type,
+                                 const CStringView s,
+                                 const Build::BuildPackageOptions& options);
     std::string to_output_string(RequestType request_type, const CStringView s);
 
     struct AnyParagraph
@@ -38,7 +42,8 @@ namespace vcpkg::Dependencies
         UNKNOWN,
         BUILD_AND_INSTALL,
         INSTALL,
-        ALREADY_INSTALLED
+        ALREADY_INSTALLED,
+        EXCLUDED
     };
 
     struct InstallPlanAction : Util::MoveOnlyBase
@@ -62,6 +67,7 @@ namespace vcpkg::Dependencies
         AnyParagraph any_paragraph;
         InstallPlanType plan_type;
         RequestType request_type;
+        Build::BuildPackageOptions build_options;
         std::unordered_set<std::string> feature_list;
     };
 
@@ -115,7 +121,10 @@ namespace vcpkg::Dependencies
         RequestType request_type;
     };
 
-    __interface PortFileProvider { virtual const SourceControlFile& get_control_file(const std::string& spec) const; };
+    struct PortFileProvider
+    {
+        virtual const SourceControlFile& get_control_file(const std::string& spec) const = 0;
+    };
 
     struct MapPortFile : Util::ResourceBase, PortFileProvider
     {
diff --git a/toolsrc/include/vcpkg/export.h b/toolsrc/include/vcpkg/export.h
index f3285e187..eb99b4fb1 100644
--- a/toolsrc/include/vcpkg/export.h
+++ b/toolsrc/include/vcpkg/export.h
@@ -4,6 +4,8 @@
 
 namespace vcpkg::Export
 {
+    extern const CommandStructure COMMAND_STRUCTURE;
+
     void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet);
 
     void export_integration_files(const fs::path& raw_exported_dir_path, const VcpkgPaths& paths);
diff --git a/toolsrc/include/vcpkg/help.h b/toolsrc/include/vcpkg/help.h
index 39ad6912d..73549efd7 100644
--- a/toolsrc/include/vcpkg/help.h
+++ b/toolsrc/include/vcpkg/help.h
@@ -7,13 +7,13 @@
 
 namespace vcpkg::Help
 {
+    extern const CommandStructure COMMAND_STRUCTURE;
+
     void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths);
 
     void help_topic_valid_triplet(const VcpkgPaths& paths);
 
     void print_usage();
 
-    void print_example(const std::string& command_and_arguments);
-
     std::string create_example_string(const std::string& command_and_arguments);
 }
diff --git a/toolsrc/include/vcpkg/install.h b/toolsrc/include/vcpkg/install.h
index db6055f4f..7bf823e99 100644
--- a/toolsrc/include/vcpkg/install.h
+++ b/toolsrc/include/vcpkg/install.h
@@ -17,13 +17,22 @@ namespace vcpkg::Install
 
     inline KeepGoing to_keep_going(const bool value) { return value ? KeepGoing::YES : KeepGoing::NO; }
 
-    enum class PrintSummary
+    struct SpecSummary
     {
-        NO = 0,
-        YES
+        explicit SpecSummary(const PackageSpec& spec);
+
+        PackageSpec spec;
+        Build::BuildResult result;
+        std::string timing;
     };
 
-    inline PrintSummary to_print_summary(const bool value) { return value ? PrintSummary::YES : PrintSummary::NO; }
+    struct InstallSummary
+    {
+        std::vector<SpecSummary> results;
+        std::string total_elapsed_time;
+
+        void print() const;
+    };
 
     struct InstallDir
     {
@@ -44,7 +53,6 @@ namespace vcpkg::Install
 
     Build::BuildResult perform_install_plan_action(const VcpkgPaths& paths,
                                                    const Dependencies::InstallPlanAction& action,
-                                                   const Build::BuildPackageOptions& install_plan_options,
                                                    StatusParagraphs& status_db);
 
     enum class InstallResult
@@ -53,17 +61,17 @@ namespace vcpkg::Install
         SUCCESS,
     };
 
+    std::vector<std::string> get_all_port_names(const VcpkgPaths& paths);
+
     void install_files_and_write_listfile(Files::Filesystem& fs, const fs::path& source_dir, const InstallDir& dirs);
     InstallResult install_package(const VcpkgPaths& paths,
                                   const BinaryControlFile& binary_paragraph,
                                   StatusParagraphs* status_db);
 
-    void perform_and_exit_ex(const std::vector<Dependencies::AnyAction>& action_plan,
-                             const Build::BuildPackageOptions& install_plan_options,
-                             const KeepGoing keep_going,
-                             const PrintSummary print_summary,
-                             const VcpkgPaths& paths,
-                             StatusParagraphs& status_db);
+    InstallSummary perform(const std::vector<Dependencies::AnyAction>& action_plan,
+                           const KeepGoing keep_going,
+                           const VcpkgPaths& paths,
+                           StatusParagraphs& status_db);
 
     extern const CommandStructure COMMAND_STRUCTURE;
 
diff --git a/toolsrc/include/vcpkg/metrics.h b/toolsrc/include/vcpkg/metrics.h
index 41be5002d..f73c636cf 100644
--- a/toolsrc/include/vcpkg/metrics.h
+++ b/toolsrc/include/vcpkg/metrics.h
@@ -15,7 +15,6 @@ namespace vcpkg::Metrics
 
         void track_metric(const std::string& name, double value);
         void track_property(const std::string& name, const std::string& value);
-        void track_property(const std::string& name, const std::wstring& value);
 
         void upload(const std::string& payload);
         void flush();
@@ -23,6 +22,6 @@ namespace vcpkg::Metrics
 
     extern Util::LockGuarded<Metrics> g_metrics;
 
-    std::wstring get_SQM_user();
+    std::string get_SQM_user();
     bool get_compiled_metrics_enabled();
 }
diff --git a/toolsrc/include/vcpkg/packagespec.h b/toolsrc/include/vcpkg/packagespec.h
index ee34f14a3..0487ae6b8 100644
--- a/toolsrc/include/vcpkg/packagespec.h
+++ b/toolsrc/include/vcpkg/packagespec.h
@@ -20,6 +20,8 @@ namespace vcpkg
         static ExpectedT<PackageSpec, PackageSpecParseResult> from_name_and_triplet(const std::string& name,
                                                                                     const Triplet& triplet);
 
+        static std::vector<PackageSpec> to_package_specs(const std::vector<std::string>& ports, const Triplet& triplet);
+
         const std::string& name() const;
 
         const Triplet& triplet() const;
@@ -48,6 +50,22 @@ namespace vcpkg
         static std::vector<FeatureSpec> from_strings_and_triplet(const std::vector<std::string>& depends,
                                                                  const Triplet& t);
 
+        bool operator<(const FeatureSpec& other) const
+        {
+            if (name() < other.name()) return true;
+            if (name() > other.name()) return false;
+            if (feature() < other.feature()) return true;
+            if (feature() > other.feature()) return false;
+            return triplet() < other.triplet();
+        }
+
+        bool operator==(const FeatureSpec& other) const
+        {
+            return triplet() == other.triplet() && name() == other.name() && feature() == other.feature();
+        }
+
+        bool operator!=(const FeatureSpec& other) const { return !(*this == other); }
+
     private:
         PackageSpec m_spec;
         std::string m_feature;
@@ -76,20 +94,23 @@ namespace vcpkg
     bool operator!=(const PackageSpec& left, const PackageSpec& right);
 }
 
-template<>
-struct std::hash<vcpkg::PackageSpec>
+namespace std
 {
-    size_t operator()(const vcpkg::PackageSpec& value) const
+    template<>
+    struct hash<vcpkg::PackageSpec>
     {
-        size_t hash = 17;
-        hash = hash * 31 + std::hash<std::string>()(value.name());
-        hash = hash * 31 + std::hash<vcpkg::Triplet>()(value.triplet());
-        return hash;
-    }
-};
-
-template<>
-struct std::equal_to<vcpkg::PackageSpec>
-{
-    bool operator()(const vcpkg::PackageSpec& left, const vcpkg::PackageSpec& right) const { return left == right; }
-};
+        size_t operator()(const vcpkg::PackageSpec& value) const
+        {
+            size_t hash = 17;
+            hash = hash * 31 + std::hash<std::string>()(value.name());
+            hash = hash * 31 + std::hash<vcpkg::Triplet>()(value.triplet());
+            return hash;
+        }
+    };
+
+    template<>
+    struct equal_to<vcpkg::PackageSpec>
+    {
+        bool operator()(const vcpkg::PackageSpec& left, const vcpkg::PackageSpec& right) const { return left == right; }
+    };
+}
diff --git a/toolsrc/include/vcpkg/packagespecparseresult.h b/toolsrc/include/vcpkg/packagespecparseresult.h
index 8a56574fd..dd91c9a67 100644
--- a/toolsrc/include/vcpkg/packagespecparseresult.h
+++ b/toolsrc/include/vcpkg/packagespecparseresult.h
@@ -20,7 +20,7 @@ namespace vcpkg
         ErrorHolder() : m_err(PackageSpecParseResult::SUCCESS) {}
         ErrorHolder(PackageSpecParseResult err) : m_err(err) {}
 
-        constexpr bool has_error() const { return m_err != PackageSpecParseResult::SUCCESS; }
+        bool has_error() const { return m_err != PackageSpecParseResult::SUCCESS; }
 
         const PackageSpecParseResult& error() const { return m_err; }
         PackageSpecParseResult& error() { return m_err; }
diff --git a/toolsrc/include/vcpkg/paragraphparseresult.h b/toolsrc/include/vcpkg/paragraphparseresult.h
index abdd9eecd..558715bbc 100644
--- a/toolsrc/include/vcpkg/paragraphparseresult.h
+++ b/toolsrc/include/vcpkg/paragraphparseresult.h
@@ -26,8 +26,11 @@ namespace vcpkg
     ParagraphParseResult to_paragraph_parse_result(std::error_code ec);
 }
 
-// Enable implicit conversion to std::error_code
-template<>
-struct std::is_error_code_enum<vcpkg::ParagraphParseResult> : ::std::true_type
+namespace std
 {
-};
+    // Enable implicit conversion to std::error_code
+    template<>
+    struct is_error_code_enum<vcpkg::ParagraphParseResult> : ::std::true_type
+    {
+    };
+}
\ No newline at end of file
diff --git a/toolsrc/include/vcpkg/sourceparagraph.h b/toolsrc/include/vcpkg/sourceparagraph.h
index 0a02e4cda..dcbbc1c3b 100644
--- a/toolsrc/include/vcpkg/sourceparagraph.h
+++ b/toolsrc/include/vcpkg/sourceparagraph.h
@@ -3,8 +3,8 @@
 #include <vcpkg/packagespec.h>
 #include <vcpkg/parse.h>
 
-#include <vcpkg/base/Span.h>
 #include <vcpkg/base/expected.h>
+#include <vcpkg/base/span.h>
 #include <vcpkg/base/system.h>
 
 #include <string>
diff --git a/toolsrc/include/vcpkg/statusparagraphs.h b/toolsrc/include/vcpkg/statusparagraphs.h
index c2f3b7b8e..747a0c1ab 100644
--- a/toolsrc/include/vcpkg/statusparagraphs.h
+++ b/toolsrc/include/vcpkg/statusparagraphs.h
@@ -16,10 +16,10 @@ namespace vcpkg
         using const_iterator = container::const_reverse_iterator;
 
         const_iterator find(const PackageSpec& spec) const { return find(spec.name(), spec.triplet()); }
-        const_iterator find(const std::string& name, const Triplet& triplet) const;
-        iterator find(const std::string& name, const Triplet& triplet);
+        iterator find(const std::string& name, const Triplet& triplet, const std::string& feature = "");
+        const_iterator find(const std::string& name, const Triplet& triplet, const std::string& feature = "") const;
+
         std::vector<std::unique_ptr<StatusParagraph>*> find_all(const std::string& name, const Triplet& triplet);
-        iterator find(const std::string& name, const Triplet& triplet, const std::string& feature);
 
         const_iterator find_installed(const PackageSpec& spec) const
         {
diff --git a/toolsrc/include/vcpkg/triplet.h b/toolsrc/include/vcpkg/triplet.h
index 46a52f8e6..2cfc2d02a 100644
--- a/toolsrc/include/vcpkg/triplet.h
+++ b/toolsrc/include/vcpkg/triplet.h
@@ -24,6 +24,7 @@ namespace vcpkg
         size_t hash_code() const;
 
         bool operator==(const Triplet& other) const;
+        bool operator<(const Triplet& other) const { return canonical_name() < other.canonical_name(); }
 
     private:
         static const TripletInstance DEFAULT_INSTANCE;
@@ -36,8 +37,11 @@ namespace vcpkg
     bool operator!=(const Triplet& left, const Triplet& right);
 }
 
-template<>
-struct std::hash<vcpkg::Triplet>
+namespace std
 {
-    size_t operator()(const vcpkg::Triplet& t) const { return t.hash_code(); }
-};
+    template<>
+    struct hash<vcpkg::Triplet>
+    {
+        size_t operator()(const vcpkg::Triplet& t) const { return t.hash_code(); }
+    };
+}
\ No newline at end of file
diff --git a/toolsrc/include/vcpkg/vcpkgcmdarguments.h b/toolsrc/include/vcpkg/vcpkgcmdarguments.h
index 8b1d766b6..93eeb6ef5 100644
--- a/toolsrc/include/vcpkg/vcpkgcmdarguments.h
+++ b/toolsrc/include/vcpkg/vcpkgcmdarguments.h
@@ -17,9 +17,49 @@ namespace vcpkg
         std::unordered_map<std::string, std::string> settings;
     };
 
+    struct VcpkgPaths;
+
+    struct CommandSwitch
+    {
+        std::string name;
+        CStringView short_help_text;
+    };
+
+    struct CommandSetting
+    {
+        std::string name;
+        CStringView short_help_text;
+    };
+
+    struct CommandOptionsStructure
+    {
+        Span<const CommandSwitch> switches;
+        Span<const CommandSetting> settings;
+    };
+
+    struct CommandStructure
+    {
+        std::string example_text;
+
+        size_t minimum_arity;
+        size_t maximum_arity;
+
+        CommandOptionsStructure options;
+
+        std::vector<std::string> (*valid_arguments)(const VcpkgPaths& paths);
+    };
+
+    void display_usage(const CommandStructure& command_structure);
+
+#if defined(_WIN32)
+    using CommandLineCharType = wchar_t;
+#else
+    using CommandLineCharType = char;
+#endif
+
     struct VcpkgCmdArguments
     {
-        static VcpkgCmdArguments create_from_command_line(const int argc, const wchar_t* const* const argv);
+        static VcpkgCmdArguments create_from_command_line(const int argc, const CommandLineCharType* const* const argv);
         static VcpkgCmdArguments create_from_arg_sequence(const std::string* arg_begin, const std::string* arg_end);
 
         std::unique_ptr<std::string> vcpkg_root_dir;
@@ -30,38 +70,10 @@ namespace vcpkg
 
         std::string command;
         std::vector<std::string> command_arguments;
-        std::unordered_set<std::string> check_and_get_optional_command_arguments(
-            const std::vector<std::string>& valid_options) const
-        {
-            return std::move(check_and_get_optional_command_arguments(valid_options, {}).switches);
-        }
-
-        ParsedArguments check_and_get_optional_command_arguments(const std::vector<std::string>& valid_switches,
-                                                                 const std::vector<std::string>& valid_settings) const;
-
-        void check_max_arg_count(const size_t expected_arg_count) const;
-        void check_max_arg_count(const size_t expected_arg_count, const std::string& example_text) const;
-        void check_min_arg_count(const size_t expected_arg_count) const;
-        void check_min_arg_count(const size_t expected_arg_count, const std::string& example_text) const;
-        void check_exact_arg_count(const size_t expected_arg_count) const;
-        void check_exact_arg_count(const size_t expected_arg_count, const std::string& example_text) const;
+
+        ParsedArguments parse_arguments(const CommandStructure& command_structure) const;
 
     private:
         std::unordered_map<std::string, Optional<std::string>> optional_command_arguments;
     };
-
-    struct VcpkgPaths;
-
-    struct CommandStructure
-    {
-        CStringView example_text;
-
-        size_t minimum_arity;
-        size_t maximum_arity;
-
-        Span<const std::string> switches;
-        Span<const std::string> settings;
-
-        std::vector<std::string> (*valid_arguments)(const VcpkgPaths& paths);
-    };
 }
diff --git a/toolsrc/include/vcpkg/vcpkglib.h b/toolsrc/include/vcpkg/vcpkglib.h
index b2aad8d7b..9a7fdb861 100644
--- a/toolsrc/include/vcpkg/vcpkglib.h
+++ b/toolsrc/include/vcpkg/vcpkglib.h
@@ -22,17 +22,16 @@ namespace vcpkg
 
     struct CMakeVariable
     {
-        CMakeVariable(const CWStringView varname, const wchar_t* varvalue);
-        CMakeVariable(const CWStringView varname, const std::string& varvalue);
-        CMakeVariable(const CWStringView varname, const std::wstring& varvalue);
-        CMakeVariable(const CWStringView varname, const fs::path& path);
+        CMakeVariable(const CStringView varname, const char* varvalue);
+        CMakeVariable(const CStringView varname, const std::string& varvalue);
+        CMakeVariable(const CStringView varname, const fs::path& path);
 
-        std::wstring s;
+        std::string s;
     };
 
-    std::wstring make_cmake_cmd(const fs::path& cmake_exe,
-                                const fs::path& cmake_script,
-                                const std::vector<CMakeVariable>& pass_variables);
+    std::string make_cmake_cmd(const fs::path& cmake_exe,
+                               const fs::path& cmake_script,
+                               const std::vector<CMakeVariable>& pass_variables);
 
     std::string shorten_text(const std::string& desc, size_t length);
 } // namespace vcpkg
diff --git a/toolsrc/include/vcpkg/vcpkgpaths.h b/toolsrc/include/vcpkg/vcpkgpaths.h
index 01c6e30cd..0790be785 100644
--- a/toolsrc/include/vcpkg/vcpkgpaths.h
+++ b/toolsrc/include/vcpkg/vcpkgpaths.h
@@ -3,15 +3,15 @@
 #include <vcpkg/binaryparagraph.h>
 #include <vcpkg/packagespec.h>
 
-#include <vcpkg/base/Lazy.h>
 #include <vcpkg/base/expected.h>
 #include <vcpkg/base/files.h>
+#include <vcpkg/base/lazy.h>
 
 namespace vcpkg
 {
     struct ToolsetArchOption
     {
-        CWStringView name;
+        CStringView name;
         System::CPUArchitecture host_arch;
         System::CPUArchitecture target_arch;
     };
@@ -21,8 +21,8 @@ namespace vcpkg
         fs::path visual_studio_root_path;
         fs::path dumpbin;
         fs::path vcvarsall;
-        std::vector<std::wstring> vcvarsall_options;
-        CWStringView version;
+        std::vector<std::string> vcvarsall_options;
+        CStringView version;
         std::vector<ToolsetArchOption> supported_architectures;
     };
 
@@ -36,6 +36,7 @@ namespace vcpkg
         fs::path build_info_file_path(const PackageSpec& spec) const;
         fs::path listfile_path(const BinaryParagraph& pgh) const;
 
+        const std::vector<std::string>& get_available_triplets() const;
         bool is_valid_triplet(const Triplet& t) const;
 
         fs::path root;
@@ -74,6 +75,7 @@ namespace vcpkg
         Files::Filesystem& get_filesystem() const;
 
     private:
+        Lazy<std::vector<std::string>> available_triplets;
         Lazy<fs::path> cmake_exe;
         Lazy<fs::path> git_exe;
         Lazy<fs::path> nuget_exe;