Basic metadata generation

crates/libs/bindgen/src/structs.rs

@@ -54,14 +54,14 @@ fn gen_struct_with_name(gen: &Gen, def: TypeDef, struct_name: &str, cfg: &Cfg) -
 
         if gen.reader.field_flags(f).literal() {
             quote! {}
-        } else if !gen.sys && flags.union() && !gen.reader.field_is_blittable(f, def) {
+        } else if !gen.sys && flags.explicit_layout() && !gen.reader.field_is_blittable(f, def) {
             quote! { pub #name: ::core::mem::ManuallyDrop<#ty>, }
         } else {
             quote! { pub #name: #ty, }
         }
     });
 
-    let struct_or_union = if flags.union() {
+    let struct_or_union = if flags.explicit_layout() {
         quote! { union }
     } else {
         quote! { struct }
@@ -153,7 +153,7 @@ fn gen_compare_traits(gen: &Gen, def: TypeDef, name: &TokenStream, cfg: &Cfg) ->
 
     if gen.sys {
         quote! {}
-    } else if gen.reader.type_def_is_blittable(def) || gen.reader.type_def_flags(def).union() || gen.reader.type_def_class_layout(def).is_some() {
+    } else if gen.reader.type_def_is_blittable(def) || gen.reader.type_def_flags(def).explicit_layout() || gen.reader.type_def_class_layout(def).is_some() {
         quote! {
             #features
             impl ::core::cmp::PartialEq for #name {
@@ -197,7 +197,7 @@ fn gen_compare_traits(gen: &Gen, def: TypeDef, name: &TokenStream, cfg: &Cfg) ->
 }
 
 fn gen_debug(gen: &Gen, def: TypeDef, ident: &TokenStream, cfg: &Cfg) -> TokenStream {
-    if gen.sys || gen.reader.type_def_has_union(def) || gen.reader.type_def_has_packing(def) {
+    if gen.sys || gen.reader.type_def_has_explicit_layout(def) || gen.reader.type_def_has_packing(def) {
         quote! {}
     } else {
         let name = ident.as_str();
@@ -245,7 +245,7 @@ fn gen_copy_clone(gen: &Gen, def: TypeDef, name: &TokenStream, cfg: &Cfg) -> Tok
                 }
             }
         }
-    } else if gen.reader.type_def_flags(def).union() {
+    } else if gen.reader.type_def_flags(def).explicit_layout() {
         quote! {
             #features
             impl ::core::clone::Clone for #name {

crates/libs/metadata/src/reader/flags.rs → crates/libs/metadata/src/common/flags.rs

@@ -1,8 +1,19 @@
+#[derive(Default)]
 pub struct FieldAttributes(pub usize);
+
+#[derive(Default)]
 pub struct MethodAttributes(pub usize);
+
+#[derive(Default)]
 pub struct MethodImplAttributes(pub usize);
+
+#[derive(Default)]
 pub struct ParamAttributes(pub usize);
+
+#[derive(Default)]
 pub struct PInvokeAttributes(pub usize);
+
+#[derive(Default)]
 pub struct TypeAttributes(pub usize);
 
 impl FieldAttributes {
@@ -42,13 +53,38 @@ impl PInvokeAttributes {
 }
 
 impl TypeAttributes {
-    pub fn union(&self) -> bool {
+    pub fn public(&self) -> bool {
+        self.0 & 0x1 != 0
+    }
+    pub fn set_public(&mut self) {
+        self.0 |= 0x1;
+    }
+
+    pub fn explicit_layout(&self) -> bool {
         self.0 & 0x10 != 0
     }
+    pub fn set_explicit_layout(&mut self) {
+        self.0 |= 0x10;
+    }
+
+    pub fn get_abstract(&self) -> bool {
+        self.0 & 0x80 != 0
+    }
+    pub fn set_abstract(&mut self) {
+        self.0 |= 0x80;
+    }
+
     pub fn winrt(&self) -> bool {
         self.0 & 0x4000 != 0
     }
+    pub fn set_winrt(&mut self) {
+        self.0 |= 0x4000;
+    }
+
     pub fn interface(&self) -> bool {
         self.0 & 0x20 != 0
     }
+    pub fn set_interface(&mut self) {
+        self.0 |= 0x20
+    }
 }

crates/libs/metadata/src/common/mod.rs

@@ -0,0 +1,3 @@
+mod flags;
+
+pub use flags::*;

crates/libs/metadata/src/imp.rs

@@ -0,0 +1,45 @@
+#[repr(C)]
+#[derive(Default)]
+pub struct METADATA_HEADER {
+    pub signature: u32,
+    pub major_version: u16,
+    pub minor_version: u16,
+    pub reserved: u32,
+    pub length: u32,
+    pub version: [u8; 20],
+    pub flags: u16,
+    pub streams: u16,
+}
+
+pub const METADATA_SIGNATURE: u32 = 0x424A_5342;
+
+extern "C" {
+    pub fn strlen(cs: *const u8) -> usize;
+}
+
+pub fn composite_index_size(tables: &[usize]) -> usize {
+    fn small(row_count: usize, bits: u8) -> bool {
+        (row_count as u64) < (1u64 << (16 - bits))
+    }
+
+    fn bits_needed(value: usize) -> u8 {
+        let mut value = value - 1;
+        let mut bits: u8 = 1;
+        loop {
+            value >>= 1;
+            if value == 0 {
+                break;
+            }
+            bits += 1;
+        }
+        bits
+    }
+
+    let bits_needed = bits_needed(tables.len());
+
+    if tables.iter().all(|table| small(*table, bits_needed)) {
+        2
+    } else {
+        4
+    }
+}

crates/libs/metadata/src/lib.rs

@@ -1,55 +1,13 @@
 #![allow(dead_code)]
 
 use std::collections::*;
+mod common;
+mod imp;
 pub mod reader;
 pub mod writer;
 
+pub use common::*;
+use imp::*;
 use std::io::*;
 use std::mem::*;
 use std::ptr::*;
-
-#[repr(C)]
-#[derive(Default)]
-struct METADATA_HEADER {
-    signature: u32,
-    major_version: u16,
-    minor_version: u16,
-    reserved: u32,
-    length: u32,
-    version: [u8; 20],
-    flags: u16,
-    streams: u16,
-}
-
-const METADATA_SIGNATURE: u32 = 0x424A_5342;
-
-extern "C" {
-    fn strlen(cs: *const u8) -> usize;
-}
-
-fn composite_index_size(tables: &[usize]) -> usize {
-    fn small(row_count: usize, bits: u8) -> bool {
-        (row_count as u64) < (1u64 << (16 - bits))
-    }
-
-    fn bits_needed(value: usize) -> u8 {
-        let mut value = value - 1;
-        let mut bits: u8 = 1;
-        loop {
-            value >>= 1;
-            if value == 0 {
-                break;
-            }
-            bits += 1;
-        }
-        bits
-    }
-
-    let bits_needed = bits_needed(tables.len());
-
-    if tables.iter().all(|table| small(*table, bits_needed)) {
-        2
-    } else {
-        4
-    }
-}

crates/libs/metadata/src/reader/mod.rs

@@ -1,7 +1,6 @@
 mod blob;
 mod codes;
 mod file;
-mod flags;
 mod guid;
 mod row;
 mod tree;
@@ -12,7 +11,6 @@ use super::*;
 pub use blob::*;
 pub use codes::*;
 pub use file::*;
-pub use flags::*;
 pub use guid::*;
 pub use r#type::*;
 pub use row::*;
@@ -94,7 +92,7 @@ pub enum AsyncKind {
     OperationWithProgress,
 }
 
-#[derive(PartialEq, Eq)]
+#[derive(PartialEq, Eq, Debug)]
 pub enum TypeKind {
     Interface,
     Class,
@@ -589,7 +587,7 @@ impl<'a> Reader<'a> {
         }
         fn type_def_size(reader: &Reader, def: TypeDef) -> usize {
             if reader.type_def_kind(def) == TypeKind::Struct {
-                if reader.type_def_flags(def).union() {
+                if reader.type_def_flags(def).explicit_layout() {
                     reader.type_def_fields(def).map(|field| type_size(reader, &reader.field_type(field, Some(def)))).max().unwrap_or(1)
                 } else {
                     reader.type_def_fields(def).fold(0, |sum, field| sum + type_size(reader, &reader.field_type(field, Some(def))))
@@ -721,7 +719,7 @@ impl<'a> Reader<'a> {
     }
     pub fn type_def_stdcall(&self, row: TypeDef) -> usize {
         if self.type_def_kind(row) == TypeKind::Struct {
-            if self.type_def_flags(row).union() {
+            if self.type_def_flags(row).explicit_layout() {
                 self.type_def_fields(row).map(|field| self.type_stdcall(&self.field_type(field, Some(row)))).max().unwrap_or(1)
             } else {
                 self.type_def_fields(row).fold(0, |sum, field| sum + self.type_stdcall(&self.field_type(field, Some(row))))
@@ -806,15 +804,15 @@ impl<'a> Reader<'a> {
             _ => false,
         }
     }
-    pub fn type_def_has_union(&self, row: TypeDef) -> bool {
+    pub fn type_def_has_explicit_layout(&self, row: TypeDef) -> bool {
         if self.type_def_kind(row) != TypeKind::Struct {
             return false;
         }
         fn check(reader: &Reader, row: TypeDef) -> bool {
-            if reader.type_def_flags(row).union() {
+            if reader.type_def_flags(row).explicit_layout() {
                 return true;
             }
-            if reader.type_def_fields(row).any(|field| reader.type_has_union(&reader.field_type(field, Some(row)))) {
+            if reader.type_def_fields(row).any(|field| reader.type_has_explicit_layout(&reader.field_type(field, Some(row)))) {
                 return true;
             }
             false
@@ -1357,10 +1355,10 @@ impl<'a> Reader<'a> {
             _ => true,
         }
     }
-    pub fn type_has_union(&self, ty: &Type) -> bool {
+    pub fn type_has_explicit_layout(&self, ty: &Type) -> bool {
         match ty {
-            Type::TypeDef((row, _)) => self.type_def_has_union(*row),
-            Type::Win32Array((ty, _)) => self.type_has_union(ty),
+            Type::TypeDef((row, _)) => self.type_def_has_explicit_layout(*row),
+            Type::Win32Array((ty, _)) => self.type_has_explicit_layout(ty),
             _ => false,
         }
     }

crates/libs/metadata/src/writer/mod.rs

@@ -1,29 +1,15 @@
 mod blobs;
 mod gen;
 mod helpers;
-mod pe;
+pub mod pe;
 mod strings;
 mod tables;
-use blobs::*;
+mod type_name;
 
 use super::*;
+use blobs::*;
 pub use gen::*;
-use helpers::*;
+pub use helpers::*;
 use strings::*;
-use tables::*;
-
-pub fn test() {
-    let mut tables = Tables::new();
-    tables.module.push(Module::new("test.winmd"));
-    tables.type_def.push(TypeDef::module());
-
-    let mut stringable = TypeDef::winrt_interface("IStringable", "Windows.Foundation");
-    stringable.method_list.push(MethodDef::new("ToString"));
-    tables.type_def.push(stringable);
-
-    let mut closable = TypeDef::winrt_interface("IClosable", "Windows.Foundation");
-    closable.method_list.push(MethodDef::new("Close"));
-    tables.type_def.push(closable);
-
-    pe::write("/git/test.winmd", tables);
-}
+pub use tables::*;
+pub use type_name::*;

crates/libs/metadata/src/writer/pe.rs

@@ -1,7 +1,7 @@
 use super::*;
 use windows_sys::{Win32::System::Diagnostics::Debug::*, Win32::System::SystemServices::*};
 
-pub(crate) fn write(filename: &str, tables: Tables) {
+pub fn write(filename: &str, tables: Tables) {
     let mut dos: IMAGE_DOS_HEADER = unsafe { zeroed() };
     dos.e_magic = IMAGE_DOS_SIGNATURE as _;
     dos.e_lfarlc = 64;
@@ -80,7 +80,8 @@ pub(crate) fn write(filename: &str, tables: Tables) {
 
     let mut buffer = Vec::<u8>::new();
     buffer.write(&dos);
-    buffer.write(&IMAGE_NT_SIGNATURE);
+    // TODO: workaround for https://github.com/microsoft/win32metadata/issues/963
+    buffer.write(&(IMAGE_NT_SIGNATURE as u32));
     buffer.write(&file);
     buffer.write(&optional);
     buffer.write(&section);

crates/libs/metadata/src/writer/tables/mod.rs

@@ -92,7 +92,7 @@ impl Tables {
         }
 
         for type_def in &self.type_def {
-            buffer.write(&type_def.flags);
+            buffer.write(&(type_def.flags.0 as u32));
             buffer.write(&strings.insert(&type_def.name));
             buffer.write(&strings.insert(&type_def.namespace));
             buffer.write(&0u16); // Extends
@@ -183,30 +183,3 @@ fn write_index(buffer: &mut Vec<u8>, index: usize, len: usize) {
         buffer.write(&(index as u32 + 1))
     }
 }
-
-// fn coded_index_size(tables: &[usize]) -> u32 {
-//     fn small(row_count: usize, bits: u8) -> bool {
-//         (row_count as u64) < (1u64 << (16 - bits))
-//     }
-
-//     fn bits_needed(value: usize) -> u8 {
-//         let mut value = value - 1;
-//         let mut bits: u8 = 1;
-//         loop {
-//             value >>= 1;
-//             if value == 0 {
-//                 break;
-//             }
-//             bits += 1;
-//         }
-//         bits
-//     }
-
-//     let bits_needed = bits_needed(tables.len());
-
-//     if tables.iter().all(|len| small(*len, bits_needed)) {
-//         2
-//     } else {
-//         4
-//     }
-// }