2021-10-21 05:12:58 +08:00
macro ( z_vcpkg_determine_autotools_host_cpu out_var )
2021-04-30 20:26:05 +02:00
# TODO: the host system processor architecture can differ from the host triplet target architecture
2020-11-10 18:52:02 +01:00
if ( DEFINED ENV{PROCESSOR_ARCHITEW6432} )
2021-10-21 05:12:58 +08:00
set ( host_arch $ENV{ PROCESSOR_ARCHITEW6432 } )
2021-04-30 20:26:05 +02:00
elseif ( DEFINED ENV{PROCESSOR_ARCHITECTURE} )
2021-10-21 05:12:58 +08:00
set ( host_arch $ENV{ PROCESSOR_ARCHITECTURE } )
2021-04-30 20:26:05 +02:00
else ( )
2021-10-21 05:12:58 +08:00
set ( host_arch "${VCPKG_DETECTED_CMAKE_HOST_SYSTEM_PROCESSOR}" )
2020-11-10 18:52:02 +01:00
endif ( )
2021-10-21 05:12:58 +08:00
if ( host_arch MATCHES "(amd|AMD)64" )
2020-11-10 18:52:02 +01:00
set ( ${ out_var } x86_64 )
2021-10-21 05:12:58 +08:00
elseif ( host_arch MATCHES "(x|X)86" )
2020-11-10 18:52:02 +01:00
set ( ${ out_var } i686 )
2021-10-21 05:12:58 +08:00
elseif ( host_arch MATCHES "^(ARM|arm)64$" )
2020-11-10 18:52:02 +01:00
set ( ${ out_var } aarch64 )
2021-10-21 05:12:58 +08:00
elseif ( host_arch MATCHES "^(ARM|arm)$" )
2020-11-10 18:52:02 +01:00
set ( ${ out_var } arm )
else ( )
2021-10-21 05:12:58 +08:00
message ( FATAL_ERROR "Unsupported host architecture ${host_arch} in z_vcpkg_determine_autotools_host_cpu!" )
2020-11-10 18:52:02 +01:00
endif ( )
2021-10-21 05:12:58 +08:00
unset ( host_arch )
2020-11-10 18:52:02 +01:00
endmacro ( )
2021-10-21 05:12:58 +08:00
macro ( z_vcpkg_determine_autotools_target_cpu out_var )
2020-11-10 18:52:02 +01:00
if ( VCPKG_TARGET_ARCHITECTURE MATCHES "(x|X)64" )
set ( ${ out_var } x86_64 )
elseif ( VCPKG_TARGET_ARCHITECTURE MATCHES "(x|X)86" )
set ( ${ out_var } i686 )
elseif ( VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)64$" )
set ( ${ out_var } aarch64 )
elseif ( VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)$" )
set ( ${ out_var } arm )
else ( )
2021-10-21 05:12:58 +08:00
message ( FATAL_ERROR "Unsupported VCPKG_TARGET_ARCHITECTURE architecture ${VCPKG_TARGET_ARCHITECTURE} in z_vcpkg_determine_autotools_target_cpu!" )
2020-11-10 18:52:02 +01:00
endif ( )
endmacro ( )
2023-04-19 23:35:20 +02:00
macro ( z_vcpkg_set_arch_mac out_var value )
# Better match the arch behavior of config.guess
# See: https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
if ( "${value}" MATCHES "^(ARM|arm)64$" )
set ( ${ out_var } "aarch64" )
else ( )
set ( ${ out_var } "${value}" )
endif ( )
endmacro ( )
2021-10-21 05:12:58 +08:00
macro ( z_vcpkg_determine_autotools_host_arch_mac out_var )
2023-04-19 23:35:20 +02:00
z_vcpkg_set_arch_mac ( ${ out_var } "${VCPKG_DETECTED_CMAKE_HOST_SYSTEM_PROCESSOR}" )
2021-01-28 22:38:32 -05:00
endmacro ( )
2021-10-21 05:12:58 +08:00
macro ( z_vcpkg_determine_autotools_target_arch_mac out_var )
list ( LENGTH VCPKG_OSX_ARCHITECTURES osx_archs_num )
if ( osx_archs_num EQUAL 0 )
2023-04-19 23:35:20 +02:00
z_vcpkg_set_arch_mac ( ${ out_var } "${VCPKG_DETECTED_CMAKE_HOST_SYSTEM_PROCESSOR}" )
2021-10-21 05:12:58 +08:00
elseif ( osx_archs_num GREATER_EQUAL 2 )
2021-01-28 22:38:32 -05:00
set ( ${ out_var } "universal" )
else ( )
2023-04-19 23:35:20 +02:00
z_vcpkg_set_arch_mac ( ${ out_var } "${VCPKG_OSX_ARCHITECTURES}" )
2021-01-28 22:38:32 -05:00
endif ( )
2021-10-21 05:12:58 +08:00
unset ( osx_archs_num )
2021-01-28 22:38:32 -05:00
endmacro ( )
2024-01-23 22:27:46 +01:00
# Define variables used in both vcpkg_configure_make and vcpkg_build_make:
# short_name_<CONFIG>: unique abbreviation for the given build type (rel, dbg)
# path_suffix_<CONFIG>: installation path suffix for the given build type ('', /debug)
# current_installed_dir_escaped: CURRENT_INSTALLED_DIR with escaped space characters
# current_installed_dir_msys: CURRENT_INSTALLED_DIR with unprotected spaces, but drive letters transformed for msys
macro ( z_vcpkg_configure_make_common_definitions )
set ( short_name_RELEASE "rel" )
set ( short_name_DEBUG "dbg" )
set ( path_suffix_RELEASE "" )
set ( path_suffix_DEBUG "/debug" )
# Some PATH handling for dealing with spaces....some tools will still fail with that!
# In particular, the libtool install command is unable to install correctly to paths with spaces.
string ( REPLACE " " "\\ " current_installed_dir_escaped "${CURRENT_INSTALLED_DIR}" )
set ( current_installed_dir_msys "${CURRENT_INSTALLED_DIR}" )
if ( CMAKE_HOST_WIN32 )
string ( REGEX REPLACE "^([a-zA-Z]):/" "/\\1/" current_installed_dir_msys "${current_installed_dir_msys}" )
endif ( )
endmacro ( )
# Initializes well-known and auxiliary variables for flags
# - CPPFLAGS_<CONFIG>: preprocessor flags common to C and CXX
# - CFLAGS_<CONFIG>
# - CXXFLAGS_<CONFIG>
# - LDFLAGS_<CONFIG>
# - ARFLAGS_<CONFIG>
# - LINK_ENV_${var_suffix}
# Prerequisite: VCPKG_DETECTED_CMAKE_... vars loaded
function ( z_vcpkg_configure_make_process_flags var_suffix )
# separate_arguments is needed to remove outer quotes from detected cmake variables.
# (e.g. Android NDK has "--sysroot=...")
separate_arguments ( CFLAGS NATIVE_COMMAND "Z_VCM_WRAP ${VCPKG_DETECTED_CMAKE_C_FLAGS_${var_suffix}} Z_VCM_WRAP" )
separate_arguments ( CXXFLAGS NATIVE_COMMAND "Z_VCM_WRAP ${VCPKG_DETECTED_CMAKE_CXX_FLAGS_${var_suffix}} Z_VCM_WRAP" )
separate_arguments ( LDFLAGS NATIVE_COMMAND "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_${var_suffix}}" )
separate_arguments ( ARFLAGS NATIVE_COMMAND "${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${var_suffix}}" )
foreach ( var IN ITEMS CFLAGS CXXFLAGS LDFLAGS ARFLAGS )
vcpkg_list ( APPEND z_vcm_all_flags ${ ${var } } )
endforeach ( )
set ( z_vcm_all_flags "${z_vcm_all_flags}" PARENT_SCOPE )
# Filter common CPPFLAGS out of CFLAGS and CXXFLAGS
vcpkg_list ( SET CPPFLAGS )
vcpkg_list ( SET pattern )
foreach ( arg IN LISTS CXXFLAGS )
if ( arg STREQUAL "Z_VCM_WRAP" )
continue ( )
elseif ( NOT pattern STREQUAL "" )
vcpkg_list ( APPEND pattern "${arg}" )
elseif ( arg MATCHES "^-(D|isystem)." )
vcpkg_list ( SET pattern "${arg}" )
elseif ( arg MATCHES "^-(D|isystem)\$" )
vcpkg_list ( SET pattern "${arg}" )
continue ( )
elseif ( arg MATCHES "^-(-sysroot|-target|m?[Aa][Rr][Cc][Hh])=." )
vcpkg_list ( SET pattern "${arg}" )
elseif ( arg MATCHES "^-(isysroot|m32|m64|m?[Aa][Rr][Cc][Hh]|target)\$" )
vcpkg_list ( SET pattern "${arg}" )
continue ( )
else ( )
continue ( )
endif ( )
string ( FIND "${CFLAGS}" ";${pattern};" index )
if ( NOT index STREQUAL "-1" )
vcpkg_list ( APPEND CPPFLAGS ${ pattern } )
string ( REPLACE ";${pattern};" ";" CFLAGS "${CFLAGS}" )
string ( REPLACE ";${pattern};" ";" CXXFLAGS "${CXXFLAGS}" )
endif ( )
vcpkg_list ( SET pattern )
endforeach ( )
vcpkg_list ( SET pattern )
foreach ( arg IN LISTS CFLAGS )
if ( arg STREQUAL "Z_VCM_WRAP" )
continue ( )
elseif ( NOT pattern STREQUAL "" )
vcpkg_list ( APPEND pattern "${arg}" )
elseif ( arg MATCHES "^-(D|isystem)\$" )
vcpkg_list ( SET pattern "${arg}" )
continue ( )
elseif ( arg MATCHES "^-(D|isystem)." )
vcpkg_list ( SET pattern "${arg}" )
elseif ( arg MATCHES "^-(-sysroot|-target|m?[Aa][Rr][Cc][Hh])=." )
vcpkg_list ( SET pattern "${arg}" )
elseif ( arg MATCHES "^-(isysroot|m32|m64|m?[Aa][Rr][Cc][Hh]|target)\$" )
vcpkg_list ( SET pattern "${arg}" )
continue ( )
else ( )
continue ( )
endif ( )
string ( FIND "${CXXFLAGS}" ";${pattern};" index )
if ( NOT index STREQUAL "-1" )
vcpkg_list ( APPEND CPPFLAGS ${ pattern } )
string ( REPLACE ";${pattern};" ";" CFLAGS "${CFLAGS}" )
string ( REPLACE ";${pattern};" ";" CXXFLAGS "${CXXFLAGS}" )
endif ( )
vcpkg_list ( SET pattern )
endforeach ( )
# Remove start/end placeholders
foreach ( list IN ITEMS CFLAGS CXXFLAGS )
vcpkg_list ( REMOVE_ITEM ${ list } "Z_VCM_WRAP" )
endforeach ( )
2024-06-14 11:35:12 -07:00
# libtool tries to filter CFLAGS passed to the link stage via an allow-list.
2024-01-23 22:27:46 +01:00
# This approach is flawed since it fails to pass flags unknown to libtool
2023-01-07 10:04:32 +01:00
# but required for linking to the link stage (e.g. -fsanitize=<x>).
2024-01-23 22:27:46 +01:00
# libtool has an -R option so we need to guard against -RTC by using -Xcompiler.
# While configuring there might be a lot of unknown compiler option warnings
# due to that; just ignore them.
set ( compiler_flag_escape "" )
2023-01-07 10:04:32 +01:00
if ( VCPKG_DETECTED_CMAKE_C_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC" OR VCPKG_DETECTED_CMAKE_C_COMPILER_ID STREQUAL "MSVC" )
2024-01-23 22:27:46 +01:00
set ( compiler_flag_escape "-Xcompiler " )
endif ( )
if ( compiler_flag_escape )
list ( TRANSFORM CFLAGS PREPEND "${compiler_flag_escape}" )
list ( TRANSFORM CXXFLAGS PREPEND "${compiler_flag_escape}" )
endif ( )
# Could use a future VCPKG_DETECTED_CMAKE_LIBRARY_PATH_FLAG
set ( library_path_flag "-L" )
# Could use a future VCPKG_DETECTED_MSVC
if ( VCPKG_TARGET_IS_WINDOWS AND VCPKG_DETECTED_CMAKE_LINKER MATCHES [[link\.exe $ ]] )
set ( library_path_flag "-LIBPATH:" )
endif ( )
set ( linker_flag_escape "" )
if ( VCPKG_TARGET_IS_WINDOWS AND VCPKG_DETECTED_CMAKE_C_COMPILER MATCHES [[cl\.exe $ ]] )
# Removed by libtool
set ( linker_flag_escape "-Xlinker " )
if ( arg_USE_WRAPPERS )
# 1st and 3rd are removed by libtool, 2nd by wrapper
set ( linker_flag_escape "-Xlinker -Xlinker -Xlinker " )
endif ( )
if ( VCPKG_LIBRARY_LINKAGE STREQUAL "static" )
string ( STRIP "$ENV{_LINK_} ${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${var_suffix}}" LINK_ENV )
else ( )
string ( STRIP "$ENV{_LINK_} ${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_${var_suffix}}" LINK_ENV )
endif ( )
endif ( )
if ( linker_flag_escape )
list ( TRANSFORM LDFLAGS PREPEND "${linker_flag_escape}" )
endif ( )
if ( EXISTS "${CURRENT_INSTALLED_DIR}${path_suffix_${var_suffix}}/lib/manual-link" )
vcpkg_list ( PREPEND LDFLAGS "${linker_flag_escape}${library_path_flag}${current_installed_dir_escaped}${path_suffix_${var_suffix}}/lib/manual-link" )
endif ( )
if ( EXISTS "${CURRENT_INSTALLED_DIR}${path_suffix_${var_suffix}}/lib" )
vcpkg_list ( PREPEND LDFLAGS "${linker_flag_escape}${library_path_flag}${current_installed_dir_escaped}${path_suffix_${var_suffix}}/lib" )
endif ( )
if ( ARFLAGS )
# ARFLAGS need to know the command for creating an archive (Maybe needs user customization?)
# or extract it from CMake via CMAKE_${lang}_ARCHIVE_CREATE ?
# or from CMAKE_${lang}_${rule} with rule being one of CREATE_SHARED_MODULE CREATE_SHARED_LIBRARY LINK_EXECUTABLE
vcpkg_list ( PREPEND ARFLAGS "cr" )
endif ( )
foreach ( var IN ITEMS CPPFLAGS CFLAGS CXXFLAGS LDFLAGS ARFLAGS )
list ( JOIN ${ var } " " string )
set ( ${ var } _ ${ var_suffix } "${string}" PARENT_SCOPE )
endforeach ( )
endfunction ( )
2020-11-10 18:52:02 +01:00
2021-10-21 05:12:58 +08:00
macro ( z_vcpkg_append_to_configure_environment inoutstring var defaultval )
# Allows to overwrite settings in custom triplets via the environment on windows
if ( CMAKE_HOST_WIN32 AND DEFINED ENV{ ${ var } } )
string ( APPEND ${ inoutstring } " ${var}='$ENV{${var}}'" )
2020-11-10 18:52:02 +01:00
else ( )
2021-10-21 05:12:58 +08:00
string ( APPEND ${ inoutstring } " ${var}='${defaultval}'" )
2020-11-10 18:52:02 +01:00
endif ( )
2021-10-21 05:12:58 +08:00
endmacro ( )
2020-11-10 18:52:02 +01:00
function ( vcpkg_configure_make )
2020-12-01 13:37:26 -08:00
# parse parameters such that semicolons in options arguments to COMMAND don't get erased
2021-10-21 05:12:58 +08:00
cmake_parse_arguments ( PARSE_ARGV 0 arg
2022-08-20 00:13:23 +02:00
" A U T O C O N F I G ; S K I P _ C O N F I G U R E ; C O P Y _ S O U R C E ; D I S A B L E _ V E R B O S E _ F L A G S ; N O _ A D D I T I O N A L _ P A T H S ; A D D _ B I N _ T O _ P A T H ; N O _ D E B U G ; U S E _ W R A P P E R S ; N O _ W R A P P E R S ; D E T E R M I N E _ B U I L D _ T R I P L E T "
2020-11-10 18:52:02 +01:00
" S O U R C E _ P A T H ; P R O J E C T _ S U B P A T H ; P R E R U N _ S H E L L ; B U I L D _ T R I P L E T "
2020-11-17 18:18:59 +01:00
" O P T I O N S ; O P T I O N S _ D E B U G ; O P T I O N S _ R E L E A S E ; C O N F I G U R E _ E N V I R O N M E N T _ V A R I A B L E S ; C O N F I G _ D E P E N D E N T _ E N V I R O N M E N T ; A D D I T I O N A L _ M S Y S _ P A C K A G E S "
2020-11-10 18:52:02 +01:00
)
2021-10-21 05:12:58 +08:00
2022-03-03 05:43:19 +08:00
if ( DEFINED arg_UNPARSED_ARGUMENTS )
message ( WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}" )
endif ( )
2022-08-20 00:13:23 +02:00
if ( arg_USE_WRAPPERS AND arg_NO_WRAPPERS )
message ( FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} was passed conflicting options USE_WRAPPERS and NO_WRAPPERS. Please remove one of them!" )
endif ( )
2021-07-29 11:47:35 -05:00
z_vcpkg_get_cmake_vars ( cmake_vars_file )
debug_message ( "Including cmake vars from: ${cmake_vars_file}" )
include ( "${cmake_vars_file}" )
2022-04-28 03:12:48 +02:00
2020-11-10 18:52:02 +01:00
if ( DEFINED VCPKG_MAKE_BUILD_TRIPLET )
2021-10-21 05:12:58 +08:00
set ( arg_BUILD_TRIPLET ${ VCPKG_MAKE_BUILD_TRIPLET } ) # Triplet overwrite for crosscompiling
2020-11-10 18:52:02 +01:00
endif ( )
2021-10-21 05:12:58 +08:00
set ( src_dir "${arg_SOURCE_PATH}/${arg_PROJECT_SUBPATH}" )
2020-11-10 18:52:02 +01:00
2021-10-21 05:12:58 +08:00
set ( requires_autogen OFF ) # use autogen.sh
set ( requires_autoconfig OFF ) # use autotools and configure.ac
2022-08-20 00:13:23 +02:00
if ( EXISTS "${src_dir}/configure" AND EXISTS "${src_dir}/configure.ac" AND arg_AUTOCONFIG ) # remove configure; rerun autoconf
set ( requires_autoconfig ON )
2023-01-07 12:01:31 +03:00
file ( REMOVE "${SRC_DIR}/configure" ) # remove possible outdated configure scripts
2024-01-23 22:27:46 +01:00
elseif ( arg_SKIP_CONFIGURE )
# no action requested
elseif ( EXISTS "${src_dir}/configure" )
# run normally; no autoconf or autogen required
2021-10-21 05:12:58 +08:00
elseif ( EXISTS "${src_dir}/configure.ac" ) # Run autoconfig
set ( requires_autoconfig ON )
set ( arg_AUTOCONFIG ON )
elseif ( EXISTS "${src_dir}/autogen.sh" ) # Run autogen
set ( requires_autogen ON )
2020-11-10 18:52:02 +01:00
else ( )
message ( FATAL_ERROR "Could not determine method to configure make" )
endif ( )
2021-10-21 05:12:58 +08:00
debug_message ( "requires_autogen:${requires_autogen}" )
debug_message ( "requires_autoconfig:${requires_autoconfig}" )
2021-05-27 04:48:41 +08:00
if ( CMAKE_HOST_WIN32 AND VCPKG_DETECTED_CMAKE_C_COMPILER MATCHES "cl.exe" ) #only applies to windows (clang-)cl and lib
2021-10-21 05:12:58 +08:00
if ( arg_AUTOCONFIG )
set ( arg_USE_WRAPPERS ON )
2021-05-27 04:48:41 +08:00
else ( )
# Keep the setting from portfiles.
# Without autotools we assume a custom configure script which correctly handles cl and lib.
# Otherwise the port needs to set CC|CXX|AR and probably CPP.
endif ( )
else ( )
2021-10-21 05:12:58 +08:00
set ( arg_USE_WRAPPERS OFF )
2021-05-27 04:48:41 +08:00
endif ( )
2022-08-20 00:13:23 +02:00
if ( arg_NO_WRAPPERS )
set ( arg_USE_WRAPPERS OFF )
endif ( )
2021-05-27 04:48:41 +08:00
2020-11-10 18:52:02 +01:00
# Backup environment variables
# CCAS CC C CPP CXX FC FF GC LD LF LIBTOOL OBJC OBJCXX R UPC Y
2022-08-20 00:13:23 +02:00
set ( cm_FLAGS AR AS CCAS CC C CPP CXX FC FF GC LD LF LIBTOOL OBJC OBJXX R UPC Y RC )
2021-10-21 05:12:58 +08:00
list ( TRANSFORM cm_FLAGS APPEND "FLAGS" )
vcpkg_backup_env_variables ( VARS ${ cm_FLAGS } )
2020-11-10 18:52:02 +01:00
# FC fotran compiler | FF Fortran 77 compiler
# LDFLAGS -> pass -L flags
# LIBS -> pass -l flags
2024-01-23 22:27:46 +01:00
# Used by gcc/linux
2021-10-21 05:12:58 +08:00
vcpkg_backup_env_variables ( VARS C_INCLUDE_PATH CPLUS_INCLUDE_PATH LIBRARY_PATH LD_LIBRARY_PATH )
2020-11-10 18:52:02 +01:00
2024-01-23 22:27:46 +01:00
# Used by cl
2021-10-21 05:12:58 +08:00
vcpkg_backup_env_variables ( VARS INCLUDE LIB LIBPATH )
2020-11-10 18:52:02 +01:00
2024-01-23 22:27:46 +01:00
vcpkg_list ( SET z_vcm_paths_with_spaces )
if ( CURRENT_PACKAGES_DIR MATCHES " " )
vcpkg_list ( APPEND z_vcm_paths_with_spaces "${CURRENT_PACKAGES_DIR}" )
endif ( )
if ( CURRENT_INSTALLED_DIR MATCHES " " )
vcpkg_list ( APPEND z_vcm_paths_with_spaces "${CURRENT_INSTALLED_DIR}" )
endif ( )
if ( z_vcm_paths_with_spaces )
2020-11-10 18:52:02 +01:00
# Don't bother with whitespace. The tools will probably fail and I tried very hard trying to make it work (no success so far)!
2024-01-23 22:27:46 +01:00
vcpkg_list ( APPEND z_vcm_paths_with_spaces "Please move the path to one without whitespaces!" )
list ( JOIN z_vcm_paths_with_spaces "\n " z_vcm_paths_with_spaces )
message ( STATUS "Warning: Paths with embedded space may be handled incorrectly by configure:\n ${z_vcm_paths_with_spaces}" )
2020-11-10 18:52:02 +01:00
endif ( )
2021-10-21 05:12:58 +08:00
set ( configure_env "V=1" )
2023-02-10 21:02:13 +01:00
2023-03-20 08:04:15 +01:00
# Establish a bash environment as expected by autotools.
if ( CMAKE_HOST_WIN32 )
2023-05-29 08:24:09 +02:00
list ( APPEND msys_require_packages autoconf-wrapper automake-wrapper binutils libtool make pkgconf which )
2023-03-20 08:04:15 +01:00
vcpkg_acquire_msys ( MSYS_ROOT PACKAGES ${ msys_require_packages } ${ arg_ADDITIONAL_MSYS_PACKAGES } )
set ( base_cmd "${MSYS_ROOT}/usr/bin/bash.exe" --noprofile --norc --debug )
vcpkg_list ( SET add_to_env )
if ( arg_USE_WRAPPERS AND VCPKG_TARGET_IS_WINDOWS )
vcpkg_list ( APPEND add_to_env "${SCRIPTS}/buildsystems/make_wrapper" ) # Other required wrappers are also located there
vcpkg_list ( APPEND add_to_env "${MSYS_ROOT}/usr/share/automake-1.16" )
endif ( )
cmake_path ( CONVERT "$ENV{PATH}" TO_CMAKE_PATH_LIST path_list NORMALIZE )
cmake_path ( CONVERT "$ENV{SystemRoot}" TO_CMAKE_PATH_LIST system_root NORMALIZE )
cmake_path ( CONVERT "$ENV{LOCALAPPDATA}" TO_CMAKE_PATH_LIST local_app_data NORMALIZE )
file ( REAL_PATH "${system_root}" system_root )
message ( DEBUG "path_list:${path_list}" ) # Just to have --trace-expand output
vcpkg_list ( SET find_system_dirs
" $ { s y s t e m _ r o o t } / S y s t e m 3 2 "
" $ { s y s t e m _ r o o t } / S y s t e m 3 2 / "
" $ { l o c a l _ a p p _ d a t a } / M i c r o s o f t / W i n d o w s A p p s "
" $ { l o c a l _ a p p _ d a t a } / M i c r o s o f t / W i n d o w s A p p s / "
)
string ( TOUPPER "${find_system_dirs}" find_system_dirs_upper )
set ( index 0 )
set ( appending TRUE )
foreach ( item IN LISTS path_list )
2023-11-03 19:01:20 +01:00
string ( TOUPPER "${item}" item_upper )
if ( item_upper IN_LIST find_system_dirs_upper )
2023-03-20 08:04:15 +01:00
set ( appending FALSE )
break ( )
endif ( )
math ( EXPR index "${index} + 1" )
endforeach ( )
if ( appending )
message ( WARNING "Unable to find system dir in the PATH variable! Appending required msys paths!" )
endif ( )
vcpkg_list ( INSERT path_list "${index}" ${ add_to_env } "${MSYS_ROOT}/usr/bin" )
cmake_path ( CONVERT "${path_list}" TO_NATIVE_PATH_LIST native_path_list )
set ( ENV{PATH} "${native_path_list}" )
else ( )
find_program ( base_cmd bash REQUIRED )
endif ( )
# macOS - cross-compiling support
2023-02-10 21:02:13 +01:00
if ( VCPKG_TARGET_IS_OSX OR VCPKG_TARGET_IS_IOS )
if ( requires_autoconfig AND NOT arg_BUILD_TRIPLET OR arg_DETERMINE_BUILD_TRIPLET )
z_vcpkg_determine_autotools_host_arch_mac ( BUILD_ARCH ) # machine you are building on => --build=
z_vcpkg_determine_autotools_target_arch_mac ( TARGET_ARCH )
# --build: the machine you are building on
# --host: the machine you are building for
# --target: the machine that CC will produce binaries for
# https://stackoverflow.com/questions/21990021/how-to-determine-host-value-for-configure-when-using-cross-compiler
# Only for ports using autotools so we can assume that they follow the common conventions for build/target/host
if ( NOT "${TARGET_ARCH}" STREQUAL "${BUILD_ARCH}" OR NOT VCPKG_TARGET_IS_OSX ) # we don't need to specify the additional flags if we build natively.
set ( arg_BUILD_TRIPLET "--host=${TARGET_ARCH}-apple-darwin" ) # (Host activates crosscompilation; The name given here is just the prefix of the host tools for the target)
endif ( )
debug_message ( "Using make triplet: ${arg_BUILD_TRIPLET}" )
endif ( )
endif ( )
# Linux - cross-compiling support
if ( VCPKG_TARGET_IS_LINUX )
if ( requires_autoconfig AND NOT arg_BUILD_TRIPLET OR arg_DETERMINE_BUILD_TRIPLET )
# The regex below takes the prefix from the resulting CMAKE_C_COMPILER variable eg. arm-linux-gnueabihf-gcc
# set in the common toolchains/linux.cmake
# This is used via --host as a prefix for all other bin tools as well.
# Setting the compiler directly via CC=arm-linux-gnueabihf-gcc does not work acording to:
# https://www.gnu.org/software/autoconf/manual/autoconf-2.65/html_node/Specifying-Target-Triplets.html
if ( VCPKG_DETECTED_CMAKE_C_COMPILER MATCHES "([^\/]*)-gcc$" AND CMAKE_MATCH_1 )
set ( arg_BUILD_TRIPLET "--host=${CMAKE_MATCH_1}" ) # (Host activates crosscompilation; The name given here is just the prefix of the host tools for the target)
endif ( )
debug_message ( "Using make triplet: ${arg_BUILD_TRIPLET}" )
endif ( )
endif ( )
2023-03-20 08:04:15 +01:00
2020-11-10 18:52:02 +01:00
# Pre-processing windows configure requirements
2021-04-30 20:26:05 +02:00
if ( VCPKG_TARGET_IS_WINDOWS )
2021-11-04 05:29:29 +01:00
if ( arg_DETERMINE_BUILD_TRIPLET OR NOT arg_BUILD_TRIPLET )
2021-10-21 05:12:58 +08:00
z_vcpkg_determine_autotools_host_cpu ( BUILD_ARCH ) # VCPKG_HOST => machine you are building on => --build=
z_vcpkg_determine_autotools_target_cpu ( TARGET_ARCH )
2020-11-10 18:52:02 +01:00
# --build: the machine you are building on
# --host: the machine you are building for
# --target: the machine that CC will produce binaries for
# https://stackoverflow.com/questions/21990021/how-to-determine-host-value-for-configure-when-using-cross-compiler
# Only for ports using autotools so we can assume that they follow the common conventions for build/target/host
2021-04-30 20:26:05 +02:00
if ( CMAKE_HOST_WIN32 )
2023-01-07 12:01:31 +03:00
# Respect host triplet when determining --build
if ( NOT VCPKG_CROSSCOMPILING )
set ( _win32_build_arch "${TARGET_ARCH}" )
else ( )
set ( _win32_build_arch "${BUILD_ARCH}" )
endif ( )
# This is required since we are running in a msys
# shell which will be otherwise identified as ${BUILD_ARCH}-pc-msys
set ( arg_BUILD_TRIPLET "--build=${_win32_build_arch}-pc-mingw32" )
2021-04-30 20:26:05 +02:00
endif ( )
if ( NOT TARGET_ARCH MATCHES "${BUILD_ARCH}" OR NOT CMAKE_HOST_WIN32 ) # we don't need to specify the additional flags if we build nativly, this does not hold when we are not on windows
2021-10-21 05:12:58 +08:00
string ( APPEND arg_BUILD_TRIPLET " --host=${TARGET_ARCH}-pc-mingw32" ) # (Host activates crosscompilation; The name given here is just the prefix of the host tools for the target)
2020-11-10 18:52:02 +01:00
endif ( )
2021-10-21 05:12:58 +08:00
if ( VCPKG_TARGET_IS_UWP AND NOT arg_BUILD_TRIPLET MATCHES "--host" )
2020-11-10 18:52:02 +01:00
# Needs to be different from --build to enable cross builds.
2021-10-21 05:12:58 +08:00
string ( APPEND arg_BUILD_TRIPLET " --host=${TARGET_ARCH}-unknown-mingw32" )
2020-11-10 18:52:02 +01:00
endif ( )
2021-10-21 05:12:58 +08:00
debug_message ( "Using make triplet: ${arg_BUILD_TRIPLET}" )
2020-11-10 18:52:02 +01:00
endif ( )
2021-04-08 03:41:56 +08:00
# Remove full filepaths due to spaces and prepend filepaths to PATH (cross-compiling tools are unlikely on path by default)
2020-11-10 18:52:02 +01:00
set ( progs VCPKG_DETECTED_CMAKE_C_COMPILER VCPKG_DETECTED_CMAKE_CXX_COMPILER VCPKG_DETECTED_CMAKE_AR
V C P K G _ D E T E C T E D _ C M A K E _ L I N K E R V C P K G _ D E T E C T E D _ C M A K E _ R A N L I B V C P K G _ D E T E C T E D _ C M A K E _ O B J D U M P
V C P K G _ D E T E C T E D _ C M A K E _ S T R I P V C P K G _ D E T E C T E D _ C M A K E _ N M V C P K G _ D E T E C T E D _ C M A K E _ D L L T O O L V C P K G _ D E T E C T E D _ C M A K E _ R C _ C O M P I L E R )
foreach ( prog IN LISTS progs )
2024-01-23 22:27:46 +01:00
set ( filepath "${${prog}}" )
if ( filepath MATCHES " " )
cmake_path ( GET filepath FILENAME ${ prog } )
find_program ( z_vcm_prog_found NAMES "${${prog}}" PATHS ENV PATH NO_DEFAULT_PATH NO_CACHE )
if ( NOT z_vcm_prog_found STREQUAL filepath )
cmake_path ( GET filepath PARENT_PATH dir )
vcpkg_add_to_path ( PREPEND "${dir}" )
2021-04-08 03:41:56 +08:00
endif ( )
2020-11-10 18:52:02 +01:00
endif ( )
endforeach ( )
2021-10-21 05:12:58 +08:00
if ( arg_USE_WRAPPERS )
z_vcpkg_append_to_configure_environment ( configure_env CPP "compile ${VCPKG_DETECTED_CMAKE_C_COMPILER} -E" )
z_vcpkg_append_to_configure_environment ( configure_env CC "compile ${VCPKG_DETECTED_CMAKE_C_COMPILER}" )
2023-02-10 21:02:13 +01:00
if ( NOT arg_BUILD_TRIPLET MATCHES "--host" )
2022-08-20 00:13:23 +02:00
z_vcpkg_append_to_configure_environment ( configure_env CC_FOR_BUILD "compile ${VCPKG_DETECTED_CMAKE_C_COMPILER}" )
z_vcpkg_append_to_configure_environment ( configure_env CPP_FOR_BUILD "compile ${VCPKG_DETECTED_CMAKE_C_COMPILER} -E" )
z_vcpkg_append_to_configure_environment ( configure_env CXX_FOR_BUILD "compile ${VCPKG_DETECTED_CMAKE_CXX_COMPILER}" )
else ( )
# Silly trick to make configure accept CC_FOR_BUILD but in reallity CC_FOR_BUILD is deactivated.
z_vcpkg_append_to_configure_environment ( configure_env CC_FOR_BUILD "touch a.out | touch conftest${VCPKG_HOST_EXECUTABLE_SUFFIX} | true" )
z_vcpkg_append_to_configure_environment ( configure_env CPP_FOR_BUILD "touch a.out | touch conftest${VCPKG_HOST_EXECUTABLE_SUFFIX} | true" )
z_vcpkg_append_to_configure_environment ( configure_env CXX_FOR_BUILD "touch a.out | touch conftest${VCPKG_HOST_EXECUTABLE_SUFFIX} | true" )
endif ( )
2021-10-21 05:12:58 +08:00
z_vcpkg_append_to_configure_environment ( configure_env CXX "compile ${VCPKG_DETECTED_CMAKE_CXX_COMPILER}" )
z_vcpkg_append_to_configure_environment ( configure_env RC "windres-rc ${VCPKG_DETECTED_CMAKE_RC_COMPILER}" )
z_vcpkg_append_to_configure_environment ( configure_env WINDRES "windres-rc ${VCPKG_DETECTED_CMAKE_RC_COMPILER}" )
2020-11-10 18:52:02 +01:00
if ( VCPKG_DETECTED_CMAKE_AR )
2021-10-21 05:12:58 +08:00
z_vcpkg_append_to_configure_environment ( configure_env AR "ar-lib ${VCPKG_DETECTED_CMAKE_AR}" )
2020-11-10 18:52:02 +01:00
else ( )
2021-10-21 05:12:58 +08:00
z_vcpkg_append_to_configure_environment ( configure_env AR "ar-lib lib.exe -verbose" )
2020-11-10 18:52:02 +01:00
endif ( )
else ( )
2021-10-21 05:12:58 +08:00
z_vcpkg_append_to_configure_environment ( configure_env CPP "${VCPKG_DETECTED_CMAKE_C_COMPILER} -E" )
z_vcpkg_append_to_configure_environment ( configure_env CC "${VCPKG_DETECTED_CMAKE_C_COMPILER}" )
2023-02-10 21:02:13 +01:00
if ( NOT arg_BUILD_TRIPLET MATCHES "--host" )
2022-08-20 00:13:23 +02:00
z_vcpkg_append_to_configure_environment ( configure_env CC_FOR_BUILD "${VCPKG_DETECTED_CMAKE_C_COMPILER}" )
z_vcpkg_append_to_configure_environment ( configure_env CPP_FOR_BUILD "${VCPKG_DETECTED_CMAKE_C_COMPILER} -E" )
z_vcpkg_append_to_configure_environment ( configure_env CXX_FOR_BUILD "${VCPKG_DETECTED_CMAKE_CXX_COMPILER}" )
else ( )
z_vcpkg_append_to_configure_environment ( configure_env CC_FOR_BUILD "touch a.out | touch conftest${VCPKG_HOST_EXECUTABLE_SUFFIX} | true" )
z_vcpkg_append_to_configure_environment ( configure_env CPP_FOR_BUILD "touch a.out | touch conftest${VCPKG_HOST_EXECUTABLE_SUFFIX} | true" )
z_vcpkg_append_to_configure_environment ( configure_env CXX_FOR_BUILD "touch a.out | touch conftest${VCPKG_HOST_EXECUTABLE_SUFFIX} | true" )
endif ( )
2021-10-21 05:12:58 +08:00
z_vcpkg_append_to_configure_environment ( configure_env CXX "${VCPKG_DETECTED_CMAKE_CXX_COMPILER}" )
z_vcpkg_append_to_configure_environment ( configure_env RC "${VCPKG_DETECTED_CMAKE_RC_COMPILER}" )
z_vcpkg_append_to_configure_environment ( configure_env WINDRES "${VCPKG_DETECTED_CMAKE_RC_COMPILER}" )
2020-11-10 18:52:02 +01:00
if ( VCPKG_DETECTED_CMAKE_AR )
2021-10-21 05:12:58 +08:00
z_vcpkg_append_to_configure_environment ( configure_env AR "${VCPKG_DETECTED_CMAKE_AR}" )
2020-11-10 18:52:02 +01:00
else ( )
2021-10-21 05:12:58 +08:00
z_vcpkg_append_to_configure_environment ( configure_env AR "lib.exe -verbose" )
2020-11-10 18:52:02 +01:00
endif ( )
endif ( )
2021-10-21 05:12:58 +08:00
z_vcpkg_append_to_configure_environment ( configure_env LD "${VCPKG_DETECTED_CMAKE_LINKER} -verbose" )
2020-11-10 18:52:02 +01:00
if ( VCPKG_DETECTED_CMAKE_RANLIB )
2021-10-21 05:12:58 +08:00
z_vcpkg_append_to_configure_environment ( configure_env RANLIB "${VCPKG_DETECTED_CMAKE_RANLIB}" ) # Trick to ignore the RANLIB call
2020-11-10 18:52:02 +01:00
else ( )
2021-10-21 05:12:58 +08:00
z_vcpkg_append_to_configure_environment ( configure_env RANLIB ":" )
2020-11-10 18:52:02 +01:00
endif ( )
if ( VCPKG_DETECTED_CMAKE_OBJDUMP ) #Objdump is required to make shared libraries. Otherwise define lt_cv_deplibs_check_method=pass_all
2021-10-21 05:12:58 +08:00
z_vcpkg_append_to_configure_environment ( configure_env OBJDUMP "${VCPKG_DETECTED_CMAKE_OBJDUMP}" ) # Trick to ignore the RANLIB call
2020-11-10 18:52:02 +01:00
endif ( )
if ( VCPKG_DETECTED_CMAKE_STRIP ) # If required set the ENV variable STRIP in the portfile correctly
2021-10-21 05:12:58 +08:00
z_vcpkg_append_to_configure_environment ( configure_env STRIP "${VCPKG_DETECTED_CMAKE_STRIP}" )
2020-11-10 18:52:02 +01:00
else ( )
2021-10-21 05:12:58 +08:00
z_vcpkg_append_to_configure_environment ( configure_env STRIP ":" )
list ( APPEND arg_OPTIONS ac_cv_prog_ac_ct_STRIP=: )
2020-11-10 18:52:02 +01:00
endif ( )
if ( VCPKG_DETECTED_CMAKE_NM ) # If required set the ENV variable NM in the portfile correctly
2021-10-21 05:12:58 +08:00
z_vcpkg_append_to_configure_environment ( configure_env NM "${VCPKG_DETECTED_CMAKE_NM}" )
2020-11-10 18:52:02 +01:00
else ( )
# Would be better to have a true nm here! Some symbols (mainly exported variables) get not properly imported with dumpbin as nm
# and require __declspec(dllimport) for some reason (same problem CMake has with WINDOWS_EXPORT_ALL_SYMBOLS)
2021-10-21 05:12:58 +08:00
z_vcpkg_append_to_configure_environment ( configure_env NM "dumpbin.exe -symbols -headers" )
2020-11-10 18:52:02 +01:00
endif ( )
if ( VCPKG_DETECTED_CMAKE_DLLTOOL ) # If required set the ENV variable DLLTOOL in the portfile correctly
2021-10-21 05:12:58 +08:00
z_vcpkg_append_to_configure_environment ( configure_env DLLTOOL "${VCPKG_DETECTED_CMAKE_DLLTOOL}" )
2020-11-10 18:52:02 +01:00
else ( )
2021-10-21 05:12:58 +08:00
z_vcpkg_append_to_configure_environment ( configure_env DLLTOOL "link.exe -verbose -dll" )
2020-11-10 18:52:02 +01:00
endif ( )
2021-10-21 05:12:58 +08:00
z_vcpkg_append_to_configure_environment ( configure_env CCAS ":" ) # If required set the ENV variable CCAS in the portfile correctly
z_vcpkg_append_to_configure_environment ( configure_env AS ":" ) # If required set the ENV variable AS in the portfile correctly
2020-11-10 18:52:02 +01:00
2021-10-21 05:12:58 +08:00
foreach ( _env IN LISTS arg_CONFIGURE_ENVIRONMENT_VARIABLES )
z_vcpkg_append_to_configure_environment ( configure_env ${ _env } "${${_env}}" )
2020-11-10 18:52:02 +01:00
endforeach ( )
2021-10-21 05:12:58 +08:00
debug_message ( "configure_env: '${configure_env}'" )
2020-11-10 18:52:02 +01:00
# Other maybe interesting variables to control
# COMPILE This is the command used to actually compile a C source file. The file name is appended to form the complete command line.
# LINK This is the command used to actually link a C program.
# CXXCOMPILE The command used to actually compile a C++ source file. The file name is appended to form the complete command line.
# CXXLINK The command used to actually link a C++ program.
# Variables not correctly detected by configure. In release builds.
2021-10-21 05:12:58 +08:00
list ( APPEND arg_OPTIONS gl_cv_double_slash_root=yes
2020-11-10 18:52:02 +01:00
a c _ c v _ f u n c _ m e m m o v e = y e s )
2021-10-21 05:12:58 +08:00
#list(APPEND arg_OPTIONS lt_cv_deplibs_check_method=pass_all) # Just ignore libtool checks
2021-01-19 22:40:30 -05:00
if ( VCPKG_TARGET_ARCHITECTURE MATCHES "^[Aa][Rr][Mm]64$" )
2021-10-21 05:12:58 +08:00
list ( APPEND arg_OPTIONS gl_cv_host_cpu_c_abi=no )
2021-01-19 22:40:30 -05:00
# Currently needed for arm64 because objdump yields: "unrecognised machine type (0xaa64) in Import Library Format archive"
2021-10-21 05:12:58 +08:00
list ( APPEND arg_OPTIONS lt_cv_deplibs_check_method=pass_all )
2021-01-19 22:40:30 -05:00
elseif ( VCPKG_TARGET_ARCHITECTURE MATCHES "^[Aa][Rr][Mm]$" )
# Currently needed for arm because objdump yields: "unrecognised machine type (0x1c4) in Import Library Format archive"
2021-10-21 05:12:58 +08:00
list ( APPEND arg_OPTIONS lt_cv_deplibs_check_method=pass_all )
2020-11-10 18:52:02 +01:00
endif ( )
2022-10-13 18:40:52 +02:00
else ( )
2024-01-23 22:27:46 +01:00
# OSX dosn't like CMAKE_C(XX)_COMPILER (cc) in CC/CXX and rather wants to have gcc/g++
vcpkg_list ( SET z_vcm_all_tools )
2022-08-20 00:13:23 +02:00
function ( z_vcpkg_make_set_env envvar cmakevar )
2024-06-29 02:28:34 +02:00
if ( NOT VCPKG_DETECTED_CMAKE_ ${ cmakevar } )
return ( )
endif ( )
2024-01-23 22:27:46 +01:00
set ( prog "${VCPKG_DETECTED_CMAKE_${cmakevar}}" )
if ( NOT DEFINED ENV{ ${ envvar } } AND NOT prog STREQUAL "" )
vcpkg_list ( APPEND z_vcm_all_tools "${prog}" )
if ( ARGN )
string ( APPEND prog " ${ARGN}" )
endif ( )
set ( z_vcm_all_tools "${z_vcm_all_tools}" PARENT_SCOPE )
2022-08-20 00:13:23 +02:00
set ( ENV{ ${ envvar } } "${prog}" )
endif ( )
endfunction ( )
z_vcpkg_make_set_env ( CC C_COMPILER )
2023-02-10 21:02:13 +01:00
if ( NOT arg_BUILD_TRIPLET MATCHES "--host" )
2022-08-20 00:13:23 +02:00
z_vcpkg_make_set_env ( CC_FOR_BUILD C_COMPILER )
z_vcpkg_make_set_env ( CPP_FOR_BUILD C_COMPILER "-E" )
z_vcpkg_make_set_env ( CXX_FOR_BUILD C_COMPILER )
else ( )
set ( ENV{CC_FOR_BUILD} "touch a.out | touch conftest${VCPKG_HOST_EXECUTABLE_SUFFIX} | true" )
set ( ENV{CPP_FOR_BUILD} "touch a.out | touch conftest${VCPKG_HOST_EXECUTABLE_SUFFIX} | true" )
set ( ENV{CXX_FOR_BUILD} "touch a.out | touch conftest${VCPKG_HOST_EXECUTABLE_SUFFIX} | true" )
endif ( )
z_vcpkg_make_set_env ( CXX CXX_COMPILER )
z_vcpkg_make_set_env ( NM NM )
z_vcpkg_make_set_env ( RC RC )
z_vcpkg_make_set_env ( WINDRES RC )
z_vcpkg_make_set_env ( DLLTOOL DLLTOOL )
z_vcpkg_make_set_env ( STRIP STRIP )
z_vcpkg_make_set_env ( OBJDUMP OBJDUMP )
z_vcpkg_make_set_env ( RANLIB RANLIB )
z_vcpkg_make_set_env ( AR AR )
z_vcpkg_make_set_env ( LD LINKER )
unset ( z_vcpkg_make_set_env )
2021-04-30 20:26:05 +02:00
endif ( )
2024-01-23 22:27:46 +01:00
list ( FILTER z_vcm_all_tools INCLUDE REGEX " " )
if ( z_vcm_all_tools )
list ( REMOVE_DUPLICATES z_vcm_all_tools )
list ( JOIN z_vcm_all_tools "\n " tools )
message ( STATUS "Warning: Tools with embedded space may be handled incorrectly by configure:\n ${tools}" )
2020-11-10 18:52:02 +01:00
endif ( )
2024-01-23 22:27:46 +01:00
z_vcpkg_configure_make_common_definitions ( )
2020-11-10 18:52:02 +01:00
# Cleanup previous build dirs
2024-01-23 22:27:46 +01:00
file ( REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${short_name_RELEASE}"
" $ { C U R R E N T _ B U I L D T R E E S _ D I R } / $ { T A R G E T _ T R I P L E T } - $ { s h o r t _ n a m e _ D E B U G } "
2020-11-10 18:52:02 +01:00
" $ { C U R R E N T _ B U I L D T R E E S _ D I R } / $ { T A R G E T _ T R I P L E T } " )
# Set configure paths
2024-01-23 22:27:46 +01:00
vcpkg_list ( APPEND arg_OPTIONS_RELEASE "--prefix=${current_installed_dir_msys}" )
vcpkg_list ( APPEND arg_OPTIONS_DEBUG "--prefix=${current_installed_dir_msys}${path_suffix_DEBUG}" )
2021-10-21 05:12:58 +08:00
if ( NOT arg_NO_ADDITIONAL_PATHS )
2021-10-01 08:58:36 +02:00
# ${prefix} has an extra backslash to prevent early expansion when calling `bash -c configure "..."`.
2024-01-23 22:27:46 +01:00
vcpkg_list ( APPEND arg_OPTIONS_RELEASE
2020-11-10 18:52:02 +01:00
# Important: These should all be relative to prefix!
2021-10-01 08:58:36 +02:00
" - - b i n d i r = \ \ \ $ { p r e f i x } / t o o l s / $ { P O R T } / b i n "
" - - s b i n d i r = \ \ \ $ { p r e f i x } / t o o l s / $ { P O R T } / s b i n "
" - - l i b d i r = \ \ \ $ { p r e f i x } / l i b " # On some Linux distributions lib64 is the default
2020-11-10 18:52:02 +01:00
#"--includedir='\${prefix}'/include" # already the default!
2021-10-01 08:58:36 +02:00
" - - m a n d i r = \ \ \ $ { p r e f i x } / s h a r e / $ { P O R T } "
" - - d o c d i r = \ \ \ $ { p r e f i x } / s h a r e / $ { P O R T } "
" - - d a t a r o o t d i r = \ \ \ $ { p r e f i x } / s h a r e / $ { P O R T } " )
2024-01-23 22:27:46 +01:00
vcpkg_list ( APPEND arg_OPTIONS_DEBUG
2020-11-10 18:52:02 +01:00
# Important: These should all be relative to prefix!
2024-01-23 22:27:46 +01:00
" - - b i n d i r = \ \ \ $ { p r e f i x } / . . / t o o l s / $ { P O R T } $ { p a t h _ s u f f i x _ D E B U G } / b i n "
" - - s b i n d i r = \ \ \ $ { p r e f i x } / . . / t o o l s / $ { P O R T } $ { p a t h _ s u f f i x _ D E B U G } / s b i n "
2021-10-01 08:58:36 +02:00
" - - l i b d i r = \ \ \ $ { p r e f i x } / l i b " # On some Linux distributions lib64 is the default
" - - i n c l u d e d i r = \ \ \ $ { p r e f i x } / . . / i n c l u d e "
" - - d a t a r o o t d i r = \ \ \ $ { p r e f i x } / s h a r e / $ { P O R T } " )
2020-11-10 18:52:02 +01:00
endif ( )
# Setup common options
2021-10-21 05:12:58 +08:00
if ( NOT arg_DISABLE_VERBOSE_FLAGS )
list ( APPEND arg_OPTIONS --disable-silent-rules --verbose )
2020-11-10 18:52:02 +01:00
endif ( )
if ( VCPKG_LIBRARY_LINKAGE STREQUAL dynamic )
2021-10-21 05:12:58 +08:00
list ( APPEND arg_OPTIONS --enable-shared --disable-static )
2020-11-10 18:52:02 +01:00
else ( )
2021-10-21 05:12:58 +08:00
list ( APPEND arg_OPTIONS --disable-shared --enable-static )
2020-11-10 18:52:02 +01:00
endif ( )
2021-06-08 12:50:09 -04:00
# Can be set in the triplet to append options for configure
2021-10-21 05:12:58 +08:00
if ( DEFINED VCPKG_CONFIGURE_MAKE_OPTIONS )
list ( APPEND arg_OPTIONS ${ VCPKG_CONFIGURE_MAKE_OPTIONS } )
2021-06-08 12:50:09 -04:00
endif ( )
2021-10-21 05:12:58 +08:00
if ( DEFINED VCPKG_CONFIGURE_MAKE_OPTIONS_RELEASE )
list ( APPEND arg_OPTIONS_RELEASE ${ VCPKG_CONFIGURE_MAKE_OPTIONS_RELEASE } )
2021-06-08 12:50:09 -04:00
endif ( )
2021-10-21 05:12:58 +08:00
if ( DEFINED VCPKG_CONFIGURE_MAKE_OPTIONS_DEBUG )
list ( APPEND arg_OPTIONS_DEBUG ${ VCPKG_CONFIGURE_MAKE_OPTIONS_DEBUG } )
2021-06-08 12:50:09 -04:00
endif ( )
2021-10-21 05:12:58 +08:00
file ( RELATIVE_PATH relative_build_path "${CURRENT_BUILDTREES_DIR}" "${arg_SOURCE_PATH}/${arg_PROJECT_SUBPATH}" )
2020-11-10 18:52:02 +01:00
# Used by CL
2022-05-20 23:41:10 +02:00
vcpkg_host_path_list ( PREPEND ENV{INCLUDE} "${CURRENT_INSTALLED_DIR}/include" )
2020-11-10 18:52:02 +01:00
# Used by GCC
2022-05-20 23:41:10 +02:00
vcpkg_host_path_list ( PREPEND ENV{C_INCLUDE_PATH} "${CURRENT_INSTALLED_DIR}/include" )
vcpkg_host_path_list ( PREPEND ENV{CPLUS_INCLUDE_PATH} "${CURRENT_INSTALLED_DIR}/include" )
2020-11-10 18:52:02 +01:00
# Flags should be set in the toolchain instead (Setting this up correctly requires a function named vcpkg_determined_cmake_compiler_flags which can also be used to setup CC and CXX etc.)
if ( VCPKG_TARGET_IS_WINDOWS )
2021-10-21 05:12:58 +08:00
vcpkg_backup_env_variables ( VARS _CL_ _LINK_ )
2020-11-10 18:52:02 +01:00
# TODO: Should be CPP flags instead -> rewrite when vcpkg_determined_cmake_compiler_flags defined
if ( VCPKG_TARGET_IS_UWP )
# Be aware that configure thinks it is crosscompiling due to:
# error while loading shared libraries: VCRUNTIME140D_APP.dll:
# cannot open shared object file: No such file or directory
# IMPORTANT: The only way to pass linker flags through libtool AND the compile wrapper
# is to use the CL and LINK environment variables !!!
# (This is due to libtool and compiler wrapper using the same set of options to pass those variables around)
2022-04-28 03:12:48 +02:00
file ( TO_CMAKE_PATH "$ENV{VCToolsInstallDir}" VCToolsInstallDir )
set ( _replacement -FU\ "${VCToolsInstallDir}/lib/x86/store/references/platform.winmd\" )
string ( REPLACE "${_replacement}" "" VCPKG_DETECTED_CMAKE_CXX_FLAGS_DEBUG "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_DEBUG}" )
string ( REPLACE "${_replacement}" "" VCPKG_DETECTED_CMAKE_C_FLAGS_DEBUG "${VCPKG_DETECTED_CMAKE_C_FLAGS_DEBUG}" )
string ( REPLACE "${_replacement}" "" VCPKG_DETECTED_CMAKE_CXX_FLAGS_RELEASE "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_RELEASE}" )
string ( REPLACE "${_replacement}" "" VCPKG_DETECTED_CMAKE_C_FLAGS_RELEASE "${VCPKG_DETECTED_CMAKE_C_FLAGS_RELEASE}" )
2020-11-10 18:52:02 +01:00
# Can somebody please check if CMake's compiler flags for UWP are correct?
2022-04-28 03:12:48 +02:00
set ( ENV{_CL_} "$ENV{_CL_} -FU\" ${ VCToolsInstallDir } /lib/x86/store/references/platform.winmd\ "" )
set ( ENV{_LINK_} "$ENV{_LINK_} ${VCPKG_DETECTED_CMAKE_C_STANDARD_LIBRARIES} ${VCPKG_DETECTED_CMAKE_CXX_STANDARD_LIBRARIES}" )
2020-11-10 18:52:02 +01:00
endif ( )
endif ( )
2024-01-23 22:27:46 +01:00
# Remove outer quotes from cmake variables which will be forwarded via makefile/shell variables
# substituted into makefile commands (e.g. Android NDK has "--sysroot=...")
separate_arguments ( c_libs_list NATIVE_COMMAND "${VCPKG_DETECTED_CMAKE_C_STANDARD_LIBRARIES}" )
separate_arguments ( cxx_libs_list NATIVE_COMMAND "${VCPKG_DETECTED_CMAKE_CXX_STANDARD_LIBRARIES}" )
list ( REMOVE_ITEM cxx_libs_list ${ c_libs_list } )
set ( all_libs_list ${ cxx_libs_list } ${ c_libs_list } )
2020-11-17 18:18:59 +01:00
#Do lib list transformation from name.lib to -lname if necessary
2021-10-21 05:12:58 +08:00
set ( x_vcpkg_transform_libs ON )
2020-11-17 18:18:59 +01:00
if ( VCPKG_TARGET_IS_UWP )
2021-10-21 05:12:58 +08:00
set ( x_vcpkg_transform_libs OFF )
2020-11-17 18:18:59 +01:00
# Avoid libtool choke: "Warning: linker path does not have real file for library -lWindowsApp."
# The problem with the choke is that libtool always falls back to built a static library even if a dynamic was requested.
# Note: Env LIBPATH;LIB are on the search path for libtool by default on windows.
# It even does unix/dos-short/unix transformation with the path to get rid of spaces.
endif ( )
2021-10-21 05:12:58 +08:00
if ( x_vcpkg_transform_libs )
2024-01-23 22:27:46 +01:00
list ( TRANSFORM all_libs_list REPLACE "[.](dll[.]lib|lib|a|so)$" "" )
2020-11-17 18:18:59 +01:00
if ( VCPKG_TARGET_IS_WINDOWS )
2021-10-21 05:12:58 +08:00
list ( REMOVE_ITEM all_libs_list "uuid" )
2020-11-17 18:18:59 +01:00
endif ( )
2024-01-23 22:27:46 +01:00
list ( TRANSFORM all_libs_list REPLACE "^([^-].*)" "-l\\1" )
if ( VCPKG_TARGET_IS_MINGW AND VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic" )
# libtool must be told explicitly that there is no dynamic linkage for uuid.
# The "-Wl,..." syntax is understood by libtool and gcc, but no by ld.
list ( TRANSFORM all_libs_list REPLACE "^-luuid\$" "-Wl,-Bstatic,-luuid,-Bdynamic" )
endif ( )
2021-05-26 18:13:16 +02:00
endif ( )
2024-01-23 22:27:46 +01:00
if ( all_libs_list )
list ( JOIN all_libs_list " " all_libs_string )
2020-11-10 18:52:02 +01:00
if ( DEFINED ENV{LIBS} )
2021-10-21 05:12:58 +08:00
set ( ENV{LIBS} "$ENV{LIBS} ${all_libs_string}" )
2020-11-10 18:52:02 +01:00
else ( )
2021-10-21 05:12:58 +08:00
set ( ENV{LIBS} "${all_libs_string}" )
2020-11-10 18:52:02 +01:00
endif ( )
endif ( )
2021-06-04 05:56:25 +08:00
debug_message ( "ENV{LIBS}:$ENV{LIBS}" )
2020-11-10 18:52:02 +01:00
# Run autoconf if necessary
2022-08-20 00:13:23 +02:00
if ( arg_AUTOCONFIG OR requires_autoconfig AND NOT arg_NO_AUTOCONFIG )
2020-11-10 18:52:02 +01:00
find_program ( AUTORECONF autoreconf )
if ( NOT AUTORECONF )
message ( FATAL_ERROR "${PORT} requires autoconf from the system package manager (example: \" sudo apt-get install autoconf\ ")" )
endif ( )
message ( STATUS "Generating configure for ${TARGET_TRIPLET}" )
if ( CMAKE_HOST_WIN32 )
vcpkg_execute_required_process (
C O M M A N D $ { b a s e _ c m d } - c " a u t o r e c o n f - v f i "
2021-10-21 05:12:58 +08:00
W O R K I N G _ D I R E C T O R Y " $ { s r c _ d i r } "
L O G N A M E " a u t o c o n f - $ { T A R G E T _ T R I P L E T } "
2020-11-10 18:52:02 +01:00
)
else ( )
vcpkg_execute_required_process (
2021-10-21 05:12:58 +08:00
C O M M A N D " $ { A U T O R E C O N F } " - v f i
W O R K I N G _ D I R E C T O R Y " $ { s r c _ d i r } "
L O G N A M E " a u t o c o n f - $ { T A R G E T _ T R I P L E T } "
2020-11-10 18:52:02 +01:00
)
endif ( )
message ( STATUS "Finished generating configure for ${TARGET_TRIPLET}" )
endif ( )
2021-10-21 05:12:58 +08:00
if ( requires_autogen )
2020-11-10 18:52:02 +01:00
message ( STATUS "Generating configure for ${TARGET_TRIPLET} via autogen.sh" )
if ( CMAKE_HOST_WIN32 )
vcpkg_execute_required_process (
C O M M A N D $ { b a s e _ c m d } - c " . / a u t o g e n . s h "
2021-10-21 05:12:58 +08:00
W O R K I N G _ D I R E C T O R Y " $ { s r c _ d i r } "
L O G N A M E " a u t o c o n f - $ { T A R G E T _ T R I P L E T } "
2020-11-10 18:52:02 +01:00
)
else ( )
vcpkg_execute_required_process (
C O M M A N D " . / a u t o g e n . s h "
2021-10-21 05:12:58 +08:00
W O R K I N G _ D I R E C T O R Y " $ { s r c _ d i r } "
L O G N A M E " a u t o c o n f - $ { T A R G E T _ T R I P L E T } "
2020-11-10 18:52:02 +01:00
)
endif ( )
message ( STATUS "Finished generating configure for ${TARGET_TRIPLET}" )
endif ( )
2021-10-21 05:12:58 +08:00
if ( arg_PRERUN_SHELL )
2020-11-10 18:52:02 +01:00
message ( STATUS "Prerun shell with ${TARGET_TRIPLET}" )
2021-10-21 05:12:58 +08:00
if ( CMAKE_HOST_WIN32 )
vcpkg_execute_required_process (
C O M M A N D $ { b a s e _ c m d } - c " $ { a r g _ P R E R U N _ S H E L L } "
W O R K I N G _ D I R E C T O R Y " $ { s r c _ d i r } "
L O G N A M E " p r e r u n - $ { T A R G E T _ T R I P L E T } "
)
else ( )
vcpkg_execute_required_process (
C O M M A N D " $ { b a s e _ c m d } " - c " $ { a r g _ P R E R U N _ S H E L L } "
W O R K I N G _ D I R E C T O R Y " $ { s r c _ d i r } "
L O G N A M E " p r e r u n - $ { T A R G E T _ T R I P L E T } "
)
endif ( )
endif ( )
2022-08-20 00:13:23 +02:00
if ( NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug" AND NOT arg_NO_DEBUG )
2024-01-23 22:27:46 +01:00
list ( APPEND all_buildtypes DEBUG )
z_vcpkg_configure_make_process_flags ( DEBUG )
2020-11-10 18:52:02 +01:00
endif ( )
if ( NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release" )
2024-01-23 22:27:46 +01:00
list ( APPEND all_buildtypes RELEASE )
z_vcpkg_configure_make_process_flags ( RELEASE )
endif ( )
list ( FILTER z_vcm_all_flags INCLUDE REGEX " " )
if ( z_vcm_all_flags )
list ( REMOVE_DUPLICATES z_vcm_all_flags )
list ( JOIN z_vcm_all_flags "\n " flags )
message ( STATUS "Warning: Arguments with embedded space may be handled incorrectly by configure:\n ${flags}" )
2020-11-10 18:52:02 +01:00
endif ( )
2021-10-21 05:12:58 +08:00
foreach ( var IN ITEMS arg_OPTIONS arg_OPTIONS_RELEASE arg_OPTIONS_DEBUG )
2021-10-01 08:58:36 +02:00
vcpkg_list ( SET tmp )
foreach ( element IN LISTS "${var}" )
string ( REPLACE [[ "]] [[\" ]] element "${element}" )
vcpkg_list ( APPEND tmp "\" ${ element } \"")
endforeach ( )
vcpkg_list ( JOIN tmp " " "${var}" )
endforeach ( )
2021-10-21 05:12:58 +08:00
foreach ( current_buildtype IN LISTS all_buildtypes )
foreach ( ENV_VAR ${ arg_CONFIG_DEPENDENT_ENVIRONMENT } )
2020-11-10 18:52:02 +01:00
if ( DEFINED ENV{ ${ ENV_VAR } } )
2021-10-21 05:12:58 +08:00
set ( backup_config_ ${ ENV_VAR } "$ENV{${ENV_VAR}}" )
2020-11-10 18:52:02 +01:00
endif ( )
2021-10-21 05:12:58 +08:00
set ( ENV{ ${ ENV_VAR } } "${${ENV_VAR}_${current_buildtype}}" )
2020-11-10 18:52:02 +01:00
endforeach ( )
2021-10-21 05:12:58 +08:00
set ( target_dir "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${short_name_${current_buildtype}}" )
file ( MAKE_DIRECTORY "${target_dir}" )
file ( RELATIVE_PATH relative_build_path "${target_dir}" "${src_dir}" )
2020-11-10 18:52:02 +01:00
2021-10-21 05:12:58 +08:00
if ( arg_COPY_SOURCE )
file ( COPY "${src_dir}/" DESTINATION "${target_dir}" )
set ( relative_build_path . )
2020-11-10 18:52:02 +01:00
endif ( )
2024-03-02 01:35:37 +01:00
# Setup PKG_CONFIG_PATH
z_vcpkg_setup_pkgconfig_path ( CONFIG "${current_buildtype}" )
2020-11-10 18:52:02 +01:00
# Setup environment
2021-10-21 05:12:58 +08:00
set ( ENV{CPPFLAGS} "${CPPFLAGS_${current_buildtype}}" )
2022-10-13 18:40:52 +02:00
set ( ENV{CPPFLAGS_FOR_BUILD} "${CPPFLAGS_${current_buildtype}}" )
2021-10-21 05:12:58 +08:00
set ( ENV{CFLAGS} "${CFLAGS_${current_buildtype}}" )
2022-10-13 18:40:52 +02:00
set ( ENV{CFLAGS_FOR_BUILD} "${CFLAGS_${current_buildtype}}" )
2021-10-21 05:12:58 +08:00
set ( ENV{CXXFLAGS} "${CXXFLAGS_${current_buildtype}}" )
2022-10-13 18:40:52 +02:00
#set(ENV{CXXFLAGS_FOR_BUILD} "${CXXFLAGS_${current_buildtype}}") -> doesn't exist officially
2021-10-21 05:12:58 +08:00
set ( ENV{RCFLAGS} "${VCPKG_DETECTED_CMAKE_RC_FLAGS_${current_buildtype}}" )
set ( ENV{LDFLAGS} "${LDFLAGS_${current_buildtype}}" )
2022-10-13 18:40:52 +02:00
set ( ENV{LDFLAGS_FOR_BUILD} "${LDFLAGS_${current_buildtype}}" )
2022-08-20 00:13:23 +02:00
if ( ARFLAGS_ ${ current_buildtype } AND NOT ( arg_USE_WRAPPERS AND VCPKG_TARGET_IS_WINDOWS ) )
# Target windows with wrappers enabled cannot forward ARFLAGS since it breaks the wrapper
set ( ENV{ARFLAGS} "${ARFLAGS_${current_buildtype}}" )
endif ( )
2022-10-13 18:40:52 +02:00
if ( VCPKG_TARGET_IS_OSX OR VCPKG_TARGET_IS_IOS )
# configure not using all flags to check if compiler works ...
set ( ENV{CC} "$ENV{CC} $ENV{CPPFLAGS} $ENV{CFLAGS}" )
set ( ENV{CC_FOR_BUILD} "$ENV{CC_FOR_BUILD} $ENV{CPPFLAGS} $ENV{CFLAGS}" )
2021-07-27 01:53:47 +08:00
endif ( )
2021-10-21 05:12:58 +08:00
if ( LINK_ENV_ ${ current_buildtype } )
set ( link_config_backup "$ENV{_LINK_}" )
set ( ENV{_LINK_} "${LINK_ENV_${current_buildtype}}" )
2023-03-13 23:02:32 +01:00
else ( )
unset ( link_config_backup )
2020-11-10 18:52:02 +01:00
endif ( )
2022-02-16 03:31:16 +01:00
vcpkg_list ( APPEND lib_env_vars LIB LIBPATH LIBRARY_PATH ) # LD_LIBRARY_PATH)
2021-10-21 05:12:58 +08:00
foreach ( lib_env_var IN LISTS lib_env_vars )
if ( EXISTS "${CURRENT_INSTALLED_DIR}${path_suffix_${current_buildtype}}/lib" )
vcpkg_host_path_list ( PREPEND ENV{ ${ lib_env_var } } "${CURRENT_INSTALLED_DIR}${path_suffix_${current_buildtype}}/lib" )
2021-04-02 22:41:17 +02:00
endif ( )
2021-10-21 05:12:58 +08:00
if ( EXISTS "${CURRENT_INSTALLED_DIR}${path_suffix_${current_buildtype}}/lib/manual-link" )
2022-02-16 03:31:16 +01:00
vcpkg_host_path_list ( PREPEND ENV{ ${ lib_env_var } } "${CURRENT_INSTALLED_DIR}${path_suffix_${current_buildtype}}/lib/manual-link" )
2021-04-02 22:41:17 +02:00
endif ( )
endforeach ( )
2021-10-21 05:12:58 +08:00
unset ( lib_env_vars )
2020-11-10 18:52:02 +01:00
2021-10-21 05:12:58 +08:00
set ( command "${base_cmd}" -c "${configure_env} ./${relative_build_path}/configure ${arg_BUILD_TRIPLET} ${arg_OPTIONS} ${arg_OPTIONS_${current_buildtype}}" )
2021-04-30 20:26:05 +02:00
2021-10-21 05:12:58 +08:00
if ( arg_ADD_BIN_TO_PATH )
set ( path_backup $ENV{ PATH } )
vcpkg_add_to_path ( "${CURRENT_INSTALLED_DIR}${path_suffix_${current_buildtype}}/bin" )
2020-11-10 18:52:02 +01:00
endif ( )
debug_message ( "Configure command:'${command}'" )
2021-10-21 05:12:58 +08:00
if ( NOT arg_SKIP_CONFIGURE )
message ( STATUS "Configuring ${TARGET_TRIPLET}-${short_name_${current_buildtype}}" )
2020-11-10 18:52:02 +01:00
vcpkg_execute_required_process (
C O M M A N D $ { c o m m a n d }
2021-10-21 05:12:58 +08:00
W O R K I N G _ D I R E C T O R Y " $ { t a r g e t _ d i r } "
L O G N A M E " c o n f i g - $ { T A R G E T _ T R I P L E T } - $ { s h o r t _ n a m e _ $ { c u r r e n t _ b u i l d t y p e } } "
2022-07-07 23:58:03 +02:00
S A V E _ L O G _ F I L E S c o n f i g . l o g
2020-11-10 18:52:02 +01:00
)
2020-12-02 05:13:58 +07:00
if ( VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW AND VCPKG_LIBRARY_LINKAGE STREQUAL dynamic )
2021-10-21 05:12:58 +08:00
file ( GLOB_RECURSE libtool_files "${target_dir}*/libtool" )
foreach ( lt_file IN LISTS libtool_files )
2020-11-10 18:52:02 +01:00
file ( READ "${lt_file}" _contents )
string ( REPLACE ".dll.lib" ".lib" _contents "${_contents}" )
file ( WRITE "${lt_file}" "${_contents}" )
endforeach ( )
endif ( )
endif ( )
2022-05-10 00:23:32 +00:00
z_vcpkg_restore_pkgconfig_path ( )
2020-11-10 18:52:02 +01:00
2023-03-13 23:02:32 +01:00
if ( DEFINED link_config_backup )
2021-10-21 05:12:58 +08:00
set ( ENV{_LINK_} "${link_config_backup}" )
2020-11-10 18:52:02 +01:00
endif ( )
2021-10-21 05:12:58 +08:00
if ( arg_ADD_BIN_TO_PATH )
set ( ENV{PATH} "${path_backup}" )
2020-11-10 18:52:02 +01:00
endif ( )
# Restore environment (config dependent)
2021-10-21 05:12:58 +08:00
foreach ( ENV_VAR IN LISTS ${ arg_CONFIG_DEPENDENT_ENVIRONMENT } )
if ( backup_config_ ${ ENV_VAR } )
set ( ENV{ ${ ENV_VAR } } "${backup_config_${ENV_VAR}}" )
2020-11-10 18:52:02 +01:00
else ( )
unset ( ENV{ ${ ENV_VAR } } )
endif ( )
endforeach ( )
endforeach ( )
2021-08-07 16:48:44 +02:00
# Export matching make program for vcpkg_build_make (cache variable)
if ( CMAKE_HOST_WIN32 AND MSYS_ROOT )
find_program ( Z_VCPKG_MAKE make PATHS "${MSYS_ROOT}/usr/bin" NO_DEFAULT_PATH REQUIRED )
2024-01-23 22:27:46 +01:00
elseif ( VCPKG_HOST_IS_FREEBSD OR VCPKG_HOST_IS_OPENBSD )
2021-08-07 16:48:44 +02:00
find_program ( Z_VCPKG_MAKE gmake REQUIRED )
else ( )
find_program ( Z_VCPKG_MAKE make REQUIRED )
endif ( )
2020-11-10 18:52:02 +01:00
# Restore environment
2021-10-21 05:12:58 +08:00
vcpkg_restore_env_variables ( VARS ${ cm_FLAGS } LIB LIBPATH LIBRARY_PATH LD_LIBRARY_PATH )
2020-11-10 18:52:02 +01:00
2021-10-21 05:12:58 +08:00
set ( _VCPKG_PROJECT_SOURCE_PATH ${ arg_SOURCE_PATH } PARENT_SCOPE )
set ( _VCPKG_PROJECT_SUBPATH ${ arg_PROJECT_SUBPATH } PARENT_SCOPE )
2022-03-03 05:43:19 +08:00
set ( _VCPKG_MAKE_NO_DEBUG ${ arg_NO_DEBUG } PARENT_SCOPE )
2020-11-10 18:52:02 +01:00
endfunction ( )
