windows-bindgen

Author: kennykerr

crates/libs/bindgen/Cargo.toml

@@ -1,11 +1,10 @@
 [package]
 name = "windows-bindgen"
 version = "0.58.0"
-authors = ["Microsoft"]
 edition = "2021"
-rust-version = "1.70"
+rust-version = "1.74"
 license = "MIT OR Apache-2.0"
-description = "Windows metadata compiler"
+description = "Windows code generator"
 repository = "https://github.com/microsoft/windows-rs"
 readme = "readme.md"
 
@@ -16,21 +15,5 @@ workspace = true
 default-target = "x86_64-pc-windows-msvc"
 targets = []
 
-[features]
-default = ["metadata"]
-metadata = []
-
 [dependencies]
-windows-metadata = { path = "../metadata", version = "0.58.0" }
 rayon = "1.7"
-
-[dependencies.proc-macro2]
-version = "1.0"
-features = ["span-locations"]
-
-[dependencies.serde]
-version = "1.0"
-features = ["derive"]
-
-[dependencies.serde_json]
-version = "1.0"

crates/libs/bindgen/src/args.rs

@@ -0,0 +1,52 @@
+use super::*;
+
+pub struct Derive(HashMap<TypeName, Vec<String>>);
+
+impl Derive {
+    pub fn new(reader: &Reader, types: &TypeMap, derive: &[&str]) -> Self {
+        let mut map = HashMap::new();
+
+        for derive in derive {
+            let Some((name, derive)) = derive.split_once('=') else {
+                panic!("`--derive` must be `<type name>=Comma,Separated,List");
+            };
+
+            let tn = get_type_name(reader, name);
+
+            if !types.contains_key(&tn) {
+                panic!("type not included: `{name}`");
+            }
+
+            let derive = derive
+                .split(',')
+                .filter(|&derive| (!derive.is_empty()))
+                .map(|derive| derive.to_string())
+                .collect();
+            map.insert(tn, derive);
+        }
+
+        Self(map)
+    }
+
+    pub fn get(&self, type_name: TypeName) -> impl Iterator<Item = String> + '_ {
+        self.0.get(&type_name).into_iter().flatten().cloned()
+    }
+}
+
+fn get_type_name(reader: &Reader, path: &str) -> TypeName {
+    if let Some((namespace, name)) = path.rsplit_once('.') {
+        if let Some((namespace, types)) = reader.get_key_value(namespace) {
+            if let Some((name, _)) = types.get_key_value(name) {
+                return TypeName(namespace, name);
+            }
+        }
+    } else {
+        for (namespace, types) in reader.iter() {
+            if let Some((name, _)) = types.get_key_value(path) {
+                return TypeName(namespace, name);
+            }
+        }
+    }
+
+    panic!("type not found: `{path}`");
+}

crates/libs/bindgen/src/derive.rs

@@ -0,0 +1,30 @@
+use super::*;
+
+pub struct DeriveWriter(BTreeSet<String>);
+
+impl DeriveWriter {
+    pub fn new(writer: &Writer, type_name: TypeName) -> Self {
+        let mut derive = BTreeSet::new();
+        derive.extend(writer.config.derive.get(type_name));
+        Self(derive)
+    }
+
+    pub fn extend<I, S>(&mut self, iter: I)
+    where
+        I: IntoIterator<Item = S>,
+        S: AsRef<str> + ToString,
+    {
+        self.0.extend(iter.into_iter().map(|s| s.to_string()));
+    }
+}
+
+impl ToTokens for DeriveWriter {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        if !self.0.is_empty() {
+            let derive = self.0.iter().map(|derive| to_ident(derive));
+            tokens.combine(quote! {
+                #[derive(#(#derive),*)]
+            })
+        }
+    }
+}

crates/libs/bindgen/src/derive_writer.rs

@@ -0,0 +1,122 @@
+use super::*;
+
+#[derive(Debug, Default)]
+pub struct Filter(Vec<(String, bool)>);
+
+impl Filter {
+    pub fn new(reader: &Reader, include: &[&str], exclude: &[&str]) -> Self {
+        let mut rules = vec![];
+
+        for filter in include {
+            push_filter(reader, &mut rules, filter, true);
+        }
+
+        for filter in exclude {
+            push_filter(reader, &mut rules, filter, false)
+        }
+
+        debug_assert!(!rules.is_empty());
+
+        rules.sort_unstable_by(|left, right| {
+            let left = (left.0.len(), !left.1);
+            let right = (right.0.len(), !right.1);
+            left.cmp(&right).reverse()
+        });
+
+        Self(rules)
+    }
+
+    pub fn includes_namespace(&self, namespace: &str) -> bool {
+        for rule in &self.0 {
+            if rule.1 {
+                // include
+                if namespace_starts_with(&rule.0, namespace) {
+                    return true;
+                }
+                if namespace_starts_with(namespace, &rule.0) {
+                    return true;
+                }
+            } else {
+                // exclude
+                if namespace_starts_with(namespace, &rule.0) {
+                    return false;
+                }
+            }
+        }
+
+        false
+    }
+
+    pub fn includes_type_name(&self, name: TypeName) -> bool {
+        for rule in &self.0 {
+            if match_type_name(&rule.0, name.namespace(), name.name()) {
+                return rule.1;
+            }
+        }
+
+        false
+    }
+
+    pub fn excludes_type_name(&self, name: TypeName) -> bool {
+        for rule in &self.0 {
+            if match_type_name(&rule.0, name.namespace(), name.name()) {
+                return !rule.1;
+            }
+        }
+
+        false
+    }
+}
+
+fn push_filter(reader: &Reader, rules: &mut Vec<(String, bool)>, filter: &str, include: bool) {
+    if reader.contains_key(filter) {
+        rules.push((filter.to_string(), include));
+        return;
+    }
+
+    if let Some((namespace, name)) = filter.rsplit_once('.') {
+        if reader.with_full_name(namespace, name).next().is_some() {
+            rules.push((filter.to_string(), include));
+            return;
+        }
+    }
+
+    let mut pushed = false;
+
+    for (namespace, types) in reader.iter() {
+        if types.get(filter).is_some() {
+            rules.push((format!("{namespace}.{filter}"), include));
+            pushed = true;
+        }
+    }
+
+    if pushed {
+        return;
+    }
+
+    if reader
+        .keys()
+        .any(|namespace| namespace_starts_with(namespace, filter))
+    {
+        rules.push((filter.to_string(), include));
+        return;
+    }
+
+    panic!("type not found: `{filter}`");
+}
+
+fn match_type_name(rule: &str, namespace: &str, name: &str) -> bool {
+    if rule.len() <= namespace.len() {
+        return namespace.starts_with(rule);
+    }
+
+    if !rule.starts_with(namespace) {
+        return false;
+    }
+
+    if rule.as_bytes()[namespace.len()] != b'.' {
+        return false;
+    }
+
+    name == &rule[namespace.len() + 1..]
+}

crates/libs/bindgen/src/error.rs

@@ -0,0 +1,23 @@
+pub struct GUID(
+    pub u32,
+    pub u16,
+    pub u16,
+    pub u8,
+    pub u8,
+    pub u8,
+    pub u8,
+    pub u8,
+    pub u8,
+    pub u8,
+    pub u8,
+);
+
+impl std::fmt::Display for GUID {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{:08x?}-{:04x?}-{:04x?}-{:02x?}{:02x?}-{:02x?}{:02x?}{:02x?}{:02x?}{:02x?}{:02x?}",
+            self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10
+        )
+    }
+}

crates/libs/bindgen/src/filter.rs

@@ -0,0 +1,20 @@
+use std::io::BufRead;
+
+pub fn read_file_lines(path: &str) -> Vec<String> {
+    let file = std::io::BufReader::new(
+        std::fs::File::open(path).unwrap_or_else(|_| panic!("failed to open file `{path}`")),
+    );
+
+    file.lines()
+        .map(|line| line.unwrap_or_else(|_| panic!("failed to read file lines `{path}`")))
+        .collect()
+}
+
+pub fn write_to_file<C: AsRef<[u8]>>(path: &str, contents: C) {
+    if let Some(parent) = std::path::Path::new(path).parent() {
+        std::fs::create_dir_all(parent)
+            .unwrap_or_else(|_| panic!("failed to create directory `{path}`"));
+    }
+
+    std::fs::write(path, contents).unwrap_or_else(|_| panic!("failed to write file `{path}`"));
+}