use crate::{Error, Result};
pub use saturnus_objects::transfer::{StackReply, parse_stack};
#[derive(Clone, Debug, PartialEq)]
pub struct Listing {
pub path: Option<Vec<String>>,
pub free: Option<f64>,
pub entries: Vec<Entry>,
}
#[derive(Clone, Debug, PartialEq)]
pub struct Entry {
pub name: String,
pub size: f64,
pub kind: String,
pub checksum: u16,
}
impl Entry {
pub fn is_directory(&self) -> bool {
self.kind == "Directory"
}
}
pub fn parse_listing(text: &str) -> Result<Listing> {
let mut listing = Listing {
path: None,
free: None,
entries: Vec::new(),
};
let mut lines = text
.lines()
.map(str::trim)
.filter(|l| !l.is_empty())
.peekable();
if lines.peek().is_some_and(|l| l.starts_with('{')) {
let mut header = String::new();
for line in lines.by_ref() {
if !header.is_empty() {
header.push(' ');
}
header.push_str(line);
if line.contains('}') {
break;
}
}
let bad = || Error::Reply(format!("bad directory header: {header:?}"));
let end = header.find('}').ok_or_else(bad)?;
let (list, rest) = header.split_at(end + 1);
listing.path = Some(parse_list(list).ok_or_else(bad)?);
if !rest.trim().is_empty() {
listing.free = Some(parse_real(rest).ok_or_else(bad)?);
}
}
for line in lines {
listing.entries.push(parse_entry(line)?);
}
Ok(listing)
}
fn parse_entry(line: &str) -> Result<Entry> {
let bad = || Error::Reply(format!("bad directory line: {line:?}"));
let tokens: Vec<&str> = line.split_whitespace().collect();
let [name, size, kind @ .., checksum] = tokens.as_slice() else {
return Err(bad());
};
if kind.is_empty() {
return Err(bad());
}
let size = parse_real(size).filter(|s| *s >= 0.0).ok_or_else(bad)?;
let checksum = parse_real(checksum)
.and_then(integer)
.and_then(|c| u16::try_from(c).ok())
.ok_or_else(bad)?;
Ok(Entry {
name: (*name).to_string(),
size,
kind: kind.join(" "),
checksum,
})
}
fn integer(x: f64) -> Option<i64> {
(x.fract() == 0.0 && x.abs() < 9.0e15).then_some(x as i64)
}
pub fn parse_real(s: &str) -> Option<f64> {
let s = s.trim();
if s.is_empty()
|| !s
.chars()
.all(|c| c.is_ascii_digit() || matches!(c, '.' | ',' | 'E' | 'e' | '+' | '-'))
{
return None;
}
let mark = match (s.rfind('.'), s.rfind(',')) {
(Some(point), Some(comma)) if comma > point => ',',
(None, Some(_)) if s.matches(',').count() == 1 => ',',
(Some(_), None) if s.matches('.').count() > 1 => ',',
_ => '.',
};
let plain: String = s
.chars()
.filter_map(|c| match c {
'.' | ',' if c == mark => Some('.'),
'.' | ',' => None,
c => Some(c),
})
.collect();
plain.parse().ok()
}
pub fn parse_list(s: &str) -> Option<Vec<String>> {
let inner = s.trim().strip_prefix('{')?.strip_suffix('}')?;
if inner.contains(['{', '}', '"', '\'']) {
return None;
}
Some(
inner
.split(|c: char| c.is_whitespace() || c == ',' || c == ';')
.filter(|item| !item.is_empty())
.map(str::to_string)
.collect(),
)
}
pub fn parse_string(s: &str) -> Option<String> {
let s = s.trim();
let body = s.strip_prefix('"')?;
Some(body.strip_suffix('"').unwrap_or(body).to_string())
}
pub fn parse_whole_string(s: &str) -> Option<String> {
let s = s.trim();
let body = s.strip_prefix('"')?.strip_suffix('"')?;
Some(body.to_string())
}
pub fn looks_cut(level: &str) -> bool {
let mut open: Vec<char> = Vec::new();
let mut in_string = false;
let mut in_algebraic = false;
for c in level.chars() {
if in_string {
in_string = c != '"';
continue;
}
match c {
'"' => in_string = true,
'\'' => in_algebraic = !in_algebraic,
'{' | '[' | '«' | '(' => open.push(c),
'}' | ']' | '»' | ')' => {
let opener = match c {
'}' => '{',
']' => '[',
'»' => '«',
_ => '(',
};
if open.pop() != Some(opener) {
return false;
}
}
_ => {}
}
}
in_string || in_algebraic || !open.is_empty()
}
pub fn cut_levels(levels: &[String]) -> Vec<usize> {
levels
.iter()
.enumerate()
.filter(|(_, level)| looks_cut(level))
.map(|(i, _)| i + 1)
.collect()
}
pub fn parse_name(s: &str) -> Option<String> {
let inner = s.trim().strip_prefix('\'')?.strip_suffix('\'')?;
let first = inner.chars().next()?;
let valid = !first.is_ascii_digit()
&& first != '.'
&& inner.chars().all(|c| {
!c.is_whitespace()
&& !matches!(
c,
'+' | '-'
| '*'
| '/'
| '^'
| '='
| '<'
| '>'
| '('
| ')'
| '{'
| '}'
| '['
| ']'
| '#'
| ','
| ';'
| '\''
| '"'
| ':'
| '«'
| '»'
)
});
valid.then(|| inner.to_string())
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Iopar {
pub baud: u32,
pub parity: i8,
pub receive_pacing: bool,
pub transmit_pacing: bool,
pub checksum: u8,
pub translate: u8,
}
impl Default for Iopar {
fn default() -> Self {
Self {
baud: 9600,
parity: 0,
receive_pacing: false,
transmit_pacing: false,
checksum: 3,
translate: 1,
}
}
}
impl Iopar {
pub fn parse(s: &str) -> Option<Self> {
Self::from_items(&parse_list(s)?)
}
pub fn from_items(items: &[impl AsRef<str>]) -> Option<Self> {
let values = items
.iter()
.map(|item| parse_real(item.as_ref()).and_then(integer))
.collect::<Option<Vec<i64>>>()?;
let [baud, parity, rx, tx, checksum, translate] = values.as_slice() else {
return None;
};
Some(Self {
baud: u32::try_from(*baud).ok()?,
parity: i8::try_from(*parity).ok()?,
receive_pacing: *rx != 0,
transmit_pacing: *tx != 0,
checksum: u8::try_from(*checksum).ok()?,
translate: u8::try_from(*translate).ok()?,
})
}
pub fn to_rpl(&self) -> String {
let [baud, parity, rx, tx, checksum, translate] = self.values();
format!("{{ {baud}. {parity}. {rx}. {tx}. {checksum}. {translate}. }}")
}
fn values(&self) -> [i64; 6] {
[
i64::from(self.baud),
i64::from(self.parity),
i64::from(self.receive_pacing),
i64::from(self.transmit_pacing),
i64::from(self.checksum),
i64::from(self.translate),
]
}
}
impl std::fmt::Display for Iopar {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let [baud, parity, rx, tx, checksum, translate] = self.values();
write!(f, "{{ {baud} {parity} {rx} {tx} {checksum} {translate} }}")
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
use crate::charset::decode;
macro_rules! fixture {
($model:literal, $name:literal) => {
decode(include_bytes!(concat!(
"../fixtures/",
$model,
"-",
$name,
".txt"
)))
};
}
macro_rules! all_models {
($name:literal) => {
[
("48sx", fixture!("48sx", $name)),
("48gx", fixture!("48gx", $name)),
("49g", fixture!("49g", $name)),
]
};
}
fn entry<'a>(l: &'a Listing, name: &str) -> &'a Entry {
l.entries
.iter()
.find(|e| e.name == name)
.unwrap_or_else(|| panic!("no entry {name}"))
}
#[test]
fn dir() {
for (model, text) in all_models!("dir") {
let l = parse_listing(&text).unwrap();
if model == "48sx" {
assert_eq!(l.path, None);
assert_eq!(l.free, None);
} else {
assert_eq!(l.path, Some(vec!["HOME".to_string()]), "{model}");
assert!(l.free.unwrap() > 0.0, "{model}");
}
let d1 = entry(&l, "D1");
assert!(d1.is_directory(), "{model}");
let g = entry(&l, "G");
assert_eq!(
(g.size, g.kind.as_str(), g.checksum),
(1103.5, "Graphic", 3894)
);
let r = entry(&l, "R");
assert_eq!(
(r.size, r.kind.as_str(), r.checksum),
(16.0, "Real Number", 52870)
);
let b = entry(&l, "B");
assert_eq!(b.kind, "Binary Integer");
let iopar = entry(&l, "IOPAR");
assert_eq!((iopar.size, iopar.kind.as_str()), (29.5, "List"));
assert!(!iopar.is_directory());
}
let l = parse_listing(&fixture!("48gx", "dir")).unwrap();
assert_eq!(l.free, Some(126562.0));
assert_eq!(l.entries.len(), 11);
assert_eq!(entry(&l, "D1").checksum, 51467);
let l = parse_listing(&fixture!("49g", "dir")).unwrap();
assert_eq!(l.free, Some(244692.0));
assert_eq!(l.entries.len(), 12);
assert_eq!(entry(&l, "IOPAR").checksum, 10777);
assert_eq!(entry(&l, "D1").checksum, 65022);
assert!(entry(&l, "CASDIR").is_directory());
assert_eq!(entry(&l, "C").size, 24.0);
}
#[test]
fn dir_sub() {
for (model, text) in all_models!("dir-sub") {
let l = parse_listing(&text).unwrap();
assert_eq!(l.entries.len(), 1, "{model}");
assert_eq!(l.entries[0].name, "Z");
if model != "48sx" {
assert_eq!(l.path, Some(vec!["HOME".to_string(), "D1".to_string()]));
}
}
let l = parse_listing(&fixture!("49g", "dir-sub")).unwrap();
assert_eq!(
l.entries[0],
Entry {
name: "Z".into(),
size: 11.5,
kind: "Integer".into(),
checksum: 25035
}
);
assert_eq!(l.free, Some(244679.0));
}
#[test]
fn path() {
for (model, text) in all_models!("path") {
let s = parse_stack(&text);
assert_eq!(
parse_list(s.level(1).unwrap()).unwrap(),
["HOME"],
"{model}"
);
}
for (model, text) in all_models!("path-sub") {
let s = parse_stack(&text);
assert_eq!(
parse_list(s.level(1).unwrap()).unwrap(),
["HOME", "D1"],
"{model}"
);
}
}
#[test]
fn mem() {
for (model, text) in all_models!("mem") {
let s = parse_stack(&text);
assert!(parse_real(s.level(1).unwrap()).unwrap() > 0.0, "{model}");
}
let s = parse_stack(&fixture!("48sx", "mem"));
assert_eq!(parse_real(s.level(1).unwrap()), Some(28859.5));
}
#[test]
fn version() {
let s = parse_stack(&fixture!("48sx", "version"));
assert_eq!(s.levels.len(), 1);
assert_eq!(parse_name(s.level(1).unwrap()).as_deref(), Some("VERSION"));
let s = parse_stack(&fixture!("48gx", "version"));
assert_eq!(s.levels.len(), 2);
assert_eq!(
parse_string(s.level(2).unwrap()).as_deref(),
Some("Version HP48-R")
);
assert_eq!(
parse_string(s.level(1).unwrap()).as_deref(),
Some("Copyright HP 1993")
);
let s = parse_stack(&fixture!("49g", "version"));
assert_eq!(s.levels.len(), 2);
assert_eq!(
parse_string(s.level(2).unwrap()).as_deref(),
Some("Version HP48-C\nRevisi")
);
assert_eq!(
parse_string(s.level(1).unwrap()).as_deref(),
Some("Copyright HP 2009")
);
}
#[test]
fn cut_levels_are_told() {
for cut in [
"{ 9600. 0. 0. 0. 3. ",
"{9600.0000,0.0000,0.00",
"\"Version HP49-C\nRevi",
"\"ABCDEFGHIJKLMNOPQRS",
"« 1 2 + DUP DUP DUP D",
"[[1.,2.],[3.,4.],[5.",
"'X+Y+Z+SIN(X+Y+Z+X+Y",
"{ \"a}\" 'X' { 1 2 } 3",
"(1.,2.",
] {
assert!(looks_cut(cut), "{cut:?}");
}
for whole in [
"42.",
"\"Copyright HP 2009\"",
"{9600.,0.,0.,0.,3.,1.}",
"{ 9600 0 0 0 3 1 }",
"« 1 2 + »",
"[[ 1 2 ][ 3 4 ]]",
"'SIN(X)'",
"{ \"a{\" 'X' }",
"(1.,2.)",
":TAG: 5",
"# 10d",
"Graphic 131 × 64",
"",
] {
assert!(!looks_cut(whole), "{whole:?}");
}
let levels = vec!["\"AB".to_string(), "1.".to_string(), "{ 1".to_string()];
assert_eq!(cut_levels(&levels), [1, 3]);
assert_eq!(parse_whole_string("\"AB\""), Some("AB".to_string()));
assert_eq!(parse_whole_string("\"AB"), None);
assert_eq!(parse_whole_string("\""), None);
assert_eq!(parse_whole_string("AB"), None);
assert_eq!(
Iopar::from_items(&["9600.", "0.", "0.", "0.", "3.", "1."]),
Some(Iopar::default())
);
assert_eq!(Iopar::from_items(&["9600", "0", "0", "0", "3"]), None);
}
#[test]
fn iopar() {
for (model, text) in all_models!("iopar") {
let s = parse_stack(&text);
let iopar = Iopar::parse(s.level(1).unwrap());
assert_eq!(iopar, Some(Iopar::default()), "{model}");
}
let d = Iopar::default();
assert_eq!(d.to_string(), "{ 9600 0 0 0 3 1 }");
assert_eq!(d.to_rpl(), "{ 9600. 0. 0. 0. 3. 1. }");
let other = Iopar {
baud: 2400,
parity: -2,
receive_pacing: true,
transmit_pacing: false,
checksum: 1,
translate: 3,
};
assert_eq!(Iopar::parse(&other.to_rpl()), Some(other));
assert_eq!(other.to_rpl(), "{ 2400. -2. 1. 0. 1. 3. }");
assert_eq!(Iopar::parse(&other.to_string()), Some(other));
assert_eq!(Iopar::parse("{ 9600 0 0 0 3 }"), None);
assert_eq!(Iopar::parse("{ 9600 0 0 0 3 1.5 }"), None);
assert_eq!(Iopar::parse("{ 9600 0 0 0 300 1 }"), None);
}
#[test]
fn vars() {
for model in ["48sx", "48gx"] {
let text = if model == "48sx" {
fixture!("48sx", "vars")
} else {
fixture!("48gx", "vars")
};
let items = parse_list(parse_stack(&text).level(1).unwrap()).unwrap();
assert!(items.iter().any(|i| i == "D1"), "{model}");
assert!(items.iter().any(|i| i == "IOPAR"), "{model}");
}
let s = parse_stack(&fixture!("49g", "vars"));
assert_eq!(s.level(1), Some("{D1,G,TG,B,C,A,P,L,S,R"));
assert_eq!(parse_list(s.level(1).unwrap()), None);
}
#[test]
fn error() {
for model in ["48sx", "48gx"] {
let text = if model == "48sx" {
fixture!("48sx", "error")
} else {
fixture!("48gx", "error")
};
let s = parse_stack(&text);
assert_eq!(s.error.as_deref(), Some("Infinite Result"), "{model}");
assert_eq!(s.levels, ["0", "1"]);
}
let s = parse_stack(&fixture!("49g", "error"));
assert_eq!(s.error, None);
assert_eq!(s.level(1), Some("∞"));
}
#[test]
fn error_undefined() {
for (model, text) in all_models!("error-undefined") {
let s = parse_stack(&text);
assert_eq!(s.error.as_deref(), Some("Undefined Name"), "{model}");
assert_eq!(s.levels.len(), 1);
if model == "49g" {
assert_eq!(s.level(1), Some("NOSUCH"));
assert_eq!(parse_name(s.level(1).unwrap()), None);
} else {
assert_eq!(parse_name(s.level(1).unwrap()).as_deref(), Some("NOSUCH"));
}
}
}
#[test]
fn error_syntax() {
for (model, text) in all_models!("error-syntax") {
let s = parse_stack(&text);
assert_eq!(s.error.as_deref(), Some("Invalid Syntax"), "{model}");
assert_eq!(s.levels.len(), 2);
assert_eq!(
parse_string(s.level(1).unwrap()).as_deref(),
Some("CLEAR \\->LIST")
);
}
}
#[test]
fn stack() {
for (model, text) in all_models!("stack") {
let s = parse_stack(&text);
assert_eq!(s.error, None);
assert_eq!(s.levels.len(), 3, "{model}");
assert_eq!(s.level(3), Some("\"a\nb\""));
assert_eq!(s.level(2), Some("1.5"));
assert_eq!(parse_list(s.level(1).unwrap()).unwrap(), ["1", "2"]);
assert_eq!(s.level(0), None);
assert_eq!(s.level(4), None);
}
let s = parse_stack(&fixture!("49g", "stack"));
assert_eq!(s.level(1), Some("{1,2}"));
}
#[test]
fn empty() {
for (model, text) in all_models!("empty") {
let s = parse_stack(&text);
assert!(s.is_empty(), "{model}");
assert_eq!(s.error, None);
}
}
#[test]
fn flag() {
for (model, text) in all_models!("flag") {
let s = parse_stack(&text);
assert_eq!(parse_real(s.level(1).unwrap()), Some(1.0), "{model}");
}
}
#[test]
fn stack_edge_cases() {
let s = parse_stack("Error: X\r\nEmpty Stack");
assert_eq!(s.error.as_deref(), Some("X"));
assert!(s.is_empty());
let s = parse_stack("2: 5\r\n1: \"x\r\n2: y\"\r\n");
assert_eq!(s.levels, ["\"x\n2: y\"", "5"]);
let s = parse_stack("2: \"a\r\n3: b\"\r\n1: 7");
assert_eq!(s.levels, ["7", "\"a\n3: b\""]);
let s = parse_stack("1: \"a \r\n b \"\r\n");
assert_eq!(s.level(1), Some("\"a \n b \""));
let s = parse_stack("garbage\r\n1: 3");
assert_eq!(s.levels, ["3"]);
assert_eq!(parse_stack(""), StackReply::default());
assert_eq!(parse_stack("noise"), StackReply::default());
}
#[test]
fn listing_edge_cases() {
let l = parse_listing("").unwrap();
assert_eq!(l.entries, []);
assert_eq!(l.path, None);
assert!(parse_listing("\r\n\r\n").unwrap().entries.is_empty());
assert!(matches!(parse_listing("X 16 Real"), Err(Error::Reply(_))));
assert!(matches!(
parse_listing("X big Real Number 12"),
Err(Error::Reply(_))
));
assert!(matches!(
parse_listing("X 16 Real Number 70000"),
Err(Error::Reply(_))
));
assert!(matches!(
parse_listing("X 16 Real Number 12.5"),
Err(Error::Reply(_))
));
let l =
parse_listing("{ HOME SATXAAAA\r\nSATXBBBB } 244872.\r\nX 10.5 Real Number 1234\r\n")
.unwrap();
assert_eq!(
l.path.as_deref(),
Some(&["HOME".to_string(), "SATXAAAA".into(), "SATXBBBB".into()][..])
);
assert_eq!((l.free, l.entries.len()), (Some(244872.0), 1));
assert!(matches!(parse_listing("{ HOME 12"), Err(Error::Reply(_))));
assert!(matches!(
parse_listing("{ HOME } lots"),
Err(Error::Reply(_))
));
let l = parse_listing("{ HOME }\r\n").unwrap();
assert_eq!((l.path.unwrap().len(), l.free), (1, None));
}
#[test]
fn scalars() {
for (s, v) in [
("127828.", 127828.0),
("1.5", 1.5),
("-3", -3.0),
("30001", 30001.0),
(" 245966.5 ", 245966.5),
("1.E-3", 0.001),
("-1.5E12", -1.5e12),
("9,600.0000", 9600.0),
("9600.0000", 9600.0),
("30.129,5000", 30129.5),
("245951,5000", 245951.5),
("-95,0000", -95.0),
("1,5", 1.5),
("1,23E4", 12300.0),
("1,000,000.", 1.0e6),
] {
assert_eq!(parse_real(s), Some(v), "{s}");
}
for s in ["", "inf", "NaN", "abc", ".", ",", "1.5.3,2,1"] {
assert_eq!(parse_real(s), None, "{s}");
}
assert_eq!(parse_list("{ }").unwrap(), Vec::<String>::new());
assert_eq!(parse_list("{}").unwrap(), Vec::<String>::new());
assert_eq!(parse_list("{1;2}").unwrap(), ["1", "2"]);
assert_eq!(parse_list("1 2"), None);
assert_eq!(parse_list("{ { 1 } }"), None);
assert_eq!(parse_list("{ \"a\" }"), None);
assert_eq!(parse_string("\"\"").as_deref(), Some(""));
assert_eq!(parse_string("\"abc").as_deref(), Some("abc"));
assert_eq!(parse_string("abc"), None);
assert_eq!(parse_name("'X1'").as_deref(), Some("X1"));
assert_eq!(parse_name("'→A'").as_deref(), Some("→A"));
assert_eq!(parse_name("NOSUCH"), None);
assert_eq!(parse_name("''"), None);
assert_eq!(parse_name("'X+1'"), None);
assert_eq!(parse_name("'1X'"), None);
}
}