Merge #592

592: add code generation support of peripheral arrays r=burrbull a=duskmoon314

## Brief Intro
- generate ArrayProxy of peripherals when const_generic is true
- generate separate struct of peripherals when const_generic is false

close issue: #492

## Design

**Notice:** This is my first try of implement this feature. Please provide suggestions for this PR to better implement this feature.

This PR aims to achieve what issue #492 is asking for. This PR implements a basic try of generating codes depending on the `const_generic` flag.

Let's say we have an svd file with descriptions of peripherals like this:

```XML
<peripheral>
    <dim>2</dim>
    <dimIncrement>0x100</dimIncrement>
    <name>PTEST[%s]</name>
    <groupName>PGroup</groupName>
    <baseAddress>0x20000000</baseAddress>
    <addressBlock>
        <offset>0</offset>
        <size>0x100</size>
        <usage>registers</usage>
    </addressBlock>
    <registers>
        ...
    </registers>
</peripheral>
```

If the `const_generic` is `false`, there is no `ArrayProxy`. So I generate separate structs and only one mod:

```rust
pub struct PTEST0 {
    _marker: PhantomData<*const ()>,
}
...
impl PTEST0 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const ptest::RegisterBlock = 0x2000_0000 as *const _;
    ...
}
impl Deref for PTEST0 {
    type Target = ptest::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}

pub struct PTEST1 {
    _marker: PhantomData<*const ()>,
}
...
impl PTEST1 {
    #[doc = r"Pointer to the register block"]
    pub const PTR: *const ptest::RegisterBlock = 0x2000_0100 as *const _;
    ...
}
impl Deref for PTEST1 {
    type Target = ptest::RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*Self::PTR }
    }
}
#[doc = "PTEST"]
pub mod ptest;
```

**NOTICE:** The following design is actually incorrect and has been removed. See the following comment.
<details>
If the `const_generic` is `true`, we can use `ArrayProxy`. So I generate code like this:

```rust
pub struct PTEST {
    _marker: PhantomData<*const ()>,
}
...

pub struct Peripherals {
    #[doc = "PTEST"]
    pub PTEST: crate::ArrayProxy<PTEST, 2usize, 0x0100>,
...
impl Peripherals {
...
    pub unsafe fn steal() -> Self {
        DEVICE_PERIPHERALS = true;
        Peripherals {
            PTEST: crate::ArrayProxy::new(),
```

Since `_array` is a private field of `ArrayProxy`, I add a `new` method to implement the `steal` method of `Peripherals`.
</details>
I also add the support of using `name_of` on `MaybeArray<PeripheralInfo>` to achieve this implementation.

Well, I haven't fully tested this implementation yet. So there may be problems that need to be solved.

Co-authored-by: Campbell He <campbell.he@icloud.com>
Co-authored-by: Campbell He <duskmoon314@users.noreply.github.com>

Author: bors[bot]

CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Generate const generic version of field array only if `const_generic` enabled
 - Clean `FieldReader`
 - Optional PascalCase for Enum values instead of UPPER_CASE
+- Add code generation support of peripheral arrays.
 
 ## [v0.22.2] - 2022-04-13
 

src/generate/array_proxy.rs

@@ -1,4 +1,3 @@
-
 /// Access an array of `COUNT` items of type `T` with the items `STRIDE` bytes
 /// apart.  This is a zero-sized-type.  No objects of this type are ever
 /// actually created, it is only a convenience for wrapping pointer arithmetic.
@@ -12,7 +11,7 @@ pub struct ArrayProxy<T, const COUNT: usize, const STRIDE: usize> {
     /// As well as providing a PhantomData, this field is non-public, and
     /// therefore ensures that code outside of this module can never create
     /// an ArrayProxy.
-    _array: marker::PhantomData<T>
+    _array: marker::PhantomData<T>,
 }
 
 impl<T, const C: usize, const S: usize> ArrayProxy<T, C, S> {
@@ -27,13 +26,14 @@ impl<T, const C: usize, const S: usize> ArrayProxy<T, C, S> {
     pub fn get(&self, index: usize) -> Option<&T> {
         if index < C {
             Some(unsafe { self.get_ref(index) })
-        }
-        else {
+        } else {
             None
         }
     }
     /// Return the number of items.
-    pub fn len(&self) -> usize { C }
+    pub fn len(&self) -> usize {
+        C
+    }
 }
 
 impl<T, const C: usize, const S: usize> core::ops::Index<usize> for ArrayProxy<T, C, S> {

src/generate/device.rs

@@ -1,8 +1,9 @@
-use crate::svd::Device;
+use crate::svd::{array::names, Device, Peripheral};
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::{quote, ToTokens};
 
 use log::debug;
+use std::borrow::Cow;
 use std::fs::File;
 use std::io::Write;
 
@@ -236,13 +237,31 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
             continue;
         }
 
-        let p = p.name.to_sanitized_upper_case();
-        let id = Ident::new(&p, Span::call_site());
-        fields.extend(quote! {
-            #[doc = #p]
-            pub #id: #id,
-        });
-        exprs.extend(quote!(#id: #id { _marker: PhantomData },));
+        match p {
+            Peripheral::Single(_p) => {
+                let p_name = util::name_of(p, config.ignore_groups);
+                let p = p_name.to_sanitized_upper_case();
+                let id = Ident::new(&p, Span::call_site());
+                fields.extend(quote! {
+                    #[doc = #p]
+                    pub #id: #id,
+                });
+                exprs.extend(quote!(#id: #id { _marker: PhantomData },));
+            }
+            Peripheral::Array(_p, dim_element) => {
+                let p_names: Vec<Cow<str>> = names(p, dim_element).map(|n| n.into()).collect();
+                let p = p_names.iter().map(|p| p.to_sanitized_upper_case());
+                let ids_f = p.clone().map(|p| Ident::new(&p, Span::call_site()));
+                let ids_e = ids_f.clone();
+                fields.extend(quote! {
+                    #(
+                        #[doc = #p]
+                        pub #ids_f: #ids_f,
+                    )*
+                });
+                exprs.extend(quote!(#(#ids_e: #ids_e { _marker: PhantomData },)*));
+            }
+        }
     }
 
     let span = Span::call_site();

src/generate/peripheral.rs

@@ -3,8 +3,8 @@ use std::cmp::Ordering;
 use std::collections::HashMap;
 
 use crate::svd::{
-    Cluster, ClusterInfo, DeriveFrom, DimElement, Peripheral, Register, RegisterCluster,
-    RegisterProperties,
+    array::names, Cluster, ClusterInfo, DeriveFrom, DimElement, Peripheral, Register,
+    RegisterCluster, RegisterProperties,
 };
 use log::{debug, trace, warn};
 use proc_macro2::{Ident, Punct, Spacing, Span, TokenStream};
@@ -43,52 +43,100 @@ pub fn render(
         return Ok(out);
     }
 
+    let name = util::name_of(p, config.ignore_groups);
     let span = Span::call_site();
-    let name_str = p.name.to_sanitized_upper_case();
+    let name_str = name.to_sanitized_upper_case();
     let name_pc = Ident::new(&name_str, span);
     let address = util::hex(p.base_address as u64);
     let description = util::respace(p.description.as_ref().unwrap_or(&p.name));
 
-    let name_sc = Ident::new(&p.name.to_sanitized_snake_case(), span);
+    let name_sc = Ident::new(&name.to_sanitized_snake_case(), span);
     let (derive_regs, base) = if let (Some(df), None) = (p_derivedfrom, &p_original.registers) {
         (true, Ident::new(&df.name.to_sanitized_snake_case(), span))
     } else {
         (false, name_sc.clone())
     };
 
-    // Insert the peripheral structure
-    out.extend(quote! {
-        #[doc = #description]
-        pub struct #name_pc { _marker: PhantomData<*const ()> }
+    match p_original {
+        Peripheral::Array(p, dim) => {
+            let names: Vec<Cow<str>> = names(p, dim).map(|n| n.into()).collect();
+            let names_str = names.iter().map(|n| n.to_sanitized_upper_case());
+            let names_pc = names_str.clone().map(|n| Ident::new(&n, span));
+            let addresses =
+                (0..=dim.dim).map(|i| util::hex(p.base_address + (i * dim.dim_increment) as u64));
+
+            // Insert the peripherals structure
+            out.extend(quote! {
+                #(
+                    #[doc = #description]
+                    pub struct #names_pc { _marker: PhantomData<*const ()> }
+
+                    unsafe impl Send for #names_pc {}
+
+                    impl #names_pc {
+                        ///Pointer to the register block
+                        pub const PTR: *const #base::RegisterBlock = #addresses as *const _;
+
+                        ///Return the pointer to the register block
+                        #[inline(always)]
+                        pub const fn ptr() -> *const #base::RegisterBlock {
+                            Self::PTR
+                        }
+                    }
 
-        unsafe impl Send for #name_pc {}
+                    impl Deref for #names_pc {
+                        type Target = #base::RegisterBlock;
 
-        impl #name_pc {
-            ///Pointer to the register block
-            pub const PTR: *const #base::RegisterBlock = #address as *const _;
+                        #[inline(always)]
+                        fn deref(&self) -> &Self::Target {
+                            unsafe { &*Self::PTR }
+                        }
+                    }
 
-            ///Return the pointer to the register block
-            #[inline(always)]
-            pub const fn ptr() -> *const #base::RegisterBlock {
-                Self::PTR
-            }
+                    impl core::fmt::Debug for #names_pc {
+                        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                            f.debug_struct(#names_str).finish()
+                        }
+                    }
+                )*
+            });
         }
+        _ => {
+            // Insert the peripheral structure
+            out.extend(quote! {
+                #[doc = #description]
+                pub struct #name_pc { _marker: PhantomData<*const ()> }
 
-        impl Deref for #name_pc {
-            type Target = #base::RegisterBlock;
+                unsafe impl Send for #name_pc {}
 
-            #[inline(always)]
-            fn deref(&self) -> &Self::Target {
-                unsafe { &*Self::PTR }
-            }
-        }
+                impl #name_pc {
+                    ///Pointer to the register block
+                    pub const PTR: *const #base::RegisterBlock = #address as *const _;
 
-        impl core::fmt::Debug for #name_pc {
-            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-                f.debug_struct(#name_str).finish()
-            }
+                    ///Return the pointer to the register block
+                    #[inline(always)]
+                    pub const fn ptr() -> *const #base::RegisterBlock {
+                        Self::PTR
+                    }
+                }
+
+                impl Deref for #name_pc {
+                    type Target = #base::RegisterBlock;
+
+                    #[inline(always)]
+                    fn deref(&self) -> &Self::Target {
+                        unsafe { &*Self::PTR }
+                    }
+                }
+
+                impl core::fmt::Debug for #name_pc {
+                    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                        f.debug_struct(#name_str).finish()
+                    }
+                }
+            });
         }
-    });
+    }
 
     // Derived peripherals may not require re-implementation, and will instead
     // use a single definition of the non-derived version.
@@ -195,8 +243,9 @@ pub fn render(
         };
     }
 
-    let description =
-        util::escape_brackets(util::respace(p.description.as_ref().unwrap_or(&p.name)).as_ref());
+    let description = util::escape_brackets(
+        util::respace(p.description.as_ref().unwrap_or(&name.as_ref().to_owned())).as_ref(),
+    );
 
     let open = Punct::new('{', Spacing::Alone);
     let close = Punct::new('}', Spacing::Alone);

src/util.rs

@@ -7,6 +7,7 @@ use inflections::Inflect;
 use proc_macro2::{Ident, Literal, Span, TokenStream};
 use quote::{quote, ToTokens};
 use std::path::{Path, PathBuf};
+use svd_rs::{MaybeArray, PeripheralInfo};
 
 use anyhow::{anyhow, bail, Context, Result};
 
@@ -221,10 +222,10 @@ pub fn escape_brackets(s: &str) -> String {
         })
 }
 
-pub fn name_of(register: &Register, ignore_group: bool) -> Cow<str> {
-    match register {
-        Register::Single(info) => info.fullname(ignore_group),
-        Register::Array(info, _) => replace_suffix(&info.fullname(ignore_group), "").into(),
+pub fn name_of<T: FullName>(maybe_array: &MaybeArray<T>, ignore_group: bool) -> Cow<str> {
+    match maybe_array {
+        MaybeArray::Single(info) => info.fullname(ignore_group),
+        MaybeArray::Array(info, _) => replace_suffix(&info.fullname(ignore_group), "").into(),
     }
 }
 
@@ -445,3 +446,9 @@ impl FullName for RegisterInfo {
         }
     }
 }
+
+impl FullName for PeripheralInfo {
+    fn fullname(&self, _ignore_group: bool) -> Cow<str> {
+        self.name.as_str().into()
+    }
+}