mirror of
https://github.com/microsoft/vcpkg.git
synced 2024-11-30 09:39:01 +08:00
9c63f97fa1
* [mesa] new port * make mesa build more. * more fine tuning * fix x86 * add supports. * comment about EGL feature. * apply suggestion from CR. added opengl feature. error on disabled shared glapi if multiple GL APIs are selected. * fix boolean option * make sharedgl-api=true the hardcoded default * add suggestion from CR * add mesa:x64-windows-static=fail to ci.baseline.txt due to static crt and parts being a dynamic library. * apply CR sugesstion Co-authored-by: PhoebeHui <20694052+PhoebeHui@users.noreply.github.com>
516 lines
24 KiB
CMake
516 lines
24 KiB
CMake
#[===[.md:
|
|
# vcpkg_configure_meson
|
|
|
|
Configure Meson for Debug and Release builds of a project.
|
|
|
|
## Usage
|
|
```cmake
|
|
vcpkg_configure_meson(
|
|
SOURCE_PATH <${SOURCE_PATH}>
|
|
[OPTIONS <-DUSE_THIS_IN_ALL_BUILDS=1>...]
|
|
[OPTIONS_RELEASE <-DOPTIMIZE=1>...]
|
|
[OPTIONS_DEBUG <-DDEBUGGABLE=1>...]
|
|
)
|
|
```
|
|
|
|
## Parameters
|
|
### SOURCE_PATH
|
|
Specifies the directory containing the `meson.build`.
|
|
By convention, this is usually set in the portfile as the variable `SOURCE_PATH`.
|
|
|
|
### OPTIONS
|
|
Additional options passed to Meson during the configuration.
|
|
|
|
### OPTIONS_RELEASE
|
|
Additional options passed to Meson during the Release configuration. These are in addition to `OPTIONS`.
|
|
|
|
### OPTIONS_DEBUG
|
|
Additional options passed to Meson during the Debug configuration. These are in addition to `OPTIONS`.
|
|
|
|
## Notes
|
|
This command supplies many common arguments to Meson. To see the full list, examine the source.
|
|
|
|
## Examples
|
|
|
|
* [fribidi](https://github.com/Microsoft/vcpkg/blob/master/ports/fribidi/portfile.cmake)
|
|
* [libepoxy](https://github.com/Microsoft/vcpkg/blob/master/ports/libepoxy/portfile.cmake)
|
|
#]===]
|
|
|
|
function(vcpkg_internal_meson_generate_native_file _additional_binaries) #https://mesonbuild.com/Native-environments.html
|
|
set(NATIVE "[binaries]\n")
|
|
#set(proglist AR RANLIB STRIP NM OBJDUMP DLLTOOL MT)
|
|
if(VCPKG_TARGET_IS_WINDOWS)
|
|
set(proglist MT)
|
|
else()
|
|
set(proglist AR RANLIB STRIP NM OBJDUMP DLLTOOL MT)
|
|
endif()
|
|
foreach(prog IN LISTS proglist)
|
|
if(VCPKG_DETECTED_CMAKE_${prog})
|
|
string(TOLOWER "${prog}" proglower)
|
|
string(APPEND NATIVE "${proglower} = '${VCPKG_DETECTED_CMAKE_${prog}}'\n")
|
|
endif()
|
|
endforeach()
|
|
set(compiler C CXX RC)
|
|
foreach(prog IN LISTS compiler)
|
|
if(VCPKG_DETECTED_CMAKE_${prog}_COMPILER)
|
|
string(REPLACE "CXX" "CPP" mesonprog "${prog}")
|
|
string(TOLOWER "${mesonprog}" proglower)
|
|
string(APPEND NATIVE "${proglower} = '${VCPKG_DETECTED_CMAKE_${prog}_COMPILER}'\n")
|
|
endif()
|
|
endforeach()
|
|
if(VCPKG_DETECTED_CMAKE_LINKER AND VCPKG_TARGET_IS_WINDOWS)
|
|
string(APPEND NATIVE "c_ld = '${VCPKG_DETECTED_CMAKE_LINKER}'\n")
|
|
string(APPEND NATIVE "cpp_ld = '${VCPKG_DETECTED_CMAKE_LINKER}'\n")
|
|
endif()
|
|
string(APPEND NATIVE "cmake = '${CMAKE_COMMAND}'\n")
|
|
foreach(_binary IN LISTS ${_additional_binaries})
|
|
string(APPEND NATIVE "${_binary}\n")
|
|
endforeach()
|
|
|
|
string(APPEND NATIVE "[built-in options]\n") #https://mesonbuild.com/Builtin-options.html
|
|
if(VCPKG_DETECTED_CMAKE_C_COMPILER MATCHES "cl.exe")
|
|
string(APPEND NATIVE "cpp_eh='none'\n") # To make sure meson is not adding eh flags by itself using msvc
|
|
endif()
|
|
if(VCPKG_TARGET_IS_WINDOWS)
|
|
string(REGEX REPLACE "( |^)(-|/)" ";\\2" WIN_C_STANDARD_LIBRARIES "${VCPKG_DETECTED_CMAKE_C_STANDARD_LIBRARIES}")
|
|
string(REGEX REPLACE "\\.lib " ".lib;" WIN_C_STANDARD_LIBRARIES "${WIN_C_STANDARD_LIBRARIES}")
|
|
list(TRANSFORM WIN_C_STANDARD_LIBRARIES APPEND "'")
|
|
list(TRANSFORM WIN_C_STANDARD_LIBRARIES PREPEND "'")
|
|
list(JOIN WIN_C_STANDARD_LIBRARIES ", " WIN_C_STANDARD_LIBRARIES)
|
|
string(APPEND NATIVE "c_winlibs = [${WIN_C_STANDARD_LIBRARIES}]\n")
|
|
string(REGEX REPLACE "( |^)(-|/)" ";\\2" WIN_CXX_STANDARD_LIBRARIES "${VCPKG_DETECTED_CMAKE_CXX_STANDARD_LIBRARIES}")
|
|
string(REGEX REPLACE "\\.lib " ".lib;" WIN_CXX_STANDARD_LIBRARIES "${WIN_CXX_STANDARD_LIBRARIES}")
|
|
list(TRANSFORM WIN_CXX_STANDARD_LIBRARIES APPEND "'")
|
|
list(TRANSFORM WIN_CXX_STANDARD_LIBRARIES PREPEND "'")
|
|
list(JOIN WIN_CXX_STANDARD_LIBRARIES ", " WIN_CXX_STANDARD_LIBRARIES)
|
|
string(APPEND NATIVE "cpp_winlibs = [${WIN_CXX_STANDARD_LIBRARIES}]\n")
|
|
endif()
|
|
|
|
set(_file "${CURRENT_BUILDTREES_DIR}/meson-nativ-${TARGET_TRIPLET}.log")
|
|
set(VCPKG_MESON_NATIVE_FILE "${_file}" PARENT_SCOPE)
|
|
file(WRITE "${_file}" "${NATIVE}")
|
|
endfunction()
|
|
|
|
function(vcpkg_internal_meson_generate_native_file_config _config) #https://mesonbuild.com/Native-environments.html
|
|
if(VCPKG_TARGET_IS_WINDOWS)
|
|
set(L_FLAG /LIBPATH:)
|
|
else()
|
|
set(L_FLAG -L)
|
|
endif()
|
|
set(PATH_SUFFIX_DEBUG /debug)
|
|
set(LIBPATH_${_config} "'${L_FLAG}${CURRENT_INSTALLED_DIR}${PATH_SUFFIX_${_config}}/lib'")
|
|
|
|
set(NATIVE_${_config} "[properties]\n") #https://mesonbuild.com/Builtin-options.html
|
|
string(REGEX REPLACE "( |^)(-|/)" ";\\2" MESON_CFLAGS_${_config} "${VCPKG_DETECTED_CMAKE_C_FLAGS_${_config}}")
|
|
list(TRANSFORM MESON_CFLAGS_${_config} APPEND "'")
|
|
list(TRANSFORM MESON_CFLAGS_${_config} PREPEND "'")
|
|
#list(APPEND MESON_CFLAGS_${_config} "${LIBPATH_${_config}}")
|
|
list(APPEND MESON_CFLAGS_${_config} "'-I${CURRENT_INSTALLED_DIR}/include'")
|
|
list(JOIN MESON_CFLAGS_${_config} ", " MESON_CFLAGS_${_config})
|
|
string(REPLACE "'', " "" MESON_CFLAGS_${_config} "${MESON_CFLAGS_${_config}}")
|
|
string(APPEND NATIVE_${_config} "c_args = [${MESON_CFLAGS_${_config}}]\n")
|
|
string(REGEX REPLACE "( |^)(-|/)" ";\\2" MESON_CXXFLAGS_${_config} "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_${_config}}")
|
|
list(TRANSFORM MESON_CXXFLAGS_${_config} APPEND "'")
|
|
list(TRANSFORM MESON_CXXFLAGS_${_config} PREPEND "'")
|
|
#list(APPEND MESON_CXXFLAGS_${_config} "${LIBPATH_${_config}}")
|
|
list(APPEND MESON_CXXFLAGS_${_config} "'-I${CURRENT_INSTALLED_DIR}/include'")
|
|
list(JOIN MESON_CXXFLAGS_${_config} ", " MESON_CXXFLAGS_${_config})
|
|
string(REPLACE "'', " "" MESON_CXXFLAGS_${_config} "${MESON_CXXFLAGS_${_config}}")
|
|
string(APPEND NATIVE_${_config} "cpp_args = [${MESON_CXXFLAGS_${_config}}]\n")
|
|
|
|
if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic")
|
|
set(LINKER_FLAGS_${_config} "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_${_config}}")
|
|
else()
|
|
set(LINKER_FLAGS_${_config} "${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${_config}}")
|
|
endif()
|
|
string(REGEX REPLACE "( |^)(-|/)" ";\\2" LINKER_FLAGS_${_config} "${LINKER_FLAGS_${_config}}")
|
|
list(TRANSFORM LINKER_FLAGS_${_config} APPEND "'")
|
|
list(TRANSFORM LINKER_FLAGS_${_config} PREPEND "'")
|
|
list(APPEND LINKER_FLAGS_${_config} "${LIBPATH_${_config}}")
|
|
list(JOIN LINKER_FLAGS_${_config} ", " LINKER_FLAGS_${_config})
|
|
string(REPLACE "'', " "" LINKER_FLAGS_${_config} "${LINKER_FLAGS_${_config}}")
|
|
string(APPEND NATIVE_${_config} "c_link_args = [${LINKER_FLAGS_${_config}}]\n")
|
|
string(APPEND NATIVE_${_config} "cpp_link_args = [${LINKER_FLAGS_${_config}}]\n")
|
|
|
|
#Setup CMake properties
|
|
string(APPEND NATIVE_${_config} "cmake_toolchain_file = '${SCRIPTS}/buildsystems/vcpkg.cmake'\n")
|
|
string(APPEND NATIVE_${_config} "[cmake]\n")
|
|
|
|
if(NOT VCPKG_CHAINLOAD_TOOLCHAIN_FILE)
|
|
if(VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW)
|
|
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/windows.cmake")
|
|
elseif(VCPKG_TARGET_IS_LINUX)
|
|
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/linux.cmake")
|
|
elseif(VCPKG_TARGET_IS_ANDROID)
|
|
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/android.cmake")
|
|
elseif(VCPKG_TARGET_IS_OSX)
|
|
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/osx.cmake")
|
|
elseif(VCPKG_TARGET_IS_IOS)
|
|
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/ios.cmake")
|
|
elseif(VCPKG_TARGET_IS_FREEBSD)
|
|
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/freebsd.cmake")
|
|
elseif(VCPKG_TARGET_IS_OPENBSD)
|
|
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/openbsd.cmake")
|
|
elseif(VCPKG_TARGET_IS_MINGW)
|
|
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/mingw.cmake")
|
|
endif()
|
|
endif()
|
|
|
|
string(APPEND NATIVE_${_config} "VCPKG_TARGET_TRIPLET = '${TARGET_TRIPLET}'\n")
|
|
string(APPEND NATIVE_${_config} "VCPKG_CHAINLOAD_TOOLCHAIN_FILE = '${VCPKG_CHAINLOAD_TOOLCHAIN_FILE}'\n")
|
|
string(APPEND NATIVE_${_config} "VCPKG_CRT_LINKAGE = '${VCPKG_CRT_LINKAGE}'\n")
|
|
|
|
string(APPEND NATIVE_${_config} "[built-in options]\n")
|
|
if(VCPKG_TARGET_IS_WINDOWS)
|
|
if(VCPKG_CRT_LINKAGE STREQUAL "static")
|
|
set(CRT mt)
|
|
else()
|
|
set(CRT md)
|
|
endif()
|
|
if(${_config} STREQUAL DEBUG)
|
|
set(CRT ${CRT}d)
|
|
endif()
|
|
string(APPEND NATIVE_${_config} "b_vscrt = '${CRT}'\n")
|
|
endif()
|
|
string(TOLOWER "${_config}" lowerconfig)
|
|
set(_file "${CURRENT_BUILDTREES_DIR}/meson-nativ-${TARGET_TRIPLET}-${lowerconfig}.log")
|
|
set(VCPKG_MESON_NATIVE_FILE_${_config} "${_file}" PARENT_SCOPE)
|
|
file(WRITE "${_file}" "${NATIVE_${_config}}")
|
|
endfunction()
|
|
|
|
function(vcpkg_internal_meson_generate_cross_file _additional_binaries) #https://mesonbuild.com/Cross-compilation.html
|
|
if(CMAKE_HOST_WIN32)
|
|
if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
|
|
set(BUILD_ARCH $ENV{PROCESSOR_ARCHITEW6432})
|
|
else()
|
|
set(BUILD_ARCH $ENV{PROCESSOR_ARCHITECTURE})
|
|
endif()
|
|
if(BUILD_ARCH MATCHES "(amd|AMD)64")
|
|
set(BUILD_CPU_FAM x86_x64)
|
|
set(BUILD_CPU x86_x64)
|
|
elseif(BUILD_ARCH MATCHES "(x|X)86")
|
|
set(BUILD_CPU_FAM x86)
|
|
set(BUILD_CPU i686)
|
|
elseif(BUILD_ARCH MATCHES "^(ARM|arm)64$")
|
|
set(BUILD_CPU_FAM aarch64)
|
|
set(BUILD_CPU armv8)
|
|
elseif(BUILD_ARCH MATCHES "^(ARM|arm)$")
|
|
set(BUILD_CPU_FAM arm)
|
|
set(BUILD_CPU armv7hl)
|
|
else()
|
|
message(FATAL_ERROR "Unsupported host architecture ${BUILD_ARCH}!" )
|
|
endif()
|
|
else() # TODO: add correct detection for OSX and Linux. Currently only x64 triplets are available in official vcpkg.
|
|
set(BUILD_CPU_FAM x86_x64)
|
|
set(BUILD_CPU x86_x64)
|
|
endif()
|
|
|
|
if(VCPKG_TARGET_ARCHITECTURE MATCHES "(amd|AMD|x|X)64")
|
|
set(HOST_CPU_FAM x86_x64)
|
|
set(HOST_CPU x86_x64)
|
|
elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "(x|X)86")
|
|
set(HOST_CPU_FAM x86)
|
|
set(HOST_CPU i686)
|
|
elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)64$")
|
|
set(HOST_CPU_FAM aarch64)
|
|
set(HOST_CPU armv8)
|
|
elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)$")
|
|
set(HOST_CPU_FAM arm)
|
|
set(HOST_CPU armv7hl)
|
|
else()
|
|
message(FATAL_ERROR "Unsupported target architecture ${VCPKG_TARGET_ARCHITECTURE}!" )
|
|
endif()
|
|
set(CROSS "[binaries]\n")
|
|
if(VCPKG_TARGET_IS_WINDOWS)
|
|
set(proglist MT)
|
|
else()
|
|
set(proglist AR RANLIB STRIP NM OBJDUMP DLLTOOL MT)
|
|
endif()
|
|
foreach(prog IN LISTS proglist)
|
|
if(VCPKG_DETECTED_CMAKE_${prog})
|
|
string(TOLOWER "${prog}" proglower)
|
|
string(APPEND CROSS "${proglower} = '${VCPKG_DETECTED_CMAKE_${prog}}'\n")
|
|
endif()
|
|
endforeach()
|
|
set(compiler C CXX RC)
|
|
foreach(prog IN LISTS compiler)
|
|
if(VCPKG_DETECTED_CMAKE_${prog}_COMPILER)
|
|
string(REPLACE "CXX" "CPP" mesonprog "${prog}")
|
|
string(TOLOWER "${mesonprog}" proglower)
|
|
string(APPEND CROSS "${proglower} = '${VCPKG_DETECTED_CMAKE_${prog}_COMPILER}'\n")
|
|
endif()
|
|
endforeach()
|
|
if(VCPKG_DETECTED_CMAKE_LINKER AND VCPKG_TARGET_IS_WINDOWS)
|
|
string(APPEND CROSS "c_ld = '${VCPKG_DETECTED_CMAKE_LINKER}'\n")
|
|
string(APPEND CROSS "cpp_ld = '${VCPKG_DETECTED_CMAKE_LINKER}'\n")
|
|
endif()
|
|
foreach(_binary IN LISTS ${_additional_binaries})
|
|
string(APPEND CROSS "${_binary}\n")
|
|
endforeach()
|
|
|
|
string(APPEND CROSS "[properties]\n")
|
|
string(APPEND CROSS "skip_sanity_check = true\n")
|
|
string(APPEND CROSS "[host_machine]\n")
|
|
string(APPEND CROSS "endian = 'little'\n")
|
|
if(NOT VCPKG_CMAKE_SYSTEM_NAME)
|
|
set(MESON_SYSTEM_NAME "windows")
|
|
else()
|
|
string(TOLOWER "${VCPKG_CMAKE_SYSTEM_NAME}" MESON_SYSTEM_NAME)
|
|
endif()
|
|
string(APPEND CROSS "system = '${MESON_SYSTEM_NAME}'\n")
|
|
string(APPEND CROSS "cpu_family = '${HOST_CPU_FAM}'\n")
|
|
string(APPEND CROSS "cpu = '${HOST_CPU}'\n")
|
|
|
|
string(APPEND CROSS "[build_machine]\n")
|
|
string(APPEND CROSS "endian = 'little'\n")
|
|
if(WIN32)
|
|
string(APPEND CROSS "system = 'windows'\n")
|
|
elseif(DARWIN)
|
|
string(APPEND CROSS "system = 'darwin'\n")
|
|
else()
|
|
string(APPEND CROSS "system = 'linux'\n")
|
|
endif()
|
|
string(APPEND CROSS "cpu_family = '${BUILD_CPU_FAM}'\n")
|
|
string(APPEND CROSS "cpu = '${BUILD_CPU}'\n")
|
|
|
|
if(NOT BUILD_CPU_FAM STREQUAL HOST_CPU_FAM)
|
|
set(_file "${CURRENT_BUILDTREES_DIR}/meson-cross-${TARGET_TRIPLET}.log")
|
|
set(VCPKG_MESON_CROSS_FILE "${_file}" PARENT_SCOPE)
|
|
file(WRITE "${_file}" "${CROSS}")
|
|
endif()
|
|
endfunction()
|
|
|
|
function(vcpkg_internal_meson_generate_cross_file_config _config) #https://mesonbuild.com/Native-environments.html
|
|
if(VCPKG_TARGET_IS_WINDOWS)
|
|
set(L_FLAG /LIBPATH:)
|
|
else()
|
|
set(L_FLAG -L)
|
|
endif()
|
|
set(PATH_SUFFIX_DEBUG /debug)
|
|
set(LIBPATH_${_config} "'${L_FLAG}${CURRENT_INSTALLED_DIR}${PATH_SUFFIX_${_config}}/lib'")
|
|
|
|
|
|
set(NATIVE_${_config} "[properties]\n") #https://mesonbuild.com/Builtin-options.html
|
|
string(REGEX REPLACE "( |^)(-|/)" ";\\2" MESON_CFLAGS_${_config} "${VCPKG_DETECTED_CMAKE_C_FLAGS_${_config}}")
|
|
list(TRANSFORM MESON_CFLAGS_${_config} APPEND "'")
|
|
list(TRANSFORM MESON_CFLAGS_${_config} PREPEND "'")
|
|
list(APPEND MESON_CFLAGS_${_config} "'-I\"${CURRENT_INSTALLED_DIR}/include\"'")
|
|
list(JOIN MESON_CFLAGS_${_config} ", " MESON_CFLAGS_${_config})
|
|
string(REPLACE "'', " "" MESON_CFLAGS_${_config} "${MESON_CFLAGS_${_config}}")
|
|
string(APPEND NATIVE_${_config} "c_args = [${MESON_CFLAGS_${_config}}]\n")
|
|
string(REGEX REPLACE "( |^)(-|/)" ";\\2" MESON_CXXFLAGS_${_config} "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_${_config}}")
|
|
list(TRANSFORM MESON_CXXFLAGS_${_config} APPEND "'")
|
|
list(TRANSFORM MESON_CXXFLAGS_${_config} PREPEND "'")
|
|
list(APPEND MESON_CXXFLAGS_${_config} "'-I\"${CURRENT_INSTALLED_DIR}/include\"'")
|
|
list(JOIN MESON_CXXFLAGS_${_config} ", " MESON_CXXFLAGS_${_config})
|
|
string(REPLACE "'', " "" MESON_CXXFLAGS_${_config} "${MESON_CXXFLAGS_${_config}}")
|
|
string(APPEND NATIVE_${_config} "cpp_args = [${MESON_CXXFLAGS_${_config}}]\n")
|
|
|
|
if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic")
|
|
set(LINKER_FLAGS_${_config} "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_${_config}}")
|
|
else()
|
|
set(LINKER_FLAGS_${_config} "${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${_config}}")
|
|
endif()
|
|
string(REGEX REPLACE "( |^)(-|/)" ";\\2" LINKER_FLAGS_${_config} "${LINKER_FLAGS_${_config}}")
|
|
list(TRANSFORM LINKER_FLAGS_${_config} APPEND "'")
|
|
list(TRANSFORM LINKER_FLAGS_${_config} PREPEND "'")
|
|
list(APPEND LINKER_FLAGS_${_config} "${LIBPATH_${_config}}")
|
|
list(JOIN LINKER_FLAGS_${_config} ", " LINKER_FLAGS_${_config})
|
|
string(REPLACE "'', " "" LINKER_FLAGS_${_config} "${LINKER_FLAGS_${_config}}")
|
|
string(APPEND NATIVE_${_config} "c_link_args = [${LINKER_FLAGS_${_config}}]\n")
|
|
string(APPEND NATIVE_${_config} "cpp_link_args = [${LINKER_FLAGS_${_config}}]\n")
|
|
|
|
string(APPEND NATIVE_${_config} "[built-in options]\n")
|
|
if(VCPKG_TARGET_IS_WINDOWS)
|
|
if(VCPKG_CRT_LINKAGE STREQUAL "static")
|
|
set(CRT mt)
|
|
else()
|
|
set(CRT md)
|
|
endif()
|
|
if(${_config} STREQUAL DEBUG)
|
|
set(CRT ${CRT}d)
|
|
endif()
|
|
string(APPEND NATIVE_${_config} "b_vscrt = '${CRT}'\n")
|
|
endif()
|
|
|
|
string(TOLOWER "${_config}" lowerconfig)
|
|
set(_file "${CURRENT_BUILDTREES_DIR}/meson-cross-${TARGET_TRIPLET}-${lowerconfig}.log")
|
|
set(VCPKG_MESON_CROSS_FILE_${_config} "${_file}" PARENT_SCOPE)
|
|
file(WRITE "${_file}" "${NATIVE_${_config}}")
|
|
endfunction()
|
|
|
|
|
|
function(vcpkg_configure_meson)
|
|
# parse parameters such that semicolons in options arguments to COMMAND don't get erased
|
|
cmake_parse_arguments(PARSE_ARGV 0 _vcm "" "SOURCE_PATH" "OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE;ADDITIONAL_NATIVE_BINARIES;ADDITIONAL_CROSS_BINARIES")
|
|
|
|
file(REMOVE_RECURSE ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel)
|
|
file(REMOVE_RECURSE ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg)
|
|
|
|
vcpkg_internal_get_cmake_vars(OUTPUT_FILE _VCPKG_CMAKE_VARS_FILE)
|
|
set(_VCPKG_CMAKE_VARS_FILE "${_VCPKG_CMAKE_VARS_FILE}" PARENT_SCOPE)
|
|
debug_message("Including cmake vars from: ${_VCPKG_CMAKE_VARS_FILE}")
|
|
include("${_VCPKG_CMAKE_VARS_FILE}")
|
|
|
|
vcpkg_find_acquire_program(PYTHON3)
|
|
get_filename_component(PYTHON3_DIR "${PYTHON3}" DIRECTORY)
|
|
vcpkg_add_to_path("${PYTHON3_DIR}")
|
|
list(APPEND _vcm_ADDITIONAL_NATIVE_BINARIES "python = '${PYTHON3}'")
|
|
list(APPEND _vcm_ADDITIONAL_CROSS_BINARIES "python = '${PYTHON3}'")
|
|
|
|
vcpkg_find_acquire_program(MESON)
|
|
|
|
get_filename_component(CMAKE_PATH ${CMAKE_COMMAND} DIRECTORY)
|
|
vcpkg_add_to_path("${CMAKE_PATH}") # Make CMake invokeable for Meson
|
|
|
|
vcpkg_find_acquire_program(NINJA)
|
|
get_filename_component(NINJA_PATH ${NINJA} DIRECTORY)
|
|
vcpkg_add_to_path(PREPEND "${NINJA_PATH}") # Need to prepend so that meson picks up the correct ninja from vcpkg ....
|
|
# list(APPEND _vcm_ADDITIONAL_NATIVE_BINARIES "ninja = '${NINJA}'") # This does not work due to meson issues ......
|
|
|
|
list(APPEND _vcm_OPTIONS --buildtype plain --backend ninja --wrap-mode nodownload)
|
|
|
|
if(NOT VCPKG_MESON_NATIVE_FILE)
|
|
vcpkg_internal_meson_generate_native_file("_vcm_ADDITIONAL_NATIVE_BINARIES")
|
|
endif()
|
|
if(NOT VCPKG_MESON_NATIVE_FILE_DEBUG)
|
|
vcpkg_internal_meson_generate_native_file_config(DEBUG)
|
|
endif()
|
|
if(NOT VCPKG_MESON_NATIVE_FILE_RELEASE)
|
|
vcpkg_internal_meson_generate_native_file_config(RELEASE)
|
|
endif()
|
|
list(APPEND _vcm_OPTIONS --native "${VCPKG_MESON_NATIVE_FILE}")
|
|
list(APPEND _vcm_OPTIONS_DEBUG --native "${VCPKG_MESON_NATIVE_FILE_DEBUG}")
|
|
list(APPEND _vcm_OPTIONS_RELEASE --native "${VCPKG_MESON_NATIVE_FILE_RELEASE}")
|
|
|
|
if(NOT VCPKG_MESON_CROSS_FILE)
|
|
vcpkg_internal_meson_generate_cross_file("_vcm_ADDITIONAL_CROSS_BINARIES")
|
|
endif()
|
|
if(NOT VCPKG_MESON_CROSS_FILE_DEBUG AND VCPKG_MESON_CROSS_FILE)
|
|
vcpkg_internal_meson_generate_cross_file_config(DEBUG)
|
|
endif()
|
|
if(NOT VCPKG_MESON_CROSS_FILE_RELEASE AND VCPKG_MESON_CROSS_FILE)
|
|
vcpkg_internal_meson_generate_cross_file_config(RELEASE)
|
|
endif()
|
|
if(VCPKG_MESON_CROSS_FILE)
|
|
list(APPEND _vcm_OPTIONS --cross "${VCPKG_MESON_CROSS_FILE}")
|
|
endif()
|
|
|
|
if(VCPKG_MESON_CROSS_FILE_DEBUG)
|
|
list(APPEND _vcm_OPTIONS_DEBUG --cross "${VCPKG_MESON_CROSS_FILE_DEBUG}")
|
|
endif()
|
|
if(VCPKG_MESON_CROSS_FILE_RELEASE)
|
|
list(APPEND _vcm_OPTIONS_RELEASE --cross "${VCPKG_MESON_CROSS_FILE_RELEASE}")
|
|
endif()
|
|
|
|
if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic")
|
|
list(APPEND _vcm_OPTIONS --default-library shared)
|
|
else()
|
|
list(APPEND _vcm_OPTIONS --default-library static)
|
|
endif()
|
|
|
|
list(APPEND _vcm_OPTIONS --libdir lib) # else meson install into an architecture describing folder
|
|
list(APPEND _vcm_OPTIONS_DEBUG -Ddebug=true --prefix ${CURRENT_PACKAGES_DIR}/debug --includedir ../include)
|
|
list(APPEND _vcm_OPTIONS_RELEASE -Ddebug=false --prefix ${CURRENT_PACKAGES_DIR})
|
|
|
|
# select meson cmd-line options
|
|
if(VCPKG_TARGET_IS_WINDOWS)
|
|
list(APPEND _vcm_OPTIONS_DEBUG "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/share']")
|
|
list(APPEND _vcm_OPTIONS_RELEASE "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}/share']")
|
|
else()
|
|
list(APPEND _vcm_OPTIONS_DEBUG "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}']")
|
|
list(APPEND _vcm_OPTIONS_RELEASE "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/debug']")
|
|
endif()
|
|
|
|
vcpkg_find_acquire_program(PKGCONFIG)
|
|
get_filename_component(PKGCONFIG_PATH ${PKGCONFIG} DIRECTORY)
|
|
vcpkg_add_to_path("${PKGCONFIG_PATH}")
|
|
set(PKGCONFIG_SHARE_DIR "${CURRENT_INSTALLED_DIR}/share/pkgconfig/")
|
|
|
|
set(buildtypes)
|
|
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
|
|
set(BUILDNAME DEBUG)
|
|
list(APPEND buildtypes ${BUILDNAME})
|
|
set(PATH_SUFFIX_${BUILDNAME} "debug/")
|
|
set(SUFFIX_${BUILDNAME} "dbg")
|
|
endif()
|
|
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
|
|
set(BUILDNAME RELEASE)
|
|
list(APPEND buildtypes ${BUILDNAME})
|
|
set(PATH_SUFFIX_${BUILDNAME} "")
|
|
set(SUFFIX_${BUILDNAME} "rel")
|
|
endif()
|
|
|
|
if(VCPKG_TARGET_IS_OSX)
|
|
if(DEFINED ENV{SDKROOT})
|
|
set(_VCPKG_ENV_SDKROOT_BACKUP $ENV{SDKROOT})
|
|
endif()
|
|
set(ENV{SDKROOT} "${VCPKG_DETECTED_CMAKE_OSX_SYSROOT}")
|
|
set(VCPKG_DETECTED_CMAKE_OSX_SYSROOT "${VCPKG_DETECTED_CMAKE_OSX_SYSROOT}" PARENT_SCOPE)
|
|
|
|
if(DEFINED ENV{MACOSX_DEPLOYMENT_TARGET})
|
|
set(_VCPKG_ENV_MACOSX_DEPLOYMENT_TARGET_BACKUP $ENV{MACOSX_DEPLOYMENT_TARGET})
|
|
endif()
|
|
set(ENV{MACOSX_DEPLOYMENT_TARGET} "${VCPKG_DETECTED_CMAKE_OSX_DEPLOYMENT_TARGET}")
|
|
set(VCPKG_DETECTED_CMAKE_OSX_DEPLOYMENT_TARGET "${VCPKG_DETECTED_CMAKE_OSX_DEPLOYMENT_TARGET}" PARENT_SCOPE)
|
|
endif()
|
|
|
|
if(DEFINED ENV{INCLUDE})
|
|
set(ENV{INCLUDE} "$ENV{INCLUDE}${VCPKG_HOST_PATH_SEPARATOR}${CURRENT_INSTALLED_DIR}/include")
|
|
else()
|
|
set(ENV{INCLUDE} "${CURRENT_INSTALLED_DIR}/include")
|
|
endif()
|
|
# configure build
|
|
foreach(buildtype IN LISTS buildtypes)
|
|
message(STATUS "Configuring ${TARGET_TRIPLET}-${SUFFIX_${buildtype}}")
|
|
file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SUFFIX_${buildtype}}")
|
|
#setting up PKGCONFIG
|
|
set(ENV{PKG_CONFIG} "${PKGCONFIG}") # Set via native file?
|
|
set(PKGCONFIG_INSTALLED_DIR "${CURRENT_INSTALLED_DIR}/${PATH_SUFFIX_${buildtype}}lib/pkgconfig/")
|
|
if(DEFINED ENV{PKG_CONFIG_PATH})
|
|
set(BACKUP_ENV_PKG_CONFIG_PATH_RELEASE $ENV{PKG_CONFIG_PATH})
|
|
set(ENV{PKG_CONFIG_PATH} "${PKGCONFIG_INSTALLED_DIR}${VCPKG_HOST_PATH_SEPARATOR}${PKGCONFIG_SHARE_DIR}${VCPKG_HOST_PATH_SEPARATOR}$ENV{PKG_CONFIG_PATH}")
|
|
else()
|
|
set(ENV{PKG_CONFIG_PATH} "${PKGCONFIG_INSTALLED_DIR}${VCPKG_HOST_PATH_SEPARATOR}${PKGCONFIG_SHARE_DIR}")
|
|
endif()
|
|
|
|
vcpkg_execute_required_process(
|
|
COMMAND ${MESON} ${_vcm_OPTIONS} ${_vcm_OPTIONS_${buildtype}} ${_vcm_SOURCE_PATH}
|
|
WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SUFFIX_${buildtype}}
|
|
LOGNAME config-${TARGET_TRIPLET}-${SUFFIX_${buildtype}}
|
|
)
|
|
|
|
#Copy meson log files into buildtree for CI
|
|
if(EXISTS "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SUFFIX_${buildtype}}/meson-logs/meson-log.txt")
|
|
file(COPY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SUFFIX_${buildtype}}/meson-logs/meson-log.txt" DESTINATION "${CURRENT_BUILDTREES_DIR}")
|
|
file(RENAME "${CURRENT_BUILDTREES_DIR}/meson-log.txt" "${CURRENT_BUILDTREES_DIR}/meson-log-${SUFFIX_${buildtype}}.txt")
|
|
endif()
|
|
if(EXISTS "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SUFFIX_${buildtype}}/meson-logs/install-log.txt")
|
|
file(COPY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SUFFIX_${buildtype}}/meson-logs/install-log.txt" DESTINATION "${CURRENT_BUILDTREES_DIR}")
|
|
file(RENAME "${CURRENT_BUILDTREES_DIR}/install-log.txt" "${CURRENT_BUILDTREES_DIR}/install-log-${SUFFIX_${buildtype}}.txt")
|
|
endif()
|
|
message(STATUS "Configuring ${TARGET_TRIPLET}-${SUFFIX_${buildtype}} done")
|
|
|
|
#Restore PKG_CONFIG_PATH
|
|
if(BACKUP_ENV_PKG_CONFIG_PATH_${buildtype})
|
|
set(ENV{PKG_CONFIG_PATH} "${BACKUP_ENV_PKG_CONFIG_PATH_${buildtype}}")
|
|
unset(BACKUP_ENV_PKG_CONFIG_PATH_${buildtype})
|
|
else()
|
|
unset(ENV{PKG_CONFIG_PATH})
|
|
endif()
|
|
endforeach()
|
|
|
|
if(VCPKG_TARGET_IS_OSX)
|
|
if(DEFINED _VCPKG_ENV_SDKROOT_BACKUP)
|
|
set(ENV{SDKROOT} "${_VCPKG_ENV_SDKROOT_BACKUP}")
|
|
else()
|
|
unset(ENV{SDKROOT})
|
|
endif()
|
|
if(DEFINED _VCPKG_ENV_MACOSX_DEPLOYMENT_TARGET_BACKUP)
|
|
set(ENV{MACOSX_DEPLOYMENT_TARGET} "${_VCPKG_ENV_MACOSX_DEPLOYMENT_TARGET_BACKUP}")
|
|
else()
|
|
unset(ENV{MACOSX_DEPLOYMENT_TARGET})
|
|
endif()
|
|
endif()
|
|
endfunction()
|