rewrite: Initial codegen

Author: Friz64

analysis/Cargo.toml

@@ -6,3 +6,4 @@ edition = "2021"
 [dependencies]
 roxmltree = "0.19"
 tracing = "0.1"
+indexmap = "2"

analysis/src/cdecl.rs

@@ -33,7 +33,7 @@ pub struct UnsupportedCTok<'a>(&'a str);
 impl<'a> CTok<'a> {
     pub const SUPPORTED_KEYWORDS: &'static [&'static str] = &["const", "struct", "typedef", "void"];
 
-    pub fn lex_into(
+    pub(crate) fn lex_into(
         s: &'a str,
         out: &mut impl Extend<CTok<'a>>,
     ) -> Result<(), UnsupportedCTok<'a>> {
@@ -143,7 +143,7 @@ pub enum CDeclParseErrorKind<'a> {
 
 impl<'a> CDecl<'a> {
     // HACK(eddyb) this split is literally just to simplify error tracking.
-    pub fn parse<'b>(
+    pub(crate) fn parse<'b>(
         mode: CDeclMode,
         tokens: &'b [CTok<'a>],
     ) -> Result<CDecl<'a>, CDeclParseError<'a, 'b>> {

analysis/src/items/mod.rs

@@ -0,0 +1,46 @@
+use self::structures::Structure;
+use crate::{xml::UnwrapBorrowed, Library, LibraryId};
+use indexmap::IndexMap;
+use std::collections::HashMap;
+
+pub mod structures;
+
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
+pub struct Origin {
+    pub library_id: LibraryId,
+    pub required_by: RequiredBy,
+}
+
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
+pub enum RequiredBy {
+    Feature { major: u32, minor: u32 },
+    Extension { name: &'static str },
+}
+
+#[derive(Default, Debug)]
+pub struct Items {
+    pub structures: IndexMap<&'static str, Structure>,
+}
+
+impl Items {
+    pub(super) fn collect(
+        &mut self,
+        library: &Library,
+        types_require_map: HashMap<&str, RequiredBy>,
+    ) {
+        for structure in &library.xml.structs {
+            let name = structure.name.unwrap_borrowed();
+            let Some(&required_by) = types_require_map.get(name) else {
+                continue;
+            };
+
+            let origin = Origin {
+                library_id: library.id,
+                required_by,
+            };
+
+            let structure = Structure::new(origin, structure);
+            assert!(self.structures.insert(name, structure).is_none());
+        }
+    }
+}

analysis/src/items/structures.rs

@@ -0,0 +1,17 @@
+use super::Origin;
+use crate::xml::{self, UnwrapBorrowed};
+
+#[derive(Debug)]
+pub struct Structure {
+    pub origin: Origin,
+    pub name: &'static str,
+}
+
+impl Structure {
+    pub fn new(origin: Origin, xml: &xml::Structure) -> Structure {
+        Structure {
+            origin,
+            name: xml.name.unwrap_borrowed(),
+        }
+    }
+}

analysis/src/lib.rs

@@ -1,38 +1,129 @@
-mod xml;
+pub mod cdecl;
+pub mod items;
+pub mod xml;
 
-use std::{fs, path::Path};
+use items::{Items, RequiredBy};
+use std::{
+    collections::HashMap,
+    fmt::{self, Display},
+    fs,
+    path::{Path, PathBuf},
+};
 use tracing::{debug, error_span};
+use xml::UnwrapBorrowed;
 
 #[derive(Debug)]
 pub struct Analysis {
-    pub vk: Library,
-    pub video: Library,
+    vk: Library,
+    video: Library,
+    items: Items,
 }
 
 impl Analysis {
     pub fn new(vulkan_headers_path: impl AsRef<Path>) -> Analysis {
+        let vk = Library::new(LibraryId::Vk, &vulkan_headers_path);
+        let video = Library::new(LibraryId::Video, &vulkan_headers_path);
+
+        let mut items = Items::default();
+        vk.collect_into(&mut items);
+        video.collect_into(&mut items);
+
+        Analysis { vk, video, items }
+    }
+
+    pub fn vk_xml(&self) -> &xml::Registry {
+        &self.vk.xml
+    }
+
+    pub fn video_xml(&self) -> &xml::Registry {
+        &self.video.xml
+    }
+
+    pub fn items(&self) -> &Items {
+        &self.items
+    }
+}
+
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
+pub enum LibraryId {
+    Vk,
+    Video,
+}
+
+impl LibraryId {
+    fn xml_path(&self, vulkan_headers_path: impl AsRef<Path>) -> PathBuf {
         let vulkan_headers_path = vulkan_headers_path.as_ref();
-        Analysis {
-            vk: Library::new(vulkan_headers_path.join("registry/vk.xml")),
-            video: Library::new(vulkan_headers_path.join("registry/video.xml")),
+        match self {
+            LibraryId::Vk => vulkan_headers_path.join("registry/vk.xml"),
+            LibraryId::Video => vulkan_headers_path.join("registry/video.xml"),
         }
     }
 }
 
+impl Display for LibraryId {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str(match self {
+            LibraryId::Vk => "vk",
+            LibraryId::Video => "video",
+        })
+    }
+}
+
 #[derive(Debug)]
 pub struct Library {
-    _xml: xml::Registry,
+    id: LibraryId,
+    xml: xml::Registry,
 }
 
 impl Library {
-    fn new(xml_path: impl AsRef<Path>) -> Library {
-        let xml = error_span!("xml", path = %xml_path.as_ref().display()).in_scope(|| {
+    fn new(id: LibraryId, vulkan_headers_path: impl AsRef<Path>) -> Library {
+        let xml = error_span!("xml", library_id = %id).in_scope(|| {
+            let path = id.xml_path(vulkan_headers_path);
             // We leak the input string here for convenience, to avoid explicit lifetimes.
-            let xml_input = Box::leak(fs::read_to_string(xml_path).unwrap().into_boxed_str());
+            let input = Box::leak(fs::read_to_string(path).unwrap().into_boxed_str());
             debug!("parsing xml");
-            xml::Registry::parse(xml_input, "vulkan")
+            xml::Registry::parse(input, "vulkan")
         });
 
-        Library { _xml: xml }
+        Library { id, xml }
+    }
+
+    pub fn id(&self) -> LibraryId {
+        self.id
+    }
+
+    pub fn xml(&self) -> &xml::Registry {
+        &self.xml
+    }
+
+    fn collect_into(&self, items: &mut Items) {
+        let mut types_require_map = HashMap::new();
+
+        for feature in &self.xml.features {
+            let required_by = RequiredBy::Feature {
+                major: feature.major,
+                minor: feature.minor,
+            };
+
+            for require in &feature.requires {
+                for require_type in &require.types {
+                    types_require_map.insert(require_type.name.unwrap_borrowed(), required_by);
+                }
+            }
+        }
+
+        for extension in &self.xml.extensions {
+            let required_by = RequiredBy::Extension {
+                name: extension.name.unwrap_borrowed(),
+            };
+
+            for require in &extension.requires {
+                for require_type in &require.types {
+                    types_require_map.insert(require_type.name.unwrap_borrowed(), required_by);
+                }
+            }
+        }
+
+        items.collect(self, types_require_map);
     }
 }

analysis/src/xml.rs

@@ -9,7 +9,26 @@ type Node<'a> = roxmltree::Node<'a, 'static>;
 ///
 /// A `&'static str` is not used directly because sometimes string allocation is
 /// needed, for example when replacing `&quot;` with normal quotes.
-type XmlStr = Cow<'static, str>;
+pub type XmlStr = Cow<'static, str>;
+
+pub trait UnwrapBorrowed<'a, B>
+where
+    B: ToOwned + ?Sized,
+{
+    fn unwrap_borrowed(&self) -> &'a B;
+}
+
+impl<'a, B> UnwrapBorrowed<'a, B> for Cow<'a, B>
+where
+    B: ToOwned + ?Sized,
+{
+    fn unwrap_borrowed(&self) -> &'a B {
+        match self {
+            Cow::Borrowed(b) => b,
+            Cow::Owned(_) => panic!("Called `unwrap_borrowed` on `Owned` value"),
+        }
+    }
+}
 
 /// Retrieves the value of the `node`'s attribute named `name`.
 fn attribute(node: Node, name: &str) -> Option<XmlStr> {

ash-rewrite/src/generated/mod.rs

@@ -0,0 +1,3 @@
+// DO NOT EDIT: @generated by ash generator-rewrite 2.0.0
+pub mod video;
+pub mod vk;

ash-rewrite/src/generated/video/extension/codec_h264std.rs

@@ -0,0 +1,9 @@
+// DO NOT EDIT: @generated by ash generator-rewrite 2.0.0
+pub struct StdVideoH264SpsVuiFlags;
+pub struct StdVideoH264HrdParameters;
+pub struct StdVideoH264SequenceParameterSetVui;
+pub struct StdVideoH264SpsFlags;
+pub struct StdVideoH264ScalingLists;
+pub struct StdVideoH264SequenceParameterSet;
+pub struct StdVideoH264PpsFlags;
+pub struct StdVideoH264PictureParameterSet;

ash-rewrite/src/generated/video/extension/codec_h264std_decode.rs

@@ -0,0 +1,5 @@
+// DO NOT EDIT: @generated by ash generator-rewrite 2.0.0
+pub struct StdVideoDecodeH264PictureInfoFlags;
+pub struct StdVideoDecodeH264PictureInfo;
+pub struct StdVideoDecodeH264ReferenceInfoFlags;
+pub struct StdVideoDecodeH264ReferenceInfo;

ash-rewrite/src/generated/video/extension/codec_h264std_encode.rs

@@ -0,0 +1,13 @@
+// DO NOT EDIT: @generated by ash generator-rewrite 2.0.0
+pub struct StdVideoEncodeH264WeightTableFlags;
+pub struct StdVideoEncodeH264WeightTable;
+pub struct StdVideoEncodeH264SliceHeaderFlags;
+pub struct StdVideoEncodeH264PictureInfoFlags;
+pub struct StdVideoEncodeH264ReferenceInfoFlags;
+pub struct StdVideoEncodeH264ReferenceListsInfoFlags;
+pub struct StdVideoEncodeH264RefListModEntry;
+pub struct StdVideoEncodeH264RefPicMarkingEntry;
+pub struct StdVideoEncodeH264ReferenceListsInfo;
+pub struct StdVideoEncodeH264PictureInfo;
+pub struct StdVideoEncodeH264ReferenceInfo;
+pub struct StdVideoEncodeH264SliceHeader;