3party/vcpkg
0
0
Fork 0
mirror of https://github.com/microsoft/vcpkg.git synced 2025-01-14 12:48:01 +08:00
Code Issues Projects Releases Wiki Activity

[boost-modular-build-helper] Pass flags more correctly into b2 (#23001)

Browse Source 
* [vcpkg-cmake][boost-modular-build-helper] Rework vcpkg_cmake_get_vars to produce fully cooked flags

* [ffmpeg] Fix arm-uwp builds

* [ffmpeg] Fix arm-uwp builds

* [ffmpeg] Fix arm64-windows

* [ffmpeg] Fix arm64-windows

* [ffmpeg] Update version after merge

* [boost-modular-build-helper] Add <linkflags> to requirements

* Address PR comments

Co-authored-by: PhoebeHui <20694052+PhoebeHui@users.noreply.github.com>
Co-authored-by: Victor Romero <viromer@microsoft.com>
This commit is contained in:
Robert Schumacher 2022-03-30 14:52:25 -07:00 committed by GitHub
parent 3048b9ab12
commit 54951282f3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
18 changed files with 312 additions and 282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
docs/maintainers/ports/vcpkg-cmake/vcpkg_cmake_get_vars.md
View File

@ -13,6 +13,16 @@ vcpkg_cmake_get_vars(<out-var>)
a path to a generated CMake file, with the detected `CMAKE_*` variables
re-exported as `VCPKG_DETECTED_CMAKE_*`.
Additionally sets, for `RELEASE` and `DEBUG`:
- VCPKG_COMBINED_CXX_FLAGS_<config>
- VCPKG_COMBINED_C_FLAGS_<config>
- VCPKG_COMBINED_SHARED_LINKER_FLAGS_<config>
- VCPKG_COMBINED_STATIC_LINKER_FLAGS_<config>
- VCPKG_COMBINED_EXE_LINKER_FLAGS_<config>
Most users should use these pre-combined flags instead of attempting
to read the `VCPKG_DETECTED_*` flags directly.
## Notes
Avoid usage in portfiles.

214
ports/boost-modular-build-helper/CMakeLists.txt
View File

@ -1,15 +1,18 @@
cmake_minimum_required(VERSION 3.9)
project(boost CXX)
project(boost NONE)
# The following variables are used in user-config.jam file
set(USER_CONFIG_TOOLSET)
set(USER_CONFIG_TOOLSET_VERSION)
set(USER_CONFIG_TOOLSET_INVOCATION_COMMAND)
set(USER_CONFIG_TOOLSET_OPTIONS)
set(USER_CONFIG_EXTRA_LINES)
set(USER_CONFIG_TOOLSET "")
set(USER_CONFIG_TOOLSET_VERSION "")
set(USER_CONFIG_TOOLSET_INVOCATION_COMMAND "")
set(USER_CONFIG_TOOLSET_OPTIONS "")
set(USER_CONFIG_EXTRA_LINES "")
set(USER_CONFIG_REQUIREMENTS "")
set(B2_OPTIONS)
include("${VCPKG_CMAKE_VARS_FILE}")
# Add build type specific options
if(VCPKG_CRT_LINKAGE STREQUAL "dynamic")
list(APPEND B2_OPTIONS runtime-link=shared)
@ -23,13 +26,13 @@ else()
list(APPEND B2_OPTIONS link=static)
endif()
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
if(VCPKG_DETECTED_CMAKE_SIZEOF_VOID_P EQUAL "8")
list(APPEND B2_OPTIONS address-model=64)
else()
list(APPEND B2_OPTIONS address-model=32)
endif()
if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "s390x")
if(VCPKG_TARGET_ARCHITECTURE STREQUAL "s390x")
list(APPEND B2_OPTIONS architecture=s390x)
elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm" OR VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64")
list(APPEND B2_OPTIONS architecture=arm)
@ -43,178 +46,103 @@ if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86" AND WIN32)
list(APPEND B2_OPTIONS "asmflags=/safeseh")
endif()
if(WIN32)
if(MSVC)
if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
set(USER_CONFIG_TOOLSET clang-win)
else()
set(USER_CONFIG_TOOLSET msvc)
endif()
if(MSVC_VERSION LESS 1900)
math(EXPR USER_CONFIG_TOOLSET_VERSION "${MSVC_VERSION} / 10 - 60")
else()
math(EXPR USER_CONFIG_TOOLSET_VERSION "${MSVC_VERSION} / 10 - 50")
endif()
if(VCPKG_DETECTED_MSVC)
if(VCPKG_DETECTED_CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
set(USER_CONFIG_TOOLSET clang-win)
else()
if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
set(USER_CONFIG_TOOLSET clang)
else()
set(USER_CONFIG_TOOLSET gcc)
endif()
set(USER_CONFIG_TOOLSET msvc)
endif()
if(VCPKG_DETECTED_MSVC_VERSION LESS "1900")
math(EXPR USER_CONFIG_TOOLSET_VERSION "${VCPKG_DETECTED_MSVC_VERSION} / 10 - 60")
else()
math(EXPR USER_CONFIG_TOOLSET_VERSION "${VCPKG_DETECTED_MSVC_VERSION} / 10 - 50")
endif()
elseif(VCPKG_DETECTED_CMAKE_CXX_COMPILER_ID MATCHES "Clang")
set(USER_CONFIG_TOOLSET clang)
else()
set(USER_CONFIG_TOOLSET gcc)
endif()
if(WIN32)
list(APPEND B2_OPTIONS target-os=windows)
elseif(APPLE)
if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
set(USER_CONFIG_TOOLSET clang)
else()
set(USER_CONFIG_TOOLSET gcc)
endif()
list(APPEND B2_OPTIONS target-os=darwin)
elseif(ANDROID)
set(USER_CONFIG_TOOLSET gcc)
list(APPEND B2_OPTIONS target-os=android)
else()
if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
set(USER_CONFIG_TOOLSET clang)
else()
set(USER_CONFIG_TOOLSET gcc)
endif()
list(APPEND B2_OPTIONS target-os=linux)
endif()
# Properly handle compiler and linker flags passed by VCPKG
if(CMAKE_BUILD_TYPE STREQUAL "Release")
set(CXXFLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE}")
set(CFLAGS "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_RELEASE}")
if(BUILD_SHARED_LIBS)
set(LDFLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS_RELEASE}")
else()
set(LDFLAGS "${CMAKE_STATIC_LINKER_FLAGS} ${CMAKE_STATIC_LINKER_FLAGS_RELEASE}")
endif()
elseif(CMAKE_BUILD_TYPE STREQUAL "Debug")
set(CXXFLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG}")
set(CFLAGS "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_DEBUG}")
if(BUILD_SHARED_LIBS)
set(LDFLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS_DEBUG}")
else()
set(LDFLAGS "${CMAKE_STATIC_LINKER_FLAGS} ${CMAKE_STATIC_LINKER_FLAGS_DEBUG}")
endif()
endif()
string(TOUPPER "${CMAKE_BUILD_TYPE}" UPPER_BUILD_TYPE)
set(CXXFLAGS "${VCPKG_COMBINED_CXX_FLAGS_${UPPER_BUILD_TYPE}}")
set(CFLAGS "${VCPKG_COMBINED_C_FLAGS_${UPPER_BUILD_TYPE}}")
set(LDFLAGS "${VCPKG_COMBINED_SHARED_LINKER_FLAGS_${UPPER_BUILD_TYPE}}")
set(ARFLAGS "${VCPKG_COMBINED_STATIC_LINKER_FLAGS_${UPPER_BUILD_TYPE}}")
if(APPLE)
if(CMAKE_OSX_DEPLOYMENT_TARGET)
set(CXXFLAGS "-mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET} ${CXXFLAGS}")
set(CFLAGS "-mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET} ${CFLAGS}")
set(LDFLAGS "-mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET} ${LDFLAGS}")
endif()
if(CMAKE_OSX_SYSROOT)
set(CXXFLAGS "-isysroot ${CMAKE_OSX_SYSROOT} ${CXXFLAGS}")
set(CFLAGS "-isysroot ${CMAKE_OSX_SYSROOT} ${CFLAGS}")
set(LDFLAGS "-isysroot ${CMAKE_OSX_SYSROOT} ${LDFLAGS}")
endif()
# if specific architectures are set, configure them,
# if not set, this will still default to current arch
foreach(ARCH IN LISTS CMAKE_OSX_ARCHITECTURES)
set(CXXFLAGS "-arch ${ARCH} ${CXXFLAGS}")
set(CFLAGS "-arch ${ARCH} ${CFLAGS}")
set(LDFLAGS "-arch ${ARCH} ${LDFLAGS}")
endforeach()
endif()
string(REGEX REPLACE "[ \t\r\n]+" " " CXXFLAGS "${CXXFLAGS}")
string(STRIP "${CXXFLAGS}" CXXFLAGS)
string(REGEX REPLACE "[ \t\r\n]+" " " CFLAGS "${CFLAGS}")
string(STRIP "${CFLAGS}" CFLAGS)
string(REGEX REPLACE "[ \t\r\n]+" " " LDFLAGS "${LDFLAGS}")
string(STRIP "${LDFLAGS}" LDFLAGS)
if(NOT CXXFLAGS STREQUAL "")
string(REPLACE " " " <cxxflags>" CXXFLAGS "<cxxflags>${CXXFLAGS}")
endif()
if(NOT CFLAGS STREQUAL "")
string(REPLACE " " " <cflags>" CFLAGS "<cflags>${CFLAGS}")
endif()
if(NOT LDFLAGS STREQUAL "")
string(REPLACE " " " <linkflags>" LDFLAGS "<linkflags>${LDFLAGS}")
endif()
if(CMAKE_CXX_COMPILER_TARGET AND CMAKE_CXX_COMPILE_OPTIONS_TARGET)
if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
string(APPEND CXXFLAGS " <compileflags>${CMAKE_CXX_COMPILE_OPTIONS_TARGET}${CMAKE_CXX_COMPILER_TARGET}")
string(APPEND LDFLAGS " <linkflags>${CMAKE_CXX_COMPILE_OPTIONS_TARGET}${CMAKE_CXX_COMPILER_TARGET}")
else()
string(APPEND CXXFLAGS " <compileflags>${CMAKE_CXX_COMPILE_OPTIONS_TARGET} <compileflags>${CMAKE_CXX_COMPILER_TARGET}")
string(APPEND LDFLAGS " <linkflags>${CMAKE_CXX_COMPILE_OPTIONS_TARGET} <linkflags>${CMAKE_CXX_COMPILER_TARGET}")
string(APPEND COMPILEFLAGS " -D_DARWIN_C_SOURCE")
if(NOT CXXFLAGS MATCHES " -std=")
# If the user hasn't provided their own standard flag, use at least c++11
string(APPEND CXXFLAGS " -std=c++11")
endif()
endif()
if(CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN)
if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
string(APPEND CXXFLAGS " <compileflags>${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN}${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}")
string(APPEND LDFLAGS " <linkflags>${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN}${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}")
else()
string(APPEND CXXFLAGS " <compileflags>${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN} <compileflags>${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}")
string(APPEND LDFLAGS " <linkflags>${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN} <linkflags>${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}")
endif()
endif()
if(CMAKE_SYSROOT AND CMAKE_CXX_COMPILE_OPTIONS_SYSROOT)
string(APPEND CXXFLAGS " <compileflags>${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT}")
string(APPEND LDFLAGS " <linkflags>${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT}")
endif()
foreach(INCDIR IN LISTS CMAKE_CXX_STANDARD_INCLUDE_DIRECTORIES)
string(APPEND CXXFLAGS " <compileflags>${CMAKE_INCLUDE_FLAG_C}${CMAKE_INCLUDE_FLAG_C_SEP}${INCDIR}")
endforeach()
if(APPLE)
if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
string(APPEND CXXFLAGS " <compileflags>-D_DARWIN_C_SOURCE <cxxflags>-std=c++11 <cxxflags>-stdlib=libc++")
string(APPEND LDFLAGS " <linkflags>-stdlib=libc++")
else()
string(APPEND CXXFLAGS " <compileflags>-D_DARWIN_C_SOURCE <cxxflags>-std=c++11")
endif()
endif()
if(CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
if(VCPKG_DETECTED_CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
# cl in b2 appears to not receive `LIBPATH` for finding winmd files, so we transform them to `/AI` options.
set(libpath_args "$ENV{LIBPATH}")
# Apply: {x -> /AI"x"}
list(TRANSFORM libpath_args PREPEND "/AI\"")
list(TRANSFORM libpath_args APPEND "\"")
# Apply: {\ -> \\}
list(TRANSFORM libpath_args REPLACE "\\\\" "\\\\\\\\")
# Apply: {" -> \"}
list(TRANSFORM libpath_args REPLACE "\\\"" "\\\\\"")
list(JOIN libpath_args " " libpath_arg)
string(APPEND CXXFLAGS " <compileflags>\"${libpath_arg}\" <cxxflags>/ZW <compileflags>\"/D_WIN32_WINNT=0x0A00\"")
string(APPEND CFLAGS " <cflags>-Zl")
string(APPEND CXXFLAGS " /ZW")
string(APPEND COMPILEFLAGS " ${libpath_arg} /D_WIN32_WINNT=0x0A00")
string(APPEND CFLAGS " -Zl")
list(APPEND B2_OPTIONS windows-api=store)
list(APPEND B2_OPTIONS linkflags=WindowsApp.lib)
endif()
set(USER_CONFIG_TOOLSET_INVOCATION_COMMAND "\"${CMAKE_CXX_COMPILER}\"")
set(USER_CONFIG_TOOLSET_INVOCATION_COMMAND "\"${VCPKG_DETECTED_CMAKE_CXX_COMPILER}\"")
string(APPEND CXXFLAGS "${COMPILEFLAGS}")
string(APPEND CFLAGS "${COMPILEFLAGS}")
foreach(var CXXFLAGS CFLAGS LDFLAGS ARFLAGS)
string(REPLACE [[\]] [[\\]] ${var} "${${var}}")
string(REPLACE [["]] [[\"]] ${var} "${${var}}")
string(REGEX REPLACE "[ \t\r\n]+" " " ${var} "${${var}}")
string(STRIP "${${var}}" ${var})
endforeach()
if(USER_CONFIG_TOOLSET STREQUAL "msvc")
file(TO_CMAKE_PATH "${CMAKE_CURRENT_LIST_DIR}/nothing.bat" NOTHING_BAT)
string(APPEND USER_CONFIG_TOOLSET_OPTIONS
" <setup>\"${NOTHING_BAT}\"\n"
" ${CXXFLAGS}\n"
" ${CFLAGS}\n"
" ${LDFLAGS}\n"
)
if(NOT ARFLAGS STREQUAL "")
# Only apply these flags for MSVC
string(APPEND USER_CONFIG_REQUIREMENTS "<archiveflags>\"${ARFLAGS}\"\n ")
endif()
else()
string(APPEND USER_CONFIG_TOOLSET_OPTIONS
" <ranlib>\"${CMAKE_RANLIB}\"\n"
" <archiver>\"${CMAKE_AR}\"\n"
" ${CXXFLAGS}\n"
" ${CFLAGS}\n"
" ${LDFLAGS}\n"
" <ranlib>\"${VCPKG_DETECTED_CMAKE_RANLIB}\"\n"
" <archiver>\"${VCPKG_DETECTED_CMAKE_AR}\"\n"
)
endif()
if(NOT CXXFLAGS STREQUAL "")
string(APPEND USER_CONFIG_TOOLSET_OPTIONS " <cxxflags>\"${CXXFLAGS}\"\n")
endif()
if(NOT CFLAGS STREQUAL "")
string(APPEND USER_CONFIG_TOOLSET_OPTIONS " <cflags>\"${CFLAGS}\"\n <asmflags>\"${CFLAGS}\"\n")
endif()
if(NOT LDFLAGS STREQUAL "")
string(APPEND USER_CONFIG_REQUIREMENTS "<linkflags>\"${LDFLAGS}\"\n ")
string(APPEND USER_CONFIG_TOOLSET_OPTIONS " <linkflags>\"${LDFLAGS}\"\n")
endif()
if(WIN32 AND NOT USER_CONFIG_TOOLSET STREQUAL "msvc")
# MINGW here causes b2 to not run cygpath
string(APPEND USER_CONFIG_TOOLSET_OPTIONS
@ -255,7 +183,7 @@ endif()
# Handle Python
set(python_versions "")
if("python2" IN_LIST FEATURES)
if(WITH_PYTHON2)
# Find Python2 in the current installed directory
file(GLOB python2_include_dir "${CURRENT_INSTALLED_DIR}/include/python2.*")
string(REGEX REPLACE ".*python([0-9\.]+).*" "\\1" python2_version "${python2_include_dir}")
@ -266,7 +194,7 @@ if("python2" IN_LIST FEATURES)
list(APPEND python_versions "${python2_version}")
endif()
if("python3" IN_LIST FEATURES)
if(WITH_PYTHON3)
# Find Python3 in the current installed directory
file(GLOB python3_include_dir "${CURRENT_INSTALLED_DIR}/include/python3.*")
string(REGEX REPLACE ".*python([0-9\.]+).*" "\\1" python3_version "${python3_include_dir}")

11
ports/boost-modular-build-helper/boost-modular-build.cmake
View File

@ -105,17 +105,28 @@ function(boost_modular_build)
list(APPEND configure_options "-DBOOST_CMAKE_FRAGMENT=${_bm_BOOST_CMAKE_FRAGMENT}")
endif()
vcpkg_cmake_get_vars(cmake_vars_file)
vcpkg_check_features(
OUT_FEATURE_OPTIONS feature_options
FEATURES
python2 WITH_PYTHON2
python3 WITH_PYTHON3
)
vcpkg_cmake_configure(
SOURCE_PATH ${BOOST_BUILD_INSTALLED_DIR}/share/boost-build
GENERATOR Ninja
OPTIONS
"-DPORT=${PORT}"
"-DFEATURES=${FEATURES}"
${feature_options}
"-DCURRENT_INSTALLED_DIR=${CURRENT_INSTALLED_DIR}"
"-DB2_EXE=${B2_EXE}"
"-DSOURCE_PATH=${_bm_SOURCE_PATH}"
"-DBOOST_BUILD_PATH=${BOOST_BUILD_PATH}"
"-DVCPKG_CRT_LINKAGE=${VCPKG_CRT_LINKAGE}"
"-DVCPKG_CMAKE_VARS_FILE=${cmake_vars_file}"
${configure_options}
MAYBE_UNUSED_VARIABLES
FEATURES

2
ports/boost-modular-build-helper/user-config.jam.in
View File

@ -7,7 +7,7 @@ using @USER_CONFIG_TOOLSET@ : @USER_CONFIG_TOOLSET_VERSION@ : @USER_CONFIG_TOOLS
@USER_CONFIG_EXTRA_LINES@
project user-config : ;
project user-config : requirements @USER_CONFIG_REQUIREMENTS@ ;
if "@USER_CONFIG_TOOLSET@" = "msvc" || "@USER_CONFIG_TOOLSET@" = "clang-win"
{

3
ports/boost-modular-build-helper/vcpkg.json
View File

@ -1,8 +1,9 @@
{
"name": "boost-modular-build-helper",
"version": "1.78.0",
"port-version": 2,
"port-version": 3,
"description": "Internal vcpkg port used to build Boost libraries",
"license": "MIT",
"dependencies": [
"boost-uninstall",
"vcpkg-cmake"

4
ports/ffmpeg/build.sh.in
View File

@ -91,11 +91,11 @@ OSX_ARCH_COUNT=0@OSX_ARCH_COUNT@
build_ffmpeg() {
echo "=== CONFIGURING ==="
sh "$PATH_TO_SRC_DIR/configure" "--prefix=$PATH_TO_PACKAGE_DIR" @CONFIGURE_OPTIONS@ $@
sh "$PATH_TO_SRC_DIR/configure" "--prefix=$PATH_TO_PACKAGE_DIR" "--cc=$CC" @CONFIGURE_OPTIONS@ $@
echo "=== BUILDING ==="
make -j${JOBS}
make -j${JOBS} V=1
echo "=== INSTALLING ==="

190
ports/ffmpeg/portfile.cmake
View File

@ -34,12 +34,12 @@ endif()
if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
# ffmpeg nasm build gives link error on x86, so fall back to yasm
vcpkg_find_acquire_program(YASM)
get_filename_component(YASM_EXE_PATH ${YASM} DIRECTORY)
vcpkg_add_to_path(${YASM_EXE_PATH})
get_filename_component(YASM_EXE_PATH "${YASM}" DIRECTORY)
vcpkg_add_to_path("${YASM_EXE_PATH}")
else()
vcpkg_find_acquire_program(NASM)
get_filename_component(NASM_EXE_PATH ${NASM} DIRECTORY)
vcpkg_add_to_path(${NASM_EXE_PATH})
get_filename_component(NASM_EXE_PATH "${NASM}" DIRECTORY)
vcpkg_add_to_path("${NASM_EXE_PATH}")
endif()
if(VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW)
@ -85,29 +85,40 @@ if(VCPKG_TARGET_IS_WINDOWS)
vcpkg_acquire_msys(MSYS_ROOT)
endif()
set(SHELL ${MSYS_ROOT}/usr/bin/bash.exe)
if(VCPKG_TARGET_IS_MINGW)
if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
set(OPTIONS "--target-os=mingw32 ${OPTIONS}")
elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
set(OPTIONS "--target-os=mingw64 ${OPTIONS}")
endif()
else()
set(OPTIONS "--toolchain=msvc ${OPTIONS}")
endif()
set(SHELL "${MSYS_ROOT}/usr/bin/bash.exe")
else()
set(SHELL /bin/sh)
endif()
if(VCPKG_TARGET_IS_MINGW)
if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
string(APPEND OPTIONS " --target-os=mingw32")
elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
string(APPEND OPTIONS " --target-os=mingw64")
endif()
elseif(VCPKG_TARGET_IS_WINDOWS)
string(APPEND OPTIONS " --target-os=win32")
elseif(VCPKG_TARGET_IS_OSX)
string(APPEND OPTIONS " --target-os=darwin")
elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Android")
string(APPEND OPTIONS " --target-os=android")
else()
endif()
vcpkg_cmake_get_vars(cmake_vars_file)
include("${cmake_vars_file}")
if(VCPKG_TARGET_IS_OSX AND VCPKG_DETECTED_CMAKE_OSX_DEPLOYMENT_TARGET)
set(OPTIONS "--extra-cflags=-mmacosx-version-min=${VCPKG_DETECTED_CMAKE_OSX_DEPLOYMENT_TARGET} ${OPTIONS}")
set(OPTIONS "--extra-ldflags=-mmacosx-version-min=${VCPKG_DETECTED_CMAKE_OSX_DEPLOYMENT_TARGET} ${OPTIONS}")
if(VCPKG_DETECTED_MSVC)
set(OPTIONS "--toolchain=msvc ${OPTIONS}")
# This is required because ffmpeg depends upon optimizations to link correctly
string(APPEND VCPKG_COMBINED_C_FLAGS_DEBUG " -O2")
string(REPLACE " -RTC1 " "" VCPKG_COMBINED_C_FLAGS_DEBUG "${VCPKG_COMBINED_C_FLAGS_DEBUG}")
string(REPLACE " -Od " "" VCPKG_COMBINED_C_FLAGS_DEBUG "${VCPKG_COMBINED_C_FLAGS_DEBUG}")
string(REPLACE " -Ob0 " "" VCPKG_COMBINED_C_FLAGS_DEBUG "${VCPKG_COMBINED_C_FLAGS_DEBUG}")
endif()
set(ENV{${INCLUDE_VAR}} "${CURRENT_INSTALLED_DIR}/include${VCPKG_HOST_PATH_SEPARATOR}$ENV{${INCLUDE_VAR}}")
string(APPEND VCPKG_COMBINED_C_FLAGS_DEBUG " -I \"${CURRENT_INSTALLED_DIR}/include\"")
string(APPEND VCPKG_COMBINED_C_FLAGS_RELEASE " -I \"${CURRENT_INSTALLED_DIR}/include\"")
set(_csc_PROJECT_PATH ffmpeg)
@ -442,80 +453,48 @@ else()
endif()
if (VCPKG_TARGET_IS_OSX)
# if the sysroot isn't set in the triplet we fall back to whatever CMake detected for us
if ("${VCPKG_OSX_SYSROOT}" STREQUAL "")
set(VCPKG_OSX_SYSROOT ${VCPKG_DETECTED_CMAKE_OSX_SYSROOT})
endif()
set(OPTIONS "${OPTIONS} --disable-vdpau") # disable vdpau in OSX
set(OPTIONS "${OPTIONS} --extra-cflags=\"-isysroot ${VCPKG_OSX_SYSROOT}\"")
set(OPTIONS "${OPTIONS} --extra-ldflags=\"-isysroot ${VCPKG_OSX_SYSROOT}\"")
list(JOIN VCPKG_OSX_ARCHITECTURES " " OSX_ARCHS)
LIST(LENGTH VCPKG_OSX_ARCHITECTURES OSX_ARCH_COUNT)
endif()
set(OPTIONS_CROSS "")
set(OPTIONS_CROSS " --enable-cross-compile")
if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
string(APPEND OPTIONS_CROSS " --arch=x86_64")
else()
string(APPEND OPTIONS_CROSS " --arch=${VCPKG_TARGET_ARCHITECTURE}")
endif()
if (VCPKG_TARGET_ARCHITECTURE STREQUAL "arm" OR VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64")
if(VCPKG_TARGET_IS_WINDOWS)
set(OPTIONS_CROSS " --enable-cross-compile --target-os=win32 --arch=${VCPKG_TARGET_ARCHITECTURE}")
vcpkg_find_acquire_program(GASPREPROCESSOR)
foreach(GAS_PATH ${GASPREPROCESSOR})
get_filename_component(GAS_ITEM_PATH ${GAS_PATH} DIRECTORY)
set(ENV{PATH} "$ENV{PATH}${VCPKG_HOST_PATH_SEPARATOR}${GAS_ITEM_PATH}")
endforeach(GAS_PATH)
elseif(VCPKG_TARGET_IS_OSX AND NOT VCPKG_TARGET_ARCHITECTURE STREQUAL "${VCPKG_DETECTED_CMAKE_HOST_SYSTEM_PROCESSOR}")
# get the number of architectures requested
list(LENGTH VCPKG_OSX_ARCHITECTURES ARCHITECTURE_COUNT)
# ideally we should check the CMAKE_HOST_SYSTEM_PROCESSOR, but that seems to be
# broken when inside a vcpkg port, so we only set it when doing a simple build
# for a single platform. multi-platform builds use a different script
if (ARCHITECTURE_COUNT LESS 2)
message(STATUS "Building on host: ${CMAKE_SYSTEM_PROCESSOR}")
set(OPTIONS_CROSS " --enable-cross-compile --target-os=darwin --arch=arm64 --extra-ldflags=-arch --extra-ldflags=arm64 --extra-cflags=-arch --extra-cflags=arm64 --extra-cxxflags=-arch --extra-cxxflags=arm64")
endif()
endif()
elseif (VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
if(VCPKG_TARGET_IS_OSX)
set(OPTIONS_CROSS " --enable-cross-compile --target-os=darwin --arch=x86_64 --extra-ldflags=-arch --extra-ldflags=x86_64 --extra-cflags=-arch --extra-cflags=x86_64 --extra-cxxflags=-arch --extra-cxxflags=x86_64")
endif()
elseif (VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
else()
message(FATAL_ERROR "Unsupported architecture")
endif()
if(VCPKG_TARGET_IS_UWP)
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(OPTIONS "${OPTIONS} --disable-programs")
set(OPTIONS "${OPTIONS} --extra-cflags=-DWINAPI_FAMILY=WINAPI_FAMILY_APP --extra-cflags=-D_WIN32_WINNT=0x0A00")
set(OPTIONS_CROSS " --enable-cross-compile --target-os=win32 --arch=${VCPKG_TARGET_ARCHITECTURE}")
string(APPEND OPTIONS " --disable-programs")
string(APPEND OPTIONS " --extra-cflags=-DWINAPI_FAMILY=WINAPI_FAMILY_APP --extra-cflags=-D_WIN32_WINNT=0x0A00")
string(APPEND OPTIONS " --extra-ldflags=-APPCONTAINER --extra-ldflags=WindowsApp.lib")
endif()
set(OPTIONS_DEBUG "--debug") # Note: --disable-optimizations can't be used due to https://ffmpeg.org/pipermail/libav-user/2013-March/003945.html
# Note: --disable-optimizations can't be used due to https://ffmpeg.org/pipermail/libav-user/2013-March/003945.html
set(OPTIONS_DEBUG "--debug")
set(OPTIONS_RELEASE "")
set(OPTIONS "${OPTIONS} ${OPTIONS_CROSS}")
if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic")
set(OPTIONS "${OPTIONS} --disable-static --enable-shared")
if (VCPKG_TARGET_IS_UWP)
set(OPTIONS "${OPTIONS} --extra-ldflags=-APPCONTAINER --extra-ldflags=WindowsApp.lib")
endif()
endif()
if(VCPKG_TARGET_IS_MINGW)
set(OPTIONS "${OPTIONS} --extra_cflags=-D_WIN32_WINNT=0x0601")
elseif(VCPKG_TARGET_IS_WINDOWS)
set(OPTIONS "${OPTIONS} --extra-cflags=-DHAVE_UNISTD_H=0")
if(VCPKG_CRT_LINKAGE STREQUAL "dynamic")
set(OPTIONS_DEBUG "${OPTIONS_DEBUG} --extra-cflags=-MDd --extra-cxxflags=-MDd")
set(OPTIONS_RELEASE "${OPTIONS_RELEASE} --extra-cflags=-MD --extra-cxxflags=-MD")
else()
set(OPTIONS_DEBUG "${OPTIONS_DEBUG} --extra-cflags=-MTd --extra-cxxflags=-MTd")
set(OPTIONS_RELEASE "${OPTIONS_RELEASE} --extra-cflags=-MT --extra-cxxflags=-MT")
endif()
endif()
if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
@ -524,17 +503,34 @@ endif()
set(ENV_LIB_PATH "$ENV{${LIB_PATH_VAR}}")
get_filename_component(CC_path "${VCPKG_DETECTED_CMAKE_C_COMPILER}" DIRECTORY)
get_filename_component(CC_filename "${VCPKG_DETECTED_CMAKE_C_COMPILER}" NAME)
set(ENV{CC} "${CC_filename}")
if(CC_path)
vcpkg_add_to_path(PREPEND "${CC_path}")
endif()
message(STATUS "Building Options: ${OPTIONS}")
# Release build
if (NOT VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
message(STATUS "Building Release Options: ${OPTIONS_RELEASE}")
set(ENV{${LIB_PATH_VAR}} "${CURRENT_INSTALLED_DIR}/lib${VCPKG_HOST_PATH_SEPARATOR}${ENV_LIB_PATH}")
set(ENV{CFLAGS} "${VCPKG_C_FLAGS} ${VCPKG_C_FLAGS_RELEASE}")
set(ENV{LDFLAGS} "${VCPKG_LINKER_FLAGS}")
set(ENV{PKG_CONFIG_PATH} "${CURRENT_INSTALLED_DIR}/lib/pkgconfig")
message(STATUS "Building ${_csc_PROJECT_PATH} for Release")
file(MAKE_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel)
file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
# We use response files here as the only known way to handle spaces in paths
set(crsp "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/cflags.rsp")
file(WRITE "${crsp}" "${VCPKG_COMBINED_C_FLAGS_RELEASE}")
set(ldrsp "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/ldflags.rsp")
file(WRITE "${ldrsp}" "${VCPKG_COMBINED_SHARED_LINKER_FLAGS_RELEASE}")
set(ENV{CFLAGS} "@${crsp}")
# All tools except the msvc arm{,64} assembler accept @... as response file syntax.
# For that assembler, there is no known way to pass in flags. We must hope that not passing flags will work acceptably.
if(NOT VCPKG_DETECTED_MSVC OR NOT VCPKG_TARGET_ARCHITECTURE MATCHES "^arm")
set(ENV{ASFLAGS} "@${crsp}")
endif()
set(ENV{LDFLAGS} "@${ldrsp}")
set(BUILD_DIR "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
set(CONFIGURE_OPTIONS "${OPTIONS} ${OPTIONS_RELEASE}")
@ -543,9 +539,9 @@ if (NOT VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
configure_file("${CMAKE_CURRENT_LIST_DIR}/build.sh.in" "${BUILD_DIR}/build.sh" @ONLY)
vcpkg_execute_required_process(
COMMAND ${SHELL} ./build.sh
WORKING_DIRECTORY ${BUILD_DIR}
LOGNAME build-${TARGET_TRIPLET}-rel
COMMAND "${SHELL}" ./build.sh
WORKING_DIRECTORY "${BUILD_DIR}"
LOGNAME "build-${TARGET_TRIPLET}-rel"
)
endif()
@ -553,11 +549,19 @@ endif()
if (NOT VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
message(STATUS "Building Debug Options: ${OPTIONS_DEBUG}")
set(ENV{${LIB_PATH_VAR}} "${CURRENT_INSTALLED_DIR}/debug/lib${VCPKG_HOST_PATH_SEPARATOR}${ENV_LIB_PATH}")
set(ENV{CFLAGS} "${VCPKG_C_FLAGS} ${VCPKG_C_FLAGS_DEBUG}")
set(ENV{LDFLAGS} "${VCPKG_LINKER_FLAGS}")
set(ENV{LDFLAGS} "${VCPKG_COMBINED_SHARED_LINKER_FLAGS_DEBUG}")
set(ENV{PKG_CONFIG_PATH} "${CURRENT_INSTALLED_DIR}/debug/lib/pkgconfig")
message(STATUS "Building ${_csc_PROJECT_PATH} for Debug")
file(MAKE_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg)
file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg")
set(crsp "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/cflags.rsp")
file(WRITE "${crsp}" "${VCPKG_COMBINED_C_FLAGS_DEBUG}")
set(ldrsp "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/ldflags.rsp")
file(WRITE "${ldrsp}" "${VCPKG_COMBINED_SHARED_LINKER_FLAGS_DEBUG}")
set(ENV{CFLAGS} "@${crsp}")
if(NOT VCPKG_DETECTED_MSVC OR NOT VCPKG_TARGET_ARCHITECTURE MATCHES "^arm")
set(ENV{ASFLAGS} "@${crsp}")
endif()
set(ENV{LDFLAGS} "@${ldrsp}")
set(BUILD_DIR "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg")
set(CONFIGURE_OPTIONS "${OPTIONS} ${OPTIONS_DEBUG}")
@ -566,14 +570,14 @@ if (NOT VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
configure_file("${CMAKE_CURRENT_LIST_DIR}/build.sh.in" "${BUILD_DIR}/build.sh" @ONLY)
vcpkg_execute_required_process(
COMMAND ${SHELL} ./build.sh
WORKING_DIRECTORY ${BUILD_DIR}
LOGNAME build-${TARGET_TRIPLET}-dbg
COMMAND "${SHELL}" ./build.sh
WORKING_DIRECTORY "${BUILD_DIR}"
LOGNAME "build-${TARGET_TRIPLET}-dbg"
)
endif()
if(VCPKG_TARGET_IS_WINDOWS)
file(GLOB DEF_FILES ${CURRENT_PACKAGES_DIR}/lib/*.def ${CURRENT_PACKAGES_DIR}/debug/lib/*.def)
file(GLOB DEF_FILES "${CURRENT_PACKAGES_DIR}/lib/*.def" "${CURRENT_PACKAGES_DIR}/debug/lib/*.def")
if(NOT VCPKG_TARGET_IS_MINGW)
if(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm")
@ -596,21 +600,21 @@ if(VCPKG_TARGET_IS_WINDOWS)
file(TO_NATIVE_PATH "${DEF_FILE_DIR}/${OUT_FILE_NAME}" OUT_FILE_NATIVE)
message(STATUS "Generating ${OUT_FILE_NATIVE}")
vcpkg_execute_required_process(
COMMAND lib.exe /def:${DEF_FILE_NATIVE} /out:${OUT_FILE_NATIVE} ${LIB_MACHINE_ARG}
WORKING_DIRECTORY ${CURRENT_PACKAGES_DIR}
LOGNAME libconvert-${TARGET_TRIPLET}
COMMAND lib.exe "/def:${DEF_FILE_NATIVE}" "/out:${OUT_FILE_NATIVE}" ${LIB_MACHINE_ARG}
WORKING_DIRECTORY "${CURRENT_PACKAGES_DIR}"
LOGNAME "libconvert-${TARGET_TRIPLET}"
)
endforeach()
endif()
file(GLOB EXP_FILES ${CURRENT_PACKAGES_DIR}/lib/*.exp ${CURRENT_PACKAGES_DIR}/debug/lib/*.exp)
file(GLOB LIB_FILES ${CURRENT_PACKAGES_DIR}/bin/*${VCPKG_TARGET_STATIC_LIBRARY_SUFFIX} ${CURRENT_PACKAGES_DIR}/debug/bin/*${VCPKG_TARGET_STATIC_LIBRARY_SUFFIX})
file(GLOB EXP_FILES "${CURRENT_PACKAGES_DIR}/lib/*.exp" "${CURRENT_PACKAGES_DIR}/debug/lib/*.exp")
file(GLOB LIB_FILES "${CURRENT_PACKAGES_DIR}/bin/*${VCPKG_TARGET_STATIC_LIBRARY_SUFFIX}" "${CURRENT_PACKAGES_DIR}/debug/bin/*${VCPKG_TARGET_STATIC_LIBRARY_SUFFIX}")
if(VCPKG_TARGET_IS_MINGW)
file(GLOB LIB_FILES_2 ${CURRENT_PACKAGES_DIR}/bin/*.lib ${CURRENT_PACKAGES_DIR}/debug/bin/*.lib)
file(GLOB LIB_FILES_2 "${CURRENT_PACKAGES_DIR}/bin/*.lib" "${CURRENT_PACKAGES_DIR}/debug/bin/*.lib")
endif()
list(APPEND FILES_TO_REMOVE ${EXP_FILES} ${LIB_FILES} ${LIB_FILES_2} ${DEF_FILES})
if(FILES_TO_REMOVE)
file(REMOVE ${FILES_TO_REMOVE})
set(files_to_remove ${EXP_FILES} ${LIB_FILES} ${LIB_FILES_2} ${DEF_FILES})
if(files_to_remove)
file(REMOVE ${files_to_remove})
endif()
endif()
@ -624,10 +628,10 @@ if("ffplay" IN_LIST FEATURES)
vcpkg_copy_tools(TOOL_NAMES ffplay AUTO_CLEAN)
endif()
file(REMOVE_RECURSE ${CURRENT_PACKAGES_DIR}/debug/include ${CURRENT_PACKAGES_DIR}/debug/share)
file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include" "${CURRENT_PACKAGES_DIR}/debug/share")
if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
file(REMOVE_RECURSE ${CURRENT_PACKAGES_DIR}/bin ${CURRENT_PACKAGES_DIR}/debug/bin)
file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/bin" "${CURRENT_PACKAGES_DIR}/debug/bin")
endif()
vcpkg_copy_pdbs()
@ -725,8 +729,8 @@ list(REMOVE_DUPLICATES FFMPEG_DEPENDENCIES_DEBUG)
list(REVERSE FFMPEG_DEPENDENCIES_RELEASE)
list(REVERSE FFMPEG_DEPENDENCIES_DEBUG)
message("Dependencies (release): ${FFMPEG_DEPENDENCIES_RELEASE}")
message("Dependencies (debug): ${FFMPEG_DEPENDENCIES_DEBUG}")
message(STATUS "Dependencies (release): ${FFMPEG_DEPENDENCIES_RELEASE}")
message(STATUS "Dependencies (debug): ${FFMPEG_DEPENDENCIES_DEBUG}")
# Handle version strings
@ -785,7 +789,7 @@ extract_version_from_component(LIBSWSCALE_VERSION
COMPONENT libswscale)
# Handle copyright
file(STRINGS ${CURRENT_BUILDTREES_DIR}/build-${TARGET_TRIPLET}-rel-out.log LICENSE_STRING REGEX "License: .*" LIMIT_COUNT 1)
file(STRINGS "${CURRENT_BUILDTREES_DIR}/build-${TARGET_TRIPLET}-rel-out.log" LICENSE_STRING REGEX "License: .*" LIMIT_COUNT 1)
if(LICENSE_STRING STREQUAL "License: LGPL version 2.1 or later")
set(LICENSE_FILE "COPYING.LGPLv2.1")
elseif(LICENSE_STRING STREQUAL "License: LGPL version 3 or later")
@ -796,11 +800,11 @@ elseif(LICENSE_STRING STREQUAL "License: GPL version 3 or later")
set(LICENSE_FILE "COPYING.GPLv3")
elseif(LICENSE_STRING STREQUAL "License: nonfree and unredistributable")
set(LICENSE_FILE "COPYING.NONFREE")
file(WRITE ${SOURCE_PATH}/${LICENSE_FILE} ${LICENSE_STRING})
file(WRITE "${SOURCE_PATH}/${LICENSE_FILE}" "${LICENSE_STRING}")
else()
message(FATAL_ERROR "Failed to identify license (${LICENSE_STRING})")
endif()
configure_file(${CMAKE_CURRENT_LIST_DIR}/FindFFMPEG.cmake.in ${CURRENT_PACKAGES_DIR}/share/${PORT}/FindFFMPEG.cmake @ONLY)
file(COPY ${CMAKE_CURRENT_LIST_DIR}/vcpkg-cmake-wrapper.cmake DESTINATION ${CURRENT_PACKAGES_DIR}/share/${PORT})
file(INSTALL ${SOURCE_PATH}/${LICENSE_FILE} DESTINATION ${CURRENT_PACKAGES_DIR}/share/${PORT} RENAME copyright)
configure_file("${CMAKE_CURRENT_LIST_DIR}/FindFFMPEG.cmake.in" "${CURRENT_PACKAGES_DIR}/share/${PORT}/FindFFMPEG.cmake" @ONLY)
file(COPY "${CMAKE_CURRENT_LIST_DIR}/vcpkg-cmake-wrapper.cmake" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}")
file(INSTALL "${SOURCE_PATH}/${LICENSE_FILE}" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}" RENAME copyright)

2
ports/ffmpeg/vcpkg.json
View File

@ -1,7 +1,7 @@
{
"name": "ffmpeg",
"version": "4.4.1",
"port-version": 10,
"port-version": 11,
"description": [
"a library to decode, encode, transcode, mux, demux, stream, filter and play pretty much anything that humans and machines have created.",
"FFmpeg is the leading multimedia framework, able to decode, encode, transcode, mux, demux, stream, filter and play pretty much anything that humans and machines have created. It supports the most obscure ancient formats up to the cutting edge. No matter if they were designed by some standards committee, the community or a corporation. It is also highly portable: FFmpeg compiles, runs, and passes our testing infrastructure FATE across Linux, Mac OS X, Microsoft Windows, the BSDs, Solaris, etc. under a wide variety of build environments, machine architectures, and configurations."

102
ports/vcpkg-cmake/cmake_get_vars/CMakeLists.txt
View File

@ -8,7 +8,10 @@ list(APPEND VCPKG_DEFAULT_VARS_TO_CHECK CMAKE_CROSSCOMPILING
CMAKE_SYSTEM_NAME
CMAKE_HOST_SYSTEM_NAME
CMAKE_SYSTEM_PROCESSOR
CMAKE_HOST_SYSTEM_PROCESSOR)
CMAKE_HOST_SYSTEM_PROCESSOR
CMAKE_SIZEOF_VOID_P
MSVC
MSVC_VERSION)
if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
list(APPEND VCPKG_DEFAULT_VARS_TO_CHECK CMAKE_OSX_DEPLOYMENT_TARGET
CMAKE_OSX_SYSROOT)
@ -21,6 +24,7 @@ endforeach()
set(COMPILERS ${VCPKG_LANGUAGES} RC)
foreach(prog IN LISTS COMPILERS)
list(APPEND VCPKG_DEFAULT_VARS_TO_CHECK CMAKE_${prog}_COMPILER)
list(APPEND VCPKG_DEFAULT_VARS_TO_CHECK CMAKE_${prog}_COMPILER_ID)
endforeach()
# Variables to check
foreach(_lang IN LISTS VCPKG_LANGUAGES)
@ -74,7 +78,7 @@ endif()
project(get_cmake_vars LANGUAGES ${VCPKG_LANGUAGES})
foreach(VAR IN LISTS VCPKG_VARS_TO_CHECK)
foreach(VAR IN LISTS VCPKG_VARS_TO_CHECK VCPKG_FLAGS_TO_CHECK)
string(APPEND OUTPUT_STRING "set(${VCPKG_VAR_PREFIX}_${VAR} \"${${VAR}}\")\n")
endforeach()
@ -87,38 +91,64 @@ foreach(_env IN LISTS VCPKG_ENV_VARS_TO_CHECK)
endif()
endforeach()
macro(_vcpkg_adjust_flags flag_var)
if(MSVC) # Transform MSVC /flags to -flags due to bash scripts intepreting /flag as a path.
string(REGEX REPLACE "(^| )/" "\\1-" ${flag_var} "${${flag_var}}")
endif()
if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
if("${flag_var}" IN_LIST VCPKG_LANG_FLAGS)
# macOS - append arch and isysroot if cross-compiling
if(NOT "${CMAKE_OSX_ARCHITECTURES}" STREQUAL "${CMAKE_HOST_SYSTEM_PROCESSOR}")
set(EXTRA_FLAGS "")
foreach(arch IN LISTS CMAKE_OSX_ARCHITECTURES)
string(APPEND ${flag_var} " -arch ${arch}")
endforeach()
string(APPEND ${flag_var} " -isysroot ${CMAKE_OSX_SYSROOT}")
endif()
endif()
if(APPLE)
if(CMAKE_OSX_SYSROOT)
string(APPEND EXTRA_FLAGS " -isysroot \"${CMAKE_OSX_SYSROOT}\"")
endif()
endmacro()
foreach(flag IN LISTS VCPKG_FLAGS_TO_CHECK)
string(STRIP "${${flag}}" ${flag}) # Strip leading and trailing whitespaces
_vcpkg_adjust_flags(${flag})
string(APPEND OUTPUT_STRING "set(${VCPKG_VAR_PREFIX}_RAW_${flag} \" ${${flag}}\")\n")
foreach(config IN LISTS VCPKG_CONFIGS)
string(STRIP "${${flag}_${config}}" ${flag}_${config})
_vcpkg_adjust_flags(${flag}_${config})
string(APPEND OUTPUT_STRING "set(${VCPKG_VAR_PREFIX}_RAW_${flag}_${config} \"${CMAKE_${flag}_FLAGS_${config}}\")\n")
set(COMBINED_${flag}_${config} "${${flag}} ${${flag}_${config}}")
string(STRIP "${COMBINED_${flag}_${config}}" COMBINED_${flag}_${config})
string(APPEND OUTPUT_STRING "set(${VCPKG_VAR_PREFIX}_${flag}_${config} \"${COMBINED_${flag}_${config}}\")\n")
foreach(arch IN LISTS CMAKE_OSX_ARCHITECTURES)
string(APPEND EXTRA_FLAGS " -arch ${arch}")
endforeach()
if(CMAKE_OSX_DEPLOYMENT_TARGET)
string(APPEND EXTRA_FLAGS " -mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}")
endif()
endif()
if(CMAKE_CXX_COMPILER_TARGET)
if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
string(APPEND EXTRA_FLAGS " \"${CMAKE_CXX_COMPILE_OPTIONS_TARGET}${CMAKE_CXX_COMPILER_TARGET}\"")
else()
string(APPEND EXTRA_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_TARGET} \"${CMAKE_CXX_COMPILER_TARGET}\"")
endif()
endif()
if(CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN)
if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
string(APPEND EXTRA_FLAGS " \"${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN}${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}\"")
else()
string(APPEND EXTRA_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN} \"${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}\"")
endif()
endif()
if(CMAKE_SYSROOT AND CMAKE_CXX_COMPILE_OPTIONS_SYSROOT)
string(APPEND EXTRA_FLAGS " \"${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT}\"")
endif()
foreach(flags CXX C SHARED_LINKER EXE_LINKER)
set(${flags}_FLAGS "${CMAKE_${flags}_FLAGS} ${CMAKE_${flags}_FLAGS_${VCPKG_CONFIGS}} ${EXTRA_FLAGS}")
endforeach()
foreach(flags STATIC_LINKER RC)
set(${flags}_FLAGS "${CMAKE_${flags}_FLAGS} ${CMAKE_${flags}_FLAGS_${VCPKG_CONFIGS}}")
endforeach()
foreach(incdir IN LISTS CMAKE_CXX_STANDARD_INCLUDE_DIRECTORIES)
string(APPEND CXX_FLAGS " \"${CMAKE_INCLUDE_FLAG_CXX}${incdir}\"")
endforeach()
foreach(incdir IN LISTS CMAKE_C_STANDARD_INCLUDE_DIRECTORIES)
string(APPEND C_FLAGS " \"${CMAKE_INCLUDE_FLAG_C}${incdir}\"")
endforeach()
foreach(flag CXX C SHARED_LINKER EXE_LINKER STATIC_LINKER RC)
if(MSVC)
# Transform MSVC /flags to -flags due to bash scripts intepreting /flag as a path.
# This is imperfect because it fails on directories with trailing spaces, but those are exceedingly rare
string(REGEX REPLACE "(^| )/" "\\1-" ${flag}_FLAGS "${${flag}_FLAGS}")
endif()
string(REPLACE "\\" "\\\\" ${flag}_FLAGS "${${flag}_FLAGS}")
string(REPLACE "\"" "\\\"" ${flag}_FLAGS "${${flag}_FLAGS}")
string(REPLACE "\$" "\\\$" ${flag}_FLAGS "${${flag}_FLAGS}")
string(APPEND OUTPUT_STRING "set(VCPKG_COMBINED_${flag}_FLAGS_${VCPKG_CONFIGS} \"${${flag}_FLAGS}\")\n")
endforeach()
file(WRITE "${VCPKG_OUTPUT_FILE}" "${OUTPUT_STRING}")
@ -137,12 +167,26 @@ file(WRITE "${VCPKG_OUTPUT_FILE}" "${OUTPUT_STRING}")
# CMAKE_CXX_COMPILER
# CMAKE_RC_COMPILER
# Program details:
# CMAKE_<LANG>_COMPILER_ID
# MSVC
# MSVC_VERSION
# Flags:
# CMAKE_<LANG>_FLAGS
# CMAKE_<LANG>_FLAGS_<CONFIG>
# CMAKE_RC_FLAGS
# CMAKE_SHARED_LINKER_FLAGS
# CMAKE_SHARED_LINKER_FLAGS_<CONFIG>
# CMAKE_STATIC_LINKER_FLAGS
# CMAKE_STATIC_LINKER_FLAGS_<CONFIG>
# CMAKE_EXE_LINKER_FLAGS
# CMAKE_EXE_LINKER_FLAGS_<CONFIG>
# Additional information:
# CMAKE_SIZEOF_VOID_P
# CMAKE_CROSSCOMPILING
# CMAKE_SYSTEM_NAME
# CMAKE_HOST_SYSTEM_NAME
# CMAKE_SYSTEM_PROCESSOR
# CMAKE_HOST_SYSTEM_PROCESSOR

3
ports/vcpkg-cmake/vcpkg.json
View File

@ -1,4 +1,5 @@
{
"name": "vcpkg-cmake",
"version-date": "2022-01-19"
"version-date": "2022-02-14",
"license": "MIT"
}

10
ports/vcpkg-cmake/vcpkg_cmake_get_vars.cmake
View File

@ -12,6 +12,16 @@ vcpkg_cmake_get_vars(<out-var>)
a path to a generated CMake file, with the detected `CMAKE_*` variables
re-exported as `VCPKG_DETECTED_CMAKE_*`.
Additionally sets, for `RELEASE` and `DEBUG`:
- VCPKG_COMBINED_CXX_FLAGS_<config>
- VCPKG_COMBINED_C_FLAGS_<config>
- VCPKG_COMBINED_SHARED_LINKER_FLAGS_<config>
- VCPKG_COMBINED_STATIC_LINKER_FLAGS_<config>
- VCPKG_COMBINED_EXE_LINKER_FLAGS_<config>
Most users should use these pre-combined flags instead of attempting
to read the `VCPKG_DETECTED_*` flags directly.
## Notes
Avoid usage in portfiles.

3
ports/vcpkg-qmake/vcpkg.json
View File

@ -1,6 +1,7 @@
{
"name": "vcpkg-qmake",
"version-date": "2021-10-23",
"version-date": "2022-02-14",
"license": "MIT",
"supports": "native",
"dependencies": [
"pkgconf",

12
ports/vcpkg-qmake/vcpkg_qmake_configure.cmake
View File

@ -131,12 +131,12 @@ function(vcpkg_qmake_configure)
set(qmake_comp_flags "")
# Note sure about these. VCPKG_QMAKE_OPTIONS offers a way to opt out of these. (earlier values being overwritten by later values; = set +=append *=append unique -=remove)
vcpkg_list(APPEND qmake_comp_flags "QMAKE_LIBS+=${VCPKG_DETECTED_CMAKE_C_STANDARD_LIBRARIES} ${VCPKG_DETECTED_CMAKE_CXX_STANDARD_LIBRARIES}"
"QMAKE_RC+=${VCPKG_DETECTED_CMAKE_RC_FLAGS_${buildtype}}"
"QMAKE_CFLAGS_${buildtype}*=${VCPKG_DETECTED_CMAKE_C_FLAGS_${buildtype}}"
"QMAKE_CXXFLAGS_${buildtype}*=${VCPKG_DETECTED_CMAKE_CXX_FLAGS_${buildtype}}"
"QMAKE_LFLAGS*=${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${buildtype}}"
"QMAKE_LFLAGS_DLL*=${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_${buildtype}}"
"QMAKE_LFLAGS_EXE*=${VCPKG_DETECTED_CMAKE_EXE_LINKER_FLAGS_${buildtype}}"
"QMAKE_RC+=${VCPKG_COMBINED_RC_FLAGS_${buildtype}}"
"QMAKE_CFLAGS_${buildtype}*=${VCPKG_COMBINED_C_FLAGS_${buildtype}}"
"QMAKE_CXXFLAGS_${buildtype}*=${VCPKG_COMBINED_CXX_FLAGS_${buildtype}}"
"QMAKE_LFLAGS*=${VCPKG_COMBINED_SHARED_LINKER_FLAGS_${buildtype}}"
"QMAKE_LIBFLAGS*=${VCPKG_COMBINED_STATIC_LINKER_FLAGS_${buildtype}}"
"QMAKE_LFLAGS_EXE*=${VCPKG_COMBINED_EXE_LINKER_FLAGS_${buildtype}}"
)
message(STATUS "Configuring ${config_triplet}")

5
versions/b-/boost-modular-build-helper.json
View File

@ -1,5 +1,10 @@
{
"versions": [
{
"git-tree": "ee3c3c2a3ecfb2bcff50d0758da7d6c36479a3c4",
"version": "1.78.0",
"port-version": 3
},
{
"git-tree": "9400b3bfdc93a165b3b509a76c59107c020113a6",
"version": "1.78.0",

8
versions/baseline.json
View File

@ -822,7 +822,7 @@
},
"boost-modular-build-helper": {
"baseline": "1.78.0",
"port-version": 2
"port-version": 3
},
"boost-move": {
"baseline": "1.78.0",
@ -2178,7 +2178,7 @@
},
"ffmpeg": {
"baseline": "4.4.1",
"port-version": 10
"port-version": 11
},
"ffnvcodec": {
"baseline": "11.1.5.0",
@ -7261,7 +7261,7 @@
"port-version": 1
},
"vcpkg-cmake": {
"baseline": "2022-01-19",
"baseline": "2022-02-14",
"port-version": 0
},
"vcpkg-cmake-config": {
@ -7281,7 +7281,7 @@
"port-version": 0
},
"vcpkg-qmake": {
"baseline": "2021-10-23",
"baseline": "2022-02-14",
"port-version": 0
},
"vcpkg-tool-gyp-nss": {

5
versions/f-/ffmpeg.json
View File

@ -1,5 +1,10 @@
{
"versions": [
{
"git-tree": "4be11b342853200f575143c5bb5353b044621293",
"version": "4.4.1",
"port-version": 11
},
{
"git-tree": "d525f98e7146a1fd731febe7c472232142d62821",
"version": "4.4.1",

5
versions/v-/vcpkg-cmake.json
View File

@ -1,5 +1,10 @@
{
"versions": [
{
"git-tree": "bdfdf28cf28bc07d02af864315ca291dcfae180b",
"version-date": "2022-02-14",
"port-version": 0
},
{
"git-tree": "b7c050fe60f91dcedef6d87a3f87584151bf8aee",
"version-date": "2022-01-19",

5
versions/v-/vcpkg-qmake.json
View File

@ -1,5 +1,10 @@
{
"versions": [
{
"git-tree": "5096e32d02b21d8f2546edf3829cbb8ee2d50425",
"version-date": "2022-02-14",
"port-version": 0
},
{
"git-tree": "1b1cd1cfcca489897822287c15af473fa4380cb1",
"version-date": "2021-10-23",