Merge remote-tracking branch 'refs/remotes/origin/master'

5 files changed, 177 insertions, 29 deletions

diff --git a/toolsrc/src/commands_build.cpp b/toolsrc/src/commands_build.cpp
index 72ebb264b..e7e005100 100644
--- a/toolsrc/src/commands_build.cpp
+++ b/toolsrc/src/commands_build.cpp
@@ -30,10 +30,13 @@ namespace vcpkg::Commands::Build
         const triplet& target_triplet = spec.target_triplet();
 
         const fs::path ports_cmake_script_path = paths.ports_cmake;
-        const std::wstring command = Strings::wformat(LR"("%%VS140COMNTOOLS%%..\..\VC\vcvarsall.bat" %s && cmake -DCMD=BUILD -DPORT=%s -DTARGET_TRIPLET=%s "-DCURRENT_PORT_DIR=%s/." -P "%s")",
+        const Environment::vcvarsall_and_platform_toolset vcvarsall_bat = Environment::get_vcvarsall_bat(paths);
+        const std::wstring command = Strings::wformat(LR"("%s" %s >nul 2>&1 && cmake -DCMD=BUILD -DPORT=%s -DTARGET_TRIPLET=%s -DVCPKG_PLATFORM_TOOLSET=%s "-DCURRENT_PORT_DIR=%s/." -P "%s")",
+                                                      vcvarsall_bat.path.native(),
                                                       Strings::utf8_to_utf16(target_triplet.architecture()),
                                                       Strings::utf8_to_utf16(source_paragraph.name),
                                                       Strings::utf8_to_utf16(target_triplet.canonical_name()),
+                                                      vcvarsall_bat.platform_toolset,
                                                       port_dir.generic_wstring(),
                                                       ports_cmake_script_path.generic_wstring());
 
diff --git a/toolsrc/src/post_build_lint.cpp b/toolsrc/src/post_build_lint.cpp
index 1fca3a2f6..af76b7963 100644
--- a/toolsrc/src/post_build_lint.cpp
+++ b/toolsrc/src/post_build_lint.cpp
@@ -3,6 +3,7 @@
 #include "vcpkg_Files.h"
 #include <functional>
 #include "vcpkg_System.h"
+#include "vcpkg_Environment.h"
 #include "coff_file_reader.h"
 #include "BuildInfo.h"
 #include <regex>
@@ -15,8 +16,6 @@ namespace vcpkg::PostBuildLint
         ERROR_DETECTED = 1
     };
 
-    static const fs::path DUMPBIN_EXE = R"(%VS140COMNTOOLS%\..\..\VC\bin\dumpbin.exe)";
-
     static lint_status check_for_files_in_include_directory(const fs::path& package_dir)
     {
         const fs::path include_dir = package_dir / "include";
@@ -185,12 +184,12 @@ namespace vcpkg::PostBuildLint
         return lint_status::SUCCESS;
     }
 
-    static lint_status check_exports_of_dlls(const std::vector<fs::path>& dlls)
+    static lint_status check_exports_of_dlls(const std::vector<fs::path>& dlls, const fs::path& dumpbin_exe)
     {
         std::vector<fs::path> dlls_with_no_exports;
         for (const fs::path& dll : dlls)
         {
-            const std::wstring cmd_line = Strings::wformat(LR"("%s" /exports "%s")", DUMPBIN_EXE.native(), dll.native());
+            const std::wstring cmd_line = Strings::wformat(LR"("%s" /exports "%s")", dumpbin_exe.native(), dll.native());
             System::exit_code_and_output ec_data = System::cmd_execute_and_capture_output(cmd_line);
             Checks::check_exit(ec_data.exit_code == 0, "Running command:\n   %s\n failed", Strings::utf16_to_utf8(cmd_line));
 
@@ -211,7 +210,7 @@ namespace vcpkg::PostBuildLint
         return lint_status::SUCCESS;
     }
 
-    static lint_status check_uwp_bit_of_dlls(const std::string& expected_system_name, const std::vector<fs::path>& dlls)
+    static lint_status check_uwp_bit_of_dlls(const std::string& expected_system_name, const std::vector<fs::path>& dlls, const fs::path dumpbin_exe)
     {
         if (expected_system_name != "uwp")
         {
@@ -221,7 +220,7 @@ namespace vcpkg::PostBuildLint
         std::vector<fs::path> dlls_with_improper_uwp_bit;
         for (const fs::path& dll : dlls)
         {
-            const std::wstring cmd_line = Strings::wformat(LR"("%s" /headers "%s")", DUMPBIN_EXE.native(), dll.native());
+            const std::wstring cmd_line = Strings::wformat(LR"("%s" /headers "%s")", dumpbin_exe.native(), dll.native());
             System::exit_code_and_output ec_data = System::cmd_execute_and_capture_output(cmd_line);
             Checks::check_exit(ec_data.exit_code == 0, "Running command:\n   %s\n failed", Strings::utf16_to_utf8(cmd_line));
 
@@ -459,7 +458,7 @@ namespace vcpkg::PostBuildLint
         BuildType build_type;
     };
 
-    static lint_status check_crt_linkage_of_libs(const BuildType& expected_build_type, const std::vector<fs::path>& libs)
+    static lint_status check_crt_linkage_of_libs(const BuildType& expected_build_type, const std::vector<fs::path>& libs, const fs::path dumpbin_exe)
     {
         std::vector<BuildType> bad_build_types = BuildType::values();
         bad_build_types.erase(std::remove(bad_build_types.begin(), bad_build_types.end(), expected_build_type), bad_build_types.end());
@@ -468,7 +467,7 @@ namespace vcpkg::PostBuildLint
 
         for (const fs::path& lib : libs)
         {
-            const std::wstring cmd_line = Strings::wformat(LR"("%s" /directives "%s")", DUMPBIN_EXE.native(), lib.native());
+            const std::wstring cmd_line = Strings::wformat(LR"("%s" /directives "%s")", dumpbin_exe.native(), lib.native());
             System::exit_code_and_output ec_data = System::cmd_execute_and_capture_output(cmd_line);
             Checks::check_exit(ec_data.exit_code == 0, "Running command:\n   %s\n failed", Strings::utf16_to_utf8(cmd_line));
 
@@ -505,7 +504,7 @@ namespace vcpkg::PostBuildLint
         OutdatedDynamicCrt outdated_crt;
     };
 
-    static lint_status check_outdated_crt_linkage_of_dlls(const std::vector<fs::path>& dlls)
+    static lint_status check_outdated_crt_linkage_of_dlls(const std::vector<fs::path>& dlls, const fs::path dumpbin_exe)
     {
         const std::vector<OutdatedDynamicCrt>& outdated_crts = OutdatedDynamicCrt::values();
 
@@ -513,7 +512,7 @@ namespace vcpkg::PostBuildLint
 
         for (const fs::path& dll : dlls)
         {
-            const std::wstring cmd_line = Strings::wformat(LR"("%s" /dependents "%s")", DUMPBIN_EXE.native(), dll.native());
+            const std::wstring cmd_line = Strings::wformat(LR"("%s" /dependents "%s")", dumpbin_exe.native(), dll.native());
             System::exit_code_and_output ec_data = System::cmd_execute_and_capture_output(cmd_line);
             Checks::check_exit(ec_data.exit_code == 0, "Running command:\n   %s\n failed", Strings::utf16_to_utf8(cmd_line));
 
@@ -575,6 +574,8 @@ namespace vcpkg::PostBuildLint
 
     void perform_all_checks(const package_spec& spec, const vcpkg_paths& paths)
     {
+        const fs::path dumpbin_exe = Environment::get_dumpbin_exe(paths);
+
         System::println("-- Performing post-build validation");
 
         BuildInfo build_info = read_build_info(paths.build_info_file_path(spec));
@@ -623,11 +624,11 @@ namespace vcpkg::PostBuildLint
                     dlls.insert(dlls.cend(), debug_dlls.cbegin(), debug_dlls.cend());
                     dlls.insert(dlls.cend(), release_dlls.cbegin(), release_dlls.cend());
 
-                    error_count += check_exports_of_dlls(dlls);
-                    error_count += check_uwp_bit_of_dlls(spec.target_triplet().system(), dlls);
+                    error_count += check_exports_of_dlls(dlls, dumpbin_exe);
+                    error_count += check_uwp_bit_of_dlls(spec.target_triplet().system(), dlls, dumpbin_exe);
                     error_count += check_dll_architecture(spec.target_triplet().architecture(), dlls);
 
-                    error_count += check_outdated_crt_linkage_of_dlls(dlls);
+                    error_count += check_outdated_crt_linkage_of_dlls(dlls, dumpbin_exe);
                     break;
                 }
             case LinkageType::STATIC:
@@ -638,8 +639,8 @@ namespace vcpkg::PostBuildLint
 
                     error_count += check_bin_folders_are_not_present_in_static_build(package_dir);
 
-                    error_count += check_crt_linkage_of_libs(BuildType::value_of(ConfigurationType::DEBUG, linkage_type_value_of(build_info.crt_linkage)), debug_libs);
-                    error_count += check_crt_linkage_of_libs(BuildType::value_of(ConfigurationType::RELEASE, linkage_type_value_of(build_info.crt_linkage)), release_libs);
+                    error_count += check_crt_linkage_of_libs(BuildType::value_of(ConfigurationType::DEBUG, linkage_type_value_of(build_info.crt_linkage)), debug_libs, dumpbin_exe);
+                    error_count += check_crt_linkage_of_libs(BuildType::value_of(ConfigurationType::RELEASE, linkage_type_value_of(build_info.crt_linkage)), release_libs, dumpbin_exe);
                     break;
                 }
             case LinkageType::UNKNOWN:
diff --git a/toolsrc/src/vcpkg_Environment.cpp b/toolsrc/src/vcpkg_Environment.cpp
index c7eec3bd0..66d33edeb 100644
--- a/toolsrc/src/vcpkg_Environment.cpp
+++ b/toolsrc/src/vcpkg_Environment.cpp
@@ -4,6 +4,8 @@
 #include "vcpkg_Commands.h"
 #include "metrics.h"
 #include "vcpkg_System.h"
+#include "vcpkg_Strings.h"
+#include "vcpkg_Files.h"
 
 namespace vcpkg::Environment
 {
@@ -12,7 +14,7 @@ namespace vcpkg::Environment
     static const fs::path default_git_installation_dir = "C:/Program Files/git/cmd";
     static const fs::path default_git_installation_dir_x86 = "C:/Program Files (x86)/git/cmd";
 
-    static void ensure_on_path(const std::array<int, 3>& version, const wchar_t* version_check_cmd, const wchar_t* install_cmd)
+    static void ensure_on_path(const std::array<int, 3>& version, const std::wstring& version_check_cmd, const std::wstring& install_cmd)
     {
         System::exit_code_and_output ec_data = System::cmd_execute_and_capture_output(version_check_cmd);
         if (ec_data.exit_code == 0)
@@ -44,6 +46,13 @@ namespace vcpkg::Environment
         }
     }
 
+    static std::wstring create_default_install_cmd(const vcpkg_paths& paths, const std::wstring& tool_name)
+    {
+        const fs::path script = paths.scripts / "fetchDependency.ps1";
+        // TODO: switch out ExecutionPolicy Bypass with "Remove Mark Of The Web" code and restore RemoteSigned
+        return Strings::wformat(L"powershell -ExecutionPolicy Bypass %s -Dependency %s", script.native(), tool_name);
+    }
+
     void ensure_git_on_path(const vcpkg_paths& paths)
     {
         const fs::path downloaded_git = paths.downloads / "PortableGit" / "cmd";
@@ -55,13 +64,14 @@ namespace vcpkg::Environment
         _wputenv_s(L"PATH", path_buf.c_str());
 
         static constexpr std::array<int, 3> git_version = {2,0,0};
-        // TODO: switch out ExecutionPolicy Bypass with "Remove Mark Of The Web" code and restore RemoteSigned
-        ensure_on_path(git_version, L"git --version 2>&1", L"powershell -ExecutionPolicy Bypass scripts\\fetchDependency.ps1 -Dependency git");
+        static const std::wstring version_check_cmd = L"git --version 2>&1";
+        const std::wstring install_cmd = create_default_install_cmd(paths, L"git");
+        ensure_on_path(git_version, version_check_cmd, install_cmd);
     }
 
     void ensure_cmake_on_path(const vcpkg_paths& paths)
     {
-        const fs::path downloaded_cmake = paths.downloads / "cmake-3.5.2-win32-x86" / "bin";
+        const fs::path downloaded_cmake = paths.downloads / "cmake-3.7.2-win32-x86" / "bin";
         const std::wstring path_buf = Strings::wformat(L"%s;%s;%s;%s",
                                                        downloaded_cmake.native(),
                                                        System::wdupenv_str(L"PATH"),
@@ -69,18 +79,131 @@ namespace vcpkg::Environment
                                                        default_cmake_installation_dir_x86.native());
         _wputenv_s(L"PATH", path_buf.c_str());
 
-        static constexpr std::array<int, 3> cmake_version = {3,5,0};
-        // TODO: switch out ExecutionPolicy Bypass with "Remove Mark Of The Web" code and restore RemoteSigned
-        ensure_on_path(cmake_version, L"cmake --version 2>&1", L"powershell -ExecutionPolicy Bypass scripts\\fetchDependency.ps1 -Dependency cmake");
+        static constexpr std::array<int, 3> cmake_version = {3,7,2};
+        static const std::wstring version_check_cmd = L"cmake --version 2>&1";
+        const std::wstring install_cmd = create_default_install_cmd(paths, L"cmake");
+        ensure_on_path(cmake_version, version_check_cmd, install_cmd);
     }
 
     void ensure_nuget_on_path(const vcpkg_paths& paths)
     {
-        const std::wstring path_buf = Strings::wformat(L"%s;%s", paths.downloads.native(), System::wdupenv_str(L"PATH"));
+        const fs::path downloaded_nuget = paths.downloads / "nuget-3.5.0";
+        const std::wstring path_buf = Strings::wformat(L"%s;%s", downloaded_nuget.native(), System::wdupenv_str(L"PATH"));
         _wputenv_s(L"PATH", path_buf.c_str());
 
-        static constexpr std::array<int, 3> nuget_version = {1,0,0};
-        // TODO: switch out ExecutionPolicy Bypass with "Remove Mark Of The Web" code and restore RemoteSigned
-        ensure_on_path(nuget_version, L"nuget 2>&1", L"powershell -ExecutionPolicy Bypass scripts\\fetchDependency.ps1 -Dependency nuget");
+        static constexpr std::array<int, 3> nuget_version = {3,3,0};
+        static const std::wstring version_check_cmd = L"nuget 2>&1";
+        const std::wstring install_cmd = create_default_install_cmd(paths, L"nuget");
+        ensure_on_path(nuget_version, version_check_cmd, install_cmd);
+    }
+
+    static std::vector<std::string> get_VS2017_installation_instances(const vcpkg_paths& paths)
+    {
+        const fs::path script = paths.scripts / "findVisualStudioInstallationInstances.ps1";
+        const std::wstring cmd = Strings::wformat(L"powershell -ExecutionPolicy Bypass %s", script.native());
+        System::exit_code_and_output ec_data = System::cmd_execute_and_capture_output(cmd);
+        Checks::check_exit(ec_data.exit_code == 0, "Could not run script to detect VS 2017 instances");
+        return Strings::split(ec_data.output, "\n");
+    }
+
+    static const fs::path& get_VS2015_installation_instance()
+    {
+        static const fs::path vs2015_cmntools = fs::path(System::wdupenv_str(L"VS140COMNTOOLS")).parent_path(); // The call to parent_path() is needed because the env variable has a trailing backslash
+        static const fs::path vs2015_path = vs2015_cmntools.parent_path().parent_path();
+        return vs2015_path;
+    }
+
+    static fs::path find_dumpbin_exe(const vcpkg_paths& paths)
+    {
+        const std::vector<std::string> vs2017_installation_instances = get_VS2017_installation_instances(paths);
+        std::vector<fs::path> paths_examined;
+
+        // VS2017
+        for (const std::string& instance : vs2017_installation_instances)
+        {
+            const fs::path msvc_path = Strings::format(R"(%s\VC\Tools\MSVC)", instance);
+            std::vector<fs::path> msvc_subdirectories;
+            Files::non_recursive_find_matching_paths_in_dir(msvc_path, [&](const fs::path& current)
+                                                            {
+                                                                return fs::is_directory(current);
+                                                            }, &msvc_subdirectories);
+
+            // Sort them so that latest comes first
+            std::sort(msvc_subdirectories.begin(), msvc_subdirectories.end(), [&](const fs::path& left, const fs::path& right)
+                      {
+                          return left.filename() > right.filename();
+                      });
+
+            for (const fs::path& subdir : msvc_subdirectories)
+            {
+                const fs::path dumpbin_path = subdir / "bin" / "HostX86" / "x86" / "dumpbin.exe";
+                paths_examined.push_back(dumpbin_path);
+                if (fs::exists(dumpbin_path))
+                {
+                    return dumpbin_path;
+                }
+            }
+        }
+
+        // VS2015
+        const fs::path vs2015_dumpbin_exe = get_VS2015_installation_instance() / "VC" / "bin" / "dumpbin.exe";
+        paths_examined.push_back(vs2015_dumpbin_exe);
+        if (fs::exists(vs2015_dumpbin_exe))
+        {
+            return vs2015_dumpbin_exe;
+        }
+
+        System::println(System::color::error, "Could not detect dumpbin.exe.");
+        System::println("The following paths were examined:");
+        for (const fs::path& path : paths_examined)
+        {
+            System::println("    %s", path.generic_string());
+        }
+        exit(EXIT_FAILURE);
+    }
+
+    const fs::path& get_dumpbin_exe(const vcpkg_paths& paths)
+    {
+        static const fs::path dumpbin_exe = find_dumpbin_exe(paths);
+        return dumpbin_exe;
+    }
+
+    static vcvarsall_and_platform_toolset find_vcvarsall_bat(const vcpkg_paths& paths)
+    {
+        const std::vector<std::string> vs2017_installation_instances = get_VS2017_installation_instances(paths);
+        std::vector<fs::path> paths_examined;
+
+        // VS2017
+        for (const fs::path& instance : vs2017_installation_instances)
+        {
+            const fs::path vcvarsall_bat = instance / "VC" / "Auxiliary" / "Build" / "vcvarsall.bat";
+            paths_examined.push_back(vcvarsall_bat);
+            if (fs::exists(vcvarsall_bat))
+            {
+                return { vcvarsall_bat , L"v141"};
+            }
+        }
+
+        // VS2015
+        const fs::path vs2015_vcvarsall_bat = get_VS2015_installation_instance() / "VC" / "vcvarsall.bat";
+        paths_examined.push_back(vs2015_vcvarsall_bat);
+        if (fs::exists(vs2015_vcvarsall_bat))
+        {
+            return { vs2015_vcvarsall_bat, L"v140" };
+        }
+
+        System::println(System::color::error, "Could not detect vccarsall.bat.");
+        System::println("The following paths were examined:");
+        for (const fs::path& path : paths_examined)
+        {
+            System::println("    %s",path.generic_string());
+        }
+        exit(EXIT_FAILURE);
+    }
+
+    const vcvarsall_and_platform_toolset& get_vcvarsall_bat(const vcpkg_paths& paths)
+    {
+        static const vcvarsall_and_platform_toolset vcvarsall_bat = find_vcvarsall_bat(paths);
+        return vcvarsall_bat;
     }
 }
diff --git a/toolsrc/src/vcpkg_Strings.cpp b/toolsrc/src/vcpkg_Strings.cpp
index cf7d3b0ee..b974b0a06 100644
--- a/toolsrc/src/vcpkg_Strings.cpp
+++ b/toolsrc/src/vcpkg_Strings.cpp
@@ -119,4 +119,24 @@ namespace vcpkg::Strings
                                           return s == "";
                                       }), strings->end());
     }
+
+    std::vector<std::string> split(const std::string& s, const std::string& delimiter)
+    {
+        std::vector<std::string> output;
+
+        size_t i = 0;
+        for (size_t pos = s.find(delimiter); pos != std::string::npos;  pos = s.find(delimiter, pos))
+        {
+            output.push_back(s.substr(i, pos - i));
+            i = ++pos;
+        }
+
+        // Add the rest of the string after the last delimiter, unless there is nothing after it
+        if (i != s.length())
+        {
+            output.push_back(s.substr(i, s.length()));
+        }
+
+        return output;
+    }
 }
diff --git a/toolsrc/src/vcpkg_paths.cpp b/toolsrc/src/vcpkg_paths.cpp
index b7e716307..39e4c8986 100644
--- a/toolsrc/src/vcpkg_paths.cpp
+++ b/toolsrc/src/vcpkg_paths.cpp
@@ -31,8 +31,9 @@ namespace vcpkg
         paths.ports = paths.root / "ports";
         paths.installed = paths.root / "installed";
         paths.triplets = paths.root / "triplets";
+        paths.scripts = paths.root / "scripts";
 
-        paths.buildsystems = paths.root / "scripts" / "buildsystems";
+        paths.buildsystems = paths.scripts / "buildsystems";
         paths.buildsystems_msbuild_targets = paths.buildsystems / "msbuild" / "vcpkg.targets";
 
         paths.vcpkg_dir = paths.installed / "vcpkg";
@@ -40,7 +41,7 @@ namespace vcpkg
         paths.vcpkg_dir_info = paths.vcpkg_dir / "info";
         paths.vcpkg_dir_updates = paths.vcpkg_dir / "updates";
 
-        paths.ports_cmake = paths.root / "scripts" / "ports.cmake";
+        paths.ports_cmake = paths.scripts / "ports.cmake";
         return paths;
     }