Merge branch 'master' into master

2 files changed, 85 insertions, 41 deletions

diff --git a/toolsrc/src/vcpkg/build.cpp b/toolsrc/src/vcpkg/build.cpp
index 43f1a6288..b8720bcc4 100644
--- a/toolsrc/src/vcpkg/build.cpp
+++ b/toolsrc/src/vcpkg/build.cpp
@@ -479,13 +479,13 @@ namespace vcpkg::Build
         const int max_port_file_count = 100;

 

         // the order of recursive_directory_iterator is undefined so save the names to sort

-        std::vector<fs::path> port_files;

+        std::vector<fs::path> hashed_files;

         for (auto &port_file : fs::stdfs::recursive_directory_iterator(config.port_dir))

         {

             if (fs::is_regular_file(status(port_file)))

             {

-                port_files.push_back(port_file);

-                if (port_files.size() > max_port_file_count)

+                hashed_files.push_back(port_file);

+                if (hashed_files.size() > max_port_file_count)

                 {

                     abi_tag_entries.emplace_back(AbiEntry{ "no_hash_max_portfile", "" });

                     break;

@@ -493,12 +493,20 @@ namespace vcpkg::Build
             }

         }

 

-        if (port_files.size() <= max_port_file_count)

+        if (hashed_files.size() <= max_port_file_count)

         {

-            std::sort(port_files.begin(), port_files.end());

+            for (auto &script_file : fs::stdfs::recursive_directory_iterator(paths.scripts))

+            {

+                if (fs::is_regular_file(status(script_file)))

+                {

+                    hashed_files.push_back(script_file);

+                }

+            }

+

+            std::sort(hashed_files.begin(), hashed_files.end());

 

             int counter = 0;

-            for (auto & port_file : port_files)

+            for (auto & hashed_file : hashed_files)

             {

                 // When vcpkg takes a dependency on C++17 it can use fs::relative,

                 // which will give a stable ordering and better names in the key entry.

@@ -508,13 +516,13 @@ namespace vcpkg::Build
                 {

                     System::print2("[DEBUG] mapping ", key, " from ", port_file.u8string(), "\n");

                 }

-                abi_tag_entries.emplace_back(AbiEntry{ key, vcpkg::Hash::get_file_hash(fs, port_file, "SHA1") });

+                abi_tag_entries.emplace_back(AbiEntry{ key, vcpkg::Hash::get_file_hash(fs, hashed_file, "SHA1") });

             }

         }

 

         abi_tag_entries.emplace_back(AbiEntry{

-            "vcpkg_fixup_cmake_targets",

-            vcpkg::Hash::get_file_hash(fs, paths.scripts / "cmake" / "vcpkg_fixup_cmake_targets.cmake", "SHA1")});

+            "vcpkg",

+            vcpkg::Hash::get_file_hash(fs, paths.scripts / "buildsystems" / "vcpkg.cmake", "SHA1")});

 

         abi_tag_entries.emplace_back(AbiEntry{"triplet", pre_build_info.triplet_abi_tag});

 

diff --git a/toolsrc/src/vcpkg/install.cpp b/toolsrc/src/vcpkg/install.cpp
index 6d4eabc89..30778cb43 100644
--- a/toolsrc/src/vcpkg/install.cpp
+++ b/toolsrc/src/vcpkg/install.cpp
@@ -19,6 +19,8 @@ namespace vcpkg::Install
 {
     using namespace Dependencies;
 
+    using file_pack = std::pair<std::string, std::string>;
+
     InstallDir InstallDir::from_destination_root(const fs::path& destination_root,
                                                  const std::string& destination_subdirectory,
                                                  const fs::path& listfile)
@@ -139,18 +141,12 @@ namespace vcpkg::Install
         fs.write_lines(listfile, output);
     }
 
-    static void remove_first_n_chars(std::vector<std::string>* strings, const size_t n)
-    {
-        for (std::string& s : *strings)
-        {
-            s.erase(0, n);
-        }
-    };
-
-    static std::vector<std::string> extract_files_in_triplet(
-        const std::vector<StatusParagraphAndAssociatedFiles>& pgh_and_files, const Triplet& triplet)
+    static std::vector<file_pack> extract_files_in_triplet(
+        const std::vector<StatusParagraphAndAssociatedFiles>& pgh_and_files,
+        const Triplet& triplet,
+        const size_t remove_chars = 0)
     {
-        std::vector<std::string> output;
+        std::vector<file_pack> output;
         for (const StatusParagraphAndAssociatedFiles& t : pgh_and_files)
         {
             if (t.pgh.package.spec.triplet() != triplet)
@@ -158,10 +154,16 @@ namespace vcpkg::Install
                 continue;
             }
 
-            Util::Vectors::concatenate(&output, t.files);
+            const std::string name = t.pgh.package.displayname();
+
+            for (const std::string &file : t.files)
+            {
+                output.emplace_back(file_pack{std::string(file, remove_chars), name});
+            }
         }
 
-        std::sort(output.begin(), output.end());
+        std::sort(output.begin(), output.end(),
+                  [](const file_pack &lhs, const file_pack &rhs) { return lhs.first < rhs.first; });
         return output;
     }
 
@@ -171,22 +173,21 @@ namespace vcpkg::Install
         const std::vector<fs::path> package_file_paths = fs.get_files_recursive(package_dir);
         const size_t package_remove_char_count = package_dir.generic_string().size() + 1; // +1 for the slash
         auto package_files = Util::fmap(package_file_paths, [package_remove_char_count](const fs::path& path) {
-            std::string as_string = path.generic_string();
-            as_string.erase(0, package_remove_char_count);
-            return std::move(as_string);
+            return std::move(std::string(path.generic_string(), package_remove_char_count));
         });
 
         return SortedVector<std::string>(std::move(package_files));
     }
 
-    static SortedVector<std::string> build_list_of_installed_files(
-        const std::vector<StatusParagraphAndAssociatedFiles>& pgh_and_files, const Triplet& triplet)
+    static SortedVector<file_pack> build_list_of_installed_files(
+        const std::vector<StatusParagraphAndAssociatedFiles>& pgh_and_files,
+        const Triplet& triplet)
     {
-        std::vector<std::string> installed_files = extract_files_in_triplet(pgh_and_files, triplet);
         const size_t installed_remove_char_count = triplet.canonical_name().size() + 1; // +1 for the slash
-        remove_first_n_chars(&installed_files, installed_remove_char_count);
+        std::vector<file_pack> installed_files =
+            extract_files_in_triplet(pgh_and_files, triplet, installed_remove_char_count);
 
-        return SortedVector<std::string>(std::move(installed_files));
+        return SortedVector<file_pack>(std::move(installed_files));
     }
 
     InstallResult install_package(const VcpkgPaths& paths, const BinaryControlFile& bcf, StatusParagraphs* status_db)
@@ -197,23 +198,58 @@ namespace vcpkg::Install
 
         const SortedVector<std::string> package_files =
             build_list_of_package_files(paths.get_filesystem(), package_dir);
-        const SortedVector<std::string> installed_files = build_list_of_installed_files(pgh_and_files, triplet);
+        const SortedVector<file_pack> installed_files =
+            build_list_of_installed_files(pgh_and_files, triplet);
 
-        std::vector<std::string> intersection;
-        std::set_intersection(package_files.begin(),
-                              package_files.end(),
-                              installed_files.begin(),
+        struct intersection_compare
+        {
+            bool operator()(const std::string &lhs, const file_pack &rhs) { return lhs < rhs.first; }
+            bool operator()(const file_pack &lhs, const std::string &rhs) { return lhs.first < rhs; }
+        };
+
+        std::vector<file_pack> intersection;
+
+        std::set_intersection(installed_files.begin(),
                               installed_files.end(),
-                              std::back_inserter(intersection));
+                              package_files.begin(),
+                              package_files.end(),
+                              std::back_inserter(intersection),
+                              intersection_compare());
+
+        std::sort(intersection.begin(), intersection.end(),
+                  [](const file_pack &lhs, const file_pack &rhs)
+                  {
+                      return lhs.second < rhs.second;
+                  });
 
         if (!intersection.empty())
         {
             const fs::path triplet_install_path = paths.installed / triplet.canonical_name();
-            System::printf(System::Color::error,
-                           "The following files are already installed in %s and are in conflict with %s\n",
-                           triplet_install_path.generic_string(),
-                           bcf.core_paragraph.spec);
-            System::print2("\n    ", Strings::join("\n    ", intersection), "\n\n");
+
+            System::println(System::Color::error,
+                            "The following files are already installed in %s by and are in conflict with %s\n",
+                            triplet_install_path.generic_string(),
+                            bcf.core_paragraph.spec);
+
+            auto i = intersection.begin();
+            while (i != intersection.end()) {
+                System::printf("%s:\n    ", i->second);
+                auto next = std::find_if(i, intersection.end(),
+                                         [i](const auto &val)
+                                         {
+                                             return i->second != val.second;
+                                         });
+
+                System::print2(Strings::join("\n    ", i, next,
+                                             [](const file_pack &file)
+                                             {
+                                                 return file.first;
+                                             }));
+                System::println();
+
+                i = next;
+            }
+
             return InstallResult::FILE_CONFLICTS;
         }