Merge remote-tracking branch 'upstream/master' into path_separator

# Conflicts:
#	scripts/cmake/vcpkg_common_definitions.cmake

21 files changed, 180 insertions, 174 deletions

diff --git a/scripts/bootstrap.ps1 b/scripts/bootstrap.ps1
index 6234efaa3..d2632e57b 100644
--- a/scripts/bootstrap.ps1
+++ b/scripts/bootstrap.ps1
@@ -226,8 +226,9 @@ function getWindowsSDK( [Parameter(Mandatory=$False)][switch]$DisableWin10SDK =
         $win10sdkVersions = @(Get-ChildItem $folder | Where-Object {$_.Name -match "^10"} | Sort-Object)
         [array]::Reverse($win10sdkVersions) # Newest SDK first
 
-        foreach ($win10sdkV in $win10sdkVersions)
+        foreach ($win10sdk in $win10sdkVersions)
         {
+            $win10sdkV = $win10sdk.Name
             $windowsheader = "$folder\$win10sdkV\um\windows.h"
             if (!(Test-Path $windowsheader))
             {
diff --git a/scripts/cmake/execute_process.cmake b/scripts/cmake/execute_process.cmake
new file mode 100644
index 000000000..51f6ad160
--- /dev/null
+++ b/scripts/cmake/execute_process.cmake
@@ -0,0 +1,20 @@
+## # execute_process

+##

+## Intercepts all calls to execute_process() inside portfiles and fails when Download Mode

+## is enabled.

+##

+## In order to execute a process in Download Mode call `_execute_process()` instead.

+##

+if (NOT DEFINED OVERRIDEN_EXECUTE_PROCESS)

+  set(OVERRIDEN_EXECUTE_PROCESS ON)

+

+  if (DEFINED VCPKG_DOWNLOAD_MODE)

+    macro(execute_process)

+      message(FATAL_ERROR "This command cannot be executed in Download Mode.\nHalting portfile execution.\n")

+    endmacro()

+  else()

+    macro(execute_process)

+      _execute_process(${ARGV})

+    endmacro()

+  endif()

+endif()
\ No newline at end of file
diff --git a/scripts/cmake/vcpkg_acquire_msys.cmake b/scripts/cmake/vcpkg_acquire_msys.cmake
index 09090db68..f1f09dc7e 100644
--- a/scripts/cmake/vcpkg_acquire_msys.cmake
+++ b/scripts/cmake/vcpkg_acquire_msys.cmake
@@ -81,15 +81,15 @@ function(vcpkg_acquire_msys PATH_TO_ROOT_OUT)
 
     file(REMOVE_RECURSE ${TOOLPATH}/${TOOLSUBPATH})
     file(MAKE_DIRECTORY ${TOOLPATH})
-    execute_process(
+    _execute_process(
       COMMAND ${CMAKE_COMMAND} -E tar xzf ${ARCHIVE_PATH}
       WORKING_DIRECTORY ${TOOLPATH}
     )
-    execute_process(
+    _execute_process(
       COMMAND ${PATH_TO_ROOT}/usr/bin/bash.exe --noprofile --norc -c "PATH=/usr/bin;pacman-key --init;pacman-key --populate"
       WORKING_DIRECTORY ${TOOLPATH}
     )
-    execute_process(
+    _execute_process(
       COMMAND ${PATH_TO_ROOT}/usr/bin/bash.exe --noprofile --norc -c "PATH=/usr/bin;pacman -Syu --noconfirm"
       WORKING_DIRECTORY ${TOOLPATH}
     )
@@ -104,6 +104,7 @@ function(vcpkg_acquire_msys PATH_TO_ROOT_OUT)
     set(_ENV_ORIGINAL $ENV{PATH})
     set(ENV{PATH} ${PATH_TO_ROOT}/usr/bin)
     vcpkg_execute_required_process(
+      ALLOW_IN_DOWNLOAD_MODE
       COMMAND ${PATH_TO_ROOT}/usr/bin/bash.exe --noprofile --norc -c "pacman -Sy --noconfirm --needed ${_am_PACKAGES}"
       WORKING_DIRECTORY ${TOOLPATH}
       LOGNAME msys-pacman-${TARGET_TRIPLET}
@@ -116,6 +117,7 @@ function(vcpkg_acquire_msys PATH_TO_ROOT_OUT)
   # Deal with a stale process created by MSYS
   if (NOT VCPKG_CMAKE_SYSTEM_NAME OR VCPKG_CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
       vcpkg_execute_required_process(
+          ALLOW_IN_DOWNLOAD_MODE
           COMMAND TASKKILL /F /IM gpg-agent.exe /fi "memusage gt 2"
           WORKING_DIRECTORY ${SOURCE_PATH}
       )
diff --git a/scripts/cmake/vcpkg_apply_patches.cmake b/scripts/cmake/vcpkg_apply_patches.cmake
index ac0b78e20..9698917de 100644
--- a/scripts/cmake/vcpkg_apply_patches.cmake
+++ b/scripts/cmake/vcpkg_apply_patches.cmake
@@ -40,7 +40,7 @@ function(vcpkg_apply_patches)
         get_filename_component(ABSOLUTE_PATCH "${PATCH}" ABSOLUTE BASE_DIR "${CURRENT_PORT_DIR}")
         message(STATUS "Applying patch ${PATCH}")
         set(LOGNAME patch-${TARGET_TRIPLET}-${PATCHNUM})
-        execute_process(
+        _execute_process(
             COMMAND ${GIT} --work-tree=. --git-dir=.git apply "${ABSOLUTE_PATCH}" --ignore-whitespace --whitespace=nowarn --verbose
             OUTPUT_FILE ${CURRENT_BUILDTREES_DIR}/${LOGNAME}-out.log
             ERROR_FILE ${CURRENT_BUILDTREES_DIR}/${LOGNAME}-err.log
diff --git a/scripts/cmake/vcpkg_build_msbuild.cmake b/scripts/cmake/vcpkg_build_msbuild.cmake
index 50432f8fa..cfd429da2 100644
--- a/scripts/cmake/vcpkg_build_msbuild.cmake
+++ b/scripts/cmake/vcpkg_build_msbuild.cmake
@@ -108,7 +108,7 @@ function(vcpkg_build_msbuild)
     if(_csc_USE_VCPKG_INTEGRATION)
         list(
             APPEND _csc_OPTIONS
-            /p:ForceImportBeforeCppTargets=${VCPKG_ROOT_DIR}/scripts/buildsystems/msbuild/vcpkg.targets
+            /p:ForceImportBeforeCppTargets=${SCRIPTS}/buildsystems/msbuild/vcpkg.targets
             "/p:VcpkgTriplet=${TARGET_TRIPLET}"
         )
     endif()
diff --git a/scripts/cmake/vcpkg_build_qmake.cmake b/scripts/cmake/vcpkg_build_qmake.cmake
index cf79fe8fc..03c468463 100644
--- a/scripts/cmake/vcpkg_build_qmake.cmake
+++ b/scripts/cmake/vcpkg_build_qmake.cmake
@@ -11,11 +11,9 @@ function(vcpkg_build_qmake)
     cmake_parse_arguments(_csc "SKIP_MAKEFILES" "BUILD_LOGNAME" "TARGETS;RELEASE_TARGETS;DEBUG_TARGETS" ${ARGN})
 
     if(CMAKE_HOST_WIN32)
-        set(_PATHSEP ";")
         vcpkg_find_acquire_program(JOM)
         set(INVOKE "${JOM}")
     else()
-        set(_PATHSEP ":")
         find_program(MAKE make)
         set(INVOKE "${MAKE}")
     endif()
@@ -23,22 +21,8 @@ function(vcpkg_build_qmake)
     # Make sure that the linker finds the libraries used 
     set(ENV_PATH_BACKUP "$ENV{PATH}")
     
-    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
-        set(DEBUG_DIR ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg)
-    endif()
-    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
-        set(RELEASE_DIR ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel)
-    endif()
-
     file(TO_NATIVE_PATH "${CURRENT_INSTALLED_DIR}" NATIVE_INSTALLED_DIR)
 
-    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
-        list(APPEND _csc_RELEASE_TARGETS ${_csc_TARGETS})
-    endif()
-    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
-        list(APPEND _csc_DEBUG_TARGETS ${_csc_TARGETS})
-    endif()
-
     if(NOT _csc_BUILD_LOGNAME)
         set(_csc_BUILD_LOGNAME build)
     endif()
@@ -56,55 +40,33 @@ function(vcpkg_build_qmake)
     set(ENV_CL_BACKUP "$ENV{_CL_}")
     set(ENV{_CL_} "/utf-8")
 
-    #First generate the makefiles so we can modify them
+    #Replace with VCPKG variables if PR #7733 is merged
+    unset(BUILDTYPES)
     if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
-        set(ENV{PATH} "${CURRENT_INSTALLED_DIR}/debug/lib${_PATHSEP}${CURRENT_INSTALLED_DIR}/debug/bin${_PATHSEP}${CURRENT_INSTALLED_DIR}/tools/qt5${_PATHSEP}${ENV_PATH_BACKUP}")
-        if(NOT _csc_SKIP_MAKEFILES)
-            run_jom(qmake_all makefiles dbg)
-
-            #Store debug makefiles path
-            file(GLOB_RECURSE DEBUG_MAKEFILES ${DEBUG_DIR}/*Makefile*)
-
-            foreach(DEBUG_MAKEFILE ${DEBUG_MAKEFILES})
-                file(READ "${DEBUG_MAKEFILE}" _contents)
-                string(REPLACE "zlib.lib" "zlibd.lib" _contents "${_contents}")
-                string(REPLACE "installed\\${TARGET_TRIPLET}\\lib" "installed\\${TARGET_TRIPLET}\\debug\\lib" _contents "${_contents}")
-                string(REPLACE "/LIBPATH:${NATIVE_INSTALLED_DIR}\\debug\\lib" "/LIBPATH:${NATIVE_INSTALLED_DIR}\\debug\\lib\\manual-link /LIBPATH:${NATIVE_INSTALLED_DIR}\\debug\\lib shell32.lib" _contents "${_contents}")
-                string(REPLACE "tools\\qt5\\qmlcachegen.exe" "tools\\qt5-declarative\\qmlcachegen.exe" _contents "${_contents}")
-                string(REPLACE "tools/qt5/qmlcachegen" "tools/qt5-declarative/qmlcachegen" _contents "${_contents}")
-                string(REPLACE "debug\\lib\\Qt5Bootstrap.lib" "tools\\qt5\\Qt5Bootstrap.lib" _contents "${_contents}")
-                string(REPLACE "lib\\Qt5Bootstrap.lib" "tools\\qt5\\Qt5Bootstrap.lib" _contents "${_contents}")
-                string(REPLACE " Qt5Bootstrap.lib " " ${NATIVE_INSTALLED_DIR}\\tools\\qt5\\Qt5Bootstrap.lib Ole32.lib Netapi32.lib Advapi32.lib ${NATIVE_INSTALLED_DIR}\\lib\\zlib.lib Shell32.lib " _contents "${_contents}")
-                file(WRITE "${DEBUG_MAKEFILE}" "${_contents}")
-            endforeach()
-        endif()
-
-        run_jom("${_csc_DEBUG_TARGETS}" ${_csc_BUILD_LOGNAME} dbg)
+        set(_buildname "DEBUG")
+        list(APPEND BUILDTYPES ${_buildname})
+        set(_short_name_${_buildname} "dbg")
+        set(_path_suffix_${_buildname} "/debug")        
     endif()
-
     if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
-        set(ENV{PATH} "${CURRENT_INSTALLED_DIR}/lib${_PATHSEP}${CURRENT_INSTALLED_DIR}/bin${_PATHSEP}${CURRENT_INSTALLED_DIR}/tools/qt5${_PATHSEP}${ENV_PATH_BACKUP}")
-        if(NOT _csc_SKIP_MAKEFILES)
-            run_jom(qmake_all makefiles rel)
-
-            #Store release makefile path
-            file(GLOB_RECURSE RELEASE_MAKEFILES ${RELEASE_DIR}/*Makefile*)
-
-            foreach(RELEASE_MAKEFILE ${RELEASE_MAKEFILES})
-                file(READ "${RELEASE_MAKEFILE}" _contents)
-                string(REPLACE "/LIBPATH:${NATIVE_INSTALLED_DIR}\\lib" "/LIBPATH:${NATIVE_INSTALLED_DIR}\\lib\\manual-link /LIBPATH:${NATIVE_INSTALLED_DIR}\\lib shell32.lib" _contents "${_contents}")
-                string(REPLACE "tools\\qt5\\qmlcachegen.exe" "tools\\qt5-declarative\\qmlcachegen.exe" _contents "${_contents}")
-                string(REPLACE "tools/qt5/qmlcachegen" "tools/qt5-declarative/qmlcachegen" _contents "${_contents}")
-                string(REPLACE "debug\\lib\\Qt5Bootstrap.lib" "tools\\qt5\\Qt5Bootstrap.lib" _contents "${_contents}")
-                string(REPLACE "lib\\Qt5Bootstrap.lib" "tools\\qt5\\Qt5Bootstrap.lib" _contents "${_contents}")
-                string(REPLACE " Qt5Bootstrap.lib " " ${NATIVE_INSTALLED_DIR}\\tools\\qt5\\Qt5Bootstrap.lib Ole32.lib Netapi32.lib Advapi32.lib ${NATIVE_INSTALLED_DIR}\\lib\\zlib.lib Shell32.lib " _contents "${_contents}")
-                file(WRITE "${RELEASE_MAKEFILE}" "${_contents}")
-            endforeach()
-        endif()
-
-        run_jom("${_csc_RELEASE_TARGETS}" ${_csc_BUILD_LOGNAME} rel)
+        set(_buildname "RELEASE")
+        list(APPEND BUILDTYPES ${_buildname})
+        set(_short_name_${_buildname} "rel")
+        set(_path_suffix_${_buildname} "")        
     endif()
+    unset(_buildname)
     
+    foreach(_buildname ${BUILDTYPES})
+        set(_BUILD_PREFIX "${_path_suffix_${_buildname}}")
+        vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}${_BUILD_PREFIX}/bin")
+        vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}${_BUILD_PREFIX}/lib")
+        list(APPEND _csc_${_buildname}_TARGETS ${_csc_TARGETS})
+        if(NOT _csc_SKIP_MAKEFILES)
+            run_jom(qmake_all makefiles ${_short_name_${_buildname}})
+        endif()
+        run_jom("${_csc_${_buildname}_TARGETS}" ${_csc_BUILD_LOGNAME} ${_short_name_${_buildname}})
+    endforeach()
+      
     # Restore the original value of ENV{PATH}
     set(ENV{PATH} "${ENV_PATH_BACKUP}")
     set(ENV{_CL_} "${ENV_CL_BACKUP}")
diff --git a/scripts/cmake/vcpkg_buildpath_length_warning.cmake b/scripts/cmake/vcpkg_buildpath_length_warning.cmake
new file mode 100644
index 000000000..b7ef10bb8
--- /dev/null
+++ b/scripts/cmake/vcpkg_buildpath_length_warning.cmake
@@ -0,0 +1,8 @@
+function(vcpkg_buildpath_length_warning WARNING_LENGTH)

+    string(LENGTH "${CURRENT_BUILDTREES_DIR}" BUILDTREES_PATH_LENGTH)

+    if(BUILDTREES_PATH_LENGTH GREATER ${WARNING_LENGTH} AND CMAKE_HOST_WIN32)

+            message(WARNING "${PORT}'s buildsystem uses very long paths and may fail on your system.\n"

+                "We recommend moving vcpkg to a short path such as 'C:\\src\\vcpkg' or using the subst command."

+            )

+    endif()

+endfunction()
\ No newline at end of file
diff --git a/scripts/cmake/vcpkg_common_definitions.cmake b/scripts/cmake/vcpkg_common_definitions.cmake
index df8c0a06c..75a1e8a9c 100644
--- a/scripts/cmake/vcpkg_common_definitions.cmake
+++ b/scripts/cmake/vcpkg_common_definitions.cmake
@@ -6,17 +6,22 @@
 ## ```cmake
 ## VCPKG_TARGET_IS_<target>                 with <target> being one of the following: WINDOWS, UWP, LINUX, OSX, ANDROID, FREEBSD. only defined if <target>
 ## VCPKG_HOST_PATH_SEPARATOR                Host specific path separator
-## VCPKG_HOST_PATH_SEPARATOR_ESCAPED        Escaped version of VCPKG_HOST_PATH_SEPARATOR if necessary (e.g. symbol with special meaning in cmake like ";")
+## VCPKG_HOST_PATH_SEPARATOR_ESCAPED        Escaped version of VCPKG_HOST_PATH_SEPARATOR if necessary (set to VCPKG_HOST_PATH_SEPARATOR if not necessary)
 ## VCPKG_HOST_EXECUTABLE_SUFFIX             executable suffix of the host
 ## VCPKG_TARGET_EXECUTABLE_SUFFIX           executable suffix of the target
 ## VCPKG_TARGET_STATIC_LIBRARY_PREFIX       static library prefix for target (same as CMAKE_STATIC_LIBRARY_PREFIX)
 ## VCPKG_TARGET_STATIC_LIBRARY_SUFFIX       static library suffix for target (same as CMAKE_STATIC_LIBRARY_SUFFIX)
 ## VCPKG_TARGET_SHARED_LIBRARY_PREFIX       shared library prefix for target (same as CMAKE_SHARED_LIBRARY_PREFIX)
 ## VCPKG_TARGET_SHARED_LIBRARY_SUFFIX       shared library suffix for target (same as CMAKE_SHARED_LIBRARY_SUFFIX)
+## VCPKG_TARGET_IMPORT_LIBRARY_PREFIX       import library prefix for target (same as CMAKE_IMPORT_LIBRARY_PREFIX)
+## VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX       import library suffix for target (same as CMAKE_IMPORT_LIBRARY_SUFFIX)
+## VCPKG_FIND_LIBRARY_PREFIXES              target dependent prefixes used for find_library calls in portfiles
+## VCPKG_FIND_LIBRARY_SUFFIXES              target dependent suffixes used for find_library calls in portfiles
 ## ```
-## 
-## CMAKE_STATIC_LIBRARY_PREFIX, CMAKE_STATIC_LIBRARY_SUFFIX, CMAKE_SHARED_LIBRARY_PREFIX, CMAKE_SHARED_LIBRARY_SUFFIX are defined for the target so that 
-## portfiles are able to use find_library calls to discover dependent libraries within the current triplet for ports. 
+##
+## CMAKE_STATIC_LIBRARY_(PREFIX|SUFFIX), CMAKE_SHARED_LIBRARY_(PREFIX|SUFFIX) and CMAKE_IMPORT_LIBRARY_(PREFIX|SUFFIX) are defined for the target
+## Furthermore the variables CMAKE_FIND_LIBRARY_(PREFIXES|SUFFIXES) are also defined for the target so that
+## portfiles are able to use find_library calls to discover dependent libraries within the current triplet for ports.
 ##
 
 #Helper variable to identify the Target system. VCPKG_TARGET_IS_<targetname>
@@ -37,11 +42,12 @@ endif()
 
 #Helper variable to identify the host path separator. 
 if(CMAKE_HOST_WIN32)
-    set(VCPKG_HOST_PATH_SEPARATOR ";")
-    set(VCPKG_HOST_PATH_SEPARATOR_ESCAPED "\\;") #sometimes needed to differentiate between the cmake list separator
+    set(VCPKG_HOST_PATH_SEPARATOR "\;")           #Is escaped here because else VCPKG_HOST_PATH_SEPARATOR will be a list of two empty elements
+    set(VCPKG_HOST_PATH_SEPARATOR_ESCAPED "\\\;") #Needed if you want to pass around variables with VCPKG_HOST_PATH_SEPARATOR
 elseif(CMAKE_HOST_UNIX)
     set(VCPKG_HOST_PATH_SEPARATOR ":")
-    set(VCPKG_HOST_PATH_SEPARATOR_ESCAPED ":")
+    set(VCPKG_HOST_PATH_SEPARATOR_ESCAPED ${VCPKG_HOST_PATH_SEPARATOR})
+endif()
 
 #Helper variables to identify executables on host/target
 if(CMAKE_HOST_WIN32)
@@ -57,25 +63,44 @@ else()
     set(VCPKG_TARGET_EXECUTABLE_SUFFIX "")
 endif()
 
-#Helper variables for libraries 
+#Helper variables for libraries
 if(VCPKG_TARGET_IS_WINDOWS)
     set(VCPKG_TARGET_STATIC_LIBRARY_SUFFIX ".lib")
     set(VCPKG_TARGET_SHARED_LIBRARY_SUFFIX ".dll")
+    set(VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX ".lib")
     set(VCPKG_TARGET_STATIC_LIBRARY_PREFIX "")
     set(VCPKG_TARGET_SHARED_LIBRARY_PREFIX "")
+    set(VCPKG_TARGET_IMPORT_LIBRARY_PREFIX "")
+    set(VCPKG_FIND_LIBRARY_SUFFIXES ".lib" ".dll") #This is a slight modification to CMakes value which does not include ".dll".
+    set(VCPKG_FIND_LIBRARY_PREFIXES "" "lib") #This is a slight modification to CMakes value which does not include "lib".
+    ## For CYGWIN and Windows GNU, maybe VCPKG will support that in the future?
+    #set(VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX ".dll.a")
+    #set(VCPKG_TARGET_IMPORT_LIBRARY_PREFIX "lib")
+    #set(VCPKG_FIND_LIBRARY_SUFFIXES ".dll" ".dll.a" ".a" ".lib")
+    #set(VCPKG_FIND_LIBRARY_PREFIXES "lib" "")
+elseif(VCPKG_TARGET_IS_OSX)
+    set(VCPKG_TARGET_STATIC_LIBRARY_SUFFIX ".a")
+    set(VCPKG_TARGET_SHARED_LIBRARY_SUFFIX ".dylib")
+    set(VCPKG_TARGET_STATIC_LIBRARY_PREFIX "lib")
+    set(VCPKG_TARGET_SHARED_LIBRARY_PREFIX "lib")
+    set(VCPKG_FIND_LIBRARY_SUFFIXES ".tbd" ".dylib" ".so" ".a")
+    set(VCPKG_FIND_LIBRARY_PREFIXES "lib" "")
 else()
     set(VCPKG_TARGET_STATIC_LIBRARY_SUFFIX ".a")
     set(VCPKG_TARGET_SHARED_LIBRARY_SUFFIX ".so")
     set(VCPKG_TARGET_STATIC_LIBRARY_PREFIX "lib")
     set(VCPKG_TARGET_SHARED_LIBRARY_PREFIX "lib")
+    set(VCPKG_FIND_LIBRARY_SUFFIXES ".so" ".a")
+    set(VCPKG_FIND_LIBRARY_PREFIXES "lib" "")
 endif()
 #Setting these variables allows find_library to work in script mode and thus in portfiles!
 #This allows us scale down on hardcoded target dependent paths in portfiles
-set(CMAKE_STATIC_LIBRARY_SUFFIX ${VCPKG_TARGET_STATIC_LIBRARY_SUFFIX})
-set(CMAKE_SHARED_LIBRARY_SUFFIX ${VCPKG_TARGET_SHARED_LIBRARY_SUFFIX})
-set(CMAKE_STATIC_LIBRARY_PREFIX ${VCPKG_TARGET_STATIC_LIBRARY_PREFIX})
-set(CMAKE_SHARED_LIBRARY_PREFIX ${VCPKG_TARGET_SHARED_LIBRARY_PREFIX})
-set(CMAKE_FIND_LIBRARY_SUFFIXES "${CMAKE_STATIC_LIBRARY_SUFFIX};${CMAKE_SHARED_LIBRARY_SUFFIX}" CACHE INTERNAL "") # Required by find_library
-set(CMAKE_FIND_LIBRARY_PREFIXES "${CMAKE_STATIC_LIBRARY_PREFIX};${CMAKE_SHARED_LIBRARY_PREFIX}" CACHE INTERNAL "") # Required by find_library
-
+set(CMAKE_STATIC_LIBRARY_SUFFIX "${VCPKG_TARGET_STATIC_LIBRARY_SUFFIX}")
+set(CMAKE_SHARED_LIBRARY_SUFFIX "${VCPKG_TARGET_SHARED_LIBRARY_SUFFIX}")
+set(CMAKE_IMPORT_LIBRARY_SUFFIX "${VCPKG_TARGET_IMPORT_LIBRARY_PREFIX}")
+set(CMAKE_STATIC_LIBRARY_PREFIX "${VCPKG_TARGET_STATIC_LIBRARY_PREFIX}")
+set(CMAKE_SHARED_LIBRARY_PREFIX "${VCPKG_TARGET_SHARED_LIBRARY_PREFIX}")
+set(CMAKE_IMPORT_LIBRARY_PREFIX "${VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX}")
 
+set(CMAKE_FIND_LIBRARY_SUFFIXES "${VCPKG_FIND_LIBRARY_SUFFIXES}" CACHE INTERNAL "") # Required by find_library
+set(CMAKE_FIND_LIBRARY_PREFIXES "${VCPKG_FIND_LIBRARY_PREFIXES}" CACHE INTERNAL "") # Required by find_library
diff --git a/scripts/cmake/vcpkg_common_functions.cmake b/scripts/cmake/vcpkg_common_functions.cmake
index e9e52bad8..d2ea35608 100644
--- a/scripts/cmake/vcpkg_common_functions.cmake
+++ b/scripts/cmake/vcpkg_common_functions.cmake
@@ -1,3 +1,4 @@
+include(execute_process)
 include(vcpkg_acquire_msys)
 include(vcpkg_add_to_path)
 include(vcpkg_check_features)
@@ -34,3 +35,4 @@ include(vcpkg_replace_string)
 include(vcpkg_from_git)
 include(vcpkg_test_cmake)
 include(vcpkg_prettify_command)
+include(vcpkg_buildpath_length_warning)
diff --git a/scripts/cmake/vcpkg_configure_cmake.cmake b/scripts/cmake/vcpkg_configure_cmake.cmake
index 6c392d385..1c3a26a74 100644
--- a/scripts/cmake/vcpkg_configure_cmake.cmake
+++ b/scripts/cmake/vcpkg_configure_cmake.cmake
@@ -198,15 +198,15 @@ function(vcpkg_configure_cmake)
 
     if(NOT VCPKG_CHAINLOAD_TOOLCHAIN_FILE)
         if(NOT DEFINED VCPKG_CMAKE_SYSTEM_NAME OR _TARGETTING_UWP)
-            set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${VCPKG_ROOT_DIR}/scripts/toolchains/windows.cmake")
+            set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/windows.cmake")
         elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Linux")
-            set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${VCPKG_ROOT_DIR}/scripts/toolchains/linux.cmake")
+            set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/linux.cmake")
         elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Android")
-            set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${VCPKG_ROOT_DIR}/scripts/toolchains/android.cmake")
+            set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/android.cmake")
         elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Darwin")
-            set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${VCPKG_ROOT_DIR}/scripts/toolchains/osx.cmake")
+            set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/osx.cmake")
         elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
-            set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${VCPKG_ROOT_DIR}/scripts/toolchains/freebsd.cmake")
+            set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/freebsd.cmake")
         endif()
     endif()
 
@@ -222,7 +222,7 @@ function(vcpkg_configure_cmake)
         "-DCMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP=TRUE"
         "-DCMAKE_VERBOSE_MAKEFILE=ON"
         "-DVCPKG_APPLOCAL_DEPS=OFF"
-        "-DCMAKE_TOOLCHAIN_FILE=${VCPKG_ROOT_DIR}/scripts/buildsystems/vcpkg.cmake"
+        "-DCMAKE_TOOLCHAIN_FILE=${SCRIPTS}/buildsystems/vcpkg.cmake"
         "-DCMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION=ON"
         "-DVCPKG_CXX_FLAGS=${VCPKG_CXX_FLAGS}"
         "-DVCPKG_CXX_FLAGS_RELEASE=${VCPKG_CXX_FLAGS_RELEASE}"
diff --git a/scripts/cmake/vcpkg_configure_qmake.cmake b/scripts/cmake/vcpkg_configure_qmake.cmake
index d660fedd7..73f554a33 100644
--- a/scripts/cmake/vcpkg_configure_qmake.cmake
+++ b/scripts/cmake/vcpkg_configure_qmake.cmake
@@ -6,37 +6,53 @@
 #  ::
 #  vcpkg_configure_qmake(SOURCE_PATH <pro_file_path>
 #                        [OPTIONS arg1 [arg2 ...]]
+#                        [OPTIONS_RELEASE arg1 [arg2 ...]]
+#                        [OPTIONS_DEBUG arg1 [arg2 ...]]
 #                        )
 #
 #  ``SOURCE_PATH``
 #    The path to the *.pro qmake project file.
-#  ``OPTIONS``
+#  ``OPTIONS[_RELEASE|_DEBUG]``
 #    The options passed to qmake.
 
 function(vcpkg_configure_qmake)
-    cmake_parse_arguments(_csc "" "SOURCE_PATH" "OPTIONS" ${ARGN})
-
+    cmake_parse_arguments(_csc "" "SOURCE_PATH" "OPTIONS;OPTIONS_RELEASE;OPTIONS_DEBUG" ${ARGN})
+     
     # Find qmake executable
-    find_program(QMAKE_COMMAND NAMES qmake PATHS ${CURRENT_INSTALLED_DIR}/tools/qt5)
+    set(_triplet_hostbindir ${CURRENT_INSTALLED_DIR}/tools/qt5/bin)
+    find_program(QMAKE_COMMAND NAMES qmake PATHS ${VCPKG_QT_HOST_TOOLS_ROOT_DIR}/bin ${_triplet_hostbindir})
 
     if(NOT QMAKE_COMMAND)
         message(FATAL_ERROR "vcpkg_configure_qmake: unable to find qmake.")
     endif()
 
-    if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
-        list(APPEND _csc_OPTIONS CONFIG+=staticlib)
+    if(${VCPKG_LIBRARY_LINKAGE} STREQUAL "static")
+        list(APPEND _csc_OPTIONS "CONFIG-=shared")
+        list(APPEND _csc_OPTIONS "CONFIG*=static")
+    else()
+        list(APPEND _csc_OPTIONS "CONFIG-=static")
+        list(APPEND _csc_OPTIONS "CONFIG*=shared")
+        list(APPEND _csc_OPTIONS_DEBUG "CONFIG*=separate_debug_info")
     endif()
-
+    
+    if(VCPKG_TARGET_IS_WINDOWS AND ${VCPKG_CRT_LINKAGE} STREQUAL "static")
+        list(APPEND _csc_OPTIONS "CONFIG*=static-runtime")
+    endif()
+    
     # Cleanup build directories
     file(REMOVE_RECURSE ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg)
 
+    if(DEFINED VCPKG_OSX_DEPLOYMENT_TARGET)
+        set(ENV{QMAKE_MACOSX_DEPLOYMENT_TARGET} ${VCPKG_OSX_DEPLOYMENT_TARGET})
+    endif()
+
     if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
         configure_file(${CURRENT_INSTALLED_DIR}/tools/qt5/qt_release.conf ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/qt.conf)
     
         message(STATUS "Configuring ${TARGET_TRIPLET}-rel")
         file(MAKE_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel)
         vcpkg_execute_required_process(
-            COMMAND ${QMAKE_COMMAND} CONFIG-=debug CONFIG+=release ${_csc_OPTIONS} ${_csc_SOURCE_PATH} -qtconf "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/qt.conf"
+            COMMAND ${QMAKE_COMMAND} CONFIG-=debug CONFIG+=release ${_csc_OPTIONS} ${_csc_OPTIONS_RELEASE} ${_csc_SOURCE_PATH} -qtconf "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/qt.conf"
             WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel
             LOGNAME config-${TARGET_TRIPLET}-rel
         )
@@ -49,7 +65,7 @@ function(vcpkg_configure_qmake)
         message(STATUS "Configuring ${TARGET_TRIPLET}-dbg")
         file(MAKE_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg)
         vcpkg_execute_required_process(
-            COMMAND ${QMAKE_COMMAND} CONFIG-=release CONFIG+=debug ${_csc_OPTIONS} ${_csc_SOURCE_PATH} -qtconf "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/qt.conf"
+            COMMAND ${QMAKE_COMMAND} CONFIG-=release CONFIG+=debug ${_csc_OPTIONS} ${_csc_OPTIONS_DEBUG} ${_csc_SOURCE_PATH} -qtconf "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/qt.conf"
             WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg
             LOGNAME config-${TARGET_TRIPLET}-dbg
         )
diff --git a/scripts/cmake/vcpkg_copy_tool_dependencies.cmake b/scripts/cmake/vcpkg_copy_tool_dependencies.cmake
index 165f19ed1..396d20b41 100644
--- a/scripts/cmake/vcpkg_copy_tool_dependencies.cmake
+++ b/scripts/cmake/vcpkg_copy_tool_dependencies.cmake
@@ -21,7 +21,7 @@ function(vcpkg_copy_tool_dependencies TOOL_DIR)
         file(GLOB TOOLS ${TOOL_DIR}/*.exe ${TOOL_DIR}/*.dll)
         foreach(TOOL ${TOOLS})
             execute_process(COMMAND powershell -noprofile -executionpolicy Bypass -nologo
-                -file ${VCPKG_ROOT_DIR}/scripts/buildsystems/msbuild/applocal.ps1
+                -file ${SCRIPTS}/buildsystems/msbuild/applocal.ps1
                 -targetBinary ${TOOL}
                 -installedDir ${PATH_TO_SEARCH}
                 OUTPUT_VARIABLE OUT)
diff --git a/scripts/cmake/vcpkg_download_distfile.cmake b/scripts/cmake/vcpkg_download_distfile.cmake
index 72016b8c9..1fbff40e5 100644
--- a/scripts/cmake/vcpkg_download_distfile.cmake
+++ b/scripts/cmake/vcpkg_download_distfile.cmake
@@ -120,7 +120,7 @@ function(vcpkg_download_distfile VAR)
                     list(APPEND request_headers "--header=${header}")
                 endforeach()
             endif()
-            execute_process(
+            _execute_process(
                 COMMAND ${ARIA2} ${vcpkg_download_distfile_URLS}
                 -o temp/${vcpkg_download_distfile_FILENAME}
                 -l download-${vcpkg_download_distfile_FILENAME}-detailed.log
diff --git a/scripts/cmake/vcpkg_execute_required_process.cmake b/scripts/cmake/vcpkg_execute_required_process.cmake
index e65d1970a..f25a5b55e 100644
--- a/scripts/cmake/vcpkg_execute_required_process.cmake
+++ b/scripts/cmake/vcpkg_execute_required_process.cmake
@@ -11,6 +11,10 @@
 ## )
 ## ```
 ## ## Parameters
+## ### ALLOW_IN_DOWNLOAD_MODE
+## Allows the command to execute in Download Mode.  
+## [See execute_process() override](../../scripts/cmake/execute_process.cmake).
+##
 ## ### COMMAND
 ## The command to be executed, along with its arguments.
 ##
@@ -30,10 +34,20 @@
 ## * [qt5](https://github.com/Microsoft/vcpkg/blob/master/ports/qt5/portfile.cmake)
 include(vcpkg_prettify_command)
 function(vcpkg_execute_required_process)
-    cmake_parse_arguments(vcpkg_execute_required_process "" "WORKING_DIRECTORY;LOGNAME" "COMMAND" ${ARGN})
+    cmake_parse_arguments(vcpkg_execute_required_process "ALLOW_IN_DOWNLOAD_MODE" "WORKING_DIRECTORY;LOGNAME" "COMMAND" ${ARGN})
     set(LOG_OUT "${CURRENT_BUILDTREES_DIR}/${vcpkg_execute_required_process_LOGNAME}-out.log")
     set(LOG_ERR "${CURRENT_BUILDTREES_DIR}/${vcpkg_execute_required_process_LOGNAME}-err.log")
-    execute_process(
+
+    set(execute_process_function execute_process)
+    if (DEFINED VCPKG_DOWNLOAD_MODE AND NOT vcpkg_execute_required_process_ALLOW_IN_DOWNLOAD_MODE)
+        message(FATAL_ERROR 
+[[
+This command cannot be executed in Download Mode.
+Halting portfile execution.
+]])
+    endif()
+
+    _execute_process(
         COMMAND ${vcpkg_execute_required_process_COMMAND}
         OUTPUT_FILE ${LOG_OUT}
         ERROR_FILE ${LOG_ERR}
diff --git a/scripts/cmake/vcpkg_extract_source_archive.cmake b/scripts/cmake/vcpkg_extract_source_archive.cmake
index a55419b19..fbae94b55 100644
--- a/scripts/cmake/vcpkg_extract_source_archive.cmake
+++ b/scripts/cmake/vcpkg_extract_source_archive.cmake
@@ -41,6 +41,7 @@ function(vcpkg_extract_source_archive ARCHIVE)
         message(STATUS "Extracting source ${ARCHIVE}")
         file(MAKE_DIRECTORY ${WORKING_DIRECTORY})
         vcpkg_execute_required_process(
+            ALLOW_IN_DOWNLOAD_MODE
             COMMAND ${CMAKE_COMMAND} -E tar xjf ${ARCHIVE}
             WORKING_DIRECTORY ${WORKING_DIRECTORY}
             LOGNAME extract
diff --git a/scripts/cmake/vcpkg_find_acquire_program.cmake b/scripts/cmake/vcpkg_find_acquire_program.cmake
index fed016c7b..aa8a70026 100644
--- a/scripts/cmake/vcpkg_find_acquire_program.cmake
+++ b/scripts/cmake/vcpkg_find_acquire_program.cmake
@@ -302,12 +302,12 @@ function(vcpkg_find_acquire_program VAR)
       if(ARCHIVE_EXTENSION STREQUAL ".msi")
         file(TO_NATIVE_PATH "${ARCHIVE_PATH}" ARCHIVE_NATIVE_PATH)
         file(TO_NATIVE_PATH "${PROG_PATH_SUBDIR}" DESTINATION_NATIVE_PATH)
-        execute_process(
+        _execute_process(
           COMMAND msiexec /a ${ARCHIVE_NATIVE_PATH} /qn TARGETDIR=${DESTINATION_NATIVE_PATH}
           WORKING_DIRECTORY ${DOWNLOADS}
         )
       else()
-        execute_process(
+        _execute_process(
           COMMAND ${CMAKE_COMMAND} -E tar xzf ${ARCHIVE_PATH}
           WORKING_DIRECTORY ${PROG_PATH_SUBDIR}
         )
@@ -316,6 +316,7 @@ function(vcpkg_find_acquire_program VAR)
 
     if(DEFINED POST_INSTALL_COMMAND)
       vcpkg_execute_required_process(
+        ALLOW_IN_DOWNLOAD_MODE
         COMMAND ${POST_INSTALL_COMMAND}
         WORKING_DIRECTORY ${PROG_PATH_SUBDIR}
         LOGNAME ${VAR}-tool-post-install
diff --git a/scripts/cmake/vcpkg_from_git.cmake b/scripts/cmake/vcpkg_from_git.cmake
index 0db818f80..bad5384ca 100644
--- a/scripts/cmake/vcpkg_from_git.cmake
+++ b/scripts/cmake/vcpkg_from_git.cmake
@@ -74,16 +74,18 @@ function(vcpkg_from_git)
     find_program(GIT NAMES git git.cmd)
     # Note: git init is safe to run multiple times
     vcpkg_execute_required_process(
+      ALLOW_IN_DOWNLOAD_MODE
       COMMAND ${GIT} init git-tmp
       WORKING_DIRECTORY ${DOWNLOADS}
       LOGNAME git-init-${TARGET_TRIPLET}
     )
     vcpkg_execute_required_process(
+      ALLOW_IN_DOWNLOAD_MODE
       COMMAND ${GIT} fetch ${_vdud_URL} ${_vdud_REF} --depth 1 -n
       WORKING_DIRECTORY ${DOWNLOADS}/git-tmp
       LOGNAME git-fetch-${TARGET_TRIPLET}
     )
-    execute_process(
+    _execute_process(
       COMMAND ${GIT} rev-parse FETCH_HEAD
       OUTPUT_VARIABLE REV_PARSE_HEAD
       ERROR_VARIABLE REV_PARSE_HEAD
@@ -100,6 +102,7 @@ function(vcpkg_from_git)
 
     file(MAKE_DIRECTORY "${DOWNLOADS}/temp")
     vcpkg_execute_required_process(
+      ALLOW_IN_DOWNLOAD_MODE
       COMMAND ${GIT} archive FETCH_HEAD -o "${TEMP_ARCHIVE}"
       WORKING_DIRECTORY ${DOWNLOADS}/git-tmp
       LOGNAME git-archive
diff --git a/scripts/cmake/vcpkg_from_gitlab.cmake b/scripts/cmake/vcpkg_from_gitlab.cmake
index 6bbe81ed6..05253289e 100644
--- a/scripts/cmake/vcpkg_from_gitlab.cmake
+++ b/scripts/cmake/vcpkg_from_gitlab.cmake
@@ -150,7 +150,7 @@ function(vcpkg_from_gitlab)
     endif()
 
     # There are issues with the Gitlab API project paths being URL-escaped, so we use git here to get the head revision
-    execute_process(COMMAND ${GIT} ls-remote
+    _execute_process(COMMAND ${GIT} ls-remote
         "${_vdud_GITLAB_URL}/${ORG_NAME}/${REPO_NAME}.git" "${_vdud_HEAD_REF}"
         RESULT_VARIABLE _git_result
         OUTPUT_VARIABLE _git_output
diff --git a/scripts/cmake/vcpkg_install_msbuild.cmake b/scripts/cmake/vcpkg_install_msbuild.cmake
index 92c84bf0b..7c2fdd836 100644
--- a/scripts/cmake/vcpkg_install_msbuild.cmake
+++ b/scripts/cmake/vcpkg_install_msbuild.cmake
@@ -144,7 +144,7 @@ function(vcpkg_install_msbuild)
     endif()
 
     if(_csc_USE_VCPKG_INTEGRATION)
-        list(APPEND _csc_OPTIONS /p:ForceImportBeforeCppTargets=${VCPKG_ROOT_DIR}/scripts/buildsystems/msbuild/vcpkg.targets /p:VcpkgApplocalDeps=false)
+        list(APPEND _csc_OPTIONS /p:ForceImportBeforeCppTargets=${SCRIPTS}/buildsystems/msbuild/vcpkg.targets /p:VcpkgApplocalDeps=false)
     endif()
 
     get_filename_component(SOURCE_PATH_SUFFIX "${_csc_SOURCE_PATH}" NAME)
diff --git a/scripts/cmake/vcpkg_test_cmake.cmake b/scripts/cmake/vcpkg_test_cmake.cmake
index 20343bf64..eeb27867c 100644
--- a/scripts/cmake/vcpkg_test_cmake.cmake
+++ b/scripts/cmake/vcpkg_test_cmake.cmake
@@ -21,59 +21,4 @@ function(vcpkg_test_cmake)
   #   2. Select a generator in the same method as vcpkg_configure_cmake() as though the PREFER_NINJA flag was always passed.
   #   3. Fully emulate the toolchain file for the just-built package (just adding it to CMAKE_PREFIX_PATH is not enough).
   return()
-
-  cmake_parse_arguments(_tc "MODULE" "PACKAGE_NAME" "" ${ARGN})
-
-  if(NOT DEFINED _tc_PACKAGE_NAME)
-    message(FATAL_ERROR "PACKAGE_NAME must be specified")
-  endif()
-  if(_tc_MODULE)
-    set(PACKAGE_TYPE MODULE)
-  else()
-    set(PACKAGE_TYPE CONFIG)
-  endif()
-
-  if(VCPKG_PLATFORM_TOOLSET STREQUAL "v142")
-    message(STATUS "Skipping CMake integration test due to v142 / CMake interaction issues")
-    return()
-  endif()
-
-  message(STATUS "Performing CMake integration test")
-  file(REMOVE_RECURSE ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-test)
-  file(MAKE_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-test)
-
-  #Generate Dummy source
-#    set(VCPKG_TEST_SOURCE ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-test/CMakeIntegration.cpp)
-#    file(WRITE  ${VCPKG_TEST_SOURCE} "int main() \{\n")
-#    file(APPEND ${VCPKG_TEST_SOURCE} "return 0;}")
-  # Generate test source CMakeLists.txt
-  set(VCPKG_TEST_CMAKELIST ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-test/CMakeLists.txt)
-  file(WRITE  ${VCPKG_TEST_CMAKELIST} "cmake_minimum_required(VERSION 3.10)\n")
-  file(APPEND ${VCPKG_TEST_CMAKELIST} "set(CMAKE_PREFIX_PATH \"${CURRENT_PACKAGES_DIR};${CURRENT_INSTALLED_DIR}\")\n")
-  file(APPEND ${VCPKG_TEST_CMAKELIST} "\n")
-  file(APPEND ${VCPKG_TEST_CMAKELIST} "find_package(${_tc_PACKAGE_NAME} ${PACKAGE_TYPE} REQUIRED)\n")
-  #To properly test if the package is actually working haveway correctly we have to link all targets of a package to 
-  #a test executable and than actually build it. This will not discover if every symbol exported by the library is available/linked
-  #but it will doscover if all files which are linked by a target actual exist. Problem is: How to discover all targets?
-#    file(APPEND ${VCPKG_TEST_CMAKELIST} "add_executable(${_tc_PACKAGE_NAME}_exe ${VCPKG_TEST_SOURCE})\n")
-#    file(APPEND ${VCPKG_TEST_CMAKELIST} "target_link_libraries(${_tc_PACKAGE_NAME}_exe PRIVATE ${_tc_PACKAGE_NAME})\n")
-
-  if(DEFINED _VCPKG_CMAKE_GENERATOR)
-      set(VCPKG_CMAKE_TEST_GENERATOR "${_VCPKG_CMAKE_GENERATOR}")
-  else()
-      set(VCPKG_CMAKE_TEST_GENERATOR Ninja)
-  endif()
-
-  # Run cmake config with a generated CMakeLists.txt
-  set(LOGPREFIX "${CURRENT_BUILDTREES_DIR}/test-cmake-${TARGET_TRIPLET}")
-  execute_process(
-    COMMAND ${CMAKE_COMMAND} -G ${VCPKG_CMAKE_TEST_GENERATOR} .
-    OUTPUT_FILE "${LOGPREFIX}-out.log"
-    ERROR_FILE "${LOGPREFIX}-err.log"
-    RESULT_VARIABLE error_code
-    WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-test
-  )
-  if(error_code)
-    message(FATAL_ERROR "CMake integration test failed; unable to find_package(${_tc_PACKAGE_NAME} ${PACKAGE_TYPE} REQUIRED)")
-  endif()
 endfunction()
diff --git a/scripts/ports.cmake b/scripts/ports.cmake
index 056485568..456434f12 100644
--- a/scripts/ports.cmake
+++ b/scripts/ports.cmake
@@ -7,22 +7,28 @@ macro(debug_message)
 endmacro()
 
 #Detect .vcpkg-root to figure VCPKG_ROOT_DIR, starting from triplet folder.
-get_filename_component(TARGET_TRIPLET_DIR ${TARGET_TRIPLET_FILE} DIRECTORY)
-SET(VCPKG_ROOT_DIR_CANDIDATE ${TARGET_TRIPLET_DIR})
-while(IS_DIRECTORY ${VCPKG_ROOT_DIR_CANDIDATE} AND NOT EXISTS "${VCPKG_ROOT_DIR_CANDIDATE}/.vcpkg-root")
-    get_filename_component(VCPKG_ROOT_DIR_TEMP ${VCPKG_ROOT_DIR_CANDIDATE} DIRECTORY)
-    if (VCPKG_ROOT_DIR_TEMP STREQUAL VCPKG_ROOT_DIR_CANDIDATE) # If unchanged, we have reached the root of the drive
-        message(FATAL_ERROR "Could not find .vcpkg-root")
-    else()
-        SET(VCPKG_ROOT_DIR_CANDIDATE ${VCPKG_ROOT_DIR_TEMP})
-    endif()
-endwhile()
+set(VCPKG_ROOT_DIR_CANDIDATE ${CMAKE_CURRENT_LIST_DIR})
+
+if(DEFINED VCPKG_ROOT_PATH)
+    set(VCPKG_ROOT_DIR_CANDIDATE ${VCPKG_ROOT_PATH})
+else()
+    message(FATAL_ERROR [[
+        Your vcpkg executable is outdated and is not compatible with the current CMake scripts.
+        Please re-build vcpkg by running bootstrap-vcpkg.
+    ]])
+endif()
+
+# Validate VCPKG_ROOT_DIR_CANDIDATE
+if (NOT EXISTS "${VCPKG_ROOT_DIR_CANDIDATE}/.vcpkg-root")
+    message(FATAL_ERROR "Could not find .vcpkg-root")
+endif()
 
 set(VCPKG_ROOT_DIR ${VCPKG_ROOT_DIR_CANDIDATE})
 
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/cmake)
 set(CURRENT_INSTALLED_DIR ${VCPKG_ROOT_DIR}/installed/${TARGET_TRIPLET} CACHE PATH "Location to install final packages")
 set(DOWNLOADS ${VCPKG_ROOT_DIR}/downloads CACHE PATH "Location to download sources and tools")
+set(SCRIPTS ${CMAKE_CURRENT_LIST_DIR} CACHE PATH "Location to stored scripts")
 set(PACKAGES_DIR ${VCPKG_ROOT_DIR}/packages CACHE PATH "Location to store package images")
 set(BUILDTREES_DIR ${VCPKG_ROOT_DIR}/buildtrees CACHE PATH "Location to perform actual extract+config+build")
 
@@ -80,8 +86,8 @@ if(CMD MATCHES "^BUILD$")
     endif()
 
     set(TRIPLET_SYSTEM_ARCH ${VCPKG_TARGET_ARCHITECTURE})
-    include(${CMAKE_CURRENT_LIST_DIR}/cmake/vcpkg_common_definitions.cmake)
-    include(${CMAKE_CURRENT_LIST_DIR}/cmake/vcpkg_common_functions.cmake)
+    include(${SCRIPTS}/cmake/vcpkg_common_definitions.cmake)
+    include(${SCRIPTS}/cmake/vcpkg_common_functions.cmake)
     include(${CURRENT_PORT_DIR}/portfile.cmake)
 
     set(BUILD_INFO_FILE_PATH ${CURRENT_PACKAGES_DIR}/BUILD_INFO)
@@ -131,8 +137,8 @@ elseif(CMD MATCHES "^CREATE$")
     file(SHA512 ${DOWNLOADS}/${FILENAME} SHA512)
 
     file(MAKE_DIRECTORY ports/${PORT})
-    configure_file(scripts/templates/portfile.in.cmake ports/${PORT}/portfile.cmake @ONLY)
-    configure_file(scripts/templates/CONTROL.in ports/${PORT}/CONTROL @ONLY)
+    configure_file(${SCRIPTS}/templates/portfile.in.cmake ports/${PORT}/portfile.cmake @ONLY)
+    configure_file(${SCRIPTS}/templates/CONTROL.in ports/${PORT}/CONTROL @ONLY)
 
     message(STATUS "Generated portfile: ${NATIVE_VCPKG_ROOT_DIR}\\ports\\${PORT}\\portfile.cmake")
     message(STATUS "Generated CONTROL: ${NATIVE_VCPKG_ROOT_DIR}\\ports\\${PORT}\\CONTROL")