Instead of working on Register structs inside register_block we now work on the new struct RegisterBlockField. Instead of creating a brand new type representing a rust field it's an extension (by composition) of the syn::Field to also give information about offset, size and description. This means that the util extend function now extend to a vector of syn::Field.

Author: kjetilkjeka

src/generate.rs

@@ -2,9 +2,10 @@ use std::collections::HashMap;
 use std::io::{self, Write};
 
 use cast::u64;
-use quote::Tokens;
+use quote::{Tokens, ToTokens};
 use svd::{Access, BitRange, Defaults, Device, EnumeratedValues, Field,
           Peripheral, Register, Usage, WriteConstraint};
+use syn;
 use syn::{Ident, Lit};
 
 use errors::*;
@@ -460,8 +461,15 @@ pub fn peripheral(
     Ok(())
 }
 
+struct RegisterBlockField {
+    field: syn::Field,
+    description: Ident,
+    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
@@ -470,8 +478,19 @@ fn register_block(registers: &[Register], defs: &Defaults) -> Result<Tokens> {
 
     for register in registers {
         match *register {
-            Register::Single(ref _into) => registers_expanded.push(register.clone()),
-            Register::Array(ref _into, ref array_info) => {
+            Register::Single(ref info) => registers_expanded.push(
+                RegisterBlockField{
+                    field: util::convert_svd_register(register),
+                    description: Ident::from(info.description.clone()),
+                    offset: info.address_offset,
+                    size: info.size.or(defs.size)
+                        .ok_or_else(
+                            || {
+                                format!("Register {} has no `size` field", register.name)
+                            },)?,
+                }
+            ),
+            Register::Array(ref info, ref array_info) => {
                 let index_convertible = if let Some(ref indexes) = array_info.dim_index {
                     let mut index_iter = indexes.iter();
                     let mut previous = 0;
@@ -512,69 +531,90 @@ fn register_block(registers: &[Register], defs: &Defaults) -> Result<Tokens> {
                 let array_convertible = index_convertible && packed_registers;
 
                 if array_convertible {
-                    registers_expanded.push(register.clone());
+                    registers_expanded.push(
+                        RegisterBlockField{
+                            field: util::convert_svd_register(&register),
+                            description: Ident::from(info.description.clone()),
+                            offset: info.address_offset,
+                            size: info.size.or(defs.size)
+                                .ok_or_else(
+                                    || {
+                                        format!("Register {} has no `size` field", register.name)
+                                    },)?
+                            * array_info.dim,
+                        });                                    
                 } else {
-                    registers_expanded.append(&mut util::expand(register));
+                    let mut field_num = 0;
+                    for field in util::expand_svd_register(register).iter() {
+                        registers_expanded.push(
+                            RegisterBlockField{
+                                field: field.clone(),
+                                description: Ident::from(info.description.clone()),
+                                offset: info.address_offset + field_num * array_info.dim_increment,
+                                size: info.size.or(defs.size)
+                                    .ok_or_else(
+                                        || {
+                                            format!("Register {} has no `size` field", register.name)
+                                        },)?
+                            });
+                        field_num += 1;
+                    }
                 }
             },
         }
     }
 
-    
-    for register in util::sort_by_offset(registers_expanded) {
-        let pad = if let Some(pad) = register.address_offset.checked_sub(offset) {
+    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.address_offset
-            ).ok();
+                register.field.ident.unwrap(),
+                register.offset
+            )
+                .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,
+            register.description,
+        )
+            [..];
 
-        fields.push( util::register_to_rust(&register) );
+        fields.append(
+            quote! {
+                #[doc = #comment]
+            }
+        );
 
-        offset = match register {
-            Register::Single(ref _into) => register.address_offset
-                +
-                register
-                .size
-                .or(defs.size)
-                .ok_or_else(
-                    || {
-                        format!("Register {} has no `size` field", register.name)
-                    },
-                )? / 8,
-            Register::Array(ref _into, ref array_info) => register.address_offset
-                +
-                register
-                .size
-                .or(defs.size)
-                .ok_or_else(
-                    || {
-                        format!("Register {} has no `size` field", register.name)
-                    },
-                )? * array_info.dim / 8,
-        };
+        register.field.to_tokens(&mut fields);
+        Ident::new(",").to_tokens(&mut fields);
+        
+        offset = register.offset + register.size/8;
     }
 
     Ok(quote! {
         /// Register block
         #[repr(C)]
         pub struct RegisterBlock {
-            #(#fields)*
+            #fields
         }
     })
 }

src/util.rs

@@ -7,7 +7,6 @@ use svd::{Access, EnumeratedValues, Field, Peripheral, Register,
           Usage};
 use syn;
 use syn::{Ident, IntTy, Lit};
-use quote::{Tokens, ToTokens};
 
 use errors::*;
 
@@ -138,44 +137,23 @@ pub fn respace(s: &str) -> String {
     s.split_whitespace().collect::<Vec<_>>().join(" ")
 }
 
-pub fn register_to_rust(register: &Register) -> Tokens {
-    match *register {
-        Register::Single(ref _info) => {
-            let comment = &format!(
-                "0x{:02x} - {}",
-                register.address_offset,
-                respace(&register.description)
-            )
-                [..];
-
-            let array_index_match = Regex::new(r"%s\((?P<i>[ a-zA-Z0-9]*)\)").unwrap();
-            //println!("{}", register.name.as_str());
-            let rty = Ident::new(array_index_match.replace_all(register.name.as_str(), "").to_sanitized_upper_case());
-            let reg_name = Ident::new(array_index_match.replace_all(register.name.as_str(), "$i").to_sanitized_snake_case());
-
-            quote! {
-                #[doc = #comment]
-                pub #reg_name : #rty,
-            }
-        },
-        Register::Array(ref info, ref array_info) => {
-            let field = convert_svd_register(register);
-            let mut tokens = Tokens::new();
-            field.to_tokens(&mut tokens);
-            Ident::new(",").to_tokens(&mut tokens);
-            tokens
-        },
-    }
-}
-
+/// 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 turn in into alist of registers where the register arrays have been expanded.
-pub fn expand(register: &Register) -> Vec<Register> {
     let mut out = vec![];
 
     match *register {
-        Register::Single(ref _info) => out.push( register.clone() ),
+        Register::Single(ref _info) => out.push( convert_svd_register(register) ),
         Register::Array(ref info, ref array_info) => {
             let has_brackets = info.name.contains("[%s]");
 
@@ -192,28 +170,34 @@ pub fn expand(register: &Register) -> Vec<Register> {
                         )
                     },
                 );
-
-            for (idx, i) in indices.iter().zip(0..) {
+            
+            for (idx, _i) in indices.iter().zip(0..) {
                 let name = if has_brackets {
-                    info.name.replace("[%s]", format!("%s({})", idx).as_str())
+                    info.name.replace("[%s]", format!("{}", idx).as_str())
                 } else {
-                    info.name.replace("%s", format!("%s({})", idx).as_str())
+                    info.name.replace("%s", format!("{}", idx).as_str())
                 };
-
-                let offset = info.address_offset +
-                    i * array_info.dim_increment;
-
-                let mut expanded_info = info.clone();
-                expanded_info.name = name;
-                expanded_info.address_offset = offset;
 
+                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);
+
                 out.push(
-                    Register::Single(expanded_info)
+                    syn::Field{
+                        ident: Some(ident),
+                        vis: syn::Visibility::Public,
+                        attrs: vec![],
+                        ty: ty,
+                    }
                 );
             }
-        }
+        },
     }
-
     out
 }
 
@@ -263,12 +247,6 @@ pub fn convert_svd_register(register: &svd::Register) -> syn::Field {
     }
 }
 
-
-pub fn sort_by_offset(mut registers: Vec<Register>) -> Vec<Register> {
-    registers.sort_by_key(|x| x.address_offset);
-    return registers;
-}
-
 pub fn name_of(register: &Register) -> Cow<str> {
     match *register {
         Register::Single(ref info) => Cow::from(&*info.name),