expand derived registers

This is a very basic first cut at expanding registers with derivedFrom.

This commit requires rust-embedded/svd#50

Author: wez

src/generate/peripheral.rs

@@ -1,9 +1,10 @@
 use std::borrow::Cow;
 use std::cmp::Ordering;
+use std::collections::HashMap;
 
 use either::Either;
 use quote::{ToTokens, Tokens};
-use svd::{Cluster, ClusterInfo, Defaults, Peripheral, Register};
+use svd::{Cluster, ClusterInfo, Defaults, Peripheral, Register, RegisterInfo};
 use syn::{self, Ident};
 
 use errors::*;
@@ -23,7 +24,7 @@ pub fn render(
         all_peripherals.iter().find(|x| x.name == *s)
     });
 
-    let p_merged = p_derivedfrom.map(|x| p_original.derive_from(x));
+    let p_merged = p_derivedfrom.map(|ancestor| p_original.derive_from(ancestor));
     let p = p_merged.as_ref().unwrap_or(p_original);
 
     if p_original.derived_from.is_some() && p_derivedfrom.is_none() {
@@ -75,9 +76,84 @@ pub fn render(
 
     // erc: *E*ither *R*egister or *C*luster
     let ercs = p.registers.as_ref().map(|x| x.as_ref()).unwrap_or(&[][..]);
-
     let registers: &[&Register] = &util::only_registers(&ercs)[..];
+
+    // make a pass to expand derived registers.  Ideally, for the most minimal
+    // code size, we'd do some analysis to figure out if we can 100% reuse the
+    // code that we're deriving from.  For the sake of proving the concept, we're
+    // just going to emit a second copy of the accessor code.  It'll probably
+    // get inlined by the compiler anyway, right? :-)
+
+    // Build a map so that we can look up registers within this peripheral
+    let mut reg_map = HashMap::new();
+    for r in registers {
+        reg_map.insert(&r.name, r.clone());
+    }
+
+    // Compute the effective, derived version of a register given the definition
+    // with the derived_from property on it (`info`) and its `ancestor`
+    fn derive_reg_info(info: &RegisterInfo, ancestor: &RegisterInfo) -> RegisterInfo {
+        let mut derived = info.clone();
+
+        if derived.size.is_none() {
+            derived.size = ancestor.size.clone();
+        }
+        if derived.access.is_none() {
+            derived.access = ancestor.access.clone();
+        }
+        if derived.reset_value.is_none() {
+            derived.reset_value = ancestor.reset_value.clone();
+        }
+        if derived.reset_mask.is_none() {
+            derived.reset_mask = ancestor.reset_mask.clone();
+        }
+        if derived.fields.is_none() {
+            derived.fields = ancestor.fields.clone();
+        }
+        if derived.write_constraint.is_none() {
+            derived.write_constraint = ancestor.write_constraint.clone();
+        }
+
+        derived
+    }
+
+    // Build up an alternate erc list by expanding any derived registers
+    let mut alt_erc :Vec<Either<Register,Cluster>> = registers.iter().filter_map(|r| {
+        match r.derived_from {
+            Some(ref derived) => {
+                let ancestor = match reg_map.get(derived) {
+                    Some(r) => r,
+                    None => {
+                        eprintln!("register {} derivedFrom missing register {}", r.name, derived);
+                        return None
+                    }
+                };
+
+                let d = match **ancestor {
+                    Register::Array(ref info, ref array_info) => {
+                        Some(Either::Left(Register::Array(derive_reg_info(*r, info), array_info.clone())))
+                    }
+                    Register::Single(ref info) => {
+                        Some(Either::Left(Register::Single(derive_reg_info(*r, info))))
+                    }
+                };
+
+                d
+            }
+            None => Some(Either::Left((*r).clone())),
+        }
+    }).collect();
+
+    // Now add the clusters to our alternate erc list
+    let clusters = util::only_clusters(ercs);
+    for cluster in &clusters {
+        alt_erc.push(Either::Right((*cluster).clone()));
+    }
+
+    // And revise registers, clusters and ercs to refer to our expanded versions
+    let registers: &[&Register] = &util::only_registers(&alt_erc)[..];
     let clusters = util::only_clusters(ercs);
+    let ercs = &alt_erc;
 
     // No `struct RegisterBlock` can be generated
     if registers.is_empty() && clusters.is_empty() {