[scripts-audit] Rollup PR 2021-02-26 (#16440)

* [scripts-audit rollup] PR #16419

* pull the cmake doc comment parsing out into its own function
* support cmake helper ports
* add real support for deprecation, as opposed to ad-hoc

* [scripts-audit rollup] PR #16192

* add a z_ in front of internal functions
* move internal functions out

set feature_vars again in parent scope

* [scripts-audit rollup] PR #16309

Audit vcpkg_copy_pdbs

* [scripts-audit rollup] PR #16304

* Fix usage, documentation

* [scripts-audit rollup] PR #16393

* [scripts-audit rollup] PR #16377

Deprecate `vcpkg_*_cmake` in favor of `vcpkg_cmake_*` from the
`vcpkg-cmake` port, as well as `vcpkg_fixup_cmake_targets`
in favor of `vcpkg_cmake_config_fixup` from the
`vcpkg-cmake-config` port.

12 files changed, 423 insertions, 300 deletions

diff --git a/scripts/ci.baseline.txt b/scripts/ci.baseline.txt
index 257db0c3d..fca598faa 100644
--- a/scripts/ci.baseline.txt
+++ b/scripts/ci.baseline.txt
@@ -27,8 +27,24 @@
 ##    x86-windows
 ##
 
-
 # Add new items alphabetically
+
+# script ports
+vcpkg-cmake:arm64-windows=fail
+vcpkg-cmake:arm-uwp=fail
+vcpkg-cmake:x64-uwp=fail
+vcpkg-cmake:x64-windows-static=fail
+vcpkg-cmake:x64-windows-static-md=fail
+vcpkg-cmake:x86-windows=fail
+
+vcpkg-cmake-config:arm64-windows=fail
+vcpkg-cmake-config:arm-uwp=fail
+vcpkg-cmake-config:x64-uwp=fail
+vcpkg-cmake-config:x64-windows-static=fail
+vcpkg-cmake-config:x64-windows-static-md=fail
+vcpkg-cmake-config:x86-windows=fail
+
+# other ports
 # Cross compiling CI machine cannot run gen_test_char to generate apr_escape_test_char.h
 apr:arm64-windows=fail
 # Requires ATL for ARM64 to be installed in CI
diff --git a/scripts/cmake/vcpkg_apply_patches.cmake b/scripts/cmake/vcpkg_apply_patches.cmake
index b2e226351..bd4325af4 100644
--- a/scripts/cmake/vcpkg_apply_patches.cmake
+++ b/scripts/cmake/vcpkg_apply_patches.cmake
@@ -1,9 +1,10 @@
+# DEPRECATED: in favor of the `PATCHES` argument to `vcpkg_from_github()` et al.
+
 #[===[.md
 # vcpkg_apply_patches
 
-Apply a set of patches to a source tree. This function is deprecated in favor of the `PATCHES` argument to `vcpkg_from_github()` et al.
+Apply a set of patches to a source tree.
 
-## Usage
 ```cmake
 vcpkg_apply_patches(
     SOURCE_PATH <${SOURCE_PATH}>
@@ -11,63 +12,22 @@ vcpkg_apply_patches(
     PATCHES <patch1.patch>...
 )
 ```
-
-## Parameters
-### SOURCE_PATH
-The source path in which apply the patches. By convention, this is usually set in the portfile as the variable `SOURCE_PATH`.
-
-### PATCHES
-A list of patches that are applied to the source tree.
-
-Generally, these take the form of `${CMAKE_CURRENT_LIST_DIR}/some.patch` to select patches in the `port\<port>\` directory.
-
-### QUIET
-Disables the warning message upon failure.
-
-This should only be used for edge cases, such as patches that are known to fail even on a clean source tree.
-
-## Examples
-
-* [libbson](https://github.com/Microsoft/vcpkg/blob/master/ports/libbson/portfile.cmake)
-* [gdal](https://github.com/Microsoft/vcpkg/blob/master/ports/gdal/portfile.cmake)
 #]===]
 
-include(vcpkg_execute_in_download_mode)
-
 function(vcpkg_apply_patches)
-    # parse parameters such that semicolons in options arguments to COMMAND don't get erased
-    cmake_parse_arguments(PARSE_ARGV 0 _ap "QUIET" "SOURCE_PATH" "PATCHES")
-
-    find_program(GIT NAMES git git.cmd)
-    if(DEFINED ENV{GIT_CONFIG_NOSYSTEM})
-        set(GIT_CONFIG_NOSYSTEM_BACKUP "$ENV{GIT_CONFIG_NOSYSTEM}")
-    else()
-        unset(GIT_CONFIG_NOSYSTEM_BACKUP)
-    endif()
-    set(ENV{GIT_CONFIG_NOSYSTEM} 1)
-    set(PATCHNUM 0)
-    foreach(PATCH ${_ap_PATCHES})
-        get_filename_component(ABSOLUTE_PATCH "${PATCH}" ABSOLUTE BASE_DIR "${CURRENT_PORT_DIR}")
-        message(STATUS "Applying patch ${PATCH}")
-        set(LOGNAME patch-${TARGET_TRIPLET}-${PATCHNUM})
-        vcpkg_execute_in_download_mode(
-            COMMAND ${GIT} -c core.longpaths=true -c core.autocrlf=false --work-tree=. --git-dir=.git apply "${ABSOLUTE_PATCH}" --ignore-whitespace --whitespace=nowarn --verbose
-            OUTPUT_FILE ${CURRENT_BUILDTREES_DIR}/${LOGNAME}-out.log
-            ERROR_VARIABLE error
-            WORKING_DIRECTORY ${_ap_SOURCE_PATH}
-            RESULT_VARIABLE error_code
-        )
-        file(WRITE "${CURRENT_BUILDTREES_DIR}/${LOGNAME}-err.log" "${error}")
+    z_vcpkg_deprecation_message("vcpkg_apply_patches has been deprecated in favor of the `PATCHES` argument to `vcpkg_from_*`.")
 
-        if(error_code AND NOT _ap_QUIET)
-            message(FATAL_ERROR "Applying patch failed. ${error}")
-        endif()
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "QUIET" "SOURCE_PATH" "PATCHES")
 
-        math(EXPR PATCHNUM "${PATCHNUM}+1")
-    endforeach()
-    if(DEFINED GIT_CONFIG_NOSYSTEM_BACKUP)
-        set(ENV{GIT_CONFIG_NOSYSTEM} "${GIT_CONFIG_NOSYSTEM_BACKUP}")
+    if(arg_QUIET)
+        set(quiet "QUIET")
     else()
-        unset(ENV{GIT_CONFIG_NOSYSTEM})
+        set(quiet)
     endif()
+
+    z_vcpkg_apply_patches(
+        SOURCE_PATH "${arg_SOURCE_PATH}"
+        ${quiet}
+        PATCHES ${arg_PATCHES}
+    )
 endfunction()
diff --git a/scripts/cmake/vcpkg_build_cmake.cmake b/scripts/cmake/vcpkg_build_cmake.cmake
index d463d29c7..2b1571413 100644
--- a/scripts/cmake/vcpkg_build_cmake.cmake
+++ b/scripts/cmake/vcpkg_build_cmake.cmake
@@ -1,6 +1,8 @@
 #[===[.md:
 # vcpkg_build_cmake
 
+**This function has been deprecated in favor of `vcpkg_cmake_build` from the vcpkg-cmake port.**
+
 Build a cmake project.
 
 ## Usage:
@@ -33,34 +35,44 @@ You can use the alias [`vcpkg_install_cmake()`](vcpkg_configure_cmake.md) functi
 #]===]
 
 function(vcpkg_build_cmake)
-    # parse parameters such that semicolons in options arguments to COMMAND don't get erased
-    cmake_parse_arguments(PARSE_ARGV 0 _bc "DISABLE_PARALLEL;ADD_BIN_TO_PATH" "TARGET;LOGFILE_ROOT" "")
+    cmake_parse_arguments(PARSE_ARGV 0 "arg"
+        "DISABLE_PARALLEL;ADD_BIN_TO_PATH;Z_VCPKG_DISABLE_DEPRECATION_MESSAGE"
+        "TARGET;LOGFILE_ROOT"
+        ""
+    )
+
+    if(NOT arg_Z_VCPKG_DISABLE_DEPRECATION_MESSAGE)
+        message(DEPRECATION "vcpkg_build_cmake has been deprecated in favor of vcpkg_cmake_build from the vcpkg-cmake port.")
+    endif()
+    if(Z_VCPKG_CMAKE_BUILD_GUARD)
+        message(FATAL_ERROR "The ${PORT} port already depends on vcpkg-cmake; using both vcpkg-cmake and vcpkg_build_cmake in the same port is unsupported.")
+    endif()
 
-    if(NOT _bc_LOGFILE_ROOT)
-        set(_bc_LOGFILE_ROOT "build")
+    if(NOT arg_LOGFILE_ROOT)
+        set(arg_LOGFILE_ROOT "build")
     endif()
 
     set(PARALLEL_ARG)
     set(NO_PARALLEL_ARG)
 
-    if(_VCPKG_CMAKE_GENERATOR MATCHES "Ninja")
+    if(Z_VCPKG_CMAKE_GENERATOR MATCHES "Ninja")
         set(BUILD_ARGS "-v") # verbose output
         set(PARALLEL_ARG "-j${VCPKG_CONCURRENCY}")
         set(NO_PARALLEL_ARG "-j1")
-    elseif(_VCPKG_CMAKE_GENERATOR MATCHES "Visual Studio")
+    elseif(Z_VCPKG_CMAKE_GENERATOR MATCHES "Visual Studio")
         set(BUILD_ARGS
             "/p:VCPkgLocalAppDataDisabled=true"
             "/p:UseIntelMKL=No"
         )
         set(PARALLEL_ARG "/m")
-    elseif(_VCPKG_CMAKE_GENERATOR MATCHES "NMake")
+    elseif(Z_VCPKG_CMAKE_GENERATOR MATCHES "NMake")
         # No options are currently added for nmake builds
     else()
         message(FATAL_ERROR "Unrecognized GENERATOR setting from vcpkg_configure_cmake(). Valid generators are: Ninja, Visual Studio, and NMake Makefiles")
     endif()
 
-    if(_bc_TARGET)
-        set(TARGET_PARAM "--target" ${_bc_TARGET})
+    if(arg_TARGET)
+        set(TARGET_PARAM "--target" ${arg_TARGET})
     else()
         set(TARGET_PARAM)
     endif()
@@ -77,7 +89,7 @@ function(vcpkg_build_cmake)
 
             message(STATUS "Building ${TARGET_TRIPLET}-${SHORT_BUILDTYPE}")
 
-            if(_bc_ADD_BIN_TO_PATH)
+            if(arg_ADD_BIN_TO_PATH)
                 set(_BACKUP_ENV_PATH "$ENV{PATH}")
                 if(BUILDTYPE STREQUAL "debug")
                     vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}/debug/bin")
@@ -86,22 +98,22 @@ function(vcpkg_build_cmake)
                 endif()
             endif()
 
-            if (_bc_DISABLE_PARALLEL)
+            if (arg_DISABLE_PARALLEL)
                 vcpkg_execute_build_process(
                     COMMAND ${CMAKE_COMMAND} --build . --config ${CONFIG} ${TARGET_PARAM} -- ${BUILD_ARGS} ${NO_PARALLEL_ARG}
                     WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SHORT_BUILDTYPE}
-                    LOGNAME "${_bc_LOGFILE_ROOT}-${TARGET_TRIPLET}-${SHORT_BUILDTYPE}"
+                    LOGNAME "${arg_LOGFILE_ROOT}-${TARGET_TRIPLET}-${SHORT_BUILDTYPE}"
                 )
             else()
                 vcpkg_execute_build_process(
                     COMMAND ${CMAKE_COMMAND} --build . --config ${CONFIG} ${TARGET_PARAM} -- ${BUILD_ARGS} ${PARALLEL_ARG}
                     NO_PARALLEL_COMMAND ${CMAKE_COMMAND} --build . --config ${CONFIG} ${TARGET_PARAM} -- ${BUILD_ARGS} ${NO_PARALLEL_ARG}
                     WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SHORT_BUILDTYPE}
-                    LOGNAME "${_bc_LOGFILE_ROOT}-${TARGET_TRIPLET}-${SHORT_BUILDTYPE}"
+                    LOGNAME "${arg_LOGFILE_ROOT}-${TARGET_TRIPLET}-${SHORT_BUILDTYPE}"
                 )
             endif()
 
-            if(_bc_ADD_BIN_TO_PATH)
+            if(arg_ADD_BIN_TO_PATH)
                 set(ENV{PATH} "${_BACKUP_ENV_PATH}")
             endif()
         endif()
diff --git a/scripts/cmake/vcpkg_check_features.cmake b/scripts/cmake/vcpkg_check_features.cmake
index be4e1265c..7679b0d11 100644
--- a/scripts/cmake/vcpkg_check_features.cmake
+++ b/scripts/cmake/vcpkg_check_features.cmake
@@ -2,53 +2,43 @@
 # vcpkg_check_features
 Check if one or more features are a part of a package installation.
 
-## Usage
 ```cmake
 vcpkg_check_features(
-  OUT_FEATURE_OPTIONS <FEATURE_OPTIONS>
-  [FEATURES
-    <cuda> <WITH_CUDA>
-    [<opencv> <WITH_OPENCV>]
-    ...]
-  [INVERTED_FEATURES
-    <cuda> <IGNORE_PACKAGE_CUDA>
-    [<opencv> <IGNORE_PACKAGE_OPENCV>]
-    ...]
+    OUT_FEATURE_OPTIONS <out-var>
+    [PREFIX <prefix>]
+    [FEATURES
+        [<feature-name> <feature-var>]...
+        ]
+    [INVERTED_FEATURES
+        [<feature-name> <feature-var>]...
+        ]
 )
 ```
-`vcpkg_check_features()` accepts these parameters:
 
-* `OUT_FEATURE_OPTIONS`:
-  An output variable, the function will clear the variable passed to `OUT_FEATURE_OPTIONS`
-  and then set it to contain a list of option definitions (`-D<OPTION_NAME>=ON|OFF`).
+The `<out-var>` should be set to `FEATURE_OPTIONS` by convention.
 
-  This should be set to `FEATURE_OPTIONS` by convention.
+`vcpkg_check_features()` will:
 
-* `FEATURES`:
-  A list of (`FEATURE_NAME`, `OPTION_NAME`) pairs.
-  For each `FEATURE_NAME` a definition is added to `OUT_FEATURE_OPTIONS` in the form of:
+- for each `<feature-name>` passed in `FEATURES`:
+    - if the feature is set, add `-D<feature-var>=ON` to `<out-var>`,
+      and set `<prefix>_<feature-var>` to ON.
+    - if the feature is not set, add `-D<feature-var>=OFF` to `<out-var>`,
+      and set `<prefix>_<feature-var>` to OFF.
+- for each `<feature-name>` passed in `INVERTED_FEATURES`:
+    - if the feature is set, add `-D<feature-var>=OFF` to `<out-var>`,
+      and set `<prefix>_<feature-var>` to OFF.
+    - if the feature is not set, add `-D<feature-var>=ON` to `<out-var>`,
+      and set `<prefix>_<feature-var>` to ON.
 
-    * `-D<OPTION_NAME>=ON`, if a feature is specified for installation,
-    * `-D<OPTION_NAME>=OFF`, otherwise.
+If `<prefix>` is not passed, then the feature vars set are simply `<feature-var>`,
+not `_<feature-var>`.
 
-* `INVERTED_FEATURES`:
-  A list of (`FEATURE_NAME`, `OPTION_NAME`) pairs, uses reversed logic from `FEATURES`.
-  For each `FEATURE_NAME` a definition is added to `OUT_FEATURE_OPTIONS` in the form of:
-
-    * `-D<OPTION_NAME>=OFF`, if a feature is specified for installation,
-    * `-D<OPTION_NAME>=ON`, otherwise.
-
-
-## Notes
-
-The `FEATURES` name parameter can be omitted if no `INVERTED_FEATURES` are used.
-
-At least one (`FEATURE_NAME`, `OPTION_NAME`) pair must be passed to the function call.
-
-Arguments passed to `FEATURES` and `INVERTED_FEATURES` are not validated to prevent duplication.
-If the same (`FEATURE_NAME`, `OPTION_NAME`) pair is passed to both lists,
-two conflicting definitions are added to `OUT_FEATURE_OPTIONS`.
+If `INVERTED_FEATURES` is not passed, then the `FEATURES` keyword is optional.
+This behavior is deprecated.
 
+If the same `<feature-var>` is passed multiple times,
+then `vcpkg_check_features` will cause a fatal error,
+since that is a bug.
 
 ## Examples
 
@@ -59,18 +49,18 @@ $ ./vcpkg install mimalloc[asm,secure]
 
 # ports/mimalloc/portfile.cmake
 vcpkg_check_features(OUT_FEATURE_OPTIONS FEATURE_OPTIONS
-  # Keyword FEATURES is optional if INVERTED_FEATURES are not used
-    asm       MI_SEE_ASM
-    override  MI_OVERRIDE
-    secure    MI_SECURE
+    FEATURES
+        asm       MI_SEE_ASM
+        override  MI_OVERRIDE
+        secure    MI_SECURE
 )
 
 vcpkg_configure_cmake(
-  SOURCE_PATH ${SOURCE_PATH}
-  PREFER_NINJA
-  OPTIONS
-    # Expands to "-DMI_SEE_ASM=ON; -DMI_OVERRIDE=OFF; -DMI_SECURE=ON"
-    ${FEATURE_OPTIONS}
+    SOURCE_PATH ${SOURCE_PATH}
+    PREFER_NINJA
+    OPTIONS
+        # Expands to "-DMI_SEE_ASM=ON;-DMI_OVERRIDE=OFF;-DMI_SECURE=ON"
+        ${FEATURE_OPTIONS}
 )
 ```
 
@@ -80,18 +70,18 @@ vcpkg_configure_cmake(
 $ ./vcpkg install cpprestsdk[websockets]
 
 # ports/cpprestsdk/portfile.cmake
-vcpkg_check_features(OUT_FEATURE_OPTIONS FEATURE_OPTIONS
-  INVERTED_FEATURES # <- Keyword INVERTED_FEATURES required
-    brotli      CPPREST_EXCLUDE_BROTLI
-    websockets  CPPREST_EXCLUDE_WEBSOCKETS
+vcpkg_check_features(
+    INVERTED_FEATURES
+        brotli      CPPREST_EXCLUDE_BROTLI
+        websockets  CPPREST_EXCLUDE_WEBSOCKETS
 )
 
 vcpkg_configure_cmake(
-  SOURCE_PATH ${SOURCE_PATH}
-  PREFER_NINJA
-  OPTIONS
-    # Expands to "-DCPPREST_EXCLUDE_BROTLI=ON; -DCPPREST_EXCLUDE_WEBSOCKETS=OFF"
-    ${FEATURE_OPTIONS}
+    SOURCE_PATH ${SOURCE_PATH}
+    PREFER_NINJA
+    OPTIONS
+        # Expands to "-DCPPREST_EXCLUDE_BROTLI=ON;-DCPPREST_EXCLUDE_WEBSOCKETS=OFF"
+        ${FEATURE_OPTIONS}
 )
 ```
 
@@ -101,18 +91,19 @@ vcpkg_configure_cmake(
 $ ./vcpkg install pcl[cuda]
 
 # ports/pcl/portfile.cmake
-vcpkg_check_features(OUT_FEATURE_OPTIONS FEATURE_OPTIONS
-    cuda  WITH_CUDA
-    cuda  BUILD_CUDA
-    cuda  BUILD_GPU
+vcpkg_check_features(
+    FEATURES
+        cuda  WITH_CUDA
+        cuda  BUILD_CUDA
+        cuda  BUILD_GPU
 )
 
 vcpkg_configure_cmake(
-  SOURCE_PATH ${SOURCE_PATH}
-  PREFER_NINJA
-  OPTIONS
-    # Expands to "-DWITH_CUDA=ON; -DBUILD_CUDA=ON; -DBUILD_GPU=ON"
-    ${FEATURE_OPTIONS}
+    SOURCE_PATH ${SOURCE_PATH}
+    PREFER_NINJA
+    OPTIONS
+        # Expands to "-DWITH_CUDA=ON;-DBUILD_CUDA=ON;-DBUILD_GPU=ON"
+        ${FEATURE_OPTIONS}
 )
 ```
 
@@ -122,19 +113,19 @@ vcpkg_configure_cmake(
 $ ./vcpkg install rocksdb[tbb]
 
 # ports/rocksdb/portfile.cmake
-vcpkg_check_features(OUT_FEATURE_OPTIONS FEATURE_OPTIONS
-  FEATURES # <- Keyword FEATURES is required because INVERTED_FEATURES are being used
-    tbb   WITH_TBB
-  INVERTED_FEATURES
-    tbb   ROCKSDB_IGNORE_PACKAGE_TBB
+vcpkg_check_features(
+    FEATURES
+        tbb   WITH_TBB
+    INVERTED_FEATURES
+        tbb   ROCKSDB_IGNORE_PACKAGE_TBB
 )
 
 vcpkg_configure_cmake(
-  SOURCE_PATH ${SOURCE_PATH}
-  PREFER_NINJA
-  OPTIONS
-    # Expands to "-DWITH_TBB=ON; -DROCKSDB_IGNORE_PACKAGE_TBB=OFF"
-    ${FEATURE_OPTIONS}
+    SOURCE_PATH ${SOURCE_PATH}
+    PREFER_NINJA
+    OPTIONS
+        # Expands to "-DWITH_TBB=ON;-DROCKSDB_IGNORE_PACKAGE_TBB=OFF"
+        ${FEATURE_OPTIONS}
 )
 ```
 
@@ -145,52 +136,98 @@ vcpkg_configure_cmake(
 * [rocksdb](https://github.com/microsoft/vcpkg/blob/master/ports/rocksdb/portfile.cmake)
 #]===]
 
+function(z_vcpkg_check_features_last_feature out_var features_name features_list)
+    list(LENGTH features_list features_length)
+    math(EXPR features_length_mod_2 "${features_length} % 2")
+    if(NOT features_length_mod_2 EQUAL 0)
+        message(FATAL_ERROR "vcpkg_check_features has an incorrect number of arguments to ${features_name}")
+    endif()
+
+    math(EXPR last_feature "${features_length} / 2 - 1")
+    set("${out_var}" "${last_feature}" PARENT_SCOPE)
+endfunction()
+
+function(z_vcpkg_check_features_get_feature idx features_list out_feature_name out_feature_var)
+    math(EXPR feature_name_idx "${idx} * 2")
+    math(EXPR feature_var_idx "${feature_name_idx} + 1")
+
+    list(GET features_list "${feature_name_idx}" feature_name)
+    list(GET features_list "${feature_var_idx}" feature_var)
+
+    set("${out_feature_name}" "${feature_name}" PARENT_SCOPE)
+    set("${out_feature_var}" "${feature_var}" PARENT_SCOPE)
+endfunction()
+
 function(vcpkg_check_features)
-    # parse parameters such that semicolons in options arguments to COMMAND don't get erased
-    cmake_parse_arguments(PARSE_ARGV 0 _vcf "" "OUT_FEATURE_OPTIONS" "FEATURES;INVERTED_FEATURES")
+    cmake_parse_arguments(
+        PARSE_ARGV 0 "arg"
+        ""
+        "OUT_FEATURE_OPTIONS;PREFIX"
+        "FEATURES;INVERTED_FEATURES"
+    )
+
+    if(NOT DEFINED arg_OUT_FEATURE_OPTIONS)
+        message(FATAL_ERROR "OUT_FEATURE_OPTIONS must be defined.")
+    endif()
+    if(NOT DEFINED arg_PREFIX)
+        set(prefix "")
+    else()
+        set(prefix "${arg_PREFIX}_")
+    endif()
 
-    if (NOT DEFINED _vcf_OUT_FEATURE_OPTIONS)
-        message(FATAL_ERROR "OUT_FEATURE_OPTIONS must be specified.")
+    set(feature_options)
+    set(feature_variables)
+
+    if(NOT DEFINED arg_FEATURES AND NOT DEFINED arg_INVERTED_FEATURES)
+        message(DEPRECATION
+"calling `vcpkg_check_features` without the `FEATURES` keyword has been deprecated.
+    Please add the `FEATURES` keyword to the call.")
+        set(arg_FEATURES "${arg_UNPARSED_ARGUMENTS}")
+    elseif(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "vcpkg_check_features called with unknown arguments: ${arg_UNPARSED_ARGUMENTS}")
     endif()
 
-    macro(_check_features _vcf_ARGUMENT _set_if _set_else)
-        list(LENGTH ${_vcf_ARGUMENT} FEATURES_SET_LEN)
-        math(EXPR _vcf_INCORRECT_ARGN "${FEATURES_SET_LEN} % 2")
-        if(_vcf_INCORRECT_ARGN)
-            message(FATAL_ERROR "Called with incorrect number of arguments.")
-        endif()
 
-        set(_vcf_IS_FEATURE_NAME_ARG ON)
-        foreach(_vcf_ARG ${${_vcf_ARGUMENT}})
-            if(_vcf_IS_FEATURE_NAME_ARG)
-                set(_vcf_FEATURE_NAME ${_vcf_ARG})
-                if(NOT ${_vcf_FEATURE_NAME} IN_LIST ALL_FEATURES)
-                    message(FATAL_ERROR "Unknown feature: ${_vcf_FEATURE_NAME}")
-                endif()
-                set(_vcf_IS_FEATURE_NAME_ARG OFF)
+
+    z_vcpkg_check_features_last_feature(last_feature "FEATURES" "${arg_FEATURES}")
+    if(last_feature GREATER_EQUAL 0)
+        foreach(feature_pair_idx RANGE "${last_feature}")
+            z_vcpkg_check_features_get_feature("${feature_pair_idx}" "${arg_FEATURES}" feature_name feature_var)
+
+            list(APPEND feature_variables "${feature_var}")
+            if(feature_name IN_LIST FEATURES)
+                list(APPEND feature_options "-D${feature_var}=ON")
+                set("${prefix}${feature_var}" ON PARENT_SCOPE)
             else()
-                set(_vcf_FEATURE_VARIABLE ${_vcf_ARG})
-                if(${_vcf_FEATURE_NAME} IN_LIST FEATURES)
-                    list(APPEND _vcf_FEATURE_OPTIONS "-D${_vcf_FEATURE_VARIABLE}=${_set_if}")
-                    set(${_vcf_FEATURE_VARIABLE} "${_set_if}" PARENT_SCOPE)
-                else()
-                    list(APPEND _vcf_FEATURE_OPTIONS "-D${_vcf_FEATURE_VARIABLE}=${_set_else}")
-                    set(${_vcf_FEATURE_VARIABLE} "${_set_else}" PARENT_SCOPE)
-                endif()
-                set(_vcf_IS_FEATURE_NAME_ARG ON)
+                list(APPEND feature_options "-D${feature_var}=OFF")
+                set("${prefix}${feature_var}" OFF PARENT_SCOPE)
             endif()
         endforeach()
-    endmacro()
+    endif()
 
-    set(_vcf_FEATURE_OPTIONS)
+    z_vcpkg_check_features_last_feature(last_inverted_feature "INVERTED_FEATURES" "${arg_INVERTED_FEATURES}")
+    if(last_inverted_feature GREATER_EQUAL 0)
+        foreach(feature_pair_idx RANGE "${last_inverted_feature}")
+            z_vcpkg_check_features_get_feature("${feature_pair_idx}" "${arg_INVERTED_FEATURES}" feature_name feature_var)
 
-    if (DEFINED _vcf_FEATURES OR DEFINED _vcf_INVERTED_FEATURES)
-        _check_features(_vcf_FEATURES ON OFF)
-        _check_features(_vcf_INVERTED_FEATURES OFF ON)
-    else()
-        # Skip arguments that correspond to OUT_FEATURE_OPTIONS and its value.
-        list(SUBLIST ARGN 2 -1 _vcf_ARGN)
-        _check_features(_vcf_ARGN ON OFF)
+            list(APPEND feature_variables "${feature_var}")
+            if(feature_name IN_LIST FEATURES)
+                list(APPEND feature_options "-D${feature_var}=OFF")
+                set("${prefix}${feature_var}" OFF PARENT_SCOPE)
+            else()
+                list(APPEND feature_options "-D${feature_var}=ON")
+                set("${prefix}${feature_var}" ON PARENT_SCOPE)
+            endif()
+        endforeach()
     endif()
-    set(${_vcf_OUT_FEATURE_OPTIONS} "${_vcf_FEATURE_OPTIONS}" PARENT_SCOPE)
+
+    list(SORT feature_variables)
+    set(last_variable)
+    foreach(variable IN LISTS feature_variables)
+        if(variable STREQUAL last_variable)
+            message(FATAL_ERROR "vcpkg_check_features passed the same feature variable multiple times: '${variable}'")
+        endif()
+    endforeach()
+
+    set("${arg_OUT_FEATURE_OPTIONS}" "${feature_options}" PARENT_SCOPE)
 endfunction()
diff --git a/scripts/cmake/vcpkg_common_definitions.cmake b/scripts/cmake/vcpkg_common_definitions.cmake
index f63d6467a..897d30832 100644
--- a/scripts/cmake/vcpkg_common_definitions.cmake
+++ b/scripts/cmake/vcpkg_common_definitions.cmake
@@ -1,9 +1,8 @@
 #[===[.md:
 # vcpkg_common_definitions
 
-File contains helpful variabls for portfiles which are commonly needed or used.
+This file defines the following variabls which are commonly needed or used in portfiles:
 
-## The following variables are available:
 ```cmake
 VCPKG_TARGET_IS_<target>                 with <target> being one of the following: WINDOWS, UWP, LINUX, OSX, ANDROID, FREEBSD, OPENBSD. only defined if <target>
 VCPKG_HOST_IS_<target>                   with <host> being one of the following: WINDOWS, LINUX, OSX, FREEBSD, OPENBSD. only defined if <host>
@@ -27,39 +26,39 @@ portfiles are able to use find_library calls to discover dependent libraries wit
 #]===]
 
 #Helper variable to identify the Target system. VCPKG_TARGET_IS_<targetname>
-if (NOT VCPKG_CMAKE_SYSTEM_NAME OR VCPKG_CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
-    set(VCPKG_TARGET_IS_WINDOWS 1)
-    if(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
-        set(VCPKG_TARGET_IS_UWP 1)
-    endif()
+if (NOT DEFINED VCPKG_CMAKE_SYSTEM_NAME OR VCPKG_CMAKE_SYSTEM_NAME STREQUAL "")
+    set(VCPKG_TARGET_IS_WINDOWS ON)
+elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
+    set(VCPKG_TARGET_IS_WINDOWS ON)
+    set(VCPKG_TARGET_IS_UWP ON)
 elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Darwin")
-    set(VCPKG_TARGET_IS_OSX 1)
+    set(VCPKG_TARGET_IS_OSX ON)
 elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "iOS")
-    set(VCPKG_TARGET_IS_IOS 1)
+    set(VCPKG_TARGET_IS_IOS ON)
 elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    set(VCPKG_TARGET_IS_LINUX 1)
+    set(VCPKG_TARGET_IS_LINUX ON)
 elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Android")
-    set(VCPKG_TARGET_IS_ANDROID 1)
+    set(VCPKG_TARGET_IS_ANDROID ON)
 elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
-    set(VCPKG_TARGET_IS_FREEBSD 1)
+    set(VCPKG_TARGET_IS_FREEBSD ON)
 elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "OpenBSD")
-    set(VCPKG_TARGET_IS_OPENBSD 1)
+    set(VCPKG_TARGET_IS_OPENBSD ON)
 elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "MinGW")
-    set(VCPKG_TARGET_IS_WINDOWS 1)
-    set(VCPKG_TARGET_IS_MINGW 1)
+    set(VCPKG_TARGET_IS_WINDOWS ON)
+    set(VCPKG_TARGET_IS_MINGW ON)
 endif()
 
 #Helper variables to identify the host system name
 if (CMAKE_HOST_WIN32)
-    set(VCPKG_HOST_IS_WINDOWS 1)
+    set(VCPKG_HOST_IS_WINDOWS ON)
 elseif (CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
-    set(VCPKG_HOST_IS_OSX 1)
+    set(VCPKG_HOST_IS_OSX ON)
 elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
-    set(VCPKG_HOST_IS_LINUX 1)
+    set(VCPKG_HOST_IS_LINUX ON)
 elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "FreeBSD")
-    set(VCPKG_HOST_IS_FREEBSD 1)
+    set(VCPKG_HOST_IS_FREEBSD ON)
 elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "OpenBSD")
-    set(VCPKG_HOST_IS_OPENBSD 1)
+    set(VCPKG_HOST_IS_OPENBSD ON)
 endif()
 
 #Helper variable to identify the host path separator.
@@ -152,12 +151,12 @@ endif()
 
 # Platforms with libstdc++
 if(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_FREEBSD OR VCPKG_TARGET_IS_OPENBSD OR VCPKG_TARGET_IS_MINGW)
-    list(APPEND VCPKG_SYSTEM_LIBRARIES [=[stdc\+\+]=])
+    list(APPEND VCPKG_SYSTEM_LIBRARIES [[stdc\+\+]])
 endif()
 
 # Platforms with libc++
 if(VCPKG_TARGET_IS_OSX)
-    list(APPEND VCPKG_SYSTEM_LIBRARIES [=[c\+\+]=])
+    list(APPEND VCPKG_SYSTEM_LIBRARIES [[c\+\+]])
 endif()
 
 # Platforms with librt
@@ -199,5 +198,5 @@ if(VCPKG_TARGET_IS_WINDOWS)
     list(APPEND VCPKG_SYSTEM_LIBRARIES wsock32)
     list(APPEND VCPKG_SYSTEM_LIBRARIES Ws2_32)
     list(APPEND VCPKG_SYSTEM_LIBRARIES wldap32)
-    list(APPEND VCPKG_SYSTEM_LIBRARIES crypt32)	
+    list(APPEND VCPKG_SYSTEM_LIBRARIES crypt32)
 endif()
diff --git a/scripts/cmake/vcpkg_configure_cmake.cmake b/scripts/cmake/vcpkg_configure_cmake.cmake
index 8800d45eb..2cb6dbf1a 100644
--- a/scripts/cmake/vcpkg_configure_cmake.cmake
+++ b/scripts/cmake/vcpkg_configure_cmake.cmake
@@ -1,6 +1,8 @@
 #[===[.md:
 # vcpkg_configure_cmake
 
+**This function has been deprecated in favor of `vcpkg_cmake_configure` from the vcpkg-cmake port.**
+
 Configure CMake for Debug and Release builds of a project.
 
 ## Usage
@@ -67,8 +69,12 @@ This command supplies many common arguments to CMake. To see the full list, exam
 #]===]
 
 function(vcpkg_configure_cmake)
-    # parse parameters such that semicolons in arguments to OPTIONS don't get erased
-    cmake_parse_arguments(PARSE_ARGV 0 _csc
+    message(DEPRECATION "vcpkg_configure_cmake has been deprecated in favor of vcpkg_cmake_configure from the vcpkg-cmake port.")
+    if(Z_VCPKG_CMAKE_CONFIGURE_GUARD)
+        message(FATAL_ERROR "The ${PORT} port already depends on vcpkg-cmake; using both vcpkg-cmake and vcpkg_configure_cmake in the same port is unsupported.")
+    endif()
+
+    cmake_parse_arguments(PARSE_ARGV 0 arg
         "PREFER_NINJA;DISABLE_PARALLEL_CONFIGURE;NO_CHARSET_FLAG"
         "SOURCE_PATH;GENERATOR;LOGNAME"
         "OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE"
@@ -79,15 +85,15 @@ function(vcpkg_configure_cmake)
             "however, vcpkg.exe must be rebuilt by re-running bootstrap-vcpkg.bat\n")
     endif()
 
-    if(NOT _csc_LOGNAME)
-        set(_csc_LOGNAME config-${TARGET_TRIPLET})
+    if(NOT arg_LOGNAME)
+        set(arg_LOGNAME config-${TARGET_TRIPLET})
     endif()
 
     if(CMAKE_HOST_WIN32)
         if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
-            set(_csc_HOST_ARCHITECTURE $ENV{PROCESSOR_ARCHITEW6432})
+            set(arg_HOST_ARCHITECTURE $ENV{PROCESSOR_ARCHITEW6432})
         else()
-            set(_csc_HOST_ARCHITECTURE $ENV{PROCESSOR_ARCHITECTURE})
+            set(arg_HOST_ARCHITECTURE $ENV{PROCESSOR_ARCHITECTURE})
         endif()
     endif()
 
@@ -98,7 +104,7 @@ function(vcpkg_configure_cmake)
         set(_TARGETTING_UWP 1)
     endif()
 
-    if(_csc_HOST_ARCHITECTURE STREQUAL "x86")
+    if(arg_HOST_ARCHITECTURE STREQUAL "x86")
         # Prebuilt ninja binaries are only provided for x64 hosts
         set(NINJA_CAN_BE_USED OFF)
         set(NINJA_HOST OFF)
@@ -107,9 +113,9 @@ function(vcpkg_configure_cmake)
         set(NINJA_CAN_BE_USED OFF)
     endif()
 
-    if(_csc_GENERATOR)
-        set(GENERATOR ${_csc_GENERATOR})
-    elseif(_csc_PREFER_NINJA AND NINJA_CAN_BE_USED)
+    if(arg_GENERATOR)
+        set(GENERATOR ${arg_GENERATOR})
+    elseif(arg_PREFER_NINJA AND NINJA_CAN_BE_USED)
         set(GENERATOR "Ninja")
     elseif(VCPKG_CHAINLOAD_TOOLCHAIN_FILE OR (VCPKG_CMAKE_SYSTEM_NAME AND NOT _TARGETTING_UWP))
         set(GENERATOR "Ninja")
@@ -164,13 +170,13 @@ function(vcpkg_configure_cmake)
         vcpkg_find_acquire_program(NINJA)
         get_filename_component(NINJA_PATH ${NINJA} DIRECTORY)
         vcpkg_add_to_path("${NINJA_PATH}")
-        list(APPEND _csc_OPTIONS "-DCMAKE_MAKE_PROGRAM=${NINJA}")
+        list(APPEND arg_OPTIONS "-DCMAKE_MAKE_PROGRAM=${NINJA}")
     endif()
 
     file(REMOVE_RECURSE ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg)
 
     if(DEFINED VCPKG_CMAKE_SYSTEM_NAME)
-        list(APPEND _csc_OPTIONS "-DCMAKE_SYSTEM_NAME=${VCPKG_CMAKE_SYSTEM_NAME}")
+        list(APPEND arg_OPTIONS "-DCMAKE_SYSTEM_NAME=${VCPKG_CMAKE_SYSTEM_NAME}")
         if(_TARGETTING_UWP AND NOT DEFINED VCPKG_CMAKE_SYSTEM_VERSION)
             set(VCPKG_CMAKE_SYSTEM_VERSION 10.0)
         elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Android" AND NOT DEFINED VCPKG_CMAKE_SYSTEM_VERSION)
@@ -179,13 +185,13 @@ function(vcpkg_configure_cmake)
     endif()
 
     if(DEFINED VCPKG_CMAKE_SYSTEM_VERSION)
-        list(APPEND _csc_OPTIONS "-DCMAKE_SYSTEM_VERSION=${VCPKG_CMAKE_SYSTEM_VERSION}")
+        list(APPEND arg_OPTIONS "-DCMAKE_SYSTEM_VERSION=${VCPKG_CMAKE_SYSTEM_VERSION}")
     endif()
 
     if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic")
-        list(APPEND _csc_OPTIONS -DBUILD_SHARED_LIBS=ON)
+        list(APPEND arg_OPTIONS -DBUILD_SHARED_LIBS=ON)
     elseif(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
-        list(APPEND _csc_OPTIONS -DBUILD_SHARED_LIBS=OFF)
+        list(APPEND arg_OPTIONS -DBUILD_SHARED_LIBS=OFF)
     else()
         message(FATAL_ERROR
             "Invalid setting for VCPKG_LIBRARY_LINKAGE: \"${VCPKG_LIBRARY_LINKAGE}\". "
@@ -203,7 +209,7 @@ function(vcpkg_configure_cmake)
     check_both_vars_are_set(VCPKG_CXX_FLAGS VCPKG_C_FLAGS)
 
     set(VCPKG_SET_CHARSET_FLAG ON)
-    if(_csc_NO_CHARSET_FLAG)
+    if(arg_NO_CHARSET_FLAG)
         set(VCPKG_SET_CHARSET_FLAG OFF)
     endif()
 
@@ -228,7 +234,7 @@ function(vcpkg_configure_cmake)
     endif()
 
 
-    list(APPEND _csc_OPTIONS
+    list(APPEND arg_OPTIONS
         "-DVCPKG_CHAINLOAD_TOOLCHAIN_FILE=${VCPKG_CHAINLOAD_TOOLCHAIN_FILE}"
         "-DVCPKG_TARGET_TRIPLET=${TARGET_TRIPLET}"
         "-DVCPKG_SET_CHARSET_FLAG=${VCPKG_SET_CHARSET_FLAG}"
@@ -260,7 +266,7 @@ function(vcpkg_configure_cmake)
     )
 
     if(DEFINED ARCH)
-        list(APPEND _csc_OPTIONS
+        list(APPEND arg_OPTIONS
             "-A${ARCH}"
         )
     endif()
@@ -268,23 +274,23 @@ function(vcpkg_configure_cmake)
     # Sets configuration variables for macOS builds
     foreach(config_var  INSTALL_NAME_DIR OSX_DEPLOYMENT_TARGET OSX_SYSROOT OSX_ARCHITECTURES)
         if(DEFINED VCPKG_${config_var})
-            list(APPEND _csc_OPTIONS "-DCMAKE_${config_var}=${VCPKG_${config_var}}")
+            list(APPEND arg_OPTIONS "-DCMAKE_${config_var}=${VCPKG_${config_var}}")
         endif()
     endforeach()
 
     set(rel_command
-        ${CMAKE_COMMAND} ${_csc_SOURCE_PATH} "${_csc_OPTIONS}" "${_csc_OPTIONS_RELEASE}"
+        ${CMAKE_COMMAND} ${arg_SOURCE_PATH} "${arg_OPTIONS}" "${arg_OPTIONS_RELEASE}"
         -G ${GENERATOR}
         -DCMAKE_BUILD_TYPE=Release
         -DCMAKE_INSTALL_PREFIX=${CURRENT_PACKAGES_DIR})
     set(dbg_command
-        ${CMAKE_COMMAND} ${_csc_SOURCE_PATH} "${_csc_OPTIONS}" "${_csc_OPTIONS_DEBUG}"
+        ${CMAKE_COMMAND} ${arg_SOURCE_PATH} "${arg_OPTIONS}" "${arg_OPTIONS_DEBUG}"
         -G ${GENERATOR}
         -DCMAKE_BUILD_TYPE=Debug
         -DCMAKE_INSTALL_PREFIX=${CURRENT_PACKAGES_DIR}/debug)
 
-    if(NINJA_HOST AND CMAKE_HOST_WIN32 AND NOT _csc_DISABLE_PARALLEL_CONFIGURE)
-        list(APPEND _csc_OPTIONS "-DCMAKE_DISABLE_SOURCE_CHANGES=ON")
+    if(NINJA_HOST AND CMAKE_HOST_WIN32 AND NOT arg_DISABLE_PARALLEL_CONFIGURE)
+        list(APPEND arg_OPTIONS "-DCMAKE_DISABLE_SOURCE_CHANGES=ON")
 
         vcpkg_find_acquire_program(NINJA)
         get_filename_component(NINJA_PATH ${NINJA} DIRECTORY)
@@ -319,7 +325,7 @@ function(vcpkg_configure_cmake)
         vcpkg_execute_required_process(
             COMMAND ninja -v
             WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/vcpkg-parallel-configure
-            LOGNAME ${_csc_LOGNAME}
+            LOGNAME ${arg_LOGNAME}
         )
     else()
         if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
@@ -328,7 +334,7 @@ function(vcpkg_configure_cmake)
             vcpkg_execute_required_process(
                 COMMAND ${dbg_command}
                 WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg
-                LOGNAME ${_csc_LOGNAME}-dbg
+                LOGNAME ${arg_LOGNAME}-dbg
             )
         endif()
 
@@ -338,10 +344,10 @@ function(vcpkg_configure_cmake)
             vcpkg_execute_required_process(
                 COMMAND ${rel_command}
                 WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel
-                LOGNAME ${_csc_LOGNAME}-rel
+                LOGNAME ${arg_LOGNAME}-rel
             )
         endif()
     endif()
 
-    set(_VCPKG_CMAKE_GENERATOR "${GENERATOR}" PARENT_SCOPE)
+    set(Z_VCPKG_CMAKE_GENERATOR "${GENERATOR}" PARENT_SCOPE)
 endfunction()
diff --git a/scripts/cmake/vcpkg_copy_pdbs.cmake b/scripts/cmake/vcpkg_copy_pdbs.cmake
index db91420b6..dd489db02 100644
--- a/scripts/cmake/vcpkg_copy_pdbs.cmake
+++ b/scripts/cmake/vcpkg_copy_pdbs.cmake
@@ -3,78 +3,70 @@
 
 Automatically locate pdbs in the build tree and copy them adjacent to all DLLs.
 
-## Usage
 ```cmake
-vcpkg_copy_pdbs([BUILD_PATHS <${CURRENT_PACKAGES_DIR}/bin/*.dll> ...])
+vcpkg_copy_pdbs(
+    [BUILD_PATHS <glob>...])
 ```
 
-## Notes
-This command should always be called by portfiles after they have finished rearranging the binary output.
+The `<glob>`s are patterns which will be passed to `file(GLOB_RECURSE)`,
+for locating DLLs. It defaults to using:
+
+- `${CURRENT_PACKAGES_DIR}/bin/*.dll`
+- `${CURRENT_PACKAGES_DIR}/debug/bin/*.dll`
 
-## Parameters
-### BUILD_PATHS
-Path patterns passed to `file(GLOB_RECURSE)` for locating dlls.
+since that is generally where DLLs are located.
 
-Defaults to `${CURRENT_PACKAGES_DIR}/bin/*.dll` and `${CURRENT_PACKAGES_DIR}/debug/bin/*.dll`.
+## Notes
+This command should always be called by portfiles after they have finished rearranging the binary output.
 
 ## Examples
 
 * [zlib](https://github.com/Microsoft/vcpkg/blob/master/ports/zlib/portfile.cmake)
 * [cpprestsdk](https://github.com/Microsoft/vcpkg/blob/master/ports/cpprestsdk/portfile.cmake)
 #]===]
-
 function(vcpkg_copy_pdbs)
-    # parse parameters such that semicolons in options arguments to COMMAND don't get erased
-    cmake_parse_arguments(PARSE_ARGV 0 _vcp "" "" "BUILD_PATHS")
-    
-    if(NOT _vcp_BUILD_PATHS)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "" "" "BUILD_PATHS")
+
+    if(NOT DEFINED arg_BUILD_PATHS)
         set(
-            _vcp_BUILD_PATHS
-            ${CURRENT_PACKAGES_DIR}/bin/*.dll
-            ${CURRENT_PACKAGES_DIR}/debug/bin/*.dll
+            arg_BUILD_PATHS
+            "${CURRENT_PACKAGES_DIR}/bin/*.dll"
+            "${CURRENT_PACKAGES_DIR}/debug/bin/*.dll"
         )
     endif()
 
-    function(merge_filelist OUTVAR INVAR)
-        set(MSG "")
-        foreach(VAR ${${INVAR}})
-            set(MSG "${MSG}    ${VAR}\n")
-        endforeach()
-        set(${OUTVAR} ${MSG} PARENT_SCOPE)
-    endfunction()
-
-    if(VCPKG_LIBRARY_LINKAGE STREQUAL dynamic AND NOT VCPKG_TARGET_IS_MINGW)
-        file(GLOB_RECURSE DLLS ${_vcp_BUILD_PATHS})
+    set(dlls_without_matching_pdbs)
 
-        set(DLLS_WITHOUT_MATCHING_PDBS)
+    if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic" AND VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW)
+        file(GLOB_RECURSE dlls ${arg_BUILD_PATHS})
 
-        set(PREVIOUS_VSLANG $ENV{VSLANG})
+        set(vslang_backup "$ENV{VSLANG}")
         set(ENV{VSLANG} 1033)
 
-        foreach(DLL ${DLLS})
-            execute_process(COMMAND dumpbin /PDBPATH ${DLL}
+        foreach(dll IN LISTS dlls)
+            execute_process(COMMAND dumpbin /PDBPATH ${dll}
                             COMMAND findstr PDB
-                OUTPUT_VARIABLE PDB_LINE
+                OUTPUT_VARIABLE pdb_line
                 ERROR_QUIET
                 RESULT_VARIABLE error_code
             )
 
-            if(NOT error_code AND PDB_LINE MATCHES "PDB file found at")
-                string(REGEX MATCH '.*' PDB_PATH ${PDB_LINE}) # Extract the path which is in single quotes
-                string(REPLACE ' "" PDB_PATH ${PDB_PATH}) # Remove single quotes
-                get_filename_component(DLL_DIR ${DLL} DIRECTORY)
-                file(COPY ${PDB_PATH} DESTINATION ${DLL_DIR})
+            if(NOT error_code AND pdb_line MATCHES "PDB file found at")
+                string(REGEX MATCH [['.*']] pdb_path "${pdb_line}") # Extract the path which is in single quotes
+                string(REPLACE "'" "" pdb_path "${pdb_path}") # Remove single quotes
+                get_filename_component(dll_dir "${dll}" DIRECTORY)
+                file(COPY "${pdb_path}" DESTINATION "${dll_dir}")
             else()
-                list(APPEND DLLS_WITHOUT_MATCHING_PDBS ${DLL})
+                list(APPEND dlls_without_matching_pdbs "${dll}")
             endif()
         endforeach()
 
-        set(ENV{VSLANG} ${PREVIOUS_VSLANG})
+        set(ENV{VSLANG} "${vslang_backup}")
 
-        list(LENGTH DLLS_WITHOUT_MATCHING_PDBS UNMATCHED_DLLS_LENGTH)
-        if(UNMATCHED_DLLS_LENGTH GREATER 0)
-            merge_filelist(MSG DLLS_WITHOUT_MATCHING_PDBS)
-            message(STATUS "Warning: Could not find a matching pdb file for:\n${MSG}")
+        list(LENGTH dlls_without_matching_pdbs unmatched_dlls_length)
+        if(unmatched_dlls_length GREATER 0)
+            list(JOIN dlls_without_matching_pdbs "\n    " message)
+            message(WARNING "Could not find a matching pdb file for:${message}\n")
         endif()
     endif()
 
diff --git a/scripts/cmake/vcpkg_extract_source_archive_ex.cmake b/scripts/cmake/vcpkg_extract_source_archive_ex.cmake
index bef245b5a..633b40b1a 100644
--- a/scripts/cmake/vcpkg_extract_source_archive_ex.cmake
+++ b/scripts/cmake/vcpkg_extract_source_archive_ex.cmake
@@ -54,7 +54,6 @@ Specifies that the default removal of the top level folder should not occur.
 * [cairo](https://github.com/Microsoft/vcpkg/blob/master/ports/cairo/portfile.cmake)

 #]===]

 

-include(vcpkg_apply_patches)

 include(vcpkg_extract_source_archive)

 

 function(vcpkg_extract_source_archive_ex)

@@ -142,7 +141,7 @@ function(vcpkg_extract_source_archive_ex)
             set (QUIET)

         endif()

 

-        vcpkg_apply_patches(

+        z_vcpkg_apply_patches(

             ${QUIET}

             SOURCE_PATH ${TEMP_SOURCE_PATH}

             PATCHES ${_vesae_PATCHES}

diff --git a/scripts/cmake/vcpkg_fixup_cmake_targets.cmake b/scripts/cmake/vcpkg_fixup_cmake_targets.cmake
index 2da44f551..b2931120b 100644
--- a/scripts/cmake/vcpkg_fixup_cmake_targets.cmake
+++ b/scripts/cmake/vcpkg_fixup_cmake_targets.cmake
@@ -1,6 +1,8 @@
 #[===[.md:
 # vcpkg_fixup_cmake_targets
 
+**This function has been deprecated in favor of `vcpkg_cmake_config_fixup` from the vcpkg-cmake-config port.**
+
 Merge release and debug CMake targets and configs to support multiconfig generators.
 
 Additionally corrects common issues with targets, such as absolute paths and incorrectly placed binaries.
@@ -23,7 +25,7 @@ This needs to be specified if the port name differs from the `find_package()` na
 
 Defaults to `share/${PORT}`.
 
-### DO_NOT_DELETE_PARENT_CONFIG_PATH 
+### DO_NOT_DELETE_PARENT_CONFIG_PATH
 By default the parent directory of CONFIG_PATH is removed if it is named "cmake".
 Passing this option disable such behavior, as it is convenient for ports that install
 more than one CMake package configuration file.
@@ -51,31 +53,35 @@ Replace `${CURRENT_INSTALLED_DIR}` with `${_IMPORT_PREFIX}` in configs and targe
 #]===]
 
 function(vcpkg_fixup_cmake_targets)
-    # parse parameters such that semicolons in options arguments to COMMAND don't get erased
-    cmake_parse_arguments(PARSE_ARGV 0 _vfct "DO_NOT_DELETE_PARENT_CONFIG_PATH" "CONFIG_PATH;TARGET_PATH;NO_PREFIX_CORRECTION" "")
+    message(DEPRECATION "vcpkg_fixup_cmake_targets has been deprecated in favor of vcpkg_cmake_config_fixup from the vcpkg-cmake-config port.")
+    if(Z_VCPKG_CMAKE_CONFIG_FIXUP_GUARD)
+        message(FATAL_ERROR "The ${PORT} port already depends on vcpkg-cmake-config; using both vcpkg-cmake-config and vcpkg_fixup_cmake_targets in the same port is unsupported.")
+    endif()
 
-    if(_vfct_UNPARSED_ARGUMENTS)
-        message(FATAL_ERROR "vcpkg_fixup_cmake_targets was passed extra arguments: ${_vfct_UNPARSED_ARGUMENTS}")
+    cmake_parse_arguments(PARSE_ARGV 0 arg "DO_NOT_DELETE_PARENT_CONFIG_PATH" "CONFIG_PATH;TARGET_PATH;NO_PREFIX_CORRECTION" "")
+
+    if(arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "vcpkg_fixup_cmake_targets was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
     endif()
 
-    if(NOT _vfct_TARGET_PATH)
-        set(_vfct_TARGET_PATH share/${PORT})
+    if(NOT arg_TARGET_PATH)
+        set(arg_TARGET_PATH share/${PORT})
     endif()
 
     string(REPLACE "." "\\." EXECUTABLE_SUFFIX "${VCPKG_TARGET_EXECUTABLE_SUFFIX}")
 
-    set(DEBUG_SHARE ${CURRENT_PACKAGES_DIR}/debug/${_vfct_TARGET_PATH})
-    set(RELEASE_SHARE ${CURRENT_PACKAGES_DIR}/${_vfct_TARGET_PATH})
+    set(DEBUG_SHARE ${CURRENT_PACKAGES_DIR}/debug/${arg_TARGET_PATH})
+    set(RELEASE_SHARE ${CURRENT_PACKAGES_DIR}/${arg_TARGET_PATH})
 
-    if(_vfct_CONFIG_PATH AND NOT RELEASE_SHARE STREQUAL "${CURRENT_PACKAGES_DIR}/${_vfct_CONFIG_PATH}")
-        if(_vfct_CONFIG_PATH STREQUAL "share")
+    if(arg_CONFIG_PATH AND NOT RELEASE_SHARE STREQUAL "${CURRENT_PACKAGES_DIR}/${arg_CONFIG_PATH}")
+        if(arg_CONFIG_PATH STREQUAL "share")
             file(RENAME ${CURRENT_PACKAGES_DIR}/debug/share ${CURRENT_PACKAGES_DIR}/debug/share2)
             file(RENAME ${CURRENT_PACKAGES_DIR}/share ${CURRENT_PACKAGES_DIR}/share2)
-            set(_vfct_CONFIG_PATH share2)
+            set(arg_CONFIG_PATH share2)
         endif()
 
-        set(DEBUG_CONFIG ${CURRENT_PACKAGES_DIR}/debug/${_vfct_CONFIG_PATH})
-        set(RELEASE_CONFIG ${CURRENT_PACKAGES_DIR}/${_vfct_CONFIG_PATH})
+        set(DEBUG_CONFIG ${CURRENT_PACKAGES_DIR}/debug/${arg_CONFIG_PATH})
+        set(RELEASE_CONFIG ${CURRENT_PACKAGES_DIR}/${arg_CONFIG_PATH})
         if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
             if(NOT EXISTS ${DEBUG_CONFIG})
                 message(FATAL_ERROR "'${DEBUG_CONFIG}' does not exist.")
@@ -95,13 +101,13 @@ function(vcpkg_fixup_cmake_targets)
         if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
             get_filename_component(DEBUG_CONFIG_DIR_NAME ${DEBUG_CONFIG} NAME)
             string(TOLOWER "${DEBUG_CONFIG_DIR_NAME}" DEBUG_CONFIG_DIR_NAME)
-            if(DEBUG_CONFIG_DIR_NAME STREQUAL "cmake" AND NOT _vfct_DO_NOT_DELETE_PARENT_CONFIG_PATH)
+            if(DEBUG_CONFIG_DIR_NAME STREQUAL "cmake" AND NOT arg_DO_NOT_DELETE_PARENT_CONFIG_PATH)
                 file(REMOVE_RECURSE ${DEBUG_CONFIG})
             else()
                 get_filename_component(DEBUG_CONFIG_PARENT_DIR ${DEBUG_CONFIG} DIRECTORY)
                 get_filename_component(DEBUG_CONFIG_DIR_NAME ${DEBUG_CONFIG_PARENT_DIR} NAME)
                 string(TOLOWER "${DEBUG_CONFIG_DIR_NAME}" DEBUG_CONFIG_DIR_NAME)
-                if(DEBUG_CONFIG_DIR_NAME STREQUAL "cmake" AND NOT _vfct_DO_NOT_DELETE_PARENT_CONFIG_PATH)
+                if(DEBUG_CONFIG_DIR_NAME STREQUAL "cmake" AND NOT arg_DO_NOT_DELETE_PARENT_CONFIG_PATH)
                     file(REMOVE_RECURSE ${DEBUG_CONFIG_PARENT_DIR})
                 endif()
             endif()
@@ -109,13 +115,13 @@ function(vcpkg_fixup_cmake_targets)
 
         get_filename_component(RELEASE_CONFIG_DIR_NAME ${RELEASE_CONFIG} NAME)
         string(TOLOWER "${RELEASE_CONFIG_DIR_NAME}" RELEASE_CONFIG_DIR_NAME)
-        if(RELEASE_CONFIG_DIR_NAME STREQUAL "cmake" AND NOT _vfct_DO_NOT_DELETE_PARENT_CONFIG_PATH)
+        if(RELEASE_CONFIG_DIR_NAME STREQUAL "cmake" AND NOT arg_DO_NOT_DELETE_PARENT_CONFIG_PATH)
             file(REMOVE_RECURSE ${RELEASE_CONFIG})
         else()
             get_filename_component(RELEASE_CONFIG_PARENT_DIR ${RELEASE_CONFIG} DIRECTORY)
             get_filename_component(RELEASE_CONFIG_DIR_NAME ${RELEASE_CONFIG_PARENT_DIR} NAME)
             string(TOLOWER "${RELEASE_CONFIG_DIR_NAME}" RELEASE_CONFIG_DIR_NAME)
-            if(RELEASE_CONFIG_DIR_NAME STREQUAL "cmake" AND NOT _vfct_DO_NOT_DELETE_PARENT_CONFIG_PATH)
+            if(RELEASE_CONFIG_DIR_NAME STREQUAL "cmake" AND NOT arg_DO_NOT_DELETE_PARENT_CONFIG_PATH)
                 file(REMOVE_RECURSE ${RELEASE_CONFIG_PARENT_DIR})
             endif()
         endif()
@@ -165,18 +171,18 @@ function(vcpkg_fixup_cmake_targets)
         endforeach()
     endif()
 
-    #Fix ${_IMPORT_PREFIX} in cmake generated targets and configs; 
+    #Fix ${_IMPORT_PREFIX} in cmake generated targets and configs;
     #Since those can be renamed we have to check in every *.cmake
     file(GLOB_RECURSE MAIN_CMAKES "${RELEASE_SHARE}/*.cmake")
 
     foreach(MAIN_CMAKE IN LISTS MAIN_CMAKES)
         file(READ ${MAIN_CMAKE} _contents)
         #This correction is not correct for all cases. To make it correct for all cases it needs to consider
-        #original folder deepness to CURRENT_PACKAGES_DIR in comparison to the moved to folder deepness which 
-        #is always at least (>=) 2, e.g. share/${PORT}. Currently the code assumes it is always 2 although 
+        #original folder deepness to CURRENT_PACKAGES_DIR in comparison to the moved to folder deepness which
+        #is always at least (>=) 2, e.g. share/${PORT}. Currently the code assumes it is always 2 although
         #this requirement is only true for the *Config.cmake. The targets are not required to be in the same
         #folder as the *Config.cmake!
-        if(NOT _vfct_NO_PREFIX_CORRECTION)
+        if(NOT arg_NO_PREFIX_CORRECTION)
             string(REGEX REPLACE
                 "get_filename_component\\(_IMPORT_PREFIX \"\\\${CMAKE_CURRENT_LIST_FILE}\" PATH\\)(\nget_filename_component\\(_IMPORT_PREFIX \"\\\${_IMPORT_PREFIX}\" PATH\\))*"
                 "get_filename_component(_IMPORT_PREFIX \"\${CMAKE_CURRENT_LIST_FILE}\" PATH)\nget_filename_component(_IMPORT_PREFIX \"\${_IMPORT_PREFIX}\" PATH)\nget_filename_component(_IMPORT_PREFIX \"\${_IMPORT_PREFIX}\" PATH)"
@@ -196,7 +202,7 @@ function(vcpkg_fixup_cmake_targets)
         #an imported target for it. We could add more logic here to identify defect target files.
         #Since the replacement here in a multi config build always requires a generator expression
         #in front of the absoulte path to ${CURRENT_INSTALLED_DIR}. So the match should always be at
-        #least >:${CURRENT_INSTALLED_DIR}. 
+        #least >:${CURRENT_INSTALLED_DIR}.
         #In general the following generator expressions should be there:
         #\$<\$<CONFIG:DEBUG>:${CURRENT_INSTALLED_DIR}/debug/lib/somelib>
         #and/or
@@ -228,4 +234,4 @@ function(vcpkg_fixup_cmake_targets)
     endforeach()
 endfunction()
 
- 
+
diff --git a/scripts/cmake/vcpkg_install_cmake.cmake b/scripts/cmake/vcpkg_install_cmake.cmake
index a1ba0cf2f..bf752f643 100644
--- a/scripts/cmake/vcpkg_install_cmake.cmake
+++ b/scripts/cmake/vcpkg_install_cmake.cmake
@@ -1,6 +1,8 @@
 #[===[.md:
 # vcpkg_install_cmake
 
+**This function has been deprecated in favor of `vcpkg_cmake_install` from the vcpkg-cmake port.**
+
 Build and install a cmake project.
 
 ## Usage:
@@ -24,5 +26,26 @@ parameter.
 #]===]
 
 function(vcpkg_install_cmake)
-    vcpkg_build_cmake(LOGFILE_ROOT install TARGET install ${ARGN})
+    message(DEPRECATION "vcpkg_install_cmake has been deprecated in favor of vcpkg_cmake_install from the vcpkg-cmake port.")
+    if(Z_VCPKG_CMAKE_INSTALL_GUARD)
+        message(FATAL_ERROR "The ${PORT} port already depends on vcpkg-cmake; using both vcpkg-cmake and vcpkg_install_cmake in the same port is unsupported.")
+    endif()
+
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "DISABLE_PARALLEL;ADD_BIN_TO_PATH" "" "")
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "vcpkg_cmake_install was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    set(args)
+    foreach(arg IN ITEMS DISABLE_PARALLEL ADD_BIN_TO_PATH)
+        if(arg_${arg})
+            list(APPEND args "${arg}")
+        endif()
+    endforeach()
+
+    vcpkg_build_cmake(Z_VCPKG_DISABLE_DEPRECATION MESSAGE
+        ${args}
+        LOGFILE_ROOT install
+        TARGET install
+    )
 endfunction()
diff --git a/scripts/cmake/z_vcpkg_apply_patches.cmake b/scripts/cmake/z_vcpkg_apply_patches.cmake
new file mode 100644
index 000000000..3f9175749
--- /dev/null
+++ b/scripts/cmake/z_vcpkg_apply_patches.cmake
@@ -0,0 +1,67 @@
+#[===[.md:
+# z_vcpkg_apply_patches
+
+**Only for internal use in vcpkg helpers. Behavior and arguments will change without notice.**
+
+Apply a set of patches to a source tree.
+
+```cmake
+z_vcpkg_apply_patches(
+    SOURCE_PATH <path-to-source>
+    [QUIET]
+    PATCHES <patch>...
+)
+```
+
+The `<path-to-source>` should be set to `${SOURCE_PATH}` by convention,
+and is the path to apply the patches in.
+
+`z_vcpkg_apply_patches` will take the list of `<patch>`es,
+which are by default relative to the port directory,
+and apply them in order using `git apply`.
+Generally, these `<patch>`es take the form of `some.patch`
+to select patches in the port directory.
+One may also download patches and use `${VCPKG_DOWNLOADS}/path/to/some.patch`.
+
+If `QUIET` is not passed, it is a fatal error for a patch to fail to apply;
+otherwise, if `QUIET` is passed, no message is printed.
+This should only be used for edge cases, such as patches that are known to fail even on a clean source tree.
+#]===]
+
+function(z_vcpkg_apply_patches)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "QUIET" "SOURCE_PATH" "PATCHES")
+
+    find_program(GIT NAMES git git.cmd REQUIRED)
+    if(DEFINED ENV{GIT_CONFIG_NOSYSTEM})
+        set(git_config_nosystem_backuP "$ENV{GIT_CONFIG_NOSYSTEM}")
+    else()
+        unset(git_config_nosystem_backup)
+    endif()
+
+    set(ENV{GIT_CONFIG_NOSYSTEM} 1)
+    set(patchnum 0)
+    foreach(patch IN LISTS arg_PATCHES)
+        get_filename_component(absolute_patch "${patch}" ABSOLUTE BASE_DIR "${CURRENT_PORT_DIR}")
+        message(STATUS "Applying patch ${patch}")
+        set(logname patch-${TARGET_TRIPLET}-${patchnum})
+        vcpkg_execute_in_download_mode(
+            COMMAND "${GIT}" -c core.longpaths=true -c core.autocrlf=false --work-tree=. --git-dir=.git apply "${absolute_patch}" --ignore-whitespace --whitespace=nowarn --verbose
+            OUTPUT_FILE "${CURRENT_BUILDTREES_DIR}/${logname}-out.log"
+            ERROR_VARIABLE error
+            WORKING_DIRECTORY "${arg_SOURCE_PATH}"
+            RESULT_VARIABLE error_code
+        )
+        file(WRITE "${CURRENT_BUILDTREES_DIR}/${logname}-err.log" "${error}")
+
+        if(error_code AND NOT arg_QUIET)
+            message(FATAL_ERROR "Applying patch failed: ${error}")
+        endif()
+
+        math(EXPR patchnum "${patchnum} + 1")
+    endforeach()
+    if(DEFINED git_config_nosystem_backup)
+        set(ENV{GIT_CONFIG_NOSYSTEM} "${git_config_nosystem_backup}")
+    else()
+        unset(ENV{GIT_CONFIG_NOSYSTEM})
+    endif()
+endfunction()
diff --git a/scripts/ports.cmake b/scripts/ports.cmake
index 68f2cbba7..62ee9f6aa 100644
--- a/scripts/ports.cmake
+++ b/scripts/ports.cmake
@@ -10,6 +10,11 @@ function(debug_message)
         message(STATUS "[DEBUG] " "${ARG_STRING}")
     endif()
 endfunction()
+function(z_vcpkg_deprecation_message)
+    z_vcpkg_function_arguments(ARGS)
+    list(JOIN ARGS " " ARG_STRING)
+    message(DEPRECATION "${ARG_STRING}")
+endfunction()
 
 option(_VCPKG_PROHIBIT_BACKCOMPAT_FEATURES "Controls whether use of a backcompat only support feature fails the build.")
 if (_VCPKG_PROHIBIT_BACKCOMPAT_FEATURES)
@@ -18,7 +23,7 @@ else()
     set(Z_VCPKG_BACKCOMPAT_MESSAGE_LEVEL "WARNING")
 endif()
 
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")
+list(APPEND CMAKE_MODULE_PATH "${SCRIPTS}/cmake")
 include("${SCRIPTS}/cmake/vcpkg_minimum_required.cmake")
 vcpkg_minimum_required(VERSION 2021-01-13)
 
@@ -128,6 +133,7 @@ if(CMD MATCHES "^BUILD$")
     include("${SCRIPTS}/cmake/vcpkg_replace_string.cmake")
     include("${SCRIPTS}/cmake/vcpkg_test_cmake.cmake")
 
+    include("${SCRIPTS}/cmake/z_vcpkg_apply_patches.cmake")
     include("${SCRIPTS}/cmake/z_vcpkg_prettify_command_line.cmake")
 
     include("${CURRENT_PORT_DIR}/portfile.cmake")