Split ArrayProxy out into its own file.

Make the usage of ArrayProxy dependent on the const_generics config
option.

Author: rcls

CHANGELOG.md

@@ -11,7 +11,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Re-export base's module for derived peripherals
 - More Cluster arrays are now emitted as an array rather than a list of
   elements.  An `ArrayProxy` wrapper is used when a Rust built-in array does not
-  match the cluster layout.
+  match the cluster layout.  Requires the `--const_generic` command line option.
 
 ## [v0.19.0] - 2021-05-26
 

src/generate/array_proxy.rs

@@ -0,0 +1,46 @@
+
+/// 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.
+///
+/// There is no safe way to produce items of this type.  Unsafe code can produce
+/// references by pointer casting.  It is up to the unsafe code doing that, to
+/// ensure that the memory really is backed by appropriate content.
+///
+/// Typically, this is used for accessing hardware registers.
+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>
+}
+
+impl<T, const C: usize, const S: usize> ArrayProxy<T, C, S> {
+    /// Get a reference from an [ArrayProxy] with no bounds checking.
+    pub unsafe fn get_ref(&self, index: usize) -> &T {
+        let base = self as *const Self as usize;
+        let address = base + S * index;
+        &*(address as *const T)
+    }
+    /// Get a reference from an [ArrayProxy], or return `None` if the index
+    /// is out of bounds.
+    pub fn get(&self, index: usize) -> Option<&T> {
+        if index < C {
+            Some(unsafe { self.get_ref(index) })
+        }
+        else {
+            None
+        }
+    }
+    /// Return the number of items.
+    pub fn len(&self) -> usize { C }
+}
+
+impl<T, const C: usize, const S: usize> core::ops::Index<usize> for ArrayProxy<T, C, S> {
+    type Output = T;
+    fn index(&self, index: usize) -> &T {
+        // Do a real array dereference for the bounds check.
+        [(); C][index];
+        unsafe { self.get_ref(index) }
+    }
+}

src/generate/device.rs

@@ -146,6 +146,10 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
                 std::str::from_utf8(include_bytes!("generic_msp430_atomic.rs"))?;
             writeln!(file, "\n{}", msp430_atomic_file)?;
         }
+        if config.const_generic {
+            let array_proxy = std::str::from_utf8(include_bytes!("array_proxy.rs"))?;
+            writeln!(file, "{}", array_proxy)?;
+        }
 
         if !config.make_mod {
             out.extend(quote! {
@@ -156,32 +160,27 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
             });
         }
     } else {
-        let tokens = syn::parse_file(generic_file)?.into_token_stream();
-
+        let mut tokens = syn::parse_file(generic_file)?.into_token_stream();
         if config.target == Target::Msp430 && config.nightly {
             let msp430_atomic_file =
                 std::str::from_utf8(include_bytes!("generic_msp430_atomic.rs"))?;
             let generic_msp430_atomic = syn::parse_file(msp430_atomic_file)?.into_token_stream();
-            out.extend(quote! {
-                #[allow(unused_imports)]
-                use generic::*;
-                ///Common register and bit access and modify traits
-                pub mod generic {
-                    #tokens
-
-                    #generic_msp430_atomic
-                }
-            });
-        } else {
-            out.extend(quote! {
-                #[allow(unused_imports)]
-                use generic::*;
-                ///Common register and bit access and modify traits
-                pub mod generic {
-                    #tokens
-                }
-            });
+            tokens.extend(generic_msp430_atomic);
+        }
+        if config.const_generic {
+            let array_proxy = std::str::from_utf8(include_bytes!("array_proxy.rs"))?;
+            let generic_array_proxy = syn::parse_file(array_proxy)?.into_token_stream();
+            tokens.extend(generic_array_proxy);
         }
+
+        out.extend(quote! {
+            #[allow(unused_imports)]
+            use generic::*;
+            ///Common register and bit access and modify traits
+            pub mod generic {
+                #tokens
+            }
+        });
     }
 
     out.extend(interrupt::render(config.target, &d.peripherals, device_x)?);

src/generate/generic.rs

@@ -280,49 +280,3 @@ impl<FI> FieldReader<bool, FI> {
         self.bit()
     }
 }
-
-/// 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.
-///
-/// There is no safe way to produce items of this type.  Unsafe code can produce
-/// references by pointer casting.  It is up to the unsafe code doing that, to
-/// ensure that the memory really is backed by appropriate content.
-///
-/// Typically, this is used for accessing hardware registers.
-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>
-}
-
-impl<T, const C: usize, const S: usize> ArrayProxy<T, C, S> {
-    /// Get a reference from an [ArrayProxy] with no bounds checking.
-    pub unsafe fn get_ref(&self, index: usize) -> &T {
-        let base = self as *const Self as usize;
-        let address = base + S * index;
-        &*(address as *const T)
-    }
-    /// Get a reference from an [ArrayProxy], or return `None` if the index
-    /// is out of bounds.
-    pub fn get(&self, index: usize) -> Option<&T> {
-        if index < C {
-            Some(unsafe { self.get_ref(index) })
-        }
-        else {
-            None
-        }
-    }
-    /// Return the number of items.
-    pub fn len(&self) -> usize { C }
-}
-
-impl<T, const C: usize, const S: usize> core::ops::Index<usize> for ArrayProxy<T, C, S> {
-    type Output = T;
-    fn index(&self, index: usize) -> &T {
-        // Do a real array dereference for the bounds check.
-        [(); C][index];
-        unsafe { self.get_ref(index) }
-    }
-}

src/generate/peripheral.rs

@@ -703,7 +703,7 @@ fn expand_cluster(
                     offset: info.address_offset,
                     size: cluster_size * array_info.dim,
                 });
-            } else if sequential_indexes {
+            } else if sequential_indexes && config.const_generic {
                 // Include a ZST ArrayProxy giving indexed access to the
                 // elements.
                 cluster_expanded.push(array_proxy(info, array_info, name)?);