From e9cc26478baeea2daedfe6edb88a055984509463 Mon Sep 17 00:00:00 2001 From: Martchus Date: Wed, 3 Apr 2019 22:06:27 +0200 Subject: [PATCH] Don't mix building static and shared libraries --- CMakeLists.txt | 6 +- application/argumentparser.h | 4 - cmake/modules/3rdParty.cmake | 427 ++++++++------------------ cmake/modules/AppTarget.cmake | 43 +-- cmake/modules/BasicConfig.cmake | 40 +-- cmake/modules/ConfigHeader.cmake | 90 +++--- cmake/modules/LibraryTarget.cmake | 312 +++++++------------ cmake/modules/TestTarget.cmake | 49 +-- cmake/templates/Config.cmake.in | 64 ++-- cmake/templates/SharedConfig.cmake.in | 9 - cmake/templates/StaticConfig.cmake.in | 9 - cmake/templates/config.h.in | 1 - doc/buildvariables.md | 45 +-- 13 files changed, 362 insertions(+), 737 deletions(-) delete mode 100644 cmake/templates/SharedConfig.cmake.in delete mode 100644 cmake/templates/StaticConfig.cmake.in diff --git a/CMakeLists.txt b/CMakeLists.txt index 11d504e..94c1bf4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -82,8 +82,6 @@ set(CMAKE_MODULE_FILES set(CMAKE_TEMPLATE_FILES cmake/templates/bash-completion.sh.in cmake/templates/Config.cmake.in - cmake/templates/SharedConfig.cmake.in - cmake/templates/StaticConfig.cmake.in cmake/templates/config.h.in cmake/templates/desktop.in cmake/templates/appdata.xml.in @@ -139,8 +137,8 @@ if (USE_NATIVE_FILE_BUFFER) PROPERTY COMPILE_DEFINITIONS ${META_PROJECT_VARNAME}_USE_GNU_CXX_STDIO_FILEBUF) else () message(STATUS "Using boost::iostreams::stream_buffer for NativeFileStream") - set(boost_iostreams_DYNAMIC_COMPILE_DEFINITIONS BOOST_IOSTREAMS_DYN_LINK) - use_external_library(boost_iostreams AUTO_LINKAGE REQUIRED) + find_package(Boost REQUIRED COMPONENTS iostreams) + use_target(TARGET_NAME Boost::iostreams) set_property(SOURCE io/nativefilestream.cpp APPEND PROPERTY COMPILE_DEFINITIONS ${META_PROJECT_VARNAME}_USE_BOOST_IOSTREAMS) diff --git a/application/argumentparser.h b/application/argumentparser.h index 817d7cd..59510c7 100644 --- a/application/argumentparser.h +++ b/application/argumentparser.h @@ -30,11 +30,7 @@ CPP_UTILITIES_EXPORT extern std::vector dependencyVersions2; * used by ArgumentParser::printHelp(). * \remarks Reads those data from the config header so "config.h" must be included. */ -#ifndef APP_STATICALLY_LINKED #define SET_DEPENDENCY_INFO ::ApplicationUtilities::dependencyVersions2 = DEPENCENCY_VERSIONS -#else -#define SET_DEPENDENCY_INFO ::ApplicationUtilities::dependencyVersions2 = STATIC_DEPENCENCY_VERSIONS -#endif /*! * \def SET_APPLICATION_INFO diff --git a/cmake/modules/3rdParty.cmake b/cmake/modules/3rdParty.cmake index d1e0899..894366b 100644 --- a/cmake/modules/3rdParty.cmake +++ b/cmake/modules/3rdParty.cmake @@ -35,311 +35,44 @@ macro (configure_dynamic_library_suffixes) endif () endmacro () -macro (link_against_library_varnames - NAME - LINKAGE - REQUIRED - PRIVATE_LIBRARIES_VARNAME - PUBLIC_LIBRARIES_VARNAME - PRIVATE_STATIC_LIBRARIES_VARNAME - PUBLIC_STATIC_LIBRARIES_VARNAME) - # determine whether the library is required or optional FIXME: improve passing required argument - if ("${REQUIRED}" STREQUAL "OPTIONAL") - set(${NAME}_REQUIRED "NO") - elseif ("${REQUIRED}" STREQUAL "REQUIRED") - set(${NAME}_REQUIRED "REQUIRED") - else () - message(FATAL_ERROR "Invalid use of link_against_library; must specify either REQUIRED or OPTIONAL.") - endif () +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() - # add library to list of libraries to link against when building dynamic libraries or applications - prefer dynamic lib - # if linkage not explicitely specified - if (${NAME}_STATIC_LIB - AND (("${LINKAGE}" STREQUAL "AUTO_LINKAGE" - AND ((NOT (${NAME}_DYNAMIC_LIB OR ${NAME}_SHARED_LIB)) - OR (STATIC_LINKAGE AND "${META_PROJECT_TYPE}" STREQUAL "application") - OR (STATIC_LIBRARY_LINKAGE - AND ("${META_PROJECT_TYPE}" STREQUAL "" OR "${META_PROJECT_TYPE}" STREQUAL "library")))) - OR ("${LINKAGE}" STREQUAL "STATIC"))) - set(USE_${NAME} ON) - set(USE_STATIC_${NAME} ON) - list(APPEND LIBRARIES ${${NAME}_STATIC_LIB}) - message( - STATUS - "Linking ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} statically against external library ${NAME} (${${NAME}_STATIC_LIB})." - ) - if (${NAME}_STATIC_INCLUDE_DIR) - list(APPEND ADDITIONAL_STATIC_INCLUDE_DIRS ${${NAME}_STATIC_INCLUDE_DIR}) - message( - STATUS - "Adding include path for ${NAME} to ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}: ${${NAME}_STATIC_INCLUDE_DIR}" - ) - endif () - if (${NAME}_STATIC_COMPILE_DEFINITIONS) - list(APPEND META_PRIVATE_STATIC_LIB_COMPILE_DEFINITIONS ${${NAME}_STATIC_COMPILE_DEFINITIONS}) - endif () +function(parse_arguments_for_use_functions) + # parse arguments + set(OPTIONAL_ARGS OPTIONAL) + set(ONE_VALUE_ARGS VISIBILITY LIBRARIES_VARIABLE TARGET_NAME) + set(MULTI_VALUE_ARGS) + cmake_parse_arguments(ARGS "${OPTIONAL_ARGS}" "${ONE_VALUE_ARGS}" "${MULTI_VALUE_ARGS}" ${ARGN}) - if (${${NAME}_STATIC_LIB} IN_LIST META_PUBLIC_STATIC_LIB_DEPENDS OR ${NAME} IN_LIST META_PUBLIC_STATIC_LIB_DEPENDS) - list(APPEND ${PUBLIC_LIBRARIES_VARNAME} ${${NAME}_STATIC_LIB}) - if (${NAME}_STATIC_INCLUDE_DIR) - list(APPEND PUBLIC_SHARED_INCLUDE_DIRS ${${NAME}_STATIC_INCLUDE_DIR}) - endif () - else () - list(APPEND ${PRIVATE_LIBRARIES_VARNAME} ${${NAME}_STATIC_LIB}) - if (${NAME}_STATIC_INCLUDE_DIR) - list(APPEND PRIVATE_SHARED_INCLUDE_DIRS ${${NAME}_STATIC_INCLUDE_DIR}) - endif () - endif () + # validate values + if (ARGS_VISIBILITY) + validate_visibility(${ARGS_VISIBILITY}) + else() + set (ARGS_VISIBILITY PRIVATE) + endif() - # add Qt resources of static library to be enabled - if (${NAME}_QT_RESOURCES) - message(STATUS "Adding ${${NAME}_QT_RESOURCES} to LIBRARIES_QT_RESOURCES for ${META_PROJECT_NAME}.") - list(APPEND LIBRARIES_QT_RESOURCES ${${NAME}_QT_RESOURCES}) - endif () + if (NOT ARGS_LIBRARIES_VARIABLE) + set (ARGS_LIBRARIES_VARIABLE "${ARGS_VISIBILITY}_LIBRARIES") + endif() - elseif ((${NAME}_DYNAMIC_LIB OR ${NAME}_SHARED_LIB) - AND (("${LINKAGE}" STREQUAL "AUTO_LINKAGE") OR ("${LINKAGE}" STREQUAL "SHARED"))) - set(USE_${NAME} ON) - set(USE_SHARED_${NAME} ON) - if (NOT ${NAME}_DYNAMIC_LIB) - set(${NAME}_DYNAMIC_LIB ${${NAME}_SHARED_LIB}) - endif () - list(APPEND LIBRARIES ${${NAME}_DYNAMIC_LIB}) - message( - STATUS - "Linking ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} dynamically against external library ${NAME} (${${NAME}_DYNAMIC_LIB})." - ) - if (${NAME}_DYNAMIC_INCLUDE_DIR) - list(APPEND ADDITIONAL_SHARED_INCLUDE_DIRS ${${NAME}_DYNAMIC_INCLUDE_DIR}) - message( - STATUS - "Adding include path for ${NAME} to ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}: ${${NAME}_DYNAMIC_INCLUDE_DIR}" - ) - endif () - if (${NAME}_DYNAMIC_COMPILE_DEFINITIONS) - list(APPEND META_PRIVATE_SHARED_LIB_COMPILE_DEFINITIONS ${${NAME}_DYNAMIC_COMPILE_DEFINITIONS}) - 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_TARGET_NAME "${ARGS_TARGET_NAME}" PARENT_SCOPE) + set(ARGS_OPTIONAL "${ARGS_OPTIONAL}" PARENT_SCOPE) + if (NOT ARGS_OPTIONAL) + set(ARGS_FIND_PACKAGE "REQUIRED" PARENT_SCOPE) + endif() +endfunction() - if (${${NAME}_DYNAMIC_LIB} IN_LIST META_PUBLIC_SHARED_LIB_DEPENDS OR ${NAME} IN_LIST META_PUBLIC_SHARED_LIB_DEPENDS) - list(APPEND ${PUBLIC_LIBRARIES_VARNAME} ${${NAME}_DYNAMIC_LIB}) - if (${NAME}_DYNAMIC_INCLUDE_DIR) - list(APPEND PUBLIC_SHARED_INCLUDE_DIRS ${${NAME}_DYNAMIC_INCLUDE_DIR}) - endif () - else () - list(APPEND ${PRIVATE_LIBRARIES_VARNAME} ${${NAME}_DYNAMIC_LIB}) - if (${NAME}_DYNAMIC_INCLUDE_DIR) - list(APPEND PRIVATE_SHARED_INCLUDE_DIRS ${${NAME}_DYNAMIC_INCLUDE_DIR}) - endif () - endif () - else () - if (${NAME}_REQUIRED) - message( - FATAL_ERROR - "External library ${NAME} required by ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} is not available for the specified linkage ${LINKAGE}." - ) - else () - message( - WARNING - "External library ${NAME} required by ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} is not available for the specified linkage ${LINKAGE}." - ) - endif () - endif () +function (use_iconv) + parse_arguments_for_use_functions(${ARGN}) - # add library to list of libraries to be provided as transitive dependencies when building static libraries - prefer - # static lib if linkage not explicitely specified - if (${NAME}_STATIC_LIB AND ("${LINKAGE}" STREQUAL "AUTO_LINKAGE") OR ("${LINKAGE}" STREQUAL "STATIC")) - set(USE_${NAME} ON) - set(USE_STATIC_${NAME} ON) - list(APPEND STATIC_LIBRARIES ${${NAME}_STATIC_LIB}) - message( - STATUS - "Adding static external library ${NAME} (${${NAME}_STATIC_LIB}) to dependencies of ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}." - ) - if (${NAME}_STATIC_INCLUDE_DIR) - list(APPEND ADDITIONAL_STATIC_INCLUDE_DIRS ${${NAME}_STATIC_INCLUDE_DIR}) - message( - STATUS - "Adding include path for ${NAME} to static ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}: ${${NAME}_STATIC_INCLUDE_DIR}" - ) - endif () - - if (${${NAME}_STATIC_LIB} IN_LIST META_PUBLIC_STATIC_LIB_DEPENDS OR ${NAME} IN_LIST META_PUBLIC_STATIC_LIB_DEPENDS) - list(APPEND ${PUBLIC_STATIC_LIBRARIES_VARNAME} ${${NAME}_STATIC_LIB}) - if (${NAME}_STATIC_INCLUDE_DIR) - list(APPEND PUBLIC_STATIC_INCLUDE_DIRS ${${NAME}_STATIC_INCLUDE_DIR}) - endif () - else () - list(APPEND ${PRIVATE_STATIC_LIBRARIES_VARNAME} ${${NAME}_STATIC_LIB}) - if (${NAME}_STATIC_INCLUDE_DIR) - list(APPEND PRIVATE_STATIC_INCLUDE_DIRS ${${NAME}_STATIC_INCLUDE_DIR}) - endif () - endif () - - # add Qt resources of static library for exporting it - if (${NAME}_QT_RESOURCES) - message(STATUS "Adding ${${NAME}_QT_RESOURCES} to STATIC_LIBRARIES_QT_RESOURCES for ${META_PROJECT_NAME}.") - list(APPEND STATIC_LIBRARIES_QT_RESOURCES ${${NAME}_QT_RESOURCES}) - endif () - - elseif ((${NAME}_DYNAMIC_LIB OR ${NAME}_SHARED_LIB) - AND (("${LINKAGE}" STREQUAL "AUTO_LINKAGE" - AND (NOT ${NAME}_STATIC_LIB - OR (NOT STATIC_LINKAGE AND "${META_PROJECT_TYPE}" STREQUAL "application") - OR (NOT STATIC_LIBRARY_LINKAGE - AND ("${META_PROJECT_TYPE}" STREQUAL "" OR "${META_PROJECT_TYPE}" STREQUAL "library")))) - OR ("${LINKAGE}" STREQUAL "SHARED"))) - set(USE_${NAME} ON) - set(USE_SHARED_${NAME} ON) - if (NOT ${NAME}_DYNAMIC_LIB) - set(${NAME}_DYNAMIC_LIB ${${NAME}_SHARED_LIB}) - endif () - list(APPEND STATIC_LIBRARIES ${${NAME}_DYNAMIC_LIB}) - message( - STATUS - "Adding dynamic external library ${NAME} (${${NAME}_DYNAMIC_LIB}) to dependencies of static ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}." - ) - if (${NAME}_DYNAMIC_INCLUDE_DIR) - list(APPEND ADDITIONAL_SHARED_INCLUDE_DIRS ${${NAME}_DYNAMIC_INCLUDE_DIR}) - message( - STATUS - "Adding include path for ${NAME} to static ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}: ${${NAME}_DYNAMIC_INCLUDE_DIR}" - ) - endif () - - if (${${NAME}_DYNAMIC_LIB} IN_LIST META_PUBLIC_SHARED_LIB_DEPENDS OR ${NAME} IN_LIST META_PUBLIC_SHARED_LIB_DEPENDS) - list(APPEND ${PUBLIC_STATIC_LIBRARIES_VARNAME} ${${NAME}_DYNAMIC_LIB}) - if (${NAME}_DYNAMIC_INCLUDE_DIR) - list(APPEND PUBLIC_STATIC_INCLUDE_DIRS ${${NAME}_DYNAMIC_INCLUDE_DIR}) - endif () - else () - list(APPEND ${PRIVATE_STATIC_LIBRARIES_VARNAME} ${${NAME}_DYNAMIC_LIB}) - if (${NAME}_DYNAMIC_INCLUDE_DIR) - list(APPEND PRIVATE_STATIC_INCLUDE_DIRS ${${NAME}_DYNAMIC_INCLUDE_DIR}) - endif () - endif () - else () - if (${NAME}_REQUIRED) - message( - FATAL_ERROR - "External library ${NAME} required by ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} is not available for the specified linkage ${LINKAGE}." - ) - else () - message( - WARNING - "External library ${NAME} required by ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} is not available for the specified linkage ${LINKAGE}." - ) - endif () - endif () -endmacro () - -macro (link_against_library NAME LINKAGE REQUIRED) - link_against_library_varnames("${NAME}" - "${LINKAGE}" - "${REQUIRED}" - PRIVATE_LIBRARIES - PUBLIC_LIBRARIES - PRIVATE_STATIC_LIBRARIES - PUBLIC_STATIC_LIBRARIES) -endmacro () - -macro (link_tests_against_library NAME LINKAGE REQUIRED) - link_against_library_varnames("${NAME}" - "${LINKAGE}" - "${REQUIRED}" - TEST_LIBRARIES - TEST_LIBRARIES - STATIC_TEST_LIBRARIES - STATIC_TEST_LIBRARIES) -endmacro () - -macro (find_external_library NAME LINKAGE REQUIRED) - set(${NAME}_DYNAMIC_INCLUDE_DIR NOTFOUND CACHE PATH "${NAME} include dir (dynamic)") - set(${NAME}_DYNAMIC_LIB NOTFOUND CACHE FILEPATH "${NAME} lib (dynamic)") - set(${NAME}_STATIC_INCLUDE_DIR NOTFOUND CACHE PATH "${NAME} include dir (static)") - set(${NAME}_STATIC_LIB NOTFOUND CACHE FILEPATH "${NAME} lib (static)") - - save_default_library_suffixes() - - if (NOT ${NAME}_DYNAMIC_LIB) - configure_dynamic_library_suffixes() - find_library(DETECTED_${NAME}_DYNAMIC_LIB ${NAME}) - set(${NAME}_DYNAMIC_LIB ${DETECTED_${NAME}_DYNAMIC_LIB} CACHE FILEPATH "${NAME} lib (dynamic)" FORCE) - endif () - - if (NOT ${NAME}_STATIC_LIB) - configure_static_library_suffixes() - find_library(DETECTED_${NAME}_STATIC_LIB ${NAME}) - set(${NAME}_STATIC_LIB ${DETECTED_${NAME}_STATIC_LIB} CACHE FILEPATH "${NAME} lib (static)" FORCE) - endif () - - restore_default_library_suffixes() -endmacro () - -macro (use_external_library NAME LINKAGE REQUIRED) - find_external_library("${NAME}" "${LINKAGE}" "${REQUIRED}") - link_against_library("${NAME}" "${LINKAGE}" "${REQUIRED}") -endmacro () - -function (use_external_library_from_package_dynamic NAME PKGNAME INCLUDE_VAR LIBRARY_VAR COMPAT_VERSION) - # internally used by find_external_library_from_package to find dynamic libraries - configure_dynamic_library_suffixes() - find_package(${PKGNAME} ${COMPAT_VERSION}) - set(${NAME}_DYNAMIC_INCLUDE_DIR ${${INCLUDE_VAR}} CACHE PATH "${NAME} include dir (dynamic)" FORCE) - set(${NAME}_DYNAMIC_LIB ${${LIBRARY_VAR}} CACHE FILEPATH "${NAME} lib (dynamic)" FORCE) -endfunction () - -function (use_external_library_from_package_static NAME PKGNAME INCLUDE_VAR LIBRARY_VAR COMPAT_VERSION) - # internally used by find_external_library_from_package to find static libraries - configure_static_library_suffixes() - find_package(${PKGNAME} ${COMPAT_VERSION}) - set(${NAME}_STATIC_INCLUDE_DIR ${${INCLUDE_VAR}} CACHE PATH "${NAME} include dir (static)" FORCE) - set(${NAME}_STATIC_LIB ${${LIBRARY_VAR}} CACHE FILEPATH "${NAME} lib (static)" FORCE) -endfunction () - -macro (find_external_library_from_package NAME PKGNAME VERSION INCLUDE_VAR LIBRARY_VAR LINKAGE REQUIRED) - # handle specified VERSION - if ("${VERSION}" STREQUAL "ANY_VERSION") - set(${NAME}_COMPATIBLE_VERSION "") - else () - set(${NAME}_COMPATIBLE_VERSION ${VERSION}) - endif () - - # use the find_library approach first because it is less buggy when trying to detect static libraries caveat: this way - # include dirs are not detected - however those are mostly the default anyways and can also be set manually by the user - # in case the auto-detection is not sufficient - find_external_library("${NAME}" "${LINKAGE}" OPTIONAL) - - # fall back to actual use of find_package use separate functions to get a new scope - save_default_library_suffixes() - if (NOT ${NAME}_DYNAMIC_LIB) - use_external_library_from_package_dynamic(${NAME} - ${PKGNAME} - ${INCLUDE_VAR} - "${LIBRARY_VAR}" - "${${NAME}_COMPATIBLE_VERSION}") - endif () - if (NOT ${NAME}_STATIC_LIB) - use_external_library_from_package_static(${NAME} - ${PKGNAME} - ${INCLUDE_VAR} - "${LIBRARY_VAR}" - "${${NAME}_COMPATIBLE_VERSION}") - endif () - restore_default_library_suffixes() -endmacro () - -macro (use_external_library_from_package NAME PKGNAME VERSION INCLUDE_VAR LIBRARY_VAR LINKAGE REQUIRED) - find_external_library_from_package("${NAME}" - "${PKGNAME}" - "${VERSION}" - "${INCLUDE_VAR}" - "${LIBRARY_VAR}" - "${LINKAGE}" - "${REQUIRED}") - link_against_library("${NAME}" "${LINKAGE}" "${REQUIRED}") -endmacro () - -macro (use_iconv LINKAGE REQUIRED) + # 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) @@ -348,9 +81,93 @@ macro (use_iconv LINKAGE REQUIRED) check_function_exists(iconv HAS_ICONV) endif () if (NOT FORCE_EXTERNAL_ICONV AND HAS_ICONV) - message(STATUS "Using iconv from the standard library for ${META_PROJECT_NAME}.") - else () - # find external iconv library - use_external_library(iconv ${LINKAGE} ${REQUIRED}) - endif () -endmacro () + message(STATUS "Using iconv from the standard library for target ${META_PROJECT_NAME}.") + return() + endif() + + # find external iconv library + if (NOT TARGET ICONV::LIBICONV) + find_library(ICONV_LIBRARY_PATH iconv) + if (NOT EXISTS "${ICONV_LIBRARY_PATH}") + if (ARGS_OPTIONAL) + return() + endif() + message(FATAL_ERROR "Unable to find iconv library for project ${META_PROJECT_NAME}.") + endif() + add_library(ICONV::LIBICONV STATIC IMPORTED) + set_property(TARGET ICONV::LIBICONV PROPERTY IMPORTED_LOCATION "${ICONV_LIBRARY_PATH}") + endif() + + set("${ARGS_LIBRARIES_VARIABLE}" "${${ARGS_LIBRARIES_VARIABLE}};ICONV::LIBICONV" PARENT_SCOPE) +endfunction() + +function (use_openssl) + parse_arguments_for_use_functions(${ARGN}) + + find_package(OpenSSL ${ARGS_FIND_PACKAGE}) + set("${ARGS_LIBRARIES_VARIABLE}" "${${ARGS_LIBRARIES_VARIABLE}};OpenSSL::SSL;OpenSSL::Crypto" PARENT_SCOPE) + set("PKG_CONFIG_OpenSSL_SSL" "libssl" PARENT_SCOPE) + set("PKG_CONFIG_OpenSSL_Crypto" "libcrypto" PARENT_SCOPE) +endfunction() + +function (use_crypto) + parse_arguments_for_use_functions(${ARGN}) + + find_package(OpenSSL ${ARGS_FIND_PACKAGE}) + set("${ARGS_LIBRARIES_VARIABLE}" "${${ARGS_LIBRARIES_VARIABLE}};OpenSSL::Crypto" PARENT_SCOPE) + set("PKG_CONFIG_OpenSSL_Crypto" "libcrypto" PARENT_SCOPE) +endfunction() + +function (use_zlib) + parse_arguments_for_use_functions(${ARGN}) + + find_package(ZLIB ${ARGS_FIND_PACKAGE}) + set("${ARGS_LIBRARIES_VARIABLE}" "${${ARGS_LIBRARIES_VARIABLE}};ZLIB::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) +endfunction() + +if (META_NO_3RDPARTY_CONFIG) + return() +endif() + +# option 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) + option(BUILD_SHARED_LIBS ON "whether to build shared or static libraries") + option(STATIC_LIBRARY_LINKAGE "adds flags for static linkage when building dynamic libraries" OFF) +elseif (META_PROJECT_IS_APPLICATION) + option(STATIC_LINKAGE "adds flags for static linkage 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)) + # add additional linker flags to achieve a fully statically linked build + if (META_PROJECT_IS_APPLICATION) + if (NOT APPLE) + list(APPEND META_ADDITIONAL_LINK_FLAGS -static) + endif () + list(APPEND META_ADDITIONAL_LINK_FLAGS -static-libstdc++ -static-libgcc) + endif() + + # prefer static libraries + configure_static_library_suffixes() +endif() diff --git a/cmake/modules/AppTarget.cmake b/cmake/modules/AppTarget.cmake index 0e2de1d..ff49e75 100644 --- a/cmake/modules/AppTarget.cmake +++ b/cmake/modules/AppTarget.cmake @@ -18,26 +18,6 @@ if (WIN32) set(WINDOWS_EXT "exe") endif (WIN32) -# set compile definitions -if (NOT META_PUBLIC_SHARED_LIB_COMPILE_DEFINITIONS) - set(META_PUBLIC_SHARED_LIB_COMPILE_DEFINITIONS ${META_PUBLIC_COMPILE_DEFINITIONS} - ${META_ADDITIONAL_PUBLIC_SHARED_COMPILE_DEFINITIONS}) -endif () -if (NOT META_PRIVATE_SHARED_LIB_COMPILE_DEFINITIONS) - set(META_PRIVATE_SHARED_LIB_COMPILE_DEFINITIONS ${META_PRIVATE_COMPILE_DEFINITIONS} - ${META_ADDITIONAL_PRIVATE_SHARED_COMPILE_DEFINITIONS}) - if (STATIC_LINKAGE) - list(APPEND META_PRIVATE_SHARED_LIB_COMPILE_DEFINITIONS APP_STATICALLY_LINKED) - endif () -endif () - -# set linker flags -if (STATIC_LINKAGE) - set(ACTUAL_ADDITIONAL_LINK_FLAGS ${META_ADDITIONAL_STATIC_LINK_FLAGS}) -else () - set(ACTUAL_ADDITIONAL_LINK_FLAGS ${META_ADDITIONAL_LINK_FLAGS}) -endif () - # define relevant files set(ALL_FILES ${HEADER_FILES} @@ -52,27 +32,30 @@ if (NOT BUILTIN_TRANSLATIONS) endif () # add target for building the application -if (NOT ANDROID) - add_executable(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} ${GUI_TYPE} ${ALL_FILES}) -else () - # create a library which can be loaded from the Java-side +if (ANDROID) + # create a shared library which can be loaded from the Java-side add_library(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} SHARED ${GUI_TYPE} ${ALL_FILES}) +else () + add_executable(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} ${GUI_TYPE} ${ALL_FILES}) endif () +message(STATUS LINKING ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} + PUBLIC ${META_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}" + PRIVATE "${PRIVATE_LIBRARIES}") target_link_libraries(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} - PUBLIC ${ACTUAL_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}" + PUBLIC ${META_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}" PRIVATE "${PRIVATE_LIBRARIES}") target_include_directories(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} PUBLIC $ $ ${PUBLIC_SHARED_INCLUDE_DIRS} - PRIVATE "${PRIVATE_SHARED_INCLUDE_DIRS}") + PRIVATE "${PRIVATE_INCLUDE_DIRS}") target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} PUBLIC - "${META_PUBLIC_SHARED_LIB_COMPILE_DEFINITIONS}" + "${META_PUBLIC_COMPILE_DEFINITIONS}" PRIVATE - "${META_PRIVATE_SHARED_LIB_COMPILE_DEFINITIONS}") + "${META_PRIVATE_COMPILE_DEFINITIONS}") target_compile_options(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} - PUBLIC "${META_PUBLIC_SHARED_LIB_COMPILE_OPTIONS}" - PRIVATE "${META_PRIVATE_SHARED_LIB_COMPILE_OPTIONS}") + PUBLIC "${META_PUBLIC_COMPILE_OPTIONS}" + PRIVATE "${META_PRIVATE_COMPILE_OPTIONS}") set_target_properties(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} PROPERTIES CXX_STANDARD "${META_CXX_STANDARD}" diff --git a/cmake/modules/BasicConfig.cmake b/cmake/modules/BasicConfig.cmake index cd38df3..5f51350 100644 --- a/cmake/modules/BasicConfig.cmake +++ b/cmake/modules/BasicConfig.cmake @@ -12,6 +12,8 @@ if (NOT META_APP_DESCRIPTION) message(FATAL_ERROR "No project name (META_APP_DESCRIPTION) specified.") endif () +string(TOUPPER "${CMAKE_BUILD_TYPE}" META_CURRENT_CONFIGURATION) + # set project name (displayed in Qt Creator) message(STATUS "Configuring project ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}") project(${META_PROJECT_NAME}) @@ -165,41 +167,6 @@ if (LOGGING_ENABLED) message(STATUS "Logging is enabled.") endif () -# options for deciding whether to build static and/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 "")) - option(ENABLE_STATIC_LIBS "whether building static libraries is enabled (disabled by default)" OFF) - option(DISABLE_SHARED_LIBS "whether building dynamic libraries is disabled (enabled by default)" OFF) - if (DISABLE_SHARED_LIBS) - set(BUILD_SHARED_LIBS OFF) - else () - set(BUILD_SHARED_LIBS ON) - endif () - if (ENABLE_STATIC_LIBS) - set(BUILD_STATIC_LIBS ON) - else () - set(BUILD_STATIC_LIBS OFF) - endif () -endif () - -# options for forcing static linkage when building applications or dynamic libraries -if (("${META_PROJECT_TYPE}" STREQUAL "library") - OR ("${META_PROJECT_TYPE}" STREQUAL "plugin") - OR ("${META_PROJECT_TYPE}" STREQUAL "qtplugin") - OR ("${META_PROJECT_TYPE}" STREQUAL "")) - option(STATIC_LIBRARY_LINKAGE "forces static linkage when building dynamic libraries" OFF) -elseif ("${META_PROJECT_TYPE}" STREQUAL "application") - option(STATIC_LINKAGE "forces static linkage when building applications" OFF) -endif () - -# additional linker flags used when static linkage is enabled -if (NOT APPLE) - list(APPEND META_ADDITIONAL_STATIC_LINK_FLAGS -static) -endif () -list(APPEND META_ADDITIONAL_STATIC_LINK_FLAGS -static-libstdc++ -static-libgcc) - # determine whether the project is a header-only library if (SRC_FILES OR GUI_SRC_FILES OR WIDGETS_SRC_FILES OR WIDGETS_UI_FILES OR QML_SRC_FILES OR RES_FILES) set(META_HEADER_ONLY_LIB NO) @@ -211,6 +178,9 @@ else () message(STATUS "Project ${META_PROJECT_NAME} is header-only library.") endif () +# ensure 3rdParty has been included to configure BUILD_SHARED_LIBS and STATIC_LINKAGE/STATIC_LIBRARY_LINKAGE +include(3rdParty) + # options for enabling/disabling Qt GUI (if available) if (WIDGETS_HEADER_FILES OR WIDGETS_SRC_FILES OR WIDGETS_UI_FILES OR META_HAS_WIDGETS_GUI) if (META_GUI_OPTIONAL) diff --git a/cmake/modules/ConfigHeader.cmake b/cmake/modules/ConfigHeader.cmake index 3a4f080..b583393 100644 --- a/cmake/modules/ConfigHeader.cmake +++ b/cmake/modules/ConfigHeader.cmake @@ -1,3 +1,5 @@ +cmake_minimum_required(VERSION 3.3.0 FATAL_ERROR) + # before including this module, all relevant variables must be set just include this module as last one since nothing should # depend on it @@ -9,48 +11,61 @@ endif () include(TemplateFinder) find_template_file("config.h" CPP_UTILITIES CONFIG_H_TEMPLATE_FILE) -# create list of dependency versions present at link time (one list for shared library and another for the static library -# since the lists might differ) +# create list of dependency versions present at link time include(ListToString) -foreach (LINKAGE IN ITEMS "" "STATIC_") - unset(DEPENCENCY_VERSIONS) - unset(${LINKAGE}DEPENCENCY_VERSIONS_ARRAY) - # iterate through public and private libraries of shared/static library - foreach (DEPENDENCY IN LISTS PUBLIC_${LINKAGE}LIBRARIES PRIVATE_${LINKAGE}LIBRARIES) - if (TARGET ${DEPENDENCY}) - unset(DEPENDENCY_DISPLAY_NAME) - unset(DEPENDENCY_VER) +unset(DEPENCENCY_VERSIONS) +unset(DEPENCENCY_VERSIONS_ARRAY) +unset(LINK_LIBRARIES_LIST) +unset(INTERFACE_LINK_LIBRARIES_LIST) +unset(PROCESSED_DEPENDENCIES) +unset(HAVE_OPENSSL) +if (NOT META_HEADER_ONLY_LIB) + get_target_property(LINK_LIBRARIES_LIST "${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}" LINK_LIBRARIES) +endif() +get_target_property(INTERFACE_LINK_LIBRARIES_LIST "${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}" INTERFACE_LINK_LIBRARIES) +foreach (DEPENDENCY IN LISTS LINK_LIBRARIES_LIST INTERFACE_LINK_LIBRARIES_LIST) + if (NOT TARGET "${DEPENDENCY}" OR "${DEPENDENCY}" IN_LIST PROCESSED_DEPENDENCIES) + continue() + endif() + unset(DEPENDENCY_DISPLAY_NAME) + unset(DEPENDENCY_VER) - # find version and display name for target - if (DEPENDENCY MATCHES "(Static)?Qt5::([A-Za-z0-9]+)") - # read meta-data of Qt module - set(DEPENDENCY_MODULE_NAME "${CMAKE_MATCH_2}") - set(DEPENDENCY_DISPLAY_NAME "Qt ${DEPENDENCY_MODULE_NAME}") - set(DEPENDENCY_VER "${Qt5${DEPENDENCY_MODULE_NAME}_VERSION_STRING}") - elseif (${DEPENDENCY}_varname) - # read meta-data of one of my own libraries - set(DEPENDENCY_VARNAME "${${DEPENDENCY}_varname}") - set(DEPENDENCY_DISPLAY_NAME "${DEPENDENCY}") - if (${DEPENDENCY_VARNAME}_DISPLAY_NAME) - set(DEPENDENCY_DISPLAY_NAME "${${DEPENDENCY_VARNAME}_DISPLAY_NAME}") - endif () - set(DEPENDENCY_VER "${${DEPENDENCY_VARNAME}_VERSION}") - endif () - # FIXME: provide meta-data for other libs, too - - if (DEPENDENCY_VER - AND NOT - "${DEPENDENCY_VER}" - STREQUAL - "DEPENDENCY_VER-NOTFOUND") - list(APPEND DEPENCENCY_VERSIONS "${DEPENDENCY_DISPLAY_NAME}: ${DEPENDENCY_VER}") - endif () + # find version and display name for target + if (DEPENDENCY MATCHES "((Static)?Qt5)::([A-Za-z0-9]+)") + # read meta-data of Qt module + set(DEPENDENCY_MODULE_PREFIX "${CMAKE_MATCH_1}") + set(DEPENDENCY_MODULE_NAME "${CMAKE_MATCH_3}") + set(DEPENDENCY_DISPLAY_NAME "Qt ${DEPENDENCY_MODULE_NAME}") + set(DEPENDENCY_VER "${${DEPENDENCY_MODULE_PREFIX}${DEPENDENCY_MODULE_NAME}_VERSION_STRING}") + elseif (DEPENDENCY STREQUAL ZLIB::ZLIB) + set(DEPENDENCY_DISPLAY_NAME "zlib") + set(DEPENDENCY_VER "${ZLIB_VERSION_STRING}") + elseif (NOT HAVE_OPENSSAL AND (DEPENDENCY STREQUAL OpenSSL::SSL OR DEPENDENCY STREQUAL OpenSSL::Crypto)) + set(DEPENDENCY_DISPLAY_NAME "OpenSSL") + set(DEPENDENCY_VER "${OPENSSL_VERSION}") + elseif (${DEPENDENCY}_varname) + # read meta-data of one of my own libraries + set(DEPENDENCY_VARNAME "${${DEPENDENCY}_varname}") + set(DEPENDENCY_DISPLAY_NAME "${DEPENDENCY}") + if (${DEPENDENCY_VARNAME}_DISPLAY_NAME) + set(DEPENDENCY_DISPLAY_NAME "${${DEPENDENCY_VARNAME}_DISPLAY_NAME}") endif () - endforeach () - if (DEPENCENCY_VERSIONS) - list_to_string("," " \\\n \"" "\"" "${DEPENCENCY_VERSIONS}" ${LINKAGE}DEPENCENCY_VERSIONS_ARRAY) + set(DEPENDENCY_VER "${${DEPENDENCY_VARNAME}_VERSION}") + endif () + # FIXME: provide meta-data for other libs, too + + if (DEPENDENCY_VER + AND NOT + "${DEPENDENCY_VER}" + STREQUAL + "DEPENDENCY_VER-NOTFOUND") + list(APPEND PROCESSED_DEPENDENCIES "${DEPENDENCY}") + list(APPEND DEPENCENCY_VERSIONS "${DEPENDENCY_DISPLAY_NAME}: ${DEPENDENCY_VER}") endif () endforeach () +if (DEPENCENCY_VERSIONS) + list_to_string("," " \\\n \"" "\"" "${DEPENCENCY_VERSIONS}" DEPENCENCY_VERSIONS_ARRAY) +endif () # add configuration header configure_file("${CONFIG_H_TEMPLATE_FILE}" "${CMAKE_CURRENT_BINARY_DIR}/resources/config.h") @@ -59,7 +74,6 @@ configure_file("${CONFIG_H_TEMPLATE_FILE}" "${CMAKE_CURRENT_BINARY_DIR}/resource if (NOT META_HEADER_ONLY_LIB) foreach (TARGET_NAME ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} - ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_tests ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_testlib) if (TARGET ${TARGET_NAME}) diff --git a/cmake/modules/LibraryTarget.cmake b/cmake/modules/LibraryTarget.cmake index e3a0ada..1d36cab 100644 --- a/cmake/modules/LibraryTarget.cmake +++ b/cmake/modules/LibraryTarget.cmake @@ -40,25 +40,10 @@ if (MINGW) set(WINDOWS_EXT "dll") endif (MINGW) -# set compile definitions -if (NOT META_PUBLIC_SHARED_LIB_COMPILE_DEFINITIONS) - set(META_PUBLIC_SHARED_LIB_COMPILE_DEFINITIONS ${META_PUBLIC_COMPILE_DEFINITIONS} - ${META_ADDITIONAL_PUBLIC_SHARED_COMPILE_DEFINITIONS}) -endif () -if (NOT META_PRIVATE_SHARED_LIB_COMPILE_DEFINITIONS) - set(META_PRIVATE_SHARED_LIB_COMPILE_DEFINITIONS ${META_PRIVATE_COMPILE_DEFINITIONS} - ${META_ADDITIONAL_PRIVATE_SHARED_COMPILE_DEFINITIONS}) -endif () -if (NOT META_PUBLIC_STATIC_LIB_COMPILE_DEFINITIONS) - set(META_PUBLIC_STATIC_LIB_COMPILE_DEFINITIONS - ${META_PUBLIC_COMPILE_DEFINITIONS} - ${META_PROJECT_VARNAME_UPPER}_STATIC - ${META_ADDITIONAL_PUBLIC_STATIC_COMPILE_DEFINITIONS}) -endif () -if (NOT META_PRIVATE_STATIC_LIB_COMPILE_DEFINITIONS) - set(META_PRIVATE_STATIC_LIB_COMPILE_DEFINITIONS ${META_PRIVATE_COMPILE_DEFINITIONS} - ${META_ADDITIONAL_PRIVATE_STATIC_COMPILE_DEFINITIONS}) -endif () +# set compile definitions for static build +if (NOT BUILD_SHARED_LIBS) + list(APPEND META_PUBLIC_COMPILE_DEFINITIONS ${META_PROJECT_VARNAME_UPPER}_STATIC) +endif() # add global library-specific header find_template_file("global.h" CPP_UTILITIES GLOBAL_H_TEMPLATE_FILE) @@ -81,7 +66,6 @@ if (NOT META_SOVERSION AND NOT META_IS_PLUGIN) set(META_SOVERSION "${META_VERSION_MAJOR}") endif () endif () -message(STATUS "${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}: BUILD_SHARED_LIBS=${BUILD_SHARED_LIBS}") # define relevant files set(ALL_FILES @@ -107,118 +91,69 @@ endif () # add target for building the library if (BUILD_SHARED_LIBS) - if (STATIC_LIBRARY_LINKAGE) - set(ACTUAL_ADDITIONAL_LINK_FLAGS ${META_ADDITIONAL_STATIC_LINK_FLAGS}) - else () - set(ACTUAL_ADDITIONAL_LINK_FLAGS ${META_ADDITIONAL_SHARED_LINK_FLAGS}) - endif () if (META_IS_PLUGIN) - set(META_SHARED_OBJECT_TYPE MODULE) + set(META_LIBRARY_TYPE MODULE) else () - set(META_SHARED_OBJECT_TYPE SHARED) + set(META_LIBRARY_TYPE SHARED) endif () - # add library to be created, set libs to link against, set version and C++ standard - if (META_HEADER_ONLY_LIB) - add_library(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} INTERFACE) - target_link_libraries(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} - INTERFACE ${ACTUAL_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}" "${PRIVATE_LIBRARIES}") - target_include_directories( - ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} - INTERFACE $ - $ ${PUBLIC_SHARED_INCLUDE_DIRS}) - target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} - INTERFACE - "${META_PUBLIC_SHARED_LIB_COMPILE_DEFINITIONS}" - "${META_PRIVATE_SHARED_LIB_COMPILE_DEFINITIONS}") - target_compile_options(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} - INTERFACE "${META_PUBLIC_SHARED_LIB_COMPILE_OPTIONS}" - "${META_PRIVATE_SHARED_LIB_COMPILE_OPTIONS}") - else () - add_library(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} ${META_SHARED_OBJECT_TYPE} ${ALL_FILES}) - target_link_libraries(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} - PUBLIC ${ACTUAL_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}" - PRIVATE "${PRIVATE_LIBRARIES}") - target_include_directories(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} - PUBLIC $ - $ ${PUBLIC_SHARED_INCLUDE_DIRS} - PRIVATE "${PRIVATE_SHARED_INCLUDE_DIRS}") - target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} - PUBLIC - "${META_PUBLIC_SHARED_LIB_COMPILE_DEFINITIONS}" - PRIVATE - "${META_PRIVATE_SHARED_LIB_COMPILE_DEFINITIONS}") - target_compile_options(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} - PUBLIC "${META_PUBLIC_SHARED_LIB_COMPILE_OPTIONS}" - PRIVATE "${META_PRIVATE_SHARED_LIB_COMPILE_OPTIONS}") - set_target_properties(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} - PROPERTIES VERSION - "${META_VERSION_MAJOR}.${META_VERSION_MINOR}.${META_VERSION_PATCH}" - SOVERSION - "${META_SOVERSION}" - CXX_STANDARD - "${META_CXX_STANDARD}" - LINK_SEARCH_START_STATIC - ${STATIC_LINKAGE} - LINK_SEARCH_END_STATIC - ${STATIC_LINKAGE} - AUTOGEN_TARGET_DEPENDS - "${AUTOGEN_DEPS}") - endif () -endif () +else() + set(META_LIBRARY_TYPE STATIC) +endif() -# add target for building a static version of the library -if (BUILD_STATIC_LIBS) - # add library to be created, set required libs, set version and C++ standard - if (META_HEADER_ONLY_LIB) - add_library(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static INTERFACE) - target_link_libraries(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static - INTERFACE ${ACTUAL_ADDITIONAL_LINK_FLAGS} "${PUBLIC_STATIC_LIBRARIES}" - "${PRIVATE_STATIC_LIBRARIES}") - target_include_directories( - ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static - INTERFACE $ - $ ${PUBLIC_STATIC_INCLUDE_DIRS}) - target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static - INTERFACE - "${META_PUBLIC_STATIC_LIB_COMPILE_DEFINITIONS}" - "${META_PRIVATE_STATIC_LIB_COMPILE_DEFINITIONS}") - target_compile_options(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static - INTERFACE "${META_PUBLIC_STATIC_LIB_COMPILE_OPTIONS}" - "${META_PRIVATE_STATIC_LIB_COMPILE_OPTIONS}") - else () - add_library(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static STATIC ${ALL_FILES}) - target_link_libraries(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static - PUBLIC "${PUBLIC_STATIC_LIBRARIES}" "${PRIVATE_STATIC_LIBRARIES}") - target_include_directories(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static - PUBLIC $ - $ ${PUBLIC_STATIC_INCLUDE_DIRS} - PRIVATE "${PRIVATE_STATIC_INCLUDE_DIRS}") - target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static - PUBLIC - "${META_PUBLIC_STATIC_LIB_COMPILE_DEFINITIONS}" - PRIVATE - "${META_PRIVATE_STATIC_LIB_COMPILE_DEFINITIONS}") - target_compile_options(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static - PUBLIC "${META_PUBLIC_STATIC_LIB_COMPILE_OPTIONS}" - PRIVATE "${META_PRIVATE_STATIC_LIB_COMPILE_OPTIONS}") - set_target_properties(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static - PROPERTIES VERSION - "${META_VERSION_MAJOR}.${META_VERSION_MINOR}.${META_VERSION_PATCH}" - SOVERSION - "${META_SOVERSION}" - OUTPUT_NAME - "${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}" - CXX_STANDARD - "${META_CXX_STANDARD}" - AUTOGEN_TARGET_DEPENDS - "${AUTOGEN_DEPS}") - endif () - foreach (DEPENDENCY ${PUBLIC_STATIC_LIBRARIES} ${PRIVATE_STATIC_LIBRARIES}) - if (NOT ${DEPENDENCY} IN_LIST META_PUBLIC_STATIC_LIB_DEPENDS) - list(APPEND META_PRIVATE_STATIC_LIB_DEPENDS ${DEPENDENCY}) +# add library to be created, set libs to link against, set version and C++ standard +if (META_HEADER_ONLY_LIB) + add_library(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} INTERFACE) + target_link_libraries(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} + INTERFACE ${META_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}" "${PRIVATE_LIBRARIES}") + target_include_directories( + ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} + INTERFACE $ + $ ${PUBLIC_INCLUDE_DIRS}) + target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} + INTERFACE + "${META_PUBLIC_COMPILE_DEFINITIONS}" + "${META_PRIVATE_COMPILE_DEFINITIONS}") + target_compile_options(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} + INTERFACE "${META_PUBLIC_COMPILE_OPTIONS}" + "${META_PRIVATE_COMPILE_OPTIONS}") +else () + add_library(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} ${META_LIBRARY_TYPE} ${ALL_FILES}) + target_link_libraries(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} + PUBLIC ${META_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}" + PRIVATE "${PRIVATE_LIBRARIES}") + target_include_directories(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} + PUBLIC $ + $ ${PUBLIC_INCLUDE_DIRS} + PRIVATE "${PRIVATE_INCLUDE_DIRS}") + target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} + PUBLIC + "${META_PUBLIC_COMPILE_DEFINITIONS}" + PRIVATE + "${META_PRIVATE_COMPILE_DEFINITIONS}") + target_compile_options(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} + PUBLIC "${META_PUBLIC_LIB_COMPILE_OPTIONS}" + PRIVATE "${META_PRIVATE_LIB_COMPILE_OPTIONS}") + set_target_properties(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} + PROPERTIES VERSION + "${META_VESION_MAJOR}.${META_VERSION_MINOR}.${META_VERSION_PATCH}" + SOVERSION + "${META_SOVERSION}" + CXX_STANDARD + "${META_CXX_STANDARD}" + LINK_SEARCH_START_STATIC + ${STATIC_LINKAGE} + LINK_SEARCH_END_STATIC + ${STATIC_LINKAGE} + AUTOGEN_TARGET_DEPENDS + "${AUTOGEN_DEPS}") +endif () +if (NOT BUILD_SHARED_LIBS) + foreach (DEPENDENCY ${PUBLIC_LIBRARIES} ${PRIVATE_LIBRARIES}) + if (NOT "${DEPENDENCY}" IN_LIST META_PUBLIC_LIB_DEPENDS) + list(APPEND META_PRIVATE_LIB_DEPENDS ${DEPENDENCY}) endif () endforeach () -endif () +endif() # Qt Creator does not show INTERFACE_SOURCES in project tree, so create a custom target as workaround if (META_HEADER_ONLY_LIB) @@ -230,14 +165,14 @@ if (META_HEADER_ONLY_LIB) ${HEADER_FILES}) target_include_directories(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_interface_sources_for_qtcreator INTERFACE $ - $ ${PUBLIC_SHARED_INCLUDE_DIRS}) + $ ${PUBLIC_INCLUDE_DIRS}) target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_interface_sources_for_qtcreator INTERFACE - "${META_PUBLIC_SHARED_LIB_COMPILE_DEFINITIONS}" - "${META_PRIVATE_SHARED_LIB_COMPILE_DEFINITIONS}") + "${META_PUBLIC_LIB_COMPILE_DEFINITIONS}" + "${META_PRIVATE_LIB_COMPILE_DEFINITIONS}") target_compile_options( ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_interface_sources_for_qtcreator - INTERFACE "${META_PUBLIC_SHARED_LIB_COMPILE_OPTIONS}" "${META_PRIVATE_SHARED_LIB_COMPILE_OPTIONS}") + INTERFACE "${META_PUBLIC_LIB_COMPILE_OPTIONS}" "${META_PRIVATE_LIB_COMPILE_OPTIONS}") set_target_properties(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_interface_sources_for_qtcreator PROPERTIES VERSION "${META_VERSION_MAJOR}.${META_VERSION_MINOR}.${META_VERSION_PATCH}" @@ -263,18 +198,6 @@ configure_package_config_file("${CONFIG_TEMPLATE_FILE}" LIB_INSTALL_DESTINATION) list(APPEND CMAKE_CONFIG_FILES "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}Config.cmake" "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}ConfigVersion.cmake") -if (BUILD_SHARED_LIBS) - find_template_file("SharedConfig.cmake" CPP_UTILITIES SHARED_CONFIG_TEMPLATE_FILE) - configure_file("${SHARED_CONFIG_TEMPLATE_FILE}" "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}SharedConfig.cmake" - @ONLY) - list(APPEND CMAKE_CONFIG_FILES "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}SharedConfig.cmake") -endif () -if (BUILD_STATIC_LIBS) - find_template_file("StaticConfig.cmake" CPP_UTILITIES STATIC_CONFIG_TEMPLATE_FILE) - configure_file("${STATIC_CONFIG_TEMPLATE_FILE}" "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}StaticConfig.cmake" - @ONLY) - list(APPEND CMAKE_CONFIG_FILES "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}StaticConfig.cmake") -endif () # write the CMake version config file write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}ConfigVersion.cmake @@ -283,7 +206,7 @@ write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME # create pkg-config file from template find_template_file("template.pc" CPP_UTILITIES PKGCONFIG_TEMPLATE_FILE) -macro (depends_for_pc LIB_TYPE DEPENDS OUTPUT_VAR_PKGS OUTPUT_VAR_LIBS) +macro (depends_for_pc DEPENDS OUTPUT_VAR_PKGS OUTPUT_VAR_LIBS) unset(${OUTPUT_VAR_PKGS}) unset(${OUTPUT_VAR_LIBS}) foreach (DEPENDENCY ${${DEPENDS}}) @@ -294,49 +217,43 @@ macro (depends_for_pc LIB_TYPE DEPENDS OUTPUT_VAR_PKGS OUTPUT_VAR_LIBS) "_" DEPENDENCY_VARNAME "${DEPENDENCY}") - if (PC_PKG_${LIB_TYPE}_${DEPENDENCY_VARNAME}) - set(${OUTPUT_VAR_PKGS} "${${OUTPUT_VAR_PKGS}} ${PC_PKG_${LIB_TYPE}_${DEPENDENCY_VARNAME}}") + if (PKG_CONFIG_${DEPENDENCY_VARNAME}) + # add pkg-config name of the dependency + set(${OUTPUT_VAR_PKGS} "${${OUTPUT_VAR_PKGS}} ${PKG_CONFIG_${DEPENDENCY_VARNAME}}") + elseif (TARGET "${DEPENDENCY}") + # add library location of the target + if (META_CURRENT_CONFIGURATION) + get_target_property("${DEPENDENCY_VARNAME}_IMPORTED_LOCATION_${META_CURRENT_CONFIGURATION}" "${DEPENDENCY}" "IMPORTED_LOCATION_${META_CURRENT_CONFIGURATION}") + if (EXISTS "${${DEPENDENCY_VARNAME}_IMPORTED_LOCATION_${META_CURRENT_CONFIGURATION}}") + set(${OUTPUT_VAR_LIBS} "${${OUTPUT_VAR_LIBS}} ${${DEPENDENCY_VARNAME}_IMPORTED_LOCATION_${META_CURRENT_CONFIGURATION}}") + endif() + endif() + get_target_property("${DEPENDENCY_VARNAME}_IMPORTED_LOCATION" "${DEPENDENCY}" IMPORTED_LOCATION) + if (EXISTS "${${DEPENDENCY_VARNAME}_IMPORTED_LOCATION}") + set(${OUTPUT_VAR_LIBS} "${${OUTPUT_VAR_LIBS}} ${${DEPENDENCY_VARNAME}_IMPORTED_LOCATION}") + endif() else () + # add raw dependency set(${OUTPUT_VAR_LIBS} "${${OUTPUT_VAR_LIBS}} ${DEPENDENCY}") endif () endforeach () endmacro () -macro (compile_defs_for_pc LIB_TYPE) - foreach (COMPILE_DEFINITION ${META_PUBLIC_${LIB_TYPE}_LIB_COMPILE_DEFINITIONS}) - set(META_COMPILE_DEFINITIONS_FOR_PC "${META_COMPILE_DEFINITIONS_FOR_PC} -D${COMPILE_DEFINITION}") - endforeach () -endmacro () unset(PC_FILES) -if (BUILD_SHARED_LIBS) - set(META_PROJECT_NAME_FOR_PC "${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}") - depends_for_pc(SHARED META_PUBLIC_SHARED_LIB_DEPENDS META_PUBLIC_PC_PKGS META_PUBLIC_LIB_DEPENDS_FOR_PC) - depends_for_pc(SHARED META_PRIVATE_SHARED_LIB_DEPENDS META_PRIVATE_PC_PKGS META_PRIVATE_LIB_DEPENDS_FOR_PC) - compile_defs_for_pc(SHARED) - if (NOT META_HEADER_ONLY_LIB) - set(META_PUBLIC_LIB_DEPENDS_FOR_PC - " -l${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}${META_PUBLIC_LIB_DEPENDS_FOR_PC}") - endif () - if (META_PUBLIC_LIB_DEPENDS_FOR_PC) - set(META_PUBLIC_LIB_DEPENDS_FOR_PC " -L\${libdir}${META_PUBLIC_LIB_DEPENDS_FOR_PC}") - endif () - configure_file("${PKGCONFIG_TEMPLATE_FILE}" "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME_FOR_PC}.pc" @ONLY) - list(APPEND PC_FILES "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME_FOR_PC}.pc") +set(META_PROJECT_NAME_FOR_PC "${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}") +depends_for_pc(META_PUBLIC_LIB_DEPENDS META_PUBLIC_PC_PKGS META_PUBLIC_LIB_DEPENDS_FOR_PC) +depends_for_pc(META_PRIVATE_LIB_DEPENDS META_PRIVATE_PC_PKGS META_PRIVATE_LIB_DEPENDS_FOR_PC) +foreach (COMPILE_DEFINITION ${META_PUBLIC_LIB_COMPILE_DEFINITIONS}) + set(META_COMPILE_DEFINITIONS_FOR_PC "${META_COMPILE_DEFINITIONS_FOR_PC} -D${COMPILE_DEFINITION}") +endforeach () +if (NOT META_HEADER_ONLY_LIB) + set(META_PUBLIC_LIB_DEPENDS_FOR_PC + " -l${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}${META_PUBLIC_LIB_DEPENDS_FOR_PC}") endif () -if (BUILD_STATIC_LIBS) - set(META_PROJECT_NAME_FOR_PC "${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static") - depends_for_pc(STATIC META_PUBLIC_STATIC_LIB_DEPENDS META_PUBLIC_PC_PKGS META_PUBLIC_LIB_DEPENDS_FOR_PC) - depends_for_pc(STATIC META_PRIVATE_STATIC_LIB_DEPENDS META_PRIVATE_PC_PKGS META_PRIVATE_LIB_DEPENDS_FOR_PC) - compile_defs_for_pc(STATIC) - if (NOT META_HEADER_ONLY_LIB) - set(META_PUBLIC_LIB_DEPENDS_FOR_PC - " -l${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}${META_PUBLIC_LIB_DEPENDS_FOR_PC}") - endif () - if (META_PUBLIC_LIB_DEPENDS_FOR_PC) - set(META_PUBLIC_LIB_DEPENDS_FOR_PC " -L\${libdir}${META_PUBLIC_LIB_DEPENDS_FOR_PC}") - endif () - configure_file("${PKGCONFIG_TEMPLATE_FILE}" "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME_FOR_PC}.pc" @ONLY) - list(APPEND PC_FILES "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME_FOR_PC}.pc") +if (META_PUBLIC_LIB_DEPENDS_FOR_PC) + set(META_PUBLIC_LIB_DEPENDS_FOR_PC " -L\${libdir}${META_PUBLIC_LIB_DEPENDS_FOR_PC}") endif () +configure_file("${PKGCONFIG_TEMPLATE_FILE}" "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME_FOR_PC}.pc" @ONLY) +list(APPEND PC_FILES "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME_FOR_PC}.pc") if (NOT META_NO_INSTALL_TARGETS AND ENABLE_INSTALL_TARGETS) # add install target for the CMake config files @@ -394,34 +311,17 @@ if (NOT META_NO_INSTALL_TARGETS AND ENABLE_INSTALL_TARGETS) endif () # add install targets and export targets - if (BUILD_SHARED_LIBS) - install(TARGETS ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} - EXPORT ${META_PROJECT_NAME}SharedTargets - RUNTIME DESTINATION bin COMPONENT binary - LIBRARY DESTINATION ${LIBRARY_DESTINATION} COMPONENT binary - ARCHIVE DESTINATION ${LIBRARY_DESTINATION} COMPONENT binary) - add_dependencies(install-binary ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}) - add_dependencies(install-binary-strip ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}) - # export shared lib - install(EXPORT ${META_PROJECT_NAME}SharedTargets - DESTINATION "share/${META_PROJECT_NAME}/cmake" - EXPORT_LINK_INTERFACE_LIBRARIES - COMPONENT cmake-config) - endif () - if (BUILD_STATIC_LIBS) - install(TARGETS ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static - EXPORT ${META_PROJECT_NAME}StaticTargets - RUNTIME DESTINATION bin COMPONENT binary - LIBRARY DESTINATION ${LIBRARY_DESTINATION} COMPONENT binary - ARCHIVE DESTINATION ${LIBRARY_DESTINATION} COMPONENT binary) - add_dependencies(install-binary ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static) - add_dependencies(install-binary-strip ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static) - # export static target - install(EXPORT ${META_PROJECT_NAME}StaticTargets - DESTINATION "share/${META_PROJECT_NAME}/cmake" - EXPORT_LINK_INTERFACE_LIBRARIES - COMPONENT cmake-config) - endif () + install(TARGETS ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} + EXPORT ${META_PROJECT_NAME}Targets + RUNTIME DESTINATION bin COMPONENT binary + LIBRARY DESTINATION ${LIBRARY_DESTINATION} COMPONENT binary + ARCHIVE DESTINATION ${LIBRARY_DESTINATION} COMPONENT binary) + add_dependencies(install-binary ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}) + add_dependencies(install-binary-strip ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}) + install(EXPORT ${META_PROJECT_NAME}Targets + DESTINATION "share/${META_PROJECT_NAME}/cmake" + EXPORT_LINK_INTERFACE_LIBRARIES + COMPONENT cmake-config) # add install target for header files if (NOT META_IS_PLUGIN) diff --git a/cmake/modules/TestTarget.cmake b/cmake/modules/TestTarget.cmake index 5b3cb86..a010b50 100644 --- a/cmake/modules/TestTarget.cmake +++ b/cmake/modules/TestTarget.cmake @@ -75,16 +75,6 @@ endif () # always link test applications against c++utilities list(APPEND TEST_LIBRARIES ${CPP_UTILITIES_LIB}) -# set compile definitions -if (NOT META_PUBLIC_SHARED_LIB_COMPILE_DEFINITIONS) - set(META_PUBLIC_SHARED_LIB_COMPILE_DEFINITIONS ${META_PUBLIC_COMPILE_DEFINITIONS} - ${META_ADDITIONAL_PUBLIC_SHARED_COMPILE_DEFINITIONS}) -endif () -if (NOT META_PRIVATE_SHARED_LIB_COMPILE_DEFINITIONS) - set(META_PRIVATE_SHARED_LIB_COMPILE_DEFINITIONS ${META_PRIVATE_COMPILE_DEFINITIONS} - ${META_ADDITIONAL_PRIVATE_SHARED_COMPILE_DEFINITIONS}) -endif () - # add target for test executable, but exclude it from the "all" target when EXCLUDE_TESTS_FROM_ALL is set if (EXCLUDE_TESTS_FROM_ALL) set(TESTS_EXCLUSION EXCLUDE_FROM_ALL) @@ -104,19 +94,14 @@ else () endif () # handle testing a library (which is default project type) -if (NOT META_PROJECT_TYPE OR "${META_PROJECT_TYPE}" STREQUAL "library") +if (META_PROJECT_IS_LIBRARY) # when testing a library, the test application always needs to link against it - if (BUILD_SHARED_LIBS) - list(APPEND TEST_LIBRARIES ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}) - message(STATUS "Linking test target dynamically against ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}") - else () - list(APPEND TEST_LIBRARIES ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static) - message(STATUS "Linking test target statically against ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}") - endif () + list(APPEND TEST_LIBRARIES ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}) + message(STATUS "Linking test target against ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}") endif () # handle testing an application -if ("${META_PROJECT_TYPE}" STREQUAL "application") +if (META_PROJECT_IS_APPLICATION) # using functions directly from the tests might be required -> also create a 'testlib' and link tests against it if (LINK_TESTS_AGAINST_APP_TARGET) # create target for the 'testlib' @@ -128,16 +113,16 @@ if ("${META_PROJECT_TYPE}" STREQUAL "application") PRIVATE "${PRIVATE_LIBRARIES}") target_include_directories(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_testlib PUBLIC $ - $ ${PUBLIC_SHARED_INCLUDE_DIRS} - PRIVATE "${PRIVATE_SHARED_INCLUDE_DIRS}") + $ ${PUBLIC_INCLUDE_DIRS} + PRIVATE "${PRIVATE_INCLUDE_DIRS}") target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_testlib PUBLIC - "${META_PUBLIC_SHARED_LIB_COMPILE_DEFINITIONS}" + "${META_PUBLIC_COMPILE_DEFINITIONS}" PRIVATE - "${META_PRIVATE_SHARED_LIB_COMPILE_DEFINITIONS}") + "${META_PRIVATE_COMPILE_DEFINITIONS}") target_compile_options(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_testlib - PUBLIC "${META_PUBLIC_SHARED_LIB_COMPILE_OPTIONS}" - PRIVATE "${META_PRIVATE_SHARED_LIB_COMPILE_OPTIONS}") + PUBLIC "${META_PUBLIC_COMPILE_OPTIONS}" + PRIVATE "${META_PRIVATE_COMPILE_OPTIONS}") set_target_properties(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_testlib PROPERTIES CXX_STANDARD "${META_CXX_STANDARD}" @@ -161,22 +146,22 @@ if ("${META_PROJECT_TYPE}" STREQUAL "application") endif () endif () -# actually apply configuration for test target +# configure test target target_link_libraries(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_tests PUBLIC ${ACTUAL_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}" PRIVATE "${TEST_LIBRARIES}" "${PRIVATE_LIBRARIES}") target_include_directories(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_tests PUBLIC $ - $ ${PUBLIC_SHARED_INCLUDE_DIRS} - PRIVATE ${TEST_INCLUDE_DIRS} "${PRIVATE_SHARED_INCLUDE_DIRS}") + $ ${PUBLIC_INCLUDE_DIRS} + PRIVATE ${TEST_INCLUDE_DIRS} "${PRIVATE_INCLUDE_DIRS}") target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_tests PUBLIC - "${META_PUBLIC_SHARED_LIB_COMPILE_DEFINITIONS}" + "${META_PUBLIC_COMPILE_DEFINITIONS}" PRIVATE - "${META_PRIVATE_SHARED_LIB_COMPILE_DEFINITIONS}") + "${META_PRIVATE_COMPILE_DEFINITIONS}") target_compile_options(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_tests - PUBLIC "${META_PUBLIC_SHARED_LIB_COMPILE_OPTIONS}" - PRIVATE "${META_PRIVATE_SHARED_LIB_COMPILE_OPTIONS}") + PUBLIC "${META_PUBLIC_COMPILE_OPTIONS}" + PRIVATE "${META_PRIVATE_COMPILE_OPTIONS}") set_target_properties(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_tests PROPERTIES CXX_STANDARD "${META_CXX_STANDARD}" diff --git a/cmake/templates/Config.cmake.in b/cmake/templates/Config.cmake.in index 46dcf1d..27ab946 100644 --- a/cmake/templates/Config.cmake.in +++ b/cmake/templates/Config.cmake.in @@ -2,7 +2,6 @@ # provide meta-data set(@META_PROJECT_NAME@_varname "@META_PROJECT_VARNAME_UPPER@") -set(@META_PROJECT_NAME@_static_varname "@META_PROJECT_VARNAME_UPPER@") set(@META_PROJECT_VARNAME_UPPER@_DISPLAY_NAME "@META_APP_NAME@") set(@META_PROJECT_VARNAME_UPPER@_AUTHOR "@META_APP_AUTHOR@") set(@META_PROJECT_VARNAME_UPPER@_VERSION "@META_APP_VERSION@") @@ -17,8 +16,6 @@ set(@META_PROJECT_VARNAME_UPPER@_LICENSE "@META_PROJECT_LICENSE@") # define general config set(@META_PROJECT_VARNAME_UPPER@_IS_HEADER_ONLY @META_HEADER_ONLY_LIB@) -set(@META_PROJECT_VARNAME_UPPER@_HAS_SHARED_LIB @BUILD_SHARED_LIBS@) -set(@META_PROJECT_VARNAME_UPPER@_HAS_STATIC_LIB @BUILD_STATIC_LIBS@) set(@META_PROJECT_VARNAME_UPPER@_INCLUDE_DIRS "@PACKAGE_HEADER_INSTALL_DESTINATION@") set(@META_PROJECT_VARNAME_UPPER@_BIN_DIR "@PACKAGE_BIN_INSTALL_DESTINATION@") set(@META_PROJECT_VARNAME_UPPER@_LIB_DIR "@PACKAGE_LIB_INSTALL_DESTINATION@") @@ -31,49 +28,48 @@ set(@META_PROJECT_VARNAME_UPPER@_PUBLIC_KF_MODULES "@META_PUBLIC_KF_MODULES@") set(@META_PROJECT_VARNAME_UPPER@_HAS_QT_TRANSLATION_FILES @APP_SPECIFIC_QT_TRANSLATIONS_AVAILABLE@) set(@META_PROJECT_VARNAME_UPPER@_QT_RESOURCES @QT_RESOURCES@) -# include files for shared/static specific configuration -set(@META_PROJECT_VARNAME_UPPER@_HAS_SHARED_LIB NO) -set(@META_PROJECT_VARNAME_UPPER@_HAS_STATIC_LIB NO) -file(GLOB @META_PROJECT_VARNAME_UPPER@_SPECIFIC_CONFIG_FILES - LIST_DIRECTORIES OFF - "${CMAKE_CURRENT_LIST_DIR}/@META_PROJECT_NAME@?*Config.cmake" -) -foreach(SPECIFIC_CONFIG_FILE IN LISTS @META_PROJECT_VARNAME_UPPER@_SPECIFIC_CONFIG_FILES) - include("${SPECIFIC_CONFIG_FILE}") -endforeach() -unset(SPECIFIC_CONFIG_FILE) - -# set default target: prefer shared lib over static lib -if(@META_PROJECT_VARNAME_UPPER@_HAS_SHARED_LIB) - set(@META_PROJECT_VARNAME_UPPER@_LIB "@TARGET_PREFIX@@META_PROJECT_NAME@@TARGET_SUFFIX@") -else() - set(@META_PROJECT_VARNAME_UPPER@_LIB "@TARGET_PREFIX@@META_PROJECT_NAME@@TARGET_SUFFIX@_static") +# define library config +set(@META_PROJECT_VARNAME_UPPER@_LIB "@TARGET_PREFIX@@META_PROJECT_NAME@@TARGET_SUFFIX@") +set(@META_PROJECT_VARNAME_UPPER@_LIB_IS_SHARED "@BUILD_SHARED_LIBS@") +set(PKG_CONFIG_@META_PROJECT_NAME@ "@META_PROJECT_NAME@") +if(NOT TARGET "${@META_PROJECT_VARNAME_UPPER@_LIB}") + include("${CMAKE_CURRENT_LIST_DIR}/@META_PROJECT_NAME@Targets.cmake") endif() -# define macro to ease use of library in projects following conventions of c++utilities' build script -macro(use_@META_PROJECT_VARNAME@) +# define function to ease use of library in projects following conventions of c++utilities' build script +function(use_@META_PROJECT_VARNAME@) + # parse arguments + include(3rdParty) + parse_arguments_for_use_functions(${ARGN}) + # make CMake modules of the project available - list(APPEND CMAKE_MODULE_PATH ${@META_PROJECT_VARNAME_UPPER@_MODULE_DIRS}) + set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH};${@META_PROJECT_VARNAME_UPPER@_MODULE_DIRS}" PARENT_SCOPE) + # link against library (also "link" against header-only libs to get compile defs and interface link libs) link_directories(${@META_PROJECT_VARNAME_UPPER@_LIB_DIR}) - include(3rdParty) - if(NOT ARGV0) - set(@META_PROJECT_VARNAME_UPPER@_LINKAGE AUTO_LINKAGE) - else() - set(@META_PROJECT_VARNAME_UPPER@_LINKAGE "${ARG0}") - endif() - link_against_library(@META_PROJECT_VARNAME_UPPER@ "${@META_PROJECT_VARNAME_UPPER@_LINKAGE}" REQUIRED) + set("${ARGS_LIBRARIES_VARIABLE}" "${${ARGS_LIBRARIES_VARIABLE}};${@META_PROJECT_VARNAME_UPPER@_LIB}" PARENT_SCOPE) + # add required Qt and KF modules - list(APPEND IMPORTED_QT_MODULES + set(IMPORTED_QT_MODULES + ${IMPORTED_QT_MODULES} ${@META_PROJECT_VARNAME_UPPER@_PUBLIC_QT_MODULES} ${@META_PROJECT_VARNAME_UPPER@_PRIVATE_QT_MODULES} + PARENT_SCOPE ) - list(APPEND IMPORTED_KF_MODULES + set(IMPORTED_KF_MODULES + ${IMPORTED_KF_MODULES} ${@META_PROJECT_VARNAME_UPPER@_PUBLIC_KF_MODULES} ${@META_PROJECT_VARNAME_UPPER@_PRIVATE_KF_MODULES} + PARENT_SCOPE ) + # add required translations to APP_SPECIFIC_QT_TRANSLATION_FILES_ARRAY if(@META_PROJECT_VARNAME_UPPER@_HAS_QT_TRANSLATION_FILES) - list(APPEND APP_SPECIFIC_QT_TRANSLATION_FILES @META_PROJECT_NAME@) + set(APP_SPECIFIC_QT_TRANSLATION_FILES "${APP_SPECIFIC_QT_TRANSLATION_FILES};@META_PROJECT_NAME@" PARENT_SCOPE) endif() -endmacro() + + # add Qt resources if it is a static library + if (NOT @META_PROJECT_VARNAME_UPPER@_LIB_IS_SHARED) + set(STATIC_LIBRARIES_QT_RESOURCES "${STATIC_LIBRARIES_QT_RESOURCES};${@META_PROJECT_VARNAME_UPPER@_QT_RESOURCES}" PARENT_SCOPE) + endif() +endfunction() diff --git a/cmake/templates/SharedConfig.cmake.in b/cmake/templates/SharedConfig.cmake.in deleted file mode 100644 index 641f1c2..0000000 --- a/cmake/templates/SharedConfig.cmake.in +++ /dev/null @@ -1,9 +0,0 @@ -# define shared library config -set(@META_PROJECT_VARNAME_UPPER@_HAS_SHARED_LIB YES) -set(@META_PROJECT_VARNAME_UPPER@_SHARED_LIB "@TARGET_PREFIX@@META_PROJECT_NAME@@TARGET_SUFFIX@") -set(@META_PROJECT_VARNAME_UPPER@_SHARED_LIB_DEPENDS @META_PUBLIC_SHARED_LIB_DEPENDS@) -set(@META_PROJECT_VARNAME_UPPER@_SHARED_LIB_COMPILE_DEFINITIONS @META_PUBLIC_SHARED_LIB_COMPILE_DEFINITIONS@) -set(PC_PKG_SHARED_@TARGET_PREFIX@@META_PROJECT_NAME@@TARGET_SUFFIX@ "@TARGET_PREFIX@@META_PROJECT_NAME@@TARGET_SUFFIX@") -if(NOT TARGET "${@META_PROJECT_VARNAME_UPPER@_SHARED_LIB}") - include("${CMAKE_CURRENT_LIST_DIR}/@META_PROJECT_NAME@SharedTargets.cmake") -endif() diff --git a/cmake/templates/StaticConfig.cmake.in b/cmake/templates/StaticConfig.cmake.in deleted file mode 100644 index a2469c3..0000000 --- a/cmake/templates/StaticConfig.cmake.in +++ /dev/null @@ -1,9 +0,0 @@ -# define static library config -set(@META_PROJECT_VARNAME_UPPER@_HAS_STATIC_LIB YES) -set(@META_PROJECT_VARNAME_UPPER@_STATIC_LIB "@TARGET_PREFIX@@META_PROJECT_NAME@@TARGET_SUFFIX@_static") -set(@META_PROJECT_VARNAME_UPPER@_STATIC_LIB_DEPENDS @META_PUBLIC_STATIC_LIB_DEPENDS@ @META_PRIVATE_STATIC_LIB_DEPENDS@) -set(@META_PROJECT_VARNAME_UPPER@_STATIC_LIB_COMPILE_DEFINITIONS @META_PUBLIC_STATIC_LIB_COMPILE_DEFINITIONS@) -set(PC_PKG_STATIC_@TARGET_PREFIX@@META_PROJECT_NAME@@TARGET_SUFFIX@_static "@TARGET_PREFIX@@META_PROJECT_NAME@@TARGET_SUFFIX@_static") -if(NOT TARGET "${@META_PROJECT_VARNAME_UPPER@_STATIC_LIB}") - include("${CMAKE_CURRENT_LIST_DIR}/@META_PROJECT_NAME@StaticTargets.cmake") -endif() diff --git a/cmake/templates/config.h.in b/cmake/templates/config.h.in index 9d9e114..e0a6d6c 100644 --- a/cmake/templates/config.h.in +++ b/cmake/templates/config.h.in @@ -13,6 +13,5 @@ #define APP_DESCRIPTION "@META_APP_DESCRIPTION@" #define APP_INSTALL_PREFIX "@CMAKE_INSTALL_PREFIX@" #define DEPENCENCY_VERSIONS {@DEPENCENCY_VERSIONS_ARRAY@} -#define STATIC_DEPENCENCY_VERSIONS {@STATIC_DEPENCENCY_VERSIONS_ARRAY@} @META_CUSTOM_CONFIG@ #endif // @META_PROJECT_VARNAME_UPPER@_CONFIG diff --git a/doc/buildvariables.md b/doc/buildvariables.md index c06db70..bba2385 100644 --- a/doc/buildvariables.md +++ b/doc/buildvariables.md @@ -10,9 +10,15 @@ install prefix is set via `make` argument `DESTDIR=path`) * `CMAKE_BUILD_TYPE=Release/Debug`: specifies whether to do a debug or a release build +* `BUILD_SHARED_LIBS=ON/OFF`: whether to build shared libraries (`ON`) or static + libraries (`OFF`); it is not possible to build both at the same time within the + same build process * `CMAKE_SKIP_BUILD_RPATH=OFF`: ensures the rpath is set in the build tree * `CMAKE_INSTALL_RPATH=rpath`: sets the rpath used when installing * `CMAKE_CXX_FLAGS`: sets flags to be passed to the C++ compiler +* `CMAKE_FIND_LIBRARY_SUFFIXES`: sets the library suffixes the build script will + consider, e.g. set to `.a;.lib` to prefer static Windows libraries or to + `.dll;.dll.a` to prefer shared Windows libraries ### Custom variables The following variables are read by the CMake modules provided by `c++utilities` @@ -27,23 +33,9 @@ None of these are enabled or set by default, unless stated otherwise. * `LIB_SUFFIX_64=suffix`: suffix for library install directory * used when building for 64-bit platforms * overrides general `LIB_SUFFIX` when building for 64-bit platforms -* `ENABLE_STATIC_LIBS=ON/OFF`: enables building static libs -* `DISABLE_SHARED_LIBS=ON/OFF`: disables building shared libs -* `STATIC_LINKAGE=ON/OFF`: enables linking applications *preferably* against - static libraries - * by default dynamic libraries are preferred - * only affect building applications -* `STATIC_LIBRARY_LINKAGE=ON/OFF`: enables linking dynamic libraries *preferably* - against static libraries - * by default linking against dynamic libraries is preferred - * only affects building dynamic libraries (static libraries are just archives - of objects and hence *not linked* against their dependencies when being built) - * note that static libraries are always preferred to provide the dependency - of another static library - * eg. linking against static `c++utilities` requires also linking against - its dependency `iconv`; the static version of `iconv` is preferred - * this behaviour has actually nothing to do with `STATIC_LIBRARY_LINKAGE` - and can currently not be controlled +* `QT_PACKAGE_PREFIX=Qt5`: sets the prefix for Qt packages, by default `Qt5` +* `KF_PACKAGE_PREFIX=KF5`: sets the prefix for KDE Frameworks packages, by + default `KF5`` * `SHELL_COMPLETION_ENABLED=ON/OFF`: enables shell completion in general (enabled by default) * `BASH_COMPLETION_ENABLED=ON/OFF`: enables Bash completion (enabled by @@ -108,14 +100,10 @@ If the detection does not work as expected or a library from a non-standard location should be used, the following variables can be used to specify the location of libraries and include directories directly: -* `dependency_DYNAMIC_LIB`: specifies the locations of the dynamic libraries - for *dependency* -* `dependency_STATIC_LIB`: specifies the locations of the static libraries - for *dependency* +* `dependency__LIBRARY_PATH`: specifies the locations of the library required + by *dependency* * `dependency_DYNAMIC_INCLUDE_DIR`: specifies the locations of the additional - include directories required for using the dynamic version of the *dependency* -* `dependency_STATIC_INCLUDE_DIR`: specifies the locations of the additional - include directories required for using the static version of the *dependency* + include directories required the *dependency* *Note about Qt*: Qt modules are always configured using the CMake packages via `find_package`. So using the variables described above to specify a custom location @@ -196,13 +184,10 @@ cmake \ * only relevant when using static Qt * `WEBVIEW_PROVIDER=auto/webkit/webengine/none`: specifies the Qt module to use for the web view -* `JS_PROVIDER=auto/script/qml/none`: specifies the Qt module to use +* `JS_PROVIDER=qml/script/none`: specifies the Qt module to use for the JavaScript engine -* `QT_LINKAGE=AUTO_LINKAGE/STATIC/SHARED`: specifies whether to use static - or shared version of Qt (only works with Qt packages provided in the AUR) -* `ADDITIONAL_QT_MODULES=Network;Concurrent;...`: specifies additional Qt - modules to link against (only use for modules which can not be added - automatically) +* `WEBVIEW_PROVIDER=webengine/webkit/none`: specifies the Qt module to use + for the built-in web view ## Variables to be set in project file