cpp-utilities/cmake/modules/LibraryTarget.cmake

574 lines
28 KiB
CMake
Raw Normal View History

2016-11-10 23:24:09 +01:00
cmake_minimum_required(VERSION 3.3.0 FATAL_ERROR)
2019-02-06 17:30:52 +01:00
if (NOT BASIC_PROJECT_CONFIG_DONE)
2017-02-11 02:30:46 +01:00
message(FATAL_ERROR "Before including the LibraryTarget module, the BasicConfig module must be included.")
2019-02-06 17:30:52 +01:00
endif ()
if (TARGET_CONFIG_DONE)
2017-02-11 02:30:46 +01:00
message(FATAL_ERROR "Can not include LibraryTarget module when targets are already configured.")
2019-02-06 17:30:52 +01:00
endif ()
# check whether project type is set correctly
2019-02-06 17:30:52 +01:00
if (("${META_PROJECT_TYPE}" STREQUAL "plugin") OR ("${META_PROJECT_TYPE}" STREQUAL "qtplugin"))
set(META_IS_PLUGIN YES)
2019-02-06 17:30:52 +01:00
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 ()
# include packages for configure_package_config_file, write_basic_package_version_file and find_template_file
include(CMakePackageConfigHelpers)
2016-06-09 22:57:51 +02:00
include(TemplateFinder)
# set install destination for the CMake modules, config files and header files
set(INCLUDE_SUBDIR "include")
if (META_CONFIG_SUFFIX)
set(INCLUDE_SUBDIR "${INCLUDE_SUBDIR}/${META_PROJECT_NAME}${META_CONFIG_SUFFIX}")
endif ()
set(HEADER_INSTALL_DESTINATION "${CMAKE_INSTALL_PREFIX}/${INCLUDE_SUBDIR}")
set(QT_PLUGIN_INSTALL_DESTINATION "${CMAKE_INSTALL_PREFIX}/lib${SELECTED_LIB_SUFFIX}/qt/plugins")
set(CMAKE_MODULE_INSTALL_DESTINATION "${CMAKE_INSTALL_PREFIX}/${META_DATA_DIR}/cmake/modules")
set(CMAKE_CONFIG_INSTALL_DESTINATION "${CMAKE_INSTALL_PREFIX}/${META_DATA_DIR}/cmake")
# remove library prefix when building with mingw-w64 (just for consistency with qmake)
2019-02-06 17:30:52 +01:00
if (MINGW)
set(CMAKE_SHARED_LIBRARY_PREFIX "")
2019-02-06 17:30:52 +01:00
endif (MINGW)
# set the windows extension to "dll", this is required by the mingw-w64 specific WindowsResources module
2019-02-06 17:30:52 +01:00
if (MINGW)
set(WINDOWS_EXT "dll")
2019-02-06 17:30:52 +01:00
endif (MINGW)
# set compile definitions for static build
if (NOT BUILD_SHARED_LIBS)
list(APPEND META_PUBLIC_COMPILE_DEFINITIONS ${META_PROJECT_VARNAME_UPPER}_STATIC)
2019-05-04 20:57:56 +02:00
endif ()
# add global library-specific header
find_template_file("global.h" CPP_UTILITIES GLOBAL_H_TEMPLATE_FILE)
2019-02-06 17:30:52 +01:00
if ("${META_PROJECT_NAME}" STREQUAL "c++utilities")
set(GENERAL_GLOBAL_H_INCLUDE_PATH "\"./application/global.h\"")
2019-02-06 17:30:52 +01:00
else ()
set(GENERAL_GLOBAL_H_INCLUDE_PATH "<c++utilities/application/global.h>")
2019-02-06 17:30:52 +01:00
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)
2019-06-16 15:33:10 +02:00
# add header to check library version
set(VERSION_HEADER_FILE "${CMAKE_CURRENT_BINARY_DIR}/resources/version.h")
find_template_file("version.h" CPP_UTILITIES VERSION_H_TEMPLATE_FILE)
configure_file("${VERSION_H_TEMPLATE_FILE}" "${VERSION_HEADER_FILE}" NEWLINE_STYLE UNIX)
list(APPEND SOURCE_FILES "${VERSION_HEADER_FILE}")
2016-10-22 21:00:33 +02:00
# determine SOVERSION
2019-02-06 17:30:52 +01:00
if (NOT META_SOVERSION AND NOT META_IS_PLUGIN)
if (META_VERSION_EXACT_SONAME)
2016-10-22 21:00:33 +02:00
set(META_SOVERSION "${META_VERSION_MAJOR}.${META_VERSION_MINOR}.${META_VERSION_PATCH}")
2019-02-06 17:30:52 +01:00
else ()
2016-10-22 21:00:33 +02:00
set(META_SOVERSION "${META_VERSION_MAJOR}")
2019-02-06 17:30:52 +01:00
endif ()
endif ()
# define relevant files
2019-02-06 17:30:52 +01:00
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})
2019-02-06 17:30:52 +01:00
endif ()
# determine include path used when building the project itself
if (TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE)
# use existing TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE if already defined
elseif (IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include")
# use special include directory if available
set(TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include")
2019-02-06 17:30:52 +01:00
else ()
# use the project folder itself
set(TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/..")
2019-02-06 17:30:52 +01:00
endif ()
# add target for building the library
2019-02-06 17:30:52 +01:00
if (BUILD_SHARED_LIBS)
if (META_IS_PLUGIN)
set(META_LIBRARY_TYPE MODULE)
2019-02-06 17:30:52 +01:00
else ()
set(META_LIBRARY_TYPE SHARED)
2019-02-06 17:30:52 +01:00
endif ()
2019-05-04 20:57:56 +02:00
else ()
set(META_LIBRARY_TYPE STATIC)
2019-05-04 20:57:56 +02:00
endif ()
# add library to be created, set libs to link against, set version and C++ standard
if (META_HEADER_ONLY_LIB)
2019-04-22 22:19:08 +02:00
add_library(${META_TARGET_NAME} INTERFACE)
target_link_libraries(${META_TARGET_NAME}
INTERFACE ${META_ADDITIONAL_LINK_FLAGS} "${PUBLIC_LIBRARIES}" "${PRIVATE_LIBRARIES}")
2019-05-04 20:57:56 +02:00
target_include_directories(${META_TARGET_NAME}
INTERFACE $<BUILD_INTERFACE:${TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE}>
$<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_INCLUDE_DIRS})
2019-04-22 22:19:08 +02:00
target_compile_definitions(${META_TARGET_NAME}
INTERFACE
"${META_PUBLIC_COMPILE_DEFINITIONS}"
"${META_PRIVATE_COMPILE_DEFINITIONS}")
2019-05-04 20:57:56 +02:00
target_compile_options(${META_TARGET_NAME} INTERFACE "${META_PUBLIC_COMPILE_OPTIONS}" "${META_PRIVATE_COMPILE_OPTIONS}")
else ()
2019-04-22 22:19:08 +02:00
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}")
2019-04-22 22:19:08 +02:00
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}")
2019-04-22 22:19:08 +02:00
target_compile_definitions(${META_TARGET_NAME}
PUBLIC
"${META_PUBLIC_COMPILE_DEFINITIONS}"
PRIVATE
"${META_PRIVATE_COMPILE_DEFINITIONS}")
2019-04-22 22:19:08 +02:00
target_compile_options(${META_TARGET_NAME}
PUBLIC "${META_PUBLIC_LIB_COMPILE_OPTIONS}"
PRIVATE "${META_PRIVATE_LIB_COMPILE_OPTIONS}")
2019-04-22 22:19:08 +02:00
set_target_properties(${META_TARGET_NAME}
PROPERTIES VERSION
2019-05-07 16:49:19 +02:00
"${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 ()
endif ()
# populate META_PUBLIC_LIB_DEPENDS
foreach (DEPENDENCY ${PUBLIC_LIBRARIES})
if (NOT "${DEPENDENCY}" IN_LIST META_PUBLIC_LIB_DEPENDS)
list(APPEND META_PUBLIC_LIB_DEPENDS ${DEPENDENCY})
endif ()
endforeach ()
# populate META_PRIVATE_LIB_DEPENDS (only required when building static libraries)
if (NOT BUILD_SHARED_LIBS)
foreach (DEPENDENCY ${PRIVATE_LIBRARIES})
if (NOT "${DEPENDENCY}" IN_LIST META_PUBLIC_LIB_DEPENDS AND NOT "${DEPENDENCY}" IN_LIST META_PRIVATE_LIB_DEPENDS)
list(APPEND META_PRIVATE_LIB_DEPENDS ${DEPENDENCY})
2019-02-06 17:30:52 +01:00
endif ()
endforeach ()
2019-05-04 20:57:56 +02:00
endif ()
# Qt Creator does not show INTERFACE_SOURCES in project tree, so create a custom target as workaround
2019-02-06 17:30:52 +01:00
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})
2019-04-22 22:19:08 +02:00
target_include_directories(${META_TARGET_NAME}_interface_sources_for_qtcreator
2019-02-06 17:30:52 +01:00
INTERFACE $<BUILD_INTERFACE:${TARGET_INCLUDE_DIRECTORY_BUILD_INTERFACE}>
$<INSTALL_INTERFACE:${HEADER_INSTALL_DESTINATION}> ${PUBLIC_INCLUDE_DIRS})
2019-04-22 22:19:08 +02:00
target_compile_definitions(${META_TARGET_NAME}_interface_sources_for_qtcreator
2019-02-06 17:30:52 +01:00
INTERFACE
"${META_PUBLIC_LIB_COMPILE_DEFINITIONS}"
"${META_PRIVATE_LIB_COMPILE_DEFINITIONS}")
2019-05-04 20:57:56 +02:00
target_compile_options(${META_TARGET_NAME}_interface_sources_for_qtcreator
INTERFACE "${META_PUBLIC_LIB_COMPILE_OPTIONS}" "${META_PRIVATE_LIB_COMPILE_OPTIONS}")
2019-04-22 22:19:08 +02:00
set_target_properties(${META_TARGET_NAME}_interface_sources_for_qtcreator
2019-02-06 17:30:52 +01:00
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 ()
2019-05-30 14:04:04 +02:00
# 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
2019-05-30 14:04:04 +02:00
"${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 ()
# generate CMake code to configure CMake-target to pkg-config module mapping
2019-05-15 15:52:29 +02:00
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})
2019-05-15 15:52:29 +02:00
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 ()
2016-08-14 16:49:40 +02:00
# create the CMake package config file from template
if (INTERFACE_REQUIRED_PACKAGES)
list(REMOVE_ITEM INTERFACE_REQUIRED_PACKAGES "")
list(REMOVE_DUPLICATES INTERFACE_REQUIRED_PACKAGES)
endif ()
if (INTERFACE_REQUIRED_PKG_CONFIG_MODULES)
list(REMOVE_ITEM INTERFACE_REQUIRED_PKG_CONFIG_MODULES "")
list(REMOVE_DUPLICATES INTERFACE_REQUIRED_PKG_CONFIG_MODULES)
endif ()
set(CONFIG_TARGETS "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}${META_CONFIG_SUFFIX}Config.cmake")
if (META_CONFIG_SUFFIX)
list(APPEND CONFIG_TARGETS "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME}Config.cmake")
endif ()
2018-02-16 23:56:29 +01:00
find_template_file("Config.cmake" CPP_UTILITIES CONFIG_TEMPLATE_FILE)
foreach (CONFIG_TARGET ${CONFIG_TARGETS})
configure_package_config_file("${CONFIG_TEMPLATE_FILE}"
2019-05-04 20:57:56 +02:00
"${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
2019-02-06 17:30:52 +01:00
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)
if (UNSET)
unset(${OUTPUT_VAR_PKGS})
unset(${OUTPUT_VAR_LIBS})
endif ()
2019-02-06 17:30:52 +01:00
foreach (DEPENDENCY ${${DEPENDS}})
if ("${DEPENDENCY}" STREQUAL "general")
2016-11-10 23:24:09 +01:00
continue()
2019-02-06 17:30:52 +01:00
endif ()
# handle use of generator expressions (use BUILD_INTERFACE; ignore INSTALL_INTERFACE)
if ("${DEPENDENCY}" MATCHES "\\\$\\<BUILD_INTERFACE:(.*)\\>")
set(DEPENDENCY "${CMAKE_MATCH_1}")
elseif ("${DEPENDENCY}" MATCHES "\\\$\\<INSTALL_INTERFACE:(.*)\\>")
continue()
endif ()
# find the name of the pkg-config package for the depencency
2019-02-06 17:30:52 +01:00
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}})
set(${OUTPUT_VAR_PKGS} "${${OUTPUT_VAR_PKGS}} ${PKG_CONFIG_MODULE}")
endforeach ()
elseif (TARGET "${DEPENDENCY}")
# find the raw-library flags for the dependency
# add interface link libraries of the target
get_target_property("${DEPENDENCY_VARNAME}_INTERFACE_LINK_LIBRARIES" "${DEPENDENCY}" "INTERFACE_LINK_LIBRARIES")
set(${DEPENDENCY_VARNAME}_INTERFACE_LINK_LIBRARIES_EXISTING FALSE)
set(${DEPENDENCY_VARNAME}_INTERFACE_LINK_LIBRARIES_TARGETS)
foreach (LIBRARY ${${DEPENDENCY_VARNAME}_INTERFACE_LINK_LIBRARIES})
if (TARGET ${LIBRARY})
list(APPEND ${DEPENDENCY_VARNAME}_INTERFACE_LINK_LIBRARIES_TARGETS ${LIBRARY})
set(${DEPENDENCY_VARNAME}_INTERFACE_LINK_LIBRARIES_EXISTING TRUE)
elseif (EXISTS ${LIBRARY})
set(${OUTPUT_VAR_LIBS} "${${OUTPUT_VAR_LIBS}} ${LIBRARY}")
set(${DEPENDENCY_VARNAME}_INTERFACE_LINK_LIBRARIES_EXISTING TRUE)
endif ()
endforeach ()
compute_dependencies_for_package_config("${DEPENDENCY_VARNAME}_INTERFACE_LINK_LIBRARIES_TARGETS" "${OUTPUT_VAR_PKGS}" "${OUTPUT_VAR_LIBS}" NO)
if (${DEPENDENCY_VARNAME}_INTERFACE_LINK_LIBRARIES_EXISTING)
continue()
2019-05-04 20:57:56 +02:00
endif ()
# add library location of the target
set(HAS_LIBRARY_LOCATION NO)
if (DEPENDENCY IN_LIST BUNDLED_TARGETS)
# bundled targets are installed at the same location and using the same flags as the actual library so adding
# the library name itself is sufficient
set(${OUTPUT_VAR_LIBS} "${${OUTPUT_VAR_LIBS}} -l${DEPENDENCY}")
set(HAS_LIBRARY_LOCATION YES)
endif ()
if (NOT HAS_LIBRARY_LOCATION AND META_CURRENT_CONFIGURATION)
2019-05-04 20:57:56 +02:00
get_target_property("${DEPENDENCY_VARNAME}_IMPORTED_LOCATION_${META_CURRENT_CONFIGURATION}" "${DEPENDENCY}"
"IMPORTED_LOCATION_${META_CURRENT_CONFIGURATION}")
# check whether path points to the build directory; libraries must not be referenced using their build location
string(FIND "${${DEPENDENCY_VARNAME}_IMPORTED_LOCATION_${META_CURRENT_CONFIGURATION}}" "${CMAKE_CURRENT_BINARY_DIR}" BINARY_DIR_INDEX)
if (NOT BINARY_DIR_INDEX EQUAL 0 AND EXISTS "${${DEPENDENCY_VARNAME}_IMPORTED_LOCATION_${META_CURRENT_CONFIGURATION}}")
2019-05-04 20:57:56 +02:00
set(${OUTPUT_VAR_LIBS}
"${${OUTPUT_VAR_LIBS}} ${${DEPENDENCY_VARNAME}_IMPORTED_LOCATION_${META_CURRENT_CONFIGURATION}}")
set(HAS_LIBRARY_LOCATION YES)
2019-05-04 20:57:56 +02:00
endif ()
endif ()
if (NOT HAS_LIBRARY_LOCATION)
get_target_property("${DEPENDENCY_VARNAME}_IMPORTED_LOCATION" "${DEPENDENCY}" IMPORTED_LOCATION)
# check whether path points to the build directory; libraries must not be referenced using their build location
string(FIND "${${DEPENDENCY_VARNAME}_IMPORTED_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}" BINARY_DIR_INDEX)
if (NOT BINARY_DIR_INDEX EQUAL 0 AND EXISTS "${${DEPENDENCY_VARNAME}_IMPORTED_LOCATION}")
set(${OUTPUT_VAR_LIBS} "${${OUTPUT_VAR_LIBS}} ${${DEPENDENCY_VARNAME}_IMPORTED_LOCATION}")
set(HAS_LIBRARY_LOCATION YES)
endif ()
2019-05-04 20:57:56 +02:00
endif ()
2019-06-16 16:54:26 +02:00
# assume the target is a 3rd party library built within the current project as a bundled dependency -> the target
# is supposed to be installed in either a standard search directory or the same directory as this library so a
# simple -l flag should be sufficient
if (NOT HAS_LIBRARY_LOCATION)
set(${OUTPUT_VAR_LIBS} "${${OUTPUT_VAR_LIBS}} -l${DEPENDENCY}")
endif ()
# add libraries required by the imported target
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)
2019-02-06 17:30:52 +01:00
else ()
# add raw dependency
2016-11-10 23:24:09 +01:00
set(${OUTPUT_VAR_LIBS} "${${OUTPUT_VAR_LIBS}} ${DEPENDENCY}")
2019-02-06 17:30:52 +01:00
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)
if (NOT META_HEADER_ONLY_LIB)
2019-05-04 20:57:56 +02:00
set(META_PUBLIC_LIB_DEPENDS_FOR_PC " -l${META_TARGET_NAME}${META_PUBLIC_LIB_DEPENDS_FOR_PC}")
2019-02-06 17:30:52 +01:00
endif ()
if (META_PUBLIC_LIB_DEPENDS_FOR_PC)
set(META_PUBLIC_LIB_DEPENDS_FOR_PC " -L\${libdir}${META_PUBLIC_LIB_DEPENDS_FOR_PC}")
2019-02-06 17:30:52 +01:00
endif ()
# compute other values for pkg-config
set(META_PROJECT_NAME_FOR_PC "${META_PROJECT_NAME}${META_CONFIG_SUFFIX}")
foreach (COMPILE_DEFINITION ${META_PUBLIC_LIB_COMPILE_DEFINITIONS})
set(META_COMPILE_DEFINITIONS_FOR_PC "${META_COMPILE_DEFINITIONS_FOR_PC} -D${COMPILE_DEFINITION}")
endforeach ()
# create pkg-config file from template using previously computed values
find_template_file("template.pc" CPP_UTILITIES PKGCONFIG_TEMPLATE_FILE)
configure_file("${PKGCONFIG_TEMPLATE_FILE}" "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME_FOR_PC}.pc" @ONLY)
set(PC_FILES "${CMAKE_CURRENT_BINARY_DIR}/${META_PROJECT_NAME_FOR_PC}.pc")
2016-08-14 16:49:40 +02:00
# add install targets
2019-02-06 17:30:52 +01:00
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)
2019-02-06 17:30:52 +01:00
if (NOT TARGET install-cmake-config)
add_custom_target(install-cmake-config
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_COMPONENT=cmake-config -P
2019-02-06 17:30:52 +01:00
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
2016-08-14 16:49:40 +02:00
# add install target for pkg-config file
2019-02-06 17:30:52 +01:00
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
2019-02-06 17:30:52 +01:00
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
2016-11-10 23:40:34 +01:00
# add install target for libs
2019-02-06 17:30:52 +01:00
if (NOT TARGET install-binary)
add_custom_target(install-binary
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_COMPONENT=binary -P
2019-02-06 17:30:52 +01:00
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
# add install target for stripped libs
2019-02-06 17:30:52 +01:00
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
2019-02-06 17:30:52 +01:00
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
2016-11-10 23:40:34 +01:00
# determine install dir for Qt plugins
2019-02-06 17:30:52 +01:00
if ("${META_PROJECT_TYPE}" STREQUAL "qtplugin")
if (QT_PLUGIN_DIR)
2019-06-16 16:54:26 +02:00
set(LIBRARY_DESTINATION "${QT_PLUGIN_DIR}")
2019-02-06 17:30:52 +01:00
else ()
if (COMMAND query_qmake_variable)
query_qmake_variable(QT_INSTALL_PLUGINS)
2019-05-04 20:57:56 +02:00
endif ()
if (QT_INSTALL_PLUGINS)
string(FIND "${QT_INSTALL_PLUGINS}" "${CMAKE_INSTALL_PREFIX}"
CMAKE_INSTALL_PREFIX_INDEX_IN_QT_INSTALL_PLUGINS)
if ("${CMAKE_INSTALL_PREFIX_INDEX_IN_QT_INSTALL_PLUGINS}" EQUAL 0)
set(LIBRARY_DESTINATION ${QT_INSTALL_PLUGINS})
else ()
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)
set(LIBRARY_DESTINATION lib${SELECTED_LIB_SUFFIX}/qt/plugins)
2019-05-04 20:57:56 +02:00
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."
2019-05-04 20:57:56 +02:00
)
endif ()
2019-02-06 17:30:52 +01:00
endif ()
if (META_PLUGIN_CATEGORY)
set(LIBRARY_DESTINATION ${LIBRARY_DESTINATION}/${META_PLUGIN_CATEGORY})
2019-02-06 17:30:52 +01:00
endif ()
else ()
set(LIBRARY_DESTINATION lib${SELECTED_LIB_SUFFIX})
2019-02-06 17:30:52 +01:00
endif ()
# add install targets and export targets
set(TARGETS_TO_EXPORT "${META_TARGET_NAME}")
foreach (BUNDLED_TARGET ${BUNDLED_TARGETS})
2019-06-16 16:54:26 +02:00
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)
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)
# add install target for header files
2019-02-06 17:30:52 +01:00
if (NOT META_IS_PLUGIN)
foreach (HEADER_FILE ${HEADER_FILES} ${ADDITIONAL_HEADER_FILES})
get_filename_component(HEADER_DIR "${HEADER_FILE}" DIRECTORY)
2019-05-04 20:57:56 +02:00
install(FILES "${HEADER_FILE}"
DESTINATION "${INCLUDE_SUBDIR}/${META_PROJECT_NAME}/${HEADER_DIR}"
COMPONENT header)
2019-02-06 17:30:52 +01:00
endforeach ()
2019-06-16 16:54:26 +02:00
install(FILES "${VERSION_HEADER_FILE}" DESTINATION "${INCLUDE_SUBDIR}/${META_PROJECT_NAME}" COMPONENT header)
2019-02-06 17:30:52 +01:00
if (NOT TARGET install-header)
add_custom_target(install-header
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_COMPONENT=header -P
2019-02-06 17:30:52 +01:00
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
endif ()
# add install target for CMake modules
2019-02-06 17:30:52 +01:00
foreach (CMAKE_MODULE_FILE ${CMAKE_MODULE_FILES})
get_filename_component(CMAKE_MODULE_DIR ${CMAKE_MODULE_FILE} DIRECTORY)
2019-05-04 20:57:56 +02:00
install(FILES ${CMAKE_MODULE_FILE} DESTINATION ${META_DATA_DIR}/${CMAKE_MODULE_DIR} COMPONENT cmake-modules)
2019-02-06 17:30:52 +01:00
endforeach ()
if (NOT TARGET install-cmake-modules)
add_custom_target(install-cmake-modules
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_COMPONENT=cmake-modules -P
2019-02-06 17:30:52 +01:00
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
# add install target for CMake templates
2019-02-06 17:30:52 +01:00
foreach (CMAKE_TEMPLATE_FILE ${CMAKE_TEMPLATE_FILES})
get_filename_component(CMAKE_TEMPLATE_DIR ${CMAKE_TEMPLATE_FILE} DIRECTORY)
2019-05-04 20:57:56 +02:00
install(FILES ${CMAKE_TEMPLATE_FILE} DESTINATION ${META_DATA_DIR}/${CMAKE_TEMPLATE_DIR} COMPONENT cmake-templates)
2019-02-06 17:30:52 +01:00
endforeach ()
if (NOT TARGET install-cmake-templates)
add_custom_target(install-cmake-templates
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_COMPONENT=cmake-templates -P
2019-02-06 17:30:52 +01:00
"${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif ()
# add install target for all the cmake stuff
2019-02-06 17:30:52 +01:00
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)
2019-02-06 17:30:52 +01:00
endif ()
# add targets to ease creating mingw-w64 packages under Arch Linux
2019-02-06 17:30:52 +01:00
if (MINGW)
2019-06-10 22:43:42 +02:00
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 ()
if (ENABLE_TARGETS_FOR_MINGW64_CROSS_PACKAGING)
2019-02-06 17:30:52 +01:00
if (NOT TARGET install-mingw-w64)
add_custom_target(install-mingw-w64)
2019-02-06 17:30:52 +01:00
endif ()
add_dependencies(install-mingw-w64
install-binary
install-header
install-cmake-stuff
install-pkg-config)
2019-02-06 17:30:52 +01:00
if (NOT TARGET install-mingw-w64-strip)
add_custom_target(install-mingw-w64-strip)
2019-02-06 17:30:52 +01:00
endif ()
add_dependencies(install-mingw-w64-strip
install-binary-strip
install-header
install-cmake-stuff
install-pkg-config)
2019-02-06 17:30:52 +01:00
if (LOCALIZATION_TARGET)
add_dependencies(install-mingw-w64 ${LOCALIZATION_TARGET})
add_dependencies(install-mingw-w64-strip ${LOCALIZATION_TARGET})
2019-02-06 17:30:52 +01:00
endif ()
find_program(STRIP_BINARY_PATH strip ONLY_CMAKE_FIND_ROOT_PATH)
2019-02-06 17:30:52 +01:00
if (NOT STRIP_BINARY_PATH)
message(FATAL_ERROR "Unable to find strip. Please set ${STRIP_BINARY_PATH}.")
2019-02-06 17:30:52 +01:00
else ()
message(STATUS "Using strip binary under \"${STRIP_BINARY_PATH}\".")
2019-02-06 17:30:52 +01:00
endif ()
if (BUILD_SHARED_LIBS AND NOT META_HEADER_ONLY_LIB)
add_custom_target(
2019-04-22 22:19:08 +02:00
install-${META_TARGET_NAME}-mingw-w64-importlib-strip
COMMAND "${STRIP_BINARY_PATH}"
-g
2019-05-04 20:57:56 +02:00
"\$\{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)
2019-02-06 17:30:52 +01:00
endif ()
if (BUILD_STATIC_LIBS AND NOT META_HEADER_ONLY_LIB)
2019-05-04 20:57:56 +02:00
add_custom_target(install-${META_TARGET_NAME}-mingw-w64-staticlib-strip
COMMAND "${STRIP_BINARY_PATH}"
-g
2019-05-04 20:57:56 +02:00
"\$\{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)
2019-02-06 17:30:52 +01:00
endif ()
endif ()
endif ()
2017-02-11 02:30:46 +01:00
set(TARGET_CONFIG_DONE YES)