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
|
// SPDX-License-Identifier: Apache-2.0
//! Provides helper functionality.
use std::path::{Path, PathBuf};
use std::process::Command;
use std::{env, io};
use glob::{self, Pattern};
use libc::c_int;
use super::CXVersion;
//================================================
// Structs
//================================================
/// A `clang` executable.
#[derive(Clone, Debug)]
pub struct Clang {
/// The path to this `clang` executable.
pub path: PathBuf,
/// The version of this `clang` executable if it could be parsed.
pub version: Option<CXVersion>,
/// The directories searched by this `clang` executable for C headers if
/// they could be parsed.
pub c_search_paths: Option<Vec<PathBuf>>,
/// The directories searched by this `clang` executable for C++ headers if
/// they could be parsed.
pub cpp_search_paths: Option<Vec<PathBuf>>,
}
impl Clang {
fn new(path: impl AsRef<Path>, args: &[String]) -> Self {
Self {
path: path.as_ref().into(),
version: parse_version(path.as_ref()),
c_search_paths: parse_search_paths(path.as_ref(), "c", args),
cpp_search_paths: parse_search_paths(path.as_ref(), "c++", args),
}
}
/// Returns a `clang` executable if one can be found.
///
/// If the `CLANG_PATH` environment variable is set, that is the instance of
/// `clang` used. Otherwise, a series of directories are searched. First, if
/// a path is supplied, that is the first directory searched. Then, the
/// directory returned by `llvm-config --bindir` is searched. On macOS
/// systems, `xcodebuild -find clang` will next be queried. Last, the
/// directories in the system's `PATH` are searched.
///
/// ## Cross-compilation
///
/// If target arguments are provided (e.g., `-target` followed by a target
/// like `x86_64-unknown-linux-gnu`) then this method will prefer a
/// target-prefixed instance of `clang` (e.g.,
/// `x86_64-unknown-linux-gnu-clang` for the above example).
pub fn find(path: Option<&Path>, args: &[String]) -> Option<Clang> {
if let Ok(path) = env::var("CLANG_PATH") {
let p = Path::new(&path);
if p.is_file() && is_executable(&p).unwrap_or(false) {
return Some(Clang::new(p, args));
}
}
// Determine the cross-compilation target, if any.
let mut target = None;
for i in 0..args.len() {
if args[i] == "-target" && i + 1 < args.len() {
target = Some(&args[i + 1]);
}
}
// Collect the paths to search for a `clang` executable in.
let mut paths = vec![];
if let Some(path) = path {
paths.push(path.into());
}
if let Ok(path) = run_llvm_config(&["--bindir"]) {
if let Some(line) = path.lines().next() {
paths.push(line.into());
}
}
if cfg!(target_os = "macos") {
if let Ok((path, _)) = run("xcodebuild", &["-find", "clang"]) {
if let Some(line) = path.lines().next() {
paths.push(line.into());
}
}
}
if let Ok(path) = env::var("PATH") {
paths.extend(env::split_paths(&path));
}
// First, look for a target-prefixed `clang` executable.
if let Some(target) = target {
let default = format!("{}-clang{}", target, env::consts::EXE_SUFFIX);
let versioned = format!("{}-clang-[0-9]*{}", target, env::consts::EXE_SUFFIX);
let patterns = &[&default[..], &versioned[..]];
for path in &paths {
if let Some(path) = find(path, patterns) {
return Some(Clang::new(path, args));
}
}
}
// Otherwise, look for any other `clang` executable.
let default = format!("clang{}", env::consts::EXE_SUFFIX);
let versioned = format!("clang-[0-9]*{}", env::consts::EXE_SUFFIX);
let patterns = &[&default[..], &versioned[..]];
for path in paths {
if let Some(path) = find(&path, patterns) {
return Some(Clang::new(path, args));
}
}
None
}
}
//================================================
// Functions
//================================================
/// Returns the first match to the supplied glob patterns in the supplied
/// directory if there are any matches.
fn find(directory: &Path, patterns: &[&str]) -> Option<PathBuf> {
// Escape the directory in case it contains characters that have special
// meaning in glob patterns (e.g., `[` or `]`).
let directory = if let Some(directory) = directory.to_str() {
Path::new(&Pattern::escape(directory)).to_owned()
} else {
return None;
};
for pattern in patterns {
let pattern = directory.join(pattern).to_string_lossy().into_owned();
if let Some(path) = glob::glob(&pattern).ok()?.filter_map(|p| p.ok()).next() {
if path.is_file() && is_executable(&path).unwrap_or(false) {
return Some(path);
}
}
}
None
}
#[cfg(unix)]
fn is_executable(path: &Path) -> io::Result<bool> {
use std::ffi::CString;
use std::os::unix::ffi::OsStrExt;
let path = CString::new(path.as_os_str().as_bytes())?;
unsafe { Ok(libc::access(path.as_ptr(), libc::X_OK) == 0) }
}
#[cfg(not(unix))]
fn is_executable(_: &Path) -> io::Result<bool> {
Ok(true)
}
/// Attempts to run an executable, returning the `stdout` and `stderr` output if
/// successful.
fn run(executable: &str, arguments: &[&str]) -> Result<(String, String), String> {
Command::new(executable)
.args(arguments)
.output()
.map(|o| {
let stdout = String::from_utf8_lossy(&o.stdout).into_owned();
let stderr = String::from_utf8_lossy(&o.stderr).into_owned();
(stdout, stderr)
})
.map_err(|e| format!("could not run executable `{}`: {}", executable, e))
}
/// Runs `clang`, returning the `stdout` and `stderr` output.
fn run_clang(path: &Path, arguments: &[&str]) -> (String, String) {
run(&path.to_string_lossy().into_owned(), arguments).unwrap()
}
/// Runs `llvm-config`, returning the `stdout` output if successful.
fn run_llvm_config(arguments: &[&str]) -> Result<String, String> {
let config = env::var("LLVM_CONFIG_PATH").unwrap_or_else(|_| "llvm-config".to_string());
run(&config, arguments).map(|(o, _)| o)
}
/// Parses a version number if possible, ignoring trailing non-digit characters.
fn parse_version_number(number: &str) -> Option<c_int> {
number
.chars()
.take_while(|c| c.is_digit(10))
.collect::<String>()
.parse()
.ok()
}
/// Parses the version from the output of a `clang` executable if possible.
fn parse_version(path: &Path) -> Option<CXVersion> {
let output = run_clang(path, &["--version"]).0;
let start = output.find("version ")? + 8;
let mut numbers = output[start..].split_whitespace().next()?.split('.');
let major = numbers.next().and_then(parse_version_number)?;
let minor = numbers.next().and_then(parse_version_number)?;
let subminor = numbers.next().and_then(parse_version_number).unwrap_or(0);
Some(CXVersion {
Major: major,
Minor: minor,
Subminor: subminor,
})
}
/// Parses the search paths from the output of a `clang` executable if possible.
fn parse_search_paths(path: &Path, language: &str, args: &[String]) -> Option<Vec<PathBuf>> {
let mut clang_args = vec!["-E", "-x", language, "-", "-v"];
clang_args.extend(args.iter().map(|s| &**s));
let output = run_clang(path, &clang_args).1;
let start = output.find("#include <...> search starts here:")? + 34;
let end = output.find("End of search list.")?;
let paths = output[start..end].replace("(framework directory)", "");
Some(
paths
.lines()
.filter(|l| !l.is_empty())
.map(|l| Path::new(l.trim()).into())
.collect(),
)
}
|
