use saturnus_core::{Machine, Model};
use serde_json::Value;
use crate::Emulator;
use crate::transfer::Op;
pub const LINE_OPEN: &str = "Finish what you're typing first.";
pub const OFF: &str = "The calculator is off. Turn it on first.";
pub const BUSY: &str = "The calculator is busy. Try again when it has finished.";
pub const YEARS: std::ops::RangeInclusive<u16> = 1991..=2090;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ClockTime {
pub year: u16,
pub month: u8,
pub day: u8,
pub hour: u8,
pub minute: u8,
pub second: u8,
}
fn days_in(year: u16, month: u8) -> u8 {
match month {
2 if year.is_multiple_of(4) && (!year.is_multiple_of(100) || year.is_multiple_of(400)) => {
29
}
2 => 28,
4 | 6 | 9 | 11 => 30,
_ => 31,
}
}
impl ClockTime {
pub fn new(
year: u16,
month: u8,
day: u8,
hour: u8,
minute: u8,
second: u8,
) -> crate::Result<ClockTime> {
if !YEARS.contains(&year) {
return Err(format!(
"the year must be between {} and {}",
YEARS.start(),
YEARS.end()
)
.into());
}
if !(1..=12).contains(&month) || day == 0 || day > days_in(year, month) {
return Err(format!("{year}-{month:02}-{day:02} is not a date").into());
}
if hour > 23 || minute > 59 || second > 59 {
return Err(format!("{hour:02}:{minute:02}:{second:02} is not a time").into());
}
Ok(ClockTime {
year,
month,
day,
hour,
minute,
second,
})
}
pub fn from_json(msg: &Value) -> crate::Result<ClockTime> {
let field = |k: &str| -> crate::Result<u16> {
msg.get(k)
.and_then(Value::as_u64)
.and_then(|v| u16::try_from(v).ok())
.ok_or_else(|| format!("missing number field {k:?}").into())
};
let small = |k: &str| -> crate::Result<u8> {
u8::try_from(field(k)?).map_err(|_| format!("{k:?} is out of range").into())
};
ClockTime::new(
field("year")?,
small("month")?,
small("day")?,
small("hour")?,
small("minute")?,
small("second")?,
)
}
pub fn shifted(self, secs: i64) -> ClockTime {
let day = days_from_civil(self.year, self.month, self.day);
let total = day * 86_400
+ i64::from(self.hour) * 3600
+ i64::from(self.minute) * 60
+ i64::from(self.second)
+ secs;
let (year, month, day) = civil_from_days(total.div_euclid(86_400));
let rest = total.rem_euclid(86_400);
ClockTime {
year,
month,
day,
hour: (rest / 3600) as u8,
minute: (rest / 60 % 60) as u8,
second: (rest % 60) as u8,
}
}
pub fn time_number(&self) -> String {
format!("{}.{:02}{:02}", self.hour, self.minute, self.second)
}
pub fn date_number(&self, day_first: bool) -> String {
let (a, b) = if day_first {
(self.day, self.month)
} else {
(self.month, self.day)
};
format!("{a}.{b:02}{}", self.year)
}
}
fn days_from_civil(year: u16, month: u8, day: u8) -> i64 {
let y = i64::from(year) - i64::from(month <= 2);
let era = y.div_euclid(400);
let yoe = y - era * 400;
let m = i64::from(month);
let doy = (153 * (if m > 2 { m - 3 } else { m + 9 }) + 2) / 5 + i64::from(day) - 1;
let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
era * 146_097 + doe - 719_468
}
fn civil_from_days(days: i64) -> (u16, u8, u8) {
let z = days + 719_468;
let era = z.div_euclid(146_097);
let doe = z - era * 146_097;
let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
let mp = (5 * doy + 2) / 153;
let day = (doy - (153 * mp + 2) / 5 + 1) as u8;
let month = (if mp < 10 { mp + 3 } else { mp - 9 }) as u8;
let year = yoe + era * 400 + i64::from(month <= 2);
(year.clamp(0, i64::from(u16::MAX)) as u16, month, day)
}
pub fn has_clock(model: Model) -> bool {
matches!(
model,
Model::Hp48sx
| Model::Hp48gx
| Model::Hp49g
| Model::Hp38g
| Model::Hp39g
| Model::Hp40g
| Model::Hp27s
| Model::Hp17bii
| Model::Hp17b
| Model::Hp19bii
)
}
pub fn by_command(model: Model) -> bool {
matches!(model, Model::Hp48sx | Model::Hp48gx | Model::Hp49g)
}
pub fn rpl_lines(
time: &ClockTime,
date: &ClockTime,
day_first: bool,
comma: bool,
algebraic: bool,
) -> Vec<String> {
let mark = |s: String| if comma { s.replace('.', ",") } else { s };
let time = mark(time.time_number());
let date = mark(date.date_number(day_first));
if algebraic {
vec![format!("→TIME({time})"), format!("→DATE({date})")]
} else {
vec![format!("{time} →TIME {date} →DATE")]
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Press {
Key(&'static str),
Letter(char),
}
fn number_keys(text: &str) -> Vec<Press> {
text.chars()
.filter_map(|c| match c {
'.' => Some(Press::Key("point")),
'0'..='9' => DIGITS
.get(usize::from(c as u8 - b'0'))
.map(|&d| Press::Key(d)),
_ => None,
})
.collect()
}
const DIGITS: [&str; 10] = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];
fn pioneer_modes(model: Model) -> Option<u32> {
match model {
Model::Hp27s => Some(0x50025),
Model::Hp17bii => Some(0x5002B),
Model::Hp17b => Some(0x5002A),
Model::Hp19bii => Some(0xC41E1),
_ => None,
}
}
pub const NO_LANGUAGE: &str = "Choose the calculator's language first.";
fn asks_language(m: &Machine) -> bool {
if m.model() == Model::Hp19bii {
return m.peek(0xC402B) & 0xF == 0;
}
let at = match m.model() {
Model::Hp17bii => 0x50092,
Model::Hp17b => 0x50091,
_ => return false,
};
let mark: Vec<u8> = (0..8)
.map(|i| (m.peek(0x2FFE6 + 2 * i) & 0xF) | ((m.peek(0x2FFE7 + 2 * i) & 0xF) << 4))
.collect();
mark == b"OK-17B-L" && m.peek(at) & 0xF == 0
}
#[derive(Clone, Debug, PartialEq)]
struct Plan {
keys: Vec<Press>,
time_at: usize,
date_at: usize,
}
fn key_plan(
m: &Machine,
time: &ClockTime,
date: &ClockTime,
time_first: bool,
) -> crate::Result<Plan> {
let model = m.model();
let mut keys = Vec::new();
let (time_at, date_at);
if let Some(modes) = pioneer_modes(model) {
let mode = u32::from(m.peek(modes) & 0xF);
if mode & 0b1010 != 0 {
return Err("the clock's settings cannot be read on this ROM".into());
}
let day_first = mode & 1 != 0;
let twelve = mode & 4 == 0;
if model == Model::Hp27s {
keys.extend([Press::Key("shift"), Press::Key("divide")]);
} else {
keys.extend([Press::Key("shift"), Press::Key("exit"), Press::Key("d")]);
}
keys.push(Press::Key("d"));
keys.extend(number_keys(&date.date_number(day_first)));
keys.push(Press::Key("a"));
date_at = keys.len();
if twelve {
keys.push(Press::Key("e"));
}
keys.extend(number_keys(&time.time_number()));
keys.push(Press::Key("b"));
time_at = keys.len();
if twelve {
keys.push(Press::Key("e"));
}
if model == Model::Hp27s {
keys.extend([Press::Key("exit"), Press::Key("exit")]);
} else {
keys.extend([Press::Key("shift"), Press::Key("exit")]);
}
} else {
keys.push(Press::Key("home"));
let store = |keys: &mut Vec<Press>, number: String, name: &str| {
keys.extend(number_keys(&number));
keys.push(Press::Key("a"));
keys.extend(name.chars().map(Press::Letter));
keys.push(Press::Key("enter"));
keys.len()
};
let forget = |keys: &mut Vec<Press>| {
keys.extend(["up", "del", "del", "down"].map(Press::Key));
};
if time_first {
time_at = store(&mut keys, time.time_number(), "TIME");
forget(&mut keys);
date_at = store(&mut keys, date.date_number(false), "DATE");
} else {
date_at = store(&mut keys, date.date_number(false), "DATE");
forget(&mut keys);
time_at = store(&mut keys, time.time_number(), "TIME");
}
forget(&mut keys);
}
Ok(Plan {
keys,
time_at,
date_at,
})
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Now {
pub time: ClockTime,
pub ms: f64,
pub wall_ms: f64,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Pace {
pub speed: f64,
pub share: f64,
pub pass_ms: f64,
}
impl Pace {
pub const REAL_TIME: Pace = Pace {
speed: 1.0,
share: 1.0,
pass_ms: 1000.0 / 60.0,
};
pub const UNBOUNDED: Pace = Pace {
speed: f64::INFINITY,
share: 1.0,
pass_ms: 1000.0,
};
fn rate(&self, emulated_ms: f64, wall_ms: f64) -> f64 {
let host = if wall_ms > 0.0 {
emulated_ms / wall_ms * self.share
} else {
f64::INFINITY
};
self.speed.min(host).max(f64::MIN_POSITIVE)
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Timing {
pub time_ms: f64,
pub date_ms: f64,
pub end_ms: f64,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Lead {
pub timing: Timing,
pub rate: f64,
pub planning_ms: f64,
pub time: ClockTime,
pub date: ClockTime,
}
fn keyed(now: &Now, timing: &Timing, rate: f64, planning_ms: f64) -> (ClockTime, ClockTime) {
let c = timing.time_ms;
let after = (timing.end_ms - c).max(0.0);
let lead = planning_ms + c / rate - after * (1.0 - 1.0 / rate);
let at = |ms: f64| now.time.shifted(((now.ms + ms) / 1000.0).round() as i64);
let between = (timing.date_ms - c).max(0.0);
(at(lead), at(lead + between))
}
pub const NOT_SETTLED: &str =
"The clock could not be set: the calculator did not finish the keys. Try again.";
const REHEARSAL_CAP_MS: f64 = 120_000.0;
fn queue_presses(e: &mut Emulator, keys: &[Press]) -> crate::Result<()> {
for p in keys {
match *p {
Press::Key(k) => e.queue().type_keys(&[k]),
Press::Letter(c) => {
if !e.queue().type_letter(c) {
return Err(format!("cannot type {c:?} on this model").into());
}
}
}
}
Ok(())
}
fn presses(keys: &[Press]) -> u64 {
keys.iter()
.map(|p| match p {
Press::Key(_) => 1,
Press::Letter(_) => 2,
})
.sum()
}
fn rehearse_keys(on: &Emulator, plan: &Plan, pass_ms: f64) -> crate::Result<Timing> {
let mut e = on.rehearsal();
queue_presses(&mut e, &plan.keys)?;
let marks = [
presses(&plan.keys[..plan.time_at]),
presses(&plan.keys[..plan.date_at]),
];
let mut down = [None::<f64>; 2];
let mut taken = [None::<f64>; 2];
let start = e.emulated_ms();
let base = e.queue().presses_started();
e.pump();
let mut pass = pass_ms;
loop {
let ran = e.emulated_ms() - start;
let n = e.queue().presses_started() - base;
let asleep = e.idle_ms().is_some();
for i in 0..2 {
if down[i].is_some() && taken[i].is_none() && (n > marks[i] || asleep) {
taken[i] = Some(ran);
}
if down[i].is_none() && n >= marks[i] {
down[i] = Some(ran);
}
}
if !e.keys_busy() && asleep {
let commit = |i: usize| match (down[i], taken[i]) {
(Some(d), Some(t)) => (d + t) / 2.0,
_ => ran,
};
return Ok(Timing {
time_ms: commit(0),
date_ms: commit(1),
end_ms: ran,
});
}
if ran > REHEARSAL_CAP_MS {
return Err(NOT_SETTLED.into());
}
if pass <= 0.0 {
pass = pass_ms;
}
pass -= e.run_slice(pass, true)?;
}
}
fn rehearse_write(on: &Emulator, time: &ClockTime, date: &ClockTime) -> crate::Result<Timing> {
let mut e = on.rehearsal();
e.start_transfer(Op::SetClock {
time: *time,
date: *date,
})?;
let start = e.emulated_ms();
let mut lines = Vec::new();
loop {
let done = e.transfer_step(crate::host::SLICE_MS)?;
let ran = e.emulated_ms() - start;
while lines.len() < e.transfer_lines_run() {
lines.push(ran);
}
if done {
let (r, _) = e.transfer_result()?;
if let Some(err) = r.error {
return Err(err.into());
}
let time_ms = lines.first().copied().unwrap_or(ran);
return Ok(Timing {
time_ms,
date_ms: lines.get(1).copied().unwrap_or(time_ms),
end_ms: ran,
});
}
if ran > REHEARSAL_CAP_MS {
return Err(NOT_SETTLED.into());
}
}
}
fn plan_lead<P: PartialEq>(
now: &Now,
pace: &Pace,
clock: &dyn crate::protocol::Clock,
plan: impl Fn(&ClockTime, &ClockTime) -> crate::Result<P>,
rehearse: impl Fn(&P) -> crate::Result<Timing>,
) -> crate::Result<(P, Lead)> {
let (mut time, mut date) = (now.time, now.time);
let mut p = plan(&time, &date)?;
let mut round = 0;
loop {
let before = clock.now_ms();
let timing = rehearse(&p)?;
let rate = pace.rate(timing.end_ms, clock.now_ms() - before);
let planning_ms = (clock.now_ms() - now.wall_ms).max(0.0);
let (t, d) = keyed(now, &timing, rate, planning_ms);
let next = plan(&t, &d)?;
round += 1;
if next == p || round == 3 {
if next == p {
(time, date) = (t, d);
}
for t in [time, date] {
if !YEARS.contains(&t.year) {
return Err(format!(
"the year must be between {} and {}",
YEARS.start(),
YEARS.end()
)
.into());
}
}
return Ok((
p,
Lead {
timing,
rate,
planning_ms,
time,
date,
},
));
}
(time, date, p) = (t, d, next);
}
}
impl Emulator {
pub fn clock_refusal(&self) -> Option<String> {
let m = self.machine();
let model = m.model();
if !has_clock(model) {
return Some(format!("The {} has no clock.", model.name().to_uppercase()));
}
if self.typing() || self.transferring() || self.keys_busy() {
return Some(BUSY.into());
}
if !m.display_on() {
return Some(OFF.into());
}
if asks_language(m) {
return Some(NO_LANGUAGE.into());
}
if pioneer_modes(model).is_none() && m.framebuffer().annunciators.busy {
return Some(BUSY.into());
}
if by_command(model) && self.command_line().is_ok_and(|l| l.active) {
return Some(LINE_OPEN.into());
}
let a = m.framebuffer().annunciators;
if !by_command(model) && (a.left_shift || a.right_shift || a.alpha) {
return Some(LINE_OPEN.into());
}
None
}
pub fn set_clock_by_keys(
&mut self,
now: &Now,
pace: &Pace,
clock: &dyn crate::protocol::Clock,
) -> crate::Result<Lead> {
if let Some(why) = self.clock_refusal() {
return Err(why.into());
}
if by_command(self.model()) {
return Err("the 48 and 49 set their clock by a write".into());
}
let this: &Emulator = self;
let m = self.machine();
let (plan, lead) = plan_lead(
now,
pace,
clock,
|time, date| key_plan(m, time, date, pace.speed <= 1.0),
|p| rehearse_keys(this, p, pace.pass_ms.max(1.0)),
)?;
self.release_keys();
if let Err(e) = queue_presses(self, &plan.keys) {
self.release_keys();
return Err(e);
}
self.pump();
Ok(lead)
}
pub fn clock_write(
&self,
now: &Now,
pace: &Pace,
clock: &dyn crate::protocol::Clock,
) -> crate::Result<(Op, Lead)> {
if let Some(why) = self.clock_refusal() {
return Err(why.into());
}
if !by_command(self.model()) {
return Err("this model sets its clock by keys".into());
}
let this: &Emulator = self;
plan_lead(
now,
pace,
clock,
|time, date| {
Ok(Op::SetClock {
time: *time,
date: *date,
})
},
|op| match op {
Op::SetClock { time, date } => rehearse_write(this, time, date),
_ => Err("not a clock write".into()),
},
)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn numbers_are_keyed_as_the_manuals_show() {
let t = ClockTime::new(2026, 6, 9, 21, 8, 30).unwrap();
assert_eq!(t.time_number(), "21.0830");
assert_eq!(t.date_number(false), "6.092026");
assert_eq!(t.date_number(true), "9.062026");
let midnight = ClockTime::new(2026, 10, 13, 0, 0, 5).unwrap();
assert_eq!(midnight.time_number(), "0.0005");
assert_eq!(
rpl_lines(&t, &t, false, false, false),
["21.0830 →TIME 6.092026 →DATE"]
);
assert_eq!(
rpl_lines(&t, &t, true, true, true),
["→TIME(21,0830)", "→DATE(9,062026)"]
);
assert_eq!(
number_keys("6.09"),
[
Press::Key("6"),
Press::Key("point"),
Press::Key("0"),
Press::Key("9")
]
);
}
#[test]
fn dates_are_checked_and_roll_over() {
assert!(ClockTime::new(2026, 2, 29, 0, 0, 0).is_err());
assert!(ClockTime::new(2024, 2, 29, 0, 0, 0).is_ok());
assert!(ClockTime::new(1990, 1, 1, 0, 0, 0).is_err());
assert!(ClockTime::new(2026, 1, 1, 24, 0, 0).is_err());
let t = ClockTime::new(2026, 12, 31, 23, 59, 50).unwrap();
assert_eq!(t.shifted(15), ClockTime::new(2027, 1, 1, 0, 0, 5).unwrap());
assert_eq!(t.shifted(15).shifted(-15), t);
let march = ClockTime::new(2024, 3, 1, 0, 0, 2).unwrap();
assert_eq!(
march.shifted(-3),
ClockTime::new(2024, 2, 29, 23, 59, 59).unwrap()
);
assert_eq!(march.shifted(86_400 * 366).year, 2025);
let json = serde_json::json!({"year": 2026, "month": 10, "day": 13, "hour": 9, "minute": 5, "second": 0});
assert_eq!(
ClockTime::from_json(&json).unwrap(),
ClockTime::new(2026, 10, 13, 9, 5, 0).unwrap()
);
assert!(ClockTime::from_json(&serde_json::json!({"year": 2026})).is_err());
}
#[test]
fn the_time_keyed_reads_the_wall_clock_when_the_set_is_done() {
let now = Now {
time: ClockTime::new(2026, 10, 13, 23, 59, 50).unwrap(),
ms: 600.0,
wall_ms: 0.0,
};
let timing = Timing {
time_ms: 10_000.0,
date_ms: 13_000.0,
end_ms: 14_000.0,
};
let (time, date) = keyed(&now, &timing, 1.0, 0.0);
assert_eq!(time, ClockTime::new(2026, 10, 14, 0, 0, 1).unwrap());
assert_eq!(date.day, 14);
let (time, _) = keyed(&now, &timing, 2.0, 0.0);
assert_eq!(time, ClockTime::new(2026, 10, 13, 23, 59, 54).unwrap());
let (time, date) = keyed(&now, &timing, f64::INFINITY, 400.0);
assert_eq!(time, ClockTime::new(2026, 10, 13, 23, 59, 47).unwrap());
assert_eq!(date.day, 13);
let first = Timing {
date_ms: 5_000.0,
..timing
};
let (time, date) = keyed(&now, &first, 1.0, 0.0);
assert_eq!(date, time);
let max = Pace {
speed: 60.0,
share: 0.5,
pass_ms: 1000.0,
};
assert_eq!(max.rate(1000.0, 0.0), 60.0);
assert_eq!(max.rate(1000.0, 50.0), 10.0);
assert_eq!(Pace::UNBOUNDED.rate(1000.0, 10.0), 100.0);
}
#[test]
fn only_the_42s_and_28s_have_no_clock() {
assert!(has_clock(Model::Hp19bii));
for m in Model::ALL {
let none = matches!(m, Model::Hp42s | Model::Hp28s);
assert_eq!(has_clock(m), !none, "{}", m.name());
}
}
}