Support loading names with placeholders

Author: datdenkikniet

src/svd2ir.rs

@@ -3,7 +3,7 @@ use clap::ValueEnum;
 use log::*;
 use std::collections::{BTreeMap, BTreeSet};
 use std::ops::Deref;
-use svd_parser::svd::{self, PeripheralInfo};
+use svd_parser::svd::{self, MaybeArray, PeripheralInfo};
 
 use crate::{ir::*, transform};
 
@@ -36,6 +36,107 @@ pub enum NamespaceMode {
     BlockWithRegsVals,
 }
 
+fn remove_placeholder(str: &str) -> String {
+    str.replace("[%s]", "").replace("%s", "")
+}
+
+fn names<T, F>(array: &MaybeArray<T>, f: F) -> ExpandedMaybeArray
+where
+    F: Fn(&T) -> &str,
+{
+    fn is_numeric(str: &String) -> bool {
+        str.chars().all(|v| v.is_numeric())
+    }
+
+    fn replace_placeholder(str: &str, replacement: &str) -> String {
+        str.replace("%s", replacement)
+    }
+
+    fn as_array_name<'a>(
+        r: &str,
+        mut dim_element: impl Iterator<Item = &'a String>,
+    ) -> Option<&str> {
+        if let Some(array) = r.strip_suffix("[%s]") {
+            Some(array)
+        } else if let Some(missed_array) = r.strip_suffix("%s") {
+            // If all dimensions are numeric, the element is an IR
+            // array because accessing with a number offset makes
+            // sense.
+            if dim_element.all(is_numeric) {
+                Some(missed_array)
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }
+
+    match array {
+        MaybeArray::Single(r) => ExpandedMaybeArray::Single(f(r).to_string()),
+        MaybeArray::Array(r, dim_element) => {
+            if let Some(array_name) = as_array_name(f(r), dim_element.dim_index.iter().flatten()) {
+                ExpandedMaybeArray::Array {
+                    name: array_name.to_string(),
+                    array: Array::Regular(RegularArray {
+                        len: dim_element.dim,
+                        stride: dim_element.dim_increment,
+                    }),
+                }
+            } else {
+                let offsets = (0..).step_by(dim_element.dim_increment as _);
+
+                let values = offsets
+                    .zip(
+                        dim_element
+                            .dim_index
+                            .iter()
+                            .flat_map(|v| v.iter())
+                            .map(|dim| replace_placeholder(f(r), dim)),
+                    )
+                    .collect();
+
+                ExpandedMaybeArray::Many(values)
+            }
+        }
+    }
+}
+
+#[derive(Clone)]
+enum ExpandedMaybeArray {
+    Single(String),
+    Array { name: String, array: Array },
+    Many(Vec<(u32, String)>),
+}
+
+impl ExpandedMaybeArray {
+    pub fn array(&self) -> Option<Array> {
+        match self {
+            ExpandedMaybeArray::Array { array, .. } => Some(array.clone()),
+            _ => None,
+        }
+    }
+}
+
+impl IntoIterator for ExpandedMaybeArray {
+    type Item = (u32, String);
+
+    type IntoIter = std::vec::IntoIter<(u32, String)>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        match self {
+            ExpandedMaybeArray::Single(s) => vec![(0, s)].into_iter(),
+            ExpandedMaybeArray::Array { name, .. } => vec![(0, name)].into_iter(),
+            ExpandedMaybeArray::Many(items) => items.into_iter(),
+        }
+    }
+}
+
+fn fieldset_name(mut block_name: Vec<String>, reg_name: String) -> Vec<String> {
+    block_name.push(reg_name);
+    block_name
+}
+
 pub fn convert_peripheral(ir: &mut IR, p: &svd::Peripheral) -> anyhow::Result<()> {
     let mut blocks = Vec::new();
     let pname = p.header_struct_name.clone().unwrap_or(p.name.clone());
@@ -47,7 +148,11 @@ pub fn convert_peripheral(ir: &mut IR, p: &svd::Peripheral) -> anyhow::Result<()
     );
 
     let enum_from_name = enum_map(&blocks);
+
     let mut fieldsets: Vec<ProtoFieldset> = Vec::new();
+    let mut used_fieldset_names = BTreeMap::new();
+    let mut inner_block_to_fieldset = BTreeMap::new();
+
     let mut enums: Vec<ProtoEnum> = Vec::new();
 
     let usable_register_clusters = blocks
@@ -66,13 +171,26 @@ pub fn convert_peripheral(ir: &mut IR, p: &svd::Peripheral) -> anyhow::Result<()
                 return None;
             };
 
-            Some((b, r.deref().clone(), fields))
+            let mut fs_name = fieldset_name(b.clone(), remove_placeholder(&r.name));
+
+            let entry = used_fieldset_names.entry(fs_name.clone()).or_insert(0);
+
+            if *entry != 0 {
+                fs_name.last_mut().map(|v| *v = format!("{v}{entry}"));
+            }
+
+            *entry += 1;
+
+            for (_, full_name) in names(r, |r| &r.name) {
+                let full_name: Vec<_> = fieldset_name(b.clone(), full_name);
+                inner_block_to_fieldset.insert(full_name, fs_name.clone());
+            }
+
+            Some((fs_name, r.deref(), fields))
         });
 
-    for (block_name, r, fields) in usable_register_clusters {
-        let mut fieldset_name = block_name.clone();
+    for (fieldset_name, r, fields) in usable_register_clusters {
         let mut field_name_counts: BTreeMap<String, usize> = BTreeMap::new();
-        fieldset_name.push(remove_placeholder(&r.name));
         fieldsets.push(ProtoFieldset {
             name: fieldset_name.clone(),
             description: r.description.clone(),
@@ -90,7 +208,6 @@ pub fn convert_peripheral(ir: &mut IR, p: &svd::Peripheral) -> anyhow::Result<()
             let mut enum_readwrite = None;
 
             let mut field_name = remove_placeholder(&f.name);
-
             let field_name_count = field_name_counts.entry(field_name.clone()).or_insert(0);
             *field_name_count += 1;
             if *field_name_count > 1 {
@@ -209,74 +326,66 @@ pub fn convert_peripheral(ir: &mut IR, p: &svd::Peripheral) -> anyhow::Result<()
                         continue;
                     }
 
-                    let fieldset_name = if r.fields.is_some() {
-                        let mut fieldset_name = proto.name.clone();
-                        fieldset_name.push(remove_placeholder(&r.name));
-                        Some(fieldset_names.get(&fieldset_name).unwrap().clone())
-                    } else {
-                        None
-                    };
-
-                    let array = if let svd::Register::Array(_, dim) = r {
-                        Some(Array::Regular(RegularArray {
-                            len: dim.dim,
-                            stride: dim.dim_increment,
-                        }))
-                    } else {
-                        None
-                    };
-
-                    let access = match r.properties.access {
-                        None => Access::ReadWrite,
-                        Some(svd::Access::ReadOnly) => Access::Read,
-                        Some(svd::Access::WriteOnly) => Access::Write,
-                        Some(svd::Access::WriteOnce) => Access::Write,
-                        Some(svd::Access::ReadWrite) => Access::ReadWrite,
-                        Some(svd::Access::ReadWriteOnce) => Access::ReadWrite,
-                    };
-
-                    let block_item = BlockItem {
-                        name: remove_placeholder(&r.name),
-                        description: r.description.clone(),
-                        array,
-                        byte_offset: r.address_offset,
-                        inner: BlockItemInner::Register(Register {
-                            access, // todo
-                            bit_size: r.properties.size.unwrap_or(32),
-                            fieldset: fieldset_name.clone(),
-                        }),
-                    };
-
-                    block.items.push(block_item)
+                    let names = crate::svd2ir::names(&r, |r| &r.name);
+                    let array = names.array();
+
+                    for (offset, name) in names {
+                        let fieldset_name = if r.fields.is_some() {
+                            let fieldset_full_name =
+                                fieldset_name(proto.name.clone(), name.clone());
+                            let fieldset_name =
+                                inner_block_to_fieldset.get(&fieldset_full_name).unwrap();
+                            Some(fieldset_names.get(fieldset_name).unwrap().clone())
+                        } else {
+                            None
+                        };
+
+                        let access = match r.properties.access {
+                            None => Access::ReadWrite,
+                            Some(svd::Access::ReadOnly) => Access::Read,
+                            Some(svd::Access::WriteOnly) => Access::Write,
+                            Some(svd::Access::WriteOnce) => Access::Write,
+                            Some(svd::Access::ReadWrite) => Access::ReadWrite,
+                            Some(svd::Access::ReadWriteOnce) => Access::ReadWrite,
+                        };
+
+                        let block_item = BlockItem {
+                            name: name,
+                            description: r.description.clone(),
+                            array: array.clone(),
+                            byte_offset: r.address_offset + offset,
+                            inner: BlockItemInner::Register(Register {
+                                access, // todo
+                                bit_size: r.properties.size.unwrap_or(32),
+                                fieldset: fieldset_name.clone(),
+                            }),
+                        };
+
+                        block.items.push(block_item)
+                    }
                 }
                 svd::RegisterCluster::Cluster(c) => {
                     if c.derived_from.is_some() {
                         warn!("unsupported derived_from in clusters");
                         continue;
                     }
 
-                    let cname = remove_placeholder(&c.name);
-
-                    let array = if let svd::Cluster::Array(_, dim) = c {
-                        Some(Array::Regular(RegularArray {
-                            len: dim.dim,
-                            stride: dim.dim_increment,
-                        }))
-                    } else {
-                        None
-                    };
-
-                    let mut block_name = proto.name.clone();
-                    block_name.push(remove_placeholder(&c.name));
-                    let block_name = block_names.get(&block_name).unwrap().clone();
-
-                    block.items.push(BlockItem {
-                        name: cname.clone(),
-                        description: c.description.clone(),
-                        array,
-                        byte_offset: c.address_offset,
-                        inner: BlockItemInner::Block(BlockItemBlock { block: block_name }),
-                    });
+                    let names = names(c, |c| &c.name);
+                    let array = names.array();
+
+                    for (offset, cname) in names {
+                        let mut block_name = proto.name.clone();
+                        block_name.push(cname.clone());
+                        let block_name = block_names.get(&block_name).unwrap().clone();
+
+                        block.items.push(BlockItem {
+                            name: cname.clone(),
+                            description: c.description.clone(),
+                            array: array.clone(),
+                            byte_offset: c.address_offset + offset,
+                            inner: BlockItemInner::Block(BlockItemBlock { block: block_name }),
+                        });
+                    }
                 }
             }
         }
@@ -299,37 +408,31 @@ pub fn convert_peripheral(ir: &mut IR, p: &svd::Peripheral) -> anyhow::Result<()
                 warn!("unsupported derived_from in fieldset");
             }
 
-            let array = if let svd::Field::Array(_, dim) = f {
-                Some(Array::Regular(RegularArray {
-                    len: dim.dim,
-                    stride: dim.dim_increment,
-                }))
-            } else {
-                None
-            };
+            let names = names(f, |f| &f.name);
+            let array = names.array();
 
-            let field_name = remove_placeholder(&f.name);
+            for (offset, field_name) in names {
+                let mut field = Field {
+                    name: field_name.clone(),
+                    description: f.description.clone(),
+                    bit_offset: BitOffset::Regular(f.bit_range.offset + offset),
+                    bit_size: f.bit_range.width,
+                    array: array.clone(),
+                    enumm: None,
+                };
 
-            let mut field = Field {
-                name: field_name.clone(),
-                description: f.description.clone(),
-                bit_offset: BitOffset::Regular(f.bit_range.offset),
-                bit_size: f.bit_range.width,
-                array,
-                enumm: None,
-            };
+                if !f.enumerated_values.is_empty() {
+                    let mut enum_name = proto.name.clone();
+                    enum_name.push(field_name);
 
-            if !f.enumerated_values.is_empty() {
-                let mut enum_name = proto.name.clone();
-                enum_name.push(field_name);
+                    trace!("finding enum {:?}", enum_name);
+                    let enum_name = enum_names.get(&enum_name).unwrap().clone();
+                    trace!("found {:?}", enum_name);
+                    field.enumm = Some(enum_name.clone())
+                }
 
-                trace!("finding enum {:?}", enum_name);
-                let enum_name = enum_names.get(&enum_name).unwrap().clone();
-                trace!("found {:?}", enum_name);
-                field.enumm = Some(enum_name.clone())
+                fieldset.fields.push(field)
             }
-
-            fieldset.fields.push(field)
         }
 
         let fieldset_name = fieldset_names.get(&proto.name).unwrap().clone();
@@ -492,9 +595,11 @@ fn collect_blocks(
                 continue;
             }
 
-            let mut block_name = block_name.clone();
-            block_name.push(remove_placeholder(&c.name));
-            collect_blocks(out, block_name, c.description.clone(), &c.children);
+            for (_, block) in names(c, |c| &c.name) {
+                let mut block_name = block_name.clone();
+                block_name.push(block);
+                collect_blocks(out, block_name, c.description.clone(), &c.children);
+            }
         }
     }
 }
@@ -588,7 +693,3 @@ pub fn namespace_names(peripheral: &PeripheralInfo, ir: &mut IR, namespace: Name
         }
     });
 }
-
-pub fn remove_placeholder(name: &str) -> String {
-    name.replace("[%s]", "").replace("%s", "")
-}