Compiles with newest svd master

Author: James Munns

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 = { git = "https://github.com/japaric/svd" }
+svd-parser = { git = "https://github.com/japaric/svd", rev = "6aa4fdc138b91d7b9d2f0bd42fd1c85cb4fb5df9" }
 syn = "0.11.11"

src/generate/peripheral.rs

@@ -2,9 +2,8 @@ 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, RegisterInfo};
+use svd::{Cluster, ClusterInfo, Defaults, Peripheral, Register, RegisterCluster, RegisterInfo};
 use syn::{self, Ident};
 
 use errors::*;
@@ -118,7 +117,7 @@ pub fn render(
     }
 
     // Build up an alternate erc list by expanding any derived registers
-    let mut alt_erc :Vec<Either<Register,Cluster>> = registers.iter().filter_map(|r| {
+    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) {
@@ -131,27 +130,27 @@ pub fn render(
 
                 let d = match **ancestor {
                     Register::Array(ref info, ref array_info) => {
-                        Some(Either::Left(Register::Array(derive_reg_info(*r, info), array_info.clone())))
+                        Some(Register::Array(derive_reg_info(*r, info), array_info.clone()).into())
                     }
                     Register::Single(ref info) => {
-                        Some(Either::Left(Register::Single(derive_reg_info(*r, info))))
+                        Some(Register::Single(derive_reg_info(*r, info)).into())
                     }
                 };
 
                 d
             }
-            None => Some(Either::Left((*r).clone())),
+            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(Either::Right((*cluster).clone()));
+        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)[..];
+    let registers: &[&Register] = &util::only_registers(alt_erc.as_slice())[..];
     let clusters = util::only_clusters(ercs);
     let ercs = &alt_erc;
 
@@ -164,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 {
@@ -433,7 +432,7 @@ impl FieldRegions {
 }
 
 fn register_or_cluster_block(
-    ercs: &[Either<Register, Cluster>],
+    ercs: &[RegisterCluster],
     defs: &Defaults,
     name: Option<&str>,
     nightly: bool,
@@ -446,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> {
@@ -511,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> {
@@ -631,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)?,
         });
     }
 
@@ -656,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();