1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file LICENSE.rst or https://cmake.org/licensing for details.
#[=======================================================================[.rst:
CheckSourceRuns
-------------------
.. versionadded:: 3.19
This module provides a command to check whether a source code can be built
and run.
Load this module in a CMake project with:
.. code-block:: cmake
include(CheckSourceRuns)
Commands
^^^^^^^^
This module provides the following command:
.. command:: check_source_runs
Checks once whether the given source code compiles and links into an
executable that can subsequently be run:
.. code-block:: cmake
check_source_runs(<lang> <code> <variable> [SRC_EXT <extension>])
This command checks once that the ``<lang>`` source code supplied in
``<code>`` can be built, linked as an executable, and then run. The
result of the check is stored in the internal cache variable specified by
``<variable>``.
The arguments are:
``<lang>``
The programming language of the source ``<code>`` to check. Supported
languages are: ``C``, ``CXX``, ``CUDA``, ``Fortran``, ``HIP``, ``OBJC``,
and ``OBJCXX``.
.. versionadded:: 3.21
Support for ``HIP`` language.
``<code>``
The source code to be tested. It must contain a valid source program.
For example, it must contain at least a ``main()`` function (in C/C++),
or a ``program`` unit (in Fortran).
``<variable>``
Name of the internal cache variable with the result of the check. If
the code builds and runs with exit code ``0``, success is indicated by
a boolean true value. Failure to build or run is indicated by a boolean
false value, such as an empty string or an error message.
``SRC_EXT <extension>``
By default, the internal test source file used for the check will be
given a file extension that matches the requested language (e.g., ``.c``
for C, ``.cxx`` for C++, ``.F90`` for Fortran, etc.). This option can
be used to override this with the ``.<extension>`` instead.
.. rubric:: Variables Affecting the Check
The following variables may be set before calling this command to modify
the way the check is run:
.. include:: /module/include/CMAKE_REQUIRED_FLAGS.rst
.. include:: /module/include/CMAKE_REQUIRED_DEFINITIONS.rst
.. include:: /module/include/CMAKE_REQUIRED_INCLUDES.rst
.. include:: /module/include/CMAKE_REQUIRED_LINK_OPTIONS.rst
.. include:: /module/include/CMAKE_REQUIRED_LIBRARIES.rst
.. include:: /module/include/CMAKE_REQUIRED_LINK_DIRECTORIES.rst
.. include:: /module/include/CMAKE_REQUIRED_QUIET.rst
Examples
^^^^^^^^
Example: Basic Usage
""""""""""""""""""""
The following example demonstrates how to use this module to check whether
the C source code is supported and operational at runtime. The result of
the check is stored in the internal cache variable ``HAVE_NORETURN``.
.. code-block:: cmake
include(CheckSourceRuns)
check_source_runs(C "
#include <stdlib.h>
#include <stdnoreturn.h>
noreturn void f(){ exit(0); }
int main(void) { f(); return 1; }
" HAVE_NORETURN)
Example: Checking Fortran Code
""""""""""""""""""""""""""""""
Checking if Fortran source code runs successfully:
.. code-block:: cmake
include(CheckSourceRuns)
check_source_runs(Fortran "
program test
real :: x[*]
call co_sum(x)
end program
" HAVE_COARRAY)
Example: Checking C++ Code With Bracket Argument
""""""""""""""""""""""""""""""""""""""""""""""""
The following example demonstrates how to check whether the C++ standard
library is functional and ``std::vector`` works at runtime. If the source
compiles, links, and runs successfully, internal cache variable
``HAVE_WORKING_STD_VECTOR`` will be set to boolean true value. Code is
supplied using :ref:`Bracket Argument` for easier embedded quotes handling:
.. code-block:: cmake
:force:
include(CheckSourceRuns)
check_source_runs(CXX [[
#include <iostream>
#include <vector>
int main()
{
std::vector<int> v = {1, 2, 3};
if (v.size() != 3) return 1;
std::cout << "Vector works correctly." << std::endl;
return 0;
}
]] HAVE_WORKING_STD_VECTOR)
Example: Isolated Check
"""""""""""""""""""""""
In the following example, this module is used in combination with the
:module:`CMakePushCheckState` module to modify required compile definitions
and libraries when checking whether the C function ``sched_getcpu()`` is
supported and operational at runtime. For example, on some systems, the
``sched_getcpu()`` function may be available at compile time but not actually
implemented by the kernel. In such cases, it returns ``-1`` and sets
``errno`` to ``ENOSYS``. This check verifies that ``sched_getcpu()`` runs
successfully and stores a boolean result in the internal cache variable
``HAVE_SCHED_GETCPU``.
.. code-block:: cmake
include(CheckSourceRuns)
include(CMakePushCheckState)
cmake_push_check_state(RESET)
set(CMAKE_REQUIRED_DEFINITIONS -D_GNU_SOURCE)
if(CMAKE_SYSTEM_NAME STREQUAL "Haiku")
set(CMAKE_REQUIRED_LIBRARIES gnu)
endif()
check_source_runs(C "
#include <sched.h>
int main(void)
{
if (sched_getcpu() == -1) {
return 1;
}
return 0;
}
" HAVE_SCHED_GETCPU)
cmake_pop_check_state()
See Also
^^^^^^^^
* The :module:`CheckSourceCompiles` module to check whether a source code
can be built.
#]=======================================================================]
include_guard(GLOBAL)
include(Internal/CheckSourceRuns)
function(CHECK_SOURCE_RUNS _lang _source _var)
cmake_check_source_runs(${_lang} "${_source}" ${_var} ${ARGN})
endfunction()
|
