From b104bedea171825db06cc257179bb3e05915a159 Mon Sep 17 00:00:00 2001 From: Alexandru Croitor Date: Wed, 28 Apr 2021 15:25:18 +0200 Subject: CMake: Refactor handling of static plugins Extract common static plugin handling functionality into a separate QtPublicPluginHelpers.cmake file which is loaded by the Qt6 package. Split the code into smaller functions that will be re-used by each templated QtPlugins.cmake.in file, rather than copy pasting the same code into each QtFooPlugins.cmake file. As a drive-by, handle QtFeatures.cmake and QtFeaturesCommon.cmake as public helper files just like QtPublicPluginHelpers.cmake. This makes it clearer that the functions are available outside the internal Qt build and also provides a way for not dumping new helper functions into Qt6CoreMacros.cmake. Task-number: QTBUG-92933 Change-Id: Id816ef009b4fac1cd317d3ef23f21b3530028067 Reviewed-by: Joerg Bornemann --- cmake/QtBaseGlobalTargets.cmake | 26 ++++++- cmake/QtBuild.cmake | 5 ++ cmake/QtConfig.cmake.in | 4 + cmake/QtModuleConfig.cmake.in | 2 - cmake/QtPlugins.cmake.in | 126 ++++-------------------------- cmake/QtPublicPluginHelpers.cmake | 156 ++++++++++++++++++++++++++++++++++++++ 6 files changed, 203 insertions(+), 116 deletions(-) create mode 100644 cmake/QtPublicPluginHelpers.cmake diff --git a/cmake/QtBaseGlobalTargets.cmake b/cmake/QtBaseGlobalTargets.cmake index a1f81ecb90..0f5d68cd0c 100644 --- a/cmake/QtBaseGlobalTargets.cmake +++ b/cmake/QtBaseGlobalTargets.cmake @@ -159,7 +159,9 @@ qt_internal_export_modern_cmake_config_targets_file(TARGETS ${__export_targets} CONFIG_INSTALL_DIR ${__GlobalConfig_install_dir}) -## Install some QtBase specific CMake files: +# Install internal CMake files. +# The functions defined inside can not be used in public projects. +# They can only be used while building Qt itself. qt_copy_or_install(FILES cmake/ModuleDescription.json.in cmake/Qt3rdPartyLibraryConfig.cmake.in @@ -179,8 +181,6 @@ qt_copy_or_install(FILES cmake/QtDbusHelpers.cmake cmake/QtDocsHelpers.cmake cmake/QtExecutableHelpers.cmake - cmake/QtFeature.cmake - cmake/QtFeatureCommon.cmake cmake/QtFileConfigure.txt.in cmake/QtFindPackageHelpers.cmake cmake/QtFindWrapConfigExtra.cmake.in @@ -237,7 +237,25 @@ qt_copy_or_install(FILES DESTINATION "${__GlobalConfig_install_dir}" ) -file(COPY cmake/QtFeature.cmake DESTINATION "${__GlobalConfig_build_dir}") +# Install public CMake files. +# The functions defined inside can be used in both public projects and while building Qt. +# Usually we put such functions into Qt6CoreMacros.cmake, but that's getting bloated. +# These files will be included by Qt6Config.cmake. +set(__public_cmake_helpers + cmake/QtFeature.cmake + cmake/QtFeatureCommon.cmake + cmake/QtPublicPluginHelpers.cmake +) + +qt_copy_or_install(FILES ${__public_cmake_helpers} DESTINATION "${__GlobalConfig_install_dir}") + +# In prefix builds we also need to copy the files into the build config directory, so that the +# build-dir Qt6Config.cmake finds the files when building examples in-tree. +if(QT_WILL_INSTALL) + foreach(_public_cmake_helper ${__public_cmake_helpers}) + file(COPY "${_public_cmake_helper}" DESTINATION "${__GlobalConfig_build_dir}") + endforeach() +endif() # TODO: Check whether this is the right place to install these qt_copy_or_install(DIRECTORY cmake/3rdparty DESTINATION "${__GlobalConfig_install_dir}") diff --git a/cmake/QtBuild.cmake b/cmake/QtBuild.cmake index 18027848c2..20efee0d6e 100644 --- a/cmake/QtBuild.cmake +++ b/cmake/QtBuild.cmake @@ -507,6 +507,7 @@ set(__qt_internal_add_executable_multi_args option(QT_CMAKE_DEBUG_EXTEND_TARGET "Debug extend_target calls in Qt's build system" OFF) +# Internal helpers available only while building Qt itself. include(Qt3rdPartyLibraryHelpers) include(QtAppHelpers) include(QtAutogenHelpers) @@ -544,6 +545,10 @@ if(ANDROID) include(QtAndroidHelpers) endif() +# Helpers that are available in public projects and while building Qt itself. +include(QtPublicPluginHelpers) + + # TODO: This block provides support for old variables. It should be removed once # we remove all references to these variables in other Qt module repos. # Prefer to use the provided commands to retrieve the relevant things instead. diff --git a/cmake/QtConfig.cmake.in b/cmake/QtConfig.cmake.in index 451d4191a7..d762cd50ca 100644 --- a/cmake/QtConfig.cmake.in +++ b/cmake/QtConfig.cmake.in @@ -53,6 +53,10 @@ set(QT_ADDITIONAL_PACKAGES_PREFIX_PATH "" CACHE STRING "Additional directories w file(TO_CMAKE_PATH "${QT_ADDITIONAL_PACKAGES_PREFIX_PATH}" _qt_additional_packages_prefix_path) file(TO_CMAKE_PATH "$ENV{QT_ADDITIONAL_PACKAGES_PREFIX_PATH}" _qt_additional_packages_prefix_path_env) +# Public helpers available to all Qt packages. +include("${CMAKE_CURRENT_LIST_DIR}/QtFeature.cmake") +include("${CMAKE_CURRENT_LIST_DIR}/QtPublicPluginHelpers.cmake") + # Find required dependencies, if any. include(CMakeFindDependencyMacro) if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@Dependencies.cmake") diff --git a/cmake/QtModuleConfig.cmake.in b/cmake/QtModuleConfig.cmake.in index 0573256982..ee66f566fa 100644 --- a/cmake/QtModuleConfig.cmake.in +++ b/cmake/QtModuleConfig.cmake.in @@ -91,8 +91,6 @@ if (TARGET @QT_CMAKE_EXPORT_NAMESPACE@::@target@) include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") endforeach() - include(${_qt_@PROJECT_VERSION_MAJOR@_config_cmake_dir}/QtFeature.cmake) - qt_make_features_available(@QT_CMAKE_EXPORT_NAMESPACE@::@target@) if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Plugins.cmake") diff --git a/cmake/QtPlugins.cmake.in b/cmake/QtPlugins.cmake.in index 3e554a43ad..3a7b8ab30d 100644 --- a/cmake/QtPlugins.cmake.in +++ b/cmake/QtPlugins.cmake.in @@ -30,123 +30,29 @@ function(__qt_internal_add_static_plugins_once) return() endif() - set(_default_plugins_are_enabled "$>,0>>") - set(_manual_plugins_genex "$>") - set(_no_plugins_genex "$>") - - # Plugin genex marker for prl processing. - set(_is_plugin_marker_genex "$") - - # The code in here uses the properties defined in qt_import_plugins (Qt6CoreMacros.cmake) - foreach(target ${_qt_plugins}) - set(_plugin_target "@INSTALL_CMAKE_NAMESPACE@::${target}") - set(_plugin_target_versionless "Qt::${target}") - get_target_property(_classname "${_plugin_target}" QT_PLUGIN_CLASS_NAME) - if(NOT _classname) - message("Warning: plugin ${_plugin_target} has no class name, skipping.") - continue() + foreach(plugin_target ${_qt_plugins}) + __qt_internal_plugin_get_plugin_type("${plugin_target}" __has_plugin_type __plugin_type) + if(NOT __has_plugin_type) + continue() endif() - get_target_property(_plugin_type "${_plugin_target}" QT_PLUGIN_TYPE) - if(NOT _plugin_type) - message("Warning: plugin ${_plugin_target} has no type ('${_plugin_type}'), skipping.") - continue() + __qt_internal_plugin_has_class_name("${plugin_target}" __has_class_name) + if(NOT __has_class_name) + continue() endif() - list(APPEND "QT_ALL_PLUGINS_FOUND_BY_FIND_PACKAGE_${_plugin_type}" "${target}") - set("QT_ALL_PLUGINS_FOUND_BY_FIND_PACKAGE_${_plugin_type}" - "${QT_ALL_PLUGINS_FOUND_BY_FIND_PACKAGE_${_plugin_type}}" - PARENT_SCOPE - ) - - set(_plugin_is_default "$") - - # INCLUDE - set(_plugin_is_whitelisted "$") - set(_plugin_versionless_is_whitelisted - "$") - - # Note: qt_import_plugins sets the QT_PLUGINS_${_plugin_type} to "-" - # when excluding it with EXCLUDE_BY_TYPE, - # which ensures that no plug-in will be supported unless explicitly re-added afterwards. - string(CONCAT _plugin_is_not_blacklisted - "$" - ">," - "$" - ">," - # Excludes both plugins targeted by EXCLUDE_BY_TYPE and not included in - # INCLUDE_BY_TYPE. - "$>>" - ">" - ) - - # Support INCLUDE_BY_TYPE - string(CONCAT _plugin_is_in_type_whitelist - "$" - ">" - ">" - ) - string(CONCAT _plugin_versionless_is_in_type_whitelist - "$" - ">" - ">" - ) - - # Complete condition that defines whether a static plugin is linked - string(CONCAT _plugin_condition - "$" - ">" - ">>" - ) + list(APPEND "QT_ALL_PLUGINS_FOUND_BY_FIND_PACKAGE_${__plugin_type}" "${plugin_target}") - # If this condition is true, we link against the plug-in - set(_plugin_genex "$<${_plugin_condition}:${_plugin_target}>") - target_link_libraries(${_module_target} INTERFACE "${_plugin_genex}") - - set(_generated_qt_plugin_file_name - "${CMAKE_CURRENT_BINARY_DIR}/qt_@QT_MODULE@_${target}.cpp") - set(_generated_qt_plugin_file_content "#include \nQ_IMPORT_PLUGIN(${_classname})") - - # Generate a source file to import that plug-in. Be careful not to - # update the timestamp of the generated file if we are not going to - # change anything. Otherwise we will trigger CMake's autogen to re-run - # and executables will then need to at least relink. - set(need_write TRUE) - if(EXISTS ${_generated_qt_plugin_file_name}) - file(READ ${_generated_qt_plugin_file_name} old_contents) - if(old_contents STREQUAL "${_generated_qt_plugin_file_content}") - set(need_write FALSE) - endif() - endif() - if(need_write) - file(WRITE "${_generated_qt_plugin_file_name}" - "${_generated_qt_plugin_file_content}") - endif() - - target_sources(${_module_target} INTERFACE - "$<${_plugin_condition}:${_generated_qt_plugin_file_name}>") + __qt_internal_add_static_plugin_linkage("${plugin_target}" "${_module_target}") + __qt_internal_add_static_plugin_import_macro( + "${plugin_target}" ${_module_target} "@QT_MODULE@") endforeach() + set("QT_ALL_PLUGINS_FOUND_BY_FIND_PACKAGE_${__plugin_type}" + "${QT_ALL_PLUGINS_FOUND_BY_FIND_PACKAGE_${__plugin_type}}" + PARENT_SCOPE + ) + set_target_properties(${_module_target} PROPERTIES __qt_internal_plugins_added TRUE) endfunction() diff --git a/cmake/QtPublicPluginHelpers.cmake b/cmake/QtPublicPluginHelpers.cmake new file mode 100644 index 0000000000..17cb20d59a --- /dev/null +++ b/cmake/QtPublicPluginHelpers.cmake @@ -0,0 +1,156 @@ +function(__qt_internal_plugin_get_plugin_type + plugin_target + out_var_has_plugin_type + out_var_plugin_type) + set(has_plugin_type TRUE) + + set(plugin_target_versioned "${QT_CMAKE_EXPORT_NAMESPACE}::${plugin_target}") + + get_target_property(_plugin_type "${plugin_target_versioned}" QT_PLUGIN_TYPE) + if(NOT _plugin_type) + message("Warning: plugin ${plugin_target_versioned} has no plugin type set, skipping.") + set(has_plugin_type FALSE) + else() + set(${out_var_plugin_type} "${_plugin_type}" PARENT_SCOPE) + endif() + + set(${out_var_has_plugin_type} "${has_plugin_type}" PARENT_SCOPE) +endfunction() + +function(__qt_internal_plugin_has_class_name plugin_target out_var) + + set(plugin_target_versioned "${QT_CMAKE_EXPORT_NAMESPACE}::${plugin_target}") + + get_target_property(classname "${plugin_target_versioned}" QT_PLUGIN_CLASS_NAME) + if(NOT classname) + message("Warning: plugin ${plugin_target_versioned} has no class name, skipping.") + endif() + + # If unset, it will be -NOTFOUND and still evaluate to false. + set(${out_var} "${classname}" PARENT_SCOPE) +endfunction() + +function(__qt_internal_get_static_plugin_condition_genex + plugin_target_unprefixed + out_var) + + set(plugin_target "${QT_CMAKE_EXPORT_NAMESPACE}::${plugin_target_unprefixed}") + set(plugin_target_versionless "Qt::${plugin_target_unprefixed}") + + get_target_property(_plugin_type "${plugin_target}" QT_PLUGIN_TYPE) + + set(_default_plugins_are_enabled + "$>,0>>") + set(_manual_plugins_genex "$>") + set(_no_plugins_genex "$>") + + # Plugin genex marker for prl processing. + set(_is_plugin_marker_genex "$") + + # The code in here uses the properties defined in qt_import_plugins (Qt6CoreMacros.cmake) + set(_plugin_is_default "$") + + # INCLUDE + set(_plugin_is_whitelisted "$") + set(_plugin_versionless_is_whitelisted + "$") + + # Note: qt_import_plugins sets the QT_PLUGINS_${_plugin_type} to "-" + # when excluding it with EXCLUDE_BY_TYPE, + # which ensures that no plug-in will be supported unless explicitly re-added afterwards. + string(CONCAT _plugin_is_not_blacklisted + "$" + ">," + "$" + ">," + # Excludes both plugins targeted by EXCLUDE_BY_TYPE and not included in + # INCLUDE_BY_TYPE. + "$>>" + ">" + ) + + # Support INCLUDE_BY_TYPE + string(CONCAT _plugin_is_in_type_whitelist + "$" + ">" + ">" + ) + string(CONCAT _plugin_versionless_is_in_type_whitelist + "$" + ">" + ">" + ) + + # Complete condition that defines whether a static plugin is linked + string(CONCAT _plugin_condition + "$" + ">" + ">>" + ) + + set(${out_var} "${_plugin_condition}" PARENT_SCOPE) +endfunction() + +function(__qt_internal_add_static_plugin_linkage plugin_target qt_module_target) + __qt_internal_get_static_plugin_condition_genex("${plugin_target}" plugin_condition) + + set(plugin_target "${QT_CMAKE_EXPORT_NAMESPACE}::${plugin_target}") + + # If this condition is true, we link against the plug-in + set(plugin_genex "$<${plugin_condition}:${plugin_target}>") + target_link_libraries(${qt_module_target} INTERFACE "${plugin_genex}") +endfunction() + +function(__qt_internal_add_static_plugin_import_macro + plugin_target + qt_module_target + qt_module_unprefixed) + set(_generated_qt_plugin_file_name + "${CMAKE_CURRENT_BINARY_DIR}/qt_${qt_module_unprefixed}_${plugin_target}.cpp") + + set(plugin_target_versioned "${QT_CMAKE_EXPORT_NAMESPACE}::${plugin_target}") + get_target_property(class_name "${plugin_target_versioned}" QT_PLUGIN_CLASS_NAME) + + set(_generated_qt_plugin_file_content "#include \nQ_IMPORT_PLUGIN(${class_name})") + + # Generate a source file to import that plug-in. Be careful not to + # update the timestamp of the generated file if we are not going to + # change anything. Otherwise we will trigger CMake's autogen to re-run + # and executables will then need to at least relink. + set(need_write TRUE) + if(EXISTS ${_generated_qt_plugin_file_name}) + file(READ ${_generated_qt_plugin_file_name} old_contents) + if(old_contents STREQUAL "${_generated_qt_plugin_file_content}") + set(need_write FALSE) + endif() + endif() + if(need_write) + file(WRITE "${_generated_qt_plugin_file_name}" + "${_generated_qt_plugin_file_content}") + endif() + + __qt_internal_get_static_plugin_condition_genex("${plugin_target}" plugin_condition) + + target_sources(${qt_module_target} INTERFACE + "$<${plugin_condition}:${_generated_qt_plugin_file_name}>") +endfunction() -- cgit v1.2.3