add insn bit fields

src/main.rs

@@ -1147,4 +1147,149 @@ impl<'a> ElementBodyBuilder<'a> {
     }
 }
 
+#[derive(Clone, Debug)]
+struct InsnBitField {
+    box_min_x: f32,
+    box_max_x: f32,
+    name: ParsedTextLine,
+    bit_number: ParsedTextLine,
+}
+
+impl fmt::Display for InsnBitField {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self {
+            box_min_x,
+            box_max_x,
+            name,
+            bit_number,
+        } = self;
+        write!(
+            f,
+            "<InsnBitField: x={box_min_x}..{box_max_x} name={name} bit_number={bit_number}>"
+        )
+    }
+}
+
+impl InsnBitField {
+    fn write_xml(&self, parent: &mut xml_tree::Element) {
+        let field = parent.sub_element("field".into(), []);
+        field.text = "\n".into();
+        field.tail = "\n".into();
+        let name = field.sub_element("name".into(), []);
+        name.tail = "\n".into();
+        self.name.write_xml(name, false);
+        let bit_number = field.sub_element("bit-number".into(), []);
+        bit_number.tail = "\n".into();
+        self.bit_number.write_xml(bit_number, false);
+    }
+}
+
+#[derive(Clone, Debug)]
+struct InsnBitFieldsPrefix {
+    box_min_x: f32,
+    box_min_y: f32,
+    box_max_x: f32,
+    box_max_y: f32,
+    prefix_text: ParsedTextLine,
+    fields: Vec<InsnBitField>,
+    suffix_text: ParsedTextLine,
+}
+
+impl fmt::Display for InsnBitFieldsPrefix {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self {
+            box_min_x,
+            box_min_y,
+            box_max_x,
+            box_max_y,
+            prefix_text,
+            fields,
+            suffix_text,
+        } = self;
+        writeln!(
+            f,
+            "<InsnBitFieldsPrefix: ({box_min_x},{box_min_y})..({box_max_x},{box_max_y})"
+        )?;
+        writeln!(f, "    prefix_text={prefix_text}")?;
+        writeln!(f, "    [")?;
+        for field in fields {
+            writeln!(f, "        {field},")?;
+        }
+        writeln!(f, "    ]")?;
+        write!(f, "    suffix_text={suffix_text}>")
+    }
+}
+
+impl InsnBitFieldsPrefix {
+    fn write_xml(&self, parent: &mut xml_tree::Element) {
+        let prefix_elm = parent.sub_element("prefix".into(), []);
+        prefix_elm.text = "\n".into();
+        prefix_elm.tail = "\n".into();
+        let prefix_text = prefix_elm.sub_element("prefix-text".into(), []);
+        prefix_text.tail = "\n".into();
+        self.prefix_text.write_xml(prefix_text, false);
+        InsnBitFields::write_xml_fields(&self.fields, prefix_elm);
+        let suffix_text = prefix_elm.sub_element("suffix-text".into(), []);
+        suffix_text.tail = "\n".into();
+        self.suffix_text.write_xml(suffix_text, false);
+    }
+}
+
+#[derive(Clone, Debug)]
+struct InsnBitFields {
+    prefix: Option<InsnBitFieldsPrefix>,
+    box_min_x: f32,
+    box_min_y: f32,
+    box_max_x: f32,
+    box_max_y: f32,
+    fields: Vec<InsnBitField>,
+}
+
+impl fmt::Display for InsnBitFields {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self {
+            prefix,
+            box_min_x,
+            box_min_y,
+            box_max_x,
+            box_max_y,
+            fields,
+        } = self;
+        if let Some(prefix) = prefix {
+            prefix.fmt(f)?;
+        }
+        writeln!(
+            f,
+            "<InsnBitFields: ({box_min_x},{box_min_y})..({box_max_x},{box_max_y}) ["
+        )?;
+        for field in fields {
+            writeln!(f, "    {field},")?;
+        }
+        write!(f, "]>")
+    }
+}
+
+impl InsnBitFields {
+    fn write_xml_fields(
+        fields: impl IntoIterator<Item: Borrow<InsnBitField>>,
+        parent: &mut xml_tree::Element,
+    ) {
+        let fields_elm = parent.sub_element("fields".into(), []);
+        fields_elm.text = "\n".into();
+        fields_elm.tail = "\n".into();
+        for field in fields {
+            field.borrow().write_xml(fields_elm);
+        }
+    }
+    fn write_xml(&self, parent: &mut xml_tree::Element) {
+        let bit_fields = parent.sub_element("bit-fields".into(), []);
+        bit_fields.text = "\n".into();
+        bit_fields.tail = "\n".into();
+        if let Some(prefix) = &self.prefix {
+            prefix.write_xml(bit_fields);
+        }
+        Self::write_xml_fields(&self.fields, bit_fields)
+    }
+}
+
 fn main() {}