use std::collections::VecDeque;
use std::sync::OnceLock;
use saturnus_core::io::Key;
use saturnus_core::{Machine, Model};
use saturnus_objects::charset;
use saturnus_objects::cmdline::{self, CommandLine, Editor, EditorLayout};
use crate::Emulator;
pub const HOLD_MS: u64 = 30;
pub const GAP_MS: u64 = 20;
pub const REPEAT_GAP_MS: u64 = 100;
pub const KEY_CAP_MS: u64 = 30_000;
pub const RUN_CAP_MS: u64 = 120_000;
pub const SETTLE_MS: u64 = 40;
pub const MAX_CHARS: usize = 4096;
pub const MAX_SEND_MS: f64 = 600_000.0;
pub const BUSY_THRESHOLD: usize = 12;
const ENSURE_TRIES: u8 = 4;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Verb {
Insert,
Run,
Replace,
}
impl Verb {
pub fn from_name(name: &str) -> Option<Verb> {
match name {
"insert" => Some(Verb::Insert),
"run" => Some(Verb::Run),
"replace" => Some(Verb::Replace),
_ => None,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Method {
None,
Alpha(Vec<Key>),
Pair { keys: Vec<Key>, open: u8, close: u8 },
Entry(Vec<Key>),
Accent { base: u8, keys: Vec<Key> },
Chars,
}
const TABLES: [(Model, &str); 3] = [
(Model::Hp48sx, include_str!("typing/48sx.tsv")),
(Model::Hp48gx, include_str!("typing/48gx.tsv")),
(Model::Hp49g, include_str!("typing/49g.tsv")),
];
pub fn table(model: Model) -> Option<&'static [Method; 256]> {
static PARSED: OnceLock<Vec<(Model, [Method; 256])>> = OnceLock::new();
let all = PARSED.get_or_init(|| {
TABLES
.iter()
.map(|&(m, text)| (m, parse_table(text)))
.collect()
});
all.iter().find(|(m, _)| *m == model).map(|(_, t)| t)
}
fn keys_of(field: &str) -> Option<Vec<Key>> {
field.split_whitespace().map(Key::from_name).collect()
}
pub fn parse_table(text: &str) -> [Method; 256] {
let mut out: [Method; 256] = std::array::from_fn(|_| Method::None);
for line in text.lines() {
if line.starts_with('#') || line.trim().is_empty() {
continue;
}
let f: Vec<&str> = line.split('\t').collect();
let Some(code) = f.first().and_then(|c| c.parse::<u8>().ok()) else {
continue;
};
let keys = f.get(2).and_then(|k| keys_of(k));
let method = match (f.get(1).copied(), keys) {
(Some("alpha"), Some(k)) => Method::Alpha(k),
(Some("entry"), Some(k)) => Method::Entry(k),
(Some(m), Some(keys)) if m.starts_with("pair:") => {
let mut oc = m[5..].split(',').filter_map(|x| x.parse::<u8>().ok());
match (oc.next(), oc.next()) {
(Some(open), Some(close)) => Method::Pair { keys, open, close },
_ => Method::None,
}
}
(Some(m), Some(keys)) if m.starts_with("accent:") => match m[7..].parse::<u8>() {
Ok(base) => Method::Accent { base, keys },
Err(_) => Method::None,
},
(Some("chars"), _) => Method::Chars,
_ => Method::None,
};
out[usize::from(code)] = method;
}
out
}
fn key_ms(model: Model, in_chars: bool) -> f64 {
match (model, in_chars) {
(Model::Hp48gx, true) => 420.0,
(Model::Hp48gx, false) => 180.0,
(Model::Hp49g, true) => 170.0,
(Model::Hp49g, false) => 100.0,
_ => 270.0,
}
}
pub fn estimate_ms(model: Model, bytes: &[u8]) -> f64 {
let Some(t) = table(model) else {
return 0.0;
};
let keys = |c: u8| -> (f64, bool) {
match &t[usize::from(c)] {
Method::None => (0.0, false),
Method::Alpha(k) => (k.len() as f64, false),
Method::Pair { keys, .. } | Method::Entry(keys) => (keys.len() as f64 + 4.0, false),
Method::Accent { base, keys } => {
let b = match &t[usize::from(*base)] {
Method::Alpha(k) => k.len(),
_ => 2,
};
((b + keys.len()) as f64, false)
}
Method::Chars if model == Model::Hp48gx => {
let page = (i32::from(c / 64) - 2).unsigned_abs();
let moves = page + u32::from(c % 64 / 16) + u32::from(c % 16);
(f64::from(moves) + 4.0, true)
}
Method::Chars => (20.0, true),
}
};
bytes
.iter()
.map(|&c| {
let (n, chars) = keys(c);
n * key_ms(model, chars)
})
.sum()
}
fn del_keys(model: Model) -> Vec<Key> {
if model == Model::Hp49g {
vec![Key::LeftShift, Key::Backspace]
} else {
vec![Key::Del]
}
}
pub fn encode_for(model: Model, text: &str) -> crate::Result<Vec<u8>> {
let table = table(model).ok_or_else(|| no_command_line(model))?;
let bytes = charset::encode(text)
.map_err(|c| format!("{c:?} is not in the calculator's character set"))?;
if bytes.len() > MAX_CHARS {
return Err(format!("text is longer than {MAX_CHARS} characters").into());
}
if let Some((i, &b)) = bytes
.iter()
.enumerate()
.find(|&(_, &b)| table[usize::from(b)] == Method::None)
{
return Err(format!(
"the {} cannot type {:?} (character {b}, position {i}): no key or CHARS entry types it",
model.name().to_uppercase(),
charset::char_of(b)
)
.into());
}
let ms = estimate_ms(model, &bytes);
if ms > MAX_SEND_MS {
return Err(format!(
"the {} would need about {:.0} s of emulated time to type this ({} at most): send less at once",
model.name().to_uppercase(),
ms / 1000.0,
MAX_SEND_MS / 1000.0
).into());
}
Ok(bytes)
}
fn no_command_line(model: Model) -> String {
format!(
"the {} has no RPL command line to type into (48SX, 48GX and 49G only)",
model.name().to_uppercase()
)
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Need {
NoShift,
AlphaLocked,
AlphaOff,
Lowercase(bool),
Program,
AlphaAs {
alpha: bool,
lock: bool,
},
}
#[derive(Clone, Debug)]
enum Op {
Ensure(Need),
Press(Vec<Key>),
Inserted {
c: u8,
advance: bool,
},
Accented {
c: u8,
},
Skipped,
InChars {
c: u8,
},
Check,
Advance,
Next,
DropTail,
Enter,
AfterEnter,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Outcome {
pub typed: usize,
pub presses: u64,
pub emulated_ms: f64,
pub closed: Option<bool>,
pub running: bool,
pub error: Option<String>,
}
#[derive(Clone, Copy, Debug)]
enum Press {
Before { key: Key, until: u64 },
Hold { key: Key, until: u64 },
Wait { key: Key, cap: u64 },
Settle {
key: Key,
quiet_since: Option<u64>,
cap: u64,
},
}
#[derive(Clone, Debug)]
pub struct Job {
model: Model,
layout: EditorLayout,
verb: Verb,
text: Vec<u8>,
pos: usize,
ops: VecDeque<Op>,
keys: VecDeque<Key>,
press: Option<Press>,
settle_next: bool,
last_key: Option<Key>,
last_release: u64,
line: Vec<u8>,
cursor: usize,
tail: VecDeque<u8>,
initial: Editor,
ensure_tries: u8,
dismissed: u8,
started: u64,
presses: u64,
outcome: Outcome,
before_enter: Vec<u8>,
done: bool,
}
fn ram_range(model: Model) -> (u32, u32) {
match model {
Model::Hp48sx => (0x70000, 0x80000),
Model::Hp48gx => (0x80000, 0xC0000),
_ => (0x80000, 0x100000),
}
}
fn cycles_per_ms(model: Model) -> u64 {
u64::from(model.clock_hz()) / 1000
}
fn run(m: &mut Machine, cycles: u64) -> crate::Result<()> {
Ok(m.run_cycles(cycles.max(1))?)
}
impl Job {
pub fn new(machine: &Machine, verb: Verb, text: &str) -> crate::Result<Job> {
let model = machine.model();
let layout = EditorLayout::of(model).ok_or_else(|| no_command_line(model))?;
let text = encode_for(model, text)?;
let e = cmdline::read(machine, &layout).map_err(|e| {
format!(
"the calculator's command line cannot be read now ({e}); it may still be starting: try again in a moment"
)
})?;
if verb == Verb::Replace && !e.active {
return Err("no command line is open to replace".to_string().into());
}
if e.active && !e.insert {
return Err("the command line is in replace mode (INS in the EDIT menu); switch it to insert mode first".to_string().into());
}
let mut ops = VecDeque::new();
ops.push_back(Op::Ensure(Need::NoShift));
if e.lowercase {
ops.push_back(Op::Ensure(Need::Lowercase(false)));
}
let (line, cursor) = if verb == Verb::Replace {
let mut keys = Vec::new();
for _ in e.cursor..e.text.len() {
keys.extend(del_keys(model));
}
keys.extend(std::iter::repeat_n(Key::Backspace, e.cursor));
ops.push_back(Op::Press(keys));
ops.push_back(Op::Check);
(Vec::new(), 0)
} else {
(e.text.clone(), e.cursor)
};
ops.push_back(Op::Advance);
Ok(Job {
model,
layout,
verb,
text,
pos: 0,
ops,
keys: VecDeque::new(),
press: None,
settle_next: false,
last_key: None,
last_release: 0,
line,
cursor,
tail: VecDeque::new(),
initial: e,
ensure_tries: 0,
dismissed: 0,
started: machine.cycles(),
presses: 0,
outcome: Outcome::default(),
before_enter: Vec::new(),
done: false,
})
}
pub fn len(&self) -> usize {
self.text.len()
}
pub fn is_empty(&self) -> bool {
self.text.is_empty()
}
pub fn freezes(&self) -> bool {
self.text.len() > BUSY_THRESHOLD
}
pub fn outcome(&self) -> &Outcome {
&self.outcome
}
pub fn step(&mut self, m: &mut Machine, budget: u64) -> crate::Result<bool> {
let result = self.step_inner(m, budget);
if result.is_err() {
self.stop(m);
}
result
}
pub fn end_wait(&mut self, m: &Machine) -> bool {
match &mut self.press {
Some(Press::Settle { cap, .. }) => {
*cap = m.cycles();
true
}
_ => false,
}
}
pub fn stop(&mut self, m: &mut Machine) {
if let Some(Press::Hold { key, .. }) = self.press.take() {
let _ = m.key_up(key);
}
self.keys.clear();
self.ops.clear();
self.done = true;
}
fn step_inner(&mut self, m: &mut Machine, budget: u64) -> crate::Result<bool> {
let per_ms = cycles_per_ms(self.model);
let stop = m.cycles().saturating_add(budget);
while !self.done {
let now = m.cycles();
if now >= stop {
return Ok(false);
}
match self.press {
Some(Press::Before { key, until }) => {
if now < until {
run(m, until.min(stop) - now)?;
} else {
m.key_down(key).map_err(|e| e.to_string())?;
self.presses += 1;
self.press = Some(Press::Hold {
key,
until: now + HOLD_MS * per_ms,
});
}
}
Some(Press::Hold { key, until }) => {
if now < until {
run(m, until.min(stop) - now)?;
} else {
m.key_up(key).map_err(|e| e.to_string())?;
self.press = Some(if std::mem::take(&mut self.settle_next) {
Press::Settle {
key,
quiet_since: None,
cap: now + RUN_CAP_MS * per_ms,
}
} else {
Press::Wait {
key,
cap: now + KEY_CAP_MS * per_ms,
}
});
}
}
Some(Press::Wait { key, cap }) => {
if m.is_shutdown() {
self.released(key, now);
} else if now >= cap {
return Err(format!(
"the calculator stayed busy for {KEY_CAP_MS} ms after the {} key; typing stopped at character {}",
key.name(),
self.pos
).into());
} else {
run(m, (per_ms / 4).max(1))?;
}
}
Some(Press::Settle {
key,
quiet_since,
cap,
}) => {
if now >= cap {
self.outcome.running = true;
self.released(key, now);
} else if !m.is_shutdown() {
self.press = Some(Press::Settle {
key,
quiet_since: None,
cap,
});
run(m, per_ms)?;
} else {
match quiet_since {
Some(t) if now - t >= SETTLE_MS * per_ms => self.released(key, now),
Some(_) => run(m, per_ms)?,
None => {
self.press = Some(Press::Settle {
key,
quiet_since: Some(now),
cap,
});
}
}
}
}
None => {
if let Some(key) = self.keys.pop_front() {
let gap = if Some(key) == self.last_key {
REPEAT_GAP_MS
} else {
GAP_MS
};
self.press = Some(Press::Before {
key,
until: self.last_release + gap * per_ms,
});
} else {
self.plan(m)?;
}
}
}
}
self.outcome.presses = self.presses;
self.outcome.typed = self.pos.min(self.text.len());
self.outcome.emulated_ms =
(m.cycles() - self.started) as f64 * 1000.0 / f64::from(self.model.clock_hz());
Ok(true)
}
fn released(&mut self, key: Key, now: u64) {
self.last_key = Some(key);
self.last_release = now;
self.press = None;
}
fn editor(&self, m: &Machine) -> crate::Result<Editor> {
cmdline::read(m, &self.layout).map_err(Into::into)
}
fn plan(&mut self, m: &mut Machine) -> crate::Result<()> {
loop {
let Some(op) = self.ops.pop_front() else {
self.done = true;
return Ok(());
};
match op {
Op::Press(keys) => {
if !keys.is_empty() {
self.keys.extend(keys);
return Ok(());
}
}
Op::Ensure(need) => {
let e = self.editor(m)?;
match keys_for(need, &e) {
None => self.ensure_tries = 0,
Some(keys) => {
self.ensure_tries += 1;
if self.ensure_tries > ENSURE_TRIES {
let why = if e.active {
""
} else {
"; the calculator does not take typing now (still starting, or another screen has the keyboard): try again in a moment"
};
return Err(format!(
"could not bring the keyboard to {need:?} (alpha {}, alpha lock {}, shifts {}/{}, lowercase {}, program entry {}){why}",
e.alpha,
e.alpha_lock,
e.left_shift,
e.right_shift,
e.lowercase,
e.program
).into());
}
self.ops.push_front(Op::Ensure(need));
self.keys.extend(keys);
return Ok(());
}
}
}
Op::Check => {
let e = self.editor(m)?;
self.expect(&e, "the line")?;
}
Op::Advance => self.advance(),
Op::Next => {
self.pos += 1;
self.ops.push_front(Op::Advance);
}
Op::Inserted { c, advance } => self.inserted(m, c, advance)?,
Op::Accented { c } => {
let e = self.editor(m)?;
let at = self.cursor.checked_sub(1);
let ok = e.active
&& e.text.len() == self.line.len()
&& e.cursor == self.cursor
&& at.is_some_and(|i| e.text[i] == c);
match at {
Some(i) if ok => self.line[i] = c,
_ => return Err(self.mismatch(&e, "an accent").into()),
}
self.expect(&e, "an accent")?;
self.ops.push_front(Op::Next);
}
Op::Skipped => {
self.cursor += 1;
self.tail.pop_front();
let e = self.editor(m)?;
self.expect(&e, "stepping over a closer")?;
self.ops.push_front(Op::Next);
}
Op::InChars { c } => {
let e = self.editor(m)?;
if e.active {
return Err(format!(
"the CHARS application did not open for {:?}",
charset::char_of(c)
)
.into());
}
let keys = self.chars_keys(m, c);
self.ops.push_front(Op::Inserted { c, advance: true });
self.keys.extend(keys);
return Ok(());
}
Op::DropTail => {
if !self.tail.is_empty() {
let mut keys = Vec::new();
for _ in 0..self.tail.len() {
keys.extend(del_keys(self.model));
self.line.remove(self.cursor);
}
self.tail.clear();
self.ops.push_front(Op::Check);
self.ops.push_front(Op::Press(keys));
self.ops.push_front(Op::Ensure(Need::NoShift));
}
}
Op::Enter => {
let (lo, hi) = ram_range(self.model);
self.before_enter = (lo..hi).map(|a| m.peek(a) & 0xF).collect();
self.settle_next = true;
self.ops.push_front(Op::AfterEnter);
self.keys.push_back(Key::Enter);
return Ok(());
}
Op::AfterEnter => {
let e = self.editor(m)?;
if e.message && self.outcome.error.is_none() {
self.outcome.error =
find_message(m, self.model, &self.before_enter, &self.text);
}
if e.message && self.layout.message_box && self.dismissed < 2 {
self.dismissed += 1;
self.settle_next = true;
self.ops.push_front(Op::AfterEnter);
self.keys.push_back(Key::On);
return Ok(());
}
self.before_enter = Vec::new();
self.outcome.closed = Some(!e.active);
}
}
}
}
fn advance(&mut self) {
let Some(&c) = self.text.get(self.pos) else {
self.ops.push_back(Op::DropTail);
if self.verb == Verb::Run {
self.ops.push_back(Op::Ensure(Need::NoShift));
self.ops.push_back(Op::Enter);
} else {
self.restore();
}
return;
};
let mut ops = Vec::new();
if self.tail.front() == Some(&c) {
ops.push(Op::Ensure(Need::NoShift));
if self.model != Model::Hp49g {
ops.push(Op::Ensure(Need::AlphaOff));
}
ops.push(Op::Press(vec![Key::Right]));
ops.push(Op::Skipped);
} else {
let table = table(self.model).map(|t| t[usize::from(c)].clone());
match table.unwrap_or(Method::None) {
Method::Alpha(keys) | Method::Pair { keys, .. } => {
ops.extend(alpha_ready());
ops.push(Op::Press(keys));
ops.push(Op::Inserted { c, advance: true });
}
Method::Entry(keys) => {
ops.push(Op::Ensure(Need::NoShift));
ops.push(Op::Ensure(Need::AlphaOff));
ops.push(Op::Ensure(Need::Program));
ops.push(Op::Press(keys));
ops.push(Op::Inserted { c, advance: true });
}
Method::Accent { base, keys } => {
let base_keys = match table_method(self.model, base) {
Method::Alpha(k) => k,
_ => Vec::new(),
};
ops.extend(alpha_ready());
ops.push(Op::Press(base_keys));
ops.push(Op::Inserted {
c: base,
advance: false,
});
ops.push(Op::Press(keys));
ops.push(Op::Accented { c });
}
Method::Chars => {
ops.push(Op::Ensure(Need::NoShift));
ops.push(Op::Ensure(Need::AlphaOff));
ops.push(Op::Press(chars_open(self.model)));
ops.push(Op::InChars { c });
}
Method::None => ops.push(Op::Next),
}
}
for op in ops.into_iter().rev() {
self.ops.push_front(op);
}
}
fn restore(&mut self) {
let i = self.initial.clone();
if i.lowercase {
self.ops.push_back(Op::Ensure(Need::Lowercase(true)));
}
self.ops.push_back(Op::Ensure(Need::AlphaAs {
alpha: i.alpha,
lock: i.alpha_lock,
}));
if i.left_shift {
self.ops.push_back(Op::Press(vec![Key::LeftShift]));
} else if i.right_shift {
self.ops.push_back(Op::Press(vec![Key::RightShift]));
}
}
fn inserted(&mut self, m: &Machine, c: u8, advance: bool) -> crate::Result<()> {
let e = self.editor(m)?;
let what = format!("{:?}", charset::char_of(c));
let cur = self.cursor;
let after = self.line.len() - cur;
let fits = e.active
&& e.text.len() >= self.line.len()
&& e.text[..cur] == self.line[..cur]
&& e.text[e.text.len() - after..] == self.line[cur..]
&& e.cursor >= cur
&& e.cursor <= e.text.len() - after;
if !fits {
return Err(self.mismatch(&e, &what).into());
}
let before: Vec<u8> = e.text[cur..e.cursor].to_vec();
let behind: Vec<u8> = e.text[e.cursor..e.text.len() - after].to_vec();
let mut ops = Vec::new();
let lead = before.iter().take_while(|&&b| b == b' ' && b != c).count();
if before.get(lead) == Some(&c) {
ops.push(Op::Press(vec![Key::Backspace; before.len() - lead - 1]));
if lead > 0 {
ops.push(Op::Ensure(Need::NoShift));
if self.model != Model::Hp49g {
ops.push(Op::Ensure(Need::AlphaOff));
}
let mut keys = vec![Key::Left];
keys.extend(vec![Key::Backspace; lead]);
keys.push(Key::Right);
ops.push(Op::Press(keys));
}
let mut line = self.line[..cur].to_vec();
line.push(c);
line.extend(&behind);
line.extend(&self.line[cur..]);
self.line = line;
self.cursor = cur + 1;
for &b in behind.iter().rev() {
self.tail.push_front(b);
}
} else if behind.first() == Some(&c) {
ops.push(Op::Press(vec![Key::Backspace; before.len()]));
ops.push(Op::Ensure(Need::NoShift));
if self.model != Model::Hp49g {
ops.push(Op::Ensure(Need::AlphaOff));
}
ops.push(Op::Press(vec![Key::Right]));
let mut line = self.line[..cur].to_vec();
line.extend(&behind);
line.extend(&self.line[cur..]);
self.line = line;
self.cursor = cur + 1;
for &b in behind[1..].iter().rev() {
self.tail.push_front(b);
}
} else {
return Err(self.mismatch(&e, &what).into());
}
ops.push(Op::Check);
if advance {
ops.push(Op::Next);
}
for op in ops.into_iter().rev() {
self.ops.push_front(op);
}
Ok(())
}
fn chars_keys(&self, m: &Machine, c: u8) -> Vec<Key> {
let mut keys = Vec::new();
let (row, col) = match self.layout.chars_position {
Some(at) => {
let p = (m.peek(at) & 0xF) | ((m.peek(at + 1) & 0xF) << 4);
(
i32::from(c / 16) - i32::from(p / 16),
i32::from(c % 16) - i32::from(p % 16),
)
}
None => {
let page = i32::from(c / 64) - 2;
let k = if page < 0 { Key::D } else { Key::E };
keys.extend(std::iter::repeat_n(k, page.unsigned_abs() as usize));
(i32::from(c % 64 / 16), i32::from(c % 16))
}
};
let v = if row < 0 { Key::Up } else { Key::Down };
keys.extend(std::iter::repeat_n(v, row.unsigned_abs() as usize));
let h = if col < 0 { Key::Left } else { Key::Right };
keys.extend(std::iter::repeat_n(h, col.unsigned_abs() as usize));
keys.push(Key::F);
keys.push(Key::On);
keys
}
fn expect(&self, e: &Editor, what: &str) -> crate::Result<()> {
if e.active && e.text == self.line && e.cursor == self.cursor {
Ok(())
} else {
Err(self.mismatch(e, what).into())
}
}
fn mismatch(&self, e: &Editor, what: &str) -> String {
let shown = if e.active {
format!(
"{:?} with the cursor at {}",
charset::decode(&e.text),
e.cursor
)
} else {
"no open command line".to_string()
};
format!(
"typing stopped at character {} ({what}): the calculator has {shown}, expected {:?} with the cursor at {}",
self.pos,
charset::decode(&self.line),
self.cursor
)
}
}
fn alpha_ready() -> [Op; 3] {
[
Op::Ensure(Need::NoShift),
Op::Ensure(Need::Lowercase(false)),
Op::Ensure(Need::AlphaLocked),
]
}
fn table_method(model: Model, c: u8) -> Method {
table(model).map_or(Method::None, |t| t[usize::from(c)].clone())
}
fn chars_open(model: Model) -> Vec<Key> {
match model {
Model::Hp49g => vec![Key::RightShift, Key::Cat],
_ => vec![Key::RightShift, Key::Prg],
}
}
fn keys_for(need: Need, e: &Editor) -> Option<Vec<Key>> {
match need {
Need::NoShift if e.left_shift => Some(vec![Key::LeftShift]),
Need::NoShift if e.right_shift => Some(vec![Key::RightShift]),
Need::NoShift => None,
Need::AlphaLocked | Need::AlphaAs { lock: true, .. } => {
(!e.alpha_lock).then(|| vec![Key::Alpha])
}
Need::AlphaOff | Need::AlphaAs { alpha: false, .. } => e.alpha.then(|| vec![Key::Alpha]),
Need::AlphaAs { .. } => (!e.alpha || e.alpha_lock).then(|| vec![Key::Alpha]),
Need::Lowercase(want) if e.lowercase == want => None,
Need::Lowercase(_) if !e.alpha_lock => Some(vec![Key::Alpha]),
Need::Lowercase(_) => Some(vec![Key::LeftShift, Key::Alpha]),
Need::Program => (!e.program).then(|| vec![Key::RightShift, Key::Alpha]),
}
}
fn find_message(m: &Machine, model: Model, before: &[u8], sent: &[u8]) -> Option<String> {
const STRING: u32 = 0x02A2C;
let (lo, hi) = ram_range(model);
let field = |a: u32, n: u32| -> u32 {
(0..n)
.rev()
.fold(0, |v, i| (v << 4) | u32::from(m.peek(a + i) & 0xF))
};
let changed = |a: u32| before.get((a - lo) as usize).copied() != Some(m.peek(a) & 0xF);
let mut found: Vec<String> = Vec::new();
let mut a = lo;
while a + 10 < hi {
if field(a, 5) != STRING {
a += 1;
continue;
}
let len = field(a + 5, 5);
if !(11..=400).contains(&len) || (len - 5) % 2 != 0 || a + 5 + len > hi {
a += 1;
continue;
}
let bytes: Vec<u8> = (0..(len - 5) / 2)
.map(|i| field(a + 10 + 2 * i, 2) as u8)
.collect();
let printable = bytes.iter().all(|&b| b == b'\n' || (32..127).contains(&b));
let letters = bytes.iter().filter(|b| b.is_ascii_alphabetic()).count();
let typed = sent.windows(bytes.len()).any(|w| w == bytes.as_slice());
let label = bytes.len() <= 5 && !bytes.contains(&b' ') && bytes.last() != Some(&b':');
if printable && letters >= 3 && !typed && !label && (a..a + 5 + len).any(changed) {
let text = charset::decode(&bytes);
let text = text.split_whitespace().collect::<Vec<_>>().join(" ");
if !found.contains(&text) {
found.push(text);
}
}
a += 1;
}
let whole: Vec<String> = found
.iter()
.filter(|t| !found.iter().any(|o| o != *t && o.contains(t.as_str())))
.cloned()
.collect();
let mut found = whole;
found.sort_by_key(|t| !t.ends_with(':'));
(!found.is_empty()).then(|| found.join(" "))
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct EntryModes {
pub lowercase: bool,
pub menu_lock: bool,
}
pub fn entry_modes(machine: &Machine) -> crate::Result<EntryModes> {
if machine.model() != Model::Hp28s {
return Err(format!(
"entryModes is for the 28S, not the {}",
machine.model().name().to_uppercase()
)
.into());
}
Ok(EntryModes {
lowercase: machine.peek(0xC00F0) & 0b0100 != 0,
menu_lock: machine.peek(0xC00F2) & 0b0010 != 0,
})
}
impl Emulator {
pub fn command_line(&self) -> crate::Result<CommandLine> {
Ok(cmdline::command_line(self.machine())?)
}
pub fn ui_state(&self) -> crate::Result<saturnus_objects::screen::Screen> {
Ok(saturnus_objects::screen::screen(self.machine())?)
}
pub fn start_typing(&mut self, verb: &str, text: &str) -> crate::Result<bool> {
self.check_typing(verb, text)?;
let verb = Verb::from_name(verb).ok_or_else(|| format!("unknown verb {verb:?}"))?;
self.release_keys();
let job = Job::new(self.machine(), verb, text)?;
let freezes = job.freezes();
self.typing = Some(job);
self.menu_dirty = true;
Ok(freezes)
}
pub fn check_typing(&self, verb: &str, text: &str) -> crate::Result<bool> {
Verb::from_name(verb).ok_or_else(|| format!("unknown verb {verb:?}"))?;
if self.typing.is_some() || self.transferring() {
return Err("typing is already in progress".into());
}
Ok(encode_for(self.model(), text)?.len() > BUSY_THRESHOLD)
}
pub fn typing(&self) -> bool {
self.typing.is_some()
}
pub fn typing_step(&mut self, ms: f64) -> crate::Result<bool> {
let budget = self.step_cycles(ms);
let Some(job) = self.typing.as_mut() else {
return Err("no typing in progress".into());
};
match job.step(&mut self.machine, budget) {
Ok(done) => Ok(done),
Err(e) => {
self.typing = None;
Err(e)
}
}
}
pub fn typing_end_wait(&mut self) -> bool {
match self.typing.as_mut() {
Some(job) => job.end_wait(&self.machine),
None => false,
}
}
pub fn stop_typing(&mut self) {
if let Some(mut job) = self.typing.take() {
job.stop(&mut self.machine);
}
}
pub fn typing_result(&mut self) -> crate::Result<SendResult> {
let job = self
.typing
.take()
.ok_or_else(|| "no typing in progress".to_string())?;
let o = job.outcome();
Ok(SendResult {
typed: o.typed,
keys: o.presses,
emulated_ms: o.emulated_ms,
command_line: self.command_line()?,
run: o.closed.map(|closed| RunResult {
closed,
error: o.error.clone(),
running: o.running,
}),
})
}
}
#[derive(Clone, Debug, PartialEq, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SendResult {
pub typed: usize,
pub keys: u64,
pub emulated_ms: f64,
pub command_line: CommandLine,
#[serde(flatten)]
pub run: Option<RunResult>,
}
#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize)]
pub struct RunResult {
pub closed: bool,
pub error: Option<String>,
pub running: bool,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_committed_tables_parse_completely() {
for (model, text) in TABLES {
let t = table(model).unwrap();
let lines = text
.lines()
.filter(|l| !l.starts_with('#') && !l.trim().is_empty())
.count();
assert_eq!(lines, 256, "{} lists every character", model.name());
for line in text.lines().filter(|l| !l.starts_with('#')) {
let f: Vec<&str> = line.split('\t').collect();
let code: usize = f[0].parse().unwrap();
let none = f[1] == "none";
assert_eq!(t[code] == Method::None, none, "{}: {line}", model.name());
}
assert_eq!(t[0], Method::None, "NUL never");
for m in t.iter() {
if let Method::Accent { base, .. } = m {
assert!(matches!(t[usize::from(*base)], Method::Alpha(_)));
}
}
}
assert!(table(Model::Hp42s).is_none());
assert!(table(Model::Hp38g).is_none());
}
#[test]
fn pairs_and_methods_read_back() {
let t = parse_table(
"40\tpair:40,41\tleftshift divide\n94\tentry\tpower\n192\taccent:65\tleftshift 7\n200\tchars\n65\talpha\ta\n66\talpha\tnosuchkey\n",
);
assert_eq!(
t[40],
Method::Pair {
keys: vec![Key::LeftShift, Key::Divide],
open: 40,
close: 41
}
);
assert_eq!(t[94], Method::Entry(vec![Key::Power]));
assert_eq!(
t[192],
Method::Accent {
base: 65,
keys: vec![Key::LeftShift, Key::Seven]
}
);
assert_eq!(t[200], Method::Chars);
assert_eq!(t[65], Method::Alpha(vec![Key::A]));
assert_eq!(t[66], Method::None, "an unknown key name types nothing");
}
#[test]
fn text_is_checked_before_anything_is_pressed() {
assert_eq!(encode_for(Model::Hp48sx, "« 1 2 + »").unwrap().len(), 9);
let err = encode_for(Model::Hp48sx, "1;2").unwrap_err().to_string();
assert!(err.contains("48SX cannot type \";\""), "{err}");
assert!(encode_for(Model::Hp48gx, "1;2").is_ok());
assert!(encode_for(Model::Hp49g, "\0").is_err());
assert!(
encode_for(Model::Hp48gx, "€")
.unwrap_err()
.to_string()
.contains("character set")
);
assert!(
encode_for(Model::Hp42s, "1")
.unwrap_err()
.to_string()
.contains("42S has no RPL command line")
);
let long = "1".repeat(MAX_CHARS + 1);
assert!(encode_for(Model::Hp49g, &long).is_err());
}
#[test]
fn a_send_that_cannot_finish_is_refused() {
assert!(encode_for(Model::Hp48sx, &"A".repeat(2222)).is_ok());
let err = encode_for(Model::Hp48sx, &"A".repeat(2223))
.unwrap_err()
.to_string();
assert!(err.contains("48SX would need about 600 s"), "{err}");
assert!(encode_for(Model::Hp49g, &"A".repeat(4096)).is_ok());
let chars: Vec<u8> = (1..=31).filter(|&c| c != 10).collect();
let text = charset::decode(&chars).repeat(40);
assert!(encode_for(Model::Hp48gx, &text).is_err());
assert!(encode_for(Model::Hp48gx, &charset::decode(&chars)).is_ok());
}
#[test]
fn keys_reach_the_needed_state() {
let e = Editor {
alpha: true,
alpha_lock: true,
lowercase: true,
..Editor::default()
};
assert_eq!(keys_for(Need::AlphaLocked, &e), None);
assert_eq!(keys_for(Need::AlphaOff, &e), Some(vec![Key::Alpha]));
assert_eq!(
keys_for(Need::Lowercase(false), &e),
Some(vec![Key::LeftShift, Key::Alpha])
);
let off = Editor::default();
assert_eq!(
keys_for(Need::Lowercase(true), &off),
Some(vec![Key::Alpha])
);
assert_eq!(
keys_for(
Need::AlphaAs {
alpha: true,
lock: false
},
&off
),
Some(vec![Key::Alpha])
);
assert_eq!(
keys_for(
Need::AlphaAs {
alpha: true,
lock: false
},
&e
),
Some(vec![Key::Alpha]),
"locked: unlock first"
);
let shifted = Editor {
right_shift: true,
..Editor::default()
};
assert_eq!(
keys_for(Need::NoShift, &shifted),
Some(vec![Key::RightShift])
);
assert_eq!(
keys_for(Need::Program, &off),
Some(vec![Key::RightShift, Key::Alpha])
);
assert_eq!(Verb::from_name("run"), Some(Verb::Run));
assert_eq!(Verb::from_name("eval"), None);
}
}