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
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
|
# SPDX-License-Identifier: Apache-2.0
# Copyright 2012-2020 The Meson development team
# Copyright © 2023-2025 Intel Corporation
from __future__ import annotations
import os
import shutil
import typing as T
from . import coredata
from . import mesonlib
from . import mlog
from .mesonlib import MachineChoice, Popen_safe, search_version, quote_arg, split_args
from .programs import ExternalProgram
def detect_gcovr(gcovr_exe: str = 'gcovr', min_version: str = '3.3', log: bool = False) \
-> T.Union[T.Tuple[None, None], T.Tuple[str, str]]:
try:
p, found = Popen_safe([gcovr_exe, '--version'])[0:2]
except (FileNotFoundError, PermissionError):
# Doesn't exist in PATH or isn't executable
return None, None
found = search_version(found)
if p.returncode == 0 and mesonlib.version_compare(found, '>=' + min_version):
if log:
mlog.log('Found gcovr-{} at {}'.format(found, quote_arg(shutil.which(gcovr_exe))))
return gcovr_exe, found
return None, None
def detect_lcov(lcov_exe: str = 'lcov', log: bool = False) \
-> T.Union[T.Tuple[None, None], T.Tuple[str, str]]:
try:
p, found = Popen_safe([lcov_exe, '--version'])[0:2]
except (FileNotFoundError, PermissionError):
# Doesn't exist in PATH or isn't executable
return None, None
found = search_version(found)
if p.returncode == 0 and found:
if log:
mlog.log('Found lcov-{} at {}'.format(found, quote_arg(shutil.which(lcov_exe))))
return lcov_exe, found
return None, None
def detect_llvm_cov(suffix: T.Optional[str] = None) -> T.Optional[str]:
# If there's a known suffix or forced lack of suffix, use that
if suffix is not None:
if suffix == '':
tool = 'llvm-cov'
else:
tool = f'llvm-cov-{suffix}'
if shutil.which(tool) is not None:
return tool
else:
# Otherwise guess in the dark
tools = get_llvm_tool_names('llvm-cov')
for tool in tools:
if shutil.which(tool):
return tool
return None
def compute_llvm_suffix(coredata: coredata.CoreData) -> T.Optional[str]:
# Check to see if the user is trying to do coverage for either a C or C++ project
compilers = coredata.compilers[MachineChoice.BUILD]
cpp_compiler_is_clang = 'cpp' in compilers and compilers['cpp'].id == 'clang'
c_compiler_is_clang = 'c' in compilers and compilers['c'].id == 'clang'
# Extract first the C++ compiler if available. If it's a Clang of some kind, compute the suffix if possible
if cpp_compiler_is_clang:
suffix = compilers['cpp'].version.split('.')[0]
return suffix
# Then the C compiler, again checking if it's some kind of Clang and computing the suffix
if c_compiler_is_clang:
suffix = compilers['c'].version.split('.')[0]
return suffix
# Neither compiler is a Clang, or no compilers are for C or C++
return None
def detect_lcov_genhtml(lcov_exe: str = 'lcov', genhtml_exe: str = 'genhtml') \
-> T.Tuple[str, T.Optional[str], str]:
lcov_exe, lcov_version = detect_lcov(lcov_exe)
if shutil.which(genhtml_exe) is None:
genhtml_exe = None
return lcov_exe, lcov_version, genhtml_exe
def find_coverage_tools(coredata: coredata.CoreData) -> T.Tuple[T.Optional[str], T.Optional[str], T.Optional[str], T.Optional[str], T.Optional[str], T.Optional[str]]:
gcovr_exe, gcovr_version = detect_gcovr()
llvm_cov_exe = detect_llvm_cov(compute_llvm_suffix(coredata))
# Some platforms may provide versioned clang but only non-versioned llvm utils
if llvm_cov_exe is None:
llvm_cov_exe = detect_llvm_cov('')
lcov_exe, lcov_version, genhtml_exe = detect_lcov_genhtml()
return gcovr_exe, gcovr_version, lcov_exe, lcov_version, genhtml_exe, llvm_cov_exe
def detect_ninja(version: str = '1.8.2', log: bool = False) -> T.Optional[T.List[str]]:
r = detect_ninja_command_and_version(version, log)
return r[0] if r else None
def detect_ninja_command_and_version(version: str = '1.8.2', log: bool = False) -> T.Optional[T.Tuple[T.List[str], str]]:
env_ninja = os.environ.get('NINJA', None)
for n in [env_ninja] if env_ninja else ['ninja', 'ninja-build', 'samu']:
prog = ExternalProgram(n, silent=True)
if not prog.found():
continue
try:
p, found = Popen_safe(prog.command + ['--version'])[0:2]
except (FileNotFoundError, PermissionError):
# Doesn't exist in PATH or isn't executable
continue
found = found.strip()
# Perhaps we should add a way for the caller to know the failure mode
# (not found or too old)
if p.returncode == 0 and mesonlib.version_compare(found, '>=' + version):
if log:
name = os.path.basename(n)
if name.endswith('-' + found):
name = name[0:-1 - len(found)]
if name == 'ninja-build':
name = 'ninja'
if name == 'samu':
name = 'samurai'
mlog.log('Found {}-{} at {}'.format(name, found,
' '.join([quote_arg(x) for x in prog.command])))
return (prog.command, found)
return None
def get_llvm_tool_names(tool: str) -> T.List[str]:
# Ordered list of possible suffixes of LLVM executables to try. Start with
# base, then try newest back to oldest (3.5 is arbitrary), and finally the
# devel version. Please note that the development snapshot in Debian does
# not have a distinct name. Do not move it to the beginning of the list
# unless it becomes a stable release.
suffixes = [
'', # base (no suffix)
'-21.1', '21.1',
'-21', '21',
'-20.1', '20.1',
'-20', '20',
'-19.1', '19.1',
'-19', '19',
'-18.1', '18.1',
'-18', '18',
'-17', '17',
'-16', '16',
'-15', '15',
'-14', '14',
'-13', '13',
'-12', '12',
'-11', '11',
'-10', '10',
'-9', '90',
'-8', '80',
'-7', '70',
'-6.0', '60',
'-5.0', '50',
'-4.0', '40',
'-3.9', '39',
'-3.8', '38',
'-3.7', '37',
'-3.6', '36',
'-3.5', '35',
'-20', # Debian development snapshot
'-devel', # FreeBSD development snapshot
]
names: T.List[str] = []
for suffix in suffixes:
names.append(tool + suffix)
return names
def detect_scanbuild() -> T.List[str]:
""" Look for scan-build binary on build platform
First, if a SCANBUILD env variable has been provided, give it precedence
on all platforms.
For most platforms, scan-build is found is the PATH contains a binary
named "scan-build". However, some distribution's package manager (FreeBSD)
don't. For those, loop through a list of candidates to see if one is
available.
Return: a single-element list of the found scan-build binary ready to be
passed to Popen()
"""
exelist: T.List[str] = []
if 'SCANBUILD' in os.environ:
exelist = split_args(os.environ['SCANBUILD'])
else:
tools = get_llvm_tool_names('scan-build')
for tool in tools:
which = shutil.which(tool)
if which is not None:
exelist = [which]
break
if exelist:
tool = exelist[0]
if os.path.isfile(tool) and os.access(tool, os.X_OK):
return [tool]
return []
def detect_clangformat() -> T.List[str]:
""" Look for clang-format binary on build platform
Do the same thing as detect_scanbuild to find clang-format except it
currently does not check the environment variable.
Return: a single-element list of the found clang-format binary ready to be
passed to Popen()
"""
tools = get_llvm_tool_names('clang-format')
for tool in tools:
path = shutil.which(tool)
if path is not None:
return [path]
return []
def detect_clangtidy() -> T.List[str]:
""" Look for clang-tidy binary on build platform
Return: a single-element list of the found clang-tidy binary ready to be
passed to Popen()
"""
tools = get_llvm_tool_names('clang-tidy')
for tool in tools:
path = shutil.which(tool)
if path is not None:
return [path]
return []
def detect_clangapply() -> T.List[str]:
""" Look for clang-apply-replacements binary on build platform
Return: a single-element list of the found clang-apply-replacements binary
ready to be passed to Popen()
"""
tools = get_llvm_tool_names('clang-apply-replacements')
for tool in tools:
path = shutil.which(tool)
if path is not None:
return [path]
return []
|
