Merge pull request #261 from rust-embedded/datatype

add Datatype

Author: Emilgardis

svd-encoder/src/datatype.rs

@@ -0,0 +1,11 @@
+use super::{Config, Element, Encode, EncodeError, XMLNode};
+
+impl Encode for crate::svd::DataType {
+    type Error = EncodeError;
+
+    fn encode_with_config(&self, _config: &Config) -> Result<Element, EncodeError> {
+        let mut elem = Element::new("dataType");
+        elem.children.push(XMLNode::Text(self.as_str().to_string()));
+        Ok(elem)
+    }
+}

svd-encoder/src/lib.rs

@@ -88,6 +88,7 @@ mod bitrange;
 mod cluster;
 mod config;
 mod cpu;
+mod datatype;
 mod device;
 mod dimelement;
 mod endian;

svd-encoder/src/register.rs

@@ -63,6 +63,10 @@ impl Encode for RegisterInfo {
         elem.children
             .extend(self.properties.encode_with_config(config)?);
 
+        if let Some(v) = &self.datatype {
+            elem.children.push(v.encode_node_with_config(config)?);
+        }
+
         if let Some(v) = &self.modified_write_values {
             elem.children.push(v.encode_node_with_config(config)?);
         }

svd-parser/src/datatype.rs

@@ -0,0 +1,14 @@
+use super::*;
+use crate::svd::DataType;
+
+impl Parse for DataType {
+    type Object = Self;
+    type Error = SVDErrorAt;
+    type Config = Config;
+
+    fn parse(tree: &Node, _config: &Self::Config) -> Result<Self, Self::Error> {
+        let text = tree.get_text()?;
+
+        Self::parse_str(text).ok_or_else(|| SVDError::InvalidDatatype(text.into()).at(tree.id()))
+    }
+}

svd-parser/src/device.rs

@@ -1,7 +1,5 @@
 use super::*;
-use crate::svd::{
-    cpu::Cpu, peripheral::Peripheral, registerproperties::RegisterProperties, Device,
-};
+use crate::svd::{cpu::Cpu, peripheral::Peripheral, registerproperties::RegisterProperties};
 
 /// Parses a SVD file
 impl Parse for Device {

svd-parser/src/lib.rs

@@ -196,6 +196,7 @@ mod addressblock;
 mod bitrange;
 mod cluster;
 mod cpu;
+mod datatype;
 mod device;
 mod dimelement;
 mod endian;
@@ -247,6 +248,8 @@ pub enum SVDError {
     NotExpectedTag(String),
     #[error("Invalid RegisterCluster (expected register or cluster), found {0}")]
     InvalidRegisterCluster(String),
+    #[error("Invalid datatype variant, found {0}")]
+    InvalidDatatype(String),
     #[error("Invalid modifiedWriteValues variant, found {0}")]
     InvalidModifiedWriteValues(String),
     #[error("Invalid readAction variant, found {0}")]

svd-parser/src/register.rs

@@ -1,6 +1,6 @@
 use super::*;
 use crate::svd::{
-    Field, ModifiedWriteValues, ReadAction, Register, RegisterInfo, RegisterProperties,
+    DataType, Field, ModifiedWriteValues, ReadAction, Register, RegisterInfo, RegisterProperties,
     WriteConstraint,
 };
 
@@ -28,6 +28,7 @@ impl Parse for RegisterInfo {
             .alternate_register(tree.get_child_text_opt("alternateRegister")?)
             .address_offset(tree.get_child_u32("addressOffset")?)
             .properties(RegisterProperties::parse(tree, config)?)
+            .datatype(optional::<DataType>("dataType", tree, config)?)
             .modified_write_values(optional::<ModifiedWriteValues>(
                 "modifiedWriteValues",
                 tree,

svd-rs/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Unreleased
 
+- Add `DataType`
+
 ## [v0.14.8] - 2024-02-13
 
 - add `maybe_array` constructors

svd-rs/src/datatype.rs

@@ -0,0 +1,88 @@
+/// Register data type
+#[cfg_attr(
+    feature = "serde",
+    derive(serde::Deserialize, serde::Serialize),
+    serde(rename_all = "snake_case")
+)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum DataType {
+    /// unsigned byte
+    U8,
+    /// unsigned half word
+    U16,
+    /// unsigned word
+    U32,
+    /// unsigned double word
+    U64,
+    /// signed byte
+    I8,
+    /// signed half word
+    I16,
+    /// signed world
+    I32,
+    /// signed double word
+    I64,
+    /// pointer to unsigned byte
+    U8Ptr,
+    /// pointer to unsigned half word
+    U16Ptr,
+    /// pointer to unsigned word
+    U32Ptr,
+    /// pointer to unsigned double word
+    U64Ptr,
+    /// pointer to signed byte
+    I8Ptr,
+    /// pointer to signed half word
+    I16Ptr,
+    /// pointer to signed world
+    I32Ptr,
+    /// pointer to signed double word
+    I64Ptr,
+}
+
+impl DataType {
+    /// Parse a string into an [`DataType`] value, returning [`Option::None`] if the string is not valid.
+    pub fn parse_str(s: &str) -> Option<Self> {
+        match s {
+            "uint8_t" => Some(Self::U8),
+            "uint16_t" => Some(Self::U16),
+            "uint32_t" => Some(Self::U32),
+            "uint64_t" => Some(Self::U64),
+            "int8_t" => Some(Self::I8),
+            "int16_t" => Some(Self::I16),
+            "int32_t" => Some(Self::I32),
+            "int64_t" => Some(Self::I64),
+            "uint8_t *" => Some(Self::U8Ptr),
+            "uint16_t *" => Some(Self::U16Ptr),
+            "uint32_t *" => Some(Self::U32Ptr),
+            "uint64_t *" => Some(Self::U64Ptr),
+            "int8_t *" => Some(Self::I8Ptr),
+            "int16_t *" => Some(Self::I16Ptr),
+            "int32_t *" => Some(Self::I32Ptr),
+            "int64_t *" => Some(Self::I64Ptr),
+            _ => None,
+        }
+    }
+
+    /// Convert this [`DataType`] into a static string.
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::U8 => "uint8_t",
+            Self::U16 => "uint16_t",
+            Self::U32 => "uint32_t",
+            Self::U64 => "uint64_t",
+            Self::I8 => "int8_t",
+            Self::I16 => "int16_t",
+            Self::I32 => "int32_t",
+            Self::I64 => "int64_t",
+            Self::U8Ptr => "uint8_t *",
+            Self::U16Ptr => "uint16_t *",
+            Self::U32Ptr => "uint32_t *",
+            Self::U64Ptr => "uint64_t *",
+            Self::I8Ptr => "int8_t *",
+            Self::I16Ptr => "int16_t *",
+            Self::I32Ptr => "int32_t *",
+            Self::I64Ptr => "int64_t *",
+        }
+    }
+}

svd-rs/src/lib.rs

@@ -90,6 +90,10 @@ pub use self::readaction::ReadAction;
 pub mod protection;
 pub use self::protection::Protection;
 
+/// DataType objects
+pub mod datatype;
+pub use self::datatype::DataType;
+
 /// Level of validation
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum ValidateLevel {