Merge pull request #231 from rust-embedded/info

initial "info" tool support

src/cli.rs

@@ -1,11 +1,12 @@
 use anyhow::{Ok, Result};
 use clap::Parser;
-use std::{fs::File, io::Write, path::PathBuf};
+use std::{fs::File, io::Write, path::PathBuf, str::FromStr};
 
 use svdtools::{
  convert::convert_cli,
  html::html_cli,
  html::htmlcompare_cli,
+ info,
  interrupts::interrupts_cli,
  makedeps::makedeps_cli,
  mmap::mmap_cli,
@@ -123,6 +124,16 @@ enum Command {
  /// Path to patched SVD files
  svdfiles: Vec<PathBuf>,
  },
+ /// Prints informetion and statistics about SVD file
+ Info {
+ /// Path to input file
+ in_path: PathBuf,
+ /// Format of input file (XML, JSON or YAML)
+ #[clap(long = "input-format")]
+ input_format: Option<convert_cli::InputFormat>,
+ /// Describe requested information
+ request: String,
+ },
 }
 
 impl Command {
@@ -198,6 +209,23 @@ impl Command {
  Self::Html { htmldir, svdfiles } => {
  html_cli::svd2html(htmldir, svdfiles)?;
  }
+ Self::Info {
+ in_path,
+ input_format,
+ request,
+ } => {
+ let request = info::Request::from_str(request)?;
+ let device = convert_cli::open_svd(
+ in_path,
+ *input_format,
+ convert_cli::ParserConfig {
+ ignore_enums: true,
+ ..Default::default()
+ },
+ )?;
+ let response = request.process(&device)?;
+ println!("{response}")
+ }
  }
  Ok(())
  }

src/convert/convert_cli.rs

@@ -2,6 +2,7 @@ use anyhow::{anyhow, Result};
 use std::io::{Read, Write};
 use std::str::FromStr;
 use std::{fs::File, path::Path};
+use svd_rs::Device;
 
 use crate::get_encoder_config;
 pub use crate::ConfigFormat;
@@ -46,34 +47,25 @@ impl FromStr for OutputFormat {
  }
 }
 
+#[derive(Clone, Copy, Debug, Default)]
 pub struct ParserConfig {
  pub expand: bool,
  pub expand_properties: bool,
  pub ignore_enums: bool,
 }
 
-pub fn convert(
+pub fn open_svd(
  in_path: &Path,
- out_path: &Path,
  input_format: Option<InputFormat>,
- output_format: Option<OutputFormat>,
  parser_config: ParserConfig,
- format_config: Option<&Path>,
-) -> Result<()> {
+) -> Result<Device> {
  let input_format = match input_format {
  None => match in_path.extension().and_then(|e| e.to_str()) {
  Some(s) => InputFormat::from_str(s)?,
  _ => return Err(anyhow!("Unknown input file format")),
  },
  Some(t) => t,
  };
- let output_format = match output_format {
- None => match out_path.extension().and_then(|e| e.to_str()) {
- Some(s) => OutputFormat::from_str(s)?,
- _ => return Err(anyhow!("Unknown output file format")),
- },
- Some(t) => t,
- };
 
  let mut input = String::new();
  File::open(in_path)?.read_to_string(&mut input)?;
@@ -94,6 +86,26 @@ pub fn convert(
  } else {
  device
  };
+ Ok(device)
+}
+
+pub fn convert(
+ in_path: &Path,
+ out_path: &Path,
+ input_format: Option<InputFormat>,
+ output_format: Option<OutputFormat>,
+ parser_config: ParserConfig,
+ format_config: Option<&Path>,
+) -> Result<()> {
+ let device = open_svd(in_path, input_format, parser_config)?;
+
+ let output_format = match output_format {
+ None => match out_path.extension().and_then(|e| e.to_str()) {
+ Some(s) => OutputFormat::from_str(s)?,
+ _ => return Err(anyhow!("Unknown output file format")),
+ },
+ Some(t) => t,
+ };
 
  let config = get_encoder_config(format_config)?;
 

src/info/mod.rs

@@ -0,0 +1,28 @@
+use std::str::FromStr;
+
+use anyhow::Ok;
+use svd_rs::Device;
+
+#[derive(Clone, Debug)]
+#[non_exhaustive]
+pub enum Request {
+ DeviceName,
+}
+
+impl FromStr for Request {
+ type Err = anyhow::Error;
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ match s {
+ "device-name" => Ok(Self::DeviceName),
+ _ => Err(anyhow::anyhow!("Unknown info request: {s}")),
+ }
+ }
+}
+
+impl Request {
+ pub fn process(&self, device: &Device) -> anyhow::Result<String> {
+ match self {
+ Self::DeviceName => Ok(device.name.to_string()),
+ }
+ }
+}

src/lib.rs

@@ -5,6 +5,7 @@ use std::{fs::File, path::Path, str::FromStr};
 pub mod common;
 pub mod convert;
 pub mod html;
+pub mod info;
 pub mod interrupts;
 pub mod makedeps;
 pub mod mmap;

src/patch/device.rs

@@ -410,9 +410,9 @@ impl DeviceExt for Device {
  .enumerate()
  .find(|(_, f)| f.name == pnew)
  .ok_or_else(|| anyhow!("peripheral {pnew} not found"))?;
- d.name = new.name.clone();
+ d.name.clone_from(&new.name);
  d.base_address = new.base_address;
- d.interrupt = new.interrupt.clone();
+ d.interrupt.clone_from(&new.interrupt);
  *new = d;
  for (i, p) in self.peripherals.iter_mut().enumerate() {
  if p.derived_from.as_deref() == Some(pold) {

src/patch/peripheral.rs

@@ -132,6 +132,7 @@ pub(crate) trait RegisterBlockExt: Name {
  fn get_mut_reg(&mut self, name: &str) -> Option<&mut Register>;
 
  /// Register/cluster block
+ #[allow(unused)]
  fn children(&self) -> Option<&Vec<RegisterCluster>>;
 
  /// Register/cluster block
@@ -402,6 +403,7 @@ pub(crate) trait RegisterBlockExt: Name {
  }
  }
  /// Work through a register, handling all fields
+ #[allow(unused)]
  fn process_register(
  &mut self,
  rspec: &str,

src/patch/register.rs

@@ -389,7 +389,7 @@ impl RegisterExt for Register {
  for f in fields.iter_mut() {
  if names.contains(&f.name) {
  if first {
- desc = f.description.clone();
+ desc.clone_from(&f.description);
  first = false;
  }
  bitwidth += f.bit_range.width;