initial commit

Author: Jorge Aparicio

.gitignore

@@ -0,0 +1,4 @@
+*.rs.bk
+Cargo.lock
+target
+tests/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "cmsis-svd"]
+	path = cmsis-svd
+	url = git://github.com/posborne/cmsis-svd.git

Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+authors = ["Jorge Aparicio <[email protected]>"]
+name = "svd"
+version = "0.1.0"
+
+[dependencies]
+xmltree = "0.3.2"

README.md

@@ -0,0 +1,23 @@
+[![Build Status][status]](https://travis-ci.org/japaric/svd)
+
+[status]: https://travis-ci.org/japaric/svd.svg?branch=master
+
+# `svd`
+
+> A WIP CMSIS-SVD file parser
+
+## License
+
+Licensed under either of
+
+- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or
+  http://www.apache.org/licenses/LICENSE-2.0)
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+
+at your option.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the
+work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any
+additional terms or conditions.

cmsis-svd

@@ -0,0 +1,60 @@
+#!/bin/bash
+
+set -e
+
+elementIn() {
+    local e
+    for e in "${@:2}"; do
+        [[ "$e" == "$1" ]] && return 0
+    done
+    return 1
+}
+
+main() {
+    local device tests_dir=$(pwd)/tests/
+    local blacklist=(
+        # These SVD files have some registers with a `resetValue` bigger than the register itself
+        Toshiba/M365
+        Toshiba/M367
+        Toshiba/M368
+        Toshiba/M369
+        Toshiba/M36B
+    )
+
+    rm -f tests/*.rs
+
+    local vendor_dir
+    for vendor_dir in $(echo cmsis-svd/data/*); do
+        local vendor=$(basename $vendor_dir)
+        cat >"$tests_dir/$vendor.rs" <<EOF
+#![allow(non_snake_case)]
+
+extern crate svd;
+
+use svd::Device;
+EOF
+
+        local device_path
+        for device_path in $(find $vendor_dir/* -name '*.svd'); do
+            local device=$(basename $device_path)
+            device=${device%.svd}
+
+            if elementIn "$vendor/$device" "${blacklist[@]}"; then
+                continue
+            fi
+
+            device=${device//./_}
+
+            cat >>"$tests_dir/$vendor.rs" <<EOF
+#[test]
+fn $device() {
+    let xml = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/$device_path"));
+
+    Device::parse(xml);
+}
+EOF
+        done
+    done
+}
+
+main

generate-tests.sh

@@ -0,0 +1,14 @@
+extern crate svd;
+
+use std::env;
+use std::fs::File;
+use std::io::Read;
+
+use svd::Device;
+
+fn main() {
+    let xml = &mut String::new();
+    File::open(env::args_os().skip(1).next().unwrap()).unwrap().read_to_string(xml).unwrap();
+
+    println!("{:#?}", Device::parse(xml));
+}

src/bin/parse.rs

@@ -0,0 +1,255 @@
+//! WIP CMSIS-SVD file parser
+//!
+//! Early stage. Not much documentation at the moment but here's some starting code:
+//!
+//! ``` ignore
+//! extern crate svd;
+//!
+//! use svd::Device;
+//!
+//! fn main() {
+//!     println!("{:?}", Device::parse(include_str!("/path/to/file.svd")));
+//! }
+//! ```
+//!
+//! # References
+//!
+//! - [SVD Schema file](https://www.keil.com/pack/doc/CMSIS/SVD/html/group__schema__1__2__gr.html)
+//! - [SVD file database](https://github.com/posborne/cmsis-svd/tree/master/data)
+//! - [Sample SVD file](https://www.keil.com/pack/doc/CMSIS/SVD/html/svd__example_pg.html)
+
+#![deny(warnings)]
+
+extern crate xmltree;
+
+use xmltree::Element;
+
+macro_rules! try {
+    ($e:expr) => {
+        $e.expect(concat!(file!(), ":", line!(), " ", stringify!($e)))
+    }
+}
+
+mod parse;
+
+trait ElementExt {
+    fn get_child_text<K>(&self, k: K) -> Option<String> where String: PartialEq<K>;
+    fn debug(&self);
+}
+
+impl ElementExt for Element {
+    fn get_child_text<K>(&self, k: K) -> Option<String>
+        where String: PartialEq<K>
+    {
+        self.get_child(k).map(|c| try!(c.text.clone()))
+    }
+
+    fn debug(&self) {
+        println!("<{}>", self.name);
+        for c in &self.children {
+            println!("{}: {:?}", c.name, c.text)
+        }
+        println!("</{}>", self.name);
+    }
+}
+
+#[derive(Debug)]
+pub struct Device {
+    pub name: String,
+    pub peripherals: Vec<Peripheral>,
+    pub defaults: Defaults,
+}
+
+impl Device {
+    /// Parses a SVD file
+    ///
+    /// # Panics
+    ///
+    /// If the input is an invalid SVD file (yay, no error handling)
+    pub fn parse(svd: &str) -> Device {
+        let tree = &try!(Element::parse(svd.as_bytes()));
+
+        Device {
+            name: try!(tree.get_child_text("name")),
+            peripherals: try!(tree.get_child("peripherals"))
+                .children
+                .iter()
+                .map(Peripheral::parse)
+                .collect(),
+            defaults: Defaults::parse(tree),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Peripheral {
+    pub name: String,
+    pub description: Option<String>,
+    pub base_address: u32,
+    pub interrupt: Option<Interrupt>,
+    pub registers: Option<Vec<Register>>,
+}
+
+impl Peripheral {
+    fn parse(tree: &Element) -> Peripheral {
+        assert_eq!(tree.name, "peripheral");
+
+        Peripheral {
+            name: try!(tree.get_child_text("name")),
+            description: tree.get_child_text("description"),
+            base_address: try!(parse::u32(try!(tree.get_child("baseAddress")))),
+            interrupt: tree.get_child("interrupt").map(Interrupt::parse),
+            registers: tree.get_child("registers").map(|rs| {
+                rs.children
+                    .iter()
+                    .filter_map(Register::parse)
+                    .collect()
+            }),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Interrupt {
+    pub name: String,
+    pub description: Option<String>,
+    pub value: u32,
+}
+
+impl Interrupt {
+    fn parse(tree: &Element) -> Interrupt {
+        Interrupt {
+            name: try!(tree.get_child_text("name")),
+            description: tree.get_child_text("description"),
+            value: try!(parse::u32(try!(tree.get_child("value")))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Register {
+    pub name: String,
+    pub description: String,
+    pub address_offset: u32,
+    pub size: Option<u32>,
+    pub access: Option<Access>,
+    pub reset_value: Option<u32>,
+    pub reset_mask: Option<u32>,
+    pub fields: Option<Vec<Field>>,
+}
+
+impl Register {
+    // TODO handle "clusters", return `Register` not an `Option`
+    fn parse(tree: &Element) -> Option<Register> {
+        if tree.name == "cluster" {
+            return None;
+        }
+
+        assert_eq!(tree.name, "register");
+
+        Some(Register {
+            name: try!(tree.get_child_text("name")),
+            description: try!(tree.get_child_text("description")),
+            address_offset: try!(parse::u32(try!(tree.get_child("addressOffset")))),
+            size: tree.get_child("size").map(|t| try!(parse::u32(t))),
+            access: tree.get_child("access").map(Access::parse),
+            reset_value: tree.get_child("resetValue").map(|t| try!(parse::u32(t))),
+            reset_mask: tree.get_child("resetMask").map(|t| try!(parse::u32(t))),
+            fields: tree.get_child("fields")
+                .map(|fs| fs.children.iter().map(Field::parse).collect()),
+        })
+    }
+}
+
+#[derive(Debug)]
+pub enum Access {
+    ReadOnly,
+    ReadWrite,
+    ReadWriteOnce,
+    WriteOnly,
+}
+
+impl Access {
+    fn parse(tree: &Element) -> Access {
+        let text = try!(tree.text.as_ref());
+
+        match &text[..] {
+            "read-only" => Access::ReadOnly,
+            "read-write" => Access::ReadWrite,
+            "read-writeOnce" => Access::ReadWriteOnce,
+            "write-only" => Access::WriteOnly,
+            _ => panic!("unknown access variant: {}", text),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Field {
+    pub name: String,
+    pub description: Option<String>,
+    pub bit_range: BitRange,
+}
+
+impl Field {
+    fn parse(tree: &Element) -> Field {
+        assert_eq!(tree.name, "field");
+
+        Field {
+            name: try!(tree.get_child_text("name")),
+            description: tree.get_child_text("description"),
+            bit_range: BitRange::parse(tree),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct BitRange {
+    pub offset: u32,
+    pub width: u32,
+}
+
+impl BitRange {
+    fn parse(tree: &Element) -> BitRange {
+        let (start, end) = if let Some(range) = tree.get_child("bitRange") {
+            let text = try!(range.text.as_ref());
+
+            assert!(text.starts_with('['));
+            assert!(text.ends_with(']'));
+
+            let mut parts = text[1..text.len() - 1].split(':');
+
+            (try!(try!(parts.next()).parse()), try!(try!(parts.next()).parse()))
+        } else if let (Some(lsb), Some(msb)) = (tree.get_child_text("lsb"),
+                                                                   tree.get_child_text("msb")) {
+            (try!(lsb.parse()), try!(msb.parse::<u32>()))
+        } else {
+            return BitRange {
+                offset: try!(try!(tree.get_child_text("bitOffset")).parse()),
+                width: try!(try!(tree.get_child_text("bitWidth")).parse()),
+            };
+        };
+
+        BitRange {
+            offset: start,
+            width: end - start + 1,
+        }
+    }
+}
+
+/// Register default properties
+#[derive(Debug)]
+pub struct Defaults {
+    pub size: Option<u32>,
+    pub reset_value: Option<u32>,
+    pub reset_mask: Option<u32>,
+}
+
+impl Defaults {
+    fn parse(tree: &Element) -> Defaults {
+        Defaults {
+            size: tree.get_child("size").map(|t| try!(parse::u32(t))),
+            reset_value: tree.get_child("resetValue").map(|t| try!(parse::u32(t))),
+            reset_mask: tree.get_child("resetMask").map(|t| try!(parse::u32(t))),
+        }
+    }
+}

src/lib.rs

@@ -0,0 +1,11 @@
+use xmltree::Element;
+
+pub fn u32(tree: &Element) -> Option<u32> {
+    let text = try!(tree.text.as_ref());
+
+    if text.starts_with("0x") || text.starts_with("0X") {
+        u32::from_str_radix(&text["0x".len()..], 16).ok()
+    } else {
+        text.parse().ok()
+    }
+}