Revision control
Copy as Markdown
# Copyright (C) 2022 The Qt Company Ltd.
# SPDX-License-Identifier: BSD-3-Clause
# Creates and installs the following wrapper CMake scripts:
# qt-make
# qt-cmake-private
# qt-configure-module
# qt-cmake-private-install
# And other helper scripts.
function(qt_internal_create_wrapper_scripts)
# Provide a convenience cmake wrapper.
if(QT_GENERATE_WRAPPER_SCRIPTS_FOR_ALL_HOSTS)
set(generate_unix TRUE)
set(generate_non_unix TRUE)
elseif(CMAKE_HOST_UNIX)
set(generate_unix TRUE)
else()
set(generate_non_unix TRUE)
endif()
set(extra_qt_cmake_code "")
if(generate_unix)
if(UIKIT)
set(extra_qt_cmake_code [=[
# Specify Xcode as the default generator by assigning it to the CMAKE_GENERATOR env var.
# An explicit -G or -D CMAKE_GENERATOR given on the command line will still take precedence.
export CMAKE_GENERATOR=Xcode
]=])
endif()
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-cmake.in"
"${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake" @ONLY
NEWLINE_STYLE LF)
qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake"
DESTINATION "${INSTALL_BINDIR}")
endif()
if(generate_non_unix)
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-cmake.bat.in"
"${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake.bat" @ONLY
NEWLINE_STYLE CRLF)
qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake.bat"
DESTINATION "${INSTALL_BINDIR}")
endif()
if(generate_unix)
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-cmake-create.in"
"${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake-create" @ONLY
NEWLINE_STYLE LF)
qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake-create"
DESTINATION "${INSTALL_BINDIR}")
endif()
if(generate_non_unix)
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-cmake-create.bat.in"
"${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake-create.bat" @ONLY
NEWLINE_STYLE CRLF)
qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake-create.bat"
DESTINATION "${INSTALL_BINDIR}")
endif()
# Reset the contents for the next script.
set(extra_qt_cmake_code "")
# Provide a private convenience wrapper with options that should not be propagated via the
# public qt-cmake wrapper e.g. CMAKE_GENERATOR.
# These options can not be set in a toolchain file, but only on the command line.
# These options should not be in the public wrapper, because a consumer of Qt might want to
# build their CMake app with the Unix Makefiles generator, while Qt should be built with the
# Ninja generator. In a similar vein, we do want to use the same compiler for all Qt modules,
# but not for user applications.
# The private wrapper is more convenient for building Qt itself, because a developer doesn't
# need to specify the same options for each qt module built.
set(__qt_cmake_extra "-G\"${CMAKE_GENERATOR}\" -DQT_USE_ORIGINAL_COMPILER=ON")
if(generate_unix)
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-cmake.in"
"${QT_BUILD_DIR}/${INSTALL_LIBEXECDIR}/qt-cmake-private" @ONLY
NEWLINE_STYLE LF)
qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_LIBEXECDIR}/qt-cmake-private"
DESTINATION "${INSTALL_LIBEXECDIR}")
endif()
if(generate_non_unix)
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-cmake.bat.in"
"${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake-private.bat" @ONLY
NEWLINE_STYLE CRLF)
qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake-private.bat"
DESTINATION "${INSTALL_BINDIR}")
endif()
unset(__qt_cmake_extra)
# Provide a script to configure Qt modules.
if(QT_WILL_INSTALL)
set(__relative_path_to_cmake_scripts_dir
"${__GlobalConfig_relative_path_from_bin_dir_to_cmake_config_dir}")
else()
file(RELATIVE_PATH __relative_path_to_cmake_scripts_dir
"${__qt_bin_dir_absolute}" "${CMAKE_CURRENT_LIST_DIR}")
endif()
# Store arguments we want to forward from configure to qt-configure-module arguments in a
# side-car file. If there's nothing to forward, create an empty file.
set(initial_configure_args "")
if(QT_USE_VCPKG)
list(APPEND initial_configure_args -vcpkg)
endif()
set(side_car_file_name "qt-configure-module-flags.txt")
set(side_car_file_path "${__GlobalConfig_build_dir}/${side_car_file_name}")
string(JOIN "\n" side_car_file_content "${initial_configure_args}")
file(CONFIGURE OUTPUT "${side_car_file_path}" CONTENT "${side_car_file_content}\n")
qt_copy_or_install(FILES "${side_car_file_path}" DESTINATION "${__GlobalConfig_install_dir}")
if(generate_unix)
# Ensure forward slashes for Unix shell scripts.
file(TO_CMAKE_PATH "${__relative_path_to_cmake_scripts_dir}"
__relative_path_to_cmake_scripts_dir)
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-configure-module.in"
"${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-configure-module" @ONLY
NEWLINE_STYLE LF)
qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-configure-module"
DESTINATION "${INSTALL_BINDIR}")
endif()
if(generate_non_unix)
# Ensure native separators for Windows batch scripts.
string(REPLACE "/" "\\" __relative_path_to_cmake_scripts_dir
"${__relative_path_to_cmake_scripts_dir}")
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-configure-module.bat.in"
"${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-configure-module.bat" @ONLY
NEWLINE_STYLE CRLF)
qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-configure-module.bat"
DESTINATION "${INSTALL_BINDIR}")
endif()
unset(__relative_path_to_cmake_scripts_dir)
# Provide a private convenience wrapper to configure and build one or more standalone tests.
# It invokes cmake directly on the test source directory. The test's CMakeLists.txt calls
# find_package(Qt6BuildInternals COMPONENTS STANDALONE_TEST) which sets up Qt's private
# build infrastructure (Main.cmake) when neither QT_BUILD_STANDALONE_TESTS nor
# QT_BUILDING_QT is set.
set(__qt_cmake_standalone_test_name "qt-cmake-standalone-test")
if(generate_unix)
set(__qt_cmake_standalone_test_libexec_path
"${INSTALL_LIBEXECDIR}/${__qt_cmake_standalone_test_name}")
endif()
if(generate_non_unix)
set(__qt_cmake_standalone_test_bin_path
"${INSTALL_BINDIR}/${__qt_cmake_standalone_test_name}")
endif()
# Configuring a standalone test on non-macOS Apple OSes should use the Xcode generator,
# but qt-cmake-private uses the generator that was used to build Qt itself (e.g. Ninja).
# Use qt-cmake instead, which does use the Xcode generator since Qt 6.2.5, 6.3.1, 6.4.
if(APPLE AND NOT MACOS)
set(__qt_cmake_private_path
"${QT_STAGING_PREFIX}/${INSTALL_BINDIR}/qt-cmake")
else()
if(generate_unix)
set(__qt_cmake_private_path
"${QT_STAGING_PREFIX}/${INSTALL_LIBEXECDIR}/qt-cmake-private")
endif()
if(generate_non_unix)
set(__qt_cmake_private_path
"${QT_STAGING_PREFIX}/${INSTALL_BINDIR}/qt-cmake-private")
endif()
endif()
if(generate_unix)
get_filename_component(rel_base_path
"${QT_STAGING_PREFIX}/${__qt_cmake_standalone_test_libexec_path}"
DIRECTORY)
file(RELATIVE_PATH __qt_cmake_private_relpath "${rel_base_path}"
"${__qt_cmake_private_path}")
set(__qt_cmake_standalone_test_os_prelude "#!/bin/sh")
set(__qt_cmake_standalone_test_script_relpath "SCRIPT_DIR=`dirname $0`")
string(PREPEND __qt_cmake_private_relpath "exec $SCRIPT_DIR/")
set(__qt_cmake_standalone_passed_args "\"$@\"")
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-cmake-standalone-test.in"
"${QT_BUILD_DIR}/${__qt_cmake_standalone_test_libexec_path}"
NEWLINE_STYLE LF)
qt_install(PROGRAMS "${QT_BUILD_DIR}/${__qt_cmake_standalone_test_libexec_path}"
DESTINATION "${INSTALL_LIBEXECDIR}")
endif()
if(generate_non_unix)
get_filename_component(rel_base_path
"${QT_STAGING_PREFIX}/${__qt_cmake_standalone_test_bin_path}"
DIRECTORY)
file(RELATIVE_PATH __qt_cmake_private_relpath "${rel_base_path}"
"${__qt_cmake_private_path}")
set(__qt_cmake_standalone_test_os_prelude "@echo off")
set(__qt_cmake_standalone_test_script_relpath "set SCRIPT_DIR=%~dp0")
string(APPEND __qt_cmake_standalone_test_bin_path ".bat")
string(APPEND __qt_cmake_private_relpath ".bat")
string(PREPEND __qt_cmake_private_relpath "%SCRIPT_DIR%")
set(__qt_cmake_standalone_passed_args "%*")
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-cmake-standalone-test.in"
"${QT_BUILD_DIR}/${__qt_cmake_standalone_test_bin_path}"
NEWLINE_STYLE CRLF)
qt_install(PROGRAMS "${QT_BUILD_DIR}/${__qt_cmake_standalone_test_bin_path}"
DESTINATION "${INSTALL_BINDIR}")
endif()
# Create an installation script that the CI can use to handle installation for both
# single and multiple configurations.
set(__qt_cmake_install_script_name "qt-cmake-private-install.cmake")
if(CMAKE_CONFIGURATION_TYPES)
set(__qt_configured_configs "${CMAKE_CONFIGURATION_TYPES}")
elseif(CMAKE_BUILD_TYPE)
set(__qt_configured_configs "${CMAKE_BUILD_TYPE}")
endif()
if(
# Skip stripping pure debug builds so it's easier to debug issues in CI VMs.
(NOT QT_FEATURE_debug_and_release
AND QT_FEATURE_debug
AND NOT QT_FEATURE_separate_debug_info)
# Skip stripping on MSVC because ${CMAKE_STRIP} might contain a MinGW strip binary
# and the breaks the linker version flag embedded in the binary and causes Qt Creator
# to mis-identify the Kit ABI.
OR MSVC
)
set(__qt_skip_strip_installed_artifacts TRUE)
else()
set(__qt_skip_strip_installed_artifacts FALSE)
endif()
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/${__qt_cmake_install_script_name}.in"
"${QT_BUILD_DIR}/${INSTALL_LIBEXECDIR}/${__qt_cmake_install_script_name}" @ONLY)
qt_install(FILES "${QT_BUILD_DIR}/${INSTALL_LIBEXECDIR}/${__qt_cmake_install_script_name}"
DESTINATION "${INSTALL_LIBEXECDIR}")
qt_internal_create_qt_configure_part_wrapper_script("STANDALONE_TESTS")
qt_internal_create_qt_configure_part_wrapper_script("STANDALONE_EXAMPLES")
qt_internal_create_cyclone_dx_sbom_generator_script()
if(NOT CMAKE_CROSSCOMPILING)
qt_internal_create_qt_android_runner_wrapper_script()
endif()
if(APPLE AND NOT MACOS)
qt_internal_install_qt_apple_runner_script()
endif()
endfunction()
function(qt_internal_create_qt_configure_part_wrapper_script component)
if(QT_GENERATE_WRAPPER_SCRIPTS_FOR_ALL_HOSTS)
set(generate_unix TRUE)
set(generate_non_unix TRUE)
elseif(CMAKE_HOST_UNIX)
set(generate_unix TRUE)
else()
set(generate_non_unix TRUE)
endif()
# Create a private wrapper script to configure and build all standalone tests / examples.
#
# The script uses qt-cmake instead of qt-cmake-private on purpose. That's to ensure we build
# only one configuration of tests (e.g RelWithDebInfo only) when Qt is configured with more
# than one configuration (RelWithDebInfo;Debug).
# Meant to be used by our CI instructions.
#
# The script takes a path to the repo for which the standalone tests / examples will be
# configured.
if(component STREQUAL "STANDALONE_TESTS")
set(script_name "qt-internal-configure-tests")
set(script_passed_args "-DQT_BUILD_STANDALONE_TESTS=ON -DQT_BUILD_EXAMPLES=OFF")
elseif(component STREQUAL "STANDALONE_EXAMPLES")
set(script_name "qt-internal-configure-examples")
set(script_passed_args "-DQT_BUILD_STANDALONE_EXAMPLES=ON -DQT_BUILD_TESTS=OFF")
else()
message(FATAL_ERROR "Invalid component type: ${component}")
endif()
string(APPEND script_passed_args " -DQT_USE_ORIGINAL_COMPILER=ON")
file(RELATIVE_PATH relative_path_from_libexec_dir_to_bin_dir
${__qt_libexec_dir_absolute}
${__qt_bin_dir_absolute})
if(generate_unix)
# Ensure forward slashes for Unix shell scripts.
file(TO_CMAKE_PATH "${relative_path_from_libexec_dir_to_bin_dir}"
relative_path_from_libexec_dir_to_bin_dir)
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/libexec/${script_name}.in"
"${QT_BUILD_DIR}/${INSTALL_LIBEXECDIR}/${script_name}" @ONLY
NEWLINE_STYLE LF)
qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_LIBEXECDIR}/${script_name}"
DESTINATION "${INSTALL_LIBEXECDIR}")
endif()
if(generate_non_unix)
# Ensure native separators for Windows batch scripts.
string(REPLACE "/" "\\" relative_path_from_libexec_dir_to_bin_dir
"${relative_path_from_libexec_dir_to_bin_dir}")
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/libexec/${script_name}.bat.in"
"${QT_BUILD_DIR}/${INSTALL_BINDIR}/${script_name}.bat" @ONLY
NEWLINE_STYLE CRLF)
qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_BINDIR}/${script_name}.bat"
DESTINATION "${INSTALL_BINDIR}")
endif()
endfunction()
# Create a shell wrapper script to reconfigure Qt with the original configure arguments and
# any additional ones passed.
#
# Removes CMakeCache.txt and friends, either manually, or using CMake's --fresh.
#
# The script is created in the root of the build dir and is called config.redo
# It has the same contents as the 'config.status' script we created in qt 5.
function(qt_internal_create_qt_configure_redo_script)
# Protect against creating the script once per repo in a top level build. Only one file should
# be created.
get_cmake_property(script_created _qt_configure_redo_script_created)
if(script_created)
return()
endif()
set(wrapper_extension "")
if(NOT CMAKE_HOST_UNIX)
set(wrapper_extension ".bat")
endif()
set(script_name "qt-internal-config.redo")
set(wrapper_rel_path "${script_name}${wrapper_extension}.in")
# Need to find the input file depending whether the qtbase sources are available.
# This mirrors the logic in qt_set_up_build_internals_paths.
# TODO: Clean this up, together with qt_set_up_build_internals_paths to only use the
# the qtbase sources when building qtbase. And perhaps also when doing a non-prefix
# developer-build.
set(qtbase_in_path "${QT_SOURCE_TREE}/cmake/${wrapper_rel_path}")
set(installed_in_path
"${_qt_cmake_dir}/${QT_CMAKE_EXPORT_NAMESPACE}/${wrapper_rel_path}")
# qtbase sources available, always use them, regardless of prefix or non-prefix builds.
if(EXISTS "${qtbase_in_path}")
set(input_script_path "${qtbase_in_path}")
# qtbase sources unavailable, use installed files.
elseif(EXISTS "${installed_in_path}")
set(input_script_path "${installed_in_path}")
else()
message(FATAL_ERROR "Can't find ${script_name}${wrapper_extension}.in file.")
endif()
# We don't use QT_BUILD_DIR because we want the file in the root of the build dir in a top-level
# build.
set(output_script_name "config.redo")
set(output_path "${CMAKE_BINARY_DIR}/${output_script_name}${wrapper_extension}")
set(repo_path "")
if(QT_SUPERBUILD)
set(configure_script_path "${Qt_SOURCE_DIR}/configure")
elseif(QtBase_SOURCE_DIR)
set(configure_script_path "${QtBase_SOURCE_DIR}/configure")
else()
if(QT_WILL_INSTALL)
set(configure_script_path "${QT_STAGING_PREFIX}")
else()
set(configure_script_path "${QT_BUILD_DIR}")
endif()
string(APPEND configure_script_path
"/${INSTALL_BINDIR}/qt-configure-module${wrapper_extension}")
# When configuring a repo other than qtbase, we also need to provide the location
# to the repo sources.
set(repo_path "${CMAKE_SOURCE_DIR}")
endif()
# Used in the file contents.
file(TO_NATIVE_PATH "${configure_script_path}" configure_path)
if(CMAKE_HOST_UNIX)
set(newline_style "LF")
else()
set(newline_style "CRLF")
endif()
configure_file("${input_script_path}" "${output_path}" @ONLY NEWLINE_STYLE ${newline_style})
set_property(GLOBAL PROPERTY _qt_configure_redo_script_created TRUE)
endfunction()
function(qt_internal_create_cyclone_dx_sbom_generator_script)
_qt_internal_sbom_get_cyclone_dx_generator_script_name(generator_name generator_relative_dir)
qt_path_join(build_dir_destination "${QT_BUILD_DIR}" "${INSTALL_LIBEXECDIR}")
qt_path_join(install_destination "${QT_INSTALL_DIR}" "${INSTALL_LIBEXECDIR}")
qt_path_join(script_path
"${CMAKE_CURRENT_SOURCE_DIR}" "${generator_relative_dir}" "${generator_name}")
if(QT_WILL_INSTALL)
file(COPY "${script_path}"
DESTINATION "${build_dir_destination}"
)
endif()
qt_copy_or_install(PROGRAMS "${script_path}" DESTINATION "${install_destination}")
endfunction()
function(qt_internal_create_qt_android_runner_wrapper_script)
qt_path_join(android_runner_destination "${QT_INSTALL_DIR}" "${INSTALL_LIBEXECDIR}")
qt_path_join(android_runner "${CMAKE_CURRENT_SOURCE_DIR}" "libexec" "qt-android-runner.py")
qt_copy_or_install(PROGRAMS "${android_runner}" DESTINATION "${android_runner_destination}")
endfunction()
function(qt_internal_install_qt_apple_runner_script)
qt_path_join(apple_runner_destination "${QT_INSTALL_DIR}" "${INSTALL_LIBEXECDIR}")
qt_path_join(apple_runner "${CMAKE_CURRENT_SOURCE_DIR}" "libexec" "qt-apple-runner.sh")
qt_copy_or_install(PROGRAMS "${apple_runner}" DESTINATION "${apple_runner_destination}")
if(NOT QT_WILL_INSTALL)
add_custom_target(Qt${QtBase_VERSION_MAJOR}AppleRunnerScript ALL
SOURCES ${apple_runner}
)
qt_internal_copy_at_build_time(TARGET Qt${QtBase_VERSION_MAJOR}AppleRunnerScript
FILES ${apple_runner}
DESTINATION ${apple_runner_destination}
)
cmake_language(DEFER CALL add_dependencies
Core
Qt${QtBase_VERSION_MAJOR}AppleRunnerScript
)
endif()
endfunction()