Merge #188

188: skip Options serialize in Cpu, svd2yaml example r=Emilgardis a=burrbull



Co-authored-by: Andrey Zgarbul <zgarbul.andrey@gmail.com>

Author: bors[bot]

svd-parser/Cargo.toml

@@ -23,7 +23,8 @@ anyhow = "1.0.45"
 thiserror = "1.0.30"
 
 [dev-dependencies]
-serde_json = "1.0"
+serde_json = { version = "1.0", features = ["preserve_order"] }
+serde_yaml = "0.8.23"
 svd-rs = { version = "0.12.0", path = "../svd-rs", features = ["serde"] }
 
 [[example]]

svd-parser/examples/svd2json.rs

@@ -5,33 +5,37 @@ use json::Value;
 use std::env::args;
 use std::fs::File;
 use std::io::{Read, Write};
+use std::path::PathBuf;
 
 fn main() {
     // Collect command-line arguments.
-    let argv: Vec<String> = args().collect();
+    let mut args = args();
     // Expect exactly one argument, with the name of the SVD file.
     // (Arg #0 is this program's name, Arg #1 is the actual argument)
-    if argv.len() != 2 {
+    let svd_fn = if let (Some(_), Some(arg1), None) = (args.next(), args.next(), args.next()) {
+        PathBuf::from(arg1)
+    } else {
         println!("Usage: (svd2json) file.svd");
         return;
-    }
-    let svd_fn: String = argv[1].clone();
+    };
 
     // Open the XML-formatted SVD file and read it into a String.
-    let svd_xml = &mut String::new();
+    let mut svd_xml = String::new();
     File::open(&svd_fn)
         .expect("Failed to open SVD input file")
-        .read_to_string(svd_xml)
+        .read_to_string(&mut svd_xml)
         .expect("Failed to read SVD input file to a String");
 
     // Use the 'svd_parser' crate to parse the file.
-    let device = svd::parse(svd_xml).expect("Failed to parse the SVD file into Rust structs");
+    let device = svd::parse(&mut svd_xml).expect("Failed to parse the SVD file into Rust structs");
 
     // Convert the parsed data into JSON format.
-    let v: Value = json::to_value(device).expect("Failed to parse Rust structs into JSON format");
+    let v: Value =
+        json::to_value(device).expect("Failed to serialize Rust structs into JSON format");
 
     // Write the JSON-formatted device description to a file.
-    let json_fn: String = svd_fn + ".json";
+    let mut json_fn = svd_fn.to_path_buf();
+    json_fn.set_extension("json");
     File::create(json_fn)
         .expect("Failed to open JSON output file")
         .write_all(json::to_string_pretty(&v).unwrap().as_bytes())

svd-parser/examples/svd2yaml.rs

@@ -0,0 +1,43 @@
+use serde_yaml as yaml;
+use svd_parser as svd;
+
+use std::env::args;
+use std::fs::File;
+use std::io::{Read, Write};
+use std::path::PathBuf;
+use yaml::Value;
+
+fn main() {
+    // Collect command-line arguments.
+    let mut args = args();
+    // Expect exactly one argument, with the name of the SVD file.
+    // (Arg #0 is this program's name, Arg #1 is the actual argument)
+    let svd_fn = if let (Some(_), Some(arg1), None) = (args.next(), args.next(), args.next()) {
+        PathBuf::from(arg1)
+    } else {
+        println!("Usage: (svd2yaml) file.svd");
+        return;
+    };
+
+    // Open the XML-formatted SVD file and read it into a String.
+    let mut svd_xml = String::new();
+    File::open(&svd_fn)
+        .expect("Failed to open SVD input file")
+        .read_to_string(&mut svd_xml)
+        .expect("Failed to read SVD input file to a String");
+
+    // Use the 'svd_parser' crate to parse the file.
+    let device = svd::parse(&mut svd_xml).expect("Failed to parse the SVD file into Rust structs");
+
+    // Convert the parsed data into YAML format.
+    let v: Value =
+        yaml::to_value(device).expect("Failed to serialize Rust structs into YAML format");
+
+    // Write the YAML-formatted device description to a file.
+    let mut yaml_fn = svd_fn.clone();
+    yaml_fn.set_extension("yaml");
+    File::create(&yaml_fn)
+        .expect("Failed to open YAML output file")
+        .write_all(yaml::to_string(&v).unwrap().as_bytes())
+        .expect("Failed to write to YAML output file");
+}

svd-rs/CHANGELOG.md

@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Unreleased
 
+- skip serializing optional fields in `Cpu` if empty
 - skip serializing `values` in `EnumeratedValues` if empty
 - add `names` function for arrays, `base_addresses` for `Peripheral`,
   `address_offsets` for `Register` and `Cluster`, `bit_offsets` for `Field` arrays

svd-rs/src/cpu.rs

@@ -25,26 +25,53 @@ pub struct Cpu {
 
     /// Indicate whether the processor is equipped with a double precision floating point unit.
     /// This element is valid only when `fpu_present` is set to `true`
-    #[cfg_attr(feature = "serde", serde(rename = "fpuDP"))]
+    #[cfg_attr(
+        feature = "serde",
+        serde(default, skip_serializing_if = "Option::is_none", rename = "fpuDP")
+    )]
     pub fpu_double_precision: Option<bool>,
 
     /// Indicates whether the processor implements the optional SIMD DSP extensions (DSP)
+    #[cfg_attr(
+        feature = "serde",
+        serde(default, skip_serializing_if = "Option::is_none")
+    )]
     pub dsp_present: Option<bool>,
 
     /// Indicate whether the processor has an instruction cache
+    #[cfg_attr(
+        feature = "serde",
+        serde(default, skip_serializing_if = "Option::is_none")
+    )]
     pub icache_present: Option<bool>,
 
     /// Indicate whether the processor has a data cache
+    #[cfg_attr(
+        feature = "serde",
+        serde(default, skip_serializing_if = "Option::is_none")
+    )]
     pub dcache_present: Option<bool>,
 
     /// Indicate whether the processor has an instruction tightly coupled memory
+    #[cfg_attr(
+        feature = "serde",
+        serde(default, skip_serializing_if = "Option::is_none")
+    )]
     pub itcm_present: Option<bool>,
 
     /// Indicate whether the processor has a data tightly coupled memory
+    #[cfg_attr(
+        feature = "serde",
+        serde(default, skip_serializing_if = "Option::is_none")
+    )]
     pub dtcm_present: Option<bool>,
 
     /// Indicate whether the Vector Table Offset Register (VTOR) is implemented.
     /// If not specified, then VTOR is assumed to be present
+    #[cfg_attr(
+        feature = "serde",
+        serde(default, skip_serializing_if = "Option::is_none")
+    )]
     pub vtor_present: Option<bool>,
 
     /// Define the number of bits available in the Nested Vectored Interrupt Controller (NVIC) for configuring priority
@@ -56,9 +83,17 @@ pub struct Cpu {
     pub has_vendor_systick: bool,
 
     /// Add 1 to the highest interrupt number and specify this number in here
+    #[cfg_attr(
+        feature = "serde",
+        serde(default, skip_serializing_if = "Option::is_none")
+    )]
     pub device_num_interrupts: Option<u32>,
 
     /// Indicate the amount of regions in the Security Attribution Unit (SAU)
+    #[cfg_attr(
+        feature = "serde",
+        serde(default, skip_serializing_if = "Option::is_none")
+    )]
     pub sau_num_regions: Option<u32>,
     // sauRegionsConfig
 }