1 files changed, 151 insertions, 0 deletions
diff --git a/cmake/QtCMakeHelpers.cmake b/cmake/QtCMakeHelpers.cmake
new file mode 100644
index 0000000000..261e9cc457
--- /dev/null
+++ b/cmake/QtCMakeHelpers.cmake
@@ -0,0 +1,151 @@
+# qt_configure_file(OUTPUT output-file <INPUT input-file | CONTENT content>)
+# input-file is relative to ${CMAKE_CURRENT_SOURCE_DIR}
+# output-file is relative to ${CMAKE_CURRENT_BINARY_DIR}
+#
+# This function is similar to file(GENERATE OUTPUT) except it writes the content
+# to the file at configure time, rather than at generate time. Once CMake 3.18 is released, it can use file(CONFIGURE) in its implmenetation. Until then, it
+# uses configure_file() with a generic input file as source, when used with the CONTENT signature.
+function(qt_configure_file)
+    qt_parse_all_arguments(arg "qt_configure_file" "" "OUTPUT;INPUT;CONTENT" "" ${ARGN})
+
+    if(NOT arg_OUTPUT)
+        message(FATAL_ERROR "No output file provided to qt_configure_file.")
+    endif()
+
+    if(arg_CONTENT)
+        set(template_name "QtFileConfigure.txt.in")
+        # When building qtbase, use the source template file.
+        # Otherwise use the installed file.
+        # This should work for non-prefix and superbuilds as well.
+        if(QtBase_SOURCE_DIR)
+            set(input_file "${QtBase_SOURCE_DIR}/cmake/${template_name}")
+        else()
+            set(input_file "${Qt6_DIR}/${template_name}")
+        endif()
+        set(__qt_file_configure_content "${arg_CONTENT}")
+    elseif(arg_INPUT)
+        set(input_file "${arg_INPUT}")
+    else()
+        message(FATAL_ERROR "No input value provided to qt_configure_file.")
+    endif()
+
+    configure_file("${input_file}" "${arg_OUTPUT}" @ONLY)
+endfunction()
+
+# A version of cmake_parse_arguments that makes sure all arguments are processed and errors out
+# with a message about ${type} having received unknown arguments.
+macro(qt_parse_all_arguments result type flags options multiopts)
+    cmake_parse_arguments(${result} "${flags}" "${options}" "${multiopts}" ${ARGN})
+    if(DEFINED ${result}_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Unknown arguments were passed to ${type} (${${result}_UNPARSED_ARGUMENTS}).")
+    endif()
+endmacro()
+
+# Print all variables defined in the current scope.
+macro(qt_debug_print_variables)
+    cmake_parse_arguments(__arg "DEDUP" "" "MATCH;IGNORE" ${ARGN})
+    message("Known Variables:")
+    get_cmake_property(__variableNames VARIABLES)
+    list (SORT __variableNames)
+    if (__arg_DEDUP)
+        list(REMOVE_DUPLICATES __variableNames)
+    endif()
+
+    foreach(__var ${__variableNames})
+        set(__ignore OFF)
+        foreach(__i ${__arg_IGNORE})
+            if(__var MATCHES "${__i}")
+                set(__ignore ON)
+                break()
+            endif()
+        endforeach()
+
+        if (__ignore)
+            continue()
+        endif()
+
+        set(__show OFF)
+        foreach(__i ${__arg_MATCH})
+            if(__var MATCHES "${__i}")
+                set(__show ON)
+                break()
+            endif()
+        endforeach()
+
+        if (__show)
+            message("    ${__var}=${${__var}}.")
+        endif()
+    endforeach()
+endmacro()
+
+macro(assert)
+    if (${ARGN})
+    else()
+        message(FATAL_ERROR "ASSERT: ${ARGN}.")
+    endif()
+endmacro()
+
+# Takes a list of path components and joins them into one path separated by forward slashes "/",
+# and saves the path in out_var.
+function(qt_path_join out_var)
+    string(JOIN "/" path ${ARGN})
+    set(${out_var} ${path} PARENT_SCOPE)
+endfunction()
+
+# qt_remove_args can remove arguments from an existing list of function
+# arguments in order to pass a filtered list of arguments to a different function.
+# Parameters:
+#   out_var: result of remove all arguments specified by ARGS_TO_REMOVE from ALL_ARGS
+#   ARGS_TO_REMOVE: Arguments to remove.
+#   ALL_ARGS: All arguments supplied to cmake_parse_arguments or
+#   qt_parse_all_arguments
+#   from which ARGS_TO_REMOVE should be removed from. We require all the
+#   arguments or we can't properly identify the range of the arguments detailed
+#   in ARGS_TO_REMOVE.
+#   ARGS: Arguments passed into the function, usually ${ARGV}
+#
+#   E.g.:
+#   We want to forward all arguments from foo to bar, execpt ZZZ since it will
+#   trigger an error in bar.
+#
+#   foo(target BAR .... ZZZ .... WWW ...)
+#   bar(target BAR.... WWW...)
+#
+#   function(foo target)
+#       qt_parse_all_arguments(arg "" "" "BAR;ZZZ;WWW ${ARGV})
+#       qt_remove_args(forward_args
+#           ARGS_TO_REMOVE ${target} ZZZ
+#           ALL_ARGS ${target} BAR ZZZ WWW
+#           ARGS ${ARGV}
+#       )
+#       bar(${target} ${forward_args})
+#   endfunction()
+#
+function(qt_remove_args out_var)
+    cmake_parse_arguments(arg "" "" "ARGS_TO_REMOVE;ALL_ARGS;ARGS" ${ARGN})
+    set(result ${arg_ARGS})
+    foreach(arg IN LISTS arg_ARGS_TO_REMOVE)
+        # find arg
+        list(FIND result ${arg} find_result)
+        if (NOT find_result EQUAL -1)
+            # remove arg
+            list(REMOVE_AT result ${find_result})
+            list(LENGTH result result_len)
+            list(GET result ${find_result} arg_current)
+            # remove values until we hit another arg
+            while(NOT ${arg_current} IN_LIST arg_ALL_ARGS AND find_result LESS result_len)
+                list(REMOVE_AT result ${find_result})
+                list(GET result ${find_result} arg_current)
+                list(LENGTH result result_len)
+            endwhile()
+        endif()
+    endforeach()
+    set(${out_var} "${result}" PARENT_SCOPE)
+endfunction()
+
+# Creates a regular expression that exactly matches the given string
+# Found in https://gitlab.kitware.com/cmake/cmake/issues/18580
+function(qt_re_escape out_var str)
+    string(REGEX REPLACE "([][+.*()^])" "\\\\\\1" regex "${str}")
+    set(${out_var} ${regex} PARENT_SCOPE)
+endfunction()