use std::collections::VecDeque;
use kermit_proto::time::{Duration, Instant};
use kermit_proto::{Client, Command, Config, Event, OutgoingFile};
use saturnus_core::io::Key;
use saturnus_core::{Machine, Model};
use saturnus_objects::transfer::{self as tfile, is_plain_name};
use saturnus_objects::{Flags, Graphic, UserMemory, Variable, charset, cmdline, prolog};
use crate::typing::{Job, Verb};
pub const MAX_FILE_BYTES: usize = 512 * 1024;
pub const SERVER_CAP_MS: u64 = 15_000;
pub const TURNAROUND_MS: u64 = 200;
pub const FINISH_SETTLE_MS: u64 = 2_500;
const STABLE_MS: u64 = 300;
const IDLE_CAP_MS: u64 = 10_000;
const ON_HOLD_MS: u64 = 100;
const PROBE_TIMEOUT: Duration = Duration::from_secs(5);
const PROBE_RETRIES: u32 = 1;
const PROBE_CAP_MS: u64 = 15_000;
const END_ROUNDS: usize = 2;
const TIMEOUT: Duration = Duration::from_secs(6);
const RETRIES: u32 = 3;
const IDLE_WAIT: Duration = Duration::from_millis(100);
const MIN_WAIT: Duration = Duration::from_millis(10);
const MAX_BUSY: Duration = Duration::from_secs(600);
const READ_STEP_MS: u64 = 1;
const QUIET_MS: u64 = 4;
const NAK_STEP_MS: u64 = 10;
const DROP_GAP_MS: u64 = 100;
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Op {
Store {
dir: Vec<String>,
name: String,
data: Vec<u8>,
},
Fetch { dir: Vec<String>, name: String },
Purge { dir: Vec<String>, name: String },
Rename {
dir: Vec<String>,
name: String,
to: String,
},
CreateDir { dir: Vec<String>, name: String },
ChangeDir { dir: Vec<String> },
Copy {
dir: Vec<String>,
name: String,
to: Vec<String>,
replace: bool,
remove: bool,
},
SetFlag { flag: i32, on: bool },
StoreText {
dir: Vec<String>,
target: Target,
text: String,
},
StoreScreen {
dir: Vec<String>,
name: Option<String>,
replace: bool,
screen: Graphic,
},
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Target {
Variable(String),
Level(usize),
}
pub const TEXT_VARIABLE: &str = "SATEDIT";
pub const SCREEN_VARIABLE: &str = "SATSCRN";
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TransferResult {
pub emulated_ms: f64,
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub size: Option<usize>,
pub keys: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub error: Option<String>,
}
#[derive(Clone, Debug)]
enum Step {
Type(String),
WaitNak,
Host { text: String, cleanup: bool },
Send { name: String, data: Vec<u8> },
Get { name: String },
Push { text: String },
Compile { text: String },
Finish,
Settle,
DropTo(usize),
Algebraic,
CancelLine,
EndServer,
}
impl Step {
fn cleanup(&self) -> bool {
match self {
Step::Host { cleanup, .. } => *cleanup,
Step::Finish
| Step::Settle
| Step::DropTo(_)
| Step::Algebraic
| Step::CancelLine
| Step::EndServer => true,
_ => false,
}
}
fn after_server(&self) -> bool {
matches!(self, Step::Algebraic | Step::DropTo(_))
}
}
#[derive(Debug)]
struct Wire {
rx: VecDeque<u8>,
start: Instant,
idle: Duration,
}
fn is_answer(input: &[u8]) -> bool {
input.contains(&kermit_proto::codec::SOH)
}
impl Wire {
fn now(&self) -> Instant {
self.start + self.idle
}
fn run(&mut self, m: &mut Machine, n: u64) -> crate::Result<bool> {
m.run_cycles(n.max(1))?;
let out = m.serial_drain();
self.rx.extend(&out);
Ok(!out.is_empty())
}
fn discard(&mut self, m: &mut Machine) {
self.rx.clear();
m.serial_drain();
}
}
#[derive(Debug, Default)]
struct Transcript {
files: Vec<Vec<u8>>,
stored: Vec<String>,
text: Vec<u8>,
}
#[derive(Debug)]
enum Phase {
Pump,
Turnaround { until: u64, packet: Vec<u8> },
Read {
deadline: Instant,
busy: Duration,
last_byte: u64,
},
}
#[derive(Debug)]
struct Exchange {
client: Client,
sending: bool,
out: VecDeque<Vec<u8>>,
phase: Phase,
transcript: Transcript,
current: Option<Vec<u8>>,
outcome: Option<Result<(), Failure>>,
answered: bool,
}
fn opens_transaction(packet: &[u8]) -> bool {
let start = packet.iter().position(|&b| b == 0x01);
start
.and_then(|i| packet.get(i + 3))
.is_some_and(|t| matches!(t, b'S' | b'R' | b'I' | b'G' | b'C'))
}
#[derive(Clone, Debug, PartialEq, Eq)]
enum Failure {
Remote(String),
Link(String),
}
fn config() -> Config {
let mut c = Config::default();
c.timeout = TIMEOUT;
c.retries = RETRIES;
c.linger = Duration::ZERO;
c
}
fn ms_cycles(m: &Machine, ms: u64) -> u64 {
ms * u64::from(m.model().clock_hz()) / 1000
}
impl Exchange {
fn new(wire: &mut Wire, m: &mut Machine, command: Command) -> crate::Result<Exchange> {
Self::with(wire, m, command, config())
}
fn with(
wire: &mut Wire,
m: &mut Machine,
command: Command,
config: Config,
) -> crate::Result<Exchange> {
wire.discard(m);
let sending = matches!(command, Command::Send(_));
let mut client = Client::new(config);
client
.start(wire.now(), command)
.map_err(|e| format!("Kermit: {e}"))?;
Ok(Exchange {
client,
sending,
out: VecDeque::new(),
phase: Phase::Pump,
transcript: Transcript::default(),
current: None,
outcome: None,
answered: false,
})
}
fn step(
&mut self,
wire: &mut Wire,
m: &mut Machine,
stop: u64,
) -> crate::Result<Option<Result<Transcript, Failure>>> {
loop {
match &mut self.phase {
Phase::Pump => {
let now = wire.now();
while let Some(p) = self.client.poll_output(now) {
self.out.push_back(p);
}
self.events();
if let Some(packet) = self.out.pop_front() {
if opens_transaction(&packet) {
let until = m.cycles() + ms_cycles(m, TURNAROUND_MS);
self.phase = Phase::Turnaround { until, packet };
} else {
m.serial_push(&packet);
}
continue;
}
let deadline = match (self.client.next_timeout(), &self.outcome) {
(None, Some(_)) => {
let outcome = self.outcome.take().unwrap_or(Ok(()));
let t = std::mem::take(&mut self.transcript);
return Ok(Some(outcome.map(|()| t)));
}
(Some(t), _) => t.max(now + MIN_WAIT),
(None, None) => now + IDLE_WAIT,
};
self.phase = Phase::Read {
deadline,
busy: Duration::ZERO,
last_byte: m.cycles(),
};
}
Phase::Turnaround { until, packet } => {
if m.cycles() < *until {
if m.cycles() >= stop {
return Ok(None);
}
let n = (*until).min(stop) - m.cycles();
wire.run(m, n)?;
} else {
m.serial_push(packet);
self.phase = Phase::Pump;
}
}
Phase::Read {
deadline,
busy,
last_byte,
} => {
let quiet = !wire.rx.is_empty()
&& m.cycles() - *last_byte >= ms_cycles(m, QUIET_MS)
&& m.serial_pending() == 0;
if quiet || wire.now() >= *deadline {
let input: Vec<u8> = wire.rx.drain(..).collect();
let now = wire.now();
if !input.is_empty() {
self.answered |= is_answer(&input);
self.client.handle_input(now, &input);
}
self.client.handle_timeout(now);
self.phase = Phase::Pump;
continue;
}
if m.cycles() >= stop {
return Ok(None);
}
let step = Duration::from_millis(READ_STEP_MS);
if wire.run(m, ms_cycles(m, READ_STEP_MS))? {
*last_byte = m.cycles();
} else if wire.rx.is_empty() && !m.is_shutdown() && *busy < MAX_BUSY {
*busy += step;
continue;
}
wire.idle += step;
}
}
}
}
fn events(&mut self) {
while let Some(event) = self.client.poll_event() {
match event {
Event::FileStart { name } if self.sending => {
self.transcript.stored.push(charset::decode(&name));
}
Event::FileStart { .. } => self.current = Some(Vec::new()),
Event::Data(data) => {
if let Some(file) = self.current.as_mut() {
file.extend_from_slice(&data);
}
}
Event::FileEnd { discarded } => {
if let Some(file) = self.current.take()
&& !discarded
{
self.transcript.files.push(file);
}
}
Event::ServerText(text) => self.transcript.text.extend_from_slice(&text),
Event::Done => self.outcome = Some(Ok(())),
Event::Error(kermit_proto::Error::Remote(text)) => {
self.outcome = Some(Err(Failure::Remote(format!(
"calculator error: {}",
charset::decode(&text)
))));
}
Event::Error(e) => self.outcome = Some(Err(Failure::Link(format!("Kermit: {e}")))),
_ => {}
}
}
}
}
#[derive(Debug)]
enum Running {
Typing(Box<Job>),
WaitNak {
cap: u64,
},
Exchange(Box<Exchange>, Step),
EndServer {
phase: EndPhase,
until: u64,
},
Probe {
x: Box<Exchange>,
until: u64,
},
CancelLine {
phase: CancelPhase,
until: u64,
},
Settle(SettleState),
Drop {
left: usize,
up: u64,
next: u64,
},
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum EndPhase {
Hold,
Settle,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum CancelPhase {
Idle,
Hold,
Gap,
}
#[derive(Debug)]
struct SettleState {
until: u64,
cap: u64,
last: Option<saturnus_core::Lcd>,
since: u64,
}
impl SettleState {
fn new(m: &Machine, first_ms: u64) -> SettleState {
let until = m.cycles() + ms_cycles(m, first_ms);
SettleState {
until,
cap: until + ms_cycles(m, IDLE_CAP_MS),
last: None,
since: until,
}
}
}
#[derive(Debug)]
pub struct Transfer {
steps: VecDeque<Step>,
running: Option<Running>,
wire: Wire,
server: bool,
entering: bool,
baseline: Option<usize>,
error: Option<String>,
result: TransferResult,
fetched: Option<Vec<u8>>,
temp_variable: bool,
pushed: usize,
started: u64,
done: bool,
algebraic: Option<usize>,
restoring: bool,
restore_error: Option<String>,
stopped: bool,
probe_finish: bool,
probes: usize,
}
pub const STOPPED: &str = "stopped";
const STOP_TURN_MS: f64 = 50.0;
const TO_RPN: &str = "CF(-95)";
const TO_ALGEBRAIC: &str = "-95 SF";
fn no_server(model: Model) -> Option<String> {
(!matches!(model, Model::Hp48sx | Model::Hp48gx | Model::Hp49g)).then(|| {
format!(
"the {} has no Kermit server and no RPL user memory to write",
model.name().to_uppercase()
)
})
}
fn quoted(name: &str) -> String {
format!("'{name}'")
}
fn check_name(name: &str) -> crate::Result<()> {
if is_plain_name(name) {
Ok(())
} else {
Err(format!(
"{name:?} is not a plain variable name (1 to 127 characters, no digit or point first, \
no spaces, delimiters or operators)"
)
.into())
}
}
fn components(dir: &[String]) -> crate::Result<&[String]> {
let rest = match dir.split_first() {
Some((home, rest)) if home == "HOME" => rest,
_ => dir,
};
for name in rest {
check_name(name)?;
}
Ok(rest)
}
fn cd_command(dir: &[String]) -> String {
std::iter::once("HOME")
.chain(dir.iter().map(String::as_str))
.collect::<Vec<_>>()
.join(" ")
}
fn directory<'a>(tree: &'a [Variable], dir: &[String]) -> crate::Result<&'a [Variable]> {
let mut vars = tree;
let mut path = String::from("HOME");
for name in dir {
path.push(' ');
path.push_str(name);
vars = vars
.iter()
.find(|v| &v.name == name)
.and_then(|v| v.variables.as_deref())
.ok_or_else(|| format!("no directory {{ {path} }}"))?;
}
Ok(vars)
}
fn inside(path: &[String], dir: &[String], name: &str) -> bool {
path.len() > dir.len() && path.starts_with(dir) && path[dir.len()] == name
}
fn flag_range(model: Model) -> i32 {
if model == Model::Hp49g { 128 } else { 64 }
}
pub fn store_bytes(data: &[u8]) -> (Vec<u8>, bool) {
if tfile::is_binary_file(data) {
return (data.to_vec(), true);
}
let encoded = std::str::from_utf8(data)
.ok()
.and_then(|t| charset::encode(t).ok());
(encoded.unwrap_or_else(|| data.to_vec()), false)
}
pub fn trim_fetched(mut data: Vec<u8>) -> Vec<u8> {
if tfile::is_binary_file(&data) {
let nibbles = tfile::unpack(&data[tfile::HEADER_LEN..]);
if let Ok(size) = prolog::object_size(&nibbles, 0) {
data.truncate(tfile::HEADER_LEN + size.div_ceil(2));
}
}
data
}
fn text_refusal(text: &str) -> Option<String> {
let mut depth = 0usize;
let mut string = false;
let mut comment = false;
let mut prev: Option<char> = None;
for c in text.chars() {
let mid_word = prev.is_some_and(|p| {
!p.is_whitespace()
&& !matches!(
p,
'{' | '}' | '[' | ']' | '(' | ')' | '«' | '»' | '\'' | '"'
)
});
match c {
'"' | '@' if !string && !comment && mid_word => {
return Some(format!(
"a {c} right after a word starts a new token on the calculator: put a space before it"
));
}
'"' if !comment => string = !string,
'@' if !string => comment = !comment,
'\n' if comment => comment = false,
'{' if !string && !comment => depth += 1,
'}' if !string && !comment => match depth.checked_sub(1) {
Some(d) => depth = d,
None => return Some("a } closes a list the text did not open".into()),
},
_ => {}
}
prev = Some(c);
}
string.then(|| "the text leaves a string open (a \" is missing)".into())
}
#[derive(Clone, Copy, Debug, Default)]
struct CopyCase {
is_dir: bool,
taken: Option<bool>,
replace: bool,
remove: bool,
holds_here: bool,
}
fn copy_plan(
from: &[String],
name: &str,
into: &[String],
c: &CopyCase,
) -> crate::Result<Vec<Step>> {
let src = cd_command(from);
let dst = cd_command(into);
if from == into {
return Err(format!("{name} is in {{ {dst} }} already").into());
}
if c.is_dir && inside(into, from, name) {
return Err(format!("{name} cannot go into itself or a directory inside it").into());
}
if c.remove && c.holds_here {
return Err(
format!("{name} holds the current directory: change to another one first").into(),
);
}
match c.taken {
Some(_) if !c.replace => {
return Err(format!("{name} already exists in {{ {dst} }}").into());
}
Some(true) => {
return Err(format!(
"{name} in {{ {dst} }} is a directory, which a copy does not replace: purge it first"
)
.into());
}
Some(false) if c.is_dir => {
return Err(format!(
"a directory does not replace the variable {name} in {{ {dst} }}: purge it first"
)
.into());
}
_ => {}
}
let q = quoted(name);
let mut texts = vec![
src.clone(),
format!("{q} RCL"),
dst.clone(),
format!("{q} STO"),
];
if c.remove {
let verb = if c.is_dir { "PGDIR" } else { "PURGE" };
texts.extend([
format!("{q} RCL BYTES"),
src,
format!("{q} RCL BYTES"),
"ROT == 3 ROLLD == AND".into(),
format!("« {q} {verb} » « \"{COPY_DIFFERS}\" DOERR » IFTE"),
]);
}
Ok(texts
.into_iter()
.map(|text| Step::Host {
text,
cleanup: false,
})
.collect())
}
const COPY_DIFFERS: &str = "Copy differs";
fn wrapped(text: &str) -> String {
format!("{{\n{text}\n}}")
}
fn free_name(vars: &[Variable], base: &str) -> String {
(1..)
.map(|n| match n {
1 => base.to_string(),
n => format!("{base}{n}"),
})
.find(|name| vars.iter().all(|v| &v.name != name))
.unwrap_or_default()
}
fn reply_count(level: &str) -> Option<u32> {
let first = level.trim().chars().next()?;
first.to_digit(10).filter(|&n| n <= 2)
}
fn identity(u: &UserMemory<'_>, address: u32) -> crate::Result<String> {
let (size, crc) = u.identity_at(address).map_err(|e| format!("{e:#}"))?;
Ok(format!("{size}:{crc:04X}"))
}
fn algebraic(model: Model, flags: &Flags) -> bool {
model == Model::Hp49g && flags.get(-95) == Some(true)
}
fn rpn_now(m: &Machine) -> bool {
UserMemory::of(m)
.and_then(|u| u.flags())
.is_ok_and(|f| f.get(-95) == Some(false))
}
impl Transfer {
pub fn new(m: &Machine, op: Op) -> crate::Result<Transfer> {
if let Some(why) = no_server(m.model()) {
return Err(why.into());
}
let u = UserMemory::of(m).map_err(|e| format!("{e:#}"))?;
let flags = u.flags().map_err(|e| format!("{e:#}"))?;
let tree = u.tree().map_err(|e| format!("{e:#}"))?;
let path = u.current_path().map_err(|e| format!("{e:#}"))?;
let here: Vec<String> = path.iter().skip(1).cloned().collect();
let line = cmdline::command_line(m).map_err(|e| format!("{e:#}"))?;
if line.active {
return Err(
"the command line is open: finish it (ENTER) or cancel it (ON) first"
.to_string()
.into(),
);
}
let mut result = TransferResult::default();
let mut steps = VecDeque::new();
let alg = algebraic(m.model(), &flags);
if let Op::SetFlag { flag, on } = op {
let max = flag_range(m.model());
if flag == 0 || flag.abs() > max {
return Err(format!("flag {flag} is not between -{max} and {max} (not 0)").into());
}
let verb = if on { "SF" } else { "CF" };
if alg {
let depth = u.stack_addresses().map_err(|e| format!("{e:#}"))?.len();
steps.push_back(Step::Type(format!("{verb}({flag})")));
steps.push_back(Step::DropTo(depth));
result.keys = true;
return Ok(Transfer::planned(m, steps, result));
}
steps.push_back(Step::Host {
text: format!("{flag} {verb}"),
cleanup: false,
});
return Transfer::serve(m, &flags, steps, result);
}
let mut back = None;
let temp_variable = matches!(op, Op::StoreText { .. } | Op::StoreScreen { .. });
match op {
Op::ChangeDir { dir } => {
let dir = components(&dir)?;
directory(&tree, dir)?;
steps.push_back(Step::Host {
text: cd_command(dir),
cleanup: false,
});
}
Op::Store { dir, name, data } => {
check_name(&name)?;
if data.len() > MAX_FILE_BYTES {
return Err(format!("the file is larger than {MAX_FILE_BYTES} bytes").into());
}
let dir = components(&dir)?;
directory(&tree, dir)?;
let (data, binary) = store_bytes(&data);
back = Transfer::enter(&mut steps, dir, &here);
Transfer::with_mode(&mut steps, &flags, binary, Step::Send { name, data });
}
Op::Fetch { dir, name } => {
check_name(&name)?;
let dir = components(&dir)?;
let vars = directory(&tree, dir)?;
if !vars.iter().any(|v| v.name == name) {
return Err(format!("no variable {name} in {{ {} }}", cd_command(dir)).into());
}
back = Transfer::enter(&mut steps, dir, &here);
Transfer::with_mode(&mut steps, &flags, true, Step::Get { name: name.clone() });
result.name = Some(name);
}
Op::Purge { dir, name } => {
check_name(&name)?;
let dir = components(&dir)?;
let vars = directory(&tree, dir)?;
let var = vars
.iter()
.find(|v| v.name == name)
.ok_or_else(|| format!("no variable {name} in {{ {} }}", cd_command(dir)))?;
if var.variables.is_some() && inside(&here, dir, &name) {
return Err(format!(
"{name} holds the current directory: change to another one first"
)
.into());
}
let verb = if var.variables.is_some() {
"PGDIR"
} else {
"PURGE"
};
back = Transfer::enter(&mut steps, dir, &here);
steps.push_back(Step::Host {
text: format!("{} {verb}", quoted(&name)),
cleanup: false,
});
}
Op::Rename { dir, name, to } => {
check_name(&name)?;
check_name(&to)?;
let dir = components(&dir)?;
let vars = directory(&tree, dir)?;
let var = vars
.iter()
.find(|v| v.name == name)
.ok_or_else(|| format!("no variable {name} in {{ {} }}", cd_command(dir)))?;
if vars.iter().any(|v| v.name == to) {
return Err(format!("{to} already exists in {{ {} }}", cd_command(dir)).into());
}
if var.variables.is_some() && inside(&here, dir, &name) {
return Err(format!(
"{name} holds the current directory: change to another one first"
)
.into());
}
let verb = if var.variables.is_some() {
"PGDIR"
} else {
"PURGE"
};
back = Transfer::enter(&mut steps, dir, &here);
steps.push_back(Step::Host {
text: format!("{} RCL {} STO", quoted(&name), quoted(&to)),
cleanup: false,
});
steps.push_back(Step::Host {
text: format!("{} {verb}", quoted(&name)),
cleanup: false,
});
}
Op::CreateDir { dir, name } => {
check_name(&name)?;
let dir = components(&dir)?;
let vars = directory(&tree, dir)?;
if vars.iter().any(|v| v.name == name) {
return Err(
format!("{name} already exists in {{ {} }}", cd_command(dir)).into(),
);
}
back = Transfer::enter(&mut steps, dir, &here);
steps.push_back(Step::Host {
text: format!("{} CRDIR", quoted(&name)),
cleanup: false,
});
}
Op::Copy {
dir,
name,
to,
replace,
remove,
} => {
check_name(&name)?;
let from = components(&dir)?;
let into = components(&to)?;
let vars = directory(&tree, from)?;
let var = vars
.iter()
.find(|v| v.name == name)
.ok_or_else(|| format!("no variable {name} in {{ {} }}", cd_command(from)))?;
let targets = directory(&tree, into)?;
let is_dir = var.variables.is_some();
for step in copy_plan(
from,
&name,
into,
&CopyCase {
is_dir,
taken: targets
.iter()
.find(|v| v.name == name)
.map(|v| v.variables.is_some()),
replace,
remove,
holds_here: is_dir && inside(&here, from, &name),
},
)? {
steps.push_back(step);
}
if here.iter().all(|n| is_plain_name(n)) {
back = Some(cd_command(&here));
}
}
Op::StoreText { dir, target, text } => {
if let Some(why) = text_refusal(&text) {
return Err(why.into());
}
let family = tfile::Family::of(m.model());
let string = saturnus_objects::Object::String {
value: wrapped(&text),
};
let file = tfile::encode_file(&string, family)
.map_err(|e| format!("{e:#}"))?
.ok_or("a string has a binary file")?;
if file.len() > MAX_FILE_BYTES {
return Err(format!("the text is longer than {MAX_FILE_BYTES} bytes").into());
}
let place = match &target {
Target::Variable(name) => {
check_name(name)?;
let dir = components(&dir)?;
let vars = directory(&tree, dir)?;
if vars
.iter()
.any(|v| &v.name == name && v.variables.is_some())
{
return Err(format!("{name} is a directory, which has no text").into());
}
back = Transfer::enter(&mut steps, dir, &here);
format!("DROP 1 GET {} STO", quoted(name))
}
Target::Level(n) => {
let depth = u.stack_addresses().map_err(|e| format!("{e:#}"))?.len();
if *n == 0 || *n > depth {
return Err(
format!("there is no level {n} (the stack has {depth})").into()
);
}
format!("DROP 1 GET {} ROLL DROP {n} ROLLD", n + 1)
}
};
let vars = match &target {
Target::Variable(_) => directory(&tree, components(&dir)?)?,
Target::Level(_) => directory(&tree, &here)?,
};
let temp = free_name(vars, TEXT_VARIABLE);
Transfer::with_mode(
&mut steps,
&flags,
true,
Step::Send {
name: temp.clone(),
data: file,
},
);
steps.push_back(Step::Compile {
text: format!("{t} RCL {t} PURGE STR→ DUP SIZE 2 MIN", t = quoted(&temp)),
});
steps.push_back(Step::Host {
text: place,
cleanup: false,
});
}
Op::StoreScreen {
dir,
name,
replace,
screen,
} => {
let file = tfile::graphic_file(&screen, tfile::Family::of(m.model()))
.map_err(|e| format!("{e:#}"))?;
let vars = match &name {
Some(name) => {
check_name(name)?;
let dir = components(&dir)?;
let vars = directory(&tree, dir)?;
match vars.iter().find(|v| &v.name == name) {
Some(v) if v.variables.is_some() => {
return Err(format!(
"{name} in {{ {} }} is a directory: choose another name",
cd_command(dir)
)
.into());
}
Some(_) if !replace => {
return Err(format!(
"{name} already exists in {{ {} }}",
cd_command(dir)
)
.into());
}
_ => {}
}
back = Transfer::enter(&mut steps, dir, &here);
vars
}
None => directory(&tree, &here)?,
};
let temp = free_name(vars, SCREEN_VARIABLE);
Transfer::with_mode(
&mut steps,
&flags,
true,
Step::Send {
name: temp.clone(),
data: file,
},
);
let t = quoted(&temp);
steps.push_back(match &name {
Some(name) => Step::Host {
text: format!("{t} RCL {t} PURGE {} STO", quoted(name)),
cleanup: false,
},
None => Step::Push {
text: format!("{t} RCL {t} PURGE"),
},
});
result.name = name;
}
Op::SetFlag { .. } => {}
}
if let Some(text) = back {
steps.push_back(Step::Host {
text,
cleanup: true,
});
}
let mut t = Transfer::serve(m, &flags, steps, result)?;
if alg {
let depth = u.stack_addresses().map_err(|e| format!("{e:#}"))?.len();
t.in_rpn(depth);
}
t.temp_variable = temp_variable;
Ok(t)
}
fn enter(steps: &mut VecDeque<Step>, dir: &[String], here: &[String]) -> Option<String> {
if dir == here {
return None;
}
steps.push_back(Step::Host {
text: cd_command(dir),
cleanup: false,
});
here.iter()
.all(|n| is_plain_name(n))
.then(|| cd_command(here))
}
fn with_mode(steps: &mut VecDeque<Step>, flags: &Flags, binary: bool, step: Step) {
let was = flags.get(-35) == Some(true);
let set = |on: bool| if on { "-35 SF" } else { "-35 CF" };
if was != binary {
steps.push_back(Step::Host {
text: set(binary).into(),
cleanup: false,
});
}
steps.push_back(step);
if was != binary {
steps.push_back(Step::Host {
text: set(was).into(),
cleanup: true,
});
}
}
fn serve(
m: &Machine,
flags: &Flags,
steps: VecDeque<Step>,
result: TransferResult,
) -> crate::Result<Transfer> {
if m.model() != Model::Hp49g && flags.get(-33) == Some(true) {
return Err(
"flag -33 is set (I/O over infrared): clear it for transfers over the wire"
.to_string()
.into(),
);
}
let mut all = VecDeque::from([
Step::Type("SERVER".into()),
Step::WaitNak,
Step::Host {
text: String::new(),
cleanup: false,
},
]);
all.extend(steps);
all.push_back(Step::Finish);
all.push_back(Step::Settle);
Ok(Transfer::planned(m, all, result))
}
fn in_rpn(&mut self, depth: usize) {
self.steps.push_front(Step::DropTo(depth));
self.steps.push_front(Step::Type(TO_RPN.into()));
self.steps.push_back(Step::Algebraic);
self.steps.push_back(Step::DropTo(depth));
self.algebraic = Some(depth);
}
#[cfg(test)]
pub(crate) fn empty(m: &Machine) -> Transfer {
Self::planned(m, VecDeque::new(), TransferResult::default())
}
fn planned(m: &Machine, steps: VecDeque<Step>, result: TransferResult) -> Transfer {
Transfer {
steps,
running: None,
wire: Wire {
rx: VecDeque::new(),
start: Instant::now(),
idle: Duration::ZERO,
},
server: false,
entering: false,
baseline: None,
error: None,
result,
fetched: None,
temp_variable: false,
pushed: 0,
started: m.cycles(),
done: false,
algebraic: None,
restoring: false,
restore_error: None,
stopped: false,
probe_finish: false,
probes: 0,
}
}
pub fn step(&mut self, m: &mut Machine, budget: u64) -> crate::Result<bool> {
let stop = m.cycles().saturating_add(budget);
while !self.done {
if m.cycles() >= stop {
return Ok(false);
}
let Some(running) = self.running.take() else {
match self.steps.pop_front() {
Some(step) => self.begin(m, step)?,
None => self.done = true,
}
continue;
};
self.running = self.advance(m, running, stop)?;
}
Ok(true)
}
fn advance(
&mut self,
m: &mut Machine,
running: Running,
stop: u64,
) -> crate::Result<Option<Running>> {
match running {
Running::Typing(mut job) => match job.step(m, stop - m.cycles()) {
Ok(false) => Ok(Some(Running::Typing(job))),
Ok(true) => {
let o = job.outcome();
let refused = if let Some(e) = &o.error {
Some(format!("the calculator refused it: {e}"))
} else if o.closed == Some(false) {
Some("the command line stayed open".to_string())
} else {
None
};
if std::mem::take(&mut self.restoring) {
self.restored(m, refused);
} else if let Some(e) = refused {
self.fail(e);
}
Ok(None)
}
Err(e) => {
if std::mem::take(&mut self.restoring) {
self.restored(m, Some(e.to_string()));
} else {
self.fail(e.to_string());
}
Ok(None)
}
},
Running::WaitNak { cap } => {
self.wire.run(m, ms_cycles(m, NAK_STEP_MS))?;
let rx = self.wire.rx.make_contiguous();
if rx.windows(4).any(|w| w[0] == 0x01 && w[3] == b'N') {
self.wire.rx.clear();
self.server = true;
return Ok(None);
}
if m.cycles() < cap {
return Ok(Some(Running::WaitNak { cap }));
}
self.wire.rx.clear();
self.server = true;
Ok(self.abort(
m,
format!(
"no Kermit server answered within {} s of emulated time after SERVER",
SERVER_CAP_MS / 1000
),
))
}
Running::Exchange(mut x, step) => {
let Some(outcome) = x.step(&mut self.wire, m, stop)? else {
return Ok(Some(Running::Exchange(x, step)));
};
match outcome {
Ok(t) => {
self.finished(step, t);
Ok(None)
}
Err(e) if matches!(step, Step::Finish) => {
if std::mem::take(&mut self.probe_finish) {
if self.probes < END_ROUNDS {
return Ok(Some(self.press_on(m)));
}
let e = match e {
Failure::Remote(e) | Failure::Link(e) => e,
};
self.fail(format!("the server could not be ended: {e}"));
}
self.server = false;
Ok(None)
}
Err(Failure::Remote(e)) => {
self.fail(e);
Ok(None)
}
Err(Failure::Link(e)) => Ok(self.abort(m, e)),
}
}
Running::EndServer { phase, until } => {
if m.cycles() < until {
m.run_cycles((until.min(stop) - m.cycles()).max(1))?;
return Ok(Some(Running::EndServer { phase, until }));
}
Ok(Some(if phase == EndPhase::Hold {
let _ = m.key_up(Key::On);
Running::EndServer {
phase: EndPhase::Settle,
until: m.cycles() + ms_cycles(m, FINISH_SETTLE_MS),
}
} else {
self.probe(m)?
}))
}
Running::Probe { mut x, until } => {
let outcome = x.step(&mut self.wire, m, stop.min(until))?;
if outcome.is_none() && m.cycles() < until {
return Ok(Some(Running::Probe { x, until }));
}
self.probed(m, x.answered);
Ok(None)
}
Running::CancelLine { phase, until } => {
if phase == CancelPhase::Idle && m.is_shutdown() || m.cycles() >= until {
return Ok(match phase {
CancelPhase::Idle if cmdline::command_line(m).is_ok_and(|l| l.active) => {
m.key_down(Key::On)?;
Some(Running::CancelLine {
phase: CancelPhase::Hold,
until: m.cycles() + ms_cycles(m, ON_HOLD_MS),
})
}
CancelPhase::Hold => {
m.key_up(Key::On)?;
Some(Running::CancelLine {
phase: CancelPhase::Gap,
until: m.cycles() + ms_cycles(m, DROP_GAP_MS * 5),
})
}
_ => None,
});
}
let n = if phase == CancelPhase::Idle {
ms_cycles(m, 1)
} else {
until.min(stop).saturating_sub(m.cycles())
};
m.run_cycles(n.max(1))?;
Ok(Some(Running::CancelLine { phase, until }))
}
Running::Drop { left, up, next } => {
let now = m.cycles();
if now < up {
m.run_cycles((up.min(stop) - now).max(1))?;
if m.cycles() >= up {
m.key_up(Key::Backspace)?;
}
return Ok(Some(Running::Drop { left, up, next }));
}
if now < next && !m.is_shutdown() {
m.run_cycles(ms_cycles(m, 1))?;
return Ok(Some(Running::Drop { left, up, next }));
}
m.run_cycles(ms_cycles(m, DROP_GAP_MS))?;
if left > 1 {
return Ok(Some(self.press_drop(m, left - 1)?));
}
Ok(None)
}
Running::Settle(mut s) => {
if m.cycles() < s.until {
m.run_cycles((s.until.min(stop) - m.cycles()).max(1))?;
return Ok(Some(Running::Settle(s)));
}
m.run_cycles(ms_cycles(m, 5))?;
let lcd = m.lcd();
let now = m.cycles();
let mut settled = now >= s.cap;
if s.last.as_ref() != Some(&lcd) {
s.last = Some(lcd);
s.since = now;
} else if m.is_shutdown() && now - s.since >= ms_cycles(m, STABLE_MS) {
settled = true;
}
if !settled {
return Ok(Some(Running::Settle(s)));
}
self.wire.discard(m);
Ok(None)
}
}
}
fn press_drop(&mut self, m: &mut Machine, left: usize) -> crate::Result<Running> {
m.key_down(Key::Backspace)?;
let up = m.cycles() + ms_cycles(m, crate::typing::HOLD_MS);
Ok(Running::Drop {
left,
up,
next: up + ms_cycles(m, crate::typing::KEY_CAP_MS),
})
}
fn begin(&mut self, m: &mut Machine, step: Step) -> crate::Result<()> {
let failed = self.error.is_some() || self.result.error.is_some();
if failed && !step.cleanup() {
return Ok(());
}
let command = match &step {
Step::Type(text) => {
self.entering = text == "SERVER";
match Job::new(m, Verb::Run, text) {
Ok(job) => self.running = Some(Running::Typing(Box::new(job))),
Err(e) => self.fail(e.to_string()),
}
return Ok(());
}
Step::WaitNak => {
self.entering = false;
let cap = m.cycles() + ms_cycles(m, SERVER_CAP_MS);
self.running = Some(Running::WaitNak { cap });
return Ok(());
}
Step::Settle => {
self.running = Some(Running::Settle(SettleState::new(m, FINISH_SETTLE_MS)));
return Ok(());
}
Step::Algebraic => {
if rpn_now(m) {
match Job::new(m, Verb::Run, TO_ALGEBRAIC) {
Ok(job) => {
self.restoring = true;
self.running = Some(Running::Typing(Box::new(job)));
}
Err(e) => self.restored(m, Some(e.to_string())),
}
}
return Ok(());
}
Step::CancelLine => {
self.running = Some(Running::CancelLine {
phase: CancelPhase::Idle,
until: m.cycles() + ms_cycles(m, 1_000),
});
return Ok(());
}
Step::EndServer => {
self.running = Some(self.press_on(m));
return Ok(());
}
Step::DropTo(depth) => {
let now = UserMemory::of(m)
.and_then(|u| u.stack_addresses())
.map_err(|e| format!("{e:#}"))?
.len();
let depth = depth + self.pushed;
if now > depth {
self.running = Some(self.press_drop(m, now - depth)?);
}
return Ok(());
}
Step::Host { text, .. } | Step::Push { text } | Step::Compile { text } => {
let bytes = charset::encode_command(text)
.map_err(|c| format!("{c:?} is not in the HP character set"))?;
Command::Host(bytes)
}
Step::Send { name, data } => Command::Send(vec![OutgoingFile {
name: charset::encode(name)
.map_err(|c| format!("{c:?} is not in the HP character set"))?,
data: data.clone(),
}]),
Step::Get { name } => Command::Get(
charset::encode(name)
.map_err(|c| format!("{c:?} is not in the HP character set"))?,
),
Step::Finish => {
if !self.server {
return Ok(());
}
Command::Finish
}
};
let x = Exchange::new(&mut self.wire, m, command)?;
self.running = Some(Running::Exchange(Box::new(x), step));
Ok(())
}
fn finished(&mut self, step: Step, t: Transcript) {
let push = matches!(step, Step::Push { .. });
match step {
Step::Host { text, .. } | Step::Push { text } => {
let reply = tfile::parse_stack(&charset::decode(&t.text));
let levels = reply.levels.len();
let Some(error) = reply.error else {
self.baseline.get_or_insert(levels);
if push {
self.pushed += 1;
}
return;
};
if self.error.is_none() {
let what = if text.is_empty() {
"reading the stack"
} else {
&text
};
self.error = Some(format!("{what}: {error}"));
}
if let Some(extra) = self.baseline.and_then(|b| levels.checked_sub(b))
&& extra > 0
{
self.steps.push_front(Step::Host {
text: format!("{extra} DROPN"),
cleanup: true,
});
}
}
Step::Compile { .. } => {
let reply = tfile::parse_stack(&charset::decode(&t.text));
let levels = reply.levels.len();
let extra = self.baseline.and_then(|b| levels.checked_sub(b));
let refusal = match (&reply.error, extra) {
(Some(e), _) => Some(e.clone()),
(None, Some(2)) => match reply.level(1).and_then(reply_count) {
Some(1) => None,
Some(0) => Some("the text holds no object".to_string()),
Some(_) => Some("the text holds more than one object".to_string()),
None => Some("the calculator's reply could not be read".to_string()),
},
_ => Some("the calculator's reply could not be read".to_string()),
};
if let Some(why) = refusal {
self.result.error = Some(why);
if let Some(extra) = extra
&& extra > 0
{
self.steps.push_front(Step::Host {
text: format!("{extra} DROPN"),
cleanup: true,
});
}
}
}
Step::Send { name, .. } if self.temp_variable => {
let stored = t.stored.into_iter().next();
if stored.as_deref() != Some(name.as_str()) {
self.fail(format!(
"the calculator stored the file as {}, not {name}",
stored.unwrap_or_default()
));
}
}
Step::Send { .. } => self.result.name = t.stored.into_iter().next(),
Step::Get { name } => match t.files.into_iter().next() {
Some(file) => {
let file = trim_fetched(file);
self.result.size = Some(file.len());
self.fetched = Some(file);
}
None => self.fail(format!("GET {name}: no file came back")),
},
Step::Finish => {
self.server = false;
self.probe_finish = false;
}
_ => {}
}
}
fn fail(&mut self, error: String) {
self.error.get_or_insert(error);
}
fn restored(&mut self, m: &Machine, refused: Option<String>) {
let why = refused.or_else(|| rpn_now(m).then(|| "flag -95 is still clear".to_string()));
if let Some(why) = why {
self.restore_error
.get_or_insert(format!("the 49G stays in RPN mode: {why}"));
}
}
fn abandon(mut self, m: &mut Machine) {
match self.running.take() {
Some(Running::Typing(mut job)) => job.stop(m),
Some(Running::Drop { .. }) => {
let _ = m.key_up(Key::Backspace);
}
Some(Running::EndServer { .. } | Running::CancelLine { .. }) => {
let _ = m.key_up(Key::On);
}
_ => {}
}
m.serial_clear_inbound();
self.wire.discard(m);
}
fn press_on(&mut self, m: &mut Machine) -> Running {
let _ = m.key_down(Key::On);
Running::EndServer {
phase: EndPhase::Hold,
until: m.cycles() + ms_cycles(m, ON_HOLD_MS),
}
}
fn probe(&mut self, m: &mut Machine) -> crate::Result<Running> {
self.probes += 1;
let x = self.probe_exchange(m)?;
Ok(Running::Probe {
x: Box::new(x),
until: m.cycles() + ms_cycles(m, PROBE_CAP_MS),
})
}
fn probe_exchange(&mut self, m: &mut Machine) -> crate::Result<Exchange> {
let mut c = config();
c.timeout = PROBE_TIMEOUT;
c.retries = PROBE_RETRIES;
Exchange::with(&mut self.wire, m, Command::Info, c)
}
fn probed(&mut self, m: &mut Machine, answered: bool) {
if answered {
self.server = true;
self.probe_finish = true;
self.steps.push_front(Step::Settle);
self.steps.push_front(Step::Finish);
} else {
self.server = false;
m.serial_clear_inbound();
}
self.wire.discard(m);
}
fn abort(&mut self, m: &mut Machine, error: String) -> Option<Running> {
self.error.get_or_insert(error);
self.steps.retain(Step::after_server);
if !self.server {
return None;
}
Some(self.press_on(m))
}
pub fn stop(&mut self, m: &mut Machine) {
if self.stopped || self.done {
self.done = true;
return;
}
self.stopped = true;
self.error.get_or_insert_with(|| STOPPED.to_string());
let running = self.running.take();
let waiting = matches!(running, Some(Running::WaitNak { .. }));
let ending = matches!(
running,
Some(Running::EndServer { .. } | Running::Probe { .. })
);
let typing = matches!(running, Some(Running::Typing(_)));
match running {
Some(Running::Typing(mut job)) => job.stop(m),
Some(Running::Drop { .. }) => {
let _ = m.key_up(Key::Backspace);
}
Some(Running::EndServer { .. } | Running::CancelLine { .. }) => {
let _ = m.key_up(Key::On);
}
_ => {}
}
self.restoring = false;
self.steps.clear();
if typing {
self.steps.push_back(Step::CancelLine);
}
if self.server || waiting || ending || std::mem::take(&mut self.entering) {
self.steps.push_back(Step::EndServer);
}
if let Some(depth) = self.algebraic {
self.steps.push_back(Step::Settle);
self.steps.push_back(Step::Algebraic);
self.steps.push_back(Step::DropTo(depth));
}
}
pub fn finish(self, m: &Machine) -> crate::Result<(TransferResult, Option<Vec<u8>>)> {
match (self.error, self.restore_error) {
(Some(e), Some(r)) if e == STOPPED => return Err(r.into()),
(Some(e), Some(r)) => return Err(format!("{e}; {r}").into()),
(Some(e), None) | (None, Some(e)) => return Err(e.into()),
(None, None) => {}
}
let mut result = self.result;
result.emulated_ms =
(m.cycles() - self.started) as f64 * 1000.0 / f64::from(m.model().clock_hz());
Ok((result, self.fetched))
}
}
impl crate::Emulator {
pub fn start_transfer(&mut self, op: Op) -> crate::Result<()> {
if self.typing.is_some() || self.transfer.is_some() {
return Err("a send or a transfer is already in progress"
.to_string()
.into());
}
self.release_keys();
self.transfer = Some(Transfer::new(&self.machine, op)?);
Ok(())
}
fn target_address(
&self,
u: &UserMemory<'_>,
dir: &[String],
target: &Target,
) -> crate::Result<u32> {
Ok(match target {
Target::Variable(name) => {
let tree = u.tree().map_err(|e| format!("{e:#}"))?;
let dir = components(dir)?;
let var = directory(&tree, dir)?
.iter()
.find(|v| &v.name == name)
.ok_or_else(|| format!("no variable {name} in {{ {} }}", cd_command(dir)))?;
if var.variables.is_some() {
return Err(format!("{name} is a directory, which has no text").into());
}
var.address
}
Target::Level(n) => {
let levels = u.stack_addresses().map_err(|e| format!("{e:#}"))?;
*n.checked_sub(1)
.and_then(|i| levels.get(i))
.ok_or_else(|| {
format!("there is no level {n} (the stack has {})", levels.len())
})?
}
})
}
pub fn edit_text(&self, dir: &[String], target: &Target) -> crate::Result<(String, String)> {
let names = self.names();
let u = UserMemory::of(&self.machine)
.map_err(|e| format!("{e:#}"))?
.with_names(&names);
let address = self.target_address(&u, dir, target)?;
let text = u.edit_text_at(address).map_err(|e| format!("{e:#}"))?;
Ok((text, identity(&u, address)?))
}
pub fn edit_identity(&self, dir: &[String], target: &Target) -> crate::Result<String> {
let u = UserMemory::of(&self.machine).map_err(|e| format!("{e:#}"))?;
let address = self.target_address(&u, dir, target)?;
identity(&u, address)
}
pub fn check_unchanged(&self, dir: &[String], target: &Target, was: &str) -> crate::Result<()> {
if self.edit_identity(dir, target).ok().as_deref() == Some(was) {
return Ok(());
}
Err(match target {
Target::Variable(n) => {
format!("{n} changed on the calculator since it was opened: open it again")
}
Target::Level(n) => {
format!("level {n} changed on the calculator since it was opened: open it again")
}
}
.into())
}
pub fn transferring(&self) -> bool {
self.transfer.is_some()
}
pub fn transfer_step(&mut self, ms: f64) -> crate::Result<bool> {
let per_ms = f64::from(self.machine.model().clock_hz()) / 1000.0;
let Some(t) = self.transfer.as_mut() else {
return Err("no transfer in progress".to_string().into());
};
let budget = (ms.max(1.0) * per_ms) as u64;
match t.step(&mut self.machine, budget) {
Ok(done) => Ok(done),
Err(e) => {
if let Some(t) = self.transfer.take() {
t.abandon(&mut self.machine);
}
Err(e)
}
}
}
pub fn stop_transfer(&mut self) {
if let Some(t) = self.transfer.as_mut() {
t.stop(&mut self.machine);
}
}
pub fn abandon_transfer(&mut self) {
if let Some(t) = self.transfer.take() {
t.abandon(&mut self.machine);
}
}
pub fn stop_transfer_now(
&mut self,
cap_ms: f64,
) -> crate::Result<(TransferResult, Option<Vec<u8>>)> {
self.stop_transfer();
let mut left = cap_ms;
while self.transfer.is_some() && left > 0.0 {
if self.transfer_step(STOP_TURN_MS)? {
break;
}
left -= STOP_TURN_MS;
}
self.transfer_result()
}
pub fn transfer_result(&mut self) -> crate::Result<(TransferResult, Option<Vec<u8>>)> {
let t = self
.transfer
.take()
.ok_or_else(|| "no transfer in progress".to_string())?;
t.finish(&self.machine)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn s(v: &[&str]) -> Vec<String> {
v.iter().map(|x| x.to_string()).collect()
}
#[test]
fn transaction_openers() {
assert!(opens_transaction(b"\x01& C1 2 +X\r"));
assert!(opens_transaction(b"\x01#\x20S~"));
assert!(!opens_transaction(b"\x01#!Y5\r"));
assert!(!opens_transaction(b""));
}
#[test]
fn directories_and_names() {
assert_eq!(components(&s(&["HOME", "A", "B"])).unwrap(), s(&["A", "B"]));
assert_eq!(components(&s(&["A"])).unwrap(), s(&["A"]));
assert!(components(&s(&["HOME", "A B"])).is_err());
assert_eq!(cd_command(&s(&["A", "B"])), "HOME A B");
assert_eq!(cd_command(&[]), "HOME");
assert!(check_name("X1").is_ok());
assert!(check_name("1X").is_err());
assert!(check_name("A'B").is_err());
assert!(inside(&s(&["A", "B"]), &[], "A"));
assert!(!inside(&s(&["A"]), &s(&["A"]), "B"));
assert!(!inside(&[], &[], "A"));
}
#[test]
fn files_to_store() {
let bin = b"HPHP48-X\x33\x92\x02".to_vec();
assert_eq!(store_bytes(&bin), (bin.clone(), true));
let (b, binary) = store_bytes("%%HP: T(3);\n« 1 »".as_bytes());
assert!(!binary);
assert!(b.ends_with(&[171, b' ', b'1', b' ', 187]));
assert_eq!(store_bytes(&[0xFF, 0x41]), (vec![0xFF, 0x41], false));
}
#[test]
fn fetched_files_lose_the_padding() {
let real = saturnus_objects::Object::Real {
value: saturnus_objects::Real::parse("1").unwrap(),
};
let file = tfile::encode_file(&real, tfile::Family::Hp48)
.unwrap()
.unwrap();
let mut padded = file.clone();
padded.extend([0, 0, 0]);
assert_eq!(trim_fetched(padded), file);
assert_eq!(trim_fetched(b"text\0\0".to_vec()), b"text\0\0");
}
#[test]
fn models_without_a_server_are_refused() {
let m = Machine::new(Model::Hp38g, &vec![0u8; Model::Hp38g.rom_bytes()]).unwrap();
let e = Transfer::new(&m, Op::ChangeDir { dir: s(&["HOME"]) }).unwrap_err();
assert!(e.to_string().contains("38G has no Kermit server"), "{e}");
}
#[test]
fn a_failed_command_drops_what_it_left() {
let m = Machine::new(Model::Hp48sx, &vec![0u8; Model::Hp48sx.rom_bytes()]).unwrap();
let mut t = Transfer::planned(
&m,
VecDeque::from([Step::Host {
text: "-35 CF".into(),
cleanup: true,
}]),
TransferResult::default(),
);
let host = |text: &str| Step::Host {
text: text.into(),
cleanup: false,
};
let reply = |text: &str| Transcript {
text: text.as_bytes().to_vec(),
..Transcript::default()
};
t.finished(host(""), reply("1: 42\r\n"));
assert_eq!(t.baseline, Some(1));
t.finished(
host("'A' RCL 'B' STO"),
reply("Error: Bad Argument Type\r\n3: 42\r\n2: 7\r\n1: 'B'\r\n"),
);
assert_eq!(
t.error.as_deref(),
Some("'A' RCL 'B' STO: Bad Argument Type")
);
let texts: Vec<_> = t
.steps
.iter()
.map(|s| match s {
Step::Host { text, cleanup } => (text.as_str(), *cleanup),
_ => ("?", false),
})
.collect();
assert_eq!(texts, [("2 DROPN", true), ("-35 CF", true)]);
assert!(!host("X").cleanup() && Step::Finish.cleanup());
}
#[test]
fn a_stop_lets_go_of_on_and_ends_the_server_in_turns() {
let mut m = Machine::new(Model::Hp48sx, &vec![0u8; Model::Hp48sx.rom_bytes()]).unwrap();
let mut t = Transfer::planned(&m, VecDeque::new(), TransferResult::default());
t.server = true;
t.running = t.abort(&mut m, "Kermit: timeout".into());
assert!(matches!(t.running, Some(Running::EndServer { .. })));
assert!(m.key_is_down(Key::On));
let before = m.cycles();
t.stop(&mut m);
assert_eq!(m.cycles(), before, "a stop runs nothing itself");
assert!(!m.key_is_down(Key::On), "ON released");
assert!(!t.done);
assert!(matches!(t.steps.front(), Some(Step::EndServer)));
let budget = ms_cycles(&m, 50);
let mut turns = 0;
loop {
let at = m.cycles();
let done = t.step(&mut m, budget).unwrap();
assert!(
m.cycles() - at <= budget + ms_cycles(&m, 10),
"turn {turns}"
);
turns += 1;
if done {
break;
}
assert!(turns < 2_000, "the stop ends");
}
assert!(turns > 1, "in turns: {turns}");
assert!(!m.key_is_down(Key::On));
assert_eq!(t.error.as_deref(), Some("Kermit: timeout"));
}
#[test]
fn a_packet_is_an_answer_and_silence_is_not() {
use kermit_proto::BlockCheck;
use kermit_proto::codec::{Framing, Packet};
let packet = |kind: u8, data: &[u8]| {
Packet::new(0, kind, data.to_vec())
.encode(BlockCheck::Type1, &Framing::default())
.unwrap()
};
let ack = packet(b'Y', &kermit_proto::InitParams::default().encode());
assert!(is_answer(&ack), "its ACK of the I packet");
assert!(is_answer(&packet(b'N', b"")), "a NAK");
assert!(is_answer(&packet(b'E', b"Bad")), "an E packet");
assert!(!is_answer(&[]), "silence");
}
#[test]
fn a_silent_calculator_after_on_has_ended_its_server() {
let mut m = Machine::new(Model::Hp48sx, &vec![0u8; Model::Hp48sx.rom_bytes()]).unwrap();
let mut t = Transfer::planned(
&m,
VecDeque::from([Step::EndServer]),
TransferResult::default(),
);
t.server = true;
let start = m.cycles();
let mut probed = false;
let turn = ms_cycles(&m, 50);
while !t.step(&mut m, turn).unwrap() {
probed |= matches!(t.running, Some(Running::Probe { .. }));
}
assert!(probed, "an I packet asked");
assert!(!t.server, "ended");
assert!(t.steps.is_empty(), "no G F: {:?}", t.steps);
assert_eq!(m.serial_pending(), 0, "the probe's bytes are dropped");
assert!(!m.key_is_down(Key::On));
let ms = (m.cycles() - start) / ms_cycles(&m, 1);
let least = ON_HOLD_MS + FINISH_SETTLE_MS;
assert!(ms >= least && ms <= least + PROBE_CAP_MS + 100, "{ms} ms");
}
#[test]
fn the_probe_tells_a_silent_running_server_from_an_ended_one() {
let Some(dir) = std::env::var_os("SATURNUS_ROM_DIR") else {
return;
};
for (model, file) in [
(Model::Hp48sx, "sxrom-j"),
(Model::Hp48gx, "gxrom-r"),
(Model::Hp49g, "rom-2.10.49g"),
] {
let Ok(rom) = std::fs::read(std::path::Path::new(&dir).join(file)) else {
eprintln!("skipped: no {file}");
continue;
};
let mut m = Machine::new(model, &rom).unwrap();
boot(&mut m);
let name = model.name();
let mut t = silent_server(&mut m);
let mut running = Some(t.press_on(&mut m));
let mut probed = false;
while let Some(r) = running.take() {
probed |= matches!(r, Running::Probe { .. });
let stop = m.cycles() + ms_cycles(&m, 50);
running = t.advance(&mut m, r, stop).unwrap();
}
assert!(probed, "{name}: probed after ON");
assert!(!t.server, "{name}: ON ended it");
assert!(t.steps.is_empty(), "{name}: no G F: {:?}", t.steps);
assert!(!t.probe_finish && t.error.is_none(), "{name}");
let mut t = silent_server(&mut m);
assert!(probe_answers(&mut t, &mut m), "{name}: it answered");
let finish = exchange(&mut t, &mut m, Command::Finish);
assert!(finish.is_ok(), "{name}: G F: {:?}", finish.err());
m.run_cycles(ms_cycles(&m, FINISH_SETTLE_MS + 1_000))
.unwrap();
assert!(!probe_answers(&mut t, &mut m), "{name}: ended");
let line = cmdline::command_line(&m).unwrap();
assert!(!line.active, "{name}: at its stack");
}
}
fn exchange_out(
t: &mut Transfer,
m: &mut Machine,
x: &mut Exchange,
cap: u64,
) -> Option<Result<Transcript, Failure>> {
while m.cycles() < cap {
let stop = (m.cycles() + ms_cycles(m, 50)).min(cap);
if let Some(outcome) = x.step(&mut t.wire, m, stop).unwrap() {
return Some(outcome);
}
}
None
}
fn probe_answers(t: &mut Transfer, m: &mut Machine) -> bool {
let mut x = t.probe_exchange(m).unwrap();
let cap = m.cycles() + ms_cycles(m, PROBE_CAP_MS);
exchange_out(t, m, &mut x, cap);
t.wire.discard(m);
m.serial_clear_inbound();
x.answered
}
fn exchange(
t: &mut Transfer,
m: &mut Machine,
command: Command,
) -> Result<Transcript, Failure> {
let mut x = Exchange::new(&mut t.wire, m, command).unwrap();
let cap = m.cycles() + ms_cycles(m, 60_000);
exchange_out(t, m, &mut x, cap).unwrap_or(Err(Failure::Link("no end".into())))
}
fn sleeper() -> Machine {
let mut rom = vec![0u8; Model::Hp48sx.rom_bytes()];
rom[0] = 0x08;
rom[1] = 0x07;
Machine::new(Model::Hp48sx, &rom).unwrap()
}
#[test]
fn a_failed_g_f_after_an_answer_gets_on_and_the_probe_again() {
let mut m = sleeper();
let steps = VecDeque::from([Step::Finish, Step::Settle]);
let mut t = Transfer::planned(&m, steps, TransferResult::default());
t.server = true;
t.probe_finish = true;
t.probes = 1;
run_out(&mut t, &mut m);
assert_eq!(t.probes, 2, "ON and the probe again");
assert!(!t.server);
assert!(t.error.is_none(), "{:?}", t.error);
assert!(!m.key_is_down(Key::On));
}
#[test]
fn a_server_that_cannot_be_ended_is_an_error() {
let mut m = sleeper();
let steps = VecDeque::from([Step::Finish, Step::Settle]);
let mut t = Transfer::planned(&m, steps, TransferResult::default());
t.server = true;
t.probe_finish = true;
t.probes = END_ROUNDS;
run_out(&mut t, &mut m);
assert_eq!(t.probes, END_ROUNDS, "no further round");
assert!(!t.server);
let e = t.error.as_deref().unwrap_or_default();
assert!(e.starts_with("the server could not be ended"), "{e}");
}
#[test]
fn an_abandoned_probe_drops_its_inbound_bytes() {
let mut m = sleeper();
let mut t = Transfer::planned(&m, VecDeque::new(), TransferResult::default());
t.server = true;
let mut running = t.probe(&mut m).unwrap();
for _ in 0..1_000 {
if m.serial_pending() > 0 {
break;
}
let stop = m.cycles() + ms_cycles(&m, 1);
running = t.advance(&mut m, running, stop).unwrap().unwrap();
}
assert!(m.serial_pending() > 0, "the I packet is on its way");
t.running = Some(running);
t.abandon(&mut m);
assert_eq!(m.serial_pending(), 0);
}
fn boot(m: &mut Machine) {
m.run_cycles(ms_cycles(m, 10_000)).unwrap();
let presses = if m.model() == Model::Hp49g { 2 } else { 1 };
for _ in 0..presses {
m.key_down(Key::F).unwrap();
m.run_cycles(ms_cycles(m, 30)).unwrap();
m.key_up(Key::F).unwrap();
m.run_cycles(ms_cycles(m, 3_000)).unwrap();
}
}
fn silent_server(m: &mut Machine) -> Transfer {
let steps = VecDeque::from([Step::Type("SERVER".into()), Step::WaitNak]);
let mut t = Transfer::planned(m, steps, TransferResult::default());
run_out(&mut t, m);
assert!(t.server && t.error.is_none(), "{:?}", t.error);
m.run_cycles(ms_cycles(m, 20_000)).unwrap();
assert!(m.serial_drain().is_empty(), "silent after its one NAK");
t.done = false;
t
}
fn run_out(t: &mut Transfer, m: &mut Machine) {
let turn = ms_cycles(m, 50);
while !t.step(m, turn).unwrap() {}
}
#[test]
fn a_failed_return_to_algebraic_mode_is_reported() {
let m = Machine::new(Model::Hp49g, &vec![0u8; Model::Hp49g.rom_bytes()]).unwrap();
let failed = |error: Option<&str>, stopped: bool| {
let mut t = Transfer::planned(&m, VecDeque::new(), TransferResult::default());
t.error = error.map(str::to_string);
t.stopped = stopped;
t.restored(&m, Some("the calculator refused it: Invalid Syntax".into()));
t.finish(&m).unwrap_err().to_string()
};
let why = "the 49G stays in RPN mode: the calculator refused it: Invalid Syntax";
assert_eq!(failed(None, false), why);
assert_eq!(
failed(Some("CRDIR: Bad Argument Type"), false),
format!("CRDIR: Bad Argument Type; {why}")
);
assert_eq!(failed(Some(STOPPED), true), why);
let mut t = Transfer::planned(&m, VecDeque::new(), TransferResult::default());
t.error = Some(STOPPED.into());
t.stopped = true;
assert_eq!(t.finish(&m).unwrap_err().to_string(), STOPPED);
}
#[test]
fn algebraic_mode_is_set_again_on_every_path() {
let mut m = Machine::new(Model::Hp49g, &vec![0u8; Model::Hp49g.rom_bytes()]).unwrap();
let plan = || {
let flags = Flags {
system: vec![0; 2],
user: vec![0; 2],
};
let steps = VecDeque::from([Step::Host {
text: "'D' CRDIR".into(),
cleanup: false,
}]);
let mut t = Transfer::serve(&m, &flags, steps, TransferResult::default()).unwrap();
t.in_rpn(2);
t
};
let name = |s: &Step| match s {
Step::Type(t) => format!("type {t}"),
Step::WaitNak => "nak".into(),
Step::Host { text, .. } => format!("host {text}"),
Step::Finish => "finish".into(),
Step::Settle => "settle".into(),
Step::DropTo(n) => format!("drop to {n}"),
Step::Algebraic => "algebraic".into(),
Step::EndServer => "end server".into(),
_ => "?".into(),
};
let t = plan();
assert_eq!(t.algebraic, Some(2), "a stop sets -95 again too");
let all: Vec<String> = t.steps.iter().map(name).collect();
assert_eq!(
all,
[
"type CF(-95)",
"drop to 2",
"type SERVER",
"nak",
"host ",
"host 'D' CRDIR",
"finish",
"settle",
"algebraic",
"drop to 2",
]
);
let cleanup: Vec<String> = t.steps.iter().filter(|s| s.cleanup()).map(name).collect();
assert_eq!(
cleanup,
["drop to 2", "finish", "settle", "algebraic", "drop to 2"]
);
let mut t = plan();
for _ in 0..6 {
t.steps.pop_front();
}
t.server = true;
t.running = t.abort(&mut m, "Kermit: timeout".into());
assert!(matches!(t.running, Some(Running::EndServer { .. })));
let left: Vec<String> = t.steps.iter().map(name).collect();
assert_eq!(left, ["algebraic", "drop to 2"]);
t.stop(&mut m);
assert!(!m.key_is_down(Key::On));
let left: Vec<String> = t.steps.iter().map(name).collect();
assert_eq!(left, ["end server", "settle", "algebraic", "drop to 2"]);
}
#[test]
fn copies_and_moves_are_planned() {
let texts = |steps: Vec<Step>| -> Vec<String> {
steps
.into_iter()
.map(|s| match s {
Step::Host { text, cleanup } => {
assert!(!cleanup, "{text}");
text
}
_ => "?".into(),
})
.collect()
};
let case = CopyCase::default();
let a = s(&["A"]);
let b = s(&["B", "C"]);
assert_eq!(
texts(copy_plan(&a, "X", &b, &case).unwrap()),
["HOME A", "'X' RCL", "HOME B C", "'X' STO"]
);
let mv = CopyCase {
remove: true,
..case
};
assert_eq!(
texts(copy_plan(&a, "X", &[], &mv).unwrap()),
[
"HOME A",
"'X' RCL",
"HOME",
"'X' STO",
"'X' RCL BYTES",
"HOME A",
"'X' RCL BYTES",
"ROT == 3 ROLLD == AND",
"« 'X' PURGE » « \"Copy differs\" DOERR » IFTE",
]
);
let dir = CopyCase {
is_dir: true,
remove: true,
..case
};
assert!(texts(copy_plan(&[], "D", &a, &dir).unwrap())[8].contains("'D' PGDIR"));
let err = |from: &[String], into: &[String], c: CopyCase| {
copy_plan(from, "D", into, &c).unwrap_err().to_string()
};
assert_eq!(err(&a, &a, case), "D is in { HOME A } already");
assert_eq!(
err(&[], &s(&["D", "E"]), dir),
"D cannot go into itself or a directory inside it"
);
assert!(
copy_plan(&[], "D", &s(&["DD"]), &dir).is_ok(),
"only D itself"
);
assert!(
err(
&[],
&a,
CopyCase {
holds_here: true,
..dir
}
)
.contains("holds the current directory")
);
assert!(
copy_plan(
&[],
"D",
&a,
&CopyCase {
holds_here: true,
is_dir: true,
..case
}
)
.is_ok()
);
let taken = CopyCase {
taken: Some(false),
..case
};
assert_eq!(err(&[], &a, taken), "D already exists in { HOME A }");
assert!(
copy_plan(
&[],
"D",
&a,
&CopyCase {
replace: true,
..taken
}
)
.is_ok()
);
assert!(
err(
&[],
&a,
CopyCase {
replace: true,
taken: Some(true),
..case
}
)
.contains("is a directory")
);
assert!(
err(
&[],
&a,
CopyCase {
replace: true,
taken: Some(false),
is_dir: true,
..case
}
)
.contains("a directory does not replace")
);
}
#[test]
fn texts_for_store_text() {
assert_eq!(text_refusal("« { 1 } \"}\" @ } @ »"), None);
assert_eq!(text_refusal("{ 1 } @ comment }\n"), None);
assert_eq!(text_refusal("{\"a\"} \"a\"\"b\" (1,2) 'X' @c@ »"), None);
assert_eq!(text_refusal("\"a@b\" 3 @ \" @ 2"), None);
assert!(
text_refusal("} 'P' PURGE {")
.unwrap()
.contains("closes a list")
);
for t in ["X@ } 'P' PURGE {", "A\"B } 'P' PURGE {", "1@ 2", "A\"B\" C"] {
assert!(
text_refusal(t).unwrap().contains("right after a word"),
"{t}"
);
}
assert!(
text_refusal("\"} 'P' PURGE {")
.unwrap()
.contains("string open")
);
assert!(text_refusal("« \"a »").unwrap().contains("string open"));
assert_eq!(wrapped("« 1 »"), "{\n« 1 »\n}");
assert_eq!(reply_count("1"), Some(1));
assert_eq!(reply_count(" 1.000"), Some(1));
assert_eq!(reply_count("0,"), Some(0));
assert_eq!(reply_count("2."), Some(2));
assert_eq!(reply_count("\"x\""), None);
let v = |name: &str| Variable {
name: name.into(),
kind: "Real Number".into(),
size: 10.5,
checksum: 0,
address: 0,
variables: None,
};
assert_eq!(free_name(&[v("A")], TEXT_VARIABLE), TEXT_VARIABLE);
assert_eq!(
free_name(
&[v(TEXT_VARIABLE), v(&format!("{TEXT_VARIABLE}2"))],
TEXT_VARIABLE
),
format!("{TEXT_VARIABLE}3")
);
assert_eq!(
free_name(&[v(TEXT_VARIABLE), v(SCREEN_VARIABLE)], SCREEN_VARIABLE),
format!("{SCREEN_VARIABLE}2")
);
}
#[test]
fn a_compile_reports_the_calculators_refusal() {
let m = Machine::new(Model::Hp48sx, &vec![0u8; Model::Hp48sx.rom_bytes()]).unwrap();
let reply = |text: &str| Transcript {
text: text.as_bytes().to_vec(),
..Transcript::default()
};
let compile = || Step::Compile {
text: "'T' RCL 'T' PURGE STR→ DUP SIZE 2 MIN".into(),
};
let fresh = || {
let mut t = Transfer::planned(&m, VecDeque::new(), TransferResult::default());
t.baseline = Some(1);
t
};
let mut t = fresh();
t.finished(compile(), reply("3: 42\r\n2: { « 1 » }\r\n1: 1.00\r\n"));
assert_eq!(t.result.error, None);
assert!(t.steps.is_empty());
let mut t = fresh();
t.finished(
compile(),
reply("Error: Invalid Syntax\r\n2: 42\r\n1: \"{ « }\"\r\n"),
);
assert_eq!(t.result.error.as_deref(), Some("Invalid Syntax"));
assert_eq!(t.error, None, "the transfer itself went well");
assert!(matches!(&t.steps[0], Step::Host { text, cleanup: true } if text == "1 DROPN"));
assert!(
!Step::Host {
text: "x".into(),
cleanup: false
}
.cleanup()
);
let mut t = fresh();
t.finished(compile(), reply("3: 42\r\n2: { 1 2 }\r\n1: 2\r\n"));
assert_eq!(
t.result.error.as_deref(),
Some("the text holds more than one object")
);
assert!(matches!(&t.steps[0], Step::Host { text, .. } if text == "2 DROPN"));
let mut t = fresh();
t.finished(compile(), reply("3: 42\r\n2: { }\r\n1: 0\r\n"));
assert_eq!(t.result.error.as_deref(), Some("the text holds no object"));
}
#[test]
fn a_directory_must_exist() {
let tree = vec![Variable {
name: "D".into(),
kind: "Directory".into(),
size: 10.0,
checksum: 0,
address: 0,
variables: Some(vec![]),
}];
assert!(directory(&tree, &s(&["D"])).is_ok());
let e = directory(&tree, &s(&["D", "E"])).unwrap_err();
assert_eq!(e.to_string(), "no directory { HOME D E }");
}
}