From 759776dcdbda730a37eae7b4647ee045c44e267b Mon Sep 17 00:00:00 2001 From: Michael Hirsch Date: Thu, 15 Aug 2024 22:24:12 -0400 Subject: [PATCH] Help: Check*SourceRuns make text more concise. Similar simplification was done in !9641 for Check*SourceCompiles --- Modules/CheckCSourceRuns.cmake | 20 ++++++++----------- Modules/CheckCXXSourceRuns.cmake | 20 ++++++++----------- Modules/CheckFortranSourceRuns.cmake | 29 ++++++++-------------------- Modules/CheckOBJCSourceRuns.cmake | 22 +++++++++------------ Modules/CheckOBJCXXSourceRuns.cmake | 22 +++++++++------------ Modules/CheckSourceRuns.cmake | 20 ++++++++----------- 6 files changed, 50 insertions(+), 83 deletions(-) diff --git a/Modules/CheckCSourceRuns.cmake b/Modules/CheckCSourceRuns.cmake index 1275da549e..7a34ecea41 100644 --- a/Modules/CheckCSourceRuns.cmake +++ b/Modules/CheckCSourceRuns.cmake @@ -5,7 +5,7 @@ CheckCSourceRuns ---------------- -Check if given C source compiles and links into an executable and can +Check once if given C source compiles and links into an executable and can subsequently be run. .. command:: check_c_source_runs @@ -14,18 +14,14 @@ subsequently be run. check_c_source_runs( ) - Check that the source supplied in ```` can be compiled as a C source - file, linked as an executable and then run. The ```` must contain at - least a ``main()`` function. If the ```` could be built and run - successfully, the internal cache variable specified by ```` will - be set to 1, otherwise it will be set to an value that evaluates to boolean - false (e.g. an empty string or an error message). + Check once that the source supplied in ```` can be built, linked as an + executable, and then run. The ```` must contain at least a ``main()`` + function. - The check is only performed once, with the result cached in the variable named - by ````. Every subsequent CMake run will reuse this cached value - rather than performing the check again, even if the ```` changes. In - order to force the check to be re-evaluated, the variable named by - ```` must be manually removed from the cache. + The result is stored in the internal cache variable specified by + ````. Success of build and run is indicated by boolean ``true``. + Failure to build or run is indicated by boolean ``false`` such as an empty + string or an error message. See also :command:`check_source_runs` for a more general command syntax. diff --git a/Modules/CheckCXXSourceRuns.cmake b/Modules/CheckCXXSourceRuns.cmake index 8e84744708..0f14a3ab17 100644 --- a/Modules/CheckCXXSourceRuns.cmake +++ b/Modules/CheckCXXSourceRuns.cmake @@ -5,7 +5,7 @@ CheckCXXSourceRuns ------------------ -Check if given C++ source compiles and links into an executable and can +Check once if given C++ source compiles and links into an executable and can subsequently be run. .. command:: check_cxx_source_runs @@ -14,18 +14,14 @@ subsequently be run. check_cxx_source_runs( ) - Check that the source supplied in ```` can be compiled as a C++ source - file, linked as an executable and then run. The ```` must contain at - least a ``main()`` function. If the ```` could be built and run - successfully, the internal cache variable specified by ```` will - be set to 1, otherwise it will be set to an value that evaluates to boolean - false (e.g. an empty string or an error message). + Check once that the source supplied in ```` can be built, linked as an + executable, and then run. The ```` must contain at least a ``main()`` + function. - The check is only performed once, with the result cached in the variable named - by ````. Every subsequent CMake run will reuse this cached value - rather than performing the check again, even if the ```` changes. In - order to force the check to be re-evaluated, the variable named by - ```` must be manually removed from the cache. + The result is stored in the internal cache variable specified by + ````. Success of build and run is indicated by boolean ``true``. + Failure to build or run is indicated by boolean ``false`` such as an empty + string or an error message. See also :command:`check_source_runs` for a more general command syntax. diff --git a/Modules/CheckFortranSourceRuns.cmake b/Modules/CheckFortranSourceRuns.cmake index 9ead9c06a7..97d750a5ae 100644 --- a/Modules/CheckFortranSourceRuns.cmake +++ b/Modules/CheckFortranSourceRuns.cmake @@ -7,7 +7,7 @@ CheckFortranSourceRuns .. versionadded:: 3.14 -Check if given Fortran source compiles and links into an executable and can +Check once if given Fortran source compiles and links into an executable and can subsequently be run. .. command:: check_fortran_source_runs @@ -17,9 +17,13 @@ subsequently be run. check_fortran_source_runs( [SRC_EXT ]) - Check that the source supplied in ```` can be compiled as a Fortran source - file, linked as an executable and then run. The ```` must be a Fortran - ``program``. + Check once that the source supplied in ```` can be built, linked as an + executable, and then run. The ```` must contain a Fortran ``program``. + + The result is stored in the internal cache variable specified by + ````. Success of build and run is indicated by boolean ``true``. + Failure to build or run is indicated by boolean ``false`` such as an empty + string or an error message. .. code-block:: cmake @@ -29,26 +33,9 @@ subsequently be run. end program" HAVE_COARRAY) - This command can help avoid costly build processes when a compiler lacks support - for a necessary feature, or a particular vendor library is not compatible with - the Fortran compiler version being used. Some of these failures only occur at runtime - instead of linktime, and a trivial runtime example can catch the issue before the - main build process. - - If the ```` could be built and run - successfully, the internal cache variable specified by ```` will - be set to 1, otherwise it will be set to an value that evaluates to boolean - false (e.g. an empty string or an error message). - By default, the test source file will be given a ``.F90`` file extension. The ``SRC_EXT`` option can be used to override this with ``.`` instead. - The check is only performed once, with the result cached in the variable named - by ````. Every subsequent CMake run will reuse this cached value - rather than performing the check again, even if the ```` changes. In - order to force the check to be re-evaluated, the variable named by - ```` must be manually removed from the cache. - See also :command:`check_source_runs` for a more general command syntax. The compile and link commands can be influenced by setting any of the diff --git a/Modules/CheckOBJCSourceRuns.cmake b/Modules/CheckOBJCSourceRuns.cmake index f2316ce9a4..6b8160d744 100644 --- a/Modules/CheckOBJCSourceRuns.cmake +++ b/Modules/CheckOBJCSourceRuns.cmake @@ -7,8 +7,8 @@ CheckOBJCSourceRuns .. versionadded:: 3.16 -Check if given Objective-C source compiles and links into an executable and can -subsequently be run. +Check once if given Objective-C source compiles and links into an executable and +can subsequently be run. .. command:: check_objc_source_runs @@ -16,18 +16,14 @@ subsequently be run. check_objc_source_runs( ) - Check that the source supplied in ```` can be compiled as a Objective-C source - file, linked as an executable and then run. The ```` must contain at - least a ``main()`` function. If the ```` could be built and run - successfully, the internal cache variable specified by ```` will - be set to 1, otherwise it will be set to an value that evaluates to boolean - false (e.g. an empty string or an error message). + Check once that the source supplied in ```` can be built, linked as an + executable, and then run. The ```` must contain at least a ``main()`` + function. - The check is only performed once, with the result cached in the variable named - by ````. Every subsequent CMake run will reuse this cached value - rather than performing the check again, even if the ```` changes. In - order to force the check to be re-evaluated, the variable named by - ```` must be manually removed from the cache. + The result is stored in the internal cache variable specified by + ````. Success of build and run is indicated by boolean ``true``. + Failure to build or run is indicated by boolean ``false`` such as an empty + string or an error message. See also :command:`check_source_runs` for a more general command syntax. diff --git a/Modules/CheckOBJCXXSourceRuns.cmake b/Modules/CheckOBJCXXSourceRuns.cmake index 4181113ef9..f867ac38f9 100644 --- a/Modules/CheckOBJCXXSourceRuns.cmake +++ b/Modules/CheckOBJCXXSourceRuns.cmake @@ -7,8 +7,8 @@ CheckOBJCXXSourceRuns .. versionadded:: 3.16 -Check if given Objective-C++ source compiles and links into an executable and can -subsequently be run. +Check once if given Objective-C++ source compiles and links into an executable +and can subsequently be run. .. command:: check_objcxx_source_runs @@ -16,18 +16,14 @@ subsequently be run. check_objcxx_source_runs( ) - Check that the source supplied in ```` can be compiled as a Objective-C++ source - file, linked as an executable and then run. The ```` must contain at - least a ``main()`` function. If the ```` could be built and run - successfully, the internal cache variable specified by ```` will - be set to 1, otherwise it will be set to an value that evaluates to boolean - false (e.g. an empty string or an error message). + Check once that the source supplied in ```` can be built, linked as an + executable, and then run. The ```` must contain at least a ``main()`` + function. - The check is only performed once, with the result cached in the variable named - by ````. Every subsequent CMake run will reuse this cached value - rather than performing the check again, even if the ```` changes. In - order to force the check to be re-evaluated, the variable named by - ```` must be manually removed from the cache. + The result is stored in the internal cache variable specified by + ````. Success of build and run is indicated by boolean ``true``. + Failure to build or run is indicated by boolean ``false`` such as an empty + string or an error message. See also :command:`check_source_runs` for a more general command syntax. diff --git a/Modules/CheckSourceRuns.cmake b/Modules/CheckSourceRuns.cmake index 75636f48e8..84684b6d19 100644 --- a/Modules/CheckSourceRuns.cmake +++ b/Modules/CheckSourceRuns.cmake @@ -18,12 +18,14 @@ subsequently be run. check_source_runs( [SRC_EXT ]) - Check that the source supplied in ```` can be compiled as a source - file for the requested language, linked as an executable and then run. - If the ```` could be built and run successfully, the internal cache variable - specified by ```` will be set to 1, otherwise it will be set to - a value that evaluates to boolean false (e.g. an empty string or an error - message). + Check once that the ```` source supplied in ```` can be built, + linked as an executable, and then run. The ```` must contain at least + a ``main()`` function, or in Fortran a ``program``. + + The result is stored in the internal cache variable specified by + ````. Success of build and run is indicated by boolean ``true``. + Failure to build or run is indicated by boolean ``false`` such as an empty + string or an error message. By default, the test source file will be given a file extension that matches the requested language. The ``SRC_EXT`` option can be used to override this @@ -47,12 +49,6 @@ subsequently be run. end program" HAVE_COARRAY) - The check is only performed once, with the result cached in the variable named - by ````. Every subsequent CMake run will reuse this cached value - rather than performing the check again, even if the ```` changes. In - order to force the check to be re-evaluated, the variable named by - ```` must be manually removed from the cache. - The compile and link commands can be influenced by setting any of the following variables prior to calling ``check_source_runs()``