#![allow(dead_code)]
pub const DI_BAD_MOUNT: u16 = 0x0000;
pub const DI_LOAD: u16 = 0x0002;
pub const DI_UNLOAD: u16 = 0x0004;
pub const DI_FORMAT: u16 = 0x0006;
pub const DI_VERIFY: u16 = 0x0008;
pub const DI_ZERO: u16 = 0x000A;
pub const NO_ERR: i16 = 0;
pub const DI_USER_PROCEEDED: i16 = 0;
pub const DI_USER_CANCEL: i16 = 1;
pub const DI_BAD_MOUNT_ARG_BYTES: u32 = 8;
pub const DI_LOAD_ARG_BYTES: u32 = 0;
pub const DI_UNLOAD_ARG_BYTES: u32 = 0;
pub const DI_FORMAT_ARG_BYTES: u32 = 2;
pub const DI_VERIFY_ARG_BYTES: u32 = 2;
pub const DI_ZERO_ARG_BYTES: u32 = 258;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DiskInitArchitecture {
M68k,
PowerPc,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DiskInitOperation {
BadMount,
Load,
Unload,
Format,
Verify,
Zero,
}
impl DiskInitOperation {
pub fn from_selector(selector: u16) -> Option<Self> {
match selector {
DI_BAD_MOUNT => Some(Self::BadMount),
DI_LOAD => Some(Self::Load),
DI_UNLOAD => Some(Self::Unload),
DI_FORMAT => Some(Self::Format),
DI_VERIFY => Some(Self::Verify),
DI_ZERO => Some(Self::Zero),
_ => None,
}
}
pub fn selector(self) -> u16 {
match self {
Self::BadMount => DI_BAD_MOUNT,
Self::Load => DI_LOAD,
Self::Unload => DI_UNLOAD,
Self::Format => DI_FORMAT,
Self::Verify => DI_VERIFY,
Self::Zero => DI_ZERO,
}
}
pub fn stack_argument_bytes_68k(self) -> u32 {
match self {
Self::BadMount => DI_BAD_MOUNT_ARG_BYTES,
Self::Load => DI_LOAD_ARG_BYTES,
Self::Unload => DI_UNLOAD_ARG_BYTES,
Self::Format => DI_FORMAT_ARG_BYTES,
Self::Verify => DI_VERIFY_ARG_BYTES,
Self::Zero => DI_ZERO_ARG_BYTES,
}
}
pub fn has_result_word_68k(self) -> bool {
match self {
Self::BadMount | Self::Format | Self::Verify | Self::Zero => true,
Self::Load | Self::Unload => false,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct DiskInitEvaluation {
pub pop_bytes_68k: u32,
pub result_word: Option<i16>,
}
pub fn evaluate_pack2(selector: u16) -> Option<DiskInitEvaluation> {
let op = DiskInitOperation::from_selector(selector)?;
let pop_bytes_68k = 2 + op.stack_argument_bytes_68k();
let result_word = if op.has_result_word_68k() {
Some(NO_ERR)
} else {
None
};
Some(DiskInitEvaluation {
pop_bytes_68k,
result_word,
})
}
pub fn evaluate_di_bad_mount(_where_v: i16, _where_h: i16, _evt_message: u32) -> i16 {
DI_USER_PROCEEDED
}
pub fn evaluate_di_format(_drv_num: i16) -> i16 {
NO_ERR
}
pub fn evaluate_di_verify(_drv_num: i16) -> i16 {
NO_ERR
}
pub fn evaluate_di_zero(_drv_num: i16, _vol_name: &[u8]) -> i16 {
NO_ERR
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn selector_decoding_and_roundtrip() {
let all_ops = [
(DI_BAD_MOUNT, DiskInitOperation::BadMount, 8, true),
(DI_LOAD, DiskInitOperation::Load, 0, false),
(DI_UNLOAD, DiskInitOperation::Unload, 0, false),
(DI_FORMAT, DiskInitOperation::Format, 2, true),
(DI_VERIFY, DiskInitOperation::Verify, 2, true),
(DI_ZERO, DiskInitOperation::Zero, 258, true),
];
for (sel, op, arg_bytes, has_result) in all_ops {
assert_eq!(DiskInitOperation::from_selector(sel), Some(op));
assert_eq!(op.selector(), sel);
assert_eq!(op.stack_argument_bytes_68k(), arg_bytes);
assert_eq!(op.has_result_word_68k(), has_result);
}
assert_eq!(DiskInitOperation::from_selector(0x000C), None);
assert_eq!(DiskInitOperation::from_selector(0xFFFF), None);
}
#[test]
fn pack2_evaluation() {
let eval = evaluate_pack2(DI_BAD_MOUNT).unwrap();
assert_eq!(eval.pop_bytes_68k, 10);
assert_eq!(eval.result_word, Some(0));
let eval = evaluate_pack2(DI_LOAD).unwrap();
assert_eq!(eval.pop_bytes_68k, 2);
assert_eq!(eval.result_word, None);
let eval = evaluate_pack2(DI_UNLOAD).unwrap();
assert_eq!(eval.pop_bytes_68k, 2);
assert_eq!(eval.result_word, None);
let eval = evaluate_pack2(DI_FORMAT).unwrap();
assert_eq!(eval.pop_bytes_68k, 4);
assert_eq!(eval.result_word, Some(0));
let eval = evaluate_pack2(DI_VERIFY).unwrap();
assert_eq!(eval.pop_bytes_68k, 4);
assert_eq!(eval.result_word, Some(0));
let eval = evaluate_pack2(DI_ZERO).unwrap();
assert_eq!(eval.pop_bytes_68k, 260);
assert_eq!(eval.result_word, Some(0));
assert_eq!(evaluate_pack2(0x1234), None);
}
#[test]
fn disk_init_evaluation_helpers() {
assert_eq!(evaluate_di_bad_mount(10, 20, 0x1234), 0);
assert_eq!(evaluate_di_format(1), 0);
assert_eq!(evaluate_di_verify(1), 0);
assert_eq!(evaluate_di_zero(1, b"DiskName"), 0);
}
}