porting more

src/main.rs

@@ -1292,4 +1292,147 @@ impl InsnBitFields {
     }
 }
 
+#[derive(Clone, Debug)]
+struct InsnSpRegsAlteredEntry {
+    reg: ParsedTextLine,
+    fields: Vec<ParsedTextLine>,
+    conds: Vec<ParsedTextLine>,
+}
+
+impl InsnSpRegsAlteredEntry {
+    fn display_fmt_with_indent(&self, f: &mut fmt::Formatter<'_>, indent: &str) -> fmt::Result {
+        let Self { reg, fields, conds } = self;
+        writeln!(f, "Entry(")?;
+        writeln!(f, "{indent}    reg={reg},")?;
+        write!(f, "{indent}    fields=")?;
+        if fields.is_empty() {
+            write!(f, "()")?;
+        } else {
+            writeln!(f, "(")?;
+            for field in fields {
+                writeln!(f, "{indent}        {field},")?;
+            }
+            write!(f, "{indent}    )")?;
+        }
+        writeln!(f, ",")?;
+        writeln!(f, "{indent}    conds=")?;
+        if conds.is_empty() {
+            write!(f, "()")?;
+        } else {
+            writeln!(f, "(")?;
+            for cond in conds {
+                writeln!(f, "{indent}        {cond},")?;
+            }
+            write!(f, "{indent}    )")?;
+        }
+        writeln!(f, ",")?;
+        write!(f, "{indent})")
+    }
+    fn write_xml(&self, parent: &mut xml_tree::Element) {
+        let entry = parent.sub_element("entry".into(), []);
+        entry.text = "\n".into();
+        entry.tail = "\n".into();
+        let reg = entry.sub_element("register".into(), []);
+        reg.tail = "\n".into();
+        self.reg.write_xml(reg, false);
+        let fields = entry.sub_element("fields".into(), []);
+        fields.tail = "\n".into();
+        ParsedTextLine::write_xml_lines(&self.fields, fields, false, false);
+        let conds = entry.sub_element("conditions".into(), []);
+        conds.tail = "\n".into();
+        ParsedTextLine::write_xml_lines(&self.conds, conds, false, false);
+    }
+}
+
+impl fmt::Display for InsnSpRegsAlteredEntry {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.display_fmt_with_indent(f, "")
+    }
+}
+
+#[derive(Clone, Debug)]
+struct InsnSpRegsAltered {
+    sp_regs_altered_text: ParsedTextLine,
+    special_text: Option<ParsedTextLine>,
+    table_header_reg: Option<ParsedTextLine>,
+    table_header_fields: Option<ParsedTextLine>,
+    entries: Vec<InsnSpRegsAlteredEntry>,
+    final_regular_min_y: f32,
+}
+
+impl fmt::Display for InsnSpRegsAltered {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self {
+            sp_regs_altered_text,
+            special_text,
+            table_header_reg,
+            table_header_fields,
+            entries,
+            final_regular_min_y,
+        } = self;
+        writeln!(f, "InsnSpRegsAltered(")?;
+        writeln!(f, "    sp_regs_altered_text={sp_regs_altered_text},")?;
+        if let Some(special_text) = special_text {
+            writeln!(f, "    special_text={special_text},")?;
+        }
+        if let Some(table_header_reg) = table_header_reg {
+            writeln!(f, "    table_header_reg={table_header_reg},")?;
+        }
+        if let Some(table_header_fields) = table_header_fields {
+            writeln!(f, "    table_header_fields={table_header_fields},")?;
+        }
+        if self.entries.is_empty() {
+            writeln!(f, "    entries=(),")?;
+        } else {
+            writeln!(f, "    entries=(")?;
+            for entry in entries {
+                write!(f, "        ")?;
+                entry.display_fmt_with_indent(f, "        ")?;
+                writeln!(f, ",")?;
+            }
+            writeln!(f, "    ),")?;
+        }
+        writeln!(f, "    final_regular_min_y={final_regular_min_y},")?;
+        write!(f, ")")
+    }
+}
+
+impl InsnSpRegsAltered {
+    fn write_xml(&self, parent: &mut xml_tree::Element) {
+        let sp_regs_altered = parent.sub_element("special-registers-altered".into(), []);
+        sp_regs_altered.text = "\n".into();
+        sp_regs_altered.tail = "\n".into();
+        let title = sp_regs_altered.sub_element("title".into(), []);
+        title.tail = "\n".into();
+        self.sp_regs_altered_text.write_xml(title, false);
+        if let Some(special_text) = &self.special_text {
+            let special_text_el = sp_regs_altered.sub_element("special-text".into(), []);
+            special_text_el.tail = "\n".into();
+            special_text.write_xml(special_text_el, false);
+        }
+        if let Some(table_header_reg) = &self.table_header_reg {
+            let table_header_reg_el =
+                sp_regs_altered.sub_element("table-header-register".into(), []);
+            table_header_reg_el.tail = "\n".into();
+            table_header_reg.write_xml(table_header_reg_el, false);
+        }
+        if let Some(table_header_fields) = &self.table_header_fields {
+            let table_header_fields_el =
+                sp_regs_altered.sub_element("table-header-fields".into(), []);
+            table_header_fields_el.tail = "\n".into();
+            table_header_fields.write_xml(table_header_fields_el, false);
+        }
+        for entry in &self.entries {
+            entry.write_xml(sp_regs_altered);
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+enum InsnParseSection {
+    Code,
+    Header,
+    Desc,
+}
+
 fn main() {}