You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
477 lines
17 KiB
477 lines
17 KiB
cmake_minimum_required(VERSION 3.3.0 FATAL_ERROR)
|
|
|
|
# prevent multiple inclusion
|
|
if (DEFINED THIRD_PARTY_MODULE_LOADED)
|
|
return()
|
|
endif ()
|
|
set(THIRD_PARTY_MODULE_LOADED YES)
|
|
|
|
cmake_policy(SET CMP0067 NEW) # make check_cxx_source_compiles() pick up the variables for the C++ version
|
|
include(CheckCXXSourceCompiles)
|
|
|
|
macro (save_default_library_suffixes)
|
|
set(DEFAULT_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
|
|
endmacro ()
|
|
|
|
macro (restore_default_library_suffixes)
|
|
set(CMAKE_FIND_LIBRARY_SUFFIXES ${DEFAULT_CMAKE_FIND_LIBRARY_SUFFIXES})
|
|
unset(DEFAULT_CMAKE_FIND_LIBRARY_SUFFIXES)
|
|
endmacro ()
|
|
|
|
macro (configure_static_library_suffixes)
|
|
# allows to look for static libraries in particular NOTE: code duplicated in Config.cmake.in
|
|
if (WIN32)
|
|
set(CMAKE_FIND_LIBRARY_SUFFIXES .a .lib)
|
|
else ()
|
|
set(CMAKE_FIND_LIBRARY_SUFFIXES .a)
|
|
endif ()
|
|
endmacro ()
|
|
|
|
macro (configure_dynamic_library_suffixes)
|
|
# allows to look for dynamic libraries in particular
|
|
if (WIN32)
|
|
set(CMAKE_FIND_LIBRARY_SUFFIXES .dll .dll.a)
|
|
elseif (APPLE)
|
|
set(CMAKE_FIND_LIBRARY_SUFFIXES .dylib .so)
|
|
else ()
|
|
set(CMAKE_FIND_LIBRARY_SUFFIXES .so)
|
|
endif ()
|
|
endmacro ()
|
|
|
|
function (validate_visibility VISIBILITY)
|
|
if (NOT (VISIBILITY STREQUAL PUBLIC OR VISIBILITY STREQUAL PRIVATE))
|
|
message(FATAL_ERROR "Specified visibility ${VISIBILITY} is invalid (must be either PUBLIC or PRIVATE).")
|
|
endif ()
|
|
endfunction ()
|
|
|
|
function (parse_arguments_for_use_functions)
|
|
# parse arguments
|
|
set(OPTIONAL_ARGS OPTIONAL ONLY_HEADERS)
|
|
set(ONE_VALUE_ARGS VISIBILITY LIBRARIES_VARIABLE PACKAGES_VARIABLE PKG_CONFIG_MODULES_VARIABLE TARGET_NAME PACKAGE_NAME)
|
|
set(MULTI_VALUE_ARGS PKG_CONFIG_MODULES PACKAGE_ARGS)
|
|
cmake_parse_arguments(ARGS "${OPTIONAL_ARGS}" "${ONE_VALUE_ARGS}" "${MULTI_VALUE_ARGS}" ${ARGN})
|
|
|
|
# validate values
|
|
if (ARGS_VISIBILITY)
|
|
validate_visibility(${ARGS_VISIBILITY})
|
|
else ()
|
|
set(ARGS_VISIBILITY PRIVATE)
|
|
endif ()
|
|
|
|
if (NOT ARGS_LIBRARIES_VARIABLE)
|
|
set(ARGS_LIBRARIES_VARIABLE "${ARGS_VISIBILITY}_LIBRARIES")
|
|
endif ()
|
|
if (NOT ARGS_PACKAGES_VARIABLE)
|
|
if (NOT BUILD_SHARED_LIBS OR VISIBILITY STREQUAL PUBLIC)
|
|
set(ARGS_PACKAGES_VARIABLE "INTERFACE_REQUIRED_PACKAGES")
|
|
else ()
|
|
set(ARGS_PACKAGES_VARIABLE "REQUIRED_PACKAGES")
|
|
endif ()
|
|
endif ()
|
|
if (NOT ARGS_PKG_CONFIG_MODULES_VARIABLE)
|
|
if (NOT BUILD_SHARED_LIBS OR VISIBILITY STREQUAL PUBLIC)
|
|
set(ARGS_PKG_CONFIG_MODULES_VARIABLE "INTERFACE_REQUIRED_PKG_CONFIG_MODULES")
|
|
else ()
|
|
set(ARGS_PKG_CONFIG_MODULES_VARIABLE "REQUIRED_PKG_CONFIG_MODULES")
|
|
endif ()
|
|
endif ()
|
|
|
|
# export parsed values to parent scope
|
|
set(ARGS_VISIBILITY
|
|
"${ARGS_VISIBILITY}"
|
|
PARENT_SCOPE)
|
|
set(ARGS_LIBRARIES_VARIABLE
|
|
"${ARGS_LIBRARIES_VARIABLE}"
|
|
PARENT_SCOPE)
|
|
set(ARGS_PACKAGES_VARIABLE
|
|
"${ARGS_PACKAGES_VARIABLE}"
|
|
PARENT_SCOPE)
|
|
set(ARGS_PKG_CONFIG_MODULES_VARIABLE
|
|
"${ARGS_PKG_CONFIG_MODULES_VARIABLE}"
|
|
PARENT_SCOPE)
|
|
set(ARGS_TARGET_NAME
|
|
"${ARGS_TARGET_NAME}"
|
|
PARENT_SCOPE)
|
|
set(ARGS_PACKAGE_NAME
|
|
"${ARGS_PACKAGE_NAME}"
|
|
PARENT_SCOPE)
|
|
set(ARGS_PACKAGE_ARGS
|
|
"${ARGS_PACKAGE_ARGS}"
|
|
PARENT_SCOPE)
|
|
set(ARGS_PKG_CONFIG_MODULES
|
|
"${ARGS_PKG_CONFIG_MODULES}"
|
|
PARENT_SCOPE)
|
|
set(ARGS_OPTIONAL
|
|
"${ARGS_OPTIONAL}"
|
|
PARENT_SCOPE)
|
|
set(ARGS_ONLY_HEADERS
|
|
"${ARGS_ONLY_HEADERS}"
|
|
PARENT_SCOPE)
|
|
if (NOT ARGS_OPTIONAL)
|
|
set(ARGS_FIND_PACKAGE
|
|
"REQUIRED"
|
|
PARENT_SCOPE)
|
|
set(ARGS_PKG_CHECK_MODULES
|
|
"REQUIRED"
|
|
PARENT_SCOPE)
|
|
endif ()
|
|
endfunction ()
|
|
|
|
function (use_iconv)
|
|
parse_arguments_for_use_functions(${ARGN})
|
|
|
|
# check whether iconv from the standard library can be used
|
|
set(FORCE_EXTERNAL_ICONV
|
|
OFF
|
|
CACHE PATH "whether to force usage of external iconv (rather than the using the one bundled with glibc)")
|
|
if (NOT FORCE_EXTERNAL_ICONV)
|
|
# check whether iconv exists in standard lib
|
|
include(CheckFunctionExists)
|
|
check_function_exists(iconv HAS_ICONV)
|
|
endif ()
|
|
if (NOT FORCE_EXTERNAL_ICONV AND HAS_ICONV)
|
|
message(STATUS "Using iconv from the standard library for target ${META_PROJECT_NAME}.")
|
|
return()
|
|
endif ()
|
|
|
|
# find external iconv library
|
|
if (NOT TARGET Iconv::Iconv)
|
|
set(Iconv_IS_BUILT_IN FALSE)
|
|
find_package(Iconv ${ARGS_FIND_PACKAGE})
|
|
if (NOT Iconv_FOUND)
|
|
return()
|
|
endif ()
|
|
endif ()
|
|
|
|
set("${ARGS_LIBRARIES_VARIABLE}"
|
|
"${${ARGS_LIBRARIES_VARIABLE}};Iconv::Iconv"
|
|
PARENT_SCOPE)
|
|
set("${ARGS_PACKAGES_VARIABLE}"
|
|
"${${ARGS_PACKAGES_VARIABLE}};Iconv"
|
|
PARENT_SCOPE)
|
|
endfunction ()
|
|
|
|
macro (_cpp_utilities_use_openssl OPENSSL_TARGETS)
|
|
find_package(OpenSSL ${ARGS_FIND_PACKAGE})
|
|
if (NOT OpenSSL_FOUND)
|
|
message(STATUS "Unable to find OpenSSL")
|
|
return()
|
|
endif ()
|
|
foreach (OPENSSL_TARGET ${OPENSSL_TARGETS})
|
|
if (TARGET "${OPENSSL_TARGET}")
|
|
continue()
|
|
endif ()
|
|
set(MESSAGE_MODE WARNING)
|
|
if (REQUIRED IN_LIST ARGS_FIND_PACKAGE)
|
|
set(MESSAGE_MODE FATAL_ERROR)
|
|
endif ()
|
|
message(
|
|
"${MESSAGE_MODE}"
|
|
"Found OpenSSL but imported target \"${OPENSSL_TARGET}\" is missing. Possibly the devel package for OpenSSL is not installed."
|
|
)
|
|
return()
|
|
endforeach ()
|
|
|
|
message(STATUS "Found required OpenSSL targets (${OPENSSL_TARGETS})")
|
|
set("${ARGS_LIBRARIES_VARIABLE}" "${${ARGS_LIBRARIES_VARIABLE}};${OPENSSL_TARGETS}")
|
|
if (WIN32 AND OPENSSL_USE_STATIC_LIBS)
|
|
# FIXME: preferably use pkg-config to cover this case without hardcoding OpenSSL's dependencies under Windows
|
|
set("${ARGS_LIBRARIES_VARIABLE}" "${${ARGS_LIBRARIES_VARIABLE}};-lws2_32;-lgdi32;-lcrypt32")
|
|
endif ()
|
|
set("${ARGS_PACKAGES_VARIABLE}"
|
|
"${${ARGS_PACKAGES_VARIABLE}};OpenSSL"
|
|
PARENT_SCOPE)
|
|
set("${ARGS_LIBRARIES_VARIABLE}"
|
|
"${${ARGS_LIBRARIES_VARIABLE}}"
|
|
PARENT_SCOPE)
|
|
set("PKG_CONFIG_OpenSSL_Crypto"
|
|
"libcrypto"
|
|
PARENT_SCOPE)
|
|
endmacro ()
|
|
|
|
function (use_openssl)
|
|
parse_arguments_for_use_functions(${ARGN})
|
|
_cpp_utilities_use_openssl("OpenSSL::SSL;OpenSSL::Crypto")
|
|
set("PKG_CONFIG_OpenSSL_SSL"
|
|
"libssl"
|
|
PARENT_SCOPE)
|
|
|
|
endfunction ()
|
|
|
|
function (use_crypto)
|
|
parse_arguments_for_use_functions(${ARGN})
|
|
_cpp_utilities_use_openssl("OpenSSL::Crypto")
|
|
endfunction ()
|
|
|
|
function (use_zlib)
|
|
parse_arguments_for_use_functions(${ARGN})
|
|
|
|
find_package(ZLIB ${ARGS_FIND_PACKAGE})
|
|
if (NOT ZLIB_FOUND)
|
|
return()
|
|
endif ()
|
|
set("${ARGS_LIBRARIES_VARIABLE}"
|
|
"${${ARGS_LIBRARIES_VARIABLE}};ZLIB::ZLIB"
|
|
PARENT_SCOPE)
|
|
set("${ARGS_PACKAGES_VARIABLE}"
|
|
"${${ARGS_PACKAGES_VARIABLE}};ZLIB"
|
|
PARENT_SCOPE)
|
|
set("PKG_CONFIG_ZLIB_ZLIB"
|
|
"zlib"
|
|
PARENT_SCOPE)
|
|
endfunction ()
|
|
|
|
function (use_target)
|
|
parse_arguments_for_use_functions(${ARGN})
|
|
|
|
if (NOT TARGET "${ARGS_TARGET_NAME}")
|
|
if (ARGS_OPTIONAL)
|
|
return()
|
|
endif ()
|
|
message(FATAL_ERROR "Target \"${ARGS_TARGET_NAME}\" does not exist.")
|
|
endif ()
|
|
set("${ARGS_LIBRARIES_VARIABLE}"
|
|
"${${ARGS_LIBRARIES_VARIABLE}};${ARGS_TARGET_NAME}"
|
|
PARENT_SCOPE)
|
|
if (ARGS_PACKAGE_NAME)
|
|
set("${ARGS_PACKAGES_VARIABLE}"
|
|
"${${ARGS_PACKAGES_VARIABLE}};${ARGS_PACKAGE_NAME}"
|
|
PARENT_SCOPE)
|
|
if (ARGS_PACKAGE_ARGS)
|
|
set("PACKAGE_ARGS_${ARGS_PACKAGE_NAME}"
|
|
"${ARGS_PACKAGE_ARGS}"
|
|
PARENT_SCOPE)
|
|
endif ()
|
|
endif ()
|
|
endfunction ()
|
|
|
|
function (use_package)
|
|
parse_arguments_for_use_functions(${ARGN})
|
|
|
|
if (NOT ARGS_PACKAGE_NAME)
|
|
message(FATAL_ERROR "No PACKAGE_NAME specified.")
|
|
endif ()
|
|
if (NOT ARGS_TARGET_NAME)
|
|
message(FATAL_ERROR "No TARGET_NAME specified.")
|
|
endif ()
|
|
if (NOT ARGS_PACKAGE_ARGS)
|
|
set(ARGS_PACKAGE_ARGS ${ARGS_FIND_PACKAGE})
|
|
endif ()
|
|
|
|
find_package("${ARGS_PACKAGE_NAME}" ${ARGS_PACKAGE_ARGS})
|
|
if (NOT TARGET "${ARGS_TARGET_NAME}")
|
|
if (ARGS_OPTIONAL)
|
|
return()
|
|
endif ()
|
|
message(FATAL_ERROR "Found package \"${ARGS_PACKAGE_NAME}\" but target \"${ARGS_TARGET_NAME}\" does not exist.")
|
|
endif ()
|
|
set("${ARGS_LIBRARIES_VARIABLE}"
|
|
"${${ARGS_LIBRARIES_VARIABLE}};${ARGS_TARGET_NAME}"
|
|
PARENT_SCOPE)
|
|
set("${ARGS_PACKAGES_VARIABLE}"
|
|
"${${ARGS_PACKAGES_VARIABLE}};${ARGS_PACKAGE_NAME}"
|
|
PARENT_SCOPE)
|
|
set("PACKAGE_ARGS_${ARGS_PACKAGE_NAME}"
|
|
"${ARGS_PACKAGE_ARGS}"
|
|
PARENT_SCOPE)
|
|
endfunction ()
|
|
|
|
function (use_pkg_config_module)
|
|
# parse and validate arguments
|
|
parse_arguments_for_use_functions(${ARGN})
|
|
if (NOT ARGS_PKG_CONFIG_MODULES)
|
|
message(FATAL_ERROR "No pkg-config modules specified.")
|
|
endif ()
|
|
if (NOT ARGS_TARGET_NAME)
|
|
list(LENGTH ARGS_PKG_CONFIG_MODULES ARGS_PKG_CONFIG_MODULES_LENGTH)
|
|
if (ARGS_PKG_CONFIG_MODULES_LENGTH STREQUAL 1)
|
|
list(GET ARGS_PKG_CONFIG_MODULES 0 ARGS_TARGET_NAME)
|
|
else ()
|
|
message(FATAL_ERROR "No target name for multi-module pkg-config specified.")
|
|
endif ()
|
|
endif ()
|
|
|
|
# add target only if it has not already been added; otherwise just add the existing target to the library variable
|
|
if (NOT TARGET "${ARGS_TARGET_NAME}")
|
|
find_package(PkgConfig)
|
|
pkg_check_modules(PKG_CHECK_MODULES_RESULT ${ARGS_PKG_CHECK_MODULES} ${ARGS_PKG_CONFIG_MODULES})
|
|
|
|
# create interface library
|
|
add_library(${ARGS_TARGET_NAME} INTERFACE IMPORTED)
|
|
if (PKG_CONFIG_USE_STATIC_LIBS)
|
|
set(PKG_CONFIG_CHECK_SUFFIX "_STATIC")
|
|
else ()
|
|
set(PKG_CONFIG_CHECK_SUFFIX "")
|
|
endif ()
|
|
set_property(
|
|
TARGET ${ARGS_TARGET_NAME} PROPERTY INTERFACE_LINK_LIBRARIES
|
|
"${PKG_CHECK_MODULES_RESULT${PKG_CONFIG_CHECK_SUFFIX}_LINK_LIBRARIES}")
|
|
set_property(
|
|
TARGET ${ARGS_TARGET_NAME} PROPERTY INTERFACE_INCLUDE_DIRECTORIES
|
|
"${PKG_CHECK_MODULES_RESULT${PKG_CONFIG_CHECK_SUFFIX}_INCLUDE_DIRS}")
|
|
set_property(TARGET ${ARGS_TARGET_NAME}
|
|
PROPERTY INTERFACE_COMPILE_OPTIONS "${PKG_CHECK_MODULES_RESULT${PKG_CONFIG_CHECK_SUFFIX}_CFLAGS_OTHER}")
|
|
set_property(TARGET ${ARGS_TARGET_NAME}
|
|
PROPERTY INTERFACE_LINK_OPTIONS "${PKG_CHECK_MODULES_RESULT${PKG_CONFIG_CHECK_SUFFIX}_LDFLAGS_OTHER}")
|
|
endif ()
|
|
|
|
set("${ARGS_PKG_CONFIG_MODULES_VARIABLE}"
|
|
"${${ARGS_PKG_CONFIG_MODULES_VARIABLE}};${ARGS_TARGET_NAME}"
|
|
PARENT_SCOPE)
|
|
set("${ARGS_LIBRARIES_VARIABLE}"
|
|
"${${ARGS_LIBRARIES_VARIABLE}};${ARGS_TARGET_NAME}"
|
|
PARENT_SCOPE)
|
|
string(REPLACE "::" "_" TARGET_VARNAME "${ARGS_TARGET_NAME}")
|
|
set("PKG_CONFIG_${TARGET_VARNAME}"
|
|
"${ARGS_PKG_CONFIG_MODULES}"
|
|
PARENT_SCOPE)
|
|
endfunction ()
|
|
|
|
function (use_standard_filesystem)
|
|
# parse and validate arguments
|
|
parse_arguments_for_use_functions(${ARGN})
|
|
|
|
# set c++ standard for `check_cxx_source_compiles()`
|
|
set(CMAKE_CXX_STANDARD 17)
|
|
set(CMAKE_CXX_STANDARD_REQUIRED 17)
|
|
|
|
# check whether an additional library for std::filesystem support is required
|
|
set(TEST_PROGRAM
|
|
[[
|
|
#include <chrono>
|
|
#include <system_error>
|
|
#include <filesystem>
|
|
int main() {
|
|
auto ec = std::error_code();
|
|
const auto cwd = std::filesystem::current_path();
|
|
const auto t = std::filesystem::last_write_time(cwd, ec);
|
|
std::filesystem::last_write_time(cwd, t, ec);
|
|
return static_cast<int>(cwd.string().size());
|
|
}
|
|
]])
|
|
set(DEFAULT_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES})
|
|
set(REQUIRED_LIBRARY FAILED)
|
|
set(INDEX 0)
|
|
foreach (LIBRARY "" "stdc++fs" "c++fs")
|
|
if (NOT LIBRARY STREQUAL "")
|
|
set(CMAKE_REQUIRED_LIBRARIES ${DEFAULT_REQUIRED_LIBRARIES} -l${LIBRARY})
|
|
endif ()
|
|
check_cxx_source_compiles("${TEST_PROGRAM}" STD_FILESYSTEM_TEST_${INDEX})
|
|
if (STD_FILESYSTEM_TEST_${INDEX})
|
|
set(REQUIRED_LIBRARY "${LIBRARY}")
|
|
break()
|
|
endif ()
|
|
math(EXPR INDEX "${INDEX}+1")
|
|
endforeach ()
|
|
|
|
# handle error
|
|
if (REQUIRED_LIBRARY STREQUAL "FAILED")
|
|
message(
|
|
FATAL_ERROR
|
|
"Unable to compile a simple std::filesystem example. A compiler supporting C++17 is required to build this project."
|
|
)
|
|
return()
|
|
endif ()
|
|
|
|
# handle case when no library is required
|
|
if (REQUIRED_LIBRARY STREQUAL "")
|
|
message(STATUS "Linking ${META_PROJECT_NAME} against special library for std::filesystem support is not required.")
|
|
return()
|
|
endif ()
|
|
|
|
# prefer the static version of the library because the ABI might not be stable (note: stdc++fs seems to be only available
|
|
# as static lib anyways)
|
|
configure_static_library_suffixes()
|
|
set(USED_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
|
|
find_library(STANDARD_FILE_SYSTEM_LIBRARY "${REQUIRED_LIBRARY}")
|
|
configure_dynamic_library_suffixes()
|
|
if (NOT STANDARD_FILE_SYSTEM_LIBRARY)
|
|
# fallback to using -l if the library is hidden in some sub directory
|
|
set(STANDARD_FILE_SYSTEM_LIBRARY "-l${REQUIRED_LIBRARY}")
|
|
endif ()
|
|
|
|
message(
|
|
STATUS
|
|
"Linking ${META_PROJECT_NAME} against library \"${STANDARD_FILE_SYSTEM_LIBRARY}\" for std::filesystem support.")
|
|
set("${ARGS_LIBRARIES_VARIABLE}"
|
|
"${${ARGS_LIBRARIES_VARIABLE}};${STANDARD_FILE_SYSTEM_LIBRARY}"
|
|
PARENT_SCOPE)
|
|
endfunction ()
|
|
|
|
# skip subsequent configuration if only the function includes are wanted
|
|
if (META_NO_3RDPARTY_CONFIG)
|
|
return()
|
|
endif ()
|
|
|
|
# add options for deciding whether to build/use static or shared libraries
|
|
if (("${META_PROJECT_TYPE}" STREQUAL "library")
|
|
OR ("${META_PROJECT_TYPE}" STREQUAL "plugin")
|
|
OR ("${META_PROJECT_TYPE}" STREQUAL "qtplugin")
|
|
OR ("${META_PROJECT_TYPE}" STREQUAL ""))
|
|
set(META_PROJECT_IS_LIBRARY YES)
|
|
elseif ("${META_PROJECT_TYPE}" STREQUAL "application")
|
|
set(META_PROJECT_IS_APPLICATION YES)
|
|
endif ()
|
|
if (META_PROJECT_IS_LIBRARY)
|
|
# when development defaults are enabled, build shared libs by default when targeting GNU/Linux
|
|
set(BUILD_SHARED_LIBS_BY_DEFAULT "${BUILD_SHARED_LIBS}")
|
|
if (ENABLE_DEVEL_DEFAULTS AND CMAKE_SYSTEM_NAME STREQUAL "Linux")
|
|
set(BUILD_SHARED_LIBS_BY_DEFAULT ON)
|
|
endif ()
|
|
if (DEFINED CACHE{${META_PROJECT_VARNAME}_BUILD_SHARED_LIBS})
|
|
# allow overriding BUILD_SHARED_LIBS via a project-specific cache variable
|
|
set(BUILD_SHARED_LIBS "${${META_PROJECT_VARNAME}_BUILD_SHARED_LIBS}")
|
|
else ()
|
|
# make BUILD_SHARED_LIBS an overridable cache variable
|
|
option(BUILD_SHARED_LIBS "whether to build shared or static libraries" "${BUILD_SHARED_LIBS_BY_DEFAULT}")
|
|
endif ()
|
|
option(
|
|
STATIC_LIBRARY_LINKAGE
|
|
"prefer linking against dependencies statically; adds additional flags for static linkage; only applies when building shared libraries"
|
|
OFF)
|
|
elseif (META_PROJECT_IS_APPLICATION)
|
|
option(
|
|
STATIC_LINKAGE
|
|
"prefer linking against dependencies statically; adds additional flags for static linkage; only applies when building applications"
|
|
OFF)
|
|
endif ()
|
|
|
|
# configure "static linkage"
|
|
if ((STATIC_LINKAGE AND META_PROJECT_IS_APPLICATION) OR (STATIC_LIBRARY_LINKAGE AND META_PROJECT_IS_LIBRARY))
|
|
set(STATIC_LINKAGE_CONFIGURED ON)
|
|
|
|
# add options to opt out from linking statically against the C and C++ standard library as it might not work under all
|
|
# platforms (see https://github.com/Martchus/syncthingtray/issues/64)
|
|
option(NO_STATIC_LIBGCC
|
|
"prevent linking statically against libgcc despite aiming otherwise for a statically linked build" OFF)
|
|
option(NO_STATIC_LIBSTDCXX
|
|
"prevent linking statically against libstdc++ despite aiming otherwise for a statically linked build" OFF)
|
|
|
|
# add additional linker flags to achieve a fully statically linked build
|
|
set(STATIC_LINKAGE_LINKER_FLAGS)
|
|
if (NOT APPLE)
|
|
list(APPEND STATIC_LINKAGE_LINKER_FLAGS -static)
|
|
# note: The -static flag is considered completely unsupported under Apple platforms (see
|
|
# https://stackoverflow.com/questions/844819/how-to-static-link-on-os-x).
|
|
endif ()
|
|
if (NOT NO_STATIC_LIBGCC)
|
|
list(APPEND STATIC_LINKAGE_LINKER_FLAGS -static-libgcc)
|
|
endif ()
|
|
if (NOT NO_STATIC_LIBSTDCXX)
|
|
list(APPEND STATIC_LINKAGE_LINKER_FLAGS -static-libstdc++)
|
|
endif ()
|
|
|
|
if (META_PROJECT_IS_APPLICATION)
|
|
list(APPEND META_ADDITIONAL_LINK_FLAGS ${STATIC_LINKAGE_LINKER_FLAGS})
|
|
endif ()
|
|
list(APPEND META_ADDITIONAL_LINK_FLAGS_TEST_TARGET ${STATIC_LINKAGE_LINKER_FLAGS})
|
|
|
|
# prefer static libraries
|
|
set(OPENSSL_USE_STATIC_LIBS ON)
|
|
set(BOOST_USE_STATIC_LIBS ON)
|
|
set(PKG_CONFIG_USE_STATIC_LIBS ON)
|
|
configure_static_library_suffixes()
|
|
|
|
else ()
|
|
set(STATIC_LINKAGE_CONFIGURED OFF)
|
|
endif ()
|
|
|