更新libclamav库1.0.0版本

clamav/libclamav_rust/.cargo/vendor/cbindgen/src/main.rs

@@ -0,0 +1,314 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::env;
+use std::io;
+use std::path::{Path, PathBuf};
+use std::str::FromStr;
+
+extern crate clap;
+#[macro_use]
+extern crate log;
+extern crate proc_macro2;
+#[macro_use]
+extern crate serde;
+extern crate serde_json;
+#[macro_use]
+extern crate quote;
+#[macro_use]
+extern crate syn;
+extern crate toml;
+
+use clap::{App, Arg, ArgMatches};
+
+mod bindgen;
+mod logging;
+
+use crate::bindgen::{Bindings, Builder, Cargo, Config, Error, Profile, Style};
+
+fn apply_config_overrides<'a>(config: &mut Config, matches: &ArgMatches<'a>) {
+    // We allow specifying a language to override the config default. This is
+    // used by compile-tests.
+    if let Some(lang) = matches.value_of("lang") {
+        config.language = match lang.parse() {
+            Ok(lang) => lang,
+            Err(reason) => {
+                error!("{}", reason);
+                return;
+            }
+        }
+    }
+
+    if matches.is_present("cpp-compat") {
+        config.cpp_compat = true;
+    }
+
+    if matches.is_present("only-target-dependencies") {
+        config.only_target_dependencies = true;
+    }
+
+    if let Some(style) = matches.value_of("style") {
+        config.style = match style {
+            "Both" => Style::Both,
+            "both" => Style::Both,
+            "Tag" => Style::Tag,
+            "tag" => Style::Tag,
+            "Type" => Style::Type,
+            "type" => Style::Type,
+            _ => {
+                error!("Unknown style specified.");
+                return;
+            }
+        }
+    }
+
+    if let Some(profile) = matches.value_of("profile") {
+        config.parse.expand.profile = match Profile::from_str(profile) {
+            Ok(p) => p,
+            Err(e) => {
+                error!("{}", e);
+                return;
+            }
+        }
+    }
+
+    if matches.is_present("d") {
+        config.parse.parse_deps = true;
+    }
+}
+
+fn load_bindings<'a>(input: &Path, matches: &ArgMatches<'a>) -> Result<Bindings, Error> {
+    // If a file is specified then we load it as a single source
+    if !input.is_dir() {
+        // Load any config specified or search in the input directory
+        let mut config = match matches.value_of("config") {
+            Some(c) => Config::from_file(c).unwrap(),
+            None => Config::from_root_or_default(input),
+        };
+
+        apply_config_overrides(&mut config, matches);
+
+        return Builder::new()
+            .with_config(config)
+            .with_src(input)
+            .generate();
+    }
+
+    // We have to load a whole crate, so we use cargo to gather metadata
+    let lib = Cargo::load(
+        input,
+        matches.value_of("lockfile"),
+        matches.value_of("crate"),
+        true,
+        matches.is_present("clean"),
+        matches.is_present("only-target-dependencies"),
+        matches.value_of("metadata").map(Path::new),
+    )?;
+
+    // Load any config specified or search in the binding crate directory
+    let mut config = match matches.value_of("config") {
+        Some(c) => Config::from_file(c).unwrap(),
+        None => {
+            let binding_crate_dir = lib.find_crate_dir(&lib.binding_crate_ref());
+
+            if let Some(binding_crate_dir) = binding_crate_dir {
+                Config::from_root_or_default(&binding_crate_dir)
+            } else {
+                // This shouldn't happen
+                Config::from_root_or_default(input)
+            }
+        }
+    };
+
+    apply_config_overrides(&mut config, matches);
+
+    Builder::new()
+        .with_config(config)
+        .with_cargo(lib)
+        .generate()
+}
+
+fn main() {
+    let matches = App::new("cbindgen")
+        .version(bindgen::VERSION)
+        .about("Generate C bindings for a Rust library")
+        .arg(
+            Arg::with_name("v")
+                .short("v")
+                .multiple(true)
+                .help("Enable verbose logging"),
+        )
+        .arg(
+            Arg::with_name("verify")
+                .long("verify")
+                .help("Generate bindings and compare it to the existing bindings file and error if they are different"),
+        )
+        .arg(
+            Arg::with_name("config")
+                .short("c")
+                .long("config")
+                .value_name("PATH")
+                .help("Specify path to a `cbindgen.toml` config to use"),
+        )
+        .arg(
+            Arg::with_name("lang")
+                .short("l")
+                .long("lang")
+                .value_name("LANGUAGE")
+                .help("Specify the language to output bindings in")
+                .possible_values(&["c++", "C++", "c", "C", "cython", "Cython"]),
+        )
+        .arg(
+            Arg::with_name("cpp-compat")
+                .long("cpp-compat")
+                .help("Whether to add C++ compatibility to generated C bindings")
+        )
+        .arg(
+            Arg::with_name("only-target-dependencies")
+                .long("only-target-dependencies")
+                .help("Only fetch dependencies needed by the target platform. \
+                    The target platform defaults to the host platform; set TARGET to override.")
+        )
+        .arg(
+            Arg::with_name("style")
+                .short("s")
+                .long("style")
+                .value_name("STYLE")
+                .help("Specify the declaration style to use for bindings")
+                .possible_values(&["Both", "both", "Tag", "tag", "Type", "type"]),
+        )
+        .arg(
+            Arg::with_name("d")
+                .short("d")
+                .long("parse-dependencies")
+                .help("Whether to parse dependencies when generating bindings"),
+        )
+        .arg(
+            Arg::with_name("clean")
+                .long("clean")
+                .help(
+                    "Whether to use a new temporary directory for expanding macros. \
+                    Affects performance, but might be required in certain build processes.")
+                .required(false)
+        )
+        .arg(
+            Arg::with_name("INPUT")
+                .help(
+                    "A crate directory or source file to generate bindings for. \
+                    In general this is the folder where the Cargo.toml file of \
+                    source Rust library resides.")
+                .required(false)
+                .index(1),
+        )
+        .arg(
+            Arg::with_name("crate")
+                .long("crate")
+                .value_name("CRATE_NAME")
+                .help(
+                    "If generating bindings for a crate, \
+                     the specific crate to generate bindings for",
+                )
+                .required(false),
+        )
+        .arg(
+            Arg::with_name("out")
+                .short("o")
+                .long("output")
+                .value_name("PATH")
+                .help("The file to output the bindings to")
+                .required(false),
+        )
+        .arg(
+            Arg::with_name("lockfile")
+                .long("lockfile")
+                .value_name("PATH")
+                .help(
+                    "Specify the path to the Cargo.lock file explicitly. If this \
+                    is not specified, the Cargo.lock file is searched for in the \
+                    same folder as the Cargo.toml file. This option is useful for \
+                    projects that use workspaces.")
+                .required(false),
+        )
+        .arg(
+            Arg::with_name("metadata")
+                .long("metadata")
+                .value_name("PATH")
+                .help(
+                    "Specify the path to the output of a `cargo metadata` \
+                     command that allows to get dependency information. \
+                     This is useful because cargo metadata may be the longest \
+                     part of cbindgen runtime, and you may want to share it \
+                     across cbindgen invocations. By default cbindgen will run \
+                     `cargo metadata --all-features --format-version 1 \
+                      --manifest-path <path/to/crate/Cargo.toml>"
+                )
+                .required(false),
+        )
+        .arg(
+            Arg::with_name("profile")
+                .long("profile")
+                .value_name("PROFILE")
+                .help(
+                    "Specify the profile to use when expanding macros. \
+                     Has no effect otherwise."
+                )
+                .possible_values(&["Debug", "debug", "Release", "release"]),
+        )
+        .arg(
+            Arg::with_name("quiet")
+                .short("q")
+                .long("quiet")
+                .help("Report errors only (overrides verbosity options).")
+                .required(false),
+        )
+        .get_matches();
+
+    if !matches.is_present("out") && matches.is_present("verify") {
+        error!(
+            "Cannot verify bindings against `stdout`, please specify a file to compare against."
+        );
+        std::process::exit(2);
+    }
+
+    // Initialize logging
+    if matches.is_present("quiet") {
+        logging::ErrorLogger::init().unwrap();
+    } else {
+        match matches.occurrences_of("v") {
+            0 => logging::WarnLogger::init().unwrap(),
+            1 => logging::InfoLogger::init().unwrap(),
+            _ => logging::TraceLogger::init().unwrap(),
+        }
+    }
+
+    // Find the input directory
+    let input = match matches.value_of("INPUT") {
+        Some(input) => PathBuf::from(input),
+        None => env::current_dir().unwrap(),
+    };
+
+    let bindings = match load_bindings(&input, &matches) {
+        Ok(bindings) => bindings,
+        Err(msg) => {
+            error!("{}", msg);
+            error!("Couldn't generate bindings for {}.", input.display());
+            std::process::exit(1);
+        }
+    };
+
+    // Write the bindings file
+    match matches.value_of("out") {
+        Some(file) => {
+            let changed = bindings.write_to_file(file);
+
+            if matches.is_present("verify") && changed {
+                error!("Bindings changed: {}", file);
+                std::process::exit(2);
+            }
+        }
+        _ => {
+            bindings.write(io::stdout());
+        }
+    }
+}