Merge pull request #53 from japaric/refactor

Whoop!

Author: ryankurte

Cargo.toml

@@ -8,6 +8,10 @@ name = "svd-parser"
 repository = "https://github.com/japaric/svd"
 version = "0.6.0"
 
+[features]
+unproven = []
+
 [dependencies]
 either = "1.1.0"
 xmltree = "0.3.2"
+failure = "0.1.1"

README.md

@@ -1,5 +1,7 @@
 [![crates.io](https://img.shields.io/crates/d/svd-parser.svg)](https://crates.io/crates/svd-parser)
 [![crates.io](https://img.shields.io/crates/v/svd-parser.svg)](https://crates.io/crates/svd-parser)
+[![Build Status](https://travis-ci.org/japaric/svd.svg?branch=master)](https://travis-ci.org/japaric/svd)
+[![Documentation](https://docs.rs/svd-parser/badge.svg)](https://docs.rs/svd-parser)
 
 # `svd-parser`
 

generate-tests.sh

@@ -10,6 +10,7 @@ elementIn() {
 
 main() {
     local tests_dir=$(pwd)/tests
+    local cmsis_dir=$tests_dir/cmsis_tests
     local blacklist=(
         # These SVD files have some registers with a `resetValue` bigger than the register itself
         Toshiba/M365
@@ -20,13 +21,13 @@ main() {
         SiliconLabs/SIM3L1x8_SVD
     )
 
-    rm -rf tests
-    mkdir -p tests
+    rm -rf tests/cmsis_tests
+    mkdir -p tests/cmsis_tests
 
     local vendor_dir
     for vendor_dir in $(echo cmsis-svd/data/*); do
         local vendor=$(basename $vendor_dir)
-        cat >"$tests_dir/$vendor.rs" <<EOF
+        cat >"$cmsis_dir/$vendor.rs" <<EOF
 #![allow(non_snake_case)]
 
 extern crate svd_parser as svd;
@@ -44,16 +45,23 @@ EOF
 
             device=${device//./_}
 
-            cat >>"$tests_dir/$vendor.rs" <<EOF
+            cat >>"$cmsis_dir/$vendor.rs" <<EOF
 #[test]
 fn $device() {
     let xml = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/$device_path"));
 
-    svd::parse(xml);
+    svd::parse(xml).unwrap();
 }
 EOF
-        done
+	done
+	cat >>"$cmsis_dir/mod.rs" <<EOF
+pub mod $vendor;
+EOF
     done
+    cat >"$tests_dir/cmsis.rs"<<EOF
+pub mod cmsis_tests;
+use cmsis_tests::*;
+EOF
 }
 
 main

src/elementext.rs

@@ -0,0 +1,110 @@
+//! SVD Element Extensions.
+//! This module is extends xmltree::Element objects with convenience methods
+
+use xmltree::Element;
+
+use failure::ResultExt;
+use types::{BoolParse, Parse};
+
+use error::*;
+
+/// Defines extensions for implementation over xmltree::Element
+pub trait ElementExt {
+    fn get_child_text_opt<K>(&self, k: K) -> Result<Option<String>, SVDError>
+    where
+        String: PartialEq<K>;
+    fn get_child_text<K>(&self, k: K) -> Result<String, SVDError>
+    where
+        String: PartialEq<K>,
+        K: ::std::fmt::Display + Clone;
+
+    fn get_text(&self) -> Result<String, SVDError>;
+
+    fn get_child_elem<'a>(&'a self, n: &str) -> Result<&'a Element, SVDError>;
+    fn get_child_u32(&self, n: &str) -> Result<u32, SVDError>;
+    fn get_child_bool(&self, n: &str) -> Result<bool, SVDError>;
+
+    fn merge(&self, n: &Self) -> Self;
+
+    fn debug(&self);
+}
+
+/// Implements extensions for xmltree::Element
+impl ElementExt for Element {
+    fn get_child_text_opt<K>(&self, k: K) -> Result<Option<String>, SVDError>
+    where
+        String: PartialEq<K>,
+    {
+        if let Some(child) = self.get_child(k) {
+            Ok(Some(child
+                .get_text()
+                .map(|s| s.to_owned())?))
+        } else {
+            Ok(None)
+        }
+    }
+    fn get_child_text<K>(&self, k: K) -> Result<String, SVDError>
+    where
+        String: PartialEq<K>,
+        K: ::std::fmt::Display + Clone,
+    {
+        self.get_child_text_opt(k.clone())?.ok_or(
+            SVDErrorKind::MissingTag(self.clone(), format!("{}", k)).into(),
+        )
+    }
+
+    /// Get text contained by an XML Element
+    fn get_text(&self) -> Result<String, SVDError> {
+        match self.text.as_ref() {
+            Some(s) => Ok(s.clone()),
+            // FIXME: Doesn't look good because SVDErrorKind doesn't format by itself. We already
+            // capture the element and this information can be used for getting the name
+            // This would fix ParseError
+            None => Err(SVDErrorKind::EmptyTag(
+                self.clone(),
+                self.name.clone(),
+            ).into()),
+        }
+    }
+
+    /// Get a named child element from an XML Element
+    fn get_child_elem<'a>(&'a self, n: &str) -> Result<&'a Element, SVDError> {
+        match self.get_child(n) {
+            Some(s) => Ok(s),
+            None => Err(
+                SVDErrorKind::MissingTag(self.clone(), n.to_string()).into(),
+            ),
+        }
+    }
+
+    /// Get a u32 value from a named child element
+    fn get_child_u32(&self, n: &str) -> Result<u32, SVDError> {
+        let s = self.get_child_elem(n)?;
+        u32::parse(&s)
+            .context(SVDErrorKind::ParseError(self.clone()))
+            .map_err(|e| e.into())
+    }
+
+    /// Get a bool value from a named child element
+    fn get_child_bool(&self, n: &str) -> Result<bool, SVDError> {
+        let s = self.get_child_elem(n)?;
+        BoolParse::parse(s)
+    }
+
+    // Merges the children of two elements, maintaining the name and description of the first
+    fn merge(&self, r: &Self) -> Self {
+        let mut n = self.clone();
+        for c in &r.children {
+            n.children.push(c.clone());
+        }
+        n
+    }
+
+    fn debug(&self) {
+        println!("<{}>", self.name);
+        for c in &self.children {
+            println!("{}: {:?}", c.name, c.text)
+        }
+        println!("</{}>", self.name);
+    }
+}

src/encode.rs

@@ -0,0 +1,21 @@
+//! Encode traits.
+//! These support encoding of SVD types to XML
+
+use xmltree::Element;
+
+/// Encode trait allows SVD objects to be encoded into XML elements.
+pub trait Encode {
+    /// Encoding error
+    type Error;
+    /// Encode into an XML/SVD element
+    fn encode(&self) -> Result<Element, Self::Error>;
+}
+
+/// EncodeChildren allows SVD objects to be encoded as a list of XML elements
+/// This is typically used to merge with an existing element.
+pub trait EncodeChildren {
+    /// Encoding error
+    type Error;
+    /// Encode into XML/SVD children to merge with existing object
+    fn encode(&self) -> Result<Vec<Element>, Self::Error>;
+}

src/error.rs

@@ -0,0 +1,113 @@
+//! SVD Errors.
+//! This module defines error types and messages for SVD parsing and encoding
+
+use failure::{Backtrace, Context, Fail};
+use std::fmt::{self, Display};
+use xmltree::{Element, ParseError};
+
+#[derive(Debug)]
+pub struct SVDError {
+    inner: Context<SVDErrorKind>,
+}
+
+// TODO: Expand and make more complex output possible.
+// We can use the `Element` to output name (if available) and etc.
+#[derive(Clone, Debug, PartialEq, Eq, Fail)]
+pub enum SVDErrorKind {
+    #[fail(display = "Unknown endianness `{}`", _0)]
+    UnknownEndian(String),
+    // TODO: Needs context
+    // TODO: Better name
+    #[fail(display = "Expected a <{}> tag, found none", _1)]
+    MissingTag(Element, String),
+    #[fail(display = "Expected content in <{}> tag, found none", _1)]
+    EmptyTag(Element, String),
+    #[fail(display = "ParseError")]
+    ParseError(Element),
+    #[fail(display = "NameMismatch")]
+    NameMismatch(Element),
+    #[fail(display = "unknown access variant found")]
+    UnknownAccessType(Element),
+    #[fail(display = "Bit range invalid, {:?}", _1)]
+    InvalidBitRange(Element, InvalidBitRange),
+    #[fail(display = "Unknown write constraint")]
+    UnknownWriteConstraint(Element),
+    #[fail(display = "Multiple wc found")]
+    MoreThanOneWriteConstraint(Element),
+    #[fail(display = "Unknown usage variant")]
+    UnknownUsageVariant(Element),
+    #[fail(display = "Expected a <{}>, found ...", _1)]
+    NotExpectedTag(Element, String),
+    #[fail(
+        display = "Invalid RegisterCluster (expected register or cluster), found {}",
+        _1
+    )]
+    InvalidRegisterCluster(Element, String),
+    #[fail(display = "Invalid modifiedWriteValues variant, found {}", _1)]
+    InvalidModifiedWriteValues(Element, String),
+    #[fail(
+        display = "The content of the element could not be parsed to a boolean value {}: {}",
+        _1,
+        _2
+    )]
+    InvalidBooleanValue(Element, String, ::std::str::ParseBoolError),
+    #[fail(display = "encoding method not implemented for svd object {}", _0)]
+    EncodeNotImplemented(String),
+    #[fail(display = "Error parsing SVD XML")]
+    FileParseError,
+    // FIXME: Should not be used, only for prototyping
+    #[fail(display = "{}", _0)]
+    Other(String),
+}
+
+// TODO: Consider making into an Error
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum InvalidBitRange {
+    Syntax,
+    ParseError,
+    MsbLsb,
+}
+
+impl Fail for SVDError {
+    fn cause(&self) -> Option<&Fail> {
+        self.inner.cause()
+    }
+
+    fn backtrace(&self) -> Option<&Backtrace> {
+        self.inner.backtrace()
+    }
+}
+
+impl Display for SVDError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.inner, f)
+    }
+}
+
+impl SVDError {
+    pub fn kind(&self) -> SVDErrorKind {
+        self.inner.get_context().clone()
+    }
+}
+
+impl From<SVDErrorKind> for SVDError {
+    fn from(kind: SVDErrorKind) -> SVDError {
+        SVDError {
+            inner: Context::new(kind),
+        }
+    }
+}
+
+impl From<Context<SVDErrorKind>> for SVDError {
+    fn from(inner: Context<SVDErrorKind>) -> SVDError {
+        SVDError { inner }
+    }
+}
+
+impl From<ParseError> for SVDError {
+    fn from(e: ParseError) -> SVDError {
+        SVDError {
+            inner: e.context(SVDErrorKind::FileParseError),
+        }
+    }
+}