cpp-utilities/cmake/modules/LibraryTarget.cmake

419 lines
20 KiB
CMake

cmake_minimum_required(VERSION 3.3.0 FATAL_ERROR)
if (NOT BASIC_PROJECT_CONFIG_DONE)
message(FATAL_ERROR "Before including the LibraryTarget module, the BasicConfig module must be included.")
endif ()
if (TARGET_CONFIG_DONE)
message(FATAL_ERROR "Can not include LibraryTarget module when targets are already configured.")
endif ()
# check whether project type is set correctly
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)
message(
FATAL_ERROR
"The LibraryTarget CMake module is intended to be used for building library projects only (and not for applications)."
)
endif ()
# includes for configure_package_config_file, write_basic_package_version_file and find_template_file
include(CMakePackageConfigHelpers)
include(TemplateFinder)
# set install destination for the CMake modules, config files and header files
set(HEADER_INSTALL_DESTINATION "${CMAKE_INSTALL_PREFIX}/include")
set(BIN_INSTALL_DESTINATION "${CMAKE_INSTALL_PREFIX}/bin")
set(LIB_INSTALL_DESTINATION "${CMAKE_INSTALL_PREFIX}/lib${SELECTED_LIB_SUFFIX}")
set(QT_PLUGIN_INSTALL_DESTINATION "${CMAKE_INSTALL_PREFIX}/lib${SELECTED_LIB_SUFFIX}/qt/plugins")
set(CMAKE_MODULE_INSTALL_DESTINATION "${CMAKE_INSTALL_PREFIX}/share/${META_PROJECT_NAME}/cmake/modules")
set(CMAKE_CONFIG_INSTALL_DESTINATION "${CMAKE_INSTALL_PREFIX}/share/${META_PROJECT_NAME}/cmake")
# remove library prefix when building with mingw-w64 (just for consistency with qmake)
if (MINGW)
set(CMAKE_SHARED_LIBRARY_PREFIX "")
endif (MINGW)
# set the windows extension to "dll", this is required by the mingw-w64 specific WindowsResources module
if (MINGW)
set(WINDOWS_EXT "dll")
endif (MINGW)
# set compile definitions for static build
if (NOT BUILD_SHARED_LIBS)
list(APPEND META_PUBLIC_COMPILE_DEFINITIONS ${META_PROJECT_VARNAME_UPPER}_STATIC)
endif()
# add global library-specific header
find_template_file("global.h" CPP_UTILITIES GLOBAL_H_TEMPLATE_FILE)
if ("${META_PROJECT_NAME}" STREQUAL "c++utilities")
set(GENERAL_GLOBAL_H_INCLUDE_PATH "\"./application/global.h\"")
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
)
list(APPEND HEADER_FILES global.h)
# determine SOVERSION
if (NOT META_SOVERSION AND NOT META_IS_PLUGIN)
if (META_VERSION_EXACT_SONAME)
set(META_SOVERSION "${META_VERSION_MAJOR}.${META_VERSION_MINOR}.${META_VERSION_PATCH}")
else ()
set(META_SOVERSION "${META_VERSION_MAJOR}")
endif ()
endif ()
# define relevant files
set(ALL_FILES
${HEADER_FILES}
${SRC_FILES}
${GENERATED_DBUS_FILES}
${WIDGETS_FILES}
${QML_FILES}
${RES_FILES}
${WINDOWS_ICON_PATH})
if (NOT BUILTIN_TRANSLATIONS)
list(APPEND ALL_FILES ${QM_FILES})
endif ()
# determine include path used when building the project itself
if (IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include")
# use special include directory if available
set(TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include")
else ()
# use the project folder itself
set(TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/..")
endif ()
# add target for building the library
if (BUILD_SHARED_LIBS)
if (META_IS_PLUGIN)
set(META_LIBRARY_TYPE MODULE)
else ()
set(META_LIBRARY_TYPE SHARED)
endif ()
else()
set(META_LIBRARY_TYPE STATIC)
endif()
# 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}"
"${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
"${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_VESION_MAJOR}.${META_VERSION_MINOR}.${META_VERSION_PATCH}"
SOVERSION
"${META_SOVERSION}"
CXX_STANDARD
"${META_CXX_STANDARD}"
LINK_SEARCH_START_STATIC
${STATIC_LINKAGE}
LINK_SEARCH_END_STATIC
${STATIC_LINKAGE}
AUTOGEN_TARGET_DEPENDS
"${AUTOGEN_DEPS}")
endif ()
if (NOT BUILD_SHARED_LIBS)
foreach (DEPENDENCY ${PUBLIC_LIBRARIES} ${PRIVATE_LIBRARIES})
if (NOT "${DEPENDENCY}" IN_LIST META_PUBLIC_LIB_DEPENDS)
list(APPEND META_PRIVATE_LIB_DEPENDS ${DEPENDENCY})
endif ()
endforeach ()
endif()
# Qt Creator does not show INTERFACE_SOURCES in project tree, so create a custom target as workaround
if (META_HEADER_ONLY_LIB)
file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/headeronly.cpp"
"// 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_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}")
endif ()
# create the CMake package config file from template
find_template_file("Config.cmake" CPP_UTILITIES CONFIG_TEMPLATE_FILE)
configure_package_config_file("${CONFIG_TEMPLATE_FILE}"
"${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}Config.cmake"
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)
list(APPEND CMAKE_CONFIG_FILES "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}Config.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}ConfigVersion.cmake")
# write the CMake version config file
write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}ConfigVersion.cmake
VERSION "${META_VERSION_MAJOR}.${META_VERSION_MINOR}.${META_VERSION_PATCH}"
COMPATIBILITY SameMajorVersion)
# create pkg-config file from template
find_template_file("template.pc" CPP_UTILITIES PKGCONFIG_TEMPLATE_FILE)
macro (depends_for_pc DEPENDS OUTPUT_VAR_PKGS OUTPUT_VAR_LIBS)
unset(${OUTPUT_VAR_PKGS})
unset(${OUTPUT_VAR_LIBS})
foreach (DEPENDENCY ${${DEPENDS}})
if ("${DEPENDENCY}" STREQUAL "general")
continue()
endif ()
string(REPLACE "::"
"_"
DEPENDENCY_VARNAME
"${DEPENDENCY}")
if (PKG_CONFIG_${DEPENDENCY_VARNAME})
# add pkg-config name of the dependency
set(${OUTPUT_VAR_PKGS} "${${OUTPUT_VAR_PKGS}} ${PKG_CONFIG_${DEPENDENCY_VARNAME}}")
elseif (TARGET "${DEPENDENCY}")
# add library location of the target
if (META_CURRENT_CONFIGURATION)
get_target_property("${DEPENDENCY_VARNAME}_IMPORTED_LOCATION_${META_CURRENT_CONFIGURATION}" "${DEPENDENCY}" "IMPORTED_LOCATION_${META_CURRENT_CONFIGURATION}")
if (EXISTS "${${DEPENDENCY_VARNAME}_IMPORTED_LOCATION_${META_CURRENT_CONFIGURATION}}")
set(${OUTPUT_VAR_LIBS} "${${OUTPUT_VAR_LIBS}} ${${DEPENDENCY_VARNAME}_IMPORTED_LOCATION_${META_CURRENT_CONFIGURATION}}")
endif()
endif()
get_target_property("${DEPENDENCY_VARNAME}_IMPORTED_LOCATION" "${DEPENDENCY}" IMPORTED_LOCATION)
if (EXISTS "${${DEPENDENCY_VARNAME}_IMPORTED_LOCATION}")
set(${OUTPUT_VAR_LIBS} "${${OUTPUT_VAR_LIBS}} ${${DEPENDENCY_VARNAME}_IMPORTED_LOCATION}")
endif()
else ()
# add raw dependency
set(${OUTPUT_VAR_LIBS} "${${OUTPUT_VAR_LIBS}} ${DEPENDENCY}")
endif ()
endforeach ()
endmacro ()
unset(PC_FILES)
set(META_PROJECT_NAME_FOR_PC "${META_TARGET_NAME}")
depends_for_pc(META_PUBLIC_LIB_DEPENDS META_PUBLIC_PC_PKGS META_PUBLIC_LIB_DEPENDS_FOR_PC)
depends_for_pc(META_PRIVATE_LIB_DEPENDS META_PRIVATE_PC_PKGS META_PRIVATE_LIB_DEPENDS_FOR_PC)
foreach (COMPILE_DEFINITION ${META_PUBLIC_LIB_COMPILE_DEFINITIONS})
set(META_COMPILE_DEFINITIONS_FOR_PC "${META_COMPILE_DEFINITIONS_FOR_PC} -D${COMPILE_DEFINITION}")
endforeach ()
if (NOT META_HEADER_ONLY_LIB)
set(META_PUBLIC_LIB_DEPENDS_FOR_PC
" -l${META_TARGET_NAME}${META_PUBLIC_LIB_DEPENDS_FOR_PC}")
endif ()
if (META_PUBLIC_LIB_DEPENDS_FOR_PC)
set(META_PUBLIC_LIB_DEPENDS_FOR_PC " -L\${libdir}${META_PUBLIC_LIB_DEPENDS_FOR_PC}")
endif ()
configure_file("${PKGCONFIG_TEMPLATE_FILE}" "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME_FOR_PC}.pc" @ONLY)
list(APPEND PC_FILES "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME_FOR_PC}.pc")
if (NOT META_NO_INSTALL_TARGETS AND ENABLE_INSTALL_TARGETS)
# add install target for the CMake config files
install(FILES ${CMAKE_CONFIG_FILES} DESTINATION "share/${META_PROJECT_NAME}/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")
endif ()
# add install target for pkg-config file
if (PC_FILES)
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")
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")
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")
endif ()
# determine install dir for Qt plugins
if ("${META_PROJECT_TYPE}" STREQUAL "qtplugin")
if (QT_PLUGIN_DIR)
set(LIBRARY_DESTINATION ${QT_PLUGIN_DIR})
else ()
if (COMMAND query_qmake_variable)
query_qmake_variable(QT_INSTALL_PLUGINS)
endif()
if (QT_INSTALL_PLUGINS)
set(LIBRARY_DESTINATION ${QT_INSTALL_PLUGINS})
else()
set(LIBRARY_DESTINATION lib${SELECTED_LIB_SUFFIX}/qt/plugins)
message(WARNING "Unable to detect appropriate install directory for Qt plugins (assuming \"${LIBRARY_DESTINATION}\").")
endif()
endif ()
if (META_PLUGIN_CATEGORY)
set(LIBRARY_DESTINATION ${LIBRARY_DESTINATION}/${META_PLUGIN_CATEGORY})
endif ()
else ()
set(LIBRARY_DESTINATION lib${SELECTED_LIB_SUFFIX})
endif ()
# add install targets and export targets
install(TARGETS ${META_TARGET_NAME}
EXPORT ${META_PROJECT_NAME}Targets
RUNTIME DESTINATION bin COMPONENT binary
LIBRARY DESTINATION ${LIBRARY_DESTINATION} COMPONENT binary
ARCHIVE DESTINATION ${LIBRARY_DESTINATION} COMPONENT binary)
add_dependencies(install-binary ${META_TARGET_NAME})
add_dependencies(install-binary-strip ${META_TARGET_NAME})
install(EXPORT ${META_PROJECT_NAME}Targets
DESTINATION "share/${META_PROJECT_NAME}/cmake"
EXPORT_LINK_INTERFACE_LIBRARIES
COMPONENT cmake-config)
# add install target for header files
if (NOT META_IS_PLUGIN)
foreach (HEADER_FILE ${HEADER_FILES} ${ADDITIONAL_HEADER_FILES})
get_filename_component(HEADER_DIR "${HEADER_FILE}" DIRECTORY)
install(FILES "${HEADER_FILE}" DESTINATION "include/${META_PROJECT_NAME}/${HEADER_DIR}" COMPONENT header)
endforeach ()
if (NOT TARGET install-header)
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 share/${META_PROJECT_NAME}/${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")
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 share/${META_PROJECT_NAME}/${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")
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)
endif ()
# add mingw-w64 specific install targets
if (MINGW)
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)
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)
if (LOCALIZATION_TARGET)
add_dependencies(install-mingw-w64 ${LOCALIZATION_TARGET})
add_dependencies(install-mingw-w64-strip ${LOCALIZATION_TARGET})
endif ()
find_program(STRIP_BINARY_PATH strip ONLY_CMAKE_FIND_ROOT_PATH)
if (NOT STRIP_BINARY_PATH)
message(FATAL_ERROR "Unable to find strip. Please set ${STRIP_BINARY_PATH}.")
else ()
message(STATUS "Using strip binary under \"${STRIP_BINARY_PATH}\".")
endif ()
if (BUILD_SHARED_LIBS AND NOT META_HEADER_ONLY_LIB)
add_custom_target(
install-${META_TARGET_NAME}-mingw-w64-importlib-strip
COMMAND
"${STRIP_BINARY_PATH}" -g
"\$\{DESTDIR\}\$\{DESTDIR:+/\}${CMAKE_INSTALL_PREFIX}/lib/lib${META_TARGET_NAME}.dll.a"
)
add_dependencies(install-${META_TARGET_NAME}-mingw-w64-importlib-strip
install-binary-strip)
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_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 ()
endif ()
endif ()
set(TARGET_CONFIG_DONE YES)