kr580 1.0.0

Desktop KR580VM80 / Intel 8080 emulator.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//! Undo/redo stack: text edits and CPU snapshot pairs share one timeline.
//! Consecutive `Text` entries on the same field collapse – the chain
//! breaks on focus change, Enter, Esc, or any CPU push.

use k580_core::{Cpu8080State, RegisterName};

#[cfg(test)]
mod tests;

/// 256 entries × ~64 KiB CPU state ≈ 16 MiB worst case.
const UNDO_DEPTH_LIMIT: usize = 256;

#[derive(Clone, Debug)]
pub(crate) enum UndoEntry {
    Text {
        field: &'static str,
        before: String,
        after: String,
    },
    /// `register_selection` rewinds the register editor's active
    /// cell on Ctrl+Z – without it, undo of "edit A → Enter → step
    /// to B" puts the byte back into A while the visible name field
    /// still shows B.
    Cpu {
        before: Box<Cpu8080State>,
        after: Box<Cpu8080State>,
        register_selection: Option<(RegisterName, RegisterName)>,
    },
}

#[derive(Default, Debug)]
pub(crate) struct UndoStack {
    pub(crate) undo: Vec<UndoEntry>,
    pub(crate) redo: Vec<UndoEntry>,
    coalesce_field: Option<&'static str>,
}

impl UndoStack {
    pub(crate) fn push_text(&mut self, field: &'static str, before: String, after: String) {
        if before == after {
            return;
        }
        self.redo.clear();

        if self.coalesce_field == Some(field)
            && let Some(UndoEntry::Text {
                field: top_field,
                after: top_after,
                ..
            }) = self.undo.last_mut()
            && *top_field == field
        {
            *top_after = after;
            return;
        }

        self.push_entry(UndoEntry::Text {
            field,
            before,
            after,
        });
        self.coalesce_field = Some(field);
    }

    pub(crate) fn push_cpu(&mut self, before: Cpu8080State, after: Cpu8080State) {
        self.push_cpu_with_register_selection(before, after, None);
    }

    pub(crate) fn push_cpu_with_register_selection(
        &mut self,
        before: Cpu8080State,
        after: Cpu8080State,
        register_selection: Option<(RegisterName, RegisterName)>,
    ) {
        if before == after {
            return;
        }
        self.redo.clear();
        self.push_entry(UndoEntry::Cpu {
            before: Box::new(before),
            after: Box::new(after),
            register_selection,
        });
        self.coalesce_field = None;
    }

    pub(crate) fn break_coalescing(&mut self) {
        self.coalesce_field = None;
    }

    pub(crate) fn pop_undo(&mut self) -> Option<UndoEntry> {
        let entry = self.undo.pop()?;
        self.coalesce_field = None;
        self.redo.push(entry.clone());
        Some(entry)
    }

    pub(crate) fn pop_redo(&mut self) -> Option<UndoEntry> {
        let entry = self.redo.pop()?;
        self.coalesce_field = None;
        self.undo.push(entry.clone());
        Some(entry)
    }

    pub(crate) fn clear(&mut self) {
        self.undo.clear();
        self.redo.clear();
        self.coalesce_field = None;
    }

    fn push_entry(&mut self, entry: UndoEntry) {
        self.undo.push(entry);
        if self.undo.len() > UNDO_DEPTH_LIMIT {
            self.undo.remove(0);
        }
    }
}