175 lines
No EOL
5.6 KiB
CMake
175 lines
No EOL
5.6 KiB
CMake
cmake_minimum_required(VERSION 3.21)
|
|
if(POLICY CMP0135) # remove if after cmake 3.23 is the minimum
|
|
cmake_policy(SET CMP0135 NEW)
|
|
endif()
|
|
|
|
macro(mesonify VAR DEST)
|
|
set(${DEST} "${${VAR}}")
|
|
separate_arguments(${DEST})
|
|
if (MSVC) # Fix compiler flags
|
|
list(TRANSFORM ${DEST} REPLACE "^\/" "-")
|
|
endif()
|
|
list(TRANSFORM ${DEST} REPLACE "(.+)" "\'\\1\'")
|
|
list(FILTER ${DEST} EXCLUDE REGEX "^$")
|
|
list(JOIN ${DEST} "," ${DEST})
|
|
set(${DEST} "[${${DEST}}]")
|
|
endmacro()
|
|
|
|
if (APPLE)
|
|
if(NOT DEFINED CMAKE_OBJC_COMPILER)
|
|
find_program(XCRUN_EXECUTABLE NAMES xcrun)
|
|
if (NOT XCRUN_EXECUTABLE)
|
|
message(FATAL_ERROR "xcrun executable is not found!")
|
|
endif()
|
|
execute_process(COMMAND ${XCRUN_EXECUTABLE} -find clang OUTPUT_VARIABLE XCRUN_OUTPUT)
|
|
string(STRIP ${XCRUN_OUTPUT} XCRUN_OUTPUT_STRIP)
|
|
set(CMAKE_OBJC_COMPILER ${XCRUN_OUTPUT_STRIP})
|
|
endif()
|
|
set(_objc_compiler "objc = ['${CMAKE_OBJC_COMPILER}'] + cross_compile_args")
|
|
endif()
|
|
|
|
if (ANDROID OR (CMAKE_CROSSCOMPILING AND NOT APPLE))
|
|
set(CROSS_COMPILE_FLAGS "--sysroot=${CMAKE_SYSROOT}")
|
|
set(CROSS_LINKER_FLAGS "--sysroot=${CMAKE_SYSROOT}")
|
|
elseif (APPLE)
|
|
set(CROSS_COMPILE_FLAGS "-isysroot ${CMAKE_OSX_SYSROOT}")
|
|
set(CROSS_LINKER_FLAGS "-isysroot ${CMAKE_OSX_SYSROOT}")
|
|
endif()
|
|
|
|
if (ANDROID OR CMAKE_CROSSCOMPILING)
|
|
set(CROSS_COMPILE_FLAGS "${CROSS_COMPILE_FLAGS} --target=${CMAKE_C_COMPILER_TARGET}")
|
|
set(CROSS_LINKER_FLAGS "${CROSS_EXE_LINKER_FLAGS} --target=${CMAKE_C_COMPILER_TARGET}")
|
|
endif()
|
|
|
|
if (ANDROID)
|
|
# Meson injects -D_FILE_OFFSET_BITS=64 which triggers off_t functions.
|
|
# Alternatively, increase API level to 24.
|
|
# set(CROSS_COMPILE_FLAGS "${CROSS_COMPILE_FLAGS} -D_LIBCPP_HAS_NO_OFF_T_FUNCTIONS")
|
|
endif()
|
|
|
|
if (CMAKE_OSX_ARCHITECTURES)
|
|
foreach(arch ${CMAKE_OSX_ARCHITECTURES})
|
|
string(APPEND CROSS_COMPILE_FLAGS_${arch} "${CROSS_COMPILE_FLAGS} -arch ${arch}")
|
|
endforeach()
|
|
endif()
|
|
|
|
mesonify(SECURITY_C_FLAGS _security_c_flags)
|
|
mesonify(SECURITY_CXX_FLAGS _security_cxx_flags)
|
|
mesonify(SECURITY_EXE_LINKER_FLAGS _security_exe_linker_flags)
|
|
mesonify(CROSS_COMPILE_FLAGS _cross_compile_flags)
|
|
mesonify(CROSS_LINKER_FLAGS _cross_linker_flags)
|
|
|
|
# Block any libraries not coming from our PATH when crosscompiling
|
|
if (UNIX AND CMAKE_CROSSCOMPILING)
|
|
set(_pkg_config_libdir "pkg_config_libdir = ''")
|
|
else()
|
|
# In Windows either we pick up the MSYS2 pkg-config
|
|
# or we ship our own, both use the correct architecture.
|
|
# Linux also uses the correct architecture.
|
|
set(_pkg_config_libdir)
|
|
endif()
|
|
|
|
include(TestBigEndian)
|
|
test_big_endian(IS_ENDIAN)
|
|
set(CROSSCOMPILING REQUIRED)
|
|
|
|
if (IS_ENDIAN)
|
|
set(_endian "big")
|
|
else()
|
|
set(_endian "little")
|
|
endif()
|
|
|
|
string(TOLOWER ${CMAKE_SYSTEM_NAME} _system_name)
|
|
|
|
if (ANDROID OR CMAKE_CROSSCOMPILING)
|
|
set(EXTRA_MESON_FLAGS
|
|
--cross-file=${CMAKE_CURRENT_BINARY_DIR}/meson-compiler.ini
|
|
--cross-file=${CMAKE_CURRENT_BINARY_DIR}/meson-host.ini
|
|
)
|
|
set(CROSSCOMPILING REQUIRED)
|
|
else()
|
|
set(EXTRA_MESON_FLAGS
|
|
--native-file=${CMAKE_CURRENT_BINARY_DIR}/meson-compiler.ini
|
|
)
|
|
set(CROSSCOMPILING)
|
|
endif()
|
|
|
|
set(EXTRA_MESON_FLAGS ${EXTRA_MESON_FLAGS} -Dpkgconfig.relocatable=true)
|
|
|
|
if (MSVC)
|
|
set(_c_ld "c_ld = ['${CMAKE_LINKER}'] + cross_link_args")
|
|
set(_cpp_ld "cpp_ld = ['${CMAKE_LINKER}'] + cross_link_args")
|
|
endif()
|
|
|
|
if (NOT MESON_BINARY_PATH)
|
|
find_program(Meson_EXECUTABLE meson)
|
|
|
|
if (Meson_EXECUTABLE)
|
|
execute_process(COMMAND meson --version OUTPUT_VARIABLE Meson_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE)
|
|
|
|
message(STATUS "Found meson (${Meson_VERSION}): ${Meson_EXECUTABLE}")
|
|
|
|
if (${Meson_VERSION} VERSION_LESS "1.1.0")
|
|
message(FATAL_ERROR "Meson executable is too old! Krita requires at least meson 1.1.0")
|
|
endif()
|
|
|
|
set(MESON_BINARY_PATH ${Meson_EXECUTABLE})
|
|
else()
|
|
set(MESON_BINARY_PATH ${EXTPREFIX}/bin/meson)
|
|
message(STATUS "Meson not available, using 3rdparty version.")
|
|
|
|
if (NOT EXISTS ${MESON_BINARY_PATH})
|
|
message(FATAL_ERROR "Meson executable is not found in 3rdparty install directory!")
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
set(MESON_NASM_PATH "${EXTPREFIX}/bin/nasm${CMAKE_EXECUTABLE_SUFFIX}")
|
|
|
|
find_package(PkgConfig)
|
|
|
|
if (NOT PKG_CONFIG_FOUND OR WIN32)
|
|
if (NOT WIN32)
|
|
set(PKG_CONFIG_EXECUTABLE ${EXTPREFIX}/bin/pkg-config)
|
|
else()
|
|
set(PKG_CONFIG_EXECUTABLE ${EXTPREFIX}/bin/pkgconf.exe)
|
|
endif()
|
|
|
|
if (NOT EXISTS ${PKG_CONFIG_EXECUTABLE})
|
|
message("WARNING: pkgconfig is NOT found in the 3rdparty prefix! This is normal only when builing pkgconfig itself.")
|
|
endif()
|
|
endif()
|
|
|
|
message(STATUS "Using pkgconfig at: ${PKG_CONFIG_EXECUTABLE}")
|
|
|
|
configure_file(
|
|
${CMAKE_CURRENT_LIST_DIR}/meson-compiler.ini.in
|
|
${CMAKE_CURRENT_BINARY_DIR}/meson-compiler.ini
|
|
)
|
|
|
|
# Meson's CPU family is a bit different from what
|
|
# Android SDK exports as CMAKE_SYSTEM_PROCESSOR
|
|
set (MESON_CPU_FAMILY ${CMAKE_SYSTEM_PROCESSOR})
|
|
if (${MESON_CPU_FAMILY} STREQUAL "armv7-a")
|
|
set(MESON_CPU_FAMILY "arm")
|
|
elseif (${MESON_CPU_FAMILY} STREQUAL "i686")
|
|
set(MESON_CPU_FAMILY "x86")
|
|
endif()
|
|
|
|
configure_file(
|
|
${CMAKE_CURRENT_LIST_DIR}/meson-host.ini.in
|
|
${CMAKE_CURRENT_BINARY_DIR}/meson-host.ini
|
|
)
|
|
|
|
# Prepare file for crosscompile multiple archs
|
|
if (CMAKE_OSX_ARCHITECTURES)
|
|
foreach(arch ${CMAKE_OSX_ARCHITECTURES})
|
|
if (NOT DEFINED ENV{FAKE_MACOS_ENVIRONMENT})
|
|
mesonify(CROSS_COMPILE_FLAGS_${arch} _cross_compile_flags)
|
|
endif()
|
|
configure_file(
|
|
${CMAKE_CURRENT_LIST_DIR}/meson-compiler.ini.in
|
|
${CMAKE_CURRENT_BINARY_DIR}/meson-compiler_${arch}.ini
|
|
)
|
|
endforeach()
|
|
endif() |