Remove enum_read, enum_write.

Chiptool's codegen doesn't support it and never will. Having it in the IR schema
complicates things for no benefit.

svd2ir now merges read-only enum and write-only enums if both are present.

Author: Dirbaio

src/generate/fieldset.rs

@@ -31,7 +31,7 @@ pub fn render(_opts: &super::Options, ir: &IR, fs: &FieldSet, path: &str) -> Res
         let to_bits: TokenStream;
         let from_bits: TokenStream;
 
-        if let Some(e_path) = &f.enum_readwrite {
+        if let Some(e_path) = &f.enumm {
             let Some(e) = ir.enums.get(e_path) else {
                 panic!("missing enum {}", e_path);
             };

src/ir.rs

@@ -157,12 +157,8 @@ pub struct Field {
     pub bit_size: u32,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub array: Option<Array>,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub enum_read: Option<String>,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub enum_write: Option<String>,
     #[serde(default, skip_serializing_if = "Option::is_none", rename = "enum")]
-    pub enum_readwrite: Option<String>,
+    pub enumm: Option<String>,
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]

src/svd2ir.rs

@@ -23,7 +23,6 @@ struct ProtoFieldset {
 #[derive(Debug)]
 struct ProtoEnum {
     name: Vec<String>,
-    usage: Option<svd::Usage>,
     bit_size: u32,
     variants: Vec<svd::EnumeratedValue>,
 }
@@ -58,26 +57,97 @@ pub fn convert_peripheral(ir: &mut IR, p: &svd::Peripheral) -> anyhow::Result<()
                     });
 
                     for f in fields {
+                        info!("field {}.{}", r.name, f.name);
+
                         if f.derived_from.is_some() {
                             continue;
                         }
 
-                        let field_name = f.name.clone();
+                        let mut enum_read = None;
+                        let mut enum_write = None;
+                        let mut enum_readwrite = None;
 
                         for e in &f.enumerated_values {
                             if e.derived_from.is_some() {
+                                // TODO
+                                warn!("ignoring enum with derivedFrom");
+                                continue;
+                            }
+
+                            let usage = e.usage.unwrap_or(svd::Usage::ReadWrite);
+                            let target = match usage {
+                                svd::Usage::Read => &mut enum_read,
+                                svd::Usage::Write => &mut enum_write,
+                                svd::Usage::ReadWrite => &mut enum_readwrite,
+                            };
+
+                            if target.is_some() {
+                                warn!("ignoring enum with dup usage {:?}", usage);
                                 continue;
                             }
 
-                            let mut enum_name = fieldset_name.clone();
-                            enum_name.push(make_enum_name(e, &f.enumerated_values, &field_name));
-                            info!("adding enum {:?}", enum_name);
+                            *target = Some(e)
+                        }
+
+                        enum EnumSet<'a> {
+                            Single(&'a svd::EnumeratedValues),
+                            ReadWrite(&'a svd::EnumeratedValues, &'a svd::EnumeratedValues),
+                        }
 
+                        let set = match (enum_read, enum_write, enum_readwrite) {
+                            (None, None, None) => None,
+                            (Some(e), None, None) => Some(EnumSet::Single(e)),
+                            (None, Some(e), None) => Some(EnumSet::Single(e)),
+                            (None, None, Some(e)) => Some(EnumSet::Single(e)),
+                            (Some(r), Some(w), None) => Some(EnumSet::ReadWrite(r, w)),
+                            (Some(r), None, Some(w)) => Some(EnumSet::ReadWrite(r, w)),
+                            (None, Some(w), Some(r)) => Some(EnumSet::ReadWrite(r, w)),
+                            (Some(_), Some(_), Some(_)) => panic!(
+                                "cannot have enumeratedvalues for read, write and readwrite!"
+                            ),
+                        };
+
+                        if let Some(set) = set {
+                            let variants = match set {
+                                EnumSet::Single(e) => e.values.clone(),
+                                EnumSet::ReadWrite(r, w) => {
+                                    let r_values = r.values.iter().map(|v| v.value.unwrap());
+                                    let w_values = w.values.iter().map(|v| v.value.unwrap());
+                                    let values: HashSet<_> = r_values.chain(w_values).collect();
+                                    let mut values: Vec<_> = values.iter().collect();
+                                    values.sort();
+
+                                    let r_values: HashMap<_, _> =
+                                        r.values.iter().map(|v| (v.value.unwrap(), v)).collect();
+                                    let w_values: HashMap<_, _> =
+                                        w.values.iter().map(|v| (v.value.unwrap(), v)).collect();
+
+                                    values
+                                        .into_iter()
+                                        .map(|&v| match (r_values.get(&v), w_values.get(&v)) {
+                                            (None, None) => unreachable!(),
+                                            (Some(&r), None) => r.clone(),
+                                            (None, Some(&w)) => w.clone(),
+                                            (Some(&r), Some(&w)) => {
+                                                let mut m = r.clone();
+                                                if r.name != w.name {
+                                                    m.name = format!("R_{}_W_{}", r.name, w.name);
+                                                }
+                                                m
+                                            }
+                                        })
+                                        .collect()
+                                }
+                            };
+
+                            info!("adding enum {:?}", fieldset_name);
+
+                            let mut name = fieldset_name.clone();
+                            name.push(f.name.clone());
                             enums.push(ProtoEnum {
-                                name: enum_name,
-                                usage: e.usage,
+                                name,
                                 bit_size: f.bit_range.width,
-                                variants: e.values.clone(),
+                                variants,
                             });
                         }
                     }
@@ -203,30 +273,17 @@ pub fn convert_peripheral(ir: &mut IR, p: &svd::Peripheral) -> anyhow::Result<()
                 bit_offset: f.bit_range.offset,
                 bit_size: f.bit_range.width,
                 array: None,
-                enum_read: None,
-                enum_write: None,
-                enum_readwrite: None,
+                enumm: None,
             };
 
-            for e in &f.enumerated_values {
+            if !f.enumerated_values.is_empty() {
                 let mut enum_name = proto.name.clone();
-                enum_name.push(
-                    e.derived_from
-                        .clone()
-                        .unwrap_or_else(|| make_enum_name(e, &f.enumerated_values, &f.name)),
-                );
+                enum_name.push(f.name.clone());
+
                 info!("finding enum {:?}", enum_name);
-                let enumm = enums.iter().find(|e| e.name == enum_name).unwrap();
                 let enum_name = enum_names.get(&enum_name).unwrap().clone();
                 info!("found {:?}", enum_name);
-
-                let usage = enumm.usage.unwrap_or(svd::Usage::ReadWrite);
-
-                match usage {
-                    svd::Usage::Read => field.enum_read = Some(enum_name.clone()),
-                    svd::Usage::Write => field.enum_write = Some(enum_name.clone()),
-                    svd::Usage::ReadWrite => field.enum_readwrite = Some(enum_name.clone()),
-                }
+                field.enumm = Some(enum_name.clone())
             }
 
             fieldset.fields.push(field)
@@ -367,28 +424,6 @@ fn collect_blocks(
     }
 }
 
-fn make_enum_name(
-    e: &svd::EnumeratedValues,
-    evs: &[svd::EnumeratedValues],
-    field_name: &str,
-) -> String {
-    if let Some(name) = &e.name {
-        return name.clone();
-    }
-
-    let mut res = field_name.to_string();
-    if evs.len() > 1 {
-        let suffix = match e.usage {
-            None => "",
-            Some(svd::Usage::Read) => "_R",
-            Some(svd::Usage::Write) => "_W",
-            Some(svd::Usage::ReadWrite) => "_RW",
-        };
-        res.push_str(suffix);
-    }
-    res
-}
-
 fn unique_names(names: Vec<Vec<String>>) -> HashMap<Vec<String>, String> {
     let mut res = HashMap::new();
     let mut seen = HashSet::new();

src/transform/common.rs

@@ -103,9 +103,7 @@ pub(crate) fn mergeable_fields(a: &Field, b: &Field, level: CheckLevel) -> bool
     if level >= CheckLevel::Layout {
         res &= a.bit_size == b.bit_size
             && a.bit_offset == b.bit_offset
-            && a.enum_read == b.enum_read
-            && a.enum_write == b.enum_write
-            && a.enum_readwrite == b.enum_readwrite
+            && a.enumm == b.enumm
             && a.array == b.array;
     }
     if level >= CheckLevel::Names {
@@ -192,10 +190,7 @@ pub(crate) fn match_expand(s: &str, regex: &regex::Regex, res: &str) -> Option<S
 pub(crate) fn replace_enum_ids(ir: &mut IR, from: &HashSet<String>, to: String) {
     for (_, fs) in ir.fieldsets.iter_mut() {
         for f in fs.fields.iter_mut() {
-            for id in [&mut f.enum_read, &mut f.enum_write, &mut f.enum_readwrite]
-                .into_iter()
-                .flatten()
-            {
+            if let Some(id) = &mut f.enumm {
                 if from.contains(id) {
                     *id = to.clone()
                 }

src/transform/delete_enums.rs

@@ -41,11 +41,9 @@ impl DeleteEnums {
 pub(crate) fn remove_enum_ids(ir: &mut IR, from: &HashSet<String>) {
     for (_, fs) in ir.fieldsets.iter_mut() {
         for f in fs.fields.iter_mut() {
-            for e in [&mut f.enum_read, &mut f.enum_write, &mut f.enum_readwrite].into_iter() {
-                if let Some(id) = e {
-                    if from.contains(id) {
-                        *e = None
-                    }
+            if let Some(id) = &mut f.enumm {
+                if from.contains(id) {
+                    f.enumm = None
                 }
             }
         }

src/transform/delete_enums_used_in.rs

@@ -22,15 +22,7 @@ impl DeleteEnumsUsedIn {
             if re.is_match(id) {
                 info!("matched fieldset {}", id);
                 for f in &fs.fields {
-                    if let Some(id) = &f.enum_read {
-                        info!("deleting enum {}", id);
-                        ids.insert(id.clone());
-                    }
-                    if let Some(id) = &f.enum_write {
-                        info!("deleting enum {}", id);
-                        ids.insert(id.clone());
-                    }
-                    if let Some(id) = &f.enum_readwrite {
+                    if let Some(id) = &f.enumm {
                         info!("deleting enum {}", id);
                         ids.insert(id.clone());
                     }

src/transform/delete_fieldsets.rs

@@ -41,13 +41,7 @@ impl DeleteFieldsets {
 fn is_useless(fs: &FieldSet) -> bool {
     match &fs.fields[..] {
         [] => true,
-        [f] => {
-            fs.bit_size == f.bit_size
-                && f.bit_offset == 0
-                && f.enum_read.is_none()
-                && f.enum_write.is_none()
-                && f.enum_readwrite.is_none()
-        }
+        [f] => fs.bit_size == f.bit_size && f.bit_offset == 0 && f.enumm.is_none(),
         _ => false,
     }
 }

src/transform/mod.rs

@@ -79,9 +79,7 @@ pub fn map_enum_names(ir: &mut IR, f: impl Fn(&mut String)) {
 
     for (_, fs) in ir.fieldsets.iter_mut() {
         for ff in fs.fields.iter_mut() {
-            rename_opt(&mut ff.enum_read, &f);
-            rename_opt(&mut ff.enum_write, &f);
-            rename_opt(&mut ff.enum_readwrite, &f);
+            rename_opt(&mut ff.enumm, &f);
         }
     }
 }