mirror of
https://github.com/crystalidea/qt6windows7.git
synced 2024-10-06 12:03:42 +08:00
250 lines
9.4 KiB
CMake
250 lines
9.4 KiB
CMake
# Copyright (C) 2022 The Qt Company Ltd.
|
|
# SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
# Wraps install() command. In a prefix build, simply passes along arguments to install().
|
|
# In a non-prefix build, handles association of targets to export names, and also calls export().
|
|
function(qt_install)
|
|
set(flags)
|
|
set(options EXPORT DESTINATION NAMESPACE)
|
|
set(multiopts TARGETS)
|
|
cmake_parse_arguments(arg "${flags}" "${options}" "${multiopts}" ${ARGN})
|
|
|
|
if(arg_TARGETS)
|
|
set(is_install_targets TRUE)
|
|
endif()
|
|
|
|
# In a prefix build, always invoke install() without modification.
|
|
# In a non-prefix build, pass install(TARGETS) commands to allow
|
|
# association of targets to export names, so we can later use the export names
|
|
# in export() commands.
|
|
if(QT_WILL_INSTALL OR is_install_targets)
|
|
install(${ARGV})
|
|
endif()
|
|
|
|
# When install(EXPORT) is called, also call export(EXPORT)
|
|
# to generate build tree target files.
|
|
if(NOT is_install_targets AND arg_EXPORT)
|
|
# For prefixed builds (both top-level and per-repo) export build tree CMake Targets files so
|
|
# they can be used in CMake ExternalProjects. One such case is examples built as
|
|
# ExternalProjects as part of the Qt build.
|
|
# In a top-level build the exported config files are placed under qtbase/lib/cmake.
|
|
# In a per-repo build, they will be placed in each repo's build dir/lib/cmake.
|
|
if(QT_WILL_INSTALL)
|
|
qt_path_join(arg_DESTINATION "${QT_BUILD_DIR}" "${arg_DESTINATION}")
|
|
endif()
|
|
|
|
set(namespace_option "")
|
|
if(arg_NAMESPACE)
|
|
set(namespace_option NAMESPACE ${arg_NAMESPACE})
|
|
endif()
|
|
export(EXPORT ${arg_EXPORT}
|
|
${namespace_option}
|
|
FILE "${arg_DESTINATION}/${arg_EXPORT}.cmake")
|
|
endif()
|
|
endfunction()
|
|
|
|
# Copies files using file(COPY) signature in non-prefix builds.
|
|
function(qt_non_prefix_copy)
|
|
if(NOT QT_WILL_INSTALL)
|
|
file(${ARGV})
|
|
endif()
|
|
endfunction()
|
|
|
|
# Retrieve the permissions that are set by install(PROGRAMS).
|
|
function(qt_get_install_executable_permissions out_var)
|
|
set(default_permissions ${CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS})
|
|
if(NOT default_permissions)
|
|
set(default_permissions OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ)
|
|
endif()
|
|
set(executable_permissions ${default_permissions} OWNER_EXECUTE)
|
|
if(GROUP_READ IN_LIST default_permissions)
|
|
list(APPEND executable_permissions GROUP_EXECUTE)
|
|
endif()
|
|
if(WORLD_READ IN_LIST default_permissions)
|
|
list(APPEND executable_permissions WORLD_EXECUTE)
|
|
endif()
|
|
set(${out_var} ${executable_permissions} PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
# Use case is installing files in a prefix build, or copying them to the correct build dir
|
|
# in a non-prefix build.
|
|
# Pass along arguments as you would pass them to install().
|
|
# Only supports FILES, PROGRAMS and DIRECTORY signature, and without fancy things
|
|
# like OPTIONAL or RENAME or COMPONENT.
|
|
function(qt_copy_or_install)
|
|
set(flags FILES PROGRAMS DIRECTORY)
|
|
set(options)
|
|
set(multiopts)
|
|
cmake_parse_arguments(arg "${flags}" "${options}" "${multiopts}" ${ARGN})
|
|
|
|
# Remember which option has to be passed to the install command.
|
|
set(copy_arguments "")
|
|
set(argv_copy ${ARGV})
|
|
if(arg_FILES)
|
|
set(install_option "FILES")
|
|
elseif(arg_PROGRAMS)
|
|
set(install_option "PROGRAMS")
|
|
qt_get_install_executable_permissions(executable_permissions)
|
|
list(APPEND copy_arguments FILE_PERMISSIONS ${executable_permissions})
|
|
elseif(arg_DIRECTORY)
|
|
set(install_option "DIRECTORY")
|
|
endif()
|
|
|
|
list(REMOVE_AT argv_copy 0)
|
|
qt_install(${install_option} ${argv_copy})
|
|
qt_non_prefix_copy(COPY ${argv_copy} ${copy_arguments})
|
|
endfunction()
|
|
|
|
# Create a versioned hard-link for the given target, or a program
|
|
# E.g. "bin/qmake6" -> "bin/qmake".
|
|
#
|
|
# One-value Arguments:
|
|
# WORKING_DIRECTORY
|
|
# The directory where the original file is already placed.
|
|
# SUFFIX
|
|
# The program file extension, only used for PROGRAMS
|
|
# Multi-value Arguments:
|
|
# TARGETS
|
|
# List of targets for which the versioned link will be created.
|
|
# If targets are given, BASE_NAME and SUFFIX will be derived from it.
|
|
# PROGRAMS
|
|
# List of program file names for which the versioned link will be created.
|
|
#
|
|
#
|
|
# NOTE: This assumes that TARGETS, or PROGRAMS are already installed in the
|
|
# WORKING_DIRECTORY.
|
|
#
|
|
# In a multi-config build, create the link for the main config only.
|
|
function(qt_internal_install_versioned_link)
|
|
if(NOT QT_WILL_INSTALL)
|
|
return()
|
|
endif()
|
|
|
|
if(NOT QT_CREATE_VERSIONED_HARD_LINK)
|
|
return()
|
|
endif()
|
|
|
|
set(options)
|
|
set(oneValueArgs "WORKING_DIRECTORY;SUFFIX")
|
|
set(multiValueArgs "TARGETS;PROGRAMS")
|
|
cmake_parse_arguments(arg "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
|
|
|
|
if(arg_TARGETS)
|
|
foreach(target "${arg_TARGETS}")
|
|
_qt_internal_create_versioned_link_or_copy("${arg_WORKING_DIRECTORY}"
|
|
$<TARGET_FILE_BASE_NAME:${target}>
|
|
$<TARGET_FILE_SUFFIX:${target}>)
|
|
endforeach()
|
|
endif()
|
|
|
|
if(arg_PROGRAMS)
|
|
foreach(program "${arg_PROGRAMS}")
|
|
_qt_internal_create_versioned_link_or_copy("${arg_WORKING_DIRECTORY}"
|
|
"${program}"
|
|
"${arg_SUFFIX}")
|
|
endforeach()
|
|
endif()
|
|
endfunction()
|
|
|
|
# Generate a script for creating a hard-link between the base_name, and
|
|
# base_name${PROJECT_VERSION_MAJOR}.
|
|
#
|
|
# If no hard link can be created, make a copy instead.
|
|
function(_qt_internal_create_versioned_link_or_copy install_dir base_name suffix)
|
|
qt_path_join(install_base_file_path "$\{qt_full_install_prefix}"
|
|
"${install_dir}" "${base_name}")
|
|
set(original "${install_base_file_path}${suffix}")
|
|
set(linkname "${install_base_file_path}${PROJECT_VERSION_MAJOR}${suffix}")
|
|
set(code "set(qt_full_install_prefix \"$\{CMAKE_INSTALL_PREFIX}\")"
|
|
" if(NOT \"$ENV\{DESTDIR}\" STREQUAL \"\")"
|
|
)
|
|
|
|
if(CMAKE_HOST_WIN32)
|
|
list(APPEND code
|
|
" if(qt_full_install_prefix MATCHES \"^[a-zA-Z]:\")"
|
|
" string(SUBSTRING \"$\{qt_full_install_prefix}\" 2 -1 qt_full_install_prefix)"
|
|
" endif()"
|
|
)
|
|
endif()
|
|
list(APPEND code
|
|
" string(PREPEND qt_full_install_prefix \"$ENV\{DESTDIR}\")"
|
|
" endif()"
|
|
" message(STATUS \"Creating hard link ${original} -> ${linkname}\")"
|
|
" file(CREATE_LINK \"${original}\" \"${linkname}\" COPY_ON_ERROR)")
|
|
|
|
if(QT_GENERATOR_IS_MULTI_CONFIG)
|
|
# Wrap the code in a configuration check,
|
|
# because install(CODE) does not support a CONFIGURATIONS argument.
|
|
qt_create_case_insensitive_regex(main_config_regex ${QT_MULTI_CONFIG_FIRST_CONFIG})
|
|
list(PREPEND code "if(\"\${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES \"${main_config_regex}\")")
|
|
list(APPEND code "endif()")
|
|
endif()
|
|
|
|
list(JOIN code "\n" code)
|
|
install(CODE "${code}")
|
|
endfunction()
|
|
|
|
# Use case is copying files or directories in a non-prefix build with each build, so that changes
|
|
# are available each time, this is useful for some Android templates that are needed for building,
|
|
# apks and need to sync changes each time a build is started
|
|
function(qt_internal_copy_at_build_time)
|
|
set(flags)
|
|
set(options TARGET DESTINATION)
|
|
set(multiopts FILES DIRECTORIES)
|
|
cmake_parse_arguments(arg "${flags}" "${options}" "${multiopts}" ${ARGN})
|
|
|
|
file(MAKE_DIRECTORY "${arg_DESTINATION}")
|
|
|
|
unset(outputs)
|
|
foreach(dir_to_copy IN LISTS arg_DIRECTORIES)
|
|
get_filename_component(file_name "${dir_to_copy}" NAME)
|
|
set(destination_file_name "${arg_DESTINATION}/${file_name}")
|
|
|
|
file(GLOB_RECURSE all_files_in_dir RELATIVE "${dir_to_copy}" "${dir_to_copy}/*")
|
|
set(dir_outputs ${all_files_in_dir})
|
|
set(dir_deps ${all_files_in_dir})
|
|
|
|
list(TRANSFORM dir_outputs PREPEND "${destination_file_name}/")
|
|
list(TRANSFORM dir_deps PREPEND "${dir_to_copy}/")
|
|
|
|
add_custom_command(OUTPUT ${dir_outputs}
|
|
COMMAND ${CMAKE_COMMAND} -E copy_directory ${dir_to_copy} "${destination_file_name}"
|
|
DEPENDS ${dir_deps}
|
|
COMMENT "Copying directory ${dir_to_copy} to ${arg_DESTINATION}."
|
|
)
|
|
list(APPEND outputs ${dir_outputs})
|
|
endforeach()
|
|
|
|
unset(file_outputs)
|
|
unset(files_to_copy)
|
|
foreach(path_to_copy IN LISTS arg_FILES)
|
|
get_filename_component(file_name "${path_to_copy}" NAME)
|
|
set(destination_file_name "${arg_DESTINATION}/${file_name}")
|
|
|
|
list(APPEND file_outputs "${destination_file_name}")
|
|
list(APPEND files_to_copy "${path_to_copy}")
|
|
endforeach()
|
|
|
|
if(files_to_copy)
|
|
add_custom_command(OUTPUT ${file_outputs}
|
|
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${files_to_copy} ${arg_DESTINATION}
|
|
DEPENDS ${files_to_copy}
|
|
COMMENT "Copying files ${files_to_copy} to ${arg_DESTINATION}."
|
|
)
|
|
list(APPEND outputs ${file_outputs})
|
|
endif()
|
|
|
|
get_property(count GLOBAL PROPERTY _qt_internal_copy_at_build_time_count)
|
|
if(NOT count)
|
|
set(count 0)
|
|
endif()
|
|
|
|
add_custom_target(qt_internal_copy_at_build_time_${count} DEPENDS ${outputs})
|
|
if(arg_TARGET)
|
|
add_dependencies(${arg_TARGET} qt_internal_copy_at_build_time_${count})
|
|
endif()
|
|
|
|
math(EXPR count "${count} + 1")
|
|
set_property(GLOBAL PROPERTY _qt_internal_copy_at_build_time_count ${count})
|
|
endfunction()
|