diff --git a/cmake/bin/vcruntime140_1.dll b/cmake/bin/vcruntime140_1.dll new file mode 100644 index 0000000000000000000000000000000000000000..2071f2814bbc6dac9a18b32c77ca86da09d579c3 Binary files /dev/null and b/cmake/bin/vcruntime140_1.dll differ diff --git a/cmake/share/aclocal/cmake.m4 b/cmake/share/aclocal/cmake.m4 new file mode 100644 index 0000000000000000000000000000000000000000..46ce5b83fc2497794bf4bdfe63f145d938f830d5 --- /dev/null +++ b/cmake/share/aclocal/cmake.m4 @@ -0,0 +1,44 @@ +dnl Distributed under the OSI-approved BSD 3-Clause License. See accompanying +dnl file Copyright.txt or https://cmake.org/licensing for details. + +AC_DEFUN([CMAKE_FIND_BINARY], +[AC_ARG_VAR([CMAKE_BINARY], [path to the cmake binary])dnl + +if test "x$ac_cv_env_CMAKE_BINARY_set" != "xset"; then + AC_PATH_TOOL([CMAKE_BINARY], [cmake])dnl +fi +])dnl + +# $1: package name +# $2: language (e.g. C/CXX/Fortran) +# $3: The compiler ID, defaults to GNU. +# Possible values are: GNU, Intel, Clang, SunPro, HP, XL, VisualAge, PGI, +# PathScale, Cray, SCO, MSVC, LCC +# $4: optional extra arguments to cmake, e.g. "-DCMAKE_SIZEOF_VOID_P=8" +# $5: optional path to cmake binary +AC_DEFUN([CMAKE_FIND_PACKAGE], [ +AC_REQUIRE([CMAKE_FIND_BINARY])dnl + +AC_ARG_VAR([$1][_][$2][FLAGS], [$2 compiler flags for $1. This overrides the cmake output])dnl +AC_ARG_VAR([$1][_LIBS], [linker flags for $1. This overrides the cmake output])dnl + +failed=false +AC_MSG_CHECKING([for $1]) +if test -z "${$1[]_$2[]FLAGS}"; then + $1[]_$2[]FLAGS=`$CMAKE_BINARY --find-package "-DNAME=$1" "-DCOMPILER_ID=m4_default([$3], [GNU])" "-DLANGUAGE=$2" -DMODE=COMPILE $4` || failed=true +fi +if test -z "${$1[]_LIBS}"; then + $1[]_LIBS=`$CMAKE_BINARY --find-package "-DNAME=$1" "-DCOMPILER_ID=m4_default([$3], [GNU])" "-DLANGUAGE=$2" -DMODE=LINK $4` || failed=true +fi + +if $failed; then + unset $1[]_$2[]FLAGS + unset $1[]_LIBS + + AC_MSG_RESULT([no]) + $6 +else + AC_MSG_RESULT([yes]) + $5 +fi[]dnl +]) diff --git a/cmake/share/cmake-3.31/Help/index.rst b/cmake/share/cmake-3.31/Help/index.rst new file mode 100644 index 0000000000000000000000000000000000000000..84896a15ec0c5bf5658fd06d5dd31ff9f2012982 --- /dev/null +++ b/cmake/share/cmake-3.31/Help/index.rst @@ -0,0 +1,109 @@ +.. title:: CMake Reference Documentation + +Introduction +############ + +CMake is a tool to manage building of source code. Originally, CMake was +designed as a generator for various dialects of ``Makefile``, today +CMake generates modern buildsystems such as ``Ninja`` as well as project +files for IDEs such as Visual Studio and Xcode. + +CMake is widely used for the C and C++ languages, but it may be used to +build source code of other languages too. + +People encountering CMake for the first time may have different initial +goals. To learn how to build a source code package downloaded from the +internet, start with the :guide:`User Interaction Guide`. +This will detail the steps needed to run the :manual:`cmake(1)` or +:manual:`cmake-gui(1)` executable and how to choose a generator, and +how to complete the build. + +The :guide:`Using Dependencies Guide` is aimed at developers +wishing to get started using a third-party library. + +For developers starting a project using CMake, the :guide:`CMake Tutorial` +is a suitable starting point. The :manual:`cmake-buildsystem(7)` +manual is aimed at developers expanding their knowledge of maintaining +a buildsystem and becoming familiar with the build targets that +can be represented in CMake. The :manual:`cmake-packages(7)` manual +explains how to create packages which can easily be consumed by +third-party CMake-based buildsystems. + +Command-Line Tools +################## + +.. toctree:: + :maxdepth: 1 + + /manual/cmake.1 + /manual/ctest.1 + /manual/cpack.1 + +Interactive Dialogs +################### + +.. toctree:: + :maxdepth: 1 + + /manual/cmake-gui.1 + /manual/ccmake.1 + +Reference Manuals +################# + +.. toctree:: + :maxdepth: 1 + + /manual/cmake-buildsystem.7 + /manual/cmake-commands.7 + /manual/cmake-compile-features.7 + /manual/cmake-configure-log.7 + /manual/cmake-cxxmodules.7 + /manual/cmake-developer.7 + /manual/cmake-env-variables.7 + /manual/cmake-file-api.7 + /manual/cmake-generator-expressions.7 + /manual/cmake-generators.7 + /manual/cmake-language.7 + /manual/cmake-modules.7 + /manual/cmake-packages.7 + /manual/cmake-policies.7 + /manual/cmake-presets.7 + /manual/cmake-properties.7 + /manual/cmake-qt.7 + /manual/cmake-server.7 + /manual/cmake-toolchains.7 + /manual/cmake-variables.7 + /manual/cpack-generators.7 + +.. only:: not man + + Guides + ###### + + .. toctree:: + :maxdepth: 1 + + /guide/tutorial/index + /guide/user-interaction/index + /guide/using-dependencies/index + /guide/importing-exporting/index + /guide/ide-integration/index + +.. only:: html or text + + Release Notes + ############# + + .. toctree:: + :maxdepth: 1 + + /release/index + +.. only:: html + + Index and Search + ################ + + * :ref:`genindex` + * :ref:`search` diff --git a/cmake/share/cmake-3.31/Licenses/LGPLv3.txt b/cmake/share/cmake-3.31/Licenses/LGPLv3.txt new file mode 100644 index 0000000000000000000000000000000000000000..b14ca0a552d7e97012befc8f4949173e6ace87c9 --- /dev/null +++ b/cmake/share/cmake-3.31/Licenses/LGPLv3.txt @@ -0,0 +1,165 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. diff --git a/cmake/share/cmake-3.31/Modules/AddFileDependencies.cmake b/cmake/share/cmake-3.31/Modules/AddFileDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..5f13846ddc512391c8c0b0b921f90ef76d1fdbb9 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/AddFileDependencies.cmake @@ -0,0 +1,33 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#[=======================================================================[.rst: +AddFileDependencies +------------------- + +.. deprecated:: 3.20 + +Add dependencies to a source file. + +.. code-block:: cmake + + add_file_dependencies( ...) + +Adds the given ```` to the dependencies of file ````. + +Do not use this command in new code. It is just a wrapper around: + +.. code-block:: cmake + + set_property(SOURCE APPEND PROPERTY OBJECT_DEPENDS ...) + +Instead use the :command:`set_property` command to append to the +:prop_sf:`OBJECT_DEPENDS` source file property directly. + +#]=======================================================================] + +function(add_file_dependencies _file) + + set_property(SOURCE "${_file}" APPEND PROPERTY OBJECT_DEPENDS "${ARGN}") + +endfunction() diff --git a/cmake/share/cmake-3.31/Modules/AndroidTestUtilities.cmake b/cmake/share/cmake-3.31/Modules/AndroidTestUtilities.cmake new file mode 100644 index 0000000000000000000000000000000000000000..866d10a094d24d9307b08c61f1a45e9c2b3ae933 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/AndroidTestUtilities.cmake @@ -0,0 +1,165 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#[======================================================================[.rst: +AndroidTestUtilities +------------------------ + +.. versionadded:: 3.7 + +Create a test that automatically loads specified data onto an Android device. + +Introduction +^^^^^^^^^^^^ + +Use this module to push data needed for testing an Android device behavior +onto a connected Android device. The module will accept files and libraries as +well as separate destinations for each. It will create a test that loads the +files into a device object store and link to them from the specified +destination. The files are only uploaded if they are not already in the object +store. + +For example: + +.. code-block:: cmake + + include(AndroidTestUtilities) + android_add_test_data( + example_setup_test + FILES ... + LIBS ... + DEVICE_TEST_DIR "/data/local/tests/example" + DEVICE_OBJECT_STORE "/sdcard/.ExternalData/SHA" + ) + + +At build time a test named "example_setup_test" will be created. Run this test +on the command line with :manual:`ctest(1)` to load the data onto the Android +device. + +Module Functions +^^^^^^^^^^^^^^^^ + +.. command:: android_add_test_data + + .. code-block:: cmake + + android_add_test_data( + [FILES ...] [FILES_DEST ] + [LIBS ...] [LIBS_DEST ] + [DEVICE_OBJECT_STORE ] + [DEVICE_TEST_DIR ] + [NO_LINK_REGEX ...] + ) + + The ``android_add_test_data`` function is used to copy files and libraries + needed to run project-specific tests. On the host operating system, this is + done at build time. For on-device testing, the files are loaded onto the + device by the manufactured test at run time. + + This function accepts the following named parameters: + + ``FILES ...`` + zero or more files needed for testing + ``LIBS ...`` + zero or more libraries needed for testing + ``FILES_DEST `` + absolute path where the data files are expected to be + ``LIBS_DEST `` + absolute path where the libraries are expected to be + ``DEVICE_OBJECT_STORE `` + absolute path to the location where the data is stored on-device + ``DEVICE_TEST_DIR `` + absolute path to the root directory of the on-device test location + ``NO_LINK_REGEX ...`` + list of regex strings matching the names of files that should be + copied from the object store to the testing directory +#]======================================================================] + +include(${CMAKE_CURRENT_LIST_DIR}/ExternalData.cmake) + +# The parameters to this function should be set to the list of directories, +# files, and libraries that need to be installed prior to testing. +function(android_add_test_data test_name) + # As the names suggest, oneValueArgs lists the arguments that specify a + # single value, while multiValueArgs can contain one or more values. + set(keywordArgs) + set(oneValueArgs FILES_DEST LIBS_DEST DEVICE_OBJECT_STORE DEVICE_TEST_DIR) + set(multiValueArgs FILES LIBS NO_LINK_REGEX) + + # For example, if you called this function with FILES + # then this path would be stored in the variable AST_FILES. + # The AST prefix stands for the name of this function (android_add_test_data). + cmake_parse_arguments(AST "${keywordArgs}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + if(NOT AST_DEVICE_TEST_DIR) + message(FATAL_ERROR "-- You must specify the location of the on device test directory.") + endif() + if(NOT AST_DEVICE_OBJECT_STORE) + message(FATAL_ERROR "-- You must specify the location of the on device object store.") + endif() + if(${AST_DEVICE_TEST_DIR} STREQUAL "/") + message(FATAL_ERROR "-- The device test directory cannot be '/'") + endif() + + # Copy all test data files into the binary directory, where tests are run. + # ExternalData will handle fetching DATA{...} references. + string(REPLACE "|" ";" hash_algs "${_ExternalData_REGEX_EXT}") + # Convert ExternalData placeholder file names to DATA{} syntax. + foreach(alg ${hash_algs}) + string(REGEX REPLACE "([^ ;]+)\\.${alg}" "DATA{\\1}" AST_FILES "${AST_FILES}") + endforeach() + + set(DATA_TARGET_NAME "${test_name}") + string(FIND "${AST_FILES}" "DATA{" data_files_found) + if(${data_files_found} GREATER "-1") + # Use ExternalData if any DATA{} files were found. + ExternalData_Expand_Arguments( + ${DATA_TARGET_NAME} + extern_data_output + ${AST_FILES}) + ExternalData_Add_Target(${DATA_TARGET_NAME}) + else() + add_custom_target(${DATA_TARGET_NAME} ALL) + set(extern_data_output ${AST_FILES}) + endif() + + # For regular files on Linux, just copy them directly. + foreach(path ${AST_FILES}) + foreach(output ${extern_data_output}) + if(${output} STREQUAL ${path}) + # Check if a destination was specified. If not, we copy by default + # into this project's binary directory, preserving its relative path. + if(AST_${VAR}_DEST) + set(DEST ${CMAKE_BINARY_DIR}/${parent_dir}/${AST_${VAR}_DEST}) + else() + get_filename_component(parent_dir ${path} DIRECTORY) + set(DEST "${CMAKE_BINARY_DIR}/${parent_dir}") + endif() + get_filename_component(extern_data_source ${output} REALPATH) + get_filename_component(extern_data_basename ${output} NAME) + add_custom_command( + TARGET ${DATA_TARGET_NAME} POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_if_different ${extern_data_source} ${DEST}/${extern_data_basename} + ) + endif() + endforeach() + endforeach() + + if(ANDROID) + string(REGEX REPLACE "DATA{([^ ;]+)}" "\\1" processed_FILES "${AST_FILES}") + # There's no target used for this command, so we don't need to do anything + # here for CMP0178. + add_test( + NAME ${test_name} + COMMAND ${CMAKE_COMMAND} + "-Darg_files_dest=${AST_FILES_DEST}" + "-Darg_libs_dest=${AST_LIBS_DEST}" + "-Darg_dev_test_dir=${AST_DEVICE_TEST_DIR}" + "-Darg_dev_obj_store=${AST_DEVICE_OBJECT_STORE}" + "-Darg_no_link_regex=${AST_NO_LINK_REGEX}" + "-Darg_files=${processed_FILES}" + "-Darg_libs=${AST_LIBS}" + "-Darg_src_dir=${CMAKE_CURRENT_SOURCE_DIR}" + -P ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/AndroidTestUtilities/PushToAndroidDevice.cmake) + endif() +endfunction() diff --git a/cmake/share/cmake-3.31/Modules/AndroidTestUtilities/PushToAndroidDevice.cmake b/cmake/share/cmake-3.31/Modules/AndroidTestUtilities/PushToAndroidDevice.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1ca01167dbb039646162de9051be6af5f2eda8c0 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/AndroidTestUtilities/PushToAndroidDevice.cmake @@ -0,0 +1,176 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +# This function handles pushing all of the test files needed to the device. +# It places the data files in the object store and makes links to them from +# the appropriate directories. +# +# This function accepts the following named parameters: +# DIRS : one or more directories needed for testing. +# FILES : one or more files needed for testing. +# LIBS : one or more libraries needed for testing. +# DIRS_DEST : specify where the directories should be installed. +# FILES_DEST : specify where the files should be installed. +# LIBS_DEST : specify where the libraries should be installed. +# DEV_OBJ_STORE : specify where the actual data files should be placed. +# DEV_TEST_DIR : specify the root file for the module test directory. +# The DEV_OBJ_STORE and DEV_TEST_DIR variables are required. + +# The parameters to this function should be set to the list of directories, +# files, and libraries that need to be installed prior to testing. +function(android_push_test_files_to_device) + + # The functions in the module need the adb executable. + find_program(adb_executable adb) + if(NOT adb_executable) + message(FATAL_ERROR "could not find adb") + endif() + + function(execute_adb_command) + execute_process(COMMAND ${adb_executable} ${ARGN} RESULT_VARIABLE res_var OUTPUT_VARIABLE out_var ERROR_VARIABLE err_var) + set(out_var ${out_var} PARENT_SCOPE) + if(res_var) + string(REGEX REPLACE ";" " " com "${ARGN}") + message(FATAL_ERROR "Error occurred during adb command: adb ${com}\nError: ${err_var}.") + endif() + endfunction() + + # Checks to make sure that a given file exists on the device. If it does, + # if(file_exists) will return true. + macro(check_device_file_exists device_file file_exists) + set(${file_exists} "") + execute_process( + COMMAND ${adb_executable} shell ls ${device_file} + OUTPUT_VARIABLE out_var ERROR_VARIABLE out_var) + if(NOT out_var) # when a directory exists but is empty the output is empty + set(${file_exists} "YES") + else() + string(FIND ${out_var} "No such file or directory" no_file_exists) + if(${no_file_exists} STREQUAL "-1") # -1 means the file exists + set(${file_exists} "YES") + endif() + endif() + endmacro() + + # Checks to see if a filename matches a regex. + function(filename_regex filename reg_ex) + string(REGEX MATCH ${reg_ex} filename_match ${filename}) + set(filename_match ${filename_match} PARENT_SCOPE) + endfunction() + + # If a file with given name exists in the CMAKE_BINARY_DIR then use that file. + # Otherwise use the file with root in CMAKE_CURRENT_SOURCE_DIR. + macro(set_absolute_path relative_path absolute_path) + set(${absolute_path} ${arg_src_dir}/${relative_path}) + if(EXISTS ${CMAKE_BINARY_DIR}/${relative_path}) + set(${absolute_path} ${CMAKE_BINARY_DIR}/${relative_path}) + endif() + if(NOT EXISTS ${${absolute_path}}) + if(EXISTS ${relative_path}) + set(${absolute_path} ${relative_path}) + else() + message(FATAL_ERROR "Cannot find file for specified path: ${relative_path}") + endif() + endif() + endmacro() + + # This function pushes the data into the device object store and + # creates a link to that data file in a specified location. + # + # This function requires the following un-named parameters: + # data_path : absolute path to data to load into dev obj store. + # dev_object_store : absolute path to the device object store directory. + # link_origin : absolute path to the origin of the link to the dev obj store data file. + function(push_and_link data_path dev_object_store link_origin) + FILE(SHA1 ${data_path} hash_val) + set(obj_store_dst ${dev_object_store}/${hash_val}) + check_device_file_exists(${obj_store_dst} obj_store_file_exists) + # TODO: Verify that the object store file is indeed hashed correctly. Could use md5. + if(NOT obj_store_file_exists) + execute_adb_command(push ${data_path} ${obj_store_dst}) + endif() + check_device_file_exists(${link_origin} link_exists) + if(link_exists) + execute_adb_command(shell rm -f ${link_origin}) + endif() + foreach(ex ${arg_no_link_regex}) + filename_regex(${data_path} ${ex}) + LIST(APPEND match_ex ${filename_match}) + endforeach() + if(match_ex) + execute_adb_command(shell cp ${obj_store_dst} ${link_origin}) + else() + execute_adb_command(shell ln -s ${obj_store_dst} ${link_origin}) + endif() + endfunction() + + #---------------------------------------------------------------------------- + #--------------------Beginning of actual function---------------------------- + #---------------------------------------------------------------------------- + set(oneValueArgs FILES_DEST LIBS_DEST DEV_TEST_DIR DEV_OBJ_STORE) + set(multiValueArgs FILES LIBS) + cmake_parse_arguments(_ptd "" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + # Setup of object store and test dir. + check_device_file_exists(${_ptd_DEV_OBJ_STORE} dev_obj_store_exists) + if(NOT dev_obj_store_exists) + execute_adb_command(shell mkdir -p ${_ptd_DEV_OBJ_STORE}) + endif() + check_device_file_exists(${_ptd_DEV_TEST_DIR} test_dir_exists) + if(test_dir_exists) + # This is protected in the SetupProjectTests module. + execute_adb_command(shell rm -r ${_ptd_DEV_TEST_DIR}) + endif() + execute_adb_command(shell mkdir -p ${_ptd_DEV_TEST_DIR}) + + # Looping over the various types of test data possible. + foreach(TYPE ${multiValueArgs}) + if(_ptd_${TYPE}) + + # determine if the data type destination has been explicitly specified. + if(_ptd_${TYPE}_DEST) + set(dest ${_ptd_${TYPE}_DEST}) + else() + if(${TYPE} STREQUAL LIBS) + set(dest ${_ptd_DEV_TEST_DIR}/lib) + else() + set(dest ${_ptd_DEV_TEST_DIR}) + endif() + endif() + execute_adb_command(shell mkdir -p ${dest}) + + # Loop over the files passed in + foreach(relative_path ${_ptd_${TYPE}}) + # The absolute path can be through the source directory or the build directory. + # If the file/dir exists in the build directory that version is chosen. + set_absolute_path(${relative_path} absolute_path) + # Need to transfer all data files in the data directories to the device + # except those explicitly ignored. + if(${TYPE} STREQUAL FILES) + get_filename_component(file_dir ${relative_path} DIRECTORY) + # dest was determined earlier, relative_path is a dir, file is path from relative path to a data + set(cur_dest ${dest}/${relative_path}) + set(on_dev_dir ${dest}/${file_dir}) + execute_adb_command(shell mkdir -p ${on_dev_dir}) + if(IS_SYMLINK ${absolute_path}) + get_filename_component(real_data_origin ${absolute_path} REALPATH) + push_and_link(${real_data_origin} ${_ptd_DEV_OBJ_STORE} ${cur_dest}) + else() + push_and_link(${absolute_path} ${_ptd_DEV_OBJ_STORE} ${cur_dest}) + endif() + else() # LIBS + execute_adb_command(push ${absolute_path} ${dest}) + endif() + endforeach() + endif() + endforeach() +endfunction() + +android_push_test_files_to_device( + FILES_DEST ${arg_files_dest} + LIBS_DEST ${arg_libs_dest} + DEV_TEST_DIR ${arg_dev_test_dir} + DEV_OBJ_STORE ${arg_dev_obj_store} + FILES ${arg_files} + LIBS ${arg_libs} + ) diff --git a/cmake/share/cmake-3.31/Modules/BasicConfigVersion-AnyNewerVersion.cmake.in b/cmake/share/cmake-3.31/Modules/BasicConfigVersion-AnyNewerVersion.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..2f581927042c460562f71d275e646005c4e24fc0 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/BasicConfigVersion-AnyNewerVersion.cmake.in @@ -0,0 +1,32 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "@CVF_VERSION@") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + +@CVF_ARCH_INDEPENDENT_CHECK@ diff --git a/cmake/share/cmake-3.31/Modules/BasicConfigVersion-ExactVersion.cmake.in b/cmake/share/cmake-3.31/Modules/BasicConfigVersion-ExactVersion.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..546d8e9c65d0fbba35c550bed0fbc7daa13adc3f --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/BasicConfigVersion-ExactVersion.cmake.in @@ -0,0 +1,72 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is equal to the requested version. +# The tweak version component is ignored. +# The variable CVF_VERSION must be set before calling configure_file(). + + +if (PACKAGE_FIND_VERSION_RANGE) + message(AUTHOR_WARNING + "`find_package()` specify a version range but the version strategy " + "(ExactVersion) of the module `${PACKAGE_FIND_NAME}` is incompatible " + "with this request. Only the lower endpoint of the range will be used.") +endif() + +set(PACKAGE_VERSION "@CVF_VERSION@") + +if("@CVF_VERSION@" MATCHES "^([0-9]+)\\.([0-9]+)\\.([0-9]+)") # strip the tweak version + set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}") + set(CVF_VERSION_MINOR "${CMAKE_MATCH_2}") + set(CVF_VERSION_PATCH "${CMAKE_MATCH_3}") + + if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0) + string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}") + endif() + if(NOT CVF_VERSION_MINOR VERSION_EQUAL 0) + string(REGEX REPLACE "^0+" "" CVF_VERSION_MINOR "${CVF_VERSION_MINOR}") + endif() + if(NOT CVF_VERSION_PATCH VERSION_EQUAL 0) + string(REGEX REPLACE "^0+" "" CVF_VERSION_PATCH "${CVF_VERSION_PATCH}") + endif() + + set(CVF_VERSION_NO_TWEAK "${CVF_VERSION_MAJOR}.${CVF_VERSION_MINOR}.${CVF_VERSION_PATCH}") +else() + set(CVF_VERSION_NO_TWEAK "@CVF_VERSION@") +endif() + +if(PACKAGE_FIND_VERSION MATCHES "^([0-9]+)\\.([0-9]+)\\.([0-9]+)") # strip the tweak version + set(REQUESTED_VERSION_MAJOR "${CMAKE_MATCH_1}") + set(REQUESTED_VERSION_MINOR "${CMAKE_MATCH_2}") + set(REQUESTED_VERSION_PATCH "${CMAKE_MATCH_3}") + + if(NOT REQUESTED_VERSION_MAJOR VERSION_EQUAL 0) + string(REGEX REPLACE "^0+" "" REQUESTED_VERSION_MAJOR "${REQUESTED_VERSION_MAJOR}") + endif() + if(NOT REQUESTED_VERSION_MINOR VERSION_EQUAL 0) + string(REGEX REPLACE "^0+" "" REQUESTED_VERSION_MINOR "${REQUESTED_VERSION_MINOR}") + endif() + if(NOT REQUESTED_VERSION_PATCH VERSION_EQUAL 0) + string(REGEX REPLACE "^0+" "" REQUESTED_VERSION_PATCH "${REQUESTED_VERSION_PATCH}") + endif() + + set(REQUESTED_VERSION_NO_TWEAK + "${REQUESTED_VERSION_MAJOR}.${REQUESTED_VERSION_MINOR}.${REQUESTED_VERSION_PATCH}") +else() + set(REQUESTED_VERSION_NO_TWEAK "${PACKAGE_FIND_VERSION}") +endif() + +if(REQUESTED_VERSION_NO_TWEAK STREQUAL CVF_VERSION_NO_TWEAK) + set(PACKAGE_VERSION_COMPATIBLE TRUE) +else() + set(PACKAGE_VERSION_COMPATIBLE FALSE) +endif() + +if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) +endif() + +@CVF_ARCH_INDEPENDENT_CHECK@ diff --git a/cmake/share/cmake-3.31/Modules/BasicConfigVersion-SameMajorVersion.cmake.in b/cmake/share/cmake-3.31/Modules/BasicConfigVersion-SameMajorVersion.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..d37873c8171344c75ec65a4ef9d661a872168514 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/BasicConfigVersion-SameMajorVersion.cmake.in @@ -0,0 +1,54 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version, +# but only if the requested major version is the same as the current one. +# The variable CVF_VERSION must be set before calling configure_file(). + + +set(PACKAGE_VERSION "@CVF_VERSION@") + +if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) +else() + + if("@CVF_VERSION@" MATCHES "^([0-9]+)\\.") + set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}") + if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0) + string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}") + endif() + else() + set(CVF_VERSION_MAJOR "@CVF_VERSION@") + endif() + + if(PACKAGE_FIND_VERSION_RANGE) + # both endpoints of the range must have the expected major version + math (EXPR CVF_VERSION_MAJOR_NEXT "${CVF_VERSION_MAJOR} + 1") + if (NOT PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX_MAJOR STREQUAL CVF_VERSION_MAJOR) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX VERSION_LESS_EQUAL CVF_VERSION_MAJOR_NEXT))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + elseif(PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR + AND ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS_EQUAL PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE TRUE) + else() + set(PACKAGE_VERSION_COMPATIBLE FALSE) + endif() + else() + if(PACKAGE_FIND_VERSION_MAJOR STREQUAL CVF_VERSION_MAJOR) + set(PACKAGE_VERSION_COMPATIBLE TRUE) + else() + set(PACKAGE_VERSION_COMPATIBLE FALSE) + endif() + + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + +@CVF_ARCH_INDEPENDENT_CHECK@ diff --git a/cmake/share/cmake-3.31/Modules/BasicConfigVersion-SameMinorVersion.cmake.in b/cmake/share/cmake-3.31/Modules/BasicConfigVersion-SameMinorVersion.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..3614670b28110b50d9df8e2d35eb3d1ba54b81de --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/BasicConfigVersion-SameMinorVersion.cmake.in @@ -0,0 +1,74 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version, +# but only if the requested major and minor versions are the same as the current +# one. +# The variable CVF_VERSION must be set before calling configure_file(). + + +set(PACKAGE_VERSION "@CVF_VERSION@") + +if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) +else() + + if("@CVF_VERSION@" MATCHES "^([0-9]+)\\.([0-9]+)") + set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}") + set(CVF_VERSION_MINOR "${CMAKE_MATCH_2}") + + if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0) + string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}") + endif() + if(NOT CVF_VERSION_MINOR VERSION_EQUAL 0) + string(REGEX REPLACE "^0+" "" CVF_VERSION_MINOR "${CVF_VERSION_MINOR}") + endif() + else() + set(CVF_VERSION_MAJOR "@CVF_VERSION@") + set(CVF_VERSION_MINOR "") + endif() + + if(PACKAGE_FIND_VERSION_RANGE) + # both endpoints of the range must have the expected major and minor versions + math (EXPR CVF_VERSION_MINOR_NEXT "${CVF_VERSION_MINOR} + 1") + if (NOT (PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR + AND PACKAGE_FIND_VERSION_MIN_MINOR STREQUAL CVF_VERSION_MINOR) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" + AND NOT (PACKAGE_FIND_VERSION_MAX_MAJOR STREQUAL CVF_VERSION_MAJOR + AND PACKAGE_FIND_VERSION_MAX_MINOR STREQUAL CVF_VERSION_MINOR)) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" + AND NOT PACKAGE_FIND_VERSION_MAX VERSION_LESS_EQUAL ${CVF_VERSION_MAJOR}.${CVF_VERSION_MINOR_NEXT}))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + elseif(PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR + AND PACKAGE_FIND_VERSION_MIN_MINOR STREQUAL CVF_VERSION_MINOR + AND ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS_EQUAL PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE TRUE) + else() + set(PACKAGE_VERSION_COMPATIBLE FALSE) + endif() + else() + if(NOT PACKAGE_FIND_VERSION_MAJOR VERSION_EQUAL 0) + string(REGEX REPLACE "^0+" "" PACKAGE_FIND_VERSION_MAJOR "${PACKAGE_FIND_VERSION_MAJOR}") + endif() + if(NOT PACKAGE_FIND_VERSION_MINOR VERSION_EQUAL 0) + string(REGEX REPLACE "^0+" "" PACKAGE_FIND_VERSION_MINOR "${PACKAGE_FIND_VERSION_MINOR}") + endif() + + if((PACKAGE_FIND_VERSION_MAJOR STREQUAL CVF_VERSION_MAJOR) AND + (PACKAGE_FIND_VERSION_MINOR STREQUAL CVF_VERSION_MINOR)) + set(PACKAGE_VERSION_COMPATIBLE TRUE) + else() + set(PACKAGE_VERSION_COMPATIBLE FALSE) + endif() + + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + +@CVF_ARCH_INDEPENDENT_CHECK@ diff --git a/cmake/share/cmake-3.31/Modules/BundleUtilities.cmake b/cmake/share/cmake-3.31/Modules/BundleUtilities.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ebd12ab24034c68d57f025bea38f9f21ec7d20a5 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/BundleUtilities.cmake @@ -0,0 +1,1131 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#[=======================================================================[.rst: +BundleUtilities +--------------- + +Functions to help assemble a standalone bundle application. + +A collection of CMake utility functions useful for dealing with ``.app`` +bundles on the Mac and bundle-like directories on any OS. + +The following functions are provided by this module: + +.. code-block:: cmake + + fixup_bundle + copy_and_fixup_bundle + verify_app + get_bundle_main_executable + get_dotapp_dir + get_bundle_and_executable + get_bundle_all_executables + get_item_key + get_item_rpaths + clear_bundle_keys + set_bundle_key_values + get_bundle_keys + copy_resolved_item_into_bundle + copy_resolved_framework_into_bundle + fixup_bundle_item + verify_bundle_prerequisites + verify_bundle_symlinks + +Requires CMake 2.6 or greater because it uses function, break and +``PARENT_SCOPE``. Also depends on ``GetPrerequisites.cmake``. + +DO NOT USE THESE FUNCTIONS AT CONFIGURE TIME (from ``CMakeLists.txt``)! +Instead, invoke them from an :command:`install(CODE)` or +:command:`install(SCRIPT)` rule. + +.. code-block:: cmake + + fixup_bundle( ) + +Fix up ```` bundle in-place and make it standalone, such that it can be +drag-n-drop copied to another machine and run on that machine as long +as all of the system libraries are compatible. + +If you pass plugins to ``fixup_bundle`` as the libs parameter, you should +install them or copy them into the bundle before calling ``fixup_bundle``. +The ```` parameter is a list of libraries that must be fixed up, but +that cannot be determined by ``otool`` output analysis (i.e. ``plugins``). + +Gather all the keys for all the executables and libraries in a bundle, +and then, for each key, copy each prerequisite into the bundle. Then +fix each one up according to its own list of prerequisites. + +Then clear all the keys and call ``verify_app`` on the final bundle to +ensure that it is truly standalone. + +.. versionadded:: 3.6 + As an optional parameter (``IGNORE_ITEM``) a list of file names can be passed, + which are then ignored + (e.g. ``IGNORE_ITEM "vcredist_x86.exe;vcredist_x64.exe"``). + +.. code-block:: cmake + + copy_and_fixup_bundle( ) + +Makes a copy of the bundle ```` at location ```` and then fixes up +the new copied bundle in-place at ````. + +.. code-block:: cmake + + verify_app() + +Verifies that an application ```` appears valid based on running +analysis tools on it. Calls :command:`message(FATAL_ERROR)` if the application +is not verified. + +.. versionadded:: 3.6 + As an optional parameter (``IGNORE_ITEM``) a list of file names can be passed, + which are then ignored + (e.g. ``IGNORE_ITEM "vcredist_x86.exe;vcredist_x64.exe"``) + +.. code-block:: cmake + + get_bundle_main_executable( ) + +The result will be the full path name of the bundle's main executable +file or an ``error:`` prefixed string if it could not be determined. + +.. code-block:: cmake + + get_dotapp_dir( ) + +Returns the nearest parent dir whose name ends with ``.app`` given the +full path to an executable. If there is no such parent dir, then +simply return the dir containing the executable. + +The returned directory may or may not exist. + +.. code-block:: cmake + + get_bundle_and_executable( ) + +Takes either a ``.app`` directory name or the name of an executable +nested inside a ``.app`` directory and returns the path to the ``.app`` +directory in ```` and the path to its main executable in +````. + +.. code-block:: cmake + + get_bundle_all_executables( ) + +Scans ```` bundle recursively for all ```` executable +files and accumulates them into a variable. + +.. code-block:: cmake + + get_item_key( ) + +Given ```` file name, generate ```` key that should be unique +considering the set of libraries that need copying or fixing up to +make a bundle standalone. This is essentially the file name including +extension with ``.`` replaced by ``_`` + +This key is used as a prefix for CMake variables so that we can +associate a set of variables with a given item based on its key. + +.. code-block:: cmake + + clear_bundle_keys() + +Loop over the ```` list of keys, clearing all the variables +associated with each key. After the loop, clear the list of keys itself. + +Caller of ``get_bundle_keys`` should call ``clear_bundle_keys`` when done with +list of keys. + +.. code-block:: cmake + + set_bundle_key_values( + []) + +Add ```` key to the list (if necessary) for the given item. +If added, also set all the variables associated with that key. + +.. code-block:: cmake + + get_bundle_keys( ) + +Loop over all the executable and library files within ```` bundle (and +given as extra ````) and accumulate a list of keys representing +them. Set values associated with each key such that we can loop over +all of them and copy prerequisite libs into the bundle and then do +appropriate ``install_name_tool`` fixups. + +.. versionadded:: 3.6 + As an optional parameter (``IGNORE_ITEM``) a list of file names can be passed, + which are then ignored + (e.g. ``IGNORE_ITEM "vcredist_x86.exe;vcredist_x64.exe"``) + +.. code-block:: cmake + + copy_resolved_item_into_bundle( ) + +Copy a resolved item into the bundle if necessary. +Copy is not necessary, if the ```` is "the same as" the +````. + +.. code-block:: cmake + + copy_resolved_framework_into_bundle( ) + +Copy a resolved framework into the bundle if necessary. +Copy is not necessary, if the ```` is "the same as" the +````. + +By default, ``BU_COPY_FULL_FRAMEWORK_CONTENTS`` is not set. If you want +full frameworks embedded in your bundles, set +``BU_COPY_FULL_FRAMEWORK_CONTENTS`` to ``ON`` before calling fixup_bundle. By +default, ``COPY_RESOLVED_FRAMEWORK_INTO_BUNDLE`` copies the framework +dylib itself plus the framework ``Resources`` directory. + +.. code-block:: cmake + + fixup_bundle_item( ) + +Get the direct/non-system prerequisites of the ````. +For each prerequisite, change the way it is referenced to the value of +the ``_EMBEDDED_ITEM`` keyed variable for that prerequisite. (Most likely +changing to an ``@executable_path`` style reference.) + +This function requires that the ```` be ``inside`` +the bundle already. In other words, if you pass plugins to ``fixup_bundle`` +as the libs parameter, you should install them or copy them into the +bundle before calling ``fixup_bundle``. The ``libs`` parameter is a list of +libraries that must be fixed up, but that cannot be determined by +otool output analysis. (i.e., ``plugins``) + +Also, change the id of the item being fixed up to its own +``_EMBEDDED_ITEM`` value. + +Accumulate changes in a local variable and make *one* call to +``install_name_tool`` at the end of the function with all the changes at +once. + +If the ``BU_CHMOD_BUNDLE_ITEMS`` variable is set then bundle items will be +marked writable before ``install_name_tool`` tries to change them. + +.. code-block:: cmake + + verify_bundle_prerequisites( ) + +Verifies that the sum of all prerequisites of all files inside the +bundle are contained within the bundle or are ``system`` libraries, +presumed to exist everywhere. + +.. versionadded:: 3.6 + As an optional parameter (``IGNORE_ITEM``) a list of file names can be passed, + which are then ignored + (e.g. ``IGNORE_ITEM "vcredist_x86.exe;vcredist_x64.exe"``) + +.. code-block:: cmake + + verify_bundle_symlinks( ) + +Verifies that any symlinks found in the ```` bundle point to other files +that are already also in the bundle... Anything that points to an +external file causes this function to fail the verification. +#]=======================================================================] + +function(_warn_cmp0080) + cmake_policy(GET_WARNING CMP0080 _cmp0080_warning) + message(AUTHOR_WARNING "${_cmp0080_warning}\n") +endfunction() + +# Do not include this module at configure time! +if(DEFINED CMAKE_GENERATOR) + cmake_policy(GET CMP0080 _BundleUtilities_CMP0080) + if(_BundleUtilities_CMP0080 STREQUAL "NEW") + message(FATAL_ERROR "BundleUtilities cannot be included at configure time!") + elseif(NOT _BundleUtilities_CMP0080 STREQUAL "OLD" AND NOT _CMP0080_SUPPRESS_WARNING) + _warn_cmp0080() + endif() +endif() + +cmake_policy(PUSH) +cmake_policy(SET CMP0057 NEW) # if IN_LIST + +# The functions defined in this file depend on the get_prerequisites function +# (and possibly others) found in: +# +include("${CMAKE_CURRENT_LIST_DIR}/GetPrerequisites.cmake") + + +function(get_bundle_main_executable bundle result_var) + set(result "error: '${bundle}/Contents/Info.plist' file does not exist") + + if(EXISTS "${bundle}/Contents/Info.plist") + set(result "error: no CFBundleExecutable in '${bundle}/Contents/Info.plist' file") + set(line_is_main_executable 0) + set(bundle_executable "") + + # Read Info.plist as a list of lines: + # + set(eol_char "E") + file(READ "${bundle}/Contents/Info.plist" info_plist) + string(REPLACE ";" "\\;" info_plist "${info_plist}") + string(REPLACE "\n" "${eol_char};" info_plist "${info_plist}") + string(REPLACE "\r" "${eol_char};" info_plist "${info_plist}") + + # Scan the lines for "CFBundleExecutable" - the line after that + # is the name of the main executable. + # + foreach(line ${info_plist}) + if(line_is_main_executable) + string(REGEX REPLACE "^.*(.*).*$" "\\1" bundle_executable "${line}") + break() + endif() + + if(line MATCHES "CFBundleExecutable") + set(line_is_main_executable 1) + endif() + endforeach() + + if(NOT bundle_executable STREQUAL "") + if(EXISTS "${bundle}/Contents/MacOS/${bundle_executable}") + set(result "${bundle}/Contents/MacOS/${bundle_executable}") + else() + + # Ultimate goal: + # If not in "Contents/MacOS" then scan the bundle for matching files. If + # there is only one executable file that matches, then use it, otherwise + # it's an error... + # + #file(GLOB_RECURSE file_list "${bundle}/${bundle_executable}") + + # But for now, pragmatically, it's an error. Expect the main executable + # for the bundle to be in Contents/MacOS, it's an error if it's not: + # + set(result "error: '${bundle}/Contents/MacOS/${bundle_executable}' does not exist") + endif() + endif() + else() + # + # More inclusive technique... (This one would work on Windows and Linux + # too, if a developer followed the typical Mac bundle naming convention...) + # + # If there is no Info.plist file, try to find an executable with the same + # base name as the .app directory: + # + endif() + + set(${result_var} "${result}" PARENT_SCOPE) +endfunction() + + +function(get_dotapp_dir exe dotapp_dir_var) + set(s "${exe}") + + if(s MATCHES "/.*\\.app/") + # If there is a ".app" parent directory, + # ascend until we hit it: + # (typical of a Mac bundle executable) + # + set(done 0) + while(NOT ${done}) + get_filename_component(snamewe "${s}" NAME_WE) + get_filename_component(sname "${s}" NAME) + get_filename_component(sdir "${s}" PATH) + set(s "${sdir}") + if(sname MATCHES "\\.app$") + set(done 1) + set(dotapp_dir "${sdir}/${sname}") + endif() + endwhile() + else() + # Otherwise use a directory containing the exe + # (typical of a non-bundle executable on Mac, Windows or Linux) + # + is_file_executable("${s}" is_executable) + if(is_executable) + get_filename_component(sdir "${s}" PATH) + set(dotapp_dir "${sdir}") + else() + set(dotapp_dir "${s}") + endif() + endif() + + + set(${dotapp_dir_var} "${dotapp_dir}" PARENT_SCOPE) +endfunction() + + +function(get_bundle_and_executable app bundle_var executable_var valid_var) + set(valid 0) + + if(EXISTS "${app}") + # Is it a directory ending in .app? + if(IS_DIRECTORY "${app}") + if(app MATCHES "\\.app$") + get_bundle_main_executable("${app}" executable) + if(EXISTS "${app}" AND EXISTS "${executable}") + set(${bundle_var} "${app}" PARENT_SCOPE) + set(${executable_var} "${executable}" PARENT_SCOPE) + set(valid 1) + #message(STATUS "info: handled .app directory case...") + else() + message(STATUS "warning: *NOT* handled - .app directory case...") + endif() + else() + message(STATUS "warning: *NOT* handled - directory but not .app case...") + endif() + else() + # Is it an executable file? + is_file_executable("${app}" is_executable) + if(is_executable) + get_dotapp_dir("${app}" dotapp_dir) + if(EXISTS "${dotapp_dir}") + set(${bundle_var} "${dotapp_dir}" PARENT_SCOPE) + set(${executable_var} "${app}" PARENT_SCOPE) + set(valid 1) + #message(STATUS "info: handled executable file in .app dir case...") + else() + get_filename_component(app_dir "${app}" PATH) + set(${bundle_var} "${app_dir}" PARENT_SCOPE) + set(${executable_var} "${app}" PARENT_SCOPE) + set(valid 1) + #message(STATUS "info: handled executable file in any dir case...") + endif() + else() + message(STATUS "warning: *NOT* handled - not .app dir, not executable file...") + endif() + endif() + else() + message(STATUS "warning: *NOT* handled - directory/file does not exist...") + endif() + + if(NOT valid) + set(${bundle_var} "error: not a bundle" PARENT_SCOPE) + set(${executable_var} "error: not a bundle" PARENT_SCOPE) + endif() + + set(${valid_var} ${valid} PARENT_SCOPE) +endfunction() + + +function(get_bundle_all_executables bundle exes_var) + set(exes "") + + if(UNIX) + find_program(find_cmd "find") + mark_as_advanced(find_cmd) + endif() + + # find command is much quicker than checking every file one by one on Unix + # which can take long time for large bundles, and since anyway we expect + # executable to have execute flag set we can narrow the list much quicker. + if(find_cmd) + execute_process(COMMAND "${find_cmd}" "${bundle}" + -type f \( -perm -0100 -o -perm -0010 -o -perm -0001 \) + OUTPUT_VARIABLE file_list + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + string(REPLACE "\n" ";" file_list "${file_list}") + else() + file(GLOB_RECURSE file_list "${bundle}/*") + endif() + + foreach(f ${file_list}) + is_file_executable("${f}" is_executable) + if(is_executable) + set(exes ${exes} "${f}") + endif() + endforeach() + + set(${exes_var} "${exes}" PARENT_SCOPE) +endfunction() + + +function(get_item_rpaths item rpaths_var) + if(APPLE) + find_program(otool_cmd "otool") + mark_as_advanced(otool_cmd) + endif() + + if(otool_cmd) + execute_process( + COMMAND "${otool_cmd}" -l "${item}" + OUTPUT_VARIABLE load_cmds_ov + RESULT_VARIABLE otool_rv + ERROR_VARIABLE otool_ev + ) + if(NOT otool_rv STREQUAL "0") + message(FATAL_ERROR "otool -l failed: ${otool_rv}\n${otool_ev}") + endif() + string(REGEX REPLACE "[^\n]+cmd LC_RPATH\n[^\n]+\n[^\n]+path ([^\n]+) \\(offset[^\n]+\n" "rpath \\1\n" load_cmds_ov "${load_cmds_ov}") + string(REGEX MATCHALL "rpath [^\n]+" load_cmds_ov "${load_cmds_ov}") + string(REGEX REPLACE "rpath " "" load_cmds_ov "${load_cmds_ov}") + if(load_cmds_ov) + foreach(rpath ${load_cmds_ov}) + gp_append_unique(${rpaths_var} "${rpath}") + endforeach() + endif() + endif() + + if(UNIX AND NOT APPLE) + file(READ_ELF ${item} RPATH rpath_var RUNPATH runpath_var CAPTURE_ERROR error_var) + get_filename_component(item_dir ${item} DIRECTORY) + foreach(rpath ${rpath_var} ${runpath_var}) + # Substitute $ORIGIN with the exepath and add to the found rpaths + string(REPLACE "$ORIGIN" "${item_dir}" rpath "${rpath}") + gp_append_unique(${rpaths_var} "${rpath}") + endforeach() + endif() + + set(${rpaths_var} ${${rpaths_var}} PARENT_SCOPE) +endfunction() + + +function(get_item_key item key_var) + get_filename_component(item_name "${item}" NAME) + if(WIN32) + string(TOLOWER "${item_name}" item_name) + endif() + string(REPLACE "." "_" ${key_var} "${item_name}") + set(${key_var} ${${key_var}} PARENT_SCOPE) +endfunction() + + +function(clear_bundle_keys keys_var) + foreach(key ${${keys_var}}) + set(${key}_ITEM PARENT_SCOPE) + set(${key}_RESOLVED_ITEM PARENT_SCOPE) + set(${key}_DEFAULT_EMBEDDED_PATH PARENT_SCOPE) + set(${key}_EMBEDDED_ITEM PARENT_SCOPE) + set(${key}_RESOLVED_EMBEDDED_ITEM PARENT_SCOPE) + set(${key}_COPYFLAG PARENT_SCOPE) + set(${key}_RPATHS PARENT_SCOPE) + endforeach() + set(${keys_var} PARENT_SCOPE) +endfunction() + + +function(set_bundle_key_values keys_var context item exepath dirs copyflag) + if(ARGC GREATER 6) + set(rpaths "${ARGV6}") + else() + set(rpaths "") + endif() + get_filename_component(item_name "${item}" NAME) + + get_item_key("${item}" key) + + list(LENGTH ${keys_var} length_before) + gp_append_unique(${keys_var} "${key}") + list(LENGTH ${keys_var} length_after) + + if(NOT length_before EQUAL length_after) + gp_resolve_item("${context}" "${item}" "${exepath}" "${dirs}" resolved_item "${rpaths}") + + gp_item_default_embedded_path("${item}" default_embedded_path) + + get_item_rpaths("${resolved_item}" item_rpaths) + + if((NOT item MATCHES "\\.dylib$") AND (item MATCHES "[^/]+\\.framework/")) + # For frameworks, construct the name under the embedded path from the + # opening "${item_name}.framework/" to the closing "/${item_name}": + # + string(REGEX REPLACE "^.*(${item_name}.framework/.*/?${item_name}).*$" "${default_embedded_path}/\\1" embedded_item "${item}") + else() + # For other items, just use the same name as the original, but in the + # embedded path: + # + set(embedded_item "${default_embedded_path}/${item_name}") + endif() + + # Replace @executable_path and resolve ".." references: + # + string(REPLACE "@executable_path" "${exepath}" resolved_embedded_item "${embedded_item}") + get_filename_component(resolved_embedded_item "${resolved_embedded_item}" ABSOLUTE) + + # *But* -- if we are not copying, then force resolved_embedded_item to be + # the same as resolved_item. In the case of multiple executables in the + # original bundle, using the default_embedded_path results in looking for + # the resolved executable next to the main bundle executable. This is here + # so that exes in the other sibling directories (like "bin") get fixed up + # properly... + # + if(NOT copyflag) + set(resolved_embedded_item "${resolved_item}") + endif() + + set(${keys_var} ${${keys_var}} PARENT_SCOPE) + set(${key}_ITEM "${item}" PARENT_SCOPE) + set(${key}_RESOLVED_ITEM "${resolved_item}" PARENT_SCOPE) + set(${key}_DEFAULT_EMBEDDED_PATH "${default_embedded_path}" PARENT_SCOPE) + set(${key}_EMBEDDED_ITEM "${embedded_item}" PARENT_SCOPE) + set(${key}_RESOLVED_EMBEDDED_ITEM "${resolved_embedded_item}" PARENT_SCOPE) + set(${key}_COPYFLAG "${copyflag}" PARENT_SCOPE) + set(${key}_RPATHS "${item_rpaths}" PARENT_SCOPE) + set(${key}_RDEP_RPATHS "${rpaths}" PARENT_SCOPE) + else() + #message("warning: item key '${key}' already in the list, subsequent references assumed identical to first") + endif() +endfunction() + + +function(get_bundle_keys app libs dirs keys_var) + set(${keys_var} PARENT_SCOPE) + + set(options) + set(oneValueArgs) + set(multiValueArgs IGNORE_ITEM) + cmake_parse_arguments(CFG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} ) + + get_bundle_and_executable("${app}" bundle executable valid) + if(valid) + # Always use the exepath of the main bundle executable for @executable_path + # replacements: + # + get_filename_component(exepath "${executable}" PATH) + + # But do fixups on all executables in the bundle: + # + get_bundle_all_executables("${bundle}" exes) + + # Set keys for main executable first: + # + set_bundle_key_values(${keys_var} "${executable}" "${executable}" "${exepath}" "${dirs}" 0) + + # Get rpaths specified by main executable: + # + get_item_key("${executable}" executable_key) + set(main_rpaths "${${executable_key}_RPATHS}") + + # For each extra lib, accumulate a key as well and then also accumulate + # any of its prerequisites. (Extra libs are typically dynamically loaded + # plugins: libraries that are prerequisites for full runtime functionality + # but that do not show up in otool -L output...) + # + foreach(lib ${libs}) + set_bundle_key_values(${keys_var} "${lib}" "${lib}" "${exepath}" "${dirs}" 0 "${main_rpaths}") + + set(prereqs "") + get_filename_component(prereq_filename ${lib} NAME) + + if(NOT prereq_filename IN_LIST CFG_IGNORE_ITEM) + get_prerequisites("${lib}" prereqs 1 1 "${exepath}" "${dirs}" "${main_rpaths}") + foreach(pr ${prereqs}) + set_bundle_key_values(${keys_var} "${lib}" "${pr}" "${exepath}" "${dirs}" 1 "${main_rpaths}") + endforeach() + else() + message(STATUS "Ignoring file: ${prereq_filename}") + endif() + endforeach() + + # For each executable found in the bundle, accumulate keys as we go. + # The list of keys should be complete when all prerequisites of all + # binaries in the bundle have been analyzed. + # + foreach(exe ${exes}) + # Main executable is scanned first above: + # + if(NOT exe STREQUAL executable) + # Add the exe itself to the keys: + # + set_bundle_key_values(${keys_var} "${exe}" "${exe}" "${exepath}" "${dirs}" 0 "${main_rpaths}") + + # Get rpaths specified by executable: + # + get_item_key("${exe}" exe_key) + set(exe_rpaths "${main_rpaths}" "${${exe_key}_RPATHS}") + else() + set(exe_rpaths "${main_rpaths}") + endif() + + # Add each prerequisite to the keys: + # + set(prereqs "") + get_filename_component(prereq_filename ${exe} NAME) + + if(NOT prereq_filename IN_LIST CFG_IGNORE_ITEM) + get_prerequisites("${exe}" prereqs 1 1 "${exepath}" "${dirs}" "${exe_rpaths}") + foreach(pr ${prereqs}) + set_bundle_key_values(${keys_var} "${exe}" "${pr}" "${exepath}" "${dirs}" 1 "${exe_rpaths}") + endforeach() + else() + message(STATUS "Ignoring file: ${prereq_filename}") + endif() + endforeach() + + # preserve library symlink structure + foreach(key ${${keys_var}}) + if("${${key}_COPYFLAG}" STREQUAL "1") + if(IS_SYMLINK "${${key}_RESOLVED_ITEM}") + get_filename_component(target "${${key}_RESOLVED_ITEM}" REALPATH) + set_bundle_key_values(${keys_var} "${exe}" "${target}" "${exepath}" "${dirs}" 1 "${exe_rpaths}") + get_item_key("${target}" targetkey) + + if(WIN32) + # ignore case on Windows + string(TOLOWER "${${key}_RESOLVED_ITEM}" resolved_item_compare) + string(TOLOWER "${${targetkey}_RESOLVED_EMBEDDED_ITEM}" resolved_embedded_item_compare) + else() + set(resolved_item_compare "${${key}_RESOLVED_ITEM}") + set(resolved_embedded_item_compare "${${targetkey}_RESOLVED_EMBEDDED_ITEM}") + endif() + get_filename_component(resolved_item_compare "${resolved_item_compare}" NAME) + get_filename_component(resolved_embedded_item_compare "${resolved_embedded_item_compare}" NAME) + + if(NOT resolved_item_compare STREQUAL resolved_embedded_item_compare) + set(${key}_COPYFLAG "2") + set(${key}_RESOLVED_ITEM "${${targetkey}_RESOLVED_EMBEDDED_ITEM}") + endif() + + endif() + endif() + endforeach() + # Propagate values to caller's scope: + # + set(${keys_var} ${${keys_var}} PARENT_SCOPE) + foreach(key ${${keys_var}}) + set(${key}_ITEM "${${key}_ITEM}" PARENT_SCOPE) + set(${key}_RESOLVED_ITEM "${${key}_RESOLVED_ITEM}" PARENT_SCOPE) + set(${key}_DEFAULT_EMBEDDED_PATH "${${key}_DEFAULT_EMBEDDED_PATH}" PARENT_SCOPE) + set(${key}_EMBEDDED_ITEM "${${key}_EMBEDDED_ITEM}" PARENT_SCOPE) + set(${key}_RESOLVED_EMBEDDED_ITEM "${${key}_RESOLVED_EMBEDDED_ITEM}" PARENT_SCOPE) + set(${key}_COPYFLAG "${${key}_COPYFLAG}" PARENT_SCOPE) + set(${key}_RPATHS "${${key}_RPATHS}" PARENT_SCOPE) + set(${key}_RDEP_RPATHS "${${key}_RDEP_RPATHS}" PARENT_SCOPE) + endforeach() + endif() +endfunction() + +function(link_resolved_item_into_bundle resolved_item resolved_embedded_item) + if(WIN32) + # ignore case on Windows + string(TOLOWER "${resolved_item}" resolved_item_compare) + string(TOLOWER "${resolved_embedded_item}" resolved_embedded_item_compare) + else() + set(resolved_item_compare "${resolved_item}") + set(resolved_embedded_item_compare "${resolved_embedded_item}") + endif() + + if(resolved_item_compare STREQUAL resolved_embedded_item_compare) + message(STATUS "warning: resolved_item == resolved_embedded_item - not linking...") + else() + get_filename_component(target_dir "${resolved_embedded_item}" DIRECTORY) + file(RELATIVE_PATH symlink_target "${target_dir}" "${resolved_item}") + if (NOT EXISTS "${target_dir}") + file(MAKE_DIRECTORY "${target_dir}") + endif() + execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink "${symlink_target}" "${resolved_embedded_item}") + endif() +endfunction() + +function(copy_resolved_item_into_bundle resolved_item resolved_embedded_item) + if(WIN32) + # ignore case on Windows + string(TOLOWER "${resolved_item}" resolved_item_compare) + string(TOLOWER "${resolved_embedded_item}" resolved_embedded_item_compare) + else() + set(resolved_item_compare "${resolved_item}") + set(resolved_embedded_item_compare "${resolved_embedded_item}") + endif() + + if(resolved_item_compare STREQUAL resolved_embedded_item_compare) + message(STATUS "warning: resolved_item == resolved_embedded_item - not copying...") + else() + #message(STATUS "copying COMMAND ${CMAKE_COMMAND} -E copy ${resolved_item} ${resolved_embedded_item}") + execute_process(COMMAND ${CMAKE_COMMAND} -E copy "${resolved_item}" "${resolved_embedded_item}") + if(UNIX AND NOT APPLE) + file(RPATH_REMOVE FILE "${resolved_embedded_item}") + endif() + endif() + +endfunction() + + +function(copy_resolved_framework_into_bundle resolved_item resolved_embedded_item) + if(WIN32) + # ignore case on Windows + string(TOLOWER "${resolved_item}" resolved_item_compare) + string(TOLOWER "${resolved_embedded_item}" resolved_embedded_item_compare) + else() + set(resolved_item_compare "${resolved_item}") + set(resolved_embedded_item_compare "${resolved_embedded_item}") + endif() + + if(resolved_item_compare STREQUAL resolved_embedded_item_compare) + message(STATUS "warning: resolved_item == resolved_embedded_item - not copying...") + else() + if(BU_COPY_FULL_FRAMEWORK_CONTENTS) + # Full Framework (everything): + get_filename_component(resolved_dir "${resolved_item}" PATH) + get_filename_component(resolved_dir "${resolved_dir}/../.." ABSOLUTE) + get_filename_component(resolved_embedded_dir "${resolved_embedded_item}" PATH) + get_filename_component(resolved_embedded_dir "${resolved_embedded_dir}/../.." ABSOLUTE) + #message(STATUS "copying COMMAND ${CMAKE_COMMAND} -E copy_directory '${resolved_dir}' '${resolved_embedded_dir}'") + execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory "${resolved_dir}" "${resolved_embedded_dir}") + else() + # Framework lib itself: + #message(STATUS "copying COMMAND ${CMAKE_COMMAND} -E copy ${resolved_item} ${resolved_embedded_item}") + execute_process(COMMAND ${CMAKE_COMMAND} -E copy "${resolved_item}" "${resolved_embedded_item}") + + # Plus Resources, if they exist: + string(REGEX REPLACE "^(.*)/[^/]+$" "\\1/Resources" resolved_resources "${resolved_item}") + string(REGEX REPLACE "^(.*)/[^/]+$" "\\1/Resources" resolved_embedded_resources "${resolved_embedded_item}") + if(EXISTS "${resolved_resources}") + #message(STATUS "copying COMMAND ${CMAKE_COMMAND} -E copy_directory '${resolved_resources}' '${resolved_embedded_resources}'") + execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory "${resolved_resources}" "${resolved_embedded_resources}") + endif() + + # Some frameworks e.g. Qt put Info.plist in wrong place, so when it is + # missing in resources, copy it from other well known incorrect locations: + if(NOT EXISTS "${resolved_resources}/Info.plist") + # Check for Contents/Info.plist in framework root (older Qt SDK): + string(REGEX REPLACE "^(.*)/[^/]+/[^/]+/[^/]+$" "\\1/Contents/Info.plist" resolved_info_plist "${resolved_item}") + string(REGEX REPLACE "^(.*)/[^/]+$" "\\1/Resources/Info.plist" resolved_embedded_info_plist "${resolved_embedded_item}") + if(EXISTS "${resolved_info_plist}") + #message(STATUS "copying COMMAND ${CMAKE_COMMAND} -E copy_directory '${resolved_info_plist}' '${resolved_embedded_info_plist}'") + execute_process(COMMAND ${CMAKE_COMMAND} -E copy "${resolved_info_plist}" "${resolved_embedded_info_plist}") + endif() + endif() + + # Check if framework is versioned and fix it layout + string(REGEX REPLACE "^.*/([^/]+)/[^/]+$" "\\1" resolved_embedded_version "${resolved_embedded_item}") + string(REGEX REPLACE "^(.*)/[^/]+/[^/]+$" "\\1" resolved_embedded_versions "${resolved_embedded_item}") + string(REGEX REPLACE "^.*/([^/]+)/[^/]+/[^/]+$" "\\1" resolved_embedded_versions_basename "${resolved_embedded_item}") + if(resolved_embedded_versions_basename STREQUAL "Versions") + # Ensure Current symlink points to the framework version + if(NOT EXISTS "${resolved_embedded_versions}/Current") + execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink "${resolved_embedded_version}" "${resolved_embedded_versions}/Current") + endif() + # Restore symlinks in framework root pointing to current framework + # binary and resources: + string(REGEX REPLACE "^(.*)/[^/]+/[^/]+/[^/]+$" "\\1" resolved_embedded_root "${resolved_embedded_item}") + string(REGEX REPLACE "^.*/([^/]+)$" "\\1" resolved_embedded_item_basename "${resolved_embedded_item}") + if(NOT EXISTS "${resolved_embedded_root}/${resolved_embedded_item_basename}") + execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink "Versions/Current/${resolved_embedded_item_basename}" "${resolved_embedded_root}/${resolved_embedded_item_basename}") + endif() + if(NOT EXISTS "${resolved_embedded_root}/Resources") + execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink "Versions/Current/Resources" "${resolved_embedded_root}/Resources") + endif() + endif() + endif() + if(UNIX AND NOT APPLE) + file(RPATH_REMOVE FILE "${resolved_embedded_item}") + endif() + endif() + +endfunction() + + +function(fixup_bundle_item resolved_embedded_item exepath dirs) + # This item's key is "ikey": + # + get_item_key("${resolved_embedded_item}" ikey) + + # Ensure the item is "inside the .app bundle" -- it should not be fixed up if + # it is not in the .app bundle... Otherwise, we'll modify files in the build + # tree, or in other varied locations around the file system, with our call to + # install_name_tool. Make sure that doesn't happen here: + # + get_dotapp_dir("${exepath}" exe_dotapp_dir) + string(LENGTH "${exe_dotapp_dir}/" exe_dotapp_dir_length) + string(LENGTH "${resolved_embedded_item}" resolved_embedded_item_length) + set(path_too_short 0) + set(is_embedded 0) + if(resolved_embedded_item_length LESS exe_dotapp_dir_length) + set(path_too_short 1) + endif() + if(NOT path_too_short) + string(SUBSTRING "${resolved_embedded_item}" 0 ${exe_dotapp_dir_length} item_substring) + if("${exe_dotapp_dir}/" STREQUAL item_substring) + set(is_embedded 1) + endif() + endif() + if(NOT is_embedded) + message(" exe_dotapp_dir/='${exe_dotapp_dir}/'") + message(" item_substring='${item_substring}'") + message(" resolved_embedded_item='${resolved_embedded_item}'") + message("") + message("Install or copy the item into the bundle before calling fixup_bundle.") + message("Or maybe there's a typo or incorrect path in one of the args to fixup_bundle?") + message("") + message(FATAL_ERROR "cannot fixup an item that is not in the bundle...") + endif() + + set(rpaths "${${ikey}_RPATHS}" "${${ikey}_RDEP_RPATHS}") + + set(prereqs "") + get_prerequisites("${resolved_embedded_item}" prereqs 1 0 "${exepath}" "${dirs}" "${rpaths}") + + set(changes "") + + foreach(pr ${prereqs}) + # Each referenced item's key is "rkey" in the loop: + # + get_item_key("${pr}" rkey) + + if(NOT "${${rkey}_EMBEDDED_ITEM}" STREQUAL "") + set(changes ${changes} "-change" "${pr}" "${${rkey}_EMBEDDED_ITEM}") + else() + message("warning: unexpected reference to '${pr}'") + endif() + endforeach() + + # CMAKE_INSTALL_NAME_TOOL may not be set if executed in script mode + # Duplicated from CMakeFindBinUtils.cmake + find_program(CMAKE_INSTALL_NAME_TOOL NAMES install_name_tool HINTS ${_CMAKE_TOOLCHAIN_LOCATION}) + + # Only if install_name_tool supports -delete_rpath: + # + execute_process(COMMAND ${CMAKE_INSTALL_NAME_TOOL} + OUTPUT_VARIABLE install_name_tool_usage + ERROR_VARIABLE install_name_tool_usage + ) + if(install_name_tool_usage MATCHES ".*-delete_rpath.*") + foreach(rpath ${${ikey}_RPATHS}) + set(changes ${changes} -delete_rpath "${rpath}") + endforeach() + endif() + + if(${ikey}_EMBEDDED_ITEM) + set(changes ${changes} -id "${${ikey}_EMBEDDED_ITEM}") + endif() + + # Change this item's id and all of its references in one call + # to install_name_tool: + # + if(changes) + # Check for a script by extension (.bat,.sh,...) or if the file starts with "#!" (shebang) + file(READ ${resolved_embedded_item} file_contents LIMIT 5) + if(NOT "${resolved_embedded_item}" MATCHES "\\.(bat|c?sh|bash|ksh|cmd)$" AND + NOT file_contents MATCHES "^#!") + set(cmd ${CMAKE_INSTALL_NAME_TOOL} ${changes} "${resolved_embedded_item}") + if(BU_CHMOD_BUNDLE_ITEMS) + execute_process(COMMAND chmod u+w "${resolved_embedded_item}") + endif() + execute_process(COMMAND ${cmd} RESULT_VARIABLE install_name_tool_result) + if(NOT install_name_tool_result EQUAL 0) + string(REPLACE ";" "' '" msg "'${cmd}'") + message(FATAL_ERROR "Command failed:\n ${msg}") + endif() + endif() + endif() +endfunction() + + +function(fixup_bundle app libs dirs) + message(STATUS "fixup_bundle") + message(STATUS " app='${app}'") + message(STATUS " libs='${libs}'") + message(STATUS " dirs='${dirs}'") + + set(options) + set(oneValueArgs) + set(multiValueArgs IGNORE_ITEM) + cmake_parse_arguments(CFG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} ) + + message(STATUS " ignoreItems='${CFG_IGNORE_ITEM}'") + + get_bundle_and_executable("${app}" bundle executable valid) + if(valid) + get_filename_component(exepath "${executable}" PATH) + + message(STATUS "fixup_bundle: preparing...") + get_bundle_keys("${app}" "${libs}" "${dirs}" keys IGNORE_ITEM "${CFG_IGNORE_ITEM}") + + message(STATUS "fixup_bundle: copying...") + list(LENGTH keys n) + math(EXPR n ${n}*2) + + set(i 0) + foreach(key ${keys}) + math(EXPR i ${i}+1) + if("${${key}_COPYFLAG}" STREQUAL "2") + message(STATUS "${i}/${n}: linking '${${key}_RESOLVED_ITEM}' -> '${${key}_RESOLVED_EMBEDDED_ITEM}'") + elseif(${${key}_COPYFLAG}) + message(STATUS "${i}/${n}: copying '${${key}_RESOLVED_ITEM}'") + else() + message(STATUS "${i}/${n}: *NOT* copying '${${key}_RESOLVED_ITEM}'") + endif() + + set(show_status 0) + if(show_status) + message(STATUS "key='${key}'") + message(STATUS "item='${${key}_ITEM}'") + message(STATUS "resolved_item='${${key}_RESOLVED_ITEM}'") + message(STATUS "default_embedded_path='${${key}_DEFAULT_EMBEDDED_PATH}'") + message(STATUS "embedded_item='${${key}_EMBEDDED_ITEM}'") + message(STATUS "resolved_embedded_item='${${key}_RESOLVED_EMBEDDED_ITEM}'") + message(STATUS "copyflag='${${key}_COPYFLAG}'") + message(STATUS "") + endif() + + if("${${key}_COPYFLAG}" STREQUAL "2") + link_resolved_item_into_bundle("${${key}_RESOLVED_ITEM}" + "${${key}_RESOLVED_EMBEDDED_ITEM}") + elseif(${${key}_COPYFLAG}) + set(item "${${key}_ITEM}") + if(item MATCHES "[^/]+\\.framework/") + copy_resolved_framework_into_bundle("${${key}_RESOLVED_ITEM}" + "${${key}_RESOLVED_EMBEDDED_ITEM}") + else() + copy_resolved_item_into_bundle("${${key}_RESOLVED_ITEM}" + "${${key}_RESOLVED_EMBEDDED_ITEM}") + endif() + endif() + endforeach() + + message(STATUS "fixup_bundle: fixing...") + foreach(key ${keys}) + math(EXPR i ${i}+1) + if(APPLE) + message(STATUS "${i}/${n}: fixing up '${${key}_RESOLVED_EMBEDDED_ITEM}'") + if(NOT "${${key}_COPYFLAG}" STREQUAL "2") + fixup_bundle_item("${${key}_RESOLVED_EMBEDDED_ITEM}" "${exepath}" "${dirs}") + endif() + else() + message(STATUS "${i}/${n}: fix-up not required on this platform '${${key}_RESOLVED_EMBEDDED_ITEM}'") + endif() + endforeach() + + message(STATUS "fixup_bundle: cleaning up...") + clear_bundle_keys(keys) + + message(STATUS "fixup_bundle: verifying...") + verify_app("${app}" IGNORE_ITEM "${CFG_IGNORE_ITEM}") + else() + message(SEND_ERROR "error: fixup_bundle: not a valid bundle") + endif() + + message(STATUS "fixup_bundle: done") +endfunction() + + +function(copy_and_fixup_bundle src dst libs dirs) + execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory "${src}" "${dst}") + fixup_bundle("${dst}" "${libs}" "${dirs}") +endfunction() + + +function(verify_bundle_prerequisites bundle result_var info_var) + set(result 1) + set(info "") + set(count 0) + + set(options) + set(oneValueArgs) + set(multiValueArgs IGNORE_ITEM) + cmake_parse_arguments(CFG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} ) + + get_bundle_main_executable("${bundle}" main_bundle_exe) + + get_bundle_all_executables("${bundle}" file_list) + foreach(f ${file_list}) + get_filename_component(exepath "${f}" PATH) + math(EXPR count "${count} + 1") + + message(STATUS "executable file ${count}: ${f}") + + set(prereqs "") + get_filename_component(prereq_filename ${f} NAME) + + if(NOT prereq_filename IN_LIST CFG_IGNORE_ITEM) + get_item_rpaths(${f} _main_exe_rpaths) + get_prerequisites("${f}" prereqs 1 1 "${exepath}" "${_main_exe_rpaths}") + + # On the Mac, + # "embedded" and "system" prerequisites are fine... anything else means + # the bundle's prerequisites are not verified (i.e., the bundle is not + # really "standalone") + # + # On Windows (and others? Linux/Unix/...?) + # "local" and "system" prereqs are fine... + # + + set(external_prereqs "") + + foreach(p ${prereqs}) + set(p_type "") + gp_file_type("${f}" "${p}" p_type) + + if(APPLE) + if(NOT p_type STREQUAL "embedded" AND NOT p_type STREQUAL "system") + set(external_prereqs ${external_prereqs} "${p}") + endif() + else() + if(NOT p_type STREQUAL "local" AND NOT p_type STREQUAL "system") + set(external_prereqs ${external_prereqs} "${p}") + endif() + endif() + endforeach() + + if(external_prereqs) + # Found non-system/somehow-unacceptable prerequisites: + set(result 0) + set(info ${info} "external prerequisites found:\nf='${f}'\nexternal_prereqs='${external_prereqs}'\n") + endif() + else() + message(STATUS "Ignoring file: ${prereq_filename}") + endif() + endforeach() + + if(result) + set(info "Verified ${count} executable files in '${bundle}'") + endif() + + set(${result_var} "${result}" PARENT_SCOPE) + set(${info_var} "${info}" PARENT_SCOPE) +endfunction() + + +function(verify_bundle_symlinks bundle result_var info_var) + set(result 1) + set(info "") + set(count 0) + + # TODO: implement this function for real... + # Right now, it is just a stub that verifies unconditionally... + + set(${result_var} "${result}" PARENT_SCOPE) + set(${info_var} "${info}" PARENT_SCOPE) +endfunction() + + +function(verify_app app) + set(verified 0) + set(info "") + + set(options) + set(oneValueArgs) + set(multiValueArgs IGNORE_ITEM) + cmake_parse_arguments(CFG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} ) + + get_bundle_and_executable("${app}" bundle executable valid) + + message(STATUS "===========================================================================") + message(STATUS "Analyzing app='${app}'") + message(STATUS "bundle='${bundle}'") + message(STATUS "executable='${executable}'") + message(STATUS "valid='${valid}'") + + # Verify that the bundle does not have any "external" prerequisites: + # + verify_bundle_prerequisites("${bundle}" verified info IGNORE_ITEM "${CFG_IGNORE_ITEM}") + message(STATUS "verified='${verified}'") + message(STATUS "info='${info}'") + message(STATUS "") + + if(verified) + # Verify that the bundle does not have any symlinks to external files: + # + verify_bundle_symlinks("${bundle}" verified info) + message(STATUS "verified='${verified}'") + message(STATUS "info='${info}'") + message(STATUS "") + endif() + + if(NOT verified) + message(FATAL_ERROR "error: verify_app failed") + endif() +endfunction() + +cmake_policy(POP) diff --git a/cmake/share/cmake-3.31/Modules/CMake.cmake b/cmake/share/cmake-3.31/Modules/CMake.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4abd6b772bf418768424a3b21bd84328669884a1 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMake.cmake @@ -0,0 +1,7 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + + +# This file is used by cmake.cxx to compute the CMAKE_ROOT location. +# Do not remove this file from cvs without updating cmake.cxx to look +# for a different file. diff --git a/cmake/share/cmake-3.31/Modules/CMakeASM-ATTInformation.cmake b/cmake/share/cmake-3.31/Modules/CMakeASM-ATTInformation.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b8e6344912d812fb45834403984255860a163ba9 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeASM-ATTInformation.cmake @@ -0,0 +1,15 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + + +# support for AT&T syntax assemblers, e.g. GNU as + +set(ASM_DIALECT "-ATT") +# *.S files are supposed to be preprocessed, so they should not be passed to +# assembler but should be processed by gcc +set(CMAKE_ASM${ASM_DIALECT}_SOURCE_FILE_EXTENSIONS s;asm) + +set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OBJECT " -o ") + +include(CMakeASMInformation) +set(ASM_DIALECT) diff --git a/cmake/share/cmake-3.31/Modules/CMakeASMCompiler.cmake.in b/cmake/share/cmake-3.31/Modules/CMakeASMCompiler.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..1a0335f5cb844c81bb37b5f435cf51010d012a6e --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeASMCompiler.cmake.in @@ -0,0 +1,28 @@ +set(CMAKE_ASM@ASM_DIALECT@_COMPILER "@_CMAKE_ASM_COMPILER@") +set(CMAKE_ASM@ASM_DIALECT@_COMPILER_ARG1 "@_CMAKE_ASM_COMPILER_ARG1@") +set(CMAKE_AR "@CMAKE_AR@") +set(CMAKE_ASM@ASM_DIALECT@_COMPILER_AR "@_CMAKE_ASM_COMPILER_AR@") +set(CMAKE_RANLIB "@CMAKE_RANLIB@") +set(CMAKE_ASM@ASM_DIALECT@_COMPILER_RANLIB "@_CMAKE_ASM_COMPILER_RANLIB@") +set(CMAKE_LINKER "@CMAKE_LINKER@") +set(CMAKE_LINKER_LINK "@CMAKE_LINKER_LINK@") +set(CMAKE_LINKER_LLD "@CMAKE_LINKER_LLD@") +set(CMAKE_ASM@ASM_DIALECT@_COMPILER_LINKER "@CMAKE_ASM_COMPILER_LINKER@") +set(CMAKE_ASM@ASM_DIALECT@_COMPILER_LINKER_ID "@CMAKE_ASM_COMPILER_LINKER_ID@") +set(CMAKE_ASM@ASM_DIALECT@_COMPILER_LINKER_VERSION @CMAKE_ASM_COMPILER_LINKER_VERSION@) +set(CMAKE_ASM@ASM_DIALECT@_COMPILER_LINKER_FRONTEND_VARIANT @CMAKE_ASM_COMPILER_LINKER_FRONTEND_VARIANT@) +set(CMAKE_MT "@CMAKE_MT@") +set(CMAKE_TAPI "@CMAKE_TAPI@") +set(CMAKE_ASM@ASM_DIALECT@_COMPILER_LOADED 1) +set(CMAKE_ASM@ASM_DIALECT@_COMPILER_ID "@_CMAKE_ASM_COMPILER_ID@") +set(CMAKE_ASM@ASM_DIALECT@_COMPILER_VERSION "@_CMAKE_ASM_COMPILER_VERSION@") +set(CMAKE_ASM@ASM_DIALECT@_COMPILER_ENV_VAR "@_CMAKE_ASM_COMPILER_ENV_VAR@") +@_SET_CMAKE_ASM_COMPILER_ID_VENDOR_MATCH@ +@_SET_CMAKE_ASM_COMPILER_ARCHITECTURE_ID@ +@_SET_CMAKE_ASM_COMPILER_SYSROOT@ + +set(CMAKE_ASM@ASM_DIALECT@_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC) +set(CMAKE_ASM@ASM_DIALECT@_LINKER_PREFERENCE 0) +set(CMAKE_ASM@ASM_DIALECT@_LINKER_DEPFILE_SUPPORTED @CMAKE_ASM_LINKER_DEPFILE_SUPPORTED@) + +@CMAKE_ASM_COMPILER_CUSTOM_CODE@ diff --git a/cmake/share/cmake-3.31/Modules/CMakeASMInformation.cmake b/cmake/share/cmake-3.31/Modules/CMakeASMInformation.cmake new file mode 100644 index 0000000000000000000000000000000000000000..83138a6b74d5b48b3043b5c7fb4b575128fc22e5 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeASMInformation.cmake @@ -0,0 +1,101 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + + +if(UNIX) + set(CMAKE_ASM${ASM_DIALECT}_OUTPUT_EXTENSION .o) +else() + set(CMAKE_ASM${ASM_DIALECT}_OUTPUT_EXTENSION .obj) +endif() + +set(CMAKE_INCLUDE_FLAG_ASM${ASM_DIALECT} "-I") # -I +set(CMAKE_BASE_NAME) +get_filename_component(CMAKE_BASE_NAME "${CMAKE_ASM${ASM_DIALECT}_COMPILER}" NAME_WE) + +if("${CMAKE_BASE_NAME}" STREQUAL "as") + set(CMAKE_BASE_NAME gas) +endif() + +# Load compiler-specific information. +set(_INCLUDED_FILE "") +if(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID) + include(Compiler/${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}-ASM${ASM_DIALECT} OPTIONAL RESULT_VARIABLE _INCLUDED_FILE) +endif() +if(NOT _INCLUDED_FILE) + if("ASM${ASM_DIALECT}" STREQUAL "ASM") + message(STATUS "Warning: Did not find file Compiler/${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}-ASM${ASM_DIALECT}") + endif() + include(Platform/${CMAKE_BASE_NAME} OPTIONAL) +endif() + +if(CMAKE_SYSTEM_PROCESSOR) + include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}-ASM${ASM_DIALECT}-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL RESULT_VARIABLE _INCLUDED_FILE) + if(NOT _INCLUDED_FILE) + include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_BASE_NAME}-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL) + endif() +endif() + +include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}-ASM${ASM_DIALECT} OPTIONAL RESULT_VARIABLE _INCLUDED_FILE) +if(NOT _INCLUDED_FILE) + include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_BASE_NAME} OPTIONAL) +endif() + +# This should be included before the _INIT variables are +# used to initialize the cache. Since the rule variables +# have if blocks on them, users can still define them here. +# But, it should still be after the platform file so changes can +# be made to those values. + +if(CMAKE_USER_MAKE_RULES_OVERRIDE) + # Save the full path of the file so try_compile can use it. + include(${CMAKE_USER_MAKE_RULES_OVERRIDE} RESULT_VARIABLE _override) + set(CMAKE_USER_MAKE_RULES_OVERRIDE "${_override}") +endif() + +if(CMAKE_USER_MAKE_RULES_OVERRIDE_ASM) + # Save the full path of the file so try_compile can use it. + include(${CMAKE_USER_MAKE_RULES_OVERRIDE_ASM} RESULT_VARIABLE _override) + set(CMAKE_USER_MAKE_RULES_OVERRIDE_ASM "${_override}") +endif() + +# Set default assembler file extensions: +if(NOT CMAKE_ASM${ASM_DIALECT}_SOURCE_FILE_EXTENSIONS) + set(CMAKE_ASM${ASM_DIALECT}_SOURCE_FILE_EXTENSIONS s;S;asm) +endif() + + +# Support for CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT and friends: +set(CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT "$ENV{ASM${ASM_DIALECT}FLAGS} ${CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT}") + +cmake_initialize_per_config_variable(CMAKE_ASM${ASM_DIALECT}_FLAGS "Flags used by the ASM${ASM_DIALECT} compiler") + +if(NOT CMAKE_ASM${ASM_DIALECT}_COMPILE_OBJECT) + set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OBJECT " -o -c ") +endif() + +if(NOT CMAKE_ASM${ASM_DIALECT}_CREATE_STATIC_LIBRARY) + set(CMAKE_ASM${ASM_DIALECT}_CREATE_STATIC_LIBRARY + " cr " + " ") +endif() + +if(NOT CMAKE_ASM${ASM_DIALECT}_LINK_EXECUTABLE) + set(CMAKE_ASM${ASM_DIALECT}_LINK_EXECUTABLE + " -o ") +endif() + +if(NOT CMAKE_EXECUTABLE_RUNTIME_ASM${ASM_DIALECT}_FLAG) + set(CMAKE_EXECUTABLE_RUNTIME_ASM${ASM_DIALECT}_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_ASM${ASM_DIALECT}_FLAG}) +endif() + +if(NOT CMAKE_EXECUTABLE_RUNTIME_ASM${ASM_DIALECT}_FLAG_SEP) + set(CMAKE_EXECUTABLE_RUNTIME_ASM${ASM_DIALECT}_FLAG_SEP ${CMAKE_SHARED_LIBRARY_RUNTIME_ASM${ASM_DIALECT}_FLAG_SEP}) +endif() + +if(NOT CMAKE_EXECUTABLE_RPATH_LINK_ASM${ASM_DIALECT}_FLAG) + set(CMAKE_EXECUTABLE_RPATH_LINK_ASM${ASM_DIALECT}_FLAG ${CMAKE_SHARED_LIBRARY_RPATH_LINK_ASM${ASM_DIALECT}_FLAG}) +endif() + +set(CMAKE_ASM${ASM_DIALECT}_USE_LINKER_INFORMATION TRUE) + +set(CMAKE_ASM${ASM_DIALECT}_INFOMATION_LOADED 1) diff --git a/cmake/share/cmake-3.31/Modules/CMakeASM_MARMASMInformation.cmake b/cmake/share/cmake-3.31/Modules/CMakeASM_MARMASMInformation.cmake new file mode 100644 index 0000000000000000000000000000000000000000..90de14bacc63cb85379d19869bc5728a9842448d --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeASM_MARMASMInformation.cmake @@ -0,0 +1,25 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + + +# support for the MS ARM assembler, marmasm and marmasm64 + +set(ASM_DIALECT "_MARMASM") + +set(CMAKE_ASM${ASM_DIALECT}_SOURCE_FILE_EXTENSIONS asm) + +set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OBJECT " -o ") +set(CMAKE_ASM${ASM_DIALECT}_CREATE_STATIC_LIBRARY " /out: ") + +# The ASM_MARMASM compiler id for this compiler is "MSVC", so fill out the runtime library table. +set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreaded "") +set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDLL "") +set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebug "") +set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebugDLL "") + +set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_DEBUG_INFORMATION_FORMAT_Embedded "-g") +set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_DEBUG_INFORMATION_FORMAT_ProgramDatabase "") +set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_DEBUG_INFORMATION_FORMAT_EditAndContinue "") + +include(CMakeASMInformation) +set(ASM_DIALECT) diff --git a/cmake/share/cmake-3.31/Modules/CMakeASM_MASMInformation.cmake b/cmake/share/cmake-3.31/Modules/CMakeASM_MASMInformation.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ee6facf11930675f4efa6138cb1bf71eb73fc317 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeASM_MASMInformation.cmake @@ -0,0 +1,25 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + + +# support for the MS assembler, masm and masm64 + +set(ASM_DIALECT "_MASM") + +set(CMAKE_ASM${ASM_DIALECT}_SOURCE_FILE_EXTENSIONS asm) + +set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OBJECT " -c -Fo ") +set(CMAKE_ASM${ASM_DIALECT}_CREATE_STATIC_LIBRARY " /out: ") + +# The ASM_MASM compiler id for this compiler is "MSVC", so fill out the runtime library table. +set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreaded "") +set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDLL "") +set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebug "") +set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebugDLL "") + +set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_DEBUG_INFORMATION_FORMAT_Embedded "-Zi") +set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_DEBUG_INFORMATION_FORMAT_ProgramDatabase "") +set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_DEBUG_INFORMATION_FORMAT_EditAndContinue "") + +include(CMakeASMInformation) +set(ASM_DIALECT) diff --git a/cmake/share/cmake-3.31/Modules/CMakeASM_NASMInformation.cmake b/cmake/share/cmake-3.31/Modules/CMakeASM_NASMInformation.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3b4e3ae5f152106e2b6276995321304e61af93a5 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeASM_NASMInformation.cmake @@ -0,0 +1,66 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + + +# support for the nasm assembler + +set(CMAKE_ASM_NASM_SOURCE_FILE_EXTENSIONS nasm asm) + +if(NOT CMAKE_ASM_NASM_OBJECT_FORMAT) + if(WIN32) + if(DEFINED CMAKE_C_SIZEOF_DATA_PTR AND CMAKE_C_SIZEOF_DATA_PTR EQUAL 8) + set(CMAKE_ASM_NASM_OBJECT_FORMAT win64) + elseif(DEFINED CMAKE_CXX_SIZEOF_DATA_PTR AND CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 8) + set(CMAKE_ASM_NASM_OBJECT_FORMAT win64) + elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64") + set(CMAKE_ASM_NASM_OBJECT_FORMAT win64) + else() + set(CMAKE_ASM_NASM_OBJECT_FORMAT win32) + endif() + elseif(APPLE) + if(DEFINED CMAKE_C_SIZEOF_DATA_PTR AND CMAKE_C_SIZEOF_DATA_PTR EQUAL 8) + set(CMAKE_ASM_NASM_OBJECT_FORMAT macho64) + elseif(DEFINED CMAKE_CXX_SIZEOF_DATA_PTR AND CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 8) + set(CMAKE_ASM_NASM_OBJECT_FORMAT macho64) + elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64") + set(CMAKE_ASM_NASM_OBJECT_FORMAT macho64) + else() + set(CMAKE_ASM_NASM_OBJECT_FORMAT macho) + endif() + else() + if(DEFINED CMAKE_C_SIZEOF_DATA_PTR AND CMAKE_C_SIZEOF_DATA_PTR EQUAL 8) + set(CMAKE_ASM_NASM_OBJECT_FORMAT elf64) + elseif(DEFINED CMAKE_CXX_SIZEOF_DATA_PTR AND CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 8) + set(CMAKE_ASM_NASM_OBJECT_FORMAT elf64) + elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64") + set(CMAKE_ASM_NASM_OBJECT_FORMAT elf64) + else() + set(CMAKE_ASM_NASM_OBJECT_FORMAT elf) + endif() + endif() +endif() + +if(NOT CMAKE_ASM_NASM_COMPILE_OBJECT) + set(CMAKE_ASM_NASM_COMPILE_OBJECT " -f ${CMAKE_ASM_NASM_OBJECT_FORMAT} -o ") +endif() + +if(NOT CMAKE_ASM_NASM_LINK_EXECUTABLE) + set(CMAKE_ASM_NASM_LINK_EXECUTABLE + " -o ") +endif() + +if(CMAKE_ASM_NASM_COMPILER_ID STREQUAL "NASM") + set(CMAKE_DEPFILE_FLAGS_ASM_NASM "-MD -MT ") + + if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER) + AND CMAKE_GENERATOR MATCHES "Makefiles|WMake") + # dependencies are computed by the compiler itself + set(CMAKE_ASM_NASM_DEPFILE_FORMAT gcc) + set(CMAKE_ASM_NASM_DEPENDS_USE_COMPILER TRUE) + endif() +endif() + +# Load the generic ASMInformation file: +set(ASM_DIALECT "_NASM") +include(CMakeASMInformation) +set(ASM_DIALECT) diff --git a/cmake/share/cmake-3.31/Modules/CMakeAddFortranSubdirectory.cmake b/cmake/share/cmake-3.31/Modules/CMakeAddFortranSubdirectory.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b0a9342c272ac9087ccefea368312daf6d25944f --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeAddFortranSubdirectory.cmake @@ -0,0 +1,194 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#[=======================================================================[.rst: +CMakeAddFortranSubdirectory +--------------------------- + +Add a fortran-only subdirectory, find a fortran compiler, and build. + +The ``cmake_add_fortran_subdirectory`` function adds a subdirectory +to a project that contains a fortran-only subproject. The module will +check the current compiler and see if it can support fortran. If no +fortran compiler is found and the compiler is MSVC, then this module +will find the MinGW gfortran. It will then use an external project to +build with the MinGW tools. It will also create imported targets for +the libraries created. This will only work if the fortran code is +built into a dll, so :variable:`BUILD_SHARED_LIBS` is turned on in +the project. In addition the :variable:`CMAKE_GNUtoMS` option is set +to on, so that Microsoft ``.lib`` files are created. Usage is as follows: + +:: + + cmake_add_fortran_subdirectory( + # name of subdirectory + PROJECT # project name in subdir top CMakeLists.txt + ARCHIVE_DIR # dir where project places .lib files + RUNTIME_DIR # dir where project places .dll files + LIBRARIES ... # names of library targets to import + LINK_LIBRARIES # link interface libraries for LIBRARIES + [LINK_LIBS ...]... + CMAKE_COMMAND_LINE ... # extra command line flags to pass to cmake + NO_EXTERNAL_INSTALL # skip installation of external project + ) + +Relative paths in ``ARCHIVE_DIR`` and ``RUNTIME_DIR`` are interpreted with +respect to the build directory corresponding to the source directory +in which the function is invoked. + +Limitations: + +``NO_EXTERNAL_INSTALL`` is required for forward compatibility with a +future version that supports installation of the external project +binaries during ``make install``. +#]=======================================================================] + +include(CheckLanguage) +include(ExternalProject) + +function(_setup_mingw_config_and_build source_dir build_dir) + # Look for a MinGW gfortran. + find_program(MINGW_GFORTRAN + NAMES gfortran + PATHS + c:/MinGW/bin + "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\MinGW;InstallLocation]/bin" + ) + if(NOT MINGW_GFORTRAN) + message(FATAL_ERROR + "gfortran not found, please install MinGW with the gfortran option." + "Or set the cache variable MINGW_GFORTRAN to the full path. " + " This is required to build") + endif() + + # Validate the MinGW gfortran we found. + if(CMAKE_SIZEOF_VOID_P EQUAL 8) + set(_mingw_target "Target:.*64.*mingw") + else() + set(_mingw_target "Target:.*mingw32") + endif() + execute_process(COMMAND "${MINGW_GFORTRAN}" -v + ERROR_VARIABLE out ERROR_STRIP_TRAILING_WHITESPACE) + if(NOT "${out}" MATCHES "${_mingw_target}") + string(REPLACE "\n" "\n " out " ${out}") + message(FATAL_ERROR + "MINGW_GFORTRAN is set to\n" + " ${MINGW_GFORTRAN}\n" + "which is not a MinGW gfortran for this architecture. " + "The output from -v does not match \"${_mingw_target}\":\n" + "${out}\n" + "Set MINGW_GFORTRAN to a proper MinGW gfortran for this architecture." + ) + endif() + + # Configure scripts to run MinGW tools with the proper PATH. + get_filename_component(MINGW_PATH ${MINGW_GFORTRAN} PATH) + file(TO_NATIVE_PATH "${MINGW_PATH}" MINGW_PATH) + string(REPLACE "\\" "\\\\" MINGW_PATH "${MINGW_PATH}") + configure_file( + ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/CMakeAddFortranSubdirectory/config_mingw.cmake.in + ${build_dir}/config_mingw.cmake + @ONLY) + configure_file( + ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/CMakeAddFortranSubdirectory/build_mingw.cmake.in + ${build_dir}/build_mingw.cmake + @ONLY) +endfunction() + +function(_add_fortran_library_link_interface library depend_library) + set_target_properties(${library} PROPERTIES + IMPORTED_LINK_INTERFACE_LIBRARIES_NOCONFIG "${depend_library}") +endfunction() + + +function(cmake_add_fortran_subdirectory subdir) + # Parse arguments to function + set(options NO_EXTERNAL_INSTALL) + set(oneValueArgs PROJECT ARCHIVE_DIR RUNTIME_DIR) + set(multiValueArgs LIBRARIES LINK_LIBRARIES CMAKE_COMMAND_LINE) + cmake_parse_arguments(ARGS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + if(NOT ARGS_NO_EXTERNAL_INSTALL) + message(FATAL_ERROR + "Option NO_EXTERNAL_INSTALL is required (for forward compatibility) " + "but was not given." + ) + endif() + + # if we are not using MSVC without fortran support + # then just use the usual add_subdirectory to build + # the fortran library + check_language(Fortran) + if(NOT (MSVC AND (NOT CMAKE_Fortran_COMPILER))) + add_subdirectory(${subdir}) + return() + endif() + + # if we have MSVC without Intel fortran then setup + # external projects to build with mingw fortran + + set(source_dir "${CMAKE_CURRENT_SOURCE_DIR}/${subdir}") + set(project_name "${ARGS_PROJECT}") + set(library_dir "${ARGS_ARCHIVE_DIR}") + set(binary_dir "${ARGS_RUNTIME_DIR}") + set(libraries ${ARGS_LIBRARIES}) + # use the same directory that add_subdirectory would have used + set(build_dir "${CMAKE_CURRENT_BINARY_DIR}/${subdir}") + foreach(dir_var library_dir binary_dir) + if(NOT IS_ABSOLUTE "${${dir_var}}") + get_filename_component(${dir_var} + "${CMAKE_CURRENT_BINARY_DIR}/${${dir_var}}" ABSOLUTE) + endif() + endforeach() + # create build and configure wrapper scripts + _setup_mingw_config_and_build("${source_dir}" "${build_dir}") + # create the external project + externalproject_add(${project_name}_build + SOURCE_DIR ${source_dir} + BINARY_DIR ${build_dir} + CONFIGURE_COMMAND ${CMAKE_COMMAND} + -P ${build_dir}/config_mingw.cmake + BUILD_COMMAND ${CMAKE_COMMAND} + -P ${build_dir}/build_mingw.cmake + BUILD_ALWAYS 1 + INSTALL_COMMAND "" + ) + # create imported targets for all libraries + foreach(lib ${libraries}) + add_library(${lib} SHARED IMPORTED GLOBAL) + set_property(TARGET ${lib} APPEND PROPERTY IMPORTED_CONFIGURATIONS NOCONFIG) + set_target_properties(${lib} PROPERTIES + IMPORTED_IMPLIB_NOCONFIG "${library_dir}/lib${lib}.lib" + IMPORTED_LOCATION_NOCONFIG "${binary_dir}/lib${lib}.dll" + ) + add_dependencies(${lib} ${project_name}_build) + endforeach() + + # now setup link libraries for targets + set(start FALSE) + set(target) + foreach(lib ${ARGS_LINK_LIBRARIES}) + if("${lib}" STREQUAL "LINK_LIBS") + set(start TRUE) + else() + if(start) + if(DEFINED target) + # process current target and target_libs + _add_fortran_library_link_interface(${target} "${target_libs}") + # zero out target and target_libs + set(target) + set(target_libs) + endif() + # save the current target and set start to FALSE + set(target ${lib}) + set(start FALSE) + else() + # append the lib to target_libs + list(APPEND target_libs "${lib}") + endif() + endif() + endforeach() + # process anything that is left in target and target_libs + if(DEFINED target) + _add_fortran_library_link_interface(${target} "${target_libs}") + endif() +endfunction() diff --git a/cmake/share/cmake-3.31/Modules/CMakeAddFortranSubdirectory/build_mingw.cmake.in b/cmake/share/cmake-3.31/Modules/CMakeAddFortranSubdirectory/build_mingw.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..96e3824cf1ef512691ac2abd7d34bcb81b1cb010 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeAddFortranSubdirectory/build_mingw.cmake.in @@ -0,0 +1,2 @@ +set(ENV{PATH} "@MINGW_PATH@\;$ENV{PATH}") +execute_process(COMMAND "@CMAKE_COMMAND@" --build . ) diff --git a/cmake/share/cmake-3.31/Modules/CMakeAddFortranSubdirectory/config_mingw.cmake.in b/cmake/share/cmake-3.31/Modules/CMakeAddFortranSubdirectory/config_mingw.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..285d9a8d70a1360cf3c7eb0244652e669c1efecc --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeAddFortranSubdirectory/config_mingw.cmake.in @@ -0,0 +1,9 @@ +set(ENV{PATH} "@MINGW_PATH@\;$ENV{PATH}") +set(CMAKE_COMMAND_LINE "@ARGS_CMAKE_COMMAND_LINE@") +execute_process( + COMMAND "@CMAKE_COMMAND@" "-GMinGW Makefiles" + -DCMAKE_Fortran_COMPILER:PATH=@MINGW_GFORTRAN@ + -DBUILD_SHARED_LIBS=ON + -DCMAKE_GNUtoMS=ON + ${CMAKE_COMMAND_LINE} + "@source_dir@") diff --git a/cmake/share/cmake-3.31/Modules/CMakeAddNewLanguage.txt b/cmake/share/cmake-3.31/Modules/CMakeAddNewLanguage.txt new file mode 100644 index 0000000000000000000000000000000000000000..8ac5f7ed5cac9d822e68a58bd248c34e304bad0e --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeAddNewLanguage.txt @@ -0,0 +1,39 @@ +This file provides a few notes to CMake developers about how to add +support for a new language to CMake. It is also possible to place +these files in :variable:`CMAKE_MODULE_PATH` within an outside project +to add languages not supported by upstream CMake. However, this is not +a fully supported use case. + +The implementation behind the scenes of project/enable_language, +including the compiler/platform modules, is an *internal* API that +does not make any compatibility guarantees. It is not covered in the +official reference documentation that is versioned with the source code. +Maintainers of external language support are responsible for porting +it to each version of CMake as upstream changes are made. Since +the API is internal we will not necessarily include notice of any +changes in release notes. + + +CMakeDetermine(LANG)Compiler.cmake -> this should find the compiler for LANG and configure CMake(LANG)Compiler.cmake.in + +CMake(LANG)Compiler.cmake.in -> used by CMakeDetermine(LANG)Compiler.cmake + This file is used to store compiler information and is copied down into try + compile directories so that try compiles do not need to re-determine and test the LANG + +CMake(LANG)Information.cmake => set compiler configuration: + CMAKE_(LANG)_CREATE_SHARED_LIBRARY + CMAKE_(LANG)_CREATE_SHARED_MODULE + CMAKE_(LANG)_CREATE_STATIC_LIBRARY + CMAKE_(LANG)_COMPILE_OBJECT + CMAKE_(LANG)_LINK_EXECUTABLE + + CMAKE_(LANG)_USE_LINKER_INFORMATION + +CMakeTest(LANG)Compiler.cmake -> test the compiler and set: + SET(CMAKE_(LANG)_COMPILER_WORKS 1 CACHE INTERNAL "") + + +If the variable CMAKE_(LANG)_USE_LINKER_INFORMATION has value TRUE, the file CMake(LANG)LinkerInformation.cmake +should be defined. + +CMake(LANG)LinkerInformation.cmake -> set up linker configuration for LANG. diff --git a/cmake/share/cmake-3.31/Modules/CMakeBackwardCompatibilityC.cmake b/cmake/share/cmake-3.31/Modules/CMakeBackwardCompatibilityC.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d1b74167a8463f9ba733a4d05fb7f636c3071ca8 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeBackwardCompatibilityC.cmake @@ -0,0 +1,76 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + + +if(NOT CMAKE_SKIP_COMPATIBILITY_TESTS) + # Old CMake versions did not support OS X universal binaries anyway, + # so just get through this with at least some size for the types. + list(LENGTH CMAKE_OSX_ARCHITECTURES NUM_ARCHS) + if(${NUM_ARCHS} GREATER 1) + if(NOT DEFINED CMAKE_TRY_COMPILE_OSX_ARCHITECTURES) + message(WARNING "This module does not work with OS X universal binaries.") + set(__ERASE_CMAKE_TRY_COMPILE_OSX_ARCHITECTURES 1) + list(GET CMAKE_OSX_ARCHITECTURES 0 CMAKE_TRY_COMPILE_OSX_ARCHITECTURES) + endif() + endif() + + include (CheckTypeSize) + CHECK_TYPE_SIZE(int CMAKE_SIZEOF_INT) + CHECK_TYPE_SIZE(long CMAKE_SIZEOF_LONG) + CHECK_TYPE_SIZE("void*" CMAKE_SIZEOF_VOID_P) + CHECK_TYPE_SIZE(char CMAKE_SIZEOF_CHAR) + CHECK_TYPE_SIZE(short CMAKE_SIZEOF_SHORT) + CHECK_TYPE_SIZE(float CMAKE_SIZEOF_FLOAT) + CHECK_TYPE_SIZE(double CMAKE_SIZEOF_DOUBLE) + + include (CheckIncludeFile) + CHECK_INCLUDE_FILE("limits.h" CMAKE_HAVE_LIMITS_H) + CHECK_INCLUDE_FILE("unistd.h" CMAKE_HAVE_UNISTD_H) + CHECK_INCLUDE_FILE("pthread.h" CMAKE_HAVE_PTHREAD_H) + + include (CheckIncludeFiles) + CHECK_INCLUDE_FILES("sys/types.h;sys/prctl.h" CMAKE_HAVE_SYS_PRCTL_H) + + include (TestBigEndian) + TEST_BIG_ENDIAN(CMAKE_WORDS_BIGENDIAN) + include (FindX11) + + if("${X11_X11_INCLUDE_PATH}" STREQUAL "/usr/include") + set (CMAKE_X_CFLAGS "" CACHE STRING "X11 extra flags.") + else() + set (CMAKE_X_CFLAGS "-I${X11_X11_INCLUDE_PATH}" CACHE STRING + "X11 extra flags.") + endif() + set (CMAKE_X_LIBS "${X11_LIBRARIES}" CACHE STRING + "Libraries and options used in X11 programs.") + set (CMAKE_HAS_X "${X11_FOUND}" CACHE INTERNAL "Is X11 around.") + + include (FindThreads) + + set (CMAKE_THREAD_LIBS "${CMAKE_THREAD_LIBS_INIT}" CACHE STRING + "Thread library used.") + + set (CMAKE_USE_PTHREADS "${CMAKE_USE_PTHREADS_INIT}" CACHE BOOL + "Use the pthreads library.") + + set (CMAKE_USE_WIN32_THREADS "${CMAKE_USE_WIN32_THREADS_INIT}" CACHE BOOL + "Use the win32 thread library.") + + set (CMAKE_HP_PTHREADS ${CMAKE_HP_PTHREADS_INIT} CACHE BOOL + "Use HP pthreads.") + + if(__ERASE_CMAKE_TRY_COMPILE_OSX_ARCHITECTURES) + set(CMAKE_TRY_COMPILE_OSX_ARCHITECTURES) + set(__ERASE_CMAKE_TRY_COMPILE_OSX_ARCHITECTURES) + endif() +endif() + +mark_as_advanced( +CMAKE_HP_PTHREADS +CMAKE_THREAD_LIBS +CMAKE_USE_PTHREADS +CMAKE_USE_WIN32_THREADS +CMAKE_X_CFLAGS +CMAKE_X_LIBS +) + diff --git a/cmake/share/cmake-3.31/Modules/CMakeBackwardCompatibilityCXX.cmake b/cmake/share/cmake-3.31/Modules/CMakeBackwardCompatibilityCXX.cmake new file mode 100644 index 0000000000000000000000000000000000000000..325ac0b65807bd9a36f18f79b2b058b97540886c --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeBackwardCompatibilityCXX.cmake @@ -0,0 +1,49 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#[=======================================================================[.rst: +CMakeBackwardCompatibilityCXX +----------------------------- + +define a bunch of backwards compatibility variables + +:: + + CMAKE_ANSI_CXXFLAGS - flag for ansi c++ + CMAKE_HAS_ANSI_STRING_STREAM - has + include(TestForANSIStreamHeaders) + include(CheckIncludeFileCXX) + include(TestForSTDNamespace) + include(TestForANSIForScope) +#]=======================================================================] + +if(NOT CMAKE_SKIP_COMPATIBILITY_TESTS) + # check for some ANSI flags in the CXX compiler if it is not gnu + if(NOT CMAKE_COMPILER_IS_GNUCXX) + include(TestCXXAcceptsFlag) + set(CMAKE_TRY_ANSI_CXX_FLAGS "") + if(CMAKE_SYSTEM_NAME MATCHES "OSF") + set(CMAKE_TRY_ANSI_CXX_FLAGS "-std strict_ansi -nopure_cname") + endif() + # if CMAKE_TRY_ANSI_CXX_FLAGS has something in it, see + # if the compiler accepts it + if(NOT CMAKE_TRY_ANSI_CXX_FLAGS STREQUAL "") + CHECK_CXX_ACCEPTS_FLAG(${CMAKE_TRY_ANSI_CXX_FLAGS} CMAKE_CXX_ACCEPTS_FLAGS) + # if the compiler liked the flag then set CMAKE_ANSI_CXXFLAGS + # to the flag + if(CMAKE_CXX_ACCEPTS_FLAGS) + set(CMAKE_ANSI_CXXFLAGS ${CMAKE_TRY_ANSI_CXX_FLAGS} CACHE INTERNAL + "What flags are required by the c++ compiler to make it ansi." ) + endif() + endif() + endif() + set(CMAKE_CXX_FLAGS_SAVE ${CMAKE_CXX_FLAGS}) + string(APPEND CMAKE_CXX_FLAGS " ${CMAKE_ANSI_CXXFLAGS}") + include(TestForANSIStreamHeaders) + include(CheckIncludeFileCXX) + include(TestForSTDNamespace) + include(TestForANSIForScope) + include(TestForSSTREAM) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_SAVE}") +endif() + diff --git a/cmake/share/cmake-3.31/Modules/CMakeBorlandFindMake.cmake b/cmake/share/cmake-3.31/Modules/CMakeBorlandFindMake.cmake new file mode 100644 index 0000000000000000000000000000000000000000..294d84e7f4f8712279da18eaaf455f19f79c8c02 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeBorlandFindMake.cmake @@ -0,0 +1,7 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + + +set (CMAKE_MAKE_PROGRAM "make" CACHE STRING + "Program used to build from makefiles.") +mark_as_advanced(CMAKE_MAKE_PROGRAM) diff --git a/cmake/share/cmake-3.31/Modules/CMakeBuildSettings.cmake.in b/cmake/share/cmake-3.31/Modules/CMakeBuildSettings.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..5b29086df2df5dfc9b83f400e7942677a5b7218e --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeBuildSettings.cmake.in @@ -0,0 +1,13 @@ + +# The command CMAKE_EXPORT_BUILD_SETTINGS(...) was used by +# @PROJECT_NAME@ to generate this file. As of CMake 2.8 the +# functionality of this command has been dropped as it was deemed +# harmful (confusing users by changing their compiler). + +# CMake 2.6 and below do not support loading their equivalent of this +# file if it was produced by a newer version of CMake. CMake 2.8 and +# above simply do not load this file. Therefore we simply error out. +message(FATAL_ERROR + "This @PROJECT_NAME@ was built by CMake @CMAKE_VERSION@, but this is CMake " + "${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION}. " + "Please upgrade CMake to a more recent version.") diff --git a/cmake/share/cmake-3.31/Modules/CMakeCCompiler.cmake.in b/cmake/share/cmake-3.31/Modules/CMakeCCompiler.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..0f2f0e16149c916d8e439c37412c1ca230e1a828 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCCompiler.cmake.in @@ -0,0 +1,81 @@ +set(CMAKE_C_COMPILER "@CMAKE_C_COMPILER@") +set(CMAKE_C_COMPILER_ARG1 "@CMAKE_C_COMPILER_ARG1@") +set(CMAKE_C_COMPILER_ID "@CMAKE_C_COMPILER_ID@") +set(CMAKE_C_COMPILER_VERSION "@CMAKE_C_COMPILER_VERSION@") +set(CMAKE_C_COMPILER_VERSION_INTERNAL "@CMAKE_C_COMPILER_VERSION_INTERNAL@") +set(CMAKE_C_COMPILER_WRAPPER "@CMAKE_C_COMPILER_WRAPPER@") +set(CMAKE_C_STANDARD_COMPUTED_DEFAULT "@CMAKE_C_STANDARD_COMPUTED_DEFAULT@") +set(CMAKE_C_EXTENSIONS_COMPUTED_DEFAULT "@CMAKE_C_EXTENSIONS_COMPUTED_DEFAULT@") +set(CMAKE_C_STANDARD_LATEST "@CMAKE_C_STANDARD_LATEST@") +set(CMAKE_C_COMPILE_FEATURES "@CMAKE_C_COMPILE_FEATURES@") +set(CMAKE_C90_COMPILE_FEATURES "@CMAKE_C90_COMPILE_FEATURES@") +set(CMAKE_C99_COMPILE_FEATURES "@CMAKE_C99_COMPILE_FEATURES@") +set(CMAKE_C11_COMPILE_FEATURES "@CMAKE_C11_COMPILE_FEATURES@") +set(CMAKE_C17_COMPILE_FEATURES "@CMAKE_C17_COMPILE_FEATURES@") +set(CMAKE_C23_COMPILE_FEATURES "@CMAKE_C23_COMPILE_FEATURES@") + +set(CMAKE_C_PLATFORM_ID "@CMAKE_C_PLATFORM_ID@") +set(CMAKE_C_SIMULATE_ID "@CMAKE_C_SIMULATE_ID@") +set(CMAKE_C_COMPILER_FRONTEND_VARIANT "@CMAKE_C_COMPILER_FRONTEND_VARIANT@") +set(CMAKE_C_SIMULATE_VERSION "@CMAKE_C_SIMULATE_VERSION@") +@_SET_CMAKE_C_COMPILER_ARCHITECTURE_ID@ +@_SET_CMAKE_C_COMPILER_SYSROOT@ +@SET_MSVC_C_ARCHITECTURE_ID@ +@SET_CMAKE_XCODE_ARCHS@ +set(CMAKE_AR "@CMAKE_AR@") +set(CMAKE_C_COMPILER_AR "@CMAKE_C_COMPILER_AR@") +set(CMAKE_RANLIB "@CMAKE_RANLIB@") +set(CMAKE_C_COMPILER_RANLIB "@CMAKE_C_COMPILER_RANLIB@") +set(CMAKE_LINKER "@CMAKE_LINKER@") +set(CMAKE_LINKER_LINK "@CMAKE_LINKER_LINK@") +set(CMAKE_LINKER_LLD "@CMAKE_LINKER_LLD@") +set(CMAKE_C_COMPILER_LINKER "@CMAKE_C_COMPILER_LINKER@") +set(CMAKE_C_COMPILER_LINKER_ID "@CMAKE_C_COMPILER_LINKER_ID@") +set(CMAKE_C_COMPILER_LINKER_VERSION @CMAKE_C_COMPILER_LINKER_VERSION@) +set(CMAKE_C_COMPILER_LINKER_FRONTEND_VARIANT @CMAKE_C_COMPILER_LINKER_FRONTEND_VARIANT@) +set(CMAKE_MT "@CMAKE_MT@") +set(CMAKE_TAPI "@CMAKE_TAPI@") +set(CMAKE_COMPILER_IS_GNUCC @CMAKE_COMPILER_IS_GNUCC@) +set(CMAKE_C_COMPILER_LOADED 1) +set(CMAKE_C_COMPILER_WORKS @CMAKE_C_COMPILER_WORKS@) +set(CMAKE_C_ABI_COMPILED @CMAKE_C_ABI_COMPILED@) + +set(CMAKE_C_COMPILER_ENV_VAR "CC") + +set(CMAKE_C_COMPILER_ID_RUN 1) +set(CMAKE_C_SOURCE_FILE_EXTENSIONS c;m) +set(CMAKE_C_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC) +set(CMAKE_C_LINKER_PREFERENCE 10) +set(CMAKE_C_LINKER_DEPFILE_SUPPORTED @CMAKE_C_LINKER_DEPFILE_SUPPORTED@) + +# Save compiler ABI information. +set(CMAKE_C_SIZEOF_DATA_PTR "@CMAKE_C_SIZEOF_DATA_PTR@") +set(CMAKE_C_COMPILER_ABI "@CMAKE_C_COMPILER_ABI@") +set(CMAKE_C_BYTE_ORDER "@CMAKE_C_BYTE_ORDER@") +set(CMAKE_C_LIBRARY_ARCHITECTURE "@CMAKE_C_LIBRARY_ARCHITECTURE@") + +if(CMAKE_C_SIZEOF_DATA_PTR) + set(CMAKE_SIZEOF_VOID_P "${CMAKE_C_SIZEOF_DATA_PTR}") +endif() + +if(CMAKE_C_COMPILER_ABI) + set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_C_COMPILER_ABI}") +endif() + +if(CMAKE_C_LIBRARY_ARCHITECTURE) + set(CMAKE_LIBRARY_ARCHITECTURE "@CMAKE_C_LIBRARY_ARCHITECTURE@") +endif() + +set(CMAKE_C_CL_SHOWINCLUDES_PREFIX "@CMAKE_C_CL_SHOWINCLUDES_PREFIX@") +if(CMAKE_C_CL_SHOWINCLUDES_PREFIX) + set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_C_CL_SHOWINCLUDES_PREFIX}") +endif() + +@CMAKE_C_COMPILER_CUSTOM_CODE@ +@CMAKE_C_SYSROOT_FLAG_CODE@ +@CMAKE_C_OSX_DEPLOYMENT_TARGET_FLAG_CODE@ + +set(CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES "@CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES@") +set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "@CMAKE_C_IMPLICIT_LINK_LIBRARIES@") +set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "@CMAKE_C_IMPLICIT_LINK_DIRECTORIES@") +set(CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "@CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES@") diff --git a/cmake/share/cmake-3.31/Modules/CMakeCCompilerABI.c b/cmake/share/cmake-3.31/Modules/CMakeCCompilerABI.c new file mode 100644 index 0000000000000000000000000000000000000000..4dafa0eea2bd45ddbe275591ed8f6bfc7308ab1a --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCCompilerABI.c @@ -0,0 +1,28 @@ +#ifdef __cplusplus +# error "A C++ compiler has been selected for C." +#endif + +#ifdef __CLASSIC_C__ +# define const +#endif + +#include "CMakeCompilerABI.h" + +#ifdef __CLASSIC_C__ +int main(argc, argv) +int argc; +char* argv[]; +#else +int main(int argc, char* argv[]) +#endif +{ + int require = 0; + require += info_sizeof_dptr[argc]; + require += info_byte_order_big_endian[argc]; + require += info_byte_order_little_endian[argc]; +#if defined(ABI_ID) + require += info_abi[argc]; +#endif + (void)argv; + return require; +} diff --git a/cmake/share/cmake-3.31/Modules/CMakeCCompilerId.c.in b/cmake/share/cmake-3.31/Modules/CMakeCCompilerId.c.in new file mode 100644 index 0000000000000000000000000000000000000000..7bc11553136867d57d0db89c125f724599b0597a --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCCompilerId.c.in @@ -0,0 +1,116 @@ +#ifdef __cplusplus +# error "A C++ compiler has been selected for C." +#endif + +#if defined(__18CXX) +# define ID_VOID_MAIN +#endif +#if defined(__CLASSIC_C__) +/* cv-qualifiers did not exist in K&R C */ +# define const +# define volatile +#endif + +#if !defined(__has_include) +/* If the compiler does not have __has_include, pretend the answer is + always no. */ +# define __has_include(x) 0 +#endif + +@CMAKE_C_COMPILER_ID_CONTENT@ + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#ifdef __QNXNTO__ +char const* qnxnto = "INFO" ":" "qnxnto[]"; +#endif + +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) +char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]"; +#endif + +@CMAKE_C_COMPILER_ID_PLATFORM_CONTENT@ +@CMAKE_C_COMPILER_ID_ERROR_FOR_TEST@ + +#define C_STD_99 199901L +#define C_STD_11 201112L +#define C_STD_17 201710L +#define C_STD_23 202311L + +#ifdef __STDC_VERSION__ +# define C_STD __STDC_VERSION__ +#endif + +#if !defined(__STDC__) && !defined(__clang__) +# if defined(_MSC_VER) || defined(__ibmxl__) || defined(__IBMC__) +# define C_VERSION "90" +# else +# define C_VERSION +# endif +#elif C_STD > C_STD_17 +# define C_VERSION "23" +#elif C_STD > C_STD_11 +# define C_VERSION "17" +#elif C_STD > C_STD_99 +# define C_VERSION "11" +#elif C_STD >= C_STD_99 +# define C_VERSION "99" +#else +# define C_VERSION "90" +#endif +const char* info_language_standard_default = + "INFO" ":" "standard_default[" C_VERSION "]"; + +const char* info_language_extensions_default = "INFO" ":" "extensions_default[" +#if (defined(__clang__) || defined(__GNUC__) || defined(__xlC__) || \ + defined(__TI_COMPILER_VERSION__)) && \ + !defined(__STRICT_ANSI__) + "ON" +#else + "OFF" +#endif +"]"; + +/*--------------------------------------------------------------------------*/ + +#ifdef ID_VOID_MAIN +void main() {} +#else +# if defined(__CLASSIC_C__) +int main(argc, argv) int argc; char *argv[]; +# else +int main(int argc, char* argv[]) +# endif +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; + require += info_arch[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#ifdef COMPILER_VERSION_INTERNAL + require += info_version_internal[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) + require += info_cray[argc]; +#endif + require += info_language_standard_default[argc]; + require += info_language_extensions_default[argc]; + (void)argv; + return require; +} +#endif diff --git a/cmake/share/cmake-3.31/Modules/CMakeCInformation.cmake b/cmake/share/cmake-3.31/Modules/CMakeCInformation.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a3f9cf7cd53b556a45a32bdd9142fdaa5cc39ad8 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCInformation.cmake @@ -0,0 +1,180 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + + +# This file sets the basic flags for the C language in CMake. +# It also loads the available platform file for the system-compiler +# if it exists. +# It also loads a system - compiler - processor (or target hardware) +# specific file, which is mainly useful for crosscompiling and embedded systems. + +include(CMakeLanguageInformation) + +# some compilers use different extensions (e.g. sdcc uses .rel) +# so set the extension here first so it can be overridden by the compiler specific file +if(UNIX) + set(CMAKE_C_OUTPUT_EXTENSION .o) +else() + set(CMAKE_C_OUTPUT_EXTENSION .obj) +endif() + +set(_INCLUDED_FILE 0) + +# Load compiler-specific information. +if(CMAKE_C_COMPILER_ID) + include(Compiler/${CMAKE_C_COMPILER_ID}-C OPTIONAL) +endif() + +set(CMAKE_BASE_NAME) +get_filename_component(CMAKE_BASE_NAME "${CMAKE_C_COMPILER}" NAME_WE) +if(CMAKE_COMPILER_IS_GNUCC) + set(CMAKE_BASE_NAME gcc) +endif() + + +# load a hardware specific file, mostly useful for embedded compilers +if(CMAKE_SYSTEM_PROCESSOR) + if(CMAKE_C_COMPILER_ID) + include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_C_COMPILER_ID}-C-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL RESULT_VARIABLE _INCLUDED_FILE) + endif() + if (NOT _INCLUDED_FILE) + include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_BASE_NAME}-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL) + endif () +endif() + + +# load the system- and compiler specific files +if(CMAKE_C_COMPILER_ID) + include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_C_COMPILER_ID}-C + OPTIONAL RESULT_VARIABLE _INCLUDED_FILE) +endif() +if (NOT _INCLUDED_FILE) + include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_BASE_NAME} + OPTIONAL RESULT_VARIABLE _INCLUDED_FILE) +endif () + +# load any compiler-wrapper specific information +if (CMAKE_C_COMPILER_WRAPPER) + __cmake_include_compiler_wrapper(C) +endif () + +# We specify the compiler information in the system file for some +# platforms, but this language may not have been enabled when the file +# was first included. Include it again to get the language info. +# Remove this when all compiler info is removed from system files. +if (NOT _INCLUDED_FILE) + include(Platform/${CMAKE_SYSTEM_NAME} OPTIONAL) +endif () + +if(CMAKE_C_SIZEOF_DATA_PTR) + foreach(f IN LISTS CMAKE_C_ABI_FILES) + include(${f}) + endforeach() + unset(CMAKE_C_ABI_FILES) +endif() + +# This should be included before the _INIT variables are +# used to initialize the cache. Since the rule variables +# have if blocks on them, users can still define them here. +# But, it should still be after the platform file so changes can +# be made to those values. + +if(CMAKE_USER_MAKE_RULES_OVERRIDE) + # Save the full path of the file so try_compile can use it. + include(${CMAKE_USER_MAKE_RULES_OVERRIDE} RESULT_VARIABLE _override) + set(CMAKE_USER_MAKE_RULES_OVERRIDE "${_override}") +endif() + +if(CMAKE_USER_MAKE_RULES_OVERRIDE_C) + # Save the full path of the file so try_compile can use it. + include(${CMAKE_USER_MAKE_RULES_OVERRIDE_C} RESULT_VARIABLE _override) + set(CMAKE_USER_MAKE_RULES_OVERRIDE_C "${_override}") +endif() + +set(CMAKE_C_FLAGS_INIT "$ENV{CFLAGS} ${CMAKE_C_FLAGS_INIT}") + +cmake_initialize_per_config_variable(CMAKE_C_FLAGS "Flags used by the C compiler") + +if(CMAKE_C_STANDARD_LIBRARIES_INIT) + set(CMAKE_C_STANDARD_LIBRARIES "${CMAKE_C_STANDARD_LIBRARIES_INIT}" + CACHE STRING "Libraries linked by default with all C applications.") + mark_as_advanced(CMAKE_C_STANDARD_LIBRARIES) +endif() + +if(NOT CMAKE_C_COMPILER_LAUNCHER AND DEFINED ENV{CMAKE_C_COMPILER_LAUNCHER}) + set(CMAKE_C_COMPILER_LAUNCHER "$ENV{CMAKE_C_COMPILER_LAUNCHER}" + CACHE STRING "Compiler launcher for C.") +endif() + +if(NOT CMAKE_C_LINKER_LAUNCHER AND DEFINED ENV{CMAKE_C_LINKER_LAUNCHER}) + set(CMAKE_C_LINKER_LAUNCHER "$ENV{CMAKE_C_LINKER_LAUNCHER}" + CACHE STRING "Linker launcher for C.") +endif() + +include(CMakeCommonLanguageInclude) +_cmake_common_language_platform_flags(C) + +# now define the following rule variables + +# CMAKE_C_CREATE_SHARED_LIBRARY +# CMAKE_C_CREATE_SHARED_MODULE +# CMAKE_C_COMPILE_OBJECT +# CMAKE_C_LINK_EXECUTABLE + +# variables supplied by the generator at use time +# +# the target without the suffix +# +# +# +# +# + +# C compiler information +# +# +# +# + +# Static library tools +# +# + + +# create a C shared library +if(NOT CMAKE_C_CREATE_SHARED_LIBRARY) + set(CMAKE_C_CREATE_SHARED_LIBRARY + " -o ") +endif() + +# create a C shared module just copy the shared library rule +if(NOT CMAKE_C_CREATE_SHARED_MODULE) + set(CMAKE_C_CREATE_SHARED_MODULE ${CMAKE_C_CREATE_SHARED_LIBRARY}) +endif() + +# Create a static archive incrementally for large object file counts. +# If CMAKE_C_CREATE_STATIC_LIBRARY is set it will override these. +if(NOT DEFINED CMAKE_C_ARCHIVE_CREATE) + set(CMAKE_C_ARCHIVE_CREATE " qc ") +endif() +if(NOT DEFINED CMAKE_C_ARCHIVE_APPEND) + set(CMAKE_C_ARCHIVE_APPEND " q ") +endif() +if(NOT DEFINED CMAKE_C_ARCHIVE_FINISH) + set(CMAKE_C_ARCHIVE_FINISH " ") +endif() + +# compile a C file into an object file +if(NOT CMAKE_C_COMPILE_OBJECT) + set(CMAKE_C_COMPILE_OBJECT + " -o -c ") +endif() + +if(NOT CMAKE_C_LINK_EXECUTABLE) + set(CMAKE_C_LINK_EXECUTABLE + " -o ") +endif() + +set(CMAKE_C_USE_LINKER_INFORMATION TRUE) + +set(CMAKE_C_INFORMATION_LOADED 1) diff --git a/cmake/share/cmake-3.31/Modules/CMakeCSharpCompiler.cmake.in b/cmake/share/cmake-3.31/Modules/CMakeCSharpCompiler.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..1ba122c910a1f135b754d6325df8e35cd19ec975 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCSharpCompiler.cmake.in @@ -0,0 +1,10 @@ +set(CMAKE_CSharp_COMPILER "@CMAKE_CSharp_COMPILER@") +set(CMAKE_CSharp_COMPILER_ID "@CMAKE_CSharp_COMPILER_ID@") +set(CMAKE_CSharp_COMPILER_VERSION "@CMAKE_CSharp_COMPILER_VERSION@") + +set(CMAKE_CSharp_COMPILER_LOADED 1) +set(CMAKE_CSharp_COMPILER_WORKS "@CMAKE_CSharp_COMPILER_WORKS@") + +set(CMAKE_CSharp_COMPILER_ID_RUN "@CMAKE_CSharp_COMPILER_ID_RUN@") +set(CMAKE_CSharp_IGNORE_EXTENSIONS "inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC") +set(CMAKE_CSharp_SOURCE_FILE_EXTENSIONS "cs") diff --git a/cmake/share/cmake-3.31/Modules/CMakeCSharpCompilerId.cs.in b/cmake/share/cmake-3.31/Modules/CMakeCSharpCompilerId.cs.in new file mode 100644 index 0000000000000000000000000000000000000000..0674fa9e85dcbb3215c432aa5188125297a7d839 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCSharpCompilerId.cs.in @@ -0,0 +1,71 @@ +using System; + +namespace CSharp +{ + public class CSharpApp + { + const string InfoCompiler = "INFO:compiler[Microsoft " +#if PlatformToolsetv100 + + "Visual Studio" +#elif PlatformToolsetv110 + + "Visual Studio" +#elif PlatformToolsetv120 + + "Visual Studio" +#elif PlatformToolsetv140 + + "Visual Studio" +#elif PlatformToolsetv141 + + "Visual Studio" +#elif PlatformToolsetv142 + + "Visual Studio" +#elif PlatformToolsetv143 + + "Visual Studio" +#else + + "unknown" +#endif + + "]"; + + const string InfoPlatform = "INFO:platform[Windows]"; + + const string InfoArchitecture = "INFO:arch[" +#if Platformx64 + + "x64" +#elif Platformx86 + + "x86" +#elif PlatformxWin32 + + "Win32]" +#else + + "unknown" +#endif + + "]"; + + const string InfoCompilerVersion = "INFO:compiler_version[" +#if PlatformToolsetv100 + + "2010" +#elif PlatformToolsetv110 + + "2012" +#elif PlatformToolsetv120 + + "2013" +#elif PlatformToolsetv140 + + "2015" +#elif PlatformToolsetv141 + + "2017" +#elif PlatformToolsetv142 + + "2019" +#elif PlatformToolsetv143 + + "2022" +#else + + "9999" +#endif + + "]"; + + static void Main(string[] args) + { + // we have to print the lines to make sure + // the compiler does not optimize them away ... + System.Console.WriteLine(InfoCompiler); + System.Console.WriteLine(InfoPlatform); + System.Console.WriteLine(InfoArchitecture); + System.Console.WriteLine(InfoCompilerVersion); + } + } +} diff --git a/cmake/share/cmake-3.31/Modules/CMakeCSharpInformation.cmake b/cmake/share/cmake-3.31/Modules/CMakeCSharpInformation.cmake new file mode 100644 index 0000000000000000000000000000000000000000..465f7aa45c1f007a0440bd42b9bfd6c6be2172a5 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCSharpInformation.cmake @@ -0,0 +1,70 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +# This file sets the basic flags for the C# language in CMake. +# It also loads the available platform file for the system-compiler +# if it exists. + +set(CMAKE_BASE_NAME) +get_filename_component(CMAKE_BASE_NAME "${CMAKE_CSharp_COMPILER}" NAME_WE) + +set(CMAKE_BUILD_TYPE_INIT Debug) + +set(CMAKE_CSharp_FLAGS_INIT "/define:TRACE") +set(CMAKE_CSharp_FLAGS_DEBUG_INIT "/debug:full /optimize- /warn:3 /errorreport:prompt /define:DEBUG") +set(CMAKE_CSharp_FLAGS_RELEASE_INIT "/debug:none /optimize /warn:1 /errorreport:queue") +set(CMAKE_CSharp_FLAGS_RELWITHDEBINFO_INIT "/debug:full /optimize-") +set(CMAKE_CSharp_FLAGS_MINSIZEREL_INIT "/debug:none /optimize") +set(CMAKE_CSharp_LINKER_SUPPORTS_PDB ON) + +set(CMAKE_CSharp_STANDARD_LIBRARIES_INIT "System") + +if(CMAKE_SIZEOF_VOID_P EQUAL 4) + set(CMAKE_CSharp_FLAGS_INIT "/platform:x86 ${CMAKE_CSharp_FLAGS_INIT}") +else() + set(CMAKE_CSharp_FLAGS_INIT "/platform:x64 ${CMAKE_CSharp_FLAGS_INIT}") +endif() + +# This should be included before the _INIT variables are +# used to initialize the cache. Since the rule variables +# have if blocks on them, users can still define them here. +# But, it should still be after the platform file so changes can +# be made to those values. + +# for most systems a module is the same as a shared library +# so unless the variable CMAKE_MODULE_EXISTS is set just +# copy the values from the LIBRARY variables +if(NOT CMAKE_MODULE_EXISTS) + set(CMAKE_SHARED_MODULE_CSharp_FLAGS ${CMAKE_SHARED_LIBRARY_CSharp_FLAGS}) + set(CMAKE_SHARED_MODULE_CREATE_CSharp_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_CSharp_FLAGS}) +endif() + +# add the flags to the cache based +# on the initial values computed in the platform/*.cmake files +# use _INIT variables so that this only happens the first time +# and you can set these flags in the cmake cache +set(CMAKE_CSharp_FLAGS_INIT "$ENV{CSFLAGS} ${CMAKE_CSharp_FLAGS_INIT}") + +cmake_initialize_per_config_variable(CMAKE_CSharp_FLAGS "Flags used by the C# compiler") + +if(CMAKE_CSharp_STANDARD_LIBRARIES_INIT) + set(CMAKE_CSharp_STANDARD_LIBRARIES "${CMAKE_CSharp_STANDARD_LIBRARIES_INIT}" + CACHE STRING "Libraries linked by default with all C# applications.") + mark_as_advanced(CMAKE_CSharp_STANDARD_LIBRARIES) +endif() + +# set missing flags (if they are not defined). This is needed in the +# unlikely case that you have only C# and no C/C++ targets in your +# project. +cmake_initialize_per_config_variable(CMAKE_EXE_LINKER_FLAGS "Flags used by the linker") +cmake_initialize_per_config_variable(CMAKE_SHARED_LINKER_FLAGS "Flags used by the linker during the creation of shared libraries") + +set(CMAKE_CSharp_CREATE_SHARED_LIBRARY "CSharp_NO_CREATE_SHARED_LIBRARY") +set(CMAKE_CSharp_CREATE_SHARED_MODULE "CSharp_NO_CREATE_SHARED_MODULE") +set(CMAKE_CSharp_LINK_EXECUTABLE "CSharp_NO_LINK_EXECUTABLE") + +set(CMAKE_CSharp_USE_RESPONSE_FILE_FOR_OBJECTS 1) + +set(CMAKE_CSharp_USE_LINKER_INFORMATION FALSE) + +set(CMAKE_CSharp_INFORMATION_LOADED 1) diff --git a/cmake/share/cmake-3.31/Modules/CMakeCUDACompiler.cmake.in b/cmake/share/cmake-3.31/Modules/CMakeCUDACompiler.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..11e23e383c8a2b16f6154eae4faf50b8a2a2aeaa --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCUDACompiler.cmake.in @@ -0,0 +1,87 @@ +set(CMAKE_CUDA_COMPILER "@CMAKE_CUDA_COMPILER@") +set(CMAKE_CUDA_HOST_COMPILER "@CMAKE_CUDA_HOST_COMPILER@") +set(CMAKE_CUDA_HOST_LINK_LAUNCHER "@CMAKE_CUDA_HOST_LINK_LAUNCHER@") +set(CMAKE_CUDA_COMPILER_ID "@CMAKE_CUDA_COMPILER_ID@") +set(CMAKE_CUDA_COMPILER_VERSION "@CMAKE_CUDA_COMPILER_VERSION@") +set(CMAKE_CUDA_HOST_COMPILER_ID "@CMAKE_CUDA_HOST_COMPILER_ID@") +set(CMAKE_CUDA_HOST_COMPILER_VERSION "@CMAKE_CUDA_HOST_COMPILER_VERSION@") +set(CMAKE_CUDA_DEVICE_LINKER "@CMAKE_CUDA_DEVICE_LINKER@") +set(CMAKE_CUDA_FATBINARY "@CMAKE_CUDA_FATBINARY@") +set(CMAKE_CUDA_STANDARD_COMPUTED_DEFAULT "@CMAKE_CUDA_STANDARD_COMPUTED_DEFAULT@") +set(CMAKE_CUDA_EXTENSIONS_COMPUTED_DEFAULT "@CMAKE_CUDA_EXTENSIONS_COMPUTED_DEFAULT@") +set(CMAKE_CUDA_STANDARD_LATEST "@CMAKE_CUDA_STANDARD_LATEST@") +set(CMAKE_CUDA_COMPILE_FEATURES "@CMAKE_CUDA_COMPILE_FEATURES@") +set(CMAKE_CUDA03_COMPILE_FEATURES "@CMAKE_CUDA03_COMPILE_FEATURES@") +set(CMAKE_CUDA11_COMPILE_FEATURES "@CMAKE_CUDA11_COMPILE_FEATURES@") +set(CMAKE_CUDA14_COMPILE_FEATURES "@CMAKE_CUDA14_COMPILE_FEATURES@") +set(CMAKE_CUDA17_COMPILE_FEATURES "@CMAKE_CUDA17_COMPILE_FEATURES@") +set(CMAKE_CUDA20_COMPILE_FEATURES "@CMAKE_CUDA20_COMPILE_FEATURES@") +set(CMAKE_CUDA23_COMPILE_FEATURES "@CMAKE_CUDA23_COMPILE_FEATURES@") +set(CMAKE_CUDA26_COMPILE_FEATURES "@CMAKE_CUDA26_COMPILE_FEATURES@") + +set(CMAKE_CUDA_PLATFORM_ID "@CMAKE_CUDA_PLATFORM_ID@") +set(CMAKE_CUDA_SIMULATE_ID "@CMAKE_CUDA_SIMULATE_ID@") +set(CMAKE_CUDA_COMPILER_FRONTEND_VARIANT "@CMAKE_CUDA_COMPILER_FRONTEND_VARIANT@") +set(CMAKE_CUDA_SIMULATE_VERSION "@CMAKE_CUDA_SIMULATE_VERSION@") +@SET_MSVC_CUDA_ARCHITECTURE_ID@ +@_SET_CMAKE_CUDA_COMPILER_SYSROOT@ + +set(CMAKE_CUDA_COMPILER_ENV_VAR "CUDACXX") +set(CMAKE_CUDA_HOST_COMPILER_ENV_VAR "CUDAHOSTCXX") + +set(CMAKE_CUDA_COMPILER_LOADED 1) +set(CMAKE_CUDA_COMPILER_ID_RUN 1) +set(CMAKE_CUDA_SOURCE_FILE_EXTENSIONS cu) +set(CMAKE_CUDA_LINKER_PREFERENCE 15) +set(CMAKE_CUDA_LINKER_PREFERENCE_PROPAGATES 1) +set(CMAKE_CUDA_LINKER_DEPFILE_SUPPORTED @CMAKE_CUDA_LINKER_DEPFILE_SUPPORTED@) + +set(CMAKE_CUDA_SIZEOF_DATA_PTR "@CMAKE_CUDA_SIZEOF_DATA_PTR@") +set(CMAKE_CUDA_COMPILER_ABI "@CMAKE_CUDA_COMPILER_ABI@") +set(CMAKE_CUDA_BYTE_ORDER "@CMAKE_CUDA_BYTE_ORDER@") +set(CMAKE_CUDA_LIBRARY_ARCHITECTURE "@CMAKE_CUDA_LIBRARY_ARCHITECTURE@") + +if(CMAKE_CUDA_SIZEOF_DATA_PTR) + set(CMAKE_SIZEOF_VOID_P "${CMAKE_CUDA_SIZEOF_DATA_PTR}") +endif() + +if(CMAKE_CUDA_COMPILER_ABI) + set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CUDA_COMPILER_ABI}") +endif() + +if(CMAKE_CUDA_LIBRARY_ARCHITECTURE) + set(CMAKE_LIBRARY_ARCHITECTURE "@CMAKE_CUDA_LIBRARY_ARCHITECTURE@") +endif() + +set(CMAKE_CUDA_COMPILER_TOOLKIT_ROOT "@CMAKE_CUDA_COMPILER_TOOLKIT_ROOT@") +set(CMAKE_CUDA_COMPILER_TOOLKIT_LIBRARY_ROOT "@CMAKE_CUDA_COMPILER_TOOLKIT_LIBRARY_ROOT@") +set(CMAKE_CUDA_COMPILER_TOOLKIT_VERSION "@CMAKE_CUDA_COMPILER_TOOLKIT_VERSION@") +set(CMAKE_CUDA_COMPILER_LIBRARY_ROOT "@CMAKE_CUDA_COMPILER_LIBRARY_ROOT@") + +set(CMAKE_CUDA_ARCHITECTURES_ALL "@CMAKE_CUDA_ARCHITECTURES_ALL@") +set(CMAKE_CUDA_ARCHITECTURES_ALL_MAJOR "@CMAKE_CUDA_ARCHITECTURES_ALL_MAJOR@") +set(CMAKE_CUDA_ARCHITECTURES_NATIVE "@CMAKE_CUDA_ARCHITECTURES_NATIVE@") + +set(CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES "@CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES@") + +set(CMAKE_CUDA_HOST_IMPLICIT_LINK_LIBRARIES "@CMAKE_CUDA_HOST_IMPLICIT_LINK_LIBRARIES@") +set(CMAKE_CUDA_HOST_IMPLICIT_LINK_DIRECTORIES "@CMAKE_CUDA_HOST_IMPLICIT_LINK_DIRECTORIES@") +set(CMAKE_CUDA_HOST_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "@CMAKE_CUDA_HOST_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES@") + +set(CMAKE_CUDA_IMPLICIT_INCLUDE_DIRECTORIES "@CMAKE_CUDA_IMPLICIT_INCLUDE_DIRECTORIES@") +set(CMAKE_CUDA_IMPLICIT_LINK_LIBRARIES "@CMAKE_CUDA_IMPLICIT_LINK_LIBRARIES@") +set(CMAKE_CUDA_IMPLICIT_LINK_DIRECTORIES "@CMAKE_CUDA_IMPLICIT_LINK_DIRECTORIES@") +set(CMAKE_CUDA_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "@CMAKE_CUDA_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES@") + +@_SET_CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT@ + +set(CMAKE_LINKER "@CMAKE_LINKER@") +set(CMAKE_LINKER_LINK "@CMAKE_LINKER_LINK@") +set(CMAKE_LINKER_LLD "@CMAKE_LINKER_LLD@") +set(CMAKE_CUDA_COMPILER_LINKER "@CMAKE_CUDA_COMPILER_LINKER@") +set(CMAKE_CUDA_COMPILER_LINKER_ID "@CMAKE_CUDA_COMPILER_LINKER_ID@") +set(CMAKE_CUDA_COMPILER_LINKER_VERSION @CMAKE_CUDA_COMPILER_LINKER_VERSION@) +set(CMAKE_CUDA_COMPILER_LINKER_FRONTEND_VARIANT @CMAKE_CUDA_COMPILER_LINKER_FRONTEND_VARIANT@) +set(CMAKE_AR "@CMAKE_AR@") +set(CMAKE_RANLIB "@CMAKE_RANLIB@") +set(CMAKE_MT "@CMAKE_MT@") diff --git a/cmake/share/cmake-3.31/Modules/CMakeCUDACompilerABI.cu b/cmake/share/cmake-3.31/Modules/CMakeCUDACompilerABI.cu new file mode 100644 index 0000000000000000000000000000000000000000..6155dcec50924b1d005090a37f6af180e421985c --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCUDACompilerABI.cu @@ -0,0 +1,26 @@ +#ifndef __CUDACC__ +# error "A C or C++ compiler has been selected for CUDA" +#endif + +#include "CMakeCompilerABI.h" +#include "CMakeCompilerCUDAArch.h" + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_sizeof_dptr[argc]; + require += info_byte_order_big_endian[argc]; + require += info_byte_order_little_endian[argc]; +#if defined(ABI_ID) + require += info_abi[argc]; +#endif + static_cast(argv); + + if (!cmakeCompilerCUDAArch()) { + // Convince the compiler that the non-zero return value depends + // on the info strings so they are not optimized out. + return require ? -1 : 1; + } + + return 0; +} diff --git a/cmake/share/cmake-3.31/Modules/CMakeCUDACompilerId.cu.in b/cmake/share/cmake-3.31/Modules/CMakeCUDACompilerId.cu.in new file mode 100644 index 0000000000000000000000000000000000000000..6b59c0cfb4b965cd72fe1b155bc79b488a25c6e9 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCUDACompilerId.cu.in @@ -0,0 +1,110 @@ +#ifndef __CUDACC__ +# error "A C or C++ compiler has been selected for CUDA" +#endif + +@CMAKE_CUDA_COMPILER_ID_CONTENT@ + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +@CMAKE_CUDA_COMPILER_ID_PLATFORM_CONTENT@ +@CMAKE_CUDA_COMPILER_ID_ERROR_FOR_TEST@ + +#ifdef HOST_COMPILER_ID +char const* info_host_compiler = "INFO" ":" "host_compiler[" HOST_COMPILER_ID "]"; +#endif +#ifdef HOST_COMPILER_VERSION +char const* info_host_compiler_version = "INFO" ":" "host_compiler_version[" HOST_COMPILER_VERSION "]"; +#elif defined(HOST_COMPILER_VERSION_MAJOR) +char const info_host_compiler_version[] = { + 'I', 'N', 'F', 'O', ':','h','o','s','t','_', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + HOST_COMPILER_VERSION_MAJOR, +# ifdef HOST_COMPILER_VERSION_MINOR + '.', HOST_COMPILER_VERSION_MINOR, +# ifdef HOST_COMPILER_VERSION_PATCH + '.', HOST_COMPILER_VERSION_PATCH, +# ifdef HOST_COMPILER_VERSION_TWEAK + '.', HOST_COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +#define CXX_STD_11 201103L +#define CXX_STD_14 201402L +#define CXX_STD_17 201703L +#define CXX_STD_20 202002L +#define CXX_STD_23 202302L + +#if defined(_MSC_VER) && defined(_MSVC_LANG) +# if _MSVC_LANG > __cplusplus +# define CXX_STD _MSVC_LANG +# else +# define CXX_STD __cplusplus +# endif +#else +# define CXX_STD __cplusplus +#endif + +const char* info_language_standard_default = "INFO" ":" "standard_default[" +#if CXX_STD > CXX_STD_23 + "26" +#elif CXX_STD > CXX_STD_20 + "23" +#elif CXX_STD > CXX_STD_17 + "20" +#elif CXX_STD > CXX_STD_14 + "17" +#elif CXX_STD > CXX_STD_11 + "14" +#elif CXX_STD >= CXX_STD_11 + "11" +#else + "03" +#endif +"]"; + +const char* info_language_extensions_default = "INFO" ":" "extensions_default[" +#if (defined(__clang__) || defined(__GNUC__)) && \ + !defined(__STRICT_ANSI__) + "ON" +#else + "OFF" +#endif +"]"; + +/*--------------------------------------------------------------------------*/ + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#ifdef HOST_COMPILER_ID + require += info_host_compiler[argc]; +#endif +#ifdef HOST_COMPILER_VERSION_MAJOR + require += info_host_compiler_version[argc]; +#endif + require += info_language_standard_default[argc]; + require += info_language_extensions_default[argc]; + (void)argv; + return require; +} diff --git a/cmake/share/cmake-3.31/Modules/CMakeCUDAInformation.cmake b/cmake/share/cmake-3.31/Modules/CMakeCUDAInformation.cmake new file mode 100644 index 0000000000000000000000000000000000000000..aa29e69011951023fa0c9e38d9507aba26f27ca3 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCUDAInformation.cmake @@ -0,0 +1,155 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +if(UNIX) + set(CMAKE_CUDA_OUTPUT_EXTENSION .o) +else() + set(CMAKE_CUDA_OUTPUT_EXTENSION .obj) +endif() +set(CMAKE_INCLUDE_FLAG_CUDA "-I") + +# Set implicit links early so compiler-specific modules can use them. +set(__IMPLICIT_LINKS) +foreach(dir ${CMAKE_CUDA_HOST_IMPLICIT_LINK_DIRECTORIES}) + string(APPEND __IMPLICIT_LINKS " -L\"${dir}\"") +endforeach() +foreach(lib ${CMAKE_CUDA_HOST_IMPLICIT_LINK_LIBRARIES}) + if(${lib} MATCHES "/") + string(APPEND __IMPLICIT_LINKS " \"${lib}\"") + else() + string(APPEND __IMPLICIT_LINKS " -l${lib}") + endif() +endforeach() + +# Load compiler-specific information. +if(CMAKE_CUDA_COMPILER_ID) + include(Compiler/${CMAKE_CUDA_COMPILER_ID}-CUDA OPTIONAL) +endif() + +# load the system- and compiler specific files +if(CMAKE_CUDA_COMPILER_ID) + # load a hardware specific file, mostly useful for embedded compilers + if(CMAKE_SYSTEM_PROCESSOR) + include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_CUDA_COMPILER_ID}-CUDA-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL) + endif() + include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_CUDA_COMPILER_ID}-CUDA OPTIONAL) +endif() + + +# This should be included before the _INIT variables are +# used to initialize the cache. Since the rule variables +# have if blocks on them, users can still define them here. +# But, it should still be after the platform file so changes can +# be made to those values. + +if(CMAKE_USER_MAKE_RULES_OVERRIDE) + # Save the full path of the file so try_compile can use it. + include(${CMAKE_USER_MAKE_RULES_OVERRIDE} RESULT_VARIABLE _override) + set(CMAKE_USER_MAKE_RULES_OVERRIDE "${_override}") +endif() + +if(CMAKE_USER_MAKE_RULES_OVERRIDE_CUDA) + # Save the full path of the file so try_compile can use it. + include(${CMAKE_USER_MAKE_RULES_OVERRIDE_CUDA} RESULT_VARIABLE _override) + set(CMAKE_USER_MAKE_RULES_OVERRIDE_CUDA "${_override}") +endif() + + + +# add the flags to the cache based +# on the initial values computed in the platform/*.cmake files +# use _INIT variables so that this only happens the first time +# and you can set these flags in the cmake cache +set(CMAKE_CUDA_FLAGS_INIT "$ENV{CUDAFLAGS} ${CMAKE_CUDA_FLAGS_INIT}") + +cmake_initialize_per_config_variable(CMAKE_CUDA_FLAGS "Flags used by the CUDA compiler") + +if(CMAKE_CUDA_STANDARD_LIBRARIES_INIT) + set(CMAKE_CUDA_STANDARD_LIBRARIES "${CMAKE_CUDA_STANDARD_LIBRARIES_INIT}" + CACHE STRING "Libraries linked by default with all CUDA applications.") + mark_as_advanced(CMAKE_CUDA_STANDARD_LIBRARIES) +endif() + +if(NOT CMAKE_CUDA_COMPILER_LAUNCHER AND DEFINED ENV{CMAKE_CUDA_COMPILER_LAUNCHER}) + set(CMAKE_CUDA_COMPILER_LAUNCHER "$ENV{CMAKE_CUDA_COMPILER_LAUNCHER}" + CACHE STRING "Compiler launcher for CUDA.") +endif() + +include(CMakeCommonLanguageInclude) +_cmake_common_language_platform_flags(CUDA) + +# now define the following rules: +# CMAKE_CUDA_CREATE_SHARED_LIBRARY +# CMAKE_CUDA_CREATE_SHARED_MODULE +# CMAKE_CUDA_COMPILE_WHOLE_COMPILATION +# CMAKE_CUDA_COMPILE_SEPARABLE_COMPILATION +# CMAKE_CUDA_LINK_EXECUTABLE + +# create a shared library +if(NOT CMAKE_CUDA_CREATE_SHARED_LIBRARY) + set(CMAKE_CUDA_CREATE_SHARED_LIBRARY + " -o ${__IMPLICIT_LINKS}") +endif() + +# create a shared module copy the shared library rule by default +if(NOT CMAKE_CUDA_CREATE_SHARED_MODULE) + set(CMAKE_CUDA_CREATE_SHARED_MODULE ${CMAKE_CUDA_CREATE_SHARED_LIBRARY}) +endif() + +# Create a static archive incrementally for large object file counts. +if(NOT DEFINED CMAKE_CUDA_ARCHIVE_CREATE) + set(CMAKE_CUDA_ARCHIVE_CREATE " qc ") +endif() +if(NOT DEFINED CMAKE_CUDA_ARCHIVE_APPEND) + set(CMAKE_CUDA_ARCHIVE_APPEND " q ") +endif() +if(NOT DEFINED CMAKE_CUDA_ARCHIVE_FINISH) + set(CMAKE_CUDA_ARCHIVE_FINISH " ") +endif() + +if(NOT CMAKE_CUDA_COMPILE_OBJECT) + set(CMAKE_CUDA_COMPILE_OBJECT + " ${_CMAKE_CUDA_EXTRA_FLAGS} ${_CMAKE_COMPILE_AS_CUDA_FLAG} -o ") +endif() + +# compile a cu file into an executable +if(NOT CMAKE_CUDA_LINK_EXECUTABLE) + set(CMAKE_CUDA_LINK_EXECUTABLE + " -o ${__IMPLICIT_LINKS}") +endif() + +# Add implicit host link directories that contain device libraries +# to the device link line. +set(__IMPLICIT_DLINK_DIRS ${CMAKE_CUDA_IMPLICIT_LINK_DIRECTORIES}) +if(__IMPLICIT_DLINK_DIRS) + list(REMOVE_ITEM __IMPLICIT_DLINK_DIRS ${CMAKE_CUDA_HOST_IMPLICIT_LINK_DIRECTORIES}) +endif() +set(__IMPLICIT_DLINK_FLAGS) +foreach(dir ${__IMPLICIT_DLINK_DIRS}) + if(EXISTS "${dir}/libcurand_static.a") + string(APPEND __IMPLICIT_DLINK_FLAGS " -L\"${dir}\"") + endif() +endforeach() +unset(__IMPLICIT_DLINK_DIRS) + + +#These are used when linking relocatable (dc) cuda code +if(NOT CMAKE_CUDA_DEVICE_LINK_LIBRARY) + set(CMAKE_CUDA_DEVICE_LINK_LIBRARY + " ${_CMAKE_CUDA_EXTRA_FLAGS} ${CMAKE_CUDA_COMPILE_OPTIONS_PIC} ${_CMAKE_CUDA_EXTRA_DEVICE_LINK_FLAGS} -shared -dlink -o ${__IMPLICIT_DLINK_FLAGS}") +endif() +if(NOT CMAKE_CUDA_DEVICE_LINK_EXECUTABLE) + set(CMAKE_CUDA_DEVICE_LINK_EXECUTABLE + " ${_CMAKE_CUDA_EXTRA_FLAGS} ${CMAKE_CUDA_COMPILE_OPTIONS_PIC} ${_CMAKE_CUDA_EXTRA_DEVICE_LINK_FLAGS} -shared -dlink -o ${__IMPLICIT_DLINK_FLAGS}") +endif() + +# Used when device linking is handled by CMake. +if(NOT CMAKE_CUDA_DEVICE_LINK_COMPILE) + set(CMAKE_CUDA_DEVICE_LINK_COMPILE " ${_CMAKE_CUDA_EXTRA_FLAGS} -D__CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__ -D__NV_EXTRA_INITIALIZATION=\"\" -D__NV_EXTRA_FINALIZATION=\"\" -DREGISTERLINKBINARYFILE=\\\"\\\" -DFATBINFILE=\\\"\\\" ${_CMAKE_COMPILE_AS_CUDA_FLAG} -c \"${CMAKE_CUDA_COMPILER_TOOLKIT_LIBRARY_ROOT}/bin/crt/link.stub\" -o ") +endif() + +unset(__IMPLICIT_DLINK_FLAGS) + +set(CMAKE_CUDA_USE_LINKER_INFORMATION TRUE) + +set(CMAKE_CUDA_INFORMATION_LOADED 1) diff --git a/cmake/share/cmake-3.31/Modules/CMakeCXXCompiler.cmake.in b/cmake/share/cmake-3.31/Modules/CMakeCXXCompiler.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..72553e2c98d75c98271dc6149e1f02b90d89fca4 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCXXCompiler.cmake.in @@ -0,0 +1,97 @@ +set(CMAKE_CXX_COMPILER "@CMAKE_CXX_COMPILER@") +set(CMAKE_CXX_COMPILER_ARG1 "@CMAKE_CXX_COMPILER_ARG1@") +set(CMAKE_CXX_COMPILER_ID "@CMAKE_CXX_COMPILER_ID@") +set(CMAKE_CXX_COMPILER_VERSION "@CMAKE_CXX_COMPILER_VERSION@") +set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "@CMAKE_CXX_COMPILER_VERSION_INTERNAL@") +set(CMAKE_CXX_COMPILER_WRAPPER "@CMAKE_CXX_COMPILER_WRAPPER@") +set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "@CMAKE_CXX_STANDARD_COMPUTED_DEFAULT@") +set(CMAKE_CXX_EXTENSIONS_COMPUTED_DEFAULT "@CMAKE_CXX_EXTENSIONS_COMPUTED_DEFAULT@") +set(CMAKE_CXX_STANDARD_LATEST "@CMAKE_CXX_STANDARD_LATEST@") +set(CMAKE_CXX_COMPILE_FEATURES "@CMAKE_CXX_COMPILE_FEATURES@") +set(CMAKE_CXX98_COMPILE_FEATURES "@CMAKE_CXX98_COMPILE_FEATURES@") +set(CMAKE_CXX11_COMPILE_FEATURES "@CMAKE_CXX11_COMPILE_FEATURES@") +set(CMAKE_CXX14_COMPILE_FEATURES "@CMAKE_CXX14_COMPILE_FEATURES@") +set(CMAKE_CXX17_COMPILE_FEATURES "@CMAKE_CXX17_COMPILE_FEATURES@") +set(CMAKE_CXX20_COMPILE_FEATURES "@CMAKE_CXX20_COMPILE_FEATURES@") +set(CMAKE_CXX23_COMPILE_FEATURES "@CMAKE_CXX23_COMPILE_FEATURES@") +set(CMAKE_CXX26_COMPILE_FEATURES "@CMAKE_CXX26_COMPILE_FEATURES@") + +set(CMAKE_CXX_PLATFORM_ID "@CMAKE_CXX_PLATFORM_ID@") +set(CMAKE_CXX_SIMULATE_ID "@CMAKE_CXX_SIMULATE_ID@") +set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "@CMAKE_CXX_COMPILER_FRONTEND_VARIANT@") +set(CMAKE_CXX_SIMULATE_VERSION "@CMAKE_CXX_SIMULATE_VERSION@") +@_SET_CMAKE_CXX_COMPILER_ARCHITECTURE_ID@ +@_SET_CMAKE_CXX_COMPILER_SYSROOT@ +@SET_MSVC_CXX_ARCHITECTURE_ID@ +@SET_CMAKE_XCODE_ARCHS@ +set(CMAKE_AR "@CMAKE_AR@") +set(CMAKE_CXX_COMPILER_AR "@CMAKE_CXX_COMPILER_AR@") +set(CMAKE_RANLIB "@CMAKE_RANLIB@") +set(CMAKE_CXX_COMPILER_RANLIB "@CMAKE_CXX_COMPILER_RANLIB@") +set(CMAKE_LINKER "@CMAKE_LINKER@") +set(CMAKE_LINKER_LINK "@CMAKE_LINKER_LINK@") +set(CMAKE_LINKER_LLD "@CMAKE_LINKER_LLD@") +set(CMAKE_CXX_COMPILER_LINKER "@CMAKE_CXX_COMPILER_LINKER@") +set(CMAKE_CXX_COMPILER_LINKER_ID "@CMAKE_CXX_COMPILER_LINKER_ID@") +set(CMAKE_CXX_COMPILER_LINKER_VERSION @CMAKE_CXX_COMPILER_LINKER_VERSION@) +set(CMAKE_CXX_COMPILER_LINKER_FRONTEND_VARIANT @CMAKE_CXX_COMPILER_LINKER_FRONTEND_VARIANT@) +set(CMAKE_MT "@CMAKE_MT@") +set(CMAKE_TAPI "@CMAKE_TAPI@") +set(CMAKE_COMPILER_IS_GNUCXX @CMAKE_COMPILER_IS_GNUCXX@) +set(CMAKE_CXX_COMPILER_LOADED 1) +set(CMAKE_CXX_COMPILER_WORKS @CMAKE_CXX_COMPILER_WORKS@) +set(CMAKE_CXX_ABI_COMPILED @CMAKE_CXX_ABI_COMPILED@) + +set(CMAKE_CXX_COMPILER_ENV_VAR "CXX") + +set(CMAKE_CXX_COMPILER_ID_RUN 1) +set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;mpp;CPP;ixx;cppm;ccm;cxxm;c++m) +set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC) + +foreach (lang IN ITEMS C OBJC OBJCXX) + if (CMAKE_${lang}_COMPILER_ID_RUN) + foreach(extension IN LISTS CMAKE_${lang}_SOURCE_FILE_EXTENSIONS) + list(REMOVE_ITEM CMAKE_CXX_SOURCE_FILE_EXTENSIONS ${extension}) + endforeach() + endif() +endforeach() + +set(CMAKE_CXX_LINKER_PREFERENCE 30) +set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1) +set(CMAKE_CXX_LINKER_DEPFILE_SUPPORTED @CMAKE_CXX_LINKER_DEPFILE_SUPPORTED@) + +# Save compiler ABI information. +set(CMAKE_CXX_SIZEOF_DATA_PTR "@CMAKE_CXX_SIZEOF_DATA_PTR@") +set(CMAKE_CXX_COMPILER_ABI "@CMAKE_CXX_COMPILER_ABI@") +set(CMAKE_CXX_BYTE_ORDER "@CMAKE_CXX_BYTE_ORDER@") +set(CMAKE_CXX_LIBRARY_ARCHITECTURE "@CMAKE_CXX_LIBRARY_ARCHITECTURE@") + +if(CMAKE_CXX_SIZEOF_DATA_PTR) + set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}") +endif() + +if(CMAKE_CXX_COMPILER_ABI) + set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}") +endif() + +if(CMAKE_CXX_LIBRARY_ARCHITECTURE) + set(CMAKE_LIBRARY_ARCHITECTURE "@CMAKE_CXX_LIBRARY_ARCHITECTURE@") +endif() + +set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "@CMAKE_CXX_CL_SHOWINCLUDES_PREFIX@") +if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX) + set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}") +endif() + +@CMAKE_CXX_COMPILER_CUSTOM_CODE@ +@CMAKE_CXX_SYSROOT_FLAG_CODE@ +@CMAKE_CXX_OSX_DEPLOYMENT_TARGET_FLAG_CODE@ + +set(CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES "@CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES@") +set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "@CMAKE_CXX_IMPLICIT_LINK_LIBRARIES@") +set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "@CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES@") +set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "@CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES@") +set(CMAKE_CXX_COMPILER_CLANG_RESOURCE_DIR "@CMAKE_CXX_COMPILER_CLANG_RESOURCE_DIR@") + +set(CMAKE_CXX_COMPILER_IMPORT_STD "") +@CMAKE_CXX_IMPORT_STD@ diff --git a/cmake/share/cmake-3.31/Modules/CMakeCXXCompilerABI.cpp b/cmake/share/cmake-3.31/Modules/CMakeCXXCompilerABI.cpp new file mode 100644 index 0000000000000000000000000000000000000000..9ecd394c9598719af6dc29cdab145bd36e1da5b2 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCXXCompilerABI.cpp @@ -0,0 +1,18 @@ +#ifndef __cplusplus +# error "A C compiler has been selected for C++." +#endif + +#include "CMakeCompilerABI.h" + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_sizeof_dptr[argc]; + require += info_byte_order_big_endian[argc]; + require += info_byte_order_little_endian[argc]; +#if defined(ABI_ID) + require += info_abi[argc]; +#endif + (void)argv; + return require; +} diff --git a/cmake/share/cmake-3.31/Modules/CMakeCXXCompilerId.cpp.in b/cmake/share/cmake-3.31/Modules/CMakeCXXCompilerId.cpp.in new file mode 100644 index 0000000000000000000000000000000000000000..5823bf99f0462a4a40c5741925429e263062e628 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCXXCompilerId.cpp.in @@ -0,0 +1,146 @@ +/* This source file must have a .cpp extension so that all C++ compilers + recognize the extension without flags. Borland does not know .cxx for + example. */ +#ifndef __cplusplus +# error "A C compiler has been selected for C++." +#endif + +#if !defined(__has_include) +/* If the compiler does not have __has_include, pretend the answer is + always no. */ +# define __has_include(x) 0 +#endif + +@CMAKE_CXX_COMPILER_ID_CONTENT@ + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#ifdef __QNXNTO__ +char const* qnxnto = "INFO" ":" "qnxnto[]"; +#endif + +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) +char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]"; +#endif + +@CMAKE_CXX_COMPILER_ID_PLATFORM_CONTENT@ +@CMAKE_CXX_COMPILER_ID_ERROR_FOR_TEST@ + +#define CXX_STD_98 199711L +#define CXX_STD_11 201103L +#define CXX_STD_14 201402L +#define CXX_STD_17 201703L +#define CXX_STD_20 202002L +#define CXX_STD_23 202302L + +#if defined(__INTEL_COMPILER) && defined(_MSVC_LANG) +# if _MSVC_LANG > CXX_STD_17 +# define CXX_STD _MSVC_LANG +# elif _MSVC_LANG == CXX_STD_17 && defined(__cpp_aggregate_paren_init) +# define CXX_STD CXX_STD_20 +# elif _MSVC_LANG > CXX_STD_14 && __cplusplus > CXX_STD_17 +# define CXX_STD CXX_STD_20 +# elif _MSVC_LANG > CXX_STD_14 +# define CXX_STD CXX_STD_17 +# elif defined(__INTEL_CXX11_MODE__) && defined(__cpp_aggregate_nsdmi) +# define CXX_STD CXX_STD_14 +# elif defined(__INTEL_CXX11_MODE__) +# define CXX_STD CXX_STD_11 +# else +# define CXX_STD CXX_STD_98 +# endif +#elif defined(_MSC_VER) && defined(_MSVC_LANG) +# if _MSVC_LANG > __cplusplus +# define CXX_STD _MSVC_LANG +# else +# define CXX_STD __cplusplus +# endif +#elif defined(__NVCOMPILER) +# if __cplusplus == CXX_STD_17 && defined(__cpp_aggregate_paren_init) +# define CXX_STD CXX_STD_20 +# else +# define CXX_STD __cplusplus +# endif +#elif defined(__INTEL_COMPILER) || defined(__PGI) +# if __cplusplus == CXX_STD_11 && defined(__cpp_namespace_attributes) +# define CXX_STD CXX_STD_17 +# elif __cplusplus == CXX_STD_11 && defined(__cpp_aggregate_nsdmi) +# define CXX_STD CXX_STD_14 +# else +# define CXX_STD __cplusplus +# endif +#elif (defined(__IBMCPP__) || defined(__ibmxl__)) && defined(__linux__) +# if __cplusplus == CXX_STD_11 && defined(__cpp_aggregate_nsdmi) +# define CXX_STD CXX_STD_14 +# else +# define CXX_STD __cplusplus +# endif +#elif __cplusplus == 1 && defined(__GXX_EXPERIMENTAL_CXX0X__) +# define CXX_STD CXX_STD_11 +#else +# define CXX_STD __cplusplus +#endif + +const char* info_language_standard_default = "INFO" ":" "standard_default[" +#if CXX_STD > CXX_STD_23 + "26" +#elif CXX_STD > CXX_STD_20 + "23" +#elif CXX_STD > CXX_STD_17 + "20" +#elif CXX_STD > CXX_STD_14 + "17" +#elif CXX_STD > CXX_STD_11 + "14" +#elif CXX_STD >= CXX_STD_11 + "11" +#else + "98" +#endif +"]"; + +const char* info_language_extensions_default = "INFO" ":" "extensions_default[" +#if (defined(__clang__) || defined(__GNUC__) || defined(__xlC__) || \ + defined(__TI_COMPILER_VERSION__)) && \ + !defined(__STRICT_ANSI__) + "ON" +#else + "OFF" +#endif +"]"; + +/*--------------------------------------------------------------------------*/ + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; + require += info_arch[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#ifdef COMPILER_VERSION_INTERNAL + require += info_version_internal[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) + require += info_cray[argc]; +#endif + require += info_language_standard_default[argc]; + require += info_language_extensions_default[argc]; + (void)argv; + return require; +} diff --git a/cmake/share/cmake-3.31/Modules/CMakeCXXInformation.cmake b/cmake/share/cmake-3.31/Modules/CMakeCXXInformation.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b1410580690e0948cf641558f1fc45bcc225b040 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCXXInformation.cmake @@ -0,0 +1,188 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + + +# This file sets the basic flags for the C++ language in CMake. +# It also loads the available platform file for the system-compiler +# if it exists. +# It also loads a system - compiler - processor (or target hardware) +# specific file, which is mainly useful for crosscompiling and embedded systems. + +include(CMakeLanguageInformation) + +# some compilers use different extensions (e.g. sdcc uses .rel) +# so set the extension here first so it can be overridden by the compiler specific file +if(UNIX) + set(CMAKE_CXX_OUTPUT_EXTENSION .o) +else() + set(CMAKE_CXX_OUTPUT_EXTENSION .obj) +endif() + +set(_INCLUDED_FILE 0) + +# Load compiler-specific information. +if(CMAKE_CXX_COMPILER_ID) + include(Compiler/${CMAKE_CXX_COMPILER_ID}-CXX OPTIONAL) +endif() + +set(CMAKE_BASE_NAME) +get_filename_component(CMAKE_BASE_NAME "${CMAKE_CXX_COMPILER}" NAME_WE) +# since the gnu compiler has several names force g++ +if(CMAKE_COMPILER_IS_GNUCXX) + set(CMAKE_BASE_NAME g++) +endif() + + +# load a hardware specific file, mostly useful for embedded compilers +if(CMAKE_SYSTEM_PROCESSOR) + if(CMAKE_CXX_COMPILER_ID) + include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_CXX_COMPILER_ID}-CXX-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL RESULT_VARIABLE _INCLUDED_FILE) + endif() + if (NOT _INCLUDED_FILE) + include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_BASE_NAME}-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL) + endif () +endif() + +# load the system- and compiler specific files +if(CMAKE_CXX_COMPILER_ID) + include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_CXX_COMPILER_ID}-CXX OPTIONAL RESULT_VARIABLE _INCLUDED_FILE) +endif() +if (NOT _INCLUDED_FILE) + include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_BASE_NAME} OPTIONAL + RESULT_VARIABLE _INCLUDED_FILE) +endif () + +# load any compiler-wrapper specific information +if (CMAKE_CXX_COMPILER_WRAPPER) + __cmake_include_compiler_wrapper(CXX) +endif () + +# We specify the compiler information in the system file for some +# platforms, but this language may not have been enabled when the file +# was first included. Include it again to get the language info. +# Remove this when all compiler info is removed from system files. +if (NOT _INCLUDED_FILE) + include(Platform/${CMAKE_SYSTEM_NAME} OPTIONAL) +endif () + +if(CMAKE_CXX_SIZEOF_DATA_PTR) + foreach(f IN LISTS CMAKE_CXX_ABI_FILES) + include(${f}) + endforeach() + unset(CMAKE_CXX_ABI_FILES) +endif() + +# This should be included before the _INIT variables are +# used to initialize the cache. Since the rule variables +# have if blocks on them, users can still define them here. +# But, it should still be after the platform file so changes can +# be made to those values. + +if(CMAKE_USER_MAKE_RULES_OVERRIDE) + # Save the full path of the file so try_compile can use it. + include(${CMAKE_USER_MAKE_RULES_OVERRIDE} RESULT_VARIABLE _override) + set(CMAKE_USER_MAKE_RULES_OVERRIDE "${_override}") +endif() + +if(CMAKE_USER_MAKE_RULES_OVERRIDE_CXX) + # Save the full path of the file so try_compile can use it. + include(${CMAKE_USER_MAKE_RULES_OVERRIDE_CXX} RESULT_VARIABLE _override) + set(CMAKE_USER_MAKE_RULES_OVERRIDE_CXX "${_override}") +endif() + + +# add the flags to the cache based +# on the initial values computed in the platform/*.cmake files +# use _INIT variables so that this only happens the first time +# and you can set these flags in the cmake cache +set(CMAKE_CXX_FLAGS_INIT "$ENV{CXXFLAGS} ${CMAKE_CXX_FLAGS_INIT}") + +cmake_initialize_per_config_variable(CMAKE_CXX_FLAGS "Flags used by the CXX compiler") + +if(CMAKE_CXX_STANDARD_LIBRARIES_INIT) + set(CMAKE_CXX_STANDARD_LIBRARIES "${CMAKE_CXX_STANDARD_LIBRARIES_INIT}" + CACHE STRING "Libraries linked by default with all C++ applications.") + mark_as_advanced(CMAKE_CXX_STANDARD_LIBRARIES) +endif() + +if(NOT CMAKE_CXX_COMPILER_LAUNCHER AND DEFINED ENV{CMAKE_CXX_COMPILER_LAUNCHER}) + set(CMAKE_CXX_COMPILER_LAUNCHER "$ENV{CMAKE_CXX_COMPILER_LAUNCHER}" + CACHE STRING "Compiler launcher for CXX.") +endif() + +if(NOT CMAKE_CXX_LINKER_LAUNCHER AND DEFINED ENV{CMAKE_CXX_LINKER_LAUNCHER}) + set(CMAKE_CXX_LINKER_LAUNCHER "$ENV{CMAKE_CXX_LINKER_LAUNCHER}" + CACHE STRING "Linker launcher for CXX.") +endif() + +include(CMakeCommonLanguageInclude) +_cmake_common_language_platform_flags(CXX) + +# now define the following rules: +# CMAKE_CXX_CREATE_SHARED_LIBRARY +# CMAKE_CXX_CREATE_SHARED_MODULE +# CMAKE_CXX_COMPILE_OBJECT +# CMAKE_CXX_LINK_EXECUTABLE + +# variables supplied by the generator at use time +# +# the target without the suffix +# +# +# +# +# + +# CXX compiler information +# +# +# +# + +# Static library tools +# +# + + +# create a shared C++ library +if(NOT CMAKE_CXX_CREATE_SHARED_LIBRARY) + set(CMAKE_CXX_CREATE_SHARED_LIBRARY + " -o ") +endif() + +# create a c++ shared module copy the shared library rule by default +if(NOT CMAKE_CXX_CREATE_SHARED_MODULE) + set(CMAKE_CXX_CREATE_SHARED_MODULE ${CMAKE_CXX_CREATE_SHARED_LIBRARY}) +endif() + + +# Create a static archive incrementally for large object file counts. +# If CMAKE_CXX_CREATE_STATIC_LIBRARY is set it will override these. +if(NOT DEFINED CMAKE_CXX_ARCHIVE_CREATE) + set(CMAKE_CXX_ARCHIVE_CREATE " qc ") +endif() +if(NOT DEFINED CMAKE_CXX_ARCHIVE_APPEND) + set(CMAKE_CXX_ARCHIVE_APPEND " q ") +endif() +if(NOT DEFINED CMAKE_CXX_ARCHIVE_FINISH) + set(CMAKE_CXX_ARCHIVE_FINISH " ") +endif() + +# compile a C++ file into an object file +if(NOT CMAKE_CXX_COMPILE_OBJECT) + set(CMAKE_CXX_COMPILE_OBJECT + " -o -c ") +endif() + +if(NOT CMAKE_CXX_LINK_EXECUTABLE) + set(CMAKE_CXX_LINK_EXECUTABLE + " -o ") +endif() + +mark_as_advanced( +CMAKE_VERBOSE_MAKEFILE +) + +set(CMAKE_CXX_USE_LINKER_INFORMATION TRUE) + +set(CMAKE_CXX_INFORMATION_LOADED 1) diff --git a/cmake/share/cmake-3.31/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake b/cmake/share/cmake-3.31/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b8e0ee739dd5d9bb4dcd34a5e11587ca05184cc0 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake @@ -0,0 +1,37 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + + +# Do NOT include this module directly into any of your code. It is meant as +# a library for Check*CompilerFlag.cmake modules. It's content may change in +# any way between releases. + +macro (CHECK_COMPILER_FLAG_COMMON_PATTERNS _VAR) + set(${_VAR} + FAIL_REGEX "[Uu]nrecogni[sz]ed .*option" # GNU, NAG, Fujitsu + FAIL_REGEX "switch .* is no longer supported" # GNU + FAIL_REGEX "unknown .*option" # Clang + FAIL_REGEX "optimization flag .* not supported" # Clang + FAIL_REGEX "unknown argument ignored" # Clang (cl) + FAIL_REGEX "ignoring unknown option" # MSVC, Intel + FAIL_REGEX "warning D9002" # MSVC, any lang + FAIL_REGEX "option.*not supported" # Intel + FAIL_REGEX "invalid argument .*option" # Intel + FAIL_REGEX "ignoring option .*argument required" # Intel + FAIL_REGEX "ignoring option .*argument is of wrong type" # Intel + FAIL_REGEX "[Uu]nknown option" # HP + FAIL_REGEX "[Ww]arning: [Oo]ption" # SunPro + FAIL_REGEX "command option .* is not recognized" # XL + FAIL_REGEX "command option .* contains an incorrect subargument" # XL + FAIL_REGEX "Option .* is not recognized. Option will be ignored." # XL + FAIL_REGEX "not supported in this configuration. ignored" # AIX + FAIL_REGEX "File with unknown suffix passed to linker" # PGI + FAIL_REGEX "[Uu]nknown switch" # PGI + FAIL_REGEX "WARNING: unknown flag:" # Open64 + FAIL_REGEX "Incorrect command line option:" # Borland + FAIL_REGEX "Warning: illegal option" # SunStudio 12 + FAIL_REGEX "[Ww]arning: Invalid suboption" # Fujitsu + FAIL_REGEX "An invalid option .* appears on the command line" # Cray + FAIL_REGEX "WARNING: invalid compiler option" # TI armcl + ) +endmacro () diff --git a/cmake/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake b/cmake/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake new file mode 100644 index 0000000000000000000000000000000000000000..32b42362e237ed61ecf911c465dcd3e62766548a --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake @@ -0,0 +1,123 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + + +# this file has flags that are shared across languages and sets +# cache values that can be initialized in the platform-compiler.cmake file +# it may be included by more than one language. + +string(APPEND CMAKE_EXE_LINKER_FLAGS_INIT " $ENV{LDFLAGS}") +string(APPEND CMAKE_SHARED_LINKER_FLAGS_INIT " $ENV{LDFLAGS}") +string(APPEND CMAKE_MODULE_LINKER_FLAGS_INIT " $ENV{LDFLAGS}") + +cmake_initialize_per_config_variable(CMAKE_EXE_LINKER_FLAGS "Flags used by the linker") +cmake_initialize_per_config_variable(CMAKE_SHARED_LINKER_FLAGS "Flags used by the linker during the creation of shared libraries") +cmake_initialize_per_config_variable(CMAKE_MODULE_LINKER_FLAGS "Flags used by the linker during the creation of modules") +cmake_initialize_per_config_variable(CMAKE_STATIC_LINKER_FLAGS "Flags used by the linker during the creation of static libraries") + +# Alias the build tool variable for backward compatibility. +set(CMAKE_BUILD_TOOL ${CMAKE_MAKE_PROGRAM}) + +mark_as_advanced( +CMAKE_VERBOSE_MAKEFILE +) + +# The Platform/* modules set a bunch of platform-specific flags expressed +# for the C toolchain. Other languages call this to copy them as defaults. +macro(_cmake_common_language_platform_flags lang) + if(NOT DEFINED CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS) + set(CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS}) + endif() + + if(NOT DEFINED CMAKE_${lang}_COMPILE_OPTIONS_PIC) + set(CMAKE_${lang}_COMPILE_OPTIONS_PIC ${CMAKE_C_COMPILE_OPTIONS_PIC}) + endif() + + if(NOT DEFINED CMAKE_${lang}_COMPILE_OPTIONS_PIE) + set(CMAKE_${lang}_COMPILE_OPTIONS_PIE ${CMAKE_C_COMPILE_OPTIONS_PIE}) + endif() + if(NOT DEFINED CMAKE_${lang}_LINK_OPTIONS_PIE) + set(CMAKE_${lang}_LINK_OPTIONS_PIE ${CMAKE_C_LINK_OPTIONS_PIE}) + endif() + if(NOT DEFINED CMAKE_${lang}_LINK_OPTIONS_NO_PIE) + set(CMAKE_${lang}_LINK_OPTIONS_NO_PIE ${CMAKE_C_LINK_OPTIONS_NO_PIE}) + endif() + + if(NOT DEFINED CMAKE_${lang}_COMPILE_OPTIONS_DLL) + set(CMAKE_${lang}_COMPILE_OPTIONS_DLL ${CMAKE_C_COMPILE_OPTIONS_DLL}) + endif() + + if(NOT DEFINED CMAKE_SHARED_LIBRARY_${lang}_FLAGS) + set(CMAKE_SHARED_LIBRARY_${lang}_FLAGS ${CMAKE_SHARED_LIBRARY_C_FLAGS}) + endif() + + if(NOT DEFINED CMAKE_SHARED_LIBRARY_LINK_${lang}_FLAGS) + set(CMAKE_SHARED_LIBRARY_LINK_${lang}_FLAGS ${CMAKE_SHARED_LIBRARY_LINK_C_FLAGS}) + endif() + + if(NOT DEFINED CMAKE_SHARED_LIBRARY_RUNTIME_${lang}_FLAG) + set(CMAKE_SHARED_LIBRARY_RUNTIME_${lang}_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG}) + endif() + + if(NOT DEFINED CMAKE_SHARED_LIBRARY_RUNTIME_${lang}_FLAG_SEP) + set(CMAKE_SHARED_LIBRARY_RUNTIME_${lang}_FLAG_SEP ${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG_SEP}) + endif() + + if(NOT DEFINED CMAKE_SHARED_LIBRARY_RPATH_LINK_${lang}_FLAG) + set(CMAKE_SHARED_LIBRARY_RPATH_LINK_${lang}_FLAG ${CMAKE_SHARED_LIBRARY_RPATH_LINK_C_FLAG}) + endif() + + if(NOT DEFINED CMAKE_EXE_EXPORTS_${lang}_FLAG) + set(CMAKE_EXE_EXPORTS_${lang}_FLAG ${CMAKE_EXE_EXPORTS_C_FLAG}) + endif() + + if(NOT DEFINED CMAKE_SHARED_LIBRARY_SONAME_${lang}_FLAG) + set(CMAKE_SHARED_LIBRARY_SONAME_${lang}_FLAG ${CMAKE_SHARED_LIBRARY_SONAME_C_FLAG}) + endif() + + if(NOT DEFINED CMAKE_EXECUTABLE_RUNTIME_${lang}_FLAG) + set(CMAKE_EXECUTABLE_RUNTIME_${lang}_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_${lang}_FLAG}) + endif() + + if(NOT DEFINED CMAKE_EXECUTABLE_RUNTIME_${lang}_FLAG_SEP) + set(CMAKE_EXECUTABLE_RUNTIME_${lang}_FLAG_SEP ${CMAKE_SHARED_LIBRARY_RUNTIME_${lang}_FLAG_SEP}) + endif() + + if(NOT DEFINED CMAKE_EXECUTABLE_RPATH_LINK_${lang}_FLAG) + set(CMAKE_EXECUTABLE_RPATH_LINK_${lang}_FLAG ${CMAKE_SHARED_LIBRARY_RPATH_LINK_${lang}_FLAG}) + endif() + + if(NOT DEFINED CMAKE_SHARED_LIBRARY_LINK_${lang}_WITH_RUNTIME_PATH) + set(CMAKE_SHARED_LIBRARY_LINK_${lang}_WITH_RUNTIME_PATH ${CMAKE_SHARED_LIBRARY_LINK_C_WITH_RUNTIME_PATH}) + endif() + + if(NOT DEFINED CMAKE_INCLUDE_FLAG_${lang}) + set(CMAKE_INCLUDE_FLAG_${lang} ${CMAKE_INCLUDE_FLAG_C}) + endif() + + # for most systems a module is the same as a shared library + # so unless the variable CMAKE_MODULE_EXISTS is set just + # copy the values from the LIBRARY variables + if(NOT CMAKE_MODULE_EXISTS) + set(CMAKE_SHARED_MODULE_${lang}_FLAGS ${CMAKE_SHARED_LIBRARY_${lang}_FLAGS}) + set(CMAKE_SHARED_MODULE_CREATE_${lang}_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS}) + endif() + + if(NOT DEFINED CMAKE_SHARED_MODULE_CREATE_${lang}_FLAGS) + set(CMAKE_SHARED_MODULE_CREATE_${lang}_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS}) + endif() + if(NOT DEFINED CMAKE_SHARED_MODULE_${lang}_FLAGS) + set(CMAKE_SHARED_MODULE_${lang}_FLAGS ${CMAKE_SHARED_LIBRARY_C_FLAGS}) + endif() + + foreach(type IN ITEMS SHARED_LIBRARY SHARED_MODULE EXE) + if(NOT DEFINED CMAKE_${type}_LINK_STATIC_${lang}_FLAGS) + set(CMAKE_${type}_LINK_STATIC_${lang}_FLAGS + ${CMAKE_${type}_LINK_STATIC_C_FLAGS}) + endif() + if(NOT DEFINED CMAKE_${type}_LINK_DYNAMIC_${lang}_FLAGS) + set(CMAKE_${type}_LINK_DYNAMIC_${lang}_FLAGS + ${CMAKE_${type}_LINK_DYNAMIC_C_FLAGS}) + endif() + endforeach() +endmacro() diff --git a/cmake/share/cmake-3.31/Modules/CMakeCompilerABI.h b/cmake/share/cmake-3.31/Modules/CMakeCompilerABI.h new file mode 100644 index 0000000000000000000000000000000000000000..3b3908ce296b47339a9d4b3812341d4069089238 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCompilerABI.h @@ -0,0 +1,45 @@ + +/* Size of a pointer-to-data in bytes. */ +#define SIZEOF_DPTR (sizeof(void*)) +const char info_sizeof_dptr[] = { + /* clang-format off */ + 'I', 'N', 'F', 'O', ':', 's', 'i', 'z', 'e', 'o', 'f', '_', 'd', 'p', 't', + 'r', '[', ('0' + ((SIZEOF_DPTR / 10) % 10)), ('0' + (SIZEOF_DPTR % 10)), ']', + '\0' + /* clang-format on */ +}; + +/* Byte order. Only one of these will have bytes in the right order. */ +static unsigned short const info_byte_order_big_endian[] = { + /* INFO:byte_order string for BIG_ENDIAN */ + 0x494E, 0x464F, 0x3A62, 0x7974, 0x655F, 0x6F72, 0x6465, 0x725B, + 0x4249, 0x475F, 0x454E, 0x4449, 0x414E, 0x5D00, 0x0000 +}; +static unsigned short const info_byte_order_little_endian[] = { + /* INFO:byte_order string for LITTLE_ENDIAN */ + 0x4E49, 0x4F46, 0x623A, 0x7479, 0x5F65, 0x726F, 0x6564, 0x5B72, + 0x494C, 0x5454, 0x454C, 0x455F, 0x444E, 0x4149, 0x5D4E, 0x0000 +}; + +/* Application Binary Interface. */ + +/* Check for (some) ARM ABIs. + * See e.g. http://wiki.debian.org/ArmEabiPort for some information on this. */ +#if defined(__GNU__) && defined(__ELF__) && defined(__ARM_EABI__) +# define ABI_ID "ELF ARMEABI" +#elif defined(__GNU__) && defined(__ELF__) && defined(__ARMEB__) +# define ABI_ID "ELF ARM" +#elif defined(__GNU__) && defined(__ELF__) && defined(__ARMEL__) +# define ABI_ID "ELF ARM" + +#elif defined(__linux__) && defined(__ELF__) && defined(__amd64__) && \ + defined(__ILP32__) +# define ABI_ID "ELF X32" + +#elif defined(__ELF__) +# define ABI_ID "ELF" +#endif + +#if defined(ABI_ID) +static char const info_abi[] = "INFO:abi[" ABI_ID "]"; +#endif diff --git a/cmake/share/cmake-3.31/Modules/CMakeCompilerCUDAArch.h b/cmake/share/cmake-3.31/Modules/CMakeCompilerCUDAArch.h new file mode 100644 index 0000000000000000000000000000000000000000..6bf915354ef415eb206d1a1f029cfa9f7b850e36 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCompilerCUDAArch.h @@ -0,0 +1,29 @@ +#include + +#include + +static bool cmakeCompilerCUDAArch() +{ + int count = 0; + if (cudaGetDeviceCount(&count) != cudaSuccess || count == 0) { + std::fprintf(stderr, "No CUDA devices found.\n"); + return -1; + } + + bool found = false; + const char* sep = ""; + for (int device = 0; device < count; ++device) { + cudaDeviceProp prop; + if (cudaGetDeviceProperties(&prop, device) == cudaSuccess) { + std::printf("%s%d%d", sep, prop.major, prop.minor); + sep = ";"; + found = true; + } + } + + if (!found) { + std::fprintf(stderr, "No CUDA architecture detected from any devices.\n"); + } + + return found; +} diff --git a/cmake/share/cmake-3.31/Modules/CMakeCompilerIdDetection.cmake b/cmake/share/cmake-3.31/Modules/CMakeCompilerIdDetection.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b084383c5198361f6e533b6c84f223caab361c38 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeCompilerIdDetection.cmake @@ -0,0 +1,162 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + + +function(_readFile file) + include(${file}) + get_filename_component(name ${file} NAME_WE) + string(REGEX REPLACE "-.*" "" CompilerId ${name}) + set(_compiler_id_version_compute_${CompilerId} ${_compiler_id_version_compute} PARENT_SCOPE) + set(_compiler_id_simulate_${CompilerId} ${_compiler_id_simulate} PARENT_SCOPE) + set(_compiler_id_pp_test_${CompilerId} ${_compiler_id_pp_test} PARENT_SCOPE) +endfunction() + +function(compiler_id_detection outvar lang) + + if (NOT "x${lang}" STREQUAL "xFortran" AND NOT "x${lang}" STREQUAL "xCSharp" + AND NOT "x${lang}" STREQUAL "xISPC") + file(GLOB lang_files + "${CMAKE_ROOT}/Modules/Compiler/*-DetermineCompiler.cmake") + set(nonlang CXX) + if ("x${lang}" STREQUAL "xCXX") + set(nonlang C) + endif() + + file(GLOB nonlang_files + "${CMAKE_ROOT}/Modules/Compiler/*-${nonlang}-DetermineCompiler.cmake") + list(REMOVE_ITEM lang_files ${nonlang_files}) + endif() + + set(files ${lang_files}) + if (files) + foreach(file ${files}) + _readFile(${file}) + endforeach() + + set(options ID_STRING VERSION_STRINGS ID_DEFINE PLATFORM_DEFAULT_COMPILER) + set(oneValueArgs PREFIX) + cmake_parse_arguments(CID "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + if (CID_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unrecognized arguments: \"${CID_UNPARSED_ARGUMENTS}\"") + endif() + + # Order is relevant here. For example, compilers which pretend to be + # GCC must appear before the actual GCC. + list(APPEND ordered_compilers + Intel + IntelLLVM + PathScale + Embarcadero + Borland + Watcom + OpenWatcom + SunPro + HP + Compaq + zOS + IBMClang + XLClang + XL + VisualAge + NVHPC + PGI + CrayClang + Cray + TI + FujitsuClang + Fujitsu + GHS + Tasking + OrangeC + ) + if ("x${lang}" STREQUAL "xC") + list(APPEND ordered_compilers + TinyCC + Bruce + ) + endif() + list(APPEND ordered_compilers + SCO + ARMCC + AppleClang + ARMClang + TIClang + ) + list(APPEND ordered_compilers + Clang + LCC + GNU + MSVC + ADSP + IAR + ) + if ("x${lang}" STREQUAL "xC") + list(APPEND ordered_compilers + SDCC + ) + endif() + + if("x${lang}" STREQUAL "xCUDA") + set(ordered_compilers NVIDIA Clang) + endif() + + if("x${lang}" STREQUAL "xHIP") + set(ordered_compilers NVIDIA Clang) + endif() + + if(CID_ID_DEFINE) + foreach(Id ${ordered_compilers}) + string(APPEND CMAKE_${lang}_COMPILER_ID_CONTENT "# define ${CID_PREFIX}COMPILER_IS_${Id} 0\n") + endforeach() + # Hard-code definitions for compilers that are no longer supported. + string(APPEND CMAKE_${lang}_COMPILER_ID_CONTENT "# define ${CID_PREFIX}COMPILER_IS_MIPSpro 0\n") + endif() + + set(pp_if "#if") + if (CID_VERSION_STRINGS) + string(APPEND CMAKE_${lang}_COMPILER_ID_CONTENT "\n/* Version number components: V=Version, R=Revision, P=Patch + Version date components: YYYY=Year, MM=Month, DD=Day */\n") + endif() + + foreach(Id ${ordered_compilers}) + if (NOT _compiler_id_pp_test_${Id}) + message(FATAL_ERROR "No preprocessor test for \"${Id}\"") + endif() + set(id_content "${pp_if} ${_compiler_id_pp_test_${Id}}\n") + if (CID_ID_STRING) + set(PREFIX ${CID_PREFIX}) + string(CONFIGURE "${_compiler_id_simulate_${Id}}" SIMULATE_BLOCK @ONLY) + string(APPEND id_content "# define ${CID_PREFIX}COMPILER_ID \"${Id}\"${SIMULATE_BLOCK}") + endif() + if (CID_ID_DEFINE) + string(APPEND id_content "# undef ${CID_PREFIX}COMPILER_IS_${Id}\n") + string(APPEND id_content "# define ${CID_PREFIX}COMPILER_IS_${Id} 1\n") + endif() + if (CID_VERSION_STRINGS) + set(PREFIX ${CID_PREFIX}) + set(MACRO_DEC DEC) + set(MACRO_HEX HEX) + string(CONFIGURE "${_compiler_id_version_compute_${Id}}" VERSION_BLOCK @ONLY) + string(APPEND id_content "${VERSION_BLOCK}\n") + endif() + string(APPEND CMAKE_${lang}_COMPILER_ID_CONTENT "\n${id_content}") + set(pp_if "#elif") + endforeach() + + if (CID_PLATFORM_DEFAULT_COMPILER) + set(platform_compiler_detection " +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__hpux) || defined(__hpua) +# define ${CID_PREFIX}COMPILER_ID \"HP\" + +#else /* unknown compiler */ +# define ${CID_PREFIX}COMPILER_ID \"\"") + endif() + + string(APPEND CMAKE_${lang}_COMPILER_ID_CONTENT "\n${platform_compiler_detection}\n#endif") + endif() + + set(${outvar} ${CMAKE_${lang}_COMPILER_ID_CONTENT} PARENT_SCOPE) +endfunction() diff --git a/cmake/share/cmake-3.31/Modules/CMakeConfigurableFile.in b/cmake/share/cmake-3.31/Modules/CMakeConfigurableFile.in new file mode 100644 index 0000000000000000000000000000000000000000..d556aba5f5f951bf44aa082c5295106e8f6e760b --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeConfigurableFile.in @@ -0,0 +1 @@ +@CMAKE_CONFIGURABLE_FILE_CONTENT@ diff --git a/cmake/share/cmake-3.31/Modules/CMakeDependentOption.cmake b/cmake/share/cmake-3.31/Modules/CMakeDependentOption.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0c536ccea547606b58f3c191a4e6eae2e66385a8 --- /dev/null +++ b/cmake/share/cmake-3.31/Modules/CMakeDependentOption.cmake @@ -0,0 +1,92 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#[=======================================================================[.rst: +CMakeDependentOption +-------------------- + +Macro to provide an option dependent on other options. + +This macro presents an option to the user only if a set of other +conditions are true. + +.. command:: cmake_dependent_option + + .. code-block:: cmake + + cmake_dependent_option(