[vcpkg] Merge from master into refactor-includes

6 files changed, 72 insertions, 25 deletions

diff --git a/toolsrc/src/vcpkg/base/system.cpp b/toolsrc/src/vcpkg/base/system.cpp
index 716c2a6a6..d5d39461c 100644
--- a/toolsrc/src/vcpkg/base/system.cpp
+++ b/toolsrc/src/vcpkg/base/system.cpp
@@ -107,6 +107,8 @@ namespace vcpkg::System
             L"HTTPS_PROXY",
             // Enables find_package(CUDA) in CMake
             L"CUDA_PATH",
+            // Environmental variable generated automatically by CUDA after installation
+            L"NVCUDASAMPLES_ROOT",
         };
 
         // Flush stdout before launching external process
diff --git a/toolsrc/src/vcpkg/commands.autocomplete.cpp b/toolsrc/src/vcpkg/commands.autocomplete.cpp
index ad2a5b227..b8c633142 100644
--- a/toolsrc/src/vcpkg/commands.autocomplete.cpp
+++ b/toolsrc/src/vcpkg/commands.autocomplete.cpp
@@ -1,9 +1,8 @@
 #include "pch.h"
 
-#include <vcpkg/base/sortedvector.h>
 #include <vcpkg/base/system.h>
 #include <vcpkg/commands.h>
-#include <vcpkg/help.h>
+#include <vcpkg/metrics.h>
 #include <vcpkg/paragraphs.h>
 #include <vcpkg/vcpkglib.h>
 
@@ -13,13 +12,12 @@ namespace vcpkg::Commands::Autocomplete
         const std::vector<std::unique_ptr<SourceControlFile>>& source_paragraphs, const std::string& start_with)
     {
         std::vector<std::string> results;
-        const auto& istartswith = Strings::case_insensitive_ascii_starts_with;
 
         for (const auto& source_control_file : source_paragraphs)
         {
             auto&& sp = *source_control_file->core_paragraph;
 
-            if (istartswith(sp.name, start_with))
+            if (Strings::case_insensitive_ascii_starts_with(sp.name, start_with))
             {
                 results.push_back(sp.name);
             }
@@ -31,13 +29,12 @@ namespace vcpkg::Commands::Autocomplete
                                                  const std::string& start_with)
     {
         std::vector<std::string> results;
-        const auto& istartswith = Strings::case_insensitive_ascii_starts_with;
 
         for (const auto& installed_package : installed_packages)
         {
-            auto sp = installed_package->package.displayname();
+            const auto sp = installed_package->package.displayname();
 
-            if (istartswith(sp, start_with))
+            if (Strings::case_insensitive_ascii_starts_with(sp, start_with))
             {
                 results.push_back(sp);
             }
@@ -45,34 +42,68 @@ namespace vcpkg::Commands::Autocomplete
         return results;
     }
 
+    [[noreturn]] static void output_sorted_results_and_exit(const LineInfo& line_info,
+                                                            std::vector<std::string>&& results)
+    {
+        const SortedVector<std::string> sorted_results(results);
+        System::println(Strings::join("\n", sorted_results));
+        Checks::exit_success(line_info);
+    }
+
     void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths)
     {
-        static const std::string EXAMPLE = Strings::format("The argument should be a command line to autocomplete.\n%s",
-                                                           Help::create_example_string("autocomplete install z"));
+        Metrics::g_metrics.lock()->set_send_metrics(false);
+        const std::string to_autocomplete = Strings::join(" ", args.command_arguments);
+        const std::vector<std::string> tokens = Strings::split(to_autocomplete, " ");
 
-        args.check_min_arg_count(1, EXAMPLE);
-        args.check_max_arg_count(2, EXAMPLE);
-        args.check_and_get_optional_command_arguments({});
+        std::smatch match;
 
-        const std::string requested_command = args.command_arguments.at(0);
-        const std::string start_with =
-            args.command_arguments.size() > 1 ? args.command_arguments.at(1) : Strings::EMPTY;
-        std::vector<std::string> results;
-        if (requested_command == "install")
+        // Handles vcpkg <command>
+        if (std::regex_match(to_autocomplete, match, std::regex{R"###(^(\S*)$)###"}))
+        {
+            const std::string requested_command = match[1].str();
+
+            std::vector<std::string> valid_commands = {"install",
+                                                       "search",
+                                                       "remove",
+                                                       "list",
+                                                       "update",
+                                                       "hash",
+                                                       "help",
+                                                       "integrate",
+                                                       "export",
+                                                       "edit",
+                                                       "create",
+                                                       "owns",
+                                                       "cache",
+                                                       "version",
+                                                       "contact"};
+
+            Util::unstable_keep_if(valid_commands, [&](const std::string& s) {
+                return Strings::case_insensitive_ascii_starts_with(s, requested_command);
+            });
+
+            output_sorted_results_and_exit(VCPKG_LINE_INFO, std::move(valid_commands));
+        }
+
+        // Handles vcpkg install <package>
+        if (std::regex_match(to_autocomplete, match, std::regex{R"###(^install.* (\S*)$)###"}))
         {
+            const std::string start_with = match[1].str();
             auto sources_and_errors = Paragraphs::try_load_all_ports(paths.get_filesystem(), paths.ports);
             auto& source_paragraphs = sources_and_errors.paragraphs;
-
-            results = autocomplete_install(source_paragraphs, start_with);
+            output_sorted_results_and_exit(VCPKG_LINE_INFO, autocomplete_install(source_paragraphs, start_with));
         }
-        else if (requested_command == "remove")
+
+        // Handles vcpkg remove <package>
+        if (std::regex_match(to_autocomplete, match, std::regex{R"###(^remove.* (\S*)$)###"}))
         {
+            const std::string start_with = match[1].str();
             const StatusParagraphs status_db = database_load_check(paths);
-            std::vector<StatusParagraph*> installed_packages = get_installed_ports(status_db);
-            results = autocomplete_remove(installed_packages, start_with);
+            const std::vector<StatusParagraph*> installed_packages = get_installed_ports(status_db);
+            output_sorted_results_and_exit(VCPKG_LINE_INFO, autocomplete_remove(installed_packages, start_with));
         }
 
-        System::println(Strings::join(" ", results));
         Checks::exit_success(VCPKG_LINE_INFO);
     }
 }
diff --git a/toolsrc/src/vcpkg/commands.exportifw.cpp b/toolsrc/src/vcpkg/commands.exportifw.cpp
index 35a3c97a7..fbf3beb8c 100644
--- a/toolsrc/src/vcpkg/commands.exportifw.cpp
+++ b/toolsrc/src/vcpkg/commands.exportifw.cpp
@@ -27,6 +27,14 @@ namespace vcpkg::Export::IFW
         return date_time_as_string;
     }
 
+    std::string safe_rich_from_plain_text(const std::string& text)
+    {
+        // match standalone ampersand, no HTML number or name

+        std::regex standalone_ampersand(R"###(&(?!(#[0-9]+|\w+);))###");
+
+        return std::regex_replace(text, standalone_ampersand, "&amp;");
+    }
+
     fs::path get_packages_dir_path(const std::string& export_id, const Options& ifw_options, const VcpkgPaths& paths)
     {
         return ifw_options.maybe_packages_dir_path.has_value()
@@ -157,7 +165,7 @@ namespace vcpkg::Export::IFW
 </Package>
 )###",
                                   action.spec.name(),
-                                  binary_paragraph.description,
+                                  safe_rich_from_plain_text(binary_paragraph.description),
                                   binary_paragraph.version,
                                   create_release_date()));
         }
diff --git a/toolsrc/src/vcpkg/install.cpp b/toolsrc/src/vcpkg/install.cpp
index 74bea0d5f..28d6d1cc6 100644
--- a/toolsrc/src/vcpkg/install.cpp
+++ b/toolsrc/src/vcpkg/install.cpp
@@ -558,6 +558,7 @@ namespace vcpkg::Install
         const bool no_downloads = options.find(OPTION_NO_DOWNLOADS) != options.cend();
         const bool is_recursive = options.find(OPTION_RECURSE) != options.cend();
         const KeepGoing keep_going = to_keep_going(options.find(OPTION_KEEP_GOING) != options.cend());
+        const PrintSummary print_summary = to_print_summary(keep_going == KeepGoing::YES);
 
         // create the plan
         StatusParagraphs status_db = database_load_check(paths);
@@ -608,7 +609,7 @@ namespace vcpkg::Install
             Checks::exit_success(VCPKG_LINE_INFO);
         }
 
-        perform_and_exit_ex(action_plan, install_plan_options, keep_going, PrintSummary::NO, paths, status_db);
+        perform_and_exit_ex(action_plan, install_plan_options, keep_going, print_summary, paths, status_db);
 
         Checks::exit_success(VCPKG_LINE_INFO);
     }
diff --git a/toolsrc/src/vcpkg/postbuildlint.cpp b/toolsrc/src/vcpkg/postbuildlint.cpp
index 5f55249df..22cf67e86 100644
--- a/toolsrc/src/vcpkg/postbuildlint.cpp
+++ b/toolsrc/src/vcpkg/postbuildlint.cpp
@@ -361,6 +361,7 @@ namespace vcpkg::PostBuildLint
             case MachineType::I386: return "x86";
             case MachineType::ARM:
             case MachineType::ARMNT: return "arm";
+            case MachineType::ARM64: return "arm64";
             default: return "Machine Type Code = " + std::to_string(static_cast<uint16_t>(machine_type));
         }
     }
diff --git a/toolsrc/src/vcpkg/vcpkgpaths.cpp b/toolsrc/src/vcpkg/vcpkgpaths.cpp
index e1a4acd69..07ce5c961 100644
--- a/toolsrc/src/vcpkg/vcpkgpaths.cpp
+++ b/toolsrc/src/vcpkg/vcpkgpaths.cpp
@@ -370,10 +370,14 @@ namespace vcpkg
                     supported_architectures.push_back({L"x86_amd64", CPU::X86, CPU::X64});
                 if (fs.exists(vcvarsall_dir / "vcvarsx86_arm.bat"))
                     supported_architectures.push_back({L"x86_arm", CPU::X86, CPU::ARM});
+                if (fs.exists(vcvarsall_dir / "vcvarsx86_arm64.bat"))
+                    supported_architectures.push_back({L"x86_arm64", CPU::X86, CPU::ARM64});
                 if (fs.exists(vcvarsall_dir / "vcvarsamd64_x86.bat"))
                     supported_architectures.push_back({L"amd64_x86", CPU::X64, CPU::X86});
                 if (fs.exists(vcvarsall_dir / "vcvarsamd64_arm.bat"))
                     supported_architectures.push_back({L"amd64_arm", CPU::X64, CPU::ARM});
+                if (fs.exists(vcvarsall_dir / "vcvarsamd64_arm64.bat"))
+                    supported_architectures.push_back({L"amd64_arm64", CPU::X64, CPU::ARM64});
 
                 // Locate the "best" MSVC toolchain version
                 const fs::path msvc_path = vc_dir / "Tools" / "MSVC";