memonitor-sys 0.2.4

Automatically generated bindings for some of memonitor's backends.
Documentation 
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

use bindgen::callbacks::ParseCallbacks;
use bindgen::{Builder, EnumVariation};
use cfg_aliases::cfg_aliases;
use cmake::Config;
use std::env;
use std::fs::read_dir;
use std::path::PathBuf;

fn main() {
    cfg_aliases! {
        apple: { any(target_os = "macos", target_os = "ios", target_os = "dragonfly") },
    }

    let cur_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));

    {
        let log_dir = cur_dir.join("log");
        let mut build = Config::new(log_dir.as_path());
        let lib_out = build.build();
        println!(
            "cargo:rustc-link-search=native={}",
            lib_out.join("lib").display()
        );
        println!("cargo:rustc-link-lib=static=memonitor-log");

        let vk_bindings = Builder::default()
            .header(log_dir.join("include").join("log.h").to_string_lossy())
            .allowlist_function("log_.*")
            .allowlist_type("log_.*")
            .parse_callbacks(Box::new(PrefixRemover::new("log_")))
            .default_enum_style(EnumVariation::Rust {
                non_exhaustive: false,
            })
            .use_core()
            .generate()
            .expect("Failed to generate Log bindings");

        let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());

        vk_bindings
            .write_to_file(out_path.join("log_bindings.rs"))
            .expect("Couldn't write bindings");
    }

    #[cfg(feature = "vulkan")]
    {
        let vk_dir = cur_dir.join("vulkan");
        let submodules_dir = vk_dir.join("thirdparty");
        read_dir(submodules_dir.join("Vulkan-Headers"))
            .expect("Could not find Vulkan Headers. Did you forget to initialize submodules?");
        read_dir(submodules_dir.join("volk"))
            .expect("Could not find Volk. Did you forget to initialize submodules?");
        let mut build = Config::new(vk_dir.as_path());

        #[cfg(debug_assertions)]
        {
            build.define("MEMONITOR_VALIDATE", "ON");
        }

        // cmake-rs overrides the standard configured inside CMakeLists for some reason
        let lib_out = build.build();
        println!(
            "cargo:rustc-link-search=native={}",
            lib_out.join("lib").display()
        );
        println!("cargo:rustc-link-lib=static=volk");
        println!("cargo:rustc-link-lib=static=memonitor-vk");

        let vk_bindings = Builder::default()
            .header(vk_dir.join("include").join("memonitor.h").to_string_lossy())
            .allowlist_function("vk_.*")
            .allowlist_type("vk_.*")
            .parse_callbacks(Box::new(PrefixRemover::new("vk_")))
            .default_enum_style(EnumVariation::Rust {
                non_exhaustive: true,
            })
            .use_core()
            .generate()
            .expect("Failed to generate Vulkan bindings");

        let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());

        vk_bindings
            .write_to_file(out_path.join("vk_bindings.rs"))
            .expect("Couldn't write bindings");
    }

    #[cfg(all(feature = "cuda", not(apple)))]
    {
        let cuda_dir = cur_dir.join("cuda");
        let mut build = Config::new(cuda_dir.as_path());

        let lib_out = build.build();
        println!(
            "cargo:rustc-link-search=native={}",
            lib_out.join("lib").display()
        );
        println!("cargo:rustc-link-lib=static=memonitor-cuda");

        let cuda_bindings = Builder::default()
            .header(
                cuda_dir
                    .join("include")
                    .join("memonitor.h")
                    .to_string_lossy(),
            )
            .allowlist_function("cu_.*")
            .allowlist_type("cu_.*")
            .parse_callbacks(Box::new(PrefixRemover::new("cu_")))
            .default_enum_style(EnumVariation::Rust {
                non_exhaustive: true,
            })
            .use_core()
            .generate()
            .expect("Failed to generate Cuda bindings");

        let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());

        cuda_bindings
            .write_to_file(out_path.join("cuda_bindings.rs"))
            .expect("Couldn't write bindings");
    }
}

#[derive(Debug)]
struct PrefixRemover {
    prefix: String,
}

impl PrefixRemover {
    fn new(prefix: impl ToString) -> Self {
        Self {
            prefix: prefix.to_string(),
        }
    }
}

impl ParseCallbacks for PrefixRemover {
    fn item_name(&self, original_item_name: &str) -> Option<String> {
        original_item_name
            .strip_prefix(&self.prefix)
            .map(move |s| s.to_string())
    }
}