Martchus
/
cpp-utilities
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Don't mix building static and shared libraries

This commit is contained in:
Martchus 2019-04-03 22:06:27 +02:00
parent 6d7a6ab735
commit e9cc26478b
13 changed files with 362 additions and 737 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
CMakeLists.txt
View File

@ -82,8 +82,6 @@ set(CMAKE_MODULE_FILES
set(CMAKE_TEMPLATE_FILES set(CMAKE_TEMPLATE_FILES
cmake/templates/bash-completion.sh.in cmake/templates/bash-completion.sh.in
cmake/templates/Config.cmake.in cmake/templates/Config.cmake.in
cmake/templates/SharedConfig.cmake.in
cmake/templates/StaticConfig.cmake.in
cmake/templates/config.h.in cmake/templates/config.h.in
cmake/templates/desktop.in cmake/templates/desktop.in
cmake/templates/appdata.xml.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) PROPERTY COMPILE_DEFINITIONS ${META_PROJECT_VARNAME}_USE_GNU_CXX_STDIO_FILEBUF)
else () else ()
message(STATUS "Using boost::iostreams::stream_buffer<boost::iostreams::file_descriptor_sink> for NativeFileStream") message(STATUS "Using boost::iostreams::stream_buffer<boost::iostreams::file_descriptor_sink> for NativeFileStream")
set(boost_iostreams_DYNAMIC_COMPILE_DEFINITIONS BOOST_IOSTREAMS_DYN_LINK) find_package(Boost REQUIRED COMPONENTS iostreams)
use_external_library(boost_iostreams AUTO_LINKAGE REQUIRED) use_target(TARGET_NAME Boost::iostreams)
set_property(SOURCE io/nativefilestream.cpp set_property(SOURCE io/nativefilestream.cpp
APPEND APPEND
PROPERTY COMPILE_DEFINITIONS ${META_PROJECT_VARNAME}_USE_BOOST_IOSTREAMS) PROPERTY COMPILE_DEFINITIONS ${META_PROJECT_VARNAME}_USE_BOOST_IOSTREAMS)

4
application/argumentparser.h
View File

@ -30,11 +30,7 @@ CPP_UTILITIES_EXPORT extern std::vector<const char *> dependencyVersions2;
* used by ArgumentParser::printHelp(). * used by ArgumentParser::printHelp().
* \remarks Reads those data from the config header so "config.h" must be included. * \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 #define SET_DEPENDENCY_INFO ::ApplicationUtilities::dependencyVersions2 = DEPENCENCY_VERSIONS
#else
#define SET_DEPENDENCY_INFO ::ApplicationUtilities::dependencyVersions2 = STATIC_DEPENCENCY_VERSIONS
#endif
/*! /*!
* \def SET_APPLICATION_INFO * \def SET_APPLICATION_INFO

427
cmake/modules/3rdParty.cmake
View File

@ -35,311 +35,44 @@ macro (configure_dynamic_library_suffixes)
endif () endif ()
endmacro () endmacro ()
macro (link_against_library_varnames function(validate_visibility VISIBILITY)
NAME if (NOT (VISIBILITY STREQUAL PUBLIC OR VISIBILITY STREQUAL PRIVATE))
LINKAGE message(FATAL_ERROR "Specified visibility ${VISIBILITY} is invalid (must be either PUBLIC or PRIVATE).")
REQUIRED endif()
PRIVATE_LIBRARIES_VARNAME endfunction()
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 ()
# add library to list of libraries to link against when building dynamic libraries or applications - prefer dynamic lib function(parse_arguments_for_use_functions)
# if linkage not explicitely specified # parse arguments
if (${NAME}_STATIC_LIB set(OPTIONAL_ARGS OPTIONAL)
AND (("${LINKAGE}" STREQUAL "AUTO_LINKAGE" set(ONE_VALUE_ARGS VISIBILITY LIBRARIES_VARIABLE TARGET_NAME)
AND ((NOT (${NAME}_DYNAMIC_LIB OR ${NAME}_SHARED_LIB)) set(MULTI_VALUE_ARGS)
OR (STATIC_LINKAGE AND "${META_PROJECT_TYPE}" STREQUAL "application") cmake_parse_arguments(ARGS "${OPTIONAL_ARGS}" "${ONE_VALUE_ARGS}" "${MULTI_VALUE_ARGS}" ${ARGN})
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 ()
if (${${NAME}_STATIC_LIB} IN_LIST META_PUBLIC_STATIC_LIB_DEPENDS OR ${NAME} IN_LIST META_PUBLIC_STATIC_LIB_DEPENDS) # validate values
list(APPEND ${PUBLIC_LIBRARIES_VARNAME} ${${NAME}_STATIC_LIB}) if (ARGS_VISIBILITY)
if (${NAME}_STATIC_INCLUDE_DIR) validate_visibility(${ARGS_VISIBILITY})
list(APPEND PUBLIC_SHARED_INCLUDE_DIRS ${${NAME}_STATIC_INCLUDE_DIR}) else()
endif () set (ARGS_VISIBILITY PRIVATE)
else () endif()
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 ()
# add Qt resources of static library to be enabled if (NOT ARGS_LIBRARIES_VARIABLE)
if (${NAME}_QT_RESOURCES) set (ARGS_LIBRARIES_VARIABLE "${ARGS_VISIBILITY}_LIBRARIES")
message(STATUS "Adding ${${NAME}_QT_RESOURCES} to LIBRARIES_QT_RESOURCES for ${META_PROJECT_NAME}.") endif()
list(APPEND LIBRARIES_QT_RESOURCES ${${NAME}_QT_RESOURCES})
endif ()
elseif ((${NAME}_DYNAMIC_LIB OR ${NAME}_SHARED_LIB) # export parsed values to parent scope
AND (("${LINKAGE}" STREQUAL "AUTO_LINKAGE") OR ("${LINKAGE}" STREQUAL "SHARED"))) set(ARGS_VISIBILITY "${ARGS_VISIBILITY}" PARENT_SCOPE)
set(USE_${NAME} ON) set(ARGS_LIBRARIES_VARIABLE "${ARGS_LIBRARIES_VARIABLE}" PARENT_SCOPE)
set(USE_SHARED_${NAME} ON) set(ARGS_TARGET_NAME "${ARGS_TARGET_NAME}" PARENT_SCOPE)
if (NOT ${NAME}_DYNAMIC_LIB) set(ARGS_OPTIONAL "${ARGS_OPTIONAL}" PARENT_SCOPE)
set(${NAME}_DYNAMIC_LIB ${${NAME}_SHARED_LIB}) if (NOT ARGS_OPTIONAL)
endif () set(ARGS_FIND_PACKAGE "REQUIRED" PARENT_SCOPE)
list(APPEND LIBRARIES ${${NAME}_DYNAMIC_LIB}) endif()
message( endfunction()
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 ()
if (${${NAME}_DYNAMIC_LIB} IN_LIST META_PUBLIC_SHARED_LIB_DEPENDS OR ${NAME} IN_LIST META_PUBLIC_SHARED_LIB_DEPENDS) function (use_iconv)
list(APPEND ${PUBLIC_LIBRARIES_VARNAME} ${${NAME}_DYNAMIC_LIB}) parse_arguments_for_use_functions(${ARGN})
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 ()
# add library to list of libraries to be provided as transitive dependencies when building static libraries - prefer # check whether iconv from the standard library can be used
# 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)
set(FORCE_EXTERNAL_ICONV OFF set(FORCE_EXTERNAL_ICONV OFF
CACHE PATH "whether to force usage of external iconv (rather than the using the one bundled with glibc)") CACHE PATH "whether to force usage of external iconv (rather than the using the one bundled with glibc)")
if (NOT FORCE_EXTERNAL_ICONV) if (NOT FORCE_EXTERNAL_ICONV)
@ -348,9 +81,93 @@ macro (use_iconv LINKAGE REQUIRED)
check_function_exists(iconv HAS_ICONV) check_function_exists(iconv HAS_ICONV)
endif () endif ()
if (NOT FORCE_EXTERNAL_ICONV AND HAS_ICONV) if (NOT FORCE_EXTERNAL_ICONV AND HAS_ICONV)
message(STATUS "Using iconv from the standard library for ${META_PROJECT_NAME}.") message(STATUS "Using iconv from the standard library for target ${META_PROJECT_NAME}.")
else () return()
# find external iconv library endif()
use_external_library(iconv ${LINKAGE} ${REQUIRED})
endif () # find external iconv library
endmacro () 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()

43
cmake/modules/AppTarget.cmake
View File

@ -18,26 +18,6 @@ if (WIN32)
set(WINDOWS_EXT "exe") set(WINDOWS_EXT "exe")
endif (WIN32) 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 # define relevant files
set(ALL_FILES set(ALL_FILES
${HEADER_FILES} ${HEADER_FILES}
@ -52,27 +32,30 @@ if (NOT BUILTIN_TRANSLATIONS)
endif () endif ()
# add target for building the application # add target for building the application
if (NOT ANDROID) if (ANDROID)
add_executable(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} ${GUI_TYPE} ${ALL_FILES}) # create a shared library which can be loaded from the Java-side
else ()
# create a library which can be loaded from the Java-side
add_library(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} SHARED ${GUI_TYPE} ${ALL_FILES}) 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 () 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} 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}") PRIVATE "${PRIVATE_LIBRARIES}")
target_include_directories(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} target_include_directories(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}
PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}> PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
$<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_SHARED_INCLUDE_DIRS} $<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_SHARED_INCLUDE_DIRS}
PRIVATE "${PRIVATE_SHARED_INCLUDE_DIRS}") PRIVATE "${PRIVATE_INCLUDE_DIRS}")
target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}
PUBLIC PUBLIC
"${META_PUBLIC_SHARED_LIB_COMPILE_DEFINITIONS}" "${META_PUBLIC_COMPILE_DEFINITIONS}"
PRIVATE PRIVATE
"${META_PRIVATE_SHARED_LIB_COMPILE_DEFINITIONS}") "${META_PRIVATE_COMPILE_DEFINITIONS}")
target_compile_options(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} target_compile_options(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}
PUBLIC "${META_PUBLIC_SHARED_LIB_COMPILE_OPTIONS}" PUBLIC "${META_PUBLIC_COMPILE_OPTIONS}"
PRIVATE "${META_PRIVATE_SHARED_LIB_COMPILE_OPTIONS}") PRIVATE "${META_PRIVATE_COMPILE_OPTIONS}")
set_target_properties(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} set_target_properties(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}
PROPERTIES CXX_STANDARD PROPERTIES CXX_STANDARD
"${META_CXX_STANDARD}" "${META_CXX_STANDARD}"

40
cmake/modules/BasicConfig.cmake
View File

@ -12,6 +12,8 @@ if (NOT META_APP_DESCRIPTION)
message(FATAL_ERROR "No project name (META_APP_DESCRIPTION) specified.") message(FATAL_ERROR "No project name (META_APP_DESCRIPTION) specified.")
endif () endif ()
string(TOUPPER "${CMAKE_BUILD_TYPE}" META_CURRENT_CONFIGURATION)
# set project name (displayed in Qt Creator) # set project name (displayed in Qt Creator)
message(STATUS "Configuring project ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}") message(STATUS "Configuring project ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}")
project(${META_PROJECT_NAME}) project(${META_PROJECT_NAME})
@ -165,41 +167,6 @@ if (LOGGING_ENABLED)
message(STATUS "Logging is enabled.") message(STATUS "Logging is enabled.")
endif () 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 # 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) 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) set(META_HEADER_ONLY_LIB NO)
@ -211,6 +178,9 @@ else ()
message(STATUS "Project ${META_PROJECT_NAME} is header-only library.") message(STATUS "Project ${META_PROJECT_NAME} is header-only library.")
endif () 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) # 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 (WIDGETS_HEADER_FILES OR WIDGETS_SRC_FILES OR WIDGETS_UI_FILES OR META_HAS_WIDGETS_GUI)
if (META_GUI_OPTIONAL) if (META_GUI_OPTIONAL)

90
cmake/modules/ConfigHeader.cmake
View File

@ -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 # before including this module, all relevant variables must be set just include this module as last one since nothing should
# depend on it # depend on it
@ -9,48 +11,61 @@ endif ()
include(TemplateFinder) include(TemplateFinder)
find_template_file("config.h" CPP_UTILITIES CONFIG_H_TEMPLATE_FILE) 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 # create list of dependency versions present at link time
# since the lists might differ)
include(ListToString) include(ListToString)
foreach (LINKAGE IN ITEMS "" "STATIC_") unset(DEPENCENCY_VERSIONS)
unset(DEPENCENCY_VERSIONS) unset(DEPENCENCY_VERSIONS_ARRAY)
unset(${LINKAGE}DEPENCENCY_VERSIONS_ARRAY) unset(LINK_LIBRARIES_LIST)
# iterate through public and private libraries of shared/static library unset(INTERFACE_LINK_LIBRARIES_LIST)
foreach (DEPENDENCY IN LISTS PUBLIC_${LINKAGE}LIBRARIES PRIVATE_${LINKAGE}LIBRARIES) unset(PROCESSED_DEPENDENCIES)
if (TARGET ${DEPENDENCY}) unset(HAVE_OPENSSL)
unset(DEPENDENCY_DISPLAY_NAME) if (NOT META_HEADER_ONLY_LIB)
unset(DEPENDENCY_VER) 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 # find version and display name for target
if (DEPENDENCY MATCHES "(Static)?Qt5::([A-Za-z0-9]+)") if (DEPENDENCY MATCHES "((Static)?Qt5)::([A-Za-z0-9]+)")
# read meta-data of Qt module # read meta-data of Qt module
set(DEPENDENCY_MODULE_NAME "${CMAKE_MATCH_2}") set(DEPENDENCY_MODULE_PREFIX "${CMAKE_MATCH_1}")
set(DEPENDENCY_DISPLAY_NAME "Qt ${DEPENDENCY_MODULE_NAME}") set(DEPENDENCY_MODULE_NAME "${CMAKE_MATCH_3}")
set(DEPENDENCY_VER "${Qt5${DEPENDENCY_MODULE_NAME}_VERSION_STRING}") set(DEPENDENCY_DISPLAY_NAME "Qt ${DEPENDENCY_MODULE_NAME}")
elseif (${DEPENDENCY}_varname) set(DEPENDENCY_VER "${${DEPENDENCY_MODULE_PREFIX}${DEPENDENCY_MODULE_NAME}_VERSION_STRING}")
# read meta-data of one of my own libraries elseif (DEPENDENCY STREQUAL ZLIB::ZLIB)
set(DEPENDENCY_VARNAME "${${DEPENDENCY}_varname}") set(DEPENDENCY_DISPLAY_NAME "zlib")
set(DEPENDENCY_DISPLAY_NAME "${DEPENDENCY}") set(DEPENDENCY_VER "${ZLIB_VERSION_STRING}")
if (${DEPENDENCY_VARNAME}_DISPLAY_NAME) elseif (NOT HAVE_OPENSSAL AND (DEPENDENCY STREQUAL OpenSSL::SSL OR DEPENDENCY STREQUAL OpenSSL::Crypto))
set(DEPENDENCY_DISPLAY_NAME "${${DEPENDENCY_VARNAME}_DISPLAY_NAME}") set(DEPENDENCY_DISPLAY_NAME "OpenSSL")
endif () set(DEPENDENCY_VER "${OPENSSL_VERSION}")
set(DEPENDENCY_VER "${${DEPENDENCY_VARNAME}_VERSION}") elseif (${DEPENDENCY}_varname)
endif () # read meta-data of one of my own libraries
# FIXME: provide meta-data for other libs, too set(DEPENDENCY_VARNAME "${${DEPENDENCY}_varname}")
set(DEPENDENCY_DISPLAY_NAME "${DEPENDENCY}")
if (DEPENDENCY_VER if (${DEPENDENCY_VARNAME}_DISPLAY_NAME)
AND NOT set(DEPENDENCY_DISPLAY_NAME "${${DEPENDENCY_VARNAME}_DISPLAY_NAME}")
"${DEPENDENCY_VER}"
STREQUAL
"DEPENDENCY_VER-NOTFOUND")
list(APPEND DEPENCENCY_VERSIONS "${DEPENDENCY_DISPLAY_NAME}: ${DEPENDENCY_VER}")
endif ()
endif () endif ()
endforeach () set(DEPENDENCY_VER "${${DEPENDENCY_VARNAME}_VERSION}")
if (DEPENCENCY_VERSIONS) endif ()
list_to_string("," " \\\n \"" "\"" "${DEPENCENCY_VERSIONS}" ${LINKAGE}DEPENCENCY_VERSIONS_ARRAY) # 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 () endif ()
endforeach () endforeach ()
if (DEPENCENCY_VERSIONS)
list_to_string("," " \\\n \"" "\"" "${DEPENCENCY_VERSIONS}" DEPENCENCY_VERSIONS_ARRAY)
endif ()
# add configuration header # add configuration header
configure_file("${CONFIG_H_TEMPLATE_FILE}" "${CMAKE_CURRENT_BINARY_DIR}/resources/config.h") 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) if (NOT META_HEADER_ONLY_LIB)
foreach (TARGET_NAME foreach (TARGET_NAME
${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} ${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}_tests
${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_testlib) ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_testlib)
if (TARGET ${TARGET_NAME}) if (TARGET ${TARGET_NAME})

312
cmake/modules/LibraryTarget.cmake
View File

@ -40,25 +40,10 @@ if (MINGW)
set(WINDOWS_EXT "dll") set(WINDOWS_EXT "dll")
endif (MINGW) endif (MINGW)
# set compile definitions # set compile definitions for static build
if (NOT META_PUBLIC_SHARED_LIB_COMPILE_DEFINITIONS) if (NOT BUILD_SHARED_LIBS)
set(META_PUBLIC_SHARED_LIB_COMPILE_DEFINITIONS ${META_PUBLIC_COMPILE_DEFINITIONS} list(APPEND META_PUBLIC_COMPILE_DEFINITIONS ${META_PROJECT_VARNAME_UPPER}_STATIC)
${META_ADDITIONAL_PUBLIC_SHARED_COMPILE_DEFINITIONS}) endif()
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 ()
# add global library-specific header # add global library-specific header
find_template_file("global.h" CPP_UTILITIES GLOBAL_H_TEMPLATE_FILE) 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}") set(META_SOVERSION "${META_VERSION_MAJOR}")
endif () endif ()
endif () endif ()
message(STATUS "${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}: BUILD_SHARED_LIBS=${BUILD_SHARED_LIBS}")
# define relevant files # define relevant files
set(ALL_FILES set(ALL_FILES
@ -107,118 +91,69 @@ endif ()
# add target for building the library # add target for building the library
if (BUILD_SHARED_LIBS) 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) if (META_IS_PLUGIN)
set(META_SHARED_OBJECT_TYPE MODULE) set(META_LIBRARY_TYPE MODULE)
else () else ()
set(META_SHARED_OBJECT_TYPE SHARED) set(META_LIBRARY_TYPE SHARED)
endif () endif ()
# add library to be created, set libs to link against, set version and C++ standard else()
if (META_HEADER_ONLY_LIB) set(META_LIBRARY_TYPE STATIC)
add_library(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} INTERFACE) endif()
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 $<BUILD_INTERFACE:${TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE}>
$<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${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 $<BUILD_INTERFACE:${TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE}>
$<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${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 ()
# add target for building a static version of the library # add library to be created, set libs to link against, set version and C++ standard
if (BUILD_STATIC_LIBS) if (META_HEADER_ONLY_LIB)
# add library to be created, set required libs, set version and C++ standard add_library(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} INTERFACE)
if (META_HEADER_ONLY_LIB) target_link_libraries(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}
add_library(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static INTERFACE) INTERFACE ${META_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}" "${PRIVATE_LIBRARIES}")
target_link_libraries(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static target_include_directories(
INTERFACE ${ACTUAL_ADDITIONAL_LINK_FLAGS} "${PUBLIC_STATIC_LIBRARIES}" ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}
"${PRIVATE_STATIC_LIBRARIES}") INTERFACE $<BUILD_INTERFACE:${TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE}>
target_include_directories( $<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_INCLUDE_DIRS})
${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}
INTERFACE $<BUILD_INTERFACE:${TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE}> INTERFACE
$<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_STATIC_INCLUDE_DIRS}) "${META_PUBLIC_COMPILE_DEFINITIONS}"
target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static "${META_PRIVATE_COMPILE_DEFINITIONS}")
INTERFACE target_compile_options(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}
"${META_PUBLIC_STATIC_LIB_COMPILE_DEFINITIONS}" INTERFACE "${META_PUBLIC_COMPILE_OPTIONS}"
"${META_PRIVATE_STATIC_LIB_COMPILE_DEFINITIONS}") "${META_PRIVATE_COMPILE_OPTIONS}")
target_compile_options(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static else ()
INTERFACE "${META_PUBLIC_STATIC_LIB_COMPILE_OPTIONS}" add_library(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} ${META_LIBRARY_TYPE} ${ALL_FILES})
"${META_PRIVATE_STATIC_LIB_COMPILE_OPTIONS}") target_link_libraries(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}
else () PUBLIC ${META_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}"
add_library(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static STATIC ${ALL_FILES}) PRIVATE "${PRIVATE_LIBRARIES}")
target_link_libraries(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static target_include_directories(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}
PUBLIC "${PUBLIC_STATIC_LIBRARIES}" "${PRIVATE_STATIC_LIBRARIES}") PUBLIC $<BUILD_INTERFACE:${TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE}>
target_include_directories(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static $<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_INCLUDE_DIRS}
PUBLIC $<BUILD_INTERFACE:${TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE}> PRIVATE "${PRIVATE_INCLUDE_DIRS}")
$<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_STATIC_INCLUDE_DIRS} target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}
PRIVATE "${PRIVATE_STATIC_INCLUDE_DIRS}") PUBLIC
target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static "${META_PUBLIC_COMPILE_DEFINITIONS}"
PUBLIC PRIVATE
"${META_PUBLIC_STATIC_LIB_COMPILE_DEFINITIONS}" "${META_PRIVATE_COMPILE_DEFINITIONS}")
PRIVATE target_compile_options(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}
"${META_PRIVATE_STATIC_LIB_COMPILE_DEFINITIONS}") PUBLIC "${META_PUBLIC_LIB_COMPILE_OPTIONS}"
target_compile_options(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static PRIVATE "${META_PRIVATE_LIB_COMPILE_OPTIONS}")
PUBLIC "${META_PUBLIC_STATIC_LIB_COMPILE_OPTIONS}" set_target_properties(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}
PRIVATE "${META_PRIVATE_STATIC_LIB_COMPILE_OPTIONS}") PROPERTIES VERSION
set_target_properties(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static "${META_VESION_MAJOR}.${META_VERSION_MINOR}.${META_VERSION_PATCH}"
PROPERTIES VERSION SOVERSION
"${META_VERSION_MAJOR}.${META_VERSION_MINOR}.${META_VERSION_PATCH}" "${META_SOVERSION}"
SOVERSION CXX_STANDARD
"${META_SOVERSION}" "${META_CXX_STANDARD}"
OUTPUT_NAME LINK_SEARCH_START_STATIC
"${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}" ${STATIC_LINKAGE}
CXX_STANDARD LINK_SEARCH_END_STATIC
"${META_CXX_STANDARD}" ${STATIC_LINKAGE}
AUTOGEN_TARGET_DEPENDS AUTOGEN_TARGET_DEPENDS
"${AUTOGEN_DEPS}") "${AUTOGEN_DEPS}")
endif () endif ()
foreach (DEPENDENCY ${PUBLIC_STATIC_LIBRARIES} ${PRIVATE_STATIC_LIBRARIES}) if (NOT BUILD_SHARED_LIBS)
if (NOT ${DEPENDENCY} IN_LIST META_PUBLIC_STATIC_LIB_DEPENDS) foreach (DEPENDENCY ${PUBLIC_LIBRARIES} ${PRIVATE_LIBRARIES})
list(APPEND META_PRIVATE_STATIC_LIB_DEPENDS ${DEPENDENCY}) if (NOT "${DEPENDENCY}" IN_LIST META_PUBLIC_LIB_DEPENDS)
list(APPEND META_PRIVATE_LIB_DEPENDS ${DEPENDENCY})
endif () endif ()
endforeach () endforeach ()
endif () endif()
# Qt Creator does not show INTERFACE_SOURCES in project tree, so create a custom target as workaround # Qt Creator does not show INTERFACE_SOURCES in project tree, so create a custom target as workaround
if (META_HEADER_ONLY_LIB) if (META_HEADER_ONLY_LIB)
@ -230,14 +165,14 @@ if (META_HEADER_ONLY_LIB)
${HEADER_FILES}) ${HEADER_FILES})
target_include_directories(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_interface_sources_for_qtcreator target_include_directories(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_interface_sources_for_qtcreator
INTERFACE $<BUILD_INTERFACE:${TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE}> INTERFACE $<BUILD_INTERFACE:${TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE}>
$<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_SHARED_INCLUDE_DIRS}) $<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_INCLUDE_DIRS})
target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_interface_sources_for_qtcreator target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_interface_sources_for_qtcreator
INTERFACE INTERFACE
"${META_PUBLIC_SHARED_LIB_COMPILE_DEFINITIONS}" "${META_PUBLIC_LIB_COMPILE_DEFINITIONS}"
"${META_PRIVATE_SHARED_LIB_COMPILE_DEFINITIONS}") "${META_PRIVATE_LIB_COMPILE_DEFINITIONS}")
target_compile_options( target_compile_options(
${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_interface_sources_for_qtcreator ${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 set_target_properties(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_interface_sources_for_qtcreator
PROPERTIES VERSION PROPERTIES VERSION
"${META_VERSION_MAJOR}.${META_VERSION_MINOR}.${META_VERSION_PATCH}" "${META_VERSION_MAJOR}.${META_VERSION_MINOR}.${META_VERSION_PATCH}"
@ -263,18 +198,6 @@ configure_package_config_file("${CONFIG_TEMPLATE_FILE}"
LIB_INSTALL_DESTINATION) LIB_INSTALL_DESTINATION)
list(APPEND CMAKE_CONFIG_FILES "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}Config.cmake" list(APPEND CMAKE_CONFIG_FILES "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}Config.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}ConfigVersion.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 the CMake version config file
write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}ConfigVersion.cmake 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 # create pkg-config file from template
find_template_file("template.pc" CPP_UTILITIES PKGCONFIG_TEMPLATE_FILE) 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_PKGS})
unset(${OUTPUT_VAR_LIBS}) unset(${OUTPUT_VAR_LIBS})
foreach (DEPENDENCY ${${DEPENDS}}) foreach (DEPENDENCY ${${DEPENDS}})
@ -294,49 +217,43 @@ macro (depends_for_pc LIB_TYPE DEPENDS OUTPUT_VAR_PKGS OUTPUT_VAR_LIBS)
"_" "_"
DEPENDENCY_VARNAME DEPENDENCY_VARNAME
"${DEPENDENCY}") "${DEPENDENCY}")
if (PC_PKG_${LIB_TYPE}_${DEPENDENCY_VARNAME}) if (PKG_CONFIG_${DEPENDENCY_VARNAME})
set(${OUTPUT_VAR_PKGS} "${${OUTPUT_VAR_PKGS}} ${PC_PKG_${LIB_TYPE}_${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 () else ()
# add raw dependency
set(${OUTPUT_VAR_LIBS} "${${OUTPUT_VAR_LIBS}} ${DEPENDENCY}") set(${OUTPUT_VAR_LIBS} "${${OUTPUT_VAR_LIBS}} ${DEPENDENCY}")
endif () endif ()
endforeach () endforeach ()
endmacro () 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) unset(PC_FILES)
if (BUILD_SHARED_LIBS) set(META_PROJECT_NAME_FOR_PC "${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}")
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(SHARED META_PUBLIC_SHARED_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)
depends_for_pc(SHARED META_PRIVATE_SHARED_LIB_DEPENDS META_PRIVATE_PC_PKGS META_PRIVATE_LIB_DEPENDS_FOR_PC) foreach (COMPILE_DEFINITION ${META_PUBLIC_LIB_COMPILE_DEFINITIONS})
compile_defs_for_pc(SHARED) set(META_COMPILE_DEFINITIONS_FOR_PC "${META_COMPILE_DEFINITIONS_FOR_PC} -D${COMPILE_DEFINITION}")
if (NOT META_HEADER_ONLY_LIB) endforeach ()
set(META_PUBLIC_LIB_DEPENDS_FOR_PC if (NOT META_HEADER_ONLY_LIB)
" -l${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}${META_PUBLIC_LIB_DEPENDS_FOR_PC}") set(META_PUBLIC_LIB_DEPENDS_FOR_PC
endif () " -l${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}${META_PUBLIC_LIB_DEPENDS_FOR_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")
endif () endif ()
if (BUILD_STATIC_LIBS) if (META_PUBLIC_LIB_DEPENDS_FOR_PC)
set(META_PROJECT_NAME_FOR_PC "${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_static") set(META_PUBLIC_LIB_DEPENDS_FOR_PC " -L\${libdir}${META_PUBLIC_LIB_DEPENDS_FOR_PC}")
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")
endif () 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) if (NOT META_NO_INSTALL_TARGETS AND ENABLE_INSTALL_TARGETS)
# add install target for the CMake config files # add install target for the CMake config files
@ -394,34 +311,17 @@ if (NOT META_NO_INSTALL_TARGETS AND ENABLE_INSTALL_TARGETS)
endif () endif ()
# add install targets and export targets # add install targets and export targets
if (BUILD_SHARED_LIBS) install(TARGETS ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}
install(TARGETS ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX} EXPORT ${META_PROJECT_NAME}Targets
EXPORT ${META_PROJECT_NAME}SharedTargets RUNTIME DESTINATION bin COMPONENT binary
RUNTIME DESTINATION bin COMPONENT binary LIBRARY DESTINATION ${LIBRARY_DESTINATION} COMPONENT binary
LIBRARY DESTINATION ${LIBRARY_DESTINATION} COMPONENT binary ARCHIVE 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 ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}) add_dependencies(install-binary-strip ${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
# export shared lib DESTINATION "share/${META_PROJECT_NAME}/cmake"
install(EXPORT ${META_PROJECT_NAME}SharedTargets EXPORT_LINK_INTERFACE_LIBRARIES
DESTINATION "share/${META_PROJECT_NAME}/cmake" COMPONENT cmake-config)
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 ()
# add install target for header files # add install target for header files
if (NOT META_IS_PLUGIN) if (NOT META_IS_PLUGIN)

49
cmake/modules/TestTarget.cmake
View File

@ -75,16 +75,6 @@ endif ()
# always link test applications against c++utilities # always link test applications against c++utilities
list(APPEND TEST_LIBRARIES ${CPP_UTILITIES_LIB}) 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 # add target for test executable, but exclude it from the "all" target when EXCLUDE_TESTS_FROM_ALL is set
if (EXCLUDE_TESTS_FROM_ALL) if (EXCLUDE_TESTS_FROM_ALL)
set(TESTS_EXCLUSION EXCLUDE_FROM_ALL) set(TESTS_EXCLUSION EXCLUDE_FROM_ALL)
@ -104,19 +94,14 @@ else ()
endif () endif ()
# handle testing a library (which is default project type) # 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 # 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})
list(APPEND TEST_LIBRARIES ${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}) message(STATUS "Linking test target against ${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 ()
endif () endif ()
# handle testing an application # 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 # using functions directly from the tests might be required -> also create a 'testlib' and link tests against it
if (LINK_TESTS_AGAINST_APP_TARGET) if (LINK_TESTS_AGAINST_APP_TARGET)
# create target for the 'testlib' # create target for the 'testlib'
@ -128,16 +113,16 @@ if ("${META_PROJECT_TYPE}" STREQUAL "application")
PRIVATE "${PRIVATE_LIBRARIES}") PRIVATE "${PRIVATE_LIBRARIES}")
target_include_directories(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_testlib target_include_directories(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_testlib
PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}> PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
$<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_SHARED_INCLUDE_DIRS} $<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_INCLUDE_DIRS}
PRIVATE "${PRIVATE_SHARED_INCLUDE_DIRS}") PRIVATE "${PRIVATE_INCLUDE_DIRS}")
target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_testlib target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_testlib
PUBLIC PUBLIC
"${META_PUBLIC_SHARED_LIB_COMPILE_DEFINITIONS}" "${META_PUBLIC_COMPILE_DEFINITIONS}"
PRIVATE PRIVATE
"${META_PRIVATE_SHARED_LIB_COMPILE_DEFINITIONS}") "${META_PRIVATE_COMPILE_DEFINITIONS}")
target_compile_options(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_testlib target_compile_options(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_testlib
PUBLIC "${META_PUBLIC_SHARED_LIB_COMPILE_OPTIONS}" PUBLIC "${META_PUBLIC_COMPILE_OPTIONS}"
PRIVATE "${META_PRIVATE_SHARED_LIB_COMPILE_OPTIONS}") PRIVATE "${META_PRIVATE_COMPILE_OPTIONS}")
set_target_properties(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_testlib set_target_properties(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_testlib
PROPERTIES CXX_STANDARD PROPERTIES CXX_STANDARD
"${META_CXX_STANDARD}" "${META_CXX_STANDARD}"
@ -161,22 +146,22 @@ if ("${META_PROJECT_TYPE}" STREQUAL "application")
endif () endif ()
endif () endif ()
# actually apply configuration for test target # configure test target
target_link_libraries(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_tests target_link_libraries(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_tests
PUBLIC ${ACTUAL_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}" PUBLIC ${ACTUAL_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}"
PRIVATE "${TEST_LIBRARIES}" "${PRIVATE_LIBRARIES}") PRIVATE "${TEST_LIBRARIES}" "${PRIVATE_LIBRARIES}")
target_include_directories(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_tests target_include_directories(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_tests
PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}> PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
$<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_SHARED_INCLUDE_DIRS} $<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_INCLUDE_DIRS}
PRIVATE ${TEST_INCLUDE_DIRS} "${PRIVATE_SHARED_INCLUDE_DIRS}") PRIVATE ${TEST_INCLUDE_DIRS} "${PRIVATE_INCLUDE_DIRS}")
target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_tests target_compile_definitions(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_tests
PUBLIC PUBLIC
"${META_PUBLIC_SHARED_LIB_COMPILE_DEFINITIONS}" "${META_PUBLIC_COMPILE_DEFINITIONS}"
PRIVATE PRIVATE
"${META_PRIVATE_SHARED_LIB_COMPILE_DEFINITIONS}") "${META_PRIVATE_COMPILE_DEFINITIONS}")
target_compile_options(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_tests target_compile_options(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_tests
PUBLIC "${META_PUBLIC_SHARED_LIB_COMPILE_OPTIONS}" PUBLIC "${META_PUBLIC_COMPILE_OPTIONS}"
PRIVATE "${META_PRIVATE_SHARED_LIB_COMPILE_OPTIONS}") PRIVATE "${META_PRIVATE_COMPILE_OPTIONS}")
set_target_properties(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_tests set_target_properties(${TARGET_PREFIX}${META_PROJECT_NAME}${TARGET_SUFFIX}_tests
PROPERTIES CXX_STANDARD PROPERTIES CXX_STANDARD
"${META_CXX_STANDARD}" "${META_CXX_STANDARD}"

64
cmake/templates/Config.cmake.in
View File

@ -2,7 +2,6 @@
# provide meta-data # provide meta-data
set(@META_PROJECT_NAME@_varname "@META_PROJECT_VARNAME_UPPER@") 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@_DISPLAY_NAME "@META_APP_NAME@")
set(@META_PROJECT_VARNAME_UPPER@_AUTHOR "@META_APP_AUTHOR@") set(@META_PROJECT_VARNAME_UPPER@_AUTHOR "@META_APP_AUTHOR@")
set(@META_PROJECT_VARNAME_UPPER@_VERSION "@META_APP_VERSION@") 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 # define general config
set(@META_PROJECT_VARNAME_UPPER@_IS_HEADER_ONLY @META_HEADER_ONLY_LIB@) 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@_INCLUDE_DIRS "@PACKAGE_HEADER_INSTALL_DESTINATION@")
set(@META_PROJECT_VARNAME_UPPER@_BIN_DIR "@PACKAGE_BIN_INSTALL_DESTINATION@") set(@META_PROJECT_VARNAME_UPPER@_BIN_DIR "@PACKAGE_BIN_INSTALL_DESTINATION@")
set(@META_PROJECT_VARNAME_UPPER@_LIB_DIR "@PACKAGE_LIB_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@_HAS_QT_TRANSLATION_FILES @APP_SPECIFIC_QT_TRANSLATIONS_AVAILABLE@)
set(@META_PROJECT_VARNAME_UPPER@_QT_RESOURCES @QT_RESOURCES@) set(@META_PROJECT_VARNAME_UPPER@_QT_RESOURCES @QT_RESOURCES@)
# include files for shared/static specific configuration # define library config
set(@META_PROJECT_VARNAME_UPPER@_HAS_SHARED_LIB NO) set(@META_PROJECT_VARNAME_UPPER@_LIB "@TARGET_PREFIX@@META_PROJECT_NAME@@TARGET_SUFFIX@")
set(@META_PROJECT_VARNAME_UPPER@_HAS_STATIC_LIB NO) set(@META_PROJECT_VARNAME_UPPER@_LIB_IS_SHARED "@BUILD_SHARED_LIBS@")
file(GLOB @META_PROJECT_VARNAME_UPPER@_SPECIFIC_CONFIG_FILES set(PKG_CONFIG_@META_PROJECT_NAME@ "@META_PROJECT_NAME@")
LIST_DIRECTORIES OFF if(NOT TARGET "${@META_PROJECT_VARNAME_UPPER@_LIB}")
"${CMAKE_CURRENT_LIST_DIR}/@META_PROJECT_NAME@?*Config.cmake" include("${CMAKE_CURRENT_LIST_DIR}/@META_PROJECT_NAME@Targets.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")
endif() endif()
# define macro to ease use of library in projects following conventions of c++utilities' build script # define function to ease use of library in projects following conventions of c++utilities' build script
macro(use_@META_PROJECT_VARNAME@) function(use_@META_PROJECT_VARNAME@)
# parse arguments
include(3rdParty)
parse_arguments_for_use_functions(${ARGN})
# make CMake modules of the project available # 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 against library (also "link" against header-only libs to get compile defs and interface link libs)
link_directories(${@META_PROJECT_VARNAME_UPPER@_LIB_DIR}) link_directories(${@META_PROJECT_VARNAME_UPPER@_LIB_DIR})
include(3rdParty) set("${ARGS_LIBRARIES_VARIABLE}" "${${ARGS_LIBRARIES_VARIABLE}};${@META_PROJECT_VARNAME_UPPER@_LIB}" PARENT_SCOPE)
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)
# add required Qt and KF modules # 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@_PUBLIC_QT_MODULES}
${@META_PROJECT_VARNAME_UPPER@_PRIVATE_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@_PUBLIC_KF_MODULES}
${@META_PROJECT_VARNAME_UPPER@_PRIVATE_KF_MODULES} ${@META_PROJECT_VARNAME_UPPER@_PRIVATE_KF_MODULES}
PARENT_SCOPE
) )
# add required translations to APP_SPECIFIC_QT_TRANSLATION_FILES_ARRAY # add required translations to APP_SPECIFIC_QT_TRANSLATION_FILES_ARRAY
if(@META_PROJECT_VARNAME_UPPER@_HAS_QT_TRANSLATION_FILES) 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() 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()

9
cmake/templates/SharedConfig.cmake.in
View File

@ -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()

9
cmake/templates/StaticConfig.cmake.in
View File

@ -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()

1
cmake/templates/config.h.in
View File

@ -13,6 +13,5 @@
#define APP_DESCRIPTION "@META_APP_DESCRIPTION@" #define APP_DESCRIPTION "@META_APP_DESCRIPTION@"
#define APP_INSTALL_PREFIX "@CMAKE_INSTALL_PREFIX@" #define APP_INSTALL_PREFIX "@CMAKE_INSTALL_PREFIX@"
#define DEPENCENCY_VERSIONS {@DEPENCENCY_VERSIONS_ARRAY@} #define DEPENCENCY_VERSIONS {@DEPENCENCY_VERSIONS_ARRAY@}
#define STATIC_DEPENCENCY_VERSIONS {@STATIC_DEPENCENCY_VERSIONS_ARRAY@}
@META_CUSTOM_CONFIG@ @META_CUSTOM_CONFIG@
#endif // @META_PROJECT_VARNAME_UPPER@_CONFIG #endif // @META_PROJECT_VARNAME_UPPER@_CONFIG

45
doc/buildvariables.md
View File

@ -10,9 +10,15 @@
install prefix is set via `make` argument `DESTDIR=path`) install prefix is set via `make` argument `DESTDIR=path`)
* `CMAKE_BUILD_TYPE=Release/Debug`: specifies whether to do a debug or a release * `CMAKE_BUILD_TYPE=Release/Debug`: specifies whether to do a debug or a release
build 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_SKIP_BUILD_RPATH=OFF`: ensures the rpath is set in the build tree
* `CMAKE_INSTALL_RPATH=rpath`: sets the rpath used when installing * `CMAKE_INSTALL_RPATH=rpath`: sets the rpath used when installing
* `CMAKE_CXX_FLAGS`: sets flags to be passed to the C++ compiler * `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 ### Custom variables
The following variables are read by the CMake modules provided by `c++utilities` 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 * `LIB_SUFFIX_64=suffix`: suffix for library install directory
* used when building for 64-bit platforms * used when building for 64-bit platforms
* overrides general `LIB_SUFFIX` 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 * `QT_PACKAGE_PREFIX=Qt5`: sets the prefix for Qt packages, by default `Qt5`
* `DISABLE_SHARED_LIBS=ON/OFF`: disables building shared libs * `KF_PACKAGE_PREFIX=KF5`: sets the prefix for KDE Frameworks packages, by
* `STATIC_LINKAGE=ON/OFF`: enables linking applications *preferably* against default `KF5``
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
* `SHELL_COMPLETION_ENABLED=ON/OFF`: enables shell completion in general * `SHELL_COMPLETION_ENABLED=ON/OFF`: enables shell completion in general
(enabled by default) (enabled by default)
* `BASH_COMPLETION_ENABLED=ON/OFF`: enables Bash completion (enabled by * `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 location should be used, the following variables can be used to specify
the location of libraries and include directories directly: the location of libraries and include directories directly:
* `dependency_DYNAMIC_LIB`: specifies the locations of the dynamic libraries * `dependency__LIBRARY_PATH`: specifies the locations of the library required
for *dependency* by *dependency*
* `dependency_STATIC_LIB`: specifies the locations of the static libraries
for *dependency*
* `dependency_DYNAMIC_INCLUDE_DIR`: specifies the locations of the additional * `dependency_DYNAMIC_INCLUDE_DIR`: specifies the locations of the additional
include directories required for using the dynamic version of the *dependency* include directories required the *dependency*
* `dependency_STATIC_INCLUDE_DIR`: specifies the locations of the additional
include directories required for using the static version of the *dependency*
*Note about Qt*: Qt modules are always configured using the CMake packages via *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 `find_package`. So using the variables described above to specify a custom location
@ -196,13 +184,10 @@ cmake \
* only relevant when using static Qt * only relevant when using static Qt
* `WEBVIEW_PROVIDER=auto/webkit/webengine/none`: specifies the Qt module to use * `WEBVIEW_PROVIDER=auto/webkit/webengine/none`: specifies the Qt module to use
for the web view 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 for the JavaScript engine
* `QT_LINKAGE=AUTO_LINKAGE/STATIC/SHARED`: specifies whether to use static * `WEBVIEW_PROVIDER=webengine/webkit/none`: specifies the Qt module to use
or shared version of Qt (only works with Qt packages provided in the AUR) for the built-in web view
* `ADDITIONAL_QT_MODULES=Network;Concurrent;...`: specifies additional Qt
modules to link against (only use for modules which can not be added
automatically)
## Variables to be set in project file ## Variables to be set in project file