impl in device instead

Author: GrantM11235

src/generate/block.rs

@@ -1,7 +1,7 @@
 use anyhow::Result;
-use proc_macro2::{Ident, Literal, Span, TokenStream};
+use proc_macro2::TokenStream;
+use proc_macro2::{Ident, Span};
 use quote::quote;
-use std::collections::HashMap;
 
 use crate::ir::*;
 use crate::util;
@@ -83,17 +83,8 @@ pub fn render(opts: &super::Options, ir: &IR, b: &Block, path: &str) -> Result<T
     }
 
     let (_, name) = super::split_path(path);
-    let unknown = Literal::string(&format!("Unknown {}", name));
     let name = Ident::new(name, span);
     let doc = util::doc(&b.description);
-
-    let addrs = get_addrs(ir, b);
-    let addrs = addrs.iter().map(|(addr, block_name)| {
-        let addr = Literal::u32_suffixed(*addr);
-        let block_name = Literal::string(block_name);
-        quote!(#addr => f.write_str(#block_name),)
-    });
-
     let out = quote! {
         #doc
         #[derive(Copy, Clone, Eq, PartialEq)]
@@ -103,22 +94,7 @@ pub fn render(opts: &super::Options, ir: &IR, b: &Block, path: &str) -> Result<T
         impl #name {
             #items
         }
-
-        impl core::fmt::Display for #name {
-            fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), core::fmt::Error> {
-                match self.0 {
-                    #(
-                        #addrs
-                    )*
-                    _ => f.write_str(#unknown),
-                }
-            }
-        }
     };
 
     Ok(out)
 }
-
-fn get_addrs(_ir: &IR, _b: &Block) -> HashMap<u32, String> {
-    todo!()
-}

src/generate/device.rs

@@ -1,5 +1,7 @@
+use std::collections::HashMap;
+
 use anyhow::Result;
-use proc_macro2::{Ident, Span, TokenStream};
+use proc_macro2::{Ident, Literal, Span, TokenStream};
 use quote::quote;
 
 use crate::ir::*;
@@ -16,6 +18,7 @@ pub fn render(_opts: &super::Options, ir: &IR, d: &Device, path: &str) -> Result
     let mut peripherals = TokenStream::new();
     let mut vectors = TokenStream::new();
     let mut names = vec![];
+    let mut addrs: HashMap<_, Vec<(_, _)>> = HashMap::new();
 
     let mut pos = 0;
     for i in &interrupts_sorted {
@@ -54,6 +57,12 @@ pub fn render(_opts: &super::Options, ir: &IR, d: &Device, path: &str) -> Result
 
         if let Some(block_name) = &p.block {
             let _b = ir.blocks.get(block_name);
+
+            addrs
+                .entry((block_name, path))
+                .or_default()
+                .push((address.clone(), name.clone()));
+
             let path = util::relative_path(block_name, path);
 
             peripherals.extend(quote! {
@@ -68,6 +77,29 @@ pub fn render(_opts: &super::Options, ir: &IR, d: &Device, path: &str) -> Result
         }
     }
 
+    for ((block_name, path), addrs) in addrs {
+        let unknown = Literal::string(&format!("Unknown {}", block_name));
+
+        let path = util::relative_path(block_name, path);
+
+        let addrs = addrs
+            .iter()
+            .map(|(addr, block_name)| quote!(#addr => f.write_str(#block_name),));
+
+        peripherals.extend(quote! {
+            impl core::fmt::Display for #path {
+                fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), core::fmt::Error> {
+                    match self.0 {
+                        #(
+                            #addrs
+                        )*
+                        _ => f.write_str(#unknown),
+                    }
+                }
+            }
+        });
+    }
+
     let n = util::unsuffixed(pos as u64);
     out.extend(quote!(
         #[derive(Copy, Clone, Debug, PartialEq, Eq)]