Try #256:

Author: bors[bot]

Cargo.toml

@@ -33,5 +33,5 @@ either = "1.0.3"
 error-chain = "0.11.0"
 inflections = "1.1.0"
 quote = "0.3.15"
-svd-parser = "0.6"
+svd-parser = { git = "https://github.com/japaric/svd", rev = "6aa4fdc138b91d7b9d2f0bd42fd1c85cb4fb5df9" }
 syn = "0.11.11"

src/generate/peripheral.rs

@@ -1,9 +1,9 @@
 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, RegisterCluster, RegisterInfo};
 use syn::{self, Ident};
 
 use errors::*;
@@ -12,25 +12,36 @@ use util::{self, ToSanitizedSnakeCase, ToSanitizedUpperCase, BITS_PER_BYTE};
 use generate::register;
 
 pub fn render(
-    p: &Peripheral,
+    p_original: &Peripheral,
     all_peripherals: &[Peripheral],
     defaults: &Defaults,
     nightly: bool,
 ) -> Result<Vec<Tokens>> {
     let mut out = vec![];
 
+    let p_derivedfrom = p_original.derived_from.as_ref().and_then(|s| {
+        all_peripherals.iter().find(|x| x.name == *s)
+    });
+
+    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() {
+        eprintln!("Couldn't find derivedFrom original: {} for {}, skipping",
+            p_original.derived_from.as_ref().unwrap(), p_original.name);
+        return Ok(out);
+    }
+
     let name_pc = Ident::new(&*p.name.to_sanitized_upper_case());
     let address = util::hex(p.base_address);
     let description = util::escape_brackets(util::respace(p.description.as_ref().unwrap_or(&p.name)).as_ref());
+    let derive_regs = p_derivedfrom.is_some() && p_original.registers.is_none();
 
     let name_sc = Ident::new(&*p.name.to_sanitized_snake_case());
-    let (base, derived) = if let Some(base) = p.derived_from.as_ref() {
-        // TODO Verify that base exists
-        // TODO We don't handle inheritance style `derivedFrom`, we should raise
-        // an error in that case
-        (Ident::new(&*base.to_sanitized_snake_case()), true)
+    let base = if derive_regs {
+        Ident::new(&*p_derivedfrom.unwrap().name.to_sanitized_snake_case())
     } else {
-        (name_sc.clone(), false)
+        name_sc.clone()
     };
 
     // Insert the peripheral structure
@@ -56,17 +67,92 @@ pub fn render(
         }
     });
 
-    // Derived peripherals do not require re-implementation, and will instead
-    // use a single definition of the non-derived version
-    if derived {
+    // Derived peripherals may not require re-implementation, and will instead
+    // use a single definition of the non-derived version.
+    if derive_regs {
         return Ok(out);
     }
 
     // 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<RegisterCluster> = 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(Register::Array(derive_reg_info(*r, info), array_info.clone()).into())
+                    }
+                    Register::Single(ref info) => {
+                        Some(Register::Single(derive_reg_info(*r, info)).into())
+                    }
+                };
+
+                d
+            }
+            None => Some((*r).clone().into()),
+        }
+    }).collect();
+
+    // Now add the clusters to our alternate erc list
+    let clusters = util::only_clusters(ercs);
+    for cluster in &clusters {
+        alt_erc.push((*cluster).clone().into());
+    }
+
+    // And revise registers, clusters and ercs to refer to our expanded versions
+    let registers: &[&Register] = &util::only_registers(alt_erc.as_slice())[..];
     let clusters = util::only_clusters(ercs);
+    let ercs = &alt_erc;
 
     // No `struct RegisterBlock` can be generated
     if registers.is_empty() && clusters.is_empty() {
@@ -77,7 +163,7 @@ pub fn render(
 
     // Push any register or cluster blocks into the output
     let mut mod_items = vec![];
-    mod_items.push(register_or_cluster_block(ercs, defaults, None, nightly)?);
+    mod_items.push(register_or_cluster_block(ercs.as_slice(), defaults, None, nightly)?);
 
     // Push all cluster related information into the peripheral module
     for c in &clusters {
@@ -346,7 +432,7 @@ impl FieldRegions {
 }
 
 fn register_or_cluster_block(
-    ercs: &[Either<Register, Cluster>],
+    ercs: &[RegisterCluster],
     defs: &Defaults,
     name: Option<&str>,
     nightly: bool,
@@ -359,7 +445,7 @@ fn register_or_cluster_block(
 }
 
 fn register_or_cluster_block_stable(
-    ercs: &[Either<Register, Cluster>],
+    ercs: &[RegisterCluster],
     defs: &Defaults,
     name: Option<&str>,
 ) -> Result<Tokens> {
@@ -424,7 +510,7 @@ fn register_or_cluster_block_stable(
 }
 
 fn register_or_cluster_block_nightly(
-    ercs: &[Either<Register, Cluster>],
+    ercs: &[RegisterCluster],
     defs: &Defaults,
     name: Option<&str>,
 ) -> Result<Tokens> {
@@ -544,16 +630,16 @@ fn register_or_cluster_block_nightly(
 /// Expand a list of parsed `Register`s or `Cluster`s, and render them to
 /// `RegisterBlockField`s containing `Field`s.
 fn expand(
-    ercs: &[Either<Register, Cluster>],
+    ercs: &[RegisterCluster],
     defs: &Defaults,
     name: Option<&str>,
 ) -> Result<Vec<RegisterBlockField>> {
     let mut ercs_expanded = vec![];
 
     for erc in ercs {
         ercs_expanded.extend(match erc {
-            Either::Left(ref register) => expand_register(register, defs, name)?,
-            Either::Right(ref cluster) => expand_cluster(cluster, defs)?,
+            RegisterCluster::Register(ref register) => expand_register(register, defs, name)?,
+            RegisterCluster::Cluster(ref cluster) => expand_cluster(cluster, defs)?,
         });
     }
 
@@ -569,15 +655,15 @@ fn cluster_size_in_bits(info: &ClusterInfo, defs: &Defaults) -> Result<u32> {
 
     for c in &info.children {
         let end = match *c {
-            Either::Left(ref reg) => {
+            RegisterCluster::Register(ref reg) => {
                 let reg_size: u32 = expand_register(reg, defs, None)?
                     .iter()
                     .map(|rbf| rbf.size)
                     .sum();
 
                 (reg.address_offset * BITS_PER_BYTE) + reg_size
             }
-            Either::Right(ref clust) => {
+            RegisterCluster::Cluster(ref clust) => {
                 (clust.address_offset * BITS_PER_BYTE) + cluster_size_in_bits(clust, defs)?
             }
         };

src/generate/register.rs

@@ -1,8 +1,7 @@
 use cast::u64;
-use either::Either;
 use quote::Tokens;
-use svd::{Access, BitRange, Cluster, Defaults, EnumeratedValues, Field, Peripheral, Register,
-          Usage, WriteConstraint};
+use svd::{Access, BitRange, Defaults, EnumeratedValues, Field, Peripheral, Register,
+          RegisterCluster, Usage, WriteConstraint};
 use syn::Ident;
 
 use errors::*;
@@ -230,7 +229,8 @@ pub fn fields(
 
     impl<'a> F<'a> {
         fn from(f: &'a Field) -> Result<Self> {
-            let BitRange { offset, width } = f.bit_range;
+            // TODO(AJM) - do we need to do anything with this range type?
+            let BitRange { offset, width, range_type: _ } = f.bit_range;
             let sc = f.name.to_sanitized_snake_case();
             let pc = f.name.to_sanitized_upper_case();
             let pc_r = Ident::new(&*format!("{}R", pc));
@@ -1027,7 +1027,7 @@ fn lookup_in_peripherals<'p>(
 
 fn periph_all_registers<'a>(p: &'a Peripheral) -> Vec<&'a Register> {
     let mut par: Vec<&Register> = Vec::new();
-    let mut rem: Vec<&Either<Register, Cluster>> = Vec::new();
+    let mut rem: Vec<&RegisterCluster> = Vec::new();
     if p.registers.is_none() {
         return par;
     }
@@ -1046,10 +1046,10 @@ fn periph_all_registers<'a>(p: &'a Peripheral) -> Vec<&'a Register> {
 
         let b = b.unwrap();
         match *b {
-            Either::Left(ref reg) => {
+            RegisterCluster::Register(ref reg) => {
                 par.push(reg);
             }
-            Either::Right(ref cluster) => for c in cluster.children.iter() {
+            RegisterCluster::Cluster(ref cluster) => for c in cluster.children.iter() {
                 rem.push(c);
             },
         }

src/main.rs

@@ -101,7 +101,12 @@ fn run() -> Result<()> {
     let nightly = matches.is_present("nightly_features");
 
     let mut device_x = String::new();
-    let items = generate::device::render(&device, &target, nightly, &mut device_x)?;
+    let items = generate::device::render(
+        &device.expect("//TODO(AJM)"),
+        &target,
+        nightly,
+        &mut device_x
+    )?;
 
     if target == Target::CortexM {
         writeln!(File::create("lib.rs").unwrap(), "{}", quote!(#(#items)*)).unwrap();

src/util.rs

@@ -1,10 +1,9 @@
 use std::borrow::Cow;
 
 use inflections::Inflect;
-use svd::{Access, Cluster, Register};
+use svd::{Access, Cluster, Register, RegisterCluster};
 use syn::Ident;
 use quote::Tokens;
-use either::Either;
 
 use errors::*;
 
@@ -271,21 +270,21 @@ impl U32Ext for u32 {
 }
 
 /// Return only the clusters from the slice of either register or clusters.
-pub fn only_clusters(ercs: &[Either<Register, Cluster>]) -> Vec<&Cluster> {
+pub fn only_clusters(ercs: &[RegisterCluster]) -> Vec<&Cluster> {
     let clusters: Vec<&Cluster> = ercs.iter()
         .filter_map(|x| match *x {
-            Either::Right(ref x) => Some(x),
+            RegisterCluster::Cluster(ref x) => Some(x),
             _ => None,
         })
         .collect();
     clusters
 }
 
 /// Return only the registers the given slice of either register or clusters.
-pub fn only_registers(ercs: &[Either<Register, Cluster>]) -> Vec<&Register> {
+pub fn only_registers(ercs: &[RegisterCluster]) -> Vec<&Register> {
     let registers: Vec<&Register> = ercs.iter()
         .filter_map(|x| match *x {
-            Either::Left(ref x) => Some(x),
+            RegisterCluster::Register(ref x) => Some(x),
             _ => None,
         })
         .collect();