Auto merge of #121 - kjetilkjeka:field_array, r=japaric

Register array in RegisterBlock

I guess this pull request is dropping a bit out of the sky, but I realized I needed the feature sooner rather than later so decided to just go for it. When it's merged it should fix #114

Some refactoring was done to allow for integration register arrays, the most significant are
- expand function only takes 1 register instead of slice. This means that the function has to be called for every register that should be expanded. This was done so a register can be conditionaly expanded depending on if it's possible to convert to a Rust array or not.
- register_to_rust method was factored out from register_block. Mainly so register block wouldn't grow very large with lots of nested control flow.
- ExpandedRegister was removed, the functions only use Register struct now. This was because if not it would require conversion functions when registers was not expanded. The struct would also need changing as it would only have to support arrays.
- Since the ExpandedRegisters was dropped the expand function now writes ```%s(i)``` (where i is the index) to the names of the expanded registers. This is used later on to resolve name and type.
- regex is a dependecy, this is used to replace ```%s(i)``` with the index. Adding this dependecy might not be desired? and if not I can reimplement it with some logic that iterates over the string.

I've tested with [S32K144.svd](https://github.com/kjetilkjeka/s32k144.rs/blob/master/src/S32K144.svd) and it seems to work perfectly with that file.

As mentioned in #114 i do hope that the method of using svd array information instead of unrolling arrays after is acceptable.

Author: homunkulus

src/generate.rs

@@ -2,14 +2,13 @@ use std::collections::HashMap;
 use std::io::{self, Write};
 
 use cast::u64;
-use either::Either;
-use quote::Tokens;
+use quote::{Tokens, ToTokens};
 use svd::{Access, BitRange, Defaults, Device, EnumeratedValues, Field,
           Peripheral, Register, Usage, WriteConstraint};
-use syn::{Ident, Lit};
+use syn::{self, Ident, Lit};
 
 use errors::*;
-use util::{self, ToSanitizedSnakeCase, ToSanitizedUpperCase, U32Ext};
+use util::{self, ToSanitizedSnakeCase, ToSanitizedUpperCase, U32Ext, BITS_PER_BYTE};
 use Target;
 
 /// Whole device generation
@@ -503,69 +502,135 @@ pub fn peripheral(
     Ok(())
 }
 
+struct RegisterBlockField {
+    field: syn::Field,
+    description: String,
+    offset: u32,
+    size: u32,
+}
+
 fn register_block(registers: &[Register], defs: &Defaults) -> Result<Tokens> {
-    let mut fields = vec![];
+    let mut fields = Tokens::new();
     // enumeration of reserved fields
     let mut i = 0;
     // offset from the base address, in bytes
     let mut offset = 0;
-    for register in util::expand(registers) {
+    let mut registers_expanded = vec![];
+
+    // If svd register arrays can't be converted to rust arrays (non sequential adresses, non numeral indexes, or not containing all elements from 0 to size) they will be expanded
+    for register in registers {
+        let register_size = register.size.or(defs.size)
+            .ok_or_else(
+                || {
+                    format!("Register {} has no `size` field", register.name)
+                },)?;
+        
+        match *register {
+            Register::Single(ref info) => registers_expanded.push(
+                RegisterBlockField{
+                    field: util::convert_svd_register(register),
+                    description: info.description.clone(),
+                    offset: info.address_offset,
+                    size: register_size,
+                }
+            ),
+            Register::Array(ref info, ref array_info) => {
+                let sequential_adresses = register_size == array_info.dim_increment*BITS_PER_BYTE;
+
+                let numeral_indexes = array_info.dim_index.clone()
+                    .ok_or_else( || format!("Register {} has no `dim_index` field", register.name))?
+                    .iter()
+                    .all(|element| element.parse::<usize>().is_ok());
+                
+                let sequential_indexes = if numeral_indexes && sequential_adresses {
+                    array_info.dim_index.clone()
+                        .unwrap()
+                        .iter()
+                        .map(|element| element.parse::<u32>().unwrap())
+                        .collect::<Vec<u32>>()
+                        .eq(&(0..array_info.dim).collect::<Vec<u32>>())
+                } else {
+                    false
+                };
+
+                let array_convertible = sequential_indexes && numeral_indexes && sequential_adresses;
+
+                if array_convertible {
+                    registers_expanded.push(
+                        RegisterBlockField{
+                            field: util::convert_svd_register(&register),
+                            description: info.description.clone(),
+                            offset: info.address_offset,
+                            size: register_size * array_info.dim,
+                        });                                    
+                } else {
+                    let mut field_num = 0;
+                    for field in util::expand_svd_register(register).iter() {
+                        registers_expanded.push(
+                            RegisterBlockField{
+                                field: field.clone(),
+                                description: info.description.clone(),
+                                offset: info.address_offset + field_num * array_info.dim_increment,
+                                size: register_size,
+                            });
+                        field_num += 1;
+                    }
+                }
+            },
+        }
+    }
+
+    registers_expanded.sort_by_key(|x| x.offset);
+
+    for register in registers_expanded {
         let pad = if let Some(pad) = register.offset.checked_sub(offset) {
             pad
         } else {
             writeln!(
                 io::stderr(),
                 "WARNING {} overlaps with another register at offset {}. \
                  Ignoring.",
-                register.name,
+                register.field.ident.unwrap(),
                 register.offset
-            ).ok();
+            )
+                .ok();
             continue;
         };
 
         if pad != 0 {
             let name = Ident::new(format!("_reserved{}", i));
             let pad = pad as usize;
-            fields.push(quote! {
-                #name : [u8; #pad],
-            });
+            fields.append(
+                quote! {
+                    #name : [u8; #pad],
+                });
             i += 1;
         }
 
         let comment = &format!(
             "0x{:02x} - {}",
             register.offset,
-            util::respace(&register.info.description)
+            util::respace(&register.description),
         )
             [..];
-
-        let rty = match register.ty {
-            Either::Left(ref ty) => Ident::from(&**ty),
-            Either::Right(ref ty) => Ident::from(&***ty),
-        };
-        let reg_name = Ident::new(&*register.name.to_sanitized_snake_case());
-        fields.push(quote! {
-            #[doc = #comment]
-            pub #reg_name : #rty,
-        });
-
-        offset = register.offset +
-                 register
-                     .info
-                     .size
-                     .or(defs.size)
-                     .ok_or_else(
-            || {
-                format!("Register {} has no `size` field", register.name)
-            },
-        )? / 8;
+        
+        fields.append(
+            quote! {
+                #[doc = #comment]
+            }
+        );
+        
+        register.field.to_tokens(&mut fields);
+        Ident::new(",").to_tokens(&mut fields);
+        
+        offset = register.offset + register.size/BITS_PER_BYTE;
     }
 
     Ok(quote! {
         /// Register block
         #[repr(C)]
         pub struct RegisterBlock {
-            #(#fields)*
+            #fields
         }
     })
 }

src/util.rs

@@ -1,14 +1,14 @@
 use std::borrow::Cow;
-use std::rc::Rc;
 
-use either::Either;
 use inflections::Inflect;
-use svd::{Access, EnumeratedValues, Field, Peripheral, Register, RegisterInfo,
+use svd::{self, Access, EnumeratedValues, Field, Peripheral, Register,
           Usage};
-use syn::{Ident, IntTy, Lit};
+use syn::{self, Ident, IntTy, Lit};
 
 use errors::*;
 
+pub const BITS_PER_BYTE: u32 = 8;
+
 /// List of chars that some vendors use in their peripheral/field names but
 /// that are not valid in Rust ident
 const BLACKLIST_CHARS: &'static [char] = &['(', ')', '[', ']'];
@@ -136,86 +136,114 @@ pub fn respace(s: &str) -> String {
     s.split_whitespace().collect::<Vec<_>>().join(" ")
 }
 
-pub struct ExpandedRegister<'a> {
-    pub info: &'a RegisterInfo,
-    pub name: String,
-    pub offset: u32,
-    pub ty: Either<String, Rc<String>>,
-}
+/// Takes a svd::Register which may be a register array, and turn in into
+/// a list of syn::Field where the register arrays have been expanded.
+pub fn expand_svd_register(register: &Register) -> Vec<syn::Field> {
+    let name_to_ty = |name: &String| -> syn::Ty {
+        syn::Ty::Path(None, syn::Path{
+            global: false,
+            segments: vec![syn::PathSegment{
+                ident: Ident::new(name.to_sanitized_upper_case()),
+                parameters: syn::PathParameters::none(),
+            }],
+        })
+    };
 
-/// Takes a list of "registers", some of which may actually be register arrays,
-/// and turns it into a new *sorted* (by address offset) list of registers where
-/// the register arrays have been expanded.
-pub fn expand(registers: &[Register]) -> Vec<ExpandedRegister> {
     let mut out = vec![];
 
-    for r in registers {
-        match *r {
-            Register::Single(ref info) => {
-                out.push(
-                    ExpandedRegister {
-                        info: info,
-                        name: info.name.to_sanitized_snake_case().into_owned(),
-                        offset: info.address_offset,
-                        ty: Either::Left(
-                            info.name
-                                .to_sanitized_upper_case()
-                                .into_owned(),
-                        ),
+    match *register {
+        Register::Single(ref _info) => out.push( convert_svd_register(register) ),
+        Register::Array(ref info, ref array_info) => {
+            let has_brackets = info.name.contains("[%s]");
+
+            let indices = array_info
+                .dim_index
+                .as_ref()
+                .map(|v| Cow::from(&**v))
+                .unwrap_or_else(
+                    || {
+                        Cow::from(
+                            (0..array_info.dim)
+                                .map(|i| i.to_string())
+                                .collect::<Vec<_>>(),
+                        )
                     },
-                )
-            }
-            Register::Array(ref info, ref array_info) => {
-                let has_brackets = info.name.contains("[%s]");
-
-                let ty = if has_brackets {
+                );
+            
+            for (idx, _i) in indices.iter().zip(0..) {
+                let name = if has_brackets {
+                    info.name.replace("[%s]", format!("{}", idx).as_str())
+                } else {
+                    info.name.replace("%s", format!("{}", idx).as_str())
+                };
+                
+                let ty_name = if has_brackets {
                     info.name.replace("[%s]", "")
                 } else {
                     info.name.replace("%s", "")
                 };
+                    
+                let ident = Ident::new(name.to_sanitized_snake_case());
+                let ty = name_to_ty(&ty_name);
 
-                let ty = Rc::new(ty.to_sanitized_upper_case().into_owned());
-
-                let indices = array_info
-                    .dim_index
-                    .as_ref()
-                    .map(|v| Cow::from(&**v))
-                    .unwrap_or_else(
-                        || {
-                            Cow::from(
-                                (0..array_info.dim)
-                                    .map(|i| i.to_string())
-                                    .collect::<Vec<_>>(),
-                            )
-                        },
-                    );
-
-                for (idx, i) in indices.iter().zip(0..) {
-                    let name = if has_brackets {
-                        info.name.replace("[%s]", idx)
-                    } else {
-                        info.name.replace("%s", idx)
-                    };
-
-                    let offset = info.address_offset +
-                                 i * array_info.dim_increment;
-
-                    out.push(
-                        ExpandedRegister {
-                            info: info,
-                            name: name.to_sanitized_snake_case().into_owned(),
-                            offset: offset,
-                            ty: Either::Right(ty.clone()),
-                        },
-                    );
-                }
+                out.push(
+                    syn::Field{
+                        ident: Some(ident),
+                        vis: syn::Visibility::Public,
+                        attrs: vec![],
+                        ty: ty,
+                    }
+                );
             }
-        }
+        },
     }
+    out
+}
 
-    out.sort_by_key(|x| x.offset);
+pub fn convert_svd_register(register: &svd::Register) -> syn::Field {
+    let name_to_ty = |name: &String| -> syn::Ty {
+        syn::Ty::Path(None, syn::Path{
+            global: false,
+            segments: vec![syn::PathSegment{
+                ident: Ident::new(name.to_sanitized_upper_case()),
+                parameters: syn::PathParameters::none(),
+            }],
+        })
+    };
+    
+    match *register {
+        Register::Single(ref info) => {
+            syn::Field{
+                ident: Some(Ident::new(info.name.to_sanitized_snake_case())),
+                vis: syn::Visibility::Public,
+                attrs: vec![],
+                ty: name_to_ty(&info.name),
+            }
+        },
+        Register::Array(ref info, ref array_info) => {
+            let has_brackets = info.name.contains("[%s]");
 
-    out
+            let name = if has_brackets {
+                info.name.replace("[%s]", "")
+            } else {
+                info.name.replace("%s", "")
+            };
+            
+            let ident = Ident::new(name.to_sanitized_snake_case());
+            
+            let ty = syn::Ty::Array(
+                Box::new(name_to_ty(&name)),
+                syn::ConstExpr::Lit(syn::Lit::Int(array_info.dim as u64, syn::IntTy::Unsuffixed)),
+            );
+
+            syn::Field{
+                ident: Some(ident),
+                vis: syn::Visibility::Public,
+                attrs: vec![],
+                ty: ty,
+            }
+        },
+    }
 }
 
 pub fn name_of(register: &Register) -> Cow<str> {