use crate::{Error, Result};
pub const HEADER_LEN: usize = 8;
const SEMI: u32 = 0x0312B;
const MAX_DEPTH: usize = 64;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Family {
Hp48,
Hp49,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct BinaryHeader {
pub family: Family,
pub rom: u8,
}
impl BinaryHeader {
pub fn parse(data: &[u8]) -> Option<Self> {
let head = data.get(..HEADER_LEN)?;
let family = match &head[..6] {
b"HPHP48" => Family::Hp48,
b"HPHP49" => Family::Hp49,
_ => return None,
};
if head[6] != b'-' || !head[7].is_ascii_graphic() {
return None;
}
Some(Self {
family,
rom: head[7],
})
}
pub fn to_bytes(self) -> [u8; HEADER_LEN] {
let digit = match self.family {
Family::Hp48 => b'8',
Family::Hp49 => b'9',
};
[b'H', b'P', b'H', b'P', b'4', digit, b'-', self.rom]
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct AsciiHeader {
pub translate: u8,
pub angle: u8,
pub fraction: u8,
}
impl Default for AsciiHeader {
fn default() -> Self {
Self {
translate: 3,
angle: b'D',
fraction: b'.',
}
}
}
impl AsciiHeader {
pub fn parse(data: &[u8]) -> Option<(Self, usize)> {
let mut p = Parser { data, pos: 0 };
p.literal(b"%%HP:")?;
p.spaces();
let translate = p.field(b'T', |c| (b'0'..=b'3').contains(&c))? - b'0';
p.spaces();
let angle = p.field(b'A', |c| matches!(c, b'D' | b'R' | b'G'))?;
p.spaces();
let fraction = p.field(b'F', |c| matches!(c, b'.' | b','))?;
p.spaces();
p.literal(b";")?;
if p.literal(b"\r\n").is_none() {
let _ = p.literal(b"\n");
}
Some((
Self {
translate,
angle,
fraction,
},
p.pos,
))
}
pub fn to_line(self) -> String {
format!(
"%%HP: T({})A({})F({});",
self.translate,
char::from(self.angle),
char::from(self.fraction)
)
}
}
struct Parser<'a> {
data: &'a [u8],
pos: usize,
}
impl Parser<'_> {
fn literal(&mut self, lit: &[u8]) -> Option<()> {
let end = self.pos.checked_add(lit.len())?;
if self.data.get(self.pos..end)? == lit {
self.pos = end;
Some(())
} else {
None
}
}
fn spaces(&mut self) {
while matches!(self.data.get(self.pos), Some(b' ' | b'\t')) {
self.pos += 1;
}
}
fn field(&mut self, key: u8, ok: impl Fn(u8) -> bool) -> Option<u8> {
self.literal(&[key, b'('])?;
let v = *self.data.get(self.pos)?;
if !ok(v) {
return None;
}
self.pos += 1;
self.literal(b")")?;
Some(v)
}
}
pub fn unpack(bytes: &[u8]) -> Vec<u8> {
bytes.iter().flat_map(|b| [b & 0x0F, b >> 4]).collect()
}
pub fn pack(nibbles: &[u8]) -> Vec<u8> {
nibbles
.chunks(2)
.map(|c| (c[0] & 0x0F) | (c.get(1).copied().unwrap_or(0) & 0x0F) << 4)
.collect()
}
pub fn read_field(nibbles: &[u8], at: usize, width: usize) -> Option<u32> {
if width > 8 {
return None;
}
let field = nibbles.get(at..at.checked_add(width)?)?;
Some(
field
.iter()
.rev()
.fold(0u32, |acc, &n| (acc << 4) | u32::from(n & 0x0F)),
)
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ObjectType {
SystemBinary,
Real,
LongReal,
Complex,
LongComplex,
Character,
Array,
LinkedArray,
String,
BinaryInteger,
List,
Directory,
Algebraic,
Unit,
Tagged,
Graphic,
Library,
Backup,
LibraryData,
Program,
Code,
GlobalName,
LocalName,
XlibName,
Integer,
SymbolicMatrix,
LongReal49,
LongComplex49,
FlashPointer,
Aplet,
MiniFont,
ExtendedPointer,
Extended2,
Extended3,
Extended4,
}
#[derive(Clone, Copy)]
enum Walk {
Fixed(usize),
Length,
Lengths(usize),
Composite,
Tagged,
Name,
Directory,
}
const PROLOG_RANGE: std::ops::RangeInclusive<u32> = 0x02600..=0x02FFF;
const TYPES: [(ObjectType, u32, &str, Walk); 35] = [
(
ObjectType::SystemBinary,
0x02911,
"System Binary",
Walk::Fixed(10),
),
(ObjectType::Real, 0x02933, "Real Number", Walk::Fixed(21)),
(ObjectType::LongReal, 0x02955, "Long Real", Walk::Fixed(26)),
(
ObjectType::Complex,
0x02977,
"Complex Number",
Walk::Fixed(37),
),
(
ObjectType::LongComplex,
0x0299D,
"Long Complex",
Walk::Fixed(47),
),
(ObjectType::Character, 0x029BF, "Character", Walk::Fixed(7)),
(ObjectType::Array, 0x029E8, "Array", Walk::Length),
(
ObjectType::LinkedArray,
0x02A0A,
"Linked Array",
Walk::Length,
),
(ObjectType::String, 0x02A2C, "String", Walk::Length),
(
ObjectType::BinaryInteger,
0x02A4E,
"Binary Integer",
Walk::Length,
),
(ObjectType::List, 0x02A74, "List", Walk::Composite),
(ObjectType::Directory, 0x02A96, "Directory", Walk::Directory),
(ObjectType::Algebraic, 0x02AB8, "Algebraic", Walk::Composite),
(ObjectType::Unit, 0x02ADA, "Unit", Walk::Composite),
(ObjectType::Tagged, 0x02AFC, "Tagged", Walk::Tagged),
(ObjectType::Graphic, 0x02B1E, "Graphic", Walk::Length),
(ObjectType::Library, 0x02B40, "Library", Walk::Length),
(ObjectType::Backup, 0x02B62, "Backup", Walk::Length),
(
ObjectType::LibraryData,
0x02B88,
"Library Data",
Walk::Length,
),
(ObjectType::Program, 0x02D9D, "Program", Walk::Composite),
(ObjectType::Code, 0x02DCC, "Code", Walk::Length),
(ObjectType::GlobalName, 0x02E48, "Global Name", Walk::Name),
(ObjectType::LocalName, 0x02E6D, "Local Name", Walk::Name),
(ObjectType::XlibName, 0x02E92, "XLIB Name", Walk::Fixed(11)),
(ObjectType::Integer, 0x02614, "Integer", Walk::Length),
(
ObjectType::SymbolicMatrix,
0x02686,
"Symbolic Matrix",
Walk::Composite,
),
(
ObjectType::LongReal49,
0x0263A,
"Long Real (49G)",
Walk::Lengths(2),
),
(
ObjectType::LongComplex49,
0x02660,
"Long Complex (49G)",
Walk::Lengths(4),
),
(
ObjectType::FlashPointer,
0x026AC,
"Flash Pointer",
Walk::Fixed(12),
),
(ObjectType::Aplet, 0x026D5, "Aplet", Walk::Length),
(ObjectType::MiniFont, 0x026FE, "Mini Font", Walk::Length),
(
ObjectType::ExtendedPointer,
0x02BAA,
"Extended Pointer",
Walk::Fixed(15),
),
(ObjectType::Extended2, 0x02BCC, "Extended 2", Walk::Length),
(ObjectType::Extended3, 0x02BEE, "Extended 3", Walk::Length),
(ObjectType::Extended4, 0x02C10, "Extended 4", Walk::Length),
];
impl ObjectType {
pub fn from_prolog(prolog: u32) -> Option<Self> {
TYPES.iter().find(|t| t.1 == prolog).map(|t| t.0)
}
fn entry(self) -> &'static (ObjectType, u32, &'static str, Walk) {
&TYPES[self as usize]
}
pub fn prolog(self) -> u32 {
self.entry().1
}
pub fn name(self) -> &'static str {
self.entry().2
}
}
fn add(a: usize, b: usize) -> Result<usize> {
a.checked_add(b)
.ok_or_else(|| Error::Object("object size overflows".into()))
}
fn field(nibbles: &[u8], at: usize, width: usize) -> Result<usize> {
read_field(nibbles, at, width)
.map(|v| v as usize)
.ok_or_else(|| Error::Object(format!("truncated object at nibble {at}")))
}
pub fn object_size(nibbles: &[u8], at: usize) -> Result<usize> {
walk(nibbles, at, 0)
}
fn element_size(nibbles: &[u8], at: usize, depth: usize) -> Result<usize> {
let p = field(nibbles, at, 5)? as u32;
if ObjectType::from_prolog(p).is_some() {
walk(nibbles, at, depth)
} else if PROLOG_RANGE.contains(&p) {
Err(Error::Object(format!(
"unknown prolog #{p:05X} at nibble {at}"
)))
} else {
Ok(5)
}
}
fn walk(nibbles: &[u8], at: usize, depth: usize) -> Result<usize> {
if depth > MAX_DEPTH {
return Err(Error::Object(format!(
"objects nested deeper than {MAX_DEPTH} levels"
)));
}
let prolog = field(nibbles, at, 5)? as u32;
let ty = ObjectType::from_prolog(prolog)
.ok_or_else(|| Error::Object(format!("unknown prolog #{prolog:05X} at nibble {at}")))?;
let body = add(at, 5)?;
let size = match ty.entry().3 {
Walk::Fixed(n) => n,
Walk::Length => add(5, lengths_size(nibbles, body, 1)?)?,
Walk::Lengths(n) => add(5, lengths_size(nibbles, body, n)?)?,
Walk::Composite => {
let mut pos = body;
loop {
if field(nibbles, pos, 5)? == SEMI as usize {
break add(pos, 5)? - at;
}
pos = add(pos, element_size(nibbles, pos, depth + 1)?)?;
}
}
Walk::Tagged => {
let n = field(nibbles, body, 2)?;
let inner = add(body, 2 + 2 * n)?;
add(inner, element_size(nibbles, inner, depth + 1)?)? - at
}
Walk::Name => 7 + 2 * field(nibbles, body, 2)?,
Walk::Directory => directory_size(nibbles, at, depth)?,
};
if add(at, size)? > nibbles.len() {
return Err(Error::Object(format!(
"{} at nibble {at} needs {size} nibbles, only {} left",
ty.name(),
nibbles.len().saturating_sub(at)
)));
}
Ok(size)
}
fn lengths_size(nibbles: &[u8], at: usize, count: usize) -> Result<usize> {
let mut pos = at;
for _ in 0..count {
let len = field(nibbles, pos, 5)?;
if len < 5 {
return Err(Error::Object(format!(
"length field #{len:05X} at nibble {pos} is shorter than itself"
)));
}
pos = add(pos, len)?;
}
Ok(pos - at)
}
fn directory_size(nibbles: &[u8], at: usize, depth: usize) -> Result<usize> {
let lib_at = add(at, 5)?;
field(nibbles, lib_at, 3)?;
let off_at = add(lib_at, 3)?;
let offset = field(nibbles, off_at, 5)?;
let mut pos = add(off_at, 5)?;
if offset == 0 {
return Ok(pos - at);
}
let last = add(off_at, offset)?;
loop {
let name_at = add(pos, 5)?;
if name_at > last {
return Err(Error::Object(format!(
"directory at nibble {at}: last-variable offset does not match its records"
)));
}
let n = field(nibbles, name_at, 2)?;
pos = add(name_at, 2 + 2 * n)?;
if n != 0 {
field(nibbles, pos, 2)?;
pos = add(pos, 2)?;
}
pos = add(pos, element_size(nibbles, pos, depth + 1)?)?;
if name_at == last {
return Ok(pos - at);
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ObjectInfo {
pub header: BinaryHeader,
pub prolog: u32,
pub object_type: Option<ObjectType>,
pub size_nibbles: Option<usize>,
}
pub fn inspect(data: &[u8]) -> Result<ObjectInfo> {
let header = BinaryHeader::parse(data)
.ok_or_else(|| Error::Object("no HPHP48-x / HPHP49-x header".into()))?;
let nibbles = unpack(&data[HEADER_LEN..]);
let prolog = read_field(&nibbles, 0, 5)
.ok_or_else(|| Error::Object("no object after the header".into()))?;
Ok(ObjectInfo {
header,
prolog,
object_type: ObjectType::from_prolog(prolog),
size_nibbles: object_size(&nibbles, 0).ok(),
})
}
pub const KERMIT_PADDING_ALLOWANCE: usize = 4;
pub fn strip_padding(data: &[u8], allowance: usize) -> &[u8] {
let Some(size) = inspect(data).ok().and_then(|i| i.size_nibbles) else {
return data;
};
let want = HEADER_LEN + size.div_ceil(2);
match data.len().checked_sub(want) {
Some(excess) if excess <= allowance => data.get(..want).unwrap_or(data),
_ => data,
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
const MODELS: [(&str, Family, u8); 3] = [
("48sx", Family::Hp48, b'J'),
("48gx", Family::Hp48, b'R'),
("49g", Family::Hp49, b'C'),
];
fn fixture(model: &str, kind: &str) -> Vec<u8> {
let path = format!("{}/fixtures/{model}-{kind}.hp", env!("CARGO_MANIFEST_DIR"));
std::fs::read(&path).unwrap_or_else(|e| panic!("{path}: {e}"))
}
fn f(value: u32, width: usize) -> Vec<u8> {
(0..width)
.map(|i| ((value >> (4 * i)) & 0xF) as u8)
.collect()
}
fn cat(parts: &[Vec<u8>]) -> Vec<u8> {
parts.concat()
}
fn real() -> Vec<u8> {
cat(&[f(0x02933, 5), vec![0; 16]])
}
#[test]
fn fixtures_walk() {
use ObjectType as T;
for (model, family, rom) in MODELS {
let kinds = [
("R", Some(T::Real)),
("S", Some(T::String)),
("L", Some(T::List)),
("P", Some(T::Program)),
("A", Some(T::Algebraic)),
("C", Some(T::Complex)),
("B", Some(T::BinaryInteger)),
("TG", Some(T::List)),
("G", Some(T::Graphic)),
("D1", Some(T::Directory)),
];
for (kind, ty) in kinds {
let data = fixture(model, kind);
let info = inspect(&data).unwrap();
assert_eq!(info.header, BinaryHeader { family, rom }, "{model}-{kind}");
assert_eq!(info.object_type, ty, "{model}-{kind}");
let size = info.size_nibbles.expect("walk");
let full = 2 * (data.len() - HEADER_LEN);
assert!(
size == full || size + 1 == full,
"{model}-{kind}: {size} vs {full}"
);
let allow = KERMIT_PADDING_ALLOWANCE;
assert_eq!(strip_padding(&data, allow), &data[..], "{model}-{kind}");
let mut padded = data.clone();
padded.extend_from_slice(&[0; KERMIT_PADDING_ALLOWANCE]);
assert_eq!(strip_padding(&padded, allow), &data[..], "{model}-{kind}");
padded.push(0);
assert_eq!(strip_padding(&padded, allow), &padded[..], "{model}-{kind}");
}
}
}
#[test]
fn tagged_fixture_holds_tag() {
for (model, _, _) in MODELS {
let data = fixture(model, "TG");
let nib = unpack(&data[HEADER_LEN..]);
assert_eq!(read_field(&nib, 5, 5), Some(ObjectType::Tagged.prolog()));
}
}
#[test]
fn binary_header_round_trip() {
for (_, family, rom) in MODELS {
let h = BinaryHeader { family, rom };
assert_eq!(BinaryHeader::parse(&h.to_bytes()), Some(h));
}
assert_eq!(
&BinaryHeader::parse(b"HPHP48-R").unwrap().to_bytes(),
b"HPHP48-R"
);
assert_eq!(BinaryHeader::parse(b"HPHP47-R"), None);
assert_eq!(BinaryHeader::parse(b"HPHP48-"), None);
assert_eq!(BinaryHeader::parse(b"%%HP: T(1)"), None);
assert!(inspect(b"HPHP48-R\x33").is_err());
assert!(inspect(b"not a file").is_err());
}
#[test]
fn ascii_header() {
let (h, len) = AsciiHeader::parse(b"%%HP: T(1)A(D)F(.);\r\n\"AB\"").unwrap();
assert_eq!(len, 21);
assert_eq!(
h,
AsciiHeader {
translate: 1,
angle: b'D',
fraction: b'.'
}
);
assert_eq!(h.to_line(), "%%HP: T(1)A(D)F(.);");
let (h2, len2) = AsciiHeader::parse(b"%%HP: T(3)A(R)F(,);\n").unwrap();
assert_eq!(len2, 20);
assert_eq!(AsciiHeader::parse(h2.to_line().as_bytes()).unwrap().0, h2);
assert_eq!(AsciiHeader::default().to_line(), "%%HP: T(3)A(D)F(.);");
assert_eq!(AsciiHeader::parse(b"%%HP: T(4)A(D)F(.);"), None);
assert_eq!(AsciiHeader::parse(b"HPHP48-R"), None);
assert_eq!(AsciiHeader::parse(b"%%HP: T(1)A(D)"), None);
}
#[test]
fn nibble_packing() {
assert_eq!(unpack(&[0x2A, 0xF0]), vec![0xA, 0x2, 0x0, 0xF]);
for n in [vec![], vec![7], vec![1, 2, 3], vec![0xF, 0, 0xA, 5]] {
let packed = pack(&n);
assert_eq!(packed.len(), n.len().div_ceil(2));
assert_eq!(unpack(&packed)[..n.len()], n[..]);
}
assert_eq!(pack(&[1, 2, 3]), vec![0x21, 0x03]);
assert_eq!(read_field(&[0xE, 0x1, 0xB, 0x2, 0x0], 0, 5), Some(0x02B1E));
assert_eq!(read_field(&[1, 2], 1, 2), None);
assert_eq!(read_field(&[1, 2], 0, 0), Some(0));
}
#[test]
fn type_table() {
for t in TYPES {
assert_eq!(ObjectType::from_prolog(t.1), Some(t.0));
assert_eq!(t.0.prolog(), t.1);
assert_eq!(t.0.name(), t.2);
}
assert_eq!(ObjectType::from_prolog(0x12345), None);
}
#[test]
fn empty_directory() {
let d = cat(&[f(0x02A96, 5), f(0x7FF, 3), f(0, 5)]);
assert_eq!(object_size(&d, 0).unwrap(), 13);
let lib = cat(&[f(0x02A96, 5), f(0x123, 3), f(0, 5)]);
assert_eq!(object_size(&lib, 0).unwrap(), 13);
}
#[test]
fn directory_two_variables() {
let rec1 = cat(&[f(0, 5), f(1, 2), f(b'A'.into(), 2), f(1, 2), real()]);
let rec2 = cat(&[f(rec1.len() as u32, 5), f(0, 2), real()]);
let off = 5 + rec1.len() as u32 + 5;
let d = cat(&[
f(0x02A96, 5),
f(0x7FF, 3),
f(off, 5),
rec1,
rec2,
vec![9; 3],
]);
assert_eq!(object_size(&d, 0).unwrap(), d.len() - 3);
let mut with_lib = d.clone();
with_lib[5..8].copy_from_slice(&f(0x123, 3));
assert_eq!(object_size(&with_lib, 0).unwrap(), d.len() - 3);
let bad = cat(&[f(0x02A96, 5), f(0x7FF, 3), f(3, 5), real()]);
assert!(object_size(&bad, 0).is_err());
}
#[test]
fn nested_lists_and_tags() {
let inner = cat(&[f(0x02A74, 5), real(), f(SEMI, 5)]);
let outer = cat(&[
f(0x02A74, 5),
inner.clone(),
f(0x1ABCD, 5),
inner,
f(SEMI, 5),
]);
assert_eq!(object_size(&outer, 0).unwrap(), outer.len());
let tag = cat(&[f(0x02AFC, 5), f(2, 2), f(0x4241, 4), real()]);
assert_eq!(object_size(&tag, 0).unwrap(), tag.len());
let tag_ptr = cat(&[f(0x02AFC, 5), f(1, 2), f(0x54, 2), f(0x2A31D, 5)]);
assert_eq!(object_size(&tag_ptr, 0).unwrap(), tag_ptr.len());
}
#[test]
fn program_with_rom_pointers_and_integer() {
let prog = cat(&[
f(0x02D9D, 5),
f(0x1E061, 5),
real(),
f(0x1A2B3, 5),
f(SEMI, 5),
]);
assert_eq!(object_size(&prog, 0).unwrap(), prog.len());
let int = cat(&[f(0x02614, 5), f(7, 5), vec![3, 0]]);
assert_eq!(object_size(&int, 0).unwrap(), 12);
let name = cat(&[f(0x02E48, 5), f(1, 2), f(0x5A, 2)]);
assert_eq!(object_size(&name, 0).unwrap(), 9);
}
#[test]
fn malformed_input_errors() {
let prog = cat(&[f(0x02D9D, 5), f(0x1E061, 5), real(), f(SEMI, 5)]);
for cut in 0..prog.len() {
assert!(object_size(&prog[..cut], 0).is_err(), "cut {cut}");
}
let err = object_size(&f(0x12345, 5), 0).unwrap_err().to_string();
assert!(err.contains("#12345"), "{err}");
let short = cat(&[f(0x02A2C, 5), f(3, 5)]);
assert!(object_size(&short, 0).is_err());
let huge = cat(&[f(0x02A2C, 5), f(0xFFFFF, 5)]);
assert!(object_size(&huge, 0).is_err());
assert!(object_size(&real(), 100).is_err());
}
#[test]
fn list_with_symbolic_matrix_walks_full_length_regression() {
let list = |matrix_prolog: u32| {
cat(&[
f(0x02A74, 5),
f(matrix_prolog, 5),
real(),
f(SEMI, 5),
f(SEMI, 5),
])
};
let fixed = list(0x02686);
assert_eq!(object_size(&fixed, 0).unwrap(), fixed.len());
let as_pointer = list(0x1ABCD);
assert_eq!(object_size(&as_pointer, 0).unwrap(), as_pointer.len() - 5);
let mut file = BinaryHeader {
family: Family::Hp49,
rom: b'C',
}
.to_bytes()
.to_vec();
file.extend(pack(&fixed));
assert_eq!(strip_padding(&file, KERMIT_PADDING_ALLOWANCE), &file[..]);
}
#[test]
fn unknown_value_in_prolog_range_errors() {
for p in [0x02600, 0x02700, 0x02FFF] {
let list = cat(&[f(0x02A74, 5), f(p, 5), real(), f(SEMI, 5)]);
let err = object_size(&list, 0).unwrap_err().to_string();
assert!(err.contains(&format!("unknown prolog #{p:05X}")), "{err}");
}
for p in [0x025FF, 0x03000] {
let list = cat(&[f(0x02A74, 5), f(p, 5), f(SEMI, 5)]);
assert_eq!(object_size(&list, 0).unwrap(), 15);
}
}
#[test]
fn strip_padding_keeps_data_when_excess_exceeds_allowance() {
let mut file = BinaryHeader {
family: Family::Hp48,
rom: b'R',
}
.to_bytes()
.to_vec();
file.extend(pack(&real()));
let object_len = file.len();
file.extend([0xAA; 10]);
assert_eq!(strip_padding(&file, 4), &file[..]);
assert_eq!(strip_padding(&file, 9), &file[..]);
assert_eq!(strip_padding(&file, 10), &file[..object_len]);
assert_eq!(strip_padding(&file, 64), &file[..object_len]);
assert_eq!(strip_padding(b"not a file", 64), b"not a file");
}
#[test]
fn hp49_and_extended_types_walk() {
let long_real = cat(&[f(0x0263A, 5), f(7, 5), vec![1, 2], f(6, 5), vec![3]]);
assert_eq!(object_size(&long_real, 0).unwrap(), long_real.len());
let long_cmp = cat(&[
f(0x02660, 5),
f(6, 5),
vec![1],
f(5, 5),
f(8, 5),
vec![1, 2, 3],
f(6, 5),
vec![4],
]);
assert_eq!(object_size(&long_cmp, 0).unwrap(), long_cmp.len());
assert!(object_size(&long_cmp[..long_cmp.len() - 1], 0).is_err());
let flash = cat(&[f(0x026AC, 5), f(0x123, 3), f(0x4567, 4)]);
assert_eq!(object_size(&flash, 0).unwrap(), 12);
let acptr = cat(&[f(0x02BAA, 5), f(0x12345, 5), f(0x6789A, 5)]);
assert_eq!(object_size(&acptr, 0).unwrap(), 15);
for p in [0x026D5, 0x026FE, 0x02BCC, 0x02BEE, 0x02C10] {
let obj = cat(&[f(p, 5), f(8, 5), vec![1, 2, 3]]);
assert_eq!(object_size(&obj, 0).unwrap(), 13, "#{p:05X}");
}
let in_list = cat(&[f(0x02A74, 5), flash, acptr, long_real, f(SEMI, 5)]);
assert_eq!(object_size(&in_list, 0).unwrap(), in_list.len());
}
#[test]
fn depth_limit() {
let deep = |levels: usize| {
let mut v = Vec::new();
for _ in 0..levels {
v.extend(f(0x02A74, 5));
}
for _ in 0..levels {
v.extend(f(SEMI, 5));
}
v
};
assert!(object_size(&deep(MAX_DEPTH), 0).is_ok());
assert!(object_size(&deep(MAX_DEPTH + 2), 0).is_err());
assert!(object_size(&deep(10_000), 0).is_err());
}
}