Merge #598

598: WriteField aliases r=Emilgardis a=burrbull



Co-authored-by: Andrey Zgarbul <zgarbul.andrey@gmail.com>

Author: bors[bot]

.github/workflows/ci.yml

@@ -46,7 +46,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        rust: [stable, nightly, 1.46.0]
+        rust: [stable, nightly, 1.51.0]
 
     steps:
       - uses: actions/checkout@v3
@@ -94,7 +94,7 @@ jobs:
             options: all
         include:
           # Test MSRV
-          - rust: 1.46.0
+          - rust: 1.51.0
             vendor: Nordic
 
           # Use nightly for architectures which don't support stable

CHANGELOG.md

@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+- Use generic `FieldWriter`, `FieldReader`, `BitWriter`, `BitReader`
 - Disable two clippy warnings in `array_proxy.rs`
 
 ## [v0.23.1] - 2022-04-29

README.md

@@ -13,9 +13,9 @@ This project is developed and maintained by the [Tools team][team].
 
 ## Minimum Supported Rust Version (MSRV)
 
-The **generated code** is guaranteed to compile on stable Rust 1.46.0 and up.
+The **generated code** is guaranteed to compile on stable Rust 1.51.0 and up.
 
-If you encounter compilation errors on any stable version newer than 1.46.0, please open an issue.
+If you encounter compilation errors on any stable version newer than 1.51.0, please open an issue.
 
 # Testing Locally
 

ci/script.sh

@@ -479,7 +479,7 @@ main() {
             echo 'version = "0.3.0"' >> $td/Cargo.toml
 
             # Test MSP430
-            test_svd_for_target msp430 https://raw.githubusercontent.com/pftbest/msp430g2553/v0.3.0-svd/msp430g2553.svd
+            #test_svd_for_target msp430 https://raw.githubusercontent.com/pftbest/msp430g2553/v0.3.0-svd/msp430g2553.svd
         ;;
 
         # Community-provided RISC-V SVDs

src/generate/device.rs

@@ -1,4 +1,5 @@
 use crate::svd::{array::names, Device, Peripheral};
+use crate::util::U32Ext;
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::{quote, ToTokens};
 
@@ -147,10 +148,15 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
         });
     }
 
+    let reg_sizes = util::get_register_sizes(d);
+
     let generic_file = std::str::from_utf8(include_bytes!("generic.rs"))?;
     if config.generic_mod {
         let mut file = File::create(config.output_dir.join("generic.rs"))?;
         writeln!(file, "{}", generic_file)?;
+        for ty in reg_sizes {
+            writeln!(file, "impl_proxy!({});", ty.size_to_str()?)?;
+        }
         if config.target == Target::Msp430 && config.nightly {
             let msp430_atomic_file =
                 std::str::from_utf8(include_bytes!("generic_msp430_atomic.rs"))?;
@@ -171,6 +177,10 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
         }
     } else {
         let mut tokens = syn::parse_file(generic_file)?.into_token_stream();
+        for ty in reg_sizes {
+            let ty = Ident::new(ty.size_to_str()?, Span::call_site());
+            tokens.extend(quote! { impl_proxy!(#ty); });
+        }
         if config.target == Target::Msp430 && config.nightly {
             let msp430_atomic_file =
                 std::str::from_utf8(include_bytes!("generic_msp430_atomic.rs"))?;

src/generate/generic.rs

@@ -223,14 +223,13 @@ impl<REG: RegisterSpec> W<REG> {
     }
 }
 
-/// Field reader.
-///
-/// Result of the `read` methods of fields.
-pub struct FieldReader<U> {
+#[doc(hidden)]
+pub struct FieldReaderRaw<U, T> {
     pub(crate) bits: U,
+    _reg: marker::PhantomData<T>,
 }
 
-impl<U> FieldReader<U>
+impl<U, FI> FieldReaderRaw<U, FI>
 where
     U: Copy,
 {
@@ -240,28 +239,70 @@ where
     pub(crate) fn new(bits: U) -> Self {
         Self {
             bits,
+            _reg: marker::PhantomData,
         }
     }
+}
+
+#[doc(hidden)]
+pub struct BitReaderRaw<T> {
+    pub(crate) bits: bool,
+    _reg: marker::PhantomData<T>,
+}
+
+impl<FI> BitReaderRaw<FI> {
+    /// Creates a new instance of the reader.
+    #[allow(unused)]
+    #[inline(always)]
+    pub(crate) fn new(bits: bool) -> Self {
+        Self {
+            bits,
+            _reg: marker::PhantomData,
+        }
+    }
+}
+
+/// Field reader.
+///
+/// Result of the `read` methods of fields.
+pub type FieldReader<U, FI> = FieldReaderRaw<U, FI>;
 
+/// Bit-wise field reader
+pub type BitReader<FI> = BitReaderRaw<FI>;
+
+impl<U, FI> FieldReader<U, FI>
+where
+    U: Copy,
+{
     /// Reads raw bits from field.
     #[inline(always)]
     pub fn bits(&self) -> U {
         self.bits
     }
 }
 
-impl<U, T> PartialEq<T> for FieldReader<U>
+impl<U, FI> PartialEq<FI> for FieldReader<U, FI>
 where
     U: PartialEq,
-    T: Copy + Into<U>,
+    FI: Copy + Into<U>,
+{
+    #[inline(always)]
+    fn eq(&self, other: &FI) -> bool {
+        self.bits.eq(&(*other).into())
+    }
+}
+
+impl<FI> PartialEq<FI> for BitReader<FI>
+where
+    FI: Copy + Into<bool>,
 {
     #[inline(always)]
-    fn eq(&self, other: &T) -> bool {
+    fn eq(&self, other: &FI) -> bool {
         self.bits.eq(&(*other).into())
     }
 }
 
-impl FieldReader<bool> {
+impl<FI> BitReader<FI> {
     /// Value of the field as raw bits.
     #[inline(always)]
     pub fn bit(&self) -> bool {
@@ -278,3 +319,178 @@ impl FieldReader<bool> {
         self.bit()
     }
 }
+
+#[doc(hidden)]
+pub struct Safe;
+#[doc(hidden)]
+pub struct Unsafe;
+
+#[doc(hidden)]
+pub struct FieldWriterRaw<'a, U, REG, N, FI, Safety, const WI: u8, const O: u8>
+where
+    REG: Writable + RegisterSpec<Ux = U>,
+    FI: Into<N>,
+{
+    pub(crate) w: &'a mut REG::Writer,
+    _field: marker::PhantomData<(N, FI, Safety)>,
+}
+
+impl<'a, U, REG, N, FI, Safety, const WI: u8, const O: u8> FieldWriterRaw<'a, U, REG, N, FI, Safety, WI, O>
+where
+    REG: Writable + RegisterSpec<Ux = U>,
+    FI: Into<N>,
+{
+    /// Creates a new instance of the writer
+    #[allow(unused)]
+    #[inline(always)]
+    pub(crate) fn new(w: &'a mut REG::Writer) -> Self {
+        Self {
+            w,
+            _field: marker::PhantomData,
+        }
+    }
+}
+
+#[doc(hidden)]
+pub struct BitWriterRaw<'a, U, REG, FI, const O: u8>
+where
+    REG: Writable + RegisterSpec<Ux = U>,
+    FI: Into<bool>,
+{
+    pub(crate) w: &'a mut REG::Writer,
+    _field: marker::PhantomData<FI>,
+}
+
+impl<'a, U, REG, FI, const O: u8> BitWriterRaw<'a, U, REG, FI, O>
+where
+    REG: Writable + RegisterSpec<Ux = U>,
+    FI: Into<bool>,
+{
+    /// Creates a new instance of the writer
+    #[allow(unused)]
+    #[inline(always)]
+    pub(crate) fn new(w: &'a mut REG::Writer) -> Self {
+        Self {
+            w,
+            _field: marker::PhantomData,
+        }
+    }
+}
+
+/// Write field Proxy with unsafe `bits`
+pub type FieldWriter<'a, U, REG, N, FI, const WI: u8, const O: u8> = FieldWriterRaw<'a, U, REG, N, FI, Unsafe, WI, O>;
+/// Write field Proxy with safe `bits`
+pub type FieldWriterSafe<'a, U, REG, N, FI, const WI: u8, const O: u8> = FieldWriterRaw<'a, U, REG, N, FI, Safe, WI, O>;
+
+/// Bit-wise write field proxy
+pub type BitWriter<'a, U, REG, FI, const O: u8> = BitWriterRaw<'a, U, REG, FI, O>;
+
+
+impl<'a, U, REG, N, FI, const WI: u8, const OF: u8> FieldWriter<'a, U, REG, N, FI, WI, OF>
+where
+    REG: Writable + RegisterSpec<Ux = U>,
+    FI: Into<N>,
+{
+    /// Field width
+    pub const WIDTH: u8 = WI;
+    /// Field offset
+    pub const OFFSET: u8 = OF;
+}
+
+impl<'a, U, REG, N, FI, const WI: u8, const OF: u8> FieldWriterSafe<'a, U, REG, N, FI, WI, OF>
+where
+    REG: Writable + RegisterSpec<Ux = U>,
+    FI: Into<N>,
+{
+    /// Field width
+    pub const WIDTH: u8 = WI;
+    /// Field offset
+    pub const OFFSET: u8 = OF;
+}
+
+impl<'a, U, REG, FI, const OF: u8> BitWriter<'a, U, REG, FI, OF>
+where
+    REG: Writable + RegisterSpec<Ux = U>,
+    FI: Into<bool>,
+{
+    /// Field width
+    pub const WIDTH: u8 = 1;
+    /// Field offset
+    pub const OFFSET: u8 = OF;
+}
+
+macro_rules! impl_proxy {
+    ($U:ty) => {
+        impl<'a, REG, N, FI, const WI: u8, const OF: u8> FieldWriter<'a, $U, REG, N, FI, WI, OF>
+        where
+            REG: Writable + RegisterSpec<Ux = $U>,
+            N: Into<$U>,
+            FI: Into<N>,
+        {
+            const MASK: $U = <$U>::MAX >> (<$U>::MAX.leading_ones() as u8 - { WI });
+            /// Writes raw bits to the field
+            ///
+            /// # Safety
+            ///
+            /// Passing incorrect value can cause undefined behaviour. See reference manual
+            #[inline(always)]
+            pub unsafe fn bits(self, value: N) -> &'a mut REG::Writer {
+                self.w.bits =
+                    (self.w.bits & !(Self::MASK << { OF })) | ((value.into() & Self::MASK) << { OF });
+                self.w
+            }
+            /// Writes `variant` to the field
+            #[inline(always)]
+            pub fn variant(self, variant: FI) -> &'a mut REG::Writer {
+                unsafe { self.bits(variant.into()) }
+            }
+        }
+        impl<'a, REG, N, FI, const WI: u8, const OF: u8> FieldWriterSafe<'a, $U, REG, N, FI, WI, OF>
+        where
+            REG: Writable + RegisterSpec<Ux = $U>,
+            N: Into<$U>,
+            FI: Into<N>,
+        {
+            const MASK: $U = <$U>::MAX >> (<$U>::MAX.leading_ones() as u8 - { WI });
+            /// Writes raw bits to the field
+            #[inline(always)]
+            pub fn bits(self, value: N) -> &'a mut REG::Writer {
+                self.w.bits =
+                    (self.w.bits & !(Self::MASK << { OF })) | ((value.into() & Self::MASK) << { OF });
+                self.w
+            }
+            /// Writes `variant` to the field
+            #[inline(always)]
+            pub fn variant(self, variant: FI) -> &'a mut REG::Writer {
+                self.bits(variant.into())
+            }
+        }
+        impl<'a, REG, FI, const OF: u8> BitWriter<'a, $U, REG, FI, OF>
+        where
+            REG: Writable + RegisterSpec<Ux = $U>,
+            FI: Into<bool>,
+        {
+            /// Writes bit to the field
+            #[inline(always)]
+            pub fn bit(self, value: bool) -> &'a mut REG::Writer {
+                self.w.bits = (self.w.bits & !(1 << { OF })) | ((<$U>::from(value) & 1) << { OF });
+                self.w
+            }
+            /// Writes `variant` to the field
+            #[inline(always)]
+            pub fn variant(self, variant: FI) -> &'a mut REG::Writer {
+                self.bit(variant.into())
+            }
+            /// Sets the field bit
+            #[inline(always)]
+            pub fn set_bit(self) -> &'a mut REG::Writer {
+                self.bit(true)
+            }
+            /// Clears the field bit
+            #[inline(always)]
+            pub fn clear_bit(self) -> &'a mut REG::Writer {
+                self.bit(false)
+            }
+        }
+    }
+}