Rebase on Compiles with newest svd master

Author: James Munns

Cargo.toml

@@ -36,5 +36,5 @@ error-chain = "0.11.0"
 inflections = "1.1.0"
 log = { version = "~0.4", features = ["std"] }
 quote = "0.3.15"
-svd-parser = "0.6"
+svd-parser = "0.7"
 syn = "0.11.11"

src/generate/peripheral.rs

@@ -1,9 +1,8 @@
 use std::borrow::Cow;
 use std::cmp::Ordering;
 
-use either::Either;
 use quote::{ToTokens, Tokens};
-use crate::svd::{Cluster, ClusterInfo, Defaults, Peripheral, Register};
+use svd::{Cluster, ClusterInfo, Defaults, Peripheral, Register, RegisterCluster};
 use syn::{self, Ident};
 use log::warn;
 
@@ -356,7 +355,7 @@ impl FieldRegions {
 }
 
 fn register_or_cluster_block(
-    ercs: &[Either<Register, Cluster>],
+    ercs: &[RegisterCluster],
     defs: &Defaults,
     name: Option<&str>,
     nightly: bool,
@@ -369,7 +368,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> {
@@ -433,7 +432,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> {
@@ -552,16 +551,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)?,
         });
     }
 
@@ -577,15 +576,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)?
             }
         };
@@ -665,7 +664,7 @@ fn expand_register(
     match *register {
         Register::Single(ref info) => register_expanded.push(RegisterBlockField {
             field: convert_svd_register(register, name),
-            description: info.description.clone(),
+            description: info.description.clone().unwrap(),
             offset: info.address_offset,
             size: register_size,
         }),
@@ -685,15 +684,15 @@ fn expand_register(
             if array_convertible {
                 register_expanded.push(RegisterBlockField {
                     field: convert_svd_register(&register, name),
-                    description: info.description.clone(),
+                    description: info.description.clone().unwrap(),
                     offset: info.address_offset,
                     size: register_size * array_info.dim,
                 });
             } else {
                 for (field_num, field) in expand_svd_register(register, name).iter().enumerate() {
                     register_expanded.push(RegisterBlockField {
                         field: field.clone(),
-                        description: info.description.clone(),
+                        description: info.description.clone().unwrap(),
                         offset: info.address_offset + field_num as u32 * array_info.dim_increment,
                         size: register_size,
                     });

src/generate/register.rs

@@ -1,8 +1,7 @@
 use cast::u64;
-use either::Either;
 use quote::Tokens;
-use crate::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 crate::errors::*;
@@ -31,7 +30,7 @@ pub fn render(
         rsize.next_power_of_two()
     };
     let rty = rsize.to_ty()?;
-    let description = util::escape_brackets(util::respace(&register.description).as_ref());
+    let description = util::escape_brackets(util::respace(&register.description.clone().unwrap()).as_ref());
 
     let unsafety = unsafety(register.write_constraint.as_ref(), rsize);
 
@@ -222,7 +221,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));
@@ -1014,7 +1014,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;
     }
@@ -1033,10 +1033,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/lib.rs

@@ -467,7 +467,7 @@ pub enum SvdError {
 pub fn generate(xml: &str, target: Target, nightly: bool) -> Result<Generation> {
     use std::fmt::Write;
 
-    let device = svd::parse(xml);
+    let device = svd::parse(xml).unwrap(); //TODO(AJM)
     let mut device_x = String::new();
     let items = generate::device::render(&device, target, nightly, &mut device_x)
         .or(Err(SvdError::Render))?;

src/main.rs

@@ -92,7 +92,7 @@ fn run() -> Result<()> {
         }
     }
 
-    let device = svd::parse(xml);
+    let device = svd::parse(xml).unwrap(); //TODO(AJM)
 
     let nightly = matches.is_present("nightly_features");
 

src/util.rs

@@ -1,10 +1,9 @@
 use std::borrow::Cow;
 
-use either::Either;
 use inflections::Inflect;
-use crate::svd::{Access, Cluster, Register};
-use quote::Tokens;
+use svd::{Access, Cluster, Register, RegisterCluster};
 use syn::Ident;
+use quote::Tokens;
 
 use crate::errors::*;
 
@@ -291,23 +290,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> {
-    let clusters: Vec<&Cluster> = ercs
-        .iter()
+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> {
-    let registers: Vec<&Register> = ercs
-        .iter()
+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();