code_ownership 2.1.4 → 2.2.1

data/ext/cargo-vendor/bindgen-0.69.5/lib.rs

@@ -1,1380 +0,0 @@
-//! Generate Rust bindings for C and C++ libraries.
-//!
-//! Provide a C/C++ header file, receive Rust FFI code to call into C/C++
-//! functions and use types defined in the header.
-//!
-//! See the [`Builder`](./struct.Builder.html) struct for usage.
-//!
-//! See the [Users Guide](https://rust-lang.github.io/rust-bindgen/) for
-//! additional documentation.
-#![deny(missing_docs)]
-#![deny(unused_extern_crates)]
-#![deny(clippy::disallowed_methods)]
-// To avoid rather annoying warnings when matching with CXCursor_xxx as a
-// constant.
-#![allow(non_upper_case_globals)]
-// `quote!` nests quite deeply.
-#![recursion_limit = "128"]
-
-#[macro_use]
-extern crate bitflags;
-#[macro_use]
-extern crate lazy_static;
-#[macro_use]
-extern crate quote;
-
-#[cfg(feature = "logging")]
-#[macro_use]
-extern crate log;
-
-#[cfg(not(feature = "logging"))]
-#[macro_use]
-mod log_stubs;
-
-#[macro_use]
-mod extra_assertions;
-
-mod codegen;
-mod deps;
-mod options;
-mod time;
-
-pub mod callbacks;
-
-mod clang;
-#[cfg(feature = "experimental")]
-mod diagnostics;
-mod features;
-mod ir;
-mod parse;
-mod regex_set;
-
-pub use codegen::{
-    AliasVariation, EnumVariation, MacroTypeVariation, NonCopyUnionStyle,
-};
-#[cfg(feature = "__cli")]
-pub use features::RUST_TARGET_STRINGS;
-pub use features::{RustTarget, LATEST_STABLE_RUST};
-pub use ir::annotations::FieldVisibilityKind;
-pub use ir::function::Abi;
-pub use regex_set::RegexSet;
-
-use codegen::CodegenError;
-use features::RustFeatures;
-use ir::comment;
-use ir::context::{BindgenContext, ItemId};
-use ir::item::Item;
-use options::BindgenOptions;
-use parse::ParseError;
-
-use std::borrow::Cow;
-use std::collections::hash_map::Entry;
-use std::env;
-use std::ffi::OsStr;
-use std::fs::{File, OpenOptions};
-use std::io::{self, Write};
-use std::path::{Path, PathBuf};
-use std::process::{Command, Stdio};
-use std::rc::Rc;
-use std::str::FromStr;
-
-// Some convenient typedefs for a fast hash map and hash set.
-type HashMap<K, V> = rustc_hash::FxHashMap<K, V>;
-type HashSet<K> = rustc_hash::FxHashSet<K>;
-
-/// Default prefix for the anon fields.
-pub const DEFAULT_ANON_FIELDS_PREFIX: &str = "__bindgen_anon_";
-
-const DEFAULT_NON_EXTERN_FNS_SUFFIX: &str = "__extern";
-
-fn file_is_cpp(name_file: &str) -> bool {
-    name_file.ends_with(".hpp") ||
-        name_file.ends_with(".hxx") ||
-        name_file.ends_with(".hh") ||
-        name_file.ends_with(".h++")
-}
-
-fn args_are_cpp(clang_args: &[Box<str>]) -> bool {
-    for w in clang_args.windows(2) {
-        if w[0].as_ref() == "-xc++" || w[1].as_ref() == "-xc++" {
-            return true;
-        }
-        if w[0].as_ref() == "-x" && w[1].as_ref() == "c++" {
-            return true;
-        }
-        if w[0].as_ref() == "-include" && file_is_cpp(w[1].as_ref()) {
-            return true;
-        }
-    }
-    false
-}
-
-bitflags! {
-    /// A type used to indicate which kind of items we have to generate.
-    #[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-    pub struct CodegenConfig: u32 {
-        /// Whether to generate functions.
-        const FUNCTIONS = 1 << 0;
-        /// Whether to generate types.
-        const TYPES = 1 << 1;
-        /// Whether to generate constants.
-        const VARS = 1 << 2;
-        /// Whether to generate methods.
-        const METHODS = 1 << 3;
-        /// Whether to generate constructors
-        const CONSTRUCTORS = 1 << 4;
-        /// Whether to generate destructors.
-        const DESTRUCTORS = 1 << 5;
-    }
-}
-
-impl CodegenConfig {
-    /// Returns true if functions should be generated.
-    pub fn functions(self) -> bool {
-        self.contains(CodegenConfig::FUNCTIONS)
-    }
-
-    /// Returns true if types should be generated.
-    pub fn types(self) -> bool {
-        self.contains(CodegenConfig::TYPES)
-    }
-
-    /// Returns true if constants should be generated.
-    pub fn vars(self) -> bool {
-        self.contains(CodegenConfig::VARS)
-    }
-
-    /// Returns true if methds should be generated.
-    pub fn methods(self) -> bool {
-        self.contains(CodegenConfig::METHODS)
-    }
-
-    /// Returns true if constructors should be generated.
-    pub fn constructors(self) -> bool {
-        self.contains(CodegenConfig::CONSTRUCTORS)
-    }
-
-    /// Returns true if destructors should be generated.
-    pub fn destructors(self) -> bool {
-        self.contains(CodegenConfig::DESTRUCTORS)
-    }
-}
-
-impl Default for CodegenConfig {
-    fn default() -> Self {
-        CodegenConfig::all()
-    }
-}
-
-/// Formatting tools that can be used to format the bindings
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[non_exhaustive]
-pub enum Formatter {
-    /// Do not format the bindings.
-    None,
-    /// Use `rustfmt` to format the bindings.
-    Rustfmt,
-    #[cfg(feature = "prettyplease")]
-    /// Use `prettyplease` to format the bindings.
-    Prettyplease,
-}
-
-impl Default for Formatter {
-    fn default() -> Self {
-        Self::Rustfmt
-    }
-}
-
-impl FromStr for Formatter {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "none" => Ok(Self::None),
-            "rustfmt" => Ok(Self::Rustfmt),
-            #[cfg(feature = "prettyplease")]
-            "prettyplease" => Ok(Self::Prettyplease),
-            _ => Err(format!("`{}` is not a valid formatter", s)),
-        }
-    }
-}
-
-impl std::fmt::Display for Formatter {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let s = match self {
-            Self::None => "none",
-            Self::Rustfmt => "rustfmt",
-            #[cfg(feature = "prettyplease")]
-            Self::Prettyplease => "prettyplease",
-        };
-
-        s.fmt(f)
-    }
-}
-
-/// Configure and generate Rust bindings for a C/C++ header.
-///
-/// This is the main entry point to the library.
-///
-/// ```ignore
-/// use bindgen::builder;
-///
-/// // Configure and generate bindings.
-/// let bindings = builder().header("path/to/input/header")
-///     .allowlist_type("SomeCoolClass")
-///     .allowlist_function("do_some_cool_thing")
-///     .generate()?;
-///
-/// // Write the generated bindings to an output file.
-/// bindings.write_to_file("path/to/output.rs")?;
-/// ```
-///
-/// # Enums
-///
-/// Bindgen can map C/C++ enums into Rust in different ways. The way bindgen maps enums depends on
-/// the pattern passed to several methods:
-///
-/// 1. [`constified_enum_module()`](#method.constified_enum_module)
-/// 2. [`bitfield_enum()`](#method.bitfield_enum)
-/// 3. [`newtype_enum()`](#method.newtype_enum)
-/// 4. [`rustified_enum()`](#method.rustified_enum)
-///
-/// For each C enum, bindgen tries to match the pattern in the following order:
-///
-/// 1. Constified enum module
-/// 2. Bitfield enum
-/// 3. Newtype enum
-/// 4. Rustified enum
-///
-/// If none of the above patterns match, then bindgen will generate a set of Rust constants.
-///
-/// # Clang arguments
-///
-/// Extra arguments can be passed to with clang:
-/// 1. [`clang_arg()`](#method.clang_arg): takes a single argument
-/// 2. [`clang_args()`](#method.clang_args): takes an iterator of arguments
-/// 3. `BINDGEN_EXTRA_CLANG_ARGS` environment variable: whitespace separate
-///    environment variable of arguments
-///
-/// Clang arguments specific to your crate should be added via the
-/// `clang_arg()`/`clang_args()` methods.
-///
-/// End-users of the crate may need to set the `BINDGEN_EXTRA_CLANG_ARGS` environment variable to
-/// add additional arguments. For example, to build against a different sysroot a user could set
-/// `BINDGEN_EXTRA_CLANG_ARGS` to `--sysroot=/path/to/sysroot`.
-///
-/// # Regular expression arguments
-///
-/// Some [`Builder`] methods, such as `allowlist_*` and `blocklist_*`, allow regular
-/// expressions as arguments. These regular expressions will be enclosed in parentheses and
-/// anchored with `^` and `$`. So, if the argument passed is `<regex>`, the regular expression to be
-/// stored will be `^(<regex>)$`.
-///
-/// As a consequence, regular expressions passed to `bindgen` will try to match the whole name of
-/// an item instead of a section of it, which means that to match any items with the prefix
-/// `prefix`, the `prefix.*` regular expression must be used.
-///
-/// Certain methods, like [`Builder::allowlist_function`], use regular expressions over function
-/// names. To match C++ methods, prefix the name of the type where they belong, followed by an
-/// underscore. So, if the type `Foo` has a method `bar`, it can be matched with the `Foo_bar`
-/// regular expression.
-///
-/// Additionally, Objective-C interfaces can be matched by prefixing the regular expression with
-/// `I`. For example, the `IFoo` regular expression matches the `Foo` interface, and the `IFoo_foo`
-/// regular expression matches the `foo` method of the `Foo` interface.
-///
-/// Releases of `bindgen` with a version lesser or equal to `0.62.0` used to accept the wildcard
-/// pattern `*` as a valid regular expression. This behavior has been deprecated, and the `.*`
-/// regular expression must be used instead.
-#[derive(Debug, Default, Clone)]
-pub struct Builder {
-    options: BindgenOptions,
-}
-
-/// Construct a new [`Builder`](./struct.Builder.html).
-pub fn builder() -> Builder {
-    Default::default()
-}
-
-fn get_extra_clang_args(
-    parse_callbacks: &[Rc<dyn callbacks::ParseCallbacks>],
-) -> Vec<String> {
-    // Add any extra arguments from the environment to the clang command line.
-    let extra_clang_args = match get_target_dependent_env_var(
-        parse_callbacks,
-        "BINDGEN_EXTRA_CLANG_ARGS",
-    ) {
-        None => return vec![],
-        Some(s) => s,
-    };
-
-    // Try to parse it with shell quoting. If we fail, make it one single big argument.
-    if let Some(strings) = shlex::split(&extra_clang_args) {
-        return strings;
-    }
-    vec![extra_clang_args]
-}
-
-impl Builder {
-    /// Generate the Rust bindings using the options built up thus far.
-    pub fn generate(mut self) -> Result<Bindings, BindgenError> {
-        // Add any extra arguments from the environment to the clang command line.
-        self.options.clang_args.extend(
-            get_extra_clang_args(&self.options.parse_callbacks)
-                .into_iter()
-                .map(String::into_boxed_str),
-        );
-
-        for header in &self.options.input_headers {
-            self.options
-                .for_each_callback(|cb| cb.header_file(header.as_ref()));
-        }
-
-        // Transform input headers to arguments on the clang command line.
-        self.options.clang_args.extend(
-            self.options.input_headers
-                [..self.options.input_headers.len().saturating_sub(1)]
-                .iter()
-                .flat_map(|header| ["-include".into(), header.clone()]),
-        );
-
-        let input_unsaved_files =
-            std::mem::take(&mut self.options.input_header_contents)
-                .into_iter()
-                .map(|(name, contents)| {
-                    clang::UnsavedFile::new(name.as_ref(), contents.as_ref())
-                })
-                .collect::<Vec<_>>();
-
-        Bindings::generate(self.options, input_unsaved_files)
-    }
-
-    /// Preprocess and dump the input header files to disk.
-    ///
-    /// This is useful when debugging bindgen, using C-Reduce, or when filing
-    /// issues. The resulting file will be named something like `__bindgen.i` or
-    /// `__bindgen.ii`
-    pub fn dump_preprocessed_input(&self) -> io::Result<()> {
-        let clang =
-            clang_sys::support::Clang::find(None, &[]).ok_or_else(|| {
-                io::Error::new(
-                    io::ErrorKind::Other,
-                    "Cannot find clang executable",
-                )
-            })?;
-
-        // The contents of a wrapper file that includes all the input header
-        // files.
-        let mut wrapper_contents = String::new();
-
-        // Whether we are working with C or C++ inputs.
-        let mut is_cpp = args_are_cpp(&self.options.clang_args);
-
-        // For each input header, add `#include "$header"`.
-        for header in &self.options.input_headers {
-            is_cpp |= file_is_cpp(header);
-
-            wrapper_contents.push_str("#include \"");
-            wrapper_contents.push_str(header);
-            wrapper_contents.push_str("\"\n");
-        }
-
-        // For each input header content, add a prefix line of `#line 0 "$name"`
-        // followed by the contents.
-        for (name, contents) in &self.options.input_header_contents {
-            is_cpp |= file_is_cpp(name);
-
-            wrapper_contents.push_str("#line 0 \"");
-            wrapper_contents.push_str(name);
-            wrapper_contents.push_str("\"\n");
-            wrapper_contents.push_str(contents);
-        }
-
-        let wrapper_path = PathBuf::from(if is_cpp {
-            "__bindgen.cpp"
-        } else {
-            "__bindgen.c"
-        });
-
-        {
-            let mut wrapper_file = File::create(&wrapper_path)?;
-            wrapper_file.write_all(wrapper_contents.as_bytes())?;
-        }
-
-        let mut cmd = Command::new(clang.path);
-        cmd.arg("-save-temps")
-            .arg("-E")
-            .arg("-C")
-            .arg("-c")
-            .arg(&wrapper_path)
-            .stdout(Stdio::piped());
-
-        for a in &self.options.clang_args {
-            cmd.arg(a.as_ref());
-        }
-
-        for a in get_extra_clang_args(&self.options.parse_callbacks) {
-            cmd.arg(a);
-        }
-
-        let mut child = cmd.spawn()?;
-
-        let mut preprocessed = child.stdout.take().unwrap();
-        let mut file = File::create(if is_cpp {
-            "__bindgen.ii"
-        } else {
-            "__bindgen.i"
-        })?;
-        io::copy(&mut preprocessed, &mut file)?;
-
-        if child.wait()?.success() {
-            Ok(())
-        } else {
-            Err(io::Error::new(
-                io::ErrorKind::Other,
-                "clang exited with non-zero status",
-            ))
-        }
-    }
-}
-
-impl BindgenOptions {
-    fn build(&mut self) {
-        const REGEX_SETS_LEN: usize = 29;
-
-        let regex_sets: [_; REGEX_SETS_LEN] = [
-            &mut self.blocklisted_types,
-            &mut self.blocklisted_functions,
-            &mut self.blocklisted_items,
-            &mut self.blocklisted_files,
-            &mut self.blocklisted_vars,
-            &mut self.opaque_types,
-            &mut self.allowlisted_vars,
-            &mut self.allowlisted_types,
-            &mut self.allowlisted_functions,
-            &mut self.allowlisted_files,
-            &mut self.allowlisted_items,
-            &mut self.bitfield_enums,
-            &mut self.constified_enums,
-            &mut self.constified_enum_modules,
-            &mut self.newtype_enums,
-            &mut self.newtype_global_enums,
-            &mut self.rustified_enums,
-            &mut self.rustified_non_exhaustive_enums,
-            &mut self.type_alias,
-            &mut self.new_type_alias,
-            &mut self.new_type_alias_deref,
-            &mut self.bindgen_wrapper_union,
-            &mut self.manually_drop_union,
-            &mut self.no_partialeq_types,
-            &mut self.no_copy_types,
-            &mut self.no_debug_types,
-            &mut self.no_default_types,
-            &mut self.no_hash_types,
-            &mut self.must_use_types,
-        ];
-
-        let record_matches = self.record_matches;
-        #[cfg(feature = "experimental")]
-        {
-            let sets_len = REGEX_SETS_LEN + self.abi_overrides.len();
-            let names = if self.emit_diagnostics {
-                <[&str; REGEX_SETS_LEN]>::into_iter([
-                    "--blocklist-type",
-                    "--blocklist-function",
-                    "--blocklist-item",
-                    "--blocklist-file",
-                    "--blocklist-var",
-                    "--opaque-type",
-                    "--allowlist-type",
-                    "--allowlist-function",
-                    "--allowlist-var",
-                    "--allowlist-file",
-                    "--allowlist-item",
-                    "--bitfield-enum",
-                    "--newtype-enum",
-                    "--newtype-global-enum",
-                    "--rustified-enum",
-                    "--rustified-enum-non-exhaustive",
-                    "--constified-enum-module",
-                    "--constified-enum",
-                    "--type-alias",
-                    "--new-type-alias",
-                    "--new-type-alias-deref",
-                    "--bindgen-wrapper-union",
-                    "--manually-drop-union",
-                    "--no-partialeq",
-                    "--no-copy",
-                    "--no-debug",
-                    "--no-default",
-                    "--no-hash",
-                    "--must-use",
-                ])
-                .chain((0..self.abi_overrides.len()).map(|_| "--override-abi"))
-                .map(Some)
-                .collect()
-            } else {
-                vec![None; sets_len]
-            };
-
-            for (regex_set, name) in
-                self.abi_overrides.values_mut().chain(regex_sets).zip(names)
-            {
-                regex_set.build_with_diagnostics(record_matches, name);
-            }
-        }
-        #[cfg(not(feature = "experimental"))]
-        for regex_set in self.abi_overrides.values_mut().chain(regex_sets) {
-            regex_set.build(record_matches);
-        }
-
-        let rust_target = self.rust_target;
-        #[allow(deprecated)]
-        if rust_target <= RustTarget::Stable_1_30 {
-            deprecated_target_diagnostic(rust_target, self);
-        }
-
-        // Disable `untagged_union` if the target does not support it.
-        if !self.rust_features.untagged_union {
-            self.untagged_union = false;
-        }
-    }
-
-    /// Update rust target version
-    pub fn set_rust_target(&mut self, rust_target: RustTarget) {
-        self.rust_target = rust_target;
-
-        // Keep rust_features synced with rust_target
-        self.rust_features = rust_target.into();
-    }
-
-    /// Get features supported by target Rust version
-    pub fn rust_features(&self) -> RustFeatures {
-        self.rust_features
-    }
-
-    fn last_callback<T>(
-        &self,
-        f: impl Fn(&dyn callbacks::ParseCallbacks) -> Option<T>,
-    ) -> Option<T> {
-        self.parse_callbacks
-            .iter()
-            .filter_map(|cb| f(cb.as_ref()))
-            .last()
-    }
-
-    fn all_callbacks<T>(
-        &self,
-        f: impl Fn(&dyn callbacks::ParseCallbacks) -> Vec<T>,
-    ) -> Vec<T> {
-        self.parse_callbacks
-            .iter()
-            .flat_map(|cb| f(cb.as_ref()))
-            .collect()
-    }
-
-    fn for_each_callback(&self, f: impl Fn(&dyn callbacks::ParseCallbacks)) {
-        self.parse_callbacks.iter().for_each(|cb| f(cb.as_ref()));
-    }
-
-    fn process_comment(&self, comment: &str) -> String {
-        let comment = comment::preprocess(comment);
-        self.parse_callbacks
-            .last()
-            .and_then(|cb| cb.process_comment(&comment))
-            .unwrap_or(comment)
-    }
-}
-
-fn deprecated_target_diagnostic(target: RustTarget, _options: &BindgenOptions) {
-    warn!("The {} Rust target is deprecated. If you have a need to use this target please report it at https://github.com/rust-lang/rust-bindgen/issues", target);
-
-    #[cfg(feature = "experimental")]
-    if _options.emit_diagnostics {
-        use crate::diagnostics::{Diagnostic, Level};
-
-        let mut diagnostic = Diagnostic::default();
-        diagnostic.with_title(
-            format!("The {} Rust target is deprecated.", target),
-            Level::Warn,
-        );
-        diagnostic.add_annotation(
-            "This Rust target was passed to `--rust-target`",
-            Level::Info,
-        );
-        diagnostic.add_annotation("If you have a good reason to use this target please report it at https://github.com/rust-lang/rust-bindgen/issues", Level::Help);
-        diagnostic.display();
-    }
-}
-
-#[cfg(feature = "runtime")]
-fn ensure_libclang_is_loaded() {
-    if clang_sys::is_loaded() {
-        return;
-    }
-
-    // XXX (issue #350): Ensure that our dynamically loaded `libclang`
-    // doesn't get dropped prematurely, nor is loaded multiple times
-    // across different threads.
-
-    lazy_static! {
-        static ref LIBCLANG: std::sync::Arc<clang_sys::SharedLibrary> = {
-            clang_sys::load().expect("Unable to find libclang");
-            clang_sys::get_library().expect(
-                "We just loaded libclang and it had better still be \
-                 here!",
-            )
-        };
-    }
-
-    clang_sys::set_library(Some(LIBCLANG.clone()));
-}
-
-#[cfg(not(feature = "runtime"))]
-fn ensure_libclang_is_loaded() {}
-
-/// Error type for rust-bindgen.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[non_exhaustive]
-pub enum BindgenError {
-    /// The header was a folder.
-    FolderAsHeader(PathBuf),
-    /// Permissions to read the header is insufficient.
-    InsufficientPermissions(PathBuf),
-    /// The header does not exist.
-    NotExist(PathBuf),
-    /// Clang diagnosed an error.
-    ClangDiagnostic(String),
-    /// Code generation reported an error.
-    Codegen(CodegenError),
-}
-
-impl std::fmt::Display for BindgenError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            BindgenError::FolderAsHeader(h) => {
-                write!(f, "'{}' is a folder", h.display())
-            }
-            BindgenError::InsufficientPermissions(h) => {
-                write!(f, "insufficient permissions to read '{}'", h.display())
-            }
-            BindgenError::NotExist(h) => {
-                write!(f, "header '{}' does not exist.", h.display())
-            }
-            BindgenError::ClangDiagnostic(message) => {
-                write!(f, "clang diagnosed error: {}", message)
-            }
-            BindgenError::Codegen(err) => {
-                write!(f, "codegen error: {}", err)
-            }
-        }
-    }
-}
-
-impl std::error::Error for BindgenError {}
-
-/// Generated Rust bindings.
-#[derive(Debug)]
-pub struct Bindings {
-    options: BindgenOptions,
-    module: proc_macro2::TokenStream,
-}
-
-pub(crate) const HOST_TARGET: &str =
-    include_str!(concat!(env!("OUT_DIR"), "/host-target.txt"));
-
-// Some architecture triplets are different between rust and libclang, see #1211
-// and duplicates.
-fn rust_to_clang_target(rust_target: &str) -> Box<str> {
-    if rust_target.starts_with("aarch64-apple-") {
-        let mut clang_target = "arm64-apple-".to_owned();
-        clang_target
-            .push_str(rust_target.strip_prefix("aarch64-apple-").unwrap());
-        return clang_target.into();
-    } else if rust_target.starts_with("riscv64gc-") {
-        let mut clang_target = "riscv64-".to_owned();
-        clang_target.push_str(rust_target.strip_prefix("riscv64gc-").unwrap());
-        return clang_target.into();
-    } else if rust_target.ends_with("-espidf") {
-        let mut clang_target =
-            rust_target.strip_suffix("-espidf").unwrap().to_owned();
-        clang_target.push_str("-elf");
-        if clang_target.starts_with("riscv32imc-") {
-            clang_target = "riscv32-".to_owned() +
-                clang_target.strip_prefix("riscv32imc-").unwrap();
-        }
-        return clang_target.into();
-    } else if rust_target.starts_with("riscv32imc-") {
-        let mut clang_target = "riscv32-".to_owned();
-        clang_target.push_str(rust_target.strip_prefix("riscv32imc-").unwrap());
-        return clang_target.into();
-    } else if rust_target.starts_with("riscv32imac-") {
-        let mut clang_target = "riscv32-".to_owned();
-        clang_target
-            .push_str(rust_target.strip_prefix("riscv32imac-").unwrap());
-        return clang_target.into();
-    }
-    rust_target.into()
-}
-
-/// Returns the effective target, and whether it was explicitly specified on the
-/// clang flags.
-fn find_effective_target(clang_args: &[Box<str>]) -> (Box<str>, bool) {
-    let mut args = clang_args.iter();
-    while let Some(opt) = args.next() {
-        if opt.starts_with("--target=") {
-            let mut split = opt.split('=');
-            split.next();
-            return (split.next().unwrap().into(), true);
-        }
-
-        if opt.as_ref() == "-target" {
-            if let Some(target) = args.next() {
-                return (target.clone(), true);
-            }
-        }
-    }
-
-    // If we're running from a build script, try to find the cargo target.
-    if let Ok(t) = env::var("TARGET") {
-        return (rust_to_clang_target(&t), false);
-    }
-
-    (rust_to_clang_target(HOST_TARGET), false)
-}
-
-impl Bindings {
-    /// Generate bindings for the given options.
-    pub(crate) fn generate(
-        mut options: BindgenOptions,
-        input_unsaved_files: Vec<clang::UnsavedFile>,
-    ) -> Result<Bindings, BindgenError> {
-        ensure_libclang_is_loaded();
-
-        #[cfg(feature = "runtime")]
-        debug!(
-            "Generating bindings, libclang at {}",
-            clang_sys::get_library().unwrap().path().display()
-        );
-        #[cfg(not(feature = "runtime"))]
-        debug!("Generating bindings, libclang linked");
-
-        options.build();
-
-        let (effective_target, explicit_target) =
-            find_effective_target(&options.clang_args);
-
-        let is_host_build =
-            rust_to_clang_target(HOST_TARGET) == effective_target;
-
-        // NOTE: The is_host_build check wouldn't be sound normally in some
-        // cases if we were to call a binary (if you have a 32-bit clang and are
-        // building on a 64-bit system for example).  But since we rely on
-        // opening libclang.so, it has to be the same architecture and thus the
-        // check is fine.
-        if !explicit_target && !is_host_build {
-            options.clang_args.insert(
-                0,
-                format!("--target={}", effective_target).into_boxed_str(),
-            );
-        };
-
-        fn detect_include_paths(options: &mut BindgenOptions) {
-            if !options.detect_include_paths {
-                return;
-            }
-
-            // Filter out include paths and similar stuff, so we don't incorrectly
-            // promote them to `-isystem`.
-            let clang_args_for_clang_sys = {
-                let mut last_was_include_prefix = false;
-                options
-                    .clang_args
-                    .iter()
-                    .filter(|arg| {
-                        if last_was_include_prefix {
-                            last_was_include_prefix = false;
-                            return false;
-                        }
-
-                        let arg = arg.as_ref();
-
-                        // https://clang.llvm.org/docs/ClangCommandLineReference.html
-                        // -isystem and -isystem-after are harmless.
-                        if arg == "-I" || arg == "--include-directory" {
-                            last_was_include_prefix = true;
-                            return false;
-                        }
-
-                        if arg.starts_with("-I") ||
-                            arg.starts_with("--include-directory=")
-                        {
-                            return false;
-                        }
-
-                        true
-                    })
-                    .map(|arg| arg.clone().into())
-                    .collect::<Vec<_>>()
-            };
-
-            debug!(
-                "Trying to find clang with flags: {:?}",
-                clang_args_for_clang_sys
-            );
-
-            let clang = match clang_sys::support::Clang::find(
-                None,
-                &clang_args_for_clang_sys,
-            ) {
-                None => return,
-                Some(clang) => clang,
-            };
-
-            debug!("Found clang: {:?}", clang);
-
-            // Whether we are working with C or C++ inputs.
-            let is_cpp = args_are_cpp(&options.clang_args) ||
-                options.input_headers.iter().any(|h| file_is_cpp(h));
-
-            let search_paths = if is_cpp {
-                clang.cpp_search_paths
-            } else {
-                clang.c_search_paths
-            };
-
-            if let Some(search_paths) = search_paths {
-                for path in search_paths.into_iter() {
-                    if let Ok(path) = path.into_os_string().into_string() {
-                        options.clang_args.push("-isystem".into());
-                        options.clang_args.push(path.into_boxed_str());
-                    }
-                }
-            }
-        }
-
-        detect_include_paths(&mut options);
-
-        #[cfg(unix)]
-        fn can_read(perms: &std::fs::Permissions) -> bool {
-            use std::os::unix::fs::PermissionsExt;
-            perms.mode() & 0o444 > 0
-        }
-
-        #[cfg(not(unix))]
-        fn can_read(_: &std::fs::Permissions) -> bool {
-            true
-        }
-
-        if let Some(h) = options.input_headers.last() {
-            let path = Path::new(h.as_ref());
-            if let Ok(md) = std::fs::metadata(path) {
-                if md.is_dir() {
-                    return Err(BindgenError::FolderAsHeader(path.into()));
-                }
-                if !can_read(&md.permissions()) {
-                    return Err(BindgenError::InsufficientPermissions(
-                        path.into(),
-                    ));
-                }
-                options.clang_args.push(h.clone());
-            } else {
-                return Err(BindgenError::NotExist(path.into()));
-            }
-        }
-
-        for (idx, f) in input_unsaved_files.iter().enumerate() {
-            if idx != 0 || !options.input_headers.is_empty() {
-                options.clang_args.push("-include".into());
-            }
-            options.clang_args.push(f.name.to_str().unwrap().into())
-        }
-
-        debug!("Fixed-up options: {:?}", options);
-
-        let time_phases = options.time_phases;
-        let mut context = BindgenContext::new(options, &input_unsaved_files);
-
-        if is_host_build {
-            debug_assert_eq!(
-                context.target_pointer_size(),
-                std::mem::size_of::<*mut ()>(),
-                "{:?} {:?}",
-                effective_target,
-                HOST_TARGET
-            );
-        }
-
-        {
-            let _t = time::Timer::new("parse").with_output(time_phases);
-            parse(&mut context)?;
-        }
-
-        let (module, options) =
-            codegen::codegen(context).map_err(BindgenError::Codegen)?;
-
-        Ok(Bindings { options, module })
-    }
-
-    /// Write these bindings as source text to a file.
-    pub fn write_to_file<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
-        let file = OpenOptions::new()
-            .write(true)
-            .truncate(true)
-            .create(true)
-            .open(path.as_ref())?;
-        self.write(Box::new(file))?;
-        Ok(())
-    }
-
-    /// Write these bindings as source text to the given `Write`able.
-    pub fn write<'a>(&self, mut writer: Box<dyn Write + 'a>) -> io::Result<()> {
-        const NL: &str = if cfg!(windows) { "\r\n" } else { "\n" };
-
-        if !self.options.disable_header_comment {
-            let version =
-                option_env!("CARGO_PKG_VERSION").unwrap_or("(unknown version)");
-            writeln!(
-                writer,
-                "/* automatically generated by rust-bindgen {version} */{NL}",
-            )?;
-        }
-
-        for line in self.options.raw_lines.iter() {
-            writer.write_all(line.as_bytes())?;
-            writer.write_all(NL.as_bytes())?;
-        }
-
-        if !self.options.raw_lines.is_empty() {
-            writer.write_all(NL.as_bytes())?;
-        }
-
-        match self.format_tokens(&self.module) {
-            Ok(formatted_bindings) => {
-                writer.write_all(formatted_bindings.as_bytes())?;
-            }
-            Err(err) => {
-                eprintln!(
-                    "Failed to run rustfmt: {} (non-fatal, continuing)",
-                    err
-                );
-                writer.write_all(self.module.to_string().as_bytes())?;
-            }
-        }
-        Ok(())
-    }
-
-    /// Gets the rustfmt path to rustfmt the generated bindings.
-    fn rustfmt_path(&self) -> io::Result<Cow<PathBuf>> {
-        debug_assert!(matches!(self.options.formatter, Formatter::Rustfmt));
-        if let Some(ref p) = self.options.rustfmt_path {
-            return Ok(Cow::Borrowed(p));
-        }
-        if let Ok(rustfmt) = env::var("RUSTFMT") {
-            return Ok(Cow::Owned(rustfmt.into()));
-        }
-        #[cfg(feature = "which-rustfmt")]
-        match which::which("rustfmt") {
-            Ok(p) => Ok(Cow::Owned(p)),
-            Err(e) => {
-                Err(io::Error::new(io::ErrorKind::Other, format!("{}", e)))
-            }
-        }
-        #[cfg(not(feature = "which-rustfmt"))]
-        // No rustfmt binary was specified, so assume that the binary is called
-        // "rustfmt" and that it is in the user's PATH.
-        Ok(Cow::Owned("rustfmt".into()))
-    }
-
-    /// Formats a token stream with the formatter set up in `BindgenOptions`.
-    fn format_tokens(
-        &self,
-        tokens: &proc_macro2::TokenStream,
-    ) -> io::Result<String> {
-        let _t = time::Timer::new("rustfmt_generated_string")
-            .with_output(self.options.time_phases);
-
-        match self.options.formatter {
-            Formatter::None => return Ok(tokens.to_string()),
-            #[cfg(feature = "prettyplease")]
-            Formatter::Prettyplease => {
-                return Ok(prettyplease::unparse(&syn::parse_quote!(#tokens)));
-            }
-            Formatter::Rustfmt => (),
-        }
-
-        let rustfmt = self.rustfmt_path()?;
-        let mut cmd = Command::new(&*rustfmt);
-
-        cmd.stdin(Stdio::piped()).stdout(Stdio::piped());
-
-        if let Some(path) = self
-            .options
-            .rustfmt_configuration_file
-            .as_ref()
-            .and_then(|f| f.to_str())
-        {
-            cmd.args(["--config-path", path]);
-        }
-
-        let mut child = cmd.spawn()?;
-        let mut child_stdin = child.stdin.take().unwrap();
-        let mut child_stdout = child.stdout.take().unwrap();
-
-        let source = tokens.to_string();
-
-        // Write to stdin in a new thread, so that we can read from stdout on this
-        // thread. This keeps the child from blocking on writing to its stdout which
-        // might block us from writing to its stdin.
-        let stdin_handle = ::std::thread::spawn(move || {
-            let _ = child_stdin.write_all(source.as_bytes());
-            source
-        });
-
-        let mut output = vec![];
-        io::copy(&mut child_stdout, &mut output)?;
-
-        let status = child.wait()?;
-        let source = stdin_handle.join().expect(
-            "The thread writing to rustfmt's stdin doesn't do \
-             anything that could panic",
-        );
-
-        match String::from_utf8(output) {
-            Ok(bindings) => match status.code() {
-                Some(0) => Ok(bindings),
-                Some(2) => Err(io::Error::new(
-                    io::ErrorKind::Other,
-                    "Rustfmt parsing errors.".to_string(),
-                )),
-                Some(3) => {
-                    rustfmt_non_fatal_error_diagnostic(
-                        "Rustfmt could not format some lines",
-                        &self.options,
-                    );
-                    Ok(bindings)
-                }
-                _ => Err(io::Error::new(
-                    io::ErrorKind::Other,
-                    "Internal rustfmt error".to_string(),
-                )),
-            },
-            _ => Ok(source),
-        }
-    }
-}
-
-fn rustfmt_non_fatal_error_diagnostic(msg: &str, _options: &BindgenOptions) {
-    warn!("{}", msg);
-
-    #[cfg(feature = "experimental")]
-    if _options.emit_diagnostics {
-        use crate::diagnostics::{Diagnostic, Level};
-
-        Diagnostic::default()
-            .with_title(msg, Level::Warn)
-            .add_annotation(
-                "The bindings will be generated but not formatted.",
-                Level::Note,
-            )
-            .display();
-    }
-}
-
-impl std::fmt::Display for Bindings {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let mut bytes = vec![];
-        self.write(Box::new(&mut bytes) as Box<dyn Write>)
-            .expect("writing to a vec cannot fail");
-        f.write_str(
-            std::str::from_utf8(&bytes)
-                .expect("we should only write bindings that are valid utf-8"),
-        )
-    }
-}
-
-/// Determines whether the given cursor is in any of the files matched by the
-/// options.
-fn filter_builtins(ctx: &BindgenContext, cursor: &clang::Cursor) -> bool {
-    ctx.options().builtins || !cursor.is_builtin()
-}
-
-/// Parse one `Item` from the Clang cursor.
-fn parse_one(
-    ctx: &mut BindgenContext,
-    cursor: clang::Cursor,
-    parent: Option<ItemId>,
-) {
-    if !filter_builtins(ctx, &cursor) {
-        return;
-    }
-
-    match Item::parse(cursor, parent, ctx) {
-        Ok(..) => {}
-        Err(ParseError::Continue) => {}
-        Err(ParseError::Recurse) => {
-            cursor
-                .visit_sorted(ctx, |ctx, child| parse_one(ctx, child, parent));
-        }
-    }
-}
-
-/// Parse the Clang AST into our `Item` internal representation.
-fn parse(context: &mut BindgenContext) -> Result<(), BindgenError> {
-    use clang_sys::*;
-
-    let mut error = None;
-    for d in context.translation_unit().diags().iter() {
-        let msg = d.format();
-        let is_err = d.severity() >= CXDiagnostic_Error;
-        if is_err {
-            let error = error.get_or_insert_with(String::new);
-            error.push_str(&msg);
-            error.push('\n');
-        } else {
-            eprintln!("clang diag: {}", msg);
-        }
-    }
-
-    if let Some(message) = error {
-        return Err(BindgenError::ClangDiagnostic(message));
-    }
-
-    let cursor = context.translation_unit().cursor();
-
-    if context.options().emit_ast {
-        fn dump_if_not_builtin(cur: &clang::Cursor) -> CXChildVisitResult {
-            if !cur.is_builtin() {
-                clang::ast_dump(cur, 0)
-            } else {
-                CXChildVisit_Continue
-            }
-        }
-        cursor.visit(|cur| dump_if_not_builtin(&cur));
-    }
-
-    let root = context.root_module();
-    context.with_module(root, |ctx| {
-        cursor.visit_sorted(ctx, |ctx, child| parse_one(ctx, child, None))
-    });
-
-    assert!(
-        context.current_module() == context.root_module(),
-        "How did this happen?"
-    );
-    Ok(())
-}
-
-/// Extracted Clang version data
-#[derive(Debug)]
-pub struct ClangVersion {
-    /// Major and minor semver, if parsing was successful
-    pub parsed: Option<(u32, u32)>,
-    /// full version string
-    pub full: String,
-}
-
-/// Get the major and the minor semver numbers of Clang's version
-pub fn clang_version() -> ClangVersion {
-    ensure_libclang_is_loaded();
-
-    //Debian clang version 11.0.1-2
-    let raw_v: String = clang::extract_clang_version();
-    let split_v: Option<Vec<&str>> = raw_v
-        .split_whitespace()
-        .find(|t| t.chars().next().map_or(false, |v| v.is_ascii_digit()))
-        .map(|v| v.split('.').collect());
-    if let Some(v) = split_v {
-        if v.len() >= 2 {
-            let maybe_major = v[0].parse::<u32>();
-            let maybe_minor = v[1].parse::<u32>();
-            if let (Ok(major), Ok(minor)) = (maybe_major, maybe_minor) {
-                return ClangVersion {
-                    parsed: Some((major, minor)),
-                    full: raw_v.clone(),
-                };
-            }
-        }
-    };
-    ClangVersion {
-        parsed: None,
-        full: raw_v.clone(),
-    }
-}
-
-fn env_var<K: AsRef<str> + AsRef<OsStr>>(
-    parse_callbacks: &[Rc<dyn callbacks::ParseCallbacks>],
-    key: K,
-) -> Result<String, std::env::VarError> {
-    for callback in parse_callbacks {
-        callback.read_env_var(key.as_ref());
-    }
-    std::env::var(key)
-}
-
-/// Looks for the env var `var_${TARGET}`, and falls back to just `var` when it is not found.
-fn get_target_dependent_env_var(
-    parse_callbacks: &[Rc<dyn callbacks::ParseCallbacks>],
-    var: &str,
-) -> Option<String> {
-    if let Ok(target) = env_var(parse_callbacks, "TARGET") {
-        if let Ok(v) = env_var(parse_callbacks, format!("{}_{}", var, target)) {
-            return Some(v);
-        }
-        if let Ok(v) = env_var(
-            parse_callbacks,
-            format!("{}_{}", var, target.replace('-', "_")),
-        ) {
-            return Some(v);
-        }
-    }
-
-    env_var(parse_callbacks, var).ok()
-}
-
-/// A ParseCallbacks implementation that will act on file includes by echoing a rerun-if-changed
-/// line and on env variable usage by echoing a rerun-if-env-changed line
-///
-/// When running inside a `build.rs` script, this can be used to make cargo invalidate the
-/// generated bindings whenever any of the files included from the header change:
-/// ```
-/// use bindgen::builder;
-/// let bindings = builder()
-///     .header("path/to/input/header")
-///     .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
-///     .generate();
-/// ```
-#[derive(Debug)]
-pub struct CargoCallbacks {
-    rerun_on_header_files: bool,
-}
-
-/// Create a new `CargoCallbacks` value with [`CargoCallbacks::rerun_on_header_files`] disabled.
-///
-/// This constructor has been deprecated in favor of [`CargoCallbacks::new`] where
-/// [`CargoCallbacks::rerun_on_header_files`] is enabled by default.
-#[deprecated = "Use `CargoCallbacks::new()` instead. Please, check the documentation for further information."]
-pub const CargoCallbacks: CargoCallbacks = CargoCallbacks {
-    rerun_on_header_files: false,
-};
-
-impl CargoCallbacks {
-    /// Create a new `CargoCallbacks` value.
-    pub fn new() -> Self {
-        Self {
-            rerun_on_header_files: true,
-        }
-    }
-
-    /// Whether Cargo should re-run the build script if any of the input header files has changed.
-    ///
-    /// This option is enabled by default unless the deprecated [`const@CargoCallbacks`]
-    /// constructor is used.
-    pub fn rerun_on_header_files(mut self, doit: bool) -> Self {
-        self.rerun_on_header_files = doit;
-        self
-    }
-}
-
-impl Default for CargoCallbacks {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl callbacks::ParseCallbacks for CargoCallbacks {
-    fn header_file(&self, filename: &str) {
-        if self.rerun_on_header_files {
-            println!("cargo:rerun-if-changed={}", filename);
-        }
-    }
-
-    fn include_file(&self, filename: &str) {
-        println!("cargo:rerun-if-changed={}", filename);
-    }
-
-    fn read_env_var(&self, key: &str) {
-        println!("cargo:rerun-if-env-changed={}", key);
-    }
-}
-
-/// Test command_line_flag function.
-#[test]
-fn commandline_flag_unit_test_function() {
-    //Test 1
-    let bindings = crate::builder();
-    let command_line_flags = bindings.command_line_flags();
-
-    let test_cases = [
-        "--rust-target",
-        "--no-derive-default",
-        "--generate",
-        "functions,types,vars,methods,constructors,destructors",
-    ]
-    .iter()
-    .map(|&x| x.into())
-    .collect::<Vec<String>>();
-
-    assert!(test_cases.iter().all(|x| command_line_flags.contains(x)));
-
-    //Test 2
-    let bindings = crate::builder()
-        .header("input_header")
-        .allowlist_type("Distinct_Type")
-        .allowlist_function("safe_function");
-
-    let command_line_flags = bindings.command_line_flags();
-    let test_cases = [
-        "--rust-target",
-        "input_header",
-        "--no-derive-default",
-        "--generate",
-        "functions,types,vars,methods,constructors,destructors",
-        "--allowlist-type",
-        "Distinct_Type",
-        "--allowlist-function",
-        "safe_function",
-    ]
-    .iter()
-    .map(|&x| x.into())
-    .collect::<Vec<String>>();
-    println!("{:?}", command_line_flags);
-
-    assert!(test_cases.iter().all(|x| command_line_flags.contains(x)));
-}
-
-#[test]
-fn test_rust_to_clang_target() {
-    assert_eq!(
-        rust_to_clang_target("aarch64-apple-ios").as_ref(),
-        "arm64-apple-ios"
-    );
-}
-
-#[test]
-fn test_rust_to_clang_target_riscv() {
-    assert_eq!(
-        rust_to_clang_target("riscv64gc-unknown-linux-gnu").as_ref(),
-        "riscv64-unknown-linux-gnu"
-    );
-    assert_eq!(
-        rust_to_clang_target("riscv32imc-unknown-none-elf").as_ref(),
-        "riscv32-unknown-none-elf"
-    );
-    assert_eq!(
-        rust_to_clang_target("riscv32imac-unknown-none-elf").as_ref(),
-        "riscv32-unknown-none-elf"
-    );
-}
-
-#[test]
-fn test_rust_to_clang_target_espidf() {
-    assert_eq!(
-        rust_to_clang_target("riscv32imc-esp-espidf").as_ref(),
-        "riscv32-esp-elf"
-    );
-    assert_eq!(
-        rust_to_clang_target("xtensa-esp32-espidf").as_ref(),
-        "xtensa-esp32-elf"
-    );
-}