Merge branch 'master' of https://github.com/Microsoft/vcpkg into qca

4 files changed, 329 insertions, 235 deletions

diff --git a/toolsrc/src/commands_installation.cpp b/toolsrc/src/commands_installation.cpp
index 93335220d..1abd16796 100644
--- a/toolsrc/src/commands_installation.cpp
+++ b/toolsrc/src/commands_installation.cpp
@@ -67,6 +67,152 @@ namespace vcpkg
         // delete_directory(port_buildtrees_dir);
     }
 
+    static void install_and_write_listfile(const vcpkg_paths& paths, const BinaryParagraph& bpgh)
+    {
+        std::fstream listfile(paths.listfile_path(bpgh), std::ios_base::out | std::ios_base::binary | std::ios_base::trunc);
+
+        auto package_prefix_path = paths.package_dir(bpgh.spec);
+        auto prefix_length = package_prefix_path.native().size();
+
+        const triplet& target_triplet = bpgh.spec.target_triplet();
+        const std::string& target_triplet_as_string = target_triplet.canonical_name();
+        std::error_code ec;
+        fs::create_directory(paths.installed / target_triplet_as_string, ec);
+        listfile << target_triplet << "\n";
+
+        for (auto it = fs::recursive_directory_iterator(package_prefix_path); it != fs::recursive_directory_iterator(); ++it)
+        {
+            const std::string filename = it->path().filename().generic_string();
+            if (fs::is_regular_file(it->status()) && (_stricmp(filename.c_str(), "CONTROL") == 0 || _stricmp(filename.c_str(), "BUILD_INFO") == 0))
+            {
+                // Do not copy the control file
+                continue;
+            }
+
+            auto suffix = it->path().generic_u8string().substr(prefix_length + 1);
+            auto target = paths.installed / target_triplet_as_string / suffix;
+
+            auto status = it->status(ec);
+            if (ec)
+            {
+                System::println(System::color::error, "failed: %s: %s", it->path().u8string(), ec.message());
+                continue;
+            }
+            if (fs::is_directory(status))
+            {
+                fs::create_directory(target, ec);
+                if (ec)
+                {
+                    System::println(System::color::error, "failed: %s: %s", target.u8string(), ec.message());
+                }
+
+                listfile << target_triplet << "/" << suffix << "\n";
+            }
+            else if (fs::is_regular_file(status))
+            {
+                fs::copy_file(*it, target, ec);
+                if (ec)
+                {
+                    System::println(System::color::error, "failed: %s: %s", target.u8string(), ec.message());
+                }
+                listfile << target_triplet << "/" << suffix << "\n";
+            }
+            else if (!fs::status_known(status))
+            {
+                System::println(System::color::error, "failed: %s: unknown status", it->path().u8string());
+            }
+            else
+                System::println(System::color::error, "failed: %s: cannot handle file type", it->path().u8string());
+        }
+
+        listfile.close();
+    }
+
+    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<StatusParagraph_and_associated_files>& pgh_and_files, const triplet& triplet)
+    {
+        std::vector<std::string> output;
+        for (const StatusParagraph_and_associated_files& t : pgh_and_files)
+        {
+            if (t.pgh.package.spec.target_triplet() != triplet)
+            {
+                continue;
+            }
+
+            output.insert(output.end(), t.files.cbegin(), t.files.cend());
+        }
+
+        std::sort(output.begin(), output.end());
+        return output;
+    }
+
+    void install_package(const vcpkg_paths& paths, const BinaryParagraph& binary_paragraph, StatusParagraphs& status_db)
+    {
+        const fs::path package_dir = paths.package_dir(binary_paragraph.spec);
+        const std::vector<fs::path> package_file_paths = Files::recursive_find_all_files_in_dir(package_dir);
+        std::vector<std::string> package_files;
+        const size_t package_remove_char_count = package_dir.generic_string().size() + 1; // +1 for the slash
+        std::transform(package_file_paths.cbegin(), package_file_paths.cend(), std::back_inserter(package_files), [package_remove_char_count](const fs::path& path)
+                       {
+                           return path.generic_string().erase(0, package_remove_char_count);
+                       });
+        std::sort(package_files.begin(), package_files.end());
+
+        const std::vector<StatusParagraph_and_associated_files>& pgh_and_files = get_installed_files(paths, status_db);
+        const triplet& triplet = binary_paragraph.spec.target_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::sort(installed_files.begin(), installed_files.end()); // Should already be sorted
+
+        std::vector<std::string> intersection;
+        std::set_intersection(package_files.cbegin(), package_files.cend(),
+                              installed_files.cbegin(), installed_files.cend(),
+                              std::back_inserter(intersection));
+
+        if (!intersection.empty())
+        {
+            const fs::path triplet_install_path = paths.installed / triplet.canonical_name();
+            System::println(System::color::error, "The following files are already installed in %s and are in conflict with %s",
+                            triplet_install_path.generic_string(),
+                            binary_paragraph.spec);
+            System::println("");
+            for (const std::string& s : intersection)
+            {
+                System::println("    %s", s);
+            }
+            System::println("");
+            exit(EXIT_FAILURE);
+        }
+
+        StatusParagraph spgh;
+        spgh.package = binary_paragraph;
+        spgh.want = want_t::install;
+        spgh.state = install_state_t::half_installed;
+        for (auto&& dep : spgh.package.depends)
+        {
+            if (status_db.find_installed(dep, spgh.package.spec.target_triplet()) == status_db.end())
+            {
+                Checks::unreachable();
+            }
+        }
+        write_update(paths, spgh);
+        status_db.insert(std::make_unique<StatusParagraph>(spgh));
+
+        install_and_write_listfile(paths, spgh.package);
+
+        spgh.state = install_state_t::installed;
+        write_update(paths, spgh);
+        status_db.insert(std::make_unique<StatusParagraph>(spgh));
+    }
+
     void install_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths, const triplet& default_target_triplet)
     {
         static const std::string example = create_example_string("install zlib zlib:x64-windows curl boost");
diff --git a/toolsrc/src/commands_owns.cpp b/toolsrc/src/commands_owns.cpp
index e5599ce01..45f073304 100644
--- a/toolsrc/src/commands_owns.cpp
+++ b/toolsrc/src/commands_owns.cpp
@@ -1,30 +1,21 @@
 #include "vcpkg_Commands.h"
 #include "vcpkg_System.h"
 #include "vcpkg.h"
-#include <fstream>
 
 namespace vcpkg
 {
     static void search_file(const vcpkg_paths& paths, const std::string& file_substr, const StatusParagraphs& status_db)
     {
-        std::string line;
-
-        for (auto&& pgh : status_db)
+        const std::vector<StatusParagraph_and_associated_files> installed_files = get_installed_files(paths, status_db);
+        for (const StatusParagraph_and_associated_files& pgh_and_file : installed_files)
         {
-            if (pgh->state != install_state_t::installed)
-                continue;
+            const StatusParagraph& pgh = pgh_and_file.pgh;
 
-            std::fstream listfile(paths.listfile_path(pgh->package));
-            while (std::getline(listfile, line))
+            for (const std::string& file : pgh_and_file.files)
             {
-                if (line.empty())
-                {
-                    continue;
-                }
-
-                if (line.find(file_substr) != std::string::npos)
+                if (file.find(file_substr) != std::string::npos)
                 {
-                    System::println("%s: %s", pgh->package.displayname(), line);
+                    System::println("%s: %s", pgh.package.displayname(), file);
                 }
             }
         }
diff --git a/toolsrc/src/commands_remove.cpp b/toolsrc/src/commands_remove.cpp
index 5bb9ecc96..31331fc2f 100644
--- a/toolsrc/src/commands_remove.cpp
+++ b/toolsrc/src/commands_remove.cpp
@@ -2,6 +2,7 @@
 #include "vcpkg.h"
 #include "vcpkg_System.h"
 #include "vcpkg_Input.h"
+#include <fstream>
 
 namespace vcpkg
 {
@@ -21,6 +22,150 @@ namespace vcpkg
         }
     }
 
+    enum class deinstall_plan
+    {
+        not_installed,
+        dependencies_not_satisfied,
+        should_deinstall
+    };
+
+    static deinstall_plan deinstall_package_plan(
+        const StatusParagraphs::iterator package_it,
+        const StatusParagraphs& status_db,
+        std::vector<const StatusParagraph*>& dependencies_out)
+    {
+        dependencies_out.clear();
+
+        if (package_it == status_db.end() || (*package_it)->state == install_state_t::not_installed)
+        {
+            return deinstall_plan::not_installed;
+        }
+
+        auto& pkg = (*package_it)->package;
+
+        for (auto&& inst_pkg : status_db)
+        {
+            if (inst_pkg->want != want_t::install)
+                continue;
+            if (inst_pkg->package.spec.target_triplet() != pkg.spec.target_triplet())
+                continue;
+
+            const auto& deps = inst_pkg->package.depends;
+
+            if (std::find(deps.begin(), deps.end(), pkg.spec.name()) != deps.end())
+            {
+                dependencies_out.push_back(inst_pkg.get());
+            }
+        }
+
+        if (!dependencies_out.empty())
+            return deinstall_plan::dependencies_not_satisfied;
+
+        return deinstall_plan::should_deinstall;
+    }
+
+    static void deinstall_package(const vcpkg_paths& paths, const package_spec& spec, StatusParagraphs& status_db)
+    {
+        auto package_it = status_db.find(spec.name(), spec.target_triplet());
+        if (package_it == status_db.end())
+        {
+            System::println(System::color::success, "Package %s is not installed", spec);
+            return;
+        }
+
+        auto& pkg = **package_it;
+
+        std::vector<const StatusParagraph*> deps;
+        auto plan = deinstall_package_plan(package_it, status_db, deps);
+        switch (plan)
+        {
+            case deinstall_plan::not_installed:
+                System::println(System::color::success, "Package %s is not installed", spec);
+                return;
+            case deinstall_plan::dependencies_not_satisfied:
+                System::println(System::color::error, "Error: Cannot remove package %s:", spec);
+                for (auto&& dep : deps)
+                {
+                    System::println("  %s depends on %s", dep->package.displayname(), pkg.package.displayname());
+                }
+                exit(EXIT_FAILURE);
+            case deinstall_plan::should_deinstall:
+                break;
+            default:
+                Checks::unreachable();
+        }
+
+        pkg.want = want_t::purge;
+        pkg.state = install_state_t::half_installed;
+        write_update(paths, pkg);
+
+        std::fstream listfile(paths.listfile_path(pkg.package), std::ios_base::in | std::ios_base::binary);
+        if (listfile)
+        {
+            std::vector<fs::path> dirs_touched;
+            std::string suffix;
+            while (std::getline(listfile, suffix))
+            {
+                if (!suffix.empty() && suffix.back() == '\r')
+                    suffix.pop_back();
+
+                std::error_code ec;
+
+                auto target = paths.installed / suffix;
+
+                auto status = fs::status(target, ec);
+                if (ec)
+                {
+                    System::println(System::color::error, "failed: %s", ec.message());
+                    continue;
+                }
+
+                if (fs::is_directory(status))
+                {
+                    dirs_touched.push_back(target);
+                }
+                else if (fs::is_regular_file(status))
+                {
+                    fs::remove(target, ec);
+                    if (ec)
+                    {
+                        System::println(System::color::error, "failed: %s: %s", target.u8string(), ec.message());
+                    }
+                }
+                else if (!fs::status_known(status))
+                {
+                    System::println(System::color::warning, "Warning: unknown status: %s", target.u8string());
+                }
+                else
+                {
+                    System::println(System::color::warning, "Warning: %s: cannot handle file type", target.u8string());
+                }
+            }
+
+            auto b = dirs_touched.rbegin();
+            auto e = dirs_touched.rend();
+            for (; b != e; ++b)
+            {
+                if (fs::directory_iterator(*b) == fs::directory_iterator())
+                {
+                    std::error_code ec;
+                    fs::remove(*b, ec);
+                    if (ec)
+                    {
+                        System::println(System::color::error, "failed: %s", ec.message());
+                    }
+                }
+            }
+
+            listfile.close();
+            fs::remove(paths.listfile_path(pkg.package));
+        }
+
+        pkg.state = install_state_t::not_installed;
+        write_update(paths, pkg);
+        System::println(System::color::success, "Package %s was successfully removed", pkg.package.displayname());
+    }
+
     void remove_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths, const triplet& default_target_triplet)
     {
         static const std::string example = create_example_string("remove zlib zlib:x64-windows curl boost");
diff --git a/toolsrc/src/vcpkg.cpp b/toolsrc/src/vcpkg.cpp
index 4b65ea972..88b05b0a9 100644
--- a/toolsrc/src/vcpkg.cpp
+++ b/toolsrc/src/vcpkg.cpp
@@ -7,24 +7,12 @@
 #include <unordered_map>
 #include <memory>
 #include <vector>
-#include <cassert>
 #include "vcpkg_Files.h"
-#include "vcpkg_System.h"
 #include "Paragraphs.h"
 #include <regex>
 
 using namespace vcpkg;
 
-bool vcpkg::g_do_dry_run = false;
-
-namespace
-{
-    std::fstream open_status_file(const vcpkg_paths& paths, std::ios_base::openmode mode = std::ios_base::app | std::ios_base::in | std::ios_base::out | std::ios_base::binary)
-    {
-        return std::fstream(paths.vcpkg_dir_status_file, mode);
-    }
-}
-
 static StatusParagraphs load_current_database(const fs::path& vcpkg_dir_status_file, const fs::path& vcpkg_dir_status_file_old)
 {
     if (!fs::exists(vcpkg_dir_status_file))
@@ -109,14 +97,7 @@ StatusParagraphs vcpkg::database_load_check(const vcpkg_paths& paths)
     return current_status_db;
 }
 
-static std::string get_fullpkgname_from_listfile(const fs::path& path)
-{
-    auto ret = path.stem().generic_u8string();
-    std::replace(ret.begin(), ret.end(), '_', ':');
-    return ret;
-}
-
-static void write_update(const vcpkg_paths& paths, const StatusParagraph& p)
+void vcpkg::write_update(const vcpkg_paths& paths, const StatusParagraph& p)
 {
     static int update_id = 0;
     auto my_update_id = update_id++;
@@ -128,232 +109,63 @@ static void write_update(const vcpkg_paths& paths, const StatusParagraph& p)
     fs::rename(tmp_update_filename, update_filename);
 }
 
-static void install_and_write_listfile(const vcpkg_paths& paths, const BinaryParagraph& bpgh)
+std::vector<StatusParagraph_and_associated_files> vcpkg::get_installed_files(const vcpkg_paths& paths, const StatusParagraphs& status_db)
 {
-    std::fstream listfile(paths.listfile_path(bpgh), std::ios_base::out | std::ios_base::binary | std::ios_base::trunc);
+    static const std::string MARK_FOR_REMOVAL = "";
 
-    auto package_prefix_path = paths.package_dir(bpgh.spec);
-    auto prefix_length = package_prefix_path.native().size();
+    std::vector<StatusParagraph_and_associated_files> installed_files;
 
-    const triplet& target_triplet = bpgh.spec.target_triplet();
-    const std::string& target_triplet_as_string = target_triplet.canonical_name();
-    std::error_code ec;
-    fs::create_directory(paths.installed / target_triplet_as_string, ec);
-    listfile << target_triplet << "\n";
+    std::string line;
 
-    for (auto it = fs::recursive_directory_iterator(package_prefix_path); it != fs::recursive_directory_iterator(); ++it)
+    for (const std::unique_ptr<StatusParagraph>& pgh : status_db)
     {
-        const std::string filename = it->path().filename().generic_string();
-        if (fs::is_regular_file(it->status()) && (_stricmp(filename.c_str(), "CONTROL") == 0 || _stricmp(filename.c_str(), "BUILD_INFO") == 0))
+        if (pgh->state != install_state_t::installed)
         {
-            // Do not copy the control file
             continue;
         }
 
-        auto suffix = it->path().generic_u8string().substr(prefix_length + 1);
-        auto target = paths.installed / target_triplet_as_string / suffix;
+        std::fstream listfile(paths.listfile_path(pgh->package));
 
-        auto status = it->status(ec);
-        if (ec)
+        std::vector<std::string> installed_files_of_current_pgh;
+        while (std::getline(listfile, line))
         {
-            System::println(System::color::error, "failed: %s: %s", it->path().u8string(), ec.message());
-            continue;
-        }
-        if (fs::is_directory(status))
-        {
-            fs::create_directory(target, ec);
-            if (ec)
-            {
-                System::println(System::color::error, "failed: %s: %s", target.u8string(), ec.message());
-            }
-
-            listfile << target_triplet << "/" << suffix << "\n";
-        }
-        else if (fs::is_regular_file(status))
-        {
-            fs::copy_file(*it, target, ec);
-            if (ec)
+            if (line.empty())
             {
-                System::println(System::color::error, "failed: %s: %s", target.u8string(), ec.message());
+                continue;
             }
-            listfile << target_triplet << "/" << suffix << "\n";
-        }
-        else if (!fs::status_known(status))
-        {
-            System::println(System::color::error, "failed: %s: unknown status", it->path().u8string());
-        }
-        else
-            System::println(System::color::error, "failed: %s: cannot handle file type", it->path().u8string());
-    }
-
-    listfile.close();
-}
-
-void vcpkg::install_package(const vcpkg_paths& paths, const BinaryParagraph& binary_paragraph, StatusParagraphs& status_db)
-{
-    StatusParagraph spgh;
-    spgh.package = binary_paragraph;
-    spgh.want = want_t::install;
-    spgh.state = install_state_t::half_installed;
-    for (auto&& dep : spgh.package.depends)
-    {
-        if (status_db.find_installed(dep, spgh.package.spec.target_triplet()) == status_db.end())
-        {
-            Checks::unreachable();
-        }
-    }
-    write_update(paths, spgh);
-    status_db.insert(std::make_unique<StatusParagraph>(spgh));
-
-    install_and_write_listfile(paths, spgh.package);
-
-    spgh.state = install_state_t::installed;
-    write_update(paths, spgh);
-    status_db.insert(std::make_unique<StatusParagraph>(spgh));
-}
-
-enum class deinstall_plan
-{
-    not_installed,
-    dependencies_not_satisfied,
-    should_deinstall
-};
-
-static deinstall_plan deinstall_package_plan(
-    const StatusParagraphs::iterator package_it,
-    const StatusParagraphs& status_db,
-    std::vector<const StatusParagraph*>& dependencies_out)
-{
-    dependencies_out.clear();
-
-    if (package_it == status_db.end() || (*package_it)->state == install_state_t::not_installed)
-    {
-        return deinstall_plan::not_installed;
-    }
-
-    auto& pkg = (*package_it)->package;
-
-    for (auto&& inst_pkg : status_db)
-    {
-        if (inst_pkg->want != want_t::install)
-            continue;
-        if (inst_pkg->package.spec.target_triplet() != pkg.spec.target_triplet())
-            continue;
-
-        const auto& deps = inst_pkg->package.depends;
 
-        if (std::find(deps.begin(), deps.end(), pkg.spec.name()) != deps.end())
-        {
-            dependencies_out.push_back(inst_pkg.get());
+            installed_files_of_current_pgh.push_back(line);
         }
-    }
-
-    if (!dependencies_out.empty())
-        return deinstall_plan::dependencies_not_satisfied;
 
-    return deinstall_plan::should_deinstall;
-}
-
-void vcpkg::deinstall_package(const vcpkg_paths& paths, const package_spec& spec, StatusParagraphs& status_db)
-{
-    auto package_it = status_db.find(spec.name(), spec.target_triplet());
-    if (package_it == status_db.end())
-    {
-        System::println(System::color::success, "Package %s is not installed", spec);
-        return;
-    }
+        // Should already be sorted
+        std::sort(installed_files_of_current_pgh.begin(), installed_files_of_current_pgh.end());
 
-    auto& pkg = **package_it;
-
-    std::vector<const StatusParagraph*> deps;
-    auto plan = deinstall_package_plan(package_it, status_db, deps);
-    switch (plan)
-    {
-        case deinstall_plan::not_installed:
-            System::println(System::color::success, "Package %s is not installed", spec);
-            return;
-        case deinstall_plan::dependencies_not_satisfied:
-            System::println(System::color::error, "Error: Cannot remove package %s:", spec);
-            for (auto&& dep : deps)
-            {
-                System::println("  %s depends on %s", dep->package.displayname(), pkg.package.displayname());
-            }
-            exit(EXIT_FAILURE);
-        case deinstall_plan::should_deinstall:
-            break;
-        default:
-            Checks::unreachable();
-    }
-
-    pkg.want = want_t::purge;
-    pkg.state = install_state_t::half_installed;
-    write_update(paths, pkg);
-
-    std::fstream listfile(paths.listfile_path(pkg.package), std::ios_base::in | std::ios_base::binary);
-    if (listfile)
-    {
-        std::vector<fs::path> dirs_touched;
-        std::string suffix;
-        while (std::getline(listfile, suffix))
+        // Since the files are sorted, we can detect the entries that represent directories
+        // by comparing every element with the next one and checking if the next has a slash immediately after the current one's length
+        for (int i = 1; i < installed_files_of_current_pgh.size(); i++)
         {
-            if (!suffix.empty() && suffix.back() == '\r')
-                suffix.pop_back();
-
-            std::error_code ec;
-
-            auto target = paths.installed / suffix;
+            std::string& current_string = installed_files_of_current_pgh.at(i - 1);
+            const std::string& next_string = installed_files_of_current_pgh.at(i);
 
-            auto status = fs::status(target, ec);
-            if (ec)
+            const size_t potential_slash_char_index = current_string.length();
+            // Make sure the index exists first
+            if (next_string.size() > potential_slash_char_index && next_string.at(potential_slash_char_index) == '/')
             {
-                System::println(System::color::error, "failed: %s", ec.message());
-                continue;
-            }
-
-            if (fs::is_directory(status))
-            {
-                dirs_touched.push_back(target);
-            }
-            else if (fs::is_regular_file(status))
-            {
-                fs::remove(target, ec);
-                if (ec)
-                {
-                    System::println(System::color::error, "failed: %s: %s", target.u8string(), ec.message());
-                }
-            }
-            else if (!fs::status_known(status))
-            {
-                System::println(System::color::warning, "Warning: unknown status: %s", target.u8string());
-            }
-            else
-            {
-                System::println(System::color::warning, "Warning: %s: cannot handle file type", target.u8string());
+                current_string = MARK_FOR_REMOVAL;
             }
         }
 
-        auto b = dirs_touched.rbegin();
-        auto e = dirs_touched.rend();
-        for (; b != e; ++b)
-        {
-            if (fs::directory_iterator(*b) == fs::directory_iterator())
-            {
-                std::error_code ec;
-                fs::remove(*b, ec);
-                if (ec)
-                {
-                    System::println(System::color::error, "failed: %s", ec.message());
-                }
-            }
-        }
+        installed_files_of_current_pgh.erase(std::remove_if(installed_files_of_current_pgh.begin(), installed_files_of_current_pgh.end(), [](const std::string& file)
+                                                            {
+                                                                return file == MARK_FOR_REMOVAL;
+                                                            }),
+                                             installed_files_of_current_pgh.end());
 
-        listfile.close();
-        fs::remove(paths.listfile_path(pkg.package));
+        const StatusParagraph_and_associated_files pgh_and_files = {*pgh, std::move(installed_files_of_current_pgh)};
+        installed_files.push_back(pgh_and_files);
     }
 
-    pkg.state = install_state_t::not_installed;
-    write_update(paths, pkg);
-    System::println(System::color::success, "Package %s was successfully removed", pkg.package.displayname());
+    return installed_files;
 }
 
 expected<SourceParagraph> vcpkg::try_load_port(const fs::path& path)