Merge from master

README.md

@@ -1,4 +1,4 @@
-# Vcpkg
+# Vcpkg ![](https://devdiv.visualstudio.com/_apis/public/build/definitions/0bdbc590-a062-4c3f-b0f6-9383f67865ee/5261/badge)
  
 ## Overview
 Vcpkg helps you get C and C++ libraries on Windows. This tool and ecosystem are currently in a preview state; your involvement is vital to its success.

ports/glib/CMakeLists.txt

@@ -60,7 +60,7 @@ macro(extract_vcproj_sources VC_PROJECT OUT_VAR)
 endmacro()
 
 # main module
-extract_vcproj_sources(build/win32/vs14/glib.vcxproj GLIB_SOURCES)
+extract_vcproj_sources(win32/vs14/glib.vcxproj GLIB_SOURCES)
 list(APPEND GLIB_SOURCES glib/libcharset/localcharset.c) # modified internal version with prefixed symbols
 add_library(glib ${GLIB_SOURCES})
 target_compile_definitions(glib PRIVATE USE_SYSTEM_PCRE ${GLIB_EXPORT_MACRO} GLIB_COMPILATION G_LOG_DOMAIN="GLib" LIBDIR)
@@ -77,7 +77,7 @@ target_include_directories(gthread PRIVATE ${LIBINTL_INCLUDE_DIR})
 list(APPEND GLIB_TARGETS gthread)
 
 # gobject
-extract_vcproj_sources(build/win32/vs14/gobject.vcxproj GOBJECT_SOURCES)
+extract_vcproj_sources(win32/vs14/gobject.vcxproj GOBJECT_SOURCES)
 add_library(gobject ${GOBJECT_SOURCES})
 target_compile_definitions(gobject PRIVATE GOBJECT_COMPILATION ${GLIB_EXPORT_MACRO} G_LOG_DOMAIN="GLib-GObject")
 target_link_libraries(gobject gthread glib ${FFI_LIBRARY})
@@ -92,7 +92,7 @@ target_include_directories(gmodule PRIVATE ${LIBINTL_INCLUDE_DIR})
 list(APPEND GLIB_TARGETS gmodule)
 
 # gio
-extract_vcproj_sources(build/win32/vs14/gio.vcxproj GIO_SOURCES)
+extract_vcproj_sources(win32/vs14/gio.vcxproj GIO_SOURCES)
 add_library(gio ${GIO_SOURCES})
 target_compile_definitions(gio PRIVATE GIO_COMPILATION ${GLIB_EXPORT_MACRO} G_LOG_DOMAIN="GLib-GIO")
 target_link_libraries(gio glib gmodule gobject ws2_32 shlwapi dnsapi iphlpapi ${ZLIB_LIBRARIES})

ports/glib/CONTROL

@@ -1,4 +1,4 @@
 Source: glib
-Version: 2.50.3
+Version: 2.52.1
 Description: Portable, general-purpose utility library.
 Build-Depends: zlib, pcre, libffi, gettext, libiconv

ports/glib/cmake/install_headers.cmake

@@ -76,6 +76,7 @@ install(FILES glib/gtypes.h DESTINATION include/glib)
 install(FILES glib/gunicode.h DESTINATION include/glib)
 install(FILES glib/gurifuncs.h DESTINATION include/glib)
 install(FILES glib/gutils.h DESTINATION include/glib)
+install(FILES glib/guuid.h DESTINATION include/glib)
 install(FILES glib/gvarianttype.h DESTINATION include/glib)
 install(FILES glib/gvariant.h DESTINATION include/glib)
 install(FILES glib/gversion.h DESTINATION include/glib)

ports/glib/portfile.cmake

@@ -10,12 +10,12 @@ if (VCPKG_LIBRARY_LINKAGE STREQUAL static)
 endif()
 
 include(vcpkg_common_functions)
-set(GLIB_VERSION 2.50.3)
+set(GLIB_VERSION 2.52.1)
 set(SOURCE_PATH ${CURRENT_BUILDTREES_DIR}/src/glib-${GLIB_VERSION})
 vcpkg_download_distfile(ARCHIVE
-    URLS "https://ftp.gnome.org/pub/gnome/sources/glib/2.50/glib-${GLIB_VERSION}.tar.xz"
+    URLS "https://ftp.gnome.org/pub/gnome/sources/glib/2.52/glib-${GLIB_VERSION}.tar.xz"
     FILENAME "glib-${GLIB_VERSION}.tar.xz"
-    SHA512 ef35806c15170b6608445f255136c0bebd2d433adf903c2af2865f6a57b4f2fcfc1e4a7cea1a0dac48ff5fe26248fbf7886dba4a8d209506f0a94160df8fb7af)
+    SHA512 6f0475b4ee1078867671a79b1751674926ba1caa872cec3896e2830c61c3cde67972afa9f2d606a2b6705e9846222462b003c6e966a9b63982f3fc3fb58c4d37)
 
 vcpkg_extract_source_archive(${ARCHIVE})
 vcpkg_apply_patches(

ports/mpg123/portfile.cmake

@@ -72,6 +72,8 @@ file(INSTALL
 )
 file(INSTALL
     ${SOURCE_PATH}/ports/MSVC++/mpg123.h
+    ${SOURCE_PATH}/src/libmpg123/fmt123.h
+    ${SOURCE_PATH}/src/libmpg123/mpg123.h.in
     DESTINATION ${CURRENT_PACKAGES_DIR}/include
 )
 

ports/xerces-c/CONTROL

@@ -1,3 +1,3 @@
 Source: xerces-c
-Version: 3.1.4
+Version: 3.1.4-3
 Description: Xerces-C++ is a XML parser, for parsing, generating, manipulating, and validating XML documents using the DOM, SAX, and SAX2 APIs.

ports/xerces-c/portfile.cmake

@@ -7,6 +7,15 @@
 #
 
 include(vcpkg_common_functions)
+if (VCPKG_LIBRARY_LINKAGE STREQUAL "static")
+    message(STATUS "Static libraries not supported; building dynamic instead")
+    set(VCPKG_LIBRARY_LINKAGE "dynamic")
+endif()
+if (VCPKG_CRT_LINKAGE STREQUAL "static")
+    message(STATUS "Static linking against the CRT not supported; building dynamic instead")
+    set(VCPKG_CRT_LINKAGE "dynamic")
+endif()
+
 
 set(SOURCE_PATH ${CURRENT_BUILDTREES_DIR}/src/xerces-c-3.1.4)
 
@@ -17,20 +26,29 @@ vcpkg_download_distfile(ARCHIVE
 )
 vcpkg_extract_source_archive(${ARCHIVE})
 
-if (TRIPLET_SYSTEM_ARCH MATCHES "x86")
+if (VCPKG_TARGET_ARCHITECTURE MATCHES "x86")
-     set(BUILD_ARCH "Win32")
+    set(BUILD_ARCH "Win32")
+    set(OUTPUT_DIR "Win32")
+elseif (VCPKG_TARGET_ARCHITECTURE MATCHES "x64")
+    set(BUILD_ARCH "x64")
+    set(OUTPUT_DIR "Win64")
 else()
-     set(BUILD_ARCH ${TRIPLET_SYSTEM_ARCH})
+    message(FATAL_ERROR "Unsupported architecture: ${VCPKG_TARGET_ARCHITECTURE}")
 endif()
 
-
 vcpkg_build_msbuild(
     #PROJECT_PATH ${SOURCE_PATH}/projects/Win32/VC14/xerces-all/xerces-all.sln
     PROJECT_PATH ${SOURCE_PATH}/projects/Win32/VC14/xerces-all/xercesLib/xercesLib.vcxproj
     PLATFORM ${BUILD_ARCH})
 
+file(COPY ${SOURCE_PATH}/Build/${OUTPUT_DIR}/VC14/Debug/xerces-c_3_1D.dll DESTINATION ${CURRENT_PACKAGES_DIR}/debug/bin)
+file(COPY ${SOURCE_PATH}/Build/${OUTPUT_DIR}/VC14/Debug/xerces-c_3D.lib DESTINATION ${CURRENT_PACKAGES_DIR}/debug/lib)
+file(COPY ${SOURCE_PATH}/Build/${OUTPUT_DIR}/VC14/Release/xerces-c_3_1.dll DESTINATION ${CURRENT_PACKAGES_DIR}/bin)
+file(COPY ${SOURCE_PATH}/Build/${OUTPUT_DIR}/VC14/Release/xerces-c_3.lib DESTINATION ${CURRENT_PACKAGES_DIR}/lib)
 
 file(COPY ${SOURCE_PATH}/src/xercesc DESTINATION ${CURRENT_PACKAGES_DIR}/include FILES_MATCHING PATTERN *.hpp)
+# Certain headers under xercesc/util include .c files, so we need these copied over as well
+file(COPY ${SOURCE_PATH}/src/xercesc DESTINATION ${CURRENT_PACKAGES_DIR}/include FILES_MATCHING PATTERN *.c)
 
 file(REMOVE_RECURSE ${CURRENT_PACKAGES_DIR}/include/xercesc/NLS)
 file(REMOVE_RECURSE ${CURRENT_PACKAGES_DIR}/include/xercesc/util/MsgLoaders/ICU/resources)
@@ -38,3 +56,5 @@ file(REMOVE_RECURSE ${CURRENT_PACKAGES_DIR}/include/xercesc/util/MsgLoaders/ICU/
 # Handle copyright
 file(COPY ${SOURCE_PATH}/LICENSE DESTINATION ${CURRENT_PACKAGES_DIR}/share/xerces-c)
 file(RENAME ${CURRENT_PACKAGES_DIR}/share/xerces-c/LICENSE ${CURRENT_PACKAGES_DIR}/share/xerces-c/copyright)
+
+vcpkg_copy_pdbs()

scripts/buildsystems/msbuild/applocal.ps1

@@ -1,5 +1,5 @@
 [cmdletbinding()]
-param([string]$targetBinary, [string]$installedDir, [string]$tlogFile)
+param([string]$targetBinary, [string]$installedDir, [string]$tlogFile, [string]$copiedFilesLog)
 
 $g_searched = @{}
 # Note: installedDir is actually the bin\ directory.
@@ -14,7 +14,7 @@ function deployBinary([string]$targetBinaryDir, [string]$SourceDir, [string]$tar
         Write-Verbose "  ${targetBinaryName}: Copying $SourceDir\$targetBinaryName"
         Copy-Item "$SourceDir\$targetBinaryName" $targetBinaryDir
     }
-    "$targetBinaryDir\$targetBinaryName"
+    if ($copiedFilesLog) { Add-Content $copiedFilesLog "$targetBinaryDir\$targetBinaryName" }
     if ($tlogFile) { Add-Content $tlogFile "$targetBinaryDir\$targetBinaryName" }
 }
 

scripts/buildsystems/msbuild/vcpkg.targets

@@ -62,18 +62,21 @@
   <Target Name="AppLocalFromInstalled" AfterTargets="CopyFilesToOutputDirectory" BeforeTargets="CopyLocalFilesOutputGroup;RegisterOutput" Condition="'$(VcpkgEnabled)' == 'true'">
     <WriteLinesToFile
     File="$(TLogLocation)$(ProjectName).write.1u.tlog"
-    Lines="^$(OutputPath)$(TargetName).$(OutputType);" Encoding="Unicode"/>
+    Lines="^$(TargetPath);$([System.IO.Path]::Combine($(ProjectDir),$(IntDir)))vcpkg.applocal.log" Encoding="Unicode"/>
     <Exec Condition="'$(VcpkgConfiguration)' == 'Debug'"
-      Command="powershell.exe -ExecutionPolicy Unrestricted -noprofile -File %22$(MSBuildThisFileDirectory)applocal.ps1%22 %22$(TargetPath)%22 %22$(VcpkgRoot)debug\bin%22 %22$(TLogLocation)$(ProjectName).write.1u.tlog%22"
+      Command="powershell.exe -ExecutionPolicy Bypass -noprofile -File %22$(MSBuildThisFileDirectory)applocal.ps1%22 %22$(TargetPath)%22 %22$(VcpkgRoot)debug\bin%22 %22$(TLogLocation)$(ProjectName).write.1u.tlog%22 %22$(IntDir)vcpkg.applocal.log%22"
-      ConsoleToMSBuild="true"
       StandardOutputImportance="Normal">
-        <Output TaskParameter="ConsoleOutput" ItemName="ReferenceCopyLocalPaths" />
     </Exec>
     <Exec Condition="'$(VcpkgConfiguration)' == 'Release'"
-      Command="powershell.exe -ExecutionPolicy Unrestricted -noprofile -File %22$(MSBuildThisFileDirectory)applocal.ps1%22 %22$(TargetPath)%22 %22$(VcpkgRoot)bin%22 %22$(TLogLocation)$(ProjectName).write.1u.tlog%22"
+      Command="powershell.exe -ExecutionPolicy Bypass -noprofile -File %22$(MSBuildThisFileDirectory)applocal.ps1%22 %22$(TargetPath)%22 %22$(VcpkgRoot)bin%22 %22$(TLogLocation)$(ProjectName).write.1u.tlog%22 %22$(IntDir)vcpkg.applocal.log%22"
-      ConsoleToMSBuild="true"
       StandardOutputImportance="Normal">
-        <Output TaskParameter="ConsoleOutput" ItemName="ReferenceCopyLocalPaths" />
     </Exec>
+    <ReadLinesFromFile File="$(IntDir)vcpkg.applocal.log">
+      <Output TaskParameter="Lines" ItemName="VcpkgAppLocalDLLs" />
+    </ReadLinesFromFile>
+    <Message Text="@(VcpkgAppLocalDLLs,'%0A')" Importance="Normal" />
+    <ItemGroup>
+      <ReferenceCopyLocalPaths Include="@(VcpkgAppLocalDLLs)" />
+    </ItemGroup>
   </Target>
 </Project>

scripts/cmake/vcpkg_copy_tool_dependencies.cmake

@@ -4,7 +4,7 @@ function(vcpkg_copy_tool_dependencies TOOL_DIR)
     macro(search_for_dependencies PATH_TO_SEARCH)
         file(GLOB TOOLS ${TOOL_DIR}/*.exe ${TOOL_DIR}/*.dll)
         foreach(TOOL ${TOOLS})
-            execute_process(COMMAND powershell -noprofile -executionpolicy UnRestricted -nologo
+            execute_process(COMMAND powershell -noprofile -executionpolicy Bypass -nologo
                 -file ${VCPKG_ROOT_DIR}/scripts/buildsystems/msbuild/applocal.ps1
                 -targetBinary ${TOOL}
                 -installedDir ${PATH_TO_SEARCH}

scripts/findAnyMSBuildWithCppPlatformToolset.ps1

@@ -91,11 +91,11 @@ foreach ($pair in $registryPairs)
     try
     {
         $VS14InstallDir = $(gp $vsEntry InstallDir -erroraction Stop | % { $_.InstallDir })
-        Write-Verbose "$vsEntry - Found"
+        Write-Verbose "$vsEntry\InstallDir - Found"
     }
     catch
     {
-        Write-Verbose "$vsEntry - Not Found"
+        Write-Verbose "$vsEntry\InstallDir - Not Found"
         continue
     }
 
@@ -118,11 +118,11 @@ foreach ($pair in $registryPairs)
     try
     {
         $MSBuild14 = $(gp $msbuildEntry MSBuildToolsPath -erroraction Stop | % { $_.MSBuildToolsPath })
-        Write-Verbose "$msbuildEntry - Found"
+        Write-Verbose "$msbuildEntry\MSBuildToolsPath - Found"
     }
     catch
     {
-        Write-Verbose "$msbuildEntry - Not Found"
+        Write-Verbose "$msbuildEntry\MSBuildToolsPath - Not Found"
         continue
     }
 

toolsrc/include/BinaryParagraph.h

@@ -10,7 +10,7 @@ namespace vcpkg
     {
         BinaryParagraph();
         explicit BinaryParagraph(std::unordered_map<std::string, std::string> fields);
-        BinaryParagraph(const SourceParagraph& spgh, const Triplet& target_triplet);
+        BinaryParagraph(const SourceParagraph& spgh, const Triplet& triplet);
 
         std::string displayname() const;
 

toolsrc/include/PackageSpec.h

@@ -7,15 +7,13 @@ namespace vcpkg
 {
     struct PackageSpec
     {
-        static Expected<PackageSpec> from_string(const std::string& spec_as_string, const Triplet& default_target_triplet);
+        static Expected<PackageSpec> from_string(const std::string& spec_as_string, const Triplet& default_triplet);
 
-        static Expected<PackageSpec> from_name_and_triplet(const std::string& name, const Triplet& target_triplet);
+        static Expected<PackageSpec> from_name_and_triplet(const std::string& name, const Triplet& triplet);
 
         const std::string& name() const;
 
-        const Triplet& target_triplet() const;
+        const Triplet& triplet() const;
-
-        std::string display_name() const;
 
         std::string dir() const;
 
@@ -23,14 +21,10 @@ namespace vcpkg
 
     private:
         std::string m_name;
-        Triplet m_target_triplet;
+        Triplet m_triplet;
     };
 
-    std::string to_printf_arg(const PackageSpec& spec);
-
     bool operator==(const PackageSpec& left, const PackageSpec& right);
-
-    std::ostream& operator<<(std::ostream& os, const PackageSpec& spec);
 } //namespace vcpkg
 
 namespace std
@@ -42,7 +36,7 @@ namespace std
         {
             size_t hash = 17;
             hash = hash * 31 + std::hash<std::string>()(value.name());
-            hash = hash * 31 + std::hash<vcpkg::Triplet>()(value.target_triplet());
+            hash = hash * 31 + std::hash<vcpkg::Triplet>()(value.triplet());
             return hash;
         }
     };

toolsrc/include/StatusParagraphs.h

@@ -16,16 +16,16 @@ namespace vcpkg
 
         const_iterator find(const PackageSpec& spec) const
         {
-            return find(spec.name(), spec.target_triplet());
+            return find(spec.name(), spec.triplet());
         }
-        const_iterator find(const std::string& name, const Triplet& target_triplet) const;
+        const_iterator find(const std::string& name, const Triplet& triplet) const;
-        iterator find(const std::string& name, const Triplet& target_triplet);
+        iterator find(const std::string& name, const Triplet& triplet);
 
         const_iterator find_installed(const PackageSpec& spec) const
         {
-            return find_installed(spec.name(), spec.target_triplet());
+            return find_installed(spec.name(), spec.triplet());
         }
-        const_iterator find_installed(const std::string& name, const Triplet& target_triplet) const;
+        const_iterator find_installed(const std::string& name, const Triplet& triplet) const;
 
         iterator insert(std::unique_ptr<StatusParagraph>);
 

toolsrc/include/VcpkgCmdArguments.h

@@ -13,7 +13,7 @@ namespace vcpkg
         static VcpkgCmdArguments create_from_arg_sequence(const std::string* arg_begin, const std::string* arg_end);
 
         std::unique_ptr<std::string> vcpkg_root_dir;
-        std::unique_ptr<std::string> target_triplet;
+        std::unique_ptr<std::string> triplet;
         OptBoolT debug = OptBoolT::UNSPECIFIED;
         OptBoolT  sendmetrics = OptBoolT::UNSPECIFIED;
         OptBoolT  printmetrics = OptBoolT::UNSPECIFIED;

toolsrc/include/VersionT.cpp

@@ -6,6 +6,7 @@ namespace vcpkg
 {
     VersionT::VersionT() : value("0.0.0") {}
     VersionT::VersionT(const std::string& value) : value(value) {}
+    std::string VersionT::to_string() const { return value; }
     bool operator==(const VersionT& left, const VersionT& right) { return left.value == right.value; }
     bool operator!=(const VersionT& left, const VersionT& right) { return left.value != right.value; }
     std::string to_printf_arg(const VersionT& version) { return version.value; }

toolsrc/include/VersionT.h

@@ -8,12 +8,13 @@ namespace vcpkg
         VersionT();
         VersionT(const std::string& value);
 
+        std::string to_string() const;
+
         std::string value;
     };
 
     bool operator ==(const VersionT& left, const VersionT& right);
     bool operator !=(const VersionT& left, const VersionT& right);
-    std::string to_printf_arg(const VersionT& version);
 
     struct VersionDiff
     {

toolsrc/include/triplet.h

@@ -15,10 +15,9 @@ namespace vcpkg
         static const Triplet ARM_UWP;
 
         const std::string& canonical_name() const;
-
         std::string architecture() const;
-
         std::string system() const;
+        const std::string& to_string() const;
 
     private:
         std::string m_canonical_name;
@@ -27,12 +26,6 @@ namespace vcpkg
     bool operator==(const Triplet& left, const Triplet& right);
 
     bool operator!=(const Triplet& left, const Triplet& right);
-
-    std::string to_string(const Triplet& spec);
-
-    std::string to_printf_arg(const Triplet& spec);
-
-    std::ostream& operator<<(std::ostream& os, const Triplet& spec);
 }
 
 namespace std

toolsrc/include/vcpkg_Commands.h

@@ -8,7 +8,7 @@
 
 namespace vcpkg::Commands
 {
-    using CommandTypeA = void(*)(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_target_triplet);
+    using CommandTypeA = void(*)(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet);
     using CommandTypeB = void(*)(const VcpkgCmdArguments& args, const VcpkgPaths& paths);
     using CommandTypeC = void(*)(const VcpkgCmdArguments& args);
 
@@ -29,32 +29,32 @@ namespace vcpkg::Commands
         std::string create_error_message(const BuildResult build_result, const PackageSpec& spec);
         std::string create_user_troubleshooting_message(const PackageSpec& spec);
 
-        std::wstring make_build_env_cmd(const Triplet& target_triplet, const Toolset& toolset);
+        std::wstring make_build_env_cmd(const Triplet& triplet, const Toolset& toolset);
 
         BuildResult build_package(const SourceParagraph& source_paragraph, const PackageSpec& spec, const VcpkgPaths& paths, const fs::path& port_dir, const StatusParagraphs& status_db);
         void perform_and_exit(const PackageSpec& spec, const fs::path& port_dir, const std::unordered_set<std::string>& options, const VcpkgPaths& paths);
-        void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_target_triplet);
+        void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet);
     }
 
     namespace BuildExternal
     {
-        void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_target_triplet);
+        void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet);
     }
 
     namespace Install
     {
         void install_package(const VcpkgPaths& paths, const BinaryParagraph& binary_paragraph, StatusParagraphs* status_db);
-        void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_target_triplet);
+        void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet);
     }
 
     namespace CI
     {
-        void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_target_triplet);
+        void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet);
     }
 
     namespace Remove
     {
-        void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_target_triplet);
+        void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet);
     }
 
     namespace Update

toolsrc/include/vcpkg_Input.h

@@ -7,7 +7,7 @@ namespace vcpkg::Input
 {
     PackageSpec check_and_get_package_spec(
         const std::string& package_spec_as_string,
-        const Triplet& default_target_triplet,
+        const Triplet& default_triplet,
         CStringView example_text);
 
     void check_triplet(const Triplet& t, const VcpkgPaths& paths);

toolsrc/include/vcpkg_Strings.h

@@ -5,6 +5,12 @@
 
 namespace vcpkg::Strings::details
 {
+    template<class T>
+    auto to_printf_arg(const T& t) -> decltype(t.to_string())
+    {
+        return t.to_string();
+    }
+
     inline const char* to_printf_arg(const std::string& s)
     {
         return s.c_str();

toolsrc/src/BinaryParagraph.cpp

@@ -29,9 +29,9 @@ namespace vcpkg
     {
         const std::string name = details::remove_required_field(&fields, BinaryParagraphRequiredField::PACKAGE);
         const std::string architecture = details::remove_required_field(&fields, BinaryParagraphRequiredField::ARCHITECTURE);
-        const Triplet target_triplet = Triplet::from_canonical_name(architecture);
+        const Triplet triplet = Triplet::from_canonical_name(architecture);
 
-        this->spec = PackageSpec::from_name_and_triplet(name, target_triplet).value_or_exit(VCPKG_LINE_INFO);
+        this->spec = PackageSpec::from_name_and_triplet(name, triplet).value_or_exit(VCPKG_LINE_INFO);
         this->version = details::remove_required_field(&fields, BinaryParagraphRequiredField::VERSION);
 
         this->description = details::remove_optional_field(&fields, BinaryParagraphOptionalField::DESCRIPTION);
@@ -44,18 +44,18 @@ namespace vcpkg
         this->depends = parse_depends(deps);
     }
 
-    BinaryParagraph::BinaryParagraph(const SourceParagraph& spgh, const Triplet& target_triplet)
+    BinaryParagraph::BinaryParagraph(const SourceParagraph& spgh, const Triplet& triplet)
     {
-        this->spec = PackageSpec::from_name_and_triplet(spgh.name, target_triplet).value_or_exit(VCPKG_LINE_INFO);
+        this->spec = PackageSpec::from_name_and_triplet(spgh.name, triplet).value_or_exit(VCPKG_LINE_INFO);
         this->version = spgh.version;
         this->description = spgh.description;
         this->maintainer = spgh.maintainer;
-        this->depends = filter_dependencies(spgh.depends, target_triplet);
+        this->depends = filter_dependencies(spgh.depends, triplet);
     }
 
     std::string BinaryParagraph::displayname() const
     {
-        return this->spec.display_name();
+        return this->spec.to_string();
     }
 
     std::string BinaryParagraph::dir() const
@@ -65,7 +65,7 @@ namespace vcpkg
 
     std::string BinaryParagraph::fullstem() const
     {
-        return Strings::format("%s_%s_%s", this->spec.name(), this->version, this->spec.target_triplet());
+        return Strings::format("%s_%s_%s", this->spec.name(), this->version, this->spec.triplet());
     }
 
     std::ostream& operator<<(std::ostream& os, const BinaryParagraph& p)
@@ -85,7 +85,7 @@ namespace vcpkg
 
             os << "\n";
         }
-        os << "Architecture: " << p.spec.target_triplet() << "\n";
+        os << "Architecture: " << p.spec.triplet().to_string() << "\n";
         os << "Multi-Arch: same\n";
         if (!p.maintainer.empty())
             os << "Maintainer: " << p.maintainer << "\n";

toolsrc/src/PackageSpec.cpp

@@ -8,12 +8,12 @@ namespace vcpkg
         return (c == '-') || isdigit(c) || (isalpha(c) && islower(c));
     }
 
-    Expected<PackageSpec> PackageSpec::from_string(const std::string& spec_as_string, const Triplet& default_target_triplet)
+    Expected<PackageSpec> PackageSpec::from_string(const std::string& spec_as_string, const Triplet& default_triplet)
     {
         auto pos = spec_as_string.find(':');
         if (pos == std::string::npos)
         {
-            return from_name_and_triplet(spec_as_string, default_target_triplet);
+            return from_name_and_triplet(spec_as_string, default_triplet);
         }
 
         auto pos2 = spec_as_string.find(':', pos + 1);
@@ -23,11 +23,11 @@ namespace vcpkg
         }
 
         const std::string name = spec_as_string.substr(0, pos);
-        const Triplet target_triplet = Triplet::from_canonical_name(spec_as_string.substr(pos + 1));
+        const Triplet triplet = Triplet::from_canonical_name(spec_as_string.substr(pos + 1));
-        return from_name_and_triplet(name, target_triplet);
+        return from_name_and_triplet(name, triplet);
     }
 
-    Expected<PackageSpec> PackageSpec::from_name_and_triplet(const std::string& name, const Triplet& target_triplet)
+    Expected<PackageSpec> PackageSpec::from_name_and_triplet(const std::string& name, const Triplet& triplet)
     {
         if (std::find_if_not(name.cbegin(), name.cend(), is_valid_package_spec_char) != name.end())
         {
@@ -36,7 +36,7 @@ namespace vcpkg
 
         PackageSpec p;
         p.m_name = name;
-        p.m_target_triplet = target_triplet;
+        p.m_triplet = triplet;
         return p;
     }
 
@@ -45,38 +45,23 @@ namespace vcpkg
         return this->m_name;
     }
 
-    const Triplet& PackageSpec::target_triplet() const
+    const Triplet& PackageSpec::triplet() const
     {
-        return this->m_target_triplet;
+        return this->m_triplet;
-    }
-
-    std::string PackageSpec::display_name() const
-    {
-        return Strings::format("%s:%s", this->name(), this->target_triplet());
     }
 
     std::string PackageSpec::dir() const
     {
-        return Strings::format("%s_%s", this->m_name, this->m_target_triplet);
+        return Strings::format("%s_%s", this->m_name, this->m_triplet);
     }
 
     std::string PackageSpec::to_string() const
     {
-        return this->display_name();
+        return Strings::format("%s:%s", this->name(), this->triplet());
-    }
-
-    std::string to_printf_arg(const PackageSpec& spec)
-    {
-        return spec.to_string();
     }
 
     bool operator==(const PackageSpec& left, const PackageSpec& right)
     {
-        return left.name() == right.name() && left.target_triplet() == right.target_triplet();
+        return left.name() == right.name() && left.triplet() == right.triplet();
-    }
-
-    std::ostream& operator<<(std::ostream& os, const PackageSpec& spec)
-    {
-        return os << spec.to_string();
     }
 }

toolsrc/src/PostBuildLint.cpp

@@ -686,7 +686,7 @@ namespace vcpkg::PostBuildLint
             libs.insert(libs.cend(), debug_libs.cbegin(), debug_libs.cend());
             libs.insert(libs.cend(), release_libs.cbegin(), release_libs.cend());
 
-            error_count += check_lib_architecture(spec.target_triplet().architecture(), libs);
+            error_count += check_lib_architecture(spec.triplet().architecture(), libs);
         }
 
         switch (build_info.library_linkage)
@@ -708,8 +708,8 @@ namespace vcpkg::PostBuildLint
                     dlls.insert(dlls.cend(), release_dlls.cbegin(), release_dlls.cend());
 
                     error_count += check_exports_of_dlls(dlls, toolset.dumpbin);
-                    error_count += check_uwp_bit_of_dlls(spec.target_triplet().system(), dlls, toolset.dumpbin);
+                    error_count += check_uwp_bit_of_dlls(spec.triplet().system(), dlls, toolset.dumpbin);
-                    error_count += check_dll_architecture(spec.target_triplet().architecture(), dlls);
+                    error_count += check_dll_architecture(spec.triplet().architecture(), dlls);
 
                     error_count += check_outdated_crt_linkage_of_dlls(dlls, toolset.dumpbin);
                     break;

toolsrc/src/StatusParagraphs.cpp

@@ -1,6 +1,9 @@
 #include "pch.h"
 #include "StatusParagraphs.h"
 #include "vcpkg_Checks.h"
+#include <algorithm>
+#include <algorithm>
+#include <algorithm>
 
 namespace vcpkg
 {
@@ -11,27 +14,27 @@ namespace vcpkg
     {
     };
 
-    StatusParagraphs::const_iterator StatusParagraphs::find(const std::string& name, const Triplet& target_triplet) const
+    StatusParagraphs::const_iterator StatusParagraphs::find(const std::string& name, const Triplet& triplet) const
     {
         return std::find_if(begin(), end(), [&](const std::unique_ptr<StatusParagraph>& pgh)
                             {
                                 const PackageSpec& spec = pgh->package.spec;
-                                return spec.name() == name && spec.target_triplet() == target_triplet;
+                                return spec.name() == name && spec.triplet() == triplet;
                             });
     }
 
-    StatusParagraphs::iterator StatusParagraphs::find(const std::string& name, const Triplet& target_triplet)
+    StatusParagraphs::iterator StatusParagraphs::find(const std::string& name, const Triplet& triplet)
     {
         return std::find_if(begin(), end(), [&](const std::unique_ptr<StatusParagraph>& pgh)
                             {
                                 const PackageSpec& spec = pgh->package.spec;
-                                return spec.name() == name && spec.target_triplet() == target_triplet;
+                                return spec.name() == name && spec.triplet() == triplet;
                             });
     }
 
-    StatusParagraphs::const_iterator StatusParagraphs::find_installed(const std::string& name, const Triplet& target_triplet) const
+    StatusParagraphs::const_iterator StatusParagraphs::find_installed(const std::string& name, const Triplet& triplet) const
     {
-        const const_iterator it = find(name, target_triplet);
+        const const_iterator it = find(name, triplet);
         if (it != end() && (*it)->want == Want::INSTALL && (*it)->state == InstallState::INSTALLED)
         {
             return it;
@@ -44,7 +47,7 @@ namespace vcpkg
     {
         Checks::check_exit(VCPKG_LINE_INFO, pgh != nullptr, "Inserted null paragraph");
         const PackageSpec& spec = pgh->package.spec;
-        auto ptr = find(spec.name(), spec.target_triplet());
+        auto ptr = find(spec.name(), spec.triplet());
         if (ptr == end())
         {
             paragraphs.push_back(std::move(pgh));

toolsrc/src/VcpkgCmdArguments.cpp

@@ -88,7 +88,7 @@ namespace vcpkg
                 if (arg == "--triplet")
                 {
                     ++arg_begin;
-                    parse_value(arg_begin, arg_end, "--triplet", args.target_triplet);
+                    parse_value(arg_begin, arg_end, "--triplet", args.triplet);
                     continue;
                 }
                 if (arg == "--debug")

toolsrc/src/commands_available_commands.cpp

@@ -6,12 +6,12 @@ namespace vcpkg::Commands
     const std::vector<PackageNameAndFunction<CommandTypeA>>& get_available_commands_type_a()
     {
         static std::vector<PackageNameAndFunction<CommandTypeA>> t = {
-            {"install", &Install::perform_and_exit},
+            { "install", &Install::perform_and_exit },
             { "ci", &CI::perform_and_exit },
-            {"remove", &Remove::perform_and_exit},
+            { "remove", &Remove::perform_and_exit },
-            {"build", &Build::perform_and_exit},
+            { "build", &Build::perform_and_exit },
-            {"env", &Env::perform_and_exit},
+            { "env", &Env::perform_and_exit },
-            {"build-external", &BuildExternal::perform_and_exit}
+            { "build-external", &BuildExternal::perform_and_exit }
         };
         return t;
     }
@@ -19,19 +19,19 @@ namespace vcpkg::Commands
     const std::vector<PackageNameAndFunction<CommandTypeB>>& get_available_commands_type_b()
     {
         static std::vector<PackageNameAndFunction<CommandTypeB>> t = {
-            {"/?", &Help::perform_and_exit},
+            { "/?", &Help::perform_and_exit },
-            {"help", &Help::perform_and_exit},
+            { "help", &Help::perform_and_exit },
-            {"search", &Search::perform_and_exit},
+            { "search", &Search::perform_and_exit },
-            {"list", &List::perform_and_exit},
+            { "list", &List::perform_and_exit },
-            {"integrate", &Integrate::perform_and_exit},
+            { "integrate", &Integrate::perform_and_exit },
-            {"owns", &Owns::perform_and_exit},
+            { "owns", &Owns::perform_and_exit },
-            {"update", &Update::perform_and_exit},
+            { "update", &Update::perform_and_exit },
-            {"depend-info", &DependInfo::perform_and_exit},
+            { "depend-info", &DependInfo::perform_and_exit },
-            {"edit", &Edit::perform_and_exit},
+            { "edit", &Edit::perform_and_exit },
-            {"create", &Create::perform_and_exit},
+            { "create", &Create::perform_and_exit },
-            {"import", &Import::perform_and_exit},
+            { "import", &Import::perform_and_exit },
-            {"cache", &Cache::perform_and_exit},
+            { "cache", &Cache::perform_and_exit },
-            {"portsdiff", &PortsDiff::perform_and_exit}
+            { "portsdiff", &PortsDiff::perform_and_exit }
         };
         return t;
     }
@@ -39,9 +39,9 @@ namespace vcpkg::Commands
     const std::vector<PackageNameAndFunction<CommandTypeC>>& get_available_commands_type_c()
     {
         static std::vector<PackageNameAndFunction<CommandTypeC>> t = {
-            {"version", &Version::perform_and_exit},
+            { "version", &Version::perform_and_exit },
-            {"contact", &Contact::perform_and_exit},
+            { "contact", &Contact::perform_and_exit },
-            {"hash", &Hash::perform_and_exit},
+            { "hash", &Hash::perform_and_exit },
         };
         return t;
     }

toolsrc/src/commands_build.cpp

@@ -18,14 +18,14 @@ namespace vcpkg::Commands::Build
 
     static const std::string OPTION_CHECKS_ONLY = "--checks-only";
 
-    static void create_binary_control_file(const VcpkgPaths& paths, const SourceParagraph& source_paragraph, const Triplet& target_triplet)
+    static void create_binary_control_file(const VcpkgPaths& paths, const SourceParagraph& source_paragraph, const Triplet& triplet)
     {
-        const BinaryParagraph bpgh = BinaryParagraph(source_paragraph, target_triplet);
+        const BinaryParagraph bpgh = BinaryParagraph(source_paragraph, triplet);
         const fs::path binary_control_file = paths.packages / bpgh.dir() / "CONTROL";
         std::ofstream(binary_control_file) << bpgh;
     }
 
-    std::wstring make_build_env_cmd(const Triplet& target_triplet, const Toolset& toolset)
+    std::wstring make_build_env_cmd(const Triplet& triplet, const Toolset& toolset)
     {
         const wchar_t * tonull = L" >nul";
         if (g_debugging)
@@ -33,17 +33,17 @@ namespace vcpkg::Commands::Build
             tonull = L"";
         }
 
-        return Strings::wformat(LR"("%s" %s %s 2>&1)", toolset.vcvarsall.native(), Strings::utf8_to_utf16(target_triplet.architecture()), tonull);
+        return Strings::wformat(LR"("%s" %s %s 2>&1)", toolset.vcvarsall.native(), Strings::utf8_to_utf16(triplet.architecture()), tonull);
     }
 
     BuildResult build_package(const SourceParagraph& source_paragraph, const PackageSpec& spec, const VcpkgPaths& paths, const fs::path& port_dir, const StatusParagraphs& status_db)
     {
         Checks::check_exit(VCPKG_LINE_INFO, spec.name() == source_paragraph.name, "inconsistent arguments to build_package()");
 
-        const Triplet& target_triplet = spec.target_triplet();
+        const Triplet& triplet = spec.triplet();
-        for (auto&& dep : filter_dependencies(source_paragraph.depends, target_triplet))
+        for (auto&& dep : filter_dependencies(source_paragraph.depends, triplet))
         {
-            if (status_db.find_installed(dep, target_triplet) == status_db.end())
+            if (status_db.find_installed(dep, triplet) == status_db.end())
             {
                 return BuildResult::CASCADED_DUE_TO_MISSING_DEPENDENCIES;
             }
@@ -54,14 +54,14 @@ namespace vcpkg::Commands::Build
 
         const fs::path ports_cmake_script_path = paths.ports_cmake;
         const Toolset& toolset = paths.get_toolset();
-        const auto cmd_set_environment = make_build_env_cmd(target_triplet, toolset);
+        const auto cmd_set_environment = make_build_env_cmd(triplet, toolset);
 
         const std::wstring cmd_launch_cmake = make_cmake_cmd(cmake_exe_path, ports_cmake_script_path,
                                                              {
                                                                  { L"CMD", L"BUILD" },
                                                                  { L"PORT", source_paragraph.name },
                                                                  { L"CURRENT_PORT_DIR", port_dir / "/." },
-                                                                 { L"TARGET_TRIPLET", target_triplet.canonical_name() },
+                                                                 { L"TARGET_TRIPLET", triplet.canonical_name() },
                                                                  { L"VCPKG_PLATFORM_TOOLSET", toolset.version },
                                                                  { L"GIT", git_exe_path }
                                                              });
@@ -88,7 +88,7 @@ namespace vcpkg::Commands::Build
             return BuildResult::POST_BUILD_CHECKS_FAILED;
         }
 
-        create_binary_control_file(paths, source_paragraph, target_triplet);
+        create_binary_control_file(paths, source_paragraph, triplet);
 
         // const fs::path port_buildtrees_dir = paths.buildtrees / spec.name;
         // delete_directory(port_buildtrees_dir);
@@ -117,7 +117,7 @@ namespace vcpkg::Commands::Build
 
     std::string create_error_message(const BuildResult build_result, const PackageSpec& spec)
     {
-        return Strings::format("Error: Building package %s failed with: %s", spec.to_string(), Build::to_string(build_result));
+        return Strings::format("Error: Building package %s failed with: %s", spec, Build::to_string(build_result));
     }
 
     std::string create_user_troubleshooting_message(const PackageSpec& spec)
@@ -128,7 +128,7 @@ namespace vcpkg::Commands::Build
                                "  Vcpkg version: %s\n"
                                "\n"
                                "Additionally, attach any relevant sections from the log files above."
-                               , spec.to_string(), Version::version());
+                               , spec, Version::version());
     }
 
     void perform_and_exit(const PackageSpec& spec, const fs::path& port_dir, const std::unordered_set<std::string>& options, const VcpkgPaths& paths)
@@ -162,7 +162,7 @@ namespace vcpkg::Commands::Build
             System::println("");
             for (const PackageSpecWithInstallPlan& p : unmet_dependencies)
             {
-                System::println("    %s", p.spec.to_string());
+                System::println("    %s", p.spec);
             }
             System::println("");
             Checks::exit_fail(VCPKG_LINE_INFO);
@@ -178,12 +178,12 @@ namespace vcpkg::Commands::Build
         Checks::exit_success(VCPKG_LINE_INFO);
     }
 
-    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_target_triplet)
+    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet)
     {
         static const std::string example = Commands::Help::create_example_string("build zlib:x64-windows");
         args.check_exact_arg_count(1, example); // Build only takes a single package and all dependencies must already be installed
-        const PackageSpec spec = Input::check_and_get_package_spec(args.command_arguments.at(0), default_target_triplet, example);
+        const PackageSpec spec = Input::check_and_get_package_spec(args.command_arguments.at(0), default_triplet, example);
-        Input::check_triplet(spec.target_triplet(), paths);
+        Input::check_triplet(spec.triplet(), paths);
         const std::unordered_set<std::string> options = args.check_and_get_optional_command_arguments({ OPTION_CHECKS_ONLY });
         perform_and_exit(spec, paths.port_dir(spec), options, paths);
     }

toolsrc/src/commands_build_external.cpp

@@ -5,12 +5,12 @@
 
 namespace vcpkg::Commands::BuildExternal
 {
-    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_target_triplet)
+    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet)
     {
         static const std::string example = Commands::Help::create_example_string(R"(build_external zlib2 C:\path\to\dir\with\controlfile\)");
         args.check_exact_arg_count(2, example);
-        const PackageSpec spec = Input::check_and_get_package_spec(args.command_arguments.at(0), default_target_triplet, example);
+        const PackageSpec spec = Input::check_and_get_package_spec(args.command_arguments.at(0), default_triplet, example);
-        Input::check_triplet(spec.target_triplet(), paths);
+        Input::check_triplet(spec.triplet(), paths);
         const std::unordered_set<std::string> options = args.check_and_get_optional_command_arguments({});
 
         const fs::path port_dir = args.command_arguments.at(1);

toolsrc/src/commands_ci.cpp

@@ -14,26 +14,26 @@ namespace vcpkg::Commands::CI
     using Dependencies::InstallPlanType;
     using Build::BuildResult;
 
-    static std::vector<PackageSpec> load_all_package_specs(Files::Filesystem& fs, const fs::path& ports_directory, const Triplet& target_triplet)
+    static std::vector<PackageSpec> load_all_package_specs(Files::Filesystem& fs, const fs::path& ports_directory, const Triplet& triplet)
     {
         std::vector<SourceParagraph> ports = Paragraphs::load_all_ports(fs, ports_directory);
         std::vector<PackageSpec> specs;
         for (const SourceParagraph& p : ports)
         {
-            specs.push_back(PackageSpec::from_name_and_triplet(p.name, target_triplet).value_or_exit(VCPKG_LINE_INFO));
+            specs.push_back(PackageSpec::from_name_and_triplet(p.name, triplet).value_or_exit(VCPKG_LINE_INFO));
         }
 
         return specs;
     }
 
-    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_target_triplet)
+    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet)
     {
         static const std::string example = Commands::Help::create_example_string("ci x64-windows");
         args.check_max_arg_count(1, example);
-        const Triplet target_triplet = args.command_arguments.size() == 1 ? Triplet::from_canonical_name(args.command_arguments.at(0)) : default_target_triplet;
+        const Triplet triplet = args.command_arguments.size() == 1 ? Triplet::from_canonical_name(args.command_arguments.at(0)) : default_triplet;
-        Input::check_triplet(target_triplet, paths);
+        Input::check_triplet(triplet, paths);
         args.check_and_get_optional_command_arguments({});
-        const std::vector<PackageSpec> specs = load_all_package_specs(paths.get_filesystem(), paths.ports, target_triplet);
+        const std::vector<PackageSpec> specs = load_all_package_specs(paths.get_filesystem(), paths.ports, triplet);
 
         StatusParagraphs status_db = database_load_check(paths);
         const std::vector<PackageSpecWithInstallPlan> install_plan = Dependencies::create_install_plan(paths, specs, status_db);
@@ -48,44 +48,52 @@ namespace vcpkg::Commands::CI
         {
             const ElapsedTime build_timer = ElapsedTime::create_started();
             counter++;
-            System::println("Starting package %d/%d: %s", counter, package_count, action.spec.to_string());
+            const std::string display_name = action.spec.to_string();
+            System::println("Starting package %d/%d: %s", counter, package_count, display_name);
 
             timing.push_back(-1);
             results.push_back(BuildResult::NULLVALUE);
 
             try
             {
-                if (action.plan.plan_type == InstallPlanType::ALREADY_INSTALLED)
+                switch (action.plan.plan_type)
                 {
-                    results.back() = BuildResult::SUCCEEDED;
+                    case InstallPlanType::ALREADY_INSTALLED:
-                    System::println(System::Color::success, "Package %s is already installed", action.spec);
+                        results.back() = BuildResult::SUCCEEDED;
+                        System::println(System::Color::success, "Package %s is already installed", display_name);
+                        break;
+                    case InstallPlanType::BUILD_AND_INSTALL:
+                        {
+                            System::println("Building package %s... ", display_name);
+                            const BuildResult result = Commands::Build::build_package(action.plan.source_pgh.value_or_exit(VCPKG_LINE_INFO),
+                                                                                      action.spec,
+                                                                                      paths,
+                                                                                      paths.port_dir(action.spec),
+                                                                                      status_db);
+                            timing.back() = build_timer.elapsed<std::chrono::milliseconds>().count();
+                            results.back() = result;
+                            if (result != BuildResult::SUCCEEDED)
+                            {
+                                System::println(System::Color::error, Build::create_error_message(result, action.spec));
+                                continue;
+                            }
+                            System::println(System::Color::success, "Building package %s... done", display_name);
+
+                            const BinaryParagraph bpgh = Paragraphs::try_load_cached_package(paths, action.spec).value_or_exit(VCPKG_LINE_INFO);
+                            System::println("Installing package %s... ", display_name);
+                            Install::install_package(paths, bpgh, &status_db);
+                            System::println(System::Color::success, "Installing package %s... done", display_name);
+                            break;
+                        }
+                    case InstallPlanType::INSTALL:
+                        results.back() = BuildResult::SUCCEEDED;
+                        System::println("Installing package %s... ", display_name);
+                        Install::install_package(paths, action.plan.binary_pgh.value_or_exit(VCPKG_LINE_INFO), &status_db);
+                        System::println(System::Color::success, "Installing package %s... done", display_name);
+                        break;
+                    default:
+                        Checks::unreachable(VCPKG_LINE_INFO);
                 }
-                else if (action.plan.plan_type == InstallPlanType::BUILD_AND_INSTALL)
-                {
-                    const BuildResult result = Commands::Build::build_package(action.plan.source_pgh.value_or_exit(VCPKG_LINE_INFO),
-                                                                              action.spec,
-                                                                              paths,
-                                                                              paths.port_dir(action.spec),
-                                                                              status_db);
-                    timing.back() = build_timer.elapsed<std::chrono::milliseconds>().count();
-                    results.back() = result;
-                    if (result != BuildResult::SUCCEEDED)
-                    {
-                        System::println(System::Color::error, Build::create_error_message(result, action.spec));
-                        continue;
-                    }
-                    const BinaryParagraph bpgh = Paragraphs::try_load_cached_package(paths, action.spec).value_or_exit(VCPKG_LINE_INFO);
-                    Install::install_package(paths, bpgh, &status_db);
-                    System::println(System::Color::success, "Package %s is installed", action.spec);
-                }
-                else if (action.plan.plan_type == InstallPlanType::INSTALL)
-                {
-                    results.back() = BuildResult::SUCCEEDED;
-                    Install::install_package(paths, action.plan.binary_pgh.value_or_exit(VCPKG_LINE_INFO), &status_db);
-                    System::println(System::Color::success, "Package %s is installed from cache", action.spec);
-                }
-                else
-                    Checks::unreachable(VCPKG_LINE_INFO);
             }
             catch (const std::exception& e)
             {
@@ -99,7 +107,7 @@ namespace vcpkg::Commands::CI
 
         for (size_t i = 0; i < results.size(); i++)
         {
-            System::println("%s: %s: %dms", install_plan[i].spec.to_string(), Build::to_string(results[i]), timing[i]);
+            System::println("%s: %s: %dms", install_plan[i].spec, Build::to_string(results[i]), timing[i]);
         }
 
         std::map<BuildResult, int> summary;

toolsrc/src/commands_install.cpp

@@ -24,11 +24,11 @@ namespace vcpkg::Commands::Install
         const fs::path package_prefix_path = paths.package_dir(bpgh.spec);
         const size_t prefix_length = package_prefix_path.native().size();
 
-        const Triplet& target_triplet = bpgh.spec.target_triplet();
+        const std::string& triplet_string = bpgh.spec.triplet().canonical_name();
-        const std::string& target_triplet_as_string = target_triplet.canonical_name();
+        const fs::path installed_subfolder_path = paths.installed / triplet_string;
         std::error_code ec;
-        fs.create_directory(paths.installed / target_triplet_as_string, ec);
+        fs.create_directory(installed_subfolder_path, ec);
-        output.push_back(Strings::format(R"(%s/)", target_triplet_as_string));
+        output.push_back(Strings::format(R"(%s/)", triplet_string));
 
         auto files = fs.recursive_find_all_files_in_dir(package_prefix_path);
         for (auto&& file : files)
@@ -48,7 +48,7 @@ namespace vcpkg::Commands::Install
             }
 
             const std::string suffix = file.generic_u8string().substr(prefix_length + 1);
-            const fs::path target = paths.installed / target_triplet_as_string / suffix;
+            const fs::path target = installed_subfolder_path / suffix;
 
             if (fs::is_directory(status))
             {
@@ -59,7 +59,7 @@ namespace vcpkg::Commands::Install
                 }
 
                 // Trailing backslash for directories
-                output.push_back(Strings::format(R"(%s/%s/)", target_triplet_as_string, suffix));
+                output.push_back(Strings::format(R"(%s/%s/)", triplet_string, suffix));
                 continue;
             }
 
@@ -74,7 +74,7 @@ namespace vcpkg::Commands::Install
                 {
                     System::println(System::Color::error, "failed: %s: %s", target.u8string(), ec.message());
                 }
-                output.push_back(Strings::format(R"(%s/%s)", target_triplet_as_string, suffix));
+                output.push_back(Strings::format(R"(%s/%s)", triplet_string, suffix));
                 continue;
             }
 
@@ -105,7 +105,7 @@ namespace vcpkg::Commands::Install
         std::vector<std::string> output;
         for (const StatusParagraphAndAssociatedFiles& t : pgh_and_files)
         {
-            if (t.pgh.package.spec.target_triplet() != triplet)
+            if (t.pgh.package.spec.triplet() != triplet)
             {
                 continue;
             }
@@ -188,7 +188,7 @@ namespace vcpkg::Commands::Install
     void install_package(const VcpkgPaths& paths, const BinaryParagraph& binary_paragraph, StatusParagraphs* status_db)
     {
         const fs::path package_dir = paths.package_dir(binary_paragraph.spec);
-        const Triplet& triplet = binary_paragraph.spec.target_triplet();
+        const Triplet& triplet = binary_paragraph.spec.triplet();
         const std::vector<StatusParagraphAndAssociatedFiles> pgh_and_files = get_installed_files(paths, *status_db);
 
         const SortedVector<std::string> package_files = build_list_of_package_files(paths.get_filesystem(), package_dir);
@@ -217,7 +217,7 @@ namespace vcpkg::Commands::Install
         spgh.state = InstallState::HALF_INSTALLED;
         for (auto&& dep : spgh.package.depends)
         {
-            if (status_db->find_installed(dep, spgh.package.spec.target_triplet()) == status_db->end())
+            if (status_db->find_installed(dep, spgh.package.spec.triplet()) == status_db->end())
             {
                 Checks::unreachable(VCPKG_LINE_INFO);
             }
@@ -232,7 +232,7 @@ namespace vcpkg::Commands::Install
         status_db->insert(std::make_unique<StatusParagraph>(spgh));
     }
 
-    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_target_triplet)
+    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet)
     {
         static const std::string OPTION_DRY_RUN = "--dry-run";
 
@@ -240,12 +240,12 @@ namespace vcpkg::Commands::Install
         static const std::string example = Commands::Help::create_example_string("install zlib zlib:x64-windows curl boost");
         args.check_min_arg_count(1, example);
 
-        auto specs = Util::fmap(args.command_arguments, [&](auto&& arg)
+        const std::vector<PackageSpec> specs = Util::fmap(args.command_arguments, [&](auto&& arg)
                                 {
-                                    auto spec = Input::check_and_get_package_spec(arg, default_target_triplet, example);
+                                    return Input::check_and_get_package_spec(arg, default_triplet, example);
-                                    Input::check_triplet(spec.target_triplet(), paths);
-                                    return spec;
                                 });
+        for (auto&& spec : specs)
+            Input::check_triplet(spec.triplet(), paths);
 
         const std::unordered_set<std::string> options = args.check_and_get_optional_command_arguments({ OPTION_DRY_RUN });
         const bool dryRun = options.find(OPTION_DRY_RUN) != options.cend();
@@ -284,16 +284,18 @@ namespace vcpkg::Commands::Install
         // execute the plan
         for (const PackageSpecWithInstallPlan& action : install_plan)
         {
+            const std::string display_name = action.spec.to_string();
+
             try
             {
                 switch (action.plan.plan_type)
                 {
                     case InstallPlanType::ALREADY_INSTALLED:
-                        System::println(System::Color::success, "Package %s is already installed", action.spec);
+                        System::println(System::Color::success, "Package %s is already installed", display_name);
                         break;
                     case InstallPlanType::BUILD_AND_INSTALL:
                         {
-                            System::println("Building package %s... ", action.spec);
+                            System::println("Building package %s... ", display_name);
                             const Build::BuildResult result = Commands::Build::build_package(action.plan.source_pgh.value_or_exit(VCPKG_LINE_INFO),
                                                                                              action.spec,
                                                                                              paths,
@@ -305,18 +307,18 @@ namespace vcpkg::Commands::Install
                                 System::println(Build::create_user_troubleshooting_message(action.spec));
                                 Checks::exit_fail(VCPKG_LINE_INFO);
                             }
-                            System::println(System::Color::success, "Building package %s... done", action.spec);
+                            System::println(System::Color::success, "Building package %s... done", display_name);
 
                             const BinaryParagraph bpgh = Paragraphs::try_load_cached_package(paths, action.spec).value_or_exit(VCPKG_LINE_INFO);
-                            System::println("Installing package %s... ", action.spec);
+                            System::println("Installing package %s... ", display_name);
                             install_package(paths, bpgh, &status_db);
-                            System::println(System::Color::success, "Installing package %s... done", action.spec);
+                            System::println(System::Color::success, "Installing package %s... done", display_name);
                             break;
                         }
                     case InstallPlanType::INSTALL:
-                        System::println("Installing package %s... ", action.spec);
+                        System::println("Installing package %s... ", display_name);
                         install_package(paths, action.plan.binary_pgh.value_or_exit(VCPKG_LINE_INFO), &status_db);
-                        System::println(System::Color::success, "Installing package %s... done", action.spec);
+                        System::println(System::Color::success, "Installing package %s... done", display_name);
                         break;
                     case InstallPlanType::UNKNOWN:
                     default:

toolsrc/src/commands_remove.cpp

@@ -30,7 +30,7 @@ namespace vcpkg::Commands::Remove
     static void remove_package(const VcpkgPaths& paths, const PackageSpec& spec, StatusParagraphs* status_db)
     {
         auto& fs = paths.get_filesystem();
-        StatusParagraph& pkg = **status_db->find(spec.name(), spec.target_triplet());
+        StatusParagraph& pkg = **status_db->find(spec.name(), spec.triplet());
 
         pkg.want = Want::PURGE;
         pkg.state = InstallState::HALF_INSTALLED;
@@ -136,7 +136,7 @@ namespace vcpkg::Commands::Remove
         }
     }
 
-    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_target_triplet)
+    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet)
     {
         static const std::string OPTION_PURGE = "--purge";
         static const std::string OPTION_NO_PURGE = "--no-purge";
@@ -156,9 +156,9 @@ namespace vcpkg::Commands::Remove
         else
         {
             args.check_min_arg_count(1, example);
-            specs = Util::fmap(args.command_arguments, [&](auto&& arg) { return Input::check_and_get_package_spec(arg, default_target_triplet, example); });
+            specs = Util::fmap(args.command_arguments, [&](auto&& arg) { return Input::check_and_get_package_spec(arg, default_triplet, example); });
             for (auto&& spec : specs)
-                Input::check_triplet(spec.target_triplet(), paths);
+                Input::check_triplet(spec.triplet(), paths);
         }
 
         const bool alsoRemoveFolderFromPackages = options.find(OPTION_NO_PURGE) == options.end();
@@ -200,7 +200,7 @@ namespace vcpkg::Commands::Remove
 
         for (const PackageSpecWithRemovePlan& action : remove_plan)
         {
-            const std::string display_name = action.spec.display_name();
+            const std::string display_name = action.spec.to_string();
 
             switch (action.plan.plan_type)
             {

toolsrc/src/commands_update.cpp

@@ -56,7 +56,7 @@ namespace vcpkg::Commands::Update
             System::println("The following packages differ from their port versions:");
             for (auto&& package : outdated_packages)
             {
-                System::println("    %-32s %s", package.spec.display_name(), package.version_diff.to_string());
+                System::println("    %-32s %s", package.spec, package.version_diff.to_string());
             }
             System::println("\n"
                 "To update these packages, run\n"

toolsrc/src/tests_paragraph.cpp

@@ -111,7 +111,7 @@ namespace UnitTest1
             Assert::AreEqual("1.2.8", pgh.version.c_str());
             Assert::AreEqual("", pgh.maintainer.c_str());
             Assert::AreEqual("", pgh.description.c_str());
-            Assert::AreEqual("x86-windows", pgh.spec.target_triplet().canonical_name().c_str());
+            Assert::AreEqual("x86-windows", pgh.spec.triplet().canonical_name().c_str());
             Assert::AreEqual(size_t(0), pgh.depends.size());
         }
 
@@ -363,7 +363,7 @@ namespace UnitTest1
             vcpkg::Expected<vcpkg::PackageSpec> spec = vcpkg::PackageSpec::from_string("zlib", vcpkg::Triplet::X86_WINDOWS);
             Assert::AreEqual(vcpkg::PackageSpecParseResult::SUCCESS, vcpkg::to_package_spec_parse_result(spec.error_code()));
             Assert::AreEqual("zlib", spec.get()->name().c_str());
-            Assert::AreEqual(vcpkg::Triplet::X86_WINDOWS.canonical_name(), spec.get()->target_triplet().canonical_name());
+            Assert::AreEqual(vcpkg::Triplet::X86_WINDOWS.canonical_name(), spec.get()->triplet().canonical_name());
         }
 
         TEST_METHOD(package_spec_parse_with_arch)
@@ -371,7 +371,7 @@ namespace UnitTest1
             vcpkg::Expected<vcpkg::PackageSpec> spec = vcpkg::PackageSpec::from_string("zlib:x64-uwp", vcpkg::Triplet::X86_WINDOWS);
             Assert::AreEqual(vcpkg::PackageSpecParseResult::SUCCESS, vcpkg::to_package_spec_parse_result(spec.error_code()));
             Assert::AreEqual("zlib", spec.get()->name().c_str());
-            Assert::AreEqual(vcpkg::Triplet::X64_UWP.canonical_name(), spec.get()->target_triplet().canonical_name());
+            Assert::AreEqual(vcpkg::Triplet::X64_UWP.canonical_name(), spec.get()->triplet().canonical_name());
         }
 
         TEST_METHOD(package_spec_parse_with_multiple_colon)

toolsrc/src/triplet.cpp

@@ -11,16 +11,6 @@ namespace vcpkg
     const Triplet Triplet::X64_UWP = from_canonical_name("x64-uwp");
     const Triplet Triplet::ARM_UWP = from_canonical_name("arm-uwp");
 
-    std::string to_string(const Triplet& t)
-    {
-        return t.canonical_name();
-    }
-
-    std::string to_printf_arg(const Triplet& t)
-    {
-        return to_string(t);
-    }
-
     bool operator==(const Triplet& left, const Triplet& right)
     {
         return left.canonical_name() == right.canonical_name();
@@ -31,11 +21,6 @@ namespace vcpkg
         return !(left == right);
     }
 
-    std::ostream& operator<<(std::ostream& os, const Triplet& t)
-    {
-        return os << to_string(t);
-    }
-
     Triplet Triplet::from_canonical_name(const std::string& triplet_as_string)
     {
         const std::string s(Strings::ascii_to_lowercase(triplet_as_string));
@@ -63,4 +48,9 @@ namespace vcpkg
         auto it = std::find(this->m_canonical_name.cbegin(), this->m_canonical_name.cend(), '-');
         return std::string(it + 1, this->m_canonical_name.cend());
     }
+
+    const std::string& Triplet::to_string() const
+    {
+        return this->m_canonical_name;
+    }
 }

toolsrc/src/vcpkg.cpp

@@ -69,29 +69,29 @@ static void inner(const VcpkgCmdArguments& args)
         return command_function(args, paths);
     }
 
-    Triplet default_target_triplet;
+    Triplet default_triplet;
-    if (args.target_triplet != nullptr)
+    if (args.triplet != nullptr)
     {
-        default_target_triplet = Triplet::from_canonical_name(*args.target_triplet);
+        default_triplet = Triplet::from_canonical_name(*args.triplet);
     }
     else
     {
         const Optional<std::wstring> vcpkg_default_triplet_env = System::get_environmental_variable(L"VCPKG_DEFAULT_TRIPLET");
         if (auto v = vcpkg_default_triplet_env.get())
         {
-            default_target_triplet = Triplet::from_canonical_name(Strings::utf16_to_utf8(*v));
+            default_triplet = Triplet::from_canonical_name(Strings::utf16_to_utf8(*v));
         }
         else
         {
-            default_target_triplet = Triplet::X86_WINDOWS;
+            default_triplet = Triplet::X86_WINDOWS;
         }
     }
 
-    Input::check_triplet(default_target_triplet, paths);
+    Input::check_triplet(default_triplet, paths);
 
     if (auto command_function = Commands::find(args.command, Commands::get_available_commands_type_a()))
     {
-        return command_function(args, paths, default_target_triplet);
+        return command_function(args, paths, default_triplet);
     }
 
     return invalid_command(args.command);

toolsrc/src/vcpkg_Dependencies.cpp

@@ -69,7 +69,7 @@ namespace vcpkg::Dependencies
                 {
                     for (const std::string& dep_as_string : dependencies_as_string)
                     {
-                        const PackageSpec current_dep = PackageSpec::from_name_and_triplet(dep_as_string, spec.target_triplet()).value_or_exit(VCPKG_LINE_INFO);
+                        const PackageSpec current_dep = PackageSpec::from_name_and_triplet(dep_as_string, spec.triplet()).value_or_exit(VCPKG_LINE_INFO);
                         auto it = status_db.find_installed(current_dep);
                         if (it != status_db.end())
                         {
@@ -103,7 +103,7 @@ namespace vcpkg::Dependencies
             Expected<SourceParagraph> maybe_spgh = Paragraphs::try_load_port(paths.get_filesystem(), paths.port_dir(spec));
             if (auto spgh = maybe_spgh.get())
             {
-                process_dependencies(filter_dependencies(spgh->depends, spec.target_triplet()));
+                process_dependencies(filter_dependencies(spgh->depends, spec.triplet()));
                 was_examined.emplace(spec, InstallPlanAction{ InstallPlanType::BUILD_AND_INSTALL, request_type, nullopt, std::move(*spgh) });
             }
             else
@@ -152,7 +152,7 @@ namespace vcpkg::Dependencies
             {
                 if (an_installed_package->want != Want::INSTALL)
                     continue;
-                if (an_installed_package->package.spec.target_triplet() != spec.target_triplet())
+                if (an_installed_package->package.spec.triplet() != spec.triplet())
                     continue;
 
                 const std::vector<std::string>& deps = an_installed_package->package.depends;

toolsrc/src/vcpkg_Input.cpp

@@ -6,10 +6,10 @@
 
 namespace vcpkg::Input
 {
-    PackageSpec check_and_get_package_spec(const std::string& package_spec_as_string, const Triplet& default_target_triplet, CStringView example_text)
+    PackageSpec check_and_get_package_spec(const std::string& package_spec_as_string, const Triplet& default_triplet, CStringView example_text)
     {
         const std::string as_lowercase = Strings::ascii_to_lowercase(package_spec_as_string);
-        Expected<PackageSpec> expected_spec = PackageSpec::from_string(as_lowercase, default_target_triplet);
+        Expected<PackageSpec> expected_spec = PackageSpec::from_string(as_lowercase, default_triplet);
         if (auto spec = expected_spec.get())
         {
             return *spec;
@@ -25,8 +25,8 @@ namespace vcpkg::Input
     {
         if (!paths.is_valid_triplet(t))
         {
-            System::println(System::Color::error, "Error: invalid triplet: %s", t.canonical_name());
+            System::println(System::Color::error, "Error: invalid triplet: %s", t);
-            Metrics::track_property("error", "invalid triplet: " + t.canonical_name());
+            Metrics::track_property("error", "invalid triplet: " + t.to_string());
             Commands::Help::help_topic_valid_triplet(paths);
             Checks::exit_fail(VCPKG_LINE_INFO);
         }