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

12 files changed, 388 insertions, 372 deletions

diff --git a/toolsrc/src/BuildInfo.cpp b/toolsrc/src/BuildInfo.cpp
index 44c7fdcf0..ddd44a1e6 100644
--- a/toolsrc/src/BuildInfo.cpp
+++ b/toolsrc/src/BuildInfo.cpp
@@ -2,7 +2,7 @@
 #include "vcpkg_Checks.h"
 #include "vcpkglib_helpers.h"
 
-namespace vcpkg
+namespace vcpkg { namespace PostBuildLint
 {
     const ConfigurationType& BuildType::config() const
     {
@@ -127,7 +127,7 @@ namespace vcpkg
     BuildInfo read_build_info(const fs::path& filepath)
     {
         const std::vector<std::unordered_map<std::string, std::string>> pghs = Paragraphs::get_paragraphs(filepath);
-        Checks::check_throw(pghs.size() == 1, "Invalid BUILD_INFO file for package");
+        Checks::check_exit(pghs.size() == 1, "Invalid BUILD_INFO file for package");
 
         return BuildInfo::create(pghs[0]);
     }
@@ -161,4 +161,4 @@ namespace vcpkg
     {
         return this->m_dll_name;
     }
-}
+}}
diff --git a/toolsrc/src/commands_hash.cpp b/toolsrc/src/commands_hash.cpp
index 4b89f2894..17c191b78 100644
--- a/toolsrc/src/commands_hash.cpp
+++ b/toolsrc/src/commands_hash.cpp
@@ -1,8 +1,6 @@
 #include "vcpkg_Commands.h"
 #include "vcpkg_System.h"
 
-namespace fs = std::tr2::sys;
-
 namespace vcpkg
 {
     static void do_file_hash(fs::path const& path, std::wstring const& hashType)
diff --git a/toolsrc/src/commands_installation.cpp b/toolsrc/src/commands_installation.cpp
index f7af2ef7c..23342070d 100644
--- a/toolsrc/src/commands_installation.cpp
+++ b/toolsrc/src/commands_installation.cpp
@@ -59,7 +59,7 @@ namespace vcpkg
             exit(EXIT_FAILURE);
         }
 
-        perform_all_checks(spec, paths);
+        PostBuildLint::perform_all_checks(spec, paths);
 
         create_binary_control_file(paths, source_paragraph, target_triplet);
 
@@ -67,6 +67,138 @@ 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 std::map<std::string, fs::path> remove_first_n_chars_and_map(const std::vector<fs::path> absolute_paths, const size_t n)
+    {
+        std::map<std::string, fs::path> output;
+
+        for (const fs::path& absolute_path : absolute_paths)
+        {
+            std::string suffix = absolute_path.generic_string();
+            suffix.erase(0, n);
+            output.emplace(suffix, absolute_path);
+        }
+
+        return output;
+    }
+
+    static void print_map_values(const std::vector<std::string> keys, const std::map<std::string, fs::path>& map)
+    {
+        System::println("");
+        for (const std::string& key : keys)
+        {
+            System::println("    %s", map.at(key).generic_string());
+        }
+        System::println("");
+    }
+
+    static 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_files = Files::recursive_find_all_files_in_dir(package_dir);
+
+        const fs::path installed_dir = paths.installed / binary_paragraph.spec.target_triplet().canonical_name();
+        const std::vector<fs::path> installed_files = Files::recursive_find_all_files_in_dir(installed_dir);
+
+        const std::map<std::string, fs::path> package_files_relative_paths_to_absolute_paths = remove_first_n_chars_and_map(package_files, package_dir.generic_string().size() + 1);
+        const std::map<std::string, fs::path> installed_files_relative_paths_to_absolute_paths = remove_first_n_chars_and_map(installed_files, installed_dir.generic_string().size() + 1);
+
+        const std::vector<std::string> package_files_set = Maps::extract_keys(package_files_relative_paths_to_absolute_paths);
+        const std::vector<std::string> installed_files_set = Maps::extract_keys(installed_files_relative_paths_to_absolute_paths);
+
+        std::vector<std::string> intersection;
+        std::set_intersection(package_files_set.cbegin(), package_files_set.cend(),
+                              installed_files_set.cbegin(), installed_files_set.cend(),
+                              std::back_inserter(intersection));
+
+        if (!intersection.empty())
+        {
+            System::println(System::color::error, "The following files are already installed and are in conflict with %s:", binary_paragraph.spec);
+            print_map_values(intersection, installed_files_relative_paths_to_absolute_paths);
+            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");
@@ -140,7 +272,7 @@ namespace vcpkg
         const std::unordered_set<std::string> options = args.check_and_get_optional_command_arguments({OPTION_CHECKS_ONLY});
         if (options.find(OPTION_CHECKS_ONLY) != options.end())
         {
-            perform_all_checks(spec, paths);
+            PostBuildLint::perform_all_checks(spec, paths);
             exit(EXIT_SUCCESS);
         }
 
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/commands_search.cpp b/toolsrc/src/commands_search.cpp
index 923368252..a604c5383 100644
--- a/toolsrc/src/commands_search.cpp
+++ b/toolsrc/src/commands_search.cpp
@@ -4,8 +4,6 @@
 #include "vcpkglib_helpers.h"
 #include "SourceParagraph.h"
 
-namespace fs = std::tr2::sys;
-
 namespace vcpkg
 {
     static std::vector<SourceParagraph> read_all_source_paragraphs(const vcpkg_paths& paths)
diff --git a/toolsrc/src/metrics.cpp b/toolsrc/src/metrics.cpp
index ada065fd6..23962bcfe 100644
--- a/toolsrc/src/metrics.cpp
+++ b/toolsrc/src/metrics.cpp
@@ -10,12 +10,10 @@
 #include <Windows.h>
 #include <winhttp.h>
 #include <fstream>
-#include <filesystem>
+#include "filesystem_fs.h"
 #include "vcpkg_Strings.h"
 #include "vcpkg_System.h"
 
-namespace fs = std::tr2::sys;
-
 namespace vcpkg
 {
     static std::string GetCurrentDateTime()
diff --git a/toolsrc/src/post_build_lint.cpp b/toolsrc/src/post_build_lint.cpp
index d358cca45..3043bd4fa 100644
--- a/toolsrc/src/post_build_lint.cpp
+++ b/toolsrc/src/post_build_lint.cpp
@@ -1,16 +1,13 @@
-#include <filesystem>
 #include "vcpkg_paths.h"
 #include "package_spec.h"
-#include <iterator>
+#include "vcpkg_Files.h"
 #include <functional>
 #include "vcpkg_System.h"
 #include "coff_file_reader.h"
 #include "BuildInfo.h"
 #include <regex>
 
-namespace fs = std::tr2::sys;
-
-namespace vcpkg
+namespace vcpkg { namespace PostBuildLint
 {
     enum class lint_status
     {
@@ -20,54 +17,6 @@ namespace vcpkg
 
     static const fs::path DUMPBIN_EXE = R"(%VS140COMNTOOLS%\..\..\VC\bin\dumpbin.exe)";
 
-    namespace
-    {
-        void print_vector_of_files(const std::vector<fs::path>& paths)
-        {
-            System::println("");
-            for (const fs::path& p : paths)
-            {
-                System::println("    %s", p.generic_string());
-            }
-            System::println("");
-        }
-
-        template <class Pred>
-        void non_recursive_find_matching_paths_in_dir(const fs::path& dir, const Pred predicate, std::vector<fs::path>* output)
-        {
-            std::copy_if(fs::directory_iterator(dir), fs::directory_iterator(), std::back_inserter(*output), predicate);
-        }
-
-        template <class Pred>
-        void recursive_find_matching_paths_in_dir(const fs::path& dir, const Pred predicate, std::vector<fs::path>* output)
-        {
-            std::copy_if(fs::recursive_directory_iterator(dir), fs::recursive_directory_iterator(), std::back_inserter(*output), predicate);
-        }
-
-        template <class Pred>
-        std::vector<fs::path> recursive_find_matching_paths_in_dir(const fs::path& dir, const Pred predicate)
-        {
-            std::vector<fs::path> v;
-            recursive_find_matching_paths_in_dir(dir, predicate, &v);
-            return v;
-        }
-
-        void recursive_find_files_with_extension_in_dir(const fs::path& dir, const std::string& extension, std::vector<fs::path>* output)
-        {
-            recursive_find_matching_paths_in_dir(dir, [&extension](const fs::path& current)
-                                                 {
-                                                     return !fs::is_directory(current) && current.extension() == extension;
-                                                 }, output);
-        }
-
-        std::vector<fs::path> recursive_find_files_with_extension_in_dir(const fs::path& dir, const std::string& extension)
-        {
-            std::vector<fs::path> v;
-            recursive_find_files_with_extension_in_dir(dir, extension, &v);
-            return v;
-        }
-    }
-
     static lint_status check_for_files_in_include_directory(const fs::path& package_dir)
     {
         const fs::path include_dir = package_dir / "include";
@@ -85,10 +34,10 @@ namespace vcpkg
         const fs::path debug_include_dir = package_dir / "debug" / "include";
         std::vector<fs::path> files_found;
 
-        recursive_find_matching_paths_in_dir(debug_include_dir, [&](const fs::path& current)
-                                             {
-                                                 return !fs::is_directory(current) && current.extension() != ".ifc";
-                                             }, &files_found);
+        Files::recursive_find_matching_paths_in_dir(debug_include_dir, [&](const fs::path& current)
+                                                    {
+                                                        return !fs::is_directory(current) && current.extension() != ".ifc";
+                                                    }, &files_found);
 
         if (!files_found.empty())
         {
@@ -129,15 +78,15 @@ namespace vcpkg
     static lint_status check_for_misplaced_cmake_files(const fs::path& package_dir, const package_spec& spec)
     {
         std::vector<fs::path> misplaced_cmake_files;
-        recursive_find_files_with_extension_in_dir(package_dir / "cmake", ".cmake", &misplaced_cmake_files);
-        recursive_find_files_with_extension_in_dir(package_dir / "debug" / "cmake", ".cmake", &misplaced_cmake_files);
-        recursive_find_files_with_extension_in_dir(package_dir / "lib" / "cmake", ".cmake", &misplaced_cmake_files);
-        recursive_find_files_with_extension_in_dir(package_dir / "debug" / "lib" / "cmake", ".cmake", &misplaced_cmake_files);
+        Files::recursive_find_files_with_extension_in_dir(package_dir / "cmake", ".cmake", &misplaced_cmake_files);
+        Files::recursive_find_files_with_extension_in_dir(package_dir / "debug" / "cmake", ".cmake", &misplaced_cmake_files);
+        Files::recursive_find_files_with_extension_in_dir(package_dir / "lib" / "cmake", ".cmake", &misplaced_cmake_files);
+        Files::recursive_find_files_with_extension_in_dir(package_dir / "debug" / "lib" / "cmake", ".cmake", &misplaced_cmake_files);
 
         if (!misplaced_cmake_files.empty())
         {
             System::println(System::color::warning, "The following cmake files were found outside /share/%s. Please place cmake files in /share/%s.", spec.name(), spec.name());
-            print_vector_of_files(misplaced_cmake_files);
+            Files::print_paths(misplaced_cmake_files);
             return lint_status::ERROR_DETECTED;
         }
 
@@ -159,13 +108,13 @@ namespace vcpkg
     static lint_status check_for_dlls_in_lib_dirs(const fs::path& package_dir)
     {
         std::vector<fs::path> dlls;
-        recursive_find_files_with_extension_in_dir(package_dir / "lib", ".dll", &dlls);
-        recursive_find_files_with_extension_in_dir(package_dir / "debug" / "lib", ".dll", &dlls);
+        Files::recursive_find_files_with_extension_in_dir(package_dir / "lib", ".dll", &dlls);
+        Files::recursive_find_files_with_extension_in_dir(package_dir / "debug" / "lib", ".dll", &dlls);
 
         if (!dlls.empty())
         {
             System::println(System::color::warning, "\nThe following dlls were found in /lib and /debug/lib. Please move them to /bin or /debug/bin, respectively.");
-            print_vector_of_files(dlls);
+            Files::print_paths(dlls);
             return lint_status::ERROR_DETECTED;
         }
 
@@ -213,7 +162,7 @@ namespace vcpkg
         if (potential_copyright_files.size() > 1)
         {
             System::println(System::color::warning, "The following files are potential copyright files:");
-            print_vector_of_files(potential_copyright_files);
+            Files::print_paths(potential_copyright_files);
         }
 
         System::println("    %s/share/%s/copyright", packages_dir.generic_string(), spec.name());
@@ -223,13 +172,13 @@ namespace vcpkg
     static lint_status check_for_exes(const fs::path& package_dir)
     {
         std::vector<fs::path> exes;
-        recursive_find_files_with_extension_in_dir(package_dir / "bin", ".exe", &exes);
-        recursive_find_files_with_extension_in_dir(package_dir / "debug" / "bin", ".exe", &exes);
+        Files::recursive_find_files_with_extension_in_dir(package_dir / "bin", ".exe", &exes);
+        Files::recursive_find_files_with_extension_in_dir(package_dir / "debug" / "bin", ".exe", &exes);
 
         if (!exes.empty())
         {
             System::println(System::color::warning, "The following EXEs were found in /bin and /debug/bin. EXEs are not valid distribution targets.");
-            print_vector_of_files(exes);
+            Files::print_paths(exes);
             return lint_status::ERROR_DETECTED;
         }
 
@@ -254,7 +203,7 @@ namespace vcpkg
         if (!dlls_with_no_exports.empty())
         {
             System::println(System::color::warning, "The following DLLs have no exports:");
-            print_vector_of_files(dlls_with_no_exports);
+            Files::print_paths(dlls_with_no_exports);
             System::println(System::color::warning, "DLLs without any exports are likely a bug in the build script.");
             return lint_status::ERROR_DETECTED;
         }
@@ -285,7 +234,7 @@ namespace vcpkg
         if (!dlls_with_improper_uwp_bit.empty())
         {
             System::println(System::color::warning, "The following DLLs do not have the App Container bit set:");
-            print_vector_of_files(dlls_with_improper_uwp_bit);
+            Files::print_paths(dlls_with_improper_uwp_bit);
             System::println(System::color::warning, "This bit is required for Windows Store apps.");
             return lint_status::ERROR_DETECTED;
         }
@@ -387,7 +336,7 @@ namespace vcpkg
         }
 
         System::println(System::color::warning, "DLLs should not be present in a static build, but the following DLLs were found:");
-        print_vector_of_files(dlls);
+        Files::print_paths(dlls);
         return lint_status::ERROR_DETECTED;
     }
 
@@ -402,10 +351,10 @@ namespace vcpkg
 
         System::println(System::color::warning, "Mismatching number of debug and release binaries. Found %d for debug but %d for release.", debug_count, release_count);
         System::println("Debug binaries");
-        print_vector_of_files(debug_binaries);
+        Files::print_paths(debug_binaries);
 
         System::println("Release binaries");
-        print_vector_of_files(release_binaries);
+        Files::print_paths(release_binaries);
 
         if (debug_count == 0)
         {
@@ -434,16 +383,16 @@ namespace vcpkg
 
     static lint_status check_no_subdirectories(const fs::path& dir)
     {
-        const std::vector<fs::path> subdirectories = recursive_find_matching_paths_in_dir(dir, [&](const fs::path& current)
-                                                                                          {
-                                                                                              return fs::is_directory(current);
-                                                                                          });
+        const std::vector<fs::path> subdirectories = Files::recursive_find_matching_paths_in_dir(dir, [&](const fs::path& current)
+                                                                                                 {
+                                                                                                     return fs::is_directory(current);
+                                                                                                 });
 
         if (!subdirectories.empty())
         {
             System::println(System::color::warning, "Directory %s should have no subdirectories", dir.generic_string());
             System::println("The following subdirectories were found: ");
-            print_vector_of_files(subdirectories);
+            Files::print_paths(subdirectories);
             return lint_status::ERROR_DETECTED;
         }
 
@@ -483,16 +432,16 @@ namespace vcpkg
 
     static lint_status check_no_empty_folders(const fs::path& dir)
     {
-        const std::vector<fs::path> empty_directories = recursive_find_matching_paths_in_dir(dir, [](const fs::path& current)
-                                                                                             {
-                                                                                                 return fs::is_directory(current) && fs::is_empty(current);
-                                                                                             });
+        const std::vector<fs::path> empty_directories = Files::recursive_find_matching_paths_in_dir(dir, [](const fs::path& current)
+                                                                                                    {
+                                                                                                        return fs::is_directory(current) && fs::is_empty(current);
+                                                                                                    });
 
         if (!empty_directories.empty())
         {
             System::println(System::color::warning, "There should be no empty directories in %s", dir.generic_string());
             System::println("The following empty directories were found: ");
-            print_vector_of_files(empty_directories);
+            Files::print_paths(empty_directories);
             System::println(System::color::warning, "If a directory should be populated but is not, this might indicate an error in the portfile.\n"
                             "If the directories are not needed and their creation cannot be disabled, use something like this in the portfile to remove them)\n"
                             "\n"
@@ -599,22 +548,19 @@ namespace vcpkg
     {
         std::vector<fs::path> misplaced_files;
 
-        non_recursive_find_matching_paths_in_dir(package_dir, [](const fs::path& current)
-                                                 {
-                                                     const std::string filename = current.filename().generic_string();
-                                                     return !fs::is_directory(current) && !((_stricmp(filename.c_str(), "CONTROL") == 0 || _stricmp(filename.c_str(), "BUILD_INFO") == 0));
-                                                 }, &misplaced_files);
+        Files::non_recursive_find_matching_paths_in_dir(package_dir, [](const fs::path& current)
+                                                        {
+                                                            const std::string filename = current.filename().generic_string();
+                                                            return !fs::is_directory(current) && !((_stricmp(filename.c_str(), "CONTROL") == 0 || _stricmp(filename.c_str(), "BUILD_INFO") == 0));
+                                                        }, &misplaced_files);
 
         const fs::path debug_dir = package_dir / "debug";
-        non_recursive_find_matching_paths_in_dir(debug_dir, [](const fs::path& current)
-                                                 {
-                                                     return !fs::is_directory(current);
-                                                 }, &misplaced_files);
+        Files::non_recursive_find_all_files_in_dir(debug_dir, &misplaced_files);
 
         if (!misplaced_files.empty())
         {
             System::println(System::color::warning, "The following files are placed in\n%s and\n%s: ", package_dir.generic_string(), debug_dir.generic_string());
-            print_vector_of_files(misplaced_files);
+            Files::print_paths(misplaced_files);
             System::println(System::color::warning, "Files cannot be present in those directories.\n");
             return lint_status::ERROR_DETECTED;
         }
@@ -645,14 +591,13 @@ namespace vcpkg
         error_count += check_for_copyright_file(spec, paths);
         error_count += check_for_exes(package_dir);
 
-        
         const fs::path debug_lib_dir = package_dir / "debug" / "lib";
         const fs::path release_lib_dir = package_dir / "lib";
         const fs::path debug_bin_dir = package_dir / "debug" / "bin";
         const fs::path release_bin_dir = package_dir / "bin";
 
-        const std::vector<fs::path> debug_libs = recursive_find_files_with_extension_in_dir(debug_lib_dir, ".lib");
-        const std::vector<fs::path> release_libs = recursive_find_files_with_extension_in_dir(release_lib_dir, ".lib");
+        const std::vector<fs::path> debug_libs = Files::recursive_find_files_with_extension_in_dir(debug_lib_dir, ".lib");
+        const std::vector<fs::path> release_libs = Files::recursive_find_files_with_extension_in_dir(release_lib_dir, ".lib");
 
         error_count += check_matching_debug_and_release_binaries(debug_libs, release_libs);
 
@@ -666,8 +611,8 @@ namespace vcpkg
         {
             case LinkageType::DYNAMIC:
                 {
-                    const std::vector<fs::path> debug_dlls = recursive_find_files_with_extension_in_dir(debug_bin_dir, ".dll");
-                    const std::vector<fs::path> release_dlls = recursive_find_files_with_extension_in_dir(release_bin_dir, ".dll");
+                    const std::vector<fs::path> debug_dlls = Files::recursive_find_files_with_extension_in_dir(debug_bin_dir, ".dll");
+                    const std::vector<fs::path> release_dlls = Files::recursive_find_files_with_extension_in_dir(release_bin_dir, ".dll");
 
                     error_count += check_matching_debug_and_release_binaries(debug_dlls, release_dlls);
 
@@ -688,7 +633,7 @@ namespace vcpkg
             case LinkageType::STATIC:
                 {
                     std::vector<fs::path> dlls;
-                    recursive_find_files_with_extension_in_dir(package_dir, ".dll", &dlls);
+                    Files::recursive_find_files_with_extension_in_dir(package_dir, ".dll", &dlls);
                     error_count += check_no_dlls_present(dlls);
 
                     error_count += check_bin_folders_are_not_present_in_static_build(package_dir);
@@ -707,8 +652,8 @@ namespace vcpkg
                 Checks::unreachable();
         }
 #if 0
-        error_count += check_no_subdirectories(package_dir / "lib");
-        error_count += check_no_subdirectories(package_dir / "debug" / "lib");
+            error_count += check_no_subdirectories(package_dir / "lib");
+            error_count += check_no_subdirectories(package_dir / "debug" / "lib");
 #endif
 
         error_count += check_no_empty_folders(package_dir);
@@ -723,4 +668,4 @@ namespace vcpkg
 
         System::println("-- Performing post-build validation done");
     }
-}
+}}
diff --git a/toolsrc/src/vcpkg.cpp b/toolsrc/src/vcpkg.cpp
index b1fe76982..6c5224f56 100644
--- a/toolsrc/src/vcpkg.cpp
+++ b/toolsrc/src/vcpkg.cpp
@@ -6,26 +6,13 @@
 #include <string>
 #include <unordered_map>
 #include <memory>
-#include <filesystem>
 #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))
@@ -110,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++;
@@ -129,234 +109,6 @@ 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::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();
-}
-
-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());
-        }
-    }
-
-    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;
-    }
-
-    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());
-}
-
 expected<SourceParagraph> vcpkg::try_load_port(const fs::path& path)
 {
     try
diff --git a/toolsrc/src/vcpkg_Files.cpp b/toolsrc/src/vcpkg_Files.cpp
index 611aa7450..698579736 100644
--- a/toolsrc/src/vcpkg_Files.cpp
+++ b/toolsrc/src/vcpkg_Files.cpp
@@ -1,9 +1,7 @@
 #include "vcpkg_Files.h"
 #include <fstream>
-#include <filesystem>
 #include <regex>
-
-namespace fs = std::tr2::sys;
+#include "vcpkg_System.h"
 
 namespace vcpkg {namespace Files
 {
@@ -58,4 +56,59 @@ namespace vcpkg {namespace Files
 
         return current_dir;
     }
+
+    void recursive_find_files_with_extension_in_dir(const fs::path& dir, const std::string& extension, std::vector<fs::path>* output)
+    {
+        recursive_find_matching_paths_in_dir(dir, [&extension](const fs::path& current)
+                                             {
+                                                 return !fs::is_directory(current) && current.extension() == extension;
+                                             }, output);
+    }
+
+    std::vector<fs::path> recursive_find_files_with_extension_in_dir(const fs::path& dir, const std::string& extension)
+    {
+        std::vector<fs::path> v;
+        recursive_find_files_with_extension_in_dir(dir, extension, &v);
+        return v;
+    }
+
+    void recursive_find_all_files_in_dir(const fs::path& dir, std::vector<fs::path>* output)
+    {
+        recursive_find_matching_paths_in_dir(dir, [&](const fs::path& current)
+                                             {
+                                                 return !fs::is_directory(current);
+                                             }, output);
+    }
+
+    std::vector<fs::path> recursive_find_all_files_in_dir(const fs::path& dir)
+    {
+        std::vector<fs::path> v;
+        recursive_find_all_files_in_dir(dir, &v);
+        return v;
+    }
+
+    void non_recursive_find_all_files_in_dir(const fs::path& dir, std::vector<fs::path>* output)
+    {
+        non_recursive_find_matching_paths_in_dir(dir, [&](const fs::path& current)
+                                                 {
+                                                     return !fs::is_directory(current);
+                                                 }, output);
+    }
+
+    std::vector<fs::path> non_recursive_find_all_files_in_dir(const fs::path& dir)
+    {
+        std::vector<fs::path> v;
+        non_recursive_find_all_files_in_dir(dir, &v);
+        return v;
+    }
+
+    void print_paths(const std::vector<fs::path>& paths)
+    {
+        System::println("");
+        for (const fs::path& p : paths)
+        {
+            System::println("    %s", p.generic_string());
+        }
+        System::println("");
+    }
 }}
diff --git a/toolsrc/src/vcpkg_System.cpp b/toolsrc/src/vcpkg_System.cpp
index cc7080069..cb3eb6584 100644
--- a/toolsrc/src/vcpkg_System.cpp
+++ b/toolsrc/src/vcpkg_System.cpp
@@ -3,8 +3,6 @@
 #include <Windows.h>
 #include <regex>
 
-namespace fs = std::tr2::sys;
-
 namespace vcpkg {namespace System
 {
     fs::path get_exe_path_of_current_process()
diff --git a/toolsrc/src/vcpkg_metrics_uploader.cpp b/toolsrc/src/vcpkg_metrics_uploader.cpp
index f1f4a52ed..63668d1d7 100644
--- a/toolsrc/src/vcpkg_metrics_uploader.cpp
+++ b/toolsrc/src/vcpkg_metrics_uploader.cpp
@@ -1,10 +1,8 @@
 #include "metrics.h"
-#include <filesystem>
 #include "vcpkg_Checks.h"
 #include "vcpkg_Files.h"
 #include <Windows.h>
 
-namespace fs = std::tr2::sys;
 using namespace vcpkg;
 
 int WINAPI
diff --git a/toolsrc/src/vcpkg_paths.cpp b/toolsrc/src/vcpkg_paths.cpp
index 5347b79d8..b7e716307 100644
--- a/toolsrc/src/vcpkg_paths.cpp
+++ b/toolsrc/src/vcpkg_paths.cpp
@@ -1,4 +1,3 @@
-#include <filesystem>
 #include "expected.h"
 #include "vcpkg_paths.h"
 #include "metrics.h"