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

Apply cmake-format v0.6.0

This commit is contained in:
Martchus 2019-11-30 17:58:01 +01:00
parent 7376a2bb9b
commit 6376819c07
11 changed files with 562 additions and 668 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
CMakeLists.txt
View File

@ -121,7 +121,9 @@ use_iconv(AUTO_LINKAGE REQUIRED)
# configure use of native file buffer and its backend implementation if enabled
set(USE_NATIVE_FILE_BUFFER_BY_DEFAULT OFF)
if (WIN32 OR ANDROID OR (UNIX AND NOT APPLE))
if (WIN32
OR ANDROID
OR (UNIX AND NOT APPLE))
set(USE_NATIVE_FILE_BUFFER_BY_DEFAULT ON)
endif ()
option(USE_NATIVE_FILE_BUFFER "enables use of native file buffer, affects ABI" ${USE_NATIVE_FILE_BUFFER_BY_DEFAULT})
@ -131,32 +133,27 @@ if (USE_NATIVE_FILE_BUFFER)
set(NATIVE_FILE_STREAM_IMPL_FILES io/nativefilestream.cpp tests/iotests.cpp)
# check whether __gnu_cxx::stdio_filebuf is available
try_compile(GNU_CXX_STDIO_FILEBUF_AVAILABLE
${CMAKE_CURRENT_BINARY_DIR}
SOURCES
${CMAKE_CURRENT_SOURCE_DIR}/feature_detection/stdio_filebuf.cpp
OUTPUT_VARIABLE GNU_CXX_STDIO_FILEBUF_CHECK_LOG)
try_compile(
GNU_CXX_STDIO_FILEBUF_AVAILABLE ${CMAKE_CURRENT_BINARY_DIR} SOURCES
${CMAKE_CURRENT_SOURCE_DIR}/feature_detection/stdio_filebuf.cpp OUTPUT_VARIABLE GNU_CXX_STDIO_FILEBUF_CHECK_LOG)
# use __gnu_cxx::stdio_filebuf if available or fallback to boost::iostreams::stream_buffer
if (GNU_CXX_STDIO_FILEBUF_AVAILABLE AND NOT FORCE_BOOST_IOSTREAMS_FOR_NATIVE_FILE_BUFFER)
message(STATUS "Using __gnu_cxx::stdio_filebuf for NativeFileStream")
foreach (NATIVE_FILE_STREAM_IMPL_FILE ${NATIVE_FILE_STREAM_IMPL_FILES})
set_property(SOURCE ${NATIVE_FILE_STREAM_IMPL_FILE}
APPEND
PROPERTY COMPILE_DEFINITIONS ${META_PROJECT_VARNAME}_USE_GNU_CXX_STDIO_FILEBUF)
set_property(
SOURCE ${NATIVE_FILE_STREAM_IMPL_FILE}
APPEND
PROPERTY COMPILE_DEFINITIONS ${META_PROJECT_VARNAME}_USE_GNU_CXX_STDIO_FILEBUF)
endforeach ()
else ()
message(STATUS "Using boost::iostreams::stream_buffer<boost::iostreams::file_descriptor_sink> for NativeFileStream")
use_package(TARGET_NAME
Boost::iostreams
PACKAGE_NAME
Boost
PACKAGE_ARGS
"REQUIRED;COMPONENTS;iostreams")
use_package(TARGET_NAME Boost::iostreams PACKAGE_NAME Boost PACKAGE_ARGS "REQUIRED;COMPONENTS;iostreams")
foreach (NATIVE_FILE_STREAM_IMPL_FILE ${NATIVE_FILE_STREAM_IMPL_FILES})
set_property(SOURCE ${NATIVE_FILE_STREAM_IMPL_FILE}
APPEND
PROPERTY COMPILE_DEFINITIONS ${META_PROJECT_VARNAME}_USE_BOOST_IOSTREAMS)
set_property(
SOURCE ${NATIVE_FILE_STREAM_IMPL_FILE}
APPEND
PROPERTY COMPILE_DEFINITIONS ${META_PROJECT_VARNAME}_USE_BOOST_IOSTREAMS)
endforeach ()
endif ()
else ()
@ -182,9 +179,10 @@ endif ()
# configure whether escape codes should be enabled by default
option(ENABLE_ESCAPE_CODES_BY_DEAULT "enables usage of escape codes by default" ON)
if (ENABLE_ESCAPE_CODES_BY_DEAULT)
set_property(SOURCE application/argumentparser.cpp io/ansiescapecodes.cpp tests/argumentparsertests.cpp
APPEND
PROPERTY COMPILE_DEFINITIONS ${META_PROJECT_VARNAME}_ESCAPE_CODES_ENABLED_BY_DEFAULT)
set_property(
SOURCE application/argumentparser.cpp io/ansiescapecodes.cpp tests/argumentparsertests.cpp
APPEND
PROPERTY COMPILE_DEFINITIONS ${META_PROJECT_VARNAME}_ESCAPE_CODES_ENABLED_BY_DEFAULT)
else ()
message(STATUS "Disabling use of escape codes by default.")
endif ()
@ -192,9 +190,10 @@ endif ()
# configure use of thread_local
option(ENABLE_THREAD_LOCAL "enables use of Thread-Local Storage" ON)
if (NOT ENABLE_THREAD_LOCAL)
set_property(SOURCE conversion/stringconversion.cpp
APPEND
PROPERTY COMPILE_DEFINITIONS ${META_PROJECT_VARNAME}_NO_THREAD_LOCAL)
set_property(
SOURCE conversion/stringconversion.cpp
APPEND
PROPERTY COMPILE_DEFINITIONS ${META_PROJECT_VARNAME}_NO_THREAD_LOCAL)
endif ()
# include modules to apply configuration

219
cmake/modules/AppTarget.cmake
View File

@ -10,7 +10,7 @@ if (NOT "${META_PROJECT_TYPE}" STREQUAL "application")
message(
FATAL_ERROR
"The AppTarget CMake module is intended to be used for building application projects only (and not for libraries)."
)
)
endif ()
# set the windows extension to "exe", this is required by the Windows-specific WindowsResources module
@ -41,52 +41,54 @@ if (ANDROID)
else ()
add_executable(${META_TARGET_NAME} ${GUI_TYPE} ${ALL_FILES})
endif ()
target_link_libraries(${META_TARGET_NAME}
PUBLIC ${META_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}"
PRIVATE "${PRIVATE_LIBRARIES}")
target_include_directories(${META_TARGET_NAME}
PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}> ${PUBLIC_INCLUDE_DIRS}
PRIVATE "${PRIVATE_INCLUDE_DIRS}")
target_compile_definitions(${META_TARGET_NAME}
PUBLIC
"${META_PUBLIC_COMPILE_DEFINITIONS}"
PRIVATE
target_link_libraries(
${META_TARGET_NAME}
PUBLIC ${META_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}"
PRIVATE "${PRIVATE_LIBRARIES}")
target_include_directories(
${META_TARGET_NAME}
PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}> ${PUBLIC_INCLUDE_DIRS}
PRIVATE "${PRIVATE_INCLUDE_DIRS}")
target_compile_definitions(${META_TARGET_NAME} PUBLIC "${META_PUBLIC_COMPILE_DEFINITIONS}" PRIVATE
"${META_PRIVATE_COMPILE_DEFINITIONS}")
target_compile_options(${META_TARGET_NAME} PUBLIC "${META_PUBLIC_COMPILE_OPTIONS}" PRIVATE "${META_PRIVATE_COMPILE_OPTIONS}")
set_target_properties(${META_TARGET_NAME}
PROPERTIES CXX_STANDARD
"${META_CXX_STANDARD}"
LINK_SEARCH_START_STATIC
${STATIC_LINKAGE}
LINK_SEARCH_END_STATIC
${STATIC_LINKAGE}
AUTOGEN_TARGET_DEPENDS
"${AUTOGEN_DEPS}")
target_compile_options(
${META_TARGET_NAME}
PUBLIC "${META_PUBLIC_COMPILE_OPTIONS}"
PRIVATE "${META_PRIVATE_COMPILE_OPTIONS}")
set_target_properties(
${META_TARGET_NAME}
PROPERTIES CXX_STANDARD
"${META_CXX_STANDARD}"
LINK_SEARCH_START_STATIC
${STATIC_LINKAGE}
LINK_SEARCH_END_STATIC
${STATIC_LINKAGE}
AUTOGEN_TARGET_DEPENDS
"${AUTOGEN_DEPS}")
if ("${GUI_TYPE}" STREQUAL "MACOSX_BUNDLE")
set_target_properties(${META_TARGET_NAME}
PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME
${META_TARGET_NAME}
MACOSX_BUNDLE_GUI_IDENTIFIER
${META_TARGET_NAME}
MACOSX_BUNDLE_BUNDLE_VERSION
${META_APP_VERSION}
MACOSX_BUNDLE_LONG_VERSION_STRING
${META_APP_VERSION}
MACOSX_BUNDLE_SHORT_VERSION_STRING
${META_APP_VERSION})
set_target_properties(
${META_TARGET_NAME}
PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME
${META_TARGET_NAME}
MACOSX_BUNDLE_GUI_IDENTIFIER
${META_TARGET_NAME}
MACOSX_BUNDLE_BUNDLE_VERSION
${META_APP_VERSION}
MACOSX_BUNDLE_LONG_VERSION_STRING
${META_APP_VERSION}
MACOSX_BUNDLE_SHORT_VERSION_STRING
${META_APP_VERSION})
find_program(PNG2ICNS_BIN png2icns)
if (PNG2ICNS_BIN AND EXISTS "${PNG_ICON_PATH}")
set(RESOURCES_DIR "${CMAKE_CURRENT_BINARY_DIR}/${META_TARGET_NAME}.app/Contents/Resources")
set(MACOSX_ICON_PATH "${RESOURCES_DIR}/${META_PROJECT_NAME}.icns")
add_custom_command(OUTPUT "${MACOSX_ICON_PATH}"
COMMAND "${CMAKE_COMMAND}"
-E
make_directory
"${RESOURCES_DIR}"
COMMAND ${PNG2ICNS_BIN} "${MACOSX_ICON_PATH}" "${PNG_ICON_PATH}"
DEPENDS "${PNG_ICON_PATH}")
add_custom_command(
OUTPUT "${MACOSX_ICON_PATH}"
COMMAND "${CMAKE_COMMAND}" -E make_directory "${RESOURCES_DIR}"
COMMAND ${PNG2ICNS_BIN} "${MACOSX_ICON_PATH}" "${PNG_ICON_PATH}"
DEPENDS "${PNG_ICON_PATH}")
message(STATUS "Generating macOS icon from \"${PNG_ICON_PATH}\" via ${PNG2ICNS_BIN}.")
set_target_properties(${META_TARGET_NAME} PROPERTIES MACOSX_BUNDLE_ICON_FILE ${META_PROJECT_NAME}.icns)
target_sources(${META_TARGET_NAME} PRIVATE "${MACOSX_ICON_PATH}")
@ -97,25 +99,26 @@ endif ()
if (NOT META_NO_INSTALL_TARGETS AND ENABLE_INSTALL_TARGETS)
# add install target for binary
if (APPLE)
set(BUNDLE_INSTALL_DESTINATION bin CACHE STRING "specifies the install destination for bundles")
install(TARGETS ${META_TARGET_NAME}
RUNTIME DESTINATION bin
BUNDLE DESTINATION "${BUNDLE_INSTALL_DESTINATION}" COMPONENT binary)
set(BUNDLE_INSTALL_DESTINATION
bin
CACHE STRING "specifies the install destination for bundles")
install(
TARGETS ${META_TARGET_NAME}
RUNTIME DESTINATION bin
BUNDLE DESTINATION "${BUNDLE_INSTALL_DESTINATION}" COMPONENT binary)
elseif (ANDROID)
install(TARGETS ${META_TARGET_NAME}
RUNTIME DESTINATION bin COMPONENT binary
LIBRARY DESTINATION lib${SELECTED_LIB_SUFFIX} COMPONENT binary
ARCHIVE DESTINATION lib${SELECTED_LIB_SUFFIX} COMPONENT binary)
install(
TARGETS ${META_TARGET_NAME}
RUNTIME DESTINATION bin COMPONENT binary
LIBRARY DESTINATION lib${SELECTED_LIB_SUFFIX} COMPONENT binary
ARCHIVE DESTINATION lib${SELECTED_LIB_SUFFIX} COMPONENT binary)
else ()
install(TARGETS ${META_TARGET_NAME} RUNTIME DESTINATION bin COMPONENT binary)
endif ()
if (NOT TARGET install-binary)
add_custom_target(install-binary
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_COMPONENT=binary
-P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
add_custom_target(install-binary COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=binary -P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
add_dependencies(install-binary ${META_TARGET_NAME})
@ -128,37 +131,34 @@ if (NOT META_NO_INSTALL_TARGETS AND ENABLE_INSTALL_TARGETS)
# add install target for desktop entries and icons
foreach (DESKTOP_FILE ${DESKTOP_FILES})
install(FILES "${DESKTOP_FILE}" DESTINATION "share/applications" COMPONENT desktop)
install(
FILES "${DESKTOP_FILE}"
DESTINATION "share/applications"
COMPONENT desktop)
endforeach ()
foreach (ICON_FILE ${ICON_FILES})
install(FILES "${ICON_FILE}" DESTINATION "share/icons/hicolor/scalable/apps" COMPONENT desktop)
install(
FILES "${ICON_FILE}"
DESTINATION "share/icons/hicolor/scalable/apps"
COMPONENT desktop)
endforeach ()
if (NOT TARGET install-desktop)
add_custom_target(install-desktop
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_COMPONENT=desktop
-P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
add_custom_target(install-desktop COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=desktop -P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
add_dependencies(install-desktop ${META_TARGET_NAME})
if (NOT TARGET install-appimage)
add_custom_target(install-appimage
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_COMPONENT=appimage
-P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
add_custom_target(install-appimage COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=appimage -P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
add_dependencies(install-appimage ${META_TARGET_NAME})
# add install target for stripped binaries
if (NOT TARGET install-binary-strip)
add_custom_target(install-binary-strip
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_DO_STRIP=1
-DCMAKE_INSTALL_COMPONENT=binary
-P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
add_custom_target(
install-binary-strip COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_DO_STRIP=1 -DCMAKE_INSTALL_COMPONENT=binary -P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
add_dependencies(install-binary-strip ${META_TARGET_NAME})
@ -181,14 +181,17 @@ endif ()
# add target for launching application with wine ensuring the WINEPATH is set correctly so wine is able to find all required
# *.dll files requires script from c++utilities, hence the sources of c++utilities must be present
if (MINGW AND CMAKE_CROSSCOMPILING AND CPP_UTILITIES_SOURCE_DIR)
if (MINGW
AND CMAKE_CROSSCOMPILING
AND CPP_UTILITIES_SOURCE_DIR)
if (NOT TARGET ${META_PROJECT_NAME}_run)
if (CMAKE_FIND_ROOT_PATH)
list(APPEND RUNTIME_LIBRARY_PATH "${CMAKE_FIND_ROOT_PATH}/bin")
endif ()
add_custom_target(${META_PROJECT_NAME}_run
COMMAND "${CPP_UTILITIES_SOURCE_DIR}/scripts/wine.sh"
"${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}.${WINDOWS_EXT}" ${RUNTIME_LIBRARY_PATH})
add_custom_target(
${META_PROJECT_NAME}_run
COMMAND "${CPP_UTILITIES_SOURCE_DIR}/scripts/wine.sh"
"${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}.${WINDOWS_EXT}" ${RUNTIME_LIBRARY_PATH})
add_dependencies(${META_PROJECT_NAME}_run ${META_PROJECT_NAME})
endif ()
endif ()
@ -213,12 +216,10 @@ function (add_custom_desktop_file)
DESKTOP_FILE_ADDITIONAL_ENTRIES)
set(MULTI_VALUE_ARGS)
set(OPTIONAL_ARGS)
cmake_parse_arguments(ARGS
"${OPTIONAL_ARGS}"
"${ONE_VALUE_ARGS}"
"${MULTI_VALUE_ARGS}"
${ARGN})
if (NOT ARGS_FILE_NAME OR NOT ARGS_DESKTOP_FILE_APP_NAME OR NOT ARGS_DESKTOP_FILE_CMD)
cmake_parse_arguments(ARGS "${OPTIONAL_ARGS}" "${ONE_VALUE_ARGS}" "${MULTI_VALUE_ARGS}" ${ARGN})
if (NOT ARGS_FILE_NAME
OR NOT ARGS_DESKTOP_FILE_APP_NAME
OR NOT ARGS_DESKTOP_FILE_CMD)
message(FATAL_ERROR "Not all mandatory arguments specified.")
endif ()
if (NOT ARGS_DESKTOP_FILE_GENERIC_NAME)
@ -228,9 +229,10 @@ function (add_custom_desktop_file)
# create desktop file from template
configure_file("${APP_DESKTOP_TEMPLATE_FILE}" "${CMAKE_CURRENT_BINARY_DIR}/resources/${ARGS_FILE_NAME}.desktop")
# add install for the desktop file
install(FILES "${CMAKE_CURRENT_BINARY_DIR}/resources/${ARGS_FILE_NAME}.desktop"
DESTINATION "share/applications"
COMPONENT desktop)
install(
FILES "${CMAKE_CURRENT_BINARY_DIR}/resources/${ARGS_FILE_NAME}.desktop"
DESTINATION "share/applications"
COMPONENT desktop)
endfunction ()
# define function to add *.desktop file and meta info from project meta data
@ -241,29 +243,29 @@ function (add_desktop_file)
list(GET META_APP_ACTION_${ACTION_VAR} 0 ACTION_ID)
list(GET META_APP_ACTION_${ACTION_VAR} 1 ACTION_NAME)
list(GET META_APP_ACTION_${ACTION_VAR} 2 ACTION_ARGS)
set(
DESKTOP_FILE_ADDITIONAL_ENTRIES
set(DESKTOP_FILE_ADDITIONAL_ENTRIES
"${DESKTOP_FILE_ADDITIONAL_ENTRIES}\n[Desktop Action ${ACTION_ID}]\nName=${ACTION_NAME}\nExec=${META_TARGET_NAME} ${ACTION_ARGS}"
)
)
endforeach ()
# create desktop file
add_custom_desktop_file(FILE_NAME
"${META_ID}"
DESKTOP_FILE_APP_NAME
"${META_APP_NAME}"
DESKTOP_FILE_GENERIC_NAME
"${META_GENERIC_NAME}"
DESKTOP_FILE_DESCRIPTION
"${META_APP_DESCRIPTION}"
DESKTOP_FILE_CATEGORIES
"${META_APP_CATEGORIES}"
DESKTOP_FILE_CMD
"${META_TARGET_NAME}"
DESKTOP_FILE_ICON
"${META_PROJECT_NAME}"
DESKTOP_FILE_ADDITIONAL_ENTRIES
"${DESKTOP_FILE_ADDITIONAL_ENTRIES}")
add_custom_desktop_file(
FILE_NAME
"${META_ID}"
DESKTOP_FILE_APP_NAME
"${META_APP_NAME}"
DESKTOP_FILE_GENERIC_NAME
"${META_GENERIC_NAME}"
DESKTOP_FILE_DESCRIPTION
"${META_APP_DESCRIPTION}"
DESKTOP_FILE_CATEGORIES
"${META_APP_CATEGORIES}"
DESKTOP_FILE_CMD
"${META_TARGET_NAME}"
DESKTOP_FILE_ICON
"${META_PROJECT_NAME}"
DESKTOP_FILE_ADDITIONAL_ENTRIES
"${DESKTOP_FILE_ADDITIONAL_ENTRIES}")
# read body for appstream desktop file from resources
set(META_APP_APPDATA_BODY_FILE "${CMAKE_CURRENT_SOURCE_DIR}/resources/body.appdata.xml")
@ -272,18 +274,15 @@ function (add_desktop_file)
configure_file("${META_APP_APPDATA_BODY_FILE}" "${META_APP_APPDATA_SUBSTITUTED_BODY_FILE}" @ONLY)
file(READ "${META_APP_APPDATA_SUBSTITUTED_BODY_FILE}" META_APP_APPDATA_BODY)
# add indentation of two additional spaces
string(REGEX
REPLACE "\n([^$])"
"\n \\1"
META_APP_APPDATA_BODY
"${META_APP_APPDATA_BODY}")
string(REGEX REPLACE "\n([^$])" "\n \\1" META_APP_APPDATA_BODY "${META_APP_APPDATA_BODY}")
endif ()
# create appstream desktop file from template
configure_file("${APP_APPSTREAM_TEMPLATE_FILE}" "${CMAKE_CURRENT_BINARY_DIR}/resources/${META_ID}.appdata.xml" @ONLY)
# add install for the appstream file
install(FILES "${CMAKE_CURRENT_BINARY_DIR}/resources/${META_ID}.appdata.xml"
DESTINATION "share/metainfo"
COMPONENT appimage)
install(
FILES "${CMAKE_CURRENT_BINARY_DIR}/resources/${META_ID}.appdata.xml"
DESTINATION "share/metainfo"
COMPONENT appimage)
endfunction ()
set(TARGET_CONFIG_DONE YES)

255
cmake/modules/BasicConfig.cmake
View File

@ -26,18 +26,18 @@ if (NOT META_PROJECT_VARNAME_UPPER)
string(TOUPPER ${META_PROJECT_VARNAME} META_PROJECT_VARNAME_UPPER)
endif ()
if (NOT META_PROJECT_VARNAME_LOWER)
string(REGEX
REPLACE "_+"
""
META_PROJECT_VARNAME_LOWER
"${META_PROJECT_VARNAME}")
string(REGEX REPLACE "_+" "" META_PROJECT_VARNAME_LOWER "${META_PROJECT_VARNAME}")
string(TOLOWER "${META_PROJECT_VARNAME_LOWER}" META_PROJECT_VARNAME_LOWER)
endif ()
# allow setting a configuration name to allow installing multiple differently configured versions within the same prefix
# (intended to be used for installing Qt 5 and Qt 6 version or shared and static version within the same prefix)
set(${META_PROJECT_VARNAME_UPPER}_CONFIGURATION_NAME "" CACHE STRING "sets the configuration name for ${META_PROJECT_NAME}")
set(CONFIGURATION_NAME "" CACHE STRING "sets the configuration name for all projects within the current build")
set(${META_PROJECT_VARNAME_UPPER}_CONFIGURATION_NAME
""
CACHE STRING "sets the configuration name for ${META_PROJECT_NAME}")
set(CONFIGURATION_NAME
""
CACHE STRING "sets the configuration name for all projects within the current build")
if (${META_PROJECT_VARNAME_UPPER}_CONFIGURATION_NAME STREQUAL "none")
set(META_CONFIG_NAME "")
elseif (${META_PROJECT_VARNAME_UPPER}_CONFIGURATION_NAME)
@ -56,7 +56,9 @@ endif ()
set(${META_PROJECT_VARNAME_UPPER}_CONFIGURATION_TARGET_SUFFIX
""
CACHE STRING "sets a target suffix for ${META_PROJECT_NAME}")
set(CONFIGURATION_TARGET_SUFFIX "" CACHE STRING "sets the target suffix for all projects within the current build")
set(CONFIGURATION_TARGET_SUFFIX
""
CACHE STRING "sets the target suffix for all projects within the current build")
if (${META_PROJECT_VARNAME_UPPER}_CONFIGURATION_TARGET_SUFFIX STREQUAL "none")
set(TARGET_SUFFIX "")
elseif (${META_PROJECT_VARNAME_UPPER}_CONFIGURATION_TARGET_SUFFIX)
@ -124,17 +126,25 @@ if (NOT META_PROJECT_LICENSE)
message(
WARNING
"Unable to detect license of ${META_PROJECT_NAME}. Set META_PROJECT_LICENSE manually to silence this warning."
)
)
endif ()
endif ()
# provide variables for other projects built as part of the same subdirs project to access files from this project
get_directory_property(HAS_PARENT PARENT_DIRECTORY)
if (HAS_PARENT)
set(${META_PROJECT_VARNAME_UPPER}_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}" PARENT_SCOPE)
set(${META_PROJECT_VARNAME_UPPER}_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}" PARENT_SCOPE)
set(${META_PROJECT_NAME}_DIR "${CMAKE_CURRENT_BINARY_DIR}" PARENT_SCOPE)
set(RUNTIME_LIBRARY_PATH "${CMAKE_CURRENT_BINARY_DIR}" ${RUNTIME_LIBRARY_PATH} PARENT_SCOPE)
set(${META_PROJECT_VARNAME_UPPER}_SOURCE_DIR
"${CMAKE_CURRENT_SOURCE_DIR}"
PARENT_SCOPE)
set(${META_PROJECT_VARNAME_UPPER}_BINARY_DIR
"${CMAKE_CURRENT_BINARY_DIR}"
PARENT_SCOPE)
set(${META_PROJECT_NAME}_DIR
"${CMAKE_CURRENT_BINARY_DIR}"
PARENT_SCOPE)
set(RUNTIME_LIBRARY_PATH
"${CMAKE_CURRENT_BINARY_DIR}" ${RUNTIME_LIBRARY_PATH}
PARENT_SCOPE)
endif ()
# determine version
@ -145,26 +155,16 @@ option(
ON)
if (APPEND_GIT_REVISION)
find_program(GIT_BIN git)
execute_process(COMMAND ${GIT_BIN}
rev-list
--count
HEAD
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
OUTPUT_VARIABLE META_GIT_REV_COUNT)
execute_process(COMMAND ${GIT_BIN}
rev-parse
--short
HEAD
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
OUTPUT_VARIABLE META_GIT_LAST_COMMIT_ID)
string(REPLACE "\n"
""
META_GIT_REV_COUNT
"${META_GIT_REV_COUNT}")
string(REPLACE "\n"
""
META_GIT_LAST_COMMIT_ID
"${META_GIT_LAST_COMMIT_ID}")
execute_process(
COMMAND ${GIT_BIN} rev-list --count HEAD
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
OUTPUT_VARIABLE META_GIT_REV_COUNT)
execute_process(
COMMAND ${GIT_BIN} rev-parse --short HEAD
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
OUTPUT_VARIABLE META_GIT_LAST_COMMIT_ID)
string(REPLACE "\n" "" META_GIT_REV_COUNT "${META_GIT_REV_COUNT}")
string(REPLACE "\n" "" META_GIT_LAST_COMMIT_ID "${META_GIT_LAST_COMMIT_ID}")
if (META_GIT_REV_COUNT AND META_GIT_LAST_COMMIT_ID)
set(META_APP_VERSION ${META_APP_VERSION}-${META_GIT_REV_COUNT}.${META_GIT_LAST_COMMIT_ID})
endif ()
@ -176,16 +176,17 @@ set(TARGET_EXECUTABLE "${CMAKE_INSTALL_PREFIX}/bin/${META_TARGET_NAME}")
# create header for feature detection
if (META_FEATURES_FOR_COMPILER_DETECTION_HEADER)
include(WriteCompilerDetectionHeader)
write_compiler_detection_header(FILE
"${CMAKE_CURRENT_BINARY_DIR}/resources/features.h"
PREFIX
"${META_PROJECT_VARNAME_UPPER}"
COMPILERS
GNU
Clang
AppleClang
FEATURES
${META_FEATURES_FOR_COMPILER_DETECTION_HEADER})
write_compiler_detection_header(
FILE
"${CMAKE_CURRENT_BINARY_DIR}/resources/features.h"
PREFIX
"${META_PROJECT_VARNAME_UPPER}"
COMPILERS
GNU
Clang
AppleClang
FEATURES
${META_FEATURES_FOR_COMPILER_DETECTION_HEADER})
endif ()
# disable new ABI (can't catch ios_base::failure with new ABI)
@ -211,7 +212,12 @@ if (LOGGING_ENABLED)
endif ()
# 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)
else ()
set(META_HEADER_ONLY_LIB YES)
@ -225,7 +231,10 @@ endif ()
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 (WIDGETS_HEADER_FILES
OR WIDGETS_SRC_FILES
OR WIDGETS_UI_FILES
OR META_HAS_WIDGETS_GUI)
if (META_GUI_OPTIONAL)
option(WIDGETS_GUI "enables/disables building the Qt Widgets GUI: yes (default) or no" ON)
else ()
@ -234,7 +243,9 @@ if (WIDGETS_HEADER_FILES OR WIDGETS_SRC_FILES OR WIDGETS_UI_FILES OR META_HAS_WI
else ()
set(WIDGETS_GUI OFF)
endif ()
if (QML_HEADER_FILES OR QML_SRC_FILES OR META_HAS_QUICK_GUI)
if (QML_HEADER_FILES
OR QML_SRC_FILES
OR META_HAS_QUICK_GUI)
if (META_GUI_OPTIONAL)
option(QUICK_GUI "enables/disables building the Qt Quick GUI: yes (default) or no" ON)
else ()
@ -286,11 +297,7 @@ set(FORMATABLE_FILES
${EXCLUDED_FILES})
# only format C/C++ files (and not eg. QML files)
if (FORMATABLE_FILES)
list(FILTER
FORMATABLE_FILES
INCLUDE
REGEX
".*\\.(c|cpp|h|hpp)")
list(FILTER FORMATABLE_FILES INCLUDE REGEX ".*\\.(c|cpp|h|hpp)")
endif ()
# determine source files which might be passed to cmake-format
@ -298,13 +305,10 @@ set(FORMATABLE_FILES_CMAKE ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_MO
# add command for symlinking clang-{format,tidy} rules so the tools can find it
if (EXISTS "${CLANG_FORMAT_RULES}")
add_custom_command(OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/.clang-format"
COMMAND "${CMAKE_COMMAND}"
-E
create_symlink
"${CLANG_FORMAT_RULES}"
"${CMAKE_CURRENT_SOURCE_DIR}/.clang-format"
COMMENT "Linking coding style from ${CLANG_FORMAT_RULES}")
add_custom_command(
OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/.clang-format"
COMMAND "${CMAKE_COMMAND}" -E create_symlink "${CLANG_FORMAT_RULES}" "${CMAKE_CURRENT_SOURCE_DIR}/.clang-format"
COMMENT "Linking coding style from ${CLANG_FORMAT_RULES}")
else ()
message(WARNING "Format rules for clang-format not found.")
endif ()
@ -316,60 +320,53 @@ if (NOT META_NO_TIDY)
endif ()
# add target for tidying with clang-format
if (NOT META_NO_TIDY AND CLANG_FORMAT_ENABLED AND FORMATABLE_FILES AND EXISTS "${CLANG_FORMAT_RULES}")
if (NOT META_NO_TIDY
AND CLANG_FORMAT_ENABLED
AND FORMATABLE_FILES
AND EXISTS "${CLANG_FORMAT_RULES}")
find_program(CLANG_FORMAT_BIN clang-format)
if (NOT CLANG_FORMAT_BIN)
message(FATAL_ERROR "Unable to add tidy target; clang-format not found")
endif ()
add_custom_target("${META_TARGET_NAME}_tidy"
COMMAND "${CLANG_FORMAT_BIN}"
-style=file
-i
${FORMATABLE_FILES}
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
COMMENT "Tidying ${META_PROJECT_NAME} sources using clang-format"
DEPENDS "${FORMATABLE_FILES};${CMAKE_CURRENT_SOURCE_DIR}/.clang-format")
add_custom_target(
"${META_TARGET_NAME}_tidy"
COMMAND "${CLANG_FORMAT_BIN}" -style=file -i ${FORMATABLE_FILES}
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
COMMENT "Tidying ${META_PROJECT_NAME} sources using clang-format"
DEPENDS "${FORMATABLE_FILES};${CMAKE_CURRENT_SOURCE_DIR}/.clang-format")
if (NOT TARGET tidy)
add_custom_target(tidy)
endif ()
add_dependencies(tidy "${META_TARGET_NAME}_tidy")
# also add a test to verify whether sources are tidy
add_test(NAME "${META_TARGET_NAME}_tidy_test"
COMMAND "${CLANG_FORMAT_BIN}"
-output-replacements-xml
-style=file
${FORMATABLE_FILES}
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_test(
NAME "${META_TARGET_NAME}_tidy_test"
COMMAND "${CLANG_FORMAT_BIN}" -output-replacements-xml -style=file ${FORMATABLE_FILES}
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
list(APPEND CHECK_TARGET_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/.clang-format")
set_tests_properties("${META_TARGET_NAME}_tidy_test"
PROPERTIES FAIL_REGULAR_EXPRESSION
"<replacement.*>.*</replacement>"
REQUIRED_FILES
"${CMAKE_CURRENT_SOURCE_DIR}/.clang-format")
set_tests_properties(
"${META_TARGET_NAME}_tidy_test" PROPERTIES FAIL_REGULAR_EXPRESSION "<replacement.*>.*</replacement>" REQUIRED_FILES
"${CMAKE_CURRENT_SOURCE_DIR}/.clang-format")
endif ()
# add target for tidying with cmake-format
if (NOT META_NO_TIDY AND CMAKE_FORMAT_ENABLED AND FORMATABLE_FILES_CMAKE)
if (NOT META_NO_TIDY
AND CMAKE_FORMAT_ENABLED
AND FORMATABLE_FILES_CMAKE)
find_program(CMAKE_FORMAT_BIN cmake-format)
if (NOT CMAKE_FORMAT_BIN)
message(FATAL_ERROR "Unable to add tidy target; cmake-format not found")
endif ()
if (NOT META_CMAKE_FORMAT_OPTIONS)
set(META_CMAKE_FORMAT_OPTIONS
--tab-size=4
--separate-ctrl-name-with-space=True
--line-width=125
--autosort=False)
set(META_CMAKE_FORMAT_OPTIONS --tab-size=4 --separate-ctrl-name-with-space=True --line-width=125 --autosort=False)
endif ()
add_custom_target("${META_TARGET_NAME}_cmake_tidy"
COMMAND "${CMAKE_FORMAT_BIN}"
--in-place
${META_CMAKE_FORMAT_OPTIONS}
${FORMATABLE_FILES_CMAKE}
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
COMMENT "Tidying ${META_PROJECT_NAME} sources using cmake-format"
DEPENDS "${FORMATABLE_FILES_CMAKE}")
add_custom_target(
"${META_TARGET_NAME}_cmake_tidy"
COMMAND "${CMAKE_FORMAT_BIN}" --in-place ${META_CMAKE_FORMAT_OPTIONS} ${FORMATABLE_FILES_CMAKE}
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
COMMENT "Tidying ${META_PROJECT_NAME} sources using cmake-format"
DEPENDS "${FORMATABLE_FILES_CMAKE}")
if (NOT TARGET tidy)
add_custom_target(tidy)
endif ()
@ -429,27 +426,23 @@ if (NOT META_NO_STATIC_ANALYSIS AND FORMATABLE_FILES)
set(SYMBOLIC_OUTPUT_FILE "${FILE}.clang-tidy-output")
list(APPEND CLANG_TIDY_SYMBOLIC_OUTPUT_FILES "${SYMBOLIC_OUTPUT_FILE}")
add_custom_command(OUTPUT "${SYMBOLIC_OUTPUT_FILE}"
COMMAND "${CLANG_TIDY_BIN}"
${FILE}
--
${CLANG_TIDY_CXX_FLAGS}
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
COMMENT "Linting ${FILE} using clang-tidy"
DEPENDS "${FILE}" COMMAND_EXPAND_LISTS
VERBATIM)
add_custom_command(
OUTPUT "${SYMBOLIC_OUTPUT_FILE}"
COMMAND "${CLANG_TIDY_BIN}" ${FILE} -- ${CLANG_TIDY_CXX_FLAGS}
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
COMMENT "Linting ${FILE} using clang-tidy"
DEPENDS "${FILE}" COMMAND_EXPAND_LISTS
VERBATIM)
endforeach ()
# mark all symbolic output files actually as symbolic
set_source_files_properties(${CLANG_TIDY_SYMBOLIC_OUTPUT_FILES}
PROPERTIES
SYMBOLIC
YES)
set_source_files_properties(${CLANG_TIDY_SYMBOLIC_OUTPUT_FILES} PROPERTIES SYMBOLIC YES)
# add targets
add_custom_target("${META_TARGET_NAME}_static_check"
DEPENDS ${CLANG_TIDY_SYMBOLIC_OUTPUT_FILES}
COMMENT "Linting ${META_TARGET_NAME} sources using clang-tidy")
add_custom_target(
"${META_TARGET_NAME}_static_check"
DEPENDS ${CLANG_TIDY_SYMBOLIC_OUTPUT_FILES}
COMMENT "Linting ${META_TARGET_NAME} sources using clang-tidy")
if (NOT TARGET static-check)
add_custom_target(static-check)
endif ()
@ -460,10 +453,11 @@ endif ()
# add autotools-style check target
if (NOT TARGET check)
set(CMAKE_CTEST_COMMAND ${CMAKE_CTEST_COMMAND} -V)
add_custom_target(check
COMMAND ${CMAKE_CTEST_COMMAND}
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
DEPENDS "${CHECK_TARGET_DEPENDS}")
add_custom_target(
check
COMMAND ${CMAKE_CTEST_COMMAND}
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
DEPENDS "${CHECK_TARGET_DEPENDS}")
endif ()
# enable source code based coverage analysis using clang
@ -492,23 +486,29 @@ endif ()
if (NOT META_NO_INSTALL_TARGETS AND ENABLE_INSTALL_TARGETS)
foreach (EXTRA_FILE ${EXTRA_FILES})
get_filename_component(EXTRA_DIR ${EXTRA_FILE} DIRECTORY)
install(FILES ${EXTRA_FILE} DESTINATION "${META_DATA_DIR}/${EXTRA_DIR}" COMPONENT extra-files)
install(
FILES ${EXTRA_FILE}
DESTINATION "${META_DATA_DIR}/${EXTRA_DIR}"
COMPONENT extra-files)
endforeach ()
if (NOT TARGET install-extra-files)
add_custom_target(install-extra-files
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_COMPONENT=extra-files
-P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
add_custom_target(install-extra-files COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=extra-files -P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
endif ()
# determine library directory suffix - Applications might be built as libraries under some platforms (eg. Android). Hence
# this is part of BasicConfig and not LibraryConfig.
set(LIB_SUFFIX "" CACHE STRING "specifies the general suffix for the library directory")
set(LIB_SUFFIX
""
CACHE STRING "specifies the general suffix for the library directory")
set(SELECTED_LIB_SUFFIX "${LIB_SUFFIX}")
set(LIB_SUFFIX_32 "" CACHE STRING "specifies the suffix for the library directory to be used when building 32-bit library")
set(LIB_SUFFIX_64 "" CACHE STRING "specifies the suffix for the library directory to be used when building 64-bit library")
set(LIB_SUFFIX_32
""
CACHE STRING "specifies the suffix for the library directory to be used when building 32-bit library")
set(LIB_SUFFIX_64
""
CACHE STRING "specifies the suffix for the library directory to be used when building 64-bit library")
if (LIB_SUFFIX_64 AND CMAKE_SIZEOF_VOID_P MATCHES "8")
set(SELECTED_LIB_SUFFIX "${LIB_SUFFIX_64}")
elseif (LIB_SUFFIX_32 AND CMAKE_SIZEOF_VOID_P MATCHES "4")
@ -535,7 +535,9 @@ function (append_user_defined_additional_libraries)
endif ()
if (LIB_COUNT LESS_EQUAL 0)
# just add the addiitional libs to PRIVATE_LIBRARIES if there are no libs yet anyways
set(PRIVATE_LIBRARIES "${USER_DEFINED_ADDITIONAL_LIBRARIES}" PARENT_SCOPE)
set(PRIVATE_LIBRARIES
"${USER_DEFINED_ADDITIONAL_LIBRARIES}"
PARENT_SCOPE)
endif ()
math(EXPR LAST_LIB_INDEX "${LIB_COUNT} - 1")
list(GET ${LIBS} ${LAST_LIB_INDEX} LAST_LIB)
@ -544,13 +546,18 @@ function (append_user_defined_additional_libraries)
if (TARGET "${LAST_LIB}")
# note: Otherwise the INTERFACE_LINK_LIBRARIES of the last target might still come after the
# USER_DEFINED_ADDITIONAL_LIBRARIES on the linker line.
set_property(TARGET "${LAST_LIB}" APPEND PROPERTY INTERFACE_LINK_LIBRARIES ${USER_DEFINED_ADDITIONAL_LIBRARIES})
set_property(
TARGET "${LAST_LIB}"
APPEND
PROPERTY INTERFACE_LINK_LIBRARIES ${USER_DEFINED_ADDITIONAL_LIBRARIES})
return()
endif ()
# fall back to simply append the library to PRIVATE_LIBRARIES
set(PRIVATE_LIBRARIES "${USER_DEFINED_ADDITIONAL_LIBRARIES}" PARENT_SCOPE)
set(PRIVATE_LIBRARIES
"${USER_DEFINED_ADDITIONAL_LIBRARIES}"
PARENT_SCOPE)
endfunction ()
set(BASIC_PROJECT_CONFIG_DONE YES)

17
cmake/modules/ConfigHeader.cmake
View File

@ -26,11 +26,7 @@ endif ()
get_target_property(INTERFACE_LINK_LIBRARIES_LIST "${META_TARGET_NAME}" INTERFACE_LINK_LIBRARIES)
# make list with link-time dependency versions and display names
foreach (DEPENDENCY
IN
LISTS
LINK_LIBRARIES_LIST
INTERFACE_LINK_LIBRARIES_LIST)
foreach (DEPENDENCY IN LISTS LINK_LIBRARIES_LIST INTERFACE_LINK_LIBRARIES_LIST)
# skip non-targets and already processed dependencies
if (NOT TARGET "${DEPENDENCY}" OR "${DEPENDENCY}" IN_LIST PROCESSED_DEPENDENCIES)
continue()
@ -73,11 +69,7 @@ endforeach ()
# format "DEPENCENCY_VERSIONS_ARRAY"
if (DEPENCENCY_VERSIONS)
include(ListToString)
list_to_string(","
" \\\n \""
"\""
"${DEPENCENCY_VERSIONS}"
DEPENCENCY_VERSIONS_ARRAY)
list_to_string("," " \\\n \"" "\"" "${DEPENCENCY_VERSIONS}" DEPENCENCY_VERSIONS_ARRAY)
endif ()
# add configuration header
@ -85,10 +77,7 @@ configure_file("${CONFIG_H_TEMPLATE_FILE}" "${CMAKE_CURRENT_BINARY_DIR}/resource
# ensure generated include files can be included via #include "resources/config.h"
if (NOT META_HEADER_ONLY_LIB)
foreach (TARGET_NAME
${META_TARGET_NAME}
${META_TARGET_NAME}_tests
${META_TARGET_NAME}_testlib)
foreach (TARGET_NAME ${META_TARGET_NAME} ${META_TARGET_NAME}_tests ${META_TARGET_NAME}_testlib)
if (TARGET ${TARGET_NAME})
target_include_directories(${TARGET_NAME} PRIVATE "${CMAKE_CURRENT_BINARY_DIR}")
endif ()

27
cmake/modules/Doxygen.cmake
View File

@ -32,8 +32,12 @@ if (NOT DOXYGEN_BIN)
endif ()
# load cached configuration and other variables
set(DOXY_LANGUAGE "English" CACHE STRING "specifies the language of the API documentation generated with Doxygen")
set(DOXY_CUSTOM_CONFIG "" CACHE STRING "specifies extra options for Doxygen")
set(DOXY_LANGUAGE
"English"
CACHE STRING "specifies the language of the API documentation generated with Doxygen")
set(DOXY_CUSTOM_CONFIG
""
CACHE STRING "specifies extra options for Doxygen")
set(DOXY_NUMBER "${META_APP_VERSION}")
set(DOXY_INPUT_FILES
${HEADER_FILES}
@ -52,11 +56,7 @@ set(DOXY_MAIN_PAGE_FILE "${DOXY_PATH_PREFIX}${DOXY_MAIN_PAGE_FILE}")
# convert DOXY_INPUT_FILES to whitespace-separated list
include(ListToString)
list_to_string(" "
"\"${DOXY_PATH_PREFIX}"
"\""
"${DOXY_INPUT_FILES}"
DOXY_INPUT_FILES_WHITESPACE_SEPARATED)
list_to_string(" " "\"${DOXY_PATH_PREFIX}" "\"" "${DOXY_INPUT_FILES}" DOXY_INPUT_FILES_WHITESPACE_SEPARATED)
# generate Doxygen configuration
configure_file("${DOXYGEN_TEMPLATE_FILE}" "${CMAKE_CURRENT_BINARY_DIR}/doxygen.config")
@ -70,13 +70,14 @@ add_dependencies(apidoc "${META_TARGET_NAME}_apidoc")
# add install target for API documentation
if (NOT META_NO_INSTALL_TARGETS AND ENABLE_INSTALL_TARGETS)
install(DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/api-doc" DESTINATION "${META_DATA_DIR}" COMPONENT api-doc OPTIONAL)
install(
DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/api-doc"
DESTINATION "${META_DATA_DIR}"
COMPONENT api-doc
OPTIONAL)
if (NOT TARGET install-api-doc)
add_custom_target(install-api-doc
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_COMPONENT=api-doc
-P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
add_custom_target(install-api-doc COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=api-doc -P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
endif ()

334
cmake/modules/LibraryTarget.cmake
View File

@ -11,11 +11,13 @@ endif ()
if (("${META_PROJECT_TYPE}" STREQUAL "plugin") OR ("${META_PROJECT_TYPE}" STREQUAL "qtplugin"))
set(META_IS_PLUGIN YES)
endif ()
if ((NOT "${META_PROJECT_TYPE}" STREQUAL "library") AND (NOT "${META_PROJECT_TYPE}" STREQUAL "") AND NOT META_IS_PLUGIN)
if ((NOT "${META_PROJECT_TYPE}" STREQUAL "library")
AND (NOT "${META_PROJECT_TYPE}" STREQUAL "")
AND NOT META_IS_PLUGIN)
message(
FATAL_ERROR
"The LibraryTarget CMake module is intended to be used for building library projects only (and not for applications)."
)
)
endif ()
# include packages for configure_package_config_file, write_basic_package_version_file and find_template_file
@ -53,10 +55,10 @@ if ("${META_PROJECT_NAME}" STREQUAL "c++utilities")
else ()
set(GENERAL_GLOBAL_H_INCLUDE_PATH "<c++utilities/application/global.h>")
endif ()
configure_file("${GLOBAL_H_TEMPLATE_FILE}"
"${CMAKE_CURRENT_SOURCE_DIR}/global.h" # simply add this to source to ease inclusion
NEWLINE_STYLE UNIX # since this goes to sources ensure consistency
)
configure_file(
"${GLOBAL_H_TEMPLATE_FILE}" "${CMAKE_CURRENT_SOURCE_DIR}/global.h" # simply add this to source to ease inclusion
NEWLINE_STYLE UNIX # since this goes to sources ensure consistency
)
list(APPEND HEADER_FILES global.h)
# add header to check library version
@ -115,46 +117,45 @@ append_user_defined_additional_libraries()
# add library to be created, set libs to link against, set version and C++ standard
if (META_HEADER_ONLY_LIB)
add_library(${META_TARGET_NAME} INTERFACE)
target_link_libraries(${META_TARGET_NAME}
INTERFACE ${META_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}" "${PRIVATE_LIBRARIES}")
target_include_directories(${META_TARGET_NAME}
INTERFACE $<BUILD_INTERFACE:${TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE}>
$<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_INCLUDE_DIRS})
target_compile_definitions(${META_TARGET_NAME}
INTERFACE
"${META_PUBLIC_COMPILE_DEFINITIONS}"
target_link_libraries(${META_TARGET_NAME} INTERFACE ${META_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}"
"${PRIVATE_LIBRARIES}")
target_include_directories(
${META_TARGET_NAME} INTERFACE $<BUILD_INTERFACE:${TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE}>
$<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_INCLUDE_DIRS})
target_compile_definitions(${META_TARGET_NAME} INTERFACE "${META_PUBLIC_COMPILE_DEFINITIONS}"
"${META_PRIVATE_COMPILE_DEFINITIONS}")
target_compile_options(${META_TARGET_NAME} INTERFACE "${META_PUBLIC_COMPILE_OPTIONS}" "${META_PRIVATE_COMPILE_OPTIONS}")
else ()
add_library(${META_TARGET_NAME} ${META_LIBRARY_TYPE} ${ALL_FILES})
target_link_libraries(${META_TARGET_NAME}
PUBLIC ${META_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}"
PRIVATE "${PRIVATE_LIBRARIES}")
target_include_directories(${META_TARGET_NAME}
PUBLIC $<BUILD_INTERFACE:${TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE}>
$<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_INCLUDE_DIRS}
PRIVATE "${PRIVATE_INCLUDE_DIRS}")
target_compile_definitions(${META_TARGET_NAME}
PUBLIC
"${META_PUBLIC_COMPILE_DEFINITIONS}"
PRIVATE
target_link_libraries(
${META_TARGET_NAME}
PUBLIC ${META_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}"
PRIVATE "${PRIVATE_LIBRARIES}")
target_include_directories(
${META_TARGET_NAME}
PUBLIC $<BUILD_INTERFACE:${TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE}>
$<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_INCLUDE_DIRS}
PRIVATE "${PRIVATE_INCLUDE_DIRS}")
target_compile_definitions(${META_TARGET_NAME} PUBLIC "${META_PUBLIC_COMPILE_DEFINITIONS}" PRIVATE
"${META_PRIVATE_COMPILE_DEFINITIONS}")
target_compile_options(${META_TARGET_NAME}
PUBLIC "${META_PUBLIC_LIB_COMPILE_OPTIONS}"
PRIVATE "${META_PRIVATE_LIB_COMPILE_OPTIONS}")
set_target_properties(${META_TARGET_NAME}
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}")
target_compile_options(
${META_TARGET_NAME}
PUBLIC "${META_PUBLIC_LIB_COMPILE_OPTIONS}"
PRIVATE "${META_PRIVATE_LIB_COMPILE_OPTIONS}")
set_target_properties(
${META_TARGET_NAME}
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}")
if (META_PLUGIN_CATEGORY)
set_target_properties(${META_TARGET_NAME} PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${META_PLUGIN_CATEGORY}")
endif ()
@ -181,34 +182,33 @@ if (META_HEADER_ONLY_LIB)
"// not belonging to a real target, only for header-only lib files showing up in Qt Creator")
add_library(${META_TARGET_NAME}_interface_sources_for_qtcreator EXCLUDE_FROM_ALL
"${CMAKE_CURRENT_BINARY_DIR}/headeronly.cpp" ${HEADER_FILES})
target_include_directories(${META_TARGET_NAME}_interface_sources_for_qtcreator
INTERFACE $<BUILD_INTERFACE:${TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE}>
$<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_INCLUDE_DIRS})
target_compile_definitions(${META_TARGET_NAME}_interface_sources_for_qtcreator
INTERFACE
"${META_PUBLIC_LIB_COMPILE_DEFINITIONS}"
"${META_PRIVATE_LIB_COMPILE_DEFINITIONS}")
target_include_directories(
${META_TARGET_NAME}_interface_sources_for_qtcreator
INTERFACE $<BUILD_INTERFACE:${TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE}>
$<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_INCLUDE_DIRS})
target_compile_definitions(${META_TARGET_NAME}_interface_sources_for_qtcreator INTERFACE
"${META_PUBLIC_LIB_COMPILE_DEFINITIONS}" "${META_PRIVATE_LIB_COMPILE_DEFINITIONS}")
target_compile_options(${META_TARGET_NAME}_interface_sources_for_qtcreator
INTERFACE "${META_PUBLIC_LIB_COMPILE_OPTIONS}" "${META_PRIVATE_LIB_COMPILE_OPTIONS}")
set_target_properties(${META_TARGET_NAME}_interface_sources_for_qtcreator
PROPERTIES VERSION
"${META_VERSION_MAJOR}.${META_VERSION_MINOR}.${META_VERSION_PATCH}"
SOVERSION
"${META_SOVERSION}"
CXX_STANDARD
"${META_CXX_STANDARD}"
AUTOGEN_TARGET_DEPENDS
"${AUTOGEN_DEPS}")
set_target_properties(
${META_TARGET_NAME}_interface_sources_for_qtcreator
PROPERTIES VERSION
"${META_VERSION_MAJOR}.${META_VERSION_MINOR}.${META_VERSION_PATCH}"
SOVERSION
"${META_SOVERSION}"
CXX_STANDARD
"${META_CXX_STANDARD}"
AUTOGEN_TARGET_DEPENDS
"${AUTOGEN_DEPS}")
endif ()
# generate CMake code to configure additional arguments for required CMake-packages
set(ADDITIONAL_ARGUMENTS_FOR_REQUIRED_CMAKE_PACKAGES)
foreach (INTERFACE_REQUIRED_PACKAGE ${INTERFACE_REQUIRED_PACKAGES})
if (PACKAGE_ARGS_${INTERFACE_REQUIRED_PACKAGE})
set(
ADDITIONAL_ARGUMENTS_FOR_REQUIRED_CMAKE_PACKAGES
set(ADDITIONAL_ARGUMENTS_FOR_REQUIRED_CMAKE_PACKAGES
"${ADDITIONAL_ARGUMENTS_FOR_REQUIRED_CMAKE_PACKAGES}set(${META_PROJECT_VARNAME_UPPER}_FIND_PACKAGE_ARGS_${INTERFACE_REQUIRED_PACKAGE} \"${PACKAGE_ARGS_${INTERFACE_REQUIRED_PACKAGE}}\")\n"
)
)
endif ()
endforeach ()
@ -216,14 +216,10 @@ endforeach ()
set(TARGET_TO_PKG_CONFIG_MODULE_NAME_MAPPING
"set(PKG_CONFIG_${META_TARGET_NAME} \"${META_PROJECT_NAME}${META_CONFIG_SUFFIX}\")")
foreach (INTERFACE_REQUIRED_PKG_CONFIG_MODULE ${INTERFACE_REQUIRED_PKG_CONFIG_MODULES})
string(REPLACE "::"
"_"
INTERFACE_REQUIRED_PKG_CONFIG_MODULE_VARNAME
"${INTERFACE_REQUIRED_PKG_CONFIG_MODULE}")
set(
TARGET_TO_PKG_CONFIG_MODULE_NAME_MAPPING
string(REPLACE "::" "_" INTERFACE_REQUIRED_PKG_CONFIG_MODULE_VARNAME "${INTERFACE_REQUIRED_PKG_CONFIG_MODULE}")
set(TARGET_TO_PKG_CONFIG_MODULE_NAME_MAPPING
"${TARGET_TO_PKG_CONFIG_MODULE_NAME_MAPPING}\nset(PKG_CONFIG_${INTERFACE_REQUIRED_PKG_CONFIG_MODULE_VARNAME} \"${PKG_CONFIG_${INTERFACE_REQUIRED_PKG_CONFIG_MODULE_VARNAME}}\")"
)
)
endforeach ()
# create the CMake package config file from template
@ -241,31 +237,29 @@ if (META_CONFIG_SUFFIX)
endif ()
find_template_file("Config.cmake" CPP_UTILITIES CONFIG_TEMPLATE_FILE)
foreach (CONFIG_TARGET ${CONFIG_TARGETS})
configure_package_config_file("${CONFIG_TEMPLATE_FILE}"
"${CONFIG_TARGET}"
INSTALL_DESTINATION
"${CMAKE_CONFIG_INSTALL_DESTINATION}"
PATH_VARS
CMAKE_MODULE_INSTALL_DESTINATION
CMAKE_CONFIG_INSTALL_DESTINATION
HEADER_INSTALL_DESTINATION
BIN_INSTALL_DESTINATION
LIB_INSTALL_DESTINATION)
configure_package_config_file(
"${CONFIG_TEMPLATE_FILE}"
"${CONFIG_TARGET}"
INSTALL_DESTINATION
"${CMAKE_CONFIG_INSTALL_DESTINATION}"
PATH_VARS
CMAKE_MODULE_INSTALL_DESTINATION
CMAKE_CONFIG_INSTALL_DESTINATION
HEADER_INSTALL_DESTINATION
BIN_INSTALL_DESTINATION
LIB_INSTALL_DESTINATION)
endforeach ()
list(APPEND CMAKE_CONFIG_FILES "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}${META_CONFIG_SUFFIX}Config.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}${META_CONFIG_SUFFIX}ConfigVersion.cmake")
# write the CMake version config file
write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}${META_CONFIG_SUFFIX}ConfigVersion.cmake
VERSION "${META_VERSION_MAJOR}.${META_VERSION_MINOR}.${META_VERSION_PATCH}"
COMPATIBILITY SameMajorVersion)
write_basic_package_version_file(
${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}${META_CONFIG_SUFFIX}ConfigVersion.cmake
VERSION "${META_VERSION_MAJOR}.${META_VERSION_MINOR}.${META_VERSION_PATCH}"
COMPATIBILITY SameMajorVersion)
# compute dependencies for pkg-config file
macro (compute_dependencies_for_package_config
DEPENDS
OUTPUT_VAR_PKGS
OUTPUT_VAR_LIBS
UNSET)
macro (compute_dependencies_for_package_config DEPENDS OUTPUT_VAR_PKGS OUTPUT_VAR_LIBS UNSET)
if (UNSET)
unset(${OUTPUT_VAR_PKGS})
unset(${OUTPUT_VAR_LIBS})
@ -281,10 +275,7 @@ macro (compute_dependencies_for_package_config
continue()
endif ()
# find the name of the pkg-config package for the depencency
string(REPLACE "::"
"_"
DEPENDENCY_VARNAME
"${DEPENDENCY}")
string(REPLACE "::" "_" DEPENDENCY_VARNAME "${DEPENDENCY}")
if (PKG_CONFIG_${DEPENDENCY_VARNAME})
# add pkg-config modules for the dependency
foreach (PKG_CONFIG_MODULE ${PKG_CONFIG_${DEPENDENCY_VARNAME}})
@ -305,9 +296,7 @@ macro (compute_dependencies_for_package_config
endif ()
endforeach ()
compute_dependencies_for_package_config("${DEPENDENCY_VARNAME}_INTERFACE_LINK_LIBRARIES_TARGETS"
"${OUTPUT_VAR_PKGS}"
"${OUTPUT_VAR_LIBS}"
NO)
"${OUTPUT_VAR_PKGS}" "${OUTPUT_VAR_LIBS}" NO)
if (${DEPENDENCY_VARNAME}_INTERFACE_LINK_LIBRARIES_EXISTING)
continue()
endif ()
@ -326,10 +315,7 @@ macro (compute_dependencies_for_package_config
# location
string(FIND "${${DEPENDENCY_VARNAME}_IMPORTED_LOCATION_${META_CURRENT_CONFIGURATION}}"
"${CMAKE_CURRENT_BINARY_DIR}" BINARY_DIR_INDEX)
if (NOT
BINARY_DIR_INDEX
EQUAL
0
if (NOT BINARY_DIR_INDEX EQUAL 0
AND EXISTS "${${DEPENDENCY_VARNAME}_IMPORTED_LOCATION_${META_CURRENT_CONFIGURATION}}")
set(${OUTPUT_VAR_LIBS}
"${${OUTPUT_VAR_LIBS}} ${${DEPENDENCY_VARNAME}_IMPORTED_LOCATION_${META_CURRENT_CONFIGURATION}}")
@ -356,23 +342,15 @@ macro (compute_dependencies_for_package_config
get_target_property("${DEPENDENCY_VARNAME}_IMPORTED_LINK_INTERFACE_LIBRARIES" "${DEPENDENCY}"
"IMPORTED_LINK_INTERFACE_LIBRARIES")
compute_dependencies_for_package_config("${DEPENDENCY_VARNAME}_IMPORTED_LINK_INTERFACE_LIBRARIES"
"${OUTPUT_VAR_PKGS}"
"${OUTPUT_VAR_LIBS}"
NO)
"${OUTPUT_VAR_PKGS}" "${OUTPUT_VAR_LIBS}" NO)
else ()
# add raw dependency
set(${OUTPUT_VAR_LIBS} "${${OUTPUT_VAR_LIBS}} ${DEPENDENCY}")
endif ()
endforeach ()
endmacro ()
compute_dependencies_for_package_config(META_PUBLIC_LIB_DEPENDS
META_PUBLIC_PC_PKGS
META_PUBLIC_LIB_DEPENDS_FOR_PC
YES)
compute_dependencies_for_package_config(META_PRIVATE_LIB_DEPENDS
META_PRIVATE_PC_PKGS
META_PRIVATE_LIB_DEPENDS_FOR_PC
YES)
compute_dependencies_for_package_config(META_PUBLIC_LIB_DEPENDS META_PUBLIC_PC_PKGS META_PUBLIC_LIB_DEPENDS_FOR_PC YES)
compute_dependencies_for_package_config(META_PRIVATE_LIB_DEPENDS META_PRIVATE_PC_PKGS META_PRIVATE_LIB_DEPENDS_FOR_PC YES)
if (NOT META_HEADER_ONLY_LIB)
set(META_PUBLIC_LIB_DEPENDS_FOR_PC " -l${META_TARGET_NAME}${META_PUBLIC_LIB_DEPENDS_FOR_PC}")
endif ()
@ -394,44 +372,38 @@ set(PC_FILES "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME_FOR_PC}.pc")
# add install targets
if (NOT META_NO_INSTALL_TARGETS AND ENABLE_INSTALL_TARGETS)
# add install target for the CMake config files
install(FILES ${CMAKE_CONFIG_FILES} DESTINATION "${META_DATA_DIR}/cmake" COMPONENT cmake-config)
install(
FILES ${CMAKE_CONFIG_FILES}
DESTINATION "${META_DATA_DIR}/cmake"
COMPONENT cmake-config)
if (NOT TARGET install-cmake-config)
add_custom_target(install-cmake-config
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_COMPONENT=cmake-config
-P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
add_custom_target(install-cmake-config COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=cmake-config -P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
# add install target for pkg-config file
if (PC_FILES)
install(FILES ${PC_FILES} DESTINATION "lib${SELECTED_LIB_SUFFIX}/pkgconfig" COMPONENT pkg-config)
install(
FILES ${PC_FILES}
DESTINATION "lib${SELECTED_LIB_SUFFIX}/pkgconfig"
COMPONENT pkg-config)
endif ()
if (NOT TARGET install-pkg-config)
add_custom_target(install-pkg-config
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_COMPONENT=pkg-config
-P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
add_custom_target(install-pkg-config COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=pkg-config -P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
# add install target for libs
if (NOT TARGET install-binary)
add_custom_target(install-binary
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_COMPONENT=binary
-P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
add_custom_target(install-binary COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=binary -P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
# add install target for stripped libs
if (NOT TARGET install-binary-strip)
add_custom_target(install-binary-strip
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_DO_STRIP=1
-DCMAKE_INSTALL_COMPONENT=binary
-P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
add_custom_target(
install-binary-strip COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_DO_STRIP=1 -DCMAKE_INSTALL_COMPONENT=binary -P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
# determine install dir for Qt plugins
@ -451,7 +423,7 @@ if (NOT META_NO_INSTALL_TARGETS AND ENABLE_INSTALL_TARGETS)
message(
WARNING
"According to qmake the Qt plugin directory is \"${QT_INSTALL_PLUGINS}\". However, that path is not within the install prefix \"${CMAKE_INSTALL_PREFIX}\" and therefore ignored."
)
)
endif ()
endif ()
if (NOT LIBRARY_DESTINATION)
@ -459,7 +431,7 @@ if (NOT META_NO_INSTALL_TARGETS AND ENABLE_INSTALL_TARGETS)
message(
WARNING
"Unable to detect appropriate install directory for Qt plugins (assuming \"${LIBRARY_DESTINATION}\"). Set QT_PLUGIN_DIR to specify the directory to install Qt plugins to manually."
)
)
endif ()
endif ()
if (META_PLUGIN_CATEGORY)
@ -472,83 +444,80 @@ if (NOT META_NO_INSTALL_TARGETS AND ENABLE_INSTALL_TARGETS)
# add install targets and export targets
set(TARGETS_TO_EXPORT "${META_TARGET_NAME}")
foreach (BUNDLED_TARGET ${BUNDLED_TARGETS})
if (NOT
${BUNDLED_TARGET}
IN_LIST
LIBRARIES
OR (NOT BUILD_SHARED_LIBS AND ${BUNDLED_TARGET} IN_LIST PRIVATE_LIBRARIES))
if (NOT ${BUNDLED_TARGET} IN_LIST LIBRARIES OR (NOT BUILD_SHARED_LIBS AND ${BUNDLED_TARGET} IN_LIST PRIVATE_LIBRARIES
))
list(APPEND TARGETS_TO_EXPORT ${BUNDLED_TARGET})
endif ()
endforeach ()
install(TARGETS ${TARGETS_TO_EXPORT}
EXPORT "${META_PROJECT_NAME}${META_CONFIG_SUFFIX}Targets"
RUNTIME DESTINATION bin COMPONENT binary
LIBRARY DESTINATION ${LIBRARY_DESTINATION} COMPONENT binary
ARCHIVE DESTINATION ${LIBRARY_DESTINATION} COMPONENT binary)
install(
TARGETS ${TARGETS_TO_EXPORT}
EXPORT "${META_PROJECT_NAME}${META_CONFIG_SUFFIX}Targets"
RUNTIME DESTINATION bin COMPONENT binary
LIBRARY DESTINATION ${LIBRARY_DESTINATION} COMPONENT binary
ARCHIVE DESTINATION ${LIBRARY_DESTINATION} COMPONENT binary)
add_dependencies(install-binary "${META_TARGET_NAME}")
add_dependencies(install-binary-strip "${META_TARGET_NAME}")
install(EXPORT ${META_PROJECT_NAME}${META_CONFIG_SUFFIX}Targets
DESTINATION "${META_DATA_DIR}/cmake"
EXPORT_LINK_INTERFACE_LIBRARIES
COMPONENT cmake-config)
install(
EXPORT ${META_PROJECT_NAME}${META_CONFIG_SUFFIX}Targets
DESTINATION "${META_DATA_DIR}/cmake"
EXPORT_LINK_INTERFACE_LIBRARIES
COMPONENT cmake-config)
# add install target for header files
if (NOT META_IS_PLUGIN)
foreach (HEADER_FILE ${HEADER_FILES} ${ADDITIONAL_HEADER_FILES})
get_filename_component(HEADER_DIR "${HEADER_FILE}" DIRECTORY)
install(FILES "${HEADER_FILE}"
DESTINATION "${INCLUDE_SUBDIR}/${META_PROJECT_NAME}/${HEADER_DIR}"
COMPONENT header)
install(
FILES "${HEADER_FILE}"
DESTINATION "${INCLUDE_SUBDIR}/${META_PROJECT_NAME}/${HEADER_DIR}"
COMPONENT header)
endforeach ()
install(FILES "${VERSION_HEADER_FILE}" DESTINATION "${INCLUDE_SUBDIR}/${META_PROJECT_NAME}" COMPONENT header)
install(
FILES "${VERSION_HEADER_FILE}"
DESTINATION "${INCLUDE_SUBDIR}/${META_PROJECT_NAME}"
COMPONENT header)
if (NOT TARGET install-header)
add_custom_target(install-header
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_COMPONENT=header
-P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
add_custom_target(install-header COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=header -P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
endif ()
# add install target for CMake modules
foreach (CMAKE_MODULE_FILE ${CMAKE_MODULE_FILES})
get_filename_component(CMAKE_MODULE_DIR ${CMAKE_MODULE_FILE} DIRECTORY)
install(FILES ${CMAKE_MODULE_FILE} DESTINATION ${META_DATA_DIR}/${CMAKE_MODULE_DIR} COMPONENT cmake-modules)
install(
FILES ${CMAKE_MODULE_FILE}
DESTINATION ${META_DATA_DIR}/${CMAKE_MODULE_DIR}
COMPONENT cmake-modules)
endforeach ()
if (NOT TARGET install-cmake-modules)
add_custom_target(install-cmake-modules
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_COMPONENT=cmake-modules
-P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
add_custom_target(install-cmake-modules COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=cmake-modules -P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
# add install target for CMake templates
foreach (CMAKE_TEMPLATE_FILE ${CMAKE_TEMPLATE_FILES})
get_filename_component(CMAKE_TEMPLATE_DIR ${CMAKE_TEMPLATE_FILE} DIRECTORY)
install(FILES ${CMAKE_TEMPLATE_FILE} DESTINATION ${META_DATA_DIR}/${CMAKE_TEMPLATE_DIR} COMPONENT cmake-templates)
install(
FILES ${CMAKE_TEMPLATE_FILE}
DESTINATION ${META_DATA_DIR}/${CMAKE_TEMPLATE_DIR}
COMPONENT cmake-templates)
endforeach ()
if (NOT TARGET install-cmake-templates)
add_custom_target(install-cmake-templates
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_COMPONENT=cmake-templates
-P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
add_custom_target(install-cmake-templates COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=cmake-templates -P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
# add install target for all the cmake stuff
if (NOT TARGET install-cmake-stuff)
add_custom_target(install-cmake-stuff)
add_dependencies(install-cmake-stuff
install-cmake-config
install-cmake-modules
install-cmake-templates)
add_dependencies(install-cmake-stuff install-cmake-config install-cmake-modules install-cmake-templates)
endif ()
# add targets to ease creating mingw-w64 packages under Arch Linux
if (MINGW)
option(ENABLE_TARGETS_FOR_MINGW_CROSS_PACKAGING "enable targets to ease creating mingw-w64 packages under Arch Linux"
OFF)
option(ENABLE_TARGETS_FOR_MINGW_CROSS_PACKAGING
"enable targets to ease creating mingw-w64 packages under Arch Linux" OFF)
else ()
set(ENABLE_TARGETS_FOR_MINGW_CROSS_PACKAGING OFF)
endif ()
@ -556,19 +525,11 @@ if (NOT META_NO_INSTALL_TARGETS AND ENABLE_INSTALL_TARGETS)
if (NOT TARGET install-mingw-w64)
add_custom_target(install-mingw-w64)
endif ()
add_dependencies(install-mingw-w64
install-binary
install-header
install-cmake-stuff
install-pkg-config)
add_dependencies(install-mingw-w64 install-binary install-header install-cmake-stuff install-pkg-config)
if (NOT TARGET install-mingw-w64-strip)
add_custom_target(install-mingw-w64-strip)
endif ()
add_dependencies(install-mingw-w64-strip
install-binary-strip
install-header
install-cmake-stuff
install-pkg-config)
add_dependencies(install-mingw-w64-strip install-binary-strip install-header install-cmake-stuff install-pkg-config)
if (LOCALIZATION_TARGET)
add_dependencies(install-mingw-w64 ${LOCALIZATION_TARGET})
add_dependencies(install-mingw-w64-strip ${LOCALIZATION_TARGET})
@ -588,9 +549,10 @@ if (NOT META_NO_INSTALL_TARGETS AND ENABLE_INSTALL_TARGETS)
add_dependencies(install-mingw-w64-strip install-${META_TARGET_NAME}-mingw-w64-importlib-strip)
endif ()
if (BUILD_STATIC_LIBS AND NOT META_HEADER_ONLY_LIB)
add_custom_target(install-${META_TARGET_NAME}-mingw-w64-staticlib-strip
COMMAND "${STRIP_BINARY_PATH}" -g
"\$\{DESTDIR\}\$\{DESTDIR:+/\}${CMAKE_INSTALL_PREFIX}/lib/lib${META_TARGET_NAME}.a")
add_custom_target(
install-${META_TARGET_NAME}-mingw-w64-staticlib-strip
COMMAND "${STRIP_BINARY_PATH}" -g
"\$\{DESTDIR\}\$\{DESTDIR:+/\}${CMAKE_INSTALL_PREFIX}/lib/lib${META_TARGET_NAME}.a")
add_dependencies(install-${META_TARGET_NAME}-mingw-w64-staticlib-strip install-binary-strip)
add_dependencies(install-mingw-w64-strip install-${META_TARGET_NAME}-mingw-w64-staticlib-strip)
endif ()

11
cmake/modules/ListToString.cmake
View File

@ -4,12 +4,7 @@ if (DEFINED LIST_TO_STRING_LOADED)
endif ()
set(LIST_TO_STRING_LOADED ON)
function (list_to_string
separator
prefix
suffix
input_list
output_string_var)
function (list_to_string separator prefix suffix input_list output_string_var)
set(res "")
# get list length
list(LENGTH input_list list_length)
@ -31,5 +26,7 @@ function (list_to_string
endif ()
endforeach ()
endif ()
set(${output_string_var} "${res}" PARENT_SCOPE)
set(${output_string_var}
"${res}"
PARENT_SCOPE)
endfunction ()

14
cmake/modules/ShellCompletion.cmake
View File

@ -20,15 +20,13 @@ if (BASH_COMPLETION_ENABLED)
# add install target bash completion
if (NOT META_NO_INSTALL_TARGETS AND ENABLE_INSTALL_TARGETS)
install(DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bash-completion/completions"
DESTINATION "share/bash-completion"
COMPONENT bash-completion)
install(
DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bash-completion/completions"
DESTINATION "share/bash-completion"
COMPONENT bash-completion)
if (NOT TARGET install-bash-completion)
add_custom_target(install-bash-completion
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_COMPONENT=bash-completion
-P
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
add_custom_target(install-bash-completion COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=bash-completion
-P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
endif ()

17
cmake/modules/TemplateFinder.cmake
View File

@ -4,21 +4,24 @@ if (DEFINED TEMPLATE_FINDER_LOADED)
endif ()
set(TEMPLATE_FINDER_LOADED YES)
function (find_template_file
FILE_NAME
PROJECT_VAR_NAME
OUTPUT_VAR)
function (find_template_file FILE_NAME PROJECT_VAR_NAME OUTPUT_VAR)
if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/cmake/templates/${FILE_NAME}.in")
# check own source directory
set(${OUTPUT_VAR} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/templates/${FILE_NAME}.in" PARENT_SCOPE)
set(${OUTPUT_VAR}
"${CMAKE_CURRENT_SOURCE_DIR}/cmake/templates/${FILE_NAME}.in"
PARENT_SCOPE)
message(STATUS "Using template for ${FILE_NAME} from own (${META_PROJECT_NAME}) source directory.")
elseif (EXISTS "${${PROJECT_VAR_NAME}_SOURCE_DIR}/cmake/templates/${FILE_NAME}.in")
# check sources of project
set(${OUTPUT_VAR} "${${PROJECT_VAR_NAME}_SOURCE_DIR}/cmake/templates/${FILE_NAME}.in" PARENT_SCOPE)
set(${OUTPUT_VAR}
"${${PROJECT_VAR_NAME}_SOURCE_DIR}/cmake/templates/${FILE_NAME}.in"
PARENT_SCOPE)
message(STATUS "Using template for ${FILE_NAME} from ${PROJECT_VAR_NAME} source directory.")
elseif (EXISTS "${${PROJECT_VAR_NAME}_CONFIG_DIRS}/templates/${FILE_NAME}.in")
# check installed version of project
set(${OUTPUT_VAR} "${${PROJECT_VAR_NAME}_CONFIG_DIRS}/templates/${FILE_NAME}.in" PARENT_SCOPE)
set(${OUTPUT_VAR}
"${${PROJECT_VAR_NAME}_CONFIG_DIRS}/templates/${FILE_NAME}.in"
PARENT_SCOPE)
message(STATUS "Using template for ${FILE_NAME} from ${PROJECT_VAR_NAME} installation.")
else ()
message(FATAL_ERROR "Template for ${FILE_NAME} file can not be located.")

270
cmake/modules/TestTarget.cmake
View File

@ -10,8 +10,12 @@ option(EXCLUDE_TESTS_FROM_ALL "specifies whether to exclude tests from the \"all
# find and link against cppunit if required (used by all my projects, so it is required by default)
if (NOT META_NO_CPP_UNIT)
# make cppunit library/include dir configurable
set(CPP_UNIT_LIB NOTFOUND CACHE FILEPATH "cppunit lib" FORCE)
set(CPP_UNIT_INCLUDE_DIR NOTFOUND CACHE FILEPATH "cppunit include dir" FORCE)
set(CPP_UNIT_LIB
NOTFOUND
CACHE FILEPATH "cppunit lib" FORCE)
set(CPP_UNIT_INCLUDE_DIR
NOTFOUND
CACHE FILEPATH "cppunit include dir" FORCE)
# set default for minimum version (only checked when using pkg-config)
if (NOT META_REQUIRED_CPP_UNIT_VERSION)
@ -23,8 +27,9 @@ if (NOT META_NO_CPP_UNIT)
include(FindPkgConfig)
pkg_search_module(CPP_UNIT_CONFIG_${META_PROJECT_NAME} cppunit>=${META_REQUIRED_CPP_UNIT_VERSION})
if (CPP_UNIT_CONFIG_${META_PROJECT_NAME}_FOUND)
set(CPP_UNIT_LIB "${CPP_UNIT_CONFIG_${META_PROJECT_NAME}_LDFLAGS_OTHER}"
"${CPP_UNIT_CONFIG_${META_PROJECT_NAME}_LIBRARIES}" CACHE FILEPATH "cppunit lib" FORCE)
set(CPP_UNIT_LIB
"${CPP_UNIT_CONFIG_${META_PROJECT_NAME}_LDFLAGS_OTHER}" "${CPP_UNIT_CONFIG_${META_PROJECT_NAME}_LIBRARIES}"
CACHE FILEPATH "cppunit lib" FORCE)
set(CPP_UNIT_INCLUDE_DIR
${CPP_UNIT_CONFIG_${META_PROJECT_NAME}_INCLUDE_DIRS}
CACHE FILEPATH "cppunit include dir" FORCE)
@ -32,7 +37,9 @@ if (NOT META_NO_CPP_UNIT)
else ()
# fall back to find_library
find_library(DETECTED_CPP_UNIT_LIB cppunit)
set(CPP_UNIT_LIB "${DETECTED_CPP_UNIT_LIB}" CACHE FILEPATH "cppunit lib" FORCE)
set(CPP_UNIT_LIB
"${DETECTED_CPP_UNIT_LIB}"
CACHE FILEPATH "cppunit lib" FORCE)
endif ()
endif ()
@ -48,7 +55,7 @@ if (NOT META_NO_CPP_UNIT)
message(
WARNING
"Cppunit not detected via pkg-config so the version couldn't be checked. Required version for ${META_PROJECT_NAME} is ${META_REQUIRED_CPP_UNIT_VERSION}."
)
)
endif ()
if (CPP_UNIT_INCLUDE_DIR)
@ -62,7 +69,7 @@ if (META_ADD_DEFAULT_CPP_UNIT_TEST_APPLICATION)
message(
FATAL_ERROR
"Project ${META_PROJECT_NAME} has META_ADD_DEFAULT_CPP_UNIT_TEST_APPLICATION and META_NO_CPP_UNIT enabled at the same time."
)
)
endif ()
set(DEFAULT_CPP_UNIT_TEST_APPLICATION_SRC "${CMAKE_CURRENT_BINARY_DIR}/cppunit.cpp")
@ -100,39 +107,34 @@ 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'
set(TESTLIB_FILES
${HEADER_FILES}
${SRC_FILES}
${WIDGETS_FILES}
${QML_FILES}
${RES_FILES}
${QM_FILES})
set(TESTLIB_FILES ${HEADER_FILES} ${SRC_FILES} ${WIDGETS_FILES} ${QML_FILES} ${RES_FILES} ${QM_FILES})
list(REMOVE_ITEM TESTLIB_FILES main.h main.cpp)
add_library(${META_TARGET_NAME}_testlib SHARED ${TESTLIB_FILES})
target_link_libraries(${META_TARGET_NAME}_testlib
PUBLIC ${META_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}"
PRIVATE "${PRIVATE_LIBRARIES}")
target_include_directories(${META_TARGET_NAME}_testlib
PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
$<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_INCLUDE_DIRS}
PRIVATE "${PRIVATE_INCLUDE_DIRS}")
target_compile_definitions(${META_TARGET_NAME}_testlib
PUBLIC
"${META_PUBLIC_COMPILE_DEFINITIONS}"
PRIVATE
target_link_libraries(
${META_TARGET_NAME}_testlib
PUBLIC ${META_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}"
PRIVATE "${PRIVATE_LIBRARIES}")
target_include_directories(
${META_TARGET_NAME}_testlib
PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}> $<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}>
${PUBLIC_INCLUDE_DIRS}
PRIVATE "${PRIVATE_INCLUDE_DIRS}")
target_compile_definitions(${META_TARGET_NAME}_testlib PUBLIC "${META_PUBLIC_COMPILE_DEFINITIONS}" PRIVATE
"${META_PRIVATE_COMPILE_DEFINITIONS}")
target_compile_options(${META_TARGET_NAME}_testlib
PUBLIC "${META_PUBLIC_COMPILE_OPTIONS}"
PRIVATE "${META_PRIVATE_COMPILE_OPTIONS}")
set_target_properties(${META_TARGET_NAME}_testlib
PROPERTIES CXX_STANDARD
"${META_CXX_STANDARD}"
LINK_SEARCH_START_STATIC
${STATIC_LINKAGE}
LINK_SEARCH_END_STATIC
${STATIC_LINKAGE}
AUTOGEN_TARGET_DEPENDS
"${AUTOGEN_DEPS}")
target_compile_options(
${META_TARGET_NAME}_testlib
PUBLIC "${META_PUBLIC_COMPILE_OPTIONS}"
PRIVATE "${META_PRIVATE_COMPILE_OPTIONS}")
set_target_properties(
${META_TARGET_NAME}_testlib
PROPERTIES CXX_STANDARD
"${META_CXX_STANDARD}"
LINK_SEARCH_START_STATIC
${STATIC_LINKAGE}
LINK_SEARCH_END_STATIC
${STATIC_LINKAGE}
AUTOGEN_TARGET_DEPENDS
"${AUTOGEN_DEPS}")
if (CPP_UNIT_CONFIG_${META_PROJECT_NAME}_FOUND)
target_include_directories(${META_TARGET_NAME}_testlib
PRIVATE "${CPP_UNIT_CONFIG_${META_PROJECT_NAME}_INCLUDE_DIRS}")
@ -147,28 +149,23 @@ if (META_PROJECT_IS_APPLICATION)
endif ()
# configure test target
target_link_libraries(${META_TARGET_NAME}_tests
PUBLIC ${META_ADDITIONAL_LINK_FLAGS} ${META_ADDITIONAL_LINK_FLAGS_TEST_TARGET} "${PUBLIC_LIBRARIES}"
PRIVATE "${TEST_LIBRARIES}" "${PRIVATE_LIBRARIES}")
target_include_directories(${META_TARGET_NAME}_tests
PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
$<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_INCLUDE_DIRS}
PRIVATE ${TEST_INCLUDE_DIRS} "${PRIVATE_INCLUDE_DIRS}")
target_compile_definitions(${META_TARGET_NAME}_tests
PUBLIC
"${META_PUBLIC_COMPILE_DEFINITIONS}"
PRIVATE
target_link_libraries(
${META_TARGET_NAME}_tests
PUBLIC ${META_ADDITIONAL_LINK_FLAGS} ${META_ADDITIONAL_LINK_FLAGS_TEST_TARGET} "${PUBLIC_LIBRARIES}"
PRIVATE "${TEST_LIBRARIES}" "${PRIVATE_LIBRARIES}")
target_include_directories(
${META_TARGET_NAME}_tests
PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}> $<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}>
${PUBLIC_INCLUDE_DIRS}
PRIVATE ${TEST_INCLUDE_DIRS} "${PRIVATE_INCLUDE_DIRS}")
target_compile_definitions(${META_TARGET_NAME}_tests PUBLIC "${META_PUBLIC_COMPILE_DEFINITIONS}" PRIVATE
"${META_PRIVATE_COMPILE_DEFINITIONS}")
target_compile_options(${META_TARGET_NAME}_tests
PUBLIC "${META_PUBLIC_COMPILE_OPTIONS}"
PRIVATE "${META_PRIVATE_COMPILE_OPTIONS}")
set_target_properties(${META_TARGET_NAME}_tests
PROPERTIES CXX_STANDARD
"${META_CXX_STANDARD}"
LINK_SEARCH_START_STATIC
${STATIC_LINKAGE}
LINK_SEARCH_END_STATIC
${STATIC_LINKAGE})
target_compile_options(
${META_TARGET_NAME}_tests
PUBLIC "${META_PUBLIC_COMPILE_OPTIONS}"
PRIVATE "${META_PRIVATE_COMPILE_OPTIONS}")
set_target_properties(${META_TARGET_NAME}_tests PROPERTIES CXX_STANDARD "${META_CXX_STANDARD}" LINK_SEARCH_START_STATIC
${STATIC_LINKAGE} LINK_SEARCH_END_STATIC ${STATIC_LINKAGE})
# make the test recognized by ctest
unset(RUN_TESTS_APPLICATION_ARG)
@ -177,12 +174,8 @@ if (META_PROJECT_TYPE STREQUAL "application")
endif ()
if (NOT META_TEST_TARGET_IS_MANUAL)
add_test(NAME ${META_PROJECT_NAME}_run_tests
COMMAND ${META_TARGET_NAME}_tests
-p
"${CMAKE_CURRENT_SOURCE_DIR}/testfiles"
-w
"${CMAKE_CURRENT_BINARY_DIR}/testworkingdir"
${RUN_TESTS_APPLICATION_ARGS})
COMMAND ${META_TARGET_NAME}_tests -p "${CMAKE_CURRENT_SOURCE_DIR}/testfiles" -w
"${CMAKE_CURRENT_BINARY_DIR}/testworkingdir" ${RUN_TESTS_APPLICATION_ARGS})
endif ()
# enable source code based coverage analysis using clang
@ -211,17 +204,11 @@ if (CLANG_SOURCE_BASED_COVERAGE_AVAILABLE)
# add command to execute tests generating raw profiling data
add_custom_command(
OUTPUT "${LLVM_PROFILE_RAW_FILE}" "${LLVM_PROFILE_RAW_LIST_FILE}"
COMMAND "${CMAKE_COMMAND}"
-E
env
"LLVM_PROFILE_FILE=${LLVM_PROFILE_RAW_FILE}"
"LLVM_PROFILE_LIST_FILE=${LLVM_PROFILE_RAW_LIST_FILE}"
$<TARGET_FILE:${META_TARGET_NAME}_tests>
-p
"${CMAKE_CURRENT_SOURCE_DIR}/testfiles"
-w
"${CMAKE_CURRENT_BINARY_DIR}/testworkingdir"
${RUN_TESTS_APPLICATION_ARGS}
COMMAND
"${CMAKE_COMMAND}" -E env "LLVM_PROFILE_FILE=${LLVM_PROFILE_RAW_FILE}"
"LLVM_PROFILE_LIST_FILE=${LLVM_PROFILE_RAW_LIST_FILE}" $<TARGET_FILE:${META_TARGET_NAME}_tests> -p
"${CMAKE_CURRENT_SOURCE_DIR}/testfiles" -w "${CMAKE_CURRENT_BINARY_DIR}/testworkingdir"
${RUN_TESTS_APPLICATION_ARGS}
COMMENT "Executing ${META_TARGET_NAME}_tests to generate raw profiling data for source-based coverage report"
DEPENDS "${META_TARGET_NAME}_tests")
@ -230,26 +217,17 @@ if (CLANG_SOURCE_BASED_COVERAGE_AVAILABLE)
find_program(LLVM_COV_BIN llvm-cov)
if (LLVM_PROFDATA_BIN AND LLVM_COV_BIN)
# merge profiling data
add_custom_command(OUTPUT "${LLVM_PROFILE_DATA_FILE}"
COMMAND cat
"${LLVM_PROFILE_RAW_LIST_FILE}"
|
xargs
"${LLVM_PROFDATA_BIN}"
merge
-o
"${LLVM_PROFILE_DATA_FILE}"
-sparse
"${LLVM_PROFILE_RAW_FILE}"
COMMENT "Generating profiling data for source-based coverage report"
DEPENDS "${LLVM_PROFILE_RAW_FILE}" "${LLVM_PROFILE_RAW_LIST_FILE}")
add_custom_command(
OUTPUT "${LLVM_PROFILE_DATA_FILE}"
COMMAND
cat "${LLVM_PROFILE_RAW_LIST_FILE}" | xargs "${LLVM_PROFDATA_BIN}" merge -o "${LLVM_PROFILE_DATA_FILE}"
-sparse "${LLVM_PROFILE_RAW_FILE}"
COMMENT "Generating profiling data for source-based coverage report"
DEPENDS "${LLVM_PROFILE_RAW_FILE}" "${LLVM_PROFILE_RAW_LIST_FILE}")
# determine llvm-cov version
execute_process(COMMAND "${LLVM_COV_BIN}" -version OUTPUT_VARIABLE LLVM_COV_VERSION)
string(REGEX MATCH
"LLVM version ([0-9](.[0-9])*)"
LLVM_COV_VERSION
"${LLVM_COV_VERSION}")
string(REGEX MATCH "LLVM version ([0-9](.[0-9])*)" LLVM_COV_VERSION "${LLVM_COV_VERSION}")
if (CMAKE_MATCH_1)
set(LLVM_COV_VERSION "${CMAKE_MATCH_1}")
else ()
@ -272,48 +250,27 @@ if (CLANG_SOURCE_BASED_COVERAGE_AVAILABLE)
# function-level)
list(APPEND LLVM_COV_ADDITIONAL_OPTIONS -show-functions)
endif ()
add_custom_command(OUTPUT "${COVERAGE_REPORT_FILE}"
COMMAND "${LLVM_COV_BIN}"
report
-format=text
-stats
-instr-profile
"${LLVM_PROFILE_DATA_FILE}"
${LLVM_COV_ADDITIONAL_OPTIONS}
${LLVM_COV_TARGET_FILE}
${HEADER_FILES}
${SRC_FILES}
${WIDGETS_HEADER_FILES}
${WIDGETS_SOURCE_FILES}
${QML_HEADER_FILES}
${QML_SOURCE_FILES}
>
"${COVERAGE_REPORT_FILE}"
COMMENT "Generating coverage report (statistics per function)"
DEPENDS "${LLVM_PROFILE_DATA_FILE}"
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_custom_command(
OUTPUT "${COVERAGE_REPORT_FILE}"
COMMAND
"${LLVM_COV_BIN}" report -format=text -stats -instr-profile "${LLVM_PROFILE_DATA_FILE}"
${LLVM_COV_ADDITIONAL_OPTIONS} ${LLVM_COV_TARGET_FILE} ${HEADER_FILES} ${SRC_FILES} ${WIDGETS_HEADER_FILES}
${WIDGETS_SOURCE_FILES} ${QML_HEADER_FILES} ${QML_SOURCE_FILES} > "${COVERAGE_REPORT_FILE}"
COMMENT "Generating coverage report (statistics per function)"
DEPENDS "${LLVM_PROFILE_DATA_FILE}"
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
# generate coverage report with statistics per file (only possible with LLVM 5 if source files are specified)
if (LLVM_COV_VERSION GREATER_EQUAL 5.0.0)
add_custom_command(OUTPUT "${COVERAGE_PER_FILE_REPORT_FILE}"
COMMAND "${LLVM_COV_BIN}"
report
-format=text
-stats
-instr-profile
"${LLVM_PROFILE_DATA_FILE}"
${LLVM_COV_TARGET_FILE}
${HEADER_FILES}
${SRC_FILES}
${WIDGETS_HEADER_FILES}
${WIDGETS_SOURCE_FILES}
${QML_HEADER_FILES}
${QML_SOURCE_FILES}
>
"${COVERAGE_PER_FILE_REPORT_FILE}"
COMMENT "Generating coverage report (statistics per file)"
DEPENDS "${LLVM_PROFILE_DATA_FILE}"
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_custom_command(
OUTPUT "${COVERAGE_PER_FILE_REPORT_FILE}"
COMMAND
"${LLVM_COV_BIN}" report -format=text -stats -instr-profile "${LLVM_PROFILE_DATA_FILE}"
${LLVM_COV_TARGET_FILE} ${HEADER_FILES} ${SRC_FILES} ${WIDGETS_HEADER_FILES} ${WIDGETS_SOURCE_FILES}
${QML_HEADER_FILES} ${QML_SOURCE_FILES} > "${COVERAGE_PER_FILE_REPORT_FILE}"
COMMENT "Generating coverage report (statistics per file)"
DEPENDS "${LLVM_PROFILE_DATA_FILE}"
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
list(APPEND COVERAGE_REPORT_FILES "${COVERAGE_PER_FILE_REPORT_FILE}")
endif ()
@ -331,42 +288,31 @@ if (CLANG_SOURCE_BASED_COVERAGE_AVAILABLE)
if (NOT EXISTS "${OVERALL_COVERAGE_AKW_SCRIPT}")
set(OVERALL_COVERAGE_AKW_SCRIPT "${CPP_UTILITIES_CONFIG_DIRS}/tests/calculateoverallcoverage.awk")
endif ()
add_custom_command(OUTPUT "${COVERAGE_OVERALL_REPORT_FILE}"
COMMAND awk
-f
"${OVERALL_COVERAGE_AKW_SCRIPT}"
"${COVERAGE_REPORT_FILE}"
>
"${COVERAGE_OVERALL_REPORT_FILE}"
COMMENT "Generating coverage report (overall figures)"
DEPENDS "${OVERALL_COVERAGE_AKW_SCRIPT}" "${COVERAGE_REPORT_FILE}")
add_custom_command(
OUTPUT "${COVERAGE_OVERALL_REPORT_FILE}"
COMMAND awk -f "${OVERALL_COVERAGE_AKW_SCRIPT}" "${COVERAGE_REPORT_FILE}" > "${COVERAGE_OVERALL_REPORT_FILE}"
COMMENT "Generating coverage report (overall figures)"
DEPENDS "${OVERALL_COVERAGE_AKW_SCRIPT}" "${COVERAGE_REPORT_FILE}")
add_custom_target("${META_TARGET_NAME}_tests_coverage_overall_summary" DEPENDS "${COVERAGE_OVERALL_REPORT_FILE}")
# generate HTML document showing covered/uncovered code
add_custom_command(OUTPUT "${COVERAGE_HTML_REPORT_FILE}"
COMMAND "${LLVM_COV_BIN}"
show
-project-title="${META_APP_NAME}"
-format=html
-instr-profile
"${LLVM_PROFILE_DATA_FILE}"
${LLVM_COV_TARGET_FILE}
${HEADER_FILES}
${SRC_FILES}
${WIDGETS_FILES}
${QML_FILES}
>
"${COVERAGE_HTML_REPORT_FILE}"
COMMENT "Generating HTML document showing covered/uncovered code"
DEPENDS "${LLVM_PROFILE_DATA_FILE}"
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_custom_command(
OUTPUT "${COVERAGE_HTML_REPORT_FILE}"
COMMAND
"${LLVM_COV_BIN}" show -project-title="${META_APP_NAME}" -format=html -instr-profile
"${LLVM_PROFILE_DATA_FILE}" ${LLVM_COV_TARGET_FILE} ${HEADER_FILES} ${SRC_FILES} ${WIDGETS_FILES}
${QML_FILES} > "${COVERAGE_HTML_REPORT_FILE}"
COMMENT "Generating HTML document showing covered/uncovered code"
DEPENDS "${LLVM_PROFILE_DATA_FILE}"
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_custom_target("${META_TARGET_NAME}_tests_coverage_html" DEPENDS "${COVERAGE_HTML_REPORT_FILE}")
# create target for all coverage docs
add_custom_target("${META_TARGET_NAME}_tests_coverage"
DEPENDS ${COVERAGE_REPORT_FILES}
DEPENDS "${COVERAGE_OVERALL_REPORT_FILE}"
DEPENDS "${COVERAGE_HTML_REPORT_FILE}")
add_custom_target(
"${META_TARGET_NAME}_tests_coverage"
DEPENDS ${COVERAGE_REPORT_FILES}
DEPENDS "${COVERAGE_OVERALL_REPORT_FILE}"
DEPENDS "${COVERAGE_HTML_REPORT_FILE}")
# add targets to global coverage target
if (NOT TARGET coverage)
@ -376,7 +322,7 @@ if (CLANG_SOURCE_BASED_COVERAGE_AVAILABLE)
else ()
message(
FATAL_ERROR "Unable to generate target for coverage report because llvm-profdata and llvm-cov are not available."
)
)
endif ()
endif ()

19
cmake/modules/WindowsResources.cmake
View File

@ -38,19 +38,12 @@ if (WINDOWS_ICON_ENABLED)
if (EXISTS "${PNG_ICON_PATH}")
set(WINDOWS_ICON_PATH "${CMAKE_CURRENT_BINARY_DIR}/resources/${META_PROJECT_NAME}.ico")
set(WINDOWS_ICON_RC_ENTRY "IDI_ICON1 ICON DISCARDABLE \"${WINDOWS_ICON_PATH}\"")
add_custom_command(OUTPUT "${WINDOWS_ICON_PATH}"
COMMAND ${FFMPEG_BIN}
-y
-i
"${PNG_ICON_PATH}"
-vf
crop=${PNG_ICON_CROP},scale=64:64
"${WINDOWS_ICON_PATH}"
DEPENDS "${PNG_ICON_PATH}")
set_source_files_properties("${WINDOWS_RC_FILE}"
PROPERTIES
OBJECT_DEPENDS
"${WINDOWS_ICON_PATH}")
add_custom_command(
OUTPUT "${WINDOWS_ICON_PATH}"
COMMAND
${FFMPEG_BIN} -y -i "${PNG_ICON_PATH}" -vf crop=${PNG_ICON_CROP},scale=64:64 "${WINDOWS_ICON_PATH}"
DEPENDS "${PNG_ICON_PATH}")
set_source_files_properties("${WINDOWS_RC_FILE}" PROPERTIES OBJECT_DEPENDS "${WINDOWS_ICON_PATH}")
message(STATUS "Generating Windows icon from \"${PNG_ICON_PATH}\" via ${FFMPEG_BIN}.")
elseif (NOT USING_DEFAULT_PNG_ICON_PATH)
message(FATAL_ERROR "The specified PNG_ICON_PATH \"${PNG_ICON_PATH}\" is invalid.")