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,15 +1,35 @@
 use std::borrow::Cow;
+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::*;
 use util::{self, ToSanitizedSnakeCase, ToSanitizedUpperCase, BITS_PER_BYTE};
 
 use generate::register;
 
+// This is a clone of the helper function from https://github.com/japaric/svd/pull/49
+// and can go away once that is resolved
+fn derive_peripheral(p: &Peripheral, other: &Peripheral) -> Peripheral {
+	let mut derived = p.clone();
+	if derived.group_name.is_none() {
+		derived.group_name = other.group_name.clone();
+	}
+	if derived.description.is_none() {
+		derived.description = other.description.clone();
+	}
+	if derived.registers.is_none() {
+		derived.registers = other.registers.clone();
+	}
+	if derived.interrupt.is_empty() {
+		derived.interrupt = other.interrupt.clone();
+	}
+	derived
+}
+
 pub fn render(
     p_original: &Peripheral,
     all_peripherals: &[Peripheral],
@@ -21,7 +41,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| derive_peripheral(p_original, ancestor));
     let p = p_merged.as_ref().unwrap_or(p_original);
 
     if p_original.derived_from.is_some() && p_derivedfrom.is_none() {
@@ -73,9 +93,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() {