From 27c6c9420277c533cc4333bdd880f9862012cb72 Mon Sep 17 00:00:00 2001 From: Alexander Neumann <30894796+Neumann-A@users.noreply.github.com> Date: Thu, 21 May 2020 19:46:07 +0200 Subject: [vcpkg] Improve make builds (#10402) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * update all 16 configure_make ports * add make wrappers for msvc * improve make builds * fix relativ path errors on linux (and osx?) * revisit all 16 portfiles again * remove trace from install * fix relative build path issues. * bump control of the 16 configure ports * never forget .... real linux is case sensitive .... * Revert "bump control of the 16 configure ports" This reverts commit 40d6d81c01d2709c4acbdbec503b4787c3fd8282. * Revert "Revert "bump control of the 16 configure ports"" This reverts commit 9c9851ddfcd01bfad604ab9c9aed7379238d619a. * bump control again for real ci rebuild * add copy_source * remove message * pass parameters to vcpkg_build_make * fix healpix build. * fix libmagic regression * fix libwandio regression * pfring changes regression fix? (cannot test in wsl) * ws change to retrigger CI * fix libpq regression * fix libudns regression * add share/pkgconfig to PKG_CONFIG_PATH * cleanup of deprecated options * cleanup docs * Revert "bump control again for real ci rebuild" This reverts commit b4bc18edc2376eba6c3aa3dda52bd82286f23616. * shared binaries on linux should stay in lib. Only dlls are mvoed to bin * move pkgconfig check and add message about missing system packages * added autopoint as a build requirement * fix prerun shell working dir. * a few fixes from the x windows pr - add libpath setting - fixed pkgconfig search on windows platforms - fixed autopoint msys package on windows * fix release prefix * minimal cleanup and ws changes to trigger true CI rebuild * fix tcl by upgrading * remove unnecessary rename * fix pfring? can't test in WSL. Linux kernel headers required. * fix lowercase in patch * fix libwandio * remove x264 from fail list * replace wrappers with wrappers from automake * update make ports * remove unnecessary message * refactor vcpkg_configure_make * [tcl] remove stray ? * [farmhash] fix build * [freexl] ws change to retrigger ci build * [x264] add pthread as a dependency * [vcpkg/scripts] add ignore flag correctly * [sdl] fix vcpkg_fixup_pkgconfig call * [farmhash/freexl] delete configure and recreate it. * [libudns] remove trailing ? * [freexl] use empty build target * [freexl] add system library; remove previous change * Update ports/x264/portfile.cmake Co-authored-by: Jack·Boos·Yu <47264268+JackBoosY@users.noreply.github.com> * [libwandio] remove unncessary comment Co-authored-by: dan-shaw <51385773+dan-shaw@users.noreply.github.com> Co-authored-by: Jack·Boos·Yu <47264268+JackBoosY@users.noreply.github.com> --- scripts/ci.baseline.txt | 1 - scripts/cmake/vcpkg_build_make.cmake | 252 ++++++++---- scripts/cmake/vcpkg_configure_make.cmake | 640 ++++++++++++++++++------------ scripts/cmake/vcpkg_fixup_pkgconfig.cmake | 3 +- scripts/cmake/vcpkg_install_make.cmake | 2 +- 5 files changed, 554 insertions(+), 344 deletions(-) (limited to 'scripts') diff --git a/scripts/ci.baseline.txt b/scripts/ci.baseline.txt index 644a7e897..aed1567bc 100644 --- a/scripts/ci.baseline.txt +++ b/scripts/ci.baseline.txt @@ -1955,7 +1955,6 @@ wxwidgets:x64-linux=fail x264:arm64-windows=fail x264:arm-uwp=fail x264:x64-uwp=ignore -x264:x64-linux=fail x264:x64-osx=fail x264:x86-windows=ignore x264:x64-windows=ignore diff --git a/scripts/cmake/vcpkg_build_make.cmake b/scripts/cmake/vcpkg_build_make.cmake index 202ef33f4..5d1b8d636 100644 --- a/scripts/cmake/vcpkg_build_make.cmake +++ b/scripts/cmake/vcpkg_build_make.cmake @@ -4,16 +4,26 @@ ## ## ## Usage: ## ```cmake -## vcpkg_build_make([TARGET ]) +## vcpkg_build_make([BUILD_TARGET ] +## [ADD_BIN_TO_PATH] +## [ENABLE_INSTALL]) +## [LOGFILE_ROOT ]) ## ``` ## -## ### TARGET -## The target passed to the configure/make build command (`./configure/make/make install`). If not specified, no target will +## ### BUILD_TARGET +## The target passed to the make build command (`./make `). If not specified, the 'all' target will ## be passed. ## ## ### ADD_BIN_TO_PATH ## Adds the appropriate Release and Debug `bin\` directories to the path during the build such that executables can run against the in-tree DLLs. ## +## ### ENABLE_INSTALL +## IF the port supports the install target use vcpkg_install_make() instead of vcpkg_build_make() +## +## ### BUILD_TARGET +## The target passed to the make build command (`./make `). If not specified, the 'all' target will +## be passed. +## ## ## Notes: ## This command should be preceeded by a call to [`vcpkg_configure_make()`](vcpkg_configure_make.md). ## You can use the alias [`vcpkg_install_make()`](vcpkg_configure_make.md) function if your CMake script supports the @@ -26,60 +36,93 @@ ## * [freexl](https://github.com/Microsoft/vcpkg/blob/master/ports/freexl/portfile.cmake) ## * [libosip2](https://github.com/Microsoft/vcpkg/blob/master/ports/libosip2/portfile.cmake) function(vcpkg_build_make) - cmake_parse_arguments(_bc "ADD_BIN_TO_PATH;ENABLE_INSTALL" "LOGFILE_ROOT" "" ${ARGN}) + cmake_parse_arguments(_bc "ADD_BIN_TO_PATH;ENABLE_INSTALL" "LOGFILE_ROOT;BUILD_TARGET" "" ${ARGN}) if(NOT _bc_LOGFILE_ROOT) set(_bc_LOGFILE_ROOT "build") endif() - - if (_VCPKG_PROJECT_SUBPATH) - set(_VCPKG_PROJECT_SUBPATH /${_VCPKG_PROJECT_SUBPATH}/) + + if(NOT _bc_BUILD_TARGET) + set(_bc_BUILD_TARGET "all") endif() - + + if(WIN32) + set(_VCPKG_PREFIX ${CURRENT_PACKAGES_DIR}) + set(_VCPKG_INSTALLED ${CURRENT_INSTALLED_DIR}) + else() + string(REPLACE " " "\ " _VCPKG_PREFIX "${CURRENT_PACKAGES_DIR}") + string(REPLACE " " "\ " _VCPKG_INSTALLED "${CURRENT_INSTALLED_DIR}") + endif() + set(MAKE ) set(MAKE_OPTS ) set(INSTALL_OPTS ) - if (_VCPKG_MAKE_GENERATOR STREQUAL "make") - if (CMAKE_HOST_WIN32) - # Compiler requriements - vcpkg_find_acquire_program(YASM) - vcpkg_find_acquire_program(PERL) - vcpkg_acquire_msys(MSYS_ROOT PACKAGES make) - get_filename_component(YASM_EXE_PATH ${YASM} DIRECTORY) - get_filename_component(PERL_EXE_PATH ${PERL} DIRECTORY) - - set(PATH_GLOBAL "$ENV{PATH}") - set(ENV{PATH} "$ENV{PATH};${YASM_EXE_PATH};${MSYS_ROOT}/usr/bin;${PERL_EXE_PATH}") - set(BASH ${MSYS_ROOT}/usr/bin/bash.exe) - # Set make command and install command - set(MAKE ${BASH} --noprofile --norc -c "${_VCPKG_PROJECT_SUBPATH}make") - # Must use absolute path to call make in windows - set(MAKE_OPTS -j ${VCPKG_CONCURRENCY}) - set(INSTALL_OPTS install -j ${VCPKG_CONCURRENCY}) - else() - # Compiler requriements - find_program(MAKE make REQUIRED) - set(MAKE make;) - # Set make command and install command - set(MAKE_OPTS -j;${VCPKG_CONCURRENCY}) - set(INSTALL_OPTS install;-j;${VCPKG_CONCURRENCY}) - endif() - elseif (_VCPKG_MAKE_GENERATOR STREQUAL "nmake") - find_program(NMAKE nmake REQUIRED) - get_filename_component(NMAKE_EXE_PATH ${NMAKE} DIRECTORY) + if (CMAKE_HOST_WIN32) set(PATH_GLOBAL "$ENV{PATH}") - set(ENV{PATH} "$ENV{PATH};${NMAKE_EXE_PATH}") - set(ENV{CL} "$ENV{CL} /MP") - # Set make command and install command - set(MAKE ${NMAKE} /NOLOGO /G /U) - set(MAKE_OPTS -f makefile all) - set(INSTALL_OPTS install) + # These should be moved into the portfile! + # vcpkg_find_acquire_program(YASM) + # get_filename_component(YASM_EXE_PATH ${YASM} DIRECTORY) + # vcpkg_add_to_path("${YASM_EXE_PATH}") + # vcpkg_find_acquire_program(PERL) + # get_filename_component(PERL_EXE_PATH ${PERL} DIRECTORY) + # vcpkg_add_to_path("${PERL_EXE_PATH}") + + vcpkg_add_to_path(PREPEND "${SCRIPTS}/buildsystems/make_wrapper") + vcpkg_acquire_msys(MSYS_ROOT) + find_program(MAKE make REQUIRED) #mingw32-make + set(MAKE_COMMAND "${MAKE}") + set(MAKE_OPTS ${_bc_MAKE_OPTIONS} -j ${VCPKG_CONCURRENCY} --trace -f Makefile ${_bc_BUILD_TARGET}) + + string(REPLACE " " "\\\ " _VCPKG_PACKAGE_PREFIX ${CURRENT_PACKAGES_DIR}) + string(REGEX REPLACE "([a-zA-Z]):/" "/\\1/" _VCPKG_PACKAGE_PREFIX "${_VCPKG_PACKAGE_PREFIX}") + set(INSTALL_OPTS -j ${VCPKG_CONCURRENCY} --trace -f Makefile install DESTDIR=${_VCPKG_PACKAGE_PREFIX}) + #TODO: optimize for install-data (release) and install-exec (release/debug) else() - message(FATAL_ERROR "${_VCPKG_MAKE_GENERATOR} not supported.") + # Compiler requriements + # set(MAKE_BASH) + find_program(MAKE make REQUIRED) + set(MAKE_COMMAND "${MAKE}") + # Set make command and install command + set(MAKE_OPTS ${_bc_MAKE_OPTIONS} V=1 -j ${VCPKG_CONCURRENCY} -f Makefile ${_bc_BUILD_TARGET}) + set(INSTALL_OPTS -j ${VCPKG_CONCURRENCY} install DESTDIR=${CURRENT_PACKAGES_DIR}) endif() - set(ENV{INCLUDE} "${CURRENT_INSTALLED_DIR}/include;$ENV{INCLUDE}") + # Backup enviromnent variables + set(C_FLAGS_BACKUP "$ENV{CFLAGS}") + set(CXX_FLAGS_BACKUP "$ENV{CXXFLAGS}") + set(LD_FLAGS_BACKUP "$ENV{LDFLAGS}") + set(INCLUDE_PATH_BACKUP "$ENV{INCLUDE_PATH}") + set(INCLUDE_BACKUP "$ENV{INCLUDE}") + set(C_INCLUDE_PATH_BACKUP "$ENV{C_INCLUDE_PATH}") + set(CPLUS_INCLUDE_PATH_BACKUP "$ENV{CPLUS_INCLUDE_PATH}") + _vcpkg_backup_env_variable(LD_LIBRARY_PATH) + _vcpkg_backup_env_variable(LIBRARY_PATH) + set(LIBPATH_BACKUP "$ENV{LIBPATH}") + # Setup include enviromnent + set(ENV{INCLUDE} "${_VCPKG_INSTALLED}/include${VCPKG_HOST_PATH_SEPARATOR}${INCLUDE_BACKUP}") + set(ENV{INCLUDE_PATH} "${_VCPKG_INSTALLED}/include${VCPKG_HOST_PATH_SEPARATOR}${INCLUDE_PATH_BACKUP}") + set(ENV{C_INCLUDE_PATH} "${_VCPKG_INSTALLED}/include${VCPKG_HOST_PATH_SEPARATOR}${C_INCLUDE_PATH_BACKUP}") + set(ENV{CPLUS_INCLUDE_PATH} "${_VCPKG_INSTALLED}/include${VCPKG_HOST_PATH_SEPARATOR}${CPLUS_INCLUDE_PATH_BACKUP}") + + # Setup global flags + set(C_FLAGS_GLOBAL "$ENV{CFLAGS} ${VCPKG_C_FLAGS}") + set(CXX_FLAGS_GLOBAL "$ENV{CXXFLAGS} ${VCPKG_CXX_FLAGS}") + set(LD_FLAGS_GLOBAL "$ENV{LDFLAGS} ${VCPKG_LINKER_FLAGS}") + if(NOT VCPKG_TARGET_IS_WINDOWS) + string(APPEND C_FLAGS_GLOBAL " -fPIC") + string(APPEND CXX_FLAGS_GLOBAL " -fPIC") + else() + string(APPEND C_FLAGS_GLOBAL " /D_WIN32_WINNT=0x0601 /DWIN32_LEAN_AND_MEAN /DWIN32 /D_WINDOWS") + string(APPEND CXX_FLAGS_GLOBAL " /D_WIN32_WINNT=0x0601 /DWIN32_LEAN_AND_MEAN /DWIN32 /D_WINDOWS") + string(APPEND LD_FLAGS_GLOBAL " /VERBOSE -no-undefined") + if(VCPKG_TARGET_ARCHITECTURE STREQUAL x64) + string(APPEND LD_FLAGS_GLOBAL " /machine:x64") + elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL x86) + string(APPEND LD_FLAGS_GLOBAL " /machine:x86") + endif() + endif() + foreach(BUILDTYPE "debug" "release") if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL BUILDTYPE) if(BUILDTYPE STREQUAL "debug") @@ -88,6 +131,7 @@ function(vcpkg_build_make) continue() endif() set(SHORT_BUILDTYPE "-dbg") + set(CMAKE_BUILDTYPE "DEBUG") else() # In NO_DEBUG mode, we only use ${TARGET_TRIPLET} directory. if (_VCPKG_NO_DEBUG) @@ -95,51 +139,76 @@ function(vcpkg_build_make) else() set(SHORT_BUILDTYPE "-rel") endif() + set(CMAKE_BUILDTYPE "RELEASE") endif() - if (CMAKE_HOST_WIN32) - # In windows we can remotely call make - set(WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}${SHORT_BUILDTYPE}) - else() - set(WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}${SHORT_BUILDTYPE}${_VCPKG_PROJECT_SUBPATH}) - endif() - + set(WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}${SHORT_BUILDTYPE}") + message(STATUS "Building ${TARGET_TRIPLET}${SHORT_BUILDTYPE}") if(_bc_ADD_BIN_TO_PATH) set(_BACKUP_ENV_PATH "$ENV{PATH}") - if(CMAKE_HOST_WIN32) - set(_PATHSEP ";") + if(BUILDTYPE STREQUAL "debug") + vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/debug/bin") else() - set(_PATHSEP ":") + vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/bin") endif() + endif() + + if (CMAKE_HOST_WIN32) + set(TMP_CFLAGS "${C_FLAGS_GLOBAL} ${VCPKG_C_FLAGS_${CMAKE_BUILDTYPE}}") + string(REGEX REPLACE "[ \t]+/" " -" TMP_CFLAGS "${TMP_CFLAGS}") + set(ENV{CFLAGS} ${TMP_CFLAGS}) + + set(TMP_CXXFLAGS "${CXX_FLAGS_GLOBAL} ${VCPKG_CXX_FLAGS_${CMAKE_BUILDTYPE}}") + string(REGEX REPLACE "[ \t]+/" " -" TMP_CXXFLAGS "${TMP_CXXFLAGS}") + set(ENV{CXXFLAGS} ${TMP_CXXFLAGS}) + + set(TMP_LDFLAGS "${LD_FLAGS_GLOBAL} ${VCPKG_LINKER_FLAGS_${CMAKE_BUILDTYPE}}") + string(REGEX REPLACE "[ \t]+/" " -" TMP_LDFLAGS "${TMP_LDFLAGS}") + set(ENV{LDFLAGS} ${TMP_LDFLAGS}) + + string(REPLACE " " "\ " _VCPKG_INSTALLED_PKGCONF "${CURRENT_INSTALLED_DIR}") + string(REGEX REPLACE "([a-zA-Z]):/" "/\\1/" _VCPKG_INSTALLED_PKGCONF "${_VCPKG_INSTALLED_PKGCONF}") + string(REPLACE "\\" "/" _VCPKG_INSTALLED_PKGCONF "${_VCPKG_INSTALLED_PKGCONF}") + if(BUILDTYPE STREQUAL "debug") + set(ENV{VCPKG_PKG_PREFIX} ${_VCPKG_INSTALLED_PKGCONF}/debug) + else() + set(ENV{VCPKG_PKG_PREFIX} ${_VCPKG_INSTALLED_PKGCONF}) + endif() + + else() + set(ENV{CFLAGS} "${C_FLAGS_GLOBAL} ${VCPKG_C_FLAGS_${CMAKE_BUILDTYPE}}") + set(ENV{CXXFLAGS} "${CXX_FLAGS_GLOBAL} ${VCPKG_CXX_FLAGS_${CMAKE_BUILDTYPE}}") + if(BUILDTYPE STREQUAL "debug") - set(ENV{PATH} "${CURRENT_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/debug/bin${_PATHSEP}$ENV{PATH}") + set(ENV{LDFLAGS} "-L${_VCPKG_INSTALLED}/debug/lib/ -L${_VCPKG_INSTALLED}/debug/lib/manual-link/ ${LD_FLAGS_GLOBAL} ${VCPKG_LINKER_FLAGS_${CMAKE_BUILDTYPE}}") + set(ENV{LIBRARY_PATH} "${_VCPKG_INSTALLED}/debug/lib/${VCPKG_HOST_PATH_SEPARATOR}${_VCPKG_INSTALLED}/debug/lib/manual-link/${LIBRARY_PATH_PATHLIKE_CONCAT}") + set(ENV{LD_LIBRARY_PATH} "${_VCPKG_INSTALLED}/debug/lib/${VCPKG_HOST_PATH_SEPARATOR}${_VCPKG_INSTALLED}/debug/lib/manual-link/${LD_LIBRARY_PATH_PATHLIKE_CONCAT}") else() - set(ENV{PATH} "${CURRENT_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/bin${_PATHSEP}$ENV{PATH}") + set(ENV{LDFLAGS} "-L${_VCPKG_INSTALLED}/lib/ -L${_VCPKG_INSTALLED}/lib/manual-link/ ${LD_FLAGS_GLOBAL} ${VCPKG_LINKER_FLAGS_${CMAKE_BUILDTYPE}}") + set(ENV{LIBRARY_PATH} "${_VCPKG_INSTALLED}/lib/${VCPKG_HOST_PATH_SEPARATOR}${_VCPKG_INSTALLED}/lib/manual-link/${LIBRARY_PATH_PATHLIKE_CONCAT}") + set(ENV{LD_LIBRARY_PATH} "${_VCPKG_INSTALLED}/lib/${VCPKG_HOST_PATH_SEPARATOR}${_VCPKG_INSTALLED}/lib/manual-link/${LD_LIBRARY_PATH_PATHLIKE_CONCAT}") endif() endif() - if (CMAKE_HOST_WIN32) - vcpkg_execute_build_process( - COMMAND "${MAKE} ${MAKE_OPTS}" - WORKING_DIRECTORY ${WORKING_DIRECTORY} - LOGNAME "${_bc_LOGFILE_ROOT}-${TARGET_TRIPLET}${SHORT_BUILDTYPE}" - ) + if(MAKE_BASH) + set(MAKE_CMD_LINE "${MAKE_COMMAND} ${MAKE_OPTS}") else() - vcpkg_execute_build_process( - COMMAND "${MAKE};${MAKE_OPTS}" - WORKING_DIRECTORY ${WORKING_DIRECTORY} + set(MAKE_CMD_LINE ${MAKE_COMMAND} ${MAKE_OPTS}) + endif() + vcpkg_execute_build_process( + COMMAND ${MAKE_BASH} ${MAKE_CMD_LINE} + WORKING_DIRECTORY "${WORKING_DIRECTORY}" LOGNAME "${_bc_LOGFILE_ROOT}-${TARGET_TRIPLET}${SHORT_BUILDTYPE}" ) - endif() - + if(_bc_ADD_BIN_TO_PATH) set(ENV{PATH} "${_BACKUP_ENV_PATH}") endif() endif() endforeach() - + if (_bc_ENABLE_INSTALL) foreach(BUILDTYPE "debug" "release") if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL BUILDTYPE) @@ -159,27 +228,44 @@ function(vcpkg_build_make) endif() message(STATUS "Installing ${TARGET_TRIPLET}${SHORT_BUILDTYPE}") - if (CMAKE_HOST_WIN32) - # In windows we can remotely call make - set(WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}${SHORT_BUILDTYPE}) - vcpkg_execute_build_process( - COMMAND "${MAKE} ${INSTALL_OPTS}" - WORKING_DIRECTORY ${WORKING_DIRECTORY} - LOGNAME "install-${TARGET_TRIPLET}${SHORT_BUILDTYPE}" - ) + + if(MAKE_BASH) + set(MAKE_CMD_LINE "${MAKE_COMMAND} ${INSTALL_OPTS}") else() - set(WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}${SHORT_BUILDTYPE}${_VCPKG_PROJECT_SUBPATH}) - vcpkg_execute_build_process( - COMMAND "${MAKE};${INSTALL_OPTS}" - WORKING_DIRECTORY ${WORKING_DIRECTORY} - LOGNAME "install-${TARGET_TRIPLET}${SHORT_BUILDTYPE}" - ) + set(MAKE_CMD_LINE ${MAKE_COMMAND} ${INSTALL_OPTS}) endif() + + set(WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}${SHORT_BUILDTYPE}") + vcpkg_execute_build_process( + COMMAND ${MAKE_BASH} ${MAKE_CMD_LINE} + WORKING_DIRECTORY "${WORKING_DIRECTORY}" + LOGNAME "install-${TARGET_TRIPLET}${SHORT_BUILDTYPE}" + ) + endif() endforeach() + string(REGEX REPLACE "([a-zA-Z]):/" "/\\1/" _VCPKG_INSTALL_PREFIX "${CURRENT_INSTALLED_DIR}") + file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}_tmp") + file(RENAME "${CURRENT_PACKAGES_DIR}" "${CURRENT_PACKAGES_DIR}_tmp") + file(RENAME "${CURRENT_PACKAGES_DIR}_tmp${_VCPKG_INSTALL_PREFIX}/" "${CURRENT_PACKAGES_DIR}") + file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}_tmp") endif() - + + # Restore enviromnent + set(ENV{CFLAGS} "${C_FLAGS_BACKUP}") + set(ENV{CXXFLAGS} "${CXX_FLAGS_BACKUP}") + set(ENV{LDFLAGS} "${LD_FLAGS_BACKUP}") + + set(ENV{INCLUDE} "${INCLUDE_BACKUP}") + set(ENV{INCLUDE_PATH} "${INCLUDE_PATH_BACKUP}") + set(ENV{C_INCLUDE_PATH} "${C_INCLUDE_PATH_BACKUP}") + set(ENV{CPLUS_INCLUDE_PATH} "${CPLUS_INCLUDE_PATH_BACKUP}") + _vcpkg_restore_env_variable(LIBRARY_PATH) + _vcpkg_restore_env_variable(LD_LIBRARY_PATH) + if (CMAKE_HOST_WIN32) set(ENV{PATH} "${PATH_GLOBAL}") endif() + + endfunction() diff --git a/scripts/cmake/vcpkg_configure_make.cmake b/scripts/cmake/vcpkg_configure_make.cmake index 1a691a945..9f31bebbc 100644 --- a/scripts/cmake/vcpkg_configure_make.cmake +++ b/scripts/cmake/vcpkg_configure_make.cmake @@ -7,9 +7,6 @@ ## vcpkg_configure_make( ## SOURCE_PATH <${SOURCE_PATH}> ## [AUTOCONFIG] -## [DISABLE_AUTO_HOST] -## [DISABLE_AUTO_DST] -## [GENERATOR] ## [NO_DEBUG] ## [SKIP_CONFIGURE] ## [PROJECT_SUBPATH <${PROJ_SUBPATH}>] @@ -28,10 +25,6 @@ ## ### PROJECT_SUBPATH ## Specifies the directory containing the ``configure`/`configure.ac`. ## By convention, this is usually set in the portfile as the variable `SOURCE_PATH`. -## Should use `GENERATOR NMake` first. -## -## ### NO_DEBUG -## This port doesn't support debug mode. ## ## ### SKIP_CONFIGURE ## Skip configure process @@ -39,21 +32,8 @@ ## ### AUTOCONFIG ## Need to use autoconfig to generate configure file. ## -## ### DISABLE_AUTO_HOST -## Don't set host automatically, the default value is `i686`. -## If use this option, you will need to set host manually. -## -## ### DISABLE_AUTO_DST -## Don't set installation path automatically, the default value is `${CURRENT_PACKAGES_DIR}` and `${CURRENT_PACKAGES_DIR}/debug` -## If use this option, you will need to set dst path manually. -## -## ### GENERATOR -## Specifies the precise generator to use. -## NMake: nmake(windows) make(unix) -## MAKE: make(windows) make(unix) -## ## ### PRERUN_SHELL -## Script that needs to be called before configuration +## Script that needs to be called before configuration (do not use for batch files which simply call autoconf or configure) ## ## ### OPTIONS ## Additional options passed to configure during the configuration. @@ -73,300 +53,444 @@ ## * [tcl](https://github.com/Microsoft/vcpkg/blob/master/ports/tcl/portfile.cmake) ## * [freexl](https://github.com/Microsoft/vcpkg/blob/master/ports/freexl/portfile.cmake) ## * [libosip2](https://github.com/Microsoft/vcpkg/blob/master/ports/libosip2/portfile.cmake) +macro(_vcpkg_determine_host) + # --build: the machine you are building on + # --host: the machine you are building for + # --target: the machine that GCC will produce binary for + set(HOST_ARCH $ENV{PROCESSOR_ARCHITECTURE}) + set(MINGW_W w64) + set(MINGW_PACKAGES) + #message(STATUS "${HOST_ARCH}") + if(HOST_ARCH MATCHES "(amd|AMD)64") + set(MSYS_HOST x86_64) + set(HOST_ARCH x64) + set(BITS 64) + #list(APPEND MINGW_PACKAGES mingw-w64-x86_64-cccl) + elseif(HOST_ARCH MATCHES "(x|X)86") + set(MSYS_HOST i686) + set(HOST_ARCH x86) + set(BITS 32) + #list(APPEND MINGW_PACKAGES mingw-w64-i686-cccl) + elseif(HOST_ARCH MATCHES "^(ARM|arm)64$") + set(MSYS_HOST arm) + set(HOST_ARCH arm) + set(BITS 32) + #list(APPEND MINGW_PACKAGES mingw-w64-i686-cccl) + elseif(HOST_ARCH MATCHES "^(ARM|arm)$") + set(MSYS_HOST arm) + set(HOST_ARCH arm) + set(BITS 32) + #list(APPEND MINGW_PACKAGES mingw-w64-i686-cccl) + message(FATAL_ERROR "Unsupported host architecture ${HOST_ARCH} in _vcpkg_get_msys_toolchain!" ) + else() + message(FATAL_ERROR "Unsupported host architecture ${HOST_ARCH} in _vcpkg_get_msys_toolchain!" ) + endif() + set(TARGET_ARCH ${VCPKG_TARGET_ARCHITECTURE}) +endmacro() + +macro(_vcpkg_backup_env_variable envvar) + if(ENV{${envvar}}) + set(${envvar}_BACKUP "$ENV{${envvar}}") + set(${envvar}_PATHLIKE_CONCAT "${VCPKG_HOST_PATH_SEPARATOR}$ENV{${envvar}}") + else() + set(${envvar}_PATHLIKE_CONCAT) + endif() +endmacro() + +macro(_vcpkg_restore_env_variable envvar) + if(${envvar}_BACKUP) + set(ENV{${envvar}} ${${envvar}_BACKUP}) + else() + unset(ENV{${envvar}}) + endif() +endmacro() + + function(vcpkg_configure_make) cmake_parse_arguments(_csc - "AUTOCONFIG;DISABLE_AUTO_HOST;DISABLE_AUTO_DST;NO_DEBUG;SKIP_CONFIGURE" - "SOURCE_PATH;PROJECT_SUBPATH;GENERATOR;PRERUN_SHELL" + "AUTOCONFIG;SKIP_CONFIGURE;COPY_SOURCE" + "SOURCE_PATH;PROJECT_SUBPATH;PRERUN_SHELL" "OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE" ${ARGN} ) - - if(NOT VCPKG_PLATFORM_TOOLSET) - message(FATAL_ERROR "Vcpkg has been updated with VS2017 support; " - "however, vcpkg.exe must be rebuilt by re-running bootstrap-vcpkg.bat\n") - endif() - - if (_csc_OPTIONS_DEBUG STREQUAL _csc_OPTIONS_RELEASE OR NMAKE_OPTION_RELEASE STREQUAL NMAKE_OPTION_DEBUG) - message(FATAL_ERROR "Detected debug configuration is equal to release configuration, please use NO_DEBUG for vcpkg_configure_make") - endif() - # Select compiler - if(_csc_GENERATOR MATCHES "NMake") - message(FATAL_ERROR "Sorry, NMake does not supported currently.") - if (CMAKE_HOST_WIN32) - set(GENERATOR "nmake") - else() - set(GENERATOR "make") - endif() - elseif(NOT _csc_GENERATOR OR _csc_GENERATOR MATCHES "MAKE") - if (CMAKE_HOST_WIN32) - set(GENERATOR "make") - else() - set(GENERATOR "make") - endif() - else() - message(FATAL_ERROR "${_csc_GENERATOR} not supported.") - endif() + # Backup enviromnent variables + set(C_FLAGS_BACKUP "$ENV{CFLAGS}") + set(CXX_FLAGS_BACKUP "$ENV{CXXFLAGS}") + set(LD_FLAGS_BACKUP "$ENV{LDFLAGS}") + set(INCLUDE_PATH_BACKUP "$ENV{INCLUDE_PATH}") + set(INCLUDE_BACKUP "$ENV{INCLUDE}") + set(C_INCLUDE_PATH_BACKUP "$ENV{C_INCLUDE_PATH}") + set(CPLUS_INCLUDE_PATH_BACKUP "$ENV{CPLUS_INCLUDE_PATH}") + #set(LD_LIBRARY_PATH_BACKUP "$ENV{LD_LIBRARY_PATH}") + _vcpkg_backup_env_variable(LD_LIBRARY_PATH) + #set(LIBRARY_PATH_BACKUP "$ENV{LIBRARY_PATH}") + _vcpkg_backup_env_variable(LIBRARY_PATH) + set(LIBPATH_BACKUP "$ENV{LIBPATH}") - set(WIN_TARGET_ARCH ) - set(WIN_TARGET_COMPILER ) - # Detect compiler - if (GENERATOR STREQUAL "nmake") - message(STATUS "Using generator NMAKE") - find_program(NMAKE nmake REQUIRED) - elseif (GENERATOR STREQUAL "make") - message(STATUS "Using generator make") - find_program(MAKE make REQUIRED) - else() - message(FATAL_ERROR "${GENERATOR} not supported.") + if(${CURRENT_PACKAGES_DIR} MATCHES " " OR ${CURRENT_INSTALLED_DIR} MATCHES " ") + # Don't bother with whitespace. The tools will probably fail and I tried very hard trying to make it work (no success so far)! + message(WARNING "Detected whitespace in root directory. Please move the path to one without whitespaces! The required tools do not handle whitespaces correctly and the build will most likely fail") endif() + # Pre-processing windows configure requirements if (CMAKE_HOST_WIN32) - vcpkg_find_acquire_program(YASM) - vcpkg_find_acquire_program(PERL) - set(MSYS_REQUIRE_PACKAGES diffutils) + # YASM and PERL are not strictly required by all ports. + # So this should probably be moved into the portfile + # vcpkg_find_acquire_program(YASM) + # get_filename_component(YASM_EXE_PATH ${YASM} DIRECTORY) + # vcpkg_add_to_path("${YASM_EXE_PATH}") + + # vcpkg_find_acquire_program(PERL) + # get_filename_component(PERL_EXE_PATH ${PERL} DIRECTORY) + # vcpkg_add_to_path("${PERL_EXE_PATH}") + + list(APPEND MSYS_REQUIRE_PACKAGES diffutils + pkg-config + binutils + libtool + gettext + gettext-devel + make) if (_csc_AUTOCONFIG) - set(MSYS_REQUIRE_PACKAGES ${MSYS_REQUIRE_PACKAGES} autoconf automake m4 libtool perl) + list(APPEND MSYS_REQUIRE_PACKAGES autoconf + autoconf-archive + automake + m4 + ) endif() vcpkg_acquire_msys(MSYS_ROOT PACKAGES ${MSYS_REQUIRE_PACKAGES}) - get_filename_component(YASM_EXE_PATH ${YASM} DIRECTORY) - get_filename_component(PERL_EXE_PATH ${PERL} DIRECTORY) + vcpkg_add_to_path("${MSYS_ROOT}/usr/bin") + set(BASH "${MSYS_ROOT}/usr/bin/bash.exe") + + # This is required because PATH contains sort and find from Windows but the MSYS versions are needed + # ${MSYS_ROOT}/urs/bin cannot be prepended to PATH due to other conflicts + file(CREATE_LINK "${MSYS_ROOT}/usr/bin/sort.exe" "${SCRIPTS}/buildsystems/make_wrapper/sort.exe" COPY_ON_ERROR) + file(CREATE_LINK "${MSYS_ROOT}/usr/bin/find.exe" "${SCRIPTS}/buildsystems/make_wrapper/find.exe" COPY_ON_ERROR) + vcpkg_add_to_path(PREPEND "${SCRIPTS}/buildsystems/make_wrapper") # Other required wrappers are also located there + + # --build: the machine you are building on + # --host: the machine you are building for + # --target: the machine that CC will produce binaries for + _vcpkg_determine_host() # VCPKG_HOST => machine you are building on => --build= + if(VCPKG_TARGET_ARCHITECTURE STREQUAL x86) + set(BUILD_TARGET "--build=${MSYS_HOST}-pc-mingw32 --target=i686-pc-mingw32 --host=i686-pc-mingw32") + elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL x64) + set(BUILD_TARGET "--build=${MSYS_HOST}-pc-mingw32 --target=x86_64-pc-mingw32 --host=x86_64-pc-mingw32") + elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL arm) + set(BUILD_TARGET "--build=${MSYS_HOST}-pc-mingw32 --target=arm-pc-mingw32 --host=i686-pc-mingw32") + endif() - if (NOT _csc_DISABLE_AUTO_HOST) - if(VCPKG_TARGET_ARCHITECTURE STREQUAL x86) - set(WIN_TARGET_ARCH --host=i686-pc-mingw32) - elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL x64) - set(WIN_TARGET_ARCH --host=i686-pc-mingw64) - elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL arm) - set(WIN_TARGET_ARCH --host=arm-pc-mingw32) + macro(_vcpkg_append_to_configure_enviromnent inoutstring var defaultval) + # Allows to overwrite settings in custom triplets via the enviromnent + if(ENV{${var}}) + string(APPEND ${inoutstring} " ${var}='$ENV{${var}}'") + else() + string(APPEND ${inoutstring} " ${var}='${defaultval}'") endif() - endif() - set(WIN_TARGET_COMPILER CC=cl) - set(ENV{PATH} "$ENV{PATH};${YASM_EXE_PATH};${MSYS_ROOT}/usr/bin;${PERL_EXE_PATH}") - set(BASH ${MSYS_ROOT}/usr/bin/bash.exe) - elseif (_csc_AUTOCONFIG) - find_program(autoreconf autoreconf REQUIRED) - endif() + endmacro() + + set(CONFIGURE_ENV "") + _vcpkg_append_to_configure_enviromnent(CONFIGURE_ENV CC "${MSYS_ROOT}/usr/share/automake-1.16/compile cl.exe -nologo") + _vcpkg_append_to_configure_enviromnent(CONFIGURE_ENV CXX "${MSYS_ROOT}/usr/share/automake-1.16/compile cl.exe -nologo") + _vcpkg_append_to_configure_enviromnent(CONFIGURE_ENV LD "link.exe -verbose") + _vcpkg_append_to_configure_enviromnent(CONFIGURE_ENV AR "${MSYS_ROOT}/usr/share/automake-1.16/ar-lib lib.exe -verbose") + _vcpkg_append_to_configure_enviromnent(CONFIGURE_ENV RANLIB ":") # Trick to ignore the RANLIB call + _vcpkg_append_to_configure_enviromnent(CONFIGURE_ENV CCAS ":") # If required set the ENV variable CCAS in the portfile correctly + _vcpkg_append_to_configure_enviromnent(CONFIGURE_ENV NM "dumpbin.exe -symbols -headers -all") + # 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) + _vcpkg_append_to_configure_enviromnent(CONFIGURE_ENV DLLTOOL "link.exe -verbose -dll") + + # 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. - if (NOT _csc_NO_DEBUG) - file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel" "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg") + #Some PATH handling for dealing with spaces....some tools will still fail with that! + string(REPLACE " " "\\\ " _VCPKG_PREFIX ${CURRENT_INSTALLED_DIR}) + string(REGEX REPLACE "([a-zA-Z]):/" "/\\1/" _VCPKG_PREFIX "${_VCPKG_PREFIX}") + set(_VCPKG_INSTALLED ${CURRENT_INSTALLED_DIR}) + string(REPLACE " " "\ " _VCPKG_INSTALLED_PKGCONF ${CURRENT_INSTALLED_DIR}) + string(REGEX REPLACE "([a-zA-Z]):/" "/\\1/" _VCPKG_INSTALLED_PKGCONF ${_VCPKG_INSTALLED_PKGCONF}) + string(REPLACE "\\" "/" _VCPKG_INSTALLED_PKGCONF ${_VCPKG_INSTALLED_PKGCONF}) + set(prefix_var "'\${prefix}'") # Windows needs extra quotes or else the variable gets expanded in the makefile! else() - file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}") + string(REPLACE " " "\ " _VCPKG_PREFIX ${CURRENT_INSTALLED_DIR}) + string(REPLACE " " "\ " _VCPKG_INSTALLED ${CURRENT_INSTALLED_DIR}) + set(_VCPKG_INSTALLED_PKGCONF ${CURRENT_INSTALLED_DIR}) + set(EXTRA_QUOTES) + set(prefix_var "\${prefix}") endif() - if (NOT _csc_DISABLE_AUTO_DST) - set(_csc_OPTIONS_RELEASE ${_csc_OPTIONS_RELEASE} - --prefix=${CURRENT_PACKAGES_DIR} - --bindir=${CURRENT_PACKAGES_DIR}/bin - --sbindir=${CURRENT_PACKAGES_DIR}/bin - --libdir=${CURRENT_PACKAGES_DIR}/lib - --includedir=${CURRENT_PACKAGES_DIR}/include) + # Cleanup previous build dirs + file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel" + "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg" + "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}") + + set(ENV{V} "1") #Enabel Verbose MODE + + # Set configure paths + set(_csc_OPTIONS_RELEASE ${_csc_OPTIONS_RELEASE} + "--prefix=${EXTRA_QUOTES}${_VCPKG_PREFIX}${EXTRA_QUOTES}" + # Important: These should all be relative to prefix! + "--bindir=${prefix_var}/tools/${PORT}/bin" + "--sbindir=${prefix_var}/tools/${PORT}/sbin" + #"--libdir='\${prefix}'/lib" # already the default! + #"--includedir='\${prefix}'/include" # already the default! + "--mandir=${prefix_var}/share/${PORT}" + "--docdir=${prefix_var}/share/${PORT}" + "--datarootdir=${prefix_var}/share/${PORT}") + set(_csc_OPTIONS_DEBUG ${_csc_OPTIONS_DEBUG} + "--prefix=${EXTRA_QUOTES}${_VCPKG_PREFIX}/debug${EXTRA_QUOTES}" + # Important: These should all be relative to prefix! + "--bindir=${prefix_var}/../tools/${PORT}/debug/bin" + "--sbindir=${prefix_var}/../tools/${PORT}/debug/sbin" + #"--libdir='\${prefix}'/lib" # already the default! + "--includedir=${prefix_var}/../include" + "--datarootdir=${prefix_var}/share/${PORT}") - set(_csc_OPTIONS_DEBUG ${_csc_OPTIONS_DEBUG} - --prefix=${CURRENT_PACKAGES_DIR}/debug - --bindir=${CURRENT_PACKAGES_DIR}/debug/bin - --sbindir=${CURRENT_PACKAGES_DIR}/debug/bin - --libdir=${CURRENT_PACKAGES_DIR}/debug/lib - --includedir=${CURRENT_PACKAGES_DIR}/debug/include) + # Setup common options + if(VCPKG_LIBRARY_LINKAGE STREQUAL dynamic) + list(APPEND _csc_OPTIONS --disable-silent-rules --verbose --enable-shared --disable-static) + if (VCPKG_TARGET_IS_UWP) + list(APPEND _csc_OPTIONS --extra-ldflags=-APPCONTAINER --extra-ldflags=WindowsApp.lib) + endif() + else() + list(APPEND _csc_OPTIONS --disable-silent-rules --verbose --enable-static --disable-shared) endif() - set(base_cmd ) + file(RELATIVE_PATH RELATIVE_BUILD_PATH "${CURRENT_BUILDTREES_DIR}" "${_csc_SOURCE_PATH}/${_csc_PROJECT_SUBPATH}") + + set(base_cmd) if(CMAKE_HOST_WIN32) - set(base_cmd ${BASH} --noprofile --norc -c) - - if(VCPKG_LIBRARY_LINKAGE STREQUAL dynamic) - set(_csc_OPTIONS ${_csc_OPTIONS} --enable-shared) - if (VCPKG_TARGET_IS_UWP) - set(_csc_OPTIONS ${_csc_OPTIONS} --extra-ldflags=-APPCONTAINER --extra-ldflags=WindowsApp.lib) - endif() - else() - set(_csc_OPTIONS ${_csc_OPTIONS} --enable-static) - endif() + set(base_cmd ${BASH} --noprofile --norc --debug) # Load toolchains if(NOT VCPKG_CHAINLOAD_TOOLCHAIN_FILE) set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/windows.cmake") endif() include("${VCPKG_CHAINLOAD_TOOLCHAIN_FILE}") - - set(C_FLAGS_GLOBAL "$ENV{CFLAGS} ${VCPKG_C_FLAGS}") - set(CXX_FLAGS_GLOBAL "$ENV{CXXFLAGS} ${VCPKG_CXX_FLAGS}") - set(LD_FLAGS_GLOBAL "$ENV{LDFLAGS}") - if(VCPKG_TARGET_IS_UWP) + # Flags should be set in the toolchain instead set(ENV{LIBPATH} "$ENV{LIBPATH};$ENV{_WKITS10}references\\windows.foundation.foundationcontract\\2.0.0.0\\;$ENV{_WKITS10}references\\windows.foundation.universalapicontract\\3.0.0.0\\") set(_csc_OPTIONS ${_csc_OPTIONS} --extra-cflags=-DWINAPI_FAMILY=WINAPI_FAMILY_APP --extra-cflags=-D_WIN32_WINNT=0x0A00) endif() - + #Join the options list as a string with spaces between options list(JOIN _csc_OPTIONS " " _csc_OPTIONS) list(JOIN _csc_OPTIONS_RELEASE " " _csc_OPTIONS_RELEASE) list(JOIN _csc_OPTIONS_DEBUG " " _csc_OPTIONS_DEBUG) - - set(rel_command - ${base_cmd} "${WIN_TARGET_COMPILER} ${_csc_SOURCE_PATH}/configure ${WIN_TARGET_ARCH} ${_csc_OPTIONS} ${_csc_OPTIONS_RELEASE}" - ) - set(dbg_command - ${base_cmd} "${WIN_TARGET_COMPILER} ${_csc_SOURCE_PATH}/configure ${WIN_TARGET_ARCH} ${_csc_OPTIONS} ${_csc_OPTIONS_DEBUG}" - ) - else() - set(base_cmd ./) - set(rel_command - ${base_cmd}configure "${_csc_OPTIONS}" "${_csc_OPTIONS_RELEASE}" - ) - set(dbg_command - ${base_cmd}configure "${_csc_OPTIONS}" "${_csc_OPTIONS_DEBUG}" - ) endif() - # Configure debug - if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug" AND NOT _csc_NO_DEBUG) - if (CMAKE_HOST_WIN32) - unset(ENV{CFLAGS}) - unset(ENV{CXXFLAGS}) - unset(ENV{LDFLAGS}) - set(TMP_CFLAGS "${C_FLAGS_GLOBAL} ${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_DEBUG}") - string(REPLACE "/" "-" TMP_CFLAGS "${TMP_CFLAGS}") - set(ENV{CFLAGS} ${TMP_CFLAGS}) - set(TMP_CXXFLAGS "${CXX_FLAGS_GLOBAL} ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG}") - string(REPLACE "/" "-" TMP_CXXFLAGS "${TMP_CXXFLAGS}") - set(ENV{CXXFLAGS} ${TMP_CXXFLAGS}) - set(TMP_LDFLAGS "${LD_FLAGS_GLOBAL}") - string(REPLACE "/" "-" TMP_LDFLAGS "${TMP_LDFLAGS}") - set(ENV{LDFLAGS} ${TMP_LDFLAGS}) + # Setup include enviromnent + set(ENV{INCLUDE} "${_VCPKG_INSTALLED}/include${VCPKG_HOST_PATH_SEPARATOR}${INCLUDE_BACKUP}") + set(ENV{INCLUDE_PATH} "${_VCPKG_INSTALLED}/include${VCPKG_HOST_PATH_SEPARATOR}${INCLUDE_PATH_BACKUP}") + set(ENV{C_INCLUDE_PATH} "${_VCPKG_INSTALLED}/include${VCPKG_HOST_PATH_SEPARATOR}${C_INCLUDE_PATH_BACKUP}") + set(ENV{CPLUS_INCLUDE_PATH} "${_VCPKG_INSTALLED}/include${VCPKG_HOST_PATH_SEPARATOR}${CPLUS_INCLUDE_PATH_BACKUP}") + + # Setup global flags -> TODO: Further improve with toolchain file in mind! + set(C_FLAGS_GLOBAL "$ENV{CFLAGS} ${VCPKG_C_FLAGS}") + set(CXX_FLAGS_GLOBAL "$ENV{CXXFLAGS} ${VCPKG_CXX_FLAGS}") + set(LD_FLAGS_GLOBAL "$ENV{LDFLAGS} ${VCPKG_LINKER_FLAGS}") + # Flags should be set in the toolchain instead + if(NOT VCPKG_TARGET_IS_WINDOWS) + string(APPEND C_FLAGS_GLOBAL " -fPIC") + string(APPEND CXX_FLAGS_GLOBAL " -fPIC") + else() + string(APPEND C_FLAGS_GLOBAL " /D_WIN32_WINNT=0x0601 /DWIN32_LEAN_AND_MEAN /DWIN32 /D_WINDOWS") + string(APPEND CXX_FLAGS_GLOBAL " /D_WIN32_WINNT=0x0601 /DWIN32_LEAN_AND_MEAN /DWIN32 /D_WINDOWS") + string(APPEND LD_FLAGS_GLOBAL " /VERBOSE -no-undefined") + if(VCPKG_TARGET_ARCHITECTURE STREQUAL x64) + string(APPEND LD_FLAGS_GLOBAL " /machine:x64") + elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL x86) + string(APPEND LD_FLAGS_GLOBAL " /machine:x86") endif() - - set(OBJ_DIR ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg) - set(PRJ_DIR ${OBJ_DIR}/${_csc_PROJECT_SUBPATH}) - - file(MAKE_DIRECTORY ${OBJ_DIR}) - - if (NOT CMAKE_HOST_WIN32) - file(GLOB_RECURSE SOURCE_FILES ${_csc_SOURCE_PATH}/*) - foreach(ONE_SOUCRCE_FILE ${SOURCE_FILES}) - get_filename_component(DST_DIR ${ONE_SOUCRCE_FILE} PATH) - string(REPLACE "${_csc_SOURCE_PATH}" "${OBJ_DIR}" DST_DIR "${DST_DIR}") - file(COPY ${ONE_SOUCRCE_FILE} DESTINATION ${DST_DIR}) - endforeach() + endif() + + if(NOT ENV{PKG_CONFIG}) + find_program(PKGCONFIG pkg-config PATHS "${MSYS_ROOT}/usr/bin" REQUIRED) + debug_message("Using pkg-config from: ${PKGCONFIG}") + if(NOT PKGCONFIG) + message(STATUS "${PORT} requires pkg-config from the system package manager (example: \"sudo apt-get install pkg-config\")") endif() + else() + debug_message("ENV{PKG_CONFIG} found! Using: $ENV{PKG_CONFIG}") + set(PKGCONFIG $ENV{PKG_CONFIG}) + endif() + + set(SRC_DIR "${_csc_SOURCE_PATH}/${_csc_PROJECT_SUBPATH}") - if (_csc_PRERUN_SHELL) - message(STATUS "Prerun shell with ${TARGET_TRIPLET}-dbg") + # Run autoconf if necessary + if(EXISTS "${SRC_DIR}/configure" AND NOT _csc_SKIP_CONFIGURE) + set(REQUIRES_AUTOCONFIG FALSE) # use autotools and configure.ac + set(REQUIRES_AUTOGEN FALSE) # use autogen.sh + elseif(EXISTS "${SRC_DIR}/configure.ac") + set(REQUIRES_AUTOCONFIG TRUE) + set(REQUIRES_AUTOGEN FALSE) + elseif(EXISTS "${SRC_DIR}/autogen.sh") + set(REQUIRES_AUTOGEN TRUE) + set(REQUIRES_AUTOCONFIG FALSE) + endif() + set(_GENERATED_CONFIGURE FALSE) + if (_csc_AUTOCONFIG OR REQUIRES_AUTOCONFIG) + find_program(AUTORECONF autoreconf REQUIRED) + if(NOT AUTORECONF) + message(STATUS "${PORT} requires autoconf from the system package manager (example: \"sudo apt-get install autoconf\")") + endif() + find_program(LIBTOOL libtool REQUIRED) + if(NOT LIBTOOL) + message(STATUS "${PORT} requires libtool from the system package manager (example: \"sudo apt-get install libtool libtool-bin\")") + endif() + find_program(AUTOPOINT autopoint REQUIRED) + if(NOT AUTOPOINT) + message(STATUS "${PORT} requires autopoint from the system package manager (example: \"sudo apt-get install autopoint\")") + endif() + message(STATUS "Generating configure for ${TARGET_TRIPLET}") + if (CMAKE_HOST_WIN32) vcpkg_execute_required_process( - COMMAND ${base_cmd}${_csc_PRERUN_SHELL} - WORKING_DIRECTORY ${PRJ_DIR} - LOGNAME prerun-${TARGET_TRIPLET}-dbg + COMMAND ${base_cmd} -c "autoreconf -vfi" + WORKING_DIRECTORY "${SRC_DIR}" + LOGNAME autoconf-${TARGET_TRIPLET} + ) + else() + vcpkg_execute_required_process( + COMMAND autoreconf -vfi + WORKING_DIRECTORY "${SRC_DIR}" + LOGNAME autoconf-${TARGET_TRIPLET} ) endif() - - if (_csc_AUTOCONFIG) - message(STATUS "Generating configure with ${TARGET_TRIPLET}-dbg") - if (CMAKE_HOST_WIN32) - vcpkg_execute_required_process( - COMMAND ${base_cmd} autoreconf -vfi - WORKING_DIRECTORY ${_csc_SOURCE_PATH}/${_csc_PROJECT_SUBPATH} - LOGNAME prerun-${TAR_TRIPLET_DIR} - ) - else() - vcpkg_execute_required_process( - COMMAND autoreconf -vfi - WORKING_DIRECTORY ${PRJ_DIR} - LOGNAME prerun-${TAR_TRIPLET_DIR} - ) - endif() - endif() - - if (NOT _csc_SKIP_CONFIGURE) - message(STATUS "Configuring ${TARGET_TRIPLET}-dbg") + message(STATUS "Finished generating configure for ${TARGET_TRIPLET}") + endif() + if(REQUIRES_AUTOGEN) + message(STATUS "Generating configure for ${TARGET_TRIPLET} via autogen.sh") + if (CMAKE_HOST_WIN32) + vcpkg_execute_required_process( + COMMAND ${base_cmd} -c "./autogen.sh" + WORKING_DIRECTORY "${SRC_DIR}" + LOGNAME autoconf-${TARGET_TRIPLET} + ) + else() vcpkg_execute_required_process( - COMMAND ${dbg_command} - WORKING_DIRECTORY ${PRJ_DIR} - LOGNAME config-${TARGET_TRIPLET}-dbg + COMMAND "./autogen.sh" + WORKING_DIRECTORY "${SRC_DIR}" + LOGNAME autoconf-${TARGET_TRIPLET} ) endif() + message(STATUS "Finished generating configure for ${TARGET_TRIPLET}") endif() - # Configure release - if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release") - if (CMAKE_HOST_WIN32) - unset(ENV{CFLAGS}) - unset(ENV{CXXFLAGS}) - unset(ENV{LDFLAGS}) - set(TMP_CFLAGS "${C_FLAGS_GLOBAL} ${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_RELEASE}") - string(REPLACE "/" "-" TMP_CFLAGS "${TMP_CFLAGS}") - set(ENV{CFLAGS} ${TMP_CFLAGS}) - - set(TMP_CXXFLAGS "${CXX_FLAGS_GLOBAL} ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE}") - string(REPLACE "/" "-" TMP_CXXFLAGS "${TMP_CXXFLAGS}") - set(ENV{CXXFLAGS} ${TMP_CXXFLAGS}) - - set(TMP_LDFLAGS "${LD_FLAGS_GLOBAL} ${CMAKE_SHARED_LINKER_FLAGS_RELEASE}") - string(REPLACE "/" "-" TMP_LDFLAGS "${TMP_LDFLAGS}") - set(ENV{LDFLAGS} ${TMP_LDFLAGS}) + if (_csc_PRERUN_SHELL) + message(STATUS "Prerun shell with ${TARGET_TRIPLET}") + vcpkg_execute_required_process( + COMMAND ${base_cmd} -c "${_csc_PRERUN_SHELL}" + WORKING_DIRECTORY "${SRC_DIR}" + LOGNAME prerun-${TARGET_TRIPLET} + ) + endif() + + if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug" AND NOT _csc_NO_DEBUG) + set(_VAR_SUFFIX DEBUG) + set(PATH_SUFFIX_${_VAR_SUFFIX} "/debug") + set(SHORT_NAME_${_VAR_SUFFIX} "dbg") + list(APPEND _buildtypes ${_VAR_SUFFIX}) + if (CMAKE_HOST_WIN32) # Flags should be set in the toolchain instead + string(REGEX REPLACE "[ \t]+/" " -" CFLAGS_${_VAR_SUFFIX} "${C_FLAGS_GLOBAL} ${VCPKG_CRT_LINK_FLAG_PREFIX}d /D_DEBUG /Ob0 /Od ${VCPKG_C_FLAGS_${_VAR_SUFFIX}}") + string(REGEX REPLACE "[ \t]+/" " -" CXXFLAGS_${_VAR_SUFFIX} "${CXX_FLAGS_GLOBAL} ${VCPKG_CRT_LINK_FLAG_PREFIX}d /D_DEBUG /Ob0 /Od ${VCPKG_CXX_FLAGS_${_VAR_SUFFIX}}") + string(REGEX REPLACE "[ \t]+/" " -" LDFLAGS_${_VAR_SUFFIX} "-L${_VCPKG_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib ${LD_FLAGS_GLOBAL} ${VCPKG_LINKER_FLAGS_${_VAR_SUFFIX}}") + else() + set(CFLAGS_${_VAR_SUFFIX} "${C_FLAGS_GLOBAL} ${VCPKG_C_FLAGS_DEBUG}") + set(CXXFLAGS_${_VAR_SUFFIX} "${CXX_FLAGS_GLOBAL} ${VCPKG_CXX_FLAGS_DEBUG}") + set(LDFLAGS_${_VAR_SUFFIX} "-L${_VCPKG_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib/ -L${_VCPKG_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib/manual-link/ ${LD_FLAGS_GLOBAL} ${VCPKG_LINKER_FLAGS_${_VAR_SUFFIX}}") endif() - - if (_csc_NO_DEBUG) - set(TAR_TRIPLET_DIR ${TARGET_TRIPLET}) - set(OBJ_DIR ${CURRENT_BUILDTREES_DIR}/${TAR_TRIPLET_DIR}) + unset(_VAR_SUFFIX) + endif() + if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release") + set(_VAR_SUFFIX RELEASE) + set(PATH_SUFFIX_${_VAR_SUFFIX} "") + set(SHORT_NAME_${_VAR_SUFFIX} "rel") + list(APPEND _buildtypes ${_VAR_SUFFIX}) + if (CMAKE_HOST_WIN32) # Flags should be set in the toolchain instead + string(REGEX REPLACE "[ \t]+/" " -" CFLAGS_${_VAR_SUFFIX} "${C_FLAGS_GLOBAL} ${VCPKG_CRT_LINK_FLAG_PREFIX} /O2 /Oi /Gy /DNDEBUG ${VCPKG_C_FLAGS_${_VAR_SUFFIX}}") + string(REGEX REPLACE "[ \t]+/" " -" CXXFLAGS_${_VAR_SUFFIX} "${CXX_FLAGS_GLOBAL} ${VCPKG_CRT_LINK_FLAG_PREFIX} /O2 /Oi /Gy /DNDEBUG ${VCPKG_CXX_FLAGS_${_VAR_SUFFIX}}") + string(REGEX REPLACE "[ \t]+/" " -" LDFLAGS_${_VAR_SUFFIX} "-L${_VCPKG_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib ${LD_FLAGS_GLOBAL} ${VCPKG_LINKER_FLAGS_${_VAR_SUFFIX}}") else() - set(TAR_TRIPLET_DIR ${TARGET_TRIPLET}-rel) - set(OBJ_DIR ${CURRENT_BUILDTREES_DIR}/${TAR_TRIPLET_DIR}) + set(CFLAGS_${_VAR_SUFFIX} "${C_FLAGS_GLOBAL} ${VCPKG_C_FLAGS_DEBUG}") + set(CXXFLAGS_${_VAR_SUFFIX} "${CXX_FLAGS_GLOBAL} ${VCPKG_CXX_FLAGS_DEBUG}") + set(LDFLAGS_${_VAR_SUFFIX} "-L${_VCPKG_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib/ -L${_VCPKG_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib/manual-link/ ${LD_FLAGS_GLOBAL} ${VCPKG_LINKER_FLAGS_${_VAR_SUFFIX}}") endif() - set(PRJ_DIR ${OBJ_DIR}/${_csc_PROJECT_SUBPATH}) - - file(MAKE_DIRECTORY ${OBJ_DIR}) - - if (NOT CMAKE_HOST_WIN32) - file(GLOB_RECURSE SOURCE_FILES ${_csc_SOURCE_PATH}/*) - foreach(ONE_SOUCRCE_FILE ${SOURCE_FILES}) - get_filename_component(DST_DIR ${ONE_SOUCRCE_FILE} PATH) - string(REPLACE "${_csc_SOURCE_PATH}" "${OBJ_DIR}" DST_DIR "${DST_DIR}") - file(COPY ${ONE_SOUCRCE_FILE} DESTINATION ${DST_DIR}) - endforeach() + unset(_VAR_SUFFIX) + endif() + + foreach(_buildtype IN LISTS _buildtypes) + set(TAR_DIR "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SHORT_NAME_${_buildtype}}") + file(MAKE_DIRECTORY "${TAR_DIR}") + file(RELATIVE_PATH RELATIVE_BUILD_PATH "${TAR_DIR}" "${SRC_DIR}") + + if(_csc_COPY_SOURCE) + file(COPY "${SRC_DIR}/" DESTINATION "${TAR_DIR}") + set(RELATIVE_BUILD_PATH .) endif() - - if (_csc_PRERUN_SHELL) - message(STATUS "Prerun shell with ${TAR_TRIPLET_DIR}") - vcpkg_execute_required_process( - COMMAND ${base_cmd}${_csc_PRERUN_SHELL} - WORKING_DIRECTORY ${PRJ_DIR} - LOGNAME prerun-${TAR_TRIPLET_DIR} - ) + + set(PKGCONFIG_INSTALLED_DIR "${_VCPKG_INSTALLED_PKGCONF}${PATH_SUFFIX_${_buildtype}}/lib/pkgconfig") + set(PKGCONFIG_INSTALLED_SHARE_DIR "${_VCPKG_INSTALLED_PKGCONF}/share/pkgconfig") + + if(ENV{PKG_CONFIG_PATH}) + set(BACKUP_ENV_PKG_CONFIG_PATH_${_buildtype} $ENV{PKG_CONFIG_PATH}) + set(ENV{PKG_CONFIG_PATH} "${PKGCONFIG_INSTALLED_DIR}:${PKGCONFIG_INSTALLED_SHARE_DIR}:$ENV{PKG_CONFIG_PATH}") + else() + set(ENV{PKG_CONFIG_PATH} "${PKGCONFIG_INSTALLED_DIR}:${PKGCONFIG_INSTALLED_SHARE_DIR}") endif() - - if (_csc_AUTOCONFIG) - message(STATUS "Generating configure with ${TAR_TRIPLET_DIR}") - if (CMAKE_HOST_WIN32) - vcpkg_execute_required_process( - COMMAND ${base_cmd} autoreconf -vfi - WORKING_DIRECTORY ${_csc_SOURCE_PATH}/${_csc_PROJECT_SUBPATH} - LOGNAME prerun-${TAR_TRIPLET_DIR} - ) - else() - vcpkg_execute_required_process( - COMMAND autoreconf -vfi - WORKING_DIRECTORY ${PRJ_DIR} - LOGNAME prerun-${TAR_TRIPLET_DIR} - ) - endif() + + # Setup enviromnent + set(ENV{CFLAGS} ${CFLAGS_${_buildtype}}) + set(ENV{CXXFLAGS} ${CXXFLAGS_${_buildtype}}) + set(ENV{LDFLAGS} ${LDFLAGS_${_buildtype}}) + set(ENV{PKG_CONFIG} "${PKGCONFIG} --define-variable=prefix=${_VCPKG_INSTALLED}${PATH_SUFFIX_${_buildtype}}") + set(ENV{LIBPATH} "${_VCPKG_INSTALLED}${PATH_SUFFIX_${_buildtype}}/lib${VCPKG_HOST_PATH_SEPARATOR}${LIBPATH_BACKUP}") + + set(ENV{LIBRARY_PATH} "${_VCPKG_INSTALLED}${PATH_SUFFIX_${_buildtype}}/lib/${VCPKG_HOST_PATH_SEPARATOR}${_VCPKG_INSTALLED}${PATH_SUFFIX_${_buildtype}}/lib/manual-link/${LD_LIBRARY_PATH_PATHLIKE_CONCAT}") + set(ENV{LD_LIBRARY_PATH} "${_VCPKG_INSTALLED}${PATH_SUFFIX_${_buildtype}}/lib/${VCPKG_HOST_PATH_SEPARATOR}${_VCPKG_INSTALLED}${PATH_SUFFIX_${_buildtype}}/lib/manual-link/${LD_LIBRARY_PATH_PATHLIKE_CONCAT}") + + if (CMAKE_HOST_WIN32) + set(command ${base_cmd} -c "${CONFIGURE_ENV} ./${RELATIVE_BUILD_PATH}/configure ${BUILD_TARGET} ${HOST_TYPE}${_csc_OPTIONS} ${_csc_OPTIONS_${_buildtype}}") + else() + set(command /bin/bash "./${RELATIVE_BUILD_PATH}/configure" ${_csc_OPTIONS} ${_csc_OPTIONS_${_buildtype}}) endif() - + if (NOT _csc_SKIP_CONFIGURE) - message(STATUS "Configuring ${TAR_TRIPLET_DIR}") + message(STATUS "Configuring ${TARGET_TRIPLET}-${SHORT_NAME_${_buildtype}}") vcpkg_execute_required_process( - COMMAND ${rel_command} - WORKING_DIRECTORY ${PRJ_DIR} - LOGNAME config-${TAR_TRIPLET_DIR} + COMMAND ${command} + WORKING_DIRECTORY "${TAR_DIR}" + LOGNAME config-${TARGET_TRIPLET}-${SHORT_NAME_${_buildtype}} ) + if(EXISTS "${TAR_DIR}/libtool" AND VCPKG_TARGET_IS_WINDOWS AND VCPKG_LIBRARY_LINKAGE STREQUAL dynamic) + set(_file "${TAR_DIR}/libtool") + file(READ "${_file}" _contents) + string(REPLACE ".dll.lib" ".lib" _contents "${_contents}") + file(WRITE "${_file}" "${_contents}") + endif() endif() - endif() - - # Restore envs - if (CMAKE_HOST_WIN32) - set(ENV{CFLAGS} "${C_FLAGS_GLOBAL}") - set(ENV{CXXFLAGS} "${CXX_FLAGS_GLOBAL}") - set(ENV{LDFLAGS} "${LD_FLAGS_GLOBAL}") - endif() - - set(_VCPKG_MAKE_GENERATOR "${GENERATOR}" PARENT_SCOPE) - set(_VCPKG_NO_DEBUG ${_csc_NO_DEBUG} PARENT_SCOPE) + + if(BACKUP_ENV_PKG_CONFIG_PATH_${_buildtype}) + set(ENV{PKG_CONFIG_PATH} "${BACKUP_ENV_PKG_CONFIG_PATH_${_buildtype}}") + else() + unset(ENV{PKG_CONFIG_PATH}) + endif() + unset(BACKUP_ENV_PKG_CONFIG_PATH_${_buildtype}) + endforeach() + + # Restore enviromnent + set(ENV{CFLAGS} "${C_FLAGS_BACKUP}") + set(ENV{CXXFLAGS} "${CXX_FLAGS_BACKUP}") + set(ENV{LDFLAGS} "${LD_FLAGS_BACKUP}") + + set(ENV{INCLUDE} "${INCLUDE_BACKUP}") + set(ENV{INCLUDE_PATH} "${INCLUDE_PATH_BACKUP}") + set(ENV{C_INCLUDE_PATH} "${C_INCLUDE_PATH_BACKUP}") + set(ENV{CPLUS_INCLUDE_PATH} "${CPLUS_INCLUDE_PATH_BACKUP}") + _vcpkg_restore_env_variable(LIBRARY_PATH) + _vcpkg_restore_env_variable(LD_LIBRARY_PATH) + set(ENV{LIBPATH} "${LIBPATH_BACKUP}") SET(_VCPKG_PROJECT_SOURCE_PATH ${_csc_SOURCE_PATH} PARENT_SCOPE) set(_VCPKG_PROJECT_SUBPATH ${_csc_PROJECT_SUBPATH} PARENT_SCOPE) endfunction() diff --git a/scripts/cmake/vcpkg_fixup_pkgconfig.cmake b/scripts/cmake/vcpkg_fixup_pkgconfig.cmake index c5ba57a20..1256bef4a 100644 --- a/scripts/cmake/vcpkg_fixup_pkgconfig.cmake +++ b/scripts/cmake/vcpkg_fixup_pkgconfig.cmake @@ -144,6 +144,8 @@ function(vcpkg_fixup_pkgconfig_check_libraries _config _contents_var _system_lib # endif() # get_filename_component(PTHREAD_LIB "${PTHREAD_LIB}" NAME_WE) # string(REPLACE "Libs: -pthread" "Libs: -L\${libdir} -l${PTHREAD_LIB}" _contents ${_contents}) + elseif(_lib STREQUAL _ignore_flags) + message(STATUS "${_lib} found in *.pc file and ignored!") else() message(FATAL_ERROR "Found ${_lib} and no rule to analyse the flag! Please check the *.pc file") endif() @@ -240,7 +242,6 @@ function(vcpkg_fixup_pkgconfig) message(STATUS "Checking file: ${_file}") get_filename_component(PKG_LIB_SEARCH_PATH "${_file}" DIRECTORY) file(RELATIVE_PATH RELATIVE_PC_PATH "${PKG_LIB_SEARCH_PATH}" "${CURRENT_PACKAGES_DIR}/debug/") - message(STATUS "REL PATH: ${RELATIVE_PC_PATH}") string(REGEX REPLACE "/$" "" RELATIVE_PC_PATH "${RELATIVE_PC_PATH}") string(REGEX REPLACE "/pkgconfig/?" "" PKG_LIB_SEARCH_PATH "${PKG_LIB_SEARCH_PATH}") file(READ "${_file}" _contents) diff --git a/scripts/cmake/vcpkg_install_make.cmake b/scripts/cmake/vcpkg_install_make.cmake index 1672d7c5a..424689468 100644 --- a/scripts/cmake/vcpkg_install_make.cmake +++ b/scripts/cmake/vcpkg_install_make.cmake @@ -21,5 +21,5 @@ ## * [libosip2](https://github.com/Microsoft/vcpkg/blob/master/ports/libosip2/portfile.cmake) function(vcpkg_install_make) - vcpkg_build_make(LOGFILE_ROOT ENABLE_INSTALL) + vcpkg_build_make(${ARGN} LOGFILE_ROOT ENABLE_INSTALL) endfunction() -- cgit v1.2.3