field array support

burrbull · burrbull · commit ff56f524334f · 2019-12-15T18:44:59.000+03:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Added
+
+- Support of field arrays
+
 ### Fixed
 
 - Properly use of default RegisterProperties.
diff --git a/src/generate/register.rs b/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,43 @@ 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>() {
+                            let sequential_indexes = dim_index
+                                .iter()
+                                .map(|element| element.parse::<u32>())
+                                .eq((first..de.dim+first).map(Ok));
+                            if !sequential_indexes {
+                                return Err(format!("unsupported array indexes in {}", f.name))?;
+                            }
+                            (first, None)
+                        } else {
+                            (0, de.dim_index.clone())
+                        }
+                    } else {
+                        (0, None)
+                    };
+                    let suffixes: Vec<_> = match index {
+                        Some(ix) => ix,
+                        None => (0..de.dim).map(|i| (first + i).to_string()).collect(),
+                    };
+                    Some((first, de.dim, de.dim_increment, suffixes))
+                },
+                Field::Single(_) => None
+            };
+
             Ok(F {
                 _pc_w,
                 _sc,
                 description,
-                description_with_bits,
                 pc_r,
                 _pc_r,
                 pc_w,
@@ -267,6 +285,7 @@ pub fn fields(
                 offset: u64::from(offset),
                 ty: width.to_ty()?,
                 write_constraint: f.write_constraint.as_ref(),
+                dim,
             })
         }
     }
@@ -306,10 +325,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 +344,72 @@ 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, suffixes)) = f.dim.clone() {
+                let mut offset_calc = if first != 0 {
+                    let first = util::unsuffixed(first as u64);
+                    quote! { (n - #first) }
+                } else {
+                    quote! { n }
+                };
+                if increment != 1 {
+                    let increment = util::unsuffixed(increment as u64);
+                    offset_calc = quote! { #offset_calc * #increment };
+                }
+                offset_calc = if offset !=0 {
+                    let offset = &util::unsuffixed(offset);
+                    quote! { let o = #offset_calc + #offset; }
+                } else {
+                    quote! { let o = #offset_calc; }
+                };
+                let value = quote! { ((self.bits >> o) & #mask) #cast };
+                let doc = &f.description;
                 r_impl_items.push(quote! {
-                    #[doc = #description_with_bits]
+                    #[doc = #doc]
+                    #[inline(always)]
+                    pub unsafe fn #sc(&self, n: u32) -> #_pc_r {
+                        #offset_calc
+                        #_pc_r::new( #value )
+                    }
+                });
+                for (i, suffix) in (0..dim).zip(suffixes.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 sc_n = Ident::new(&util::replace_suffix(&f.name.to_sanitized_snake_case(), &suffix), Span::call_site());
+                    let doc = util::replace_suffix(&description_with_bits(&f.description, offset, width), &suffix);
+                    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 = #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 +422,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 +432,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 +447,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 +507,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 +519,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 +592,33 @@ pub fn fields(
                 });
             }
 
-            proxy_items.push(if offset != 0 {
+            proxy_items.push(if let Some((first, _, increment, _)) = f.dim {
+                let mut offset_calc = if first != 0 {
+                    let first = util::unsuffixed(first as u64);
+                    quote! { (self.n - #first) }
+                } else {
+                    quote! { self.n }
+                };
+                if increment != 1 {
+                    let increment = util::unsuffixed(increment as u64);
+                    offset_calc = quote! { #offset_calc * #increment };
+                }
+                offset_calc = if offset !=0 {
+                    let offset = &util::unsuffixed(offset);
+                    quote! { let o = #offset_calc + #offset; }
+                } else {
+                    quote! { let o = #offset_calc; }
+                };
+                quote! {
+                    ///Writes raw bits to the field
+                    #[inline(always)]
+                    pub #unsafety fn #bits(self, value: #fty) -> &'a mut W {
+                        #offset_calc
+                        self.w.bits = (self.w.bits & !(#mask << o)) | (((value as #rty) & #mask) << o);
+                        self.w
+                    }
+                }
+            } else if offset != 0 {
                 let offset = &util::unsuffixed(offset);
                 quote! {
                     ///Writes raw bits to the field
@@ -554,11 +639,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 +659,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, suffixes)) = f.dim.clone() {
+                let doc = &f.description;
+                w_impl_items.push(quote! {
+                    #[doc = #doc]
+                    #[inline(always)]
+                    pub unsafe fn #sc(&mut self, n: u32) -> #_pc_w {
+                        #_pc_w { w: self, n }
+                    }
+                });
+                for (i, suffix) in (0..dim).zip(suffixes.iter()) {
+                    let n = first + i;
+                    let n = util::unsuffixed(n as u64);
+                    let offset = offset + (i as u64)*(increment as u64);
+                    let sc_n = Ident::new(&util::replace_suffix(&f.name.to_sanitized_snake_case(), &suffix), Span::call_site());
+                    let doc = util::replace_suffix(&description_with_bits(&f.description, offset, width), &suffix);
+                    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 +837,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 +867,7 @@ struct F<'a> {
     ty: Ident,
     width: u32,
     write_constraint: Option<&'a WriteConstraint>,
+    dim: Option<(u32, u32, u32, Vec<String>)>,
 }
 
 #[derive(Clone, Debug)]
diff --git a/src/util.rs b/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 {

Original file line number	Diff line number	Diff line change
`@@ -195,6 +195,14 @@ pub fn name_of(register: &Register) -> Cow<str> {`
`195`	`195`	`}`
`196`	`196`	`}`
`197`	`197`
	`198`	`+pub fn replace_suffix(name: &str, suffix: &str) -> String {`
	`199`	`+ if name.contains("[%s]") {`
	`200`	`+ name.replace("[%s]", suffix)`
	`201`	`+ } else {`
	`202`	`+ name.replace("%s", suffix)`
	`203`	`+ }`
	`204`	`+}`
	`205`	`+`
`198`	`206`	`pub fn access_of(register: &Register) -> Access {`
`199`	`207`	`register.access.unwrap_or_else(\|\| {`
`200`	`208`	`if let Some(fields) = &register.fields {`