field array support

Author: burrbull

src/generate/generic.rs

@@ -219,6 +219,13 @@ impl<U, REG> W<U, REG> {
     }
 }
 
+///Calculate exact field offset in field array
+#[allow(dead_code)]
+#[inline(always)]
+pub const fn field_offset(n: u32, base: u32, first: u32, increment: u32) -> u32 {
+    base + (n - first)*increment
+}
+
 ///Used if enumerated values cover not the whole range
 #[derive(Clone,Copy,PartialEq)]
 pub enum Variant<U, T> {

src/generate/register.rs

@@ -221,8 +221,9 @@ pub fn fields(
                 width,
                 range_type: _,
             } = f.bit_range;
-            let sc = f.name.to_sanitized_snake_case();
-            let pc = f.name.to_sanitized_upper_case();
+            let name = util::replace_suffix(&f.name, "");
+            let sc = name.to_sanitized_snake_case();
+            let pc = name.to_sanitized_upper_case();
             let span = Span::call_site();
             let pc_r = Ident::new(&format!("{}_A", pc), span);
             let _pc_r = Ident::new(&format!("{}_R", pc), span);
@@ -234,26 +235,44 @@ pub fn fields(
             } else {
                 "bits"
             }, Span::call_site());
-            let mut description_with_bits = if width == 1 {
-                format!("Bit {}", offset)
-            } else {
-                format!("Bits {}:{}", offset, offset + width - 1)
-            };
-            if let Some(d) = &f.description {
-                description_with_bits.push_str(" - ");
-                description_with_bits.push_str(&util::respace(&util::escape_brackets(d)));
-            }
             let description = if let Some(d) = &f.description {
                 util::respace(&util::escape_brackets(d))
             } else {
                 "".to_owned()
             };
 
+            let dim = match f {
+                Field::Array(_, de) => {
+                    let (first, index) = if let Some(dim_index) = &de.dim_index {
+                        if let Ok(first) = dim_index[0].parse::<u32>() {
+                            (first, None)
+                        } else {
+                            (0, de.dim_index.clone())
+                        }
+                    } else {
+                        (0, None)
+                    };
+                    let span = Span::call_site();
+                    let names_with_index: Vec<_> = match index {
+                        Some(ix) => ix.iter().map(|i| Ident::new(&util::replace_suffix(&f.name.to_sanitized_snake_case(), &i), span)).collect(),
+                        None => (0..de.dim).map(|i| Ident::new(&util::replace_suffix(&f.name.to_sanitized_snake_case(), &(first + i).to_string()), span)).collect(),
+                    };
+                    let last = util::unsuffixed((first + de.dim - 1) as u64);
+                    let first_unsuf = util::unsuffixed(first as u64);
+                    let check = if first == 0 {
+                        quote! { debug_assert!(n <= #last); }
+                    } else {
+                        quote! { debug_assert!(n >= #first_unsuf && n <= #last); }
+                    };
+                    Some((first, de.dim, de.dim_increment, check, names_with_index))
+                },
+                Field::Single(_) => None
+            };
+
             Ok(F {
                 _pc_w,
                 _sc,
                 description,
-                description_with_bits,
                 pc_r,
                 _pc_r,
                 pc_w,
@@ -267,6 +286,7 @@ pub fn fields(
                 offset: u64::from(offset),
                 ty: width.to_ty()?,
                 write_constraint: f.write_constraint.as_ref(),
+                dim,
             })
         }
     }
@@ -306,10 +326,10 @@ pub fn fields(
         let _pc_r = &f._pc_r;
         let _pc_w = &f._pc_w;
         let description = &f.description;
-        let description_with_bits = &f.description_with_bits;
+        let width = f.width;
 
         if can_read {
-            let cast = if f.width == 1 {
+            let cast = if width == 1 {
                 quote! { != 0 }
             } else {
                 quote! { as #fty }
@@ -325,21 +345,59 @@ pub fn fields(
                 }
             };
 
-            if let Some((evs, base)) = lookup_filter(&lookup_results, Usage::Read) {
-                evs_r = Some(evs.clone());
-
-                let sc = &f.sc;
+            let sc = &f.sc;
+            if let Some((first, dim, increment, check, names)) = f.dim.clone() {
+                let first_unsuf = util::unsuffixed(first as u64);
+                let offset_unsuf = &util::unsuffixed(offset);
+                let increment_unsuf = &util::unsuffixed(increment as u64);
+                let offset_calc = quote! {crate::field_offset(n, #offset_unsuf, #first_unsuf, #increment_unsuf)};
+                let value = quote! { ((self.bits >> #offset_calc) & #mask) #cast };
+                let doc = &f.description;
+                r_impl_items.push(quote! {
+                    #[doc = #doc]
+                    #[inline(always)]
+                    pub fn #sc(&self, n: u32) -> #_pc_r {
+                        #check
+                        #_pc_r::new( #value )
+                    }
+                });
+                for (i, sc_n) in (0..dim).zip(names.iter()) {
+                    let offset = offset + (i as u64)*(increment as u64);
+                    let value = if offset != 0 {
+                        let offset = &util::unsuffixed(offset);
+                        quote! {
+                            ((self.bits >> #offset) & #mask) #cast
+                        }
+                    } else {
+                        quote! {
+                            (self.bits & #mask) #cast
+                        }
+                    };
+                    let doc = description_with_bits(&f.description, offset, width);
+                    r_impl_items.push(quote! {
+                        #[doc = #doc]
+                        #[inline(always)]
+                        pub fn #sc_n(&self) -> #_pc_r {
+                            #_pc_r::new( #value )
+                        }
+                    });
+                }
+            } else {
+                let doc = description_with_bits(&f.description, f.offset, width);
                 r_impl_items.push(quote! {
-                    #[doc = #description_with_bits]
+                    #[doc = #doc]
                     #[inline(always)]
                     pub fn #sc(&self) -> #_pc_r {
                         #_pc_r::new( #value )
                     }
                 });
+            }
+
+            if let Some((evs, base)) = lookup_filter(&lookup_results, Usage::Read) {
+                evs_r = Some(evs.clone());
 
                 base_pc_w = base.as_ref().map(|base| {
-                    let pc = base.field.to_sanitized_upper_case();
-                    let base_pc_r = Ident::new(&format!("{}_A", pc), Span::call_site());
+                    let base_pc_r = Ident::new(&format!("{}_A", util::replace_suffix(base.field, "").to_sanitized_upper_case()), Span::call_site());
                     let base_pc_r = derive_from_base(mod_items, &base, &pc_r, &base_pc_r, description);
 
                     let doc = format!("Reader of field `{}`", f.name);
@@ -352,7 +410,7 @@ pub fn fields(
                 });
 
                 if base.is_none() {
-                    let has_reserved_variant = evs.values.len() != (1 << f.width);
+                    let has_reserved_variant = evs.values.len() != (1 << width);
                     let variants = Variant::from_enumerated_values(evs)?;
 
                     add_from_variants(mod_items, &variants, pc_r, &f, description, rv);
@@ -362,7 +420,7 @@ pub fn fields(
                     let mut arms = variants
                         .iter()
                         .map(|v| {
-                            let i = util::unsuffixed_or_bool(v.value, f.width);
+                            let i = util::unsuffixed_or_bool(v.value, width);
                             let pc = &v.pc;
 
                             if has_reserved_variant {
@@ -377,7 +435,7 @@ pub fn fields(
                         arms.push(quote! {
                             i => Res(i)
                         });
-                    } else if 1 << f.width.to_ty_width()? != variants.len() {
+                    } else if 1 << width.to_ty_width()? != variants.len() {
                         arms.push(quote! {
                             _ => unreachable!()
                         });
@@ -437,15 +495,6 @@ pub fn fields(
                 }
 
             } else {
-                let sc = &f.sc;
-                r_impl_items.push(quote! {
-                    #[doc = #description_with_bits]
-                    #[inline(always)]
-                    pub fn #sc(&self) -> #_pc_r {
-                        #_pc_r::new ( #value )
-                    }
-                });
-
                 let doc = format!("Reader of field `{}`", f.name);
                 mod_items.push(quote! {
                     #[doc = #doc]
@@ -458,22 +507,20 @@ pub fn fields(
         if can_write {
             let mut proxy_items = vec![];
 
-            let mut unsafety = unsafety(f.write_constraint, f.width);
-            let width = f.width;
+            let mut unsafety = unsafety(f.write_constraint, width);
 
             if let Some((evs, base)) = lookup_filter(&lookup_results, Usage::Write) {
                 let variants = Variant::from_enumerated_values(evs)?;
 
-                if variants.len() == 1 << f.width {
+                if variants.len() == 1 << width {
                     unsafety = None;
                 }
 
                 if Some(evs) != evs_r.as_ref() {
                     pc_w = &f.pc_w;
 
                     base_pc_w = base.as_ref().map(|base| {
-                        let pc = base.field.to_sanitized_upper_case();
-                        let base_pc_w = Ident::new(&format!("{}_AW", pc), Span::call_site());
+                        let base_pc_w = Ident::new(&format!("{}_AW", util::replace_suffix(base.field, "").to_sanitized_upper_case()), Span::call_site());
                         derive_from_base(mod_items, &base, &pc_w, &base_pc_w, description)
                     });
 
@@ -533,7 +580,20 @@ pub fn fields(
                 });
             }
 
-            proxy_items.push(if offset != 0 {
+            proxy_items.push(if let Some((first, _, increment, _, _)) = f.dim {
+                let offset = &util::unsuffixed(offset);
+                let first = util::unsuffixed(first as u64);
+                let increment_unsuf = util::unsuffixed(increment as u64);
+                let offset_calc = quote! {crate::field_offset(self.n, #offset, #first, #increment_unsuf)};
+                quote! {
+                    ///Writes raw bits to the field
+                    #[inline(always)]
+                    pub #unsafety fn #bits(self, value: #fty) -> &'a mut W {
+                        self.w.bits = (self.w.bits & !(#mask << #offset_calc)) | (((value as #rty) & #mask) << #offset_calc);
+                        self.w
+                    }
+                }
+            } else if offset != 0 {
                 let offset = &util::unsuffixed(offset);
                 quote! {
                     ///Writes raw bits to the field
@@ -554,11 +614,18 @@ pub fn fields(
                 }
             });
 
+            let n_entry = if f.dim.is_some() {
+                quote! {n: u32,}
+            } else {
+                quote! {}
+            };
+
             let doc = format!("Write proxy for field `{}`", f.name);
             mod_items.push(quote! {
                 #[doc = #doc]
                 pub struct #_pc_w<'a> {
                     w: &'a mut W,
+                    #n_entry
                 }
 
                 impl<'a> #_pc_w<'a> {
@@ -567,13 +634,39 @@ pub fn fields(
             });
 
             let sc = &f.sc;
-            w_impl_items.push(quote! {
-                #[doc = #description_with_bits]
-                #[inline(always)]
-                pub fn #sc(&mut self) -> #_pc_w {
-                    #_pc_w { w: self }
+            if let Some((first, dim, increment, check, names)) = f.dim.clone() {
+                let doc = &f.description;
+                w_impl_items.push(quote! {
+                    #[doc = #doc]
+                    #[inline(always)]
+                    pub fn #sc(&mut self, n: u32) -> #_pc_w {
+                        #check
+                        #_pc_w { w: self, n }
+                    }
+                });
+                for (i, sc_n) in (0..dim).zip(names.iter()) {
+                    let n = first + i;
+                    let n = util::unsuffixed(n as u64);
+                    let offset = offset + (i as u64)*(increment as u64);
+                    let doc = description_with_bits(&f.description, offset, width);
+                    w_impl_items.push(quote! {
+                        #[doc = #doc]
+                        #[inline(always)]
+                        pub fn #sc_n(&mut self) -> #_pc_w {
+                            #_pc_w { w: self, n: #n }
+                        }
+                    });
                 }
-            })
+            } else {
+                let doc = description_with_bits(&f.description, f.offset, width);
+                w_impl_items.push(quote! {
+                    #[doc = #doc]
+                    #[inline(always)]
+                    pub fn #sc(&mut self) -> #_pc_w {
+                        #_pc_w { w: self }
+                    }
+                });
+            }
         }
     }
 
@@ -719,12 +812,24 @@ fn derive_from_base(mod_items: &mut Vec<TokenStream>, base: &Base, pc: &Ident, b
     }
 }
 
+fn description_with_bits(description: &str, offset: u64, width: u32) -> String {
+    let mut res = if width == 1 {
+        format!("Bit {}", offset)
+    } else {
+        format!("Bits {}:{}", offset, offset + width as u64 - 1)
+    };
+    if description.len() > 0 {
+        res.push_str(" - ");
+        res.push_str(&util::respace(&util::escape_brackets(description)));
+    }
+    res
+}
+
 struct F<'a> {
     _pc_w: Ident,
     _sc: Ident,
     access: Option<Access>,
     description: String,
-    description_with_bits: String,
     evs: &'a [EnumeratedValues],
     mask: u64,
     name: &'a str,
@@ -737,6 +842,7 @@ struct F<'a> {
     ty: Ident,
     width: u32,
     write_constraint: Option<&'a WriteConstraint>,
+    dim: Option<(u32, u32, u32, TokenStream, Vec<Ident>)>,
 }
 
 #[derive(Clone, Debug)]

src/util.rs

@@ -195,6 +195,14 @@ pub fn name_of(register: &Register) -> Cow<str> {
     }
 }
 
+pub fn replace_suffix(name: &str, suffix: &str) -> String {
+    if name.contains("[%s]") {
+        name.replace("[%s]", suffix)
+    } else {
+        name.replace("%s", suffix)
+    }
+}
+
 pub fn access_of(register: &Register) -> Access {
     register.access.unwrap_or_else(|| {
         if let Some(fields) = &register.fields {