Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 236 insertions, 0 deletions

diff --git a/third_party/rust/clang-sys/src/support.rs b/third_party/rust/clang-sys/src/support.rs
new file mode 100644
index 0000000000..11247123a6
--- /dev/null
+++ b/third_party/rust/clang-sys/src/support.rs
@@ -0,0 +1,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(),

+    )

+}